syncode/control

feat: let a push on the forge start a run #4

Merged

day01 merged %!d() commits from %!s() into %!s()

2026-08-06 12:14:48 +00:00

day01 commented

2026-08-06 12:11:39 +00:00

Owner

The control plane had every piece needed to turn an event into runs, and none of them were connected. trigger, sources and reusable lived in the library with their own tests; main.rs started a gRPC server over an empty registry. Nothing in a running process called queue, so a node could enrol, say hello, and wait forever for work that had no way to exist.

This closes that gap end to end.

events.rs reads a forge delivery into the shape deciding needs: repository, commit, and the event with its branch and changed paths.
intake.rs fetches the workflows at that commit and offers the event to each one.
webhook.rs serves the signed endpoint the forge delivers to.
main.rs runs both ends over one set of registries.

Decisions worth reviewing

Deliveries the control plane does not act on — an unmodelled event, a deleted branch, a reference that is not a branch — are accepted, not refused. Answering an error would make the forge retry something that can never succeed.

A workflow that declares the event and fails to compile stops the intake. A run that silently fails to exist is worse than a delivery the forge sees refused.

The signature is verified with hmac's own comparison, which does not stop at the first differing byte.

Verification

The test drives the whole path over both protocols: a signed push arrives on the endpoint, and a node that enrols against the same control plane receives the compiled plan. An unsigned delivery queues nothing; an event the workflow does not declare queues nothing.

fmt, clippy -D warnings, 34 tests, check-architecture.sh and check-rust-loc.sh all pass.

Not in this slice

Pull request, manual and scheduled events. Reusable calls are resolved by reusable.rs but not yet folded into compilation. State is still in memory — persistence is the next slice.

The control plane had every piece needed to turn an event into runs, and none of them were connected. `trigger`, `sources` and `reusable` lived in the library with their own tests; `main.rs` started a gRPC server over an empty registry. Nothing in a running process called `queue`, so a node could enrol, say hello, and wait forever for work that had no way to exist. This closes that gap end to end. - `events.rs` reads a forge delivery into the shape deciding needs: repository, commit, and the event with its branch and changed paths. - `intake.rs` fetches the workflows at that commit and offers the event to each one. - `webhook.rs` serves the signed endpoint the forge delivers to. - `main.rs` runs both ends over one set of registries. ## Decisions worth reviewing Deliveries the control plane does not act on — an unmodelled event, a deleted branch, a reference that is not a branch — are **accepted**, not refused. Answering an error would make the forge retry something that can never succeed. A workflow that declares the event and fails to compile **stops the intake**. A run that silently fails to exist is worse than a delivery the forge sees refused. The signature is verified with `hmac`'s own comparison, which does not stop at the first differing byte. ## Verification The test drives the whole path over both protocols: a signed push arrives on the endpoint, and a node that enrols against the same control plane receives the compiled plan. An unsigned delivery queues nothing; an event the workflow does not declare queues nothing. `fmt`, `clippy -D warnings`, 34 tests, `check-architecture.sh` and `check-rust-loc.sh` all pass. ## Not in this slice Pull request, manual and scheduled events. Reusable calls are resolved by `reusable.rs` but not yet folded into compilation. State is still in memory — persistence is the next slice.

day01 added 1 commit 2026-08-06 12:11:40 +00:00

feat: let a push on the forge start a run

		The pieces that turn an event into runs were all here and none of them was
connected: trigger, the workflow sources and the reusable resolver lived in the
library with their own tests, while the binary started a gRPC server over an
empty registry. Nothing in a running process ever called queue, so a node could
enrol, say hello and wait forever for work that had no way to exist.

The forge now delivers events over a signed endpoint. A push is read into the
shape deciding needs, the workflows at that commit are fetched, and every
workflow that declares the event is compiled into runs. A node holding a session
is handed the plan the push produced.

Deliveries the control plane does not act on — an event it does not model, a
deleted branch, a reference that is not a branch — are accepted rather than
refused, because answering an error would make the forge retry something that
can never succeed. A workflow that declares the event and does not compile stops
the intake instead: a run that silently fails to exist is worse than a delivery
the forge sees refused.

The test drives the whole path the way production does, over both protocols: a
signed push arrives on the endpoint, and a node that enrols against the same
control plane receives the compiled plan.

day01 merged commit d75b7ee638 into %!s()

2026-08-06 12:14:48 +00:00

day01 deleted branch feat/let-a-push-on-the-forge-start-a-run

2026-08-06 12:14:49 +00:00

1 Participants

Notifications

Due Date

No due date set.

Dependencies

No dependencies set.

Reference: syncode/control#4