at main
2 folders
37 files
requests: one client API, reached through run
The eio facade carried two complete client APIs -- the session verbs and a One module duplicating every one of them -- so a caller had to know which of the two to reach for, and opening Requests_eio dumped thirty-two modules into scope, most of them pure vocabulary with no caller. The low-level driver added six request_ names fanning a single function over three optional axes, ending in request_100_continue_stream_decompress.
There is now one verb set, entered through run, which opens the switch and hands back a session; a one-shot is a session that ends with the scope. The driver is Requests_eio_h1.request, one name taking the axes as optional arguments and always streaming, so callers who want a string drain it. The facade carries the thirteen modules callers reach for, ordered session, core types, behaviour, low-level; the rest stay in the pure core. Routing the buffered callers onto the streaming path surfaced a live bug: a fixed-length body that ends early read back as complete, because sub stops at end of input, so a peer promising more than it sends went unnoticed.
opam: fix the dependency hygiene monopam lint reports
Across the packages monopam lint flagged: declare the libraries each
package actually uses (test-only ones scoped with-test, dev tools and
benches scoped with-dev-setup), drop the opam deps and dune (libraries)
entries nothing references, declare pin-depends for the wire and zarith
git pins so a standalone opam install can resolve them, and point the
five stale dune-project source URLs at the names sources.toml already
uses. The generated .opam files are regenerated to match.
Where monopam lint and merlint's project rules disagree, merlint wins:
[protocol] packages keep probe linked (E932), CSV-trace interop tests
keep csv (E825), and dev-scope deps carry the right filter (E943).
The few dead-lib reports that remain are monopam lint blind spots, not
real dead deps: usage reached only through an mdx README block (slirp),
through copy_files# (vz), or inside a library's own private modules
(builder), plus a tar gz dep kept live for a stub test still to write.
docker: container list/create/inspect over a runtime backend seam
Add the first container endpoints -- GET /containers/json, POST
/containers/create, GET /containers/{id}/json -- the point where the API
first needs a runtime underneath it.
The seam follows the Irmin Heap.Make pattern: docker-runner defines a
BACKEND module type (a container runtime: an in-memory store now, runc or
a VMM later) and an in-memory Memory backend; Server.Make (B : BACKEND)
builds the server over it, projecting the backend's containers to the
Engine API shapes. The static endpoints (/version, /_ping, /info) and the
container endpoints are all served, each also under a /v<api> prefix.
New docker types: Container.{Config,Create_response,Summary,Detail}.
Client gains container_create / container_list / container_inspect (named
after the Docker Go SDK). Errors are emitted as the {"message": ...} body
via Docker.Error.to_body.
The real docker 29.x CLI drives the lifecycle against dockrd end to end:
`docker create`, `docker ps -a`, `docker inspect` all work. A live bug it
surfaced -- the CLI sends null, not [], for empty Cmd/Env/Warnings arrays
-- is fixed with a null-tolerant list codec and a regression test.
docker: container list/create/inspect over a runtime backend seam
Add the first container endpoints -- GET /containers/json, POST
/containers/create, GET /containers/{id}/json -- the point where the API
first needs a runtime underneath it.
The seam follows the Irmin Heap.Make pattern: docker-runner defines a
BACKEND module type (a container runtime: an in-memory store now, runc or
a VMM later) and an in-memory Memory backend; Server.Make (B : BACKEND)
builds the server over it, projecting the backend's containers to the
Engine API shapes. The static endpoints (/version, /_ping, /info) and the
container endpoints are all served, each also under a /v<api> prefix.
New docker types: Container.{Config,Create_response,Summary,Detail}.
Client gains container_create / container_list / container_inspect (named
after the Docker Go SDK). Errors are emitted as the {"message": ...} body
via Docker.Error.to_body.
The real docker 29.x CLI drives the lifecycle against dockrd end to end:
`docker create`, `docker ps -a`, `docker inspect` all work. A live bug it
surfaced -- the CLI sends null, not [], for empty Cmd/Env/Warnings arrays
-- is fixed with a null-tolerant list codec and a regression test.
docker: container list/create/inspect over a runtime backend seam
Add the first container endpoints -- GET /containers/json, POST
/containers/create, GET /containers/{id}/json -- the point where the API
first needs a runtime underneath it.
The seam follows the Irmin Heap.Make pattern: docker-runner defines a
BACKEND module type (a container runtime: an in-memory store now, runc or
a VMM later) and an in-memory Memory backend; Server.Make (B : BACKEND)
builds the server over it, projecting the backend's containers to the
Engine API shapes. The static endpoints (/version, /_ping, /info) and the
container endpoints are all served, each also under a /v<api> prefix.
New docker types: Container.{Config,Create_response,Summary,Detail}.
Client gains container_create / container_list / container_inspect (named
after the Docker Go SDK). Errors are emitted as the {"message": ...} body
via Docker.Error.to_body.
The real docker 29.x CLI drives the lifecycle against dockrd end to end:
`docker create`, `docker ps -a`, `docker inspect` all work. A live bug it
surfaced -- the CLI sends null, not [], for empty Cmd/Env/Warnings arrays
-- is fixed with a null-tolerant list codec and a regression test.
docker: container list/create/inspect over a runtime backend seam
Add the first container endpoints -- GET /containers/json, POST
/containers/create, GET /containers/{id}/json -- the point where the API
first needs a runtime underneath it.
The seam follows the Irmin Heap.Make pattern: docker-runner defines a
BACKEND module type (a container runtime: an in-memory store now, runc or
a VMM later) and an in-memory Memory backend; Server.Make (B : BACKEND)
builds the server over it, projecting the backend's containers to the
Engine API shapes. The static endpoints (/version, /_ping, /info) and the
container endpoints are all served, each also under a /v<api> prefix.
New docker types: Container.{Config,Create_response,Summary,Detail}.
Client gains container_create / container_list / container_inspect (named
after the Docker Go SDK). Errors are emitted as the {"message": ...} body
via Docker.Error.to_body.
The real docker 29.x CLI drives the lifecycle against dockrd end to end:
`docker create`, `docker ps -a`, `docker inspect` all work. A live bug it
surfaced -- the CLI sends null, not [], for empty Cmd/Env/Warnings arrays
-- is fixed with a null-tolerant list codec and a regression test.
docker: Engine API client and server, first slice
New ocaml-docker package: the Docker Engine REST API on the host, in
pure OCaml. The IO-free `docker` library maps request and response
bodies to OCaml values with nox-json; `docker-client` (the `dockr` CLI)
and `docker-server` (the `dockrd` daemon) are thin Eio adapters over a
Unix socket, so the same definitions back the client, the server, and
the tests.
This first slice covers GET /version and GET /_ping (both also under a
/v<api> prefix) -- enough to exercise the whole stack (Unix-socket
transport, routing, headers, JSON codecs, client/server symmetry)
without a container runtime behind it.
The interop tests cover both directions. test/client drives a real
daemon and test/interop/dockerd replays committed real-daemon captures
(the oracle is contacted only at REGEN=1), validating our client against
a real server. test/server points the stock `docker` CLI at our server,
validating our server against a real client.
docker: Engine API client and server, first slice
New ocaml-docker package: the Docker Engine REST API on the host, in
pure OCaml. The IO-free `docker` library maps request and response
bodies to OCaml values with nox-json; `docker-client` (the `dockr` CLI)
and `docker-server` (the `dockrd` daemon) are thin Eio adapters over a
Unix socket, so the same definitions back the client, the server, and
the tests.
This first slice covers GET /version and GET /_ping (both also under a
/v<api> prefix) -- enough to exercise the whole stack (Unix-socket
transport, routing, headers, JSON codecs, client/server symmetry)
without a container runtime behind it.
The interop tests cover both directions. test/client drives a real
daemon and test/interop/dockerd replays committed real-daemon captures
(the oracle is contacted only at REGEN=1), validating our client against
a real server. test/server points the stock `docker` CLI at our server,
validating our server against a real client.