If you make the following changes to your first example, it should work:

1. Replace tokio::sync::Mutex with std::sync::Mutex so you don't have to use try_lock in the callback.
2. Do not store the receiver in the mutex, only the sender.
3. In the callback, either use an unbounded channel, or make sure to release the lock before sending.
4. Run the blocking C code on a dedicated thread with std::thread::spawn rather than in tokio::spawn. (why?)

To not store the receiver in the mutex, you can do this:

static ref BROADCAST_CONNECT: Mutex<Option<Sender<bool>>> = Mutex::new(None);

// in main
let (send, recv) = channel(128);
*BROADCAST_CONNECT.lock().unwrap() = Some(send);

If you want a bounded channel, you can release the lock by first cloning the channel, then calling drop on the lock, and then using blocking_send to send. With an unbounded channel, this doesn't matter as sending is instant.

// in C callback
let lock = BROADCAST_CONNECT.lock().unwrap();
let send = lock.as_ref().clone();
drop(lock);
send.blocking_send(...);

What you are asking for doesn’t make any sense. To keep the ordering reasonable, you would need to consume values when writing which violates the sc part of the queue. Would need an mpmc queue to do what you want and consume values when it’s full so you can add the new value.

What type of data are you trying to send? To be as fast as possible, a ring buffer of bytes to store the messages and then sending it them in bulk would be the fastest. Not sure how to make this lossy besides the obvious way of have multiple queues.

Choose life; use channels

axum is for building HTTP servers, it does not provide a client.

I think a closer equivalent to aiohttp would be hyper on which both axum and reqwest is built.

It's safe to use reqwest inside axum handlers, just note that some types may have the same name but actually be different (e.g. if you wanted to take Response from reqwest and return that from an axum handler).

I’m here if anyone has follow up questions or just general questions about axum.

Your post title made me think you were inquiring about tokio-graceful-shutdown, which implements a tree-like structure for cancellation, with timeout and error propagation.

Edit: I'm not sure it will achieve "bottom up" cancellation naturally, but it might be amenable? Its API is more oriented to shutting down a sub-tree.

Either will work for your use case. Both are good web frameworks in Rust. Actix happens to be older than Axum, but both should provide you the building blocks you need to do what you want. I've used both. Take a look at the documentation for each. Whichever one looks better to your eyes is probably sufficient to jump up and get started.

L’un ou l’autre fonctionnera pour votre cas d’utilisation. Les deux sont de bons frameworks Web dans Rust. Actix se trouve être plus ancien que Axum, mais les deux devraient vous fournir les éléments de base dont vous avez besoin pour faire ce que vous voulez. J'ai utilisé les deux. Jetez un œil à la documentation de chacun. Celui qui vous semble le mieux est probablement suffisant pour vous lancer et commencer.

https://play.rust-lang.org/?version=stable&mode=debug&edition=2021&gist=6e748c0be222dbef09139d66997d02ae