@procedures/server 0.20.0 → 0.22.0

package/CHANGELOG.md

@@ -1,5 +1,41 @@
 # @procedures/server
 
+## 0.22.0
+
+### Patch Changes
+
+- @procedures/peer@0.22.0
+  - @procedures/client@0.22.0
+
+## 0.21.0
+
+### Minor Changes
+
+- 4e496ba: Breaking: `server.start` waits for the readiness of the server, and a start that is not ready at the timeout gives `success: false` (CLI-9). Before, the procedure read the lockfile and `host.info` each 500 ms for 15 s, and at the timeout it gave `success: true` with the message "still loading" while the process still started. CLI-9 step 1, a PATCH before this release, marked that result as deprecated.
+  
+  The new behavior:
+  
+  - `server.start` reads the readiness probe of the new listener (`/_probes/readiness`, from CLI-9 step 1) until it answers 200.
+  - The probe has no identity: another server on the port can answer it. Thus the procedure also needs the new lockfile of the port, and `host.info` must answer its token with its peer id.
+  - A listener without probes (a build of `mark` before CLI-9, for example an older `mark` in `PATH`) answers 404. Then `host.info` alone tells the readiness, because the service refuses each call until its startup ends.
+  - The wait stops as soon as the server is ready, or as soon as its process exits. Before, it read each 500 ms and found an exit only at the next read.
+  - An exit before the readiness gives `success: false`, the PID, the log file and the exit code or the signal of the process. A spawn that fails (no `mark` in `PATH`) gives the same result. Before, its error event was not handled.
+  - At the timeout, the result is `success: false`, with the PID of the process that still starts, the port and the log file. The procedure does not stop that process.
+  - The new optional input `timeout` sets the limit in milliseconds (1 to 600000). The default stays 15000.
+  
+  Migration:
+  
+  - A script that runs `mark server start` and reads `success` now gets `false` when the server is not ready at the timeout. Give a longer `timeout` (`mark server start --timeout 60000`), or read `mark server status` later. The `pid` of the result is the process that still starts.
+  - The site: no change. It does not start `server.start`.
+  - MiniMongo: no change. Its dev host starts through `runProcedureHost()`, not through `server.start`.
+  - Graph: no change. Its hosts do not start `server.start`.
+  - jarvis: no change. It does not start `server.start`.
+
+### Patch Changes
+
+- @procedures/client@0.21.0
+  - @procedures/peer@0.21.0
+
 ## 0.20.0
 
 ### Patch Changes

package/README.md

@@ -244,14 +244,16 @@ The package has three procedures. They manage the background server of the `mark
 
 | Procedure | Function |
 |---|---|
-| `server.start` | Start the CLI server as a background process. It writes `~/.mark/server.log`. It waits up to 15 s for the server. |
+| `server.start` | Start the CLI server as a background process, and wait for its readiness. It writes `~/.mark/server.log`. |
 | `server.stop` | Stop the CLI servers of the lockfiles, or the server of one port. A process that does not answer as the peer of its lockfile gets no signal. |
 | `server.status` | Give the state of the CLI servers. It deletes the lockfile of a server that does not answer. |
 
 - `import "@procedures/server/register"` registers them in the global registry. The package root and the `./module` entry register nothing.
 - `mark` finds the package from its `client.procedures` field: `mark server start`, `mark server stop` and `mark server status` run them.
 - The lockfiles stay in `@procedures/peer` (`@procedures/peer/lockfile`), because the peer of `mark --server` writes them.
-- **Deprecated (CLI-9):** at the timeout of 15 s, `server.start` gives `success: true` with the message "still loading" when the process still starts. From the next MINOR of the client group, a start that is not ready at the timeout gives `success: false`, with the PID of the process that still starts. Read the readiness probe (`/_probes/readiness`) or `mark server status` for the state.
+- `server.start` waits for the readiness of the server (CLI-9). It reads the readiness probe of the listener (`/_probes/readiness`) until it answers 200. The probe has no identity, thus `host.info` must also answer the token of the new lockfile with its peer id. A listener without probes (a build of `mark` before CLI-9) answers 404, and then `host.info` alone tells the readiness.
+- The wait stops as soon as the server is ready or its process exits. `timeout` (milliseconds, default 15000) sets the limit.
+- At the timeout, `server.start` gives `success: false` with the PID of the process that still starts. Before CLI-9, it gave `success: true` with the message "still loading".
 
 ---