hyprstream_pds/placement/
workload.rs1use anyhow::{bail, Result};
25
26use super::{
27 map_get_opt_str, map_get_str, validate_at_uri, validate_datetime, validate_did,
28 validate_nonempty,
29};
30use crate::cid::Cid;
31use crate::dag_cbor::DagCbor;
32
33pub const COLLECTION_NSID: &str = "ai.hyprstream.placement.workload";
35
36#[derive(Clone, Debug, Eq, PartialEq)]
38pub struct WorkloadRecord {
39 pub repo: String,
41 pub workload: String,
43 pub node: String,
45 pub group: Option<String>,
47 pub created_at: String,
49}
50
51impl WorkloadRecord {
52 pub fn new(
54 repo: impl Into<String>,
55 workload: impl Into<String>,
56 node: impl Into<String>,
57 group: Option<String>,
58 created_at: impl Into<String>,
59 ) -> Result<Self> {
60 let repo = repo.into();
61 let workload = workload.into();
62 let node = node.into();
63 let created_at = created_at.into();
64 validate_at_uri(&repo)?;
65 validate_nonempty(&workload, "workload")?;
66 validate_did(&node)?;
67 if let Some(g) = &group {
68 validate_nonempty(g, "group")?;
69 }
70 validate_datetime(&created_at)?;
71 Ok(WorkloadRecord {
72 repo,
73 workload,
74 node,
75 group,
76 created_at,
77 })
78 }
79
80 pub fn to_dag_cbor(&self) -> Vec<u8> {
82 self.to_value().encode()
83 }
84
85 pub fn cid(&self) -> Cid {
87 Cid::from_dag_cbor(&self.to_dag_cbor())
88 }
89
90 pub fn to_value(&self) -> DagCbor {
93 let mut pairs: Vec<(&str, DagCbor)> = vec![
94 ("repo", DagCbor::Text(self.repo.clone())),
95 ("workload", DagCbor::Text(self.workload.clone())),
96 ("node", DagCbor::Text(self.node.clone())),
97 ("createdAt", DagCbor::Text(self.created_at.clone())),
98 ];
99 if let Some(group) = &self.group {
100 pairs.push(("group", DagCbor::Text(group.clone())));
101 }
102 DagCbor::str_map(pairs)
103 }
104
105 pub fn from_dag_cbor(bytes: &[u8]) -> Result<Self> {
107 let value = DagCbor::decode(bytes)?;
108 Self::from_value(&value)
109 }
110
111 pub fn from_value(value: &DagCbor) -> Result<Self> {
112 let map = value.as_map()?;
113 let repo = map_get_str(value, "repo", COLLECTION_NSID)?.to_owned();
114 let workload = map_get_str(value, "workload", COLLECTION_NSID)?.to_owned();
115 let node = map_get_str(value, "node", COLLECTION_NSID)?.to_owned();
116 let group = map_get_opt_str(value, "group")?.map(str::to_owned);
117 let created_at = map_get_str(value, "createdAt", COLLECTION_NSID)?.to_owned();
118 for (k, _v) in map {
120 match k.as_str()? {
121 "repo" | "workload" | "node" | "group" | "createdAt" => {}
122 other => {
123 bail!("{COLLECTION_NSID}: unknown field {other:?} (lexicon is 5 fields)")
124 }
125 }
126 }
127 Self::new(repo, workload, node, group, created_at)
128 }
129}
130
131#[cfg(test)]
132mod tests {
133 #![allow(
134 clippy::unwrap_used,
135 clippy::expect_used,
136 clippy::indexing_slicing,
137 clippy::panic
138 )]
139 use super::*;
140
141 fn sample() -> WorkloadRecord {
142 WorkloadRecord::new(
143 "at://did:web:alice.example.com",
144 "at://did:web:alice.example.com/ai.hyprstream.model/3kxy",
145 "did:web:node1.example.com",
146 Some("at://did:web:alice.example.com/ai.hyprstream.placement.group/3kxz".into()),
147 "2026-06-23T12:34:56.789Z",
148 )
149 .expect("valid sample")
150 }
151
152 #[test]
153 fn record_round_trip_same_cid() {
154 let r = sample();
155 let bytes = r.to_dag_cbor();
156 let back = WorkloadRecord::from_dag_cbor(&bytes).expect("round-trip");
157 assert_eq!(r, back);
158 assert_eq!(r.cid(), back.cid());
159 assert_eq!(r.to_dag_cbor(), back.to_dag_cbor());
160 }
161
162 #[test]
163 fn record_optional_group_omitted() {
164 let mut r = sample();
165 r.group = None;
166 let v = r.to_value();
167 assert!(v.get("group").is_none(), "absent group must be omitted");
168 let back = WorkloadRecord::from_dag_cbor(&r.to_dag_cbor()).expect("round-trip");
169 assert_eq!(r, back);
170 }
171
172 #[test]
173 fn record_fields_canonical_order() {
174 let r = sample();
175 let v = DagCbor::decode(&r.to_dag_cbor()).expect("decode");
176 let map = v.as_map().expect("map");
177 let keys: Vec<&str> = map.iter().map(|(k, _)| k.as_str().expect("str")).collect();
178 assert_eq!(keys, vec!["createdAt", "group", "node", "repo", "workload"]);
180 }
181
182 #[test]
183 fn record_rejects_extra_fields() {
184 let mut extra = sample().to_value();
185 if let DagCbor::Map(ref mut v) = extra {
186 v.push((DagCbor::Text("extra".into()), DagCbor::Unsigned(1)));
187 v.sort_by(|a, b| a.0.as_str().unwrap_or("").cmp(b.0.as_str().unwrap_or("")));
188 }
189 assert!(WorkloadRecord::from_value(&extra).is_err());
190 }
191
192 #[test]
193 fn record_validates_formats() {
194 assert!(
196 WorkloadRecord::new("nope", "w", "did:web:n", None, "2026-06-23T12:34:56.789Z")
197 .is_err()
198 );
199 assert!(WorkloadRecord::new(
201 "at://did:web:x",
202 "",
203 "did:web:n",
204 None,
205 "2026-06-23T12:34:56.789Z"
206 )
207 .is_err());
208 assert!(WorkloadRecord::new(
210 "at://did:web:x",
211 "w",
212 "not-a-did",
213 None,
214 "2026-06-23T12:34:56.789Z"
215 )
216 .is_err());
217 assert!(WorkloadRecord::new(
219 "at://did:web:x",
220 "w",
221 "did:web:n",
222 Some("".into()),
223 "2026-06-23T12:34:56.789Z"
224 )
225 .is_err());
226 assert!(WorkloadRecord::new("at://did:web:x", "w", "did:web:n", None, "2026").is_err());
228 }
229}