You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
209 lines
9.9 KiB
209 lines
9.9 KiB
"use strict";
|
|
Object.defineProperty(exports, "__esModule", { value: true });
|
|
exports.secretsAreValid = exports.functionIdsAreValid = exports.functionsDirectoryExists = exports.endpointsAreUnique = exports.cpuConfigIsValid = exports.endpointsAreValid = void 0;
|
|
const path = require("path");
|
|
const clc = require("colorette");
|
|
const error_1 = require("../../error");
|
|
const secretManager_1 = require("../../gcp/secretManager");
|
|
const logger_1 = require("../../logger");
|
|
const fsutils = require("../../fsutils");
|
|
const backend = require("./backend");
|
|
const utils = require("../../utils");
|
|
const secrets = require("../../functions/secrets");
|
|
const services_1 = require("./services");
|
|
function matchingIds(endpoints, filter) {
|
|
return endpoints
|
|
.filter(filter)
|
|
.map((endpoint) => endpoint.id)
|
|
.join(",");
|
|
}
|
|
const mem = (endpoint) => endpoint.availableMemoryMb || backend.DEFAULT_MEMORY;
|
|
const cpu = (endpoint) => {
|
|
var _a;
|
|
return endpoint.cpu === "gcf_gen1"
|
|
? backend.memoryToGen1Cpu(mem(endpoint))
|
|
: (_a = endpoint.cpu) !== null && _a !== void 0 ? _a : backend.memoryToGen2Cpu(mem(endpoint));
|
|
};
|
|
function endpointsAreValid(wantBackend) {
|
|
const endpoints = backend.allEndpoints(wantBackend);
|
|
functionIdsAreValid(endpoints);
|
|
for (const ep of endpoints) {
|
|
(0, services_1.serviceForEndpoint)(ep).validateTrigger(ep, wantBackend);
|
|
}
|
|
const gcfV1WithConcurrency = matchingIds(endpoints, (endpoint) => (endpoint.concurrency || 1) !== 1 && endpoint.platform === "gcfv1");
|
|
if (gcfV1WithConcurrency.length) {
|
|
const msg = `Cannot set concurrency on the functions ${gcfV1WithConcurrency} because they are GCF gen 1`;
|
|
throw new error_1.FirebaseError(msg);
|
|
}
|
|
const tooSmallForConcurrency = matchingIds(endpoints, (endpoint) => {
|
|
if ((endpoint.concurrency || 1) === 1) {
|
|
return false;
|
|
}
|
|
return cpu(endpoint) < backend.MIN_CPU_FOR_CONCURRENCY;
|
|
});
|
|
if (tooSmallForConcurrency.length) {
|
|
const msg = "The following functions are configured to allow concurrent " +
|
|
"execution and less than one full CPU. This is not supported: " +
|
|
tooSmallForConcurrency;
|
|
throw new error_1.FirebaseError(msg);
|
|
}
|
|
cpuConfigIsValid(endpoints);
|
|
}
|
|
exports.endpointsAreValid = endpointsAreValid;
|
|
function cpuConfigIsValid(endpoints) {
|
|
const gcfV1WithCPU = matchingIds(endpoints, (endpoint) => endpoint.platform === "gcfv1" && typeof endpoint["cpu"] !== "undefined");
|
|
if (gcfV1WithCPU.length) {
|
|
const msg = `Cannot set CPU on the functions ${gcfV1WithCPU} because they are GCF gen 1`;
|
|
throw new error_1.FirebaseError(msg);
|
|
}
|
|
const invalidCPU = matchingIds(endpoints, (endpoint) => {
|
|
const c = cpu(endpoint);
|
|
if (c < 0.08) {
|
|
return true;
|
|
}
|
|
if (c < 1) {
|
|
return false;
|
|
}
|
|
return ![1, 2, 4, 6, 8].includes(c);
|
|
});
|
|
if (invalidCPU.length) {
|
|
const msg = `The following functions have invalid CPU settings ${invalidCPU}. Valid CPU options are (0.08, 1], 2, 4, 6, 8, or "gcf_gen1"`;
|
|
throw new error_1.FirebaseError(msg);
|
|
}
|
|
const smallCPURegions = ["australia-southeast2", "asia-northeast3", "asia-south2"];
|
|
const tooBigCPUForRegion = matchingIds(endpoints, (endpoint) => smallCPURegions.includes(endpoint.region) && cpu(endpoint) > 4);
|
|
if (tooBigCPUForRegion) {
|
|
const msg = `The functions ${tooBigCPUForRegion} have > 4 CPU in a region that supports a maximum 4 CPU`;
|
|
throw new error_1.FirebaseError(msg);
|
|
}
|
|
const tooSmallCPUSmall = matchingIds(endpoints, (endpoint) => mem(endpoint) > 512 && cpu(endpoint) < 0.5);
|
|
if (tooSmallCPUSmall) {
|
|
const msg = `The functions ${tooSmallCPUSmall} have too little CPU for their memory allocation. A minimum of 0.5 CPU is needed to set a memory limit greater than 512MiB`;
|
|
throw new error_1.FirebaseError(msg);
|
|
}
|
|
const tooSmallCPUBig = matchingIds(endpoints, (endpoint) => mem(endpoint) > 1024 && cpu(endpoint) < 1);
|
|
if (tooSmallCPUBig) {
|
|
const msg = `The functions ${tooSmallCPUSmall} have too little CPU for their memory allocation. A minimum of 1 CPU is needed to set a memory limit greater than 1GiB`;
|
|
throw new error_1.FirebaseError(msg);
|
|
}
|
|
const tooSmallMemory4CPU = matchingIds(endpoints, (endpoint) => cpu(endpoint) === 4 && mem(endpoint) < 2 << 10);
|
|
if (tooSmallMemory4CPU) {
|
|
const msg = `The functions ${tooSmallMemory4CPU} have too little memory for their CPU. Functions with 4 CPU require at least 2GiB`;
|
|
throw new error_1.FirebaseError(msg);
|
|
}
|
|
const tooSmallMemory6CPU = matchingIds(endpoints, (endpoint) => cpu(endpoint) === 6 && mem(endpoint) < 3 << 10);
|
|
if (tooSmallMemory6CPU) {
|
|
const msg = `The functions ${tooSmallMemory6CPU} have too little memory for their CPU. Functions with 6 CPU require at least 3GiB`;
|
|
throw new error_1.FirebaseError(msg);
|
|
}
|
|
const tooSmallMemory8CPU = matchingIds(endpoints, (endpoint) => cpu(endpoint) === 8 && mem(endpoint) < 4 << 10);
|
|
if (tooSmallMemory8CPU) {
|
|
const msg = `The functions ${tooSmallMemory8CPU} have too little memory for their CPU. Functions with 8 CPU require at least 4GiB`;
|
|
throw new error_1.FirebaseError(msg);
|
|
}
|
|
}
|
|
exports.cpuConfigIsValid = cpuConfigIsValid;
|
|
function endpointsAreUnique(backends) {
|
|
const endpointToCodebases = {};
|
|
for (const [codebase, b] of Object.entries(backends)) {
|
|
for (const endpoint of backend.allEndpoints(b)) {
|
|
const key = backend.functionName(endpoint);
|
|
const cs = endpointToCodebases[key] || new Set();
|
|
cs.add(codebase);
|
|
endpointToCodebases[key] = cs;
|
|
}
|
|
}
|
|
const conflicts = {};
|
|
for (const [fn, codebases] of Object.entries(endpointToCodebases)) {
|
|
if (codebases.size > 1) {
|
|
conflicts[fn] = Array.from(codebases);
|
|
}
|
|
}
|
|
if (Object.keys(conflicts).length === 0) {
|
|
return;
|
|
}
|
|
const msgs = Object.entries(conflicts).map(([fn, codebases]) => `${fn}: ${codebases.join(",")}`);
|
|
throw new error_1.FirebaseError("More than one codebase claims following functions:\n\t" + `${msgs.join("\n\t")}`);
|
|
}
|
|
exports.endpointsAreUnique = endpointsAreUnique;
|
|
function functionsDirectoryExists(sourceDir, projectDir) {
|
|
if (!fsutils.dirExistsSync(sourceDir)) {
|
|
const sourceDirName = path.relative(projectDir, sourceDir);
|
|
const msg = `could not deploy functions because the ${clc.bold('"' + sourceDirName + '"')} ` +
|
|
`directory was not found. Please create it or specify a different source directory in firebase.json`;
|
|
throw new error_1.FirebaseError(msg);
|
|
}
|
|
}
|
|
exports.functionsDirectoryExists = functionsDirectoryExists;
|
|
function functionIdsAreValid(functions) {
|
|
const v1FunctionName = /^[a-zA-Z][a-zA-Z0-9_-]{0,62}$/;
|
|
const invalidV1Ids = functions.filter((fn) => {
|
|
return fn.platform === "gcfv1" && !v1FunctionName.test(fn.id);
|
|
});
|
|
if (invalidV1Ids.length !== 0) {
|
|
const msg = `${invalidV1Ids.map((f) => f.id).join(", ")} function name(s) can only contain letters, ` +
|
|
`numbers, hyphens, and not exceed 62 characters in length`;
|
|
throw new error_1.FirebaseError(msg);
|
|
}
|
|
const v2FunctionName = /^[a-z][a-z0-9-]{0,62}$/;
|
|
const invalidV2Ids = functions.filter((fn) => {
|
|
return fn.platform === "gcfv2" && !v2FunctionName.test(fn.id);
|
|
});
|
|
if (invalidV2Ids.length !== 0) {
|
|
const msg = `${invalidV2Ids.map((f) => f.id).join(", ")} v2 function name(s) can only contain lower ` +
|
|
`case letters, numbers, hyphens, and not exceed 62 characters in length`;
|
|
throw new error_1.FirebaseError(msg);
|
|
}
|
|
}
|
|
exports.functionIdsAreValid = functionIdsAreValid;
|
|
async function secretsAreValid(projectId, wantBackend) {
|
|
const endpoints = backend
|
|
.allEndpoints(wantBackend)
|
|
.filter((e) => e.secretEnvironmentVariables && e.secretEnvironmentVariables.length > 0);
|
|
validatePlatformTargets(endpoints);
|
|
await validateSecretVersions(projectId, endpoints);
|
|
}
|
|
exports.secretsAreValid = secretsAreValid;
|
|
const secretsSupportedPlatforms = ["gcfv1", "gcfv2"];
|
|
function validatePlatformTargets(endpoints) {
|
|
const unsupported = endpoints.filter((e) => !secretsSupportedPlatforms.includes(e.platform));
|
|
if (unsupported.length > 0) {
|
|
const errs = unsupported.map((e) => `${e.id}[platform=${e.platform}]`);
|
|
throw new error_1.FirebaseError(`Tried to set secret environment variables on ${errs.join(", ")}. ` +
|
|
`Only ${secretsSupportedPlatforms.join(", ")} support secret environments.`);
|
|
}
|
|
}
|
|
async function validateSecretVersions(projectId, endpoints) {
|
|
const toResolve = new Set();
|
|
for (const s of secrets.of(endpoints)) {
|
|
toResolve.add(s.secret);
|
|
}
|
|
const results = await utils.allSettled(Array.from(toResolve).map(async (secret) => {
|
|
const sv = await (0, secretManager_1.getSecretVersion)(projectId, secret, "latest");
|
|
logger_1.logger.debug(`Resolved secret version of ${clc.bold(secret)} to ${clc.bold(sv.versionId)}.`);
|
|
return sv;
|
|
}));
|
|
const secretVersions = {};
|
|
const errs = [];
|
|
for (const result of results) {
|
|
if (result.status === "fulfilled") {
|
|
const sv = result.value;
|
|
if (sv.state !== "ENABLED") {
|
|
errs.push(new error_1.FirebaseError(`Expected secret ${sv.secret.name}@${sv.versionId} to be in state ENABLED not ${sv.state}.`));
|
|
}
|
|
secretVersions[sv.secret.name] = sv;
|
|
}
|
|
else {
|
|
errs.push(new error_1.FirebaseError(result.reason.message));
|
|
}
|
|
}
|
|
if (errs.length) {
|
|
throw new error_1.FirebaseError("Failed to validate secret versions", { children: errs });
|
|
}
|
|
for (const s of secrets.of(endpoints)) {
|
|
s.version = secretVersions[s.secret].versionId;
|
|
if (!s.version) {
|
|
throw new error_1.FirebaseError("Secret version is unexpectedly undefined. This should never happen.");
|
|
}
|
|
}
|
|
}
|