setup-cpp
Version:
Install all the tools required for building and testing C++/C projects.
103 lines • 12.1 kB
JavaScript
import { tmpdir } from "os";
import { join } from "path";
import { execRoot, execRootSync } from "admina";
import { warning } from "ci-log";
import { DownloaderHelper } from "node-downloader-helper";
import { pathExists } from "path-exists";
import { installAptPack } from "./install.js";
/**
* Add an apt key
* @param options The options for adding the key
* @returns The file name of the key that was added or `undefined` if it failed
*
* @example
* ```ts
* await addAptKey({ key: "3B4FE6ACC0B21F32" fileName: "bazel-archive-keyring.gpg"})
* ```
*
* @example
* ```ts
* await addAptKey({ keyUrl: "https://bazel.build/bazel-release.pub.gpg", fileName: "bazel-archive-keyring.gpg"})
* ```
*/
export function addAptKey(options) {
if ("keyUrl" in options) {
return addAptKeyViaURL(options);
}
else {
return addAptKeyViaServer(options);
}
}
export const defaultKeyStorePath = "/etc/apt/trusted.gpg.d";
export const defaultKeyServer = "keyserver.ubuntu.com";
/**
* Add an apt key via a keyserver
* @returns The file name of the key that was added or `undefined` if it failed
*/
export async function addAptKeyViaServer({ key, keyServer = defaultKeyServer, fileName, keyStorePath = defaultKeyServer }) {
try {
assertGpgFileName(fileName);
const filePath = join(keyStorePath, fileName);
if (!(await pathExists(filePath))) {
initGpg();
await execRoot("gpg", [
"--no-default-keyring",
"--keyring",
`gnupg-ring:${filePath}`,
"--keyserver",
keyServer,
"--recv-keys",
key,
]);
await execRoot("chmod", ["644", filePath]);
}
return filePath;
}
catch (err) {
warning(`Failed to add apt key via server ${keyServer}: ${err}`);
return undefined;
}
}
/**
* Add an apt key via a download
* @param options The options for adding the key
* @returns The file name of the key that was added
*/
export async function addAptKeyViaURL({ keyUrl, fileName, keyStorePath = defaultKeyStorePath }) {
try {
assertGpgFileName(fileName);
const filePath = join(keyStorePath, fileName);
if (!(await pathExists(filePath))) {
initGpg();
await installAptPack([{ name: "ca-certificates" }]);
const dlPath = join(tmpdir(), fileName);
const dl = new DownloaderHelper(keyUrl, tmpdir(), { fileName });
dl.on("error", (err) => {
throw new Error(`Failed to download ${keyUrl}: ${err}`);
});
await dl.start();
execRootSync("gpg", [
"--no-default-keyring",
"--keyring",
`gnupg-ring:${filePath}`,
"--import",
dlPath,
]);
execRootSync("chmod", ["644", filePath]);
}
return filePath;
}
catch (err) {
warning(`Failed to add apt key via download ${keyUrl}: ${err}`);
return undefined;
}
}
function initGpg() {
execRootSync("gpg", ["-k"]);
}
function assertGpgFileName(fileName) {
if (!fileName.endsWith(".gpg")) {
throw new Error(`Key file name must end with .gpg: ${fileName}`);
}
}
//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"apt-key.js","sourceRoot":"","sources":["../src/apt-key.ts"],"names":[],"mappings":"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","sourcesContent":["import { tmpdir } from \"os\"\nimport { join } from \"path\"\nimport { execRoot, execRootSync } from \"admina\"\nimport { warning } from \"ci-log\"\nimport { DownloaderHelper } from \"node-downloader-helper\"\nimport { pathExists } from \"path-exists\"\nimport { installAptPack } from \"./install.js\"\n\nexport type AddAptKeyOptions = KeyServerOptions | KeyUrl\n\n/**\n * Add an apt key\n * @param options The options for adding the key\n * @returns The file name of the key that was added or `undefined` if it failed\n *\n * @example\n * ```ts\n * await addAptKey({ key: \"3B4FE6ACC0B21F32\" fileName: \"bazel-archive-keyring.gpg\"})\n * ```\n *\n * @example\n * ```ts\n * await addAptKey({ keyUrl: \"https://bazel.build/bazel-release.pub.gpg\", fileName: \"bazel-archive-keyring.gpg\"})\n * ```\n */\nexport function addAptKey(options: AddAptKeyOptions) {\n  if (\"keyUrl\" in options) {\n    return addAptKeyViaURL(options)\n  } else {\n    return addAptKeyViaServer(options)\n  }\n}\n\ntype GpgKeyOptions = {\n  /**\n   * The file name for the key (should end in `.gpg`)\n   */\n  fileName: string\n  /**\n   * The key store path (Defaults to `/etc/apt/trusted.gpg.d`)\n   */\n  keyStorePath?: string\n}\n\nexport const defaultKeyStorePath = \"/etc/apt/trusted.gpg.d\"\n\nexport type KeyServerOptions = {\n  /**\n   * The key to add\n   *\n   * @example\n   * ```ts\n   * \"3B4FE6ACC0B21F32\"\n   * ```\n   */\n  key: string\n  /**\n   * The keyserver to use (Defaults to `keyserver.ubuntu.com`)\n   */\n  keyServer?: string\n} & GpgKeyOptions\n\nexport const defaultKeyServer = \"keyserver.ubuntu.com\"\n\n/**\n * Add an apt key via a keyserver\n * @returns The file name of the key that was added or `undefined` if it failed\n */\nexport async function addAptKeyViaServer(\n  { key, keyServer = defaultKeyServer, fileName, keyStorePath = defaultKeyServer }: KeyServerOptions,\n) {\n  try {\n    assertGpgFileName(fileName)\n    const filePath = join(keyStorePath, fileName)\n    if (!(await pathExists(filePath))) {\n      initGpg()\n\n      await execRoot(\"gpg\", [\n        \"--no-default-keyring\",\n        \"--keyring\",\n        `gnupg-ring:${filePath}`,\n        \"--keyserver\",\n        keyServer,\n        \"--recv-keys\",\n        key,\n      ])\n      await execRoot(\"chmod\", [\"644\", filePath])\n    }\n    return filePath\n  } catch (err) {\n    warning(`Failed to add apt key via server ${keyServer}: ${err}`)\n    return undefined\n  }\n}\n\nexport type KeyUrl = {\n  /**\n   * The URL to download the key from\n   */\n  keyUrl: string\n} & GpgKeyOptions\n\n/**\n * Add an apt key via a download\n * @param options The options for adding the key\n * @returns The file name of the key that was added\n */\nexport async function addAptKeyViaURL({ keyUrl, fileName, keyStorePath = defaultKeyStorePath }: KeyUrl) {\n  try {\n    assertGpgFileName(fileName)\n    const filePath = join(keyStorePath, fileName)\n    if (!(await pathExists(filePath))) {\n      initGpg()\n\n      await installAptPack([{ name: \"ca-certificates\" }])\n\n      const dlPath = join(tmpdir(), fileName)\n      const dl = new DownloaderHelper(keyUrl, tmpdir(), { fileName })\n      dl.on(\"error\", (err) => {\n        throw new Error(`Failed to download ${keyUrl}: ${err}`)\n      })\n      await dl.start()\n\n      execRootSync(\"gpg\", [\n        \"--no-default-keyring\",\n        \"--keyring\",\n        `gnupg-ring:${filePath}`,\n        \"--import\",\n        dlPath,\n      ])\n      execRootSync(\"chmod\", [\"644\", filePath])\n    }\n    return filePath\n  } catch (err) {\n    warning(`Failed to add apt key via download ${keyUrl}: ${err}`)\n    return undefined\n  }\n}\n\nfunction initGpg() {\n  execRootSync(\"gpg\", [\"-k\"])\n}\n\nfunction assertGpgFileName(fileName: string) {\n  if (!fileName.endsWith(\".gpg\")) {\n    throw new Error(`Key file name must end with .gpg: ${fileName}`)\n  }\n}\n"]}