@lage-run/scheduler 1.1.3 → 1.1.5

package/CHANGELOG.json

@@ -2,7 +2,49 @@
   "name": "@lage-run/scheduler",
   "entries": [
     {
-      "date": "Tue, 30 May 2023 18:19:19 GMT",
+      "date": "Wed, 21 Jun 2023 19:05:46 GMT",
+      "tag": "@lage-run/scheduler_v1.1.5",
+      "version": "1.1.5",
+      "comments": {
+        "patch": [
+          {
+            "author": "beachball",
+            "package": "@lage-run/scheduler",
+            "comment": "Bump @lage-run/hasher to v1.0.2",
+            "commit": "3efba30544ff1844986f469e01b47316d700ceeb"
+          }
+        ]
+      }
+    },
+    {
+      "date": "Thu, 15 Jun 2023 17:04:58 GMT",
+      "tag": "@lage-run/scheduler_v1.1.4",
+      "version": "1.1.4",
+      "comments": {
+        "patch": [
+          {
+            "author": "altinokd@microsoft.com",
+            "package": "@lage-run/scheduler",
+            "commit": "91dfab46c2cb13c175931f12f2964b2b9ace491a",
+            "comment": "Return value from worker run functions as part of TargetRun.result object. Encapsulated status and result fields. Added a way to reset WrappedTarget"
+          },
+          {
+            "author": "beachball",
+            "package": "@lage-run/scheduler",
+            "comment": "Bump @lage-run/config to v0.3.1",
+            "commit": "91dfab46c2cb13c175931f12f2964b2b9ace491a"
+          },
+          {
+            "author": "beachball",
+            "package": "@lage-run/scheduler",
+            "comment": "Bump @lage-run/scheduler-types to v0.3.10",
+            "commit": "91dfab46c2cb13c175931f12f2964b2b9ace491a"
+          }
+        ]
+      }
+    },
+    {
+      "date": "Tue, 30 May 2023 18:19:34 GMT",
       "tag": "@lage-run/scheduler_v1.1.3",
       "version": "1.1.3",
       "comments": {

package/CHANGELOG.md

@@ -1,12 +1,30 @@
 # Change Log - @lage-run/scheduler
 
-This log was last generated on Tue, 30 May 2023 18:19:19 GMT and should not be manually modified.
+This log was last generated on Wed, 21 Jun 2023 19:05:46 GMT and should not be manually modified.
 
 <!-- Start content -->
 
+## 1.1.5
+
+Wed, 21 Jun 2023 19:05:46 GMT
+
+### Patches
+
+- Bump @lage-run/hasher to v1.0.2
+
+## 1.1.4
+
+Thu, 15 Jun 2023 17:04:58 GMT
+
+### Patches
+
+- Return value from worker run functions as part of TargetRun.result object. Encapsulated status and result fields. Added a way to reset WrappedTarget (altinokd@microsoft.com)
+- Bump @lage-run/config to v0.3.1
+- Bump @lage-run/scheduler-types to v0.3.10
+
 ## 1.1.3
 
-Tue, 30 May 2023 18:19:19 GMT
+Tue, 30 May 2023 18:19:34 GMT
 
 ### Patches
 

package/lib/SimpleScheduler.d.ts

@@ -3,6 +3,7 @@
 /// <reference types="global" />
 import { WrappedTarget } from "./WrappedTarget.js";
 import { TargetRunnerPicker } from "./runners/TargetRunnerPicker.js";
+import type { WorkerResult } from "./WrappedTarget.js";
 import type { Logger } from "@lage-run/logger";
 import type { TargetGraph } from "@lage-run/target-graph";
 import type { TargetScheduler, SchedulerRunSummary } from "@lage-run/scheduler-types";
@@ -42,7 +43,7 @@ export interface SimpleSchedulerOptions {
  * 1. Allow for multiple kinds of runner (currently only ONE is supported, and it is applied to all targets)
  *
  */
-export declare class SimpleScheduler implements TargetScheduler {
+export declare class SimpleScheduler implements TargetScheduler<WorkerResult> {
     #private;
     private options;
     targetRuns: Map<string, WrappedTarget>;
@@ -64,7 +65,7 @@ export declare class SimpleScheduler implements TargetScheduler {
      * @param targetGraph
      * @returns
      */
-    run(root: string, targetGraph: TargetGraph, shouldRerun?: boolean): Promise<SchedulerRunSummary>;
+    run(root: string, targetGraph: TargetGraph, shouldRerun?: boolean): Promise<SchedulerRunSummary<WorkerResult>>;
     /**
      * Used by consumers of the scheduler to notify that the inputs to the target has changed
      * @param targetId

package/lib/SimpleScheduler.js

@@ -95,9 +95,6 @@ class SimpleScheduler {
                     onMessage: this.options.onMessage
                 });
             }
-            if (target.id === (0, _targetgraph.getStartTargetId)()) {
-                targetRun.status = "success";
-            }
             this.targetRuns.set(target.id, targetRun);
         }
         let results = "failed";
@@ -143,7 +140,7 @@ class SimpleScheduler {
             if (this.targetRuns.has(current)) {
                 const targetRun = this.targetRuns.get(current);
                 if (targetRun.status !== "pending") {
-                    targetRun.status = "pending";
+                    targetRun.reset();
                     this.rerunTargets.add(targetRun.target.id);
                     const dependents = targetRun.target.dependents;
                     for (const dependent of dependents){
@@ -259,9 +256,7 @@ class SimpleScheduler {
 }
 async function generateTargetRunPromise(target) {
     let runError;
-    if (target.result && target.successful && !this.rerunTargets.has(target.target.id)) {
-        await target.result;
-    } else {
+    if (!target.successful || this.rerunTargets.has(target.target.id)) {
         // This do-while loop only runs again if something causes this target to rerun (asynchronously triggering a re-run)
         do {
             this.rerunTargets.delete(target.target.id);

package/lib/WrappedTarget.d.ts

@@ -2,7 +2,7 @@
 /// <reference types="node" />
 import type { Pool } from "@lage-run/worker-threads-pool";
 import type { TargetRun, TargetStatus } from "@lage-run/scheduler-types";
-import type { Target } from "@lage-run/target-graph";
+import { type Target } from "@lage-run/target-graph";
 import type { Logger } from "@lage-run/logger";
 import type { TargetHasher } from "@lage-run/hasher";
 import type { MessagePort } from "worker_threads";
@@ -17,11 +17,12 @@ export interface WrappedTargetOptions {
     hasher: TargetHasher;
     onMessage?: (message: any, postMessage: MessagePort["postMessage"]) => void;
 }
-interface WorkerResult {
+export interface WorkerResult {
     stdoutBuffer: string;
     stderrBuffer: string;
     skipped: boolean;
     hash: string;
+    value: unknown;
 }
 /**
  * Wraps a target with additional functionality:
@@ -30,15 +31,16 @@ interface WorkerResult {
  * 3. Abort signal
  * 4. Continue on error
  */
-export declare class WrappedTarget implements TargetRun {
+export declare class WrappedTarget implements TargetRun<WorkerResult> {
+    #private;
     options: WrappedTargetOptions;
     queueTime: [number, number];
     startTime: [number, number];
     duration: [number, number];
     target: Target;
-    status: TargetStatus;
     threadId: number;
-    result: Promise<WorkerResult> | undefined;
+    get result(): WorkerResult | undefined;
+    get status(): TargetStatus;
     get abortController(): AbortController;
     set abortController(abortController: AbortController);
     get successful(): boolean;
@@ -63,5 +65,8 @@ export declare class WrappedTarget implements TargetRun {
         target: string;
         status: TargetStatus;
     };
+    /**
+     * Reset the state of this wrapped target.
+     */
+    reset(): void;
 }
-export {};

package/lib/WrappedTarget.js

@@ -14,6 +14,47 @@ const _logger = require("@lage-run/logger");
 const _fs = /*#__PURE__*/ _interop_require_default(require("fs"));
 const _path = /*#__PURE__*/ _interop_require_default(require("path"));
 const _promises = require("fs/promises");
+const _targetgraph = require("@lage-run/target-graph");
+function _check_private_redeclaration(obj, privateCollection) {
+    if (privateCollection.has(obj)) {
+        throw new TypeError("Cannot initialize the same private elements twice on an object");
+    }
+}
+function _class_apply_descriptor_get(receiver, descriptor) {
+    if (descriptor.get) {
+        return descriptor.get.call(receiver);
+    }
+    return descriptor.value;
+}
+function _class_apply_descriptor_set(receiver, descriptor, value) {
+    if (descriptor.set) {
+        descriptor.set.call(receiver, value);
+    } else {
+        if (!descriptor.writable) {
+            throw new TypeError("attempted to set read only private field");
+        }
+        descriptor.value = value;
+    }
+}
+function _class_extract_field_descriptor(receiver, privateMap, action) {
+    if (!privateMap.has(receiver)) {
+        throw new TypeError("attempted to " + action + " private field on non-instance");
+    }
+    return privateMap.get(receiver);
+}
+function _class_private_field_get(receiver, privateMap) {
+    var descriptor = _class_extract_field_descriptor(receiver, privateMap, "get");
+    return _class_apply_descriptor_get(receiver, descriptor);
+}
+function _class_private_field_init(obj, privateMap, value) {
+    _check_private_redeclaration(obj, privateMap);
+    privateMap.set(obj, value);
+}
+function _class_private_field_set(receiver, privateMap, value) {
+    var descriptor = _class_extract_field_descriptor(receiver, privateMap, "set");
+    _class_apply_descriptor_set(receiver, descriptor, value);
+    return value;
+}
 function _define_property(obj, key, value) {
     if (key in obj) {
         Object.defineProperty(obj, key, {
@@ -32,7 +73,14 @@ function _interop_require_default(obj) {
         default: obj
     };
 }
+var _status = /*#__PURE__*/ new WeakMap(), _result = /*#__PURE__*/ new WeakMap();
 class WrappedTarget {
+    get result() {
+        return _class_private_field_get(this, _result);
+    }
+    get status() {
+        return _class_private_field_get(this, _status);
+    }
     get abortController() {
         return this.options.abortController;
     }
@@ -40,17 +88,17 @@ class WrappedTarget {
         this.options.abortController = abortController;
     }
     get successful() {
-        return this.status === "skipped" || this.status === "success";
+        return _class_private_field_get(this, _status) === "skipped" || _class_private_field_get(this, _status) === "success";
     }
     get waiting() {
-        return this.status === "pending" || this.status === "queued";
+        return _class_private_field_get(this, _status) === "pending" || _class_private_field_get(this, _status) === "queued";
     }
     onQueued() {
-        this.status = "queued";
+        _class_private_field_set(this, _status, "queued");
         this.queueTime = process.hrtime();
     }
     onAbort() {
-        this.status = "aborted";
+        _class_private_field_set(this, _status, "aborted");
         this.duration = process.hrtime(this.startTime);
         this.options.logger.info("", {
             target: this.target,
@@ -61,7 +109,7 @@ class WrappedTarget {
     onStart(threadId) {
         if (this.status !== "running") {
             this.threadId = threadId;
-            this.status = "running";
+            _class_private_field_set(this, _status, "running");
             this.startTime = process.hrtime();
             this.options.logger.info("", {
                 target: this.target,
@@ -71,7 +119,7 @@ class WrappedTarget {
         }
     }
     onComplete() {
-        this.status = "success";
+        _class_private_field_set(this, _status, "success");
         this.duration = process.hrtime(this.startTime);
         this.options.logger.info("", {
             target: this.target,
@@ -81,7 +129,7 @@ class WrappedTarget {
         });
     }
     onFail() {
-        this.status = "failed";
+        _class_private_field_set(this, _status, "failed");
         this.duration = process.hrtime(this.startTime);
         this.options.logger.info("", {
             target: this.target,
@@ -97,7 +145,7 @@ class WrappedTarget {
         if (this.startTime[0] !== 0 && this.startTime[1] !== 0) {
             this.duration = process.hrtime(this.startTime);
         }
-        this.status = "skipped";
+        _class_private_field_set(this, _status, "skipped");
         if (hash) {
             this.options.logger.info("", {
                 target: this.target,
@@ -117,23 +165,23 @@ class WrappedTarget {
             return;
         }
         try {
-            const result = await this.runInPool();
-            const cacheEnabled = target.cache && shouldCache && result.hash;
+            _class_private_field_set(this, _result, await this.runInPool());
+            const cacheEnabled = target.cache && shouldCache && _class_private_field_get(this, _result).hash;
             // Save output if cache is enabled & cache is hit
-            if (!result.skipped && cacheEnabled) {
-                const outputLocation = (0, _getLageOutputCacheLocation.getLageOutputCacheLocation)(root, result.hash);
+            if (!_class_private_field_get(this, _result).skipped && cacheEnabled) {
+                const outputLocation = (0, _getLageOutputCacheLocation.getLageOutputCacheLocation)(root, _class_private_field_get(this, _result).hash);
                 const outputPath = _path.default.dirname(outputLocation);
                 await (0, _promises.mkdir)(outputPath, {
                     recursive: true
                 });
-                const output = `${result.stdoutBuffer}\n${result.stderrBuffer}`;
+                const output = `${_class_private_field_get(this, _result).stdoutBuffer}\n${_class_private_field_get(this, _result).stderrBuffer}`;
                 await (0, _promises.writeFile)(outputLocation, output);
-                logger.verbose(`>> Saved cache - ${result.hash}`, {
+                logger.verbose(`>> Saved cache - ${_class_private_field_get(this, _result).hash}`, {
                     target
                 });
             }
-            if (result.skipped) {
-                const { hash  } = result;
+            if (_class_private_field_get(this, _result).skipped) {
+                const { hash  } = _class_private_field_get(this, _result);
                 const cachedOutputFile = (0, _getLageOutputCacheLocation.getLageOutputCacheLocation)(root, hash ?? "");
                 const shouldShowCachedOutput = _fs.default.existsSync(cachedOutputFile);
                 if (shouldShowCachedOutput) {
@@ -169,7 +217,7 @@ class WrappedTarget {
         const bufferStdout = (0, _bufferTransform.bufferTransform)();
         const bufferStderr = (0, _bufferTransform.bufferTransform)();
         let msgHandler;
-        this.result = pool.exec({
+        const result = await pool.exec({
             target
         }, target.weight ?? 1, (worker, stdout, stderr)=>{
             const postMessage = worker.postMessage.bind(worker);
@@ -216,12 +264,12 @@ class WrappedTarget {
             releaseStdout();
             releaseStderr();
         }, abortSignal);
-        const result = await this.result;
         return {
             stdoutBuffer: bufferStdout.buffer,
             stderrBuffer: bufferStderr.buffer,
             skipped: result?.skipped,
-            hash: result?.hash
+            hash: result?.hash,
+            value: result?.value
         };
     }
     /**
@@ -236,16 +284,29 @@ class WrappedTarget {
             status: this.status
         };
     }
+    /**
+   * Reset the state of this wrapped target.
+   */ reset() {
+        _class_private_field_set(this, _result, undefined);
+        _class_private_field_set(this, _status, "pending");
+    }
     constructor(options){
         _define_property(this, "options", void 0);
+        _class_private_field_init(this, _status, {
+            writable: true,
+            value: void 0
+        });
+        _class_private_field_init(this, _result, {
+            writable: true,
+            value: void 0
+        });
         _define_property(this, "queueTime", void 0);
         _define_property(this, "startTime", void 0);
         _define_property(this, "duration", void 0);
         _define_property(this, "target", void 0);
-        _define_property(this, "status", void 0);
         _define_property(this, "threadId", void 0);
-        _define_property(this, "result", void 0);
         this.options = options;
+        _class_private_field_set(this, _status, "pending");
         this.queueTime = [
             0,
             0
@@ -259,7 +320,9 @@ class WrappedTarget {
             0
         ];
         this.threadId = 0;
-        this.status = "pending";
         this.target = options.target;
+        if (this.target.id === (0, _targetgraph.getStartTargetId)()) {
+            _class_private_field_set(this, _status, "success");
+        }
     }
 }

package/lib/runners/WorkerRunner.d.ts

@@ -43,6 +43,6 @@ export declare class WorkerRunner implements TargetRunner {
     static gracefulKillTimeout: number;
     constructor(options: WorkerRunnerOptions);
     shouldRun(target: Target): Promise<boolean>;
-    run(runOptions: TargetRunnerOptions): Promise<void>;
+    run(runOptions: TargetRunnerOptions): Promise<any>;
     getScriptModule(target: Target): Promise<any>;
 }

package/lib/runners/WorkerRunner.js

@@ -38,7 +38,7 @@ class WorkerRunner {
         if (typeof runFn !== "function") {
             throw new Error("WorkerRunner: worker script must export a function; you likely need to use `module.exports = function() {...}`");
         }
-        await runFn({
+        return await runFn({
             target,
             weight,
             taskArgs,

package/lib/workers/targetWorker.js

@@ -82,9 +82,10 @@ async function setup(options) {
     async function run(data, abortSignal) {
         const { hash , cacheHit  } = await getCache(data.target);
         const cacheEnabled = data.target.cache && options.shouldCache && hash;
+        let value = undefined;
         if (!cacheHit || !cacheEnabled) {
             const runner = await runnerPicker.pick(data.target);
-            await runner.run({
+            value = await runner.run({
                 ...data,
                 abortSignal
             });
@@ -92,7 +93,8 @@ async function setup(options) {
         }
         return {
             skipped: cacheHit,
-            hash
+            hash,
+            value
         };
     }
     (0, _workerthreadspool.registerWorker)(run);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lage-run/scheduler",
-  "version": "1.1.3",
+  "version": "1.1.5",
   "description": "Scheduler for Lage",
   "repository": {
     "type": "git",
@@ -20,12 +20,12 @@
     "@lage-run/target-graph": "^0.8.6",
     "@lage-run/logger": "^1.3.0",
     "@lage-run/cache": "^1.1.1",
-    "@lage-run/config": "^0.3.0",
-    "@lage-run/hasher": "^1.0.1",
+    "@lage-run/config": "^0.3.1",
+    "@lage-run/hasher": "^1.0.2",
     "@lage-run/worker-threads-pool": "^0.8.0"
   },
   "devDependencies": {
-    "@lage-run/scheduler-types": "^0.3.9",
+    "@lage-run/scheduler-types": "^0.3.10",
     "monorepo-scripts": "*"
   },
   "publishConfig": {