@kitsi/action 0.0.17 → 0.0.18

package/dist/index.js

@@ -101569,7 +101569,7 @@ import { pathToFileURL } from "node:url";
 // ../core/dist/version.js
 var VERSION = "0.0.1";
 // ../core/dist/dsl/plan.js
-var clonePlan = (plan, patch) => new PlanBuilder((() => {
+var clonePlan = (plan, patch) => {
   const next = {
     name: patch.name ?? plan.config.name,
     concurrency: patch.concurrency ?? plan.config.concurrency,
@@ -101578,6 +101578,9 @@ var clonePlan = (plan, patch) => new PlanBuilder((() => {
   const when = patch.when ?? plan.config.when;
   if (when)
     next.when = when;
+  const maxConcurrency = patch.maxConcurrency ?? plan.config.maxConcurrency;
+  if (maxConcurrency !== undefined)
+    next.maxConcurrency = maxConcurrency;
   const matrix = patch.matrix ?? plan.config.matrix;
   if (matrix)
     next.matrix = matrix;
@@ -101587,8 +101590,8 @@ var clonePlan = (plan, patch) => new PlanBuilder((() => {
   const taskFactory = patch.taskFactory ?? plan.config.taskFactory;
   if (taskFactory)
     next.taskFactory = taskFactory;
-  return next;
-})());
+  return new PlanBuilder(next);
+};
 
 class PlanBuilder {
   config;
@@ -101600,6 +101603,8 @@ class PlanBuilder {
     };
     if (config.when)
       next.when = config.when;
+    if (config.maxConcurrency !== undefined)
+      next.maxConcurrency = config.maxConcurrency;
     if (config.matrix)
       next.matrix = config.matrix;
     if (config.params)
@@ -101611,6 +101616,9 @@ class PlanBuilder {
   when(predicate) {
     return clonePlan(this, { when: predicate });
   }
+  maxConcurrency(value) {
+    return clonePlan(this, { maxConcurrency: value });
+  }
   concurrency = {
     group: (fn) => clonePlan(this, { concurrency: { ...this.config.concurrency, group: fn } }),
     cancelInProgress: (value) => clonePlan(this, { concurrency: { ...this.config.concurrency, cancelInProgress: value } })
@@ -104220,6 +104228,58 @@ class UseHandler {
   }
 }
 
+// ../core/dist/engine/executor/buffering-reporter.js
+class BufferingReporter {
+  target;
+  taskBuffers = new Map;
+  enableBuffering;
+  constructor(target, enableBuffering) {
+    this.target = target ?? { emit: () => {} };
+    this.enableBuffering = enableBuffering;
+  }
+  setBuffering(enabled) {
+    this.enableBuffering = enabled;
+  }
+  emit(event, data) {
+    if (!this.enableBuffering) {
+      this.target.emit(event, data);
+      return;
+    }
+    const taskName = this.extractTaskName(event, data);
+    if (!taskName || event === "plan_start" || event === "plan_end") {
+      this.target.emit(event, data);
+      return;
+    }
+    if (event === "task_start") {
+      this.taskBuffers.set(taskName, []);
+    }
+    const buffer = this.taskBuffers.get(taskName);
+    if (buffer) {
+      buffer.push({ event, data });
+    } else {
+      this.target.emit(event, data);
+    }
+    if (event === "task_end") {
+      this.flush(taskName);
+    }
+  }
+  extractTaskName(_event, data) {
+    if (typeof data.task === "string") {
+      return data.task;
+    }
+    return null;
+  }
+  flush(taskName) {
+    const buffer = this.taskBuffers.get(taskName);
+    if (!buffer)
+      return;
+    for (const bufferedEvent of buffer) {
+      this.target.emit(bufferedEvent.event, bufferedEvent.data);
+    }
+    this.taskBuffers.delete(taskName);
+  }
+}
+
 // ../core/dist/engine/executor/command-runner.js
 import { spawn } from "node:child_process";
 class CommandRunner {
@@ -104438,6 +104498,7 @@ class PlanRunner {
   params;
   logger;
   failFast;
+  maxConcurrencyOverride;
   reporter;
   signal;
   states = new Map;
@@ -104448,6 +104509,7 @@ class PlanRunner {
   opHandlers;
   cache;
   expandedTasks = null;
+  taskPromises = new Map;
   constructor(plan2, opts) {
     this.plan = plan2;
     this.workspace = opts.workspace;
@@ -104456,7 +104518,8 @@ class PlanRunner {
     this.params = opts.params ?? {};
     this.logger = opts.logger;
     this.failFast = opts.failFast;
-    this.reporter = opts.reporter;
+    this.maxConcurrencyOverride = opts.maxConcurrency;
+    this.reporter = new BufferingReporter(opts.reporter, false);
     this.signal = opts.signal;
     this.resolver = new ValueResolver(this.states, this.params, this.secrets);
     this.commandRunner = new CommandRunner({
@@ -104512,15 +104575,22 @@ class PlanRunner {
     }
     const tasks = this.plan.expand();
     this.expandedTasks = tasks;
+    const maxConcurrency = this.maxConcurrencyOverride ?? this.plan.config.maxConcurrency ?? 1;
     const results = {};
-    for (const task2 of tasks) {
-      this.checkSignal("plan");
-      const result = await this.executeTask(task2);
-      results[task2.config.name] = result;
-      if (result.status === "failed") {
-        if (this.failFast)
-          break;
+    if (maxConcurrency === 1) {
+      this.reporter.setBuffering(false);
+      for (const task2 of tasks) {
+        this.checkSignal("plan");
+        const result = await this.executeTask(task2);
+        results[task2.config.name] = result;
+        if (result.status === "failed") {
+          if (this.failFast)
+            break;
+        }
       }
+    } else {
+      this.reporter.setBuffering(true);
+      await this.executeTasksParallel(tasks, maxConcurrency, results);
     }
     const status = Object.values(results).some((task2) => task2.status === "failed") ? "failed" : "success";
     this.reporter?.emit("plan_end", {
@@ -104535,6 +104605,46 @@ class PlanRunner {
       tasks: results
     };
   }
+  async executeTasksParallel(tasks, maxConcurrency, results) {
+    const limit = maxConcurrency === 0 ? Number.POSITIVE_INFINITY : maxConcurrency;
+    const queue = [...tasks];
+    const executing = [];
+    let shouldStop = false;
+    while (queue.length > 0 || executing.length > 0) {
+      while (!shouldStop && executing.length < limit && queue.length > 0) {
+        const task2 = queue.shift();
+        if (!task2)
+          break;
+        const promise = (async () => {
+          try {
+            this.checkSignal("plan");
+            const result = await this.executeTask(task2);
+            results[task2.config.name] = result;
+            if (result.status === "failed" && this.failFast) {
+              shouldStop = true;
+            }
+          } catch (error2) {
+            shouldStop = true;
+            throw error2;
+          }
+        })();
+        executing.push(promise);
+        promise.finally(() => {
+          const index = executing.indexOf(promise);
+          if (index >= 0) {
+            executing.splice(index, 1);
+          }
+        });
+      }
+      if (executing.length > 0) {
+        await Promise.race(executing);
+      }
+      if (shouldStop) {
+        break;
+      }
+    }
+    await Promise.all(executing);
+  }
   findTask(name) {
     const tasks = this.expandedTasks ?? this.plan.expand();
     return tasks.find((task2) => task2.config.name === name);
@@ -104545,12 +104655,26 @@ class PlanRunner {
     if (existing?.status === "success" || existing?.status === "failed") {
       return this.toResult(existing, undefined, this.cache.wasTaskCached(name));
     }
+    const existingPromise = this.taskPromises.get(name);
+    if (existingPromise) {
+      if (this.inProgress.has(name)) {
+        throw new Error(`Cycle detected while executing task "${name}"`);
+      }
+      return existingPromise;
+    }
     if (this.inProgress.has(name)) {
       throw new Error(`Cycle detected while executing task "${name}"`);
     }
+    const promise = this.executeTaskInternal(task2);
+    this.taskPromises.set(name, promise);
+    return promise;
+  }
+  async executeTaskInternal(task2) {
+    const name = task2.config.name;
     this.inProgress.add(name);
     this.reporter?.emit("task_start", { task: name });
     const taskStart = Date.now();
+    const existing = this.states.get(name);
     const state = existing ?? (() => {
       const next = {
         status: "pending",
@@ -104834,6 +104958,7 @@ var runPlan = async (registryOrPlan, planName, options = {}) => {
     params: options.params ?? {},
     logger,
     failFast: options.failFast ?? true,
+    maxConcurrency: options.maxConcurrency,
     reporter: options.reporter,
     signal: options.signal,
     ...options.cache ? { cache: options.cache } : {}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@kitsi/action",
-  "version": "0.0.17",
+  "version": "0.0.18",
   "description": "GitHub Action for running Kitsi pipelines",
   "type": "module",
   "main": "./dist/index.js",