Create a basic implementation of local builds that uses the new effective API fields. Also, this code keeps the source deploy path (existing feature, different from local builds) unaffected.

falahat · falahat · commit b8e17366be0e · 2026-03-10T19:52:42.000-04:00
We create tar.gz files instead of zip files.
diff --git a/src/deploy/apphosting/deploy.spec.ts b/src/deploy/apphosting/deploy.spec.ts
@@ -8,6 +8,7 @@ import deploy from "./deploy";
 import * as util from "./util";
 import * as fs from "fs";
 import * as getProjectNumber from "../../getProjectNumber";
+import * as experiments from "../../experiments";
 
 const BASE_OPTS = {
   cwd: "/",
@@ -51,8 +52,10 @@ describe("apphosting", () => {
   let upsertBucketStub: sinon.SinonStub;
   let uploadObjectStub: sinon.SinonStub;
   let createArchiveStub: sinon.SinonStub;
+  let createTarArchiveStub: sinon.SinonStub;
   let createReadStreamStub: sinon.SinonStub;
   let getProjectNumberStub: sinon.SinonStub;
+  let isEnabledStub: sinon.SinonStub;
 
   beforeEach(() => {
     getProjectNumberStub = sinon
@@ -61,9 +64,13 @@ describe("apphosting", () => {
     upsertBucketStub = sinon.stub(gcs, "upsertBucket").throws("Unexpected upsertBucket call");
     uploadObjectStub = sinon.stub(gcs, "uploadObject").throws("Unexpected uploadObject call");
     createArchiveStub = sinon.stub(util, "createArchive").throws("Unexpected createArchive call");
+    createTarArchiveStub = sinon
+      .stub(util, "createTarArchive")
+      .throws("Unexpected createTarArchive call");
     createReadStreamStub = sinon
       .stub(fs, "createReadStream")
       .throws("Unexpected createReadStream call");
+    isEnabledStub = sinon.stub(experiments, "isEnabled").returns(false);
   });
 
   afterEach(() => {
@@ -195,5 +202,31 @@ describe("apphosting", () => {
         `gs://${bucketName}/foo-local-build-1234.zip`,
       );
     });
+
+    it("uses createTarArchive for local builds when experiment is enabled", async () => {
+      const context = initializeContext();
+      // Remove the non-local build backend for this test for simplicity
+      delete context.backendConfigs.foo;
+      delete context.backendLocations.foo;
+      const projectNumber = "000000000000";
+      const location = "us-central1";
+      const bucketName = `firebaseapphosting-sources-${projectNumber}-${location}`;
+
+      getProjectNumberStub.resolves(projectNumber);
+      upsertBucketStub.resolves(bucketName);
+      isEnabledStub.withArgs("apphostinglocalbuilds").returns(true);
+      createTarArchiveStub.resolves("path/to/foo-local-build-1234.tar.gz");
+      uploadObjectStub.resolves({
+        bucket: bucketName,
+        object: "foo-local-build-1234.tar.gz",
+      });
+      createReadStreamStub.returns("stream" as any);
+
+      await deploy(context, { ...opts, config: new Config({ apphosting: { backendId: "fooLocalBuild", localBuild: true } }) });
+
+      expect(createTarArchiveStub).to.be.calledOnce;
+      expect(createArchiveStub).to.not.be.called;
+      expect(context.backendStorageUris["fooLocalBuild"]).to.equal(`gs://${bucketName}/foo-local-build-1234.tar.gz`);
+    });
   });
 });
diff --git a/src/deploy/apphosting/deploy.ts b/src/deploy/apphosting/deploy.ts
@@ -7,7 +7,8 @@ import { Options } from "../../options";
 import { needProjectId } from "../../projectUtils";
 import { logLabeledBullet } from "../../utils";
 import { Context } from "./args";
-import { createArchive } from "./util";
+import { createArchive, createTarArchive } from "./util";
+import { isEnabled } from "../../experiments";
 
 /**
  * Zips and uploads App Hosting source code to Google Cloud Storage in preparation for
@@ -71,10 +72,15 @@ export default async function (context: Context, options: Options): Promise<void
           throw new FirebaseError(`No local build dir found for ${cfg.backendId}`);
         }
       }
-      const zippedSourcePath = await createArchive(cfg, rootDir, builtAppDir);
+      let zippedSourcePath;
+      if (cfg.localBuild && isEnabled("apphostinglocalbuilds")) {
+        zippedSourcePath = await createTarArchive(cfg, rootDir, builtAppDir);
+      } else {
+        zippedSourcePath = await createArchive(cfg, rootDir, builtAppDir);
+      }
       logLabeledBullet(
         "apphosting",
-        `Zipped ${cfg.localBuild ? "built app" : "source"} for backend ${cfg.backendId}`,
+        `Archived ${cfg.localBuild ? "built app" : "source"} for backend ${cfg.backendId}`,
       );
 
       const backendLocation = context.backendLocations[cfg.backendId];
diff --git a/src/deploy/apphosting/release.spec.ts b/src/deploy/apphosting/release.spec.ts
@@ -1,10 +1,14 @@
 import * as sinon from "sinon";
 import * as rollout from "../../apphosting/rollout";
+import * as backend from "../../apphosting/backend";
 import { Config } from "../../config";
 import { RC } from "../../rc";
+import { needProjectId } from "../../projectUtils";
 import { Context } from "./args";
 import release from "./release";
 import { expect } from "chai";
+import * as experiments from "../../experiments";
+import { isEnabled } from "../../experiments";
 
 const BASE_OPTS = {
   cwd: "/",
@@ -18,7 +22,14 @@ const BASE_OPTS = {
 };
 
 describe("apphosting", () => {
+  let isEnabledStub: sinon.SinonStub;
   let orchestrateRolloutStub: sinon.SinonStub;
+  let getBackendStub: sinon.SinonStub;
+
+  beforeEach(() => {
+    isEnabledStub = sinon.stub(experiments, "isEnabled").returns(false);
+    getBackendStub = sinon.stub(backend, "getBackend").resolves({ uri: "https://foo-us-central1.a.run.app" } as any);
+  });
 
   afterEach(() => {
     sinon.verifyAndRestore();
@@ -63,5 +74,107 @@ describe("apphosting", () => {
 
       await expect(release(context, opts)).to.eventually.not.rejected;
     });
+
+    it("uses archive for standard source deployments", async () => {
+      const context: Context = {
+        backendConfigs: {
+          foo: {
+            backendId: "foo",
+            rootDir: "/",
+            ignore: [],
+          },
+        },
+        backendLocations: { foo: "us-central1" },
+        backendStorageUris: {
+          foo: "gs://bucket/source.zip",
+        },
+        backendLocalBuilds: {},
+      };
+
+      orchestrateRolloutStub = sinon.stub(rollout, "orchestrateRollout").resolves();
+
+      await release(context, opts);
+
+      expect(orchestrateRolloutStub).to.be.calledOnceWith(sinon.match({
+        buildInput: {
+          source: {
+            archive: {
+              userStorageUri: "gs://bucket/source.zip",
+              rootDirectory: "/",
+            },
+          },
+        },
+      }));
+    });
+
+    it("uses locallyBuilt for local builds when experiment is enabled", async () => {
+      isEnabledStub.withArgs("apphostinglocalbuilds").returns(true);
+      const context: Context = {
+        backendConfigs: {
+          foo: {
+            backendId: "foo",
+            rootDir: "/",
+            ignore: [],
+            localBuild: true,
+          },
+        },
+        backendLocations: { foo: "us-central1" },
+        backendStorageUris: {
+          foo: "gs://bucket/built.tar.gz",
+        },
+        backendLocalBuilds: {
+          foo: {
+            buildDir: "dist",
+            buildConfig: {},
+            annotations: {},
+          },
+        },
+      };
+
+      orchestrateRolloutStub = sinon.stub(rollout, "orchestrateRollout").resolves();
+
+      await release(context, opts);
+
+      expect(orchestrateRolloutStub).to.be.calledOnceWith(sinon.match({
+        buildInput: {
+          source: {
+            locallyBuilt: {
+              userStorageUri: "gs://bucket/built.tar.gz",
+            },
+          },
+        },
+      }));
+    });
+
+    it("skips local builds when experiment is disabled", async () => {
+      isEnabledStub.withArgs("apphostinglocalbuilds").returns(false);
+      const context: Context = {
+        backendConfigs: {
+          foo: {
+            backendId: "foo",
+            rootDir: "/",
+            ignore: [],
+            localBuild: true,
+          },
+        },
+        backendLocations: { foo: "us-central1" },
+        backendStorageUris: {
+          foo: "gs://bucket/built.tar.gz",
+        },
+        backendLocalBuilds: {
+          foo: {
+            buildDir: "dist",
+            buildConfig: {},
+            annotations: {},
+          },
+        },
+      };
+
+      orchestrateRolloutStub = sinon.stub(rollout, "orchestrateRollout").resolves();
+
+      await release(context, opts);
+
+      expect(orchestrateRolloutStub).to.not.be.called;
+    });
   });
 });
diff --git a/src/deploy/apphosting/release.ts b/src/deploy/apphosting/release.ts
@@ -12,6 +12,7 @@ import {
 } from "../../utils";
 import { Context } from "./args";
 import { FirebaseError } from "../../error";
+import { isEnabled } from "../../experiments";
 
 /**
  * Orchestrates rollouts for the backends targeted for deployment.
@@ -30,7 +31,9 @@ export default async function (context: Context, options: Options): Promise<void
     backendIds = backendIds.filter((id) => !missingBackends.includes(id));
   }
 
-  const localBuildBackends = backendIds.filter((id) => context.backendLocalBuilds[id]);
+  const localBuildBackends = backendIds.filter(
+    (id) => context.backendLocalBuilds[id] && !isEnabled("apphostinglocalbuilds"),
+  );
   if (localBuildBackends.length > 0) {
     logLabeledWarning(
       "apphosting",
@@ -44,24 +47,34 @@ export default async function (context: Context, options: Options): Promise<void
   }
 
   const projectId = needProjectId(options);
-  const rollouts = backendIds.map((backendId) =>
-    // TODO(9114): Add run_command
-    // TODO(914): Set the buildConfig.
-    // TODO(914): Set locallyBuiltSource.
-    orchestrateRollout({
+  const rollouts = backendIds.map((backendId) => {
+    const cfg = context.backendConfigs[backendId];
+    const isLocalBuild = cfg.localBuild && isEnabled("apphostinglocalbuilds");
+    let source: any;
+    if (isLocalBuild) {
+      source = {
+        locallyBuilt: {
+          userStorageUri: context.backendStorageUris[backendId],
+        },
+      };
+    } else {
+      source = {
+        archive: {
+          userStorageUri: context.backendStorageUris[backendId],
+          rootDirectory: cfg.rootDir,
+        },
+      };
+    }
+
+    return orchestrateRollout({
       projectId,
       backendId,
       location: context.backendLocations[backendId],
       buildInput: {
-        source: {
-          archive: {
-            userStorageUri: context.backendStorageUris[backendId],
-            rootDirectory: context.backendConfigs[backendId].rootDir,
-          },
-        },
+        source,
       },
-    }),
-  );
+    });
+  });
 
   logLabeledBullet(
     "apphosting",
diff --git a/src/deploy/apphosting/util.ts b/src/deploy/apphosting/util.ts
@@ -51,6 +51,60 @@ export async function createArchive(
   return tmpFile;
 }
 
+/**
+ * Locates the source code for a backend and creates a tar archive to eventually upload to GCS.
+ */
+export async function createTarArchive(
+  config: AppHostingSingle,
+  rootDir: string,
+  targetSubDir?: string,
+): Promise<string> {
+  const tmpFile = tmp.fileSync({ prefix: `${config.backendId}-`, postfix: ".tar.gz" }).name;
+  const fileStream = fs.createWriteStream(tmpFile, {
+    flags: "w",
+    encoding: "binary",
+  });
+  const archive = archiver("tar", {
+    gzip: true,
+    gzipOptions: {
+      level: 9,
+    },
+  });
+
+  const targetDir = targetSubDir ? path.join(rootDir, targetSubDir) : rootDir;
+  const ignore = config.ignore || ["node_modules", ".git"];
+  ignore.push("firebase-debug.log", "firebase-debug.*.log");
+  const gitIgnorePatterns = parseGitIgnorePatterns(targetDir);
+  ignore.push(...gitIgnorePatterns);
+  try {
+    const files = await fsAsync.readdirRecursive({
+      path: targetDir,
+      ignore: ignore,
+      isGitIgnore: true,
+    });
+    for (const file of files) {
+      const name = path.relative(rootDir, file.name);
+      archive.file(file.name, {
+        name,
+        mode: file.mode,
+        // Set fixed metadata for deterministic hashing
+        stats: {
+          uid: 0,
+          gid: 0,
+          mtime: new Date(0),
+        },
+      } as archiver.EntryData);
+    }
+    await pipeAsync(archive, fileStream);
+  } catch (err: unknown) {
+    throw new FirebaseError(
+      "Could not read source directory. Remove links and shortcuts and try again.",
+      { original: err as Error, exit: 1 },
+    );
+  }
+  return tmpFile;
+}
+
 function parseGitIgnorePatterns(projectRoot: string, gitIgnorePath = ".gitignore"): string[] {
   const absoluteFilePath = path.resolve(projectRoot, gitIgnorePath);
   if (!fs.existsSync(absoluteFilePath)) {
diff --git a/src/gcp/apphosting.ts b/src/gcp/apphosting.ts
@@ -118,6 +118,21 @@ export interface BuildConfig {
 interface BuildSource {
   codebase?: CodebaseSource;
   archive?: ArchiveSource;
+  locallyBuilt?: LocallyBuiltSource;
+}
+
+export interface LocallyBuiltSource {
+  userStorageUri: string;
+  rootDirectory?: string;
+  description?: string;
+  runCommand?: string;
+  runConfig?: RunConfig;
+  env?: Env[];
+}
+
+export interface RunConfig {
+  cpu?: number;
+  memoryMiB?: number;
 }
 
 interface CodebaseSource {
@@ -140,6 +155,7 @@ interface ArchiveSource {
   // end oneof reference
   rootDirectory?: string;
   author?: SourceUserMetadata;
+  /** @deprecated use Build.source.locallyBuilt instead */
   locallyBuiltSource?: boolean;
 }
 
