From 75cec40e58036a29c95f7c2f83686be164890ebe Mon Sep 17 00:00:00 2001 From: Daz DeBoer Date: Sat, 30 Oct 2021 07:21:27 -0600 Subject: [PATCH] Rename 'report' classes to 'listener' - `CachingReport` -> `CacheListener` - `CacheEntryReport` -> `CacheEntryListener` --- __tests__/cache-base.test.ts | 72 +++++++++++++++++------------------ src/cache-base.ts | 56 +++++++++++++-------------- src/cache-gradle-user-home.ts | 38 +++++++++--------- src/caches.ts | 16 ++++---- 4 files changed, 93 insertions(+), 89 deletions(-) diff --git a/__tests__/cache-base.test.ts b/__tests__/cache-base.test.ts index 0ae84fb..0b5fb52 100644 --- a/__tests__/cache-base.test.ts +++ b/__tests__/cache-base.test.ts @@ -1,90 +1,90 @@ -import {CacheEntryReport, CachingReport} from '../src/cache-base' +import {CacheEntryListener, CacheListener} from '../src/cache-base' describe('caching report', () => { describe('reports not fully restored', () => { it('with one requested entry report', async () => { - const report = new CachingReport() - report.entryReport('foo').markRequested('1', ['2']) - report.entryReport('bar').markRequested('3').markRestored('4') + const report = new CacheListener() + report.entry('foo').markRequested('1', ['2']) + report.entry('bar').markRequested('3').markRestored('4') expect(report.fullyRestored).toBe(false) }) }) describe('reports fully restored', () => { it('when empty', async () => { - const report = new CachingReport() + const report = new CacheListener() expect(report.fullyRestored).toBe(true) }) it('with empty entry reports', async () => { - const report = new CachingReport() - report.entryReport('foo') - report.entryReport('bar') + const report = new CacheListener() + report.entry('foo') + report.entry('bar') expect(report.fullyRestored).toBe(true) }) it('with restored entry report', async () => { - const report = new CachingReport() - report.entryReport('bar').markRequested('3').markRestored('4') + const report = new CacheListener() + report.entry('bar').markRequested('3').markRestored('4') expect(report.fullyRestored).toBe(true) }) it('with multiple restored entry reportss', async () => { - const report = new CachingReport() - report.entryReport('foo').markRestored('4') - report.entryReport('bar').markRequested('3').markRestored('4') + const report = new CacheListener() + report.entry('foo').markRestored('4') + report.entry('bar').markRequested('3').markRestored('4') expect(report.fullyRestored).toBe(true) }) }) describe('can be stringified and rehydrated', () => { it('when empty', async () => { - const report = new CachingReport() + const report = new CacheListener() const stringRep = report.stringify() - const reportClone: CachingReport = CachingReport.rehydrate(stringRep) + const reportClone: CacheListener = CacheListener.rehydrate(stringRep) - expect(reportClone.cacheEntryReports).toEqual([]) + expect(reportClone.cacheEntries).toEqual([]) // Can call methods on rehydrated - expect(reportClone.entryReport('foo')).toBeInstanceOf(CacheEntryReport) + expect(reportClone.entry('foo')).toBeInstanceOf(CacheEntryListener) }) it('with entry reports', async () => { - const report = new CachingReport() - report.entryReport('foo') - report.entryReport('bar') - report.entryReport('baz') + const report = new CacheListener() + report.entry('foo') + report.entry('bar') + report.entry('baz') const stringRep = report.stringify() - const reportClone: CachingReport = CachingReport.rehydrate(stringRep) + const reportClone: CacheListener = CacheListener.rehydrate(stringRep) - expect(reportClone.cacheEntryReports.length).toBe(3) - expect(reportClone.cacheEntryReports[0].entryName).toBe('foo') - expect(reportClone.cacheEntryReports[1].entryName).toBe('bar') - expect(reportClone.cacheEntryReports[2].entryName).toBe('baz') + expect(reportClone.cacheEntries.length).toBe(3) + expect(reportClone.cacheEntries[0].entryName).toBe('foo') + expect(reportClone.cacheEntries[1].entryName).toBe('bar') + expect(reportClone.cacheEntries[2].entryName).toBe('baz') - expect(reportClone.entryReport('foo')).toBe(reportClone.cacheEntryReports[0]) + expect(reportClone.entry('foo')).toBe(reportClone.cacheEntries[0]) }) it('with rehydrated entry report', async () => { - const report = new CachingReport() - const entryReport = report.entryReport('foo') + const report = new CacheListener() + const entryReport = report.entry('foo') entryReport.markRequested('1', ['2', '3']) entryReport.markSaved('4') const stringRep = report.stringify() - const reportClone: CachingReport = CachingReport.rehydrate(stringRep) - const entryClone = reportClone.entryReport('foo') + const reportClone: CacheListener = CacheListener.rehydrate(stringRep) + const entryClone = reportClone.entry('foo') expect(entryClone.requestedKey).toBe('1') expect(entryClone.requestedRestoreKeys).toEqual(['2', '3']) expect(entryClone.savedKey).toBe('4') }) it('with live entry report', async () => { - const report = new CachingReport() - const entryReport = report.entryReport('foo') + const report = new CacheListener() + const entryReport = report.entry('foo') entryReport.markRequested('1', ['2', '3']) const stringRep = report.stringify() - const reportClone: CachingReport = CachingReport.rehydrate(stringRep) - const entryClone = reportClone.entryReport('foo') + const reportClone: CacheListener = CacheListener.rehydrate(stringRep) + const entryClone = reportClone.entry('foo') // Check type and call method on rehydrated entry report - expect(entryClone).toBeInstanceOf(CacheEntryReport) + expect(entryClone).toBeInstanceOf(CacheEntryListener) entryClone.markSaved('4') expect(entryClone.requestedKey).toBe('1') diff --git a/src/cache-base.ts b/src/cache-base.ts index dc4a53b..efee35b 100644 --- a/src/cache-base.ts +++ b/src/cache-base.ts @@ -40,41 +40,41 @@ class CacheKey { } } -export class CachingReport { - cacheEntryReports: CacheEntryReport[] = [] +export class CacheListener { + cacheEntries: CacheEntryListener[] = [] get fullyRestored(): boolean { - return this.cacheEntryReports.every(x => !x.wasRequestedButNotRestored()) + return this.cacheEntries.every(x => !x.wasRequestedButNotRestored()) } - entryReport(name: string): CacheEntryReport { - for (const report of this.cacheEntryReports) { - if (report.entryName === name) { - return report + entry(name: string): CacheEntryListener { + for (const entry of this.cacheEntries) { + if (entry.entryName === name) { + return entry } } - const newReport = new CacheEntryReport(name) - this.cacheEntryReports.push(newReport) - return newReport + const newEntry = new CacheEntryListener(name) + this.cacheEntries.push(newEntry) + return newEntry } stringify(): string { return JSON.stringify(this) } - static rehydrate(stringRep: string): CachingReport { - const rehydrated: CachingReport = Object.assign(new CachingReport(), JSON.parse(stringRep)) - const entryReports = rehydrated.cacheEntryReports - for (let index = 0; index < entryReports.length; index++) { - const rawEntryReport = entryReports[index] - entryReports[index] = Object.assign(new CacheEntryReport(rawEntryReport.entryName), rawEntryReport) + static rehydrate(stringRep: string): CacheListener { + const rehydrated: CacheListener = Object.assign(new CacheListener(), JSON.parse(stringRep)) + const entries = rehydrated.cacheEntries + for (let index = 0; index < entries.length; index++) { + const rawEntry = entries[index] + entries[index] = Object.assign(new CacheEntryListener(rawEntry.entryName), rawEntry) } return rehydrated } } -export class CacheEntryReport { +export class CacheEntryListener { entryName: string requestedKey: string | undefined requestedRestoreKeys: string[] | undefined @@ -92,18 +92,18 @@ export class CacheEntryReport { return this.requestedKey !== undefined && this.restoredKey === undefined } - markRequested(key: string, restoreKeys: string[] = []): CacheEntryReport { + markRequested(key: string, restoreKeys: string[] = []): CacheEntryListener { this.requestedKey = key this.requestedRestoreKeys = restoreKeys return this } - markRestored(key: string): CacheEntryReport { + markRestored(key: string): CacheEntryListener { this.restoredKey = key return this } - markSaved(key: string): CacheEntryReport { + markSaved(key: string): CacheEntryListener { this.savedKey = key return this } @@ -125,14 +125,14 @@ export abstract class AbstractCache { this.cacheDebuggingEnabled = isCacheDebuggingEnabled() } - async restore(report: CachingReport): Promise { + async restore(listener: CacheListener): Promise { if (this.cacheOutputExists()) { core.info(`${this.cacheDescription} already exists. Not restoring from cache.`) return } const cacheKey = this.prepareCacheKey() - const entryReport = report.entryReport(this.cacheName) + const entryReport = listener.entry(this.cacheName) entryReport.markRequested(cacheKey.key, cacheKey.restoreKeys) this.debug( @@ -153,7 +153,7 @@ export abstract class AbstractCache { core.info(`Restored ${this.cacheDescription} from cache key: ${cacheResult}`) try { - await this.afterRestore(report) + await this.afterRestore(listener) } catch (error) { core.warning(`Restore ${this.cacheDescription} failed in 'afterRestore': ${error}`) } @@ -184,9 +184,9 @@ export abstract class AbstractCache { } } - protected async afterRestore(_report: CachingReport): Promise {} + protected async afterRestore(_listener: CacheListener): Promise {} - async save(report: CachingReport): Promise { + async save(listener: CacheListener): Promise { if (!this.cacheOutputExists()) { this.debug(`No ${this.cacheDescription} to cache.`) return @@ -206,7 +206,7 @@ export abstract class AbstractCache { } try { - await this.beforeSave(report) + await this.beforeSave(listener) } catch (error) { core.warning(`Save ${this.cacheDescription} failed in 'beforeSave': ${error}`) return @@ -216,12 +216,12 @@ export abstract class AbstractCache { const cachePath = this.getCachePath() await this.saveCache(cachePath, cacheKey) - report.entryReport(this.cacheName).markSaved(cacheKey) + listener.entry(this.cacheName).markSaved(cacheKey) return } - protected async beforeSave(_report: CachingReport): Promise {} + protected async beforeSave(_listener: CacheListener): Promise {} protected async saveCache(cachePath: string[], cacheKey: string): Promise { try { diff --git a/src/cache-gradle-user-home.ts b/src/cache-gradle-user-home.ts index 115a32a..fe68dfb 100644 --- a/src/cache-gradle-user-home.ts +++ b/src/cache-gradle-user-home.ts @@ -5,7 +5,7 @@ import * as core from '@actions/core' import * as glob from '@actions/glob' import * as exec from '@actions/exec' -import {AbstractCache, CacheEntryReport, CachingReport} from './cache-base' +import {AbstractCache, CacheEntryListener, CacheListener} from './cache-base' import {getCacheKeyPrefix, hashFileNames, tryDelete} from './cache-utils' const META_FILE_DIR = '.gradle-build-action' @@ -22,13 +22,13 @@ export class GradleUserHomeCache extends AbstractCache { this.gradleUserHome = this.determineGradleUserHome(rootDir) } - async afterRestore(report: CachingReport): Promise { + async afterRestore(listener: CacheListener): Promise { await this.reportGradleUserHomeSize('as restored from cache') - await this.restoreArtifactBundles(report) + await this.restoreArtifactBundles(listener) await this.reportGradleUserHomeSize('after restoring common artifacts') } - private async restoreArtifactBundles(report: CachingReport): Promise { + private async restoreArtifactBundles(listener: CacheListener): Promise { const processes: Promise[] = [] const bundleMetaFiles = await this.getBundleMetaFiles() @@ -37,16 +37,16 @@ export class GradleUserHomeCache extends AbstractCache { // Iterate over all bundle meta files and try to restore for (const bundleMetaFile of bundleMetaFiles) { const bundle = path.basename(bundleMetaFile, '.cache') - const bundleEntryReport = report.entryReport(bundle) + const entryListener = listener.entry(bundle) const bundlePattern = bundlePatterns.get(bundle) // Handle case where the 'artifactBundlePatterns' have been changed if (bundlePattern === undefined) { core.info(`Found bundle metafile for ${bundle} but no such bundle defined`) - bundleEntryReport.markRequested('BUNDLE_NOT_CONFIGURED') + entryListener.markRequested('BUNDLE_NOT_CONFIGURED') tryDelete(bundleMetaFile) } else { - const p = this.restoreArtifactBundle(bundle, bundlePattern, bundleMetaFile, bundleEntryReport) + const p = this.restoreArtifactBundle(bundle, bundlePattern, bundleMetaFile, entryListener) // Run sequentially when debugging enabled if (this.cacheDebuggingEnabled) { await p @@ -62,15 +62,15 @@ export class GradleUserHomeCache extends AbstractCache { bundle: string, bundlePattern: string, bundleMetaFile: string, - report: CacheEntryReport + listener: CacheEntryListener ): Promise { const cacheKey = fs.readFileSync(bundleMetaFile, 'utf-8').trim() - report.markRequested(cacheKey) + listener.markRequested(cacheKey) const restoredKey = await this.restoreCache([bundlePattern], cacheKey) if (restoredKey) { core.info(`Restored ${bundle} with key ${cacheKey} to ${bundlePattern}`) - report.markRestored(restoredKey) + listener.markRestored(restoredKey) } else { core.info(`Did not restore ${bundle} with key ${cacheKey} to ${bundlePattern}`) tryDelete(bundleMetaFile) @@ -88,10 +88,10 @@ export class GradleUserHomeCache extends AbstractCache { return bundleFiles } - async beforeSave(report: CachingReport): Promise { + async beforeSave(listener: CacheListener): Promise { await this.reportGradleUserHomeSize('before saving common artifacts') this.removeExcludedPaths() - await this.saveArtifactBundles(report) + await this.saveArtifactBundles(listener) await this.reportGradleUserHomeSize( "after saving common artifacts (only 'caches' and 'notifications' will be stored)" ) @@ -107,12 +107,12 @@ export class GradleUserHomeCache extends AbstractCache { } } - private async saveArtifactBundles(report: CachingReport): Promise { + private async saveArtifactBundles(listener: CacheListener): Promise { const processes: Promise[] = [] for (const [bundle, pattern] of this.getArtifactBundles()) { - const bundleEntryReport = report.entryReport(bundle) + const entryListener = listener.entry(bundle) - const p = this.saveArtifactBundle(bundle, pattern, bundleEntryReport) + const p = this.saveArtifactBundle(bundle, pattern, entryListener) // Run sequentially when debugging enabled if (this.cacheDebuggingEnabled) { await p @@ -123,7 +123,11 @@ export class GradleUserHomeCache extends AbstractCache { await Promise.all(processes) } - private async saveArtifactBundle(bundle: string, artifactPath: string, report: CacheEntryReport): Promise { + private async saveArtifactBundle( + bundle: string, + artifactPath: string, + listener: CacheEntryListener + ): Promise { const bundleMetaFile = this.getBundleMetaFile(bundle) const globber = await glob.create(artifactPath, { @@ -152,7 +156,7 @@ export class GradleUserHomeCache extends AbstractCache { core.info(`Caching ${bundle} with cache key: ${cacheKey}`) await this.saveCache([artifactPath], cacheKey) this.writeBundleMetaFile(bundleMetaFile, cacheKey) - report.markSaved(cacheKey) + listener.markSaved(cacheKey) } for (const file of bundleFiles) { diff --git a/src/caches.ts b/src/caches.ts index 555e673..8eb9200 100644 --- a/src/caches.ts +++ b/src/caches.ts @@ -2,7 +2,7 @@ import {GradleUserHomeCache} from './cache-gradle-user-home' import {ProjectDotGradleCache} from './cache-project-dot-gradle' import * as core from '@actions/core' import {isCacheDisabled, isCacheReadOnly} from './cache-utils' -import {CachingReport} from './cache-base' +import {CacheListener} from './cache-base' const BUILD_ROOT_DIR = 'BUILD_ROOT_DIR' const CACHING_REPORT = 'CACHING_REPORT' @@ -16,20 +16,20 @@ export async function restore(buildRootDirectory: string): Promise { await core.group('Restore Gradle state from cache', async () => { core.saveState(BUILD_ROOT_DIR, buildRootDirectory) - const cachingReport = new CachingReport() - await new GradleUserHomeCache(buildRootDirectory).restore(cachingReport) + const cacheListener = new CacheListener() + await new GradleUserHomeCache(buildRootDirectory).restore(cacheListener) const projectDotGradleCache = new ProjectDotGradleCache(buildRootDirectory) - if (cachingReport.fullyRestored) { + if (cacheListener.fullyRestored) { // Only restore the configuration-cache if the Gradle Home is fully restored - await projectDotGradleCache.restore(cachingReport) + await projectDotGradleCache.restore(cacheListener) } else { // Otherwise, prepare the cache key for later save() core.info('Gradle Home cache not fully restored: not restoring configuration-cache state') projectDotGradleCache.prepareCacheKey() } - core.saveState(CACHING_REPORT, cachingReport.stringify()) + core.saveState(CACHING_REPORT, cacheListener.stringify()) }) } @@ -39,7 +39,7 @@ export async function save(): Promise { return } - const cachingReport: CachingReport = CachingReport.rehydrate(core.getState(CACHING_REPORT)) + const cachingReport: CacheListener = CacheListener.rehydrate(core.getState(CACHING_REPORT)) await core.group('Caching Gradle state', async () => { const buildRootDirectory = core.getState(BUILD_ROOT_DIR) @@ -52,6 +52,6 @@ export async function save(): Promise { logCachingReport(cachingReport) } -function logCachingReport(report: CachingReport): void { +function logCachingReport(report: CacheListener): void { core.info(JSON.stringify(report, null, 2)) }