Basic create support

This change adds support for `firebase --open-sesame golang`.

After running this command, `firebase init` will support Go 1.13
as a langauge for Cloud Functions.

Limitations:

1. .gitignore is empty
2. Customers cannot mix Node and Go code (WAI)
3. There is little validation being done of customer code
4. The actual deployed function params are hard coded; SDK incoming

Author: inlined

src/config.ts

@@ -68,7 +68,7 @@ export class Config {
     if (
       this.projectDir &&
       !this.get("functions.source") &&
-      fsutils.fileExistsSync(this.path("functions/package.json"))
+      fsutils.dirExistsSync(this.path("functions"))
     ) {
       this.set("functions.source", "functions");
     }

src/deploy/functions/runtimes/golang/index.ts

@@ -0,0 +1,179 @@
+import { promisify } from "util";
+import * as path from "path";
+import * as fs from "fs";
+import * as spawn from "cross-spawn";
+
+import { FirebaseError } from "../../../../error";
+import { Options } from "../../../../options";
+import { logger } from "../../../../logger";
+import * as args from "../../args";
+import * as backend from "../../backend";
+import * as getProjectId from "../../../../getProjectId";
+import * as runtimes from "..";
+
+const VERSION_TO_RUNTIME: Record<string, runtimes.Runtime> = {
+  "1.13": "go113",
+};
+
+export async function tryCreateDelegate(
+  context: args.Context,
+  options: Options
+): Promise<Delegate | undefined> {
+  const sourceDirName = options.config.get("functions.source") as string;
+  const sourceDir = options.config.path(sourceDirName);
+  const goModPath = path.join(sourceDir, "go.mod");
+  const projectId = getProjectId(options);
+
+  let module: Module;
+  try {
+    const modBuffer = await promisify(fs.readFile)(goModPath);
+    module = parseModule(modBuffer.toString("utf8"));
+  } catch (err) {
+    logger.debug("Customer code is not Golang code (or they aren't using modules)");
+    return;
+  }
+
+  let runtime = options.config.get("functions.runtime");
+  if (!runtime) {
+    if (!module.version) {
+      throw new FirebaseError("Could not detect Golang version from go.mod");
+    }
+    if (!VERSION_TO_RUNTIME[module.version]) {
+      throw new FirebaseError(
+        `go.mod specifies Golang version ${
+          module.version
+        } which is unsupported by Google Cloud Functions. Valid values are ${Object.keys(
+          VERSION_TO_RUNTIME
+        ).join(", ")}`
+      );
+    }
+    runtime = VERSION_TO_RUNTIME[module.version];
+  }
+
+  return new Delegate(projectId, sourceDirName, sourceDir, runtime, module);
+}
+
+// A module can be much more complicated than this, but this is all we need so far.
+// for a full reference, see https://golang.org/doc/modules/gomod-ref
+interface Module {
+  module: string;
+  version: string;
+  dependencies: Record<string, string>;
+}
+
+export function parseModule(mod: string): Module {
+  const module: Module = {
+    module: "",
+    version: "",
+    dependencies: {},
+  };
+  const lines = mod.split("\n");
+  let inRequire = false;
+  for (const line of lines) {
+    if (inRequire) {
+      const endRequireMatch = /\)/.exec(line);
+      if (endRequireMatch) {
+        inRequire = false;
+        continue;
+      }
+
+      const requireMatch = /([^ ]+) (.*)/.exec(line);
+      if (requireMatch) {
+        module.dependencies[requireMatch[1]] = requireMatch[2];
+        continue;
+      }
+
+      if (line.trim()) {
+        logger.debug("Don't know how to handle line", line, "inside a mod.go require block");
+      }
+      continue;
+    }
+    const modMatch = /^module (.*)$/.exec(line);
+    if (modMatch) {
+      module.module = modMatch[1];
+      continue;
+    }
+    const versionMatch = /^go (\d+\.\d+)$/.exec(line);
+    if (versionMatch) {
+      module.version = versionMatch[1];
+      continue;
+    }
+
+    const requireMatch = /^require ([^ ]+) (.*)$/.exec(line);
+    if (requireMatch) {
+      module.dependencies[requireMatch[1]] = requireMatch[2];
+      continue;
+    }
+
+    const requireBlockMatch = /^require +\(/.exec(line);
+    if (requireBlockMatch) {
+      inRequire = true;
+      continue;
+    }
+
+    if (line.trim()) {
+      logger.debug("Don't know how to handle line", line, "in mod.go");
+    }
+  }
+
+  return module;
+}
+
+export class Delegate {
+  public readonly name = "golang";
+
+  constructor(
+    private readonly projectId: string,
+    private readonly sourceDirName: string,
+    private readonly sourceDir: string,
+    public readonly runtime: runtimes.Runtime,
+    private readonly module: Module
+  ) {}
+  validate(): Promise<void> {
+    // throw new FirebaseError("Cannot yet analyze Go source code");
+    return Promise.resolve();
+  }
+
+  build(): Promise<void> {
+    const res = spawn.sync("go", ["build"], {
+      cwd: this.sourceDir,
+      stdio: "inherit",
+    });
+    if (res.error) {
+      logger.debug("Got error running go build", res);
+      throw new FirebaseError("Failed to build functions source", { children: [res.error] });
+    }
+
+    return Promise.resolve();
+  }
+
+  watch(): Promise<() => Promise<void>> {
+    return Promise.resolve(() => Promise.resolve());
+  }
+
+  discoverSpec(
+    configValues: backend.RuntimeConfigValues,
+    envs: backend.EnvironmentVariables
+  ): Promise<backend.Backend> {
+    const stubbed: backend.Backend = {
+      requiredAPIs: {},
+      topics: [],
+      schedules: [],
+      cloudFunctions: [
+        {
+          apiVersion: 1,
+          id: "HelloWorld",
+          region: "us-central1",
+          project: this.projectId,
+          entryPoint: "HelloWorld",
+          runtime: this.runtime,
+          trigger: {
+            allowInsecure: false,
+          },
+        },
+      ],
+      environmentVariables: envs,
+    };
+    return Promise.resolve(stubbed);
+  }
+}

src/deploy/functions/runtimes/index.ts

@@ -1,12 +1,13 @@
 import { Options } from "../../../options";
 import * as backend from "../backend";
 import * as args from "../args";
+import * as golang from "./golang";
 import * as node from "./node";
 import * as validate from "../validate";
 import { FirebaseError } from "../../../error";
 
 /** Supported runtimes for new Cloud Functions. */
-const RUNTIMES: string[] = ["nodejs10", "nodejs12", "nodejs14"];
+const RUNTIMES: string[] = ["nodejs10", "nodejs12", "nodejs14", "go113"];
 export type Runtime = typeof RUNTIMES[number];
 
 /** Runtimes that can be found in existing backends but not used for new functions. */
@@ -29,6 +30,7 @@ const MESSAGE_FRIENDLY_RUNTIMES: Record<Runtime | DeprecatedRuntime, string> = {
   nodejs10: "Node.js 10",
   nodejs12: "Node.js 12",
   nodejs14: "Node.js 14",
+  go113: "Go 1.13",
 };
 
 /**
@@ -94,7 +96,7 @@ export interface RuntimeDelegate {
 }
 
 type Factory = (context: args.Context, options: Options) => Promise<RuntimeDelegate | undefined>;
-const factories: Factory[] = [node.tryCreateDelegate];
+const factories: Factory[] = [node.tryCreateDelegate, golang.tryCreateDelegate];
 
 export async function getRuntimeDelegate(
   context: args.Context,
@@ -108,6 +110,13 @@ export async function getRuntimeDelegate(
   }
   validate.functionsDirectoryExists(options, sourceDirName);
 
+  // There isn't currently an easy way to map from runtime name to a delegate, but we can at least guarantee
+  // that any explicit runtime from firebase.json is valid
+  const runtime = options.config.get("functions.runtime");
+  if (runtime && !isValidRuntime(runtime)) {
+    throw new FirebaseError("Cannot deploy function with runtime " + runtime);
+  }
+
   for (const factory of factories) {
     const delegate = await factory(context, options);
     if (delegate) {

src/init/features/functions/golang.ts

@@ -0,0 +1,72 @@
+import * as fs from "fs";
+import * as path from "path";
+import * as spawn from "cross-spawn";
+
+import { FirebaseError } from "../../../error";
+import { Config } from "../../../config";
+import { promptOnce } from "../../../prompt";
+import * as utils from "../../../utils";
+import { logger } from "../../../logger";
+import { options } from "../../../commands/auth-export";
+
+const clc = require("cli-color");
+
+const ADMIN_SDK = "firebase.google.com/go/v4";
+const RUNTIME_VERSION = "1.13";
+
+const TEMPLATE_ROOT = path.resolve(__dirname, "../../../../templates/init/functions/golang");
+const MAIN_TEMPLATE = fs.readFileSync(path.join(TEMPLATE_ROOT, "functions.go"), "utf8");
+const GITIGNORE_TEMPLATE = fs.readFileSync(path.join(TEMPLATE_ROOT, "_gitignore"), "utf8");
+
+async function init(setup: unknown, config: Config) {
+  await writeModFile(config);
+  await config.askWriteProjectFile("functions/functions.go", MAIN_TEMPLATE);
+  await config.askWriteProjectFile("functions/.gitignore", GITIGNORE_TEMPLATE);
+}
+
+// writeModFile is meant to look like askWriteProjectFile but it generates the contents
+// dynamically using the go tool
+async function writeModFile(config: Config) {
+  const modPath = config.path("functions/go.mod");
+  if (fs.existsSync(modPath)) {
+    const shoudlWriteModFile = await promptOnce({
+      type: "confirm",
+      message: "File " + clc.underline("functions/go.mod") + " already exists. Overwrite?",
+      default: false,
+    });
+    if (!shoudlWriteModFile) {
+      return;
+    }
+
+    // Go will refuse to overwrite an existing mod file.
+    fs.unlinkSync(modPath);
+  }
+
+  // Nit(inlined) can we look at functions code and see if there's a domain mapping?
+  const modName = await promptOnce({
+    type: "input",
+    message: "What would you like to name your module?",
+    default: "acme.com/functions",
+  });
+  // Manually create a go mod file because (A) it's easier this way and (B) it seems to be the only
+  // way to set the min Go version to anything but what the user has installed.
+  config.writeProjectFile(
+    "functions/go.mod",
+    "module " + modName + "\n\ngo " + RUNTIME_VERSION + "\n"
+  );
+
+  // Should this come later as "would you like to install dependencies" to mirror Node?
+  // It's less clearly distinct from node where you can edit the package.json file w/o installing.
+  // Here we're actually locking in a version in go.mod _and_ installing it in one step.
+  const result = spawn.sync("go", ["get", ADMIN_SDK], {
+    cwd: config.path("functions"),
+    stdio: "inherit",
+  });
+  if (result.error) {
+    logger.debug("Full output from go get command:", JSON.stringify(result, null, 2));
+    throw new FirebaseError("Error installing dependencies", { children: [result.error] });
+  }
+  utils.logSuccess("Wrote " + clc.bold("functions/go.mod"));
+}
+
+module.exports = init;