@mark1russell7/machines 0.3.22 → 0.3.23
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
- package/README.md +2 -2
- package/build/index.d.ts +7 -5
- package/build/index.js +224 -213
- package/build/index.js.map +1 -1
- package/package.json +1 -1
package/build/index.js
CHANGED
|
@@ -1,49 +1,49 @@
|
|
|
1
1
|
import { machineSchema } from "@mark1russell7/algebra";
|
|
2
2
|
import { z } from "zod";
|
|
3
3
|
//#region src/grpc/grpc-go-server.ts
|
|
4
|
-
const AT$
|
|
4
|
+
const AT$15 = "grpc-go v1.84.0";
|
|
5
5
|
const GO = "go1.27.2 src/net";
|
|
6
6
|
const ETCD = "etcd v3.6.15";
|
|
7
7
|
/** These are the facts of the transport of grpc-go, for each server on it. */
|
|
8
8
|
const TRANSPORT = [
|
|
9
9
|
{
|
|
10
|
-
ref: `${AT$
|
|
10
|
+
ref: `${AT$15} internal/transport/defaults.go:31-40 the server keepalive: Time 2 h, Timeout 20 s. MinTime of the policy 5 min. MaxConnectionIdle, Age and AgeGrace infinite`,
|
|
11
11
|
rung: "implemented"
|
|
12
12
|
},
|
|
13
13
|
{
|
|
14
|
-
ref: `${AT$
|
|
14
|
+
ref: `${AT$15} internal/transport/http2_server.go:226-253 the defaults of the parameters, a jitter of 10 % on MaxConnectionAge, and TCP_USER_TIMEOUT = Timeout when Time is not infinite`,
|
|
15
15
|
rung: "implemented"
|
|
16
16
|
},
|
|
17
17
|
{
|
|
18
|
-
ref: `${AT$
|
|
18
|
+
ref: `${AT$15} internal/syscall/syscall_linux.go:71-90 SetTCPUserTimeout acts only on a *net.TCPConn. On any other net.Conn it does nothing`,
|
|
19
19
|
rung: "implemented"
|
|
20
20
|
},
|
|
21
21
|
{
|
|
22
|
-
ref: `${AT$
|
|
22
|
+
ref: `${AT$15} internal/transport/http2_server.go:1197-1286 keepalive(): a PING after Time with no read, and Close when no read comes for Timeout after it. MaxConnectionIdle and MaxConnectionAge drain with GOAWAY, and AgeGrace closes`,
|
|
23
23
|
rung: "implemented"
|
|
24
24
|
},
|
|
25
25
|
{
|
|
26
|
-
ref: `${AT$
|
|
26
|
+
ref: `${AT$15} internal/transport/http2_server.go:881-933 handlePing: a PING less than MinTime after the last one is a strike, and with no stream open and PermitWithoutStream false, less than 2 h. The third strike sends GOAWAY ENHANCE_YOUR_CALM too_many_pings and closes the connection`,
|
|
27
27
|
rung: "implemented"
|
|
28
28
|
},
|
|
29
29
|
{
|
|
30
|
-
ref: `${AT$
|
|
30
|
+
ref: `${AT$15} internal/transport/http2_server.go:279-281, :1064, :1132, :1176 each write of headers, a status or data by the server clears the strikes`,
|
|
31
31
|
rung: "implemented"
|
|
32
32
|
},
|
|
33
33
|
{
|
|
34
|
-
ref: `${AT$
|
|
34
|
+
ref: `${AT$15} internal/transport/http2_server.go:1291-1310 Close closes the net.Conn: a FIN, or a reset when bytes are unread`,
|
|
35
35
|
rung: "implemented"
|
|
36
36
|
},
|
|
37
37
|
{
|
|
38
|
-
ref: `${AT$
|
|
38
|
+
ref: `${AT$15} internal/transport/http2_server.go:536-537, :603-615 a call with the header grpc-timeout gets a timer of that timeout from the read of its headers. Its end closes the stream with RST_STREAM CANCEL, and the context of the handler ends`,
|
|
39
39
|
rung: "implemented"
|
|
40
40
|
},
|
|
41
41
|
{
|
|
42
|
-
ref: `${AT$
|
|
42
|
+
ref: `${AT$15} server.go:192, :1000-1009 a deadline of 120 s for the handshake of each new connection (ConnectionTimeout)`,
|
|
43
43
|
rung: "implemented"
|
|
44
44
|
},
|
|
45
45
|
{
|
|
46
|
-
ref: `${AT$
|
|
46
|
+
ref: `${AT$15} server.go:894-905 the comment of grpc-go: Go sets a TCP keepalive of 15 s on each accepted connection`,
|
|
47
47
|
rung: "documented"
|
|
48
48
|
},
|
|
49
49
|
{
|
|
@@ -702,7 +702,7 @@ const ETCD_SERVER = serverOf({
|
|
|
702
702
|
});
|
|
703
703
|
//#endregion
|
|
704
704
|
//#region src/grpc/grpc-js.ts
|
|
705
|
-
const AT$
|
|
705
|
+
const AT$14 = "@grpc/grpc-js 1.14.6 src";
|
|
706
706
|
/**
|
|
707
707
|
* This document is grpc-js 1.14.6 on Node, for one channel to one server with no TLS, its transport
|
|
708
708
|
* (one HTTP/2 session on one TCP connection) and one unary call on it. It gives the states of the
|
|
@@ -732,83 +732,83 @@ const GRPC_JS = machineSchema.parse({
|
|
|
732
732
|
},
|
|
733
733
|
sources: [
|
|
734
734
|
{
|
|
735
|
-
ref: `${AT$
|
|
735
|
+
ref: `${AT$14}/transport.ts:70 KEEPALIVE_TIMEOUT_MS is 20000`,
|
|
736
736
|
rung: "implemented"
|
|
737
737
|
},
|
|
738
738
|
{
|
|
739
|
-
ref: `${AT$
|
|
739
|
+
ref: `${AT$14}/transport.ts:183-198 grpc.keepalive_time_ms is -1 when the caller gives none, grpc.keepalive_timeout_ms is 20000, and grpc.keepalive_permit_without_calls is false`,
|
|
740
740
|
rung: "implemented"
|
|
741
741
|
},
|
|
742
742
|
{
|
|
743
|
-
ref: `${AT$
|
|
743
|
+
ref: `${AT$14}/transport.ts:447-453 a PING goes out only with a keepalive time above 0, and with a call in flight or permit_without_calls`,
|
|
744
744
|
rung: "implemented"
|
|
745
745
|
},
|
|
746
746
|
{
|
|
747
|
-
ref: `${AT$
|
|
747
|
+
ref: `${AT$14}/transport.ts:455-507 each PING starts a timer of keepalive_timeout_ms, and its end with no ACK ends the transport (handleDisconnect). A failed send of the PING ends it too`,
|
|
748
748
|
rung: "implemented"
|
|
749
749
|
},
|
|
750
750
|
{
|
|
751
|
-
ref: `${AT$
|
|
751
|
+
ref: `${AT$14}/transport.ts:515-534 and :553-561 the keepalive timer starts with the first call in flight, and after each ACK. It is not reset by data. When it ends with no call in flight, the PING goes out at the start of the next call`,
|
|
752
752
|
rung: "implemented"
|
|
753
753
|
},
|
|
754
754
|
{
|
|
755
|
-
ref: `${AT$
|
|
755
|
+
ref: `${AT$14}/transport.ts:200-242 a close or an error of the session, or a close of its socket, ends the transport. A GOAWAY makes it unusable (reportDisconnectToOwner)`,
|
|
756
756
|
rung: "implemented"
|
|
757
757
|
},
|
|
758
758
|
{
|
|
759
|
-
ref: `${AT$
|
|
759
|
+
ref: `${AT$14}/transport.ts:205-227 a GOAWAY ENHANCE_YOUR_CALM with the data too_many_pings tells the subchannel that the server refused the pings`,
|
|
760
760
|
rung: "implemented"
|
|
761
761
|
},
|
|
762
762
|
{
|
|
763
|
-
ref: `${AT$
|
|
763
|
+
ref: `${AT$14}/transport.ts:431-441 handleDisconnect: each call in flight gets onDisconnect, and the session is destroyed in the next turn of the event loop`,
|
|
764
764
|
rung: "implemented"
|
|
765
765
|
},
|
|
766
766
|
{
|
|
767
|
-
ref: `${AT$
|
|
767
|
+
ref: `${AT$14}/transport.ts:684-687 shutdown closes the session: a GOAWAY, then the end of the socket after the last stream`,
|
|
768
768
|
rung: "implemented"
|
|
769
769
|
},
|
|
770
770
|
{
|
|
771
|
-
ref: `${AT$
|
|
771
|
+
ref: `${AT$14}/transport.ts:792-810 the transport is ready at the first SETTINGS of the server (remoteSettings)`,
|
|
772
772
|
rung: "implemented"
|
|
773
773
|
},
|
|
774
774
|
{
|
|
775
|
-
ref: `${AT$
|
|
775
|
+
ref: `${AT$14}/transport.ts:818-840 the TCP connect is net.connect with no timeout`,
|
|
776
776
|
rung: "implemented"
|
|
777
777
|
},
|
|
778
778
|
{
|
|
779
|
-
ref: `${AT$
|
|
779
|
+
ref: `${AT$14}/transport.ts:862 setNoDelay on each connection: TCP_NODELAY, thus no Nagle. No setKeepAlive anywhere in the package`,
|
|
780
780
|
rung: "implemented"
|
|
781
781
|
},
|
|
782
782
|
{
|
|
783
|
-
ref: `${AT$
|
|
783
|
+
ref: `${AT$14}/subchannel-call.ts:360-371 onDisconnect ends the call with UNAVAILABLE 'Connection dropped' in the next turn of the event loop, unless the stream ends first`,
|
|
784
784
|
rung: "implemented"
|
|
785
785
|
},
|
|
786
786
|
{
|
|
787
|
-
ref: `${AT$
|
|
787
|
+
ref: `${AT$14}/subchannel-call.ts:230-329 the end of a stream with no status: REFUSED_STREAM is UNAVAILABLE, CANCEL after a dropped connection is UNAVAILABLE, and an internal error of ECONNRESET or ETIMEDOUT is UNAVAILABLE`,
|
|
788
788
|
rung: "implemented"
|
|
789
789
|
},
|
|
790
790
|
{
|
|
791
|
-
ref: `${AT$
|
|
791
|
+
ref: `${AT$14}/load-balancing-call.ts:257-261 a stream that the server refused has the progress REFUSED, and any other started stream PROCESSED`,
|
|
792
792
|
rung: "implemented"
|
|
793
793
|
},
|
|
794
794
|
{
|
|
795
|
-
ref: `${AT$
|
|
795
|
+
ref: `${AT$14}/retrying-call.ts:631-652 a transparent retry for NOT_STARTED, and one for REFUSED. A PROCESSED call is retried only by a retry policy of the service config, which the defaults do not have`,
|
|
796
796
|
rung: "implemented"
|
|
797
797
|
},
|
|
798
798
|
{
|
|
799
|
-
ref: `${AT$
|
|
799
|
+
ref: `${AT$14}/load-balancing-call.ts:338-345 a pick in TRANSIENT_FAILURE fails the call at once, unless it asks for waitForReady`,
|
|
800
800
|
rung: "implemented"
|
|
801
801
|
},
|
|
802
802
|
{
|
|
803
|
-
ref: `${AT$
|
|
803
|
+
ref: `${AT$14}/resolving-call.ts:118-180 the deadline of a call is a timer from the start of the call. Its end cancels the call with DEADLINE_EXCEEDED`,
|
|
804
804
|
rung: "implemented"
|
|
805
805
|
},
|
|
806
806
|
{
|
|
807
|
-
ref: `${AT$
|
|
807
|
+
ref: `${AT$14}/deadline.ts:39-52 the header grpc-timeout is the time left to the deadline when the call sends its headers, rounded up to whole milliseconds. A server can start a timer of it`,
|
|
808
808
|
rung: "implemented"
|
|
809
809
|
},
|
|
810
810
|
{
|
|
811
|
-
ref: `${AT$
|
|
811
|
+
ref: `${AT$14}/subchannel-call.ts:269-279 a RST_STREAM CANCEL of the server ends the call with CANCELLED 'Call cancelled'`,
|
|
812
812
|
rung: "implemented"
|
|
813
813
|
},
|
|
814
814
|
{
|
|
@@ -816,23 +816,23 @@ const GRPC_JS = machineSchema.parse({
|
|
|
816
816
|
rung: "observed"
|
|
817
817
|
},
|
|
818
818
|
{
|
|
819
|
-
ref: `${AT$
|
|
819
|
+
ref: `${AT$14}/subchannel.ts:275-291 the end of the transport takes the subchannel from READY to IDLE. After too_many_pings the keepalive time doubles`,
|
|
820
820
|
rung: "implemented"
|
|
821
821
|
},
|
|
822
822
|
{
|
|
823
|
-
ref: `${AT$
|
|
823
|
+
ref: `${AT$14}/subchannel.ts:298-304 a failed connect takes the subchannel to TRANSIENT_FAILURE`,
|
|
824
824
|
rung: "implemented"
|
|
825
825
|
},
|
|
826
826
|
{
|
|
827
|
-
ref: `${AT$
|
|
827
|
+
ref: `${AT$14}/backoff-timeout.ts:23-26 the reconnect waits 1000 ms first, each next wait 1.6 times longer, up to 120000 ms, with a jitter of 0.2`,
|
|
828
828
|
rung: "implemented"
|
|
829
829
|
},
|
|
830
830
|
{
|
|
831
|
-
ref: `${AT$
|
|
831
|
+
ref: `${AT$14}/backoff-timeout.ts:124, :169-181, :197-201 the first wait after a reset is the initial delay, with no jitter. Each next wait is the last wait, jitter included, times 1.6 and capped, then ± 20 %: the jitter compounds`,
|
|
832
832
|
rung: "implemented"
|
|
833
833
|
},
|
|
834
834
|
{
|
|
835
|
-
ref: `${AT$
|
|
835
|
+
ref: `${AT$14}/internal-channel.ts:74-77 and :324-325 a channel with no call for grpc.client_idle_timeout_ms goes IDLE: 30 min at the defaults, 1 s at least`,
|
|
836
836
|
rung: "implemented"
|
|
837
837
|
},
|
|
838
838
|
{
|
|
@@ -2586,7 +2586,7 @@ const UNDICI_CLIENT = machineSchema.parse({
|
|
|
2586
2586
|
});
|
|
2587
2587
|
//#endregion
|
|
2588
2588
|
//#region src/http/undici-retry.ts
|
|
2589
|
-
const AT$
|
|
2589
|
+
const AT$13 = "undici 8.12.2 lib/handler/retry-handler.js";
|
|
2590
2590
|
/**
|
|
2591
2591
|
* This document is one request through a `RetryAgent` of undici 8.12.2: the retries of a reply
|
|
2592
2592
|
* whose status is retryable, for example 429 or 503. Each fact comes from the published package at
|
|
@@ -2620,7 +2620,7 @@ const UNDICI_RETRY = machineSchema.parse({
|
|
|
2620
2620
|
},
|
|
2621
2621
|
sources: [
|
|
2622
2622
|
{
|
|
2623
|
-
ref: `${AT$
|
|
2623
|
+
ref: `${AT$13}:125-133 the defaults: retryAfter true, maxTimeout 30000, minTimeout 500, timeoutFactor 2, maxRetries 5, the methods GET HEAD OPTIONS PUT DELETE TRACE QUERY, the statusCodes 500 502 503 504 429`,
|
|
2624
2624
|
rung: "implemented"
|
|
2625
2625
|
},
|
|
2626
2626
|
{
|
|
@@ -2628,19 +2628,19 @@ const UNDICI_RETRY = machineSchema.parse({
|
|
|
2628
2628
|
rung: "implemented"
|
|
2629
2629
|
},
|
|
2630
2630
|
{
|
|
2631
|
-
ref: `${AT$
|
|
2631
|
+
ref: `${AT$13}:331-351 the policy: a method or a status out of its lists is not retried, and a counter above maxRetries gives up`,
|
|
2632
2632
|
rung: "implemented"
|
|
2633
2633
|
},
|
|
2634
2634
|
{
|
|
2635
|
-
ref: `${AT$
|
|
2635
|
+
ref: `${AT$13}:353-370 the delay: Retry-After in seconds times 1000, or an HTTP-date less the clock of the client (:13-16), capped by maxTimeout; 0 at once; else min(minTimeout * timeoutFactor^(counter - 1), maxTimeout); then setTimeout`,
|
|
2636
2636
|
rung: "implemented"
|
|
2637
2637
|
},
|
|
2638
2638
|
{
|
|
2639
|
-
ref: `${AT$
|
|
2639
|
+
ref: `${AT$13}:380 the counter: one more at each reply`,
|
|
2640
2640
|
rung: "implemented"
|
|
2641
2641
|
},
|
|
2642
2642
|
{
|
|
2643
|
-
ref: `${AT$
|
|
2643
|
+
ref: `${AT$13}:175-192 and :518-535 a retryable status with throwOnError drops the body of the reply, and the error goes to the policy`,
|
|
2644
2644
|
rung: "implemented"
|
|
2645
2645
|
},
|
|
2646
2646
|
{
|
|
@@ -2802,7 +2802,7 @@ const UNDICI_RETRY = machineSchema.parse({
|
|
|
2802
2802
|
});
|
|
2803
2803
|
//#endregion
|
|
2804
2804
|
//#region src/ioredis-sentinel.ts
|
|
2805
|
-
const AT$
|
|
2805
|
+
const AT$12 = "ioredis 6.0.0 built";
|
|
2806
2806
|
/**
|
|
2807
2807
|
* This document is the Sentinel path of ioredis 6.0.0. It tells how ioredis finds the primary of a
|
|
2808
2808
|
* group through the Sentinels, loses it, and connects to the new one. The standalone states of
|
|
@@ -2823,43 +2823,43 @@ const IOREDIS_SENTINEL = machineSchema.parse({
|
|
|
2823
2823
|
},
|
|
2824
2824
|
sources: [
|
|
2825
2825
|
{
|
|
2826
|
-
ref: `${AT$
|
|
2826
|
+
ref: `${AT$12}/connectors/SentinelConnector/index.js:46-121 connect (each Sentinel in turn, then sentinelRetryStrategy)`,
|
|
2827
2827
|
rung: "implemented"
|
|
2828
2828
|
},
|
|
2829
2829
|
{
|
|
2830
|
-
ref: `${AT$
|
|
2830
|
+
ref: `${AT$12}/connectors/SentinelConnector/index.js:145-151 resolveMaster (get-master-addr-by-name, then SENTINEL sentinels)`,
|
|
2831
2831
|
rung: "implemented"
|
|
2832
2832
|
},
|
|
2833
2833
|
{
|
|
2834
|
-
ref: `${AT$
|
|
2834
|
+
ref: `${AT$12}/connectors/SentinelConnector/index.js:175-212 connectToSentinel and resolve (one connection for each question, no retry)`,
|
|
2835
2835
|
rung: "implemented"
|
|
2836
2836
|
},
|
|
2837
2837
|
{
|
|
2838
|
-
ref: `${AT$
|
|
2838
|
+
ref: `${AT$12}/connectors/SentinelConnector/index.js:27-39 check (the role of the ready check)`,
|
|
2839
2839
|
rung: "implemented"
|
|
2840
2840
|
},
|
|
2841
2841
|
{
|
|
2842
|
-
ref: `${AT$
|
|
2842
|
+
ref: `${AT$12}/connectors/SentinelConnector/FailoverDetector.js:6-43 (+switch-master, only with failoverDetector)`,
|
|
2843
2843
|
rung: "implemented"
|
|
2844
2844
|
},
|
|
2845
2845
|
{
|
|
2846
|
-
ref: `${AT$
|
|
2846
|
+
ref: `${AT$12}/redis/RedisOptions.js:9-57 (the defaults)`,
|
|
2847
2847
|
rung: "implemented"
|
|
2848
2848
|
},
|
|
2849
2849
|
{
|
|
2850
|
-
ref: `${AT$
|
|
2850
|
+
ref: `${AT$12}/redis/event_handler.js:294-355 closeHandler (retryStrategy, then maxRetriesPerRequest flushes the queue)`,
|
|
2851
2851
|
rung: "implemented"
|
|
2852
2852
|
},
|
|
2853
2853
|
{
|
|
2854
|
-
ref: `${AT$
|
|
2854
|
+
ref: `${AT$12}/redis/event_handler.js:364-449 readyHandler (retryAttempts back to 0, the resend, the offline queue)`,
|
|
2855
2855
|
rung: "implemented"
|
|
2856
2856
|
},
|
|
2857
2857
|
{
|
|
2858
|
-
ref: `${AT$
|
|
2858
|
+
ref: `${AT$12}/Redis.js:123-240 _connect (connectTimeout, keepAlive) and :379-405 sendCommand (the offline queue)`,
|
|
2859
2859
|
rung: "implemented"
|
|
2860
2860
|
},
|
|
2861
2861
|
{
|
|
2862
|
-
ref: `${AT$
|
|
2862
|
+
ref: `${AT$12}/Redis.js:599-605 handleReconnection (reconnectOnError: null, thus a READONLY error goes to the caller)`,
|
|
2863
2863
|
rung: "implemented"
|
|
2864
2864
|
}
|
|
2865
2865
|
],
|
|
@@ -5019,7 +5019,7 @@ const IOREDIS_STATUS = machineSchema.parse(ioredis_status_default);
|
|
|
5019
5019
|
const MANIFESTATIONS = z.record(z.string(), z.array(z.string())).parse(manifestations_default);
|
|
5020
5020
|
//#endregion
|
|
5021
5021
|
//#region src/mongo/mongod-replication.ts
|
|
5022
|
-
const AT$
|
|
5022
|
+
const AT$11 = "mongodb r9.0.4 src/mongo/db/repl";
|
|
5023
5023
|
/**
|
|
5024
5024
|
* This document is the replication of mongod 9.0.4. It gives one member of a replica set, its view
|
|
5025
5025
|
* of the primary, and the election that it can hold. The states are the states of the member. The
|
|
@@ -5050,95 +5050,95 @@ const MONGOD_REPL = machineSchema.parse({
|
|
|
5050
5050
|
},
|
|
5051
5051
|
sources: [
|
|
5052
5052
|
{
|
|
5053
|
-
ref: `${AT$
|
|
5053
|
+
ref: `${AT$11}/repl_set_config.idl:74-109 the settings: heartbeatIntervalMillis 2000, heartbeatTimeoutSecs 10, electionTimeoutMillis 10000, catchUpTimeoutMillis -1, catchUpTakeoverDelayMillis 30000`,
|
|
5054
5054
|
rung: "implemented"
|
|
5055
5055
|
},
|
|
5056
5056
|
{
|
|
5057
|
-
ref: `${AT$
|
|
5057
|
+
ref: `${AT$11}/repl_server_parameters.idl:320-328 replElectionTimeoutOffsetLimitFraction 0.15`,
|
|
5058
5058
|
rung: "implemented"
|
|
5059
5059
|
},
|
|
5060
5060
|
{
|
|
5061
|
-
ref: `${AT$
|
|
5061
|
+
ref: `${AT$11}/topology_coordinator.cpp:1058-1101 the heartbeat window and the timeout of each request, :1124-1147 the next heartbeat, :1239-1248 a member DOWN`,
|
|
5062
5062
|
rung: "implemented"
|
|
5063
5063
|
},
|
|
5064
5064
|
{
|
|
5065
|
-
ref: `${AT$
|
|
5065
|
+
ref: `${AT$11}/topology_coordinator.h:62 kMaxHeartbeatRetries 2`,
|
|
5066
5066
|
rung: "implemented"
|
|
5067
5067
|
},
|
|
5068
5068
|
{
|
|
5069
|
-
ref: `${AT$
|
|
5069
|
+
ref: `${AT$11}/replication_coordinator_impl_heartbeat.cpp:97-111 the random offset, :346-352 a heartbeat from the primary postpones the election, :1215-1271 the election timeout and its offset`,
|
|
5070
5070
|
rung: "implemented"
|
|
5071
5071
|
},
|
|
5072
5072
|
{
|
|
5073
|
-
ref: `${AT$
|
|
5073
|
+
ref: `${AT$11}/data_replicator_external_state_impl.cpp:70-81 an oplog batch that names a primary postpones the election`,
|
|
5074
5074
|
rung: "implemented"
|
|
5075
5075
|
},
|
|
5076
5076
|
{
|
|
5077
|
-
ref: `${AT$
|
|
5077
|
+
ref: `${AT$11}/delayable_timeout_callback.cpp:149-172 the offset changes at most once in its own length`,
|
|
5078
5078
|
rung: "implemented"
|
|
5079
5079
|
},
|
|
5080
5080
|
{
|
|
5081
|
-
ref: `${AT$
|
|
5081
|
+
ref: `${AT$11}/topology_coordinator.cpp:1440-1457 and :1476-1489 the liveness check: a primary that cannot see a majority steps down`,
|
|
5082
5082
|
rung: "implemented"
|
|
5083
5083
|
},
|
|
5084
5084
|
{
|
|
5085
|
-
ref: `${AT$
|
|
5085
|
+
ref: `${AT$11}/replication_coordinator_impl_heartbeat.cpp:1158-1188 the liveness check runs at the stalest member's last update plus the election timeout`,
|
|
5086
5086
|
rung: "implemented"
|
|
5087
5087
|
},
|
|
5088
5088
|
{
|
|
5089
|
-
ref: `${AT$
|
|
5089
|
+
ref: `${AT$11}/replication_coordinator_impl_elect_v1.cpp:189-226 the dry run, :268-382 the term, the durable vote and the real vote, :408-468 the win`,
|
|
5090
5090
|
rung: "implemented"
|
|
5091
5091
|
},
|
|
5092
5092
|
{
|
|
5093
|
-
ref: `${AT$
|
|
5093
|
+
ref: `${AT$11}/vote_requester.cpp:96 a vote request times out at min(electionTimeoutMillis, 30 s), :160-177 a majority of yes votes ends the round`,
|
|
5094
5094
|
rung: "implemented"
|
|
5095
5095
|
},
|
|
5096
5096
|
{
|
|
5097
|
-
ref: `${AT$
|
|
5097
|
+
ref: `${AT$11}/topology_coordinator.cpp:3741-3790 a member votes for each candidate whose data is not staler than its own, and only an arbiter refuses one because it sees a primary`,
|
|
5098
5098
|
rung: "implemented"
|
|
5099
5099
|
},
|
|
5100
5100
|
{
|
|
5101
|
-
ref: `${AT$
|
|
5101
|
+
ref: `${AT$11}/replication_coordinator_impl_catchup.cpp:35-85 the catch-up and its timeout, :110-133 it ends when each other member answered a heartbeat since the win, or failed one, :349-379 the win restarts each heartbeat`,
|
|
5102
5102
|
rung: "implemented"
|
|
5103
5103
|
},
|
|
5104
5104
|
{
|
|
5105
|
-
ref: `${AT$
|
|
5105
|
+
ref: `${AT$11}/topology_coordinator.cpp:3841-3849 and :3910-3932 a restarted heartbeat, and the latest optime that the catch-up waits for`,
|
|
5106
5106
|
rung: "implemented"
|
|
5107
5107
|
},
|
|
5108
5108
|
{
|
|
5109
|
-
ref: `${AT$
|
|
5109
|
+
ref: `${AT$11}/replication_coordinator_impl.cpp:1490-1570 the end of the drain: a reconfig of the term, then writes, :2580-2588 the hello of a primary that cannot write yet`,
|
|
5110
5110
|
rung: "implemented"
|
|
5111
5111
|
},
|
|
5112
5112
|
{
|
|
5113
|
-
ref: `${AT$
|
|
5113
|
+
ref: `${AT$11}/replication_coordinator_impl_step_up_step_down.cpp:64-329 replSetStepDown: the wait for a caught-up secondary, the step-down and the hand-off`,
|
|
5114
5114
|
rung: "implemented"
|
|
5115
5115
|
},
|
|
5116
5116
|
{
|
|
5117
|
-
ref: `${AT$
|
|
5117
|
+
ref: `${AT$11}/repl_set_commands.cpp:545-561 stepDownSecs 60 and secondaryCatchUpPeriodSecs 10`,
|
|
5118
5118
|
rung: "implemented"
|
|
5119
5119
|
},
|
|
5120
5120
|
{
|
|
5121
|
-
ref: `${AT$
|
|
5121
|
+
ref: `${AT$11}/replication_coordinator_impl.idl:18-26 enableElectionHandoff true, and replication_coordinator_impl.cpp:2830-2873 the hand-off: replSetStepUp with skipDryRun`,
|
|
5122
5122
|
rung: "implemented"
|
|
5123
5123
|
},
|
|
5124
5124
|
{
|
|
5125
|
-
ref: `${AT$
|
|
5125
|
+
ref: `${AT$11}/replication_coordinator_impl.cpp:1516 the reconfig of the term, :4598 and :4750 a new config starts each heartbeat again`,
|
|
5126
5126
|
rung: "implemented"
|
|
5127
5127
|
},
|
|
5128
5128
|
{
|
|
5129
|
-
ref: `${AT$
|
|
5129
|
+
ref: `${AT$11}/replication_coordinator_impl_heartbeat.cpp:367-376 a heartbeat response that moves a member's optime forward moves the commit point and wakes the writes that wait`,
|
|
5130
5130
|
rung: "implemented"
|
|
5131
5131
|
},
|
|
5132
5132
|
{
|
|
5133
|
-
ref: `${AT$
|
|
5133
|
+
ref: `${AT$11}/oplog_fetcher.cpp:119-133 the awaitData timeout min(electionTimeoutMillis / 2, 30 s), :317-324 the socket timeout adds oplogNetworkTimeoutBufferSeconds, :640-647 the exhaust read`,
|
|
5134
5134
|
rung: "implemented"
|
|
5135
5135
|
},
|
|
5136
5136
|
{
|
|
5137
|
-
ref: `${AT$
|
|
5137
|
+
ref: `${AT$11}/oplog_fetcher.cpp:395-441 an error makes a new cursor while restarts remain, :596-611 the new cursor sets the retried find timeout, :1073-1113 one restart after 5 ms`,
|
|
5138
5138
|
rung: "implemented"
|
|
5139
5139
|
},
|
|
5140
5140
|
{
|
|
5141
|
-
ref: `${AT$
|
|
5141
|
+
ref: `${AT$11}/repl_server_parameters.idl:121-126 oplogRetriedFindMaxSeconds 2, :234-244 oplogFetcherSteadyStateMaxFetcherRestarts 1, :344-351 oplogNetworkTimeoutBufferSeconds 5`,
|
|
5142
5142
|
rung: "implemented"
|
|
5143
5143
|
},
|
|
5144
5144
|
{
|
|
@@ -5146,19 +5146,19 @@ const MONGOD_REPL = machineSchema.parse({
|
|
|
5146
5146
|
rung: "implemented"
|
|
5147
5147
|
},
|
|
5148
5148
|
{
|
|
5149
|
-
ref: `${AT$
|
|
5149
|
+
ref: `${AT$11}/bgsync.cpp:395-447 a member without a sync source waits for new heartbeat data or 1 s (:971-976), and topology_coordinator.cpp:1124-1136 it sends its heartbeats each 500 ms`,
|
|
5150
5150
|
rung: "implemented"
|
|
5151
5151
|
},
|
|
5152
5152
|
{
|
|
5153
|
-
ref: `${AT$
|
|
5153
|
+
ref: `${AT$11}/replication_coordinator_impl.cpp:4947-4972 a member that loses its sync source starts each heartbeat again at once`,
|
|
5154
5154
|
rung: "implemented"
|
|
5155
5155
|
},
|
|
5156
5156
|
{
|
|
5157
|
-
ref: `${AT$
|
|
5157
|
+
ref: `${AT$11}/sync_source_feedback.cpp:37-47 the keepalive of the reporter min(electionTimeoutMillis / 2, 30 s), :39-40 the network timeout 30 s, :99-117 and :134-236 a new reporter only after the old one ends`,
|
|
5158
5158
|
rung: "implemented"
|
|
5159
5159
|
},
|
|
5160
5160
|
{
|
|
5161
|
-
ref: `${AT$
|
|
5161
|
+
ref: `${AT$11}/reporter.cpp:113-117 a reporter ends when its command in flight ends, :119-169 a trigger, :195-228 each replSetUpdatePosition has the network timeout`,
|
|
5162
5162
|
rung: "implemented"
|
|
5163
5163
|
},
|
|
5164
5164
|
{
|
|
@@ -5777,7 +5777,7 @@ const MONGOD_REPL = machineSchema.parse({
|
|
|
5777
5777
|
});
|
|
5778
5778
|
//#endregion
|
|
5779
5779
|
//#region src/mongo/mongod-session.ts
|
|
5780
|
-
const AT$
|
|
5780
|
+
const AT$10 = "mongodb r9.0.4 src/mongo";
|
|
5781
5781
|
/**
|
|
5782
5782
|
* This document is the hold of mongod 9.0.4 on one client connection, over its socket. `mongod`
|
|
5783
5783
|
* turns keepalive on for each TCP session. It lowers two keepalive options of the socket to a
|
|
@@ -5804,27 +5804,27 @@ const MONGOD_SESSION = machineSchema.parse({
|
|
|
5804
5804
|
},
|
|
5805
5805
|
sources: [
|
|
5806
5806
|
{
|
|
5807
|
-
ref: `${AT$
|
|
5807
|
+
ref: `${AT$10}/transport/asio/asio_session_impl.cpp:156-165 each TCP session: TCP_NODELAY, SO_KEEPALIVE, setSocketKeepAliveParams, failures at debug 3 in a release build`,
|
|
5808
5808
|
rung: "implemented"
|
|
5809
5809
|
},
|
|
5810
5810
|
{
|
|
5811
|
-
ref: `${AT$
|
|
5811
|
+
ref: `${AT$10}/util/net/socket_utils.h:15-16 kMaxKeepIdleSecs 300 and kMaxKeepIntvlSecs 1, :19-22 the defaults of setSocketKeepAliveParams`,
|
|
5812
5812
|
rung: "implemented"
|
|
5813
5813
|
},
|
|
5814
5814
|
{
|
|
5815
|
-
ref: `${AT$
|
|
5815
|
+
ref: `${AT$10}/util/net/socket_utils.cpp:165-196 applyMax: read the option, and set the maximum only when the value is higher, :199-220 TCP_KEEPIDLE and TCP_KEEPINTVL, never TCP_KEEPCNT`,
|
|
5816
5816
|
rung: "implemented"
|
|
5817
5817
|
},
|
|
5818
5818
|
{
|
|
5819
|
-
ref: `${AT$
|
|
5819
|
+
ref: `${AT$10}/util/net/socket_utils.cpp:176-181 and :190-194 the log of a failed read or set, at the severity of the caller`,
|
|
5820
5820
|
rung: "implemented"
|
|
5821
5821
|
},
|
|
5822
5822
|
{
|
|
5823
|
-
ref: `${AT$
|
|
5823
|
+
ref: `${AT$10}/util/net/sock.cpp:135-142 the older socket path: SO_KEEPALIVE, then the same maximums, failures as errors`,
|
|
5824
5824
|
rung: "implemented"
|
|
5825
5825
|
},
|
|
5826
5826
|
{
|
|
5827
|
-
ref: `${AT$
|
|
5827
|
+
ref: `${AT$10}/db/repl/replication_info.cpp:131-143 an awaitable hello waits until now + maxAwaitTimeMS on the precise clock, or a change of the topology`,
|
|
5828
5828
|
rung: "implemented"
|
|
5829
5829
|
}
|
|
5830
5830
|
],
|
|
@@ -5986,7 +5986,7 @@ const MONGOD_SESSION = machineSchema.parse({
|
|
|
5986
5986
|
});
|
|
5987
5987
|
//#endregion
|
|
5988
5988
|
//#region src/mongo/mongodb-node.ts
|
|
5989
|
-
const AT$
|
|
5989
|
+
const AT$9 = "mongodb 7.7.0 src";
|
|
5990
5990
|
/**
|
|
5991
5991
|
* This document is the MongoDB Node driver 7.7.0, for one server of a replica set. It gives one
|
|
5992
5992
|
* connection of the driver by its role, and the timers that act on it. The roles are the monitor
|
|
@@ -6013,75 +6013,75 @@ const MONGODB_NODE = machineSchema.parse({
|
|
|
6013
6013
|
},
|
|
6014
6014
|
sources: [
|
|
6015
6015
|
{
|
|
6016
|
-
ref: `${AT$
|
|
6016
|
+
ref: `${AT$9}/connection_string.ts:804-807 connectTimeoutMS 30000, :850-853 heartbeatFrequencyMS 10000, :934-937 minHeartbeatFrequencyMS 500`,
|
|
6017
6017
|
rung: "implemented"
|
|
6018
6018
|
},
|
|
6019
6019
|
{
|
|
6020
|
-
ref: `${AT$
|
|
6020
|
+
ref: `${AT$9}/connection_string.ts:1100-1103 serverSelectionTimeoutMS 30000, :1107-1111 socketTimeoutMS 0, :1178-1182 waitQueueTimeoutMS 0`,
|
|
6021
6021
|
rung: "implemented"
|
|
6022
6022
|
},
|
|
6023
6023
|
{
|
|
6024
|
-
ref: `${AT$
|
|
6024
|
+
ref: `${AT$9}/connection_string.ts:896-898 maxConnecting 2, :906-908 maxIdleTimeMS 0, :910-912 maxPoolSize 100, :930-933 minPoolSize 0, :1075-1082 retryReads and retryWrites true, :1089-1091 serverMonitoringMode auto`,
|
|
6025
6025
|
rung: "implemented"
|
|
6026
6026
|
},
|
|
6027
6027
|
{
|
|
6028
|
-
ref: `${AT$
|
|
6028
|
+
ref: `${AT$9}/cmap/connect.ts:291 DEFAULT_KEEP_ALIVE_INITIAL_DELAY_MS 120000, :336-338 keepAlive and noDelay, :378-417 makeSocket: setKeepAlive, setNoDelay, setTimeout(connectTimeoutMS), :432-438 the connect timeout`,
|
|
6029
6029
|
rung: "implemented"
|
|
6030
6030
|
},
|
|
6031
6031
|
{
|
|
6032
|
-
ref: `${AT$
|
|
6032
|
+
ref: `${AT$9}/cmap/connect.ts:117-120 the handshake reads with socketTimeoutMS = connectTimeoutMS`,
|
|
6033
6033
|
rung: "implemented"
|
|
6034
6034
|
},
|
|
6035
6035
|
{
|
|
6036
|
-
ref: `${AT$
|
|
6036
|
+
ref: `${AT$9}/sdam/monitor.ts:245-259 the streaming protocol, :338-371 the awaitable hello: maxAwaitTimeMS = heartbeatFrequencyMS, socketTimeoutMS = connectTimeoutMS + maxAwaitTimeMS`,
|
|
6037
6037
|
rung: "implemented"
|
|
6038
6038
|
},
|
|
6039
6039
|
{
|
|
6040
|
-
ref: `${AT$
|
|
6040
|
+
ref: `${AT$9}/sdam/monitor.ts:273-293 a failed heartbeat: ResetPool, and InterruptInUseConnections for a timeout`,
|
|
6041
6041
|
rung: "implemented"
|
|
6042
6042
|
},
|
|
6043
6043
|
{
|
|
6044
|
-
ref: `${AT$
|
|
6044
|
+
ref: `${AT$9}/sdam/monitor.ts:175-194 reset: the next check after heartbeatFrequencyMS, :609-636 wake: no check sooner than minHeartbeatFrequencyMS, :668-691 the next check after heartbeatFrequencyMS`,
|
|
6045
6045
|
rung: "implemented"
|
|
6046
6046
|
},
|
|
6047
6047
|
{
|
|
6048
|
-
ref: `${AT$
|
|
6048
|
+
ref: `${AT$9}/sdam/monitor.ts:490-565 the RTT pinger: its own connection, a hello each heartbeatFrequencyMS, no socket timeout`,
|
|
6049
6049
|
rung: "implemented"
|
|
6050
6050
|
},
|
|
6051
6051
|
{
|
|
6052
|
-
ref: `${AT$
|
|
6052
|
+
ref: `${AT$9}/cmap/connection.ts:328-334 a socket timeout, 1 ms later, is a MongoNetworkTimeoutError, :461-505 the socket timeout of a command, set again at each reply`,
|
|
6053
6053
|
rung: "implemented"
|
|
6054
6054
|
},
|
|
6055
6055
|
{
|
|
6056
|
-
ref: `${AT$
|
|
6056
|
+
ref: `${AT$9}/sdam/server.ts:186 resetServer, :390-444 handleError, :450-515 decorateCommandError, :532-546 markServerUnknown: a network error that is not a timeout resets the monitor`,
|
|
6057
6057
|
rung: "implemented"
|
|
6058
6058
|
},
|
|
6059
6059
|
{
|
|
6060
|
-
ref: `${AT$
|
|
6060
|
+
ref: `${AT$9}/sdam/topology.ts:559 the selection timeout, :568-572 and :635-664 MongoServerSelectionError, :862-888 updateServers clears the pool, :1082-1089 a waiting selection wakes each monitor`,
|
|
6061
6061
|
rung: "implemented"
|
|
6062
6062
|
},
|
|
6063
6063
|
{
|
|
6064
|
-
ref: `${AT$
|
|
6064
|
+
ref: `${AT$9}/sdam/topology_description.ts:458-467 a primary that another primary replaces is Unknown, and nothing clears its pool`,
|
|
6065
6065
|
rung: "implemented"
|
|
6066
6066
|
},
|
|
6067
6067
|
{
|
|
6068
|
-
ref: `${AT$
|
|
6068
|
+
ref: `${AT$9}/cmap/connection_pool.ts:417-468 clear, :475-481 interruptInUseConnections: PoolClearedOnNetworkError, :584 a connection idle for maxIdleTimeMS is perished at the next check-out`,
|
|
6069
6069
|
rung: "implemented"
|
|
6070
6070
|
},
|
|
6071
6071
|
{
|
|
6072
|
-
ref: `${AT$
|
|
6072
|
+
ref: `${AT$9}/cmap/errors.ts:37-84 PoolClearedError and PoolClearedOnNetworkError, with the label PoolRequestedRetry`,
|
|
6073
6073
|
rung: "implemented"
|
|
6074
6074
|
},
|
|
6075
6075
|
{
|
|
6076
|
-
ref: `${AT$
|
|
6076
|
+
ref: `${AT$9}/operations/execute_operation.ts:252-279 two attempts for a retryable read or write, :375-380 the retry selects a server again, :442-445 canRetry`,
|
|
6077
6077
|
rung: "implemented"
|
|
6078
6078
|
},
|
|
6079
6079
|
{
|
|
6080
|
-
ref: `${AT$
|
|
6080
|
+
ref: `${AT$9}/error.ts:1377-1394 the retryable codes, :1431-1436 isRetryableWriteError: RetryableWriteError or PoolRequestedRetry`,
|
|
6081
6081
|
rung: "implemented"
|
|
6082
6082
|
},
|
|
6083
6083
|
{
|
|
6084
|
-
ref: `${AT$
|
|
6084
|
+
ref: `${AT$9}/timeout.ts:362-372 the legacy timeout context: the selection timeout, and no check-out timeout at waitQueueTimeoutMS 0`,
|
|
6085
6085
|
rung: "implemented"
|
|
6086
6086
|
},
|
|
6087
6087
|
{
|
|
@@ -7761,7 +7761,7 @@ const HIKARICP_PGJDBC = machineSchema.parse({
|
|
|
7761
7761
|
});
|
|
7762
7762
|
//#endregion
|
|
7763
7763
|
//#region src/pg/node-postgres.ts
|
|
7764
|
-
const AT$
|
|
7764
|
+
const AT$8 = "pg 8.23.1 lib";
|
|
7765
7765
|
const POOL = "pg-pool 3.14.0";
|
|
7766
7766
|
/**
|
|
7767
7767
|
* This document is node-postgres 8.23.1 (the npm package pg) with pg-pool 3.14.0, for one client
|
|
@@ -7803,75 +7803,75 @@ const NODE_POSTGRES = machineSchema.parse({
|
|
|
7803
7803
|
rung: "implemented"
|
|
7804
7804
|
},
|
|
7805
7805
|
{
|
|
7806
|
-
ref: `${AT$
|
|
7806
|
+
ref: `${AT$8}/defaults.js:42 max 10 and :46 idleTimeoutMillis 30000: no line of pg or pg-pool reads them, thus a pool does not use them`,
|
|
7807
7807
|
rung: "implemented"
|
|
7808
7808
|
},
|
|
7809
7809
|
{
|
|
7810
|
-
ref: `${AT$
|
|
7810
|
+
ref: `${AT$8}/defaults.js:65, :69, :73 and :76 statement_timeout, lock_timeout, idle_in_transaction_session_timeout and query_timeout are false`,
|
|
7811
7811
|
rung: "implemented"
|
|
7812
7812
|
},
|
|
7813
7813
|
{
|
|
7814
|
-
ref: `${AT$
|
|
7814
|
+
ref: `${AT$8}/defaults.js:63-76 the comments of pg: each of the four is in milliseconds, false is no limit, and query_timeout is on the client side`,
|
|
7815
7815
|
rung: "documented"
|
|
7816
7816
|
},
|
|
7817
7817
|
{
|
|
7818
|
-
ref: `${AT$
|
|
7818
|
+
ref: `${AT$8}/connection-parameters.js:9-23 val: the config, else the default of pg, :121-124 the three timeouts of the server and query_timeout, with no environment variable`,
|
|
7819
7819
|
rung: "implemented"
|
|
7820
7820
|
},
|
|
7821
7821
|
{
|
|
7822
|
-
ref: `${AT$
|
|
7822
|
+
ref: `${AT$8}/client.js:89-98 the Connection gets keepAlive false and keepAliveInitialDelayMillis 0 when the config does not give them, :116 connectionTimeoutMillis 0`,
|
|
7823
7823
|
rung: "implemented"
|
|
7824
7824
|
},
|
|
7825
7825
|
{
|
|
7826
|
-
ref: `${AT$
|
|
7826
|
+
ref: `${AT$8}/stream.js:20-24 and :78-83 outside Cloudflare Workers, the socket is a new net.Socket with no option`,
|
|
7827
7827
|
rung: "implemented"
|
|
7828
7828
|
},
|
|
7829
7829
|
{
|
|
7830
|
-
ref: `${AT$
|
|
7830
|
+
ref: `${AT$8}/connection.js:40-52 setNoDelay(true) before the connect, and setKeepAlive(true, keepAliveInitialDelayMillis) at the connect only when keepAlive is true, :54-65 the error and the close of the socket`,
|
|
7831
7831
|
rung: "implemented"
|
|
7832
7832
|
},
|
|
7833
7833
|
{
|
|
7834
|
-
ref: `${AT$
|
|
7834
|
+
ref: `${AT$8}/client.js:167-176 and :702-737 are the only timers of the client, and connection.js has none: the client sends nothing by itself on an idle connection`,
|
|
7835
7835
|
rung: "implemented"
|
|
7836
7836
|
},
|
|
7837
7837
|
{
|
|
7838
|
-
ref: `${AT$
|
|
7838
|
+
ref: `${AT$8}/client.js:153-230 _connect: no second connect, the connect timer of the client ('timeout expired'), and 'Connection terminated unexpectedly' for an end that the client did not ask for`,
|
|
7839
7839
|
rung: "implemented"
|
|
7840
7840
|
},
|
|
7841
7841
|
{
|
|
7842
|
-
ref: `${AT$
|
|
7842
|
+
ref: `${AT$8}/client.js:373-387 the first ReadyForQuery ends the connect and clears the timer, :398-423 an error before it goes to the connect callback, and an error after it makes the client unqueryable`,
|
|
7843
7843
|
rung: "implemented"
|
|
7844
7844
|
},
|
|
7845
7845
|
{
|
|
7846
|
-
ref: `${AT$
|
|
7846
|
+
ref: `${AT$8}/client.js:426-442 an ErrorResponse fails the active query only, and with no active query it is an error of the client`,
|
|
7847
7847
|
rung: "implemented"
|
|
7848
7848
|
},
|
|
7849
7849
|
{
|
|
7850
|
-
ref: `${AT$
|
|
7850
|
+
ref: `${AT$8}/connection.js:137-145 and pg-protocol 1.16.1 dist/parser.js:142-144, :296-323 an ErrorResponse is a DatabaseError, with the severity and the code that the server gives`,
|
|
7851
7851
|
rung: "implemented"
|
|
7852
7852
|
},
|
|
7853
7853
|
{
|
|
7854
|
-
ref: `${AT$
|
|
7854
|
+
ref: `${AT$8}/client.js:133-151 _errorAllQueries: each query of the client fails with the same error, on the next tick`,
|
|
7855
7855
|
rung: "implemented"
|
|
7856
7856
|
},
|
|
7857
7857
|
{
|
|
7858
|
-
ref: `${AT$
|
|
7858
|
+
ref: `${AT$8}/query.js:122-150 a query gives its error or its result to its callback, at the error or at the ReadyForQuery`,
|
|
7859
7859
|
rung: "implemented"
|
|
7860
7860
|
},
|
|
7861
7861
|
{
|
|
7862
|
-
ref: `${AT$
|
|
7862
|
+
ref: `${AT$8}/client.js:702-737 query_timeout: a Node timer for each query, 'Query read timeout'. The client sends no cancel, and it keeps the active query`,
|
|
7863
7863
|
rung: "implemented"
|
|
7864
7864
|
},
|
|
7865
7865
|
{
|
|
7866
|
-
ref: `${AT$
|
|
7866
|
+
ref: `${AT$8}/client.js:616-641 the next query goes only after a ReadyForQuery, :765-777 a query on an unqueryable or ended client fails at once`,
|
|
7867
7867
|
rung: "implemented"
|
|
7868
7868
|
},
|
|
7869
7869
|
{
|
|
7870
|
-
ref: `${AT$
|
|
7870
|
+
ref: `${AT$8}/client.js:799-836 end: a dead socket or an active query destroys the socket, else connection.js:217-227 sends Terminate and ends the socket`,
|
|
7871
7871
|
rung: "implemented"
|
|
7872
7872
|
},
|
|
7873
7873
|
{
|
|
7874
|
-
ref: `${AT$
|
|
7874
|
+
ref: `${AT$8}/client.js:543-572 getStartupConf: statement_timeout, lock_timeout and idle_in_transaction_session_timeout go to the server only when they are set`,
|
|
7875
7875
|
rung: "implemented"
|
|
7876
7876
|
},
|
|
7877
7877
|
{
|
|
@@ -10267,7 +10267,7 @@ const PGPOOL_SESSION = machineSchema.parse({
|
|
|
10267
10267
|
});
|
|
10268
10268
|
//#endregion
|
|
10269
10269
|
//#region src/pg/postgres-session.ts
|
|
10270
|
-
const AT$
|
|
10270
|
+
const AT$7 = "postgresql REL_17_11 src";
|
|
10271
10271
|
const DOC = "postgresql REL_17_11 doc/src/sgml";
|
|
10272
10272
|
/**
|
|
10273
10273
|
* This document is the hold of a PostgreSQL 17.11 backend on one client connection, over its TCP
|
|
@@ -10307,163 +10307,163 @@ const POSTGRES_SESSION = machineSchema.parse({
|
|
|
10307
10307
|
rung: "implemented"
|
|
10308
10308
|
},
|
|
10309
10309
|
{
|
|
10310
|
-
ref: `${AT$
|
|
10310
|
+
ref: `${AT$7}/backend/tcop/backend_startup.c:157-161 BackendInitialize calls pq_init in the backend, before the startup packet`,
|
|
10311
10311
|
rung: "implemented"
|
|
10312
10312
|
},
|
|
10313
10313
|
{
|
|
10314
|
-
ref: `${AT$
|
|
10314
|
+
ref: `${AT$7}/backend/libpq/pqcomm.c:793-817 AcceptConnection in the postmaster, :180 the Port starts at zeros, :195-220 TCP_NODELAY and SO_KEEPALIVE on each socket that is not AF_UNIX, a failure is FATAL, :264-274 then the four TCP GUCs, a failure is a LOG only`,
|
|
10315
10315
|
rung: "implemented"
|
|
10316
10316
|
},
|
|
10317
10317
|
{
|
|
10318
|
-
ref: `${AT$
|
|
10318
|
+
ref: `${AT$7}/backend/libpq/pqcomm.c:1663-1711 pq_setkeepalivesidle: no call at a value equal to the Port's, and 0 sets the value that getsockopt read first; :1748-1795, :1827-1870 and :1902-1945 the same for TCP_KEEPINTVL, TCP_KEEPCNT and TCP_USER_TIMEOUT`,
|
|
10319
10319
|
rung: "implemented"
|
|
10320
10320
|
},
|
|
10321
10321
|
{
|
|
10322
|
-
ref: `${AT$
|
|
10322
|
+
ref: `${AT$7}/backend/libpq/pqcomm.c:87-90 TCP_KEEPIDLE on Linux, :1947-2047 an assign hook sets the socket of the session at once, and a show hook reads the kernel`,
|
|
10323
10323
|
rung: "implemented"
|
|
10324
10324
|
},
|
|
10325
10325
|
{
|
|
10326
|
-
ref: `${AT$
|
|
10326
|
+
ref: `${AT$7}/backend/utils/misc/guc_tables.c:3452-3461 tcp_keepalives_idle 0 s, :3463-3472 tcp_keepalives_interval 0 s, :3485-3495 tcp_keepalives_count 0, :3587-3596 tcp_user_timeout 0 ms: each PGC_USERSET, 0 to INT_MAX, 0 is the system default`,
|
|
10327
10327
|
rung: "implemented"
|
|
10328
10328
|
},
|
|
10329
10329
|
{
|
|
10330
|
-
ref: `${AT$
|
|
10330
|
+
ref: `${AT$7}/backend/utils/misc/guc_tables.c:2611-2620 statement_timeout, :2622-2631 lock_timeout, :2633-2642 idle_in_transaction_session_timeout, :2644-2653 transaction_timeout, :2655-2664 idle_session_timeout: each 0 ms, 0 to INT_MAX, PGC_USERSET, 0 turns it off`,
|
|
10331
10331
|
rung: "implemented"
|
|
10332
10332
|
},
|
|
10333
10333
|
{
|
|
10334
|
-
ref: `${AT$
|
|
10334
|
+
ref: `${AT$7}/backend/utils/misc/guc_tables.c:2774-2783 authentication_timeout 60 s, 1 to 600, PGC_SIGHUP; :3632-3641 client_connection_check_interval 0 ms, 0 to INT_MAX, PGC_USERSET`,
|
|
10335
10335
|
rung: "implemented"
|
|
10336
10336
|
},
|
|
10337
10337
|
{
|
|
10338
|
-
ref: `${AT$
|
|
10338
|
+
ref: `${AT$7}/backend/storage/lmgr/proc.c:58-62, backend/tcop/postgres.c:106 and backend/postmaster/postmaster.c:228 the C defaults agree: 0 ms for each timeout, 0 ms for the client check, 60 s for authentication`,
|
|
10339
10339
|
rung: "implemented"
|
|
10340
10340
|
},
|
|
10341
10341
|
{
|
|
10342
|
-
ref: `${AT$
|
|
10342
|
+
ref: `${AT$7}/include/utils/timeout.h:3-4 and :23-43 one SIGALRM for each timeout id, STARTUP_PACKET_TIMEOUT to CLIENT_CONNECTION_CHECK_TIMEOUT`,
|
|
10343
10343
|
rung: "implemented"
|
|
10344
10344
|
},
|
|
10345
10345
|
{
|
|
10346
|
-
ref: `${AT$
|
|
10346
|
+
ref: `${AT$7}/backend/utils/misc/timeout.c:559-575 enable_timeout_after: the deadline is the current time + the delay in ms, :209-350 schedule_alarm: setitimer(ITIMER_REAL) for the nearest deadline, :363-453 handle_sig_alarm sets the latch and calls each handler that is due`,
|
|
10347
10347
|
rung: "implemented"
|
|
10348
10348
|
},
|
|
10349
10349
|
{
|
|
10350
|
-
ref: `${AT$
|
|
10350
|
+
ref: `${AT$7}/backend/utils/init/postinit.c:770-782 the handlers of a backend, :1374-1407 the statement timer sends SIGINT, or SIGTERM in authentication, and the lock timer sends SIGINT, :1409-1447 each other handler sets a flag and the latch`,
|
|
10351
10351
|
rung: "implemented"
|
|
10352
10352
|
},
|
|
10353
10353
|
{
|
|
10354
|
-
ref: `${AT$
|
|
10354
|
+
ref: `${AT$7}/backend/tcop/postgres.c:2999-3023 die (SIGTERM) sets ProcDiePending, :3029-3043 StatementCancelHandler (SIGINT) sets QueryCancelPending, :4292-4294 the two handlers`,
|
|
10355
10355
|
rung: "implemented"
|
|
10356
10356
|
},
|
|
10357
10357
|
{
|
|
10358
|
-
ref: `${AT$
|
|
10358
|
+
ref: `${AT$7}/backend/tcop/postgres.c:3271-3319 ProcessInterrupts acts on a die request first: FATAL 57014 "canceling authentication due to timeout" in authentication, else FATAL 57P01 "terminating connection due to administrator command"`,
|
|
10359
10359
|
rung: "implemented"
|
|
10360
10360
|
},
|
|
10361
10361
|
{
|
|
10362
|
-
ref: `${AT$
|
|
10362
|
+
ref: `${AT$7}/backend/tcop/postgres.c:3321-3350 then the client check, then a lost connection: FATAL 08006 "connection to client lost", with no message to the client`,
|
|
10363
10363
|
rung: "implemented"
|
|
10364
10364
|
},
|
|
10365
10365
|
{
|
|
10366
|
-
ref: `${AT$
|
|
10366
|
+
ref: `${AT$7}/backend/tcop/postgres.c:3372-3430 a cancel: ERROR 55P03 "canceling statement due to lock timeout", ERROR 57014 "canceling statement due to statement timeout"`,
|
|
10367
10367
|
rung: "implemented"
|
|
10368
10368
|
},
|
|
10369
10369
|
{
|
|
10370
|
-
ref: `${AT$
|
|
10370
|
+
ref: `${AT$7}/backend/tcop/postgres.c:3435-3477 FATAL 25P03 "terminating connection due to idle-in-transaction timeout", FATAL 25P04 "terminating connection due to transaction timeout", FATAL 57P05 "terminating connection due to idle-session timeout"`,
|
|
10371
10371
|
rung: "implemented"
|
|
10372
10372
|
},
|
|
10373
10373
|
{
|
|
10374
|
-
ref: `${AT$
|
|
10374
|
+
ref: `${AT$7}/backend/utils/errcodes.txt:106-107 08003 and 08006, :111 08P01, :254-255 25P03 and 25P04, :421 55P03, :428-429 57014 and 57P01, :433 57P05`,
|
|
10375
10375
|
rung: "implemented"
|
|
10376
10376
|
},
|
|
10377
10377
|
{
|
|
10378
|
-
ref: `${AT$
|
|
10378
|
+
ref: `${AT$7}/backend/tcop/postgres.c:4618-4706 at ReadyForQuery the backend arms idle_in_transaction_session_timeout in a transaction block, open or aborted, and idle_session_timeout outside one; :4714-4750 after a message it disarms them, then checks for interrupts`,
|
|
10379
10379
|
rung: "implemented"
|
|
10380
10380
|
},
|
|
10381
10381
|
{
|
|
10382
|
-
ref: `${AT$
|
|
10382
|
+
ref: `${AT$7}/backend/tcop/postgres.c:2770-2796 start_xact_command arms statement_timeout and the client check, each only when not active, :2798-2802 finish_xact_command disarms statement_timeout, :5251-5278 no statement timer when statement_timeout >= transaction_timeout > 0`,
|
|
10383
10383
|
rung: "implemented"
|
|
10384
10384
|
},
|
|
10385
10385
|
{
|
|
10386
|
-
ref: `${AT$
|
|
10386
|
+
ref: `${AT$7}/backend/utils/adt/misc.c:391-412 pg_sleep: CHECK_FOR_INTERRUPTS before each WaitLatch on the latch of the backend, thus the SIGALRM of a timeout ends its wait`,
|
|
10387
10387
|
rung: "implemented"
|
|
10388
10388
|
},
|
|
10389
10389
|
{
|
|
10390
|
-
ref: `${AT$
|
|
10390
|
+
ref: `${AT$7}/backend/tcop/postgres.c:4446-4502 an ERROR: disable_all_timeouts, the error to the client, AbortCurrentTransaction; :4562-4563 then ReadyForQuery`,
|
|
10391
10391
|
rung: "implemented"
|
|
10392
10392
|
},
|
|
10393
10393
|
{
|
|
10394
|
-
ref: `${AT$
|
|
10394
|
+
ref: `${AT$7}/backend/access/transam/xact.c:2174-2176 StartTransaction arms transaction_timeout, :2315-2317, :2592-2594 and :2768-2770 commit, prepare and abort disarm it, :3472-3477 an error in a transaction block aborts the transaction and keeps the block`,
|
|
10395
10395
|
rung: "implemented"
|
|
10396
10396
|
},
|
|
10397
10397
|
{
|
|
10398
|
-
ref: `${AT$
|
|
10398
|
+
ref: `${AT$7}/backend/storage/lmgr/proc.c:1292-1307 ProcSleep arms lock_timeout with the deadlock timer, :1652-1666 and disarms it after the wait`,
|
|
10399
10399
|
rung: "implemented"
|
|
10400
10400
|
},
|
|
10401
10401
|
{
|
|
10402
|
-
ref: `${AT$
|
|
10402
|
+
ref: `${AT$7}/backend/tcop/postgres.c:3652-3661 a client_connection_check_interval above 0 needs a wait set that reports a close`,
|
|
10403
10403
|
rung: "implemented"
|
|
10404
10404
|
},
|
|
10405
10405
|
{
|
|
10406
|
-
ref: `${AT$
|
|
10406
|
+
ref: `${AT$7}/backend/libpq/pqcomm.c:2049-2084 pq_check_connection: a wait of 0 ms for WL_SOCKET_CLOSED`,
|
|
10407
10407
|
rung: "implemented"
|
|
10408
10408
|
},
|
|
10409
10409
|
{
|
|
10410
|
-
ref: `${AT$
|
|
10410
|
+
ref: `${AT$7}/backend/storage/ipc/latch.c:72-85 epoll where sys/epoll.h exists, :1131-1156 WL_SOCKET_CLOSED adds EPOLLRDHUP, and EPOLLERR and EPOLLHUP are always on, :1661-1680 EPOLLERR or EPOLLHUP make the socket readable, writable and closed, :2253-2263 epoll can report a close`,
|
|
10411
10411
|
rung: "implemented"
|
|
10412
10412
|
},
|
|
10413
10413
|
{
|
|
10414
|
-
ref: `${AT$
|
|
10414
|
+
ref: `${AT$7}/backend/libpq/be-secure.c:174-261 secure_read and :300-370 secure_write: a wait for the socket or the latch with no timeout; at the latch, ProcessClientReadInterrupt or ProcessClientWriteInterrupt; :234-237 and :343-346 FATAL 57P01 at the death of the postmaster`,
|
|
10415
10415
|
rung: "implemented"
|
|
10416
10416
|
},
|
|
10417
10417
|
{
|
|
10418
|
-
ref: `${AT$
|
|
10418
|
+
ref: `${AT$7}/backend/tcop/postgres.c:513-548 ProcessClientReadInterrupt: each interrupt in the wait for a command, a die request in another read; :559-600 ProcessClientWriteInterrupt: a die request only, with no message to the client`,
|
|
10419
10419
|
rung: "implemented"
|
|
10420
10420
|
},
|
|
10421
10421
|
{
|
|
10422
|
-
ref: `${AT$
|
|
10422
|
+
ref: `${AT$7}/backend/libpq/pqcomm.c:287-297 the socket has O_NONBLOCK, and the latch gives the waits; :896-956 pq_recvbuf: 0 bytes or an error is EOF, and an error logs COMMERROR "could not receive data from client: %m"`,
|
|
10423
10423
|
rung: "implemented"
|
|
10424
10424
|
},
|
|
10425
10425
|
{
|
|
10426
|
-
ref: `${AT$
|
|
10426
|
+
ref: `${AT$7}/backend/tcop/postgres.c:364-396 SocketBackend: EOF in a transaction logs COMMERROR 08006 "unexpected EOF on client connection with an open transaction", else DEBUG1 08003; :4988-5016 EOF or Terminate: proc_exit(0)`,
|
|
10427
10427
|
rung: "implemented"
|
|
10428
10428
|
},
|
|
10429
10429
|
{
|
|
10430
|
-
ref: `${AT$
|
|
10430
|
+
ref: `${AT$7}/backend/access/transam/xact.c:383-396 IsTransactionState is TRANS_INPROGRESS only; backend/utils/init/postinit.c:1360-1371 ShutdownPostgres aborts the transaction at exit`,
|
|
10431
10431
|
rung: "implemented"
|
|
10432
10432
|
},
|
|
10433
10433
|
{
|
|
10434
|
-
ref: `${AT$
|
|
10434
|
+
ref: `${AT$7}/backend/libpq/pqcomm.c:1275-1336 a full buffer flushes, and the flush waits for the socket, :1358-1423 internal_flush_buffer: an error logs COMMERROR "could not send data to client: %m" once for each errno, drops the buffer and sets ClientConnectionLost`,
|
|
10435
10435
|
rung: "implemented"
|
|
10436
10436
|
},
|
|
10437
10437
|
{
|
|
10438
|
-
ref: `${AT$
|
|
10438
|
+
ref: `${AT$7}/backend/tcop/postgres.c:4310-4316 the backend ignores SIGPIPE`,
|
|
10439
10439
|
rung: "implemented"
|
|
10440
10440
|
},
|
|
10441
10441
|
{
|
|
10442
|
-
ref: `${AT$
|
|
10442
|
+
ref: `${AT$7}/include/utils/elog.h:31-38 COMMERROR is LOG_SERVER_ONLY; backend/utils/error/elog.c:205-228 it goes to the log at log_min_messages WARNING (guc_tables.c:534), and DEBUG1 does not`,
|
|
10443
10443
|
rung: "implemented"
|
|
10444
10444
|
},
|
|
10445
10445
|
{
|
|
10446
|
-
ref: `${AT$
|
|
10446
|
+
ref: `${AT$7}/backend/utils/error/elog.c:245-262 and :1726-1732 an error goes to the client while the output is DestRemote, :3643-3651 the backend flushes it, :559-590 FATAL ends the process with proc_exit(1)`,
|
|
10447
10447
|
rung: "implemented"
|
|
10448
10448
|
},
|
|
10449
10449
|
{
|
|
10450
|
-
ref: `${AT$
|
|
10450
|
+
ref: `${AT$7}/backend/libpq/pqcomm.c:347-392 socket_close keeps the socket open until the process exits`,
|
|
10451
10451
|
rung: "implemented"
|
|
10452
10452
|
},
|
|
10453
10453
|
{
|
|
10454
|
-
ref: `${AT$
|
|
10454
|
+
ref: `${AT$7}/backend/tcop/backend_startup.c:237-253 the startup timer: authentication_timeout, after the DNS lookup, :311-314 the end of the startup packet disarms it, :895-922 its handler and SIGTERM call _exit(1), with no log and no message`,
|
|
10455
10455
|
rung: "implemented"
|
|
10456
10456
|
},
|
|
10457
10457
|
{
|
|
10458
|
-
ref: `${AT$
|
|
10458
|
+
ref: `${AT$7}/backend/tcop/backend_startup.c:460-519 ProcessStartupPacket: no byte is a silent end, a part of a packet logs COMMERROR 08P01 "incomplete startup packet"; :328-333 proc_exit(0)`,
|
|
10459
10459
|
rung: "implemented"
|
|
10460
10460
|
},
|
|
10461
10461
|
{
|
|
10462
|
-
ref: `${AT$
|
|
10462
|
+
ref: `${AT$7}/backend/utils/init/postinit.c:235-251 PerformAuthentication arms the statement timer at authentication_timeout * 1000 ms, :305 ClientAuthInProgress ends after it, :1210-1215 the GUCs of the startup packet apply after it`,
|
|
10463
10463
|
rung: "implemented"
|
|
10464
10464
|
},
|
|
10465
10465
|
{
|
|
10466
|
-
ref: `${AT$
|
|
10466
|
+
ref: `${AT$7}/backend/libpq/auth.c:260-271 an EOF from the client in authentication: proc_exit(0), with no log; :714-744 recv_password_packet gives an EOF as NULL`,
|
|
10467
10467
|
rung: "implemented"
|
|
10468
10468
|
},
|
|
10469
10469
|
{
|
|
@@ -11861,15 +11861,24 @@ const SUPAVISOR_SERVER = machineSchema.parse({
|
|
|
11861
11861
|
//#endregion
|
|
11862
11862
|
//#region src/procedures-ws.ts
|
|
11863
11863
|
/**
|
|
11864
|
-
* This module holds the machine documents of the WebSocket transport of `@procedures/client`
|
|
11865
|
-
*
|
|
11866
|
-
*
|
|
11867
|
-
*
|
|
11864
|
+
* This module holds the machine documents of the WebSocket transport of `@procedures/client` at
|
|
11865
|
+
* commit 2408cea of the client repository: 0.22.0 and two PATCHes after it. The WS and WST cells
|
|
11866
|
+
* run the subject that the client repository builds from that commit (CLI-33). Each fact comes
|
|
11867
|
+
* from the source of that commit, from `@mark1russell7/service` 0.5.8, from ws 8.22.0, or from Node
|
|
11868
|
+
* v24.21.0 and its undici 7.29.1. The comments and the sources give the file and the line.
|
|
11868
11869
|
*
|
|
11869
|
-
* The client repository has a document of the connection
|
|
11870
|
-
* `
|
|
11871
|
-
*
|
|
11870
|
+
* The client repository has a document of the connection: `WEBSOCKET_CONNECTION_MACHINE` in
|
|
11871
|
+
* `packages/client/src/machines.ts`. This document takes its states and its events, and the code
|
|
11872
|
+
* of the transports gives the timers.
|
|
11872
11873
|
*/
|
|
11874
|
+
/** This text is the folder of the WebSocket transports at the commit of the subject. */
|
|
11875
|
+
const AT$6 = "client 2408cea packages/client/src/adapters/websocket";
|
|
11876
|
+
/** This text is the client transport at that commit. */
|
|
11877
|
+
const CT = `${AT$6}/client/transport.ts`;
|
|
11878
|
+
/** This text is the server transport at that commit. */
|
|
11879
|
+
const ST = `${AT$6}/server/transport.ts`;
|
|
11880
|
+
/** This text is the source of the version of the service that the lock of the client gives (pnpm-lock.yaml:443-454). */
|
|
11881
|
+
const SERVICE = "@mark1russell7/service 0.5.8 (systems 571e9e5) packages/service/src";
|
|
11873
11882
|
/** This function gives the arithmetic of a duration in ms. */
|
|
11874
11883
|
const arithmetic = (duration) => {
|
|
11875
11884
|
if (!("expr" in duration) || duration.unit !== "ms") throw new Error("not arithmetic in ms");
|
|
@@ -11882,10 +11891,11 @@ const late = (ms) => arithmetic(nodeTimerLateness(ms));
|
|
|
11882
11891
|
/** This text is the early bound of one Node timer, in ms. */
|
|
11883
11892
|
const EARLY = arithmetic(NODE_TIMER_EARLY);
|
|
11884
11893
|
/**
|
|
11885
|
-
* This document is the connection of the WebSocket client of `@procedures/client` 0.
|
|
11886
|
-
* (`WebSocketTransport`), over its socket class and its Linux TCP socket.
|
|
11894
|
+
* This document is the connection of the WebSocket client of `@procedures/client` 0.22.0 at
|
|
11895
|
+
* commit 2408cea (`WebSocketTransport`), over its socket class and its Linux TCP socket. The
|
|
11896
|
+
* root entry uses the global `WebSocket` of Node, and `@procedures/client/node` uses the `ws` package.
|
|
11887
11897
|
*
|
|
11888
|
-
* - The heartbeat is `heartbeat()` of `@mark1russell7/service` 0.
|
|
11898
|
+
* - The heartbeat is `heartbeat()` of `@mark1russell7/service` 0.5.8. A tick each interval sends a
|
|
11889
11899
|
* ping only when no pong is awaited. The timeout of the ping starts before its send. A
|
|
11890
11900
|
* ping without a pong at its timeout is a miss, and `misses` misses in sequence drop the
|
|
11891
11901
|
* connection. With a timeout below the interval, each tick after a miss sends the next ping.
|
|
@@ -11901,12 +11911,12 @@ const EARLY = arithmetic(NODE_TIMER_EARLY);
|
|
|
11901
11911
|
const PROCEDURES_WS_CLIENT = machineSchema.parse({
|
|
11902
11912
|
format: "mark1russell7.machine/1",
|
|
11903
11913
|
id: "procedures-ws-client",
|
|
11904
|
-
title: "The connection of the WebSocket client of @procedures/client 0.
|
|
11914
|
+
title: "The connection of the WebSocket client of @procedures/client 0.22.0 (client 2408cea)",
|
|
11905
11915
|
layer: "driver",
|
|
11906
|
-
version: "0.
|
|
11916
|
+
version: "0.22.0",
|
|
11907
11917
|
conditions: {
|
|
11908
|
-
"@procedures/client": "0.
|
|
11909
|
-
"@mark1russell7/service": "0.
|
|
11918
|
+
"@procedures/client": "0.22.0 (client 2408cea)",
|
|
11919
|
+
"@mark1russell7/service": "0.5.8",
|
|
11910
11920
|
node: "24.21.0",
|
|
11911
11921
|
undici: "7.29.1",
|
|
11912
11922
|
ws: "8.22.0",
|
|
@@ -11914,27 +11924,27 @@ const PROCEDURES_WS_CLIENT = machineSchema.parse({
|
|
|
11914
11924
|
},
|
|
11915
11925
|
sources: [
|
|
11916
11926
|
{
|
|
11917
|
-
ref:
|
|
11927
|
+
ref: `${CT}:260-290 (the options: each time a duration, its default from TIMER_DEFAULTS.webSocketClient; the misses of the heartbeat at least 1 (:278); the jitter of the reconnect from 0 to 1 (:269); the class of the sockets (:289), used at :324)`,
|
|
11918
11928
|
rung: "implemented"
|
|
11919
11929
|
},
|
|
11920
11930
|
{
|
|
11921
|
-
ref:
|
|
11931
|
+
ref: `${CT}:486-511 startHeartbeat: heartbeat() of @mark1russell7/service with the interval, the timeout and the misses; a tick sends a ping only when CONNECTED (:498); the open starts it (:357-360)`,
|
|
11922
11932
|
rung: "implemented"
|
|
11923
11933
|
},
|
|
11924
11934
|
{
|
|
11925
|
-
ref:
|
|
11935
|
+
ref: `${SERVICE}/heartbeat.ts:129-135 (each tick starts the next one first), :96-127 (the timeout starts before the send of the ping, :110-114 and :117; a send that throws is a miss, :118-121), :81-94 (misses in sequence)`,
|
|
11926
11936
|
rung: "implemented"
|
|
11927
11937
|
},
|
|
11928
11938
|
{
|
|
11929
|
-
ref:
|
|
11939
|
+
ref: `${CT}:401-422 dropConnection: the handlers go (:128-134), terminate() when the class has it (:414-416), else close(), and handleClose at once (:421)`,
|
|
11930
11940
|
rung: "implemented"
|
|
11931
11941
|
},
|
|
11932
11942
|
{
|
|
11933
|
-
ref:
|
|
11943
|
+
ref: `${CT}:172-195 and :460-484: reconnectDelay is backoffDelay of @mark1russell7/service (${SERVICE}/backoff.ts:58-64), with a subtracted jitter; an open sets the attempts to 0 (:345)`,
|
|
11934
11944
|
rung: "implemented"
|
|
11935
11945
|
},
|
|
11936
11946
|
{
|
|
11937
|
-
ref:
|
|
11947
|
+
ref: `${CT}:330-339 and :389-392: the time limit of the handshake, and a failed handshake drops at once`,
|
|
11938
11948
|
rung: "implemented"
|
|
11939
11949
|
},
|
|
11940
11950
|
{
|
|
@@ -11942,15 +11952,15 @@ const PROCEDURES_WS_CLIENT = machineSchema.parse({
|
|
|
11942
11952
|
rung: "implemented"
|
|
11943
11953
|
},
|
|
11944
11954
|
{
|
|
11945
|
-
ref: "ws 8.22.0 lib/websocket.js:
|
|
11955
|
+
ref: "ws 8.22.0 lib/websocket.js:500-517 terminate(): the socket is destroyed at once (:513-516), and a handshake is aborted (:507-511)",
|
|
11946
11956
|
rung: "implemented"
|
|
11947
11957
|
},
|
|
11948
11958
|
{
|
|
11949
|
-
ref:
|
|
11959
|
+
ref: `node v24.21.0 deps/undici/src/lib/core/connect.js:120-129 setKeepAlive(true, 60000); deps/uv/src/unix/tcp.c:591-593 uv_tcp_keepalive: 1 s and 10 probes. The ws package sets no keepalive on its socket (ws 8.22.0 lib/websocket.js:260-261), and the transport gives the class only the URL (${CT}:325, ${AT$6}/client/node.ts:30-34).`,
|
|
11950
11960
|
rung: "implemented"
|
|
11951
11961
|
},
|
|
11952
11962
|
{
|
|
11953
|
-
ref: "client
|
|
11963
|
+
ref: "client 2408cea packages/client/src/machines.ts:76-141 WEBSOCKET_CONNECTION_MACHINE: the states and the events of this document",
|
|
11954
11964
|
rung: "documented"
|
|
11955
11965
|
}
|
|
11956
11966
|
],
|
|
@@ -12184,7 +12194,7 @@ const PROCEDURES_WS_CLIENT = machineSchema.parse({
|
|
|
12184
12194
|
from: "CONNECTING",
|
|
12185
12195
|
on: "open",
|
|
12186
12196
|
to: "CONNECTED",
|
|
12187
|
-
source:
|
|
12197
|
+
source: `${CT}:342-361`
|
|
12188
12198
|
},
|
|
12189
12199
|
{
|
|
12190
12200
|
id: "pw.handshake-timeout",
|
|
@@ -12192,7 +12202,7 @@ const PROCEDURES_WS_CLIENT = machineSchema.parse({
|
|
|
12192
12202
|
on: "handshake-timeout",
|
|
12193
12203
|
to: "RECONNECTING",
|
|
12194
12204
|
timer: "handshake",
|
|
12195
|
-
source:
|
|
12205
|
+
source: `${CT}:330-339`
|
|
12196
12206
|
},
|
|
12197
12207
|
{
|
|
12198
12208
|
id: "pw.ping",
|
|
@@ -12201,7 +12211,7 @@ const PROCEDURES_WS_CLIENT = machineSchema.parse({
|
|
|
12201
12211
|
to: "AWAITING_PONG",
|
|
12202
12212
|
timer: "ping",
|
|
12203
12213
|
emits: ["tx.ping"],
|
|
12204
|
-
source:
|
|
12214
|
+
source: `${CT}:491-511`
|
|
12205
12215
|
},
|
|
12206
12216
|
{
|
|
12207
12217
|
id: "pw.skip",
|
|
@@ -12210,14 +12220,14 @@ const PROCEDURES_WS_CLIENT = machineSchema.parse({
|
|
|
12210
12220
|
to: "AWAITING_PONG",
|
|
12211
12221
|
timer: "ping",
|
|
12212
12222
|
note: "one ping at a time: the tick sends nothing",
|
|
12213
|
-
source:
|
|
12223
|
+
source: `${SERVICE}/heartbeat.ts:129-134`
|
|
12214
12224
|
},
|
|
12215
12225
|
{
|
|
12216
12226
|
id: "pw.pong",
|
|
12217
12227
|
from: "AWAITING_PONG",
|
|
12218
12228
|
on: "pong",
|
|
12219
12229
|
to: "CONNECTED",
|
|
12220
|
-
source:
|
|
12230
|
+
source: `${CT}:566-570`
|
|
12221
12231
|
},
|
|
12222
12232
|
{
|
|
12223
12233
|
id: "pw.pong-timeout",
|
|
@@ -12227,7 +12237,7 @@ const PROCEDURES_WS_CLIENT = machineSchema.parse({
|
|
|
12227
12237
|
timer: "pong",
|
|
12228
12238
|
emits: ["tx.close-frame"],
|
|
12229
12239
|
note: "dropConnection: terminate() destroys the socket of ws at once; close() of the global WebSocket writes a close frame, and its socket stays open below",
|
|
12230
|
-
source:
|
|
12240
|
+
source: `${CT}:401-422, :506-509`
|
|
12231
12241
|
},
|
|
12232
12242
|
{
|
|
12233
12243
|
id: "pw.drop",
|
|
@@ -12239,7 +12249,7 @@ const PROCEDURES_WS_CLIENT = machineSchema.parse({
|
|
|
12239
12249
|
on: "drop",
|
|
12240
12250
|
to: "RECONNECTING",
|
|
12241
12251
|
guard: "the reconnect is on, and tries are left",
|
|
12242
|
-
source:
|
|
12252
|
+
source: `${CT}:375-379, :436-458`
|
|
12243
12253
|
},
|
|
12244
12254
|
{
|
|
12245
12255
|
id: "pw.give-up",
|
|
@@ -12250,7 +12260,7 @@ const PROCEDURES_WS_CLIENT = machineSchema.parse({
|
|
|
12250
12260
|
],
|
|
12251
12261
|
on: "give-up",
|
|
12252
12262
|
to: "DISCONNECTED",
|
|
12253
|
-
source:
|
|
12263
|
+
source: `${CT}:444-445`
|
|
12254
12264
|
},
|
|
12255
12265
|
{
|
|
12256
12266
|
id: "pw.reconnect",
|
|
@@ -12258,7 +12268,7 @@ const PROCEDURES_WS_CLIENT = machineSchema.parse({
|
|
|
12258
12268
|
on: "reconnect-due",
|
|
12259
12269
|
to: "CONNECTING",
|
|
12260
12270
|
timer: "reconnect",
|
|
12261
|
-
source:
|
|
12271
|
+
source: `${CT}:463-484`
|
|
12262
12272
|
},
|
|
12263
12273
|
{
|
|
12264
12274
|
id: "pw.request-timeout",
|
|
@@ -12267,7 +12277,7 @@ const PROCEDURES_WS_CLIENT = machineSchema.parse({
|
|
|
12267
12277
|
to: "CONNECTED",
|
|
12268
12278
|
timer: "request",
|
|
12269
12279
|
errno: "TIMEOUT",
|
|
12270
|
-
source:
|
|
12280
|
+
source: `${CT}:724-733`
|
|
12271
12281
|
},
|
|
12272
12282
|
{
|
|
12273
12283
|
id: "pw.request-timeout-pinged",
|
|
@@ -12276,7 +12286,7 @@ const PROCEDURES_WS_CLIENT = machineSchema.parse({
|
|
|
12276
12286
|
to: "AWAITING_PONG",
|
|
12277
12287
|
timer: "request",
|
|
12278
12288
|
errno: "TIMEOUT",
|
|
12279
|
-
source:
|
|
12289
|
+
source: `${CT}:724-733`
|
|
12280
12290
|
},
|
|
12281
12291
|
{
|
|
12282
12292
|
id: "pw.close",
|
|
@@ -12323,8 +12333,9 @@ const PROCEDURES_WS_CLIENT = machineSchema.parse({
|
|
|
12323
12333
|
}
|
|
12324
12334
|
});
|
|
12325
12335
|
/**
|
|
12326
|
-
* This document is one connection as the WebSocket server of `@procedures/client` 0.
|
|
12327
|
-
* (`WebSocketServerTransport` on the `ws`
|
|
12336
|
+
* This document is one connection as the WebSocket server of `@procedures/client` 0.22.0 at
|
|
12337
|
+
* commit 2408cea holds it (`WebSocketServerTransport` of `@procedures/client/node`, on the `ws`
|
|
12338
|
+
* package), over its Linux TCP socket.
|
|
12328
12339
|
*
|
|
12329
12340
|
* The heartbeat of the server (roadmap R3) is a `setInterval`. Each beat pings each connection,
|
|
12330
12341
|
* and the server ends a connection after `misses` beats without a pong (`terminate()`). Thus the
|
|
@@ -12334,30 +12345,30 @@ const PROCEDURES_WS_CLIENT = machineSchema.parse({
|
|
|
12334
12345
|
const PROCEDURES_WS_SERVER = machineSchema.parse({
|
|
12335
12346
|
format: "mark1russell7.machine/1",
|
|
12336
12347
|
id: "procedures-ws-server",
|
|
12337
|
-
title: "One connection as the WebSocket server of @procedures/client 0.
|
|
12348
|
+
title: "One connection as the WebSocket server of @procedures/client 0.22.0 (client 2408cea) holds it",
|
|
12338
12349
|
layer: "server",
|
|
12339
|
-
version: "0.
|
|
12350
|
+
version: "0.22.0",
|
|
12340
12351
|
conditions: {
|
|
12341
|
-
"@procedures/client": "0.
|
|
12352
|
+
"@procedures/client": "0.22.0 (client 2408cea)",
|
|
12342
12353
|
ws: "8.22.0",
|
|
12343
12354
|
node: "24.21.0",
|
|
12344
12355
|
kernel: "Linux 6.6"
|
|
12345
12356
|
},
|
|
12346
12357
|
sources: [
|
|
12347
12358
|
{
|
|
12348
|
-
ref:
|
|
12359
|
+
ref: `${ST}:146-152 (the heartbeat: interval and misses, or false), :155-175 beat(): terminate after misses (:163-167), or count a miss and ping (:168-173); :232-236 setInterval of the interval; :429 a pong sets the misses to 0`,
|
|
12349
12360
|
rung: "implemented"
|
|
12350
12361
|
},
|
|
12351
12362
|
{
|
|
12352
|
-
ref: "
|
|
12363
|
+
ref: "client 2408cea packages/client/src/timers.ts:86-88 webSocketServer: heartbeatIntervalMs 15000, heartbeatMisses 2",
|
|
12353
12364
|
rung: "implemented"
|
|
12354
12365
|
},
|
|
12355
12366
|
{
|
|
12356
|
-
ref:
|
|
12367
|
+
ref: `${ST}:523-527: a ping of a client gets a pong`,
|
|
12357
12368
|
rung: "implemented"
|
|
12358
12369
|
},
|
|
12359
12370
|
{
|
|
12360
|
-
ref:
|
|
12371
|
+
ref: `node v24.21.0 lib/_http_server.js:646-651 and lib/net.js:2753-2756: keepAlive of http.Server is off at the default, thus an accepted socket has no SO_KEEPALIVE. The transport takes the upgrades of the server of its host (${ST}:187-230) and sets no option of a socket`,
|
|
12361
12372
|
rung: "implemented"
|
|
12362
12373
|
}
|
|
12363
12374
|
],
|
|
@@ -12462,7 +12473,7 @@ const PROCEDURES_WS_SERVER = machineSchema.parse({
|
|
|
12462
12473
|
on: "rx.ping",
|
|
12463
12474
|
to: "OPEN",
|
|
12464
12475
|
emits: ["tx.pong"],
|
|
12465
|
-
source:
|
|
12476
|
+
source: `${ST}:523-527`
|
|
12466
12477
|
},
|
|
12467
12478
|
{
|
|
12468
12479
|
id: "ps.terminate",
|
|
@@ -12471,7 +12482,7 @@ const PROCEDURES_WS_SERVER = machineSchema.parse({
|
|
|
12471
12482
|
to: "CLOSED",
|
|
12472
12483
|
timer: "heartbeat",
|
|
12473
12484
|
emits: ["tx.fin"],
|
|
12474
|
-
source:
|
|
12485
|
+
source: `${ST}:163-167`
|
|
12475
12486
|
},
|
|
12476
12487
|
{
|
|
12477
12488
|
id: "ps.close",
|