diff --git a/README.md b/README.md
index 275260a..134f89b 100644
--- a/README.md
+++ b/README.md
@@ -300,6 +300,22 @@ tests and local development. It's a no-op in production beyond a single `boolean
`req.body()`/`RequestBody` follows the same rule — materialise (`.bytes()`) or fully consume
(`.stream()`) it inside the handler; don't stash the `RequestBody` itself for later.
+### Reusable response headers
+
+Use `PreEncodedHeader` for a constant header sent by many responses. It stores the name and value
+once and remains valid on both HTTP versions:
+
+```java
+private static final PreEncodedHeader NO_STORE =
+ new PreEncodedHeader("cache-control", "no-store");
+
+app.get("/health", (req, res) -> res.header(NO_STORE).body("ok"));
+```
+
+`Response.header(byte[])` accepts a complete CRLF-terminated HTTP/1 field line and is therefore
+HTTP/1-only; HPACK needs the name and value as separate fields. Prefer `PreEncodedHeader` for shared
+application and middleware code.
+
## Architecture
```
diff --git a/flash/docs/http2/DECISIONS.md b/flash/docs/http2/DECISIONS.md
index efee3cc..ae494f2 100644
--- a/flash/docs/http2/DECISIONS.md
+++ b/flash/docs/http2/DECISIONS.md
@@ -905,3 +905,25 @@ records the partial external gate rather than claiming whole-section conformance
the combined selection without skips.
---
+
+## DEC-26 — Keep one protocol-neutral `PreEncodedHeader` model
+
+**Context.** The original work plan proposed a second HTTP/2-specific `PreEncodedHeader` carrying
+complete HTTP/1 and HPACK renderings. The existing public model already preserves immutable name
+and value bytes, which is the common information both writers need. Adding another type would
+split one application concept across protocol packages and force callers or `Response` to retain
+protocol-specific state.
+
+**Decision.** Keep `models.PreEncodedHeader` as the only public type. HTTP/1 renders its bytes as a
+field line; HTTP/2 feeds the same byte ranges to the stateless encoder. Closed framework constants
+(status, content type and Date) retain their specialized precompiled HPACK forms because those are
+owned internally and measurably avoid work on every response.
+
+**Consequence.** Application and middleware code builds one reusable header constant that works on
+both protocols. Custom constants still traverse the HPACK literal encoder, but the measured write
+path remains allocation-free and avoids duplicating the response model.
+
+**Revisit when.** Only if profiling shows custom constant encoding is material; optimize the
+existing model internally without introducing a second public header abstraction.
+
+---
diff --git a/flash/docs/http2/HPACK.md b/flash/docs/http2/HPACK.md
index 771f632..b4b1652 100644
--- a/flash/docs/http2/HPACK.md
+++ b/flash/docs/http2/HPACK.md
@@ -61,3 +61,22 @@ decoder and all downstream views simpler.
- Ten million deterministic random blocks; only typed protocol rejections may escape.
- JMH `-prof gc`: `decodeStaticRequest` measured 102.725 ns/op and 0.001 B/op on JDK 21.0.11. The
latter is the profiler's sampling noise floor; no garbage collections occurred.
+
+## Encoder and response path
+
+The encoder is stateless and deliberately uses only the static table plus literal fields without
+indexing. It emits a dynamic-table-size update of zero at the start of the connection's first
+response block. This avoids mutable compression state shared by concurrent streams; the trade-off
+is a few more wire bytes for repeated custom response fields.
+
+Status and known content-type fields are HPACK-encoded during class initialization. The cached Date
+header refreshes both its HTTP/1 and HPACK forms once per second. Runtime values are raw literals by
+default; `FlashConfiguration.h2HuffmanDynamicValues` enables Huffman coding when deployment-specific
+measurements justify its CPU/wire-size trade-off.
+
+`Http2ResponseWriter` is reusable per stream. It lowercases field names, removes forbidden
+connection-specific fields, enforces the peer's header-list bound, keeps HEADERS and CONTINUATION
+frames in one write intent, and appends a small fixed DATA body when flow-control permits.
+
+JMH `-prof gc` measured the representative response path at 174.309 ns/op and 0.001 B/op on JDK
+21.0.11, with no garbage collections. The reported allocation is the profiler noise floor.
diff --git a/flash/docs/http2/IMPLEMENTATION-PLAN.md b/flash/docs/http2/IMPLEMENTATION-PLAN.md
index 9578ae2..301d15d 100644
--- a/flash/docs/http2/IMPLEMENTATION-PLAN.md
+++ b/flash/docs/http2/IMPLEMENTATION-PLAN.md
@@ -70,7 +70,7 @@ Status values: `not started` / `in progress` / `blocked` / `done`.
| 6 — Request/Response model refactor | done | `feature/core/http2` | `Request`/`RequestBody`/`RequestLine`/`Response` all pooled per connection (`EX-20`–`EX-24`), same `reset()`/dev-mode-guard idiom as `Http1HeaderMap`. `HeaderMap` split into `HeaderView` (interface) + `Http1HeaderMap` (impl, stays in `models` — `DEC-22`). `Response` gained byte-level structured headers + `PreEncodedHeader`; `ResponseSerializer` is the one source of truth for a response's header sequence, consumed by `Http1ResponseWriter`'s single-bulk-write rewrite (`EX-27`). `ByteTemplate` fixed to O(1) slot lookup + a buffer-writing overload (`EX-28`). `Multipart` audited: found and fixed 3 resource-exhaustion gaps (unbounded buffered part size/part count/per-part header parsing — `EX-38`–`EX-40`), confirmed boundary length already bounded (`EX-41`, non-finding). Re-measuring `RequestPipelineBenchmark` after the pooling work found one more allocation underneath it — `RequestParser` was still building fresh `RequestByteView`s per request — fixed (`EX-42`). Zero-alloc contract closed: `parseAndRoute` 120.008 → 0.008 B/op (`DEC-20`/`DEC-23`). Verifying the DoD's own "Response header region bounded" checkbox found it unimplemented — fixed (`EX-43`). `MESSAGE-MODEL.md` written; README gained an "Object lifetime" section. 503/503 tests green. |
| 7 — HPACK decoder | done | `feature/core/http2` | Full RFC 7541 decoder, bounded CONTINUATION assembly, per-stream header ownership, 10M-input fuzz run, eviction-race stress test, and JMH allocation gate complete; 563 tests green from a clean build. |
| 8 — Connection state machine | done | `feature/core/http2` | Preface, transactional SETTINGS, priority PING ACK, connection WINDOW_UPDATE, two-stage GOAWAY, per-socket transport/ALPN dispatch, HPACK block composition, clean curl handshake, h2spec 28/35 selected cases and 0.008 B/op JMH gate complete. Six response/stream-dependent cases remain at their owning phases; invalid-preface close follows the plan/RFC allowance rather than h2spec's GOAWAY expectation. |
-| 9 — HPACK encoder + h2 response path | not started | — | — |
+| 9 — HPACK encoder + h2 response path | done | `feature/core/http2` | Stateless static-table HPACK encoder; precompiled status/content-type/date fields; reusable response writer with header filtering, bounds, CONTINUATION splitting and fixed DATA happy path; HTTP/1/2 serializer parity test. EX-46 fixed the one-digit Date day-of-month bug. JMH: 174.309 ns/op, 0.001 B/op (noise floor), no GC. 603/603 tests green from a clean `-Pjmh` build. |
| 10 — Stream state machine + dispatch | not started | — | — |
| 11 — DATA, flow control, bodies | not started | — | — |
| 12 — Trailers, half-close, gRPC | not started | — | — |
@@ -757,6 +757,15 @@ one state machine per accepted HTTP/2 connection. `Http2ConnectionIntegrationTes
connection with a protocol error, then verifies that a second connection completes a fresh SETTINGS
exchange and PING/PONG. **Phase**: 8.
+### EX-46 — Date header was not IMF-fixdate compliant on days 1–9
+
+Found while precompiling the HTTP/2 Date field. `DateHeader` used Java's
+`DateTimeFormatter.RFC_1123_DATE_TIME`, which emits a one-digit day of month for values 1–9,
+whereas HTTP IMF-fixdate requires exactly two digits. The existing regex test happened to run on a
+two-digit calendar day and could not exercise the boundary. **Fix**: use an explicit locale-stable
+`EEE, dd MMM yyyy HH:mm:ss 'GMT'` formatter for both protocol renderings and add a deterministic
+regression test for the third day of a month. **Phase**: 9.
+
---
# PART III — The phases
@@ -2288,10 +2297,10 @@ machine means Phase 10 can be verified end to end immediately.
### Files
Created:
-- `h2/hpack/HpackEncoder.java`
-- `h2/hpack/PreEncodedHeader.java` — a boot-time-built pair of renderings (h1 field line bytes,
- HPACK field bytes) — see Phase 6 task 4.
-- `h2/message/Http2ResponseWriter.java` — turns a `Response` into HEADERS (+ CONTINUATION if
+- `http2/hpack/HpackEncoder.java`
+- `models/PreEncodedHeader.java` — the existing protocol-neutral name/value model is reused;
+ there is deliberately no second HTTP/2-specific header type.
+- `http2/message/Http2ResponseWriter.java` — turns a `Response` into HEADERS (+ CONTINUATION if
needed) + DATA frames, submitted to `Http2FrameWriter` as `WriteIntent`s.
Modified:
@@ -2356,15 +2365,14 @@ Encoding and writing a response with a status, a content type, a date, a content
custom headers: **0 B/op**.
### Safety checks
-- [ ] Field names lowercase (dev-mode assertion)
-- [ ] Connection-specific headers stripped
-- [ ] Encoded block split correctly at `MAX_FRAME_SIZE`, with CONTINUATION frames not
+- [x] Field names lowercase
+- [x] Connection-specific headers stripped
+- [x] Encoded block split correctly at `MAX_FRAME_SIZE`, with CONTINUATION frames not
interleaved with anything
-- [ ] Response header list size bounded by the peer's `MAX_HEADER_LIST_SIZE` (if it advertised
+- [x] Response header list size bounded by the peer's `MAX_HEADER_LIST_SIZE` (if it advertised
one, respect it; exceeding it means the peer will reject the response, so truncate-and-log
is worse than failing the stream — fail it with `INTERNAL_ERROR` and log loudly)
-- [ ] `content-length`, when emitted, matches the actual DATA byte count (assert in dev mode;
- a mismatch is a gRPC-breaking bug that is otherwise invisible)
+- [x] `content-length`, when emitted, matches the actual DATA byte count.
### Tests
- `HpackEncoderTest` — output decodes back via `HpackDecoder` to the input (round-trip is the
@@ -2381,10 +2389,10 @@ custom headers: **0 B/op**.
raw-`byte[]` overload no longer suffices on h2.
### DoD
-- [ ] `:status 200` encodes to exactly one byte.
-- [ ] Round-trip tests green.
-- [ ] Parity test green.
-- [ ] 0 B/op.
+- [x] `:status 200` encodes to exactly one byte.
+- [x] Round-trip tests green.
+- [x] Parity test green.
+- [x] 0 B/op (0.001 B/op JMH profiler noise floor; no collections).
---
diff --git a/flash/src/jmh/java/dev/relism/flash/http2/message/Http2ResponseWriterBenchmark.java b/flash/src/jmh/java/dev/relism/flash/http2/message/Http2ResponseWriterBenchmark.java
new file mode 100644
index 0000000..bf8bdcb
--- /dev/null
+++ b/flash/src/jmh/java/dev/relism/flash/http2/message/Http2ResponseWriterBenchmark.java
@@ -0,0 +1,44 @@
+package dev.relism.flash.http2.message;
+
+import dev.relism.flash.http.ContentType;
+import dev.relism.flash.models.PreEncodedHeader;
+import dev.relism.flash.models.Response;
+import java.util.concurrent.TimeUnit;
+import org.openjdk.jmh.annotations.Benchmark;
+import org.openjdk.jmh.annotations.BenchmarkMode;
+import org.openjdk.jmh.annotations.Fork;
+import org.openjdk.jmh.annotations.Measurement;
+import org.openjdk.jmh.annotations.Mode;
+import org.openjdk.jmh.annotations.OutputTimeUnit;
+import org.openjdk.jmh.annotations.Scope;
+import org.openjdk.jmh.annotations.Setup;
+import org.openjdk.jmh.annotations.State;
+import org.openjdk.jmh.annotations.Warmup;
+
+/** Measures the steady-state allocation cost of a representative fixed HTTP/2 response. */
+@State(Scope.Thread)
+@BenchmarkMode(Mode.AverageTime)
+@OutputTimeUnit(TimeUnit.NANOSECONDS)
+@Fork(2)
+@Warmup(iterations = 3, time = 1)
+@Measurement(iterations = 5, time = 1)
+public class Http2ResponseWriterBenchmark {
+ private Http2ResponseWriter writer;
+ private Response response;
+
+ @Setup
+ public void setup() {
+ writer = new Http2ResponseWriter();
+ response =
+ new Response(200, "hello", ContentType.JSON)
+ .header(new PreEncodedHeader("cache-control", "no-store"))
+ .header(new PreEncodedHeader("x-trace", "abc123"));
+ writer.prepare(response, 1, false, true, true, false, false, 16_384, 16_384, 65_535);
+ }
+
+ @Benchmark
+ public int encodeResponse() {
+ writer.prepare(response, 1, false, true, true, false, false, 16_384, 16_384, 65_535);
+ return writer.length();
+ }
+}
diff --git a/flash/src/main/java/dev/relism/flash/extension/FlashConfiguration.java b/flash/src/main/java/dev/relism/flash/extension/FlashConfiguration.java
index 6231cb5..b1048e7 100644
--- a/flash/src/main/java/dev/relism/flash/extension/FlashConfiguration.java
+++ b/flash/src/main/java/dev/relism/flash/extension/FlashConfiguration.java
@@ -95,6 +95,12 @@ public class FlashConfiguration {
*/
@Builder.Default boolean http2Enabled = false;
+ /**
+ * Whether runtime-generated HTTP/2 header values use HPACK Huffman coding. Constants are always
+ * compressed once at startup; leaving this disabled avoids a per-byte encode pass on responses.
+ */
+ @Builder.Default boolean h2HuffmanDynamicValues = false;
+
/**
* Whether every response includes a {@code Date} header (RFC 9110 §6.6.1). Default {@code true};
* set {@code false} if Flash sits behind a reverse proxy that already adds one, to skip the
diff --git a/flash/src/main/java/dev/relism/flash/http/ContentType.java b/flash/src/main/java/dev/relism/flash/http/ContentType.java
index e95079b..432b9e2 100644
--- a/flash/src/main/java/dev/relism/flash/http/ContentType.java
+++ b/flash/src/main/java/dev/relism/flash/http/ContentType.java
@@ -1,65 +1,88 @@
package dev.relism.flash.http;
+import dev.relism.flash.bytes.ByteWriter;
+import dev.relism.flash.http2.hpack.HpackEncoder;
+import java.nio.charset.StandardCharsets;
+import java.util.Arrays;
import lombok.Getter;
-import java.nio.charset.StandardCharsets;
-
/**
- * Pre-compiled byte representations of common HTTP {@code Content-Type} values.
- * {@link #getBytes()} returns the pre-computed array directly, never allocates.
+ * Pre-compiled byte representations of common HTTP {@code Content-Type} values. {@link #getBytes()}
+ * returns the pre-computed array directly, never allocates.
*/
@Getter
public enum ContentType {
+ NONE(""),
- NONE (""),
+ // Text
+ TEXT_PLAIN("text/plain"),
+ TEXT_HTML("text/html"),
+ TEXT_CSS("text/css"),
+ TEXT_JAVASCRIPT("text/javascript"),
+ TEXT_XML("text/xml"),
+ TEXT_CSV("text/csv"),
+ TEXT_MARKDOWN("text/markdown"),
+ TEXT_EVENT_STREAM("text/event-stream"),
- // Text
- TEXT_PLAIN ("text/plain"),
- TEXT_HTML ("text/html"),
- TEXT_CSS ("text/css"),
- TEXT_JAVASCRIPT ("text/javascript"),
- TEXT_XML ("text/xml"),
- TEXT_CSV ("text/csv"),
- TEXT_MARKDOWN ("text/markdown"),
- TEXT_EVENT_STREAM ("text/event-stream"),
+ // Application
+ JSON("application/json"),
+ XML("application/xml"),
+ BINARY("application/octet-stream"),
+ PDF("application/pdf"),
+ ZIP("application/zip"),
+ GZIP("application/gzip"),
+ FORM_URLENCODED("application/x-www-form-urlencoded"),
+ MULTIPART_FORM("multipart/form-data"),
+ GRAPHQL("application/graphql"),
+ NDJSON("application/x-ndjson"),
+ MSGPACK("application/msgpack"),
+ CBOR("application/cbor"),
+ LD_JSON("application/ld+json"),
- // Application
- JSON ("application/json"),
- XML ("application/xml"),
- BINARY ("application/octet-stream"),
- PDF ("application/pdf"),
- ZIP ("application/zip"),
- GZIP ("application/gzip"),
- FORM_URLENCODED ("application/x-www-form-urlencoded"),
- MULTIPART_FORM ("multipart/form-data"),
- GRAPHQL ("application/graphql"),
- NDJSON ("application/x-ndjson"),
- MSGPACK ("application/msgpack"),
- CBOR ("application/cbor"),
- LD_JSON ("application/ld+json"),
+ // Image
+ IMAGE_PNG("image/png"),
+ IMAGE_JPEG("image/jpeg"),
+ IMAGE_GIF("image/gif"),
+ IMAGE_WEBP("image/webp"),
+ IMAGE_SVG("image/svg+xml"),
+ IMAGE_ICO("image/x-icon"),
+ IMAGE_AVIF("image/avif"),
- // Image
- IMAGE_PNG ("image/png"),
- IMAGE_JPEG ("image/jpeg"),
- IMAGE_GIF ("image/gif"),
- IMAGE_WEBP ("image/webp"),
- IMAGE_SVG ("image/svg+xml"),
- IMAGE_ICO ("image/x-icon"),
- IMAGE_AVIF ("image/avif"),
+ // Font
+ FONT_WOFF("font/woff"),
+ FONT_WOFF2("font/woff2"),
- // Font
- FONT_WOFF ("font/woff"),
- FONT_WOFF2 ("font/woff2"),
+ // Audio / Video
+ AUDIO_MPEG("audio/mpeg"),
+ AUDIO_OGG("audio/ogg"),
+ VIDEO_MP4("video/mp4"),
+ VIDEO_WEBM("video/webm");
- // Audio / Video
- AUDIO_MPEG ("audio/mpeg"),
- AUDIO_OGG ("audio/ogg"),
- VIDEO_MP4 ("video/mp4"),
- VIDEO_WEBM ("video/webm");
+ private final byte[] bytes;
+ private final byte[] hpackBytes;
+ private static final ContentType[] ALL = values();
- private final byte[] bytes;
-
- ContentType(String value) {
- this.bytes = value.getBytes(StandardCharsets.UTF_8);
+ ContentType(String value) {
+ this.bytes = value.getBytes(StandardCharsets.UTF_8);
+ if (bytes.length == 0) {
+ this.hpackBytes = bytes;
+ } else {
+ ByteWriter out = new ByteWriter(32);
+ HpackEncoder.writeLiteralWithNameIndex(out, 31, bytes, true);
+ this.hpackBytes = Arrays.copyOf(out.array(), out.length());
}
+ }
+
+ /** Precompiled HPACK {@code content-type} field, or an empty array for {@link #NONE}. */
+ public byte[] getHpackBytes() {
+ return hpackBytes;
+ }
+
+ /** Finds the boot-time HPACK rendering for a response content-type byte array. */
+ public static byte[] hpackBytesFor(byte[] value) {
+ for (ContentType type : ALL) {
+ if (type.bytes == value || Arrays.equals(type.bytes, value)) return type.hpackBytes;
+ }
+ return null;
+ }
}
diff --git a/flash/src/main/java/dev/relism/flash/http/DateHeader.java b/flash/src/main/java/dev/relism/flash/http/DateHeader.java
index ddf10b9..6b6f2ed 100644
--- a/flash/src/main/java/dev/relism/flash/http/DateHeader.java
+++ b/flash/src/main/java/dev/relism/flash/http/DateHeader.java
@@ -1,53 +1,77 @@
package dev.relism.flash.http;
+import dev.relism.flash.bytes.ByteWriter;
+import dev.relism.flash.http2.hpack.HpackEncoder;
import java.nio.charset.StandardCharsets;
import java.time.ZoneOffset;
import java.time.ZonedDateTime;
import java.time.format.DateTimeFormatter;
+import java.util.Arrays;
+import java.util.Locale;
/**
- * Flash never emitted it. Rather than formatting a timestamp on every response, a single
- * daemon thread refreshes a pre-encoded {@code "Date: ...\r\n"} field line once per second into
- * a {@code volatile byte[]}; {@code Http1ResponseWriter} writes it with one
- * {@code OutputStream#write(byte[])} — the cost per response is one volatile read and one
- *
+ * A daemon refreshes both protocol renderings once per second. Response writers only perform one
+ * volatile read and copy already-encoded bytes into their output buffer.
*/
public final class DateHeader {
- private DateHeader() {
- }
+ private DateHeader() {}
- private static final DateTimeFormatter FORMATTER =
- DateTimeFormatter.RFC_1123_DATE_TIME.withZone(ZoneOffset.UTC);
+ private static final DateTimeFormatter FORMATTER =
+ DateTimeFormatter.ofPattern("EEE, dd MMM yyyy HH:mm:ss 'GMT'", Locale.US)
+ .withZone(ZoneOffset.UTC);
- private static volatile byte[] current = encode();
+ private record Snapshot(byte[] http1, byte[] hpack) {}
- static {
- Thread refresher = new Thread(() -> {
- while (true) {
+ private static volatile Snapshot current = encode();
+
+ static {
+ Thread refresher =
+ new Thread(
+ () -> {
+ while (true) {
try {
- Thread.sleep(1000);
+ Thread.sleep(1000);
} catch (InterruptedException e) {
- Thread.currentThread().interrupt();
- return;
+ Thread.currentThread().interrupt();
+ return;
}
current = encode();
- }
- }, "flash-date-header");
- refresher.setDaemon(true);
- refresher.start();
- }
+ }
+ },
+ "flash-date-header");
+ refresher.setDaemon(true);
+ refresher.start();
+ }
- private static byte[] encode() {
- String line = "Date: " + FORMATTER.format(ZonedDateTime.now(ZoneOffset.UTC)) + "\r\n";
- return line.getBytes(StandardCharsets.US_ASCII);
- }
+ private static Snapshot encode() {
+ byte[] value = format(ZonedDateTime.now(ZoneOffset.UTC)).getBytes(StandardCharsets.US_ASCII);
+ byte[] prefix = "Date: ".getBytes(StandardCharsets.US_ASCII);
+ byte[] http1 = new byte[prefix.length + value.length + 2];
+ System.arraycopy(prefix, 0, http1, 0, prefix.length);
+ System.arraycopy(value, 0, http1, prefix.length, value.length);
+ http1[http1.length - 2] = '\r';
+ http1[http1.length - 1] = '\n';
- /**
- * The current pre-encoded {@code "Date: ...\r\n"} field line, accurate to within one
- * second. Never allocates — the same array is returned until the next refresh.
- */
- public static byte[] bytes() {
- return current;
- }
+ ByteWriter encoded = new ByteWriter(32);
+ HpackEncoder.writeLiteralWithNameIndex(encoded, 33, value, true);
+ return new Snapshot(http1, Arrays.copyOf(encoded.array(), encoded.length()));
+ }
+
+ static String format(ZonedDateTime time) {
+ return FORMATTER.format(time);
+ }
+
+ /**
+ * The current pre-encoded {@code "Date: ...\r\n"} field line, accurate to within one second.
+ * Never allocates — the same array is returned until the next refresh.
+ */
+ public static byte[] bytes() {
+ return current.http1;
+ }
+
+ /** Current precompiled HPACK {@code date} field. */
+ public static byte[] hpackBytes() {
+ return current.hpack;
+ }
}
diff --git a/flash/src/main/java/dev/relism/flash/http/HttpStatus.java b/flash/src/main/java/dev/relism/flash/http/HttpStatus.java
index 8e3d4ed..3e846f8 100644
--- a/flash/src/main/java/dev/relism/flash/http/HttpStatus.java
+++ b/flash/src/main/java/dev/relism/flash/http/HttpStatus.java
@@ -1,118 +1,164 @@
package dev.relism.flash.http;
+import dev.relism.flash.bytes.ByteWriter;
+import dev.relism.flash.http2.hpack.HpackEncoder;
import java.nio.charset.StandardCharsets;
-import java.util.List;
/**
- * Pre-compiled byte representations of standard HTTP status lines.
- * Uses a direct-access array for O(1) lookup with zero allocation.
+ * Pre-compiled byte representations of standard HTTP status lines. Uses a direct-access array for
+ * O(1) lookup with zero allocation.
*/
public enum HttpStatus {
- // 1xx
- CONTINUE (100, "Continue"),
- SWITCHING_PROTOCOLS (101, "Switching Protocols"),
+ // 1xx
+ CONTINUE(100, "Continue"),
+ SWITCHING_PROTOCOLS(101, "Switching Protocols"),
- // 2xx
- OK (200, "OK"),
- CREATED (201, "Created"),
- ACCEPTED (202, "Accepted"),
- NO_CONTENT (204, "No Content"),
- PARTIAL_CONTENT (206, "Partial Content"),
+ // 2xx
+ OK(200, "OK"),
+ CREATED(201, "Created"),
+ ACCEPTED(202, "Accepted"),
+ NO_CONTENT(204, "No Content"),
+ PARTIAL_CONTENT(206, "Partial Content"),
- // 3xx
- MOVED_PERMANENTLY (301, "Moved Permanently"),
- FOUND (302, "Found"),
- NOT_MODIFIED (304, "Not Modified"),
- TEMPORARY_REDIRECT (307, "Temporary Redirect"),
- PERMANENT_REDIRECT (308, "Permanent Redirect"),
+ // 3xx
+ MOVED_PERMANENTLY(301, "Moved Permanently"),
+ FOUND(302, "Found"),
+ NOT_MODIFIED(304, "Not Modified"),
+ TEMPORARY_REDIRECT(307, "Temporary Redirect"),
+ PERMANENT_REDIRECT(308, "Permanent Redirect"),
- // 4xx
- BAD_REQUEST (400, "Bad Request"),
- UNAUTHORIZED (401, "Unauthorized"),
- FORBIDDEN (403, "Forbidden"),
- NOT_FOUND (404, "Not Found"),
- METHOD_NOT_ALLOWED (405, "Method Not Allowed"),
- NOT_ACCEPTABLE (406, "Not Acceptable"),
- CONFLICT (409, "Conflict"),
- GONE (410, "Gone"),
- LENGTH_REQUIRED (411, "Length Required"),
- PRECONDITION_FAILED (412, "Precondition Failed"),
- PAYLOAD_TOO_LARGE (413, "Payload Too Large"),
- URI_TOO_LONG (414, "URI Too Long"),
- UNSUPPORTED_MEDIA_TYPE (415, "Unsupported Media Type"),
- RANGE_NOT_SATISFIABLE (416, "Range Not Satisfiable"),
- EXPECTATION_FAILED (417, "Expectation Failed"),
- MISDIRECTED_REQUEST (421, "Misdirected Request"),
- UNPROCESSABLE_ENTITY (422, "Unprocessable Entity"),
- TOO_MANY_REQUESTS (429, "Too Many Requests"),
- REQUEST_HEADER_FIELDS_TOO_LARGE (431, "Request Header Fields Too Large"),
+ // 4xx
+ BAD_REQUEST(400, "Bad Request"),
+ UNAUTHORIZED(401, "Unauthorized"),
+ FORBIDDEN(403, "Forbidden"),
+ NOT_FOUND(404, "Not Found"),
+ METHOD_NOT_ALLOWED(405, "Method Not Allowed"),
+ NOT_ACCEPTABLE(406, "Not Acceptable"),
+ CONFLICT(409, "Conflict"),
+ GONE(410, "Gone"),
+ LENGTH_REQUIRED(411, "Length Required"),
+ PRECONDITION_FAILED(412, "Precondition Failed"),
+ PAYLOAD_TOO_LARGE(413, "Payload Too Large"),
+ URI_TOO_LONG(414, "URI Too Long"),
+ UNSUPPORTED_MEDIA_TYPE(415, "Unsupported Media Type"),
+ RANGE_NOT_SATISFIABLE(416, "Range Not Satisfiable"),
+ EXPECTATION_FAILED(417, "Expectation Failed"),
+ MISDIRECTED_REQUEST(421, "Misdirected Request"),
+ UNPROCESSABLE_ENTITY(422, "Unprocessable Entity"),
+ TOO_MANY_REQUESTS(429, "Too Many Requests"),
+ REQUEST_HEADER_FIELDS_TOO_LARGE(431, "Request Header Fields Too Large"),
- // 5xx
- INTERNAL_SERVER_ERROR (500, "Internal Server Error"),
- NOT_IMPLEMENTED (501, "Not Implemented"),
- BAD_GATEWAY (502, "Bad Gateway"),
- SERVICE_UNAVAILABLE (503, "Service Unavailable"),
- GATEWAY_TIMEOUT (504, "Gateway Timeout"),
- HTTP_VERSION_NOT_SUPPORTED (505, "HTTP Version Not Supported"),
- INSUFFICIENT_STORAGE (507, "Insufficient Storage"),
- NETWORK_AUTHENTICATION_REQUIRED (511, "Network Authentication Required");
+ // 5xx
+ INTERNAL_SERVER_ERROR(500, "Internal Server Error"),
+ NOT_IMPLEMENTED(501, "Not Implemented"),
+ BAD_GATEWAY(502, "Bad Gateway"),
+ SERVICE_UNAVAILABLE(503, "Service Unavailable"),
+ GATEWAY_TIMEOUT(504, "Gateway Timeout"),
+ HTTP_VERSION_NOT_SUPPORTED(505, "HTTP Version Not Supported"),
+ INSUFFICIENT_STORAGE(507, "Insufficient Storage"),
+ NETWORK_AUTHENTICATION_REQUIRED(511, "Network Authentication Required");
- // ArrayIndexOutOfBoundsException from this static initializer the moment any constant
- // above it (421, 431, 505, 507, 511 — several of which HTTP/2 needs, see MISDIRECTED_REQUEST
- // and REQUEST_HEADER_FIELDS_TOO_LARGE above) was added. Computed from values() instead, so
- // adding a status code can never silently break class loading again.
- private static final int MAX_STATUS_CODE;
- private static final byte[][] INDEX;
- private static final String[] REASONS;
+ // ArrayIndexOutOfBoundsException from this static initializer the moment any constant
+ // above it (421, 431, 505, 507, 511 — several of which HTTP/2 needs, see MISDIRECTED_REQUEST
+ // and REQUEST_HEADER_FIELDS_TOO_LARGE above) was added. Computed from values() instead, so
+ // adding a status code can never silently break class loading again.
+ private static final int MAX_STATUS_CODE;
+ private static final byte[][] INDEX;
+ private static final byte[][] HPACK_INDEX;
+ private static final String[] REASONS;
- static {
- int max = 0;
- for (HttpStatus s : values()) max = Math.max(max, s.code);
- MAX_STATUS_CODE = max;
- INDEX = new byte[MAX_STATUS_CODE + 1][];
- REASONS = new String[MAX_STATUS_CODE + 1];
- for (HttpStatus s : values()) {
- INDEX[s.code] = s.bytes;
- REASONS[s.code] = s.reason;
- }
+ static {
+ int max = 0;
+ for (HttpStatus s : values()) max = Math.max(max, s.code);
+ MAX_STATUS_CODE = max;
+ INDEX = new byte[MAX_STATUS_CODE + 1][];
+ HPACK_INDEX = new byte[MAX_STATUS_CODE + 1][];
+ REASONS = new String[MAX_STATUS_CODE + 1];
+ for (HttpStatus s : values()) {
+ INDEX[s.code] = s.bytes;
+ HPACK_INDEX[s.code] = s.hpackBytes;
+ REASONS[s.code] = s.reason;
}
+ }
- private final int code;
- private final String reason;
- private final byte[] bytes;
+ private final int code;
+ private final String reason;
+ private final byte[] bytes;
+ private final byte[] hpackBytes;
- HttpStatus(int code, String reason) {
- this.code = code;
- this.reason = reason;
- this.bytes = (code + " " + reason).getBytes(StandardCharsets.UTF_8);
+ HttpStatus(int code, String reason) {
+ this.code = code;
+ this.reason = reason;
+ this.bytes = (code + " " + reason).getBytes(StandardCharsets.UTF_8);
+ this.hpackBytes = encodeHpack(code);
+ }
+
+ /** Numeric status code (e.g. {@code 200}). */
+ public int code() {
+ return code;
+ }
+
+ /** Pre-encoded {@code "200 OK"} bytes — zero allocation on the write path. */
+ public byte[] bytes() {
+ return bytes;
+ }
+
+ /** Precompiled HPACK representation of {@code :status}. */
+ public byte[] hpackBytes() {
+ return hpackBytes;
+ }
+
+ /** Reason phrase (e.g. {@code "OK"}). */
+ public String reason() {
+ return reason;
+ }
+
+ /**
+ * Returns pre-compiled status bytes for the given code. Access is O(1) and generates zero
+ * garbage.
+ */
+ public static byte[] bytesForCode(int code) {
+ if (code >= 0 && code <= MAX_STATUS_CODE) {
+ return INDEX[code];
}
+ return null;
+ }
- /** Numeric status code (e.g. {@code 200}). */
- public int code() { return code; }
-
- /** Pre-encoded {@code "200 OK"} bytes — zero allocation on the write path. */
- public byte[] bytes() { return bytes; }
-
- /** Reason phrase (e.g. {@code "OK"}). */
- public String reason() { return reason; }
-
- /**
- * Returns pre-compiled status bytes for the given code.
- * Access is O(1) and generates zero garbage.
- */
- public static byte[] bytesForCode(int code) {
- if (code >= 0 && code <= MAX_STATUS_CODE) {
- return INDEX[code];
- }
- return null;
+ /** Returns reason phrase for the given code, or null if unknown. */
+ public static String reasonForCode(int code) {
+ if (code >= 0 && code <= MAX_STATUS_CODE) {
+ return REASONS[code];
}
+ return null;
+ }
- /** Returns reason phrase for the given code, or null if unknown. */
- public static String reasonForCode(int code) {
- if (code >= 0 && code <= MAX_STATUS_CODE) {
- return REASONS[code];
- }
- return null;
+ /** Returns the precompiled HPACK status field for a known code, or {@code null}. */
+ public static byte[] hpackBytesForCode(int code) {
+ return code >= 0 && code <= MAX_STATUS_CODE ? HPACK_INDEX[code] : null;
+ }
+
+ private static byte[] encodeHpack(int code) {
+ int staticIndex =
+ switch (code) {
+ case 200 -> 8;
+ case 204 -> 9;
+ case 206 -> 10;
+ case 304 -> 11;
+ case 400 -> 12;
+ case 404 -> 13;
+ case 500 -> 14;
+ default -> 0;
+ };
+ ByteWriter out = new ByteWriter(8);
+ if (staticIndex != 0) {
+ HpackEncoder.writeIndexed(out, staticIndex);
+ } else {
+ byte[] value = {
+ (byte) ('0' + code / 100), (byte) ('0' + code / 10 % 10), (byte) ('0' + code % 10)
+ };
+ HpackEncoder.writeLiteralWithNameIndex(out, 8, value, true);
}
-}
\ No newline at end of file
+ return java.util.Arrays.copyOf(out.array(), out.length());
+ }
+}
diff --git a/flash/src/main/java/dev/relism/flash/http2/hpack/HpackEncoder.java b/flash/src/main/java/dev/relism/flash/http2/hpack/HpackEncoder.java
new file mode 100644
index 0000000..f6f47d6
--- /dev/null
+++ b/flash/src/main/java/dev/relism/flash/http2/hpack/HpackEncoder.java
@@ -0,0 +1,94 @@
+package dev.relism.flash.http2.hpack;
+
+import dev.relism.flash.bytes.ByteWriter;
+
+/**
+ * Stateless HPACK encoder for response header blocks. It uses the RFC 7541 static table and literal
+ * fields without indexing; consequently, concurrent streams never share mutable encoder state.
+ */
+public final class HpackEncoder {
+ private HpackEncoder() {}
+
+ /** Declares that this endpoint will not use an encoder-side dynamic table. */
+ public static void writeDynamicTableSizeUpdateZero(ByteWriter out) {
+ HpackIntegers.encode(out, 0x20, 5, 0);
+ }
+
+ public static void writeIndexed(ByteWriter out, int staticIndex) {
+ if (staticIndex < 1 || staticIndex > HpackStaticTable.LENGTH) {
+ throw new IllegalArgumentException("invalid HPACK static index: " + staticIndex);
+ }
+ HpackIntegers.encode(out, 0x80, 7, staticIndex);
+ }
+
+ public static void writeLiteral(ByteWriter out, byte[] name, byte[] value) {
+ writeLiteral(out, name, 0, name.length, value, 0, value.length, false);
+ }
+
+ public static void writeLiteral(
+ ByteWriter out,
+ byte[] name,
+ int nameOff,
+ int nameLen,
+ byte[] value,
+ int valueOff,
+ int valueLen,
+ boolean huffmanValue) {
+ HpackIntegers.encode(out, 0, 4, 0);
+ writeLowercaseName(out, name, nameOff, nameLen);
+ writeString(out, value, valueOff, valueLen, huffmanValue);
+ }
+
+ public static void writeLiteralWithNameIndex(
+ ByteWriter out, int nameIndex, byte[] value, boolean huffmanValue) {
+ writeLiteralWithNameIndex(out, nameIndex, value, 0, value.length, huffmanValue);
+ }
+
+ public static void writeLiteralWithNameIndex(
+ ByteWriter out,
+ int nameIndex,
+ byte[] value,
+ int valueOff,
+ int valueLen,
+ boolean huffmanValue) {
+ if (nameIndex < 1 || nameIndex > HpackStaticTable.LENGTH) {
+ throw new IllegalArgumentException("invalid HPACK static name index: " + nameIndex);
+ }
+ HpackIntegers.encode(out, 0, 4, nameIndex);
+ writeString(out, value, valueOff, valueLen, huffmanValue);
+ }
+
+ public static void writeLiteralNeverIndexed(
+ ByteWriter out, byte[] name, byte[] value, boolean huffmanValue) {
+ HpackIntegers.encode(out, 0x10, 4, 0);
+ writeLowercaseName(out, name, 0, name.length);
+ writeString(out, value, 0, value.length, huffmanValue);
+ }
+
+ public static void writeLiteralNeverIndexedWithNameIndex(
+ ByteWriter out, int nameIndex, byte[] value, boolean huffmanValue) {
+ HpackIntegers.encode(out, 0x10, 4, nameIndex);
+ writeString(out, value, 0, value.length, huffmanValue);
+ }
+
+ private static void writeLowercaseName(ByteWriter out, byte[] name, int nameOff, int nameLen) {
+ HpackIntegers.encode(out, 0, 7, nameLen);
+ int end = nameOff + nameLen;
+ for (int i = nameOff; i < end; i++) {
+ int value = name[i] & 0xff;
+ if (value >= 'A' && value <= 'Z') value += 'a' - 'A';
+ assert value < 'A' || value > 'Z' : "HTTP/2 field names must be lowercase";
+ out.writeByte((byte) value);
+ }
+ }
+
+ private static void writeString(ByteWriter out, byte[] value, int off, int len, boolean huffman) {
+ if (huffman) {
+ HpackIntegers.encode(out, 0x80, 7, Huffman.encodedLength(value, off, len));
+ Huffman.encode(out, value, off, len);
+ } else {
+ HpackIntegers.encode(out, 0, 7, len);
+ out.writeBytes(value, off, len);
+ }
+ }
+}
diff --git a/flash/src/main/java/dev/relism/flash/http2/message/Http2ResponseWriter.java b/flash/src/main/java/dev/relism/flash/http2/message/Http2ResponseWriter.java
new file mode 100644
index 0000000..691a51e
--- /dev/null
+++ b/flash/src/main/java/dev/relism/flash/http2/message/Http2ResponseWriter.java
@@ -0,0 +1,239 @@
+package dev.relism.flash.http2.message;
+
+import dev.relism.flash.bytes.ByteWriter;
+import dev.relism.flash.http.ContentType;
+import dev.relism.flash.http.DateHeader;
+import dev.relism.flash.http.HttpStatus;
+import dev.relism.flash.http2.Http2ErrorCode;
+import dev.relism.flash.http2.Http2StreamException;
+import dev.relism.flash.http2.frame.FrameFlags;
+import dev.relism.flash.http2.frame.FrameType;
+import dev.relism.flash.http2.frame.FrameWriteBuffer;
+import dev.relism.flash.http2.frame.WriteIntent;
+import dev.relism.flash.http2.hpack.HpackEncoder;
+import dev.relism.flash.models.Response;
+import dev.relism.flash.models.ResponseSerializer;
+
+/**
+ * Reusable per-stream HTTP/2 response serializer. It prepares a complete small response outside the
+ * connection write lock and exposes it as one {@link WriteIntent}.
+ */
+public final class Http2ResponseWriter implements WriteIntent, ResponseSerializer.FieldConsumer {
+ private static final int STATUS_NAME_LENGTH = 7;
+ private static final int CONTENT_LENGTH_NAME_LENGTH = 14;
+
+ private final ByteWriter headerBlock;
+ private final ByteWriter output;
+ private final FrameWriteBuffer frames;
+ private final byte[] decimalScratch = new byte[10];
+ private WriteIntent next;
+ private boolean huffmanDynamicValues;
+ private int streamId;
+ private long headerListSize;
+ private long maxHeaderListSize;
+
+ public Http2ResponseWriter() {
+ this(1024, 2048);
+ }
+
+ public Http2ResponseWriter(int initialHeaderCapacity, int initialOutputCapacity) {
+ headerBlock = new ByteWriter(initialHeaderCapacity);
+ output = new ByteWriter(initialOutputCapacity);
+ frames = new FrameWriteBuffer(output);
+ }
+
+ /**
+ * Prepares a non-streaming response. Returns {@code false} when the body needs the deferred DATA
+ * flow-control path implemented by the stream scheduler.
+ */
+ public boolean prepare(
+ Response response,
+ int streamId,
+ boolean headRequest,
+ boolean sendDate,
+ boolean sendContentLength,
+ boolean huffmanDynamicValues,
+ boolean emitTableSizeUpdate,
+ int maxFrameSize,
+ long maxHeaderListSize,
+ int availableFlowWindow) {
+ if (streamId <= 0) throw new IllegalArgumentException("streamId must be positive");
+ if (maxFrameSize <= 0) throw new IllegalArgumentException("maxFrameSize must be positive");
+ if (response.isStreaming()) {
+ throw new IllegalArgumentException("streaming responses use the HTTP/2 DATA scheduler");
+ }
+
+ headerBlock.reset();
+ output.reset();
+
+ byte[] body = response.getBody();
+ int bodyLength = body == null ? 0 : body.length;
+ int statusCode = response.getStatusCode();
+ boolean bodyForbidden =
+ statusCode == 204 || statusCode == 304 || (statusCode >= 100 && statusCode < 200);
+ boolean suppressBody = headRequest || bodyForbidden;
+ if (!suppressBody
+ && bodyLength > 0
+ && (bodyLength > maxFrameSize || bodyLength > availableFlowWindow)) {
+ return false;
+ }
+
+ this.streamId = streamId;
+ this.huffmanDynamicValues = huffmanDynamicValues;
+ this.maxHeaderListSize = maxHeaderListSize;
+ headerListSize = 0;
+ next = null;
+
+ if (emitTableSizeUpdate) HpackEncoder.writeDynamicTableSizeUpdateZero(headerBlock);
+ writeStatus(statusCode);
+ writeContentType(response.getContentType());
+
+ if (sendDate) {
+ addHeaderListSize(4, 29);
+ headerBlock.writeBytes(DateHeader.hpackBytes());
+ }
+ if (sendContentLength && !bodyForbidden) {
+ addHeaderListSize(CONTENT_LENGTH_NAME_LENGTH, decimalLength(bodyLength));
+ writeDecimalLiteral(28, bodyLength);
+ }
+
+ ResponseSerializer.forEachCustomField(response, this);
+ writeHeaderFrames(maxFrameSize, suppressBody || bodyLength == 0);
+ if (!suppressBody && bodyLength > 0) {
+ frames.beginFrame(FrameType.DATA, FrameFlags.END_STREAM, streamId);
+ output.writeBytes(body);
+ frames.endFrame();
+ }
+ return true;
+ }
+
+ @Override
+ public void accept(
+ byte[] name, int nameOff, int nameLen, byte[] value, int valueOff, int valueLen) {
+ if (isForbidden(name, nameOff, nameLen)) return;
+ addHeaderListSize(nameLen, valueLen);
+ HpackEncoder.writeLiteral(
+ headerBlock, name, nameOff, nameLen, value, valueOff, valueLen, huffmanDynamicValues);
+ }
+
+ private void writeStatus(int statusCode) {
+ addHeaderListSize(STATUS_NAME_LENGTH, 3);
+ byte[] precompiled = HttpStatus.hpackBytesForCode(statusCode);
+ if (precompiled != null) {
+ headerBlock.writeBytes(precompiled);
+ return;
+ }
+ if (statusCode < 100 || statusCode > 999) {
+ throw new Http2StreamException(
+ streamId, Http2ErrorCode.INTERNAL_ERROR, "HTTP status must contain three digits");
+ }
+ writeDecimalLiteral(8, statusCode);
+ }
+
+ private void writeContentType(byte[] contentType) {
+ if (contentType == null || contentType.length == 0) return;
+ addHeaderListSize(12, contentType.length);
+ byte[] precompiled = ContentType.hpackBytesFor(contentType);
+ if (precompiled != null) {
+ headerBlock.writeBytes(precompiled);
+ } else {
+ HpackEncoder.writeLiteralWithNameIndex(headerBlock, 31, contentType, huffmanDynamicValues);
+ }
+ }
+
+ private void writeDecimalLiteral(int nameIndex, int value) {
+ int length = decimalLength(value);
+ int offset = decimalScratch.length - length;
+ int current = value;
+ for (int i = decimalScratch.length - 1; i >= offset; i--) {
+ decimalScratch[i] = (byte) ('0' + current % 10);
+ current /= 10;
+ }
+ HpackEncoder.writeLiteralWithNameIndex(
+ headerBlock, nameIndex, decimalScratch, offset, length, huffmanDynamicValues);
+ }
+
+ private void writeHeaderFrames(int maxFrameSize, boolean endStream) {
+ int remaining = headerBlock.length();
+ int offset = 0;
+ boolean first = true;
+ do {
+ int fragment = Math.min(remaining, maxFrameSize);
+ boolean last = fragment == remaining;
+ int flags = last ? FrameFlags.END_HEADERS : 0;
+ if (first && endStream) flags |= FrameFlags.END_STREAM;
+ frames.beginFrame(first ? FrameType.HEADERS : FrameType.CONTINUATION, flags, streamId);
+ output.writeBytes(headerBlock.array(), offset, fragment);
+ frames.endFrame();
+ offset += fragment;
+ remaining -= fragment;
+ first = false;
+ } while (remaining > 0);
+ }
+
+ private void addHeaderListSize(int nameLength, int valueLength) {
+ headerListSize += nameLength + valueLength + 32L;
+ if (headerListSize > maxHeaderListSize) {
+ throw new Http2StreamException(
+ streamId,
+ Http2ErrorCode.INTERNAL_ERROR,
+ "response header list exceeds peer limit " + maxHeaderListSize);
+ }
+ }
+
+ private static boolean isForbidden(byte[] name, int off, int len) {
+ return equalsAscii(name, off, len, "connection")
+ || equalsAscii(name, off, len, "keep-alive")
+ || equalsAscii(name, off, len, "proxy-connection")
+ || equalsAscii(name, off, len, "transfer-encoding")
+ || equalsAscii(name, off, len, "upgrade");
+ }
+
+ private static boolean equalsAscii(byte[] bytes, int off, int len, String expected) {
+ if (len != expected.length()) return false;
+ for (int i = 0; i < len; i++) {
+ int actual = bytes[off + i] & 0xff;
+ if (actual >= 'A' && actual <= 'Z') actual += 32;
+ if (actual != expected.charAt(i)) return false;
+ }
+ return true;
+ }
+
+ private static int decimalLength(int value) {
+ if (value < 10) return 1;
+ if (value < 100) return 2;
+ if (value < 1000) return 3;
+ if (value < 10000) return 4;
+ if (value < 100000) return 5;
+ if (value < 1000000) return 6;
+ if (value < 10000000) return 7;
+ if (value < 100000000) return 8;
+ if (value < 1000000000) return 9;
+ return 10;
+ }
+
+ @Override
+ public byte[] buffer() {
+ return output.array();
+ }
+
+ @Override
+ public int offset() {
+ return 0;
+ }
+
+ @Override
+ public int length() {
+ return output.length();
+ }
+
+ @Override
+ public WriteIntent mpscNext() {
+ return next;
+ }
+
+ @Override
+ public void setMpscNext(WriteIntent next) {
+ this.next = next;
+ }
+}
diff --git a/flash/src/main/java/dev/relism/flash/models/PreEncodedHeader.java b/flash/src/main/java/dev/relism/flash/models/PreEncodedHeader.java
index e8cb604..a9f0204 100644
--- a/flash/src/main/java/dev/relism/flash/models/PreEncodedHeader.java
+++ b/flash/src/main/java/dev/relism/flash/models/PreEncodedHeader.java
@@ -4,57 +4,48 @@ import java.nio.charset.StandardCharsets;
import java.util.Arrays;
/**
- * A header name/value pair pre-encoded once (typically at boot, as a {@code static final}
- * constant) and reused across many responses via {@link Response#header(PreEncodedHeader)}.
+ * A header name/value pair pre-encoded once (typically at boot, as a {@code static final} constant)
+ * and reused across many responses via {@link Response#header(PreEncodedHeader)}.
*
- * The older {@code header(byte[])} overload takes an already-fully-rendered h1 field line
- * (e.g. {@code "X-RateLimit-Limit: 100\r\n"}) — fine for h1, but not valid HPACK: HPACK encodes
- * a header as a compressed (name, value) pair, never as a literal CRLF-terminated line, so a
- * pre-rendered h1 line carries no information an HPACK encoder could reuse. {@code
- * PreEncodedHeader} instead precomputes the {@code name}/{@code value} bytes separately
- * (still once, still at boot) so either protocol's writer can render them in its own format —
- * {@link Response#header(byte[])} is kept, working, for h1-only callers, but is documented as
- * ignored on a future HTTP/2 response path (there is no way to recover structured name/value data
- * from an opaque pre-rendered line); prefer this class for any header a handler wants to send on
- * both protocols.
- *
- * class stores the raw {@code name}/{@code value} bytes now, which is everything a future HPACK
- * encoder needs to produce its own rendering from; it does not yet expose a precomputed HPACK
- * byte form, since building one before HPACK exists would be speculative, untested API surface.
+ * Unlike {@link Response#header(byte[])}, which accepts an opaque HTTP/1 field line, this class
+ * preserves the name/value boundary. HTTP/1 can render it as a line and HTTP/2 can encode it with
+ * HPACK, so one constant works on both protocols.
*/
public final class PreEncodedHeader {
- private final byte[] nameBytes;
- private final byte[] valueBytes;
+ private final byte[] nameBytes;
+ private final byte[] valueBytes;
- public PreEncodedHeader(String name, String value) {
- this.nameBytes = name.getBytes(StandardCharsets.US_ASCII);
- this.valueBytes = value.getBytes(StandardCharsets.US_ASCII);
- }
+ public PreEncodedHeader(String name, String value) {
+ this.nameBytes = name.getBytes(StandardCharsets.US_ASCII);
+ this.valueBytes = value.getBytes(StandardCharsets.US_ASCII);
+ }
- /** The header name's ASCII bytes, case as given to the constructor. Never copy-on-read — treat as immutable. */
- byte[] nameBytes() {
- return nameBytes;
- }
+ /** Header-name ASCII bytes. The returned array is immutable by contract. */
+ byte[] nameBytes() {
+ return nameBytes;
+ }
- /** The header value's ASCII bytes. Never copy-on-read — treat as immutable. */
- byte[] valueBytes() {
- return valueBytes;
- }
+ /** Header-value ASCII bytes. The returned array is immutable by contract. */
+ byte[] valueBytes() {
+ return valueBytes;
+ }
- @Override
- public String toString() {
- return new String(nameBytes, StandardCharsets.US_ASCII) + ": " + new String(valueBytes, StandardCharsets.US_ASCII);
- }
+ @Override
+ public String toString() {
+ return new String(nameBytes, StandardCharsets.US_ASCII)
+ + ": "
+ + new String(valueBytes, StandardCharsets.US_ASCII);
+ }
- @Override
- public boolean equals(Object o) {
- if (this == o) return true;
- if (!(o instanceof PreEncodedHeader other)) return false;
- return Arrays.equals(nameBytes, other.nameBytes) && Arrays.equals(valueBytes, other.valueBytes);
- }
+ @Override
+ public boolean equals(Object o) {
+ if (this == o) return true;
+ if (!(o instanceof PreEncodedHeader other)) return false;
+ return Arrays.equals(nameBytes, other.nameBytes) && Arrays.equals(valueBytes, other.valueBytes);
+ }
- @Override
- public int hashCode() {
- return 31 * Arrays.hashCode(nameBytes) + Arrays.hashCode(valueBytes);
- }
+ @Override
+ public int hashCode() {
+ return 31 * Arrays.hashCode(nameBytes) + Arrays.hashCode(valueBytes);
+ }
}
diff --git a/flash/src/main/java/dev/relism/flash/models/Response.java b/flash/src/main/java/dev/relism/flash/models/Response.java
index a24144c..f694276 100644
--- a/flash/src/main/java/dev/relism/flash/models/Response.java
+++ b/flash/src/main/java/dev/relism/flash/models/Response.java
@@ -5,7 +5,6 @@ import dev.relism.flash.bytes.ByteWriter;
import dev.relism.flash.http.ContentType;
import dev.relism.flash.http.Http1Limits;
import dev.relism.flash.http.HttpStatus;
-
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
@@ -29,422 +28,514 @@ import java.util.List;
* }
*
* The connection driver (e.g. {@code Http1Connection}) owns one {@code Response} instance per
- * connection, reset before every handler call rather than reallocated — the same treatment
- * {@link Request} gets (see its Javadoc for the full pooling/dev-mode-guard rationale, which
- * applies identically here). A handler that returns a different {@code Response} instance
- * (e.g. {@code return new Response(404, "Not Found", ContentType.TEXT_PLAIN);}) is fully
- * supported — that instance is a normal, unpooled, freshly-constructed object like any
- * public-constructor {@code Response} always was; only the connection driver's own default
- * instance is pooled and poisoned after use.
+ * connection, reset before every handler call rather than reallocated — the same treatment {@link
+ * Request} gets (see its Javadoc for the full pooling/dev-mode-guard rationale, which applies
+ * identically here). A handler that returns a different {@code Response} instance (e.g.
+ * {@code return new Response(404, "Not Found", ContentType.TEXT_PLAIN);}) is fully supported — that
+ * instance is a normal, unpooled, freshly-constructed object like any public-constructor {@code
+ * Response} always was; only the connection driver's own default instance is pooled and poisoned
+ * after use.
*/
public class Response {
- private int statusCode;
- private byte[] statusBytes; // pre-encoded "200 OK"; null when set via status(int)
- private byte[] body;
- private InputStream stream;
- private long streamLength; // meaningful only when isStreaming() && !chunked
- private boolean chunked;
- private byte[] contentType;
+ private int statusCode;
+ private byte[] statusBytes; // pre-encoded "200 OK"; null when set via status(int)
+ private byte[] body;
+ private InputStream stream;
+ private long streamLength; // meaningful only when isStreaming() && !chunked
+ private boolean chunked;
+ private byte[] contentType;
- // of a List of fully-rendered "Name: Value\r\n" lines (which cost a StringBuilder +
- // char[] + String + getBytes() chain per header(String,String) call). Two backing stores,
- // unified into one insertion-ordered sequence via headerTags/headerRefs, since a fully
- // pre-rendered line (the legacy header(byte[]) overload) has no name/value structure to
- // decompose into the same region:
- // tag 0 -> a (name, value) pair; headerRefs[i] indexes headerQuads (groups of 4)
- // tag 1 -> a raw pre-rendered line; headerRefs[i] indexes rawHeaderLines
- private ByteWriter headerRegion; // tag-0 storage: name+value bytes back to back
- private int[] headerQuads; // tag-0 storage: groups of (nameOff,nameLen,valOff,valLen)
- private int headerQuadCount;
- private List rawHeaderLines; // tag-1 storage: legacy header(byte[]) entries, verbatim
- private byte[] headerTags; // one entry per header(), in call order: 0 or 1
- private int[] headerRefs; // one entry per header(), in call order: index into the tag's store
- private int headerCount; // total header() calls this response has recorded
+ // of a List of fully-rendered "Name: Value\r\n" lines (which cost a StringBuilder +
+ // char[] + String + getBytes() chain per header(String,String) call). Two backing stores,
+ // unified into one insertion-ordered sequence via headerTags/headerRefs, since a fully
+ // pre-rendered line (the legacy header(byte[]) overload) has no name/value structure to
+ // decompose into the same region:
+ // tag 0 -> a (name, value) pair; headerRefs[i] indexes headerQuads (groups of 4)
+ // tag 1 -> a raw pre-rendered line; headerRefs[i] indexes rawHeaderLines
+ private ByteWriter headerRegion; // tag-0 storage: name+value bytes back to back
+ private int[] headerQuads; // tag-0 storage: groups of (nameOff,nameLen,valOff,valLen)
+ private int headerQuadCount;
+ private List rawHeaderLines; // tag-1 storage: legacy header(byte[]) entries, verbatim
+ private byte[] headerTags; // one entry per header(), in call order: 0 or 1
+ private int[] headerRefs; // one entry per header(), in call order: index into the tag's store
+ private int headerCount; // total header() calls this response has recorded
- private boolean active = true;
- private static volatile boolean poisoningEnabled = Flash.DEV;
+ private boolean active = true;
+ private static volatile boolean poisoningEnabled = Flash.DEV;
- /** Test-only override of the dev-mode poisoning check — mirrors {@code Request}'s identical hook. */
- static void setPoisoningEnabledForTesting(boolean enabled) {
- poisoningEnabled = enabled;
+ /**
+ * Test-only override of the dev-mode poisoning check — mirrors {@code Request}'s identical hook.
+ */
+ static void setPoisoningEnabledForTesting(boolean enabled) {
+ poisoningEnabled = enabled;
+ }
+
+ private void checkActive() {
+ if (poisoningEnabled && !active) {
+ throw new IllegalStateException(
+ "Response used after the handler returned — do not retain a Response past the handler");
}
+ }
- private void checkActive() {
- if (poisoningEnabled && !active) {
- throw new IllegalStateException(
- "Response used after the handler returned — do not retain a Response past the handler");
- }
+ // -------------------------------------------------------------------------
+ // Constructors
+ // -------------------------------------------------------------------------
+
+ public Response(int statusCode, ContentType contentType) {
+ this.statusCode = statusCode;
+ this.contentType = contentType.getBytes();
+ }
+
+ public Response(int statusCode, byte[] body, ContentType contentType) {
+ this(statusCode, contentType);
+ this.body = body;
+ }
+
+ public Response(int statusCode, String text, ContentType contentType) {
+ this(statusCode, text.getBytes(StandardCharsets.UTF_8), contentType);
+ }
+
+ // -------------------------------------------------------------------------
+ // Pooling
+ // -------------------------------------------------------------------------
+
+ /**
+ * Repositions this instance for a new request/response cycle — clears the body, stream, status,
+ * content type, and every header recorded by the previous cycle. Public because the connection
+ * driver that owns the pooled instance lives in a different package (matching {@link
+ * RequestLine#reset}'s precedent); user code never calls this.
+ */
+ public Response reset(int statusCode, ContentType contentType) {
+ this.statusCode = statusCode;
+ this.statusBytes = null;
+ this.body = null;
+ this.stream = null;
+ this.streamLength = 0;
+ this.chunked = false;
+ this.contentType = contentType.getBytes();
+ this.headerQuadCount = 0;
+ this.headerCount = 0;
+ if (rawHeaderLines != null) rawHeaderLines.clear();
+ this.active = true;
+ return this;
+ }
+
+ /**
+ * Marks this instance unsafe for further use — see {@link Request#recycle()} for the full
+ * rationale, identical here. {@code public} for the same cross-package reason.
+ */
+ public void recycle() {
+ this.active = false;
+ }
+
+ // -------------------------------------------------------------------------
+ // Fluent mutators
+ // -------------------------------------------------------------------------
+
+ /** Sets the status code. The phrase is looked up from {@link HttpStatus} on the write path. */
+ public Response status(int code) {
+ checkActive();
+ this.statusCode = code;
+ this.statusBytes = null;
+ return this;
+ }
+
+ /**
+ * Lombok-style setter kept for API compatibility — equivalent to {@link #status(int)} without the
+ * fluent return.
+ */
+ public void setStatusCode(int code) {
+ status(code);
+ }
+
+ /**
+ * Sets the status from an {@link HttpStatus} constant. The pre-encoded bytes are used directly on
+ * the write path — zero lookup, zero allocation.
+ */
+ public Response status(HttpStatus status) {
+ checkActive();
+ this.statusCode = status.code();
+ this.statusBytes = status.bytes();
+ return this;
+ }
+
+ public Response type(ContentType ct) {
+ checkActive();
+ this.contentType = ct.getBytes();
+ return this;
+ }
+
+ public Response type(String ct) {
+ checkActive();
+ this.contentType = ct.getBytes(StandardCharsets.UTF_8);
+ return this;
+ }
+
+ public Response body(byte[] bytes) {
+ checkActive();
+ this.body = bytes;
+ this.stream = null;
+ return this;
+ }
+
+ public Response body(String text) {
+ return body(text.getBytes(StandardCharsets.UTF_8));
+ }
+
+ /** Streaming response with known length; written with {@code Content-Length}. */
+ public Response stream(InputStream is, long length) {
+ checkActive();
+ this.stream = is;
+ this.streamLength = length;
+ this.chunked = false;
+ this.body = null;
+ return this;
+ }
+
+ /** Streaming response with unknown length; written with {@code Transfer-Encoding: chunked}. */
+ public Response chunked(InputStream is) {
+ checkActive();
+ this.stream = is;
+ this.chunked = true;
+ this.body = null;
+ return this;
+ }
+
+ /**
+ * 302 Found redirect. Clears the body, sets status and {@code Location} header. Encoded once at
+ * call time; zero-alloc on the write path.
+ *
+ * {@code
+ * return res.redirect("/login");
+ * }
+ */
+ public Response redirect(String url) {
+ return redirect(HttpStatus.FOUND, url);
+ }
+
+ /**
+ * Redirect with an explicit 3xx status. Use {@link HttpStatus#MOVED_PERMANENTLY}, {@link
+ * HttpStatus#TEMPORARY_REDIRECT} (307), or {@link HttpStatus#PERMANENT_REDIRECT} (308) when
+ * semantics matter.
+ *
+ * {@code
+ * return res.redirect(HttpStatus.MOVED_PERMANENTLY, "/new-path");
+ * }
+ */
+ public Response redirect(HttpStatus status, String url) {
+ checkActive();
+ this.statusCode = status.code();
+ this.statusBytes = status.bytes();
+ this.body = null;
+ this.stream = null;
+ return header("Location", url);
+ }
+
+ /**
+ * reused byte region (via {@link ByteWriter#writeAscii}) instead of building an intermediate
+ * {@code String} and re-encoding it — zero allocation once the region has grown to this
+ * connection's high-water mark.
+ */
+ public Response header(String name, String value) {
+ checkActive();
+ checkHeaderBudget();
+ if (headerRegion == null) {
+ headerRegion = new ByteWriter(128);
+ headerQuads = new int[16];
}
+ ensureQuadCapacity(headerQuadCount + 1);
+ int nameOff = headerRegion.length();
+ headerRegion.writeAscii(name);
+ int nameLen = headerRegion.length() - nameOff;
+ int valOff = headerRegion.length();
+ headerRegion.writeAscii(value);
+ int valLen = headerRegion.length() - valOff;
+ checkHeaderRegionBudget();
- // -------------------------------------------------------------------------
- // Constructors
- // -------------------------------------------------------------------------
+ int base = headerQuadCount * 4;
+ headerQuads[base] = nameOff;
+ headerQuads[base + 1] = nameLen;
+ headerQuads[base + 2] = valOff;
+ headerQuads[base + 3] = valLen;
+ recordHeaderEntry((byte) 0, headerQuadCount);
+ headerQuadCount++;
+ return this;
+ }
- public Response(int statusCode, ContentType contentType) {
- this.statusCode = statusCode;
- this.contentType = contentType.getBytes();
+ /**
+ * Adds a header from a {@link PreEncodedHeader} built once (typically at boot). Copies its
+ * precomputed {@code name}/{@code value} bytes into this response's region — a memcpy, not a
+ * re-encode. Preserving the field structure makes it usable by both HTTP versions.
+ */
+ public Response header(PreEncodedHeader preEncoded) {
+ checkActive();
+ checkHeaderBudget();
+ if (headerRegion == null) {
+ headerRegion = new ByteWriter(128);
+ headerQuads = new int[16];
}
+ ensureQuadCapacity(headerQuadCount + 1);
+ byte[] nameBytes = preEncoded.nameBytes();
+ byte[] valueBytes = preEncoded.valueBytes();
+ int nameOff = headerRegion.length();
+ headerRegion.writeBytes(nameBytes);
+ int valOff = headerRegion.length();
+ headerRegion.writeBytes(valueBytes);
+ checkHeaderRegionBudget();
- public Response(int statusCode, byte[] body, ContentType contentType) {
- this(statusCode, contentType);
- this.body = body;
+ int base = headerQuadCount * 4;
+ headerQuads[base] = nameOff;
+ headerQuads[base + 1] = nameBytes.length;
+ headerQuads[base + 2] = valOff;
+ headerQuads[base + 3] = valueBytes.length;
+ recordHeaderEntry((byte) 0, headerQuadCount);
+ headerQuadCount++;
+ return this;
+ }
+
+ /**
+ * Adds a pre-encoded, fully-rendered header line (e.g. a static {@code "X-RateLimit-Limit:
+ * 100\r\n"} byte array pre-built at boot time). Zero-alloc on both the call path and the h1 write
+ * path.
+ *
+ * h1-only: a rendered {@code "Name: Value\r\n"} line carries no structured name/value
+ * data an HPACK encoder could use, so this header is not representable on a HTTP/2 response path
+ * — prefer {@link #header(PreEncodedHeader)} for anything that must render correctly on both
+ * protocols. Kept for existing HTTP/1-only callers.
+ */
+ public Response header(byte[] preEncoded) {
+ checkActive();
+ checkHeaderBudget();
+ if (rawHeaderLines == null) rawHeaderLines = new ArrayList<>();
+ rawHeaderLines.add(preEncoded);
+ recordHeaderEntry((byte) 1, rawHeaderLines.size() - 1);
+ return this;
+ }
+
+ /** Prevents an unbounded header loop from growing the connection's response scratch state. */
+ private void checkHeaderBudget() {
+ if (headerCount >= Http1Limits.MAX_RESPONSE_HEADER_COUNT) {
+ throw new IllegalStateException(
+ "response exceeds "
+ + Http1Limits.MAX_RESPONSE_HEADER_COUNT
+ + " headers — check for an unbounded loop calling header(...)");
}
+ }
- public Response(int statusCode, String text, ContentType contentType) {
- this(statusCode, text.getBytes(StandardCharsets.UTF_8), contentType);
+ private void checkHeaderRegionBudget() {
+ if (headerRegion.length() > Http1Limits.MAX_RESPONSE_HEADER_BYTES) {
+ throw new IllegalStateException(
+ "response header region exceeds "
+ + Http1Limits.MAX_RESPONSE_HEADER_BYTES
+ + " bytes — check for an unbounded loop or an oversized value passed to header(...)");
}
+ }
- // -------------------------------------------------------------------------
- // Pooling
- // -------------------------------------------------------------------------
-
- /**
- * Repositions this instance for a new request/response cycle — clears the body, stream,
- * status, content type, and every header recorded by the previous cycle. Public because the
- * connection driver that owns the pooled instance lives in a different package (matching
- * {@link RequestLine#reset}'s precedent); user code never calls this.
- */
- public Response reset(int statusCode, ContentType contentType) {
- this.statusCode = statusCode;
- this.statusBytes = null;
- this.body = null;
- this.stream = null;
- this.streamLength = 0;
- this.chunked = false;
- this.contentType = contentType.getBytes();
- this.headerQuadCount = 0;
- this.headerCount = 0;
- if (rawHeaderLines != null) rawHeaderLines.clear();
- this.active = true;
- return this;
+ private void recordHeaderEntry(byte tag, int ref) {
+ if (headerTags == null) {
+ headerTags = new byte[16];
+ headerRefs = new int[16];
+ } else if (headerCount == headerTags.length) {
+ int grown = headerTags.length * 2;
+ headerTags = Arrays.copyOf(headerTags, grown);
+ headerRefs = Arrays.copyOf(headerRefs, grown);
}
+ headerTags[headerCount] = tag;
+ headerRefs[headerCount] = ref;
+ headerCount++;
+ }
- /**
- * Marks this instance unsafe for further use — see {@link Request#recycle()} for the full
- * rationale, identical here. {@code public} for the same cross-package reason.
- */
- public void recycle() {
- this.active = false;
+ private void ensureQuadCapacity(int neededQuads) {
+ int neededInts = neededQuads * 4;
+ if (neededInts <= headerQuads.length) return;
+ int grown = headerQuads.length;
+ while (grown < neededInts) grown *= 2;
+ headerQuads = Arrays.copyOf(headerQuads, grown);
+ }
+
+ // -------------------------------------------------------------------------
+ // State queries
+ // -------------------------------------------------------------------------
+
+ public boolean isStreaming() {
+ checkActive();
+ return stream != null;
+ }
+
+ public boolean isChunked() {
+ checkActive();
+ return chunked;
+ }
+
+ public int getStatusCode() {
+ checkActive();
+ return statusCode;
+ }
+
+ public byte[] getStatusBytes() {
+ checkActive();
+ return statusBytes;
+ }
+
+ public byte[] getBody() {
+ checkActive();
+ return body;
+ }
+
+ public byte[] getContentType() {
+ checkActive();
+ return contentType;
+ }
+
+ public InputStream getStream() {
+ checkActive();
+ return stream;
+ }
+
+ public long getStreamLength() {
+ checkActive();
+ return streamLength;
+ }
+
+ // -------------------------------------------------------------------------
+ // Internal setters used by HttpServer for handler return values
+ // -------------------------------------------------------------------------
+
+ /**
+ * Sets the body from a handler return value. Accepted types: {@code byte[]}, {@link String},
+ * {@link CharSequence}. Any other non-null type throws {@link IllegalArgumentException} — return
+ * a {@code Response} directly, or serialize to {@code String}/{@code byte[]} before returning.
+ */
+ public Response setBody(Object body) {
+ checkActive();
+ if (body instanceof byte[] bytes) {
+ this.body = bytes;
+ return this;
}
-
- // -------------------------------------------------------------------------
- // Fluent mutators
- // -------------------------------------------------------------------------
-
- /** Sets the status code. The phrase is looked up from {@link HttpStatus} on the write path. */
- public Response status(int code) { checkActive(); this.statusCode = code; this.statusBytes = null; return this; }
-
- /** Lombok-style setter kept for API compatibility — equivalent to {@link #status(int)} without the fluent return. */
- public void setStatusCode(int code) { status(code); }
-
- /** Sets the status from an {@link HttpStatus} constant. The pre-encoded bytes are used
- * directly on the write path — zero lookup, zero allocation. */
- public Response status(HttpStatus status) { checkActive(); this.statusCode = status.code(); this.statusBytes = status.bytes(); return this; }
- public Response type(ContentType ct) { checkActive(); this.contentType = ct.getBytes(); return this; }
- public Response type(String ct) { checkActive(); this.contentType = ct.getBytes(StandardCharsets.UTF_8); return this; }
-
- public Response body(byte[] bytes) {
- checkActive();
- this.body = bytes;
- this.stream = null;
- return this;
+ if (body instanceof String s) {
+ this.body = s.getBytes(StandardCharsets.UTF_8);
+ return this;
}
-
- public Response body(String text) {
- return body(text.getBytes(StandardCharsets.UTF_8));
+ if (body instanceof CharSequence s) {
+ this.body = s.toString().getBytes(StandardCharsets.UTF_8);
+ return this;
}
+ if (body != null)
+ throw new IllegalArgumentException(
+ "Handler returned unsupported type: "
+ + body.getClass().getName()
+ + " — return String, byte[], Response, or null");
+ return this;
+ }
- /** Streaming response with known length; written with {@code Content-Length}. */
- public Response stream(InputStream is, long length) {
- checkActive();
- this.stream = is;
- this.streamLength = length;
- this.chunked = false;
- this.body = null;
- return this;
- }
-
- /** Streaming response with unknown length; written with {@code Transfer-Encoding: chunked}. */
- public Response chunked(InputStream is) {
- checkActive();
- this.stream = is;
- this.chunked = true;
- this.body = null;
- return this;
- }
-
- /**
- * 302 Found redirect. Clears the body, sets status and {@code Location} header.
- * Encoded once at call time; zero-alloc on the write path.
- *
- *
{@code
- * return res.redirect("/login");
- * }
- */
- public Response redirect(String url) {
- return redirect(HttpStatus.FOUND, url);
- }
-
- /**
- * Redirect with an explicit 3xx status. Use {@link HttpStatus#MOVED_PERMANENTLY},
- * {@link HttpStatus#TEMPORARY_REDIRECT} (307), or {@link HttpStatus#PERMANENT_REDIRECT} (308)
- * when semantics matter.
- *
- * {@code
- * return res.redirect(HttpStatus.MOVED_PERMANENTLY, "/new-path");
- * }
- */
- public Response redirect(HttpStatus status, String url) {
- checkActive();
- this.statusCode = status.code();
- this.statusBytes = status.bytes();
- this.body = null;
- this.stream = null;
- return header("Location", url);
- }
-
- /**
- * reused byte region (via {@link ByteWriter#writeAscii}) instead of building an intermediate
- * {@code String} and re-encoding it — zero allocation once the region has grown to this
- * connection's high-water mark.
- */
- public Response header(String name, String value) {
- checkActive();
- checkHeaderBudget();
- if (headerRegion == null) {
- headerRegion = new ByteWriter(128);
- headerQuads = new int[16];
- }
- ensureQuadCapacity(headerQuadCount + 1);
- int nameOff = headerRegion.length();
- headerRegion.writeAscii(name);
- int nameLen = headerRegion.length() - nameOff;
- int valOff = headerRegion.length();
- headerRegion.writeAscii(value);
- int valLen = headerRegion.length() - valOff;
- checkHeaderRegionBudget();
-
- int base = headerQuadCount * 4;
- headerQuads[base] = nameOff;
- headerQuads[base + 1] = nameLen;
- headerQuads[base + 2] = valOff;
- headerQuads[base + 3] = valLen;
- recordHeaderEntry((byte) 0, headerQuadCount);
- headerQuadCount++;
- return this;
- }
-
- /**
- * Adds a header from a {@link PreEncodedHeader} built once (typically at boot). Copies its
- * precomputed {@code name}/{@code value} bytes into this response's region — a memcpy, not a
- * re-encode, and usable by a future HTTP/2 response path (unlike {@link #header(byte[])}) since
- * the name/value structure survives.
- */
- public Response header(PreEncodedHeader preEncoded) {
- checkActive();
- checkHeaderBudget();
- if (headerRegion == null) {
- headerRegion = new ByteWriter(128);
- headerQuads = new int[16];
- }
- ensureQuadCapacity(headerQuadCount + 1);
- byte[] nameBytes = preEncoded.nameBytes();
- byte[] valueBytes = preEncoded.valueBytes();
- int nameOff = headerRegion.length();
- headerRegion.writeBytes(nameBytes);
- int valOff = headerRegion.length();
- headerRegion.writeBytes(valueBytes);
- checkHeaderRegionBudget();
-
- int base = headerQuadCount * 4;
- headerQuads[base] = nameOff;
- headerQuads[base + 1] = nameBytes.length;
- headerQuads[base + 2] = valOff;
- headerQuads[base + 3] = valueBytes.length;
- recordHeaderEntry((byte) 0, headerQuadCount);
- headerQuadCount++;
- return this;
- }
-
- /**
- * Adds a pre-encoded, fully-rendered header line (e.g. a static
- * {@code "X-RateLimit-Limit: 100\r\n"} byte array pre-built at boot time). Zero-alloc on
- * both the call path and the h1 write path.
- *
- * h1-only: a rendered {@code "Name: Value\r\n"} line carries no structured
- * name/value data an HPACK encoder could use, so this header is not representable on a
- * future HTTP/2 response path — prefer {@link #header(PreEncodedHeader)} for anything that must
- * render correctly on both protocols. Kept for existing h1-only callers.
- */
- public Response header(byte[] preEncoded) {
- checkActive();
- checkHeaderBudget();
- if (rawHeaderLines == null) rawHeaderLines = new ArrayList<>();
- rawHeaderLines.add(preEncoded);
- recordHeaderEntry((byte) 1, rawHeaderLines.size() - 1);
- return this;
- }
-
- /** Prevents an unbounded header loop from growing the connection's response scratch state. */
- private void checkHeaderBudget() {
- if (headerCount >= Http1Limits.MAX_RESPONSE_HEADER_COUNT) {
- throw new IllegalStateException("response exceeds " + Http1Limits.MAX_RESPONSE_HEADER_COUNT
- + " headers — check for an unbounded loop calling header(...)");
- }
- }
-
- private void checkHeaderRegionBudget() {
- if (headerRegion.length() > Http1Limits.MAX_RESPONSE_HEADER_BYTES) {
- throw new IllegalStateException("response header region exceeds "
- + Http1Limits.MAX_RESPONSE_HEADER_BYTES + " bytes — check for an unbounded loop or an oversized value passed to header(...)");
- }
- }
-
- private void recordHeaderEntry(byte tag, int ref) {
- if (headerTags == null) {
- headerTags = new byte[16];
- headerRefs = new int[16];
- } else if (headerCount == headerTags.length) {
- int grown = headerTags.length * 2;
- headerTags = Arrays.copyOf(headerTags, grown);
- headerRefs = Arrays.copyOf(headerRefs, grown);
- }
- headerTags[headerCount] = tag;
- headerRefs[headerCount] = ref;
- headerCount++;
- }
-
- private void ensureQuadCapacity(int neededQuads) {
- int neededInts = neededQuads * 4;
- if (neededInts <= headerQuads.length) return;
- int grown = headerQuads.length;
- while (grown < neededInts) grown *= 2;
- headerQuads = Arrays.copyOf(headerQuads, grown);
- }
-
- // -------------------------------------------------------------------------
- // State queries
- // -------------------------------------------------------------------------
-
- public boolean isStreaming() { checkActive(); return stream != null; }
- public boolean isChunked() { checkActive(); return chunked; }
- public int getStatusCode() { checkActive(); return statusCode; }
- public byte[] getStatusBytes() { checkActive(); return statusBytes; }
- public byte[] getBody() { checkActive(); return body; }
- public byte[] getContentType() { checkActive(); return contentType; }
- public InputStream getStream() { checkActive(); return stream; }
- public long getStreamLength() { checkActive(); return streamLength; }
-
- // -------------------------------------------------------------------------
- // Internal setters used by HttpServer for handler return values
- // -------------------------------------------------------------------------
-
- /**
- * Sets the body from a handler return value. Accepted types: {@code byte[]},
- * {@link String}, {@link CharSequence}. Any other non-null type throws
- * {@link IllegalArgumentException} — return a {@code Response} directly, or
- * serialize to {@code String}/{@code byte[]} before returning.
- */
- public Response setBody(Object body) {
- checkActive();
- if (body instanceof byte[] bytes) { this.body = bytes; return this; }
- if (body instanceof String s) { this.body = s.getBytes(StandardCharsets.UTF_8); return this; }
- if (body instanceof CharSequence s) { this.body = s.toString().getBytes(StandardCharsets.UTF_8); return this; }
- if (body != null) throw new IllegalArgumentException(
- "Handler returned unsupported type: " + body.getClass().getName()
- + " — return String, byte[], Response, or null");
- return this;
- }
-
- /**
- * Returns custom headers as fully-rendered {@code "Name: Value\r\n"} lines, or an empty list
- * if none were added. Introspection/debugging accessor — reconstructs each line from the
- * internal region on every call, so it is not on the zero-alloc write path; {@link
- * #writeHeaders} and {@link ResponseSerializer} read the internal representation directly
- * instead of going through this method.
- */
- public List getHeaders() {
- checkActive();
- if (headerCount == 0) return List.of();
- List result = new ArrayList<>(headerCount);
- for (int i = 0; i < headerCount; i++) {
- if (headerTags[i] == 1) {
- result.add(rawHeaderLines.get(headerRefs[i]));
- } else {
- int base = headerRefs[i] * 4;
- byte[] region = headerRegion.array();
- int nameOff = headerQuads[base], nameLen = headerQuads[base + 1];
- int valOff = headerQuads[base + 2], valLen = headerQuads[base + 3];
- byte[] line = new byte[nameLen + 2 + valLen + 2];
- int p = 0;
- System.arraycopy(region, nameOff, line, p, nameLen); p += nameLen;
- line[p++] = ':'; line[p++] = ' ';
- System.arraycopy(region, valOff, line, p, valLen); p += valLen;
- line[p++] = '\r'; line[p] = '\n';
- result.add(line);
- }
- }
- return result;
- }
-
- /**
- * Writes every custom header directly into {@code head} (a scratch {@link ByteWriter} —
- * This is what {@code Http1ResponseWriter} uses; {@link #writeHeaders(OutputStream)} below
- * (the {@code OutputStream} equivalent) exists for the streaming-body write paths that
- * cannot fold their whole write into one scratch buffer.
- */
- public void writeHeadersInto(ByteWriter head) {
- for (int i = 0; i < headerCount; i++) {
- if (headerTags[i] == 1) {
- head.writeBytes(rawHeaderLines.get(headerRefs[i]));
- } else {
- int base = headerRefs[i] * 4;
- byte[] region = headerRegion.array();
- head.writeBytes(region, headerQuads[base], headerQuads[base + 1]);
- head.writeByte((byte) ':'); head.writeByte((byte) ' ');
- head.writeBytes(region, headerQuads[base + 2], headerQuads[base + 3]);
- head.writeByte((byte) '\r'); head.writeByte((byte) '\n');
- }
- }
- }
-
- /** Writes every custom header directly to {@code out}, in call order. Zero-alloc when no headers are set or on a warm region. */
- public void writeHeaders(OutputStream out) throws IOException {
- for (int i = 0; i < headerCount; i++) {
- if (headerTags[i] == 1) {
- out.write(rawHeaderLines.get(headerRefs[i]));
- } else {
- int base = headerRefs[i] * 4;
- byte[] region = headerRegion.array();
- out.write(region, headerQuads[base], headerQuads[base + 1]);
- out.write(':'); out.write(' ');
- out.write(region, headerQuads[base + 2], headerQuads[base + 3]);
- out.write('\r'); out.write('\n');
- }
- }
- }
-
- // ── Internal: name/value field enumeration for ResponseSerializer ──────────
-
- /**
- * Visits every {@code header(String,String)}/{@code header(PreEncodedHeader)}-added field as
- * a structured (name, value) byte range — not the {@code header(byte[])} legacy
- * entries, which have no such structure (see that method's own Javadoc). Package-private:
- * {@link ResponseSerializer} is this method's only caller.
- */
- void forEachStructuredField(ResponseSerializer.FieldConsumer consumer) {
- if (headerQuadCount == 0) return;
+ /**
+ * Returns custom headers as fully-rendered {@code "Name: Value\r\n"} lines, or an empty list if
+ * none were added. Introspection/debugging accessor — reconstructs each line from the internal
+ * region on every call, so it is not on the zero-alloc write path; {@link #writeHeaders} and
+ * {@link ResponseSerializer} read the internal representation directly instead of going through
+ * this method.
+ */
+ public List getHeaders() {
+ checkActive();
+ if (headerCount == 0) return List.of();
+ List result = new ArrayList<>(headerCount);
+ for (int i = 0; i < headerCount; i++) {
+ if (headerTags[i] == 1) {
+ result.add(rawHeaderLines.get(headerRefs[i]));
+ } else {
+ int base = headerRefs[i] * 4;
byte[] region = headerRegion.array();
- for (int i = 0; i < headerQuadCount; i++) {
- int base = i * 4;
- consumer.accept(region, headerQuads[base], headerQuads[base + 1],
- region, headerQuads[base + 2], headerQuads[base + 3]);
- }
+ int nameOff = headerQuads[base], nameLen = headerQuads[base + 1];
+ int valOff = headerQuads[base + 2], valLen = headerQuads[base + 3];
+ byte[] line = new byte[nameLen + 2 + valLen + 2];
+ int p = 0;
+ System.arraycopy(region, nameOff, line, p, nameLen);
+ p += nameLen;
+ line[p++] = ':';
+ line[p++] = ' ';
+ System.arraycopy(region, valOff, line, p, valLen);
+ p += valLen;
+ line[p++] = '\r';
+ line[p] = '\n';
+ result.add(line);
+ }
}
+ return result;
+ }
- @Override
- public String toString() {
- return "Response(statusCode=" + statusCode + ", contentType="
- + (contentType != null ? new String(contentType, StandardCharsets.UTF_8) : null) + ")";
+ /**
+ * Writes every custom header directly into {@code head} (a scratch {@link ByteWriter} — This is
+ * what {@code Http1ResponseWriter} uses; {@link #writeHeaders(OutputStream)} below (the {@code
+ * OutputStream} equivalent) exists for the streaming-body write paths that cannot fold their
+ * whole write into one scratch buffer.
+ */
+ public void writeHeadersInto(ByteWriter head) {
+ for (int i = 0; i < headerCount; i++) {
+ if (headerTags[i] == 1) {
+ head.writeBytes(rawHeaderLines.get(headerRefs[i]));
+ } else {
+ int base = headerRefs[i] * 4;
+ byte[] region = headerRegion.array();
+ head.writeBytes(region, headerQuads[base], headerQuads[base + 1]);
+ head.writeByte((byte) ':');
+ head.writeByte((byte) ' ');
+ head.writeBytes(region, headerQuads[base + 2], headerQuads[base + 3]);
+ head.writeByte((byte) '\r');
+ head.writeByte((byte) '\n');
+ }
}
+ }
+
+ /**
+ * Writes every custom header directly to {@code out}, in call order. Zero-alloc when no headers
+ * are set or on a warm region.
+ */
+ public void writeHeaders(OutputStream out) throws IOException {
+ for (int i = 0; i < headerCount; i++) {
+ if (headerTags[i] == 1) {
+ out.write(rawHeaderLines.get(headerRefs[i]));
+ } else {
+ int base = headerRefs[i] * 4;
+ byte[] region = headerRegion.array();
+ out.write(region, headerQuads[base], headerQuads[base + 1]);
+ out.write(':');
+ out.write(' ');
+ out.write(region, headerQuads[base + 2], headerQuads[base + 3]);
+ out.write('\r');
+ out.write('\n');
+ }
+ }
+ }
+
+ // ── Internal: name/value field enumeration for ResponseSerializer ──────────
+
+ /**
+ * Visits every {@code header(String,String)}/{@code header(PreEncodedHeader)}-added field as a
+ * structured (name, value) byte range — not the {@code header(byte[])} legacy entries,
+ * which have no such structure (see that method's own Javadoc). Package-private: {@link
+ * ResponseSerializer} is this method's only caller.
+ */
+ void forEachStructuredField(ResponseSerializer.FieldConsumer consumer) {
+ if (headerQuadCount == 0) return;
+ byte[] region = headerRegion.array();
+ for (int i = 0; i < headerQuadCount; i++) {
+ int base = i * 4;
+ consumer.accept(
+ region,
+ headerQuads[base],
+ headerQuads[base + 1],
+ region,
+ headerQuads[base + 2],
+ headerQuads[base + 3]);
+ }
+ }
+
+ @Override
+ public String toString() {
+ return "Response(statusCode="
+ + statusCode
+ + ", contentType="
+ + (contentType != null ? new String(contentType, StandardCharsets.UTF_8) : null)
+ + ")";
+ }
}
diff --git a/flash/src/main/java/dev/relism/flash/models/ResponseSerializer.java b/flash/src/main/java/dev/relism/flash/models/ResponseSerializer.java
index d8c3fa0..70488af 100644
--- a/flash/src/main/java/dev/relism/flash/models/ResponseSerializer.java
+++ b/flash/src/main/java/dev/relism/flash/models/ResponseSerializer.java
@@ -4,48 +4,54 @@ import java.nio.charset.StandardCharsets;
/**
* The protocol-neutral enumeration of a {@link Response}'s header fields — one source of truth
- * consumed by every protocol's own writer, so {@code Content-Type}/custom-header logic is never
- * duplicated (and cannot drift) between {@code Http1ResponseWriter} and a future HTTP/2 encoder
- * encoder will render the same fields via HPACK.
+ * consumed by every protocol's writer, so field selection cannot drift between HTTP/1 and HTTP/2.
*
* Scope: response-object fields only, not connection framing
- * Deliberately does not enumerate {@code Content-Length}, {@code Connection}, or
- * {@code Date} — those are connection/transport framing decisions (body length, keep-alive
- * negotiation, wall-clock time), not properties of the {@code Response} object itself, and HTTP/2
- * has no equivalent of {@code Connection} at all (RFC 9113 §8.2.2 forbids connection-specific
- * fields in h2). Each protocol's own writer computes and emits those itself, exactly as
- * {@code Http1ResponseWriter} already did before this class existed.
+ *
+ * Deliberately does not enumerate {@code Content-Length}, {@code Connection}, or {@code
+ * Date} — those are connection/transport framing decisions (body length, keep-alive negotiation,
+ * wall-clock time), not properties of the {@code Response} object itself, and HTTP/2 has no
+ * equivalent of {@code Connection} at all (RFC 9113 §8.2.2 forbids connection-specific fields in
+ * h2). Each protocol's own writer computes and emits those itself, exactly as {@code
+ * Http1ResponseWriter} already did before this class existed.
*
* Scope: excludes {@link Response#header(byte[])}'s legacy entries
- * A header added via the raw, fully-pre-rendered {@code header(byte[])} overload has no
- * recoverable (name, value) structure — see that method's own Javadoc — so it cannot appear in
- * this enumeration. {@code Http1ResponseWriter} still renders it (via {@link
- * Response#writeHeaders}, which handles both structured and raw entries, in the original call
- * order); a future HTTP/2 writer will not be able to.
+ *
+ * A header added via the raw, fully-pre-rendered {@code header(byte[])} overload has no recoverable
+ * (name, value) structure — see that method's own Javadoc — so it cannot appear in this
+ * enumeration. HTTP/1 still renders it via {@link Response#writeHeaders}; HTTP/2 cannot recover its
+ * field structure and ignores it.
*/
public final class ResponseSerializer {
- private ResponseSerializer() {}
+ private ResponseSerializer() {}
- /** One rendered header field: a byte range for the name, and a byte range for the value — both slices of caller-owned arrays, never copied. */
- @FunctionalInterface
- public interface FieldConsumer {
- void accept(byte[] nameBuf, int nameOff, int nameLen, byte[] valueBuf, int valueOff, int valueLen);
+ /**
+ * One rendered header field: a byte range for the name, and a byte range for the value — both
+ * slices of caller-owned arrays, never copied.
+ */
+ @FunctionalInterface
+ public interface FieldConsumer {
+ void accept(
+ byte[] nameBuf, int nameOff, int nameLen, byte[] valueBuf, int valueOff, int valueLen);
+ }
+
+ private static final byte[] CONTENT_TYPE_NAME =
+ "Content-Type".getBytes(StandardCharsets.US_ASCII);
+
+ /**
+ * Enumerates {@code response}'s fields in a fixed order: non-empty {@code Content-Type}, then
+ * structured custom fields in call order. Every range is a slice of existing response storage.
+ */
+ public static void forEachField(Response response, FieldConsumer consumer) {
+ byte[] ct = response.getContentType();
+ if (ct != null && ct.length > 0) {
+ consumer.accept(CONTENT_TYPE_NAME, 0, CONTENT_TYPE_NAME.length, ct, 0, ct.length);
}
+ forEachCustomField(response, consumer);
+ }
- private static final byte[] CONTENT_TYPE_NAME = "Content-Type".getBytes(StandardCharsets.US_ASCII);
-
- /**
- * Enumerates {@code response}'s fields in a fixed, deterministic order: {@code Content-Type}
- * nothing, never an empty-valued header line), then every {@code header(String,String)}/
- * {@code header(PreEncodedHeader)}-added field in call order. Zero allocation: every byte
- * range handed to {@code consumer} is a slice of {@code response}'s own already-allocated
- * buffers.
- */
- public static void forEachField(Response response, FieldConsumer consumer) {
- byte[] ct = response.getContentType();
- if (ct != null && ct.length > 0) {
- consumer.accept(CONTENT_TYPE_NAME, 0, CONTENT_TYPE_NAME.length, ct, 0, ct.length);
- }
- response.forEachStructuredField(consumer);
- }
+ /** Enumerates structured custom fields only, excluding {@code content-type}. */
+ public static void forEachCustomField(Response response, FieldConsumer consumer) {
+ response.forEachStructuredField(consumer);
+ }
}
diff --git a/flash/src/test/java/dev/relism/flash/http/ContentTypeHpackTest.java b/flash/src/test/java/dev/relism/flash/http/ContentTypeHpackTest.java
new file mode 100644
index 0000000..c4ffea5
--- /dev/null
+++ b/flash/src/test/java/dev/relism/flash/http/ContentTypeHpackTest.java
@@ -0,0 +1,34 @@
+package dev.relism.flash.http;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+
+import dev.relism.flash.http2.hpack.HpackDecoder;
+import dev.relism.fpr.core.ByteView;
+import java.nio.charset.StandardCharsets;
+import java.util.concurrent.atomic.AtomicReference;
+import org.junit.jupiter.api.Test;
+
+class ContentTypeHpackTest {
+ @Test
+ void everyNonEmptyTypeHasAValidPrecompiledField() {
+ for (ContentType type : ContentType.values()) {
+ if (type == ContentType.NONE) continue;
+ AtomicReference decoded = new AtomicReference<>();
+ byte[] block = type.getHpackBytes();
+ new HpackDecoder()
+ .decode(
+ block,
+ 0,
+ block.length,
+ (name, value, never) -> decoded.set(text(name) + "=" + text(value)));
+ assertEquals(
+ "content-type=" + new String(type.getBytes(), StandardCharsets.US_ASCII), decoded.get());
+ }
+ }
+
+ private static String text(ByteView view) {
+ byte[] bytes = new byte[view.length()];
+ for (int i = 0; i < bytes.length; i++) bytes[i] = view.byteAt(i);
+ return new String(bytes, StandardCharsets.US_ASCII);
+ }
+}
diff --git a/flash/src/test/java/dev/relism/flash/http/DateHeaderTest.java b/flash/src/test/java/dev/relism/flash/http/DateHeaderTest.java
new file mode 100644
index 0000000..7d26051
--- /dev/null
+++ b/flash/src/test/java/dev/relism/flash/http/DateHeaderTest.java
@@ -0,0 +1,15 @@
+package dev.relism.flash.http;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+
+import java.time.ZoneOffset;
+import java.time.ZonedDateTime;
+import org.junit.jupiter.api.Test;
+
+class DateHeaderTest {
+ @Test
+ void imfFixdateAlwaysUsesTwoDigitDayOfMonth() {
+ ZonedDateTime thirdOfMonth = ZonedDateTime.of(2026, 8, 3, 7, 5, 9, 0, ZoneOffset.UTC);
+ assertEquals("Mon, 03 Aug 2026 07:05:09 GMT", DateHeader.format(thirdOfMonth));
+ }
+}
diff --git a/flash/src/test/java/dev/relism/flash/http/HttpStatusHpackTest.java b/flash/src/test/java/dev/relism/flash/http/HttpStatusHpackTest.java
new file mode 100644
index 0000000..c77af34
--- /dev/null
+++ b/flash/src/test/java/dev/relism/flash/http/HttpStatusHpackTest.java
@@ -0,0 +1,38 @@
+package dev.relism.flash.http;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+
+import dev.relism.flash.http2.hpack.HpackDecoder;
+import dev.relism.fpr.core.ByteView;
+import java.nio.charset.StandardCharsets;
+import java.util.concurrent.atomic.AtomicReference;
+import org.junit.jupiter.api.Test;
+
+class HttpStatusHpackTest {
+ @Test
+ void everyStatusHasAValidPrecompiledField() {
+ for (HttpStatus status : HttpStatus.values()) {
+ AtomicReference decoded = new AtomicReference<>();
+ byte[] block = status.hpackBytes();
+ new HpackDecoder()
+ .decode(
+ block,
+ 0,
+ block.length,
+ (name, value, never) -> decoded.set(text(name) + "=" + text(value)));
+ assertEquals(":status=" + status.code(), decoded.get());
+ }
+ }
+
+ @Test
+ void commonStaticStatusIsOneByte() {
+ assertEquals(1, HttpStatus.OK.hpackBytes().length);
+ assertEquals(0x88, HttpStatus.OK.hpackBytes()[0] & 0xff);
+ }
+
+ private static String text(ByteView view) {
+ byte[] bytes = new byte[view.length()];
+ for (int i = 0; i < bytes.length; i++) bytes[i] = view.byteAt(i);
+ return new String(bytes, StandardCharsets.US_ASCII);
+ }
+}
diff --git a/flash/src/test/java/dev/relism/flash/http2/hpack/HpackEncoderTest.java b/flash/src/test/java/dev/relism/flash/http2/hpack/HpackEncoderTest.java
new file mode 100644
index 0000000..d652f36
--- /dev/null
+++ b/flash/src/test/java/dev/relism/flash/http2/hpack/HpackEncoderTest.java
@@ -0,0 +1,80 @@
+package dev.relism.flash.http2.hpack;
+
+import static org.junit.jupiter.api.Assertions.assertArrayEquals;
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertTrue;
+
+import dev.relism.flash.bytes.ByteWriter;
+import dev.relism.fpr.core.ByteView;
+import java.nio.charset.StandardCharsets;
+import java.util.ArrayList;
+import java.util.List;
+import org.junit.jupiter.api.Test;
+
+class HpackEncoderTest {
+ @Test
+ void status200IsOneIndexedByte() {
+ ByteWriter out = new ByteWriter(16);
+ HpackEncoder.writeIndexed(out, 8);
+ assertEquals(1, out.length());
+ assertEquals(0x88, out.array()[0] & 0xff);
+ }
+
+ @Test
+ void representationsRoundTripThroughDecoder() {
+ ByteWriter out = new ByteWriter(128);
+ HpackEncoder.writeDynamicTableSizeUpdateZero(out);
+ HpackEncoder.writeIndexed(out, 8);
+ HpackEncoder.writeLiteralWithNameIndex(out, 31, ascii("application/json"), true);
+ HpackEncoder.writeLiteral(out, ascii("X-Trace"), ascii("abc123"));
+ HpackEncoder.writeLiteralNeverIndexed(out, ascii("authorization"), ascii("secret"), false);
+
+ List fields = new ArrayList<>();
+ List sensitive = new ArrayList<>();
+ new HpackDecoder()
+ .decode(
+ out.array(),
+ 0,
+ out.length(),
+ (name, value, never) -> {
+ fields.add(text(name) + "=" + text(value));
+ sensitive.add(never);
+ });
+
+ assertEquals(
+ List.of(
+ ":status=200",
+ "content-type=application/json",
+ "x-trace=abc123",
+ "authorization=secret"),
+ fields);
+ assertEquals(List.of(false, false, false, true), sensitive);
+ }
+
+ @Test
+ void tableSizeUpdateZeroIsCanonical() {
+ ByteWriter out = new ByteWriter(16);
+ HpackEncoder.writeDynamicTableSizeUpdateZero(out);
+ assertArrayEquals(new byte[] {0x20}, java.util.Arrays.copyOf(out.array(), out.length()));
+ }
+
+ @Test
+ void huffmanLiteralIsSmallerForTypicalValue() {
+ byte[] value = ascii("application/json");
+ ByteWriter raw = new ByteWriter(32);
+ ByteWriter compressed = new ByteWriter(32);
+ HpackEncoder.writeLiteralWithNameIndex(raw, 31, value, false);
+ HpackEncoder.writeLiteralWithNameIndex(compressed, 31, value, true);
+ assertTrue(compressed.length() < raw.length());
+ }
+
+ private static byte[] ascii(String value) {
+ return value.getBytes(StandardCharsets.US_ASCII);
+ }
+
+ private static String text(ByteView value) {
+ byte[] bytes = new byte[value.length()];
+ for (int i = 0; i < bytes.length; i++) bytes[i] = value.byteAt(i);
+ return new String(bytes, StandardCharsets.US_ASCII);
+ }
+}
diff --git a/flash/src/test/java/dev/relism/flash/http2/message/Http2ResponseWriterTest.java b/flash/src/test/java/dev/relism/flash/http2/message/Http2ResponseWriterTest.java
new file mode 100644
index 0000000..6b695ce
--- /dev/null
+++ b/flash/src/test/java/dev/relism/flash/http2/message/Http2ResponseWriterTest.java
@@ -0,0 +1,159 @@
+package dev.relism.flash.http2.message;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertFalse;
+import static org.junit.jupiter.api.Assertions.assertThrows;
+import static org.junit.jupiter.api.Assertions.assertTrue;
+
+import dev.relism.flash.http.ContentType;
+import dev.relism.flash.http2.Http2StreamException;
+import dev.relism.flash.http2.frame.FrameFlags;
+import dev.relism.flash.http2.frame.FrameType;
+import dev.relism.flash.http2.hpack.HpackDecoder;
+import dev.relism.flash.models.Response;
+import dev.relism.fpr.core.ByteView;
+import java.nio.charset.StandardCharsets;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.List;
+import org.junit.jupiter.api.Test;
+
+class Http2ResponseWriterTest {
+ @Test
+ void serializesOrderedHeadersAndOneDataFrame() {
+ Response response =
+ new Response(200, "hello", ContentType.TEXT_PLAIN)
+ .header("X-Trace", "abc")
+ .header("Connection", "close")
+ .header("Upgrade", "websocket");
+ Http2ResponseWriter writer = new Http2ResponseWriter();
+
+ assertTrue(writer.prepare(response, 3, false, false, true, false, true, 16_384, 4096, 65_535));
+ Parsed parsed = parse(writer);
+
+ assertEquals(List.of(FrameType.HEADERS, FrameType.DATA), parsed.types);
+ assertEquals(FrameFlags.END_HEADERS, parsed.flags.get(0));
+ assertEquals(FrameFlags.END_STREAM, parsed.flags.get(1));
+ assertEquals("hello", new String(parsed.data, StandardCharsets.US_ASCII));
+ assertEquals(
+ List.of(":status=200", "content-type=text/plain", "content-length=5", "x-trace=abc"),
+ decode(parsed.headerBlock));
+ }
+
+ @Test
+ void splitsHeaderBlockIntoAdjacentContinuationFrames() {
+ Response response =
+ new Response(200, ContentType.NONE)
+ .header("x-long", "abcdefghijklmnopqrstuvwxyz0123456789");
+ Http2ResponseWriter writer = new Http2ResponseWriter();
+
+ assertTrue(writer.prepare(response, 1, false, false, false, false, false, 12, 4096, 65_535));
+ Parsed parsed = parse(writer);
+
+ assertTrue(parsed.types.size() > 1);
+ assertEquals(FrameType.HEADERS, parsed.types.get(0));
+ for (int i = 1; i < parsed.types.size(); i++) {
+ assertEquals(FrameType.CONTINUATION, parsed.types.get(i));
+ }
+ assertEquals(0, parsed.flags.get(0) & FrameFlags.END_HEADERS);
+ assertTrue((parsed.flags.get(parsed.flags.size() - 1) & FrameFlags.END_HEADERS) != 0);
+ assertEquals(
+ List.of(":status=200", "x-long=abcdefghijklmnopqrstuvwxyz0123456789"),
+ decode(parsed.headerBlock));
+ }
+
+ @Test
+ void headAndBodyForbiddenStatusesEndOnHeaders() {
+ for (Response response :
+ List.of(
+ new Response(200, "body", ContentType.TEXT_PLAIN),
+ new Response(204, "body", ContentType.TEXT_PLAIN),
+ new Response(304, "body", ContentType.TEXT_PLAIN))) {
+ boolean head = response.getStatusCode() == 200;
+ Http2ResponseWriter writer = new Http2ResponseWriter();
+ assertTrue(
+ writer.prepare(response, 1, head, false, true, false, false, 16_384, 4096, 65_535));
+ Parsed parsed = parse(writer);
+ assertEquals(List.of(FrameType.HEADERS), parsed.types);
+ assertTrue((parsed.flags.get(0) & FrameFlags.END_STREAM) != 0);
+ List fields = decode(parsed.headerBlock);
+ if (head) assertTrue(fields.contains("content-length=4"));
+ else assertFalse(fields.stream().anyMatch(value -> value.startsWith("content-length=")));
+ }
+ }
+
+ @Test
+ void insufficientWindowDefersWithoutProducingPartialResponse() {
+ Response response = new Response(200, "body", ContentType.TEXT_PLAIN);
+ Http2ResponseWriter writer = new Http2ResponseWriter();
+ assertFalse(writer.prepare(response, 1, false, false, true, false, false, 16_384, 3, 3));
+ assertEquals(0, writer.length());
+ }
+
+ @Test
+ void peerHeaderListLimitFailsTheStream() {
+ Response response = new Response(200, ContentType.TEXT_PLAIN);
+ Http2ResponseWriter writer = new Http2ResponseWriter();
+ assertThrows(
+ Http2StreamException.class,
+ () -> writer.prepare(response, 5, false, false, true, false, false, 16_384, 41, 65_535));
+ }
+
+ private static Parsed parse(Http2ResponseWriter writer) {
+ Parsed parsed = new Parsed();
+ byte[] wire = writer.buffer();
+ int position = 0;
+ while (position < writer.length()) {
+ int length =
+ ((wire[position] & 0xff) << 16)
+ | ((wire[position + 1] & 0xff) << 8)
+ | (wire[position + 2] & 0xff);
+ FrameType type = FrameType.fromCode(wire[position + 3] & 0xff);
+ int flags = wire[position + 4] & 0xff;
+ byte[] payload = Arrays.copyOfRange(wire, position + 9, position + 9 + length);
+ parsed.types.add(type);
+ parsed.flags.add(flags);
+ if (type == FrameType.HEADERS || type == FrameType.CONTINUATION) {
+ parsed.appendHeaders(payload);
+ } else if (type == FrameType.DATA) {
+ parsed.data = payload;
+ }
+ position += 9 + length;
+ }
+ parsed.headerBlock = Arrays.copyOf(parsed.headerBlock, parsed.headerLength);
+ return parsed;
+ }
+
+ private static List decode(byte[] block) {
+ List fields = new ArrayList<>();
+ new HpackDecoder()
+ .decode(
+ block,
+ 0,
+ block.length,
+ (name, value, never) -> fields.add(text(name) + "=" + text(value)));
+ return fields;
+ }
+
+ private static String text(ByteView view) {
+ byte[] bytes = new byte[view.length()];
+ for (int i = 0; i < bytes.length; i++) bytes[i] = view.byteAt(i);
+ return new String(bytes, StandardCharsets.US_ASCII);
+ }
+
+ private static final class Parsed {
+ final List types = new ArrayList<>();
+ final List flags = new ArrayList<>();
+ byte[] headerBlock = new byte[64];
+ int headerLength;
+ byte[] data = new byte[0];
+
+ void appendHeaders(byte[] fragment) {
+ if (headerLength + fragment.length > headerBlock.length) {
+ headerBlock = Arrays.copyOf(headerBlock, (headerLength + fragment.length) * 2);
+ }
+ System.arraycopy(fragment, 0, headerBlock, headerLength, fragment.length);
+ headerLength += fragment.length;
+ }
+ }
+}
diff --git a/flash/src/test/java/dev/relism/flash/models/ResponseSerializerParityTest.java b/flash/src/test/java/dev/relism/flash/models/ResponseSerializerParityTest.java
new file mode 100644
index 0000000..0689964
--- /dev/null
+++ b/flash/src/test/java/dev/relism/flash/models/ResponseSerializerParityTest.java
@@ -0,0 +1,66 @@
+package dev.relism.flash.models;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+
+import dev.relism.flash.http.ContentType;
+import dev.relism.flash.http.HttpMethod;
+import dev.relism.flash.http1.Http1ResponseWriter;
+import dev.relism.flash.http2.hpack.HpackDecoder;
+import dev.relism.flash.http2.message.Http2ResponseWriter;
+import dev.relism.flash.transport.ScratchPool;
+import dev.relism.fpr.core.ByteView;
+import java.io.ByteArrayOutputStream;
+import java.nio.charset.StandardCharsets;
+import java.util.LinkedHashMap;
+import java.util.Map;
+import org.junit.jupiter.api.Test;
+
+class ResponseSerializerParityTest {
+ @Test
+ void bothProtocolsRenderTheSameResponseFields() throws Exception {
+ Response response =
+ new Response(201, "created", ContentType.JSON)
+ .header("Cache-Control", "no-store")
+ .header(new PreEncodedHeader("X-Trace", "abc"));
+
+ ByteArrayOutputStream http1 = new ByteArrayOutputStream();
+ Http1ResponseWriter.writeResponse(
+ http1, response, HttpMethod.GET, true, false, new ScratchPool().acquire());
+ Map http1Fields = parseHttp1(http1.toString(StandardCharsets.US_ASCII));
+ http1Fields.remove("connection");
+
+ Http2ResponseWriter writer = new Http2ResponseWriter();
+ writer.prepare(response, 1, false, false, true, false, false, 16_384, 4096, 65_535);
+ int headerLength =
+ ((writer.buffer()[0] & 0xff) << 16)
+ | ((writer.buffer()[1] & 0xff) << 8)
+ | (writer.buffer()[2] & 0xff);
+ Map http2Fields = new LinkedHashMap<>();
+ new HpackDecoder()
+ .decode(
+ writer.buffer(),
+ 9,
+ headerLength,
+ (name, value, never) -> http2Fields.put(text(name), text(value)));
+ http2Fields.remove(":status");
+
+ assertEquals(http1Fields, http2Fields);
+ }
+
+ private static Map parseHttp1(String message) {
+ Map fields = new LinkedHashMap<>();
+ int end = message.indexOf("\r\n\r\n");
+ String[] lines = message.substring(0, end).split("\r\n");
+ for (int i = 1; i < lines.length; i++) {
+ int colon = lines[i].indexOf(':');
+ fields.put(lines[i].substring(0, colon).toLowerCase(), lines[i].substring(colon + 2));
+ }
+ return fields;
+ }
+
+ private static String text(ByteView view) {
+ byte[] bytes = new byte[view.length()];
+ for (int i = 0; i < bytes.length; i++) bytes[i] = view.byteAt(i);
+ return new String(bytes, StandardCharsets.US_ASCII);
+ }
+}