firebase-tools 10.7.0 → 10.8.0

package/lib/deploy/functions/prepare.js

@@ -1,8 +1,9 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.inferBlockingDetails = exports.inferDetailsFromExisting = exports.prepare = void 0;
+exports.resolveCpu = exports.inferBlockingDetails = exports.inferDetailsFromExisting = exports.prepare = void 0;
 const clc = require("cli-color");
 const backend = require("./backend");
+const build = require("./build");
 const ensureApiEnabled = require("../../ensureApiEnabled");
 const functionsConfig = require("../../functionsConfig");
 const functionsEnv = require("../../functions/env");
@@ -22,19 +23,17 @@ const error_1 = require("../../error");
 const projectConfig_1 = require("../../functions/projectConfig");
 const previews_1 = require("../../previews");
 const v1_1 = require("../../functions/events/v1");
+const serviceusage_1 = require("../../gcp/serviceusage");
 function hasUserConfig(config) {
     return Object.keys(config).length > 1;
 }
-function hasDotenv(opts) {
-    return functionsEnv.hasUserEnvs(opts);
-}
 async function prepare(context, options, payload) {
     const projectId = (0, projectUtils_1.needProjectId)(options);
     const projectNumber = await (0, projectUtils_1.needProjectNumber)(options);
-    context.config = (0, projectConfig_1.normalizeAndValidate)(options.config.src.functions)[0];
+    context.config = (0, projectConfig_1.normalizeAndValidate)(options.config.src.functions);
     context.filters = (0, functionsDeployHelper_1.getEndpointFilters)(options);
-    if (context.filters &&
-        !context.filters.map((f) => f.codebase).includes(context.config.codebase)) {
+    const codebases = (0, functionsDeployHelper_1.targetCodebases)(context.config, context.filters);
+    if (codebases.length === 0) {
         throw new error_1.FirebaseError("No function matches given --only filters. Aborting deployment.");
     }
     const checkAPIsEnabled = await Promise.all([
@@ -50,79 +49,106 @@ async function prepare(context, options, payload) {
     if (checkAPIsEnabled[1]) {
         runtimeConfig = Object.assign(Object.assign({}, runtimeConfig), (await (0, prepareFunctionsUpload_1.getFunctionsConfig)(projectId)));
     }
-    (0, utils_1.logLabeledBullet)("functions", `preparing codebase ${clc.bold(context.config.codebase)} for deployment`);
-    const sourceDirName = context.config.source;
-    if (!sourceDirName) {
-        throw new error_1.FirebaseError(`No functions code detected at default location (./functions), and no functions source defined in firebase.json`);
+    context.sources = {};
+    const codebaseUsesEnvs = [];
+    const wantBackends = {};
+    for (const codebase of codebases) {
+        (0, utils_1.logLabeledBullet)("functions", `preparing codebase ${clc.bold(codebase)} for deployment`);
+        const config = (0, projectConfig_1.configForCodebase)(context.config, codebase);
+        const sourceDirName = config.source;
+        if (!sourceDirName) {
+            throw new error_1.FirebaseError(`No functions code detected at default location (./functions), and no functions source defined in firebase.json`);
+        }
+        const sourceDir = options.config.path(sourceDirName);
+        const delegateContext = {
+            projectId,
+            sourceDir,
+            projectDir: options.config.projectDir,
+            runtime: config.runtime || "",
+        };
+        const runtimeDelegate = await runtimes.getRuntimeDelegate(delegateContext);
+        logger_1.logger.debug(`Validating ${runtimeDelegate.name} source`);
+        await runtimeDelegate.validate();
+        logger_1.logger.debug(`Building ${runtimeDelegate.name} source`);
+        await runtimeDelegate.build();
+        const firebaseEnvs = functionsEnv.loadFirebaseEnvs(firebaseConfig, projectId);
+        const userEnvOpt = {
+            functionsSource: sourceDir,
+            projectId: projectId,
+            projectAlias: options.projectAlias,
+        };
+        const userEnvs = functionsEnv.loadUserEnvs(userEnvOpt);
+        const envs = Object.assign(Object.assign({}, userEnvs), firebaseEnvs);
+        let wantBackend;
+        if (previews_1.previews.functionsparams) {
+            const wantBuild = await runtimeDelegate.discoverBuild(runtimeConfig, firebaseEnvs);
+            wantBackend = build.resolveBackend(wantBuild, userEnvs);
+        }
+        else {
+            logger_1.logger.debug(`Analyzing ${runtimeDelegate.name} backend spec`);
+            wantBackend = await runtimeDelegate.discoverSpec(runtimeConfig, firebaseEnvs);
+        }
+        wantBackend.environmentVariables = envs;
+        for (const endpoint of backend.allEndpoints(wantBackend)) {
+            endpoint.environmentVariables = wantBackend.environmentVariables;
+            endpoint.codebase = codebase;
+        }
+        wantBackends[codebase] = wantBackend;
+        if (functionsEnv.hasUserEnvs(userEnvOpt)) {
+            codebaseUsesEnvs.push(codebase);
+        }
+    }
+    validate.endpointsAreUnique(wantBackends);
+    for (const [codebase, wantBackend] of Object.entries(wantBackends)) {
+        const config = (0, projectConfig_1.configForCodebase)(context.config, codebase);
+        const sourceDirName = config.source;
+        const sourceDir = options.config.path(sourceDirName);
+        const source = {};
+        if (backend.someEndpoint(wantBackend, () => true)) {
+            (0, utils_1.logLabeledBullet)("functions", `preparing ${clc.bold(sourceDirName)} directory for uploading...`);
+        }
+        if (backend.someEndpoint(wantBackend, (e) => e.platform === "gcfv2")) {
+            if (!previews_1.previews.functionsv2) {
+                throw new error_1.FirebaseError("This version of firebase-tools does not support Google Cloud " +
+                    "Functions gen 2\n" +
+                    "If Cloud Functions for Firebase gen 2 is still in alpha, sign up " +
+                    "for the alpha program at " +
+                    "https://services.google.com/fb/forms/firebasealphaprogram/\n" +
+                    "If Cloud Functions for Firebase gen 2 is in beta, get the latest " +
+                    "version of Firebse Tools with `npm i -g firebase-tools@latest`");
+            }
+            source.functionsSourceV2 = await (0, prepareFunctionsUpload_1.prepareFunctionsUpload)(sourceDir, config);
+        }
+        if (backend.someEndpoint(wantBackend, (e) => e.platform === "gcfv1")) {
+            source.functionsSourceV1 = await (0, prepareFunctionsUpload_1.prepareFunctionsUpload)(sourceDir, config, runtimeConfig);
+        }
+        context.sources[codebase] = source;
+    }
+    payload.functions = {};
+    const haveBackends = (0, functionsDeployHelper_1.groupEndpointsByCodebase)(wantBackends, backend.allEndpoints(await backend.existingBackend(context)));
+    for (const [codebase, wantBackend] of Object.entries(wantBackends)) {
+        const haveBackend = haveBackends[codebase] || backend.empty();
+        payload.functions[codebase] = { wantBackend, haveBackend };
+    }
+    for (const [codebase, { wantBackend, haveBackend }] of Object.entries(payload.functions)) {
+        inferDetailsFromExisting(wantBackend, haveBackend, codebaseUsesEnvs.includes(codebase));
+        await (0, triggerRegionHelper_1.ensureTriggerRegions)(wantBackend);
+        resolveCpu(wantBackend);
+        validate.endpointsAreValid(wantBackend);
+        inferBlockingDetails(wantBackend);
     }
-    const sourceDir = options.config.path(sourceDirName);
-    const delegateContext = {
-        projectId,
-        sourceDir,
-        projectDir: options.config.projectDir,
-        runtime: context.config.runtime || "",
-    };
-    const runtimeDelegate = await runtimes.getRuntimeDelegate(delegateContext);
-    logger_1.logger.debug(`Validating ${runtimeDelegate.name} source`);
-    await runtimeDelegate.validate();
-    logger_1.logger.debug(`Building ${runtimeDelegate.name} source`);
-    await runtimeDelegate.build();
-    const firebaseEnvs = functionsEnv.loadFirebaseEnvs(firebaseConfig, projectId);
-    const userEnvOpt = {
-        functionsSource: sourceDir,
-        projectId: projectId,
-        projectAlias: options.projectAlias,
-    };
-    const userEnvs = functionsEnv.loadUserEnvs(userEnvOpt);
-    const usedDotenv = hasDotenv(userEnvOpt);
     const tag = hasUserConfig(runtimeConfig)
-        ? usedDotenv
+        ? codebaseUsesEnvs.length > 0
             ? "mixed"
             : "runtime_config"
-        : usedDotenv
+        : codebaseUsesEnvs.length > 0
             ? "dotenv"
             : "none";
     void (0, track_1.track)("functions_codebase_deploy_env_method", tag);
-    logger_1.logger.debug(`Analyzing ${runtimeDelegate.name} backend spec`);
-    const wantBackend = await runtimeDelegate.discoverSpec(runtimeConfig, firebaseEnvs);
-    wantBackend.environmentVariables = Object.assign(Object.assign({}, userEnvs), firebaseEnvs);
-    for (const endpoint of backend.allEndpoints(wantBackend)) {
-        endpoint.environmentVariables = wantBackend.environmentVariables;
-        endpoint.codebase = context.config.codebase;
-    }
-    const source = {};
-    if (backend.someEndpoint(wantBackend, () => true)) {
-        (0, utils_1.logLabeledBullet)("functions", `preparing ${clc.bold(sourceDirName)} directory for uploading...`);
-    }
-    if (backend.someEndpoint(wantBackend, (e) => e.platform === "gcfv2")) {
-        if (!previews_1.previews.functionsv2) {
-            throw new error_1.FirebaseError("This version of firebase-tools does not support Google Cloud " +
-                "Functions gen 2\n" +
-                "If Cloud Functions for Firebase gen 2 is still in alpha, sign up " +
-                "for the alpha program at " +
-                "https://services.google.com/fb/forms/firebasealphaprogram/\n" +
-                "If Cloud Functions for Firebase gen 2 is in beta, get the latest " +
-                "version of Firebse Tools with `npm i -g firebase-tools@latest`");
-        }
-        source.functionsSourceV2 = await (0, prepareFunctionsUpload_1.prepareFunctionsUpload)(sourceDir, context.config);
-    }
-    if (backend.someEndpoint(wantBackend, (e) => e.platform === "gcfv1")) {
-        source.functionsSourceV1 = await (0, prepareFunctionsUpload_1.prepareFunctionsUpload)(sourceDir, context.config, runtimeConfig);
-    }
-    context.source = source;
-    const wantEndpointNames = backend.allEndpoints(wantBackend).map((e) => backend.functionName(e));
-    const haveBackend = backend.matchingBackend(await backend.existingBackend(context), (endpoint) => {
-        var _a;
-        if (endpoint.codebase === ((_a = context.config) === null || _a === void 0 ? void 0 : _a.codebase)) {
-            return true;
-        }
-        return wantEndpointNames.includes(backend.functionName(endpoint));
-    });
-    inferDetailsFromExisting(wantBackend, haveBackend, usedDotenv);
-    await (0, triggerRegionHelper_1.ensureTriggerRegions)(wantBackend);
-    validate.endpointsAreValid(wantBackend);
-    inferBlockingDetails(wantBackend);
-    payload.functions = { wantBackend: wantBackend, haveBackend: haveBackend };
+    const codebaseCnt = Object.keys(payload.functions).length;
+    void (0, track_1.track)("functions_codebase_deploy_count", codebaseCnt >= 5 ? "5+" : codebaseCnt.toString());
+    const wantBackend = backend.merge(...Object.values(wantBackends));
+    const haveBackend = backend.merge(...Object.values(haveBackends));
     await Promise.all(Object.values(wantBackend.requiredAPIs).map(({ api }) => {
         return ensureApiEnabled.ensure(projectId, api, "functions", false);
     }));
@@ -138,6 +164,11 @@ async function prepare(context, options, payload) {
             return ensureApiEnabled.ensure(context.projectId, api, "functions");
         });
         await Promise.all(enablements);
+        const services = ["pubsub.googleapis.com", "eventarc.googleapis.com"];
+        const generateServiceAccounts = services.map((service) => {
+            return (0, serviceusage_1.generateServiceIdentity)(projectNumber, service, "functions");
+        });
+        await Promise.all(generateServiceAccounts);
     }
     const matchingBackend = backend.matchingBackend(wantBackend, (endpoint) => {
         return (0, functionsDeployHelper_1.endpointMatchesAnyFilter)(endpoint, context.filters);
@@ -145,7 +176,7 @@ async function prepare(context, options, payload) {
     await (0, prompts_1.promptForFailurePolicies)(options, matchingBackend, haveBackend);
     await (0, prompts_1.promptForMinInstances)(options, matchingBackend, haveBackend);
     await backend.checkAvailability(context, matchingBackend);
-    await (0, checkIam_1.ensureServiceAgentRoles)(projectNumber, matchingBackend, haveBackend);
+    await (0, checkIam_1.ensureServiceAgentRoles)(projectId, projectNumber, matchingBackend, haveBackend);
     await validate.secretsAreValid(projectId, matchingBackend);
     await ensure.secretAccess(projectId, matchingBackend, haveBackend);
 }
@@ -163,6 +194,12 @@ function inferDetailsFromExisting(want, have, usedDotenv) {
         if (!wantE.availableMemoryMb && haveE.availableMemoryMb) {
             wantE.availableMemoryMb = haveE.availableMemoryMb;
         }
+        if (!wantE.concurrency && haveE.concurrency) {
+            wantE.concurrency = haveE.concurrency;
+        }
+        if (!wantE.cpu && haveE.cpu) {
+            wantE.cpu = haveE.cpu;
+        }
         wantE.securityLevel = haveE.securityLevel ? haveE.securityLevel : "SECURE_ALWAYS";
         maybeCopyTriggerRegion(wantE, haveE);
     }
@@ -208,3 +245,17 @@ function inferBlockingDetails(want) {
     }
 }
 exports.inferBlockingDetails = inferBlockingDetails;
+function resolveCpu(want) {
+    for (const e of backend.allEndpoints(want)) {
+        if (e.platform === "gcfv1") {
+            continue;
+        }
+        if (e.cpu === "gcf_gen1") {
+            e.cpu = backend.memoryToGen1Cpu(e.availableMemoryMb || backend.DEFAULT_MEMORY);
+        }
+        else if (!e.cpu) {
+            e.cpu = backend.memoryToGen2Cpu(e.availableMemoryMb || backend.DEFAULT_MEMORY);
+        }
+    }
+}
+exports.resolveCpu = resolveCpu;

package/lib/deploy/functions/pricing.js

@@ -145,12 +145,12 @@ function monthlyMinInstanceCost(endpoints) {
                 usage["gcfv1"][tier].cpu + cpu * SECONDS_PER_MONTH * endpoint.minInstances;
         }
         else {
-            const cpu = 1;
             const tier = V2_REGION_TO_TIER[endpoint.region];
             usage["gcfv2"][tier].ram =
                 usage["gcfv2"][tier].ram + ramGb * SECONDS_PER_MONTH * endpoint.minInstances;
             usage["gcfv2"][tier].cpu =
-                usage["gcfv2"][tier].cpu + cpu * SECONDS_PER_MONTH * endpoint.minInstances;
+                usage["gcfv2"][tier].cpu +
+                    endpoint.cpu * SECONDS_PER_MONTH * endpoint.minInstances;
         }
     }
     let v1MemoryBill = usage["gcfv1"][1].ram * exports.V1_RATES.memoryGb[1] + usage["gcfv1"][2].ram * exports.V1_RATES.memoryGb[2];

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

@@ -13,7 +13,7 @@ async function handler(op) {
             ((_b = (_a = err.context) === null || _a === void 0 ? void 0 : _a.response) === null || _b === void 0 ? void 0 : _b.statusCode) ||
             ((_c = err.original) === null || _c === void 0 ? void 0 : _c.code) ||
             ((_f = (_e = (_d = err.original) === null || _d === void 0 ? void 0 : _d.context) === null || _e === void 0 ? void 0 : _e.response) === null || _f === void 0 ? void 0 : _f.statusCode);
-        if (code === 429 || code === 409) {
+        if (code === 429 || code === 409 || code === 503) {
             throw err;
         }
         op.error = err;

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

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.Fabricator = void 0;
+exports.serviceIsResolved = exports.Fabricator = void 0;
 const clc = require("cli-color");
 const error_1 = require("../../../error");
 const sourceTokenScraper_1 = require("./sourceTokenScraper");
@@ -23,6 +23,7 @@ const scheduler = require("../../../gcp/cloudscheduler");
 const utils = require("../../../utils");
 const services = require("../services");
 const v1_1 = require("../../../functions/events/v1");
+const throttler_1 = require("../../../throttler/throttler");
 const gcfV1PollerOptions = {
     apiOrigin: api_1.functionsOrigin,
     apiVersion: gcf.API_VERSION,
@@ -44,8 +45,7 @@ class Fabricator {
     constructor(args) {
         this.executor = args.executor;
         this.functionExecutor = args.functionExecutor;
-        this.sourceUrl = args.sourceUrl;
-        this.storage = args.storage;
+        this.sources = args.sources;
         this.appEngineLocation = args.appEngineLocation;
     }
     async applyPlan(plan) {
@@ -154,12 +154,13 @@ class Fabricator {
         }
     }
     async createV1Function(endpoint, scraper) {
-        var _a;
-        if (!this.sourceUrl) {
+        var _a, _b;
+        const sourceUrl = (_a = this.sources[endpoint.codebase]) === null || _a === void 0 ? void 0 : _a.sourceUrl;
+        if (!sourceUrl) {
             logger_1.logger.debug("Precondition failed. Cannot create a GCF function without sourceUrl");
             throw new Error("Precondition failed");
         }
-        const apiFunction = gcf.functionFromEndpoint(endpoint, this.sourceUrl);
+        const apiFunction = gcf.functionFromEndpoint(endpoint, sourceUrl);
         if (apiFunction.httpsTrigger) {
             apiFunction.httpsTrigger.securityLevel = "SECURE_ALWAYS";
         }
@@ -167,10 +168,10 @@ class Fabricator {
         const resultFunction = await this.functionExecutor
             .run(async () => {
             const op = await gcf.createFunction(apiFunction);
-            return poller.pollOperation(Object.assign(Object.assign({}, gcfV1PollerOptions), { pollerName: `create-${endpoint.region}-${endpoint.id}`, operationResourceName: op.name, onPoll: scraper.poller }));
+            return poller.pollOperation(Object.assign(Object.assign({}, gcfV1PollerOptions), { pollerName: `create-${endpoint.codebase}-${endpoint.region}-${endpoint.id}`, operationResourceName: op.name, onPoll: scraper.poller }));
         })
             .catch(rethrowAs(endpoint, "create"));
-        endpoint.uri = (_a = resultFunction === null || resultFunction === void 0 ? void 0 : resultFunction.httpsTrigger) === null || _a === void 0 ? void 0 : _a.url;
+        endpoint.uri = (_b = resultFunction === null || resultFunction === void 0 ? void 0 : resultFunction.httpsTrigger) === null || _b === void 0 ? void 0 : _b.url;
         if (backend.isHttpsTriggered(endpoint)) {
             const invoker = endpoint.httpsTrigger.invoker || ["public"];
             if (!invoker.includes("private")) {
@@ -208,13 +209,14 @@ class Fabricator {
         }
     }
     async createV2Function(endpoint) {
-        var _a;
-        if (!this.storage) {
+        var _a, _b;
+        const storage = (_a = this.sources[endpoint.codebase]) === null || _a === void 0 ? void 0 : _a.storage;
+        if (!storage) {
             logger_1.logger.debug("Precondition failed. Cannot create a GCFv2 function without storage");
             throw new Error("Precondition failed");
         }
-        const apiFunction = gcfV2.functionFromEndpoint(endpoint, this.storage);
-        const topic = (_a = apiFunction.eventTrigger) === null || _a === void 0 ? void 0 : _a.pubsubTopic;
+        const apiFunction = gcfV2.functionFromEndpoint(endpoint, storage);
+        const topic = (_b = apiFunction.eventTrigger) === null || _b === void 0 ? void 0 : _b.pubsubTopic;
         if (topic) {
             await this.executor
                 .run(async () => {
@@ -235,7 +237,7 @@ class Fabricator {
         const resultFunction = await this.functionExecutor
             .run(async () => {
             const op = await gcfV2.createFunction(apiFunction);
-            return await poller.pollOperation(Object.assign(Object.assign({}, gcfV2PollerOptions), { pollerName: `create-${endpoint.region}-${endpoint.id}`, operationResourceName: op.name }));
+            return await poller.pollOperation(Object.assign(Object.assign({}, gcfV2PollerOptions), { pollerName: `create-${endpoint.codebase}-${endpoint.region}-${endpoint.id}`, operationResourceName: op.name }));
         })
             .catch(rethrowAs(endpoint, "create"));
         endpoint.uri = resultFunction.serviceConfig.uri;
@@ -270,25 +272,34 @@ class Fabricator {
                 .catch(rethrowAs(endpoint, "set invoker"));
         }
         const mem = endpoint.availableMemoryMb || backend.DEFAULT_MEMORY;
-        if (mem >= backend.MIN_MEMORY_FOR_CONCURRENCY && endpoint.concurrency !== 1) {
-            await this.setConcurrency(endpoint, serviceName, endpoint.concurrency || DEFAULT_GCFV2_CONCURRENCY);
+        const hasCustomCPU = endpoint.cpu !== backend.memoryToGen1Cpu(mem);
+        if (!endpoint.concurrency) {
+            endpoint.concurrency =
+                endpoint.cpu >= backend.MIN_CPU_FOR_CONCURRENCY
+                    ? backend.DEFAULT_CONCURRENCY
+                    : 1;
+        }
+        const hasConcurrency = endpoint.concurrency !== 1;
+        if (hasCustomCPU || hasConcurrency) {
+            await this.setRunTraits(serviceName, endpoint);
         }
     }
     async updateV1Function(endpoint, scraper) {
-        var _a;
-        if (!this.sourceUrl) {
+        var _a, _b;
+        const sourceUrl = (_a = this.sources[endpoint.codebase]) === null || _a === void 0 ? void 0 : _a.sourceUrl;
+        if (!sourceUrl) {
             logger_1.logger.debug("Precondition failed. Cannot update a GCF function without sourceUrl");
             throw new Error("Precondition failed");
         }
-        const apiFunction = gcf.functionFromEndpoint(endpoint, this.sourceUrl);
+        const apiFunction = gcf.functionFromEndpoint(endpoint, sourceUrl);
         apiFunction.sourceToken = await scraper.tokenPromise();
         const resultFunction = await this.functionExecutor
             .run(async () => {
             const op = await gcf.updateFunction(apiFunction);
-            return await poller.pollOperation(Object.assign(Object.assign({}, gcfV1PollerOptions), { pollerName: `update-${endpoint.region}-${endpoint.id}`, operationResourceName: op.name, onPoll: scraper.poller }));
+            return await poller.pollOperation(Object.assign(Object.assign({}, gcfV1PollerOptions), { pollerName: `update-${endpoint.codebase}-${endpoint.region}-${endpoint.id}`, operationResourceName: op.name, onPoll: scraper.poller }));
         })
             .catch(rethrowAs(endpoint, "update"));
-        endpoint.uri = (_a = resultFunction === null || resultFunction === void 0 ? void 0 : resultFunction.httpsTrigger) === null || _a === void 0 ? void 0 : _a.url;
+        endpoint.uri = (_b = resultFunction === null || resultFunction === void 0 ? void 0 : resultFunction.httpsTrigger) === null || _b === void 0 ? void 0 : _b.url;
         let invoker;
         if (backend.isHttpsTriggered(endpoint)) {
             invoker = endpoint.httpsTrigger.invoker;
@@ -307,19 +318,20 @@ class Fabricator {
         }
     }
     async updateV2Function(endpoint) {
-        var _a;
-        if (!this.storage) {
+        var _a, _b;
+        const storage = (_a = this.sources[endpoint.codebase]) === null || _a === void 0 ? void 0 : _a.storage;
+        if (!storage) {
             logger_1.logger.debug("Precondition failed. Cannot update a GCFv2 function without storage");
             throw new Error("Precondition failed");
         }
-        const apiFunction = gcfV2.functionFromEndpoint(endpoint, this.storage);
-        if ((_a = apiFunction.eventTrigger) === null || _a === void 0 ? void 0 : _a.pubsubTopic) {
+        const apiFunction = gcfV2.functionFromEndpoint(endpoint, storage);
+        if ((_b = apiFunction.eventTrigger) === null || _b === void 0 ? void 0 : _b.pubsubTopic) {
             delete apiFunction.eventTrigger.pubsubTopic;
         }
         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 }));
+            return await poller.pollOperation(Object.assign(Object.assign({}, gcfV2PollerOptions), { pollerName: `update-${endpoint.codebase}-${endpoint.region}-${endpoint.id}`, operationResourceName: op.name }));
         })
             .catch(rethrowAs(endpoint, "update"));
         endpoint.uri = resultFunction.serviceConfig.uri;
@@ -340,8 +352,17 @@ class Fabricator {
                 .run(() => run.setInvokerUpdate(endpoint.project, serviceName, invoker))
                 .catch(rethrowAs(endpoint, "set invoker"));
         }
-        if (endpoint.concurrency) {
-            await this.setConcurrency(endpoint, serviceName, endpoint.concurrency);
+        const hasCustomCPU = endpoint.cpu !==
+            backend.memoryToGen1Cpu(endpoint.availableMemoryMb || backend.DEFAULT_MEMORY);
+        const explicitConcurrency = endpoint.concurrency !== undefined;
+        if (hasCustomCPU || explicitConcurrency) {
+            if (endpoint.concurrency === undefined) {
+                endpoint.concurrency =
+                    endpoint.cpu < backend.MIN_CPU_FOR_CONCURRENCY
+                        ? 1
+                        : backend.DEFAULT_CONCURRENCY;
+            }
+            await this.setRunTraits(serviceName, endpoint);
         }
     }
     async deleteV1Function(endpoint) {
@@ -349,7 +370,7 @@ class Fabricator {
         await this.functionExecutor
             .run(async () => {
             const op = await gcf.deleteFunction(fnName);
-            const pollerOptions = Object.assign(Object.assign({}, gcfV1PollerOptions), { pollerName: `delete-${endpoint.region}-${endpoint.id}`, operationResourceName: op.name });
+            const pollerOptions = Object.assign(Object.assign({}, gcfV1PollerOptions), { pollerName: `delete-${endpoint.codebase}-${endpoint.region}-${endpoint.id}`, operationResourceName: op.name });
             await poller.pollOperation(pollerOptions);
         })
             .catch(rethrowAs(endpoint, "delete"));
@@ -359,23 +380,37 @@ class Fabricator {
         await this.functionExecutor
             .run(async () => {
             const op = await gcfV2.deleteFunction(fnName);
-            const pollerOptions = Object.assign(Object.assign({}, gcfV2PollerOptions), { pollerName: `delete-${endpoint.region}-${endpoint.id}`, operationResourceName: op.name });
+            const pollerOptions = Object.assign(Object.assign({}, gcfV2PollerOptions), { pollerName: `delete-${endpoint.codebase}-${endpoint.region}-${endpoint.id}`, operationResourceName: op.name });
             await poller.pollOperation(pollerOptions);
         })
             .catch(rethrowAs(endpoint, "delete"));
     }
-    async setConcurrency(endpoint, serviceName, concurrency) {
+    async setRunTraits(serviceName, endpoint) {
         await this.functionExecutor
             .run(async () => {
-            const service = await run.getService(serviceName);
-            if (service.spec.template.spec.containerConcurrency === concurrency) {
-                logger_1.logger.debug("Skipping setConcurrency on", serviceName, " because it already matches");
+            let service = await run.getService(serviceName);
+            let changed = false;
+            if (service.spec.template.spec.containerConcurrency !== endpoint.concurrency) {
+                service.spec.template.spec.containerConcurrency = endpoint.concurrency;
+                changed = true;
+            }
+            if (+service.spec.template.spec.containers[0].resources.limits.cpu !== endpoint.cpu) {
+                service.spec.template.spec.containers[0].resources.limits.cpu = `${endpoint.cpu}`;
+                changed = true;
+            }
+            if (!changed) {
+                logger_1.logger.debug("Skipping setRunTraits on", serviceName, " because it already matches");
                 return;
             }
             delete service.status;
             delete service.spec.template.metadata.name;
-            service.spec.template.spec.containerConcurrency = concurrency;
-            await run.replaceService(serviceName, service);
+            service = await run.replaceService(serviceName, service);
+            let retry = 0;
+            while (!exports.serviceIsResolved(service)) {
+                await (0, throttler_1.backoff)(retry, 2, 30);
+                retry = retry + 1;
+                service = await run.getService(serviceName);
+            }
         })
             .catch(rethrowAs(endpoint, "set concurrency"));
     }
@@ -471,7 +506,7 @@ class Fabricator {
     logOpStart(op, endpoint) {
         const runtime = (0, runtimes_1.getHumanFriendlyRuntimeName)(endpoint.runtime);
         const label = helper.getFunctionLabel(endpoint);
-        utils.logBullet(`${clc.bold.cyan("functions:")} ${op} ${runtime} function ${clc.bold(label)}...`);
+        utils.logLabeledBullet("functions", `${op} ${runtime} function ${clc.bold(label)}...`);
     }
     logOpSuccess(op, endpoint) {
         const label = helper.getFunctionLabel(endpoint);
@@ -479,3 +514,26 @@ class Fabricator {
     }
 }
 exports.Fabricator = Fabricator;
+function serviceIsResolved(service) {
+    var _a, _b, _c, _d, _e;
+    if (((_a = service.status) === null || _a === void 0 ? void 0 : _a.observedGeneration) !== service.metadata.generation) {
+        logger_1.logger.debug(`Service ${service.metadata.name} is not resolved because` +
+            `observed generation ${(_b = service.status) === null || _b === void 0 ? void 0 : _b.observedGeneration} does not ` +
+            `match spec generation ${service.metadata.generation}`);
+        return false;
+    }
+    const readyCondition = (_d = (_c = service.status) === null || _c === void 0 ? void 0 : _c.conditions) === null || _d === void 0 ? void 0 : _d.find((condition) => {
+        return condition.type === "Ready";
+    });
+    if ((readyCondition === null || readyCondition === void 0 ? void 0 : readyCondition.status) === "Unknown") {
+        logger_1.logger.debug(`Waiting for service ${service.metadata.name} to be ready. ` +
+            `Status is ${JSON.stringify((_e = service.status) === null || _e === void 0 ? void 0 : _e.conditions)}`);
+        return false;
+    }
+    else if ((readyCondition === null || readyCondition === void 0 ? void 0 : readyCondition.status) === "True") {
+        return true;
+    }
+    logger_1.logger.debug(`Service ${service.metadata.name} has unexpected ready status ${JSON.stringify(readyCondition)}. It may have failed rollout.`);
+    throw new error_1.FirebaseError(`Unexpected Status ${readyCondition === null || readyCondition === void 0 ? void 0 : readyCondition.status} for service ${service.metadata.name}`);
+}
+exports.serviceIsResolved = serviceIsResolved;

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

@@ -11,12 +11,9 @@ const fabricator = require("./fabricator");
 const reporter = require("./reporter");
 const executor = require("./executor");
 const prompts = require("../prompts");
-const secrets = require("../../../functions/secrets");
 const functionsConfig_1 = require("../../../functionsConfig");
 const functionsDeployHelper_1 = require("../functionsDeployHelper");
 const error_1 = require("../../../error");
-const projectUtils_1 = require("../../../projectUtils");
-const utils_1 = require("../../../utils");
 async function release(context, options, payload) {
     if (!context.config) {
         return;
@@ -24,8 +21,18 @@ async function release(context, options, payload) {
     if (!payload.functions) {
         return;
     }
-    const { wantBackend, haveBackend } = payload.functions;
-    const plan = planner.createDeploymentPlan(wantBackend, haveBackend, context.filters);
+    if (!context.sources) {
+        return;
+    }
+    let plan = {};
+    for (const [codebase, { wantBackend, haveBackend }] of Object.entries(payload.functions)) {
+        plan = Object.assign(Object.assign({}, plan), planner.createDeploymentPlan({
+            codebase,
+            wantBackend,
+            haveBackend,
+            filters: context.filters,
+        }));
+    }
     const fnsToDelete = Object.values(plan)
         .map((regionalChanges) => regionalChanges.endpointsToDelete)
         .reduce(functional_1.reduceFlat, []);
@@ -44,15 +51,15 @@ async function release(context, options, payload) {
     const fab = new fabricator.Fabricator({
         functionExecutor,
         executor: new executor.QueueExecutor({}),
-        sourceUrl: context.source.sourceUrl,
-        storage: context.source.storage,
+        sources: context.sources,
         appEngineLocation: (0, functionsConfig_1.getAppEngineLocation)(context.firebaseConfig),
     });
     const summary = await fab.applyPlan(plan);
     await reporter.logAndTrackDeployStats(summary);
     reporter.printErrors(summary);
-    printTriggerUrls(payload.functions.wantBackend);
-    const haveEndpoints = backend.allEndpoints(payload.functions.wantBackend);
+    const wantBackend = backend.merge(...Object.values(payload.functions).map((p) => p.wantBackend));
+    printTriggerUrls(wantBackend);
+    const haveEndpoints = backend.allEndpoints(wantBackend);
     const deletedEndpoints = Object.values(plan)
         .map((r) => r.endpointsToDelete)
         .reduce(functional_1.reduceFlat, []);
@@ -66,24 +73,6 @@ async function release(context, options, payload) {
         const opts = allErrors.length === 1 ? { original: allErrors[0] } : { children: allErrors };
         throw new error_1.FirebaseError("There was an error deploying functions", Object.assign(Object.assign({}, opts), { exit: 2 }));
     }
-    else {
-        if (secrets.of(haveEndpoints).length > 0) {
-            const projectId = (0, projectUtils_1.needProjectId)(options);
-            const projectNumber = await (0, projectUtils_1.needProjectNumber)(options);
-            const reloadedBackend = await backend.existingBackend({ projectId });
-            const prunedResult = await secrets.pruneAndDestroySecrets({ projectId, projectNumber }, backend.allEndpoints(reloadedBackend));
-            if (prunedResult.destroyed.length > 0) {
-                (0, utils_1.logLabeledBullet)("functions", `Destroyed unused secret versions: ${prunedResult.destroyed
-                    .map((s) => `${s.secret}@${s.version}`)
-                    .join(", ")}`);
-            }
-            if (prunedResult.erred.length > 0) {
-                (0, utils_1.logLabeledWarning)("functions", `Failed to destroy unused secret versions:\n\t${prunedResult.erred
-                    .map((err) => err.message)
-                    .join("\n\t")}`);
-            }
-        }
-    }
 }
 exports.release = release;
 function printTriggerUrls(results) {