Function download

sources/corepackUtils.ts:143–206

(installTarget: string, url: string, algo: string, binPath: string | null = null)

}

async function download(installTarget: string, url: string, algo: string, binPath: string | null = null): Promise<DownloadSpec> {
  // Creating a temporary folder inside the install folder means that we
  // are sure it'll be in the same drive as the destination, so we can
  // just move it there atomically once we are done

  const tmpFolder = folderUtils.getTemporaryFolder(installTarget);
  debugUtils.log(`Downloading to ${tmpFolder}`);

  const stream = await httpUtils.fetchUrlStream(url);

  const parsedUrl = new URL(url);
  const ext = path.posix.extname(parsedUrl.pathname);

  let outputFile: string | null = null;
  let sendTo: any;

  if (ext === `.tgz`) {
    const {extract: tarX} = await import(`tar/extract`);
    sendTo = tarX({
      strip: 1,
      cwd: tmpFolder,
      filter: binPath ? path => {
        const pos = path.indexOf(`/`);
        return pos !== -1 && path.slice(pos + 1) === binPath;
      } : undefined,
    });
  } else if (ext === `.js`) {
    outputFile = path.join(tmpFolder, path.posix.basename(parsedUrl.pathname));
    sendTo = fs.createWriteStream(outputFile);
  }
  stream.pipe(sendTo);

  let hash = !binPath ? stream.pipe(createHash(algo)) : null;
  await once(sendTo, `finish`);

  if (binPath) {
    const downloadedBin = path.join(tmpFolder, binPath);
    outputFile = path.join(tmpFolder, path.basename(downloadedBin));
    try {
      await renameSafe(downloadedBin, outputFile);
    } catch (err) {
      if (nodeUtils.isNodeError(err) && err.code === `ENOENT`)
        throw new Error(`Cannot locate '${binPath}' in downloaded tarball`, {cause: err});

      // It's alright if another process downloaded the same binary in parallel
      if (nodeUtils.isNodeError(err) && nodeUtils.isExistError(err)) {
        await fs.promises.rm(downloadedBin);
      } else {
        throw err;
      }
    }

    // Calculate the hash of the bin file
    const fileStream = fs.createReadStream(outputFile);
    hash = fileStream.pipe(createHash(algo));
    await once(fileStream, `close`);
  }