taskito 0.7.0__tar.gz → 0.9.0__tar.gz

{taskito-0.7.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.7.0"
+version = "0.9.0"
 dependencies = [
  "async-trait",
  "crossbeam-channel",
@@ -1213,7 +1229,7 @@ dependencies = [
 
 [[package]]
 name = "taskito-core"
-version = "0.7.0"
+version = "0.9.0"
 dependencies = [
  "async-trait",
  "chrono",
@@ -1237,12 +1253,15 @@ dependencies = [
 
 [[package]]
 name = "taskito-python"
-version = "0.7.0"
+version = "0.9.0"
 dependencies = [
  "async-trait",
+ "base64",
  "crossbeam-channel",
+ "gethostname",
  "log",
  "pyo3",
+ "serde",
  "serde_json",
  "taskito-async",
  "taskito-core",

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

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

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

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

{taskito-0.7.0 → taskito-0.9.0}/crates/taskito-core/src/scheduler/maintenance.rs

@@ -99,7 +99,7 @@ impl Scheduler {
                 depends_on: vec![],
                 expires_at: None,
                 result_ttl_ms: None,
-                namespace: None,
+                namespace: self.namespace.clone(),
             };
 
             if let Err(e) = self.storage.enqueue_unique(new_job) {

{taskito-0.7.0 → taskito-0.9.0}/crates/taskito-core/src/scheduler/mod.rs

@@ -128,6 +128,7 @@ pub struct Scheduler {
     config: SchedulerConfig,
     shutdown: Arc<Notify>,
     paused_cache: Mutex<(HashSet<String>, Instant)>,
+    namespace: Option<String>,
 }
 
 /// Counters for tick-based scheduling of periodic maintenance tasks.
@@ -139,7 +140,12 @@ struct TickCounters {
 }
 
 impl Scheduler {
-    pub fn new(storage: StorageBackend, queues: Vec<String>, config: SchedulerConfig) -> Self {
+    pub fn new(
+        storage: StorageBackend,
+        queues: Vec<String>,
+        config: SchedulerConfig,
+        namespace: Option<String>,
+    ) -> Self {
         let rate_limiter = RateLimiter::new(storage.clone());
         let dlq = DeadLetterQueue::new(storage.clone());
         let circuit_breaker = CircuitBreaker::new(storage.clone());
@@ -155,6 +161,7 @@ impl Scheduler {
             config,
             shutdown: Arc::new(Notify::new()),
             paused_cache: Mutex::new((HashSet::new(), Instant::now())),
+            namespace,
         }
     }
 
@@ -249,6 +256,7 @@ mod tests {
             storage,
             vec!["default".to_string()],
             SchedulerConfig::default(),
+            None,
         )
     }
 
@@ -445,7 +453,7 @@ mod tests {
         // The second job should be back in pending with a future scheduled_at
         let jobs = scheduler
             .storage
-            .list_jobs(Some(JobStatus::Pending as i32), None, None, 10, 0)
+            .list_jobs(Some(JobStatus::Pending as i32), None, None, 10, 0, None)
             .unwrap();
         assert_eq!(jobs.len(), 1);
         assert!(jobs[0].scheduled_at > now_millis());
@@ -486,7 +494,7 @@ mod tests {
         // Job should be rescheduled
         let jobs = scheduler
             .storage
-            .list_jobs(Some(JobStatus::Pending as i32), None, None, 10, 0)
+            .list_jobs(Some(JobStatus::Pending as i32), None, None, 10, 0, None)
             .unwrap();
         assert_eq!(jobs.len(), 1);
         assert!(jobs[0].scheduled_at > now_millis());
@@ -562,6 +570,7 @@ mod tests {
                 Some("periodic_task"),
                 10,
                 0,
+                None,
             )
             .unwrap();
         assert_eq!(jobs.len(), 1);
@@ -575,13 +584,13 @@ mod tests {
             result_ttl_ms: Some(1), // 1ms TTL
             ..SchedulerConfig::default()
         };
-        let scheduler = Scheduler::new(storage, vec!["default".to_string()], config);
+        let scheduler = Scheduler::new(storage, vec!["default".to_string()], config, None);
 
         // Enqueue, dequeue, and complete a job
         let job = scheduler.storage.enqueue(make_job("cleanup_task")).unwrap();
         scheduler
             .storage
-            .dequeue("default", now_millis() + 1000)
+            .dequeue("default", now_millis() + 1000, None)
             .unwrap();
         scheduler.storage.complete(&job.id, Some(vec![1])).unwrap();
 
@@ -605,7 +614,7 @@ mod tests {
             cleanup_interval: 1,
             ..SchedulerConfig::default()
         };
-        let scheduler = Scheduler::new(storage, vec!["default".to_string()], config);
+        let scheduler = Scheduler::new(storage, vec!["default".to_string()], config, None);
 
         scheduler.storage.enqueue(make_job("tick_task")).unwrap();
 

{taskito-0.7.0 → taskito-0.9.0}/crates/taskito-core/src/scheduler/poller.rs

@@ -51,7 +51,10 @@ impl Scheduler {
             return Ok(false);
         }
 
-        let job = match self.storage.dequeue_from(&active_queues, now)? {
+        let job = match self
+            .storage
+            .dequeue_from(&active_queues, now, self.namespace.as_deref())?
+        {
             Some(j) => j,
             None => return Ok(false),
         };

{taskito-0.7.0 → taskito-0.9.0}/crates/taskito-core/src/storage/diesel_common/jobs.rs

@@ -270,17 +270,27 @@ macro_rules! impl_diesel_job_ops {
             }
 
             /// Atomically dequeue the highest-priority ready job from the given queue.
-            /// Skips expired jobs.
-            pub fn dequeue(&self, queue_name: &str, now: i64) -> Result<Option<Job>> {
+            /// Skips expired jobs. When `namespace` is `Some`, only jobs in that
+            /// namespace are considered; when `None`, only jobs with no namespace.
+            pub fn dequeue(&self, queue_name: &str, now: i64, namespace: Option<&str>) -> Result<Option<Job>> {
                 let mut conn = self.conn()?;
 
                 conn.transaction(|conn| {
-                    let candidates: Vec<JobRow> = jobs::table
+                    let mut query = jobs::table
                         .filter(jobs::queue.eq(queue_name))
                         .filter(jobs::status.eq(JobStatus::Pending as i32))
                         .filter(jobs::scheduled_at.le(now))
                         .order((jobs::priority.desc(), jobs::scheduled_at.asc()))
                         .limit(100)
+                        .into_boxed();
+
+                    if let Some(ns) = namespace {
+                        query = query.filter(jobs::namespace.eq(ns));
+                    } else {
+                        query = query.filter(jobs::namespace.is_null());
+                    }
+
+                    let candidates: Vec<JobRow> = query
                         .select(JobRow::as_select())
                         .load(conn)?;
 
@@ -327,9 +337,9 @@ macro_rules! impl_diesel_job_ops {
             }
 
             /// Dequeue from multiple queues, checking each in order.
-            pub fn dequeue_from(&self, queues: &[String], now: i64) -> Result<Option<Job>> {
+            pub fn dequeue_from(&self, queues: &[String], now: i64, namespace: Option<&str>) -> Result<Option<Job>> {
                 for queue_name in queues {
-                    if let Some(job) = self.dequeue(queue_name, now)? {
+                    if let Some(job) = self.dequeue(queue_name, now, namespace)? {
                         return Ok(Some(job));
                     }
                 }
@@ -554,6 +564,8 @@ macro_rules! impl_diesel_job_ops {
             }
 
             /// List jobs with optional filters and pagination.
+            /// When `namespace` is `Some`, only jobs in that namespace are returned.
+            /// When `None`, all jobs are returned regardless of namespace.
             pub fn list_jobs(
                 &self,
                 status: Option<i32>,
@@ -561,6 +573,7 @@ macro_rules! impl_diesel_job_ops {
                 task_name: Option<&str>,
                 limit: i64,
                 offset: i64,
+                namespace: Option<&str>,
             ) -> Result<Vec<Job>> {
                 let mut conn = self.conn()?;
 
@@ -575,6 +588,9 @@ macro_rules! impl_diesel_job_ops {
                 if let Some(t) = task_name {
                     query = query.filter(jobs::task_name.eq(t));
                 }
+                if let Some(ns) = namespace {
+                    query = query.filter(jobs::namespace.eq(ns));
+                }
 
                 let rows: Vec<JobRow> = query
                     .limit(limit)
@@ -678,6 +694,8 @@ macro_rules! impl_diesel_job_ops {
             }
 
             /// List jobs with extended filters.
+            /// When `namespace` is `Some`, only jobs in that namespace are returned.
+            /// When `None`, all jobs are returned regardless of namespace.
             #[allow(clippy::too_many_arguments)]
             pub fn list_jobs_filtered(
                 &self,
@@ -690,6 +708,7 @@ macro_rules! impl_diesel_job_ops {
                 created_before: Option<i64>,
                 limit: i64,
                 offset: i64,
+                namespace: Option<&str>,
             ) -> Result<Vec<Job>> {
                 let mut conn = self.conn()?;
 
@@ -716,6 +735,9 @@ macro_rules! impl_diesel_job_ops {
                 if let Some(before) = created_before {
                     query = query.filter(jobs::created_at.le(before));
                 }
+                if let Some(ns) = namespace {
+                    query = query.filter(jobs::namespace.eq(ns));
+                }
 
                 let rows: Vec<JobRow> = query
                     .limit(limit)

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

@@ -40,6 +40,7 @@ pub struct DeadJob {
     pub max_retries: i32,
     pub timeout_ms: i64,
     pub result_ttl_ms: Option<i64>,
+    pub namespace: Option<String>,
 }
 
 impl From<models::DeadLetterRow> for DeadJob {
@@ -58,6 +59,7 @@ impl From<models::DeadLetterRow> for DeadJob {
             max_retries: row.max_retries,
             timeout_ms: row.timeout_ms,
             result_ttl_ms: row.result_ttl_ms,
+            namespace: row.namespace,
         }
     }
 }
@@ -93,15 +95,17 @@ macro_rules! impl_storage {
                 &self,
                 queue_name: &str,
                 now: i64,
+                namespace: Option<&str>,
             ) -> $crate::error::Result<Option<$crate::job::Job>> {
-                self.dequeue(queue_name, now)
+                self.dequeue(queue_name, now, namespace)
             }
             fn dequeue_from(
                 &self,
                 queues: &[String],
                 now: i64,
+                namespace: Option<&str>,
             ) -> $crate::error::Result<Option<$crate::job::Job>> {
-                self.dequeue_from(queues, now)
+                self.dequeue_from(queues, now, namespace)
             }
             fn complete(
                 &self,
@@ -151,8 +155,9 @@ macro_rules! impl_storage {
                 task_name: Option<&str>,
                 limit: i64,
                 offset: i64,
+                namespace: Option<&str>,
             ) -> $crate::error::Result<Vec<$crate::job::Job>> {
-                self.list_jobs(status, queue_name, task_name, limit, offset)
+                self.list_jobs(status, queue_name, task_name, limit, offset, namespace)
             }
             fn get_job(&self, id: &str) -> $crate::error::Result<Option<$crate::job::Job>> {
                 self.get_job(id)
@@ -347,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,
@@ -357,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)
             }
@@ -473,6 +491,7 @@ macro_rules! impl_storage {
                 created_before: Option<i64>,
                 limit: i64,
                 offset: i64,
+                namespace: Option<&str>,
             ) -> $crate::error::Result<Vec<$crate::job::Job>> {
                 self.list_jobs_filtered(
                     status,
@@ -484,6 +503,7 @@ macro_rules! impl_storage {
                     created_before,
                     limit,
                     offset,
+                    namespace,
                 )
             }
         }
@@ -526,11 +546,16 @@ impl Storage for StorageBackend {
     fn enqueue_unique(&self, new_job: NewJob) -> Result<Job> {
         delegate!(self, enqueue_unique, new_job)
     }
-    fn dequeue(&self, queue_name: &str, now: i64) -> Result<Option<Job>> {
-        delegate!(self, dequeue, queue_name, now)
+    fn dequeue(&self, queue_name: &str, now: i64, namespace: Option<&str>) -> Result<Option<Job>> {
+        delegate!(self, dequeue, queue_name, now, namespace)
     }
-    fn dequeue_from(&self, queues: &[String], now: i64) -> Result<Option<Job>> {
-        delegate!(self, dequeue_from, queues, now)
+    fn dequeue_from(
+        &self,
+        queues: &[String],
+        now: i64,
+        namespace: Option<&str>,
+    ) -> Result<Option<Job>> {
+        delegate!(self, dequeue_from, queues, now, namespace)
     }
     fn complete(&self, id: &str, result_bytes: Option<Vec<u8>>) -> Result<()> {
         delegate!(self, complete, id, result_bytes)
@@ -572,8 +597,9 @@ impl Storage for StorageBackend {
         task_name: Option<&str>,
         limit: i64,
         offset: i64,
+        namespace: Option<&str>,
     ) -> Result<Vec<Job>> {
-        delegate!(self, list_jobs, status, queue_name, task_name, limit, offset)
+        delegate!(self, list_jobs, status, queue_name, task_name, limit, offset, namespace)
     }
     fn get_job(&self, id: &str) -> Result<Option<Job>> {
         delegate!(self, get_job, id)
@@ -726,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,
@@ -735,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)
     }
@@ -818,6 +856,7 @@ impl Storage for StorageBackend {
         created_before: Option<i64>,
         limit: i64,
         offset: i64,
+        namespace: Option<&str>,
     ) -> Result<Vec<Job>> {
         delegate!(
             self,
@@ -830,7 +869,8 @@ impl Storage for StorageBackend {
             created_after,
             created_before,
             limit,
-            offset
+            offset,
+            namespace
         )
     }
 }

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

@@ -75,6 +75,7 @@ pub struct DeadLetterRow {
     pub max_retries: i32,
     pub timeout_ms: i64,
     pub result_ttl_ms: Option<i64>,
+    pub namespace: Option<String>,
 }
 
 /// Insertable struct for dead letter entries.
@@ -94,6 +95,7 @@ pub struct NewDeadLetterRow<'a> {
     pub max_retries: i32,
     pub timeout_ms: i64,
     pub result_ttl_ms: Option<i64>,
+    pub namespace: Option<&'a str>,
 }
 
 /// A row in the `rate_limits` table.
@@ -305,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)]
@@ -318,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 ─────────────────────────────────────────────────
@@ -394,4 +404,5 @@ pub struct ArchivedJobRow {
     pub cancel_requested: i32,
     pub expires_at: Option<i64>,
     pub result_ttl_ms: Option<i64>,
+    pub namespace: Option<String>,
 }

{taskito-0.7.0 → taskito-0.9.0}/crates/taskito-core/src/storage/postgres/archival.rs

@@ -70,7 +70,7 @@ impl PostgresStorage {
                 cancel_requested: row.cancel_requested != 0,
                 expires_at: row.expires_at,
                 result_ttl_ms: row.result_ttl_ms,
-                namespace: None,
+                namespace: row.namespace,
             })
             .collect())
     }

{taskito-0.7.0 → taskito-0.9.0}/crates/taskito-core/src/storage/postgres/dead_letter.rs

@@ -30,6 +30,7 @@ impl PostgresStorage {
                 max_retries: job.max_retries,
                 timeout_ms: job.timeout_ms,
                 result_ttl_ms: job.result_ttl_ms,
+                namespace: job.namespace.as_deref(),
             };
 
             diesel::insert_into(dead_letter::table)
@@ -94,7 +95,7 @@ impl PostgresStorage {
             depends_on: vec![],
             expires_at: None,
             result_ttl_ms: dead_row.result_ttl_ms,
-            namespace: None,
+            namespace: dead_row.namespace,
         };
 
         let job = new_job.into_job();

{taskito-0.7.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,
@@ -434,6 +452,16 @@ impl PostgresStorage {
             "ALTER TABLE circuit_breakers ADD COLUMN IF NOT EXISTS half_open_failure_count INTEGER NOT NULL DEFAULT 0",
         );
 
+        // Migration: add namespace column to dead_letter and archived_jobs
+        migration_alter(
+            &mut conn,
+            "ALTER TABLE dead_letter ADD COLUMN IF NOT EXISTS namespace TEXT",
+        );
+        migration_alter(
+            &mut conn,
+            "ALTER TABLE archived_jobs ADD COLUMN IF NOT EXISTS namespace TEXT",
+        );
+
         // ── Distributed Locks ─────────────────────────────
         diesel::sql_query(
             "CREATE TABLE IF NOT EXISTS distributed_locks (