1use chrono::{DateTime, Utc};
10use serde::{Deserialize, Serialize};
11use std::collections::HashMap;
12
13use crate::distributed::types::{JobId, NodeId, TaskId, WorkerCapabilities};
14
15#[derive(Debug, Clone, Serialize, Deserialize)]
17pub struct RegisterRequest {
18 pub worker_id: NodeId,
20 pub address: String,
22 pub capacity: usize,
24 pub capabilities: WorkerCapabilities,
26 pub tags: Vec<String>,
28 pub metadata: HashMap<String, String>,
30}
31
32#[derive(Debug, Clone, Serialize, Deserialize)]
34pub struct RegisterResponse {
35 pub success: bool,
37 pub coordinator_version: String,
39 pub assigned_worker_id: NodeId,
41 pub heartbeat_interval: u64,
43 pub message: String,
45}
46
47#[derive(Debug, Clone, Serialize, Deserialize)]
49pub struct DeregisterRequest {
50 pub worker_id: NodeId,
52 pub reason: String,
54}
55
56#[derive(Debug, Clone, Serialize, Deserialize)]
58pub struct DeregisterResponse {
59 pub success: bool,
61 pub message: String,
63}
64
65#[derive(Debug, Clone, Serialize, Deserialize)]
67pub struct HealthCheckRequest {
68 pub worker_id: NodeId,
70 pub timestamp: DateTime<Utc>,
72}
73
74#[derive(Debug, Clone, Serialize, Deserialize)]
76pub struct HealthCheckResponse {
77 pub healthy: bool,
79 pub status: String,
81 pub current_tasks: usize,
83 pub available_capacity: usize,
85 pub cpu_usage: f64,
87 pub memory_usage: f64,
89 pub timestamp: DateTime<Utc>,
91}
92
93#[derive(Debug, Clone, Serialize, Deserialize)]
95pub struct HeartbeatRequest {
96 pub worker_id: NodeId,
98 pub status: String,
100 pub current_tasks: usize,
102 pub completed_tasks_delta: u64,
104 pub failed_tasks_delta: u64,
106 pub timestamp: DateTime<Utc>,
108}
109
110#[derive(Debug, Clone, Serialize, Deserialize)]
112pub struct HeartbeatResponse {
113 pub acknowledged: bool,
115 pub has_pending_tasks: bool,
117 pub timestamp: DateTime<Utc>,
119}
120
121#[derive(Debug, Clone, Serialize, Deserialize)]
123pub struct JobRequest {
124 pub job_type: String,
126 pub payload: serde_json::Value,
128 pub priority: i32,
130 pub required_tags: Vec<String>,
132 pub metadata: HashMap<String, String>,
134 pub timeout_seconds: u64,
136 pub max_retries: u32,
138}
139
140impl JobRequest {
141 pub fn builder() -> JobRequestBuilder {
143 JobRequestBuilder::default()
144 }
145}
146
147#[derive(Default)]
149pub struct JobRequestBuilder {
150 job_type: Option<String>,
151 payload: Option<serde_json::Value>,
152 priority: i32,
153 required_tags: Vec<String>,
154 metadata: HashMap<String, String>,
155 timeout_seconds: u64,
156 max_retries: u32,
157}
158
159impl JobRequestBuilder {
160 pub fn job_type(mut self, job_type: impl Into<String>) -> Self {
161 self.job_type = Some(job_type.into());
162 self
163 }
164
165 pub fn payload(mut self, payload: serde_json::Value) -> Self {
166 self.payload = Some(payload);
167 self
168 }
169
170 pub fn priority(mut self, priority: i32) -> Self {
171 self.priority = priority;
172 self
173 }
174
175 pub fn required_tags(mut self, tags: Vec<String>) -> Self {
176 self.required_tags = tags;
177 self
178 }
179
180 pub fn metadata(mut self, metadata: HashMap<String, String>) -> Self {
181 self.metadata = metadata;
182 self
183 }
184
185 pub fn timeout_seconds(mut self, seconds: u64) -> Self {
186 self.timeout_seconds = seconds;
187 self
188 }
189
190 pub fn max_retries(mut self, retries: u32) -> Self {
191 self.max_retries = retries;
192 self
193 }
194
195 pub fn build(self) -> JobRequest {
196 JobRequest {
197 job_type: self.job_type.unwrap_or_else(|| "default".to_string()),
198 payload: self.payload.unwrap_or(serde_json::json!({})),
199 priority: self.priority,
200 required_tags: self.required_tags,
201 metadata: self.metadata,
202 timeout_seconds: self.timeout_seconds,
203 max_retries: self.max_retries,
204 }
205 }
206}
207
208#[derive(Debug, Clone, Serialize, Deserialize)]
210pub struct JobResponse {
211 pub job_id: JobId,
213 pub success: bool,
215 pub message: String,
217 pub estimated_completion: Option<DateTime<Utc>>,
219}
220
221#[derive(Debug, Clone, Serialize, Deserialize)]
223pub struct TaskRequest {
224 pub task_id: TaskId,
226 pub job_id: JobId,
228 pub task_type: String,
230 pub payload: serde_json::Value,
232 pub metadata: HashMap<String, String>,
234 pub timeout_seconds: u64,
236 pub retry_count: u32,
238}
239
240#[derive(Debug, Clone, Serialize, Deserialize)]
242pub struct TaskResponse {
243 pub task_id: TaskId,
245 pub success: bool,
247 pub result: Option<serde_json::Value>,
249 pub error: Option<String>,
251 pub execution_time_ms: u64,
253 pub completed_at: DateTime<Utc>,
255}
256
257#[derive(Debug, Clone, Serialize, Deserialize)]
259pub struct PullTaskRequest {
260 pub worker_id: NodeId,
262 pub count: usize,
264 pub capabilities: Vec<String>,
266}
267
268#[derive(Debug, Clone, Serialize, Deserialize)]
270pub struct PullTaskResponse {
271 pub tasks: Vec<TaskRequest>,
273 pub message: String,
275}
276
277#[derive(Debug, Clone, Serialize, Deserialize)]
279pub struct JobStatusRequest {
280 pub job_id: JobId,
282}
283
284#[derive(Debug, Clone, Serialize, Deserialize)]
286pub struct JobStatusResponse {
287 pub job_id: JobId,
289 pub status: String,
291 pub progress: f64,
293 pub result: Option<serde_json::Value>,
295 pub error: Option<String>,
297 pub created_at: DateTime<Utc>,
299 pub started_at: Option<DateTime<Utc>>,
301 pub completed_at: Option<DateTime<Utc>>,
303}
304
305#[derive(Debug, Clone, Serialize, Deserialize)]
307pub struct CancelJobRequest {
308 pub job_id: JobId,
310 pub reason: String,
312}
313
314#[derive(Debug, Clone, Serialize, Deserialize)]
316pub struct CancelJobResponse {
317 pub success: bool,
319 pub message: String,
321}
322
323#[derive(Debug, Clone, Serialize, Deserialize)]
325pub struct ListWorkersRequest {
326 pub status_filter: Option<String>,
328 pub tag_filter: Vec<String>,
330}
331
332#[derive(Debug, Clone, Serialize, Deserialize)]
334pub struct ListWorkersResponse {
335 pub workers: Vec<WorkerSummary>,
337 pub total: usize,
339}
340
341#[derive(Debug, Clone, Serialize, Deserialize)]
343pub struct WorkerSummary {
344 pub worker_id: NodeId,
346 pub address: String,
348 pub status: String,
350 pub current_tasks: usize,
352 pub capacity: usize,
354 pub load: f64,
356 pub tags: Vec<String>,
358 pub last_heartbeat: DateTime<Utc>,
360}
361
362#[derive(Debug, Clone, Serialize, Deserialize)]
364pub struct ClusterStatsRequest {}
365
366#[derive(Debug, Clone, Serialize, Deserialize)]
368pub struct ClusterStatsResponse {
369 pub total_workers: usize,
371 pub active_workers: usize,
373 pub total_jobs: u64,
375 pub pending_jobs: usize,
377 pub running_jobs: usize,
379 pub completed_jobs: u64,
381 pub failed_jobs: u64,
383 pub avg_job_duration: f64,
385 pub uptime_seconds: u64,
387}
388
389#[cfg(test)]
390mod tests {
391 use super::*;
392
393 #[test]
394 fn test_job_request_builder() {
395 let job = JobRequest::builder()
396 .job_type("benchmark")
397 .payload(serde_json::json!({"model": "gpt-4"}))
398 .priority(10)
399 .timeout_seconds(300)
400 .max_retries(3)
401 .build();
402
403 assert_eq!(job.job_type, "benchmark");
404 assert_eq!(job.priority, 10);
405 assert_eq!(job.timeout_seconds, 300);
406 assert_eq!(job.max_retries, 3);
407 }
408
409 #[test]
410 fn test_heartbeat_request() {
411 let heartbeat = HeartbeatRequest {
412 worker_id: "worker-1".to_string(),
413 status: "idle".to_string(),
414 current_tasks: 0,
415 completed_tasks_delta: 5,
416 failed_tasks_delta: 0,
417 timestamp: Utc::now(),
418 };
419
420 assert_eq!(heartbeat.worker_id, "worker-1");
421 assert_eq!(heartbeat.current_tasks, 0);
422 }
423}