@sap/cds-dk 10.1.2 → 10.2.1

package/node_modules/@sap/cds-mtxs/srv/jobs-service.js

@@ -69,6 +69,9 @@ module.exports = class JobsService extends cds.ApplicationService {
         }
       }
     })
+    // Route detached maintenance through CAP requests to establish transaction and telemetry contexts.
+    this.on('jobsHeartbeat', req => _heartbeat(this, req.data.heartbeatAge))
+    this.on('jobsCleanup', req => _cleanup(req.data.cleanupAge))
 
     return super.init()
   }
@@ -243,10 +246,19 @@ module.exports = class JobsService extends cds.ApplicationService {
   }
 
   async _nextJob(clusters, fn, onJobDone) {
+    const errors = new Map()
+    const run = async task => {
+      try {
+        return await fn(task)
+      } catch (error) {
+        errors.set(task.ID, error)
+        throw error
+      }
+    }
     if (clusters.length > 1) {
-      await this.limiter(this._conf.clusterSize, clusters, cluster => this.limiter(this._conf.workerSize ?? this._conf.poolSize, Array.from(cluster), fn, true))
+      await this.limiter(this._conf.clusterSize, clusters, cluster => this.limiter(this._conf.workerSize ?? this._conf.poolSize, Array.from(cluster), run, true))
     } else {
-      await this.limiter(this._conf.workerSize ?? this._conf.poolSize, Array.from(clusters[0]), fn, true)
+      await this.limiter(this._conf.workerSize ?? this._conf.poolSize, Array.from(clusters[0]), run, true)
     }
 
     const { job_ID } = clusters[0][0] // all tasks have the same job ID -> just take the first
@@ -258,7 +270,7 @@ module.exports = class JobsService extends cds.ApplicationService {
       await UPDATE(Jobs, { ID: job_ID }).with(patch)
     })
     if (failed) {
-      await onJobDone?.(failed.error ?? failed.ERROR ?? 'Unknown error')
+      await onJobDone?.(failed.error ?? failed.ERROR ?? 'Unknown error', errors.get(failed.ID))
     } else if (!running) {
       await onJobDone?.()
     }
@@ -322,16 +334,7 @@ function _scheduled(srv) {
 
   const heartbeat = setInterval(async () => {
     try {
-      const cutoff = new Date(new Date - (heartbeatAge ?? 90*minutes))
-      await t0_(async () => {
-        const timedOut = { status: { in: [RUNNING, QUEUED] }, and: { modifiedAt: { '<': cutoff.toISOString() }}}
-        const affectedJobs = await SELECT.from(Jobs, j => { j.ID, j.status }).where(timedOut)
-        const affectedTasks = await SELECT.from(Tasks, t => { t.ID, t.status, t.job_ID }).where(timedOut)
-        await UPDATE(Jobs, timedOut).with({ status: TIMEOUT })
-        await UPDATE(Tasks, timedOut).with({ status: TIMEOUT })
-        await Promise.all(affectedJobs.map(job => srv.emit('jobUpdate', { job: { ...job, status: TIMEOUT }})))
-        await Promise.all(affectedTasks.map(task => srv.emit('taskUpdate', { task: { ...task, status: TIMEOUT }})))
-      })
+      await srv.send('jobsHeartbeat', { heartbeatAge })
     } catch (error) {
       LOG.error('Error in heartbeat interval:', error)
     }
@@ -341,8 +344,7 @@ function _scheduled(srv) {
   if (!noCleanup) {
     cleanup = setInterval(async () => {
       try {
-        const cutoff = new Date(new Date - (cleanupAge ?? 24*hours))
-        await t0_(DELETE.from(Jobs, { status: FAILED, or: { status: FINISHED, and: { modifiedAt: { '<': cutoff.toISOString() }}}}))
+        await srv.send('jobsCleanup', { cleanupAge })
       } catch (error) {
         LOG.error('Error in cleanup interval:', error)
       }
@@ -355,6 +357,28 @@ function _scheduled(srv) {
   })
 }
 
+// Mark timed-out jobs and tasks within one CAP request context.
+async function _heartbeat(srv, heartbeatAge) {
+  const minutes = 1000 * 60
+  const cutoff = new Date(new Date - (heartbeatAge ?? 90*minutes))
+  await t0_(async () => {
+    const timedOut = { status: { in: [RUNNING, QUEUED] }, and: { modifiedAt: { '<': cutoff.toISOString() }}}
+    const affectedJobs = await SELECT.from(Jobs, j => { j.ID, j.status }).where(timedOut)
+    const affectedTasks = await SELECT.from(Tasks, t => { t.ID, t.status, t.job_ID }).where(timedOut)
+    await UPDATE(Jobs, timedOut).with({ status: TIMEOUT })
+    await UPDATE(Tasks, timedOut).with({ status: TIMEOUT })
+    await Promise.all(affectedJobs.map(job => srv.emit('jobUpdate', { job: { ...job, status: TIMEOUT }})))
+    await Promise.all(affectedTasks.map(task => srv.emit('taskUpdate', { task: { ...task, status: TIMEOUT }})))
+  })
+}
+
+// Remove completed jobs within one CAP request context.
+async function _cleanup(cleanupAge) {
+  const hours = 1000 * 60 * 60
+  const cutoff = new Date(new Date - (cleanupAge ?? 24*hours))
+  await t0_(DELETE.from(Jobs, { status: FAILED, or: { status: FINISHED, and: { modifiedAt: { '<': cutoff.toISOString() }}}}))
+}
+
 /*********************************************
  * Opt-in Websockets for diagnostics
  *********************************************/

package/node_modules/@sap/cds-mtxs/srv/plugins/common.js

@@ -1,6 +1,7 @@
 const cds = require('@sap/cds/lib')
 const { t0_ } = require('../../lib/utils')
 const Tenants = 'cds.xt.Tenants'
+const SUBSCRIBED = 'SUBSCRIBED', UNSUBSCRIBING = 'UNSUBSCRIBING', UNSUBSCRIPTION_FAILED = 'UNSUBSCRIPTION_FAILED'
 const LOG = cds.log('mtx')
 const main = require('../config')
 
@@ -33,6 +34,13 @@ cds.on('serving:cds.xt.DeploymentService', ds => {
     const { tenant } = req?.data ?? {}
     if (tenant) cds.context = { tenant }
 
+    // Ensure cds.xt.Extensions is in the model (it isn't when extensibility is disabled), so the
+    // query resolves against the physical table instead of throwing and being swallowed as 'none'.
+    if (!cds.model.definitions['cds.xt.Extensions']) {
+      const extCsn = await cds.load(`${__dirname}/../../db/extensions`)
+      Object.assign(cds.model.definitions, cds.linked(extCsn).definitions)
+    }
+
     let existingExt
     try {
       existingExt = await SELECT.one(1).from('cds.xt.Extensions')
@@ -53,7 +61,7 @@ cds.on('serving:cds.xt.DeploymentService', ds => {
 
     try {
       // can't use UPSERT here so @cds.on.insert still works for createdAt
-      await t0_(INSERT.into(Tenants, { ID: tenant, metadata: JSON.stringify(metadata), ...(schema ? { schema } : {}), version }))
+      await t0_(INSERT.into(Tenants, { ID: tenant, metadata: JSON.stringify(metadata), ...(schema ? { schema } : {}), version, status: SUBSCRIBED }))
     } catch (e) {
       if (e.message === 'ENTITY_ALREADY_EXISTS' || e.code === 301 || e.message.match(/unique constraint/i)) {
         await t0_(async () => {
@@ -65,7 +73,7 @@ cds.on('serving:cds.xt.DeploymentService', ds => {
             LOG.error('Failed to parse metadata to JSON', { error, metadata });
           }
           const merged = JSON.stringify(cds.utils.merge(existingMetadata, metadata))
-          await UPSERT.into(Tenants, { ID: tenant, metadata: merged, ...(schema ? { schema } : {}) })
+          await UPSERT.into(Tenants, { ID: tenant, metadata: merged, ...(schema ? { schema } : {}), status: SUBSCRIBED })
         })
       } else throw e
     }
@@ -82,6 +90,18 @@ cds.on('serving:cds.xt.DeploymentService', ds => {
     LOG.info('upgraded tenant', tenant)
   })
 
+  ds.before('unsubscribe', async req => {
+    const { tenant } = req.data
+    if (tenant === t0) return
+
+    const previous = await t0_(async () => {
+      const row = await SELECT.one.from(Tenants).columns('status', 'modifiedAt').where({ ID: tenant })
+      if (row) await UPDATE(Tenants).with({ status: UNSUBSCRIBING, modifiedAt: row.modifiedAt }).where({ ID: tenant })
+      return row
+    })
+    if (previous) req.on('failed', () => t0_(UPDATE(Tenants).with({ status: UNSUBSCRIPTION_FAILED, modifiedAt: previous.modifiedAt }).where({ ID: tenant, status: UNSUBSCRIBING })))
+  })
+
   ds.after('unsubscribe', async (_, req) => {
     const { tenant } = req.data
     if (tenant !== t0) await t0_(DELETE.from(Tenants).where({ ID: tenant }))
@@ -91,13 +111,13 @@ cds.on('serving:cds.xt.DeploymentService', ds => {
   ds.prepend(() => {
     ds.on('getTenants', async req => {
       const { options } = req.data ?? {}
-      const skipAfter = options?.skipAfter
+      const { skipAfter, status } = options ?? {}
       const query = skipAfter
-        ? SELECT.from(Tenants, tenant => { tenant.ID }).where('modifiedAt <', skipAfter)
-        : SELECT.from(Tenants, tenant => { tenant.ID })
+        ? SELECT.from(Tenants, tenant => { tenant.ID, tenant.status }).where('modifiedAt <', skipAfter)
+        : SELECT.from(Tenants, tenant => { tenant.ID, tenant.status })
       return (await cds.tx({ tenant: t0 }, tx =>
         tx.run(query)
-      )).map(({ ID }) => ID)
+      )).filter(tenant => !status || (tenant.status ?? SUBSCRIBED) === status).map(({ ID }) => ID)
     })
   })
 
@@ -124,14 +144,15 @@ cds.on('serving:cds.xt.DeploymentService', ds => {
     await ds.tx({ tenant: t0 }, async tx => {
       const csn = await cds.load(`${__dirname}/../../db/t0.cds`)
       const columns = await tx.getColumns(t0, _getT0TenantsTableName(csn), effectiveParams)
-      const needsT0Redeployment = !columns.some(c => c.toLowerCase() === 'version')
+      const needsT0Redeployment = !columns.some(c => c.toLowerCase() === 'status')
       if (!needsT0Redeployment) return
       await tx.subscribe({ tenant: t0, options: { csn, _: effectiveParams } })
     })
   }
-  cds.once('served', () => {
-    const cfInstanceIndex = process.env.CF_INSTANCE_INDEX
-    if (cfInstanceIndex && cfInstanceIndex !== '0') return
-    return _resubscribeT0IfNeeded()
-  })
+})
+
+cds.once('served', () => {
+  const cfInstanceIndex = process.env.CF_INSTANCE_INDEX
+  if (cfInstanceIndex && cfInstanceIndex !== '0') return
+  return module.exports.resubscribeT0IfNeeded?.()
 })

package/node_modules/@sap/cds-mtxs/srv/plugins/hana/ctnr-mgr-base.js

@@ -3,6 +3,9 @@ const { fs, path } = cds.utils
 const { token, fetchResiliently } = require('../../../lib/utils')
 const { t0 = 't0' } = cds.requires.multitenancy ?? {}
 
+// TMS-specific parameters that must not be forwarded to the Service Manager
+const TMS_ONLY_PARAMS = ['hana_tenant_prefix', 'hana_tenant_id', 'cleanup_hana_tenants', 'immediate_deletion']
+
 /* API */
 class AbstractContainerManagerClient {
 
@@ -15,6 +18,7 @@ class AbstractContainerManagerClient {
     this.version = JSON.parse(fs.readFileSync(path.join(__dirname, '../../../package.json'), 'utf8')).version
     this.cachedToken = null
     this.sm_url = null
+    this.sm_api_version = 'v1'
   }
 
   create = () => {
@@ -37,7 +41,8 @@ class AbstractContainerManagerClient {
   }
 
   deploy = (container, tenant, out, options, deployEnv) => {
-    return require('./hdi').deploy(container, tenant, out, options, deployEnv)
+    const hdi = cds.env.features?.native_hdi_deploy ? require('./hdi-native') : require('./hdi')
+    return hdi.deploy(container, tenant, out, options, deployEnv)
   }
 
   remove = async () => {
@@ -54,6 +59,15 @@ class AbstractContainerManagerClient {
     return `Bearer ${access_token}`
   }
 
+  _config = () => {
+    const { containerManager = {}, serviceManager = {} } = cds.requires?.multitenancy ?? {}
+    return {
+      retries: serviceManager.retries ?? containerManager.retries,
+      maxRetryAfter: serviceManager.maxRetryAfter ?? containerManager.maxRetryAfter,
+      lifecycleMaxRetryAfter: containerManager.lifecycleMaxRetryAfter
+    }
+  }
+
   fetchApi = async (url, conf, { failures = 0, retryUntil } = {}) => {
     const { version } = JSON.parse(fs.readFileSync(path.join(__dirname, '../../../package.json'), 'utf8'))
     conf.headers ??= {}
@@ -65,15 +79,18 @@ class AbstractContainerManagerClient {
     conf.headers['Client-Version'] ??= version
     conf.headers['X-CorrelationID'] ??= cds.context?.id
     conf.headers['X-Correlation-ID'] ??= cds.context?.id
-    conf.baseURL ??= url.startsWith('http') ? '' : this.sm_url + '/v1/'
+    conf.baseURL ??= url.startsWith('http') ? '' : this.sm_url + `/${this.sm_api_version}/`
 
-    const { retries, maxRetryAfter } = cds.requires?.multitenancy?.serviceManager ?? cds.requires?.multitenancy?.containerManager ?? {}
-    return fetchResiliently(conf.baseURL + url, conf, { retriesLeft: retries ?? 10, maxRetryAfter: maxRetryAfter ?? 5000, retryUntil, failures })
+    const { retries, maxRetryAfter, lifecycleMaxRetryAfter } = this._config()
+    const lifecycle = cds.context?.event === 'subscribe' || cds.context?.event === 'unsubscribe'
+    const retryAfter = lifecycle ? lifecycleMaxRetryAfter ?? maxRetryAfter : maxRetryAfter
+    return fetchResiliently(conf.baseURL + url, conf, { retries, maxRetryAfter: retryAfter, retryUntil, failures })
   }
 
   _poll = async (location, conf = {}) => {
     let attempts = 0, maxAttempts = 60, pollingTimeout = 3000, maxTime = pollingTimeout * maxAttempts / 1000
-    const url = location.includes('/v1/') ? location.slice('/v1/'.length) : location
+    const url = typeof location === 'string' && location.includes(`/${this.sm_api_version}/`) ? location.slice(`/${this.sm_api_version}/`.length) : location
+    if (!url) throw new Error('Service Manager did not return operation location')
     const _next = async (resolve, reject) => {
       let response
       try {
@@ -153,5 +170,6 @@ class AbstractContainerManagerClient {
 
 }
 
+AbstractContainerManagerClient.TMS_ONLY_PARAMS = TMS_ONLY_PARAMS
 
-module.exports = AbstractContainerManagerClient
+module.exports = AbstractContainerManagerClient

package/node_modules/@sap/cds-mtxs/srv/plugins/hana/hdi-ctnr-mgr.js

@@ -4,7 +4,9 @@ const { sm_url, baseurl, url, identity } = db.credentials || {}
 const LOG = cds.log('mtx')
 
 if (sm_url) {
-  module.exports = require('./srv-mgr')
+  module.exports = cds.env.features?.service_manager_v2
+    ? require('./srv-mgr-v2')
+    : require('./srv-mgr')
 } else if (baseurl) {
   if (cds.env.requires['cds.xt.SaasProvisioningService']?.upgrade?.ignoreNonExistingContainers) {
     LOG.warn('SaaS Provisioning Service is configured with ignoreNonExistingContainers. This can cause problems when using HANA TMS v2 as container manager.')