firebase-tools 9.21.0 → 9.23.2

package/lib/deploy/functions/containerCleaner.js

@@ -1,38 +1,15 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.DockerHelper = exports.deleteGcfArtifacts = exports.listGcfPaths = exports.ContainerRegistryCleaner = exports.cleanupBuildImages = exports.SUBDOMAIN_MAPPING = void 0;
+exports.DockerHelper = exports.deleteGcfArtifacts = exports.listGcfPaths = exports.ContainerRegistryCleaner = exports.NoopArtifactRegistryCleaner = exports.ArtifactRegistryCleaner = exports.cleanupBuildImages = void 0;
 const clc = require("cli-color");
+const error_1 = require("../../error");
 const api_1 = require("../../api");
 const logger_1 = require("../../logger");
-const docker = require("../../gcp/docker");
+const artifactregistry = require("../../gcp/artifactregistry");
 const backend = require("./backend");
+const docker = require("../../gcp/docker");
 const utils = require("../../utils");
-const error_1 = require("../../error");
-exports.SUBDOMAIN_MAPPING = {
-    "us-west2": "us",
-    "us-west3": "us",
-    "us-west4": "us",
-    "us-central1": "us",
-    "us-central2": "us",
-    "us-east1": "us",
-    "us-east4": "us",
-    "northamerica-northeast1": "us",
-    "southamerica-east1": "us",
-    "europe-west1": "eu",
-    "europe-west2": "eu",
-    "europe-west3": "eu",
-    "europe-west5": "eu",
-    "europe-west6": "eu",
-    "europe-central2": "eu",
-    "asia-east1": "asia",
-    "asia-east2": "asia",
-    "asia-northeast1": "asia",
-    "asia-northeast2": "asia",
-    "asia-northeast3": "asia",
-    "asia-south1": "asia",
-    "asia-southeast2": "asia",
-    "australia-southeast1": "asia",
-};
+const poller = require("../../operation-poller");
 async function retry(func) {
     const sleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
     const MAX_RETRIES = 3;
@@ -47,7 +24,7 @@ async function retry(func) {
             return await Promise.race([func(), timeout]);
         }
         catch (error) {
-            logger_1.logger.debug("Failed docker command with error", error);
+            logger_1.logger.debug("Failed docker command with error ", error);
             retry += 1;
             if (retry >= MAX_RETRIES) {
                 throw new error_1.FirebaseError("Failed to clean up artifacts", { original: error });
@@ -56,19 +33,40 @@ async function retry(func) {
         }
     }
 }
-async function cleanupBuildImages(functions) {
+async function cleanupBuildImages(haveFunctions, deletedFunctions, cleaners = {}) {
     utils.logBullet(clc.bold.cyan("functions: ") + "cleaning up build files...");
-    const gcrCleaner = new ContainerRegistryCleaner();
     const failedDomains = new Set();
-    await Promise.all(functions.map((func) => (async () => {
+    const cleanup = [];
+    const arCleaner = cleaners.ar || new ArtifactRegistryCleaner();
+    cleanup.push(...haveFunctions.map(async (func) => {
+        try {
+            await arCleaner.cleanupFunction(func);
+        }
+        catch (err) {
+            const path = `${func.project}/${func.region}/gcf-artifacts`;
+            failedDomains.add(`https://console.cloud.google.com/artifacts/docker/${path}`);
+        }
+    }));
+    cleanup.push(...deletedFunctions.map(async (func) => {
+        try {
+            await Promise.all([arCleaner.cleanupFunction(func), arCleaner.cleanupFunctionCache(func)]);
+        }
+        catch (err) {
+            const path = `${func.project}/${func.region}/gcf-artifacts`;
+            failedDomains.add(`https://console.cloud.google.com/artifacts/docker/${path}`);
+        }
+    }));
+    const gcrCleaner = cleaners.gcr || new ContainerRegistryCleaner();
+    cleanup.push(...[...haveFunctions, ...deletedFunctions].map(async (func) => {
         try {
             await gcrCleaner.cleanupFunction(func);
         }
         catch (err) {
-            const path = `${func.project}/${exports.SUBDOMAIN_MAPPING[func.region]}/gcf`;
+            const path = `${func.project}/${docker.GCR_SUBDOMAIN_MAPPING[func.region]}/gcf`;
             failedDomains.add(`https://console.cloud.google.com/gcr/images/${path}`);
         }
-    })()));
+    }));
+    await Promise.all(cleanup);
     if (failedDomains.size) {
         let message = "Unhandled error cleaning up build images. This could result in a small monthly bill if not corrected. ";
         message +=
@@ -83,12 +81,60 @@ async function cleanupBuildImages(functions) {
     }
 }
 exports.cleanupBuildImages = cleanupBuildImages;
+class ArtifactRegistryCleaner {
+    static packagePath(func) {
+        const encodedId = func.id
+            .replace(/_/g, "__")
+            .replace(/-/g, "--")
+            .replace(/^[A-Z]/, (first) => `${first.toLowerCase()}-${first.toLowerCase()}`)
+            .replace(/[A-Z]/g, (upper) => `_${upper.toLowerCase()}`);
+        return `projects/${func.project}/locations/${func.region}/repositories/gcf-artifacts/packages/${encodedId}`;
+    }
+    async cleanupFunction(func) {
+        let op;
+        try {
+            op = await artifactregistry.deletePackage(ArtifactRegistryCleaner.packagePath(func));
+        }
+        catch (err) {
+            if (err.status === 404) {
+                return;
+            }
+            throw err;
+        }
+        if (op.done) {
+            return;
+        }
+        await poller.pollOperation(Object.assign(Object.assign({}, ArtifactRegistryCleaner.POLLER_OPTIONS), { pollerName: `cleanup-${func.region}-${func.id}`, operationResourceName: op.name }));
+    }
+    async cleanupFunctionCache(func) {
+        const op = await artifactregistry.deletePackage(`${ArtifactRegistryCleaner.packagePath(func)}%2Fcache`);
+        if (op.done) {
+            return;
+        }
+        await poller.pollOperation(Object.assign(Object.assign({}, ArtifactRegistryCleaner.POLLER_OPTIONS), { pollerName: `cleanup-cache-${func.region}-${func.id}`, operationResourceName: op.name }));
+    }
+}
+exports.ArtifactRegistryCleaner = ArtifactRegistryCleaner;
+ArtifactRegistryCleaner.POLLER_OPTIONS = {
+    apiOrigin: api_1.artifactRegistryDomain,
+    apiVersion: artifactregistry.API_VERSION,
+    masterTimeout: 5 * 60 * 1000,
+};
+class NoopArtifactRegistryCleaner extends ArtifactRegistryCleaner {
+    cleanupFunction() {
+        return Promise.resolve();
+    }
+    cleanupFunctionCache() {
+        return Promise.resolve();
+    }
+}
+exports.NoopArtifactRegistryCleaner = NoopArtifactRegistryCleaner;
 class ContainerRegistryCleaner {
     constructor() {
         this.helpers = {};
     }
     helper(location) {
-        const subdomain = exports.SUBDOMAIN_MAPPING[location] || "us";
+        const subdomain = docker.GCR_SUBDOMAIN_MAPPING[location] || "us";
         if (!this.helpers[subdomain]) {
             const origin = `https://${subdomain}.${api_1.containerRegistryDomain}`;
             this.helpers[subdomain] = new DockerHelper(origin);
@@ -128,14 +174,14 @@ function getHelper(cache, subdomain) {
 }
 async function listGcfPaths(projectId, locations, dockerHelpers = {}) {
     if (!locations) {
-        locations = Object.keys(exports.SUBDOMAIN_MAPPING);
+        locations = Object.keys(docker.GCR_SUBDOMAIN_MAPPING);
     }
-    const invalidRegion = locations.find((loc) => !exports.SUBDOMAIN_MAPPING[loc]);
+    const invalidRegion = locations.find((loc) => !docker.GCR_SUBDOMAIN_MAPPING[loc]);
     if (invalidRegion) {
         throw new error_1.FirebaseError(`Invalid region ${invalidRegion} supplied`);
     }
     const locationsSet = new Set(locations);
-    const subdomains = new Set(Object.values(exports.SUBDOMAIN_MAPPING));
+    const subdomains = new Set(Object.values(docker.GCR_SUBDOMAIN_MAPPING));
     const failedSubdomains = [];
     const listAll = [];
     for (const subdomain of subdomains) {
@@ -166,26 +212,27 @@ async function listGcfPaths(projectId, locations, dockerHelpers = {}) {
         throw new error_1.FirebaseError(`Failed to search the following subdomains: ${failedSubdomains.join(",")}`);
     }
     return gcfDirs.map((loc) => {
-        return `${exports.SUBDOMAIN_MAPPING[loc]}.${api_1.containerRegistryDomain}/${projectId}/gcf/${loc}`;
+        return `${docker.GCR_SUBDOMAIN_MAPPING[loc]}.${api_1.containerRegistryDomain}/${projectId}/gcf/${loc}`;
     });
 }
 exports.listGcfPaths = listGcfPaths;
 async function deleteGcfArtifacts(projectId, locations, dockerHelpers = {}) {
     if (!locations) {
-        locations = Object.keys(exports.SUBDOMAIN_MAPPING);
+        locations = Object.keys(docker.GCR_SUBDOMAIN_MAPPING);
     }
-    const invalidRegion = locations.find((loc) => !exports.SUBDOMAIN_MAPPING[loc]);
+    const invalidRegion = locations.find((loc) => !docker.GCR_SUBDOMAIN_MAPPING[loc]);
     if (invalidRegion) {
         throw new error_1.FirebaseError(`Invalid region ${invalidRegion} supplied`);
     }
-    const subdomains = new Set(Object.values(exports.SUBDOMAIN_MAPPING));
+    const subdomains = new Set(Object.values(docker.GCR_SUBDOMAIN_MAPPING));
     const failedSubdomains = [];
     const deleteLocations = locations.map((loc) => {
+        const subdomain = docker.GCR_SUBDOMAIN_MAPPING[loc];
         try {
-            return getHelper(dockerHelpers, exports.SUBDOMAIN_MAPPING[loc]).rm(`${projectId}/gcf/${loc}`);
+            return getHelper(dockerHelpers, subdomain).rm(`${projectId}/gcf/${loc}`);
         }
         catch (err) {
-            failedSubdomains.push(exports.SUBDOMAIN_MAPPING[loc]);
+            failedSubdomains.push(subdomain);
             logger_1.logger.debug(err);
         }
     });
@@ -217,7 +264,7 @@ class DockerHelper {
     async rm(path) {
         let toThrowLater = undefined;
         const stat = await this.ls(path);
-        const recursive = stat.children.map((child) => (async () => {
+        const recursive = stat.children.map(async (child) => {
             try {
                 await this.rm(`${path}/${child}`);
                 stat.children.splice(stat.children.indexOf(child), 1);
@@ -225,8 +272,8 @@ class DockerHelper {
             catch (err) {
                 toThrowLater = err;
             }
-        })());
-        const deleteTags = stat.tags.map((tag) => (async () => {
+        });
+        const deleteTags = stat.tags.map(async (tag) => {
             try {
                 await retry(() => this.client.deleteTag(path, tag));
                 stat.tags.splice(stat.tags.indexOf(tag), 1);
@@ -235,9 +282,9 @@ class DockerHelper {
                 logger_1.logger.debug("Got error trying to remove docker tag:", err);
                 toThrowLater = err;
             }
-        })());
+        });
         await Promise.all(deleteTags);
-        const deleteImages = stat.digests.map((digest) => (async () => {
+        const deleteImages = stat.digests.map(async (digest) => {
             try {
                 await retry(() => this.client.deleteImage(path, digest));
                 stat.digests.splice(stat.digests.indexOf(digest), 1);
@@ -246,7 +293,7 @@ class DockerHelper {
                 logger_1.logger.debug("Got error trying to remove docker image:", err);
                 toThrowLater = err;
             }
-        })());
+        });
         await Promise.all(deleteImages);
         await Promise.all(recursive);
         if (toThrowLater) {

package/lib/deploy/functions/eventTypes.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PUBSUB_V2_EVENT = exports.STORAGE_V2_EVENTS = void 0;
+exports.STORAGE_V2_EVENTS = [
+    "google.cloud.storage.object.v1.finalized",
+    "google.cloud.storage.object.v1.archived",
+    "google.cloud.storage.object.v1.deleted",
+    "google.cloud.storage.object.v1.metadataUpdated",
+];
+exports.PUBSUB_V2_EVENT = "google.cloud.pubsub.topic.v1.messagePublished";

package/lib/deploy/functions/prepare.js

@@ -19,12 +19,20 @@ const validate = require("./validate");
 const utils = require("../../utils");
 const logger_1 = require("../../logger");
 const triggerRegionHelper_1 = require("./triggerRegionHelper");
+const checkIam_1 = require("./checkIam");
 function hasUserConfig(config) {
     return Object.keys(config).length > 1;
 }
 function hasDotenv(opts) {
     return previews_1.previews.dotenv && functionsEnv.hasUserEnvs(opts);
 }
+async function maybeEnableAR(projectId) {
+    if (previews_1.previews.artifactregistry) {
+        return ensureApiEnabled.check(projectId, "artifactregistry.googleapis.com", "functions", true);
+    }
+    await ensureApiEnabled.ensure(projectId, "artifactregistry.googleapis.com", "functions");
+    return true;
+}
 async function prepare(context, options, payload) {
     if (!options.config.src.functions) {
         return;
@@ -39,8 +47,10 @@ async function prepare(context, options, payload) {
         ensureApiEnabled.ensure(projectId, "cloudfunctions.googleapis.com", "functions"),
         ensureApiEnabled.check(projectId, "runtimeconfig.googleapis.com", "runtimeconfig", true),
         ensureCloudBuildEnabled_1.ensureCloudBuildEnabled(projectId),
+        maybeEnableAR(projectId),
     ]);
     context.runtimeConfigEnabled = checkAPIsEnabled[1];
+    context.artifactRegistryEnabled = checkAPIsEnabled[3];
     const firebaseConfig = await functionsConfig.getFirebaseConfig(options);
     context.firebaseConfig = firebaseConfig;
     const runtimeConfig = await prepareFunctionsUpload_1.getFunctionsConfig(context);
@@ -103,8 +113,9 @@ async function prepare(context, options, payload) {
         return functionsDeployHelper_1.functionMatchesAnyGroup(endpoint, context.filters);
     });
     const haveBackend = await backend.existingBackend(context);
+    await checkIam_1.ensureServiceAgentRoles(projectId, wantBackend, haveBackend);
     inferDetailsFromExisting(wantBackend, haveBackend, usedDotenv);
-    await triggerRegionHelper_1.lookupMissingTriggerRegions(wantBackend);
+    await triggerRegionHelper_1.ensureTriggerRegions(wantBackend);
     await prompts_1.promptForFailurePolicies(options, matchingBackend, haveBackend);
     await prompts_1.promptForMinInstances(options, matchingBackend, haveBackend);
     await backend.checkAvailability(context, wantBackend);

package/lib/deploy/functions/release/fabricator.js

@@ -10,6 +10,7 @@ const runtimes_1 = require("../runtimes");
 const api_1 = require("../../../api");
 const logger_1 = require("../../../logger");
 const backend = require("../backend");
+const cloudtasks = require("../../../gcp/cloudtasks");
 const deploymentTool = require("../../../deploymentTool");
 const gcf = require("../../../gcp/cloudfunctions");
 const gcfV2 = require("../../../gcp/cloudfunctionsv2");
@@ -24,11 +25,13 @@ const gcfV1PollerOptions = {
     apiOrigin: api_1.functionsOrigin,
     apiVersion: gcf.API_VERSION,
     masterTimeout: 25 * 60 * 1000,
+    maxBackoff: 10000,
 };
 const gcfV2PollerOptions = {
     apiOrigin: api_1.functionsV2Origin,
     apiVersion: gcfV2.API_VERSION,
     masterTimeout: 25 * 60 * 1000,
+    maxBackoff: 10000,
 };
 const DEFAULT_GCFV2_CONCURRENCY = 80;
 const rethrowAs = (endpoint, op) => (err) => {
@@ -121,7 +124,9 @@ class Fabricator {
         await this.setTrigger(endpoint);
     }
     async updateEndpoint(update, scraper) {
-        update.endpoint.labels = Object.assign(Object.assign({}, update.endpoint.labels), deploymentTool.labels());
+        if (update.deleteAndRecreate || update.endpoint.platform !== "gcfv2") {
+            update.endpoint.labels = Object.assign(Object.assign({}, update.endpoint.labels), deploymentTool.labels());
+        }
         if (update.deleteAndRecreate) {
             await this.deleteEndpoint(update.deleteAndRecreate);
             await this.createEndpoint(update.endpoint, scraper);
@@ -154,6 +159,9 @@ class Fabricator {
             throw new Error("Precondition failed");
         }
         const apiFunction = gcf.functionFromEndpoint(endpoint, this.sourceUrl);
+        if (apiFunction.httpsTrigger) {
+            apiFunction.httpsTrigger.securityLevel = "SECURE_ALWAYS";
+        }
         apiFunction.sourceToken = await scraper.tokenPromise();
         const resultFunction = await this.functionExecutor
             .run(async () => {
@@ -172,6 +180,16 @@ class Fabricator {
                     .catch(rethrowAs(endpoint, "set invoker"));
             }
         }
+        else if (backend.isTaskQueueTriggered(endpoint)) {
+            const invoker = endpoint.taskQueueTrigger.invoker;
+            if (invoker && !invoker.includes("private")) {
+                await this.executor
+                    .run(async () => {
+                    await gcf.setInvokerCreate(endpoint.project, backend.functionName(endpoint), invoker);
+                })
+                    .catch(rethrowAs(endpoint, "set invoker"));
+            }
+        }
     }
     async createV2Function(endpoint) {
         var _a;
@@ -214,6 +232,16 @@ class Fabricator {
                     .catch(rethrowAs(endpoint, "set invoker"));
             }
         }
+        else if (backend.isTaskQueueTriggered(endpoint)) {
+            const invoker = endpoint.taskQueueTrigger.invoker;
+            if (invoker && !invoker.includes("private")) {
+                await this.executor
+                    .run(async () => {
+                    await gcf.setInvokerCreate(endpoint.project, backend.functionName(endpoint), invoker);
+                })
+                    .catch(rethrowAs(endpoint, "set invoker"));
+            }
+        }
         await this.setConcurrency(endpoint, serviceName, endpoint.concurrency || DEFAULT_GCFV2_CONCURRENCY);
     }
     async updateV1Function(endpoint, scraper) {
@@ -231,12 +259,16 @@ class Fabricator {
         })
             .catch(rethrowAs(endpoint, "update"));
         endpoint.uri = (_a = resultFunction === null || resultFunction === void 0 ? void 0 : resultFunction.httpsTrigger) === null || _a === void 0 ? void 0 : _a.url;
-        if (backend.isHttpsTriggered(endpoint) && endpoint.httpsTrigger.invoker) {
+        let invoker;
+        if (backend.isHttpsTriggered(endpoint)) {
+            invoker = endpoint.httpsTrigger.invoker;
+        }
+        else if (backend.isTaskQueueTriggered(endpoint)) {
+            invoker = endpoint.taskQueueTrigger.invoker;
+        }
+        if (invoker) {
             await this.executor
-                .run(async () => {
-                await gcf.setInvokerUpdate(endpoint.project, backend.functionName(endpoint), endpoint.httpsTrigger.invoker);
-                return;
-            })
+                .run(() => gcf.setInvokerUpdate(endpoint.project, backend.functionName(endpoint), invoker))
                 .catch(rethrowAs(endpoint, "set invoker"));
         }
     }
@@ -250,17 +282,24 @@ class Fabricator {
         if ((_a = apiFunction.eventTrigger) === null || _a === void 0 ? void 0 : _a.pubsubTopic) {
             delete apiFunction.eventTrigger.pubsubTopic;
         }
-        const resultFunction = (await this.functionExecutor
+        const resultFunction = await this.functionExecutor
             .run(async () => {
             const op = await gcfV2.updateFunction(apiFunction);
             return await poller.pollOperation(Object.assign(Object.assign({}, gcfV2PollerOptions), { pollerName: `update-${endpoint.region}-${endpoint.id}`, operationResourceName: op.name }));
         })
-            .catch(rethrowAs(endpoint, "update")));
+            .catch(rethrowAs(endpoint, "update"));
         endpoint.uri = resultFunction.serviceConfig.uri;
         const serviceName = resultFunction.serviceConfig.service;
-        if (backend.isHttpsTriggered(endpoint) && endpoint.httpsTrigger.invoker) {
+        let invoker;
+        if (backend.isHttpsTriggered(endpoint)) {
+            invoker = endpoint.httpsTrigger.invoker;
+        }
+        else if (backend.isTaskQueueTriggered(endpoint)) {
+            invoker = endpoint.taskQueueTrigger.invoker;
+        }
+        if (invoker) {
             await this.executor
-                .run(() => run.setInvokerUpdate(endpoint.project, serviceName, endpoint.httpsTrigger.invoker))
+                .run(() => run.setInvokerUpdate(endpoint.project, serviceName, invoker))
                 .catch(rethrowAs(endpoint, "set invoker"));
         }
         if (endpoint.concurrency) {
@@ -314,6 +353,9 @@ class Fabricator {
             }
             functional_1.assertExhaustive(endpoint.platform);
         }
+        else if (backend.isTaskQueueTriggered(endpoint)) {
+            await this.upsertTaskQueue(endpoint);
+        }
     }
     async deleteTrigger(endpoint) {
         if (backend.isScheduleTriggered(endpoint)) {
@@ -327,6 +369,9 @@ class Fabricator {
             }
             functional_1.assertExhaustive(endpoint.platform);
         }
+        else if (backend.isTaskQueueTriggered(endpoint)) {
+            await this.disableTaskQueue(endpoint);
+        }
     }
     async upsertScheduleV1(endpoint) {
         const job = scheduler.jobFromEndpoint(endpoint, this.appEngineLocation);
@@ -337,6 +382,17 @@ class Fabricator {
     upsertScheduleV2(endpoint) {
         return Promise.reject(new reporter.DeploymentError(endpoint, "upsert schedule", new Error("Not implemented")));
     }
+    async upsertTaskQueue(endpoint) {
+        const queue = cloudtasks.queueFromEndpoint(endpoint);
+        await this.executor
+            .run(() => cloudtasks.upsertQueue(queue))
+            .catch(rethrowAs(endpoint, "upsert task queue"));
+        if (endpoint.taskQueueTrigger.invoker) {
+            await this.executor
+                .run(() => cloudtasks.setEnqueuer(queue.name, endpoint.taskQueueTrigger.invoker))
+                .catch(rethrowAs(endpoint, "set invoker"));
+        }
+    }
     async deleteScheduleV1(endpoint) {
         const job = scheduler.jobFromEndpoint(endpoint, this.appEngineLocation);
         await this.executor
@@ -349,6 +405,15 @@ class Fabricator {
     deleteScheduleV2(endpoint) {
         return Promise.reject(new reporter.DeploymentError(endpoint, "delete schedule", new Error("Not implemented")));
     }
+    async disableTaskQueue(endpoint) {
+        const update = {
+            name: cloudtasks.queueNameForEndpoint(endpoint),
+            state: "DISABLED",
+        };
+        await this.executor
+            .run(() => cloudtasks.updateQueue(update))
+            .catch(rethrowAs(endpoint, "disable task queue"));
+    }
     logOpStart(op, endpoint) {
         const runtime = runtimes_1.getHumanFriendlyRuntimeName(endpoint.runtime);
         const label = helper.getFunctionLabel(endpoint);

package/lib/deploy/functions/release/index.js

@@ -45,7 +45,15 @@ async function release(context, options, payload) {
     await reporter.logAndTrackDeployStats(summary);
     reporter.printErrors(summary);
     printTriggerUrls(payload.functions.backend);
-    await containerCleaner.cleanupBuildImages(backend.allEndpoints(payload.functions.backend));
+    const haveEndpoints = backend.allEndpoints(payload.functions.backend);
+    const deletedEndpoints = Object.values(plan)
+        .map((r) => r.endpointsToDelete)
+        .reduce(functional_1.reduceFlat, []);
+    const opts = {};
+    if (!context.artifactRegistryEnabled) {
+        opts.ar = new containerCleaner.NoopArtifactRegistryCleaner();
+    }
+    await containerCleaner.cleanupBuildImages(haveEndpoints, deletedEndpoints, opts);
     const allErrors = summary.results.filter((r) => r.error).map((r) => r.error);
     if (allErrors.length) {
         const opts = allErrors.length == 1 ? { original: allErrors[0] } : { children: allErrors };

package/lib/deploy/functions/release/planner.js

@@ -138,6 +138,9 @@ function checkForIllegalUpdate(want, have) {
         else if (backend.isScheduleTriggered(e)) {
             return "a scheduled";
         }
+        else if (backend.isTaskQueueTriggered(e)) {
+            return "a task queue";
+        }
         throw Error("Functions release planner is not able to handle an unknown trigger type");
     };
     const wantType = triggerType(want);

package/lib/deploy/functions/release/reporter.js

@@ -29,8 +29,10 @@ async function logAndTrackDeployStats(summary) {
     let totalSuccesses = 0;
     let totalAborts = 0;
     const reports = [];
+    const regions = new Set();
     for (const result of summary.results) {
         const tag = triggerTag(result.endpoint);
+        regions.add(result.endpoint.region);
         totalTime += result.durationMs;
         if (!result.error) {
             totalSuccesses++;
@@ -45,6 +47,8 @@ async function logAndTrackDeployStats(summary) {
             reports.push(track.track("function_deploy_failure", tag, result.durationMs));
         }
     }
+    const regionCountTag = regions.size < 5 ? regions.size.toString() : ">=5";
+    reports.push(track.track("functions_region_count", regionCountTag, 1));
     const gcfv1 = summary.results.find((r) => r.endpoint.platform === "gcfv1");
     const gcfv2 = summary.results.find((r) => r.endpoint.platform === "gcfv2");
     const tag = gcfv1 && gcfv2 ? "v1+v2" : gcfv1 ? "v1" : "v2";
@@ -135,7 +139,7 @@ function printQuotaErrors(results) {
 }
 function printAbortedErrors(results) {
     const aborted = results.filter((r) => r.error instanceof AbortedDeploymentError);
-    if (!aborted) {
+    if (!aborted.length) {
         return;
     }
     logger_1.logger.info("");
@@ -151,6 +155,9 @@ function triggerTag(endpoint) {
     if (backend.isScheduleTriggered(endpoint)) {
         return `${prefix}.scheduled`;
     }
+    if (backend.isTaskQueueTriggered(endpoint)) {
+        return `${prefix}.taskQueue`;
+    }
     if (backend.isHttpsTriggered(endpoint)) {
         if ((_a = endpoint.labels) === null || _a === void 0 ? void 0 : _a["deployment-callable"]) {
             return `${prefix}.callable`;

package/lib/deploy/functions/runtimes/discovery/v1alpha1.js

@@ -59,6 +59,7 @@ function parseEndpoints(manifest, id, project, defaultRegion, runtime) {
         httpsTrigger: "object",
         eventTrigger: "object",
         scheduleTrigger: "object",
+        taskQueueTrigger: "object",
     });
     let triggerCount = 0;
     if (ep.httpsTrigger) {
@@ -70,6 +71,9 @@ function parseEndpoints(manifest, id, project, defaultRegion, runtime) {
     if (ep.scheduleTrigger) {
         triggerCount++;
     }
+    if (ep.taskQueueTrigger) {
+        triggerCount++;
+    }
     if (!triggerCount) {
         throw new error_1.FirebaseError("Expected trigger in endpoint" + id);
     }
@@ -111,6 +115,30 @@ function parseEndpoints(manifest, id, project, defaultRegion, runtime) {
             });
             triggered = { scheduleTrigger: ep.scheduleTrigger };
         }
+        else if (backend.isTaskQueueTriggered(ep)) {
+            parsing_1.assertKeyTypes(prefix + ".taskQueueTrigger", ep.taskQueueTrigger, {
+                rateLimits: "object",
+                retryConfig: "object",
+                invoker: "array",
+            });
+            if (ep.taskQueueTrigger.rateLimits) {
+                parsing_1.assertKeyTypes(prefix + ".taskQueueTrigger.rateLimits", ep.taskQueueTrigger.rateLimits, {
+                    maxBurstSize: "number",
+                    maxConcurrentDispatches: "number",
+                    maxDispatchesPerSecond: "number",
+                });
+            }
+            if (ep.taskQueueTrigger.retryConfig) {
+                parsing_1.assertKeyTypes(prefix + ".taskQueueTrigger.retryConfig", ep.taskQueueTrigger.retryConfig, {
+                    maxAttempts: "number",
+                    maxRetryDuration: "string",
+                    minBackoff: "string",
+                    maxBackoff: "string",
+                    maxDoublings: "number",
+                });
+            }
+            triggered = { taskQueueTrigger: ep.taskQueueTrigger };
+        }
         else {
             throw new error_1.FirebaseError(`Do not recognize trigger type for endpoint ${id}. Try upgrading ` +
                 "firebase-tools with npm install -g firebase-tools@latest");

package/lib/deploy/functions/runtimes/node/parseTriggers.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.addResourcesToBackend = exports.discoverBackend = exports.useStrategy = exports.GCS_EVENTS = void 0;
+exports.addResourcesToBackend = exports.discoverBackend = exports.useStrategy = void 0;
 const path = require("path");
 const _ = require("lodash");
 const child_process_1 = require("child_process");
@@ -9,13 +9,8 @@ const logger_1 = require("../../../../logger");
 const backend = require("../../backend");
 const api = require("../../../../api");
 const proto = require("../../../../gcp/proto");
+const eventTypes_1 = require("../../eventTypes");
 const TRIGGER_PARSER = path.resolve(__dirname, "./triggerParser.js");
-exports.GCS_EVENTS = new Set([
-    "google.cloud.storage.object.v1.finalized",
-    "google.cloud.storage.object.v1.archived",
-    "google.cloud.storage.object.v1.deleted",
-    "google.cloud.storage.object.v1.metadataUpdated",
-]);
 function removeInspectOptions(options) {
     return options.filter((opt) => !opt.startsWith("--inspect"));
 }
@@ -64,14 +59,18 @@ async function discoverBackend(projectId, sourceDir, runtime, configValues, envs
 }
 exports.discoverBackend = discoverBackend;
 function addResourcesToBackend(projectId, runtime, annotation, want) {
-    var _a;
     Object.freeze(annotation);
     for (const region of annotation.regions || [api.functionsDefaultRegion]) {
         let triggered;
-        if (!!annotation.httpsTrigger == !!annotation.eventTrigger) {
+        const triggerCount = +!!annotation.httpsTrigger + +!!annotation.eventTrigger + +!!annotation.taskQueueTrigger;
+        if (triggerCount != 1) {
             throw new error_1.FirebaseError("Unexpected annotation generated by the Firebase Functions SDK. This should never happen.");
         }
-        if (annotation.httpsTrigger) {
+        if (annotation.taskQueueTrigger) {
+            triggered = { taskQueueTrigger: annotation.taskQueueTrigger };
+            want.requiredAPIs["cloudtasks"] = "cloudtasks.googleapis.com";
+        }
+        else if (annotation.httpsTrigger) {
             const trigger = {};
             if (annotation.failurePolicy) {
                 logger_1.logger.warn(`Ignoring retry policy for HTTPS function ${annotation.name}`);
@@ -94,7 +93,7 @@ function addResourcesToBackend(projectId, runtime, annotation, want) {
                     retry: !!annotation.failurePolicy,
                 },
             };
-            if (exports.GCS_EVENTS.has(((_a = annotation.eventTrigger) === null || _a === void 0 ? void 0 : _a.eventType) || "")) {
+            if (eventTypes_1.STORAGE_V2_EVENTS.find((event) => { var _a; return event === (((_a = annotation.eventTrigger) === null || _a === void 0 ? void 0 : _a.eventType) || ""); })) {
                 triggered.eventTrigger.eventFilters = {
                     bucket: annotation.eventTrigger.resource,
                 };