tiny.http.ClientOperationStorage

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 = std.mem.Allocator.Error || error{CapacityOverflow};1011    pub const claim: alloc_phase.capacity.Declaration = .{12        .source = .{13            .id = "http.client_operation_storage",14            .kind = .phase_static,15            .limit_source = .caller,16            .storage = .{17                .covered = &.{18                    .{19                        .id = "fixed_decoded_host_bytes_for_every_concurrent_client_operation",20                        .lifetime = .steady,21                        .detail = "fixed decoded host bytes for every concurrent client operation",22                    },23                    .{24                        .id = "normalized_request_target_bytes_for_every_client_operation",25                        .lifetime = .steady,26                        .detail = "normalized request-target bytes for every client operation",27                    },28                    .{29                        .id = "plain_socket_windows_for_every_client_operation",30                        .lifetime = .steady,31                        .detail = "plain-socket windows for every client operation",32                    },33                },34                .excluded = &.{35                    "TLS buffers, certificate bundles, sockets, DNS state, and kernel queues",36                    "borrowed request inputs, response storage, handlers, and handler output",37                },38            },39            .capacity = .{40                .inputs = &.{41                    alloc_phase.capacity.bindInput(Limits, "host_bytes_per_operation", "host_bytes_per_operation"),42                    alloc_phase.capacity.bindInput(Limits, "target_bytes_per_operation", "target_bytes_per_operation"),43                    alloc_phase.capacity.bindInput(Limits, "plain_read_bytes_per_operation", "plain_read_bytes_per_operation"),44                    alloc_phase.capacity.bindInput(Limits, "plain_write_bytes_per_operation", "plain_write_bytes_per_operation"),45                    alloc_phase.capacity.bindInput(Limits, "operation_count", "operation_count"),46                },47                .type_selectors = &.{},48                .nodes = &.{49                    .{ .input = 0 },50                    .{ .input = 1 },51                    .{ .input = 2 },52                    .{ .input = 3 },53                    .{ .add = .{ .left = 0, .right = 1 } },54                    .{ .add = .{ .left = 4, .right = 2 } },55                    .{ .add = .{ .left = 5, .right = 3 } },56                    .{ .input = 4 },57                    .{ .product = .{ .left = 7, .right = 6 } },58                },59                .assertions = &.{.{60                    .scope = .closure_total,61                    .measure = .retained,62                    .relation = .exact,63                    .expression = 8,64                }},65            },66            .overload = .{67                .kind = .terminal,68                .detail = "capacity exhaustion rejects before connection or output publication",69            },70            .risks = .{71                .transitive = .{72                    .status = .witnessed,73                    .detail = "URL preparation and request serialization allocate no storage",74                },75                .foreign = .{76                    .status = .excluded,77                    .detail = "TLS and operating-system network owners remain independent",78                },79            },80            .obligations = &.{81                .{ .key = "http_client_operation_capacity", .role = .capacity_model },82                .{ .key = "http_client_operation_oom_retry", .role = .custom },83                .{ .key = "http_client_operation_partition", .role = .custom },84                .{ .key = "http_client_operation_sealed", .role = .transitive_risk },85                .{ .key = "http_client_operation_boundary", .role = .custom },86                .{ .key = "http_client_operation_atomic", .role = .overload },87                .{ .key = "http_client_operation_network_overload", .role = .overload },88                .{ .key = "http_client_operation_network_foreign_risk", .role = .foreign_risk },89            },90        },91        .bindings = .{92            .owner = @This(),93            .seal = .{94                .family = alloc_phase.capacity.selector(@This().activate),95                .premise = .{96                    .class = .checked_semantic_fact,97                    .authority = .checker,98                },99            },100            .teardown = .{101                .family = alloc_phase.capacity.selector(@This().deinit),102                .premise = .{103                    .class = .checked_semantic_fact,104                    .authority = .checker,105                },106            },107        },108    };109110    pub fn init(allocator: std.mem.Allocator, limits: Limits) InitError!Storage {111        const capacity = try Capacity.derive(limits);112        const bytes = if (capacity.storage_bytes == 0)113            @as([]u8, &.{})114        else115            try allocator.alloc(u8, capacity.storage_bytes);116        std.debug.assert(bytes.len == capacity.storage_bytes);117        return .{118            .phase = .initialization,119            .capacity = capacity,120            .bytes = bytes,121        };122    }123124    pub fn activate(self: *Storage) void {125        std.debug.assert(self.phase == .initialization);126        std.debug.assert(self.bytes.len == self.capacity.storage_bytes);127        self.phase = .steady;128    }129130    pub fn operation(self: *Storage, index: usize) Exhaustion!Scratch {131        std.debug.assert(self.phase == .steady);132        if (index >= self.capacity.operation_count) {133            return error.ClientOperationCapacityExceeded;134        }135        const host_start = index * self.capacity.host_bytes_per_operation;136        const target_region_start = self.capacity.host_bytes;137        const target_start = target_region_start +138            index * self.capacity.target_bytes_per_operation;139        const plain_read_region_start = target_region_start + self.capacity.target_bytes;140        const plain_read_start = plain_read_region_start +141            index * self.capacity.plain_read_bytes_per_operation;142        const plain_write_region_start = plain_read_region_start + self.capacity.plain_read_bytes;143        const plain_write_start = plain_write_region_start +144            index * self.capacity.plain_write_bytes_per_operation;145        const plain_read_region = self.bytes[plain_read_start..];146        const plain_write_region = self.bytes[plain_write_start..];147        std.debug.assert(host_start <= self.capacity.host_bytes);148        std.debug.assert(target_start <= plain_read_region_start);149        std.debug.assert(plain_read_start <= plain_write_region_start);150        std.debug.assert(plain_write_start <= self.bytes.len);151        return .{152            .host = self.bytes[host_start..][0..self.capacity.host_bytes_per_operation],153            .target = self.bytes[target_start..][0..self.capacity.target_bytes_per_operation],154            .plain_read = plain_read_region[0..self.capacity.plain_read_bytes_per_operation],155            .plain_write = plain_write_region[0..self.capacity.plain_write_bytes_per_operation],156        };157    }158159    pub fn deinit(self: *Storage, allocator: std.mem.Allocator) void {160        std.debug.assert(self.phase != .teardown);161        std.debug.assert(self.bytes.len == self.capacity.storage_bytes);162        self.phase = .teardown;163        if (self.bytes.len != 0) allocator.free(self.bytes);164        self.bytes = &.{};165    }166};

1pub const ClientOperationStorage = client.OperationStorage;