Refactor code

2022-11-28 10:24:40 +00:00 · 2022-11-28 10:24:40 +00:00 · 0fd856d0a0
parent 0822441ee0
commit 0fd856d0a0
3 changed files with 118 additions and 130 deletions
--- a/packages/cache/src/internal/constants.ts
+++ b/packages/cache/src/internal/constants.ts
@ -11,6 +11,11 @@ export enum CompressionMethod {
  Zstd = 'zstd'
 }

+export enum ArchiveToolType {
+  GNU = 'gnu',
+  BSD = 'bsd'
+}
+
 // The default number of retry attempts.
 export const DefaultRetryAttempts = 2

--- a/packages/cache/src/internal/contracts.d.ts
+++ b/packages/cache/src/internal/contracts.d.ts
@ -31,3 +31,8 @@ export interface InternalCacheOptions {
  compressionMethod?: CompressionMethod
  cacheSize?: number
 }
+
+export interface ArchiveTool {
+  path: string
+  type: string
+}
--- a/packages/cache/src/internal/tar.ts
+++ b/packages/cache/src/internal/tar.ts
@ -3,21 +3,26 @@ 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 {ArchiveTool} from './contracts'
+import {
+  CompressionMethod,
+  SystemTarPathOnWindows,
+  ArchiveToolType
+} 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(): Promise<ArchiveTool> {
  switch (process.platform) {
    case 'win32': {
      const gnuTar = await utils.getGnuTarPathOnWindows()
      const systemTar = SystemTarPathOnWindows
      if (gnuTar) {
        // Use GNUtar as default on windows
-        return gnuTar
+        return <ArchiveTool>{path: gnuTar, type: ArchiveToolType.GNU}
      } else if (existsSync(systemTar)) {
-        return systemTar
+        return <ArchiveTool>{path: systemTar, type: ArchiveToolType.BSD}
      }
      break
    }
@ -25,30 +30,39 @@ 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
-        return gnuTar
+        return <ArchiveTool>{path: gnuTar, type: ArchiveToolType.GNU}
+      } else {
+        return <ArchiveTool>{
+          path: await io.which('tar', true),
+          type: ArchiveToolType.BSD
+        }
      }
-      break
    }
    default:
      break
  }
-  return await io.which('tar', true)
+  return <ArchiveTool>{
+    path: await io.which('tar', true),
+    type: ArchiveToolType.GNU
+  }
 }

+// Return arguments for tar as per tarPath, compressionMethod, method type and os
 async function getTarArgs(
+  tarPath: ArchiveTool,
  compressionMethod: CompressionMethod,
  type: string,
  archivePath = ''
 ): Promise<string[]> {
-  const args = []
+  const args = [tarPath.path]
  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
+    tarPath.type === ArchiveToolType.BSD &&
+    compressionMethod !== CompressionMethod.Gzip &&
+    IS_WINDOWS

  // Method specific args
  switch (type) {
@ -93,21 +107,13 @@ async function getTarArgs(
  }

  // Platform specific args
+  if (tarPath.type === ArchiveToolType.GNU) {
    switch (process.platform) {
-    case 'win32': {
-      const gnuTar = await utils.getGnuTarPathOnWindows()
-      if (gnuTar) {
-        // Use GNUtar as default on windows
+      case 'win32':
        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
+      case 'darwin':
        args.push('--delay-directory-restore')
-      }
        break
    }
  }
@ -115,23 +121,30 @@ async function getTarArgs(
  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})
-  } catch (error) {
-    throw new Error(`Tar failed with error: ${error?.message}`)
+async function getArgs(
+  compressionMethod: CompressionMethod,
+  type: string,
+  archivePath = ''
+): Promise<string> {
+  const tarPath = await getTarPath()
+  const tarArgs = await getTarArgs(
+    tarPath,
+    compressionMethod,
+    type,
+    archivePath
+  )
+  const compressionArgs =
+    type !== 'create'
+      ? await getDecompressionProgram(tarPath, compressionMethod, archivePath)
+      : await getCompressionProgram(tarPath, compressionMethod)
+  const BSD_TAR_ZSTD =
+    tarPath.type === ArchiveToolType.BSD &&
+    compressionMethod !== CompressionMethod.Gzip &&
+    IS_WINDOWS
+  if (BSD_TAR_ZSTD && type !== 'create') {
+    return [...compressionArgs, ...tarArgs].join(' ')
+  } else {
+    return [...tarArgs, ...compressionArgs].join(' ')
  }
 }

@ -140,7 +153,8 @@ function getWorkingDirectory(): string {
 }

 // Common function for extractTar and listTar to get the compression method
-async function getCompressionProgram(
+async function getDecompressionProgram(
+  tarPath: ArchiveTool,
  compressionMethod: CompressionMethod,
  archivePath: string
 ): Promise<string[]> {
@ -148,11 +162,11 @@ async function getCompressionProgram(
  // 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
+    tarPath.type === ArchiveToolType.BSD &&
+    compressionMethod !== CompressionMethod.Gzip &&
+    IS_WINDOWS
  switch (compressionMethod) {
    case CompressionMethod.Zstd:
      return BSD_TAR_ZSTD
@ -180,86 +194,21 @@ async function getCompressionProgram(
  }
 }

-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)
-  }
-}
-
-export async function extractTar(
-  archivePath: string,
-  compressionMethod: CompressionMethod
-): 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)
-  }
-}
-
-export async function createTar(
-  archiveFolder: string,
-  sourceDirectories: string[],
-  compressionMethod: CompressionMethod
-): Promise<void> {
-  // 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')
-  )
-
 // -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'
 // --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.
 // Long range mode is added to zstd in v1.3.2 release, so we will not use --long in older version of zstd.
-  function getCompressionProgram(): string[] {
+async function getCompressionProgram(
+  tarPath: ArchiveTool,
+  compressionMethod: CompressionMethod
+): Promise<string[]> {
+  const cacheFileName = utils.getCacheFileName(compressionMethod)
+  const tarFile = 'cache.tar'
+  const BSD_TAR_ZSTD =
+    tarPath.type === ArchiveToolType.BSD &&
+    compressionMethod !== CompressionMethod.Gzip &&
+    IS_WINDOWS
  switch (compressionMethod) {
    case CompressionMethod.Zstd:
      return BSD_TAR_ZSTD
@ -286,8 +235,37 @@ export async function createTar(
      return ['-z']
  }
 }
-  const tarArgs = await getTarArgs(compressionMethod, 'create')
-  const compressionArgs = getCompressionProgram()
-  const args = tarArgs.concat(compressionArgs)
-  await execTar(args, archiveFolder)
+
+export async function listTar(
+  archivePath: string,
+  compressionMethod: CompressionMethod
+): Promise<void> {
+  const args = await getArgs(compressionMethod, 'list', archivePath)
+  exec(args)
+}
+
+export async function extractTar(
+  archivePath: string,
+  compressionMethod: CompressionMethod
+): Promise<void> {
+  // Create directory to extract tar into
+  const workingDirectory = getWorkingDirectory()
+  await io.mkdirP(workingDirectory)
+  const args = await getArgs(compressionMethod, 'extract', archivePath)
+  exec(args)
+}
+
+export async function createTar(
+  archiveFolder: string,
+  sourceDirectories: string[],
+  compressionMethod: CompressionMethod
+): Promise<void> {
+  // Write source directories to manifest.txt to avoid command length limits
+  const manifestFilename = 'manifest.txt'
+  writeFileSync(
+    path.join(archiveFolder, manifestFilename),
+    sourceDirectories.join('\n')
+  )
+  const args = await getArgs(compressionMethod, 'create')
+  await exec(args)
 }