1#![forbid(unsafe_code)]
9
10use std::{collections::BTreeMap, path::PathBuf};
11
12use serde::{
13 de::{Error as _, MapAccess, SeqAccess, Visitor},
14 ser::SerializeMap,
15 Deserialize, Deserializer, Serialize, Serializer,
16};
17use subc_protocol::{
18 manifest::{
19 CapabilityDeclarations, EventDeclaration, ManifestProvenance, OperationDelivery,
20 OperationPayload, ProviderRole, RichUiDescriptor, SelfSignalDeclaration,
21 },
22 scope::ScopeSelector,
23 session::HealthStatus,
24 BindIdentity, RouteTarget,
25};
26
27pub use subc_protocol::RouteCloseReason;
28
29mod activity;
30pub use activity::*;
31
32mod scope_served_by;
33pub use scope_served_by::*;
34
35macro_rules! open_string_enum {
36 (
37 $(#[$meta:meta])*
38 $name:ident {
39 $( $(#[$variant_meta:meta])* $variant:ident => $wire_name:literal ),+ $(,)?
40 }
41 ) => {
42 $(#[$meta])*
43 #[derive(Debug, Clone, PartialEq, Eq)]
44 pub enum $name {
45 $( $(#[$variant_meta])* $variant, )+
46 Unknown(String),
47 }
48
49 impl $name {
50 fn wire_name(&self) -> &str {
51 match self {
52 $( Self::$variant => $wire_name, )+
53 Self::Unknown(value) => value,
54 }
55 }
56 }
57
58 impl Serialize for $name {
59 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
60 where
61 S: serde::Serializer,
62 {
63 serializer.serialize_str(self.wire_name())
64 }
65 }
66
67 impl<'de> Deserialize<'de> for $name {
68 fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
69 where
70 D: serde::Deserializer<'de>,
71 {
72 let value = String::deserialize(deserializer)?;
73 Ok(match value.as_str() {
74 $( $wire_name => Self::$variant, )+
75 _ => Self::Unknown(value),
76 })
77 }
78 }
79 };
80}
81
82mod rescan_checked;
83pub use rescan_checked::*;
84
85#[derive(Clone, Serialize, Deserialize, PartialEq, Eq, Hash)]
87pub struct ConsumerIdentity {
88 pub module_id: String,
89 pub launch_nonce: String,
90}
91
92impl std::fmt::Debug for ConsumerIdentity {
97 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
98 f.debug_struct("ConsumerIdentity")
99 .field("module_id", &self.module_id)
100 .field(
101 "launch_nonce",
102 &format_args!("<{} bytes redacted>", self.launch_nonce.len()),
103 )
104 .finish()
105 }
106}
107
108pub mod ops {
119 pub const SERVER: &str = "server.";
120 pub const CATALOG: &str = "catalog.";
121 pub const ROUTE: &str = "route.";
122 pub const SUPERVISOR: &str = "supervisor.";
123 pub const CONFIG: &str = "config.";
124
125 pub const SERVER_DESCRIBE: &str = "server.describe";
126 pub const CATALOG_LIST: &str = "catalog.list";
127 pub const ROUTE_OPEN: &str = "route.open";
128 pub const ROUTE_POLL: &str = "route.poll";
129 pub const ROUTE_CLOSING: &str = "route.closing";
130 pub const ROUTE_CLOSED: &str = "route.closed";
131 pub const SUPERVISOR_LIST: &str = "supervisor.list";
132 pub const SUPERVISOR_RESTART: &str = "supervisor.restart";
133 pub const SUPERVISOR_SWAP: &str = "supervisor.swap";
134 pub const SUPERVISOR_RELOAD: &str = "supervisor.reload";
135 pub const SUPERVISOR_RESCAN: &str = "supervisor.rescan";
136 pub const SUPERVISOR_RESCAN_CHECKED: &str = "supervisor.rescan_checked";
137 pub const SUPERVISOR_RELEASE_RESERVED: &str = "supervisor.release_reserved";
138 pub const SUPERVISOR_SET_ENABLED: &str = "supervisor.set_enabled";
139 pub const SUPERVISOR_HEALTH_PROBE: &str = "supervisor.health_probe";
140 pub const SUPERVISOR_HEALTH: &str = "supervisor.health";
141 pub const SUPERVISOR_STDERR_TAIL: &str = "supervisor.stderr_tail";
142 pub const SUPERVISOR_TERMINALS: &str = "supervisor.terminals";
143 pub const SUPERVISOR_ROUTES: &str = "supervisor.routes";
144 pub const SUPERVISOR_PROVENANCE: &str = "supervisor.provenance";
145 pub const SUPERVISOR_SPAWN_SNAPSHOT: &str = "supervisor.spawn_snapshot";
146 pub const SUPERVISOR_SPAWN_SUBSCRIBE: &str = "supervisor.spawn_subscribe";
147 pub const ACTIVITY_RECORD: &str = "activity.record";
148 pub const ACTIVITY_QUERY: &str = "activity.query";
149 pub const ACTIVITY_SUBSCRIBE: &str = "activity.subscribe";
150}
151
152#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
154#[serde(tag = "op")]
155#[allow(clippy::large_enum_variant)]
158pub enum ClientControlRequest {
159 #[serde(rename = "server.describe")]
160 ServerDescribe {},
161 #[serde(rename = "catalog.list")]
162 CatalogList {
163 #[serde(default)]
168 module_id: Option<String>,
169 },
170 #[serde(rename = "route.open")]
171 RouteOpen {
172 target: RouteTarget,
173 identity: BindIdentity,
174 #[serde(default, skip_serializing_if = "Option::is_none")]
183 consumer_identity: Option<ConsumerIdentity>,
184 #[serde(default, skip_serializing_if = "Option::is_none")]
192 consumer_capabilities: Option<Vec<String>>,
193 #[serde(default, skip_serializing_if = "Option::is_none")]
204 role_versions: Option<BTreeMap<String, String>>,
205 #[serde(default, skip_serializing_if = "Option::is_none")]
207 admission_facts: Option<serde_json::Value>,
208 #[serde(default, skip_serializing_if = "Option::is_none")]
215 scope: Option<ScopeSelector>,
216 },
217 #[serde(rename = "route.poll")]
218 RoutePoll {
219 route_channel: u16,
220 route_epoch: u32,
221 kind: PollKind,
222 },
223 #[serde(rename = "supervisor.list")]
224 SupervisorList {},
225 #[serde(rename = "supervisor.spawn_snapshot")]
227 SupervisorSpawnSnapshot {},
228 #[serde(rename = "supervisor.spawn_subscribe")]
244 SupervisorSpawnSubscribe {
245 #[serde(default, skip_serializing_if = "Option::is_none")]
246 since: Option<SpawnCursor>,
247 },
248 #[serde(rename = "supervisor.restart")]
249 SupervisorRestart {
250 module_id: String,
251 #[serde(default, skip_serializing_if = "Option::is_none")]
261 drain_timeout_ms: Option<u64>,
262 },
263 #[serde(rename = "supervisor.swap")]
278 SupervisorSwap {
279 module_id: String,
280 #[serde(default, skip_serializing_if = "Option::is_none")]
283 ready_timeout_ms: Option<u64>,
284 },
285 #[serde(rename = "supervisor.reload")]
286 SupervisorReload { module_id: String },
287 #[serde(rename = "supervisor.rescan")]
288 SupervisorRescan {
289 #[serde(default, skip_serializing_if = "std::ops::Not::not")]
309 preview: bool,
310 },
311 #[serde(rename = "supervisor.rescan_checked")]
335 SupervisorRescanChecked {
336 preview: bool,
337 #[serde(default, skip_serializing_if = "Option::is_none")]
338 candidate: Option<String>,
339 #[serde(default, skip_serializing_if = "Option::is_none")]
340 expect: Option<RescanExpect>,
341 },
342 #[serde(rename = "supervisor.release_reserved")]
346 SupervisorReleaseReserved { module_id: String },
347 #[serde(rename = "supervisor.set_enabled")]
348 SupervisorSetEnabled { module_id: String, enabled: bool },
349 #[serde(rename = "supervisor.health_probe")]
350 SupervisorHealthProbe { module_id: String },
351 #[serde(rename = "supervisor.health")]
352 SupervisorHealth {},
353 #[serde(rename = "supervisor.routes")]
366 SupervisorRoutes {
367 #[serde(default, skip_serializing_if = "Option::is_none")]
368 module_id: Option<String>,
369 },
370 #[serde(rename = "supervisor.provenance")]
373 SupervisorProvenance {
374 #[serde(default, skip_serializing_if = "Option::is_none")]
375 module_id: Option<String>,
376 },
377 #[serde(rename = "supervisor.stderr_tail")]
385 SupervisorStderrTail {
386 module_id: String,
387 #[serde(default, skip_serializing_if = "Option::is_none")]
388 max_lines: Option<u32>,
389 #[serde(default, skip_serializing_if = "Option::is_none")]
390 max_bytes: Option<u32>,
391 },
392 #[serde(rename = "supervisor.terminals")]
405 SupervisorTerminals { module_id: String },
406}
407
408#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
410#[serde(tag = "op")]
411pub enum ClientControlResponse {
412 #[serde(rename = "server.describe")]
413 ServerDescribe {
414 protocol_ver: u8,
415 subc_ops: Vec<String>,
416 capabilities: Vec<String>,
417 connected_clients: u64,
418 #[serde(default, skip_serializing_if = "Option::is_none")]
419 counters: Option<serde_json::Value>,
420 #[serde(default, skip_serializing_if = "Option::is_none")]
427 build_git_sha: Option<String>,
428 #[serde(default, skip_serializing_if = "Option::is_none")]
434 build_lock_digest: Option<String>,
435 #[serde(default, skip_serializing_if = "Vec::is_empty")]
439 capability_requirements: Vec<CapabilityRequirementStatus>,
440 #[serde(default, skip_serializing_if = "Option::is_none")]
445 machine_id: Option<String>,
446 #[serde(default, skip_serializing_if = "Option::is_none")]
455 config_path: Option<PathBuf>,
456 },
457 #[serde(rename = "catalog.list")]
458 CatalogList {
459 generation: u64,
460 modules: Vec<CatalogEntry>,
461 subc_ops: Vec<String>,
462 },
463 #[serde(rename = "route.open")]
464 RouteOpen {
465 route_channel: u16,
466 route_epoch: u32,
467 },
468 #[serde(rename = "route.poll")]
469 RoutePoll {
470 route_channel: u16,
471 route_epoch: u32,
472 status: Option<String>,
473 live: Option<bool>,
474 },
475 #[serde(rename = "supervisor.list")]
476 SupervisorList {
477 generation: u64,
478 modules: Vec<SupervisorEntry>,
479 },
480 #[serde(rename = "supervisor.spawn_snapshot")]
481 SupervisorSpawnSnapshot {
482 #[serde(flatten)]
483 snapshot: SpawnSnapshot,
484 },
485 #[serde(rename = "supervisor.ack")]
486 SupervisorAck { module_id: String, applied: bool },
487 #[serde(rename = "supervisor.rescan")]
488 SupervisorRescan {
489 #[serde(flatten)]
490 result: SupervisorRescanResult,
491 },
492 #[serde(rename = "supervisor.health_probe")]
493 SupervisorHealthProbe {
494 module_id: String,
495 status: HealthStatus,
496 #[serde(default, skip_serializing_if = "Option::is_none")]
497 detail: Option<String>,
498 #[serde(default, skip_serializing_if = "Option::is_none")]
499 metrics: Option<serde_json::Value>,
500 },
501 #[serde(rename = "supervisor.health")]
502 SupervisorHealth {
503 generation: u64,
504 modules: Vec<SupervisorHealthEntry>,
505 },
506 #[serde(rename = "supervisor.routes")]
507 SupervisorRoutes { modules: Vec<SupervisorRouteModule> },
508 #[serde(rename = "supervisor.provenance")]
509 SupervisorProvenance {
510 daemon: SupervisorDaemonProvenance,
511 modules: Vec<SupervisorModuleProvenance>,
512 },
513 #[serde(rename = "supervisor.stderr_tail")]
514 SupervisorStderrTail {
515 module_id: String,
516 #[serde(flatten)]
517 tail: StderrTail,
518 },
519 #[serde(rename = "supervisor.terminals")]
520 SupervisorTerminals {
521 module_id: String,
522 #[serde(flatten)]
523 terminals: TerminalHistory,
524 },
525}
526
527#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
532#[serde(tag = "op")]
533pub enum ClientControlPush {
534 #[serde(rename = "route.closing")]
535 RouteClosing {
536 module_id: String,
537 #[serde(default)]
540 channels: Vec<u16>,
541 reason: RouteCloseReason,
542 },
543 #[serde(rename = "route.closed")]
544 RouteClosed {
545 module_id: String,
546 #[serde(default)]
549 channels: Vec<u16>,
550 reason: RouteCloseReason,
551 drained: bool,
553 abandoned: u32,
556 #[serde(default)]
558 excluded_subscriptions: u32,
559 #[serde(default, skip_serializing_if = "Option::is_none")]
565 terminal: Option<bool>,
566 },
567}
568
569#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
571pub struct SpawnCursor {
572 pub daemon_incarnation: String,
573 pub seq: u64,
574}
575
576#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
578pub struct LiveSpawn {
579 pub module_id: String,
580 pub spawn_generation: u64,
581 pub pid: u32,
582 pub spawned_at_ms: u64,
583}
584
585#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
587pub struct SpawnSnapshot {
588 pub cursor: SpawnCursor,
589 pub ring_bound: u64,
591 pub live: Vec<LiveSpawn>,
592}
593
594#[derive(Debug, Clone, Copy, Serialize, Deserialize, PartialEq, Eq)]
596#[serde(rename_all = "snake_case")]
597pub enum SpawnEventKind {
598 Spawned,
599 Exited,
600}
601
602#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
608pub struct SpawnEvent {
609 pub cursor: SpawnCursor,
610 pub kind: SpawnEventKind,
611 pub module_id: String,
612 pub spawn_generation: u64,
613 pub pid: u32,
614 #[serde(default, skip_serializing_if = "Option::is_none")]
615 pub exit_code: Option<i32>,
616 #[serde(default, skip_serializing_if = "Option::is_none")]
617 pub exit_signal: Option<i32>,
618}
619
620#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
622pub struct StderrTail {
623 pub capture: StderrCaptureState,
624 pub entries: Vec<StderrTailEntry>,
625 #[serde(default, skip_serializing_if = "is_zero_u64")]
634 pub dropped_lines: u64,
635}
636
637#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
639pub struct SupervisorRouteModule {
640 pub module_id: String,
641 pub routes: Vec<SupervisorRoute>,
642}
643
644#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
646pub struct SupervisorRoute {
647 pub consumer: SupervisorRouteConsumer,
648 pub age_ms: u64,
650 pub draining: bool,
653 #[serde(default, skip_serializing_if = "Option::is_none")]
659 pub drain_reason: Option<RouteCloseReason>,
660}
661
662#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
664pub struct SupervisorModuleProvenance {
665 pub module_id: String,
666 pub module_declared: ModuleDeclaredProvenance,
667 pub daemon_observed: SupervisorObservedProcess,
668}
669
670#[derive(Debug, Clone, PartialEq)]
672pub enum ModuleDeclaredProvenance {
673 Reported {
674 build: ManifestProvenance,
675 },
676 Unverifiable,
677 Unknown {
680 tag: String,
681 body: OrderedJsonObject,
682 },
683}
684
685#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
690pub struct SupervisorObservedProcess {
691 #[serde(default, skip_serializing_if = "Option::is_none")]
697 pub launch_nonce_source: Option<String>,
698 #[serde(default, skip_serializing_if = "Option::is_none")]
699 pub pid: Option<u32>,
700 #[serde(default, skip_serializing_if = "Option::is_none")]
701 pub spawned_at_ms: Option<u64>,
702 #[serde(default, skip_serializing_if = "Option::is_none")]
703 pub spawned_from: Option<PathBuf>,
704 pub running_image: RunningImageAgreement,
705}
706
707#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
710pub struct PendingReloadVerdict {
711 pub path: ReloadPathAgreement,
712 pub image: RunningImageAgreement,
713 #[serde(default, skip_serializing_if = "Option::is_none")]
714 pub spec: Option<LaunchSpecAgreement>,
715}
716
717#[cfg(test)]
718mod launch_spec_wire_tests {
719 use super::*;
720
721 #[test]
722 fn older_daemon_omission_is_not_reported_and_unknown_status_round_trips() {
723 let old = r#"{"path":{"status":"match"},"image":{"status":"unavailable","reason":"not_running"}}"#;
724 let parsed: PendingReloadVerdict = serde_json::from_str(old).unwrap();
725 assert_eq!(parsed.spec, None);
726 assert_eq!(serde_json::to_string(&parsed).unwrap(), old);
727 let future = r#"{"status":"future_spec","detail":{"z":1,"a":2}}"#;
728 let parsed: LaunchSpecAgreement = serde_json::from_str(future).unwrap();
729 assert!(
730 matches!(parsed, LaunchSpecAgreement::Unknown { ref tag, .. } if tag == "future_spec")
731 );
732 assert_eq!(serde_json::to_string(&parsed).unwrap(), future);
733 let unavailable = LaunchSpecAgreement::Unavailable {
734 reason: LaunchSpecUnavailableReason::SpawnedSpecUnavailable,
735 };
736 let encoded = serde_json::to_string(&unavailable).unwrap();
737 assert_eq!(
738 encoded,
739 r#"{"status":"unavailable","reason":"spawned_spec_unavailable"}"#
740 );
741 assert_eq!(
742 serde_json::from_str::<LaunchSpecAgreement>(&encoded).unwrap(),
743 unavailable
744 );
745 }
746}
747
748#[derive(Debug, Clone, PartialEq)]
751pub enum LaunchSpecAgreement {
752 Match,
753 Mismatch,
754 Unavailable {
755 reason: LaunchSpecUnavailableReason,
756 },
757 Unknown {
758 tag: String,
759 body: OrderedJsonObject,
760 },
761}
762
763open_string_enum! {
764 LaunchSpecUnavailableReason {
765 NotRunning => "not_running",
766 SpawnedSpecUnavailable => "spawned_spec_unavailable",
767 }
768}
769
770#[derive(Debug, Clone, PartialEq)]
772pub enum ReloadPathAgreement {
773 Match,
774 Mismatch {
775 configured: PathBuf,
776 spawned_from: PathBuf,
777 },
778 Unavailable {
779 reason: ReloadPathUnavailableReason,
780 },
781 Unknown {
782 tag: String,
783 body: OrderedJsonObject,
784 },
785}
786
787open_string_enum! {
788 ReloadPathUnavailableReason {
790 NotRunning => "not_running",
791 SpawnedPathUnavailable => "spawned_path_unavailable",
792 }
793}
794
795#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
797pub struct SupervisorDaemonProvenance {
798 pub daemon_build: DaemonBuildProvenance,
799 pub daemon_observed: DaemonObservedProcess,
800}
801
802#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
804pub struct DaemonBuildProvenance {
805 #[serde(default, skip_serializing_if = "Option::is_none")]
806 pub build_git_sha: Option<String>,
807 #[serde(default, skip_serializing_if = "Option::is_none")]
808 pub build_lock_digest: Option<String>,
809}
810
811#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
813pub struct DaemonObservedProcess {
814 #[serde(default, skip_serializing_if = "Option::is_none")]
815 pub pid: Option<u32>,
816 #[serde(default, skip_serializing_if = "Option::is_none")]
821 pub started_at_ms: Option<u64>,
822 pub running_image: RunningImageAgreement,
823}
824
825#[derive(Debug, Clone, PartialEq)]
827pub enum RunningImageAgreement {
828 Match {
829 evidence: RunningImageEvidence,
830 },
831 Mismatch {
832 running: RunningImageEvidence,
833 disk: RunningImageEvidence,
834 },
835 Unavailable {
836 reason: RunningImageUnavailableReason,
837 },
838 Unknown {
841 tag: String,
842 body: OrderedJsonObject,
843 },
844}
845
846#[derive(Debug, Clone, PartialEq)]
848pub enum RunningImageEvidence {
849 LinuxProcSha256 {
850 digest: String,
851 },
852 MacosSpawnInode {
853 device: u64,
854 inode: u64,
855 },
856 WindowsSpawnFileId {
858 volume_serial_number: u64,
859 file_id: [u8; 16],
860 },
861 Unknown {
864 tag: String,
865 body: OrderedJsonObject,
866 },
867}
868
869open_string_enum! {
870 RunningImageUnavailableReason {
872 NotRunning => "not_running",
873 UnsupportedPlatform => "unsupported_platform",
874 RunningExecutableUnreadable => "running_executable_unreadable",
875 RunningExecutablePermissionDenied => "running_executable_permission_denied",
876 ProcessHidden => "process_hidden",
877 SpawnedPathUnreadable => "spawned_path_unreadable",
878 HashFailed => "hash_failed",
879 ProcessIdentityUnconfirmed => "process_identity_unconfirmed",
880 }
881}
882
883#[derive(Debug, Clone, PartialEq)]
889pub enum SupervisorRouteConsumer {
890 Reserved {
891 module_id: String,
892 },
893 Direct {
894 connection_id: u64,
895 },
896 Unknown {
899 tag: String,
900 body: OrderedJsonObject,
901 },
902}
903
904#[derive(Debug, Clone, PartialEq)]
911pub enum StderrCaptureState {
912 Captured,
915 Incomplete { reason: String },
917 NotCaptured { reason: String },
919 Unknown {
922 tag: String,
923 body: OrderedJsonObject,
924 },
925}
926
927#[derive(Debug, Clone, PartialEq)]
928pub enum StderrTailEntry {
929 Line {
930 text: String,
931 truncated: bool,
936 at_ms: Option<u64>,
940 },
941 ProcessStart,
946 Unknown {
949 tag: String,
950 body: OrderedJsonObject,
951 },
952}
953
954#[derive(Debug, Serialize, Deserialize)]
955#[serde(tag = "status", rename_all = "snake_case")]
956enum ModuleDeclaredProvenanceWire {
957 Reported { build: ManifestProvenance },
958 Unverifiable,
959}
960
961#[derive(Debug, Serialize, Deserialize)]
962#[serde(tag = "status", rename_all = "snake_case")]
963enum RunningImageAgreementWire {
964 Match {
965 evidence: RunningImageEvidence,
966 },
967 Mismatch {
968 running: RunningImageEvidence,
969 disk: RunningImageEvidence,
970 },
971 Unavailable {
972 reason: RunningImageUnavailableReason,
973 },
974}
975
976#[derive(Debug, Serialize, Deserialize)]
977#[serde(tag = "status", rename_all = "snake_case")]
978enum ReloadPathAgreementWire {
979 Match,
980 Mismatch {
981 configured: PathBuf,
982 spawned_from: PathBuf,
983 },
984 Unavailable {
985 reason: ReloadPathUnavailableReason,
986 },
987}
988
989#[derive(Debug, Serialize, Deserialize)]
990#[serde(tag = "status", rename_all = "snake_case")]
991enum LaunchSpecAgreementWire {
992 Match,
993 Mismatch,
994 Unavailable { reason: LaunchSpecUnavailableReason },
995}
996
997#[derive(Debug, Serialize, Deserialize)]
998#[serde(tag = "method", rename_all = "snake_case")]
999enum RunningImageEvidenceWire {
1000 LinuxProcSha256 {
1001 digest: String,
1002 },
1003 MacosSpawnInode {
1004 device: u64,
1005 inode: u64,
1006 },
1007 WindowsSpawnFileId {
1008 volume_serial_number: u64,
1009 file_id: [u8; 16],
1010 },
1011}
1012
1013#[derive(Debug, Serialize, Deserialize)]
1014#[serde(tag = "kind", rename_all = "snake_case")]
1015enum SupervisorRouteConsumerWire {
1016 Reserved { module_id: String },
1017 Direct { connection_id: u64 },
1018}
1019
1020#[derive(Debug, Serialize, Deserialize)]
1021#[serde(tag = "state", rename_all = "snake_case")]
1022enum StderrCaptureStateWire {
1023 Captured,
1024 Incomplete { reason: String },
1025 NotCaptured { reason: String },
1026}
1027
1028#[derive(Debug, Serialize, Deserialize)]
1029#[serde(tag = "status", rename_all = "snake_case")]
1030enum ChildResourceUsageWire {
1031 Measured(ChildResourceReading),
1032 Unavailable {
1033 reason: ChildResourceUnavailableReason,
1034 },
1035}
1036
1037#[derive(Debug, Serialize, Deserialize)]
1038#[serde(tag = "kind", rename_all = "snake_case")]
1039enum StderrTailEntryWire {
1040 Line {
1041 text: String,
1042 #[serde(default, skip_serializing_if = "std::ops::Not::not")]
1043 truncated: bool,
1044 #[serde(default, skip_serializing_if = "Option::is_none")]
1047 at_ms: Option<u64>,
1048 },
1049 ProcessStart,
1050}
1051
1052#[derive(Debug, Clone, PartialEq)]
1054pub enum OrderedJsonValue {
1055 Null,
1056 Bool(bool),
1057 Number(serde_json::Number),
1058 String(String),
1059 Array(Vec<Self>),
1060 Object(OrderedJsonObject),
1061}
1062
1063#[derive(Debug, Clone, PartialEq)]
1065pub struct OrderedJsonObject(Vec<(String, OrderedJsonValue)>);
1066
1067impl OrderedJsonObject {
1068 pub fn as_entries(&self) -> &[(String, OrderedJsonValue)] {
1070 &self.0
1071 }
1072
1073 fn into_value(self) -> serde_json::Value {
1074 serde_json::Value::Object(
1075 self.0
1076 .into_iter()
1077 .map(|(key, value)| (key, value.into_value()))
1078 .collect(),
1079 )
1080 }
1081}
1082
1083impl OrderedJsonValue {
1084 fn into_value(self) -> serde_json::Value {
1085 match self {
1086 Self::Null => serde_json::Value::Null,
1087 Self::Bool(value) => serde_json::Value::Bool(value),
1088 Self::Number(value) => serde_json::Value::Number(value),
1089 Self::String(value) => serde_json::Value::String(value),
1090 Self::Array(values) => {
1091 serde_json::Value::Array(values.into_iter().map(Self::into_value).collect())
1092 }
1093 Self::Object(value) => value.into_value(),
1094 }
1095 }
1096}
1097
1098impl Serialize for OrderedJsonValue {
1099 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
1100 where
1101 S: Serializer,
1102 {
1103 match self {
1104 Self::Null => serializer.serialize_unit(),
1105 Self::Bool(value) => serializer.serialize_bool(*value),
1106 Self::Number(value) => value.serialize(serializer),
1107 Self::String(value) => serializer.serialize_str(value),
1108 Self::Array(values) => values.serialize(serializer),
1109 Self::Object(value) => value.serialize(serializer),
1110 }
1111 }
1112}
1113
1114impl<'de> Deserialize<'de> for OrderedJsonValue {
1115 fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
1116 where
1117 D: Deserializer<'de>,
1118 {
1119 struct OrderedValueVisitor;
1120
1121 impl<'de> Visitor<'de> for OrderedValueVisitor {
1122 type Value = OrderedJsonValue;
1123
1124 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1125 formatter.write_str("a JSON value with ordered object members")
1126 }
1127
1128 fn visit_unit<E>(self) -> Result<Self::Value, E>
1129 where
1130 E: serde::de::Error,
1131 {
1132 Ok(OrderedJsonValue::Null)
1133 }
1134
1135 fn visit_none<E>(self) -> Result<Self::Value, E>
1136 where
1137 E: serde::de::Error,
1138 {
1139 Ok(OrderedJsonValue::Null)
1140 }
1141
1142 fn visit_some<D>(self, deserializer: D) -> Result<Self::Value, D::Error>
1143 where
1144 D: Deserializer<'de>,
1145 {
1146 OrderedJsonValue::deserialize(deserializer)
1147 }
1148
1149 fn visit_bool<E>(self, value: bool) -> Result<Self::Value, E>
1150 where
1151 E: serde::de::Error,
1152 {
1153 Ok(OrderedJsonValue::Bool(value))
1154 }
1155
1156 fn visit_i64<E>(self, value: i64) -> Result<Self::Value, E>
1157 where
1158 E: serde::de::Error,
1159 {
1160 Ok(OrderedJsonValue::Number(value.into()))
1161 }
1162
1163 fn visit_u64<E>(self, value: u64) -> Result<Self::Value, E>
1164 where
1165 E: serde::de::Error,
1166 {
1167 Ok(OrderedJsonValue::Number(value.into()))
1168 }
1169
1170 fn visit_f64<E>(self, value: f64) -> Result<Self::Value, E>
1171 where
1172 E: serde::de::Error,
1173 {
1174 serde_json::Number::from_f64(value)
1175 .map(OrderedJsonValue::Number)
1176 .ok_or_else(|| E::custom("non-finite JSON number"))
1177 }
1178
1179 fn visit_str<E>(self, value: &str) -> Result<Self::Value, E>
1180 where
1181 E: serde::de::Error,
1182 {
1183 Ok(OrderedJsonValue::String(value.to_owned()))
1184 }
1185
1186 fn visit_string<E>(self, value: String) -> Result<Self::Value, E>
1187 where
1188 E: serde::de::Error,
1189 {
1190 Ok(OrderedJsonValue::String(value))
1191 }
1192
1193 fn visit_seq<A>(self, mut sequence: A) -> Result<Self::Value, A::Error>
1194 where
1195 A: SeqAccess<'de>,
1196 {
1197 let mut values = Vec::new();
1198 while let Some(value) = sequence.next_element()? {
1199 values.push(value);
1200 }
1201 Ok(OrderedJsonValue::Array(values))
1202 }
1203
1204 fn visit_map<A>(self, mut map: A) -> Result<Self::Value, A::Error>
1205 where
1206 A: MapAccess<'de>,
1207 {
1208 let mut entries = Vec::new();
1209 while let Some((key, value)) = map.next_entry()? {
1210 entries.push((key, value));
1211 }
1212 Ok(OrderedJsonValue::Object(OrderedJsonObject(entries)))
1213 }
1214 }
1215
1216 deserializer.deserialize_any(OrderedValueVisitor)
1217 }
1218}
1219
1220impl Serialize for OrderedJsonObject {
1221 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
1222 where
1223 S: Serializer,
1224 {
1225 let mut map = serializer.serialize_map(Some(self.0.len()))?;
1226 for (key, value) in &self.0 {
1227 map.serialize_entry(key, value)?;
1228 }
1229 map.end()
1230 }
1231}
1232
1233impl<'de> Deserialize<'de> for OrderedJsonObject {
1234 fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
1235 where
1236 D: Deserializer<'de>,
1237 {
1238 struct OrderedObjectVisitor;
1239
1240 impl<'de> Visitor<'de> for OrderedObjectVisitor {
1241 type Value = OrderedJsonObject;
1242
1243 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1244 formatter.write_str("an object with ordered JSON members")
1245 }
1246
1247 fn visit_map<A>(self, mut map: A) -> Result<Self::Value, A::Error>
1248 where
1249 A: MapAccess<'de>,
1250 {
1251 let mut entries = Vec::new();
1252 while let Some((key, value)) = map.next_entry()? {
1253 entries.push((key, value));
1254 }
1255 Ok(OrderedJsonObject(entries))
1256 }
1257 }
1258
1259 deserializer.deserialize_map(OrderedObjectVisitor)
1260 }
1261}
1262
1263fn read_tagged<'de, D>(
1264 deserializer: D,
1265 field: &'static str,
1266) -> Result<(String, OrderedJsonObject), D::Error>
1267where
1268 D: Deserializer<'de>,
1269{
1270 let body = OrderedJsonObject::deserialize(deserializer)?;
1271 let mut tag = None;
1272 for (key, value) in body.as_entries() {
1273 if key != field {
1274 continue;
1275 }
1276 if tag.is_some() {
1277 return Err(D::Error::custom(format!(
1278 "tagged object has duplicate `{field}` field"
1279 )));
1280 }
1281 let OrderedJsonValue::String(value) = value else {
1282 return Err(D::Error::custom(format!(
1283 "tagged object has no string `{field}` field"
1284 )));
1285 };
1286 tag = Some(value);
1287 }
1288 let Some(tag) = tag else {
1289 return Err(D::Error::custom(format!(
1290 "tagged object has no string `{field}` field"
1291 )));
1292 };
1293 Ok((tag.to_string(), body))
1294}
1295
1296fn read_ordered_tagged(
1297 value: OrderedJsonValue,
1298 field: &'static str,
1299) -> Result<(String, OrderedJsonObject), String> {
1300 let OrderedJsonValue::Object(body) = value else {
1301 return Err(format!("expected tagged object with `{field}` field"));
1302 };
1303 let mut tag = None;
1304 for (key, value) in body.as_entries() {
1305 if key != field {
1306 continue;
1307 }
1308 if tag.is_some() {
1309 return Err(format!("tagged object has duplicate `{field}` field"));
1310 }
1311 let OrderedJsonValue::String(value) = value else {
1312 return Err(format!("tagged object has no string `{field}` field"));
1313 };
1314 tag = Some(value);
1315 }
1316 let Some(tag) = tag else {
1317 return Err(format!("tagged object has no string `{field}` field"));
1318 };
1319 Ok((tag.to_string(), body))
1320}
1321
1322fn ordered_field<'a>(body: &'a OrderedJsonObject, field: &str) -> Option<&'a OrderedJsonValue> {
1323 body.as_entries()
1324 .iter()
1325 .find_map(|(key, value)| (key == field).then_some(value))
1326}
1327
1328fn ordered_string(body: &OrderedJsonObject, field: &str) -> Result<String, String> {
1329 match ordered_field(body, field) {
1330 Some(OrderedJsonValue::String(value)) => Ok(value.clone()),
1331 Some(_) => Err(format!("tagged object field `{field}` is not a string")),
1332 None => Err(format!("tagged object has no `{field}` field")),
1333 }
1334}
1335
1336fn decode_running_image_evidence(value: OrderedJsonValue) -> Result<RunningImageEvidence, String> {
1337 let (tag, body) = read_ordered_tagged(value, "method")?;
1338 match tag.as_str() {
1339 "linux_proc_sha256" => Ok(RunningImageEvidence::LinuxProcSha256 {
1340 digest: ordered_string(&body, "digest")?,
1341 }),
1342 "macos_spawn_inode" => {
1343 let device = ordered_field(&body, "device")
1344 .and_then(|value| match value {
1345 OrderedJsonValue::Number(number) => number.as_u64(),
1346 _ => None,
1347 })
1348 .ok_or_else(|| "tagged object has no unsigned `device` field".to_string())?;
1349 let inode = ordered_field(&body, "inode")
1350 .and_then(|value| match value {
1351 OrderedJsonValue::Number(number) => number.as_u64(),
1352 _ => None,
1353 })
1354 .ok_or_else(|| "tagged object has no unsigned `inode` field".to_string())?;
1355 Ok(RunningImageEvidence::MacosSpawnInode { device, inode })
1356 }
1357 "windows_spawn_file_id" => {
1358 let wire: RunningImageEvidenceWire = serde_json::from_value(
1359 serde_json::to_value(&body).map_err(|error| error.to_string())?,
1360 )
1361 .map_err(|error| error.to_string())?;
1362 match wire {
1363 RunningImageEvidenceWire::WindowsSpawnFileId {
1364 volume_serial_number,
1365 file_id,
1366 } => Ok(RunningImageEvidence::WindowsSpawnFileId {
1367 volume_serial_number,
1368 file_id,
1369 }),
1370 _ => unreachable!(),
1371 }
1372 }
1373 _ => Ok(RunningImageEvidence::Unknown { tag, body }),
1374 }
1375}
1376
1377impl Serialize for ModuleDeclaredProvenance {
1378 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
1379 where
1380 S: Serializer,
1381 {
1382 match self {
1383 Self::Reported { build } => ModuleDeclaredProvenanceWire::Reported {
1384 build: build.clone(),
1385 }
1386 .serialize(serializer),
1387 Self::Unverifiable => ModuleDeclaredProvenanceWire::Unverifiable.serialize(serializer),
1388 Self::Unknown { body, .. } => body.serialize(serializer),
1389 }
1390 }
1391}
1392
1393impl<'de> Deserialize<'de> for ModuleDeclaredProvenance {
1394 fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
1395 where
1396 D: serde::Deserializer<'de>,
1397 {
1398 let (tag, value) = read_tagged(deserializer, "status")?;
1399 match tag.as_str() {
1400 "reported" => match serde_json::from_value(value.into_value())
1401 .map_err(D::Error::custom)?
1402 {
1403 ModuleDeclaredProvenanceWire::Reported { build } => Ok(Self::Reported { build }),
1404 ModuleDeclaredProvenanceWire::Unverifiable => unreachable!(),
1405 },
1406 "unverifiable" => {
1407 match serde_json::from_value(value.into_value()).map_err(D::Error::custom)? {
1408 ModuleDeclaredProvenanceWire::Unverifiable => Ok(Self::Unverifiable),
1409 ModuleDeclaredProvenanceWire::Reported { .. } => unreachable!(),
1410 }
1411 }
1412 _ => Ok(Self::Unknown { tag, body: value }),
1413 }
1414 }
1415}
1416
1417impl Serialize for RunningImageAgreement {
1418 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
1419 where
1420 S: Serializer,
1421 {
1422 match self {
1423 Self::Match { evidence } => RunningImageAgreementWire::Match {
1424 evidence: evidence.clone(),
1425 }
1426 .serialize(serializer),
1427 Self::Mismatch { running, disk } => RunningImageAgreementWire::Mismatch {
1428 running: running.clone(),
1429 disk: disk.clone(),
1430 }
1431 .serialize(serializer),
1432 Self::Unavailable { reason } => RunningImageAgreementWire::Unavailable {
1433 reason: reason.clone(),
1434 }
1435 .serialize(serializer),
1436 Self::Unknown { body, .. } => body.serialize(serializer),
1437 }
1438 }
1439}
1440
1441impl Serialize for ReloadPathAgreement {
1442 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
1443 where
1444 S: Serializer,
1445 {
1446 match self {
1447 Self::Match => ReloadPathAgreementWire::Match.serialize(serializer),
1448 Self::Mismatch {
1449 configured,
1450 spawned_from,
1451 } => ReloadPathAgreementWire::Mismatch {
1452 configured: configured.clone(),
1453 spawned_from: spawned_from.clone(),
1454 }
1455 .serialize(serializer),
1456 Self::Unavailable { reason } => ReloadPathAgreementWire::Unavailable {
1457 reason: reason.clone(),
1458 }
1459 .serialize(serializer),
1460 Self::Unknown { body, .. } => body.serialize(serializer),
1461 }
1462 }
1463}
1464
1465impl Serialize for LaunchSpecAgreement {
1466 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
1467 where
1468 S: Serializer,
1469 {
1470 match self {
1471 Self::Match => LaunchSpecAgreementWire::Match.serialize(serializer),
1472 Self::Mismatch => LaunchSpecAgreementWire::Mismatch.serialize(serializer),
1473 Self::Unavailable { reason } => LaunchSpecAgreementWire::Unavailable {
1474 reason: reason.clone(),
1475 }
1476 .serialize(serializer),
1477 Self::Unknown { body, .. } => body.serialize(serializer),
1478 }
1479 }
1480}
1481
1482impl<'de> Deserialize<'de> for LaunchSpecAgreement {
1483 fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
1484 where
1485 D: Deserializer<'de>,
1486 {
1487 let (tag, body) = read_tagged(deserializer, "status")?;
1488 match tag.as_str() {
1489 "match" => Ok(Self::Match),
1490 "mismatch" => Ok(Self::Mismatch),
1491 "unavailable" => match serde_json::from_value(body.into_value())
1492 .map_err(D::Error::custom)?
1493 {
1494 LaunchSpecAgreementWire::Unavailable { reason } => Ok(Self::Unavailable { reason }),
1495 _ => unreachable!(),
1496 },
1497 _ => Ok(Self::Unknown { tag, body }),
1498 }
1499 }
1500}
1501
1502impl<'de> Deserialize<'de> for ReloadPathAgreement {
1503 fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
1504 where
1505 D: Deserializer<'de>,
1506 {
1507 let (tag, body) = read_tagged(deserializer, "status")?;
1508 match tag.as_str() {
1509 "match" => Ok(Self::Match),
1510 "mismatch" => {
1511 match serde_json::from_value(body.into_value()).map_err(D::Error::custom)? {
1512 ReloadPathAgreementWire::Mismatch {
1513 configured,
1514 spawned_from,
1515 } => Ok(Self::Mismatch {
1516 configured,
1517 spawned_from,
1518 }),
1519 _ => unreachable!(),
1520 }
1521 }
1522 "unavailable" => match serde_json::from_value(body.into_value())
1523 .map_err(D::Error::custom)?
1524 {
1525 ReloadPathAgreementWire::Unavailable { reason } => Ok(Self::Unavailable { reason }),
1526 _ => unreachable!(),
1527 },
1528 _ => Ok(Self::Unknown { tag, body }),
1529 }
1530 }
1531}
1532
1533impl<'de> Deserialize<'de> for RunningImageAgreement {
1534 fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
1535 where
1536 D: serde::Deserializer<'de>,
1537 {
1538 let (tag, value) = read_tagged(deserializer, "status")?;
1539 match tag.as_str() {
1540 "match" => Ok(Self::Match {
1541 evidence: decode_running_image_evidence(
1542 ordered_field(&value, "evidence")
1543 .cloned()
1544 .ok_or_else(|| D::Error::custom("tagged object has no `evidence` field"))?,
1545 )
1546 .map_err(D::Error::custom)?,
1547 }),
1548 "mismatch" => Ok(Self::Mismatch {
1549 running: decode_running_image_evidence(
1550 ordered_field(&value, "running")
1551 .cloned()
1552 .ok_or_else(|| D::Error::custom("tagged object has no `running` field"))?,
1553 )
1554 .map_err(D::Error::custom)?,
1555 disk: decode_running_image_evidence(
1556 ordered_field(&value, "disk")
1557 .cloned()
1558 .ok_or_else(|| D::Error::custom("tagged object has no `disk` field"))?,
1559 )
1560 .map_err(D::Error::custom)?,
1561 }),
1562 "unavailable" => Ok(Self::Unavailable {
1563 reason: serde_json::from_value(
1564 ordered_field(&value, "reason")
1565 .cloned()
1566 .ok_or_else(|| D::Error::custom("tagged object has no `reason` field"))?
1567 .into_value(),
1568 )
1569 .map_err(D::Error::custom)?,
1570 }),
1571 _ => Ok(Self::Unknown { tag, body: value }),
1572 }
1573 }
1574}
1575
1576impl Serialize for ChildResourceUsage {
1577 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
1578 where
1579 S: Serializer,
1580 {
1581 match self {
1582 Self::Measured(reading) => {
1583 ChildResourceUsageWire::Measured(reading.clone()).serialize(serializer)
1584 }
1585 Self::Unavailable { reason } => ChildResourceUsageWire::Unavailable {
1586 reason: reason.clone(),
1587 }
1588 .serialize(serializer),
1589 Self::Unknown { body, .. } => body.serialize(serializer),
1590 }
1591 }
1592}
1593
1594impl<'de> Deserialize<'de> for ChildResourceUsage {
1595 fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
1596 where
1597 D: Deserializer<'de>,
1598 {
1599 let (tag, body) = read_tagged(deserializer, "status")?;
1600 match tag.as_str() {
1601 "measured" | "unavailable" => {
1602 match serde_json::from_value(body.into_value()).map_err(D::Error::custom)? {
1603 ChildResourceUsageWire::Measured(reading) => Ok(Self::Measured(reading)),
1604 ChildResourceUsageWire::Unavailable { reason } => {
1605 Ok(Self::Unavailable { reason })
1606 }
1607 }
1608 }
1609 _ => Ok(Self::Unknown { tag, body }),
1610 }
1611 }
1612}
1613
1614impl Serialize for RunningImageEvidence {
1615 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
1616 where
1617 S: Serializer,
1618 {
1619 match self {
1620 Self::LinuxProcSha256 { digest } => RunningImageEvidenceWire::LinuxProcSha256 {
1621 digest: digest.clone(),
1622 }
1623 .serialize(serializer),
1624 Self::MacosSpawnInode { device, inode } => RunningImageEvidenceWire::MacosSpawnInode {
1625 device: *device,
1626 inode: *inode,
1627 }
1628 .serialize(serializer),
1629 Self::WindowsSpawnFileId {
1630 volume_serial_number,
1631 file_id,
1632 } => RunningImageEvidenceWire::WindowsSpawnFileId {
1633 volume_serial_number: *volume_serial_number,
1634 file_id: *file_id,
1635 }
1636 .serialize(serializer),
1637 Self::Unknown { body, .. } => body.serialize(serializer),
1638 }
1639 }
1640}
1641
1642impl<'de> Deserialize<'de> for RunningImageEvidence {
1643 fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
1644 where
1645 D: serde::Deserializer<'de>,
1646 {
1647 let (tag, value) = read_tagged(deserializer, "method")?;
1648 match tag.as_str() {
1649 "linux_proc_sha256" => {
1650 match serde_json::from_value(value.into_value()).map_err(D::Error::custom)? {
1651 RunningImageEvidenceWire::LinuxProcSha256 { digest } => {
1652 Ok(Self::LinuxProcSha256 { digest })
1653 }
1654 _ => unreachable!(),
1655 }
1656 }
1657 "macos_spawn_inode" => {
1658 match serde_json::from_value(value.into_value()).map_err(D::Error::custom)? {
1659 RunningImageEvidenceWire::MacosSpawnInode { device, inode } => {
1660 Ok(Self::MacosSpawnInode { device, inode })
1661 }
1662 _ => unreachable!(),
1663 }
1664 }
1665 "windows_spawn_file_id" => {
1666 match serde_json::from_value(value.into_value()).map_err(D::Error::custom)? {
1667 RunningImageEvidenceWire::WindowsSpawnFileId {
1668 volume_serial_number,
1669 file_id,
1670 } => Ok(Self::WindowsSpawnFileId {
1671 volume_serial_number,
1672 file_id,
1673 }),
1674 _ => unreachable!(),
1675 }
1676 }
1677 _ => Ok(Self::Unknown { tag, body: value }),
1678 }
1679 }
1680}
1681
1682impl Serialize for SupervisorRouteConsumer {
1683 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
1684 where
1685 S: Serializer,
1686 {
1687 match self {
1688 Self::Reserved { module_id } => SupervisorRouteConsumerWire::Reserved {
1689 module_id: module_id.clone(),
1690 }
1691 .serialize(serializer),
1692 Self::Direct { connection_id } => SupervisorRouteConsumerWire::Direct {
1693 connection_id: *connection_id,
1694 }
1695 .serialize(serializer),
1696 Self::Unknown { body, .. } => body.serialize(serializer),
1697 }
1698 }
1699}
1700
1701impl<'de> Deserialize<'de> for SupervisorRouteConsumer {
1702 fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
1703 where
1704 D: serde::Deserializer<'de>,
1705 {
1706 let (tag, value) = read_tagged(deserializer, "kind")?;
1707 match tag.as_str() {
1708 "reserved" => {
1709 match serde_json::from_value(value.into_value()).map_err(D::Error::custom)? {
1710 SupervisorRouteConsumerWire::Reserved { module_id } => {
1711 Ok(Self::Reserved { module_id })
1712 }
1713 _ => unreachable!(),
1714 }
1715 }
1716 "direct" => {
1717 match serde_json::from_value(value.into_value()).map_err(D::Error::custom)? {
1718 SupervisorRouteConsumerWire::Direct { connection_id } => {
1719 Ok(Self::Direct { connection_id })
1720 }
1721 _ => unreachable!(),
1722 }
1723 }
1724 _ => Ok(Self::Unknown { tag, body: value }),
1725 }
1726 }
1727}
1728
1729impl Serialize for StderrCaptureState {
1730 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
1731 where
1732 S: Serializer,
1733 {
1734 match self {
1735 Self::Captured => StderrCaptureStateWire::Captured.serialize(serializer),
1736 Self::Incomplete { reason } => StderrCaptureStateWire::Incomplete {
1737 reason: reason.clone(),
1738 }
1739 .serialize(serializer),
1740 Self::NotCaptured { reason } => StderrCaptureStateWire::NotCaptured {
1741 reason: reason.clone(),
1742 }
1743 .serialize(serializer),
1744 Self::Unknown { body, .. } => body.serialize(serializer),
1745 }
1746 }
1747}
1748
1749impl<'de> Deserialize<'de> for StderrCaptureState {
1750 fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
1751 where
1752 D: serde::Deserializer<'de>,
1753 {
1754 let (tag, value) = read_tagged(deserializer, "state")?;
1755 match tag.as_str() {
1756 "captured" => {
1757 match serde_json::from_value(value.into_value()).map_err(D::Error::custom)? {
1758 StderrCaptureStateWire::Captured => Ok(Self::Captured),
1759 _ => unreachable!(),
1760 }
1761 }
1762 "incomplete" => match serde_json::from_value(value.into_value())
1763 .map_err(D::Error::custom)?
1764 {
1765 StderrCaptureStateWire::Incomplete { reason } => Ok(Self::Incomplete { reason }),
1766 _ => unreachable!(),
1767 },
1768 "not_captured" => match serde_json::from_value(value.into_value())
1769 .map_err(D::Error::custom)?
1770 {
1771 StderrCaptureStateWire::NotCaptured { reason } => Ok(Self::NotCaptured { reason }),
1772 _ => unreachable!(),
1773 },
1774 _ => Ok(Self::Unknown { tag, body: value }),
1775 }
1776 }
1777}
1778
1779impl Serialize for StderrTailEntry {
1780 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
1781 where
1782 S: Serializer,
1783 {
1784 match self {
1785 Self::Line {
1786 text,
1787 truncated,
1788 at_ms,
1789 } => StderrTailEntryWire::Line {
1790 text: text.clone(),
1791 truncated: *truncated,
1792 at_ms: *at_ms,
1793 }
1794 .serialize(serializer),
1795 Self::ProcessStart => StderrTailEntryWire::ProcessStart.serialize(serializer),
1796 Self::Unknown { body, .. } => body.serialize(serializer),
1797 }
1798 }
1799}
1800
1801impl<'de> Deserialize<'de> for StderrTailEntry {
1802 fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
1803 where
1804 D: serde::Deserializer<'de>,
1805 {
1806 let (tag, value) = read_tagged(deserializer, "kind")?;
1807 match tag.as_str() {
1808 "line" => match serde_json::from_value(value.into_value()).map_err(D::Error::custom)? {
1809 StderrTailEntryWire::Line {
1810 text,
1811 truncated,
1812 at_ms,
1813 } => Ok(Self::Line {
1814 text,
1815 truncated,
1816 at_ms,
1817 }),
1818 _ => unreachable!(),
1819 },
1820 "process_start" => {
1821 match serde_json::from_value(value.into_value()).map_err(D::Error::custom)? {
1822 StderrTailEntryWire::ProcessStart => Ok(Self::ProcessStart),
1823 _ => unreachable!(),
1824 }
1825 }
1826 _ => Ok(Self::Unknown { tag, body: value }),
1827 }
1828 }
1829}
1830
1831fn is_zero_u64(value: &u64) -> bool {
1832 *value == 0
1833}
1834
1835fn default_true() -> bool {
1836 true
1837}
1838
1839#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
1841pub struct TerminalHistory {
1842 pub daemon_started_at_ms: u64,
1844 pub entries: Vec<TerminalEntry>,
1845 #[serde(default, skip_serializing_if = "is_zero_u64")]
1848 pub dropped: u64,
1849 #[serde(default, skip_serializing_if = "is_zero_u64")]
1852 pub journal_skipped_lines: u64,
1853 #[serde(default, skip_serializing_if = "is_zero_u64")]
1855 pub journal_read_errors: u64,
1856 #[serde(default, skip_serializing_if = "is_zero_u64")]
1858 pub journal_write_failures: u64,
1859}
1860
1861#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
1863pub struct TerminalEntry {
1864 #[serde(default, skip_serializing_if = "Option::is_none")]
1867 pub daemon_incarnation: Option<String>,
1868 #[serde(default, skip_serializing_if = "Option::is_none")]
1869 pub exit_code: Option<i32>,
1870 #[serde(default, skip_serializing_if = "Option::is_none")]
1871 pub exit_signal: Option<i32>,
1872 pub at_ms: u64,
1873 pub disposition: TerminalDisposition,
1874 #[serde(default, skip_serializing_if = "Option::is_none")]
1878 pub exit_kind: Option<TerminalExitKind>,
1879 #[serde(default, skip_serializing_if = "Option::is_none")]
1886 pub disposition_detail: Option<String>,
1887}
1888
1889#[derive(Debug, Clone, PartialEq, Eq)]
1894pub enum TerminalExitKind {
1895 Clean,
1896 Crash,
1897 DeliberateSeverance,
1898 Unknown(String),
1899}
1900
1901impl TerminalExitKind {
1902 fn wire_name(&self) -> &str {
1903 match self {
1904 Self::Clean => "clean",
1905 Self::Crash => "crash",
1906 Self::DeliberateSeverance => "deliberate_severance",
1907 Self::Unknown(value) => value,
1908 }
1909 }
1910}
1911
1912impl Serialize for TerminalExitKind {
1913 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
1914 where
1915 S: serde::Serializer,
1916 {
1917 serializer.serialize_str(self.wire_name())
1918 }
1919}
1920
1921impl<'de> Deserialize<'de> for TerminalExitKind {
1922 fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
1923 where
1924 D: serde::Deserializer<'de>,
1925 {
1926 let value = String::deserialize(deserializer)?;
1927 Ok(match value.as_str() {
1928 "clean" => Self::Clean,
1929 "crash" => Self::Crash,
1930 "deliberate_severance" => Self::DeliberateSeverance,
1931 _ => Self::Unknown(value),
1932 })
1933 }
1934}
1935
1936open_string_enum! {
1937 TerminalDisposition {
1939 Stopped => "stopped",
1940 Disabled => "disabled",
1941 Failed => "failed",
1942 Restarting => "restarting",
1943 DaemonShutdown => "daemon_shutdown",
1948 }
1949}
1950
1951#[derive(Debug, Clone, Copy, Serialize, Deserialize, PartialEq, Eq)]
1952#[serde(rename_all = "snake_case")]
1953pub enum PollKind {
1954 Status,
1955 Liveness,
1956}
1957
1958#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
1970#[non_exhaustive]
1971pub struct CatalogEntry {
1972 pub module_id: String,
1973 #[serde(default = "default_true")]
1984 pub ready: bool,
1985 #[serde(default, skip_serializing_if = "Option::is_none")]
1989 pub not_ready: Option<NotReadyReason>,
1990 #[serde(default, skip_serializing_if = "Option::is_none")]
2011 pub module_version: Option<String>,
2012 pub roles: Vec<ProviderRole>,
2013 pub control_ops: Vec<String>,
2014 #[serde(default, skip_serializing_if = "Option::is_none")]
2019 pub capabilities: Option<CapabilityDeclarations>,
2020 #[serde(default, skip_serializing_if = "Option::is_none")]
2023 pub self_signals: Option<Vec<SelfSignalDeclaration>>,
2024 #[serde(default, skip_serializing_if = "Option::is_none")]
2028 pub events: Option<Vec<EventDeclaration>>,
2029 #[serde(default, skip_serializing_if = "BTreeMap::is_empty")]
2032 pub operation_delivery: BTreeMap<String, OperationDelivery>,
2033 #[serde(default, skip_serializing_if = "BTreeMap::is_empty")]
2036 pub operation_payload: BTreeMap<String, OperationPayload>,
2037 #[serde(default, skip_serializing_if = "Option::is_none")]
2043 pub flow_operations: Option<Vec<String>>,
2044 #[serde(default, skip_serializing_if = "Option::is_none")]
2047 pub rich_ui: Option<RichUiDescriptor>,
2048 #[serde(default, skip_serializing_if = "BTreeMap::is_empty")]
2051 pub role_declarations: BTreeMap<String, serde_json::Map<String, serde_json::Value>>,
2052 #[serde(default, skip_serializing_if = "is_false")]
2055 pub nonce_verified: bool,
2056}
2057
2058impl CatalogEntry {
2059 #[must_use]
2061 pub fn new(
2062 module_id: impl Into<String>,
2063 roles: Vec<ProviderRole>,
2064 control_ops: Vec<String>,
2065 ) -> Self {
2066 Self {
2067 module_id: module_id.into(),
2068 ready: default_true(),
2069 not_ready: None,
2070 module_version: None,
2071 roles,
2072 control_ops,
2073 capabilities: None,
2074 self_signals: None,
2075 events: None,
2076 operation_delivery: BTreeMap::new(),
2077 operation_payload: BTreeMap::new(),
2078 flow_operations: None,
2079 rich_ui: None,
2080 role_declarations: BTreeMap::new(),
2081 nonce_verified: false,
2082 }
2083 }
2084
2085 #[must_use]
2087 pub fn with_operation_payload(
2088 mut self,
2089 operation_payload: BTreeMap<String, OperationPayload>,
2090 ) -> Self {
2091 self.operation_payload = operation_payload;
2092 self
2093 }
2094
2095 #[must_use]
2098 pub fn with_flow_operations(mut self, flow_operations: Option<Vec<String>>) -> Self {
2099 self.flow_operations = flow_operations;
2100 self
2101 }
2102
2103 #[must_use]
2105 pub fn with_ready(mut self, ready: bool) -> Self {
2106 self.ready = ready;
2107 self
2108 }
2109
2110 #[must_use]
2112 pub fn with_not_ready(mut self, not_ready: Option<NotReadyReason>) -> Self {
2113 self.not_ready = not_ready;
2114 self
2115 }
2116
2117 #[must_use]
2119 pub fn with_module_version(mut self, module_version: Option<String>) -> Self {
2120 self.module_version = module_version;
2121 self
2122 }
2123
2124 #[must_use]
2126 pub fn with_capabilities(mut self, capabilities: Option<CapabilityDeclarations>) -> Self {
2127 self.capabilities = capabilities;
2128 self
2129 }
2130
2131 #[must_use]
2133 pub fn with_self_signals(mut self, self_signals: Option<Vec<SelfSignalDeclaration>>) -> Self {
2134 self.self_signals = self_signals;
2135 self
2136 }
2137
2138 #[must_use]
2140 pub fn with_events(mut self, events: Option<Vec<EventDeclaration>>) -> Self {
2141 self.events = events;
2142 self
2143 }
2144
2145 #[must_use]
2148 pub fn with_operation_delivery(
2149 mut self,
2150 operation_delivery: BTreeMap<String, OperationDelivery>,
2151 ) -> Self {
2152 self.operation_delivery = operation_delivery;
2153 self
2154 }
2155
2156 #[must_use]
2158 pub fn with_rich_ui(mut self, rich_ui: Option<RichUiDescriptor>) -> Self {
2159 self.rich_ui = rich_ui;
2160 self
2161 }
2162
2163 #[must_use]
2165 pub fn with_role_declarations(
2166 mut self,
2167 role_declarations: BTreeMap<String, serde_json::Map<String, serde_json::Value>>,
2168 ) -> Self {
2169 self.role_declarations = role_declarations;
2170 self
2171 }
2172
2173 #[must_use]
2176 pub fn with_nonce_verified(mut self, nonce_verified: bool) -> Self {
2177 self.nonce_verified = nonce_verified;
2178 self
2179 }
2180}
2181
2182fn is_false(value: &bool) -> bool {
2183 !value
2184}
2185
2186#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
2188pub struct NotReadyReason {
2189 pub reason: String,
2194 #[serde(default, skip_serializing_if = "Option::is_none")]
2197 pub capability: Option<String>,
2198}
2199
2200impl NotReadyReason {
2201 pub const DECLARED_NOT_READY: &'static str = "declared_not_ready";
2202 pub const REQUIRED_CAPABILITY_UNPROVIDED: &'static str = "required_capability_unprovided";
2203}
2204
2205#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
2206pub struct CapabilityRequirementStatus {
2207 pub consumer: String,
2208 pub capability: String,
2209 pub need: String,
2210 pub verdict: String,
2211 pub episode_seq: u64,
2212 pub config_satisfiable: bool,
2213 pub runtime_available: bool,
2214 pub detail: String,
2215}
2216
2217#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
2218pub struct SupervisorRescanResult {
2219 pub added: Vec<String>,
2220 pub removed: Vec<String>,
2221 pub changed_pending_reload: Vec<String>,
2222 #[serde(default, skip_serializing_if = "Vec::is_empty")]
2235 pub enabled_changes: Vec<String>,
2236 pub unchanged: u32,
2237 #[serde(default, skip_serializing_if = "std::ops::Not::not")]
2245 pub preview: bool,
2246 #[serde(default, skip_serializing_if = "Vec::is_empty")]
2264 pub restart_required: Vec<String>,
2265 #[serde(default, skip_serializing_if = "Vec::is_empty")]
2269 pub capability_warnings: Vec<String>,
2270 #[serde(default, skip_serializing_if = "Vec::is_empty")]
2277 pub module_actions: Vec<RescanModuleAction>,
2278 #[serde(default, skip_serializing_if = "Vec::is_empty")]
2282 pub earlier_pending: Vec<String>,
2283 #[serde(default, skip_serializing_if = "Option::is_none")]
2286 pub expect: Option<RescanExpect>,
2287}
2288
2289#[derive(Debug, Clone, Copy, Default, Serialize, Deserialize, PartialEq, Eq)]
2305#[serde(rename_all = "snake_case")]
2306pub enum ModuleProtocol {
2307 #[default]
2311 Subc,
2312 None,
2321}
2322
2323#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
2335#[non_exhaustive]
2336pub struct SupervisorEntry {
2337 #[serde(default, skip_serializing_if = "Option::is_none")]
2340 pub waiting_for_previous_pid: Option<u32>,
2341 pub module_id: String,
2342 pub state: String,
2343 #[serde(default, skip_serializing_if = "Option::is_none")]
2347 pub next_retry_at_ms: Option<u64>,
2348 pub enabled: bool,
2349 #[serde(default, skip_serializing_if = "Option::is_none")]
2352 pub configured_enabled: Option<bool>,
2353 pub live: bool,
2363 #[serde(default)]
2367 pub protocol: ModuleProtocol,
2368 #[serde(default, skip_serializing_if = "Option::is_none")]
2371 pub launch_nonce_env: Option<bool>,
2372 #[serde(default, skip_serializing_if = "Option::is_none")]
2378 pub launch_nonce_source: Option<String>,
2379 pub health: SupervisorHealthStatus,
2380 #[serde(default, skip_serializing_if = "Option::is_none")]
2383 pub pending_reload: Option<PendingReloadVerdict>,
2384 #[serde(default)]
2390 pub last_probe_ms: Option<u64>,
2391 #[serde(default, skip_serializing_if = "Option::is_none")]
2395 pub last_exit_code: Option<i32>,
2396 #[serde(default, skip_serializing_if = "Option::is_none")]
2400 pub last_exit_signal: Option<i32>,
2401 #[serde(default, skip_serializing_if = "Option::is_none")]
2405 pub last_exit_ms: Option<u64>,
2406 #[serde(default, skip_serializing_if = "Option::is_none")]
2409 pub last_exit_kind: Option<TerminalExitKind>,
2410 #[serde(default, skip_serializing_if = "Option::is_none")]
2427 pub restart_count: Option<u32>,
2428 #[serde(default, skip_serializing_if = "Option::is_none")]
2431 pub max_restarts: Option<u32>,
2432 #[serde(default, skip_serializing_if = "Option::is_none")]
2435 pub lifetime_restarts: Option<u32>,
2436 #[serde(default, skip_serializing_if = "Option::is_none")]
2440 pub spawn_generation: Option<u64>,
2441 #[serde(default, skip_serializing_if = "Option::is_none")]
2451 pub restart_window_secs: Option<u64>,
2452 #[serde(default, skip_serializing_if = "Option::is_none")]
2456 pub drain_timeout_ms: Option<u64>,
2457 #[serde(default, skip_serializing_if = "Option::is_none")]
2460 pub restart_backoff_ms: Option<u64>,
2461 #[serde(default, skip_serializing_if = "Option::is_none")]
2464 pub restart_max_backoff_ms: Option<u64>,
2465 #[serde(default, skip_serializing_if = "Option::is_none")]
2478 pub resources: Option<ChildResourceUsage>,
2479}
2480
2481impl SupervisorEntry {
2482 #[must_use]
2484 pub fn with_next_retry_at_ms(mut self, next_retry_at_ms: Option<u64>) -> Self {
2485 self.next_retry_at_ms = next_retry_at_ms;
2486 self
2487 }
2488
2489 #[must_use]
2491 pub fn new(
2492 module_id: impl Into<String>,
2493 state: impl Into<String>,
2494 enabled: bool,
2495 live: bool,
2496 health: SupervisorHealthStatus,
2497 ) -> Self {
2498 Self {
2499 module_id: module_id.into(),
2500 state: state.into(),
2501 next_retry_at_ms: None,
2502 waiting_for_previous_pid: None,
2503 enabled,
2504 configured_enabled: None,
2505 live,
2506 protocol: ModuleProtocol::default(),
2507 launch_nonce_env: None,
2508 launch_nonce_source: None,
2509 health,
2510 pending_reload: None,
2511 last_probe_ms: None,
2512 last_exit_code: None,
2513 last_exit_signal: None,
2514 last_exit_ms: None,
2515 last_exit_kind: None,
2516 restart_count: None,
2517 max_restarts: None,
2518 lifetime_restarts: None,
2519 spawn_generation: None,
2520 restart_window_secs: None,
2521 drain_timeout_ms: None,
2522 restart_backoff_ms: None,
2523 restart_max_backoff_ms: None,
2524 resources: None,
2525 }
2526 }
2527
2528 #[must_use]
2530 pub fn with_protocol(mut self, protocol: ModuleProtocol) -> Self {
2531 self.protocol = protocol;
2532 self
2533 }
2534
2535 #[must_use]
2537 pub fn with_configured_enabled(mut self, configured_enabled: Option<bool>) -> Self {
2538 self.configured_enabled = configured_enabled;
2539 self
2540 }
2541
2542 #[must_use]
2544 pub fn with_launch_nonce_env(mut self, launch_nonce_env: Option<bool>) -> Self {
2545 self.launch_nonce_env = launch_nonce_env;
2546 self
2547 }
2548
2549 pub fn with_launch_nonce_source(mut self, source: Option<String>) -> Self {
2550 self.launch_nonce_source = source;
2551 self
2552 }
2553
2554 #[must_use]
2555 pub fn with_waiting_for_previous_pid(mut self, pid: Option<u32>) -> Self {
2556 self.waiting_for_previous_pid = pid;
2557 self
2558 }
2559
2560 #[must_use]
2562 pub fn with_pending_reload(mut self, pending_reload: Option<PendingReloadVerdict>) -> Self {
2563 self.pending_reload = pending_reload;
2564 self
2565 }
2566
2567 #[must_use]
2569 pub fn with_last_probe_ms(mut self, last_probe_ms: Option<u64>) -> Self {
2570 self.last_probe_ms = last_probe_ms;
2571 self
2572 }
2573
2574 #[must_use]
2576 pub fn with_last_exit_code(mut self, last_exit_code: Option<i32>) -> Self {
2577 self.last_exit_code = last_exit_code;
2578 self
2579 }
2580
2581 #[must_use]
2583 pub fn with_last_exit_signal(mut self, last_exit_signal: Option<i32>) -> Self {
2584 self.last_exit_signal = last_exit_signal;
2585 self
2586 }
2587
2588 #[must_use]
2590 pub fn with_last_exit_ms(mut self, last_exit_ms: Option<u64>) -> Self {
2591 self.last_exit_ms = last_exit_ms;
2592 self
2593 }
2594
2595 #[must_use]
2597 pub fn with_last_exit_kind(mut self, last_exit_kind: Option<TerminalExitKind>) -> Self {
2598 self.last_exit_kind = last_exit_kind;
2599 self
2600 }
2601
2602 #[must_use]
2604 pub fn with_restart_count(mut self, restart_count: Option<u32>) -> Self {
2605 self.restart_count = restart_count;
2606 self
2607 }
2608
2609 #[must_use]
2611 pub fn with_max_restarts(mut self, max_restarts: Option<u32>) -> Self {
2612 self.max_restarts = max_restarts;
2613 self
2614 }
2615
2616 #[must_use]
2618 pub fn with_lifetime_restarts(mut self, lifetime_restarts: Option<u32>) -> Self {
2619 self.lifetime_restarts = lifetime_restarts;
2620 self
2621 }
2622
2623 #[must_use]
2625 pub fn with_spawn_generation(mut self, spawn_generation: Option<u64>) -> Self {
2626 self.spawn_generation = spawn_generation;
2627 self
2628 }
2629
2630 #[must_use]
2632 pub fn with_restart_window_secs(mut self, restart_window_secs: Option<u64>) -> Self {
2633 self.restart_window_secs = restart_window_secs;
2634 self
2635 }
2636
2637 #[must_use]
2639 pub fn with_drain_timeout_ms(mut self, drain_timeout_ms: Option<u64>) -> Self {
2640 self.drain_timeout_ms = drain_timeout_ms;
2641 self
2642 }
2643
2644 #[must_use]
2646 pub fn with_restart_backoff_ms(mut self, restart_backoff_ms: Option<u64>) -> Self {
2647 self.restart_backoff_ms = restart_backoff_ms;
2648 self
2649 }
2650
2651 #[must_use]
2653 pub fn with_restart_max_backoff_ms(mut self, restart_max_backoff_ms: Option<u64>) -> Self {
2654 self.restart_max_backoff_ms = restart_max_backoff_ms;
2655 self
2656 }
2657
2658 #[must_use]
2660 pub fn with_resources(mut self, resources: Option<ChildResourceUsage>) -> Self {
2661 self.resources = resources;
2662 self
2663 }
2664}
2665
2666#[derive(Debug, Clone, PartialEq)]
2669pub enum ChildResourceUsage {
2670 Measured(ChildResourceReading),
2671 Unavailable {
2672 reason: ChildResourceUnavailableReason,
2673 },
2674 Unknown {
2677 tag: String,
2678 body: OrderedJsonObject,
2679 },
2680}
2681
2682#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
2684pub struct ChildResourceReading {
2685 pub memory_bytes: u64,
2688 pub memory_kind: ChildMemoryKind,
2689 #[serde(default, skip_serializing_if = "Option::is_none")]
2692 pub swap_bytes: Option<u64>,
2693 pub cpu_user_ms: u64,
2697 pub cpu_system_ms: u64,
2700}
2701
2702open_string_enum! {
2703 ChildMemoryKind {
2705 PhysFootprint => "phys_footprint",
2709 ResidentSet => "resident_set",
2712 WindowsWorkingSet => "windows_working_set",
2715 }
2716}
2717
2718open_string_enum! {
2719 ChildResourceUnavailableReason {
2721 NotRunning => "not_running",
2723 UnsupportedPlatform => "unsupported_platform",
2725 Unreadable => "unreadable",
2728 ProcessIdentityUnconfirmed => "process_identity_unconfirmed",
2731 }
2732}
2733
2734#[derive(Debug, Clone, Copy, Serialize, Deserialize, PartialEq, Eq)]
2735#[serde(rename_all = "snake_case")]
2736pub enum SupervisorHealthStatus {
2737 Ok,
2738 Degraded,
2739 Failing,
2740 Unresponsive,
2741 Unknown,
2742}
2743
2744#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
2745pub struct SupervisorHealthEntry {
2746 pub module_id: String,
2747 pub status: SupervisorHealthStatus,
2748 #[serde(default, skip_serializing_if = "Option::is_none")]
2754 pub detail: Option<String>,
2755 #[serde(default, skip_serializing_if = "Option::is_none")]
2760 pub metrics: Option<serde_json::Value>,
2761 pub consecutive_failures: u32,
2762 #[serde(default)]
2765 pub late_answer_count: u64,
2766 #[serde(default, skip_serializing_if = "Option::is_none")]
2768 pub last_late_answer_latency_ms: Option<u64>,
2769 #[serde(default)]
2774 pub last_action: Option<String>,
2775 #[serde(default)]
2778 pub last_action_ms: Option<u64>,
2779 #[serde(default, skip_serializing_if = "Option::is_none")]
2792 pub last_probe_ms: Option<u64>,
2793}
2794
2795#[cfg(test)]
2796mod tests {
2797 #[test]
2798 fn configured_enabled_omission_preserves_exact_old_list_bytes() {
2799 let entry = r#"{"module_id":"provider","state":"running","enabled":true,"live":true,"protocol":"subc","health":"unknown","last_probe_ms":null}"#;
2800 let decoded: SupervisorEntry = serde_json::from_str(entry).unwrap();
2801 assert_eq!(decoded.configured_enabled, None);
2802 assert_eq!(serde_json::to_string(&decoded).unwrap(), entry);
2803 }
2804
2805 #[test]
2806 fn configured_enabled_values_round_trip_in_list() {
2807 for enabled in [false, true] {
2808 let entry = SupervisorEntry::new(
2809 "provider",
2810 "running",
2811 true,
2812 true,
2813 SupervisorHealthStatus::Unknown,
2814 )
2815 .with_configured_enabled(Some(enabled));
2816 let entry_json = serde_json::to_value(&entry).unwrap();
2817 assert_eq!(entry_json["configured_enabled"], enabled);
2818 assert_eq!(
2819 serde_json::from_value::<SupervisorEntry>(entry_json).unwrap(),
2820 entry
2821 );
2822 }
2823 }
2824
2825 #[test]
2826 fn windows_running_image_evidence_round_trips_all_sixteen_id_bytes() {
2827 let evidence = super::RunningImageEvidence::WindowsSpawnFileId {
2828 volume_serial_number: u64::MAX,
2829 file_id: [
2830 0, 1, 2, 3, 4, 5, 6, 7, 128, 129, 130, 131, 252, 253, 254, 255,
2831 ],
2832 };
2833 let agreement = super::RunningImageAgreement::Match { evidence };
2834 let encoded = serde_json::to_string(&agreement).unwrap();
2835 assert!(encoded.contains("windows_spawn_file_id"));
2836 assert_eq!(
2837 serde_json::from_str::<super::RunningImageAgreement>(&encoded).unwrap(),
2838 agreement
2839 );
2840 }
2841
2842 #[test]
2843 fn unix_running_image_evidence_keeps_original_wire_bytes() {
2844 assert_eq!(
2845 serde_json::to_string(&super::RunningImageEvidence::MacosSpawnInode {
2846 device: 7,
2847 inode: 11
2848 })
2849 .unwrap(),
2850 "{\"method\":\"macos_spawn_inode\",\"device\":7,\"inode\":11}"
2851 );
2852 assert_eq!(
2853 serde_json::to_string(&super::RunningImageEvidence::LinuxProcSha256 {
2854 digest: "abc".to_owned()
2855 })
2856 .unwrap(),
2857 "{\"method\":\"linux_proc_sha256\",\"digest\":\"abc\"}"
2858 );
2859 }
2860 use super::*;
2861 use subc_protocol::{BindIdentity, RouteTarget};
2862
2863 #[test]
2864 fn legacy_terminal_decoder_ignores_deliberate_severance_kind() {
2865 let entry = TerminalEntry {
2866 daemon_incarnation: Some("daemon-before-restart".into()),
2867 exit_code: Some(1),
2868 exit_signal: None,
2869 at_ms: 1_700_000_000_123,
2870 disposition: TerminalDisposition::Restarting,
2871 exit_kind: Some(TerminalExitKind::DeliberateSeverance),
2872 disposition_detail: None,
2873 };
2874 let wire = serde_json::to_string(&entry).expect("terminal entry serializes");
2875 assert_eq!(
2876 serde_json::from_str::<serde_json::Value>(&wire).expect("terminal entry is JSON")
2877 ["exit_kind"],
2878 "deliberate_severance"
2879 );
2880
2881 #[derive(serde::Deserialize)]
2882 struct LegacyTerminalEntry {
2883 exit_code: Option<i32>,
2884 exit_signal: Option<i32>,
2885 at_ms: u64,
2886 disposition: TerminalDisposition,
2887 }
2888
2889 let decoded: LegacyTerminalEntry =
2890 serde_json::from_str(&wire).expect("legacy decoder keeps the terminal record");
2891 assert_eq!(decoded.exit_code, Some(1));
2892 assert_eq!(decoded.exit_signal, None);
2893 assert_eq!(decoded.at_ms, 1_700_000_000_123);
2894 assert_eq!(decoded.disposition, TerminalDisposition::Restarting);
2895
2896 let future_wire = wire.replace("deliberate_severance", "future_exit_kind");
2897 let future: TerminalEntry =
2898 serde_json::from_str(&future_wire).expect("new decoder keeps a future terminal kind");
2899 assert_eq!(
2900 future.exit_kind,
2901 Some(TerminalExitKind::Unknown("future_exit_kind".to_string()))
2902 );
2903 }
2904
2905 #[test]
2906 fn terminal_incarnation_is_optional_for_older_daemons() {
2907 let entry: TerminalEntry = serde_json::from_value(serde_json::json!({
2908 "at_ms": 123,
2909 "disposition": "stopped"
2910 }))
2911 .unwrap();
2912 let encoded = serde_json::to_value(&entry).unwrap();
2913 assert_eq!(
2914 (entry.daemon_incarnation, encoded.get("daemon_incarnation")),
2915 (None, None)
2916 );
2917 }
2918
2919 #[test]
2920 fn route_poll_uses_kind_field() {
2921 let body = serde_json::to_value(ClientControlRequest::RoutePoll {
2922 route_channel: 7,
2923 route_epoch: 11,
2924 kind: PollKind::Status,
2925 })
2926 .unwrap();
2927
2928 assert_eq!(body["op"], "route.poll");
2929 assert_eq!(body["route_epoch"], 11);
2930 assert_eq!(body["kind"], "status");
2931 assert!(body.get("op").is_some());
2932 }
2933
2934 #[test]
2935 fn route_open_is_internally_tagged() {
2936 let request = ClientControlRequest::RouteOpen {
2937 target: RouteTarget::ToolProvider {
2938 module_id: "aft".to_string(),
2939 },
2940 identity: BindIdentity::new("/tmp/project", "opencode", "session-1"),
2941 consumer_identity: None,
2942 consumer_capabilities: None,
2943 role_versions: None,
2944 admission_facts: None,
2945 scope: None,
2946 };
2947
2948 let body = serde_json::to_value(request).unwrap();
2949 assert_eq!(body["op"], "route.open");
2950 assert_eq!(body["target"]["kind"], "tool_provider");
2951 assert!(body.get("consumer_identity").is_none());
2952 assert!(body.get("consumer_capabilities").is_none());
2953 assert!(body.get("role_versions").is_none());
2954 }
2955
2956 #[test]
2957 fn route_open_without_optional_fields_still_decodes() {
2958 let body = serde_json::json!({
2959 "op": "route.open",
2960 "target": { "kind": "tool_provider", "module_id": "aft" },
2961 "identity": {
2962 "project_root": "/tmp/project",
2963 "harness": "opencode",
2964 "session": "session-1"
2965 }
2966 });
2967
2968 let decoded: ClientControlRequest = serde_json::from_value(body).unwrap();
2969 let ClientControlRequest::RouteOpen {
2970 consumer_identity,
2971 consumer_capabilities,
2972 role_versions,
2973 admission_facts,
2974 ..
2975 } = decoded
2976 else {
2977 panic!("decoded wrong request variant");
2978 };
2979 assert_eq!(consumer_identity, None);
2980 assert_eq!(consumer_capabilities, None);
2981 assert_eq!(role_versions, None);
2982 assert_eq!(admission_facts, None);
2983 }
2984
2985 #[test]
2986 fn new_route_closed_decoder_defaults_fields_absent_from_old_daemon() {
2987 let old_wire = r#"{"op":"route.closed","module_id":"aft-tools","reason":"crash","drained":false,"abandoned":0}"#;
2988 let decoded: ClientControlPush = serde_json::from_str(old_wire).unwrap();
2989 match decoded {
2990 ClientControlPush::RouteClosed {
2991 excluded_subscriptions,
2992 terminal,
2993 ..
2994 } => {
2995 assert_eq!(excluded_subscriptions, 0);
2996 assert_eq!(terminal, None);
2997 }
2998 other => panic!("unexpected push: {other:?}"),
2999 }
3000 assert!(!serde_json::to_string(&decoded)
3001 .unwrap()
3002 .contains("terminal"));
3003 }
3004
3005 #[test]
3006 fn old_route_closed_decoder_ignores_new_terminal_field() {
3007 #[derive(serde::Deserialize)]
3008 #[serde(tag = "op")]
3009 enum LegacyClientControlPush {
3010 #[serde(rename = "route.closed")]
3011 RouteClosed {
3012 module_id: String,
3013 reason: RouteCloseReason,
3014 drained: bool,
3015 abandoned: u32,
3016 },
3017 }
3018
3019 let wire = r#"{"op":"route.closed","module_id":"aft-tools","reason":"crash","drained":false,"abandoned":0,"excluded_subscriptions":3,"terminal":true}"#;
3020 let decoded: LegacyClientControlPush = serde_json::from_str(wire).unwrap();
3021 match decoded {
3022 LegacyClientControlPush::RouteClosed {
3023 module_id,
3024 reason,
3025 drained,
3026 abandoned,
3027 } => {
3028 assert_eq!(module_id, "aft-tools");
3029 assert_eq!(reason, RouteCloseReason::Crash);
3030 assert!(!drained);
3031 assert_eq!(abandoned, 0);
3032 }
3033 }
3034 }
3035
3036 #[test]
3037 fn supervisor_routes_is_a_control_plane_request() {
3038 let body = serde_json::json!({
3039 "op": "supervisor.routes",
3040 "module_id": "aft"
3041 });
3042
3043 let request: ClientControlRequest = serde_json::from_value(body.clone()).unwrap();
3044 assert_eq!(serde_json::to_value(request).unwrap(), body);
3045 }
3046
3047 #[test]
3048 fn diagnostic_string_enums_retain_unknown_wire_values() {
3049 let reason: RunningImageUnavailableReason =
3050 serde_json::from_str("\"future_reason\"").unwrap();
3051 let disposition: TerminalDisposition =
3052 serde_json::from_str("\"future_disposition\"").unwrap();
3053
3054 assert_eq!(
3055 reason,
3056 RunningImageUnavailableReason::Unknown("future_reason".to_string())
3057 );
3058 assert_eq!(
3059 disposition,
3060 TerminalDisposition::Unknown("future_disposition".to_string())
3061 );
3062 }
3063
3064 #[test]
3065 fn diagnostic_string_enums_preserve_existing_wire_names() {
3066 let names = [
3067 (RunningImageUnavailableReason::NotRunning, "not_running"),
3068 (
3069 RunningImageUnavailableReason::UnsupportedPlatform,
3070 "unsupported_platform",
3071 ),
3072 (
3073 RunningImageUnavailableReason::RunningExecutableUnreadable,
3074 "running_executable_unreadable",
3075 ),
3076 (
3077 RunningImageUnavailableReason::RunningExecutablePermissionDenied,
3078 "running_executable_permission_denied",
3079 ),
3080 (
3081 RunningImageUnavailableReason::ProcessHidden,
3082 "process_hidden",
3083 ),
3084 (
3085 RunningImageUnavailableReason::SpawnedPathUnreadable,
3086 "spawned_path_unreadable",
3087 ),
3088 (RunningImageUnavailableReason::HashFailed, "hash_failed"),
3089 (
3090 RunningImageUnavailableReason::ProcessIdentityUnconfirmed,
3091 "process_identity_unconfirmed",
3092 ),
3093 ];
3094 for (value, expected) in names {
3095 let wire = serde_json::to_string(&value).unwrap();
3096 assert_eq!(wire, format!("\"{expected}\""));
3097 let decoded: RunningImageUnavailableReason = serde_json::from_str(&wire).unwrap();
3098 assert_eq!(decoded, value);
3099 }
3100
3101 for (value, expected) in [
3102 (TerminalDisposition::Stopped, "stopped"),
3103 (TerminalDisposition::Disabled, "disabled"),
3104 (TerminalDisposition::Failed, "failed"),
3105 (TerminalDisposition::Restarting, "restarting"),
3106 (TerminalDisposition::DaemonShutdown, "daemon_shutdown"),
3107 ] {
3108 let wire = serde_json::to_string(&value).unwrap();
3109 assert_eq!(wire, format!("\"{expected}\""));
3110 let decoded: TerminalDisposition = serde_json::from_str(&wire).unwrap();
3111 assert_eq!(decoded, value);
3112 }
3113 }
3114
3115 #[test]
3116 fn supervisor_waiting_previous_pid_is_optional_and_round_trips() {
3117 let entry = SupervisorEntry::new(
3118 "waiting-module",
3119 "starting",
3120 true,
3121 false,
3122 SupervisorHealthStatus::Unknown,
3123 );
3124 let old_wire = serde_json::to_value(&entry).unwrap();
3125 assert!(old_wire.get("waiting_for_previous_pid").is_none());
3126 let decoded: SupervisorEntry = serde_json::from_value(old_wire).unwrap();
3127 assert_eq!(decoded.waiting_for_previous_pid, None);
3128 let entry = entry.with_waiting_for_previous_pid(Some(42));
3129 let wire = serde_json::to_value(&entry).unwrap();
3130 assert_eq!(wire["waiting_for_previous_pid"], 42);
3131 let decoded: SupervisorEntry = serde_json::from_value(wire).unwrap();
3132 assert_eq!(decoded.waiting_for_previous_pid, Some(42));
3133 }
3134
3135 #[test]
3136 fn diagnostic_string_enums_reject_non_string_bodies() {
3137 assert!(serde_json::from_str::<RunningImageUnavailableReason>("42").is_err());
3138 assert!(serde_json::from_str::<TerminalDisposition>("{\"value\":\"failed\"}").is_err());
3139 }
3140
3141 #[test]
3142 fn unknown_provenance_reason_does_not_discard_healthy_siblings() {
3143 let body = serde_json::json!({
3144 "op": "supervisor.provenance",
3145 "daemon": {
3146 "daemon_build": {},
3147 "daemon_observed": {
3148 "running_image": {
3149 "status": "unavailable",
3150 "reason": "not_running"
3151 }
3152 }
3153 },
3154 "modules": [
3155 {
3156 "module_id": "future",
3157 "module_declared": { "status": "unverifiable" },
3158 "daemon_observed": {
3159 "running_image": {
3160 "status": "unavailable",
3161 "reason": "future_reason"
3162 }
3163 }
3164 },
3165 {
3166 "module_id": "healthy-a",
3167 "module_declared": { "status": "unverifiable" },
3168 "daemon_observed": {
3169 "running_image": {
3170 "status": "match",
3171 "evidence": {
3172 "method": "linux_proc_sha256",
3173 "digest": "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"
3174 }
3175 }
3176 }
3177 },
3178 {
3179 "module_id": "healthy-b",
3180 "module_declared": { "status": "unverifiable" },
3181 "daemon_observed": {
3182 "running_image": {
3183 "status": "unavailable",
3184 "reason": "unsupported_platform"
3185 }
3186 }
3187 }
3188 ]
3189 });
3190
3191 let decoded: ClientControlResponse = serde_json::from_value(body).unwrap();
3192 let ClientControlResponse::SupervisorProvenance { modules, .. } = decoded else {
3193 panic!("decoded wrong response variant");
3194 };
3195 assert_eq!(modules.len(), 3);
3196 assert_eq!(modules[0].module_id, "future");
3197 assert_eq!(
3198 modules[0].daemon_observed.running_image,
3199 RunningImageAgreement::Unavailable {
3200 reason: RunningImageUnavailableReason::Unknown("future_reason".to_string())
3201 }
3202 );
3203 assert_eq!(modules[1].module_id, "healthy-a");
3204 assert_eq!(modules[2].module_id, "healthy-b");
3205 }
3206
3207 #[test]
3208 fn tagged_unknown_values_retain_tag_and_body() {
3209 macro_rules! assert_unknown_round_trip {
3210 ($ty:ident, $field:literal, $value:expr) => {
3211 let value = $value;
3212 let wire = serde_json::to_string(&value).unwrap();
3213 let decoded: $ty = serde_json::from_str(&wire).unwrap();
3214 match decoded {
3215 $ty::Unknown { tag, body } => {
3216 assert_eq!(tag, value[$field].as_str().unwrap());
3217 assert_eq!(serde_json::to_value(&body).unwrap(), value);
3218 }
3219 _ => panic!("decoded known variant"),
3220 }
3221 };
3222 }
3223
3224 assert_unknown_round_trip!(
3225 ModuleDeclaredProvenance,
3226 "status",
3227 serde_json::json!({"status": "future", "build": {"version": 7}})
3228 );
3229 assert_unknown_round_trip!(
3230 RunningImageAgreement,
3231 "status",
3232 serde_json::json!({"status": "future", "evidence": {"digest": "abc"}})
3233 );
3234 assert_unknown_round_trip!(
3235 RunningImageEvidence,
3236 "method",
3237 serde_json::json!({"method": "future", "digest": "abc"})
3238 );
3239 assert_unknown_round_trip!(
3240 SupervisorRouteConsumer,
3241 "kind",
3242 serde_json::json!({"kind": "future", "module_id": "m"})
3243 );
3244 assert_unknown_round_trip!(
3245 StderrCaptureState,
3246 "state",
3247 serde_json::json!({"state": "future", "reason": "because"})
3248 );
3249 assert_unknown_round_trip!(
3250 StderrTailEntry,
3251 "kind",
3252 serde_json::json!({"kind": "future", "text": "line"})
3253 );
3254 assert_unknown_round_trip!(
3255 ChildResourceUsage,
3256 "status",
3257 serde_json::json!({"status": "future", "memory_bytes": 1})
3258 );
3259 }
3260
3261 #[test]
3262 fn child_resource_usage_round_trips_both_known_states() {
3263 let measured = ChildResourceUsage::Measured(ChildResourceReading {
3264 memory_bytes: 0,
3265 memory_kind: ChildMemoryKind::ResidentSet,
3266 swap_bytes: Some(0),
3267 cpu_user_ms: 0,
3268 cpu_system_ms: 0,
3269 });
3270 let wire = serde_json::to_value(&measured).unwrap();
3271 assert_eq!(
3272 wire,
3273 serde_json::json!({
3274 "status": "measured",
3275 "memory_bytes": 0,
3276 "memory_kind": "resident_set",
3277 "swap_bytes": 0,
3278 "cpu_user_ms": 0,
3279 "cpu_system_ms": 0
3280 })
3281 );
3282 assert_eq!(
3283 serde_json::from_value::<ChildResourceUsage>(wire).unwrap(),
3284 measured
3285 );
3286
3287 let unavailable = ChildResourceUsage::Unavailable {
3288 reason: ChildResourceUnavailableReason::NotRunning,
3289 };
3290 let wire = serde_json::to_value(&unavailable).unwrap();
3291 assert_eq!(
3292 wire,
3293 serde_json::json!({"status": "unavailable", "reason": "not_running"})
3294 );
3295 assert_eq!(
3296 serde_json::from_value::<ChildResourceUsage>(wire).unwrap(),
3297 unavailable
3298 );
3299 }
3300
3301 #[test]
3302 fn a_stderr_line_decodes_with_and_without_its_capture_time() {
3303 let stamped: StderrTailEntry = serde_json::from_str(
3307 r#"{"kind":"line","text":"boom","truncated":true,"at_ms":1789801440685}"#,
3308 )
3309 .unwrap();
3310 assert_eq!(
3311 stamped,
3312 StderrTailEntry::Line {
3313 text: "boom".to_string(),
3314 truncated: true,
3315 at_ms: Some(1_789_801_440_685),
3316 }
3317 );
3318 let unstamped: StderrTailEntry =
3319 serde_json::from_str(r#"{"kind":"line","text":"boom"}"#).unwrap();
3320 assert_eq!(
3321 unstamped,
3322 StderrTailEntry::Line {
3323 text: "boom".to_string(),
3324 truncated: false,
3325 at_ms: None,
3326 }
3327 );
3328 assert_eq!(
3331 serde_json::to_string(&unstamped).unwrap(),
3332 r#"{"kind":"line","text":"boom"}"#
3333 );
3334 assert_eq!(
3335 serde_json::to_value(&stamped).unwrap()["at_ms"],
3336 serde_json::json!(1_789_801_440_685u64)
3337 );
3338 }
3339
3340 #[test]
3341 fn tagged_unknown_values_round_trip_the_original_json() {
3342 let wire = r#"{"kind":"future_consumer","detail":{"z":1}}"#;
3343 let decoded: SupervisorRouteConsumer = serde_json::from_str(wire).unwrap();
3344 assert_eq!(serde_json::to_string(&decoded).unwrap(), wire);
3345 }
3346
3347 #[test]
3348 fn tagged_unknown_values_round_trip_trailing_tag() {
3349 let route_wire = r#"{"detail":{"z":1},"kind":"future_consumer"}"#;
3350 let route: SupervisorRouteConsumer = serde_json::from_str(route_wire).unwrap();
3351 assert_eq!(serde_json::to_string(&route).unwrap(), route_wire);
3352
3353 let stderr_wire = r#"{"reason":"because","state":"future_state"}"#;
3354 let stderr: StderrCaptureState = serde_json::from_str(stderr_wire).unwrap();
3355 assert_eq!(serde_json::to_string(&stderr).unwrap(), stderr_wire);
3356 }
3357
3358 #[test]
3359 fn tagged_unknown_values_round_trip_middle_tag() {
3360 let route_wire = r#"{"a":1,"kind":"future_x","b":2}"#;
3361 let route: SupervisorRouteConsumer = serde_json::from_str(route_wire).unwrap();
3362 assert_eq!(serde_json::to_string(&route).unwrap(), route_wire);
3363
3364 let stderr_wire = r#"{"a":1,"state":"future_state","b":2}"#;
3365 let stderr: StderrCaptureState = serde_json::from_str(stderr_wire).unwrap();
3366 assert_eq!(serde_json::to_string(&stderr).unwrap(), stderr_wire);
3367 }
3368
3369 #[test]
3370 fn tagged_unknown_values_round_trip_deep_payload() {
3371 let route_wire = r#"{"a":{"n":[1,2]},"kind":"future_x","zz":"s","b":null}"#;
3372 let route: SupervisorRouteConsumer = serde_json::from_str(route_wire).unwrap();
3373 assert_eq!(serde_json::to_string(&route).unwrap(), route_wire);
3374
3375 let stderr_wire = r#"{"a":{"n":[1,2]},"state":"future_state","zz":"s","b":null}"#;
3376 let stderr: StderrCaptureState = serde_json::from_str(stderr_wire).unwrap();
3377 assert_eq!(serde_json::to_string(&stderr).unwrap(), stderr_wire);
3378 }
3379
3380 #[test]
3381 fn tagged_unknown_values_reject_non_object_bodies() {
3382 for wire in ["42", r#""future""#, "[]"] {
3383 assert!(serde_json::from_str::<SupervisorRouteConsumer>(wire).is_err());
3384 assert!(serde_json::from_str::<StderrCaptureState>(wire).is_err());
3385 }
3386 }
3387
3388 #[test]
3389 fn duplicate_discriminators_reject_without_panicking() {
3390 assert_eq!(
3391 serde_json::from_str::<ModuleDeclaredProvenance>(r#"{"status":"unverifiable"}"#)
3392 .unwrap(),
3393 ModuleDeclaredProvenance::Unverifiable
3394 );
3395 match serde_json::from_str::<ModuleDeclaredProvenance>(r#"{"status":"future_thing"}"#)
3396 .unwrap()
3397 {
3398 ModuleDeclaredProvenance::Unknown { tag, .. } => assert_eq!(tag, "future_thing"),
3399 _ => panic!("future discriminator decoded as a known variant"),
3400 }
3401
3402 let wires = [
3403 r#"{"status":"reported","status":"unverifiable"}"#,
3404 r#"{"status":"unverifiable","status":"reported"}"#,
3405 r#"{"status":"reported","build":{},"status":"unverifiable"}"#,
3406 r#"{"status":"unverifiable","build":{},"status":"reported"}"#,
3407 ];
3408
3409 for wire in wires {
3410 let result =
3411 std::panic::catch_unwind(|| serde_json::from_str::<ModuleDeclaredProvenance>(wire));
3412 assert!(result.is_ok(), "duplicate discriminator panicked: {wire}");
3413 assert!(
3414 result.unwrap().is_err(),
3415 "duplicate discriminator decoded: {wire}"
3416 );
3417 }
3418
3419 let wire = r#"{"state":"captured","state":"incomplete","reason":"x"}"#;
3420 let result = std::panic::catch_unwind(|| serde_json::from_str::<StderrCaptureState>(wire));
3421 assert!(result.is_ok(), "duplicate discriminator panicked: {wire}");
3422 assert!(
3423 result.unwrap().is_err(),
3424 "duplicate discriminator decoded: {wire}"
3425 );
3426 }
3427
3428 #[test]
3429 fn nested_unknown_values_round_trip_without_normalizing_member_order() {
3430 let known_wire =
3431 r#"{"status":"match","evidence":{"method":"linux_proc_sha256","digest":"abc"}}"#;
3432 let known: RunningImageAgreement = serde_json::from_str(known_wire).unwrap();
3433 assert_eq!(serde_json::to_string(&known).unwrap(), known_wire);
3434
3435 for wire in [
3436 r#"{"kind":"future_x","detail":{"zeta":1,"alpha":2}}"#,
3437 r#"{"kind":"future_x","d":{"b":{"zz":1,"aa":2}}}"#,
3438 ] {
3439 let decoded: SupervisorRouteConsumer = serde_json::from_str(wire).unwrap();
3440 assert_eq!(serde_json::to_string(&decoded).unwrap(), wire);
3441 }
3442
3443 for wire in [
3444 r#"{"status":"match","evidence":{"method":"future_probe","zz":1,"aa":2}}"#,
3445 r#"{"status":"match","evidence":{"method":"future_probe","d":{"zz":1,"aa":2}}}"#,
3446 ] {
3447 let decoded: RunningImageAgreement = serde_json::from_str(wire).unwrap();
3448 assert_eq!(serde_json::to_string(&decoded).unwrap(), wire);
3449 }
3450
3451 let wire = r#"{"status":"mismatch","running":{"detail":{"z":1},"method":"future_running"},"disk":{"method":"future_disk","detail":{"z":1}}}"#;
3452 let decoded: RunningImageAgreement = serde_json::from_str(wire).unwrap();
3453 assert_eq!(serde_json::to_string(&decoded).unwrap(), wire);
3454
3455 let wire = r#"{"capture":{"state":"captured"},"entries":[{"detail":{"z":1,"a":2},"kind":"future_line"},{"kind":"future_restart","meta":{"b":{"zz":1,"aa":2}}}]}"#;
3456 let decoded: StderrTail = serde_json::from_str(wire).unwrap();
3457 assert_eq!(serde_json::to_string(&decoded).unwrap(), wire);
3458 }
3459
3460 #[test]
3461 fn tagged_unknown_member_does_not_discard_known_siblings() {
3462 let body = serde_json::json!({
3463 "modules": [{
3464 "module_id": "target",
3465 "routes": [
3466 {"consumer": {"kind": "future_consumer", "module_id": "m", "detail": {"retry": true}}, "age_ms": 0, "draining": false},
3467 {"consumer": {"kind": "direct", "connection_id": 7}, "age_ms": 0, "draining": false}
3468 ]
3469 }]
3470 });
3471 let decoded: ClientControlResponse = serde_json::from_value(
3472 serde_json::json!({"op": "supervisor.routes", "modules": body["modules"]}),
3473 )
3474 .unwrap();
3475 let ClientControlResponse::SupervisorRoutes { modules } = decoded else {
3476 panic!("decoded wrong response variant");
3477 };
3478 assert_eq!(modules[0].routes.len(), 2);
3479 assert_eq!(
3480 modules[0].routes[1].consumer,
3481 SupervisorRouteConsumer::Direct { connection_id: 7 }
3482 );
3483 }
3484}
3485
3486#[cfg(test)]
3487mod launch_nonce_redaction_tests {
3488 use super::*;
3489
3490 const NONCE: &str = "nonce-f00dfeed1234abcd";
3491
3492 fn identity() -> ConsumerIdentity {
3493 ConsumerIdentity {
3494 module_id: "wernicke".to_string(),
3495 launch_nonce: NONCE.to_string(),
3496 }
3497 }
3498
3499 #[test]
3500 fn consumer_identity_debug_names_the_module_and_never_the_nonce() {
3501 let printed = format!("{:?}", identity());
3502 assert!(printed.contains("wernicke"), "{printed}");
3503 assert!(!printed.contains(NONCE), "launch nonce printed: {printed}");
3504 }
3505
3506 #[test]
3507 fn route_open_request_debug_never_prints_the_nonce() {
3508 let request = ClientControlRequest::RouteOpen {
3509 target: subc_protocol::RouteTarget::ToolProvider {
3510 module_id: "broca".to_string(),
3511 },
3512 identity: subc_protocol::BindIdentity::new(
3513 PathBuf::from("/tmp/project"),
3514 "test".to_string(),
3515 "session".to_string(),
3516 ),
3517 consumer_identity: Some(identity()),
3518 consumer_capabilities: None,
3519 role_versions: None,
3520 admission_facts: None,
3521 scope: None,
3522 };
3523 let printed = format!("{request:?}");
3524 assert!(!printed.contains(NONCE), "launch nonce printed: {printed}");
3525 }
3526}