feat(core): add runtimeCacheInputs to capture node version, os in the cache key

Author: vsavkin

packages/workspace/src/tasks-runner/hasher.spec.ts

@@ -1,4 +1,5 @@
 import { Hasher } from './hasher';
+
 const hasha = require('hasha');
 const fs = require('fs');
 jest.mock('hasha');
@@ -30,7 +31,10 @@ describe('Hasher', () => {
           proj: []
         }
       },
-      {} as any
+      {} as any,
+      {
+        runtimeCacheInputs: ['echo runtime123', 'echo runtime456']
+      }
     );
 
     const hash = await hasher.hash({
@@ -44,10 +48,39 @@ describe('Hasher', () => {
     expect(hash).toContain('prop-value'); //overrides
     expect(hash).toContain('proj'); //project
     expect(hash).toContain('build'); //target
+    expect(hash).toContain('runtime123'); //target
+    expect(hash).toContain('runtime456'); //target
 
     done();
   });
 
+  it('should throw an error when failed to execute runtimeCacheInputs', async () => {
+    const hasher = new Hasher(
+      {
+        nodes: {},
+        dependencies: {}
+      },
+      {} as any,
+      {
+        runtimeCacheInputs: ['boom']
+      }
+    );
+
+    try {
+      await hasher.hash({
+        target: { project: 'proj', target: 'build' },
+        id: 'proj-build',
+        overrides: {}
+      });
+      fail('Should not be here');
+    } catch (e) {
+      expect(e.message).toContain(
+        'Nx failed to execute runtimeCacheInputs defined in nx.json failed:'
+      );
+      expect(e.message).toContain('boom: not found');
+    }
+  });
+
   it('should hash when circular dependencies', async done => {
     hashes['/filea'] = 'a.hash';
     hashes['/fileb'] = 'b.hash';
@@ -70,7 +103,8 @@ describe('Hasher', () => {
           projb: [{ source: 'projb', target: 'proja', type: 'static' }]
         }
       },
-      {} as any
+      {} as any,
+      {}
     );
 
     const hasha = await hasher.hash({
@@ -119,7 +153,8 @@ describe('Hasher', () => {
         },
         dependencies: {}
       },
-      {} as any
+      {} as any,
+      {}
     );
 
     const hash = await hasher.hash({

packages/workspace/src/tasks-runner/hasher.ts

@@ -3,37 +3,69 @@ import { NxJson } from '../core/shared-interfaces';
 import { Task } from './tasks-runner';
 import { statSync } from 'fs';
 import { rootWorkspaceFileNames } from '../core/file-utils';
+import { execSync } from 'child_process';
 
 const hasha = require('hasha');
 
 export class Hasher {
   static version = '1.0';
   implicitDependencies: Promise<string>;
+  runtimeInputs: Promise<string>;
   fileHashes = new FileHashes();
   projectHashes = new ProjectHashes(this.projectGraph, this.fileHashes);
 
   constructor(
     private readonly projectGraph: ProjectGraph,
-    private readonly nxJson: NxJson
+    private readonly nxJson: NxJson,
+    private readonly options: any
   ) {}
 
   async hash(task: Task): Promise<string> {
-    const hash = await this.projectHashes.hashProject(task.target.project, [
-      task.target.project
+    const args = [
+      task.target.project || '',
+      task.target.target || '',
+      task.target.configuration || '',
+      JSON.stringify(task.overrides)
+    ];
+
+    const values = await Promise.all([
+      this.projectHashes.hashProject(task.target.project, [
+        task.target.project
+      ]),
+      this.implicitDepsHash(),
+      this.runtimeInputsHash()
     ]);
-    const implicits = await this.implicitDepsHash();
-    return hasha(
-      [
-        Hasher.version,
-        task.target.project || '',
-        task.target.target || '',
-        task.target.configuration || '',
-        JSON.stringify(task.overrides),
-        implicits,
-        hash
-      ],
-      { algorithm: 'sha256' }
-    );
+
+    return hasha([Hasher.version, ...args, ...values], { algorithm: 'sha256' });
+  }
+
+  private async runtimeInputsHash() {
+    if (this.runtimeInputs) return this.runtimeInputs;
+
+    const inputs =
+      this.options && this.options.runtimeCacheInputs
+        ? this.options.runtimeCacheInputs
+        : [];
+    if (inputs.length > 0) {
+      try {
+        const values = await Promise.all(
+          inputs.map(async i =>
+            execSync(i)
+              .toString()
+              .trim()
+          )
+        );
+        this.runtimeInputs = hasha(values, { algorithm: 'sha256' });
+      } catch (e) {
+        throw new Error(
+          `Nx failed to execute runtimeCacheInputs defined in nx.json failed:\n${e.message}`
+        );
+      }
+    } else {
+      this.runtimeInputs = Promise.resolve('');
+    }
+
+    return this.runtimeInputs;
   }
 
   private async implicitDepsHash() {

packages/workspace/src/tasks-runner/run-command.ts

@@ -36,7 +36,7 @@ export async function runCommand<T extends RunArgs>(
   );
 
   if (tasksRunner !== require('./default-tasks-runner').defaultTasksRunner) {
-    const hasher = new Hasher(projectGraph, nxJson);
+    const hasher = new Hasher(projectGraph, nxJson, tasksOptions);
     await Promise.all(
       tasks.map(async t => {
         t.hash = await hasher.hash(t);

packages/workspace/src/tasks-runner/tasks-runner-v2.ts

@@ -29,6 +29,7 @@ export interface DefaultTasksRunnerOptions {
   parallel?: boolean;
   maxParallel?: number;
   cacheableOperations?: string[];
+  runtimeCacheInputs?: string[];
   cacheDirectory?: string;
   remoteCache?: RemoteCache;
   lifeCycle?: LifeCycle;