@lage-run/cli 0.5.7 → 0.6.0

package/CHANGELOG.json

@@ -2,7 +2,40 @@
   "name": "@lage-run/cli",
   "entries": [
     {
-      "date": "Thu, 05 Jan 2023 00:40:39 GMT",
+      "date": "Wed, 18 Jan 2023 18:18:13 GMT",
+      "tag": "@lage-run/cli_v0.6.0",
+      "version": "0.6.0",
+      "comments": {
+        "minor": [
+          {
+            "author": "kchau@microsoft.com",
+            "package": "@lage-run/cli",
+            "commit": "71b5b1452ee25148a637894d1bf99cf1cc6a80a7",
+            "comment": "Using lage for prune and clear on cache and get reporter in shape for ADO"
+          },
+          {
+            "author": "beachball",
+            "package": "@lage-run/cli",
+            "comment": "Bump @lage-run/scheduler to v0.8.0",
+            "commit": "71b5b1452ee25148a637894d1bf99cf1cc6a80a7"
+          },
+          {
+            "author": "beachball",
+            "package": "@lage-run/cli",
+            "comment": "Bump @lage-run/scheduler-types to v0.3.0",
+            "commit": "71b5b1452ee25148a637894d1bf99cf1cc6a80a7"
+          },
+          {
+            "author": "beachball",
+            "package": "@lage-run/cli",
+            "comment": "Bump @lage-run/reporters to v0.3.0",
+            "commit": "71b5b1452ee25148a637894d1bf99cf1cc6a80a7"
+          }
+        ]
+      }
+    },
+    {
+      "date": "Thu, 05 Jan 2023 00:40:50 GMT",
       "tag": "@lage-run/cli_v0.5.7",
       "version": "0.5.7",
       "comments": {

package/CHANGELOG.md

@@ -1,12 +1,23 @@
 # Change Log - @lage-run/cli
 
-This log was last generated on Thu, 05 Jan 2023 00:40:39 GMT and should not be manually modified.
+This log was last generated on Wed, 18 Jan 2023 18:18:13 GMT and should not be manually modified.
 
 <!-- Start content -->
 
+## 0.6.0
+
+Wed, 18 Jan 2023 18:18:13 GMT
+
+### Minor changes
+
+- Using lage for prune and clear on cache and get reporter in shape for ADO (kchau@microsoft.com)
+- Bump @lage-run/scheduler to v0.8.0
+- Bump @lage-run/scheduler-types to v0.3.0
+- Bump @lage-run/reporters to v0.3.0
+
 ## 0.5.7
 
-Thu, 05 Jan 2023 00:40:39 GMT
+Thu, 05 Jan 2023 00:40:50 GMT
 
 ### Patches
 

package/lib/commands/cache/action.js

@@ -22,9 +22,20 @@ async function cacheAction(options, command) {
     const logger = (0, _logger.default)();
     (0, _reporters.initializeReporters)(logger, options);
     if (options.clear) {
-        return await (0, _clearCacheJs.clearCache)(process.cwd(), config.cacheOptions.internalCacheFolder, logger);
+        return await (0, _clearCacheJs.clearCache)({
+            cwd: process.cwd(),
+            internalCacheFolder: config.cacheOptions.internalCacheFolder,
+            logger,
+            concurrency: options.concurrency
+        });
     } else if (options.prune) {
-        return await (0, _pruneCacheJs.pruneCache)(options.prune, process.cwd(), config.cacheOptions.internalCacheFolder, logger);
+        return await (0, _pruneCacheJs.pruneCache)({
+            pruneDays: options.prune,
+            cwd: process.cwd(),
+            internalCacheFolder: config.cacheOptions.internalCacheFolder,
+            logger,
+            concurrency: options.concurrency
+        });
     }
     command.help();
 }

package/lib/commands/cache/clearCache.d.ts

@@ -1,2 +1,8 @@
 import type { Logger } from "@lage-run/logger";
-export declare function clearCache(cwd: string, internalCacheFolder: string, logger: Logger): Promise<void>;
+export interface ClearCacheOptions {
+    cwd: string;
+    internalCacheFolder: string;
+    logger: Logger;
+    concurrency: number;
+}
+export declare function clearCache(options: ClearCacheOptions): Promise<void>;

package/lib/commands/cache/clearCache.js

@@ -7,38 +7,67 @@ Object.defineProperty(exports, "clearCache", {
     get: ()=>clearCache
 });
 const _cacheDirJs = require("./cacheDir.js");
+const _getConfigJs = require("../../config/getConfig.js");
 const _workspaceTools = require("workspace-tools");
-const _promises = require("fs/promises");
-const _fs = /*#__PURE__*/ _interopRequireDefault(require("fs"));
+const _scheduler = require("@lage-run/scheduler");
+const _targetGraph = require("@lage-run/target-graph");
 const _path = /*#__PURE__*/ _interopRequireDefault(require("path"));
+const _getConcurrencyJs = require("../../config/getConcurrency.js");
 function _interopRequireDefault(obj) {
     return obj && obj.__esModule ? obj : {
         default: obj
     };
 }
-async function clearCache(cwd, internalCacheFolder, logger) {
+async function clearCache(options) {
+    const { logger , cwd , internalCacheFolder  } = options;
+    const config = await (0, _getConfigJs.getConfig)(cwd);
     const workspaceRoot = (0, _workspaceTools.getWorkspaceRoot)(cwd);
+    const concurrency = (0, _getConcurrencyJs.getConcurrency)(options.concurrency, config.concurrency);
     if (!workspaceRoot) {
         return;
     }
+    const graphBuilder = new _targetGraph.TargetGraphBuilder();
     const workspaces = (0, _workspaceTools.getWorkspaces)(workspaceRoot);
     for (const workspace of workspaces){
-        logger.info(`clear cache for ${workspace.name}`);
         const cachePath = (0, _cacheDirJs.getCacheDir)(workspace.path, internalCacheFolder);
         const logOutputCachePath = _path.default.join(workspace.path, "node_modules/.cache/lage/output/");
-        await Promise.all([
-            clearPath(cachePath),
-            clearPath(logOutputCachePath)
-        ]);
-    }
-}
-async function clearPath(cachePath) {
-    if (_fs.default.existsSync(cachePath)) {
-        const entries = _fs.default.readdirSync(cachePath);
-        for (const entry of entries){
-            const entryPath = _path.default.join(cachePath, entry);
-            const entryStat = await (0, _promises.stat)(entryPath);
-            await (0, _cacheDirJs.removeCacheEntry)(entryPath, entryStat);
-        }
+        graphBuilder.addTarget({
+            packageName: workspace.name,
+            cwd: workspace.path,
+            dependencies: [],
+            dependents: [],
+            id: `${workspace.name}#clearCache`,
+            label: `Clearing Cache for ${workspace.name}`,
+            task: "clearCache",
+            type: "worker",
+            depSpecs: [],
+            options: {
+                clearPaths: [
+                    cachePath,
+                    logOutputCachePath
+                ]
+            }
+        });
     }
+    const graph = graphBuilder.build();
+    const scheduler = new _scheduler.SimpleScheduler({
+        logger,
+        concurrency,
+        continueOnError: true,
+        shouldCache: false,
+        shouldResetCache: false,
+        maxWorkersPerTask: new Map(),
+        runners: {
+            worker: {
+                script: require.resolve("./runners/ClearCacheRunner.js"),
+                options: {}
+            }
+        },
+        workerIdleMemoryLimit: config.workerIdleMemoryLimit
+    });
+    const summary = await scheduler.run(workspaceRoot, graph);
+    await scheduler.cleanup();
+    logger.reporters.forEach((reporter)=>{
+        reporter.summarize(summary);
+    });
 }

package/lib/commands/cache/pruneCache.d.ts

@@ -1,2 +1,9 @@
 import type { Logger } from "@lage-run/logger";
-export declare function pruneCache(pruneDays: number, cwd: string, internalCacheFolder: string, logger: Logger): Promise<void>;
+export interface PruneCacheOptions {
+    cwd: string;
+    internalCacheFolder: string;
+    logger: Logger;
+    concurrency: number;
+    pruneDays: number;
+}
+export declare function pruneCache(options: PruneCacheOptions): Promise<void>;

package/lib/commands/cache/pruneCache.js

@@ -6,40 +6,72 @@ Object.defineProperty(exports, "pruneCache", {
     enumerable: true,
     get: ()=>pruneCache
 });
-const _promises = require("fs/promises");
-const _fs = /*#__PURE__*/ _interopRequireDefault(require("fs"));
 const _path = /*#__PURE__*/ _interopRequireDefault(require("path"));
 const _cacheDirJs = require("./cacheDir.js");
 const _workspaceTools = require("workspace-tools");
+const _getConfigJs = require("../../config/getConfig.js");
+const _getConcurrencyJs = require("../../config/getConcurrency.js");
+const _targetGraph = require("@lage-run/target-graph");
+const _scheduler = require("@lage-run/scheduler");
 function _interopRequireDefault(obj) {
     return obj && obj.__esModule ? obj : {
         default: obj
     };
 }
-const MS_IN_A_DAY = 1000 * 60 * 60 * 24;
-async function pruneCache(pruneDays, cwd, internalCacheFolder, logger) {
+async function pruneCache(options) {
+    const { logger , cwd , pruneDays , internalCacheFolder  } = options;
+    const config = await (0, _getConfigJs.getConfig)(cwd);
+    const workspaceRoot = (0, _workspaceTools.getWorkspaceRoot)(cwd);
+    const concurrency = (0, _getConcurrencyJs.getConcurrency)(options.concurrency, config.concurrency);
+    if (!workspaceRoot) {
+        return;
+    }
+    const graphBuilder = new _targetGraph.TargetGraphBuilder();
+    const workspaces = (0, _workspaceTools.getWorkspaces)(workspaceRoot);
     const prunePeriod = pruneDays || 30;
     const now = new Date().getTime();
-    const workspaces = (0, _workspaceTools.getWorkspaces)(cwd);
     for (const workspace of workspaces){
-        logger.info(`prune cache for ${workspace.name} older than ${prunePeriod} days`);
         const cachePath = (0, _cacheDirJs.getCacheDir)(workspace.path, internalCacheFolder);
         const logOutputCachePath = _path.default.join(workspace.path, "node_modules/.cache/lage/output/");
-        await Promise.all([
-            prunePath(cachePath, prunePeriod, now),
-            prunePath(logOutputCachePath, prunePeriod, now)
-        ]);
-    }
-}
-async function prunePath(cachePath, days, now) {
-    if (_fs.default.existsSync(cachePath)) {
-        const entries = _fs.default.readdirSync(cachePath);
-        for (const entry of entries){
-            const entryPath = _path.default.join(cachePath, entry);
-            const entryStat = await (0, _promises.stat)(entryPath);
-            if (now - entryStat.mtime.getTime() > days * MS_IN_A_DAY) {
-                await (0, _cacheDirJs.removeCacheEntry)(entryPath, entryStat);
+        graphBuilder.addTarget({
+            packageName: workspace.name,
+            cwd: workspace.path,
+            dependencies: [],
+            dependents: [],
+            id: `${workspace.name}#pruneCache`,
+            label: `Pruning Cache for ${workspace.name}`,
+            task: "pruneCache",
+            type: "worker",
+            depSpecs: [],
+            options: {
+                clearPaths: [
+                    cachePath,
+                    logOutputCachePath
+                ],
+                now,
+                prunePeriod
             }
-        }
+        });
     }
+    const graph = graphBuilder.build();
+    const scheduler = new _scheduler.SimpleScheduler({
+        logger,
+        concurrency,
+        continueOnError: true,
+        shouldCache: false,
+        shouldResetCache: false,
+        maxWorkersPerTask: new Map(),
+        runners: {
+            worker: {
+                script: require.resolve("./runners/PruneCacheRunner.js"),
+                options: {}
+            }
+        },
+        workerIdleMemoryLimit: config.workerIdleMemoryLimit
+    });
+    const summary = await scheduler.run(workspaceRoot, graph);
+    await scheduler.cleanup();
+    logger.reporters.forEach((reporter)=>{
+        reporter.summarize(summary);
+    });
 }

package/lib/commands/cache/runners/ClearCacheRunner.d.ts

@@ -0,0 +1,5 @@
+import type { TargetRunner, TargetRunnerOptions } from "@lage-run/scheduler-types";
+export declare class ClearCacheRunner implements TargetRunner {
+    shouldRun(): Promise<boolean>;
+    run(runOptions: TargetRunnerOptions): Promise<void>;
+}

package/lib/commands/cache/runners/ClearCacheRunner.js

@@ -0,0 +1,36 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "ClearCacheRunner", {
+    enumerable: true,
+    get: ()=>ClearCacheRunner
+});
+const _fs = /*#__PURE__*/ _interopRequireDefault(require("fs"));
+const _path = /*#__PURE__*/ _interopRequireDefault(require("path"));
+const _promises = require("fs/promises");
+const _cacheDirJs = require("../cacheDir.js");
+function _interopRequireDefault(obj) {
+    return obj && obj.__esModule ? obj : {
+        default: obj
+    };
+}
+class ClearCacheRunner {
+    async shouldRun() {
+        return true;
+    }
+    async run(runOptions) {
+        const { target  } = runOptions;
+        const { clearPaths  } = target.options;
+        for (const cachePath of clearPaths){
+            if (_fs.default.existsSync(cachePath)) {
+                const entries = _fs.default.readdirSync(cachePath);
+                for (const entry of entries){
+                    const entryPath = _path.default.join(cachePath, entry);
+                    const entryStat = await (0, _promises.stat)(entryPath);
+                    await (0, _cacheDirJs.removeCacheEntry)(entryPath, entryStat);
+                }
+            }
+        }
+    }
+}

package/lib/commands/cache/runners/PruneCacheRunner.d.ts

@@ -0,0 +1,5 @@
+import type { TargetRunner, TargetRunnerOptions } from "@lage-run/scheduler-types";
+export declare class PruneCacheRunner implements TargetRunner {
+    shouldRun(): Promise<boolean>;
+    run(runOptions: TargetRunnerOptions): Promise<void>;
+}

package/lib/commands/cache/runners/PruneCacheRunner.js

@@ -0,0 +1,39 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "PruneCacheRunner", {
+    enumerable: true,
+    get: ()=>PruneCacheRunner
+});
+const _fs = /*#__PURE__*/ _interopRequireDefault(require("fs"));
+const _path = /*#__PURE__*/ _interopRequireDefault(require("path"));
+const _promises = require("fs/promises");
+const _cacheDirJs = require("../cacheDir.js");
+function _interopRequireDefault(obj) {
+    return obj && obj.__esModule ? obj : {
+        default: obj
+    };
+}
+const MS_IN_A_DAY = 1000 * 60 * 60 * 24;
+class PruneCacheRunner {
+    async shouldRun() {
+        return true;
+    }
+    async run(runOptions) {
+        const { target  } = runOptions;
+        const { clearPaths , prunePeriod , now  } = target.options;
+        for (const cachePath of clearPaths){
+            if (_fs.default.existsSync(cachePath)) {
+                const entries = _fs.default.readdirSync(cachePath);
+                for (const entry of entries){
+                    const entryPath = _path.default.join(cachePath, entry);
+                    const entryStat = await (0, _promises.stat)(entryPath);
+                    if (now - entryStat.mtime.getTime() > prunePeriod * MS_IN_A_DAY) {
+                        await (0, _cacheDirJs.removeCacheEntry)(entryPath, entryStat);
+                    }
+                }
+            }
+        }
+    }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lage-run/cli",
-  "version": "0.5.7",
+  "version": "0.6.0",
   "description": "Command Line Interface for Lage",
   "repository": {
     "url": "https://github.com/microsoft/lage"
@@ -20,11 +20,11 @@
   "dependencies": {
     "@lage-run/find-npm-client": "^0.1.4",
     "@lage-run/logger": "^1.2.2",
-    "@lage-run/scheduler": "^0.7.3",
-    "@lage-run/scheduler-types": "^0.2.10",
+    "@lage-run/scheduler": "^0.8.0",
+    "@lage-run/scheduler-types": "^0.3.0",
     "@lage-run/target-graph": "^0.6.1",
     "@lage-run/cache": "^0.2.3",
-    "@lage-run/reporters": "^0.2.44",
+    "@lage-run/reporters": "^0.3.0",
     "commander": "^9.4.0",
     "workspace-tools": "^0.29.0",
     "chokidar": "3.5.3",