Skip to content

feat(runway): wire the git merger into the server - #463

Open
behinddwalls wants to merge 1 commit into
preetam/runway-git-merger-promotefrom
preetam/runway-wire-git-merger
Open

feat(runway): wire the git merger into the server#463
behinddwalls wants to merge 1 commit into
preetam/runway-git-merger-promotefrom
preetam/runway-wire-git-merger

Conversation

@behinddwalls

@behinddwalls behinddwalls commented Jul 29, 2026

Copy link
Copy Markdown
Collaborator

Summary

Why?

The git merger exists but nothing constructs it — the server still builds the noop factory, so a deployed Runway acknowledges every merge as an instant success. This is the change that makes Runway actually merge.

It is deliberately last in the stack and deliberately opt-in: the switch is the presence of MERGE_CHECKOUT_PATH. Unset, the server keeps wiring noop, which is what local development, the compose stack, and the e2e suite depend on — none of them have a git checkout to hand the merger.

What?

newMergerFactory now reads the environment and returns either backend. With MERGE_CHECKOUT_PATH set it builds a git merger from the MERGE_* / GIT_* variables — remote, target branch, default strategy, committer identity, and the pinned git runtime — and logs the resolved configuration at startup. Without it, noop, with a log line saying so. A malformed configuration fails startup rather than degrading silently: parseStrategy rejects an unrecognized MERGE_DEFAULT_STRATEGY, and DEFAULT itself is rejected because it cannot be the value a DEFAULT step resolves to.

Three settings govern the behaviors the merger cannot infer:

  • MERGE_CHECK_STALENESS (default on) verifies each change's provider ref still points at the commit its URI names before applying.
  • MERGE_ALLOW_UNRELATED_HISTORIES (default off) lets a MERGE step import a history that shares no ancestry with the target. It stays off because the refusal it lifts is a safeguard everywhere except a queue whose purpose is such imports.
  • MERGE_FETCH_REFSPECS supplies extra refspecs for a remote that will not serve an unadvertised commit by SHA. Normally empty.

gitMergerFactory hands the same merger instance to every queue. The merger owns one checkout and serializes its own operations, so a second instance over the same directory would race; a deployment that lands multiple targets wires a per-queue map instead. This is also why the factory is built once at startup rather than per request.

Test Plan

bazel build //service/runway/... — wiring compiles
bazel test //runway/... — all targets pass

Not covered by automated tests: the git path only engages when MERGE_CHECKOUT_PATH points at a real checkout, so the env-to-Params mapping is exercised by the merger's own suite rather than through main. Watch the git merger configured startup log — with checkout, target, and default strategy — on the first deployment that sets the variable; its absence means the server silently fell back to noop.

Stack

  1. feat(runway): dlq reconciler for merge topics #459
  2. feat(runway): git-backed merger with REBASE #460
  3. feat(runway): git merger SQUASH_REBASE and MERGE #461
  4. feat(runway): git merger PROMOTE #462
  5. @ feat(runway): wire the git merger into the server #463
  6. feat(runway): reject changes that disagree on provider #476
  7. docs: define the URI as the unit of change #477

@behinddwalls
behinddwalls force-pushed the preetam/runway-wire-git-merger branch from 134f713 to ecb28ea Compare July 30, 2026 16:12
@behinddwalls
behinddwalls force-pushed the preetam/runway-git-merger-promote branch 2 times, most recently from 7c2728f to ddfaebd Compare July 30, 2026 16:16
@behinddwalls
behinddwalls force-pushed the preetam/runway-wire-git-merger branch from ecb28ea to a1a9c75 Compare July 30, 2026 16:16
@behinddwalls
behinddwalls force-pushed the preetam/runway-git-merger-promote branch from ddfaebd to d305166 Compare July 30, 2026 16:51
@behinddwalls
behinddwalls force-pushed the preetam/runway-wire-git-merger branch from a1a9c75 to 8d38f2a Compare July 30, 2026 16:51
@behinddwalls
behinddwalls marked this pull request as ready for review July 30, 2026 17:06
@behinddwalls
behinddwalls requested review from a team and sbalabanov as code owners July 30, 2026 17:06
@behinddwalls
behinddwalls force-pushed the preetam/runway-git-merger-promote branch from d305166 to 9d0e8b7 Compare July 30, 2026 17:13
@behinddwalls
behinddwalls force-pushed the preetam/runway-wire-git-merger branch from 8d38f2a to c006239 Compare July 30, 2026 17:13
@behinddwalls
behinddwalls force-pushed the preetam/runway-git-merger-promote branch from 9d0e8b7 to ba92c9c Compare July 30, 2026 17:55
@behinddwalls
behinddwalls force-pushed the preetam/runway-wire-git-merger branch from c006239 to b2f4eb3 Compare July 30, 2026 17:55
@behinddwalls
behinddwalls force-pushed the preetam/runway-git-merger-promote branch from ba92c9c to dcecbbe Compare July 30, 2026 18:05
@behinddwalls
behinddwalls force-pushed the preetam/runway-wire-git-merger branch from b2f4eb3 to 4d9c1e8 Compare July 30, 2026 18:05
@behinddwalls
behinddwalls force-pushed the preetam/runway-git-merger-promote branch from dcecbbe to e3972ff Compare July 30, 2026 18:07
@behinddwalls
behinddwalls force-pushed the preetam/runway-wire-git-merger branch from 4d9c1e8 to dd48ba1 Compare July 30, 2026 18:08
## Summary

### Why?

The git merger exists but nothing constructs it — the server still builds the noop factory, so a deployed Runway acknowledges every merge as an instant success. This is the change that makes Runway actually merge.

It is deliberately last in the stack and deliberately opt-in: the switch is the presence of `MERGE_CHECKOUT_PATH`. Unset, the server keeps wiring noop, which is what local development, the compose stack, and the e2e suite depend on — none of them have a git checkout to hand the merger.

### What?

`newMergerFactory` now reads the environment and returns either backend. With `MERGE_CHECKOUT_PATH` set it builds a git merger from the `MERGE_*` / `GIT_*` variables — remote, target branch, default strategy, committer identity, and the pinned git runtime — and logs the resolved configuration at startup. Without it, noop, with a log line saying so. A malformed configuration fails startup rather than degrading silently: `parseStrategy` rejects an unrecognized `MERGE_DEFAULT_STRATEGY`, and `DEFAULT` itself is rejected because it cannot be the value a `DEFAULT` step resolves to.

Three settings govern the behaviors the merger cannot infer:

- `MERGE_CHECK_STALENESS` (default on) verifies each change's provider ref still points at the commit its URI names before applying.
- `MERGE_ALLOW_UNRELATED_HISTORIES` (default off) lets a MERGE step import a history that shares no ancestry with the target. It stays off because the refusal it lifts is a safeguard everywhere except a queue whose purpose is such imports.
- `MERGE_FETCH_REFSPECS` supplies extra refspecs for a remote that will not serve an unadvertised commit by SHA. Normally empty.

`gitMergerFactory` hands the same merger instance to every queue. The merger owns one checkout and serializes its own operations, so a second instance over the same directory would race; a deployment that lands multiple targets wires a per-queue map instead. This is also why the factory is built once at startup rather than per request.

## Test Plan

✅ `bazel build //service/runway/...` — wiring compiles
✅ `bazel test //runway/...` — all targets pass

Not covered by automated tests: the git path only engages when `MERGE_CHECKOUT_PATH` points at a real checkout, so the env-to-`Params` mapping is exercised by the merger's own suite rather than through `main`. Watch the `git merger configured` startup log — with checkout, target, and default strategy — on the first deployment that sets the variable; its absence means the server silently fell back to noop.
@behinddwalls
behinddwalls force-pushed the preetam/runway-git-merger-promote branch from e3972ff to d060c76 Compare July 30, 2026 19:25
@behinddwalls
behinddwalls force-pushed the preetam/runway-wire-git-merger branch from dd48ba1 to b3cf80c Compare July 30, 2026 19:25
behinddwalls added a commit that referenced this pull request Jul 30, 2026
## Summary

### Why?

SubmitQueue records in-flight merge work before publishing and then
waits for exactly one `MergeResult` echoing its correlation id. Runway
is stateless and the sole responder on that id, so every request must
resolve to a result — or the client waits forever.

The primary controllers resolve what they can name: conflicts and
invalid requests become a `FAILED` result, infrastructure faults are
nacked for retry. But a fault that never recovers exhausts the retry
budget and dead-letters. Nothing consumed those dead-letter topics, so
the request produced no signal at all and the client's correlation id
hung indefinitely.

### What?

Adds `runway/controller/dlq`, a reconciler that subscribes to an inbound
topic's `_dlq` queue and, for each dead-lettered `MergeRequest`,
republishes a `FAILED` `MergeResult` echoing the correlation id to the
corresponding signal topic. `dlq.TopicKey` derives the DLQ topic key
from the primary one so the two stay in lockstep.

Unlike the SubmitQueue and Stovepipe DLQ reconcilers this one writes no
entity state — Runway has none, and the signal *is* the resolution. A
payload that cannot be decoded carries no correlation id and is dropped
rather than retried forever.

Wires two instances in the server (one per inbound topic) on a dedicated
consumer running under `errs.AlwaysRetryableProcessor`, so a transient
publish failure retries indefinitely rather than dead-lettering the
dead-letter. The DLQ consumer is started alongside the primary one and
stopped with the same 30s drain on shutdown; both stop errors are joined
into the exit status.

## Test Plan

✅ `bazel test //runway/...` — 5/5 pass, including new
`//runway/controller/dlq` coverage for republish-on-dead-letter, the
drop-undecodable-payload path, and publish-failure propagation
✅ `bazel build //service/runway/...` — wiring compiles
✅ `make gazelle`, `make fmt`


## Stack
1. @ #459
1. #460
1. #461
1. #462
1. #463
1. #476
1. #477
behinddwalls added a commit that referenced this pull request Jul 30, 2026
## Summary

### Why?

PR #443 disabled this workflow outright (`if: false`) when the repo moved to GitHub's native stacked PRs. That was too blunt: native stacks and hand-rolled `arh` chains coexist here today. Stacks #470, #472 and #474 are native, while #460#461#462#463#476 is a plain chain whose every member reports `stack: null`. With the workflow off, merging any PR in a hand-rolled chain leaves the children still carrying their parent's commits — precisely the broken-diff problem this workflow was written to fix.

GitHub owns the lifecycle of its own stacks: on a partial merge it rebases and retargets the surviving members itself, so the workflow must not touch those. It only needs to tell the two apart rather than give up on both.

### What?

Re-enables the job and skips only the PRs GitHub actually owns, instead of switching the whole workflow off.

A `detect_stack` helper resolves native-stack membership from `GET /repos/{owner}/{repo}/pulls/{n}`. It queries the REST API at run time rather than reading `github.event.pull_request.stack` off the webhook payload, so a PR added to a stack after the merge event was queued is still recognised. Membership survives merge — a merged member still reports its stack — which is what makes the lookup meaningful at this point in the lifecycle.

The check is applied **per child PR**, not to the merged PR. GitHub only ever rebases a stack's own members; a PR that targets a member's head branch without joining the stack is invisible to that machinery. Skipping the whole chain whenever the merged PR happened to be a stack member would therefore strand such a PR with exactly the broken diff this workflow exists to prevent. `rebase_chain` always runs; each child that is a stack member is skipped and not recursed into, while its siblings rebase normally. Membership of the merged PR is logged for context and gates nothing.

Presence is tested on the `stack` object itself rather than on `stack.number`. Probing a sub-field means a stack object arriving without that field reads as "standalone" and gets force-pushed — the unsafe direction to fail in. The number is used only for logging. An unreadable response still falls back to standalone, since the Stacks API 404s when the feature is not enabled for a repo, which is exactly when the rebase is wanted.

`cleanup_orphaned_merged_branches` still runs on every merge, including those where every child turned out to be GitHub's to rebase. This workflow therefore remains the sole owner of head-branch deletion, and native-stack head branches are reaped here too, each on the first merge after GitHub has retargeted its successors off it.

This depends on "Automatically delete head branches" being OFF, as the header has always documented — otherwise GitHub retargets children to `main` before the job runs and the non-native path silently no-ops on a green job. The setting has been turned off on the repo.

## Test Plan

✅ YAML parses; job `if` and step `env` verified after the edit.

✅ `bash -n` clean on the extracted `run:` block under bash 5.2, the version Actions runners use. Note for future edits: macOS `/bin/bash` 3.2 reports a spurious `syntax error near ';;'` on this script — it cannot parse the heredoc nested in `$( )`, so it blames a line far from the real construct.

✅ `actionlint` v1.7.7 — clean.

✅ `zizmor` v1.25.2 (`--no-online-audits`, the version CI pins) — no findings, 2 ignored and 5 suppressed, confirming the existing `.github/zizmor.yml` exceptions still cover the file.

✅ `yamlfmt` v0.16.0 `-lint` — clean.

✅ `detect_stack` exercised against live PRs in this repo:

| PR | `.stack` | Result |
| --- | --- | --- |
| #467 | stack #470, position 4/6, merged | native → skipped |
| #468 | stack #470, position 5/6, open | native → skipped |
| #404 | stack #472 | native → skipped |
| #457 | stack #475, size 1 | native → skipped |
| #443 | `null` | standalone → rebased |
| #460 | `null` | standalone → rebased |
| #999999 | HTTP 404 | warns, treated as standalone, no `set -euo pipefail` abort |

✅ The sub-field trap verified directly: a synthetic `{"stack":{"id":51488,"position":4,"size":6}}` with no `number` reads as standalone under `.stack.number // empty`, and as in-a-stack under the expression shipped here.

✅ Observed reference case — the merge of #467 (position 4 of stack #470). GitHub retargeted #468 from `preetam/stovepipe-buildsignal-outcome` to `main` and left #469 on #468's branch, confirming both that GitHub handles its own members and that a merged member retains its `stack` object.

The rebase itself can only be exercised post-merge. On the next merge of a hand-rolled chain (the runway series is the live case) watch for `=== Stack rebase complete ===` and a child retargeted with only its own commits; on a native-stack merge watch for each member child logging `skipped: belongs to native stack #N`, followed by the branch sweep. The first sweep will also reap `preetam/stovepipe-buildsignal-outcome`, which is currently orphaned — it merged after auto-delete was turned off and has no open dependents.
behinddwalls added a commit that referenced this pull request Jul 30, 2026
## Summary

### Why?

PR #443 disabled this workflow outright (`if: false`) when the repo
moved to GitHub's native stacked PRs. That was too blunt: native stacks
and hand-rolled `arh` chains coexist here today. Stacks #470, #472 and
#474 are native, while #460#461#462#463#476 is a plain chain
whose every member reports `stack: null`. With the workflow off, merging
any PR in a hand-rolled chain leaves the children still carrying their
parent's commits — precisely the broken-diff problem this workflow was
written to fix.

GitHub owns the lifecycle of its own stacks: on a partial merge it
rebases and retargets the surviving members itself, so the workflow must
not touch those. It only needs to tell the two apart rather than give up
on both.

### What?

Re-enables the job and skips only the PRs GitHub actually owns, instead
of switching the whole workflow off.

A `detect_stack` helper resolves native-stack membership from `GET
/repos/{owner}/{repo}/pulls/{n}`. It queries the REST API at run time
rather than reading `github.event.pull_request.stack` off the webhook
payload, so a PR added to a stack after the merge event was queued is
still recognised. Membership survives merge — a merged member still
reports its stack — which is what makes the lookup meaningful at this
point in the lifecycle.

The check is applied **per child PR**, not to the merged PR. GitHub only
ever rebases a stack's own members; a PR that targets a member's head
branch without joining the stack is invisible to that machinery.
Skipping the whole chain whenever the merged PR happened to be a stack
member would therefore strand such a PR with exactly the broken diff
this workflow exists to prevent. `rebase_chain` always runs; each child
that is a stack member is skipped and not recursed into, while its
siblings rebase normally. Membership of the merged PR is logged for
context and gates nothing.

Presence is tested on the `stack` object itself rather than on
`stack.number`. Probing a sub-field means a stack object arriving
without that field reads as "standalone" and gets force-pushed — the
unsafe direction to fail in. The number is used only for logging. An
unreadable response still falls back to standalone, since the Stacks API
404s when the feature is not enabled for a repo, which is exactly when
the rebase is wanted.

`cleanup_orphaned_merged_branches` still runs on every merge, including
those where every child turned out to be GitHub's to rebase. This
workflow therefore remains the sole owner of head-branch deletion, and
native-stack head branches are reaped here too, each on the first merge
after GitHub has retargeted its successors off it.

This depends on "Automatically delete head branches" being OFF, as the
header has always documented — otherwise GitHub retargets children to
`main` before the job runs and the non-native path silently no-ops on a
green job. The setting has been turned off on the repo.

## Test Plan

✅ YAML parses; job `if` and step `env` verified after the edit.

✅ `bash -n` clean on the extracted `run:` block under bash 5.2, the
version Actions runners use. Note for future edits: macOS `/bin/bash`
3.2 reports a spurious `syntax error near ';;'` on this script — it
cannot parse the heredoc nested in `$( )`, so it blames a line far from
the real construct.

✅ `actionlint` v1.7.7 — clean.

✅ `zizmor` v1.25.2 (`--no-online-audits`, the version CI pins) — no
findings, 2 ignored and 5 suppressed, confirming the existing
`.github/zizmor.yml` exceptions still cover the file.

✅ `yamlfmt` v0.16.0 `-lint` — clean.

✅ `detect_stack` exercised against live PRs in this repo:

| PR | `.stack` | Result |
| --- | --- | --- |
| #467 | stack #470, position 4/6, merged | native → skipped |
| #468 | stack #470, position 5/6, open | native → skipped |
| #404 | stack #472 | native → skipped |
| #457 | stack #475, size 1 | native → skipped |
| #443 | `null` | standalone → rebased |
| #460 | `null` | standalone → rebased |
| #999999 | HTTP 404 | warns, treated as standalone, no `set -euo
pipefail` abort |

✅ The sub-field trap verified directly: a synthetic
`{"stack":{"id":51488,"position":4,"size":6}}` with no `number` reads as
standalone under `.stack.number // empty`, and as in-a-stack under the
expression shipped here.

✅ Observed reference case — the merge of #467 (position 4 of stack
#470). GitHub retargeted #468 from
`preetam/stovepipe-buildsignal-outcome` to `main` and left #469 on
#468's branch, confirming both that GitHub handles its own members and
that a merged member retains its `stack` object.

The rebase itself can only be exercised post-merge. On the next merge of
a hand-rolled chain (the runway series is the live case) watch for `===
Stack rebase complete ===` and a child retargeted with only its own
commits; on a native-stack merge watch for each member child logging
`skipped: belongs to native stack #N`, followed by the branch sweep. The
first sweep will also reap `preetam/stovepipe-buildsignal-outcome`,
which is currently orphaned — it merged after auto-delete was turned off
and has no open dependents.
Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment

Projects

None yet

Development

Successfully merging this pull request may close these issues.

1 participant