@mark1russell7/machines 0.3.15 → 0.3.16

package/README.md

@@ -52,8 +52,11 @@ The algebra reads these documents. It gives the closed form of each timer, the f
 | `RABBITMQ_CONNECTION` | `rabbitmq-connection` | RabbitMQ 4.3.6: one connection of AMQP 0-9-1 on the broker | server | 14 implemented, 1 documented |
 | `ATEN_DETECTOR` | `aten` | aten 0.6.0: one node that the failure detector of another node of RabbitMQ watches | server | 7 implemented |
 | `RA_MEMBER` | `ra-member` | ra 3.1.10: one member of the Raft cluster of a quorum queue of RabbitMQ 4.3.6 | server | 25 implemented |
+| `GRPC_JS` | `grpc-js` | grpc-js 1.14.6: one channel to a gRPC server, its HTTP/2 transport, its keepalive and a unary call | driver | 26 implemented, 1 observed |
+| `GRPC_GO_SERVER` | `grpc-go-server` | A server of grpc-go v1.84.0: one HTTP/2 connection, its keepalive, its policy for PINGs and its TCP socket | server | 13 implemented, 1 documented |
+| `ETCD_SERVER` | `etcd-server` | The server of etcd v3.6.15 on grpc-go v1.83.2: one gRPC connection of a client | server | 19 implemented, 1 documented |
 
-Twenty-one documents operate on Linux TCP (`over`). Linux TCP, conntrack, the Sentinel, the replication of mongod, aten and the member of Ra operate on no other document. The `conditions` of each document give the range where it holds, for example a range of kernels.
+Twenty-four documents operate on Linux TCP (`over`). Linux TCP, conntrack, the Sentinel, the replication of mongod, aten and the member of Ra operate on no other document. The `conditions` of each document give the range where it holds, for example a range of kernels.
 
 The package also gives these parts:
 
@@ -99,6 +102,13 @@ A change to the version of a system changes its sources too. Each fact of the do
 
 In this repository, a snapshot of the predictions of the cells (`packages/cells/src/__snapshots__/predictions.json`) shows each prediction that a change to a document moves.
 
+### 0.3.16
+
+- **gRPC: grpc-js 1.14.6, a server of grpc-go v1.84.0, and the server of etcd v3.6.15.** Three new documents, each from the source at its tag:
+  - `grpc-js`: one channel, its transport and a unary call. At the defaults the keepalive is off, a call has no deadline, and the connect has no timeout. grpc-js sets TCP_NODELAY and no TCP keepalive. When the transport ends, each call in flight ends with UNAVAILABLE, and grpc-js does not retry it.
+  - `grpc-go-server`: one connection of a server of grpc-go. The server sends a PING after 2 h with no read, and it closes the connection 20 s after it. Its keepalive is on, thus each accepted connection gets a TCP_USER_TIMEOUT of 20 s. With the TCP keepalive of Go (15 s, 15 s, 9), an idle connection to a client that is gone ends 30 s after the last data. The third PING that breaks the policy gives GOAWAY too_many_pings. A call with a deadline gets a timer of it at the server, which resets the stream at its end. Thus the deadline of grpc-js and the deadline at the server race: run 39272272260 ended 4 of 11 such calls with CANCELLED, not DEADLINE_EXCEEDED.
+  - `etcd-server`: the same transport with the values of etcd. A client can ping each 5 s with a stream open. etcd serves gRPC through cmux, thus its connections get no TCP_USER_TIMEOUT. Its listener sets the keepalive idle to 30 s: an idle connection to a client that is gone ends 165 s after the last data.
+
 ### 0.3.15
 
 - **The cluster of a quorum queue of RabbitMQ 4.3.6.** Two new documents, each from the source in the release of RabbitMQ:

package/build/index.d.ts

@@ -1,4 +1,40 @@
 import { Expr, Machine } from "@mark1russell7/algebra";
+//#region src/grpc/grpc-go-server.d.ts
+/**
+ * This document is a server of grpc-go v1.84.0 on its own listener: grpc.NewServer on net.Listen, at the
+ * defaults, as in the server of the harness. Its keepalive is on (a PING after 2 h with no read). Thus the
+ * transport gives each accepted connection a TCP_USER_TIMEOUT of 20 s. With the TCP keepalive of Go
+ * (15 s, 15 s, 9), an idle connection to a client that is gone ends 30 s after the last data. A client
+ * that pings more often than 5 min with a stream open, or than 2 h with none, gets GOAWAY
+ * too_many_pings at its third strike.
+ */
+export declare const GRPC_GO_SERVER: Machine;
+/**
+ * This document is the server of etcd v3.6.15, on grpc-go v1.83.2, at the defaults: one client URL with no
+ * TLS. The keepalive of the server is 2 h and 20 s, and a client can ping each 5 s with a stream open.
+ * The server serves gRPC and HTTP on one port through cmux. Thus the transport gets a wrapper of the conn,
+ * and it sets no TCP_USER_TIMEOUT. The listener sets the keepalive idle to 30 s. The interval and the
+ * count of Go stay. Thus an idle connection to a gone client ends 165 s after the last data: 30 + 9 × 15.
+ */
+export declare const ETCD_SERVER: Machine;
+//#endregion
+//#region src/grpc/grpc-js.d.ts
+/**
+ * This document is grpc-js 1.14.6 on Node, for one channel to one server with no TLS, its transport
+ * (one HTTP/2 session on one TCP connection) and one unary call on it. It gives the states of the
+ * transport, from its connect to its end, and the timers that act on it.
+ *
+ * At the defaults the keepalive of grpc-js is off: it sends no PING. It sets TCP_NODELAY and no TCP
+ * keepalive, and its connect has no timeout. A call has no deadline. Thus nothing in grpc-js ends a
+ * call on a silent connection: only the kernel can, or the server.
+ *
+ * When the transport ends, each call in flight on it ends with UNAVAILABLE. The client does not retry such
+ * a call, because the call reached the server (PROCESSED). It retries only a call that did not start, and
+ * once a stream that the server refused. The channel then goes IDLE, and the next call connects again. A call
+ * that finds the channel in TRANSIENT_FAILURE fails at once, unless it asks to wait for the channel.
+ */
+export declare const GRPC_JS: Machine;
+//#endregion
 //#region src/http/go-transport.d.ts
 /**
  * This document is one connection of the `http.Transport` of Go 1.27.2 at its defaults, over its