@amritk/nish-x86_64-linux 0.28.0 → 0.30.0

package/std/net/http1-server.ts

@@ -70,7 +70,11 @@
  * most once a second; a 1xx carries none. The pool's slots share one, so a
  * busy server formats a second once, not once a slot. A program that sets its
  * own `date` field sends that one instead, so a response has one `Date`.
- * `date.pin(unixMs)` fixes it, for a test that compares bytes.
+ * `Http1Server` reads the clock once per serve call — from `readable` or
+ * `writable` to the `flush` that ends it — and every response written in
+ * between carries that reading; one written outside a serve call, an answer
+ * given later, reads the clock then. `date.pin(unixMs)` fixes it, for a test
+ * that compares bytes.
  *
  * **Refusals.** Every refusal of `nish/net/http1`'s parser — the smuggling
  * shapes, a `Content-Length` with a `Transfer-Encoding`, two that disagree,
@@ -118,11 +122,12 @@ import {
   HTTP_CODING_GZIP,
   HTTP_CODING_IDENTITY,
   HTTP_CODING_NONE,
+  HTTP_DEFAULT_MSS,
   HTTP_OFFER_GZIP,
   HttpCompressor,
   httpAcceptEncoding,
 } from "nish/net/http-compress"
-import { netClose, netRead, netWrite, tcpAccept } from "nish:net"
+import { netClose, netMss, netRead, netWrite, tcpAccept } from "nish:net"
 import {
   HTTP1_BODY,
   HTTP1_CHUNKED,
@@ -274,7 +279,8 @@ const http1ServerCopy = (out: u8[], at: i32, src: u8[], off: i32, n: i32): i32 =
  * it calls, `httpDateWrite`, stays in `nish/net/http-fields`, which compiles
  * for wasm32 (the split `nish/crypto/x509` and `x509-random` make). `pin`
  * replaces the clock with one instant, which is how a test asserts a response
- * byte for byte.
+ * byte for byte. `hold` reads the clock once for a run of responses, a serve
+ * call's, until `unhold`; `pin` wins over it.
  */
 export class HttpDate {
   /** The IMF-fixdate of `second`: what `current` answers, made once. */
@@ -283,9 +289,14 @@ export class HttpDate {
   second: i64 = -1
   /** The instant `pin` fixed, in milliseconds since 1970, while `pinned`. */
   pinnedMs: i64 = 0
+  /** The clock reading `hold` took, in milliseconds since 1970, while `held`. */
+  heldMs: i64 = 0
   /** How many times `bytes` has been rewritten. */
   rewrites: i64 = 0
+  /** How many times the wall clock has been read. */
+  reads: i64 = 0
   pinned: boolean = false
+  held: boolean = false
 
   /** A date on the wall clock, with nothing formatted yet. */
   constructor() {
@@ -300,7 +311,10 @@ export class HttpDate {
    * or past 9999 answers the nearer of the two ends.
    */
   current(): u8[] {
-    const ms: i64 = this.pinned ? this.pinnedMs : toI64(Date.now())
+    let ms: i64 = this.pinnedMs
+    if (!this.pinned) {
+      ms = this.held ? this.heldMs : this.now()
+    }
     let second: i64 = ms / 1000
     if (ms < 0) {
       second = 0
@@ -334,6 +348,34 @@ export class HttpDate {
     this.pinned = false
   }
 
+  /**
+   * Reads the wall clock once and makes `current` answer that reading until
+   * `unhold`, so the responses of one serve call cost one read. A pinned date
+   * reads nothing. A second `hold` takes a fresh reading.
+   */
+  hold(): void {
+    if (!this.pinned) {
+      this.heldMs = this.now()
+    }
+    this.held = true
+  }
+
+  /** Puts `current` back on a clock read per call, for a response written outside a serve call. */
+  unhold(): void {
+    this.held = false
+  }
+
+  /** The wall clock, in milliseconds since 1970. */
+  now(): i64 {
+    this.reads += 1
+    return toI64(Date.now())
+  }
+
+  /** How many times the wall clock has been read: once per `hold`, and once per `current` outside one. */
+  clockReads(): i64 {
+    return this.reads
+  }
+
   /** How many times the bytes have been rewritten: one per second that `current` was asked for, at most. */
   formats(): i64 {
     return this.rewrites
@@ -493,7 +535,11 @@ export class Http1Connection {
    * put another, to share it or to pin its clock.
    */
   date: HttpDate
-  /** The request parser: its head (`methodIs`, `targetIs`, `header`, spans) is the last `H1_REQUEST`'s. */
+  /**
+   * The request parser: its head (`methodIs`, `targetIs`, `header`, spans) is
+   * the current request's from its `H1_REQUEST` until its response is done,
+   * `H1_END` included, however much of a pipelined request is fed behind it.
+   */
   parser: Http1Parser
   /**
    * The frame decoder: made when the slot first switches to WebSocket, so a
@@ -562,10 +608,14 @@ export class Http1Connection {
   /** A head has begun to arrive and is not read whole yet: `headSince` is its deadline's start. */
   headTimed: boolean = false
   /**
-   * This connection's TCP maximum segment size, for `respondEncoded` under
-   * `HttpCompressor.segmentMode`; 0, the default, uses the compressor's `mss`.
+   * The TCP maximum segment size the program sets for this connection, for
+   * `respondEncoded` under `HttpCompressor.segmentMode`; 0, the default,
+   * leaves it to the compressor and the socket (`segmentMss`). Each accept
+   * puts it back to 0.
    */
   mss: i32 = 0
+  /** The MSS `Http1Server.accept` read from this connection's socket (`netMss`), or 0 when it reports none. */
+  socketMss: i32 = 0
 
   /** A connection under `config`. A cap outside what the connection can work with panics. */
   constructor(config: Http1Config) {
@@ -649,6 +699,8 @@ export class Http1Connection {
     this.inputEnded = false
     this.headTimed = false
     this.headSince = 0
+    this.mss = 0
+    this.socketMss = 0
     this.release()
     this.park()
   }
@@ -1225,7 +1277,8 @@ export class Http1Connection {
    * `Accept-Encoding` with gzip offered (`httpAcceptEncoding`):
    * `HTTP_CODING_GZIP`, `HTTP_CODING_IDENTITY` (also with no such field), or
    * `HTTP_CODING_NONE` when the client refuses identity and does not take
-   * gzip. Allocates nothing.
+   * gzip. Allocates nothing. Read at `H1_REQUEST`, `H1_BODY` or `H1_END`
+   * alike: the head stays the request's until its response is done.
    */
   acceptEncoding(): i32 {
     return this.acceptEncodingOf(HTTP_OFFER_GZIP)
@@ -1255,6 +1308,22 @@ export class Http1Connection {
     return httpAcceptEncoding(parser.head, start, end, offered)
   }
 
+  /**
+   * The segment `respondEncoded` counts in under `enc.segmentMode`: this
+   * connection's `mss` when the program set it, else `enc.mss` when the
+   * program set it to other than `HTTP_DEFAULT_MSS`, else the socket's
+   * (`socketMss`), else `HTTP_DEFAULT_MSS`.
+   */
+  segmentMss(enc: HttpCompressor): i32 {
+    if (this.mss > 0) {
+      return this.mss
+    }
+    if (enc.mss > 0 && enc.mss !== HTTP_DEFAULT_MSS) {
+      return enc.mss
+    }
+    return this.socketMss > 0 ? this.socketMss : HTTP_DEFAULT_MSS
+  }
+
   /**
    * Answers the current request with all of `body[off .. off + len)` in one
    * call: `respond`, `write` and `end`, the body compressed by `enc` when
@@ -1263,10 +1332,12 @@ export class Http1Connection {
    * otherwise sent as it is; `Vary: Accept-Encoding` while `enc.vary` is set
    * and the choice turned on the request (`HttpCompressor.varies`). Under
    * `enc.segmentMode` the compressed response goes out only when, head
-   * included, it takes fewer segments of `mss` bytes (this connection's, or
-   * `enc.mss`) than the body as it is; `enc.decision` says what was chosen.
-   * A request that refuses identity (`identityRefused`) is sent gzip whatever
-   * the length, the saving or the segments (`enc.compressAnyway`).
+   * included, it takes fewer segments of `segmentMss(enc)` bytes than the
+   * body as it is, and a response that fits one segment as it is goes so
+   * without compressing (`enc.oneSegment`); `enc.decision`
+   * says what was chosen. A request that refuses identity (`identityRefused`)
+   * is sent gzip whatever the length, the saving or the segments
+   * (`enc.compressAnyway`).
    * The program's fields may not name `Content-Encoding` or, with
    * `enc.vary`, `Vary`. The whole response is written or none of
    * it: `H1_AGAIN` when the output has no room for it yet (`H1_WRITE` says
@@ -1290,16 +1361,6 @@ export class Http1Connection {
       return H1_CLOSED
     }
     const required: boolean = coding === HTTP_CODING_GZIP && this.identityRefused()
-    let packed: i32 = required
-      ? enc.compressAnyway(coding, body, off, len)
-      : enc.compress(coding, body, off, len)
-    let n: i32 = len
-    if (packed >= 0) {
-      enc.addFields(names, values)
-      n = packed
-    } else {
-      enc.identityFields(names, values)
-    }
     // `respond` and the body together, or neither: what `respond` sets is
     // put back when the body does not fit behind the head. `room` first, so
     // that what was sent is already moved out of the way and the `outputEnd`
@@ -1307,15 +1368,43 @@ export class Http1Connection {
     this.room()
     const outputEnd: i32 = this.outputEnd
     const closeAfter: boolean = this.closeAfter
-    let r: i32 = this.respond(status, enc.names, enc.values, n)
-    if (r !== 0) {
-      return r
+    let packed: i32 = -1
+    let n: i32 = len
+    let r: i32 = 0
+    let queued: boolean = false
+    const mss: i32 = this.segmentMss(enc)
+    if (!required && enc.segmentMode && enc.oneSegment(coding, len, mss)) {
+      // A response that fits one segment as it is cannot take fewer
+      // compressed, so it goes as it is with no encoder run, unless its head
+      // pushes it past the segment: then it is taken back and decided below.
+      enc.identityFields(names, values)
+      r = this.respond(status, enc.names, enc.values, len)
+      if (r !== 0) {
+        return r
+      }
+      queued = this.outputEnd - outputEnd + len <= enc.segmentSize(mss)
+      if (!queued) {
+        this.unrespond(outputEnd, closeAfter)
+      }
+    }
+    if (!queued) {
+      packed = required ? enc.compressAnyway(coding, body, off, len) : enc.compress(coding, body, off, len)
+      if (packed >= 0) {
+        enc.addFields(names, values)
+        n = packed
+      } else {
+        enc.identityFields(names, values)
+      }
+      r = this.respond(status, enc.names, enc.values, n)
+      if (r !== 0) {
+        return r
+      }
     }
     if (packed >= 0 && enc.segmentMode && !required) {
       // The head just written, and the one the body as it is would get.
       const head: i32 = this.outputEnd - outputEnd
       const plain: i32 = enc.http1IdentityHead(head, packed, len)
-      if (!enc.fewerSegments(plain + len, head + packed, this.mss)) {
+      if (!enc.fewerSegments(plain + len, head + packed, mss)) {
         this.unrespond(outputEnd, closeAfter)
         enc.identityFields(names, values)
         packed = -1
@@ -1525,7 +1614,11 @@ export class Http1Server {
    * accepted into, and slot 0's once `connection` has asked for it.
    */
   connections: Http1Connection[]
-  /** The `Date` every slot's responses carry, formatted once a second for all of them. `date.pin` fixes its clock. */
+  /**
+   * The `Date` every slot's responses carry, formatted once a second for all
+   * of them and read from the clock once per serve call: `readable` and
+   * `writable` hold a reading and `flush` lets it go. `date.pin` fixes its clock.
+   */
   date: HttpDate
   /**
    * Each slot's descriptor, or -1 while it is free, for the slots accepted
@@ -1669,18 +1762,27 @@ export class Http1Server {
     this.fds[k] = fd
     this.armed[k] = H1_WANT_READ
     conn.restart()
+    // Once a connection, not a request, so a keep-alive request costs no
+    // syscall: a path whose MSS moves after the handshake is not followed.
+    const mss: i32 = netMss(fd)
+    if (mss > 0) {
+      conn.socketMss = mss
+    }
     conn.lastActive = monotonicNanos()
     return k
   }
 
   /**
    * The socket of `slot` is readable: reads it while the connection has room
-   * and the socket has more, then sends. Answers the interest.
+   * and the socket has more, then sends. Answers the interest. It begins a
+   * serve call, which the program's `flush` of the slot ends: the responses
+   * written in between carry one clock reading as their `Date`.
    */
   readable(slot: i32): i32 {
     if (!this.holds(slot)) {
       return H1_DONE
     }
+    this.date.hold()
     const conn: Http1Connection = this.connections[slot]
     const fd: i32 = this.fds[slot]
     let moved: boolean = false
@@ -1714,12 +1816,16 @@ export class Http1Server {
       conn.lastActive = now
       conn.headArrived(now)
     }
-    return this.flush(slot)
+    return this.settle(slot)
   }
 
-  /** The socket of `slot` is writable. Answers the interest. */
+  /** The socket of `slot` is writable: sends, and begins a serve call as `readable` does. Answers the interest. */
   writable(slot: i32): i32 {
-    return this.flush(slot)
+    if (!this.holds(slot)) {
+      return H1_DONE
+    }
+    this.date.hold()
+    return this.settle(slot)
   }
 
   /**
@@ -1743,9 +1849,16 @@ export class Http1Server {
   /**
    * Sends what `slot`'s connection holds until the socket would block, and
    * answers the interest: `H1_DONE` once the connection is over and sent,
-   * otherwise read while it has room and write while it holds bytes.
+   * otherwise read while it has room and write while it holds bytes. It ends
+   * the serve call, so a response written after it reads the clock anew.
    */
   flush(slot: i32): i32 {
+    this.date.unhold()
+    return this.settle(slot)
+  }
+
+  /** `flush` within a serve call: sends, answers the interest, and keeps the clock reading. */
+  settle(slot: i32): i32 {
     if (!this.holds(slot)) {
       return H1_DONE
     }