When extracting into a non-empty directory, cache the .zip file

Since the `@actions/cache` functionality has _no_ option to include only
a given set of files (unless that very set of files is known _when
restoring the cache_, not only when saving it), we have no chance of
caching files directly when we write them into non-empty directories.

To work around that, let's special-case non-empty directories, caching
the downloaded `.zip` file instead (and obviously paying the slight
performance penalty of `unzip`ping it in that scenario even when
restoring the cache, which is slower than extracting a `.tgz`).

Signed-off-by: Johannes Schindelin <[email protected]>

Author: dscho

main.ts

@@ -1,7 +1,7 @@
 import * as core from '@actions/core'
-import {get} from './src/downloader'
+import {unzip, get} from './src/downloader'
 import {restoreCache, saveCache} from '@actions/cache'
-import {readdirSync} from 'fs'
+import {readdirSync, unlinkSync} from 'fs'
 
 async function run(): Promise<void> {
   try {
@@ -26,14 +26,23 @@ async function run(): Promise<void> {
       }
     }
 
-    if (useCache && !isDirectoryEmpty(outputDirectory)) {
-      throw new Error(`Directory '${outputDirectory}' not empty`)
-    }
-
     let needToDownload = true
+    let storeZipAs: string | undefined
     if (useCache) {
       try {
-        if (await restoreCache([outputDirectory], cacheId)) {
+        if (!isDirectoryEmpty(outputDirectory)) {
+          storeZipAs = `${outputDirectory}/.${cacheId}.zip`
+          if (await restoreCache([storeZipAs], cacheId)) {
+            await unzip(
+              `file:${storeZipAs}`,
+              stripPrefix,
+              outputDirectory,
+              verbose
+            )
+            core.info(`Cached ${cacheId} was successfully restored`)
+            needToDownload = false
+          }
+        } else if (await restoreCache([outputDirectory], cacheId)) {
           core.info(`Cached ${cacheId} was successfully restored`)
           needToDownload = false
         }
@@ -45,15 +54,22 @@ async function run(): Promise<void> {
 
     if (needToDownload) {
       core.info(`Downloading ${artifactName}`)
-      await download(outputDirectory, verbose)
+      await download(outputDirectory, verbose, storeZipAs)
 
       try {
-        if (useCache && !(await saveCache([outputDirectory], cacheId))) {
+        if (
+          useCache &&
+          !(await saveCache([storeZipAs || outputDirectory], cacheId))
+        ) {
           core.warning(`Failed to cache ${cacheId}`)
         }
       } catch (e) {
         core.warning(`Failed to cache ${cacheId}: ${e.message}`)
       }
+
+      if (storeZipAs) {
+        unlinkSync(storeZipAs)
+      }
     }
   } catch (error) {
     core.setFailed(error.message)

src/downloader.ts

@@ -29,11 +29,12 @@ function mkdirp(directoryPath: string): void {
   fs.mkdirSync(directoryPath, {recursive: true})
 }
 
-async function unzip(
+export async function unzip(
   url: string,
   stripPrefix: string,
   outputDirectory: string,
-  verbose: boolean | number
+  verbose: boolean | number,
+  storeZipAs?: string
 ): Promise<string[]> {
   const files: string[] = []
   let progress =
@@ -64,6 +65,10 @@ async function unzip(
 
   return new Promise<string[]>((resolve, reject) => {
     const callback = (res: Readable): void => {
+      if (storeZipAs) {
+        process.stderr.write(`Writing ${storeZipAs}\n`)
+        res.pipe(fs.createWriteStream(storeZipAs)).on('error', reject)
+      }
       res
         .on('error', reject)
         .pipe(unzipper.Parse())
@@ -88,7 +93,11 @@ async function unzip(
         .on('finish', progress)
         .on('finish', () => resolve(files))
     }
-    https.get(url, callback).on('error', reject)
+    if (url.startsWith('file:')) {
+      callback(fs.createReadStream(url.substring('file:'.length)))
+    } else {
+      https.get(url, callback).on('error', reject)
+    }
   })
 }
 
@@ -103,7 +112,8 @@ export async function get(
   cacheId: string
   download: (
     outputDirectory: string,
-    verbose?: number | boolean
+    verbose?: number | boolean,
+    storeZipAs?: string
   ) => Promise<string[]>
 }> {
   if (!repository || !definitionId) {
@@ -158,7 +168,8 @@ export async function get(
 
   const download = async (
     outputDirectory: string,
-    verbose: number | boolean = false
+    verbose: number | boolean = false,
+    storeZipAs?: string
   ): Promise<string[]> => {
     if (!url) {
       url = await getURL()
@@ -170,7 +181,8 @@ export async function get(
           url,
           stripPrefix || `${artifactName}/`,
           outputDirectory,
-          verbose
+          verbose,
+          storeZipAs
         )
       } catch (e) {
         delayInSeconds *= 2