skip

Author: satackey

main.ts

@@ -1,13 +1,17 @@
 import * as core from '@actions/core'
 
 import { LayerCache } from './src/LayerCache'
+
 const main = async () => {
-  const repotag = core.getInput('repotag', { required: true })
-  const key = core.getInput('key', { required: true })
+  const repotag = core.getInput(`repotag`, { required: true })
+  const primaryKey = core.getInput(`key`, { required: true })
+  const restoreKeys = core.getInput(`restore-keys`, { required: false }).split(`\n`).filter(key => key !== ``)
 
   const layerCache = new LayerCache(repotag)
-  await layerCache.restore(key)
+  const restoredKey = await layerCache.restore(primaryKey, restoreKeys)
   await layerCache.cleanUp()
+
+  core.saveState(`exists-primary-key`, primaryKey === restoredKey)
 }
 
 main().catch(e => {

post.ts

@@ -3,10 +3,15 @@ import * as core from '@actions/core'
 import { LayerCache } from './src/LayerCache'
 const main = async () => {
   const repotag = core.getInput('repotag', { required: true })
-  const key = core.getInput('key', { required: true })
+  const primaryKey = core.getInput('key', { required: true })
+
+  if (JSON.parse(core.getState(`exists-primary-key`)) === true) {
+    core.info(`Key ${primaryKey} already exists, aborting.`)
+    return
+  }
 
   const layerCache = new LayerCache(repotag)
-  await layerCache.store(key)
+  await layerCache.store(primaryKey)
   await layerCache.cleanUp()
 }
 

src/LayerCache.ts

@@ -136,32 +136,32 @@ class LayerCache {
   async restore(key: string, restoreKeys?: string[]) {
     this.originalKeyToStore = key
     // const restoreKeysIncludedRootKey = [key, ...(restoreKeys !== undefined ? restoreKeys : [])]
-    const hasRestoredRootCache = await this.restoreRoot(restoreKeys)
-    if (!hasRestoredRootCache) {
+    const restoredCacheKey = await this.restoreRoot(restoreKeys)
+    if (restoredCacheKey === undefined) {
       core.info(`Root cache could not be found. aborting.`)
-      return false
+      return undefined
     }
     if (this.enabledParallel) {
       const hasRestoredAllLayers = await this.restoreLayers()
       if (!hasRestoredAllLayers) {
         core.info(`Some layer cache could not be found. aborting.`)
-        return false
+        return undefined
       }
       await this.joinAllLayerCaches()
     }
     await this.loadImageFromUnpacked()
-    return true
+    return restoredCacheKey
   }
 
-  private async restoreRoot(restoreKeys?: string[]): Promise<boolean> {
+  private async restoreRoot(restoreKeys?: string[]): Promise<string | undefined> {
     core.debug(`Trying to restore root cache, ID: ${this.getRootKey()}, dir: ${this.getUnpackedTarDir()}`)
     const restoredCacheKeyMayUndefined = await cache.restoreCache([this.getUnpackedTarDir()], this.getRootKey(), restoreKeys)
     core.debug(`restoredCacheKeyMayUndefined: ${restoredCacheKeyMayUndefined}`)
     if (restoredCacheKeyMayUndefined === undefined) {
-      return false
+      return undefined
     }
     this.originalKeyToStore = restoredCacheKeyMayUndefined.replace(/-root$/, '')
-    return true
+    return this.originalKeyToStore
   }
 
   private async restoreLayers() {