lib/machine/src/fabric/types.zig
daab053ee43316e1809a84551d573ddd1e5bf3d2
1 const admission = @import("../admission/root.zig");
2 const fault = @import("../fault/root.zig");
3 const instance = @import("../instance/root.zig");
4 const os = @import("os");
5 const profile = @import("../profile/root.zig");
6 const std = @import("std");
7
8 pub const node_limit: usize = 4;
9 pub const packet_limit: usize = os.abi.ring.capacity;
10 pub const packet_bytes_max: usize = admission.effect_result_bytes_max;
11 pub const admission_limit: u32 = 4096;
12
13 pub const Dialect = enum(u16) {
14 ordered_effect_fabric_v3 = 3,
15 };
16
17 pub const NodeId = struct {
18 bytes: [16]u8,
19 };
20
21 pub const Node = struct {
22 id: NodeId,
23 basis: admission.Basis,
24 };
25
26 pub const Input = struct {
27 profile: profile.Profile,
28 world: [16]u8,
29 virtual_time_tick: u64,
30 nodes: []const Node,
31 };
32
33 pub const Root = struct {
34 digest: os.abi.Digest,
35 dialect: Dialect,
36 machine_contract: profile.ContractFingerprint,
37 entry_frontier: u64,
38 admission_frontier: u64,
39 fault_frontier: u64,
40 };
41
42 pub const MachineBoundaryKind = enum(u8) {
43 basis = 1,
44 semantic = 2,
45 };
46
47 pub const MachineBoundary = struct {
48 kind: MachineBoundaryKind,
49 digest: os.abi.Digest,
50 };
51
52 pub const NodeBoundary = struct {
53 id: NodeId,
54 available: bool,
55 machine: MachineBoundary,
56 };
57
58 pub const Cut = struct {
59 root: Root,
60 node_count: u8,
61 nodes: [node_limit]NodeBoundary,
62 };
63
64 pub const PacketInput = struct {
65 destination: NodeId,
66 channel: u16,
67 bytes: []const u8,
68 };
69
70 pub const ServiceResult = struct {
71 status: os.abi.EffectStatus,
72 output_root: os.abi.Digest,
73 bytes: []const u8,
74 };
75
76 pub const CapacityResource = enum(u8) {
77 admission = 1,
78 packet = 2,
79 };
80
81 pub const FaultAlternatives = struct {
82 node: NodeId,
83 bypass: os.abi.Digest,
84 inject: os.abi.Digest,
85 };
86
87 pub const ProcessCrash = struct {
88 node: NodeId,
89 process: u64,
90 };
91
92 pub const PacketDelay = struct {
93 packet: u64,
94 until_tick: u64,
95 };
96
97 pub const PacketReorder = struct {
98 first: u64,
99 second: u64,
100 };
101
102 pub const Partition = struct {
103 first: NodeId,
104 second: NodeId,
105 active: bool,
106 };
107
108 pub const CapacityFault = struct {
109 resource: CapacityResource,
110 active: bool,
111 };
112
113 pub const FaultEffect = union(fault.Kind) {
114 machine_crash: NodeId,
115 process_crash: ProcessCrash,
116 io_error: FaultAlternatives,
117 packet_loss: u64,
118 packet_delay: PacketDelay,
119 packet_reorder: PacketReorder,
120 partition: Partition,
121 clock_jump: u64,
122 entropy_choice: FaultAlternatives,
123 capacity_exhaustion: CapacityFault,
124 host_service_failure: FaultAlternatives,
125 };
126
127 pub const FaultInput = struct {
128 effect: FaultEffect,
129 choice: fault.Choice,
130 };
131
132 pub const AdmissionFault = struct {
133 effect: FaultEffect,
134 decision: fault.Decision,
135 };
136
137 pub const FaultEntry = struct {
138 effect: FaultEffect,
139 decision: fault.Decision,
140 };
141
142 pub const Packet = struct {
143 id: u64,
144 source: NodeId,
145 destination: NodeId,
146 channel: u16,
147 request: admission.EffectRequest,
148 length: u16,
149 storage: [packet_bytes_max]u8,
150 digest: os.abi.Digest,
151
152 pub fn bytes(self: *const Packet) []const u8 {
153 std.debug.assert(self.length <= self.storage.len);
154 return self.storage[0..self.length];
155 }
156 };
157
158 pub const AdmissionEffect = union(enum) {
159 direct,
160 packet_send: Packet,
161 packet_delivery: u64,
162 };
163
164 pub const AdmissionEntry = struct {
165 node: NodeId,
166 admission: admission.Admission,
167 effect: AdmissionEffect,
168 fault: ?AdmissionFault,
169 };
170
171 pub const SettlementEntry = struct {
172 node: NodeId,
173 receipt: instance.SemanticReceipt,
174 };
175
176 pub const EntryValue = union(enum) {
177 admission: AdmissionEntry,
178 settlement: SettlementEntry,
179 fault: FaultEntry,
180 };
181
182 pub const Entry = struct {
183 sequence: u64,
184 previous: Root,
185 value: EntryValue,
186 };
187
188 pub const Transition = struct {
189 entry: Entry,
190 root: Root,
191 };
192
193 pub const Admitted = struct {
194 entry: Entry,
195 root: Root,
196 delivery: admission.Delivery,
197 };
198
199 pub const Settled = struct {
200 entry: Entry,
201 root: Root,
202 };
203
204 pub const Faulted = struct {
205 entry: Entry,
206 root: Root,
207 decision: fault.Decision,
208 };
209
210 pub const PendingEffect = union(enum) {
211 direct,
212 packet_send: u64,
213 packet_delivery: u64,
214 };
215
216 pub const Pending = struct {
217 node: NodeId,
218 admission: admission.Admission,
219 effect: PendingEffect,
220 delivery_root: os.abi.Digest,
221 };
222
223 pub const NodeState = struct {
224 id: NodeId,
225 basis: admission.Basis,
226 machine: MachineBoundary,
227 available: bool,
228 };
229
230 pub const QueuedPacket = struct {
231 packet: Packet,
232 ready: bool,
233 ready_at_tick: u64,
234 order: u64,
235 };
236
237 pub const State = struct {
238 contract: profile.ContractFingerprint,
239 world: [16]u8,
240 node_count: u8,
241 nodes: [node_limit]NodeState,
242 virtual_time_tick: u64,
243 entropy_frontier: u64,
244 entropy_bytes: u64,
245 packet_next_id: u64,
246 packet_count: u8,
247 packets: [packet_limit]QueuedPacket,
248 partition_bits: u8,
249 capacity_bits: u8,
250 pending: ?Pending,
251 entry_frontier: u64,
252 admission_frontier: u64,
253 fault_frontier: u64,
254 admission_limit: u32,
255 ledger_digest: os.abi.Digest,
256 fault_digest: os.abi.Digest,
257 root: Root,
258 };