@lage-run/scheduler 0.5.9 → 0.5.11

package/CHANGELOG.json

@@ -2,7 +2,67 @@
   "name": "@lage-run/scheduler",
   "entries": [
     {
-      "date": "Wed, 02 Nov 2022 20:44:52 GMT",
+      "date": "Thu, 10 Nov 2022 20:20:28 GMT",
+      "tag": "@lage-run/scheduler_v0.5.11",
+      "version": "0.5.11",
+      "comments": {
+        "patch": [
+          {
+            "author": "kchau@microsoft.com",
+            "package": "@lage-run/scheduler",
+            "commit": "b1a42cb963a5fc680e4c59b1e705acbc964f0804",
+            "comment": "update api from targetgraphbuilder"
+          },
+          {
+            "author": "ken@gizzar.com",
+            "package": "@lage-run/scheduler",
+            "commit": "b1a42cb963a5fc680e4c59b1e705acbc964f0804",
+            "comment": "making swc the transpiler of choice"
+          },
+          {
+            "author": "kchau@microsoft.com",
+            "package": "@lage-run/scheduler",
+            "commit": "b1a42cb963a5fc680e4c59b1e705acbc964f0804",
+            "comment": "fixing real imports with rollup as well as getting rid of getPackageAndTask implementation details"
+          },
+          {
+            "author": "beachball",
+            "package": "@lage-run/scheduler",
+            "comment": "Bump @lage-run/target-graph to v0.6.0",
+            "commit": "b1a42cb963a5fc680e4c59b1e705acbc964f0804"
+          },
+          {
+            "author": "beachball",
+            "package": "@lage-run/scheduler",
+            "comment": "Bump @lage-run/cache to v0.2.1",
+            "commit": "b1a42cb963a5fc680e4c59b1e705acbc964f0804"
+          },
+          {
+            "author": "beachball",
+            "package": "@lage-run/scheduler",
+            "comment": "Bump @lage-run/scheduler-types to v0.2.7",
+            "commit": "b1a42cb963a5fc680e4c59b1e705acbc964f0804"
+          }
+        ]
+      }
+    },
+    {
+      "date": "Fri, 04 Nov 2022 21:14:01 GMT",
+      "tag": "@lage-run/scheduler_v0.5.10",
+      "version": "0.5.10",
+      "comments": {
+        "patch": [
+          {
+            "author": "kchau@microsoft.com",
+            "package": "@lage-run/scheduler",
+            "commit": "6dba6df4c699c92ca201e91301dfa4aac6344902",
+            "comment": "fixed the tsconfig.lage2.json to output node16 moduleRes"
+          }
+        ]
+      }
+    },
+    {
+      "date": "Wed, 02 Nov 2022 20:45:00 GMT",
       "tag": "@lage-run/scheduler_v0.5.9",
       "version": "0.5.9",
       "comments": {

package/CHANGELOG.md

@@ -1,12 +1,33 @@
 # Change Log - @lage-run/scheduler
 
-This log was last generated on Wed, 02 Nov 2022 20:44:52 GMT and should not be manually modified.
+This log was last generated on Thu, 10 Nov 2022 20:20:28 GMT and should not be manually modified.
 
 <!-- Start content -->
 
+## 0.5.11
+
+Thu, 10 Nov 2022 20:20:28 GMT
+
+### Patches
+
+- update api from targetgraphbuilder (kchau@microsoft.com)
+- making swc the transpiler of choice (ken@gizzar.com)
+- fixing real imports with rollup as well as getting rid of getPackageAndTask implementation details (kchau@microsoft.com)
+- Bump @lage-run/target-graph to v0.6.0
+- Bump @lage-run/cache to v0.2.1
+- Bump @lage-run/scheduler-types to v0.2.7
+
+## 0.5.10
+
+Fri, 04 Nov 2022 21:14:01 GMT
+
+### Patches
+
+- fixed the tsconfig.lage2.json to output node16 moduleRes (kchau@microsoft.com)
+
 ## 0.5.9
 
-Wed, 02 Nov 2022 20:44:52 GMT
+Wed, 02 Nov 2022 20:45:00 GMT
 
 ### Patches
 

package/lib/SimpleScheduler.d.ts

@@ -38,7 +38,6 @@ export declare class SimpleScheduler implements TargetScheduler {
     targetsByPriority: Target[];
     abortController: AbortController;
     abortSignal: AbortSignal;
-    dependencies: [string, string][];
     pool: Pool;
     runPromise: Promise<any>;
     constructor(options: SimpleSchedulerOptions);

package/lib/SimpleScheduler.js

@@ -1,69 +1,36 @@
 "use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.SimpleScheduler = void 0;
-const categorizeTargetRuns_js_1 = require("./categorizeTargetRuns.js");
-const target_graph_1 = require("@lage-run/target-graph");
-const WrappedTarget_js_1 = require("./WrappedTarget.js");
-const worker_threads_pool_1 = require("@lage-run/worker-threads-pool");
-const formatBytes_js_1 = require("./formatBytes.js");
-/**
- * Simple scheduler that runs all targets in a promise graph using p-graph library.
- *
- * Some characteristics:
- * 1. Can cache results of target runs via the cache provider.
- * 2. Takes a TargetRunner, a CacheProvider, a TargetHasher and a Logger as constructor parameters (dependency injection).
- * 3. Directly constructs new WrappedTarget, which provides the call to caching and logging.
- *
- * Roadmap / future enhancements:
- * 1. Allow for multiple kinds of runner (currently only ONE is supported, and it is applied to all targets)
- *
- */
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "SimpleScheduler", {
+    enumerable: true,
+    get: ()=>SimpleScheduler
+});
+const _categorizeTargetRunsJs = require("./categorizeTargetRuns.js");
+const _targetGraph = require("@lage-run/target-graph");
+const _wrappedTargetJs = require("./WrappedTarget.js");
+const _workerThreadsPool = require("@lage-run/worker-threads-pool");
+const _formatBytesJs = require("./formatBytes.js");
 class SimpleScheduler {
-    constructor(options) {
-        var _a;
-        this.options = options;
-        this.targetRuns = new Map();
-        this.targetsByPriority = [];
-        this.abortController = new AbortController();
-        this.abortSignal = this.abortController.signal;
-        this.dependencies = [];
-        this.runPromise = Promise.resolve();
-        this.pool =
-            (_a = options.pool) !== null && _a !== void 0 ? _a : new worker_threads_pool_1.AggregatedPool({
-                logger: options.logger,
-                maxWorkersByGroup: options.maxWorkersPerTask,
-                groupBy: ({ target }) => target.task,
-                maxWorkers: options.concurrency,
-                script: require.resolve("./workers/targetWorker"),
-                workerOptions: {
-                    stdout: true,
-                    stderr: true,
-                    workerData: {
-                        runners: options.runners,
-                    },
-                },
-                workerIdleMemoryLimit: options.workerIdleMemoryLimit, // in bytes
-            });
-    }
     /**
-     * The job of the run method is to:
-     * 1. Convert the target graph into a promise graph.
-     * 2. Create a promise graph of all targets
-     * 3. Pass the continueOnError option to the promise graph runner.
-     *
-     * @param root
-     * @param targetGraph
-     * @returns
-     */
-    async run(root, targetGraph) {
+   * The job of the run method is to:
+   * 1. Convert the target graph into a promise graph.
+   * 2. Create a promise graph of all targets
+   * 3. Pass the continueOnError option to the promise graph runner.
+   *
+   * @param root
+   * @param targetGraph
+   * @returns
+   */ async run(root, targetGraph) {
         const startTime = process.hrtime();
-        const { continueOnError, logger, cacheProvider, shouldCache, shouldResetCache, hasher } = this.options;
-        const { pool, abortController } = this;
-        const { dependencies, targets } = targetGraph;
-        this.dependencies = dependencies;
-        this.targetsByPriority = (0, target_graph_1.sortTargetsByPriority)([...targets.values()]);
-        for (const target of targets.values()) {
-            const targetRun = new WrappedTarget_js_1.WrappedTarget({
+        const { continueOnError , logger , cacheProvider , shouldCache , shouldResetCache , hasher  } = this.options;
+        const { pool , abortController  } = this;
+        const { targets  } = targetGraph;
+        this.targetsByPriority = (0, _targetGraph.sortTargetsByPriority)([
+            ...targets.values()
+        ]);
+        for (const target of targets.values()){
+            const targetRun = new _wrappedTargetJs.WrappedTarget({
                 target,
                 root,
                 logger,
@@ -73,31 +40,30 @@ class SimpleScheduler {
                 shouldResetCache,
                 continueOnError,
                 abortController,
-                pool,
+                pool
             });
-            if (target.id === (0, target_graph_1.getStartTargetId)()) {
+            if (target.id === (0, _targetGraph.getStartTargetId)()) {
                 targetRun.status = "success";
             }
             this.targetRuns.set(target.id, targetRun);
         }
         let results = "failed";
         let error;
-        let duration = [0, 0];
+        let duration = [
+            0,
+            0
+        ];
         let targetRunByStatus;
         try {
             await this.scheduleReadyTargets();
-        }
-        catch (e) {
+        } catch (e) {
             error = e instanceof Error ? e.message : String(e);
-        }
-        finally {
+        } finally{
             duration = process.hrtime(startTime);
-            targetRunByStatus = (0, categorizeTargetRuns_js_1.categorizeTargetRuns)([...this.targetRuns.values()]);
-            if (targetRunByStatus.failed.length +
-                targetRunByStatus.aborted.length +
-                targetRunByStatus.pending.length +
-                targetRunByStatus.running.length ===
-                0) {
+            targetRunByStatus = (0, _categorizeTargetRunsJs.categorizeTargetRuns)([
+                ...this.targetRuns.values()
+            ]);
+            if (targetRunByStatus.failed.length + targetRunByStatus.aborted.length + targetRunByStatus.pending.length + targetRunByStatus.running.length === 0) {
                 results = "success";
             }
         }
@@ -110,65 +76,64 @@ class SimpleScheduler {
             results,
             error,
             workerRestarts: poolStats.workerRestarts,
-            maxWorkerMemoryUsage: poolStats.maxWorkerMemoryUsage, // max memory usage of a worker in bytes
+            maxWorkerMemoryUsage: poolStats.maxWorkerMemoryUsage
         };
     }
     /**
-     * Used by consumers of the scheduler to notify that the inputs to the target has changed
-     * @param targetId
-     */
-    async onTargetChange(targetId) {
+   * Used by consumers of the scheduler to notify that the inputs to the target has changed
+   * @param targetId
+   */ async onTargetChange(targetId) {
         this.abortController.abort();
         await this.runPromise;
-        const queue = [targetId];
-        while (queue.length > 0) {
+        const queue = [
+            targetId
+        ];
+        while(queue.length > 0){
             const current = queue.shift();
             const targetRun = this.targetRuns.get(current);
             if (targetRun.status !== "pending") {
                 targetRun.status = "pending";
                 const dependents = targetRun.target.dependents;
-                for (const dependent of dependents) {
+                for (const dependent of dependents){
                     queue.push(dependent);
                 }
             }
         }
         this.abortController = new AbortController();
         this.abortSignal = this.abortController.signal;
-        for (const targetRun of this.targetRuns.values()) {
-            targetRun.abortController = this.abortController;
+        for (const targetRun1 of this.targetRuns.values()){
+            targetRun1.abortController = this.abortController;
         }
         this.runPromise = this.scheduleReadyTargets();
     }
     getReadyTargets() {
-        var _a;
         const readyTargets = [];
-        const runningTargets = this.targetsByPriority.filter((target) => this.targetRuns.get(target.id).status === "running");
+        const runningTargets = this.targetsByPriority.filter((target)=>this.targetRuns.get(target.id).status === "running");
         const runningTargetsCountByTask = {};
-        for (const target of runningTargets) {
-            runningTargetsCountByTask[target.task] =
-                typeof runningTargetsCountByTask[target.task] !== "number" ? 1 : runningTargetsCountByTask[target.task]++;
+        for (const target of runningTargets){
+            runningTargetsCountByTask[target.task] = typeof runningTargetsCountByTask[target.task] !== "number" ? 1 : runningTargetsCountByTask[target.task]++;
         }
-        for (const target of this.targetsByPriority) {
-            if (target.id === (0, target_graph_1.getStartTargetId)()) {
+        for (const target1 of this.targetsByPriority){
+            if (target1.id === (0, _targetGraph.getStartTargetId)()) {
                 continue;
             }
-            const targetRun = this.targetRuns.get(target.id);
+            const targetRun = this.targetRuns.get(target1.id);
             const targetDeps = targetRun.target.dependencies;
             // filter all dependencies for those that are "ready"
-            const ready = targetDeps.every((dep) => {
+            const ready = targetDeps.every((dep)=>{
                 const fromTarget = this.targetRuns.get(dep);
-                return fromTarget.status === "success" || fromTarget.status === "skipped" || dep === (0, target_graph_1.getStartTargetId)();
+                return fromTarget.status === "success" || fromTarget.status === "skipped" || dep === (0, _targetGraph.getStartTargetId)();
             });
             if (ready && targetRun.status === "pending") {
                 readyTargets.push(targetRun);
-                runningTargetsCountByTask[target.task] = ((_a = runningTargetsCountByTask[target.task]) !== null && _a !== void 0 ? _a : 0) + 1;
+                runningTargetsCountByTask[target1.task] = (runningTargetsCountByTask[target1.task] ?? 0) + 1;
             }
         }
         return readyTargets;
     }
     isAllDone() {
-        for (const t of this.targetRuns.values()) {
-            if (t.status !== "skipped" && t.status !== "success" && t.target.id !== (0, target_graph_1.getStartTargetId)()) {
+        for (const t of this.targetRuns.values()){
+            if (t.status !== "skipped" && t.status !== "success" && t.target.id !== (0, _targetGraph.getStartTargetId)()) {
                 return false;
             }
         }
@@ -178,22 +143,17 @@ class SimpleScheduler {
         if (this.isAllDone() || this.abortSignal.aborted) {
             return Promise.resolve();
         }
-        this.options.logger.silly(`Max Worker Memory Usage: ${(0, formatBytes_js_1.formatBytes)(this.pool.stats().maxWorkerMemoryUsage)}`);
+        this.options.logger.silly(`Max Worker Memory Usage: ${(0, _formatBytesJs.formatBytes)(this.pool.stats().maxWorkerMemoryUsage)}`);
         const promises = [];
-        for (const nextTarget of this.getReadyTargets()) {
-            promises.push(nextTarget
-                .run()
-                .then(() => {
+        for (const nextTarget of this.getReadyTargets()){
+            promises.push(nextTarget.run().then(()=>{
                 return this.scheduleReadyTargets();
-            })
-                .catch((e) => {
-                var _a;
+            }).catch((e)=>{
                 // if a continue option is set, this merely records what errors have been encountered
                 // it'll continue down the execution until all the tasks that still works
-                if ((_a = this.options) === null || _a === void 0 ? void 0 : _a.continueOnError) {
+                if (this.options?.continueOnError) {
                     return this.scheduleReadyTargets();
-                }
-                else {
+                } else {
                     // immediately reject, if not using "continue" option
                     throw e;
                 }
@@ -203,16 +163,36 @@ class SimpleScheduler {
         return this.runPromise;
     }
     async cleanup() {
-        this.options.logger.silly(`Max Worker Memory Usage: ${(0, formatBytes_js_1.formatBytes)(this.pool.stats().maxWorkerMemoryUsage)}`);
+        this.options.logger.silly(`Max Worker Memory Usage: ${(0, _formatBytesJs.formatBytes)(this.pool.stats().maxWorkerMemoryUsage)}`);
         await this.pool.close();
     }
     /**
-     * Abort the scheduler using the abort controller.
-     */
-    abort() {
+   * Abort the scheduler using the abort controller.
+   */ abort() {
         this.abortController.abort();
     }
+    constructor(options){
+        this.options = options;
+        this.targetRuns = new Map();
+        this.targetsByPriority = [];
+        this.abortController = new AbortController();
+        this.abortSignal = this.abortController.signal;
+        this.runPromise = Promise.resolve();
+        this.pool = options.pool ?? new _workerThreadsPool.AggregatedPool({
+            logger: options.logger,
+            maxWorkersByGroup: options.maxWorkersPerTask,
+            groupBy: ({ target  })=>target.task,
+            maxWorkers: options.concurrency,
+            script: require.resolve("./workers/targetWorker"),
+            workerOptions: {
+                stdout: true,
+                stderr: true,
+                workerData: {
+                    runners: options.runners
+                }
+            },
+            workerIdleMemoryLimit: options.workerIdleMemoryLimit
+        });
+    }
 }
-exports.SimpleScheduler = SimpleScheduler;
 encodeURI;
-//# sourceMappingURL=SimpleScheduler.js.map