revert build cache integration

Author: bmiddha

common/changes/@microsoft/rush/bmiddha-zipsync-3_2025-09-16-00-42.json

@@ -2,5 +2,5 @@
 {
   "pnpmShrinkwrapHash": "2ac01ba33e09661dc0e7d7faa36d215bb3d3b91e",
   "preferredVersionsHash": "550b4cee0bef4e97db6c6aad726df5149d20e7d9",
-  "packageJsonInjectedDependenciesHash": "73ac91f09601cd919fddc7f1d193a03eab37102a"
+  "packageJsonInjectedDependenciesHash": "79ac135cb61506457e8d49c7ec1342d419bde3e2"
 }

common/config/subspaces/build-tests-subspace/repo-state.json

@@ -42,7 +42,6 @@
     "@rushstack/stream-collator": "workspace:*",
     "@rushstack/terminal": "workspace:*",
     "@rushstack/ts-command-line": "workspace:*",
-    "@rushstack/zipsync": "workspace:*",
     "@yarnpkg/lockfile": "~1.0.2",
     "builtin-modules": "~3.1.0",
     "cli-table": "~0.3.1",

common/config/subspaces/default/pnpm-lock.yaml

@@ -226,7 +226,7 @@ export class RushConstants {
    * Build cache version number, incremented when the logic to create cache entries changes.
    * Changing this ensures that cache entries generated by an old version will no longer register as a cache hit.
    */
-  public static readonly buildCacheVersion: 2 = 2;
+  public static readonly buildCacheVersion: 1 = 1;
 
   /**
    * Cobuild configuration file.

libraries/rush-lib/package.json

@@ -3,17 +3,16 @@
 
 import * as path from 'path';
 import * as crypto from 'crypto';
-import * as fs from 'fs';
 
 import { FileSystem, type FolderItem, InternalError, Async } from '@rushstack/node-core-library';
 import type { ITerminal } from '@rushstack/terminal';
-import { packWorkerAsync, type IZipSyncPackWorkerResult } from '@rushstack/zipsync/lib/packWorkerAsync';
-import { unpackWorkerAsync, type IZipSyncUnpackWorkerResult } from '@rushstack/zipsync/lib/unpackWorkerAsync';
 
 import type { RushConfigurationProject } from '../../api/RushConfigurationProject';
 import type { BuildCacheConfiguration } from '../../api/BuildCacheConfiguration';
 import type { ICloudBuildCacheProvider } from './ICloudBuildCacheProvider';
 import type { FileSystemBuildCacheProvider } from './FileSystemBuildCacheProvider';
+import { TarExecutable } from '../../utilities/TarExecutable';
+import { EnvironmentVariableNames } from '../../api/EnvironmentConfiguration';
 import type { IOperationExecutionResult } from '../operations/IOperationExecutionResult';
 
 /**
@@ -61,6 +60,8 @@ interface IPathsToCache {
  * @internal
  */
 export class OperationBuildCache {
+  private static _tarUtilityPromise: Promise<TarExecutable | undefined> | undefined;
+
   private readonly _project: RushConfigurationProject;
   private readonly _localBuildCacheProvider: FileSystemBuildCacheProvider;
   private readonly _cloudBuildCacheProvider: ICloudBuildCacheProvider | undefined;
@@ -89,6 +90,14 @@ export class OperationBuildCache {
     this._cacheId = cacheId;
   }
 
+  private static _tryGetTarUtility(terminal: ITerminal): Promise<TarExecutable | undefined> {
+    if (!OperationBuildCache._tarUtilityPromise) {
+      OperationBuildCache._tarUtilityPromise = TarExecutable.tryInitializeAsync(terminal);
+    }
+
+    return OperationBuildCache._tarUtilityPromise;
+  }
+
   public get cacheId(): string | undefined {
     return this._cacheId;
   }
@@ -167,52 +176,32 @@ export class OperationBuildCache {
 
     const projectFolderPath: string = this._project.projectFolder;
 
+    // Purge output folders
+    terminal.writeVerboseLine(`Clearing cached folders: ${this._projectOutputFolderNames.join(', ')}`);
+    await Promise.all(
+      this._projectOutputFolderNames.map((outputFolderName: string) =>
+        FileSystem.deleteFolderAsync(`${projectFolderPath}/${outputFolderName}`)
+      )
+    );
+
+    const tarUtility: TarExecutable | undefined = await OperationBuildCache._tryGetTarUtility(terminal);
     let restoreSuccess: boolean = false;
-    try {
-      const logFilePath: string = this._getLogFilePath(cacheId, 'unpack');
-      let unpackWorkerResult: IZipSyncUnpackWorkerResult;
-      try {
-        unpackWorkerResult = await unpackWorkerAsync({
-          archivePath: localCacheEntryPath!,
-          targetDirectories: this._projectOutputFolderNames,
-          baseDir: projectFolderPath
-        });
-      } catch (e) {
-        const { zipSyncLogs } = e as { zipSyncLogs: string | undefined };
-        if (zipSyncLogs) {
-          fs.writeFileSync(logFilePath, zipSyncLogs);
-          terminal.writeVerboseLine(`The zipsync log has been written to: ${logFilePath}`);
-        }
-        throw e;
-      }
-      const {
-        zipSyncReturn: { filesDeleted, filesExtracted, filesSkipped, foldersDeleted, otherEntriesDeleted },
-        zipSyncLogs
-      } = unpackWorkerResult;
-      fs.writeFileSync(logFilePath, zipSyncLogs);
-      terminal.writeVerboseLine(`The zipsync log has been written to: ${logFilePath}`);
-      terminal.writeVerboseLine(`Restored ${filesExtracted + filesSkipped} files from cache.`);
-      if (filesExtracted > 0) {
-        terminal.writeVerboseLine(`Extracted ${filesExtracted} files to target folders.`);
-      }
-      if (filesSkipped > 0) {
-        terminal.writeVerboseLine(`Skipped ${filesSkipped} files that were already up to date.`);
-      }
-      if (filesDeleted > 0) {
-        terminal.writeVerboseLine(`Deleted ${filesDeleted} files from target folders.`);
-      }
-      if (foldersDeleted > 0) {
-        terminal.writeVerboseLine(`Deleted ${foldersDeleted} empty folders from target folders.`);
-      }
-      if (otherEntriesDeleted > 0) {
-        terminal.writeVerboseLine(
-          `Deleted ${otherEntriesDeleted} items (e.g. symbolic links) from target folders.`
+    if (tarUtility && localCacheEntryPath) {
+      const logFilePath: string = this._getTarLogFilePath(cacheId, 'untar');
+      const tarExitCode: number = await tarUtility.tryUntarAsync({
+        archivePath: localCacheEntryPath,
+        outputFolderPath: projectFolderPath,
+        logFilePath
+      });
+      if (tarExitCode === 0) {
+        restoreSuccess = true;
+        terminal.writeLine('Successfully restored output from the build cache.');
+      } else {
+        terminal.writeWarningLine(
+          'Unable to restore output from the build cache. ' +
+            `See "${logFilePath}" for logs from the tar process.`
         );
       }
-      restoreSuccess = true;
-      terminal.writeLine('Successfully restored output from the build cache.');
-    } catch (e) {
-      terminal.writeWarningLine(`Unable to restore output from the build cache: ${e}`);
     }
 
     if (updateLocalCacheSuccess === false) {
@@ -245,71 +234,59 @@ export class OperationBuildCache {
 
     let localCacheEntryPath: string | undefined;
 
-    const finalLocalCacheEntryPath: string = this._localBuildCacheProvider.getCacheEntryPath(cacheId);
-
-    // Derive the temp file from the destination path to ensure they are on the same volume
-    // In the case of a shared network drive containing the build cache, we also need to make
-    // sure the the temp path won't be shared by two parallel rush builds.
-    const randomSuffix: string = crypto.randomBytes(8).toString('hex');
-    const tempLocalCacheEntryPath: string = `${finalLocalCacheEntryPath}-${randomSuffix}.temp`;
+    const tarUtility: TarExecutable | undefined = await OperationBuildCache._tryGetTarUtility(terminal);
+    if (tarUtility) {
+      const finalLocalCacheEntryPath: string = this._localBuildCacheProvider.getCacheEntryPath(cacheId);
+
+      // Derive the temp file from the destination path to ensure they are on the same volume
+      // In the case of a shared network drive containing the build cache, we also need to make
+      // sure the the temp path won't be shared by two parallel rush builds.
+      const randomSuffix: string = crypto.randomBytes(8).toString('hex');
+      const tempLocalCacheEntryPath: string = `${finalLocalCacheEntryPath}-${randomSuffix}.temp`;
+
+      const logFilePath: string = this._getTarLogFilePath(cacheId, 'tar');
+      const tarExitCode: number = await tarUtility.tryCreateArchiveFromProjectPathsAsync({
+        archivePath: tempLocalCacheEntryPath,
+        paths: filesToCache.outputFilePaths,
+        project: this._project,
+        logFilePath
+      });
 
-    terminal.writeVerboseLine(`Using zipsync to create cache archive.`);
-    try {
-      const logFilePath: string = this._getLogFilePath(cacheId, 'pack');
-      let packWorkerResult: IZipSyncPackWorkerResult;
-      try {
-        packWorkerResult = await packWorkerAsync({
-          compression: 'auto',
-          archivePath: tempLocalCacheEntryPath,
-          targetDirectories: this._projectOutputFolderNames,
-          baseDir: this._project.projectFolder
-        });
-      } catch (e) {
-        const { zipSyncLogs } = e as { zipSyncLogs: string | undefined };
-        if (zipSyncLogs) {
-          fs.writeFileSync(logFilePath, zipSyncLogs);
-          terminal.writeVerboseLine(`The zipsync log has been written to: ${logFilePath}`);
-        }
-        throw e;
-      }
-      const {
-        zipSyncReturn: { filesPacked },
-        zipSyncLogs
-      } = packWorkerResult;
-      fs.writeFileSync(logFilePath, zipSyncLogs);
-      terminal.writeVerboseLine(`The zipsync log has been written to: ${logFilePath}`);
-      terminal.writeVerboseLine(`Packed ${filesPacked} files for caching.`);
-
-      // Move after the archive is finished so that if the process is interrupted we aren't left with an invalid file
-      try {
-        await Async.runWithRetriesAsync({
-          action: () =>
-            new Promise<void>((resolve, reject) => {
-              fs.rename(tempLocalCacheEntryPath, finalLocalCacheEntryPath, (err) => {
-                if (err) {
-                  reject(err);
-                } else {
-                  resolve();
-                }
-              });
-            }),
-          maxRetries: 2,
-          retryDelayMs: 500
-        });
-      } catch (moveError) {
+      if (tarExitCode === 0) {
+        // Move after the archive is finished so that if the process is interrupted we aren't left with an invalid file
         try {
-          await FileSystem.deleteFileAsync(tempLocalCacheEntryPath);
-        } catch (deleteError) {
-          // Ignored
+          await Async.runWithRetriesAsync({
+            action: () =>
+              FileSystem.moveAsync({
+                sourcePath: tempLocalCacheEntryPath,
+                destinationPath: finalLocalCacheEntryPath,
+                overwrite: true
+              }),
+            maxRetries: 2,
+            retryDelayMs: 500
+          });
+        } catch (moveError) {
+          try {
+            await FileSystem.deleteFileAsync(tempLocalCacheEntryPath);
+          } catch (deleteError) {
+            // Ignored
+          }
+          throw moveError;
         }
-        throw moveError;
+        localCacheEntryPath = finalLocalCacheEntryPath;
+      } else {
+        terminal.writeWarningLine(
+          `"tar" exited with code ${tarExitCode} while attempting to create the cache entry. ` +
+            `See "${logFilePath}" for logs from the tar process.`
+        );
+        return false;
       }
-      localCacheEntryPath = finalLocalCacheEntryPath;
-    } catch (e) {
-      await FileSystem.deleteFileAsync(tempLocalCacheEntryPath).catch(() => {
-        /* ignore delete error */
-      });
-      throw e;
+    } else {
+      terminal.writeWarningLine(
+        `Unable to locate "tar". Please ensure that "tar" is on your PATH environment variable, or set the ` +
+          `${EnvironmentVariableNames.RUSH_TAR_BINARY_PATH} environment variable to the full path to the "tar" binary.`
+      );
+      return false;
     }
 
     let cacheEntryBuffer: Buffer | undefined;
@@ -418,7 +395,7 @@ export class OperationBuildCache {
     };
   }
 
-  private _getLogFilePath(cacheId: string, mode: 'pack' | 'unpack'): string {
+  private _getTarLogFilePath(cacheId: string, mode: 'tar' | 'untar'): string {
     return path.join(this._project.projectRushTempFolder, `${cacheId}.${mode}.log`);
   }