tiny.http.ConnectionInputStorage

1pub const InputStorage = struct {2    phase: alloc_phase.capacity.Phase,3    capacity: StorageCapacity,4    bytes: []u8,56    pub const Limits: type = StorageLimits;7    pub const Capacity: type = StorageCapacity;8    pub const Exhaustion: type = InputExhaustion;9    pub const InitError = std.mem.Allocator.Error || error{CapacityOverflow};1011    pub const claim: alloc_phase.capacity.Declaration = .{12        .source = .{13            .id = "http.connection_input_storage",14            .kind = .phase_static,15            .limit_source = .caller,16            .storage = .{17                .covered = &.{18                    .{19                        .id = "fixed_retained_input_byte_region_for_every_connection_slot",20                        .lifetime = .steady,21                        .detail = "fixed retained-input byte region for every connection slot",22                    },23                },24                .excluded = &.{25                    "request header-map buckets and decoded chunked-body output",26                    "WebSocket storage, protocol sessions, handlers, and response output",27                    "socket and kernel queues",28                },29            },30            .capacity = .{31                .inputs = &.{32                    alloc_phase.capacity.bindInput(Limits, "connection_count", "connection_count"),33                    alloc_phase.capacity.bindInput(Limits, "bytes_per_connection", "bytes_per_connection"),34                },35                .type_selectors = &.{},36                .nodes = &.{37                    .{ .input = 0 },38                    .{ .input = 1 },39                    .{ .product = .{ .left = 0, .right = 1 } },40                },41                .assertions = &.{.{42                    .scope = .closure_total,43                    .measure = .retained,44                    .relation = .exact,45                    .expression = 2,46                }},47            },48            .overload = .{49                .kind = .reject_before_mutation,50                .detail = "full input preserves retained bytes and leaves foreign input unread",51            },52            .risks = .{53                .transitive = .{54                    .status = .open,55                    .detail = "request parsing and installed protocol callbacks own separate storage",56                },57                .foreign = .{58                    .status = .open,59                    .detail = "input admission reads from socket and kernel storage",60                },61            },62            .obligations = &.{63                .{ .key = "http_connection_input_capacity", .role = .capacity_model },64                .{ .key = "http_connection_input_oom_retry", .role = .custom },65                .{ .key = "http_connection_input_partition", .role = .custom },66                .{ .key = "http_connection_input_sealed", .role = .overload },67                .{ .key = "http_connection_input_partial", .role = .custom },68                .{ .key = "http_connection_input_pipeline", .role = .custom },69                .{ .key = "http_connection_input_overload", .role = .custom },70                .{ .key = "http_connection_input_accept", .role = .custom },71            },72        },73        .bindings = .{74            .owner = @This(),75            .seal = .{76                .family = alloc_phase.capacity.selector(@This().activate),77                .premise = .{78                    .class = .checked_semantic_fact,79                    .authority = .checker,80                },81            },82            .teardown = .{83                .family = alloc_phase.capacity.selector(@This().deinit),84                .premise = .{85                    .class = .checked_semantic_fact,86                    .authority = .checker,87                },88            },89        },90    };9192    pub fn init(allocator: std.mem.Allocator, limits: StorageLimits) InitError!InputStorage {93        const capacity = try StorageCapacity.derive(limits);94        const bytes = if (capacity.storage_bytes == 0)95            @as([]u8, &.{})96        else97            try allocator.alloc(u8, capacity.storage_bytes);98        return .{99            .phase = .initialization,100            .capacity = capacity,101            .bytes = bytes,102        };103    }104105    pub fn activate(self: *InputStorage) void {106        std.debug.assert(self.phase == .initialization);107        std.debug.assert(self.bytes.len == self.capacity.storage_bytes);108        self.phase = .steady;109    }110111    pub fn connection(self: *InputStorage, index: usize) Exhaustion![]u8 {112        std.debug.assert(self.phase == .steady);113        if (index >= self.capacity.connection_count) {114            return error.ConnectionCapacityExceeded;115        }116        const start = index * self.capacity.bytes_per_connection;117        return self.bytes[start..][0..self.capacity.bytes_per_connection];118    }119120    pub fn deinit(self: *InputStorage, allocator: std.mem.Allocator) void {121        std.debug.assert(self.phase != .teardown);122        std.debug.assert(self.bytes.len == self.capacity.storage_bytes);123        self.phase = .teardown;124        if (self.bytes.len != 0) allocator.free(self.bytes);125        self.bytes = &.{};126    }127};

1pub const ConnectionInputStorage = connection.InputStorage;