tiny.http.RequestStorage

1pub const RequestStorage = struct {2    phase: alloc_phase.capacity.Phase,3    capacity: RequestStorageCapacity,4    bytes: []align(@alignOf(RequestHeader)) u8,56    pub const Limits: type = RequestStorageLimits;7    pub const Capacity: type = RequestStorageCapacity;8    pub const Exhaustion: type = RequestStorageExhaustion;9    pub const InitError = std.mem.Allocator.Error || error{CapacityOverflow};1011    pub const claim: alloc_phase.capacity.Declaration = .{12        .source = .{13            .id = "http.request_storage",14            .kind = .phase_static,15            .limit_source = .caller,16            .storage = .{17                .covered = &.{18                    .{19                        .id = "fixed_parsed_header_entry_region_for_every_request_slot",20                        .lifetime = .steady,21                        .detail = "fixed parsed-header entry region for every request slot",22                    },23                    .{24                        .id = "fixed_decoded_chunked_body_byte_region_for_every_request_slot",25                        .lifetime = .steady,26                        .detail = "fixed decoded chunked-body byte region for every request slot",27                    },28                },29                .excluded = &.{30                    "connection wire input and borrowed content-length bodies",31                    "response output, handlers, clients, TLS, sockets, and kernel queues",32                },33            },34            .capacity = .{35                .inputs = &.{36                    alloc_phase.capacity.bindInput(Limits, "request_count", "request_count"),37                    alloc_phase.capacity.bindInput(Limits, "header_count_per_request", "header_count_per_request"),38                    alloc_phase.capacity.bindInput(Limits, "body_bytes_per_request", "body_bytes_per_request"),39                },40                .type_selectors = &.{41                    alloc_phase.capacity.bindType(RequestHeader, "requestheader"),42                },43                .nodes = &.{44                    .{ .input = 0 },45                    .{ .input = 1 },46                    .{ .product = .{ .left = 0, .right = 1 } },47                    .{ .constant = 1 },48                    .{ .scale = .{ .node = 3, .coefficient = .{ .size_of_concrete_type = 0 } } },49                    .{ .product = .{ .left = 2, .right = 4 } },50                    .{ .input = 2 },51                    .{ .product = .{ .left = 0, .right = 6 } },52                    .{ .add = .{ .left = 5, .right = 7 } },53                },54                .assertions = &.{.{55                    .scope = .closure_total,56                    .measure = .retained,57                    .relation = .exact,58                    .expression = 8,59                }},60            },61            .overload = .{62                .kind = .reject_before_mutation,63                .detail = "header, line, and body surveys reject max plus one before populating request storage",64            },65            .risks = .{66                .transitive = .{67                    .status = .witnessed,68                    .detail = "request and chunk surveys allocate no storage after activation",69                },70                .foreign = .{71                    .status = .excluded,72                    .detail = "request parsing transforms caller-owned memory without I/O",73                },74            },75            .obligations = &.{76                .{ .key = "http_request_capacity", .role = .capacity_model },77                .{ .key = "http_request_oom_retry", .role = .custom },78                .{ .key = "http_request_partition", .role = .custom },79                .{ .key = "http_request_sealed", .role = .transitive_risk },80                .{ .key = "http_request_atomic_overload", .role = .overload },81                .{ .key = "http_request_atomic_foreign_risk", .role = .foreign_risk },82                .{ .key = "http_request_boundary", .role = .custom },83                .{ .key = "http_request_pipeline", .role = .custom },84            },85        },86        .bindings = .{87            .owner = @This(),88            .seal = .{89                .family = alloc_phase.capacity.selector(@This().activate),90                .premise = .{91                    .class = .checked_semantic_fact,92                    .authority = .checker,93                },94            },95            .teardown = .{96                .family = alloc_phase.capacity.selector(@This().deinit),97                .premise = .{98                    .class = .checked_semantic_fact,99                    .authority = .checker,100                },101            },102        },103    };104105    pub fn init(106        allocator: std.mem.Allocator,107        limits: RequestStorageLimits,108    ) InitError!RequestStorage {109        const capacity = try RequestStorageCapacity.derive(limits);110        const bytes = if (capacity.storage_bytes == 0)111            @as([]align(@alignOf(RequestHeader)) u8, &.{})112        else113            try allocator.alignedAlloc(114                u8,115                .of(RequestHeader),116                capacity.storage_bytes,117            );118        return .{119            .phase = .initialization,120            .capacity = capacity,121            .bytes = bytes,122        };123    }124125    pub fn activate(self: *RequestStorage) void {126        std.debug.assert(self.phase == .initialization);127        std.debug.assert(self.bytes.len == self.capacity.storage_bytes);128        self.phase = .steady;129    }130131    pub fn request(self: *RequestStorage, index: usize) Exhaustion!RequestScratch {132        std.debug.assert(self.phase == .steady);133        if (index >= self.capacity.request_count) return error.RequestCapacityExceeded;134        const all_headers = std.mem.bytesAsSlice(135            RequestHeader,136            self.bytes[0..self.capacity.header_bytes],137        );138        const header_start = index * self.capacity.header_count_per_request;139        const body_start = self.capacity.header_bytes +140            index * self.capacity.body_bytes_per_request;141        return .{142            .headers = all_headers[header_start..][0..self.capacity.header_count_per_request],143            .body = self.bytes[body_start..][0..self.capacity.body_bytes_per_request],144            .header_line_bytes = self.capacity.header_line_bytes,145        };146    }147148    pub fn deinit(self: *RequestStorage, allocator: std.mem.Allocator) void {149        std.debug.assert(self.phase != .teardown);150        std.debug.assert(self.bytes.len == self.capacity.storage_bytes);151        self.phase = .teardown;152        if (self.bytes.len != 0) allocator.free(self.bytes);153        self.bytes = &.{};154    }155};

1pub const RequestStorage = message.RequestStorage;