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")]
2040 pub rich_ui: Option<RichUiDescriptor>,
2041 #[serde(default, skip_serializing_if = "BTreeMap::is_empty")]
2044 pub role_declarations: BTreeMap<String, serde_json::Map<String, serde_json::Value>>,
2045 #[serde(default, skip_serializing_if = "is_false")]
2048 pub nonce_verified: bool,
2049}
2050
2051impl CatalogEntry {
2052 #[must_use]
2054 pub fn new(
2055 module_id: impl Into<String>,
2056 roles: Vec<ProviderRole>,
2057 control_ops: Vec<String>,
2058 ) -> Self {
2059 Self {
2060 module_id: module_id.into(),
2061 ready: default_true(),
2062 not_ready: None,
2063 module_version: None,
2064 roles,
2065 control_ops,
2066 capabilities: None,
2067 self_signals: None,
2068 events: None,
2069 operation_delivery: BTreeMap::new(),
2070 operation_payload: BTreeMap::new(),
2071 rich_ui: None,
2072 role_declarations: BTreeMap::new(),
2073 nonce_verified: false,
2074 }
2075 }
2076
2077 #[must_use]
2079 pub fn with_operation_payload(
2080 mut self,
2081 operation_payload: BTreeMap<String, OperationPayload>,
2082 ) -> Self {
2083 self.operation_payload = operation_payload;
2084 self
2085 }
2086
2087 #[must_use]
2089 pub fn with_ready(mut self, ready: bool) -> Self {
2090 self.ready = ready;
2091 self
2092 }
2093
2094 #[must_use]
2096 pub fn with_not_ready(mut self, not_ready: Option<NotReadyReason>) -> Self {
2097 self.not_ready = not_ready;
2098 self
2099 }
2100
2101 #[must_use]
2103 pub fn with_module_version(mut self, module_version: Option<String>) -> Self {
2104 self.module_version = module_version;
2105 self
2106 }
2107
2108 #[must_use]
2110 pub fn with_capabilities(mut self, capabilities: Option<CapabilityDeclarations>) -> Self {
2111 self.capabilities = capabilities;
2112 self
2113 }
2114
2115 #[must_use]
2117 pub fn with_self_signals(mut self, self_signals: Option<Vec<SelfSignalDeclaration>>) -> Self {
2118 self.self_signals = self_signals;
2119 self
2120 }
2121
2122 #[must_use]
2124 pub fn with_events(mut self, events: Option<Vec<EventDeclaration>>) -> Self {
2125 self.events = events;
2126 self
2127 }
2128
2129 #[must_use]
2132 pub fn with_operation_delivery(
2133 mut self,
2134 operation_delivery: BTreeMap<String, OperationDelivery>,
2135 ) -> Self {
2136 self.operation_delivery = operation_delivery;
2137 self
2138 }
2139
2140 #[must_use]
2142 pub fn with_rich_ui(mut self, rich_ui: Option<RichUiDescriptor>) -> Self {
2143 self.rich_ui = rich_ui;
2144 self
2145 }
2146
2147 #[must_use]
2149 pub fn with_role_declarations(
2150 mut self,
2151 role_declarations: BTreeMap<String, serde_json::Map<String, serde_json::Value>>,
2152 ) -> Self {
2153 self.role_declarations = role_declarations;
2154 self
2155 }
2156
2157 #[must_use]
2160 pub fn with_nonce_verified(mut self, nonce_verified: bool) -> Self {
2161 self.nonce_verified = nonce_verified;
2162 self
2163 }
2164}
2165
2166fn is_false(value: &bool) -> bool {
2167 !value
2168}
2169
2170#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
2172pub struct NotReadyReason {
2173 pub reason: String,
2178 #[serde(default, skip_serializing_if = "Option::is_none")]
2181 pub capability: Option<String>,
2182}
2183
2184impl NotReadyReason {
2185 pub const DECLARED_NOT_READY: &'static str = "declared_not_ready";
2186 pub const REQUIRED_CAPABILITY_UNPROVIDED: &'static str = "required_capability_unprovided";
2187}
2188
2189#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
2190pub struct CapabilityRequirementStatus {
2191 pub consumer: String,
2192 pub capability: String,
2193 pub need: String,
2194 pub verdict: String,
2195 pub episode_seq: u64,
2196 pub config_satisfiable: bool,
2197 pub runtime_available: bool,
2198 pub detail: String,
2199}
2200
2201#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
2202pub struct SupervisorRescanResult {
2203 pub added: Vec<String>,
2204 pub removed: Vec<String>,
2205 pub changed_pending_reload: Vec<String>,
2206 #[serde(default, skip_serializing_if = "Vec::is_empty")]
2219 pub enabled_changes: Vec<String>,
2220 pub unchanged: u32,
2221 #[serde(default, skip_serializing_if = "std::ops::Not::not")]
2229 pub preview: bool,
2230 #[serde(default, skip_serializing_if = "Vec::is_empty")]
2248 pub restart_required: Vec<String>,
2249 #[serde(default, skip_serializing_if = "Vec::is_empty")]
2253 pub capability_warnings: Vec<String>,
2254 #[serde(default, skip_serializing_if = "Vec::is_empty")]
2261 pub module_actions: Vec<RescanModuleAction>,
2262 #[serde(default, skip_serializing_if = "Vec::is_empty")]
2266 pub earlier_pending: Vec<String>,
2267 #[serde(default, skip_serializing_if = "Option::is_none")]
2270 pub expect: Option<RescanExpect>,
2271}
2272
2273#[derive(Debug, Clone, Copy, Default, Serialize, Deserialize, PartialEq, Eq)]
2289#[serde(rename_all = "snake_case")]
2290pub enum ModuleProtocol {
2291 #[default]
2295 Subc,
2296 None,
2305}
2306
2307#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
2319#[non_exhaustive]
2320pub struct SupervisorEntry {
2321 #[serde(default, skip_serializing_if = "Option::is_none")]
2324 pub waiting_for_previous_pid: Option<u32>,
2325 pub module_id: String,
2326 pub state: String,
2327 pub enabled: bool,
2328 #[serde(default, skip_serializing_if = "Option::is_none")]
2331 pub configured_enabled: Option<bool>,
2332 pub live: bool,
2342 #[serde(default)]
2346 pub protocol: ModuleProtocol,
2347 #[serde(default, skip_serializing_if = "Option::is_none")]
2350 pub launch_nonce_env: Option<bool>,
2351 #[serde(default, skip_serializing_if = "Option::is_none")]
2357 pub launch_nonce_source: Option<String>,
2358 pub health: SupervisorHealthStatus,
2359 #[serde(default, skip_serializing_if = "Option::is_none")]
2362 pub pending_reload: Option<PendingReloadVerdict>,
2363 #[serde(default)]
2369 pub last_probe_ms: Option<u64>,
2370 #[serde(default, skip_serializing_if = "Option::is_none")]
2374 pub last_exit_code: Option<i32>,
2375 #[serde(default, skip_serializing_if = "Option::is_none")]
2379 pub last_exit_signal: Option<i32>,
2380 #[serde(default, skip_serializing_if = "Option::is_none")]
2384 pub last_exit_ms: Option<u64>,
2385 #[serde(default, skip_serializing_if = "Option::is_none")]
2388 pub last_exit_kind: Option<TerminalExitKind>,
2389 #[serde(default, skip_serializing_if = "Option::is_none")]
2406 pub restart_count: Option<u32>,
2407 #[serde(default, skip_serializing_if = "Option::is_none")]
2410 pub max_restarts: Option<u32>,
2411 #[serde(default, skip_serializing_if = "Option::is_none")]
2414 pub lifetime_restarts: Option<u32>,
2415 #[serde(default, skip_serializing_if = "Option::is_none")]
2419 pub spawn_generation: Option<u64>,
2420 #[serde(default, skip_serializing_if = "Option::is_none")]
2430 pub restart_window_secs: Option<u64>,
2431 #[serde(default, skip_serializing_if = "Option::is_none")]
2435 pub drain_timeout_ms: Option<u64>,
2436 #[serde(default, skip_serializing_if = "Option::is_none")]
2439 pub restart_backoff_ms: Option<u64>,
2440 #[serde(default, skip_serializing_if = "Option::is_none")]
2443 pub restart_max_backoff_ms: Option<u64>,
2444 #[serde(default, skip_serializing_if = "Option::is_none")]
2457 pub resources: Option<ChildResourceUsage>,
2458}
2459
2460impl SupervisorEntry {
2461 #[must_use]
2463 pub fn new(
2464 module_id: impl Into<String>,
2465 state: impl Into<String>,
2466 enabled: bool,
2467 live: bool,
2468 health: SupervisorHealthStatus,
2469 ) -> Self {
2470 Self {
2471 module_id: module_id.into(),
2472 state: state.into(),
2473 waiting_for_previous_pid: None,
2474 enabled,
2475 configured_enabled: None,
2476 live,
2477 protocol: ModuleProtocol::default(),
2478 launch_nonce_env: None,
2479 launch_nonce_source: None,
2480 health,
2481 pending_reload: None,
2482 last_probe_ms: None,
2483 last_exit_code: None,
2484 last_exit_signal: None,
2485 last_exit_ms: None,
2486 last_exit_kind: None,
2487 restart_count: None,
2488 max_restarts: None,
2489 lifetime_restarts: None,
2490 spawn_generation: None,
2491 restart_window_secs: None,
2492 drain_timeout_ms: None,
2493 restart_backoff_ms: None,
2494 restart_max_backoff_ms: None,
2495 resources: None,
2496 }
2497 }
2498
2499 #[must_use]
2501 pub fn with_protocol(mut self, protocol: ModuleProtocol) -> Self {
2502 self.protocol = protocol;
2503 self
2504 }
2505
2506 #[must_use]
2508 pub fn with_configured_enabled(mut self, configured_enabled: Option<bool>) -> Self {
2509 self.configured_enabled = configured_enabled;
2510 self
2511 }
2512
2513 #[must_use]
2515 pub fn with_launch_nonce_env(mut self, launch_nonce_env: Option<bool>) -> Self {
2516 self.launch_nonce_env = launch_nonce_env;
2517 self
2518 }
2519
2520 pub fn with_launch_nonce_source(mut self, source: Option<String>) -> Self {
2521 self.launch_nonce_source = source;
2522 self
2523 }
2524
2525 #[must_use]
2526 pub fn with_waiting_for_previous_pid(mut self, pid: Option<u32>) -> Self {
2527 self.waiting_for_previous_pid = pid;
2528 self
2529 }
2530
2531 #[must_use]
2533 pub fn with_pending_reload(mut self, pending_reload: Option<PendingReloadVerdict>) -> Self {
2534 self.pending_reload = pending_reload;
2535 self
2536 }
2537
2538 #[must_use]
2540 pub fn with_last_probe_ms(mut self, last_probe_ms: Option<u64>) -> Self {
2541 self.last_probe_ms = last_probe_ms;
2542 self
2543 }
2544
2545 #[must_use]
2547 pub fn with_last_exit_code(mut self, last_exit_code: Option<i32>) -> Self {
2548 self.last_exit_code = last_exit_code;
2549 self
2550 }
2551
2552 #[must_use]
2554 pub fn with_last_exit_signal(mut self, last_exit_signal: Option<i32>) -> Self {
2555 self.last_exit_signal = last_exit_signal;
2556 self
2557 }
2558
2559 #[must_use]
2561 pub fn with_last_exit_ms(mut self, last_exit_ms: Option<u64>) -> Self {
2562 self.last_exit_ms = last_exit_ms;
2563 self
2564 }
2565
2566 #[must_use]
2568 pub fn with_last_exit_kind(mut self, last_exit_kind: Option<TerminalExitKind>) -> Self {
2569 self.last_exit_kind = last_exit_kind;
2570 self
2571 }
2572
2573 #[must_use]
2575 pub fn with_restart_count(mut self, restart_count: Option<u32>) -> Self {
2576 self.restart_count = restart_count;
2577 self
2578 }
2579
2580 #[must_use]
2582 pub fn with_max_restarts(mut self, max_restarts: Option<u32>) -> Self {
2583 self.max_restarts = max_restarts;
2584 self
2585 }
2586
2587 #[must_use]
2589 pub fn with_lifetime_restarts(mut self, lifetime_restarts: Option<u32>) -> Self {
2590 self.lifetime_restarts = lifetime_restarts;
2591 self
2592 }
2593
2594 #[must_use]
2596 pub fn with_spawn_generation(mut self, spawn_generation: Option<u64>) -> Self {
2597 self.spawn_generation = spawn_generation;
2598 self
2599 }
2600
2601 #[must_use]
2603 pub fn with_restart_window_secs(mut self, restart_window_secs: Option<u64>) -> Self {
2604 self.restart_window_secs = restart_window_secs;
2605 self
2606 }
2607
2608 #[must_use]
2610 pub fn with_drain_timeout_ms(mut self, drain_timeout_ms: Option<u64>) -> Self {
2611 self.drain_timeout_ms = drain_timeout_ms;
2612 self
2613 }
2614
2615 #[must_use]
2617 pub fn with_restart_backoff_ms(mut self, restart_backoff_ms: Option<u64>) -> Self {
2618 self.restart_backoff_ms = restart_backoff_ms;
2619 self
2620 }
2621
2622 #[must_use]
2624 pub fn with_restart_max_backoff_ms(mut self, restart_max_backoff_ms: Option<u64>) -> Self {
2625 self.restart_max_backoff_ms = restart_max_backoff_ms;
2626 self
2627 }
2628
2629 #[must_use]
2631 pub fn with_resources(mut self, resources: Option<ChildResourceUsage>) -> Self {
2632 self.resources = resources;
2633 self
2634 }
2635}
2636
2637#[derive(Debug, Clone, PartialEq)]
2640pub enum ChildResourceUsage {
2641 Measured(ChildResourceReading),
2642 Unavailable {
2643 reason: ChildResourceUnavailableReason,
2644 },
2645 Unknown {
2648 tag: String,
2649 body: OrderedJsonObject,
2650 },
2651}
2652
2653#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
2655pub struct ChildResourceReading {
2656 pub memory_bytes: u64,
2659 pub memory_kind: ChildMemoryKind,
2660 #[serde(default, skip_serializing_if = "Option::is_none")]
2663 pub swap_bytes: Option<u64>,
2664 pub cpu_user_ms: u64,
2668 pub cpu_system_ms: u64,
2671}
2672
2673open_string_enum! {
2674 ChildMemoryKind {
2676 PhysFootprint => "phys_footprint",
2680 ResidentSet => "resident_set",
2683 WindowsWorkingSet => "windows_working_set",
2686 }
2687}
2688
2689open_string_enum! {
2690 ChildResourceUnavailableReason {
2692 NotRunning => "not_running",
2694 UnsupportedPlatform => "unsupported_platform",
2696 Unreadable => "unreadable",
2699 ProcessIdentityUnconfirmed => "process_identity_unconfirmed",
2702 }
2703}
2704
2705#[derive(Debug, Clone, Copy, Serialize, Deserialize, PartialEq, Eq)]
2706#[serde(rename_all = "snake_case")]
2707pub enum SupervisorHealthStatus {
2708 Ok,
2709 Degraded,
2710 Failing,
2711 Unresponsive,
2712 Unknown,
2713}
2714
2715#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
2716pub struct SupervisorHealthEntry {
2717 pub module_id: String,
2718 pub status: SupervisorHealthStatus,
2719 #[serde(default, skip_serializing_if = "Option::is_none")]
2725 pub detail: Option<String>,
2726 #[serde(default, skip_serializing_if = "Option::is_none")]
2731 pub metrics: Option<serde_json::Value>,
2732 pub consecutive_failures: u32,
2733 #[serde(default)]
2736 pub late_answer_count: u64,
2737 #[serde(default, skip_serializing_if = "Option::is_none")]
2739 pub last_late_answer_latency_ms: Option<u64>,
2740 #[serde(default)]
2745 pub last_action: Option<String>,
2746 #[serde(default)]
2749 pub last_action_ms: Option<u64>,
2750 #[serde(default, skip_serializing_if = "Option::is_none")]
2763 pub last_probe_ms: Option<u64>,
2764}
2765
2766#[cfg(test)]
2767mod tests {
2768 #[test]
2769 fn configured_enabled_omission_preserves_exact_old_list_bytes() {
2770 let entry = r#"{"module_id":"provider","state":"running","enabled":true,"live":true,"protocol":"subc","health":"unknown","last_probe_ms":null}"#;
2771 let decoded: SupervisorEntry = serde_json::from_str(entry).unwrap();
2772 assert_eq!(decoded.configured_enabled, None);
2773 assert_eq!(serde_json::to_string(&decoded).unwrap(), entry);
2774 }
2775
2776 #[test]
2777 fn configured_enabled_values_round_trip_in_list() {
2778 for enabled in [false, true] {
2779 let entry = SupervisorEntry::new(
2780 "provider",
2781 "running",
2782 true,
2783 true,
2784 SupervisorHealthStatus::Unknown,
2785 )
2786 .with_configured_enabled(Some(enabled));
2787 let entry_json = serde_json::to_value(&entry).unwrap();
2788 assert_eq!(entry_json["configured_enabled"], enabled);
2789 assert_eq!(
2790 serde_json::from_value::<SupervisorEntry>(entry_json).unwrap(),
2791 entry
2792 );
2793 }
2794 }
2795
2796 #[test]
2797 fn windows_running_image_evidence_round_trips_all_sixteen_id_bytes() {
2798 let evidence = super::RunningImageEvidence::WindowsSpawnFileId {
2799 volume_serial_number: u64::MAX,
2800 file_id: [
2801 0, 1, 2, 3, 4, 5, 6, 7, 128, 129, 130, 131, 252, 253, 254, 255,
2802 ],
2803 };
2804 let agreement = super::RunningImageAgreement::Match { evidence };
2805 let encoded = serde_json::to_string(&agreement).unwrap();
2806 assert!(encoded.contains("windows_spawn_file_id"));
2807 assert_eq!(
2808 serde_json::from_str::<super::RunningImageAgreement>(&encoded).unwrap(),
2809 agreement
2810 );
2811 }
2812
2813 #[test]
2814 fn unix_running_image_evidence_keeps_original_wire_bytes() {
2815 assert_eq!(
2816 serde_json::to_string(&super::RunningImageEvidence::MacosSpawnInode {
2817 device: 7,
2818 inode: 11
2819 })
2820 .unwrap(),
2821 "{\"method\":\"macos_spawn_inode\",\"device\":7,\"inode\":11}"
2822 );
2823 assert_eq!(
2824 serde_json::to_string(&super::RunningImageEvidence::LinuxProcSha256 {
2825 digest: "abc".to_owned()
2826 })
2827 .unwrap(),
2828 "{\"method\":\"linux_proc_sha256\",\"digest\":\"abc\"}"
2829 );
2830 }
2831 use super::*;
2832 use subc_protocol::{BindIdentity, RouteTarget};
2833
2834 #[test]
2835 fn legacy_terminal_decoder_ignores_deliberate_severance_kind() {
2836 let entry = TerminalEntry {
2837 daemon_incarnation: Some("daemon-before-restart".into()),
2838 exit_code: Some(1),
2839 exit_signal: None,
2840 at_ms: 1_700_000_000_123,
2841 disposition: TerminalDisposition::Restarting,
2842 exit_kind: Some(TerminalExitKind::DeliberateSeverance),
2843 disposition_detail: None,
2844 };
2845 let wire = serde_json::to_string(&entry).expect("terminal entry serializes");
2846 assert_eq!(
2847 serde_json::from_str::<serde_json::Value>(&wire).expect("terminal entry is JSON")
2848 ["exit_kind"],
2849 "deliberate_severance"
2850 );
2851
2852 #[derive(serde::Deserialize)]
2853 struct LegacyTerminalEntry {
2854 exit_code: Option<i32>,
2855 exit_signal: Option<i32>,
2856 at_ms: u64,
2857 disposition: TerminalDisposition,
2858 }
2859
2860 let decoded: LegacyTerminalEntry =
2861 serde_json::from_str(&wire).expect("legacy decoder keeps the terminal record");
2862 assert_eq!(decoded.exit_code, Some(1));
2863 assert_eq!(decoded.exit_signal, None);
2864 assert_eq!(decoded.at_ms, 1_700_000_000_123);
2865 assert_eq!(decoded.disposition, TerminalDisposition::Restarting);
2866
2867 let future_wire = wire.replace("deliberate_severance", "future_exit_kind");
2868 let future: TerminalEntry =
2869 serde_json::from_str(&future_wire).expect("new decoder keeps a future terminal kind");
2870 assert_eq!(
2871 future.exit_kind,
2872 Some(TerminalExitKind::Unknown("future_exit_kind".to_string()))
2873 );
2874 }
2875
2876 #[test]
2877 fn terminal_incarnation_is_optional_for_older_daemons() {
2878 let entry: TerminalEntry = serde_json::from_value(serde_json::json!({
2879 "at_ms": 123,
2880 "disposition": "stopped"
2881 }))
2882 .unwrap();
2883 let encoded = serde_json::to_value(&entry).unwrap();
2884 assert_eq!(
2885 (entry.daemon_incarnation, encoded.get("daemon_incarnation")),
2886 (None, None)
2887 );
2888 }
2889
2890 #[test]
2891 fn route_poll_uses_kind_field() {
2892 let body = serde_json::to_value(ClientControlRequest::RoutePoll {
2893 route_channel: 7,
2894 route_epoch: 11,
2895 kind: PollKind::Status,
2896 })
2897 .unwrap();
2898
2899 assert_eq!(body["op"], "route.poll");
2900 assert_eq!(body["route_epoch"], 11);
2901 assert_eq!(body["kind"], "status");
2902 assert!(body.get("op").is_some());
2903 }
2904
2905 #[test]
2906 fn route_open_is_internally_tagged() {
2907 let request = ClientControlRequest::RouteOpen {
2908 target: RouteTarget::ToolProvider {
2909 module_id: "aft".to_string(),
2910 },
2911 identity: BindIdentity::new("/tmp/project", "opencode", "session-1"),
2912 consumer_identity: None,
2913 consumer_capabilities: None,
2914 role_versions: None,
2915 admission_facts: None,
2916 scope: None,
2917 };
2918
2919 let body = serde_json::to_value(request).unwrap();
2920 assert_eq!(body["op"], "route.open");
2921 assert_eq!(body["target"]["kind"], "tool_provider");
2922 assert!(body.get("consumer_identity").is_none());
2923 assert!(body.get("consumer_capabilities").is_none());
2924 assert!(body.get("role_versions").is_none());
2925 }
2926
2927 #[test]
2928 fn route_open_without_optional_fields_still_decodes() {
2929 let body = serde_json::json!({
2930 "op": "route.open",
2931 "target": { "kind": "tool_provider", "module_id": "aft" },
2932 "identity": {
2933 "project_root": "/tmp/project",
2934 "harness": "opencode",
2935 "session": "session-1"
2936 }
2937 });
2938
2939 let decoded: ClientControlRequest = serde_json::from_value(body).unwrap();
2940 let ClientControlRequest::RouteOpen {
2941 consumer_identity,
2942 consumer_capabilities,
2943 role_versions,
2944 admission_facts,
2945 ..
2946 } = decoded
2947 else {
2948 panic!("decoded wrong request variant");
2949 };
2950 assert_eq!(consumer_identity, None);
2951 assert_eq!(consumer_capabilities, None);
2952 assert_eq!(role_versions, None);
2953 assert_eq!(admission_facts, None);
2954 }
2955
2956 #[test]
2957 fn new_route_closed_decoder_defaults_fields_absent_from_old_daemon() {
2958 let old_wire = r#"{"op":"route.closed","module_id":"aft-tools","reason":"crash","drained":false,"abandoned":0}"#;
2959 let decoded: ClientControlPush = serde_json::from_str(old_wire).unwrap();
2960 match decoded {
2961 ClientControlPush::RouteClosed {
2962 excluded_subscriptions,
2963 terminal,
2964 ..
2965 } => {
2966 assert_eq!(excluded_subscriptions, 0);
2967 assert_eq!(terminal, None);
2968 }
2969 other => panic!("unexpected push: {other:?}"),
2970 }
2971 assert!(!serde_json::to_string(&decoded)
2972 .unwrap()
2973 .contains("terminal"));
2974 }
2975
2976 #[test]
2977 fn old_route_closed_decoder_ignores_new_terminal_field() {
2978 #[derive(serde::Deserialize)]
2979 #[serde(tag = "op")]
2980 enum LegacyClientControlPush {
2981 #[serde(rename = "route.closed")]
2982 RouteClosed {
2983 module_id: String,
2984 reason: RouteCloseReason,
2985 drained: bool,
2986 abandoned: u32,
2987 },
2988 }
2989
2990 let wire = r#"{"op":"route.closed","module_id":"aft-tools","reason":"crash","drained":false,"abandoned":0,"excluded_subscriptions":3,"terminal":true}"#;
2991 let decoded: LegacyClientControlPush = serde_json::from_str(wire).unwrap();
2992 match decoded {
2993 LegacyClientControlPush::RouteClosed {
2994 module_id,
2995 reason,
2996 drained,
2997 abandoned,
2998 } => {
2999 assert_eq!(module_id, "aft-tools");
3000 assert_eq!(reason, RouteCloseReason::Crash);
3001 assert!(!drained);
3002 assert_eq!(abandoned, 0);
3003 }
3004 }
3005 }
3006
3007 #[test]
3008 fn supervisor_routes_is_a_control_plane_request() {
3009 let body = serde_json::json!({
3010 "op": "supervisor.routes",
3011 "module_id": "aft"
3012 });
3013
3014 let request: ClientControlRequest = serde_json::from_value(body.clone()).unwrap();
3015 assert_eq!(serde_json::to_value(request).unwrap(), body);
3016 }
3017
3018 #[test]
3019 fn diagnostic_string_enums_retain_unknown_wire_values() {
3020 let reason: RunningImageUnavailableReason =
3021 serde_json::from_str("\"future_reason\"").unwrap();
3022 let disposition: TerminalDisposition =
3023 serde_json::from_str("\"future_disposition\"").unwrap();
3024
3025 assert_eq!(
3026 reason,
3027 RunningImageUnavailableReason::Unknown("future_reason".to_string())
3028 );
3029 assert_eq!(
3030 disposition,
3031 TerminalDisposition::Unknown("future_disposition".to_string())
3032 );
3033 }
3034
3035 #[test]
3036 fn diagnostic_string_enums_preserve_existing_wire_names() {
3037 let names = [
3038 (RunningImageUnavailableReason::NotRunning, "not_running"),
3039 (
3040 RunningImageUnavailableReason::UnsupportedPlatform,
3041 "unsupported_platform",
3042 ),
3043 (
3044 RunningImageUnavailableReason::RunningExecutableUnreadable,
3045 "running_executable_unreadable",
3046 ),
3047 (
3048 RunningImageUnavailableReason::RunningExecutablePermissionDenied,
3049 "running_executable_permission_denied",
3050 ),
3051 (
3052 RunningImageUnavailableReason::ProcessHidden,
3053 "process_hidden",
3054 ),
3055 (
3056 RunningImageUnavailableReason::SpawnedPathUnreadable,
3057 "spawned_path_unreadable",
3058 ),
3059 (RunningImageUnavailableReason::HashFailed, "hash_failed"),
3060 (
3061 RunningImageUnavailableReason::ProcessIdentityUnconfirmed,
3062 "process_identity_unconfirmed",
3063 ),
3064 ];
3065 for (value, expected) in names {
3066 let wire = serde_json::to_string(&value).unwrap();
3067 assert_eq!(wire, format!("\"{expected}\""));
3068 let decoded: RunningImageUnavailableReason = serde_json::from_str(&wire).unwrap();
3069 assert_eq!(decoded, value);
3070 }
3071
3072 for (value, expected) in [
3073 (TerminalDisposition::Stopped, "stopped"),
3074 (TerminalDisposition::Disabled, "disabled"),
3075 (TerminalDisposition::Failed, "failed"),
3076 (TerminalDisposition::Restarting, "restarting"),
3077 (TerminalDisposition::DaemonShutdown, "daemon_shutdown"),
3078 ] {
3079 let wire = serde_json::to_string(&value).unwrap();
3080 assert_eq!(wire, format!("\"{expected}\""));
3081 let decoded: TerminalDisposition = serde_json::from_str(&wire).unwrap();
3082 assert_eq!(decoded, value);
3083 }
3084 }
3085
3086 #[test]
3087 fn supervisor_waiting_previous_pid_is_optional_and_round_trips() {
3088 let entry = SupervisorEntry::new(
3089 "waiting-module",
3090 "starting",
3091 true,
3092 false,
3093 SupervisorHealthStatus::Unknown,
3094 );
3095 let old_wire = serde_json::to_value(&entry).unwrap();
3096 assert!(old_wire.get("waiting_for_previous_pid").is_none());
3097 let decoded: SupervisorEntry = serde_json::from_value(old_wire).unwrap();
3098 assert_eq!(decoded.waiting_for_previous_pid, None);
3099 let entry = entry.with_waiting_for_previous_pid(Some(42));
3100 let wire = serde_json::to_value(&entry).unwrap();
3101 assert_eq!(wire["waiting_for_previous_pid"], 42);
3102 let decoded: SupervisorEntry = serde_json::from_value(wire).unwrap();
3103 assert_eq!(decoded.waiting_for_previous_pid, Some(42));
3104 }
3105
3106 #[test]
3107 fn diagnostic_string_enums_reject_non_string_bodies() {
3108 assert!(serde_json::from_str::<RunningImageUnavailableReason>("42").is_err());
3109 assert!(serde_json::from_str::<TerminalDisposition>("{\"value\":\"failed\"}").is_err());
3110 }
3111
3112 #[test]
3113 fn unknown_provenance_reason_does_not_discard_healthy_siblings() {
3114 let body = serde_json::json!({
3115 "op": "supervisor.provenance",
3116 "daemon": {
3117 "daemon_build": {},
3118 "daemon_observed": {
3119 "running_image": {
3120 "status": "unavailable",
3121 "reason": "not_running"
3122 }
3123 }
3124 },
3125 "modules": [
3126 {
3127 "module_id": "future",
3128 "module_declared": { "status": "unverifiable" },
3129 "daemon_observed": {
3130 "running_image": {
3131 "status": "unavailable",
3132 "reason": "future_reason"
3133 }
3134 }
3135 },
3136 {
3137 "module_id": "healthy-a",
3138 "module_declared": { "status": "unverifiable" },
3139 "daemon_observed": {
3140 "running_image": {
3141 "status": "match",
3142 "evidence": {
3143 "method": "linux_proc_sha256",
3144 "digest": "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"
3145 }
3146 }
3147 }
3148 },
3149 {
3150 "module_id": "healthy-b",
3151 "module_declared": { "status": "unverifiable" },
3152 "daemon_observed": {
3153 "running_image": {
3154 "status": "unavailable",
3155 "reason": "unsupported_platform"
3156 }
3157 }
3158 }
3159 ]
3160 });
3161
3162 let decoded: ClientControlResponse = serde_json::from_value(body).unwrap();
3163 let ClientControlResponse::SupervisorProvenance { modules, .. } = decoded else {
3164 panic!("decoded wrong response variant");
3165 };
3166 assert_eq!(modules.len(), 3);
3167 assert_eq!(modules[0].module_id, "future");
3168 assert_eq!(
3169 modules[0].daemon_observed.running_image,
3170 RunningImageAgreement::Unavailable {
3171 reason: RunningImageUnavailableReason::Unknown("future_reason".to_string())
3172 }
3173 );
3174 assert_eq!(modules[1].module_id, "healthy-a");
3175 assert_eq!(modules[2].module_id, "healthy-b");
3176 }
3177
3178 #[test]
3179 fn tagged_unknown_values_retain_tag_and_body() {
3180 macro_rules! assert_unknown_round_trip {
3181 ($ty:ident, $field:literal, $value:expr) => {
3182 let value = $value;
3183 let wire = serde_json::to_string(&value).unwrap();
3184 let decoded: $ty = serde_json::from_str(&wire).unwrap();
3185 match decoded {
3186 $ty::Unknown { tag, body } => {
3187 assert_eq!(tag, value[$field].as_str().unwrap());
3188 assert_eq!(serde_json::to_value(&body).unwrap(), value);
3189 }
3190 _ => panic!("decoded known variant"),
3191 }
3192 };
3193 }
3194
3195 assert_unknown_round_trip!(
3196 ModuleDeclaredProvenance,
3197 "status",
3198 serde_json::json!({"status": "future", "build": {"version": 7}})
3199 );
3200 assert_unknown_round_trip!(
3201 RunningImageAgreement,
3202 "status",
3203 serde_json::json!({"status": "future", "evidence": {"digest": "abc"}})
3204 );
3205 assert_unknown_round_trip!(
3206 RunningImageEvidence,
3207 "method",
3208 serde_json::json!({"method": "future", "digest": "abc"})
3209 );
3210 assert_unknown_round_trip!(
3211 SupervisorRouteConsumer,
3212 "kind",
3213 serde_json::json!({"kind": "future", "module_id": "m"})
3214 );
3215 assert_unknown_round_trip!(
3216 StderrCaptureState,
3217 "state",
3218 serde_json::json!({"state": "future", "reason": "because"})
3219 );
3220 assert_unknown_round_trip!(
3221 StderrTailEntry,
3222 "kind",
3223 serde_json::json!({"kind": "future", "text": "line"})
3224 );
3225 assert_unknown_round_trip!(
3226 ChildResourceUsage,
3227 "status",
3228 serde_json::json!({"status": "future", "memory_bytes": 1})
3229 );
3230 }
3231
3232 #[test]
3233 fn child_resource_usage_round_trips_both_known_states() {
3234 let measured = ChildResourceUsage::Measured(ChildResourceReading {
3235 memory_bytes: 0,
3236 memory_kind: ChildMemoryKind::ResidentSet,
3237 swap_bytes: Some(0),
3238 cpu_user_ms: 0,
3239 cpu_system_ms: 0,
3240 });
3241 let wire = serde_json::to_value(&measured).unwrap();
3242 assert_eq!(
3243 wire,
3244 serde_json::json!({
3245 "status": "measured",
3246 "memory_bytes": 0,
3247 "memory_kind": "resident_set",
3248 "swap_bytes": 0,
3249 "cpu_user_ms": 0,
3250 "cpu_system_ms": 0
3251 })
3252 );
3253 assert_eq!(
3254 serde_json::from_value::<ChildResourceUsage>(wire).unwrap(),
3255 measured
3256 );
3257
3258 let unavailable = ChildResourceUsage::Unavailable {
3259 reason: ChildResourceUnavailableReason::NotRunning,
3260 };
3261 let wire = serde_json::to_value(&unavailable).unwrap();
3262 assert_eq!(
3263 wire,
3264 serde_json::json!({"status": "unavailable", "reason": "not_running"})
3265 );
3266 assert_eq!(
3267 serde_json::from_value::<ChildResourceUsage>(wire).unwrap(),
3268 unavailable
3269 );
3270 }
3271
3272 #[test]
3273 fn a_stderr_line_decodes_with_and_without_its_capture_time() {
3274 let stamped: StderrTailEntry = serde_json::from_str(
3278 r#"{"kind":"line","text":"boom","truncated":true,"at_ms":1789801440685}"#,
3279 )
3280 .unwrap();
3281 assert_eq!(
3282 stamped,
3283 StderrTailEntry::Line {
3284 text: "boom".to_string(),
3285 truncated: true,
3286 at_ms: Some(1_789_801_440_685),
3287 }
3288 );
3289 let unstamped: StderrTailEntry =
3290 serde_json::from_str(r#"{"kind":"line","text":"boom"}"#).unwrap();
3291 assert_eq!(
3292 unstamped,
3293 StderrTailEntry::Line {
3294 text: "boom".to_string(),
3295 truncated: false,
3296 at_ms: None,
3297 }
3298 );
3299 assert_eq!(
3302 serde_json::to_string(&unstamped).unwrap(),
3303 r#"{"kind":"line","text":"boom"}"#
3304 );
3305 assert_eq!(
3306 serde_json::to_value(&stamped).unwrap()["at_ms"],
3307 serde_json::json!(1_789_801_440_685u64)
3308 );
3309 }
3310
3311 #[test]
3312 fn tagged_unknown_values_round_trip_the_original_json() {
3313 let wire = r#"{"kind":"future_consumer","detail":{"z":1}}"#;
3314 let decoded: SupervisorRouteConsumer = serde_json::from_str(wire).unwrap();
3315 assert_eq!(serde_json::to_string(&decoded).unwrap(), wire);
3316 }
3317
3318 #[test]
3319 fn tagged_unknown_values_round_trip_trailing_tag() {
3320 let route_wire = r#"{"detail":{"z":1},"kind":"future_consumer"}"#;
3321 let route: SupervisorRouteConsumer = serde_json::from_str(route_wire).unwrap();
3322 assert_eq!(serde_json::to_string(&route).unwrap(), route_wire);
3323
3324 let stderr_wire = r#"{"reason":"because","state":"future_state"}"#;
3325 let stderr: StderrCaptureState = serde_json::from_str(stderr_wire).unwrap();
3326 assert_eq!(serde_json::to_string(&stderr).unwrap(), stderr_wire);
3327 }
3328
3329 #[test]
3330 fn tagged_unknown_values_round_trip_middle_tag() {
3331 let route_wire = r#"{"a":1,"kind":"future_x","b":2}"#;
3332 let route: SupervisorRouteConsumer = serde_json::from_str(route_wire).unwrap();
3333 assert_eq!(serde_json::to_string(&route).unwrap(), route_wire);
3334
3335 let stderr_wire = r#"{"a":1,"state":"future_state","b":2}"#;
3336 let stderr: StderrCaptureState = serde_json::from_str(stderr_wire).unwrap();
3337 assert_eq!(serde_json::to_string(&stderr).unwrap(), stderr_wire);
3338 }
3339
3340 #[test]
3341 fn tagged_unknown_values_round_trip_deep_payload() {
3342 let route_wire = r#"{"a":{"n":[1,2]},"kind":"future_x","zz":"s","b":null}"#;
3343 let route: SupervisorRouteConsumer = serde_json::from_str(route_wire).unwrap();
3344 assert_eq!(serde_json::to_string(&route).unwrap(), route_wire);
3345
3346 let stderr_wire = r#"{"a":{"n":[1,2]},"state":"future_state","zz":"s","b":null}"#;
3347 let stderr: StderrCaptureState = serde_json::from_str(stderr_wire).unwrap();
3348 assert_eq!(serde_json::to_string(&stderr).unwrap(), stderr_wire);
3349 }
3350
3351 #[test]
3352 fn tagged_unknown_values_reject_non_object_bodies() {
3353 for wire in ["42", r#""future""#, "[]"] {
3354 assert!(serde_json::from_str::<SupervisorRouteConsumer>(wire).is_err());
3355 assert!(serde_json::from_str::<StderrCaptureState>(wire).is_err());
3356 }
3357 }
3358
3359 #[test]
3360 fn duplicate_discriminators_reject_without_panicking() {
3361 assert_eq!(
3362 serde_json::from_str::<ModuleDeclaredProvenance>(r#"{"status":"unverifiable"}"#)
3363 .unwrap(),
3364 ModuleDeclaredProvenance::Unverifiable
3365 );
3366 match serde_json::from_str::<ModuleDeclaredProvenance>(r#"{"status":"future_thing"}"#)
3367 .unwrap()
3368 {
3369 ModuleDeclaredProvenance::Unknown { tag, .. } => assert_eq!(tag, "future_thing"),
3370 _ => panic!("future discriminator decoded as a known variant"),
3371 }
3372
3373 let wires = [
3374 r#"{"status":"reported","status":"unverifiable"}"#,
3375 r#"{"status":"unverifiable","status":"reported"}"#,
3376 r#"{"status":"reported","build":{},"status":"unverifiable"}"#,
3377 r#"{"status":"unverifiable","build":{},"status":"reported"}"#,
3378 ];
3379
3380 for wire in wires {
3381 let result =
3382 std::panic::catch_unwind(|| serde_json::from_str::<ModuleDeclaredProvenance>(wire));
3383 assert!(result.is_ok(), "duplicate discriminator panicked: {wire}");
3384 assert!(
3385 result.unwrap().is_err(),
3386 "duplicate discriminator decoded: {wire}"
3387 );
3388 }
3389
3390 let wire = r#"{"state":"captured","state":"incomplete","reason":"x"}"#;
3391 let result = std::panic::catch_unwind(|| serde_json::from_str::<StderrCaptureState>(wire));
3392 assert!(result.is_ok(), "duplicate discriminator panicked: {wire}");
3393 assert!(
3394 result.unwrap().is_err(),
3395 "duplicate discriminator decoded: {wire}"
3396 );
3397 }
3398
3399 #[test]
3400 fn nested_unknown_values_round_trip_without_normalizing_member_order() {
3401 let known_wire =
3402 r#"{"status":"match","evidence":{"method":"linux_proc_sha256","digest":"abc"}}"#;
3403 let known: RunningImageAgreement = serde_json::from_str(known_wire).unwrap();
3404 assert_eq!(serde_json::to_string(&known).unwrap(), known_wire);
3405
3406 for wire in [
3407 r#"{"kind":"future_x","detail":{"zeta":1,"alpha":2}}"#,
3408 r#"{"kind":"future_x","d":{"b":{"zz":1,"aa":2}}}"#,
3409 ] {
3410 let decoded: SupervisorRouteConsumer = serde_json::from_str(wire).unwrap();
3411 assert_eq!(serde_json::to_string(&decoded).unwrap(), wire);
3412 }
3413
3414 for wire in [
3415 r#"{"status":"match","evidence":{"method":"future_probe","zz":1,"aa":2}}"#,
3416 r#"{"status":"match","evidence":{"method":"future_probe","d":{"zz":1,"aa":2}}}"#,
3417 ] {
3418 let decoded: RunningImageAgreement = serde_json::from_str(wire).unwrap();
3419 assert_eq!(serde_json::to_string(&decoded).unwrap(), wire);
3420 }
3421
3422 let wire = r#"{"status":"mismatch","running":{"detail":{"z":1},"method":"future_running"},"disk":{"method":"future_disk","detail":{"z":1}}}"#;
3423 let decoded: RunningImageAgreement = serde_json::from_str(wire).unwrap();
3424 assert_eq!(serde_json::to_string(&decoded).unwrap(), wire);
3425
3426 let wire = r#"{"capture":{"state":"captured"},"entries":[{"detail":{"z":1,"a":2},"kind":"future_line"},{"kind":"future_restart","meta":{"b":{"zz":1,"aa":2}}}]}"#;
3427 let decoded: StderrTail = serde_json::from_str(wire).unwrap();
3428 assert_eq!(serde_json::to_string(&decoded).unwrap(), wire);
3429 }
3430
3431 #[test]
3432 fn tagged_unknown_member_does_not_discard_known_siblings() {
3433 let body = serde_json::json!({
3434 "modules": [{
3435 "module_id": "target",
3436 "routes": [
3437 {"consumer": {"kind": "future_consumer", "module_id": "m", "detail": {"retry": true}}, "age_ms": 0, "draining": false},
3438 {"consumer": {"kind": "direct", "connection_id": 7}, "age_ms": 0, "draining": false}
3439 ]
3440 }]
3441 });
3442 let decoded: ClientControlResponse = serde_json::from_value(
3443 serde_json::json!({"op": "supervisor.routes", "modules": body["modules"]}),
3444 )
3445 .unwrap();
3446 let ClientControlResponse::SupervisorRoutes { modules } = decoded else {
3447 panic!("decoded wrong response variant");
3448 };
3449 assert_eq!(modules[0].routes.len(), 2);
3450 assert_eq!(
3451 modules[0].routes[1].consumer,
3452 SupervisorRouteConsumer::Direct { connection_id: 7 }
3453 );
3454 }
3455}
3456
3457#[cfg(test)]
3458mod launch_nonce_redaction_tests {
3459 use super::*;
3460
3461 const NONCE: &str = "nonce-f00dfeed1234abcd";
3462
3463 fn identity() -> ConsumerIdentity {
3464 ConsumerIdentity {
3465 module_id: "wernicke".to_string(),
3466 launch_nonce: NONCE.to_string(),
3467 }
3468 }
3469
3470 #[test]
3471 fn consumer_identity_debug_names_the_module_and_never_the_nonce() {
3472 let printed = format!("{:?}", identity());
3473 assert!(printed.contains("wernicke"), "{printed}");
3474 assert!(!printed.contains(NONCE), "launch nonce printed: {printed}");
3475 }
3476
3477 #[test]
3478 fn route_open_request_debug_never_prints_the_nonce() {
3479 let request = ClientControlRequest::RouteOpen {
3480 target: subc_protocol::RouteTarget::ToolProvider {
3481 module_id: "broca".to_string(),
3482 },
3483 identity: subc_protocol::BindIdentity::new(
3484 PathBuf::from("/tmp/project"),
3485 "test".to_string(),
3486 "session".to_string(),
3487 ),
3488 consumer_identity: Some(identity()),
3489 consumer_capabilities: None,
3490 role_versions: None,
3491 admission_facts: None,
3492 scope: None,
3493 };
3494 let printed = format!("{request:?}");
3495 assert!(!printed.contains(NONCE), "launch nonce printed: {printed}");
3496 }
3497}