Lib.rs

derive_hub

A simple actor hub that generates the following code.

       #[derive(::derive_builder::Builder, ::std::fmt::Debug)]
       pub struct #hub_name {
           #[builder(setter(skip))]
           workers: ::std::vec::Vec<tokio_util::sync::CancellationToken>,
           #(#field_declarations,)*
       }

       impl ::std::ops::Drop for #hub_name {
           fn drop(&mut self) {
               self.shutdown();
           }
       }

       impl #hub_name {
           /// Spawns a given number of workers threads.
           ///
           #[inline]
           pub fn spawn(&mut self, worker_count: usize) -> ::std::vec::Vec<::tokio::task::JoinHandle<()>> {
               assert!(worker_count > 0, "Worker count has to be greater than zero, but got {}", worker_count);
               (0..worker_count)
                   .map(|_| {
                       let token = ::tokio_util::sync::CancellationToken::new();
                       self.workers.push(token.clone());
                       let item = #item_builder::default()
                           #(#inits)*
                           .build()
                           .expect(concat!("Should be able to build ", stringify!(#hub_name), "."));
                       ::tokio::spawn(async move {
                           item.run(token).await;
                       })
                   })
                   .collect::<Vec<_>>()
           }

           /// Shutdown hub.
           ///
           #[inline]
           pub fn shutdown(&self) {
               for worker in &self.workers {
                   worker.cancel();
               }
           }
       }

Inert Attributes:

• #[hub(skip)] - Should be used in conjunction with default functions of the builder of the agent struct.

Preconditions:

• Crates that have to be installed: Tikio, tokio-util, derive-builder.
• The members of the struct should be inside an Arc, which will be cloned by the hub when spawning.
• Naturally, all members have to be syn and send.
• The struct has to implemnet derive_builder::Builder
• The struct that has the derive attribute has to have a method of same signature as this example:

pub async fn run(self, flag: tokio_util::sync::CancellationToken) {
       loop {
           tokio::select! {
               biased;
               _ = flag.cancelled() => {
                   /* Wind down actor */
                   break;
               }
               item = self.foo.pop() => {
                   /* Do something important */
               }
               item = self.bar.pop() => {
                   /* Do something important */
               }
               item = self.baz.pop() => {
                   /* Do something important */
               }
           };
       }
   }

Recommendations.

• Fields should ideally contain a deadqueue::Queue.