Move the extracted JDK into the tool-cache and speed up extraction (#1206)

Two wall-clock optimizations on the JDK install path.

`tc.cacheDir` recursively copies the extracted tree into RUNNER_TOOL_CACHE,
so a 200-600MB JDK is written to disk twice. The extraction directory and
the tool-cache normally share a filesystem, so `cacheJdkDir` renames it
instead and writes the `.complete` marker itself, mirroring the destination
layout `tc.cacheDir` produces. It falls back to the copy when the tool-cache
location is unknown, when the source is not a real directory (a symlinked
source would otherwise leave a dangling entry once RUNNER_TEMP is cleaned),
or when the rename fails - a cross-device tool-cache, or anti-virus holding
a handle on Windows. The rename is atomic, so the source is still intact
for the fallback.

Extraction now uses `pigz` for tarballs when the runner provides it, and
Windows zips go through the bundled `tar.exe` rather than `tc.extractZip`,
which shells out to PowerShell's much slower `Expand-Archive`. Both fall
back to the stock extraction and clean up the abandoned directory first.

Co-authored-by: Copilot App <223556219+Copilot@users.noreply.github.com>
Copilot-Session: b76d8cb0-f629-46e1-bf9a-ffde06948644

src/util.ts

@@ -5,7 +5,10 @@ import * as semver from 'semver';
 import * as core from '@actions/core';
 
 import * as tc from '@actions/tool-cache';
+import * as exec from '@actions/exec';
+import * as io from '@actions/io';
 import * as httpm from '@actions/http-client';
+import {randomUUID} from 'crypto';
 import {
   INPUT_JOB_STATUS,
   DISTRIBUTIONS_ONLY_MAJOR_VERSION,
@@ -64,15 +67,154 @@ export async function extractJdkFile(toolPath: string, extension?: string) {
 
   switch (extension) {
     case 'tar.gz':
+      return await extractTarGz(toolPath);
     case 'tar':
       return await tc.extractTar(toolPath);
     case 'zip':
-      return await tc.extractZip(toolPath);
+      return await extractZipArchive(toolPath);
     default:
       return await tc.extract7z(toolPath);
   }
 }
 
+async function createExtractFolder(): Promise<string> {
+  const dest = path.join(getTempDir(), randomUUID());
+  await io.mkdirP(dest);
+
+  return dest;
+}
+
+/**
+ * Decompressing a JDK tarball with the default single-threaded gzip is one of the
+ * slowest parts of the install, so hand the decompression to `pigz` when the runner
+ * provides it. Any failure falls back to the stock extraction.
+ */
+async function extractTarGz(toolPath: string): Promise<string> {
+  const pigzPath = await io.which('pigz');
+  // tar splits --use-compress-program on whitespace, so a path containing a
+  // space would be word-split into a bogus command.
+  if (pigzPath && !/\s/.test(pigzPath)) {
+    const dest = await createExtractFolder();
+    try {
+      return await tc.extractTar(toolPath, dest, [
+        '--use-compress-program',
+        `${pigzPath} -d`,
+        '-x'
+      ]);
+    } catch (error) {
+      await io.rmRF(dest);
+      core.debug(
+        `Failed to extract '${toolPath}' with pigz, falling back to gzip: ${getErrorMessage(error)}`
+      );
+    }
+  }
+
+  return await tc.extractTar(toolPath);
+}
+
+/**
+ * `tc.extractZip` shells out to PowerShell's `Expand-Archive` on Windows, which is
+ * several times slower than the bundled bsdtar. Prefer `tar.exe` and fall back to
+ * the stock extraction when it is unavailable or fails.
+ */
+async function extractZipArchive(toolPath: string): Promise<string> {
+  if (process.platform === 'win32') {
+    const systemTar = path.join(
+      process.env['SystemRoot'] || 'C:\\Windows',
+      'System32',
+      'tar.exe'
+    );
+
+    if (fs.existsSync(systemTar)) {
+      const dest = await createExtractFolder();
+      try {
+        await exec.exec(`"${systemTar}"`, ['-xf', toolPath, '-C', dest], {
+          silent: true
+        });
+
+        return dest;
+      } catch (error) {
+        await io.rmRF(dest);
+        core.debug(
+          `Failed to extract '${toolPath}' with tar.exe, falling back to Expand-Archive: ${getErrorMessage(error)}`
+        );
+      }
+    }
+  }
+
+  return await tc.extractZip(toolPath);
+}
+
+/**
+ * Equivalent of `tc.cacheDir`, but moves the extracted JDK into the tool-cache
+ * instead of copying it. `tc.cacheDir` recursively copies the whole tree, which
+ * means a several hundred megabyte JDK is written to disk twice. The extraction
+ * directory and the tool-cache normally live on the same filesystem, so a rename
+ * is effectively free. Anything unexpected (a different filesystem, or a file
+ * handle held open by anti-virus software on Windows) falls back to the copy.
+ */
+export async function cacheJdkDir(
+  sourceDir: string,
+  toolName: string,
+  version: string,
+  architecture: string
+): Promise<string> {
+  const destPath = getToolcacheDestination(toolName, version, architecture);
+
+  if (destPath) {
+    let moved = false;
+    try {
+      // lstat, not stat: renaming a symlinked source would put the link itself
+      // in the tool-cache, leaving a dangling JAVA_HOME once RUNNER_TEMP is
+      // cleaned. tc.cacheDir dereferences it, so let it handle that case.
+      if (fs.lstatSync(sourceDir).isDirectory()) {
+        await io.rmRF(destPath);
+        await io.rmRF(`${destPath}.complete`);
+        await io.mkdirP(path.dirname(destPath));
+        // Renaming is atomic, so a failure here leaves sourceDir untouched and
+        // the copy-based fallback below can still run.
+        fs.renameSync(sourceDir, destPath);
+        moved = true;
+      }
+    } catch (error) {
+      core.debug(
+        `Failed to move '${sourceDir}' into the tool-cache, falling back to a copy: ${getErrorMessage(error)}`
+      );
+    }
+
+    if (moved) {
+      fs.writeFileSync(`${destPath}.complete`, '');
+
+      return destPath;
+    }
+  }
+
+  return await tc.cacheDir(sourceDir, toolName, version, architecture);
+}
+
+function getToolcacheDestination(
+  toolName: string,
+  version: string,
+  architecture: string
+): string | null {
+  const toolcacheRoot = process.env['RUNNER_TOOL_CACHE'];
+  if (!toolcacheRoot) {
+    return null;
+  }
+
+  // Mirrors the destination layout used by `tc.cacheDir`.
+  return path.join(
+    toolcacheRoot,
+    toolName,
+    semver.clean(version) || version,
+    architecture || os.arch()
+  );
+}
+
+function getErrorMessage(error: unknown): string {
+  return error instanceof Error ? error.message : String(error);
+}
+
 export function getDownloadArchiveExtension() {
   return process.platform === 'win32' ? 'zip' : 'tar.gz';
 }