1use serde::{Deserialize, Serialize};
7
8use crate::{
9 api::{HealthResponse, RunStats, Verdict},
10 types::{
11 Accuracy, DriveUsage, EndCause, JobProfile, JobRun, Lease, LeaseId, NoiseReport,
12 ResourceUsage, SessionKey, is_default,
13 },
14};
15
16#[cfg_attr(any(feature = "schema", test), derive(schemars::JsonSchema))]
18#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
19pub struct UiState {
20 pub generated_at_ms: i64,
23 pub service: HealthResponse,
25 pub first_session_at_ms: Option<i64>,
28 pub sessions: Vec<UiSession>,
30 pub active: Vec<ActiveJob>,
32 pub queue: Vec<QueuedJob>,
34 pub meters: Meters,
36 pub recent: Vec<RecentRun>,
38 pub notices: Vec<Notice>,
40 #[serde(default)]
43 pub ended: Vec<EndedLease>,
44}
45
46#[cfg_attr(any(feature = "schema", test), derive(schemars::JsonSchema))]
48#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
49pub struct UiSession {
50 pub session: SessionKey,
52 pub cwd: Option<String>,
55 pub usage: ResourceUsage,
57}
58
59#[cfg_attr(any(feature = "schema", test), derive(schemars::JsonSchema))]
61#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
62pub struct ActiveJob {
63 pub lease: Lease,
65 pub process: Option<JobProcess>,
67 #[serde(default)]
71 pub quiet_at_start: Option<bool>,
72}
73
74#[cfg_attr(any(feature = "schema", test), derive(schemars::JsonSchema))]
76#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
77pub struct JobProcess {
78 pub pid: u32,
80 pub name: String,
82 pub exe: Option<String>,
84 pub bound: bool,
88}
89
90#[cfg_attr(any(feature = "schema", test), derive(schemars::JsonSchema))]
92#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
93pub struct QueuedJob {
94 pub lease: Lease,
96 pub position: u32,
98 pub verdict: Verdict,
100}
101
102#[cfg_attr(any(feature = "schema", test), derive(schemars::JsonSchema))]
104#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
105pub struct Meters {
106 pub headroom_pct: f32,
108 pub cpu: CpuMeter,
110 pub ram: RamMeter,
112 pub gpus: Vec<GpuMeter>,
114 pub drives: Vec<DriveUsage>,
116}
117
118#[cfg_attr(any(feature = "schema", test), derive(schemars::JsonSchema))]
120#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
121pub struct CpuMeter {
122 pub logical_cores: u32,
124 pub usage_pct: f32,
126 pub history_pct: Vec<f32>,
128 pub reserved_cores: f32,
130}
131
132#[cfg_attr(any(feature = "schema", test), derive(schemars::JsonSchema))]
134#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
135pub struct RamMeter {
136 pub total_mb: u64,
138 pub used_mb: u64,
140 pub reserved_mb: u64,
142}
143
144#[cfg_attr(any(feature = "schema", test), derive(schemars::JsonSchema))]
146#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
147pub struct GpuMeter {
148 pub name: String,
150 pub busiest_pct: f32,
152 pub vram_used_mb: u64,
155 pub vram_total_mb: Option<u64>,
158 pub reserved_pct: f32,
161 pub reserved_vram_mb: u64,
164 #[serde(default, skip_serializing_if = "std::ops::Not::not")]
168 #[cfg_attr(any(feature = "schema", test), schemars(extend("default" = false)))]
169 pub unified_memory: bool,
170 #[serde(default, skip_serializing_if = "is_default")]
172 #[cfg_attr(any(feature = "schema", test), schemars(extend("default" = "exact")))]
173 pub process_load: Accuracy,
174}
175
176#[cfg_attr(any(feature = "schema", test), derive(schemars::JsonSchema))]
178#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
179pub struct RecentRun {
180 pub lease_id: Option<LeaseId>,
182 pub session: Option<SessionKey>,
184 pub command: String,
186 pub cwd: String,
188 pub declared: JobProfile,
190 pub started_at_ms: i64,
192 pub ended_at_ms: i64,
194 pub end_cause: Option<EndCause>,
196 pub noise: Option<NoiseReport>,
198 #[serde(default, skip_serializing_if = "Option::is_none")]
201 pub stats: Option<RunStats>,
202}
203
204impl From<JobRun> for RecentRun {
205 fn from(run: JobRun) -> Self {
206 Self {
207 lease_id: run.lease_id,
208 session: run.session,
209 command: run.command,
210 cwd: run.cwd,
211 declared: run.declared,
212 started_at_ms: run.started_at_ms,
213 ended_at_ms: run.ended_at_ms,
214 end_cause: run.end_cause,
215 noise: run.noise,
216 stats: None,
217 }
218 }
219}
220
221#[cfg_attr(any(feature = "schema", test), derive(schemars::JsonSchema))]
223#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
224pub struct EndedLease {
225 pub lease_id: LeaseId,
227 pub session: SessionKey,
229 pub command: String,
231 pub cause: EndCause,
233 pub reason: String,
236 pub granted_at_ms: Option<i64>,
238 pub ended_at_ms: i64,
240}
241
242#[cfg_attr(any(feature = "schema", test), derive(schemars::JsonSchema))]
244#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
245pub struct Notice {
246 pub lease_id: LeaseId,
248 pub session: SessionKey,
250 pub cause: EndCause,
252 pub command: String,
254 #[serde(default)]
257 pub tool_use_id: Option<String>,
258 pub ended_at_ms: i64,
260 pub delivered_at_ms: Option<i64>,
262}
263
264#[cfg(test)]
265mod tests {
266 use super::*;
267 use crate::test_support::assert_json_round_trip;
268
269 #[test]
270 fn test_notice_json_round_trip_writes_cause_and_null_delivery() {
271 let notice = Notice {
272 lease_id: LeaseId(44),
273 session: SessionKey("3f2a9c1e-session".into()),
274 cause: EndCause::Removed,
275 command: "cargo test".into(),
276 tool_use_id: Some("toolu_01".into()),
277 ended_at_ms: 1_793_000_090_000,
278 delivered_at_ms: None,
279 };
280 assert_json_round_trip(¬ice);
281 let value = serde_json::to_value(¬ice).unwrap();
282 assert_eq!(value["lease_id"], 44);
283 assert_eq!(value["cause"], "removed");
284 assert_eq!(value["tool_use_id"], "toolu_01");
285 assert!(value["delivered_at_ms"].is_null());
286 }
287
288 #[test]
289 fn test_ended_lease_json_round_trip_writes_cause_and_null_grant() {
290 let ended = EndedLease {
291 lease_id: LeaseId(45),
292 session: SessionKey("3f2a9c1e-session".into()),
293 command: "npm test".into(),
294 cause: EndCause::Expired,
295 reason: "holder process exited".into(),
296 granted_at_ms: None,
297 ended_at_ms: 1_793_000_090_000,
298 };
299 assert_json_round_trip(&ended);
300 let value = serde_json::to_value(&ended).unwrap();
301 assert_eq!(value["cause"], "expired");
302 assert!(value["granted_at_ms"].is_null());
303 }
304
305 #[test]
306 fn test_ui_state_from_an_older_allotd_has_no_ended_leases() {
307 let mut value = serde_json::to_value(crate::contract::busy()).unwrap();
308 value.as_object_mut().unwrap().remove("ended");
309 let state: UiState = serde_json::from_value(value).unwrap();
310 assert!(state.ended.is_empty());
311 }
312
313 #[test]
314 fn test_gpu_meter_schema_defaults_match_the_rust_defaults() {
315 let schema = schemars::schema_for!(GpuMeter);
316 let properties = &schema.as_value()["properties"];
317 assert_eq!(
318 properties["process_load"]["default"],
319 serde_json::to_value(Accuracy::default()).unwrap()
320 );
321 assert_eq!(properties["unified_memory"]["default"], bool::default());
322 }
323
324 #[test]
325 fn test_gpu_meter_from_an_older_allotd_is_exact_and_not_unified() {
326 let old = r#"{"name":"RTX","busiest_pct":1.0,"vram_used_mb":0,"vram_total_mb":null,
327 "reserved_pct":0.0,"reserved_vram_mb":0}"#;
328 let meter: GpuMeter = serde_json::from_str(old).unwrap();
329 assert!(!meter.unified_memory);
330 assert_eq!(meter.process_load, Accuracy::Exact);
331 }
332
333 #[test]
334 fn test_notice_from_an_older_allotd_has_no_tool_use_id() {
335 let old = r#"{"lease_id":1,"session":"s","cause":"killed","command":"cargo build",
336 "ended_at_ms":5,"delivered_at_ms":null}"#;
337 let notice: Notice = serde_json::from_str(old).unwrap();
338 assert_eq!(notice.tool_use_id, None);
339 }
340}