Make WorkerBuilder return Self

src/bin/loadtest.rs

@@ -58,19 +58,20 @@ async fn main() {
         set.spawn(async move {
             // make producer and consumer
             let mut p = Client::connect(None).await.unwrap();
-            let mut c = WorkerBuilder::default();
-            c.register_fn("SomeJob", |_| {
-                Box::pin(async move {
-                    let mut rng = rand::thread_rng();
-                    if rng.gen_bool(0.01) {
-                        Err(io::Error::new(io::ErrorKind::Other, "worker closed"))
-                    } else {
-                        Ok(())
-                    }
+            let mut worker = WorkerBuilder::default()
+                .register_fn("SomeJob", |_| {
+                    Box::pin(async move {
+                        let mut rng = rand::thread_rng();
+                        if rng.gen_bool(0.01) {
+                            Err(io::Error::new(io::ErrorKind::Other, "worker closed"))
+                        } else {
+                            Ok(())
+                        }
+                    })
                 })
-            });
-            let mut c = c.connect(None).await.unwrap();
-
+                .connect(None)
+                .await
+                .unwrap();
             let mut rng = rand::rngs::OsRng;
             let mut random_queues = Vec::from(QUEUES);
             random_queues.shuffle(&mut rng);
@@ -89,7 +90,7 @@ async fn main() {
                     }
                 } else {
                     // pop
-                    c.run_one(0, &random_queues[..]).await?;
+                    worker.run_one(0, &random_queues[..]).await?;
                     if popped.fetch_add(1, atomic::Ordering::SeqCst) >= jobs {
                         return Ok(idx);
                     }

src/lib.rs

@@ -50,12 +50,13 @@
 //! # tokio_test::block_on(async {
 //! use faktory::WorkerBuilder;
 //! use std::io;
-//! let mut w = WorkerBuilder::default();
-//! w.register_fn("foobar", |job| async move {
-//!     println!("{:?}", job);
-//!     Ok::<(), io::Error>(())
-//! });
-//! let mut w = w.connect(None).await.unwrap();
+//! let mut w = WorkerBuilder::default()
+//!     .register_fn("foobar", |job| async move {
+//!         println!("{:?}", job);
+//!         Ok::<(), io::Error>(())
+//!     })
+//!     .connect(None).await.unwrap();
+//!
 //! if let Err(e) = w.run(&["default"]).await {
 //!     println!("worker failed: {}", e);
 //! }

src/worker/builder.rs

@@ -40,15 +40,15 @@ impl<E: 'static> WorkerBuilder<E> {
     /// Set the hostname to use for this worker.
     ///
     /// Defaults to the machine's hostname as reported by the operating system.
-    pub fn hostname(&mut self, hn: String) -> &mut Self {
+    pub fn hostname(mut self, hn: String) -> Self {
         self.opts.hostname = Some(hn);
         self
     }
 
     /// Set a unique identifier for this worker.
     ///
     /// Defaults to a randomly generated 32-char ASCII string.
-    pub fn wid(&mut self, wid: WorkerId) -> &mut Self {
+    pub fn wid(mut self, wid: WorkerId) -> Self {
         self.opts.wid = Some(wid);
         self
     }
@@ -60,7 +60,7 @@ impl<E: 'static> WorkerBuilder<E> {
     /// Note that calling this overrides the labels set previously.
     ///
     /// If you need to extend the labels already set, use [`WorkerBuilder::add_to_labels`] instead.
-    pub fn labels<I>(&mut self, labels: I) -> &mut Self
+    pub fn labels<I>(mut self, labels: I) -> Self
     where
         I: IntoIterator<Item = String>,
     {
@@ -74,7 +74,7 @@ impl<E: 'static> WorkerBuilder<E> {
     /// if no labels have been explicitly set before - to the default `"rust"` label.
     ///
     /// If you need to override the labels set previously, use [`WorkerBuilder::labels`] instead.
-    pub fn add_to_labels<I>(&mut self, labels: I) -> &mut Self
+    pub fn add_to_labels<I>(mut self, labels: I) -> Self
     where
         I: IntoIterator<Item = String>,
     {
@@ -85,7 +85,7 @@ impl<E: 'static> WorkerBuilder<E> {
     /// Set the number of workers to use `run` and `run_to_completion`.
     ///
     /// Defaults to 1.
-    pub fn workers(&mut self, w: usize) -> &mut Self {
+    pub fn workers(mut self, w: usize) -> Self {
         self.workers_count = w;
         self
     }
@@ -97,14 +97,13 @@ impl<E: 'static> WorkerBuilder<E> {
     ///
     /// Note that only one single handler per job kind is supported. Registering another handler
     /// for the same job kind will silently override the handler registered previously.
-    pub fn register_fn<K, H, Fut>(&mut self, kind: K, handler: H) -> &mut Self
+    pub fn register_fn<K, H, Fut>(self, kind: K, handler: H) -> Self
     where
         K: Into<String>,
         H: Fn(Job) -> Fut + Send + Sync + 'static,
         Fut: Future<Output = Result<(), E>> + Send,
     {
-        self.register(kind, Closure(handler));
-        self
+        self.register(kind, Closure(handler))
     }
 
     /// Register a handler for the given job type (`kind`).
@@ -114,7 +113,7 @@ impl<E: 'static> WorkerBuilder<E> {
     ///
     /// Note that only one single handler per job kind is supported. Registering another handler
     /// for the same job kind will silently override the handler registered previously.
-    pub fn register<K, H>(&mut self, kind: K, runner: H) -> &mut Self
+    pub fn register<K, H>(mut self, kind: K, runner: H) -> Self
     where
         K: Into<String>,
         H: JobRunner<Error = E> + 'static,

src/worker/mod.rs

@@ -110,11 +110,12 @@ type CallbacksRegistry<E> = FnvHashMap<String, runner::BoxedJobRunner<E>>;
 ///     Ok(())
 /// }
 ///
-/// let mut w = WorkerBuilder::default();
+/// let mut w = WorkerBuilder::default()
+///     .register_fn("foo", process_job)
+///     .connect(None)
+///     .await
+///     .unwrap();
 ///
-/// w.register_fn("foo", process_job);
-///
-/// let mut w = w.connect(None).await.unwrap();
 /// if let Err(e) = w.run(&["default"]).await {
 ///     println!("worker failed: {}", e);
 /// }
@@ -124,12 +125,17 @@ type CallbacksRegistry<E> = FnvHashMap<String, runner::BoxedJobRunner<E>>;
 /// Handler can be inlined.
 ///
 /// ```no_run
+/// # tokio_test::block_on(async {
 /// # use faktory::WorkerBuilder;
 /// # use std::io;
-/// let mut w = WorkerBuilder::default();
-/// w.register_fn("bar", |job| async move {
-///     println!("{:?}", job);
-///     Ok::<(), io::Error>(())
+/// let _w = WorkerBuilder::default()
+///     .register_fn("bar", |job| async move {
+///         println!("{:?}", job);
+///         Ok::<(), io::Error>(())
+///     })
+///     .connect(None)
+///     .await
+///     .unwrap();
 /// });
 /// ```
 ///

src/worker/runner.rs

@@ -31,13 +31,17 @@ use std::future::Future;
 ///       Ok(())
 ///   }
 /// }
-///
-/// let mut w = WorkerBuilder::default();
+/// 
 /// let handler = MyHandler {
 ///    config: "bar".to_string(),
 /// };
-/// w.register("foo", handler);
-/// let mut w = w.connect(None).await.unwrap();
+/// 
+/// let mut w = WorkerBuilder::default()
+///     .register("foo", handler)
+///     .connect(None)
+///     .await
+///     .unwrap();
+/// 
 /// if let Err(e) = w.run(&["default"]).await {
 ///     println!("worker failed: {}", e);
 /// }