Rename from refresh to invalidate

Author: RubenEschauzier

README.md

@@ -68,7 +68,7 @@ Options:
   --outputRaw    Destination for the raw JSON output file                 [string]
   --metadata     Load query metadata files (*.metadata.json) and enable
                  sequence aggregation                   [boolean] [default: false]
-  --refreshAfterQuerySet  Send a cache refresh request after each query set
+  --invalidateCacheAfterQuerySet  Send a cache invalidation request after each query set
                  execution                              [boolean] [default: false]
   --timeout      Timeout value in seconds to use for individual queries [number]
   ----help
@@ -126,8 +126,8 @@ async function executeQueries(pathToQueries, pathToOutputCsv) {
 
 To enable sequence metadata from the CLI, add `--metadata`. Raw JSON output is
 only written when `--outputRaw` is provided, or automatically to
-`./output-raw.json` when `--metadata` is enabled. Cache refresh requests are
-disabled by default and can be enabled with `--refreshAfterQuerySet`.
+`./output-raw.json` when `--metadata` is enabled. Cache invalidation requests are
+disabled by default and can be enabled with `--invalidateCacheAfterQuerySet`.
 
 ## Docker
 

bin/sparql-benchmark-runner.ts

@@ -79,10 +79,10 @@ async function main(): Promise<void> {
         default: false,
         description: 'Load query metadata files (*.metadata.json) and enable sequence aggregation',
       },
-      refreshAfterQuerySet: {
+      invalidateCacheAfterQuerySet: {
         type: 'boolean',
         default: false,
-        description: 'Send a cache refresh request after each query set execution',
+        description: 'Send a cache invalidation request after each query set execution',
       },
 
       timeout: {
@@ -107,7 +107,7 @@ async function main(): Promise<void> {
     timeout: args.timeout,
     availabilityCheckTimeout: 1_000,
     logger,
-    resetCacheBetweenSetExecutions: args.refreshAfterQuerySet,
+    invalidateCacheBetweenSetExecutions: args.invalidateCacheAfterQuerySet,
   });
 
   const results: IRunResult = await runner.run();

lib/SparqlBenchmarkRunner.ts

@@ -23,7 +23,7 @@ export class SparqlBenchmarkRunner {
   protected readonly logger?: (message: string) => void;
   protected readonly resultAggregator: IResultAggregator;
   protected readonly availabilityCheckTimeout: number;
-  protected readonly sendResetSignalBetweenQuerySets: boolean;
+  protected readonly invalidateCacheBetweenSetExecutions: boolean;
   public readonly endpointFetcher: SparqlEndpointFetcher;
 
   public constructor(options: ISparqlBenchmarkRunnerArgs) {
@@ -39,7 +39,7 @@ export class SparqlBenchmarkRunner {
     this.requestDelay = options.requestDelay;
     this.bindingsHashAlgorithm = 'md5';
     this.availabilityCheckTimeout = options.availabilityCheckTimeout ?? 10_000;
-    this.sendResetSignalBetweenQuerySets = options.resetCacheBetweenSetExecutions ?? false;
+    this.invalidateCacheBetweenSetExecutions = options.invalidateCacheBetweenSetExecutions ?? false;
     this.endpointFetcher = new SparqlEndpointFetcher({
       additionalUrlParams: options.additionalUrlParams,
       timeout: options.timeout,
@@ -132,14 +132,14 @@ export class SparqlBenchmarkRunner {
         }
 
         // Trigger the worker restart after completing the query set execution
-        if (this.sendResetSignalBetweenQuerySets) {
-          this.log(`Sending cache refresh signal to trigger worker restart.`);
+        if (this.invalidateCacheBetweenSetExecutions) {
+          this.log(`Sending cache invalidation signal to trigger worker restart.`);
           try {
-            const refreshHeaders = new Headers();
-            refreshHeaders.set('x-comunica-refresh-cache', 'true');
+            const invalidationHeaders = new Headers();
+            invalidationHeaders.set('x-comunica-refresh-cache', 'true');
             await fetch(this.endpoint, {
               method: 'GET',
-              headers: refreshHeaders,
+              headers: invalidationHeaders,
             });
           } catch {
             // Suppress error: The server terminates the connection forcefully during shutdown.
@@ -351,7 +351,7 @@ export interface ISparqlBenchmarkRunnerArgs {
   /**
    * If the engine should reset the cache between executions
    */
-  resetCacheBetweenSetExecutions?: boolean;
+  invalidateCacheBetweenSetExecutions?: boolean;
   /**
    * The delay between subsequent requests sent to the server.
    */

test/SparqlBenchmarkRunner-test.ts

@@ -468,21 +468,21 @@ describe('SparqlBenchmarkRunner', () => {
       expect(results[4]).not.toHaveProperty('template');
     });
 
-    it('sends cache refresh requests only when enabled', async() => {
+    it('sends cache invalidation requests only when enabled', async() => {
       runner = new SparqlBenchmarkRunner({
         endpoint,
         querySets,
         replication,
         warmup,
         logger,
-        resetCacheBetweenSetExecutions: true,
+        invalidateCacheBetweenSetExecutions: true,
       });
 
       await runner.executeAllQueries(replication, false);
 
       const queryExecutions = replication * Object.values(querySets).flatMap(qs => qs).length;
-      const refreshExecutions = replication * Object.keys(querySets).length;
-      expect(fetch).toHaveBeenCalledTimes(queryExecutions + refreshExecutions);
+      const invalidateExecutions = replication * Object.keys(querySets).length;
+      expect(fetch).toHaveBeenCalledTimes(queryExecutions + invalidateExecutions);
       const lastCall = jest.mocked(fetch).mock.calls.at(-1);
       expect(lastCall?.[0]).toBe(endpoint);
       expect(lastCall?.[1]).toMatchObject({ method: 'GET' });