parking_lot | efficient synchronization primitives for Rust. Also provides

The behaviour of the panic! macro changed a bit with the Rust 2021 edition, to make it more consistent with other format family macros. An entire chapter of the migration guide is dedicated to this.

The fix, and the link with the detailed information is also indicated in the error message you get:

The issue here is that the code expands to a match statement including an .await point where the Err is sent over the channel used to implement the stream:

I believe you meant "store" the data in a variable.

It will be easier for you to understand if you use async/await.

run

cargo update -p parity-db

If this doesn't help please clear cargo cache and reinstall

To enable polling a future with Tokio, you need a Runtime.

This is supported on crate feature rt only.

You need to add sample data in setUp method and use them in test methods. Add the sample data like following.

Reqwest lists OpenSSL as a requirement on Linux due to it using native-tls, which depends on openssl. You need to install the pkg-config and libssl-dev packages:

In my experience, the main source of deadlocks is locking two primitives at the same time. For example:

Rust guarantees that safe code will not contain data races (concurrent mutable access to the same object). Mutexes allow for threads to have mutually exclusive access to read/write an object, thereby avoiding the race.

In other languages, (Java and C++ come to mind) mutexes aren't explicitly associated with data. It is up to programmers to make sure they lock and unlock them appropriately, accessing the data only within the critical section between the lock and unlock. In Rust, this would mean that safe code could contain data races if things were written incorrectly.

The solution to this is the RAII guard. The mutex "owns" the associated object and only allows read/write access through a RAII guard that represents a lock on the mutex. This is the MutexGuard type returned by std's Mutex::lock()

Parking_lot is claiming to allow locking/unlocking without creation of a RAII guard, which can be useful when writing unsafe code doing fancy things with mutexes for speed reasons. This differentiates it from std's sync::Mutex, which does not provide these methods.

The primary limitation of RAII guards is that by the nature of RAII they only last as long as the enclosing scope. Further, they hold a reference to the mutex, so "storing" the "lock" past its scope is hard due to Rust's borrowing rules.

The referenced parking_lot methods are the unsafe raw_unlock and the safe raw_lock. Since a raw_lock() needs an associated raw_unlock() to finish the critical section, use of these features means delving into unsafe code, which is usually ill-advised and unnecessary unless you have good reason to believe its the only way to accomplish what you need.