@camunda8/orchestration-cluster-api 10.0.0-alpha.20 → 10.0.0-alpha.21

package/dist/fp/index.cjs

@@ -12967,7 +12967,7 @@ function createLogger(opts = {}) {
 }
 
 // src/runtime/version.ts
-var packageVersion = "10.0.0-alpha.20";
+var packageVersion = "10.0.0-alpha.21";
 
 // src/runtime/supportLogger.ts
 var NoopSupportLogger = class {
@@ -14205,6 +14205,50 @@ function createVariableSearchFetchPage(params) {
   };
 }
 
+// src/runtime/workerStartGate.ts
+var WorkerStartGate = class {
+  /**
+   * @param transportReady Resolves when the worker's transport can service polls.
+   * @param isStopped Reports whether the worker was stopped while the gate was buffering.
+   */
+  constructor(_transportReady, _isStopped) {
+    this._transportReady = _transportReady;
+    this._isStopped = _isStopped;
+  }
+  _transportReady;
+  _isStopped;
+  _requested = false;
+  /** True once a start request has been accepted and not since released. */
+  get requested() {
+    return this._requested;
+  }
+  /**
+   * Record a start request.
+   *
+   * The first accepted request invokes `onReady` once the transport resolves,
+   * and only if the worker has not been stopped in the meantime. If the
+   * transport fails to come up, `onError` is invoked and the gate is released so
+   * a later `start()` can retry.
+   *
+   * @returns `false` when the request was dropped as redundant.
+   */
+  request(onReady, onError) {
+    if (this._requested) return false;
+    this._requested = true;
+    void this._transportReady().then(
+      () => {
+        if (this._isStopped()) return;
+        onReady();
+      },
+      (err) => {
+        this._requested = false;
+        onError(err);
+      }
+    );
+    return true;
+  }
+};
+
 // src/runtime/jobWorker.ts
 var JobActionReceipt = "JOB_ACTION_RECEIPT";
 var _workerCounter = 0;
@@ -14221,6 +14265,7 @@ var JobWorker = class {
   _inFlightActivation = null;
   // CancelablePromise-like
   _log;
+  _startGate;
   constructor(client2, cfg) {
     this._client = client2;
     this._cfg = {
@@ -14241,6 +14286,10 @@ var JobWorker = class {
         { maxBackoffTimeMs: cfg.maxBackoffTimeMs }
       ]);
     }
+    this._startGate = new WorkerStartGate(
+      () => Promise.resolve(),
+      () => this._stopped
+    );
     if (this._cfg.autoStart) this.start();
   }
   get name() {
@@ -14252,10 +14301,25 @@ var JobWorker = class {
   get stopped() {
     return this._stopped;
   }
+  /**
+   * Begin polling for jobs. Safe to call at any point: the request is buffered
+   * until the transport is ready, and redundant calls (including an explicit
+   * call on an `autoStart` worker) are dropped rather than starting a second
+   * poll loop. Once the worker is stopped, `start()` is a no-op.
+   */
   start() {
     if (this._stopped) return;
-    if (this._pollTimer) return;
+    const accepted = this._startGate.request(
+      () => this._beginPolling(),
+      (err) => this._log.error("worker.start.transportError", err)
+    );
+    if (!accepted) {
+      this._log.debug("worker.start.alreadyRequested");
+      return;
+    }
     this._log.info("worker.start");
+  }
+  _beginPolling() {
     const jitterMax = this._cfg.startupJitterMaxSeconds ?? 0;
     if (jitterMax > 0) {
       const jitterMs = Math.floor(Math.random() * jitterMax * 1e3);
@@ -14514,6 +14578,7 @@ var ThreadedJobWorker = class {
   _inFlightActivation = null;
   _log;
   _jobQueue = [];
+  _startGate;
   constructor(client2, pool, cfg) {
     this._client = client2;
     this._pool = pool;
@@ -14530,6 +14595,10 @@ var ThreadedJobWorker = class {
     this._name = cfg.workerName || `threaded-worker-${cfg.jobType}-${++_workerCounter2}`;
     this._log = this._client.logger().scope(`worker:${this._name}`);
     this._pool.onThreadReady = () => this._drainQueue();
+    this._startGate = new WorkerStartGate(
+      () => this._pool.ready,
+      () => this._stopped
+    );
     if (this._cfg.autoStart) this.start();
   }
   get name() {
@@ -14553,10 +14622,25 @@ var ThreadedJobWorker = class {
   get ready() {
     return this._pool.ready;
   }
+  /**
+   * Begin polling for jobs. Safe to call at any point: the request is buffered
+   * until the shared thread pool is ready, and redundant calls (including an
+   * explicit call on an `autoStart` worker) are dropped rather than starting a
+   * second poll loop. Once the worker is stopped, `start()` is a no-op.
+   */
   start() {
     if (this._stopped) return;
-    if (this._pollTimer) return;
+    const accepted = this._startGate.request(
+      () => this._beginPolling(),
+      (err) => this._log.error("worker.start.transportError", err)
+    );
+    if (!accepted) {
+      this._log.debug("worker.start.alreadyRequested");
+      return;
+    }
     this._log.info("worker.start");
+  }
+  _beginPolling() {
     const jitterMax = this._cfg.startupJitterMaxSeconds ?? 0;
     if (jitterMax > 0) {
       const jitterMs = Math.floor(Math.random() * jitterMax * 1e3);