@sap/cds-dk 10.1.0 → 10.1.1

package/node_modules/@sap/cds-mtxs/srv/worker/job-worker-pool.js

@@ -0,0 +1,212 @@
+'use strict'
+
+const { Worker } = require('worker_threads')
+const path = require('path')
+const cds = require('@sap/cds')
+
+const LOG = cds.log('mtx')
+const WORKER_PATH = path.join(__dirname, 'job-worker.js')
+
+const IDLE = 'idle'
+const BUSY = 'busy'
+const BOOTING = 'booting'
+
+class DeploymentPool {
+
+  constructor(size) {
+    this.size = size
+    this.workers = []       // { worker, state, pending: Map<id, {resolve,reject}> }
+    this.waitQueue = []     // queued acquire requests: { resolve, reject }
+    this._idCounter = 0
+    this._shuttingDown = false
+  }
+
+  /**
+   * Spawn a new worker, bootstrap it, and add it to the pool.
+   * Returns a promise that resolves when the worker is ready.
+   */
+  _spawn() {
+    return new Promise((resolve, reject) => {
+      const worker = new Worker(WORKER_PATH, { env: process.env, workerData: { cdsEnv: cds.env, cdsRoot: cds.root } })
+      const entry = { worker, state: BOOTING, pending: new Map() }
+      this.workers.push(entry)
+
+      const onReady = (msg) => {
+        if (msg.ready) {
+          worker.off('message', onReady)
+          worker.off('error', onError)
+          entry.state = IDLE
+          worker.on('message', (msg) => this._onMessage(entry, msg))
+          worker.on('error', (err) => this._onError(entry, err))
+          worker.on('exit', (code) => this._onExit(entry, code))
+          resolve(entry)
+        } else if (msg.error) {
+          worker.off('message', onReady)
+          worker.off('error', onError)
+          this.workers = this.workers.filter(e => e !== entry)
+          reject(new Error(msg.error))
+        }
+      }
+
+      const onError = (err) => {
+        worker.off('message', onReady)
+        this.workers = this.workers.filter(e => e !== entry)
+        reject(err)
+      }
+
+      worker.on('message', onReady)
+      worker.on('error', onError)
+    })
+  }
+
+  /**
+   * Handle messages from a worker (command responses).
+   */
+  _onMessage(entry, { id, result, error }) {
+    const pending = entry.pending.get(id)
+    if (!pending) return
+    entry.pending.delete(id)
+    if (error) pending.reject(new Error(error))
+    else pending.resolve(result)
+  }
+
+  /**
+   * Handle worker errors.
+   */
+  _onError(entry, err) {
+    LOG.error('Deployment worker error:', err.message)
+    // Reject all pending tasks on this worker
+    for (const [, { reject }] of entry.pending) {
+      reject(new Error(`Worker error: ${err.message}`))
+    }
+    entry.pending.clear()
+  }
+
+  /**
+   * Handle worker exit — reject in-flight tasks and replace the worker.
+   */
+  _onExit(entry, code) {
+    this.workers = this.workers.filter(e => e !== entry)
+
+    // Reject any in-flight tasks
+    for (const [, { reject }] of entry.pending) {
+      reject(new Error(`Worker exited unexpectedly with code ${code}`))
+    }
+    entry.pending.clear()
+
+    // Do not replace workers during shutdown
+    if (this._shuttingDown) return
+
+    // Immediately replace the crashed worker
+    LOG.warn('Deployment worker exited with code', code, '- spawning replacement')
+    this._spawn().then(newEntry => {
+      // If there are queued requests waiting, serve them
+      if (this.waitQueue.length > 0 && newEntry.state === IDLE) {
+        newEntry.state = BUSY
+        const { resolve } = this.waitQueue.shift()
+        resolve(newEntry)
+      }
+    }).catch(err => {
+      LOG.error('Failed to spawn replacement worker:', err.message)
+      // If there are queued requests waiting, reject the first one
+      if (this.waitQueue.length > 0) {
+        const { reject } = this.waitQueue.shift()
+        reject(err)
+      }
+    })
+  }
+
+  /**
+   * Acquire an idle worker. If none available and pool not full, spawns a new one.
+   * If all workers are busy and pool is full, queues the request.
+   */
+  async acquire() {
+    // Try to find an idle worker
+    const idle = this.workers.find(e => e.state === IDLE)
+    if (idle) {
+      idle.state = BUSY
+      return idle
+    }
+
+    // Pool not full — spawn a new worker
+    if (this.workers.length < this.size) {
+      const entry = await this._spawn()
+      entry.state = BUSY
+      return entry
+    }
+
+    // All busy — wait in queue
+    return new Promise((resolve, reject) => {
+      this.waitQueue.push({ resolve, reject })
+    })
+  }
+
+  /**
+   * Release a worker back to idle state. Serves the next queued request if any.
+   */
+  release(entry) {
+    if (this.waitQueue.length > 0) {
+      entry.state = BUSY
+      const { resolve } = this.waitQueue.shift()
+      resolve(entry)
+    } else {
+      entry.state = IDLE
+    }
+  }
+
+  /**
+   * Execute a service action on a worker.
+   * Acquires a worker, sends the command, waits for the result, releases the worker.
+   */
+  async exec(service, op, tenant, args) {
+    const entry = await this.acquire()
+    const id = ++this._idCounter
+    try {
+      const result = await new Promise((resolve, reject) => {
+        entry.pending.set(id, { resolve, reject })
+        entry.worker.postMessage({ id, service, op, tenant, args, cdsEnv: cds.env })
+      })
+      return result
+    } finally {
+      this.release(entry)
+    }
+  }
+
+  /**
+   * Shut down all workers. Sends a shutdown message to each worker and waits for them to exit.
+   */
+  async shutdown() {
+    this._shuttingDown = true
+
+    // Reject all queued acquire requests
+    for (const { reject } of this.waitQueue) {
+      reject(new Error('Worker pool is shutting down'))
+    }
+    this.waitQueue = []
+
+    // Send shutdown message to all workers and wait for them to exit
+    await Promise.all(this.workers.map(entry => {
+      for (const [, { reject }] of entry.pending) {
+        reject(new Error('Worker pool is shutting down'))
+      }
+      entry.pending.clear()
+      entry.worker.postMessage({ shutdown: true })
+      return new Promise(resolve => entry.worker.once('exit', resolve))
+    }))
+    this.workers = []
+  }
+}
+
+let _pool
+
+/**
+ * Returns the singleton DeploymentPool instance.
+ * @param {number} size - Pool size (number of workers)
+ */
+module.exports = function getDeploymentPool(size) {
+  if (!_pool) {
+    _pool = new DeploymentPool(size)
+    cds.on('shutdown', async () => _pool.shutdown())
+  }
+  return _pool
+}

package/node_modules/@sap/cds-mtxs/srv/worker/job-worker.js

@@ -0,0 +1,61 @@
+'use strict'
+
+const { parentPort, workerData } = require('worker_threads')
+const cds = require('@sap/cds')
+const { _import, isfile, path } = cds.utils
+
+if (workerData?.cdsRoot) cds.root = workerData.cdsRoot
+if (workerData?.cdsEnv) cds.env.add(workerData.cdsEnv)
+
+async function bootstrap() {
+  const services = [
+    '@sap/cds-mtxs/srv/deployment-service',
+    '@sap/cds-mtxs/srv/model-provider',
+    '@sap/cds-mtxs/srv/cf/saas-provisioning-service',
+    '@sap/cds-mtxs/srv/extensibility-service',
+  ]
+  await _local_cli_js()
+  cds.emit('bootstrap')
+  const model = await cds.load([...services, '@sap/cds-mtxs/db/extensions'])
+  cds.model = cds.compile.for.nodejs(model)
+  const unserved = !cds.services['cds.xt.DeploymentService']
+  if (unserved) await cds.serve(services)
+  await cds.plugins
+  await cds.emit('served', cds.services)
+  parentPort.postMessage({ ready: true })
+}
+
+async function _local_cli_js() {
+  const _local = file => isfile(file) || isfile(path.join(cds.env.folders.srv, file))
+  const cli_js = process.env.CDS_TYPESCRIPT && (_local('cli.ts') || _local('server.ts')) || _local('cli.js') || _local('server.js')
+  if (cli_js) await _import(cli_js)
+}
+
+parentPort.on('message', async (msg) => {
+  if (msg.shutdown) {
+    await cds.shutdown()
+    process.exit(0)
+  }
+  const { id, service, op, tenant, args, cdsEnv } = msg
+  if (cdsEnv) cds.env.add(cdsEnv)
+  const srv = cds.services[service]
+  if (!srv) {
+    parentPort.postMessage({ id, error: `Service ${service} not available` })
+    return
+  }
+  try {
+    const result = await srv[op](tenant, ...Object.values(args))
+    parentPort.postMessage({ id, result })
+  } catch (e) {
+    const error = e.message ?? 'Unknown error'
+    parentPort.postMessage({ id, error })
+  } finally {
+    // cds.db.disconnect(cds.env.requires.multitenancy.t0 ?? 't0')
+    // cds.db.disconnect(tenant)
+  }
+})
+
+bootstrap().catch(e => {
+  parentPort.postMessage({ error: `Bootstrap failed: ${e.message}` })
+  process.exit(1)
+})

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sap/cds-dk",
-  "version": "10.1.0",
+  "version": "10.1.1",
   "description": "Command line client and development toolkit for the SAP Cloud Application Programming Model",
   "homepage": "https://cap.cloud.sap/",
   "keywords": [
@@ -21,7 +21,7 @@
     "@cap-js/openapi": "^1.0.0",
     "@cap-js/sqlite": "^3",
     "@sap/cds": "^10",
-    "@sap/cds-mtxs": "4.0.3",
+    "@sap/cds-mtxs": "^4",
     "@sap/hdi-deploy": "^5",
     "express": "^5",
     "hdb": "^2.0.0",