feat(buildrunner): drop per-call queueName, add Factory

## Summary

### Why?

`BuildRunner.Trigger` took a `queueName` argument that selected the
runner-specific job configuration on every call. That put queue routing
on the hot path and on a single verb, leaving `Status` and `Cancel` to
rediscover the queue from the build ID. A runner's connection pools,
caches, and job defaults are all keyed to one queue's configuration, so
the queue belongs at construction time, not per call.

### What?

- Drop `queueName` from `BuildRunner.Trigger`; the verbs now speak only
  in builds and changes.
- Add a `Factory` interface (`New(cfg Config) (BuildRunner, error)`) and
  a placeholder `Config` struct. A runner is bound to one queue's job
  configuration at construction. `Config` is intentionally empty for now
  — its fields (queue/job selection plus backend settings) land with the
  first real backend.
- noop: add `NewFactory()` + factory `New`; keep `New()` so existing
  wiring is untouched.
- build controller: call site drops `batch.Queue`.
- Update the build-runner RFC (new Construction section, Interface and
  Lifecycle updates), the extension README, and regenerate the mock.

## Test Plan

✅ `make mocks`, `make gazelle`, `make fmt`
✅ `bazel build //...`
✅ `bazel test //extension/buildrunner/... //orchestrator/controller/build/...`

Author: behinddwalls

doc/rfc/build-runner.md

@@ -38,12 +38,27 @@ The build stage needs a vendor-agnostic abstraction for talking to a Build Runne
 
 `BuildRunner` exposes three verbs, all keyed by a build identifier (`entity.BuildID`):
 
-- **`Trigger`** — submit a build for a queue, given the ordered `base` and `head` change sets plus a free-form metadata map; returns the new build's ID. Runner-side work is asynchronous.
+- **`Trigger`** — submit a build given the ordered `base` and `head` change sets plus a free-form metadata map; returns the new build's ID. Runner-side work is asynchronous.
 - **`Status`** — fetch the current `BuildStatus` and runner-defined metadata for a build; MAY round-trip to the runner.
 - **`Cancel`** — request cancellation; returns once the request reaches the runner, not once the build stops.
 
 See `extension/buildrunner/build_runner.go` for the exact Go signatures. The sections below record why the contract is shaped this way.
 
+### Construction: a Factory, queue bound at build time
+
+A `BuildRunner` does not take a queue selector on any verb. The queue whose job configuration a runner uses is fixed when the runner is constructed, and runners are constructed by a `Factory`.
+
+- **`Factory`** — produces `BuildRunner` instances from a `Config`. A controller that drives builds for several queues holds one `Factory` and obtains one `BuildRunner` per queue.
+- **`Config`** — the per-runner configuration the factory binds in: the queue's job selection plus any backend-specific settings (endpoints, credentials, defaults). The schema is backend-defined and lands with the first real implementation; today it is an intentionally empty placeholder so the `Factory` contract can stabilize ahead of it.
+
+Why bind the queue at construction rather than pass it per call:
+
+- A runner's connection pool, caches, and job defaults are all keyed to one queue's configuration. Passing the queue per call would force every implementation to re-resolve that configuration on the hot path, or to maintain an internal queue→config map the factory already expresses cleanly.
+- It keeps the per-call verbs (`Trigger`, `Status`, `Cancel`) free of routing concerns — they speak only in builds and changes.
+- It matches the rest of the extension family, whose implementations are long-lived singletons bound to their configuration at construction.
+
+Rejected: a `queueName` argument on `Trigger`. It put routing on the hot path and on a single verb, leaving `Status` and `Cancel` to rediscover the queue from the build ID. Moving the selection into `Config` makes one runner mean one queue everywhere.
+
 ### Trigger: base + head
 
 `Trigger` takes two ordered lists of changes and a free-form metadata map:
@@ -125,7 +140,7 @@ Rejected: long-polling on `Status`. Not every backend supports efficient server-
 
 ### Lifecycle
 
-Implementations are long-lived singletons bound to provider config at construction. Every method is concurrent-safe; connection pools and caches live inside the manager; anything that must survive a restart belongs in persistent storage, not the manager.
+Implementations are long-lived singletons constructed by a `Factory` and bound to one queue's provider config at construction (see *Construction* above). Every method is concurrent-safe; connection pools and caches live inside the manager; anything that must survive a restart belongs in persistent storage, not the manager.
 
 ### Transient failures
 

extension/buildrunner/README.md

@@ -6,7 +6,7 @@ See [`doc/rfc/build-runner.md`](../../doc/rfc/build-runner.md) for the contract
 
 ## Adding a new backend
 
-1. Create `extension/buildrunner/{backend}/` with a `BuildRunner` implementation bound to its runner configuration at construction.
+1. Create `extension/buildrunner/{backend}/` with a `Factory` whose `New` returns a `BuildRunner` bound to one queue's job configuration. The runner verbs carry no queue selector — that selection lives in the `Config` passed to the factory.
 2. Map the `base` and `head` change slices onto the backend's build primitives (apply `base`, apply `head`, validate the result).
 3. Map the runner's lifecycle states down to the `BuildStatus` values: `Accepted` (accepted for execution), `Running` (executing), and the terminal `Succeeded` / `Failed` / `Cancelled`.
 4. Implement internal reconnect / retry so transient failures surface as plain errors without blocking the caller.

extension/buildrunner/build_runner.go

@@ -22,8 +22,35 @@ import (
 	"github.com/uber/submitqueue/entity"
 )
 
+// Config carries the per-runner configuration a Factory binds into a
+// BuildRunner: the queue's job selection that Trigger used to receive via a
+// queueName argument, plus any backend-specific settings (endpoints,
+// credentials, defaults). Its fields are defined by the concrete backend
+// and land with the first real implementation; today it is an
+// intentionally empty placeholder so the Factory contract can stabilize
+// ahead of them.
+type Config struct{}
+
+// Factory constructs BuildRunner instances bound to a Config.
+//
+// A BuildRunner is bound at construction to a single Config — in particular
+// to one queue's job configuration — which is why Trigger no longer carries
+// a queueName: the routing that argument expressed now lives in Config and
+// is fixed when the runner is built. A controller that serves multiple
+// queues holds a Factory and obtains one BuildRunner per queue.
+//
+// Implementations must be safe for concurrent use by multiple goroutines.
+type Factory interface {
+	// New returns a BuildRunner bound to cfg, ready to trigger builds.
+	// Returns an error if a runner cannot be constructed from cfg (e.g.
+	// invalid configuration or an unreachable backend).
+	New(cfg Config) (BuildRunner, error)
+}
+
 // BuildRunner triggers builds against an external Build Runner, queries
-// their status, and cancels them.
+// their status, and cancels them. A BuildRunner is bound to a single
+// queue's job configuration at construction (see Factory); the verbs below
+// carry no queue selector.
 //
 // Implementations are long-lived singletons and must:
 //   - make every method safe for concurrent use by multiple goroutines;
@@ -55,11 +82,11 @@ type BuildRunner interface {
 	// asynchronously. Callers learn the build's progress via Status, not
 	// via Trigger.
 	//
-	// queueName selects the runner-specific job configuration.
-	// Returns an error if the request is invalid.
+	// The queue whose job configuration this runner uses is fixed at
+	// construction (see Factory and Config); Trigger does not take a queue
+	// selector. Returns an error if the request is invalid.
 	Trigger(
 		ctx context.Context,
-		queueName string,
 		base []entity.Change,
 		head []entity.Change,
 		metadata entity.BuildMetadata,

extension/buildrunner/mock/BUILD.bazel

@@ -7,6 +7,7 @@ go_library(
     visibility = ["//visibility:public"],
     deps = [
         "//entity",
+        "//extension/buildrunner",
         "@org_uber_go_mock//gomock",
     ],
 )

extension/buildrunner/mock/build_runner_mock.go

@@ -34,14 +34,27 @@ type runner struct {
 	counter atomic.Uint64
 }
 
+// factory builds no-op runners. It ignores the supplied Config.
+type factory struct{}
+
+// NewFactory returns a buildrunner.Factory that produces no-op runners.
+func NewFactory() buildrunner.Factory {
+	return factory{}
+}
+
+// New returns a no-op buildrunner.BuildRunner. The Config is ignored.
+func (factory) New(_ buildrunner.Config) (buildrunner.BuildRunner, error) {
+	return New(), nil
+}
+
 // New returns a buildrunner.BuildRunner that performs no real work.
 func New() buildrunner.BuildRunner {
 	return &runner{}
 }
 
 // Trigger returns a unique build ID without contacting any runner.
 // Inputs are ignored.
-func (r *runner) Trigger(_ context.Context, _ string, _ []entity.Change, _ []entity.Change, _ entity.BuildMetadata) (entity.BuildID, error) {
+func (r *runner) Trigger(_ context.Context, _ []entity.Change, _ []entity.Change, _ entity.BuildMetadata) (entity.BuildID, error) {
 	return entity.BuildID{ID: fmt.Sprintf("noop-%d", r.counter.Add(1))}, nil
 }
 

extension/buildrunner/noop/noop.go

@@ -28,11 +28,18 @@ func TestNew_ImplementsInterface(t *testing.T) {
 	var _ buildrunner.BuildRunner = New()
 }
 
+func TestNewFactory_ImplementsInterface(t *testing.T) {
+	var f buildrunner.Factory = NewFactory()
+	r, err := f.New(buildrunner.Config{})
+	require.NoError(t, err)
+	assert.NotNil(t, r)
+}
+
 func TestRunner_Trigger(t *testing.T) {
 	r := New()
 	ctx := context.Background()
 
-	id1, err := r.Trigger(ctx, "queueA",
+	id1, err := r.Trigger(ctx,
 		[]entity.Change{{URIs: []string{"github://owner/repo/pull/1"}}},
 		[]entity.Change{{URIs: []string{"github://owner/repo/pull/2"}}},
 		entity.BuildMetadata{"requester": "alice"},
@@ -41,7 +48,7 @@ func TestRunner_Trigger(t *testing.T) {
 	assert.NotEmpty(t, id1.ID)
 
 	// IDs are unique across calls, even with empty inputs.
-	id2, err := r.Trigger(ctx, "queueA", nil, nil, nil)
+	id2, err := r.Trigger(ctx, nil, nil, nil)
 	require.NoError(t, err)
 	assert.NotEqual(t, id1, id2)
 }

extension/buildrunner/noop/noop_test.go

@@ -112,10 +112,12 @@ func (c *Controller) Process(ctx context.Context, delivery consumer.Delivery) (r
 		return fmt.Errorf("failed to assemble head changes for batch %s: %w", batch.ID, err)
 	}
 
-	// Trigger the build with the configured build manager. metadata is nil
-	// until a caller-supplied source materializes (e.g. requester / ticket
-	// pulled off the originating LandRequest).
-	buildID, err := c.buildRunner.Trigger(ctx, batch.Queue, base, head, nil)
+	// Trigger the build with the configured build runner. The runner is
+	// bound to this queue's job configuration at construction, so Trigger
+	// takes no queue selector. metadata is nil until a caller-supplied
+	// source materializes (e.g. requester / ticket pulled off the
+	// originating LandRequest).
+	buildID, err := c.buildRunner.Trigger(ctx, base, head, nil)
 	if err != nil {
 		metrics.NamedCounter(c.metricsScope, opName, "trigger_errors", 1)
 		return fmt.Errorf("failed to trigger build for batch %s: %w", batch.ID, err)

orchestrator/controller/build/build.go

@@ -176,7 +176,7 @@ func TestController_Process_TriggersWithBaseAndHead(t *testing.T) {
 	br := buildrunnermock.NewMockBuildRunner(ctrl)
 	wantBase := []entity.Change{depReq.Change}
 	wantHead := []entity.Change{head1.Change, head2.Change}
-	br.EXPECT().Trigger(gomock.Any(), headBatch.Queue, wantBase, wantHead, gomock.Nil()).Return(entity.BuildID{ID: "build-xyz"}, nil)
+	br.EXPECT().Trigger(gomock.Any(), wantBase, wantHead, gomock.Nil()).Return(entity.BuildID{ID: "build-xyz"}, nil)
 
 	var publishedTopic string
 	var published entity.BuildID
@@ -239,7 +239,7 @@ func TestController_Process_BuildStoreAlreadyExistsIsSwallowed(t *testing.T) {
 	store.EXPECT().GetBuildStore().Return(mockBuildStore).AnyTimes()
 
 	br := buildrunnermock.NewMockBuildRunner(ctrl)
-	br.EXPECT().Trigger(gomock.Any(), batch.Queue, gomock.Any(), gomock.Any(), gomock.Any()).Return(entity.BuildID{ID: "build-dup"}, nil)
+	br.EXPECT().Trigger(gomock.Any(), gomock.Any(), gomock.Any(), gomock.Any()).Return(entity.BuildID{ID: "build-dup"}, nil)
 
 	publishCalled := false
 	mockPub := queuemock.NewMockPublisher(ctrl)
@@ -280,7 +280,7 @@ func TestController_Process_TriggerFailure(t *testing.T) {
 	// No build store expectation: Trigger failure must short-circuit before Create.
 
 	br := buildrunnermock.NewMockBuildRunner(ctrl)
-	br.EXPECT().Trigger(gomock.Any(), batch.Queue, gomock.Any(), gomock.Any(), gomock.Any()).
+	br.EXPECT().Trigger(gomock.Any(), gomock.Any(), gomock.Any(), gomock.Any()).
 		Return(entity.BuildID{}, fmt.Errorf("provider down"))
 
 	registry, err := consumer.NewTopicRegistry(