Adding default timeout for dart functions (#10501)

* Adding default timeout for dart functions

* fix: resolve lint errors and remove any casts in tests

* Adding change log

* changelog

* Addressing reviews

* Rehauling the logic to handle all functions deployed as run

* Modularize resolveDefaultTimeout

Author: shettyvarun268

CHANGELOG.md

@@ -1,2 +1,3 @@
 - Updated Pub/Sub emulator to version 0.8.31
 - Resolves undefined regions earlier, during the build to backend resolution phase (#10471)
+- Default timeout for Dart functions is now 60 seconds when not explicitly set (#10501)

src/deploy/functions/backend.ts

@@ -256,6 +256,7 @@ export function memoryToGen2Cpu(memory: MemoryOptions): number {
 
 export const DEFAULT_CONCURRENCY = 80;
 export const DEFAULT_MEMORY: MemoryOptions = 256;
+export const DEFAULT_TIMEOUT_SECONDS = 60;
 export const MIN_CPU_FOR_CONCURRENCY = 1;
 export const SCHEDULED_FUNCTION_LABEL = Object.freeze({ deployment: "firebase-schedule" });
 

src/deploy/functions/prepare.spec.ts

@@ -593,6 +593,18 @@ describe("prepare", () => {
       expect(want.availableMemoryMb).to.equal(512);
     });
 
+    it("fills in timeout from last deploy", () => {
+      const want: backend.Endpoint = {
+        ...ENDPOINT_BASE,
+        httpsTrigger: {},
+      };
+      const have: backend.Endpoint = JSON.parse(JSON.stringify(want));
+      have.timeoutSeconds = 120;
+
+      prepare.inferDetailsFromExisting(backend.of(want), backend.of(have), /* usedDotEnv= */ false);
+      expect(want.timeoutSeconds).to.equal(120);
+    });
+
     it("downgrades concurrency if necessary (explicit)", () => {
       const have: backend.Endpoint = {
         ...ENDPOINT_BASE,
@@ -645,6 +657,28 @@ describe("prepare", () => {
       prepare.resolveCpuAndConcurrency(backend.of(want));
       expect(want.concurrency).to.equal(1);
     });
+
+    it("defaults timeout to 60 for run platform functions", () => {
+      const want: backend.Endpoint = {
+        ...ENDPOINT_BASE,
+        platform: "run",
+        httpsTrigger: {},
+      };
+
+      prepare.resolveDefaultTimeout(backend.of(want));
+      expect(want.timeoutSeconds).to.equal(60);
+    });
+
+    it("does not default timeout for gcfv2 platform functions", () => {
+      const want: backend.Endpoint = {
+        ...ENDPOINT_BASE,
+        platform: "gcfv2",
+        httpsTrigger: {},
+      };
+
+      prepare.resolveDefaultTimeout(backend.of(want));
+      expect(want.timeoutSeconds).to.be.undefined;
+    });
   });
 
   describe("inferBlockingDetails", () => {

src/deploy/functions/prepare.ts

@@ -302,6 +302,7 @@ export async function prepare(
     inferDetailsFromExisting(wantBackend, haveBackend, codebaseUsesEnvs.includes(codebase));
     await ensureTriggerRegions(wantBackend);
     resolveCpuAndConcurrency(wantBackend);
+    resolveDefaultTimeout(wantBackend);
     validate.endpointsAreValid(wantBackend);
     inferBlockingDetails(wantBackend);
   }
@@ -552,6 +553,10 @@ export function inferDetailsFromExisting(
       wantE.cpu = haveE.cpu;
     }
 
+    if (typeof wantE.timeoutSeconds === "undefined" && haveE.timeoutSeconds) {
+      wantE.timeoutSeconds = haveE.timeoutSeconds;
+    }
+
     // N.B. concurrency has different defaults based on CPU. If the customer
     // only specifies CPU and they change that specification to < 1, we should
     // turn off concurrency.
@@ -650,6 +655,18 @@ export function resolveCpuAndConcurrency(want: backend.Backend): void {
   }
 }
 
+/**
+ * Assigns the default timeout to a function if it is deployed to Cloud Run
+ * and no timeout was specified.
+ */
+export function resolveDefaultTimeout(want: backend.Backend): void {
+  for (const e of backend.allEndpoints(want)) {
+    if (e.platform === "run" && e.timeoutSeconds === undefined) {
+      e.timeoutSeconds = backend.DEFAULT_TIMEOUT_SECONDS;
+    }
+  }
+}
+
 /**
  * Exported for use by an internal command (internaltesting:functions:discover) only.
  * @internal

src/deploy/functions/runtimes/dart/index.spec.ts

@@ -0,0 +1,97 @@
+import { expect } from "chai";
+import * as sinon from "sinon";
+import { Delegate } from "./index";
+import * as discovery from "../discovery";
+import * as build from "../../build";
+import * as supported from "../supported";
+
+describe("Dart Runtime Delegate", () => {
+  describe("discoverBuild", () => {
+    let detectFromYamlStub: sinon.SinonStub;
+
+    beforeEach(() => {
+      detectFromYamlStub = sinon.stub(discovery, "detectFromYaml");
+    });
+
+    afterEach(() => {
+      sinon.restore();
+    });
+
+    it("should not set default timeout", async () => {
+      const delegate = new Delegate("project", "sourceDir", supported.latest("dart"));
+
+      const mockBuild: build.Build = {
+        endpoints: {
+          func1: {
+            platform: "gcfv2",
+            entryPoint: "func1",
+            project: "project",
+            runtime: supported.latest("dart"),
+            httpsTrigger: {},
+          },
+        },
+        params: [],
+        requiredAPIs: [],
+      };
+
+      detectFromYamlStub.resolves(mockBuild);
+
+      const result = await delegate.discoverBuild({}, {});
+
+      expect(result.endpoints.func1.timeoutSeconds).to.be.undefined;
+      expect(result.endpoints.func1.platform).to.equal("run");
+    });
+
+    it("should preserve user-defined timeout", async () => {
+      const delegate = new Delegate("project", "sourceDir", supported.latest("dart"));
+
+      const mockBuild: build.Build = {
+        endpoints: {
+          func1: {
+            platform: "gcfv2",
+            entryPoint: "func1",
+            project: "project",
+            runtime: supported.latest("dart"),
+            httpsTrigger: {},
+            timeoutSeconds: 120,
+          },
+        },
+        params: [],
+        requiredAPIs: [],
+      };
+
+      detectFromYamlStub.resolves(mockBuild);
+
+      const result = await delegate.discoverBuild({}, {});
+
+      expect(result.endpoints.func1.timeoutSeconds).to.equal(120);
+      expect(result.endpoints.func1.platform).to.equal("run");
+    });
+
+    it("should not apply default timeout in emulator mode", async () => {
+      const delegate = new Delegate("project", "sourceDir", supported.latest("dart"));
+
+      const mockBuild: build.Build = {
+        endpoints: {
+          func1: {
+            platform: "gcfv2",
+            entryPoint: "func1",
+            project: "project",
+            runtime: supported.latest("dart"),
+            httpsTrigger: {},
+          },
+        },
+        params: [],
+        requiredAPIs: [],
+      };
+
+      detectFromYamlStub.resolves(mockBuild);
+
+      const result = await delegate.discoverBuild({}, { FUNCTIONS_EMULATOR: "true" });
+
+      expect(result.endpoints.func1.timeoutSeconds).to.be.undefined;
+      // Platform should not be converted to "run" in emulator mode either
+      expect(result.endpoints.func1.platform).to.equal("gcfv2");
+    });
+  });
+});