hyper | HTTP/2 for Python | HTTP library

you can try the approximate_row_count() function (https://docs.timescale.com/api/latest/analytics/approximate_row_count/) which gives an immediate result.

It's something pretty new called optional chaining, actually syntaxic sugar for this:

You may want to use below xpath :

This thread here: https://github.com/hashicorp/vagrant/issues/11987 outlines the same problem. When WSL2 is enabled as part of the Docker install, the vagrant up command hangs.

The commenter here: https://github.com/hashicorp/vagrant/issues/11987#issuecomment-758089840 mentions that by disabling the VirtualMachinePlatform and restarting the machine, vagrant will work as normal again.

Of course, it's not an ideal solution especially if you need to use Docker but it does offer a temporary solution.

It turns out that the default user in mcr.microsoft.com/windows/nanoserver:1809 is ContainerUser, a non-administrator account. I'm not sure the exact permissions Docker's COPY command uses on Windows containers. On Linux it creates files owned by root though, so something similar in Windows. Switching to the ContainerAdministrator user (USER ContainerAdministrator) for the npm install process fixed my permissions problems.

Do it like this

There are two issues, first of all, Body only implements From<&'static str> but the given &str is bound to the lifetime on the MutexGuard, therefore the Body::from call fails with a lifetime error. You can work around this via foo.clone().

The second issue is about the multiple nested scopes which would require additional clone()s on the Arc> and move on the service_fn closure. The following compiles:

The first error in your error message is that Sync is not implemented for RefCell. This is by design, as stated by Sync's rustdoc:

Types that are not Sync are those that have “interior mutability” in a non-thread-safe form, such as Cell and RefCell. These types allow for mutation of their contents even through an immutable, shared reference. For example the set method on Cell takes &self, so it requires only a shared reference &Cell. The method performs no synchronization, thus Cell cannot be Sync.

Thus it's not safe to share RefCells between threads, because you can cause a data race through a regular, shared reference.

But what if you wrap it in Arc ? Well, the rustdoc is quite clear again:

Arc will implement Send and Sync as long as the T implements Send and Sync. Why can’t you put a non-thread-safe type T in an Arc to make it thread-safe? This may be a bit counter-intuitive at first: after all, isn’t the point of Arc thread safety? The key is this: Arc makes it thread safe to have multiple ownership of the same data, but it doesn’t add thread safety to its data. Consider Arc. RefCell isn’t Sync, and if Arc was always Send, Arc would be as well. But then we’d have a problem: RefCell is not thread safe; it keeps track of the borrowing count using non-atomic operations.

In the end, this means that you may need to pair Arc with some sort of std::sync type, usually Mutex.

Arc will not be Sync unless T is Sync because of the same reason. Given that, probably you should use std/tokio Mutex instead of RefCell

If you want to clone test then you need to clone it outside the closure and then move it into the closure. Note that if you want to change test later on and have these changes reflected inside the closure you will need to use Arc so that both inside and outside the closure have mutable access to the same string.