Method enqueueRun

server/src/RunQueue.ts:58–115

(
    accessToken: string,
    partialRun: NewRun & {
      taskSource: TaskSource
      userId: string
      batchConcurrencyLimit: number | null
    },
    branchArgs: BranchArgs,
  )

  @atimedMethod
  async enqueueRun(
    accessToken: string,
    partialRun: NewRun & {
      taskSource: TaskSource
      userId: string
      batchConcurrencyLimit: number | null
    },
    branchArgs: BranchArgs,
  ): Promise<RunId> {
    const isProd = this.config.NODE_ENV === 'production'
    const runId = isProd ? null : (random(1_000_000_000, 2_000_000_000) as RunId)

    let batchName: string | null = null

    const taskInfo = makeTaskInfo(this.config, partialRun.taskId, partialRun.taskSource, null)
    const fetchedTask = await this.taskFetcher.fetch(taskInfo)
    const taskVersion = getTaskVersion(taskInfo, fetchedTask)

    await this.dbRuns.transaction(async conn => {
      if (partialRun.batchName != null) {
        const existingBatchConcurrencyLimit = await this.dbRuns
          .with(conn)
          .getBatchConcurrencyLimit(partialRun.batchName)
        if (
          existingBatchConcurrencyLimit != null &&
          existingBatchConcurrencyLimit !== partialRun.batchConcurrencyLimit
        ) {
          throw new TRPCError({
            code: 'BAD_REQUEST',
            message:
              `The batch ${partialRun.batchName} already exists and has a concurrency limit of ${existingBatchConcurrencyLimit}. ` +
              `You must specify the same concurrency limit when creating new runs in this batch.`,
          })
        }
      }

      batchName = partialRun.batchName ?? (await this.dbRuns.getDefaultBatchNameForUser(partialRun.userId))
      const batchConcurrencyLimit = partialRun.batchConcurrencyLimit ?? this.config.DEFAULT_RUN_BATCH_CONCURRENCY_LIMIT

      await this.dbRuns.with(conn).insertBatchInfo(batchName, batchConcurrencyLimit)
    })

    // We encrypt accessToken before storing it in the database. That way, an attacker with only
    // database access can't use the access tokens stored there. If an attacker had access to both the database
    // and the Vivaria server, they could decrypt the access tokens stored in the database, but they could also just
    // change the web server processes to collect and store access tokens sent in API requests.
    const { encrypted, nonce } = encrypt({ key: this.config.getAccessTokenSecretKey(), plaintext: accessToken })

    return await this.dbRuns.insert(
      runId,
      { ...partialRun, batchName: batchName!, taskVersion },
      branchArgs,
      this.config.VERSION ?? (await this.git.getServerCommitId()),
      encrypted,
      nonce,
      partialRun.taskSource,
    )
  }