Fix test

Revert "Add GNUtar as default in windows"

packages/cache/__tests__/tar.test.ts

@@ -4,8 +4,7 @@ import * as path from 'path'
 import {
   CacheFilename,
   CompressionMethod,
-  GnuTarPathOnWindows,
-  SystemTarPathOnWindows
+  GnuTarPathOnWindows
 } from '../src/internal/constants'
 import * as tar from '../src/internal/tar'
 import * as utils from '../src/internal/cacheUtils'
@@ -18,7 +17,7 @@ jest.mock('@actions/io')
 const IS_WINDOWS = process.platform === 'win32'
 const IS_MAC = process.platform === 'darwin'
 
-const defaultTarPath = IS_MAC ? 'gtar' : 'tar'
+const defaultTarPath = process.platform === 'darwin' ? 'gtar' : 'tar'
 
 function getTempDir(): string {
   return path.join(__dirname, '_temp', 'tar')
@@ -59,6 +58,8 @@ test('zstd extract tar', async () => {
   expect(execMock).toHaveBeenCalledWith(
     `"${tarPath}"`,
     [
+      '--use-compress-program',
+      IS_WINDOWS ? 'zstd -d --long=30' : 'unzstd --long=30',
       '-xf',
       IS_WINDOWS ? archivePath.replace(/\\/g, '/') : archivePath,
       '-P',
@@ -66,50 +67,11 @@ test('zstd extract tar', async () => {
       IS_WINDOWS ? workspace?.replace(/\\/g, '/') : workspace
     ]
       .concat(IS_WINDOWS ? ['--force-local'] : [])
-      .concat(IS_MAC ? ['--delay-directory-restore'] : [])
-      .concat([
-        '--use-compress-program',
-        IS_WINDOWS ? 'zstd -d --long=30' : 'unzstd --long=30'
-      ]),
+      .concat(IS_MAC ? ['--delay-directory-restore'] : []),
     {cwd: undefined}
   )
 })
 
-test('zstd extract tar with windows BSDtar', async () => {
-  if (IS_WINDOWS) {
-    const mkdirMock = jest.spyOn(io, 'mkdirP')
-    const execMock = jest.spyOn(exec, 'exec')
-    jest
-      .spyOn(utils, 'getGnuTarPathOnWindows')
-      .mockReturnValue(Promise.resolve(''))
-
-    const archivePath = `${process.env['windir']}\\fakepath\\cache.tar`
-    const workspace = process.env['GITHUB_WORKSPACE']
-    const tarPath = SystemTarPathOnWindows
-    const tarFilename = 'cache.tar'
-
-    await tar.extractTar(archivePath, CompressionMethod.Zstd)
-
-    expect(mkdirMock).toHaveBeenCalledWith(workspace)
-    expect(execMock).toHaveBeenCalledTimes(1)
-    expect(execMock).toHaveBeenCalledWith(
-      'zstd -d --long=30 -o',
-      [
-        tarFilename.replace(new RegExp(`\\${path.sep}`, 'g'), '/'),
-        archivePath.replace(new RegExp(`\\${path.sep}`, 'g'), '/'),
-        '&&',
-        `${tarPath}`,
-        '-xf',
-        tarFilename.replace(new RegExp(`\\${path.sep}`, 'g'), '/'),
-        '-P',
-        '-C',
-        workspace?.replace(/\\/g, '/')
-      ],
-      {cwd: undefined}
-    )
-  }
-})
-
 test('gzip extract tar', async () => {
   const mkdirMock = jest.spyOn(io, 'mkdirP')
   const execMock = jest.spyOn(exec, 'exec')
@@ -126,6 +88,7 @@ test('gzip extract tar', async () => {
   expect(execMock).toHaveBeenCalledWith(
     `"${tarPath}"`,
     [
+      '-z',
       '-xf',
       IS_WINDOWS ? archivePath.replace(/\\/g, '/') : archivePath,
       '-P',
@@ -133,8 +96,7 @@ test('gzip extract tar', async () => {
       IS_WINDOWS ? workspace?.replace(/\\/g, '/') : workspace
     ]
       .concat(IS_WINDOWS ? ['--force-local'] : [])
-      .concat(IS_MAC ? ['--delay-directory-restore'] : [])
-      .concat(['-z']),
+      .concat(IS_MAC ? ['--delay-directory-restore'] : []),
     {cwd: undefined}
   )
 })
@@ -142,7 +104,7 @@ test('gzip extract tar', async () => {
 test('gzip extract GNU tar on windows with GNUtar in path', async () => {
   if (IS_WINDOWS) {
     // GNU tar present in path but not at default location
-    jest
+    const isGnuMock = jest
       .spyOn(utils, 'getGnuTarPathOnWindows')
       .mockReturnValue(Promise.resolve('tar'))
     const execMock = jest.spyOn(exec, 'exec')
@@ -151,17 +113,18 @@ test('gzip extract GNU tar on windows with GNUtar in path', async () => {
 
     await tar.extractTar(archivePath, CompressionMethod.Gzip)
 
+    expect(isGnuMock).toHaveBeenCalledTimes(1)
     expect(execMock).toHaveBeenCalledTimes(1)
     expect(execMock).toHaveBeenCalledWith(
       `"tar"`,
       [
+        '-z',
         '-xf',
         archivePath.replace(/\\/g, '/'),
         '-P',
         '-C',
         workspace?.replace(/\\/g, '/'),
-        '--force-local',
-        '-z'
+        '--force-local'
       ],
       {cwd: undefined}
     )
@@ -186,6 +149,8 @@ test('zstd create tar', async () => {
     `"${tarPath}"`,
     [
       '--posix',
+      '--use-compress-program',
+      IS_WINDOWS ? 'zstd -T0 --long=30' : 'zstdmt --long=30',
       '-cf',
       IS_WINDOWS ? CacheFilename.Zstd.replace(/\\/g, '/') : CacheFilename.Zstd,
       '--exclude',
@@ -197,65 +162,13 @@ test('zstd create tar', async () => {
       'manifest.txt'
     ]
       .concat(IS_WINDOWS ? ['--force-local'] : [])
-      .concat(IS_MAC ? ['--delay-directory-restore'] : [])
-      .concat([
-        '--use-compress-program',
-        IS_WINDOWS ? 'zstd -T0 --long=30' : 'zstdmt --long=30'
-      ]),
+      .concat(IS_MAC ? ['--delay-directory-restore'] : []),
     {
       cwd: archiveFolder
     }
   )
 })
 
-test('zstd create tar with windows BSDtar', async () => {
-  if (IS_WINDOWS) {
-    const execMock = jest.spyOn(exec, 'exec')
-    jest
-      .spyOn(utils, 'getGnuTarPathOnWindows')
-      .mockReturnValue(Promise.resolve(''))
-
-    const archiveFolder = getTempDir()
-    const workspace = process.env['GITHUB_WORKSPACE']
-    const sourceDirectories = ['~/.npm/cache', `${workspace}/dist`]
-    const tarFilename = 'cache.tar'
-
-    await fs.promises.mkdir(archiveFolder, {recursive: true})
-
-    await tar.createTar(
-      archiveFolder,
-      sourceDirectories,
-      CompressionMethod.Zstd
-    )
-
-    const tarPath = SystemTarPathOnWindows
-
-    expect(execMock).toHaveBeenCalledTimes(1)
-    expect(execMock).toHaveBeenCalledWith(
-      `"${tarPath}"`,
-      [
-        '--posix',
-        '-cf',
-        tarFilename.replace(/\\/g, '/'),
-        '--exclude',
-        tarFilename.replace(/\\/g, '/'),
-        '-P',
-        '-C',
-        workspace?.replace(/\\/g, '/'),
-        '--files-from',
-        'manifest.txt',
-        '&&',
-        'zstd -T0 --long=30 -o',
-        CacheFilename.Zstd.replace(/\\/g, '/'),
-        tarFilename.replace(/\\/g, '/')
-      ],
-      {
-        cwd: archiveFolder
-      }
-    )
-  }
-})
-
 test('gzip create tar', async () => {
   const execMock = jest.spyOn(exec, 'exec')
 
@@ -274,6 +187,7 @@ test('gzip create tar', async () => {
     `"${tarPath}"`,
     [
       '--posix',
+      '-z',
       '-cf',
       IS_WINDOWS ? CacheFilename.Gzip.replace(/\\/g, '/') : CacheFilename.Gzip,
       '--exclude',
@@ -285,8 +199,7 @@ test('gzip create tar', async () => {
       'manifest.txt'
     ]
       .concat(IS_WINDOWS ? ['--force-local'] : [])
-      .concat(IS_MAC ? ['--delay-directory-restore'] : [])
-      .concat(['-z']),
+      .concat(IS_MAC ? ['--delay-directory-restore'] : []),
     {
       cwd: archiveFolder
     }
@@ -306,46 +219,19 @@ test('zstd list tar', async () => {
   expect(execMock).toHaveBeenCalledTimes(1)
   expect(execMock).toHaveBeenCalledWith(
     `"${tarPath}"`,
-    ['-tf', IS_WINDOWS ? archivePath.replace(/\\/g, '/') : archivePath, '-P']
+    [
+      '--use-compress-program',
+      IS_WINDOWS ? 'zstd -d --long=30' : 'unzstd --long=30',
+      '-tf',
+      IS_WINDOWS ? archivePath.replace(/\\/g, '/') : archivePath,
+      '-P'
+    ]
       .concat(IS_WINDOWS ? ['--force-local'] : [])
-      .concat(IS_MAC ? ['--delay-directory-restore'] : [])
-      .concat([
-        '--use-compress-program',
-        IS_WINDOWS ? 'zstd -d --long=30' : 'unzstd --long=30'
-      ]),
+      .concat(IS_MAC ? ['--delay-directory-restore'] : []),
     {cwd: undefined}
   )
 })
 
-test('zstd list tar with windows BSDtar', async () => {
-  if (IS_WINDOWS) {
-    const execMock = jest.spyOn(exec, 'exec')
-    jest
-      .spyOn(utils, 'getGnuTarPathOnWindows')
-      .mockReturnValue(Promise.resolve(''))
-    const archivePath = `${process.env['windir']}\\fakepath\\cache.tar`
-
-    await tar.listTar(archivePath, CompressionMethod.Zstd)
-
-    const tarFilename = 'cache.tar'
-    const tarPath = SystemTarPathOnWindows
-    expect(execMock).toHaveBeenCalledTimes(1)
-    expect(execMock).toHaveBeenCalledWith(
-      'zstd -d --long=30 -o',
-      [
-        tarFilename.replace(new RegExp(`\\${path.sep}`, 'g'), '/'),
-        archivePath.replace(new RegExp(`\\${path.sep}`, 'g'), '/'),
-        '&&',
-        `${tarPath}`,
-        '-tf',
-        tarFilename.replace(new RegExp(`\\${path.sep}`, 'g'), '/'),
-        '-P'
-      ],
-      {cwd: undefined}
-    )
-  }
-})
-
 test('zstdWithoutLong list tar', async () => {
   const execMock = jest.spyOn(exec, 'exec')
 
@@ -359,10 +245,15 @@ test('zstdWithoutLong list tar', async () => {
   expect(execMock).toHaveBeenCalledTimes(1)
   expect(execMock).toHaveBeenCalledWith(
     `"${tarPath}"`,
-    ['-tf', IS_WINDOWS ? archivePath.replace(/\\/g, '/') : archivePath, '-P']
+    [
+      '--use-compress-program',
+      IS_WINDOWS ? 'zstd -d' : 'unzstd',
+      '-tf',
+      IS_WINDOWS ? archivePath.replace(/\\/g, '/') : archivePath,
+      '-P'
+    ]
       .concat(IS_WINDOWS ? ['--force-local'] : [])
-      .concat(IS_MAC ? ['--delay-directory-restore'] : [])
-      .concat(['--use-compress-program', IS_WINDOWS ? 'zstd -d' : 'unzstd']),
+      .concat(IS_MAC ? ['--delay-directory-restore'] : []),
     {cwd: undefined}
   )
 })
@@ -379,10 +270,14 @@ test('gzip list tar', async () => {
   expect(execMock).toHaveBeenCalledTimes(1)
   expect(execMock).toHaveBeenCalledWith(
     `"${tarPath}"`,
-    ['-tf', IS_WINDOWS ? archivePath.replace(/\\/g, '/') : archivePath, '-P']
+    [
+      '-z',
+      '-tf',
+      IS_WINDOWS ? archivePath.replace(/\\/g, '/') : archivePath,
+      '-P'
+    ]
       .concat(IS_WINDOWS ? ['--force-local'] : [])
-      .concat(IS_MAC ? ['--delay-directory-restore'] : [])
-      .concat(['-z']),
+      .concat(IS_MAC ? ['--delay-directory-restore'] : []),
     {cwd: undefined}
   )
 })

packages/cache/src/internal/cacheUtils.ts

@@ -71,7 +71,7 @@ export async function unlinkFile(filePath: fs.PathLike): Promise<void> {
   return util.promisify(fs.unlink)(filePath)
 }
 
-export async function getVersion(app: string): Promise<string> {
+async function getVersion(app: string): Promise<string> {
   core.debug(`Checking ${app} --version`)
   let versionOutput = ''
   try {
@@ -94,6 +94,11 @@ export async function getVersion(app: string): Promise<string> {
 
 // Use zstandard if possible to maximize cache performance
 export async function getCompressionMethod(): Promise<CompressionMethod> {
+  if (process.platform === 'win32' && !(await getGnuTarPathOnWindows())) {
+    // Disable zstd due to bug https://github.com/actions/cache/issues/301
+    return CompressionMethod.Gzip
+  }
+
   const versionOutput = await getVersion('zstd')
   const version = semver.clean(versionOutput)
 

packages/cache/src/internal/constants.ts

@@ -24,5 +24,3 @@ export const SocketTimeout = 5000
 
 // The default path of GNUtar on hosted Windows runners
 export const GnuTarPathOnWindows = `${process.env['PROGRAMFILES']}\\Git\\usr\\bin\\tar.exe`
-
-export const SystemTarPathOnWindows = `${process.env['SYSTEMDRIVE']}\\Windows\\System32\\tar.exe`

packages/cache/src/internal/tar.ts

@@ -3,18 +3,18 @@ import * as io from '@actions/io'
 import {existsSync, writeFileSync} from 'fs'
 import * as path from 'path'
 import * as utils from './cacheUtils'
-import {CompressionMethod, SystemTarPathOnWindows} from './constants'
+import {CompressionMethod} from './constants'
 
 const IS_WINDOWS = process.platform === 'win32'
 
-// Function also mutates the args array. For non-mutation call with passing an empty array.
-async function getTarPath(): Promise<string> {
+async function getTarPath(args: string[]): Promise<string> {
   switch (process.platform) {
     case 'win32': {
       const gnuTar = await utils.getGnuTarPathOnWindows()
-      const systemTar = SystemTarPathOnWindows
+      const systemTar = `${process.env['windir']}\\System32\\tar.exe`
       if (gnuTar) {
         // Use GNUtar as default on windows
+        args.push('--force-local')
         return gnuTar
       } else if (existsSync(systemTar)) {
         return systemTar
@@ -25,6 +25,7 @@ async function getTarPath(): Promise<string> {
       const gnuTar = await io.which('gtar', false)
       if (gnuTar) {
         // fix permission denied errors when extracting BSD tar archive with GNU tar - https://github.com/actions/cache/issues/527
+        args.push('--delay-directory-restore')
         return gnuTar
       }
       break
@@ -35,101 +36,9 @@ async function getTarPath(): Promise<string> {
   return await io.which('tar', true)
 }
 
-async function getTarArgs(
-  compressionMethod: CompressionMethod,
-  type: string,
-  archivePath = ''
-): Promise<string[]> {
-  const args = []
-  const manifestFilename = 'manifest.txt'
-  const cacheFileName = utils.getCacheFileName(compressionMethod)
-  const tarFile = 'cache.tar'
-  const tarPath = await getTarPath()
-  const workingDirectory = getWorkingDirectory()
-  const BSD_TAR_ZSTD =
-    tarPath === SystemTarPathOnWindows &&
-    compressionMethod !== CompressionMethod.Gzip
-
-  // Method specific args
-  switch (type) {
-    case 'create':
-      args.push(
-        '--posix',
-        '-cf',
-        BSD_TAR_ZSTD
-          ? tarFile
-          : cacheFileName.replace(new RegExp(`\\${path.sep}`, 'g'), '/'),
-        '--exclude',
-        BSD_TAR_ZSTD
-          ? tarFile
-          : cacheFileName.replace(new RegExp(`\\${path.sep}`, 'g'), '/'),
-        '-P',
-        '-C',
-        workingDirectory.replace(new RegExp(`\\${path.sep}`, 'g'), '/'),
-        '--files-from',
-        manifestFilename
-      )
-      break
-    case 'extract':
-      args.push(
-        '-xf',
-        BSD_TAR_ZSTD
-          ? tarFile
-          : archivePath.replace(new RegExp(`\\${path.sep}`, 'g'), '/'),
-        '-P',
-        '-C',
-        workingDirectory.replace(new RegExp(`\\${path.sep}`, 'g'), '/')
-      )
-      break
-    case 'list':
-      args.push(
-        '-tf',
-        BSD_TAR_ZSTD
-          ? tarFile
-          : archivePath.replace(new RegExp(`\\${path.sep}`, 'g'), '/'),
-        '-P'
-      )
-      break
-  }
-
-  // Platform specific args
-  switch (process.platform) {
-    case 'win32': {
-      const gnuTar = await utils.getGnuTarPathOnWindows()
-      if (gnuTar) {
-        // Use GNUtar as default on windows
-        args.push('--force-local')
-      }
-      break
-    }
-    case 'darwin': {
-      const gnuTar = await io.which('gtar', false)
-      if (gnuTar) {
-        // fix permission denied errors when extracting BSD tar archive with GNU tar - https://github.com/actions/cache/issues/527
-        args.push('--delay-directory-restore')
-      }
-      break
-    }
-  }
-
-  return args
-}
-
 async function execTar(args: string[], cwd?: string): Promise<void> {
   try {
-    await exec(`"${await getTarPath()}"`, args, {cwd})
-  } catch (error) {
-    throw new Error(`Tar failed with error: ${error?.message}`)
-  }
-}
-
-async function execCommand(
-  command: string,
-  args: string[],
-  cwd?: string
-): Promise<void> {
-  try {
-    await exec(command, args, {cwd})
+    await exec(`"${await getTarPath(args)}"`, args, {cwd})
   } catch (error) {
     throw new Error(`Tar failed with error: ${error?.message}`)
   }
@@ -140,41 +49,19 @@ function getWorkingDirectory(): string {
 }
 
 // Common function for extractTar and listTar to get the compression method
-async function getCompressionProgram(
-  compressionMethod: CompressionMethod,
-  archivePath: string
-): Promise<string[]> {
+function getCompressionProgram(compressionMethod: CompressionMethod): string[] {
   // -d: Decompress.
   // unzstd is equivalent to 'zstd -d'
   // --long=#: Enables long distance matching with # bits. Maximum is 30 (1GB) on 32-bit OS and 31 (2GB) on 64-bit.
   // Using 30 here because we also support 32-bit self-hosted runners.
-  const tarPath = await getTarPath()
-  const tarFile = 'cache.tar'
-  const BSD_TAR_ZSTD =
-    tarPath === SystemTarPathOnWindows &&
-    compressionMethod !== CompressionMethod.Gzip
   switch (compressionMethod) {
     case CompressionMethod.Zstd:
-      return BSD_TAR_ZSTD
-        ? [
-            'zstd -d --long=30 -o',
-            tarFile,
-            archivePath.replace(new RegExp(`\\${path.sep}`, 'g'), '/'),
-            '&&'
-          ]
-        : [
-            '--use-compress-program',
-            IS_WINDOWS ? 'zstd -d --long=30' : 'unzstd --long=30'
-          ]
+      return [
+        '--use-compress-program',
+        IS_WINDOWS ? 'zstd -d --long=30' : 'unzstd --long=30'
+      ]
     case CompressionMethod.ZstdWithoutLong:
-      return BSD_TAR_ZSTD
-        ? [
-            'zstd -d -o',
-            tarFile,
-            archivePath.replace(new RegExp(`\\${path.sep}`, 'g'), '/'),
-            '&&'
-          ]
-        : ['--use-compress-program', IS_WINDOWS ? 'zstd -d' : 'unzstd']
+      return ['--use-compress-program', IS_WINDOWS ? 'zstd -d' : 'unzstd']
     default:
       return ['-z']
   }
@@ -184,27 +71,13 @@ export async function listTar(
   archivePath: string,
   compressionMethod: CompressionMethod
 ): Promise<void> {
-  const tarPath = await getTarPath()
-  const BSD_TAR_ZSTD =
-    tarPath === SystemTarPathOnWindows &&
-    compressionMethod !== CompressionMethod.Gzip
-  const compressionArgs = await getCompressionProgram(
-    compressionMethod,
-    archivePath
-  )
-  const tarArgs = await getTarArgs(compressionMethod, 'list', archivePath)
-  // TODO: Add a test for BSD tar on windows
-  if (BSD_TAR_ZSTD) {
-    const command = compressionArgs[0]
-    const args = compressionArgs
-      .slice(1)
-      .concat([tarPath])
-      .concat(tarArgs)
-    await execCommand(command, args)
-  } else {
-    const args = tarArgs.concat(compressionArgs)
-    await execTar(args)
-  }
+  const args = [
+    ...getCompressionProgram(compressionMethod),
+    '-tf',
+    archivePath.replace(new RegExp(`\\${path.sep}`, 'g'), '/'),
+    '-P'
+  ]
+  await execTar(args)
 }
 
 export async function extractTar(
@@ -213,27 +86,16 @@ export async function extractTar(
 ): Promise<void> {
   // Create directory to extract tar into
   const workingDirectory = getWorkingDirectory()
-  const tarPath = await getTarPath()
-  const BSD_TAR_ZSTD =
-    tarPath === SystemTarPathOnWindows &&
-    compressionMethod !== CompressionMethod.Gzip
   await io.mkdirP(workingDirectory)
-  const tarArgs = await getTarArgs(compressionMethod, 'extract', archivePath)
-  const compressionArgs = await getCompressionProgram(
-    compressionMethod,
-    archivePath
-  )
-  if (BSD_TAR_ZSTD) {
-    const command = compressionArgs[0]
-    const args = compressionArgs
-      .slice(1)
-      .concat([tarPath])
-      .concat(tarArgs)
-    await execCommand(command, args)
-  } else {
-    const args = tarArgs.concat(compressionArgs)
-    await execTar(args)
-  }
+  const args = [
+    ...getCompressionProgram(compressionMethod),
+    '-xf',
+    archivePath.replace(new RegExp(`\\${path.sep}`, 'g'), '/'),
+    '-P',
+    '-C',
+    workingDirectory.replace(new RegExp(`\\${path.sep}`, 'g'), '/')
+  ]
+  await execTar(args)
 }
 
 export async function createTar(
@@ -244,15 +106,11 @@ export async function createTar(
   // Write source directories to manifest.txt to avoid command length limits
   const manifestFilename = 'manifest.txt'
   const cacheFileName = utils.getCacheFileName(compressionMethod)
-  const tarFile = 'cache.tar'
-  const tarPath = await getTarPath()
-  const BSD_TAR_ZSTD =
-    tarPath === SystemTarPathOnWindows &&
-    compressionMethod !== CompressionMethod.Gzip
   writeFileSync(
     path.join(archiveFolder, manifestFilename),
     sourceDirectories.join('\n')
   )
+  const workingDirectory = getWorkingDirectory()
 
   // -T#: Compress using # working thread. If # is 0, attempt to detect and use the number of physical CPU cores.
   // zstdmt is equivalent to 'zstd -T0'
@@ -262,145 +120,28 @@ export async function createTar(
   function getCompressionProgram(): string[] {
     switch (compressionMethod) {
       case CompressionMethod.Zstd:
-        return BSD_TAR_ZSTD
-          ? [
-              '&&',
-              'zstd -T0 --long=30 -o',
-              cacheFileName.replace(new RegExp(`\\${path.sep}`, 'g'), '/'),
-              tarFile
-            ]
-          : [
-              '--use-compress-program',
-              IS_WINDOWS ? 'zstd -T0 --long=30' : 'zstdmt --long=30'
-            ]
+        return [
+          '--use-compress-program',
+          IS_WINDOWS ? 'zstd -T0 --long=30' : 'zstdmt --long=30'
+        ]
       case CompressionMethod.ZstdWithoutLong:
-        return BSD_TAR_ZSTD
-          ? [
-              '&&',
-              'zstd -T0 -o',
-              cacheFileName.replace(new RegExp(`\\${path.sep}`, 'g'), '/'),
-              tarFile
-            ]
-          : ['--use-compress-program', IS_WINDOWS ? 'zstd -T0' : 'zstdmt']
+        return ['--use-compress-program', IS_WINDOWS ? 'zstd -T0' : 'zstdmt']
       default:
         return ['-z']
     }
   }
-  const tarArgs = await getTarArgs(compressionMethod, 'create')
-  const compressionArgs = getCompressionProgram()
-  const args = tarArgs.concat(compressionArgs)
+  const args = [
+    '--posix',
+    ...getCompressionProgram(),
+    '-cf',
+    cacheFileName.replace(new RegExp(`\\${path.sep}`, 'g'), '/'),
+    '--exclude',
+    cacheFileName.replace(new RegExp(`\\${path.sep}`, 'g'), '/'),
+    '-P',
+    '-C',
+    workingDirectory.replace(new RegExp(`\\${path.sep}`, 'g'), '/'),
+    '--files-from',
+    manifestFilename
+  ]
   await execTar(args, archiveFolder)
 }
-
-const ARCHIVE_TOOL_GNU: string = 'gnu'
-const ARCHIVE_TOOL_BSD: string = 'bsd'
-
-const manifestFilename = 'manifest.txt'
-
-export async function createTar2(
-  archiveFolder: string,
-  sourceDirectories: string[]
-): Promise<void> {
-
-  // 1. decide the compression algo - zstd otherwise gzip
-  // 2. decide tar - gnutar otherwise bsdtar or systemtar
-  // 3. deide archiving/unarchiving args depending on tar
-  // 4. decide compression/decompression args depending on tar and compression
-  // 5. decide the exec command
-
-  let tar = getTarPath2()
-  let compression = getCompressionMethod2()
-  let args = argsMap.get({tar: tar, compression: compression, os: process.platform, "create"})
-
-
-
-
-}
-
-// return archive tool name and path
-async function getTarPath2(): Promise<ArchiveTool> {
-  switch (process.platform) {
-    case 'win32': {
-      const gnuTar = await utils.getGnuTarPathOnWindows()
-      const systemTar = SystemTarPathOnWindows
-      if (gnuTar) {
-        // Use GNUtar as default on windows
-        return <ArchiveTool>{ name: ARCHIVE_TOOL_GNU, path: gnuTar }
-      } else if (existsSync(systemTar)) {
-        return <ArchiveTool>{name: ARCHIVE_TOOL_BSD, path: systemTar}
-      }
-      break
-    }
-    case 'darwin': {
-      const gnuTar = await io.which('gtar', false)
-      if (gnuTar) {
-        // fix permission denied errors when extracting BSD tar archive with GNU tar - https://github.com/actions/cache/issues/527
-        return <ArchiveTool>{ name: ARCHIVE_TOOL_GNU, path: gnuTar }
-      } else {
-        const path = await io.which('tar', true)
-        return <ArchiveTool>{name: ARCHIVE_TOOL_BSD, path: path}
-      }
-    }
-    default:
-      break
-  }
-  const path = await io.which('tar', true)
-  return <ArchiveTool>{name: ARCHIVE_TOOL_GNU, path: path}
-}
-
-// Use zstandard if possible to maximize cache performance
-export async function getCompressionMethod2(): Promise<CompressionMethod> {
-  const versionOutput = await utils.getVersion('zstd')
-  const version = semver.clean(versionOutput)
-
-  if (!versionOutput.toLowerCase().includes('zstd command line interface')) {
-    // zstd is not installed
-    return CompressionMethod.Gzip
-  } else if (!version || semver.lt(version, 'v1.3.2')) {
-    // zstd is installed but using a version earlier than v1.3.2
-    // v1.3.2 is required to use the `--long` options in zstd
-    return CompressionMethod.ZstdWithoutLong
-  } else {
-    return CompressionMethod.Zstd
-  }
-}
-
-interface ArchiveTool {
-  name: string
-  path: string
-}
-
-// tar, compression, os, operation -> tar args + compression args
-const argsMap: Map<ArgsLookupKey, string[][]> = new Map()
-argsMap.set({tar: ARCHIVE_TOOL_GNU, compression: CompressionMethod.Zstd, os: "windows", operation: "create"},
-[[
-  '--posix',
-  '-cf',
-  '%%cacheFileName%%',
-  '--exclude',
-  '%%cacheFileName%%',
-  '-P',
-  '-C',
-  '%%workingDirectory%%',
-  '--files-from',
-  manifestFilename],
-  ['--use-compress-program',
-  'zstd -T0 --long=30']
-])
-
-argsMap.set({tar: ARCHIVE_TOOL_GNU, compression: CompressionMethod.Zstd, os: "linux", operation: "create"},
-[
-  '--use-compress-program',
-  'zstdmt --long=30'
-])
-
-
-
-interface ArgsLookupKey {
-  tar: string
-  compression: string
-  os: string
-  operation: string
-}
-
-