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