@shipfox/api-runners 6.0.0 → 7.0.2

package/src/db/runner-instances.test.ts

@@ -3,8 +3,7 @@ import {and, desc, eq, inArray, or, sql} from 'drizzle-orm';
 import {db} from '#db/db.js';
 import {createRunnerSessionConsumingEphemeralToken} from '#db/ephemeral-registration-tokens.js';
 import {
-  attachProviderRunnerId,
-  createPlannedProvisionedCapacity,
+  attachRunnerInstanceProviderId,
   listActiveRunnerInstanceCountsByTemplateTx,
   listActiveRunnerInstances,
   listProvisionerTerminateIntentRowsTx,
@@ -1014,26 +1013,33 @@ describe('reapStaleRunnerInstances', () => {
     expect(reservation?.count).toBe(1);
   });
 
-  it('fails stale planned installation capacity before provider attachment', async () => {
+  it('fails a stale installation runner instance before provider attachment', async () => {
     const installationProvisioner = await provisionerTokenFactory.create({
       scope: 'installation',
       workspaceId: null,
     });
-    const capacity = await createPlannedProvisionedCapacity({
-      provisionerId: installationProvisioner.id,
-      providerKind: 'docker',
-      templateKey: null,
-    });
     await db()
-      .update(providerRunners)
-      .set({reportedAt: staleAt(), updatedAt: staleAt()})
-      .where(eq(providerRunners.id, capacity.capacityId));
+      .update(provisionerTokens)
+      .set({lastSeenAt: null})
+      .where(eq(provisionerTokens.id, installationProvisioner.id));
+    const [instance] = await db()
+      .insert(providerRunners)
+      .values({
+        provisionerId: installationProvisioner.id,
+        providerKind: 'docker',
+        labels: [],
+        state: 'starting',
+        reportedAt: staleAt(),
+        updatedAt: staleAt(),
+      })
+      .returning({id: providerRunners.id});
+    if (!instance) throw new Error('Runner instance insert returned no row');
 
     const result = await reapStaleRunnerInstances({thresholdSeconds: 60, limit: 100});
     const [row] = await db()
       .select()
       .from(providerRunners)
-      .where(eq(providerRunners.id, capacity.capacityId));
+      .where(eq(providerRunners.id, instance.id));
 
     expect(result.reaped).toBe(1);
     expect(row).toMatchObject({workspaceId: null, providerRunnerId: null, state: 'failed'});
@@ -1815,29 +1821,36 @@ describe('reconcileRunnerInstances', () => {
   }
 });
 
-describe('planned provisioned capacity', () => {
+describe('runner instance provider attachment', () => {
   it('belongs to its provisioner until it receives one provider runner identity', async () => {
     const provisionerId = crypto.randomUUID();
-    const capacity = await createPlannedProvisionedCapacity({
-      provisionerId,
-      providerKind: 'docker',
-      templateKey: 'linux',
-    });
+    const [instance] = await db()
+      .insert(providerRunners)
+      .values({
+        provisionerId,
+        providerKind: 'docker',
+        templateKey: 'linux',
+        labels: [],
+        state: 'starting',
+        reportedAt: new Date(),
+      })
+      .returning({id: providerRunners.id});
+    if (!instance) throw new Error('Runner instance insert returned no row');
 
-    const attached = await attachProviderRunnerId({
-      capacityId: capacity.capacityId,
+    const attached = await attachRunnerInstanceProviderId({
+      runnerInstanceId: instance.id,
       provisionerId,
       providerRunnerId: 'container-1',
     });
-    const rebound = await attachProviderRunnerId({
-      capacityId: capacity.capacityId,
+    const rebound = await attachRunnerInstanceProviderId({
+      runnerInstanceId: instance.id,
       provisionerId,
       providerRunnerId: 'container-2',
     });
     const [row] = await db()
       .select()
       .from(providerRunners)
-      .where(eq(providerRunners.id, capacity.capacityId));
+      .where(eq(providerRunners.id, instance.id));
 
     expect(attached).toBe(true);
     expect(rebound).toBe(false);

package/src/db/runner-instances.ts

@@ -97,28 +97,8 @@ export interface ReapStaleRunnerInstancesResult {
   reservationsReleased: number;
 }
 
-export async function createPlannedProvisionedCapacity(params: {
-  provisionerId: string;
-  providerKind: string | null;
-  templateKey: string | null;
-}): Promise<{capacityId: string}> {
-  const [row] = await db()
-    .insert(providerRunners)
-    .values({
-      provisionerId: params.provisionerId,
-      providerKind: params.providerKind,
-      templateKey: params.templateKey,
-      state: 'starting',
-      labels: [],
-      reportedAt: new Date(),
-    })
-    .returning({capacityId: providerRunners.id});
-  if (!row) throw new Error('Planned capacity insert returned no row');
-  return row;
-}
-
-export async function attachProviderRunnerId(params: {
-  capacityId: string;
+export async function attachRunnerInstanceProviderId(params: {
+  runnerInstanceId: string;
   provisionerId: string;
   providerRunnerId: string;
 }): Promise<boolean> {
@@ -127,7 +107,7 @@ export async function attachProviderRunnerId(params: {
     .set({providerRunnerId: params.providerRunnerId, updatedAt: sql`now()`})
     .where(
       and(
-        eq(providerRunners.id, params.capacityId),
+        eq(providerRunners.id, params.runnerInstanceId),
         eq(providerRunners.provisionerId, params.provisionerId),
         isNull(providerRunners.providerRunnerId),
         notInArray(providerRunners.state, [...terminalStates]),

package/src/db/schema/runner-instances.ts

@@ -24,6 +24,7 @@ export const providerRunners = pgTable(
     provisionerId: uuid('provisioner_id').notNull(),
     providerRunnerId: text('provider_runner_id'),
     reservationId: uuid('reservation_id'),
+    assignedAt: timestamp('assigned_at', {withTimezone: true}),
     templateKey: text('template_key'),
     labels: text('labels').array().notNull().default([]),
     state: providerRunnerStateEnum('state').notNull(),
@@ -62,13 +63,14 @@ export type RunnerInstanceDb = typeof providerRunners.$inferSelect;
 export type RunnerInstanceInsertDb = typeof providerRunners.$inferInsert;
 
 export function toRunnerInstance(row: RunnerInstanceDb): RunnerInstance {
-  if (!row.providerRunnerId) throw new Error('Planned capacity has no provider runner identity');
+  if (!row.providerRunnerId) throw new Error('Runner instance has no provider runner identity');
   return {
     id: row.id,
     workspaceId: row.workspaceId,
     provisionerId: row.provisionerId,
     providerRunnerId: row.providerRunnerId,
     reservationId: row.reservationId,
+    assignedAt: row.assignedAt,
     templateKey: row.templateKey,
     labels: row.labels,
     state: row.state,

package/src/index.ts

@@ -21,15 +21,6 @@ import {createRunnersInterModulePresentation} from '#presentation/inter-module.j
 import {createRunnersMaintenanceActivities} from '#temporal/activities/index.js';
 import {RUNNERS_MAINTENANCE_TASK_QUEUE} from '#temporal/constants.js';
 
-export {
-  type MintEphemeralRegistrationTokenParams,
-  type MintEphemeralRegistrationTokenResult,
-  type MintEphemeralRegistrationTokensBatchParams,
-  type MintEphemeralRegistrationTokensBatchResult,
-  type MintEphemeralRegistrationTokensBatchRunnerInstance,
-  mintEphemeralRegistrationToken,
-  mintEphemeralRegistrationTokensBatch,
-} from '#core/ephemeral-registration-tokens.js';
 export {
   type EffectiveRunnerToolCapabilitiesResult,
   getEffectiveRunnerToolCapabilities,

package/src/presentation/dto/index.ts

@@ -1,9 +1,5 @@
 export {toActiveProvisionerDto} from './active-provisioner.js';
 export {toManualRegistrationTokenDto} from './manual-registration-token.js';
-export {
-  toMintRegistrationTokensResponseDto,
-  toMintRegistrationTokensRunnerInstances,
-} from './mint-registration-tokens.js';
 export {toPollDemandResponseDto} from './poll-demand.js';
 export {toProvisionerTokenDto} from './provisioner-token.js';
 export {

package/src/presentation/routes/assign-runner-instances.ts

@@ -0,0 +1,49 @@
+import {requireProvisionerContext} from '@shipfox/api-auth-context';
+import {
+  assignRunnerInstancesBodySchema,
+  assignRunnerInstancesResponseSchema,
+} from '@shipfox/api-runners-dto';
+import {ClientError, defineRoute} from '@shipfox/node-fastify';
+import {
+  ReservationExpiredError,
+  ReservationNotFoundError,
+  RunnerInstanceAlreadyAssignedError,
+  RunnerInstanceNotAssignableError,
+} from '#core/errors.js';
+import {assignRunnerInstances} from '#core/runner-assignments.js';
+
+export const assignRunnerInstancesRoute = defineRoute({
+  method: 'POST',
+  path: '/runner-instances/assignments',
+  description: 'Assign enrolled runner instances to an owned demand reservation',
+  schema: {
+    body: assignRunnerInstancesBodySchema,
+    response: {200: assignRunnerInstancesResponseSchema},
+  },
+  errorHandler: (error) => {
+    if (error instanceof ReservationNotFoundError)
+      throw new ClientError('Reservation not found', 'reservation-not-found', {status: 404});
+    if (error instanceof ReservationExpiredError)
+      throw new ClientError('Reservation has expired', 'reservation-expired', {status: 409});
+    if (
+      error instanceof RunnerInstanceAlreadyAssignedError ||
+      error instanceof RunnerInstanceNotAssignableError
+    )
+      throw new ClientError(
+        'Runner instance cannot be assigned',
+        'runner-instance-not-assignable',
+        {status: 409},
+      );
+    throw error;
+  },
+  handler: async (request) => {
+    const {provisionerTokenId} = requireProvisionerContext(request);
+    return {
+      runner_instance_ids: await assignRunnerInstances({
+        provisionerId: provisionerTokenId,
+        reservationId: request.body.reservation_id,
+        runnerInstanceIds: request.body.runner_instance_ids,
+      }),
+    };
+  },
+});

package/src/presentation/routes/index.ts

@@ -8,7 +8,7 @@ import {
 import type {AuthInterModuleClient} from '@shipfox/api-auth-dto/inter-module';
 import type {RouteGroup} from '@shipfox/node-fastify';
 import type {CreateRunnersModuleOptions} from '#installation-provisioning.js';
-import {assignCapacityRoute} from './assign-capacity.js';
+import {assignRunnerInstancesRoute} from './assign-runner-instances.js';
 import {createManualRegistrationTokenRoute} from './create-manual-registration-token.js';
 import {createProvisionerTokenRoute} from './create-provisioner-token.js';
 import {getProvisionerMeRoute} from './get-provisioner-me.js';
@@ -17,8 +17,6 @@ import {listActiveProvisionersRoute} from './list-active-provisioners.js';
 import {listActiveRunnersRoute} from './list-active-runners.js';
 import {listManualRegistrationTokensRoute} from './list-manual-registration-tokens.js';
 import {listProvisionerTokensRoute} from './list-provisioner-tokens.js';
-import {mintRegistrationTokensRoute} from './mint-registration-tokens.js';
-import {attachProviderRunnerRoute, createPlannedCapacityRoute} from './planned-capacity.js';
 import {createPollDemandRoute, pollDemandRoute} from './poll-demand.js';
 import {reconcileRunnerInstancesRoute} from './reconcile-runner-instances.js';
 import {createRegisterRoute} from './register.js';
@@ -28,6 +26,7 @@ import {revokeManualRegistrationTokenRoute} from './revoke-manual-registration-t
 import {revokeProvisionerTokenRoute} from './revoke-provisioner-token.js';
 import {
   attachRunnerControlProviderIdRoute,
+  attachRunnerInstanceProviderIdRoute,
   createRunnerInstancesRoute,
   enrollRunnerRoute,
   exchangeRunnerBootstrapRoute,
@@ -72,10 +71,8 @@ function createRunnerOnlyRoutes(auth: AuthInterModuleClient): RouteGroup[] {
       routes: [
         pollDemandRoute,
         createRunnerInstancesRoute,
-        createPlannedCapacityRoute,
-        attachProviderRunnerRoute,
-        assignCapacityRoute,
-        mintRegistrationTokensRoute,
+        attachRunnerInstanceProviderIdRoute,
+        assignRunnerInstancesRoute,
         reportRunnerInstancesRoute,
         reconcileRunnerInstancesRoute,
       ],

package/src/presentation/routes/runner-enrollment.test.ts

@@ -10,6 +10,7 @@ import {
 import {eq} from 'drizzle-orm';
 import type {FastifyInstance, FastifyRequest} from 'fastify';
 import {db} from '#db/db.js';
+import {reservations} from '#db/schema/reservations.js';
 import {runnerActivationTokens} from '#db/schema/runner-activation-tokens.js';
 import {runnerBootstrapTokens, runnerControlSessions} from '#db/schema/runner-control-sessions.js';
 import {providerRunners} from '#db/schema/runner-instances.js';
@@ -162,6 +163,65 @@ describe('runner enrollment control plane', () => {
     expect(enrolled.json()).toMatchObject({code: 'runner-control-session-invalid'});
   });
 
+  it('assigns an enrolled runner instance only through the owned reservation', async () => {
+    const workspaceId = crypto.randomUUID();
+    const created = await app.inject({
+      method: 'POST',
+      url: '/provisioners/runner-instances/batch',
+      headers: {authorization: `Bearer ${token}`},
+      payload: {runner_instances: [{template_key: 'linux'}]},
+    });
+    const runner = created.json().runner_instances[0];
+    const exchanged = await app.inject({
+      method: 'POST',
+      url: '/runner-enrollment/exchange',
+      payload: {bootstrap_token: runner.bootstrap_token},
+    });
+    const controlToken = exchanged.json().control_session_token;
+    await app.inject({
+      method: 'POST',
+      url: '/runner-control/enrollment',
+      headers: {authorization: `Bearer ${controlToken}`},
+      payload: {labels: ['linux'], provider_kind: 'docker', protocol_version: '1'},
+    });
+    await app.inject({
+      method: 'POST',
+      url: '/runner-control/provider-runner',
+      headers: {authorization: `Bearer ${controlToken}`},
+      payload: {provider_runner_id: 'container-assignment-test'},
+    });
+    const [reservation] = await db()
+      .insert(reservations)
+      .values({
+        workspaceId,
+        provisionerId,
+        requiredLabels: ['linux'],
+        count: 1,
+        expiresAt: new Date(Date.now() + 60_000),
+      })
+      .returning();
+    if (!reservation) throw new Error('Reservation insert returned no row');
+
+    const assigned = await app.inject({
+      method: 'POST',
+      url: '/provisioners/runner-instances/assignments',
+      headers: {authorization: `Bearer ${token}`},
+      payload: {reservation_id: reservation.id, runner_instance_ids: [runner.runner_instance_id]},
+    });
+
+    expect(assigned.statusCode).toBe(200);
+    expect(assigned.json()).toEqual({runner_instance_ids: [runner.runner_instance_id]});
+    const [instance] = await db()
+      .select()
+      .from(providerRunners)
+      .where(eq(providerRunners.id, runner.runner_instance_id));
+    expect(instance).toMatchObject({
+      workspaceId,
+      reservationId: reservation.id,
+      assignedAt: expect.any(Date),
+    });
+  });
+
   it('returns an activation token only for its assigned runner and closes control access after registration', async () => {
     const created = await app.inject({
       method: 'POST',

package/src/presentation/routes/runner-enrollment.ts

@@ -25,6 +25,7 @@ import {
   RunnerControlSessionInvalidError,
   touchRunnerControlSession,
 } from '#core/runner-control-sessions.js';
+import {attachRunnerInstanceProviderId} from '#core/runner-instances.js';
 import {runnerBootstrapExchangeCount, runnerControlHeartbeatCount} from '#metrics/instance.js';
 import {authenticateRunnerControlSession} from '#presentation/auth/index.js';
 
@@ -56,6 +57,27 @@ export const createRunnerInstancesRoute = defineRoute({
   },
 });
 
+export const attachRunnerInstanceProviderIdRoute = defineRoute({
+  method: 'POST',
+  path: '/runner-instances/:runnerInstanceId/provider-runner',
+  description: 'Attach the provider identity after the provisioner launches a runner instance',
+  schema: {
+    params: z.object({runnerInstanceId: z.string().uuid()}),
+    body: attachRunnerControlProviderIdBodySchema,
+    response: {200: z.object({attached: z.boolean()})},
+  },
+  handler: async (request) => {
+    const {provisionerTokenId} = requireProvisionerContext(request);
+    return {
+      attached: await attachRunnerInstanceProviderId({
+        runnerInstanceId: request.params.runnerInstanceId,
+        provisionerId: provisionerTokenId,
+        providerRunnerId: request.body.provider_runner_id,
+      }),
+    };
+  },
+});
+
 export const exchangeRunnerBootstrapRoute = defineRoute({
   method: 'POST',
   path: '/exchange',

package/test/globalSetup.ts

@@ -9,7 +9,6 @@ export async function setup() {
 
   await runMigrations(db(), migrationsPath, '__drizzle_migrations_runners');
   await db().execute(sql`TRUNCATE runners_provisioner_capability_snapshots CASCADE`);
-  await db().execute(sql`TRUNCATE runners_capacity_assignments CASCADE`);
   await db().execute(sql`TRUNCATE runners_runner_instances, runners_reservations CASCADE`);
   await db().execute(sql`TRUNCATE runners_provisioner_tokens CASCADE`);
   await db().execute(sql`TRUNCATE runners_ephemeral_registration_tokens CASCADE`);