taskito 0.8.0__tar.gz → 0.9.0__tar.gz

{taskito-0.8.0 → taskito-0.9.0}/Cargo.lock

@@ -43,6 +43,12 @@ version = "1.5.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "c08606f8c3cbf4ce6ec8e28fb0014a2c086708fe954eaa885384a6165172e7e8"
 
+[[package]]
+name = "base64"
+version = "0.22.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "72b3254f16251a8381aa12e40e3c4d2f0199f8c6508fbecb9d91f575e0fbb8c6"
+
 [[package]]
 name = "bitflags"
 version = "2.11.0"
@@ -324,6 +330,16 @@ dependencies = [
  "percent-encoding",
 ]
 
+[[package]]
+name = "gethostname"
+version = "1.1.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1bd49230192a3797a9a4d6abe9b3eed6f7fa4c8a8a4947977c6f80025f92cbd8"
+dependencies = [
+ "rustix",
+ "windows-link",
+]
+
 [[package]]
 name = "getrandom"
 version = "0.2.17"
@@ -1201,7 +1217,7 @@ checksum = "61c41af27dd6d1e27b1b16b489db798443478cef1f06a660c96db617ba5de3b1"
 
 [[package]]
 name = "taskito-async"
-version = "0.8.0"
+version = "0.9.0"
 dependencies = [
  "async-trait",
  "crossbeam-channel",
@@ -1213,7 +1229,7 @@ dependencies = [
 
 [[package]]
 name = "taskito-core"
-version = "0.8.0"
+version = "0.9.0"
 dependencies = [
  "async-trait",
  "chrono",
@@ -1237,12 +1253,15 @@ dependencies = [
 
 [[package]]
 name = "taskito-python"
-version = "0.8.0"
+version = "0.9.0"
 dependencies = [
  "async-trait",
+ "base64",
  "crossbeam-channel",
+ "gethostname",
  "log",
  "pyo3",
+ "serde",
  "serde_json",
  "taskito-async",
  "taskito-core",

{taskito-0.8.0 → taskito-0.9.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: taskito
-Version: 0.8.0
+Version: 0.9.0
 Classifier: Development Status :: 4 - Beta
 Classifier: Intended Audience :: Developers
 Classifier: License :: OSI Approved :: MIT License

{taskito-0.8.0 → taskito-0.9.0}/crates/taskito-core/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "taskito-core"
-version = "0.8.0"
+version = "0.9.0"
 edition = "2021"
 
 [features]

{taskito-0.8.0 → taskito-0.9.0}/crates/taskito-core/src/storage/mod.rs

@@ -352,8 +352,11 @@ macro_rules! impl_storage {
                 resources: Option<&str>,
                 resource_health: Option<&str>,
                 threads: i32,
+                hostname: Option<&str>,
+                pid: Option<i32>,
+                pool_type: Option<&str>,
             ) -> $crate::error::Result<()> {
-                self.register_worker(worker_id, queues, tags, resources, resource_health, threads)
+                self.register_worker(worker_id, queues, tags, resources, resource_health, threads, hostname, pid, pool_type)
             }
             fn heartbeat(
                 &self,
@@ -362,17 +365,27 @@ macro_rules! impl_storage {
             ) -> $crate::error::Result<()> {
                 self.heartbeat(worker_id, resource_health)
             }
+            fn update_worker_status(
+                &self,
+                worker_id: &str,
+                status: &str,
+            ) -> $crate::error::Result<()> {
+                self.update_worker_status(worker_id, status)
+            }
             fn list_workers(
                 &self,
             ) -> $crate::error::Result<Vec<$crate::storage::models::WorkerRow>> {
                 self.list_workers()
             }
-            fn reap_dead_workers(&self) -> $crate::error::Result<u64> {
+            fn reap_dead_workers(&self) -> $crate::error::Result<Vec<String>> {
                 self.reap_dead_workers()
             }
             fn unregister_worker(&self, worker_id: &str) -> $crate::error::Result<()> {
                 self.unregister_worker(worker_id)
             }
+            fn list_claims_by_worker(&self, worker_id: &str) -> $crate::error::Result<Vec<String>> {
+                self.list_claims_by_worker(worker_id)
+            }
             fn pause_queue(&self, queue_name: &str) -> $crate::error::Result<()> {
                 self.pause_queue(queue_name)
             }
@@ -739,6 +752,9 @@ impl Storage for StorageBackend {
         resources: Option<&str>,
         resource_health: Option<&str>,
         threads: i32,
+        hostname: Option<&str>,
+        pid: Option<i32>,
+        pool_type: Option<&str>,
     ) -> Result<()> {
         delegate!(
             self,
@@ -748,21 +764,30 @@ impl Storage for StorageBackend {
             tags,
             resources,
             resource_health,
-            threads
+            threads,
+            hostname,
+            pid,
+            pool_type
         )
     }
     fn heartbeat(&self, worker_id: &str, resource_health: Option<&str>) -> Result<()> {
         delegate!(self, heartbeat, worker_id, resource_health)
     }
+    fn update_worker_status(&self, worker_id: &str, status: &str) -> Result<()> {
+        delegate!(self, update_worker_status, worker_id, status)
+    }
     fn list_workers(&self) -> Result<Vec<models::WorkerRow>> {
         delegate!(self, list_workers)
     }
-    fn reap_dead_workers(&self) -> Result<u64> {
+    fn reap_dead_workers(&self) -> Result<Vec<String>> {
         delegate!(self, reap_dead_workers)
     }
     fn unregister_worker(&self, worker_id: &str) -> Result<()> {
         delegate!(self, unregister_worker, worker_id)
     }
+    fn list_claims_by_worker(&self, worker_id: &str) -> Result<Vec<String>> {
+        delegate!(self, list_claims_by_worker, worker_id)
+    }
     fn pause_queue(&self, queue_name: &str) -> Result<()> {
         delegate!(self, pause_queue, queue_name)
     }

{taskito-0.8.0 → taskito-0.9.0}/crates/taskito-core/src/storage/models.rs

@@ -307,6 +307,10 @@ pub struct WorkerRow {
     pub resources: Option<String>,
     pub resource_health: Option<String>,
     pub threads: i32,
+    pub started_at: Option<i64>,
+    pub hostname: Option<String>,
+    pub pid: Option<i32>,
+    pub pool_type: Option<String>,
 }
 
 #[derive(Insertable, AsChangeset, Debug)]
@@ -320,6 +324,10 @@ pub struct NewWorkerRow<'a> {
     pub resources: Option<&'a str>,
     pub resource_health: Option<&'a str>,
     pub threads: i32,
+    pub started_at: Option<i64>,
+    pub hostname: Option<&'a str>,
+    pub pid: Option<i32>,
+    pub pool_type: Option<&'a str>,
 }
 
 // ── Queue State ─────────────────────────────────────────────────

{taskito-0.8.0 → taskito-0.9.0}/crates/taskito-core/src/storage/postgres/mod.rs

@@ -359,6 +359,24 @@ impl PostgresStorage {
             "ALTER TABLE workers ADD COLUMN IF NOT EXISTS threads INTEGER NOT NULL DEFAULT 0",
         );
 
+        // Migration: add worker discovery metadata columns
+        migration_alter(
+            &mut conn,
+            "ALTER TABLE workers ADD COLUMN IF NOT EXISTS started_at BIGINT",
+        );
+        migration_alter(
+            &mut conn,
+            "ALTER TABLE workers ADD COLUMN IF NOT EXISTS hostname TEXT",
+        );
+        migration_alter(
+            &mut conn,
+            "ALTER TABLE workers ADD COLUMN IF NOT EXISTS pid INTEGER",
+        );
+        migration_alter(
+            &mut conn,
+            "ALTER TABLE workers ADD COLUMN IF NOT EXISTS pool_type TEXT",
+        );
+
         diesel::sql_query(
             "CREATE TABLE IF NOT EXISTS queue_state (
                 queue_name TEXT PRIMARY KEY,

{taskito-0.8.0 → taskito-0.9.0}/crates/taskito-core/src/storage/postgres/workers.rs

@@ -1,7 +1,7 @@
 use diesel::prelude::*;
 
 use super::super::models::*;
-use super::super::schema::workers;
+use super::super::schema::{execution_claims, workers};
 use super::PostgresStorage;
 use crate::error::Result;
 use crate::job::now_millis;
@@ -11,6 +11,7 @@ const DEAD_WORKER_THRESHOLD_MS: i64 = 30_000;
 
 impl PostgresStorage {
     /// Register a new worker or update an existing one.
+    #[allow(clippy::too_many_arguments)]
     pub fn register_worker(
         &self,
         worker_id: &str,
@@ -19,6 +20,9 @@ impl PostgresStorage {
         resources: Option<&str>,
         resource_health: Option<&str>,
         threads: i32,
+        hostname: Option<&str>,
+        pid: Option<i32>,
+        pool_type: Option<&str>,
     ) -> Result<()> {
         let mut conn = self.conn()?;
         let now = now_millis();
@@ -32,6 +36,10 @@ impl PostgresStorage {
             resources,
             resource_health,
             threads,
+            started_at: Some(now),
+            hostname,
+            pid,
+            pool_type,
         };
 
         diesel::insert_into(workers::table)
@@ -60,6 +68,18 @@ impl PostgresStorage {
         Ok(())
     }
 
+    /// Update the status of a worker.
+    pub fn update_worker_status(&self, worker_id: &str, status: &str) -> Result<()> {
+        let mut conn = self.conn()?;
+
+        diesel::update(workers::table)
+            .filter(workers::worker_id.eq(worker_id))
+            .set(workers::status.eq(status))
+            .execute(&mut conn)?;
+
+        Ok(())
+    }
+
     /// List all workers with their heartbeat status.
     pub fn list_workers(&self) -> Result<Vec<WorkerRow>> {
         let mut conn = self.conn()?;
@@ -72,14 +92,22 @@ impl PostgresStorage {
     }
 
     /// Remove workers that haven't sent a heartbeat within the threshold.
-    pub fn reap_dead_workers(&self) -> Result<u64> {
+    /// Returns the IDs of the reaped workers.
+    pub fn reap_dead_workers(&self) -> Result<Vec<String>> {
         let mut conn = self.conn()?;
         let cutoff = now_millis().saturating_sub(DEAD_WORKER_THRESHOLD_MS);
 
-        let affected = diesel::delete(workers::table.filter(workers::last_heartbeat.lt(cutoff)))
-            .execute(&mut conn)?;
+        let dead_ids: Vec<String> = workers::table
+            .filter(workers::last_heartbeat.lt(cutoff))
+            .select(workers::worker_id)
+            .load(&mut conn)?;
+
+        if !dead_ids.is_empty() {
+            diesel::delete(workers::table.filter(workers::worker_id.eq_any(&dead_ids)))
+                .execute(&mut conn)?;
+        }
 
-        Ok(affected as u64)
+        Ok(dead_ids)
     }
 
     /// Unregister a worker (called on shutdown).
@@ -91,4 +119,16 @@ impl PostgresStorage {
 
         Ok(())
     }
+
+    /// List all job IDs currently claimed by a worker.
+    pub fn list_claims_by_worker(&self, worker_id: &str) -> Result<Vec<String>> {
+        let mut conn = self.conn()?;
+
+        let job_ids: Vec<String> = execution_claims::table
+            .filter(execution_claims::worker_id.eq(worker_id))
+            .select(execution_claims::job_id)
+            .load(&mut conn)?;
+
+        Ok(job_ids)
+    }
 }

{taskito-0.8.0 → taskito-0.9.0}/crates/taskito-core/src/storage/redis_backend/workers.rs

@@ -8,6 +8,7 @@ use crate::storage::models::WorkerRow;
 const DEAD_WORKER_THRESHOLD_MS: i64 = 30_000;
 
 impl RedisStorage {
+    #[allow(clippy::too_many_arguments)]
     pub fn register_worker(
         &self,
         worker_id: &str,
@@ -16,6 +17,9 @@ impl RedisStorage {
         resources: Option<&str>,
         resource_health: Option<&str>,
         threads: i32,
+        hostname: Option<&str>,
+        pid: Option<i32>,
+        pool_type: Option<&str>,
     ) -> Result<()> {
         let mut conn = self.conn()?;
         let now = now_millis();
@@ -30,6 +34,10 @@ impl RedisStorage {
         pipe.hset(&wkey, "resources", resources.unwrap_or(""));
         pipe.hset(&wkey, "resource_health", resource_health.unwrap_or(""));
         pipe.hset(&wkey, "threads", threads);
+        pipe.hset(&wkey, "started_at", now);
+        pipe.hset(&wkey, "hostname", hostname.unwrap_or(""));
+        pipe.hset(&wkey, "pid", pid.unwrap_or(0));
+        pipe.hset(&wkey, "pool_type", pool_type.unwrap_or(""));
         pipe.sadd(&wall, worker_id);
         pipe.query::<()>(&mut conn).map_err(map_err)?;
 
@@ -49,6 +57,16 @@ impl RedisStorage {
         Ok(())
     }
 
+    pub fn update_worker_status(&self, worker_id: &str, status: &str) -> Result<()> {
+        let mut conn = self.conn()?;
+        let wkey = self.key(&["worker", worker_id]);
+
+        conn.hset::<_, _, _, ()>(&wkey, "status", status)
+            .map_err(map_err)?;
+
+        Ok(())
+    }
+
     pub fn list_workers(&self) -> Result<Vec<WorkerRow>> {
         let mut conn = self.conn()?;
         let wall = self.key(&["workers", "all"]);
@@ -89,43 +107,46 @@ impl RedisStorage {
                     .get("threads")
                     .and_then(|s| s.parse().ok())
                     .unwrap_or(0),
+                started_at: data.get("started_at").and_then(|s| s.parse().ok()),
+                hostname: to_opt("hostname"),
+                pid: data
+                    .get("pid")
+                    .and_then(|s| s.parse().ok())
+                    .filter(|&v: &i32| v != 0),
+                pool_type: to_opt("pool_type"),
             });
         }
 
         Ok(rows)
     }
 
-    pub fn reap_dead_workers(&self) -> Result<u64> {
+    pub fn reap_dead_workers(&self) -> Result<Vec<String>> {
         let mut conn = self.conn()?;
         let cutoff = now_millis().saturating_sub(DEAD_WORKER_THRESHOLD_MS);
         let wall = self.key(&["workers", "all"]);
 
         let worker_ids: Vec<String> = conn.smembers(&wall).map_err(map_err)?;
 
-        let mut count = 0u64;
+        let mut reaped = Vec::new();
         for wid in worker_ids {
             let wkey = self.key(&["worker", &wid]);
             let hb: Option<i64> = conn.hget(&wkey, "last_heartbeat").map_err(map_err)?;
 
-            if let Some(last_hb) = hb {
-                if last_hb < cutoff {
-                    let pipe = &mut redis::pipe();
-                    pipe.del(&wkey);
-                    pipe.srem(&wall, &wid);
-                    pipe.query::<()>(&mut conn).map_err(map_err)?;
-                    count += 1;
-                }
-            } else {
-                // No heartbeat data — remove
+            let is_dead = match hb {
+                Some(last_hb) => last_hb < cutoff,
+                None => true,
+            };
+
+            if is_dead {
                 let pipe = &mut redis::pipe();
                 pipe.del(&wkey);
                 pipe.srem(&wall, &wid);
                 pipe.query::<()>(&mut conn).map_err(map_err)?;
-                count += 1;
+                reaped.push(wid);
             }
         }
 
-        Ok(count)
+        Ok(reaped)
     }
 
     pub fn unregister_worker(&self, worker_id: &str) -> Result<()> {
@@ -140,4 +161,43 @@ impl RedisStorage {
 
         Ok(())
     }
+
+    pub fn list_claims_by_worker(&self, worker_id: &str) -> Result<Vec<String>> {
+        let mut conn = self.conn()?;
+        let pattern = self.key(&["exec_claim", "*"]);
+
+        let mut job_ids = Vec::new();
+        let mut cursor: u64 = 0;
+        loop {
+            let (next_cursor, keys): (u64, Vec<String>) = redis::cmd("SCAN")
+                .arg(cursor)
+                .arg("MATCH")
+                .arg(&pattern)
+                .arg("COUNT")
+                .arg(100)
+                .query(&mut conn)
+                .map_err(map_err)?;
+
+            for key in keys {
+                let value: Option<String> = conn.get(&key).map_err(map_err)?;
+                if let Some(val) = value {
+                    // Value format is "{worker_id}:{timestamp}"
+                    if val.starts_with(worker_id) && val[worker_id.len()..].starts_with(':') {
+                        // Extract job_id from key: "{prefix}exec_claim:{job_id}"
+                        let prefix = self.key(&["exec_claim", ""]);
+                        if let Some(job_id) = key.strip_prefix(&prefix) {
+                            job_ids.push(job_id.to_string());
+                        }
+                    }
+                }
+            }
+
+            cursor = next_cursor;
+            if cursor == 0 {
+                break;
+            }
+        }
+
+        Ok(job_ids)
+    }
 }

{taskito-0.8.0 → taskito-0.9.0}/crates/taskito-core/src/storage/schema.rs

@@ -153,6 +153,10 @@ diesel::table! {
         resources -> Nullable<Text>,
         resource_health -> Nullable<Text>,
         threads -> Integer,
+        started_at -> Nullable<BigInt>,
+        hostname -> Nullable<Text>,
+        pid -> Nullable<Integer>,
+        pool_type -> Nullable<Text>,
     }
 }
 

{taskito-0.8.0 → taskito-0.9.0}/crates/taskito-core/src/storage/sqlite/mod.rs

@@ -356,6 +356,15 @@ impl SqliteStorage {
             "ALTER TABLE workers ADD COLUMN threads INTEGER NOT NULL DEFAULT 0",
         );
 
+        // Migration: add worker discovery metadata columns
+        migration_alter(
+            &mut conn,
+            "ALTER TABLE workers ADD COLUMN started_at INTEGER",
+        );
+        migration_alter(&mut conn, "ALTER TABLE workers ADD COLUMN hostname TEXT");
+        migration_alter(&mut conn, "ALTER TABLE workers ADD COLUMN pid INTEGER");
+        migration_alter(&mut conn, "ALTER TABLE workers ADD COLUMN pool_type TEXT");
+
         // ── Queue State ──────────────────────────────────
         diesel::sql_query(
             "CREATE TABLE IF NOT EXISTS queue_state (

{taskito-0.8.0 → taskito-0.9.0}/crates/taskito-core/src/storage/sqlite/workers.rs

@@ -1,7 +1,7 @@
 use diesel::prelude::*;
 
 use super::super::models::*;
-use super::super::schema::workers;
+use super::super::schema::{execution_claims, workers};
 use super::SqliteStorage;
 use crate::error::Result;
 use crate::job::now_millis;
@@ -11,6 +11,7 @@ const DEAD_WORKER_THRESHOLD_MS: i64 = 30_000;
 
 impl SqliteStorage {
     /// Register a new worker or update an existing one.
+    #[allow(clippy::too_many_arguments)]
     pub fn register_worker(
         &self,
         worker_id: &str,
@@ -19,6 +20,9 @@ impl SqliteStorage {
         resources: Option<&str>,
         resource_health: Option<&str>,
         threads: i32,
+        hostname: Option<&str>,
+        pid: Option<i32>,
+        pool_type: Option<&str>,
     ) -> Result<()> {
         let mut conn = self.conn()?;
         let now = now_millis();
@@ -32,6 +36,10 @@ impl SqliteStorage {
             resources,
             resource_health,
             threads,
+            started_at: Some(now),
+            hostname,
+            pid,
+            pool_type,
         };
 
         diesel::replace_into(workers::table)
@@ -57,6 +65,18 @@ impl SqliteStorage {
         Ok(())
     }
 
+    /// Update the status of a worker.
+    pub fn update_worker_status(&self, worker_id: &str, status: &str) -> Result<()> {
+        let mut conn = self.conn()?;
+
+        diesel::update(workers::table)
+            .filter(workers::worker_id.eq(worker_id))
+            .set(workers::status.eq(status))
+            .execute(&mut conn)?;
+
+        Ok(())
+    }
+
     /// List all workers with their heartbeat status.
     pub fn list_workers(&self) -> Result<Vec<WorkerRow>> {
         let mut conn = self.conn()?;
@@ -69,14 +89,22 @@ impl SqliteStorage {
     }
 
     /// Remove workers that haven't sent a heartbeat within the threshold.
-    pub fn reap_dead_workers(&self) -> Result<u64> {
+    /// Returns the IDs of the reaped workers.
+    pub fn reap_dead_workers(&self) -> Result<Vec<String>> {
         let mut conn = self.conn()?;
         let cutoff = now_millis().saturating_sub(DEAD_WORKER_THRESHOLD_MS);
 
-        let affected = diesel::delete(workers::table.filter(workers::last_heartbeat.lt(cutoff)))
-            .execute(&mut conn)?;
+        let dead_ids: Vec<String> = workers::table
+            .filter(workers::last_heartbeat.lt(cutoff))
+            .select(workers::worker_id)
+            .load(&mut conn)?;
+
+        if !dead_ids.is_empty() {
+            diesel::delete(workers::table.filter(workers::worker_id.eq_any(&dead_ids)))
+                .execute(&mut conn)?;
+        }
 
-        Ok(affected as u64)
+        Ok(dead_ids)
     }
 
     /// Unregister a worker (called on shutdown).
@@ -88,4 +116,16 @@ impl SqliteStorage {
 
         Ok(())
     }
+
+    /// List all job IDs currently claimed by a worker.
+    pub fn list_claims_by_worker(&self, worker_id: &str) -> Result<Vec<String>> {
+        let mut conn = self.conn()?;
+
+        let job_ids: Vec<String> = execution_claims::table
+            .filter(execution_claims::worker_id.eq(worker_id))
+            .select(execution_claims::job_id)
+            .load(&mut conn)?;
+
+        Ok(job_ids)
+    }
 }

{taskito-0.8.0 → taskito-0.9.0}/crates/taskito-core/src/storage/traits.rs

@@ -119,6 +119,7 @@ pub trait Storage: Send + Sync + Clone {
 
     // ── Worker operations ───────────────────────────────────────────
 
+    #[allow(clippy::too_many_arguments)]
     fn register_worker(
         &self,
         worker_id: &str,
@@ -127,11 +128,16 @@ pub trait Storage: Send + Sync + Clone {
         resources: Option<&str>,
         resource_health: Option<&str>,
         threads: i32,
+        hostname: Option<&str>,
+        pid: Option<i32>,
+        pool_type: Option<&str>,
     ) -> Result<()>;
     fn heartbeat(&self, worker_id: &str, resource_health: Option<&str>) -> Result<()>;
+    fn update_worker_status(&self, worker_id: &str, status: &str) -> Result<()>;
     fn list_workers(&self) -> Result<Vec<WorkerRow>>;
-    fn reap_dead_workers(&self) -> Result<u64>;
+    fn reap_dead_workers(&self) -> Result<Vec<String>>;
     fn unregister_worker(&self, worker_id: &str) -> Result<()>;
+    fn list_claims_by_worker(&self, worker_id: &str) -> Result<Vec<String>>;
 
     // ── Queue pause/resume ───────────────────────────────────────
 

{taskito-0.8.0 → taskito-0.9.0}/crates/taskito-core/tests/rust/storage_tests.rs

@@ -165,8 +165,18 @@ fn test_workers(s: &impl Storage) {
     let resources = Some(r#"["db","redis"]"#);
     let health = Some(r#"{"db":"healthy","redis":"healthy"}"#);
 
-    s.register_worker("w-test-1", "q-workers", None, resources, health, 4)
-        .unwrap();
+    s.register_worker(
+        "w-test-1",
+        "q-workers",
+        None,
+        resources,
+        health,
+        4,
+        Some("test-host"),
+        Some(12345),
+        Some("thread"),
+    )
+    .unwrap();
     s.heartbeat("w-test-1", Some(r#"{"db":"unhealthy","redis":"healthy"}"#))
         .unwrap();
 
@@ -176,6 +186,16 @@ fn test_workers(s: &impl Storage) {
     assert_eq!(w.threads, 4);
     assert!(w.resources.as_deref().unwrap().contains("db"));
     assert!(w.resource_health.as_deref().unwrap().contains("unhealthy"));
+    assert_eq!(w.hostname.as_deref(), Some("test-host"));
+    assert_eq!(w.pid, Some(12345));
+    assert_eq!(w.pool_type.as_deref(), Some("thread"));
+    assert!(w.started_at.is_some());
+
+    // Test update_worker_status
+    s.update_worker_status("w-test-1", "draining").unwrap();
+    let workers = s.list_workers().unwrap();
+    let w = workers.iter().find(|w| w.worker_id == "w-test-1").unwrap();
+    assert_eq!(w.status, "draining");
 
     s.unregister_worker("w-test-1").unwrap();
 }

{taskito-0.8.0 → taskito-0.9.0}/crates/taskito-python/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "taskito-python"
-version = "0.8.0"
+version = "0.9.0"
 edition = "2021"
 
 [features]
@@ -23,4 +23,7 @@ uuid = { workspace = true }
 async-trait = { workspace = true }
 taskito-async = { path = "../taskito-async", optional = true }
 serde_json = { workspace = true }
+serde = { workspace = true }
+base64 = "0.22"
 log = { workspace = true }
+gethostname = "1.1.0"

{taskito-0.8.0 → taskito-0.9.0}/crates/taskito-python/src/lib.rs

@@ -2,6 +2,7 @@ use pyo3::prelude::*;
 
 #[cfg(not(feature = "native-async"))]
 mod async_worker;
+mod prefork;
 mod py_config;
 mod py_job;
 mod py_queue;