tiny.http.ClientWebSocketStorage

1pub const Storage = struct {2    phase: alloc_phase.capacity.Phase,3    capacity: model.Capacity,4    bytes: []u8,56    pub const Limits: type = model.Limits;7    pub const Capacity: type = model.Capacity;8    pub const Exhaustion: type = StorageExhaustion;9    pub const InitError =10        std.mem.Allocator.Error || error{CapacityOverflow};1112    pub const claim: alloc_phase.capacity.Declaration = .{13        .source = .{14            .id = "http.client_websocket_storage",15            .kind = .phase_static,16            .limit_source = .caller,17            .storage = .{18                .covered = &.{19                    .{20                        .id = "one_fixed_inbound_wire_frame_region_for_every_client_websocket",21                        .lifetime = .steady,22                        .detail = "one fixed inbound wire-frame region for every client WebSocket",23                    },24                    .{25                        .id = "one_fixed_masked_outbound_wire_frame_region_for_eve_72613139f624",26                        .lifetime = .steady,27                        .detail = "one fixed masked outbound wire-frame region for every client WebSocket",28                    },29                },30                .excluded = &.{31                    "URL preparation, HTTP upgrade headers, TLS state, certificate bundles, sockets, and kernel queues",32                    "application payload owners and protocol effects",33                },34            },35            .capacity = .{36                .inputs = &.{37                    alloc_phase.capacity.bindInput(Limits, "websocket_count", "websocket_count"),38                    alloc_phase.capacity.bindInput(Limits, "frame_payload_bytes_per_websocket", "frame_payload_bytes_per_websocket"),39                },40                .type_selectors = &.{},41                .nodes = &.{42                    .{ .input = 0 },43                    .{ .scale = .{ .node = 0, .coefficient = .{ .literal = 2 } } },44                    .{ .constant = 14 },45                    .{ .input = 1 },46                    .{ .add = .{ .left = 2, .right = 3 } },47                    .{ .product = .{ .left = 1, .right = 4 } },48                },49                .assertions = &.{.{50                    .scope = .closure_total,51                    .measure = .retained,52                    .relation = .exact,53                    .expression = 5,54                }},55            },56            .overload = .{57                .kind = .terminal,58                .detail = "capacity exhaustion rejects before opening a WebSocket or publishing a frame",59            },60            .risks = .{61                .transitive = .{62                    .status = .witnessed,63                    .detail = "WebSocket frame send and receive allocate no storage after activation",64                },65                .foreign = .{66                    .status = .excluded,67                    .detail = "TLS and operating-system network owners remain independent",68                },69            },70            .obligations = &.{71                .{ .key = "http_client_websocket_capacity", .role = .capacity_model },72                .{ .key = "http_client_websocket_oom_retry", .role = .custom },73                .{ .key = "http_client_websocket_partition", .role = .overload },74                .{ .key = "http_client_websocket_sealed", .role = .transitive_risk },75                .{ .key = "http_client_websocket_network_overload", .role = .overload },76                .{ .key = "http_client_websocket_network_transitive_risk", .role = .transitive_risk },77                .{ .key = "http_client_websocket_network_foreign_risk", .role = .foreign_risk },78            },79        },80        .bindings = .{81            .owner = @This(),82            .seal = .{83                .family = alloc_phase.capacity.selector(@This().activate),84                .premise = .{85                    .class = .checked_semantic_fact,86                    .authority = .checker,87                },88            },89            .teardown = .{90                .family = alloc_phase.capacity.selector(@This().deinit),91                .premise = .{92                    .class = .checked_semantic_fact,93                    .authority = .checker,94                },95            },96        },97    };9899    pub fn init(100        allocator: std.mem.Allocator,101        limits: Limits,102    ) InitError!Storage {103        const capacity = try Capacity.derive(limits);104        const bytes = if (capacity.storage_bytes == 0)105            @as([]u8, &.{})106        else107            try allocator.alloc(u8, capacity.storage_bytes);108        return .{109            .phase = .initialization,110            .capacity = capacity,111            .bytes = bytes,112        };113    }114115    pub fn activate(self: *Storage) void {116        std.debug.assert(self.phase == .initialization);117        std.debug.assert(118            self.bytes.len == self.capacity.storage_bytes,119        );120        self.phase = .steady;121    }122123    pub fn websocket(124        self: *Storage,125        index: usize,126    ) StorageExhaustion!Scratch {127        std.debug.assert(self.phase == .steady);128        if (index >= self.capacity.websocket_count) {129            return error.ClientWebSocketCapacityExceeded;130        }131        const frame_bytes =132            self.capacity.frame_bytes_per_websocket;133        const read_start = index * frame_bytes;134        const write_region_start =135            self.capacity.websocket_count * frame_bytes;136        const write_start =137            write_region_start + index * frame_bytes;138        return .{139            .read = self.bytes[read_start..][0..frame_bytes],140            .write = self.bytes[write_start..][0..frame_bytes],141            .frame_payload_bytes = self.capacity.frame_payload_bytes_per_websocket,142        };143    }144145    pub fn deinit(146        self: *Storage,147        allocator: std.mem.Allocator,148    ) void {149        std.debug.assert(self.phase != .teardown);150        std.debug.assert(151            self.bytes.len == self.capacity.storage_bytes,152        );153        self.phase = .teardown;154        if (self.bytes.len != 0) allocator.free(self.bytes);155        self.bytes = &.{};156    }157};

1pub const ClientWebSocketStorage = client.WebSocketStorage;