Create build and update traffic during backends:create.

taeold · taeold · commit 2a87679e216b · 2023-12-12T17:41:17.000-08:00
diff --git a/src/gcp/apphosting.ts b/src/gcp/apphosting.ts
@@ -1,3 +1,4 @@
+import * as proto from "../gcp/proto";
 import { Client } from "../apiv2";
 import { needProjectId } from "../projectUtils";
 import { apphostingOrigin } from "../api";
@@ -46,33 +47,139 @@ export interface Build {
   state: State;
   error: Status;
   image: string;
+  config?: BuildConfig;
   source: BuildSource;
-  buildLogsUri: string;
-  createTime: Date;
-  updateTime: Date;
   sourceRef: string;
+  buildLogsUri?: string;
+  displayName?: string;
+  labels?: Record<string, string>;
+  annotations?: Record<string, string>;
+  uuid: string;
+  etag: string;
+  reconciling: boolean;
+  createTime: string;
+  updateTime: string;
+  deleteTime: string;
 }
 
-export type BuildOutputOnlyFields = "createTime" | "updateTime" | "sourceRef";
+export type BuildOutputOnlyFields =
+  | "state"
+  | "error"
+  | "image"
+  | "sourceRef"
+  | "buildLogUri"
+  | "reconciling"
+  | "uuid"
+  | "etag"
+  | "createTime"
+  | "updateTime"
+  | "deleteTime";
+
+export interface BuildConfig {
+  minInstances?: number;
+  memory?: string;
+}
 
 interface BuildSource {
-  codeBaseSource?: CodebaseSource;
+  codebase: CodebaseSource;
 }
 
+interface CodebaseSource {
+  // oneof reference
+  branch?: string;
+  commit?: string;
+  tag?: string;
+  // end oneof reference
+  displayName: string;
+  hash: string;
+  commitMessage: string;
+  uri: string;
+  commitTime: string;
+}
+
+export type CodebaseSourceOutputOnlyFields =
+  | "displayName"
+  | "hash"
+  | "commitMessage"
+  | "uri"
+  | "commitTime";
+
+export type BuildInput = Omit<Build, BuildOutputOnlyFields | "source"> & {
+  source: Omit<BuildSource, "codebase"> & {
+    codebase: Omit<CodebaseSource, CodebaseSourceOutputOnlyFields>;
+  };
+};
+
 interface Status {
   code: number;
   message: string;
-  details: any[];
+  details: unknown;
 }
 
-interface CodebaseSource {
-  // oneof reference
-  branch: string;
-  commit: string;
-  tag: string;
-  // end oneof reference
+export interface Traffic {
+  name: string;
+  // oneof traffic_management
+  target?: TrafficSet;
+  rolloutPolicy?: RolloutPolicy;
+  // end oneof traffic_management
+  current: TrafficSet;
+  reconciling: boolean;
+  createTime: string;
+  updateTime: string;
+  annotations?: Record<string, string>;
+  etag: string;
+  uid: string;
 }
 
+export type TrafficOutputOnlyFields =
+  | "current"
+  | "reconciling"
+  | "createTime"
+  | "updateTime"
+  | "etag"
+  | "uid";
+
+export interface TrafficSet {
+  splits: TrafficSplit[];
+}
+
+export interface TrafficSplit {
+  build: string;
+  percent: number;
+}
+
+export interface RolloutPolicy {
+  // oneof trigger
+  codebaseBranch?: string;
+  codebaseTagPatter?: string;
+  // end oneof trigger
+  stages?: RolloutStage[];
+  disabled?: boolean;
+  disabledTime: string;
+}
+
+export type RolloutPolicyOutputOnlyFields = "disabledtime";
+
+export type RolloutProgression =
+  | "PROGRESSION_UNSPECIFIED"
+  | "IMMEDIATE"
+  | "LINEAR"
+  | "EXPONENTIAL"
+  | "PAUSE";
+
+export interface RolloutStage {
+  progression: RolloutProgression;
+  duration?: {
+    seconds: number;
+    nanos: number;
+  };
+  targetPercent?: number;
+  startTime: string;
+  endTime: string;
+}
+
+export type RolloutStageOutputOnlyFields = "startTime" | "endTime";
+
 interface OperationMetadata {
   createTime: string;
   endTime: string;
@@ -162,15 +269,14 @@ export async function createBuild(
   projectId: string,
   location: string,
   backendId: string,
-  buildInput: Omit<Build, BuildOutputOnlyFields>
+  buildId: string,
+  buildInput: Omit<BuildInput, "name">
 ): Promise<Operation> {
-  const buildId = buildInput.name;
-  const res = await client.post<Omit<Build, BuildOutputOnlyFields>, Operation>(
+  const res = await client.post<Omit<BuildInput, "name">, Operation>(
     `projects/${projectId}/locations/${location}/backends/${backendId}/builds`,
     buildInput,
     { queryParams: { buildId } }
   );
-
   return res.body;
 }
 
@@ -184,6 +290,30 @@ interface ListLocationsResponse {
   nextPageToken?: string;
 }
 
+/**
+ * Update traffic of a backend
+ */
+export async function updateTraffic(
+  projectId: string,
+  location: string,
+  backendId: string,
+  traffic: Omit<Traffic, TrafficOutputOnlyFields | "name">
+): Promise<Operation> {
+  const fieldMasks = proto.fieldMasks(traffic);
+  const queryParams = {
+    updateMask: fieldMasks.join(","),
+  };
+  const name = `projects/${projectId}/locations/${location}/backends/${backendId}/traffic`;
+  const res = await client.patch<Omit<Traffic, TrafficOutputOnlyFields>, Operation>(
+    name,
+    { ...traffic, name },
+    {
+      queryParams,
+    }
+  );
+  return res.body;
+}
+
 /**
  * Lists information about the supported locations.
  */
diff --git a/src/init/features/apphosting/index.ts b/src/init/features/apphosting/index.ts
@@ -4,7 +4,13 @@ import * as poller from "../../../operation-poller";
 import * as apphosting from "../../../gcp/apphosting";
 import { logBullet, logSuccess, logWarning } from "../../../utils";
 import { apphostingOrigin } from "../../../api";
-import { Backend, BackendOutputOnlyFields, API_VERSION } from "../../../gcp/apphosting";
+import {
+  Backend,
+  BackendOutputOnlyFields,
+  API_VERSION,
+  Build,
+  BuildInput,
+} from "../../../gcp/apphosting";
 import { Repository } from "../../../gcp/cloudbuild";
 import { FirebaseError } from "../../../error";
 import { promptOnce } from "../../../prompt";
@@ -66,27 +72,50 @@ export async function doSetup(setup: any, projectId: string): Promise<void> {
     }
     logWarning(`Backend with id ${backendId} already exists in ${location}`);
   }
-  const backend: Backend = await onboardBackend(projectId, location, backendId);
+  const backend = await onboardBackend(projectId, location, backendId);
+
+  const branch = await promptOnce({
+    name: "branch",
+    type: "input",
+    default: "main",
+    message: "Which branch do you want to deploy?",
+  });
+  const build = await createBuild(projectId, location, backendId, {
+    source: {
+      codebase: {
+        branch,
+      },
+    },
+  });
+
+  if (build.state !== "READY") {
+    throw new FirebaseError(
+      `Failed to build your app. Please inspect the build logs at ${build.buildLogsUri}.`,
+      { children: [build.error] }
+    );
+  }
+
+  await setDefaultTraffic(projectId, location, backendId, build.name.split("/").pop()!);
 
   if (backend) {
     logSuccess(`Successfully created backend:\n\t${backend.name}`);
-    logSuccess(`Your site is being deployed at:\n\thttps://${backend.uri}`);
+    logSuccess(`Your site is now deployed at:\n\thttps://${backend.uri}`);
     logSuccess(
       `View the rollout status by running:\n\tfirebase apphosting:backends:get ${backendId} --project ${projectId}`
     );
   }
 }
 
 async function promptLocation(projectId: string, locations: string[]): Promise<string> {
-  return await promptOnce({
+  return (await promptOnce({
     name: "region",
     type: "list",
     default: DEFAULT_REGION,
     message:
       "Please select a region " +
       `(${clc.yellow("info")}: Your region determines where your backend is located):\n`,
     choices: locations.map((loc) => ({ value: loc })),
-  });
+  })) as string;
 }
 
 function toBackend(cloudBuildConnRepo: Repository): Omit<Backend, BackendOutputOnlyFields> {
@@ -109,20 +138,12 @@ export async function onboardBackend(
   backendId: string
 ): Promise<Backend> {
   const cloudBuildConnRepo = await repo.linkGitHubRepository(projectId, location);
-  const barnchName = await promptOnce({
-    name: "branchName",
-    type: "input",
-    default: "main",
-    message: "Which branch do you want to deploy?",
-  });
-  // branchName unused for now.
-  void barnchName;
   const backendDetails = toBackend(cloudBuildConnRepo);
   return await createBackend(projectId, location, backendDetails, backendId);
 }
 
 /**
- * Creates backend object from long running operations.
+ * Creates (and waits for) a new backend.
  */
 export async function createBackend(
   projectId: string,
@@ -136,6 +157,69 @@ export async function createBackend(
     pollerName: `create-${projectId}-${location}-${backendId}`,
     operationResourceName: op.name,
   });
-
   return backend;
 }
+
+/**
+ * Only lowercase, digits, and hyphens; must begin with letter, and cannot end with hyphen
+ */
+function generateBuildId(n = 6) {
+  const letters = "abcdefghijklmnopqrstuvwxyz";
+  const allChars = "01234567890-abcdefghijklmnopqrstuvwxyz";
+  let id = letters[Math.floor(Math.random() * letters.length)];
+  for (let i = 1; i < n; i++) {
+    const idx = Math.floor(Math.random() * allChars.length);
+    id += allChars[idx];
+  }
+  return id;
+}
+
+/**
+ * Create (and waits for) a new build.
+ */
+export async function createBuild(
+  projectId: string,
+  location: string,
+  backendId: string,
+  buildInput: Omit<BuildInput, "name">
+): Promise<Build> {
+  logBullet("Creating a new build... this may take a few minutes.");
+  const buildId = generateBuildId();
+  const op = await apphosting.createBuild(projectId, location, backendId, buildId, buildInput);
+  const build = await poller.pollOperation<Build>({
+    ...apphostingPollerOptions,
+    pollerName: `create-${projectId}-${location}-backend-${backendId}-build-${buildId}`,
+    operationResourceName: op.name,
+  });
+  logSuccess("Build finished.");
+  return build;
+}
+
+/**
+ * Set (and waits for) a default traffic that directs all traffic to the buildId.
+ */
+export async function setDefaultTraffic(
+  projectId: string,
+  location: string,
+  backendId: string,
+  buildId: string
+): Promise<Build> {
+  logBullet("Directing traffic to the new build...");
+  const op = await apphosting.updateTraffic(projectId, location, backendId, {
+    target: {
+      splits: [
+        {
+          build: buildId,
+          percent: 100,
+        },
+      ],
+    },
+  });
+  const traffic = await poller.pollOperation<Build>({
+    ...apphostingPollerOptions,
+    pollerName: `create-${projectId}-${location}-backend-${backendId}-traffic`,
+    operationResourceName: op.name,
+  });
+  logSuccess("Traffic update finished.");
+  return traffic;
+}
