@1aboveio/skills 0.10.0

package/skills/engineering/resolve-release/scripts/fixtures/durable-processing-adapter.mjs

@@ -0,0 +1,169 @@
+const RECEIPT_SCHEMA = 'resolve-release/durable-processing-receipt@1'
+const isObject = (value) => value != null && typeof value === 'object' && !Array.isArray(value)
+
+export const DURABLE_PROCESSING_ADAPTER = Object.freeze({
+  schemaVersion: 1,
+  writerId: 'fixture-durable-processing-job',
+  pauseOrder: Object.freeze(['database-admission', 'worker-scheduling']),
+  resumeOrder: Object.freeze(['worker-scheduling', 'database-admission']),
+  quiescence: Object.freeze({
+    component: 'durable-state',
+    blockerField: 'blockers',
+    readyValue: 0,
+    timeoutMs: 1_000,
+  }),
+  evidenceSchema: RECEIPT_SCHEMA,
+  execute,
+})
+
+function receipt(request, state, durableState, observed, failed) {
+  return {
+    schema: RECEIPT_SCHEMA,
+    state,
+    operation: request.operation,
+    component: request.component,
+    requestId: request.requestId,
+    writer: { id: 'fixture-durable-processing-job' },
+    writtenAt: new Date().toISOString(),
+    generation: durableState.generation,
+    fence: durableState.fence,
+    observed,
+    ...(failed ? { failed } : {}),
+  }
+}
+
+function operationSignature(request) {
+  return JSON.stringify({
+    operation: request.operation,
+    component: request.component,
+    expectedGeneration: request.expectedGeneration,
+    expectedFence: request.expectedFence,
+    servingRevision: request.servingRevision,
+  })
+}
+
+function wrap(outputMode, value) {
+  if (outputMode === 'structured') return { payload: value }
+  if (outputMode === 'text') return { text: JSON.stringify(value) }
+  if (outputMode === 'malformed-text') return { text: '{not-json' }
+  if (outputMode === 'partial') return { payload: { schema: RECEIPT_SCHEMA } }
+  if (outputMode === 'ambiguous') return { payload: value, text: JSON.stringify(value) }
+  if (outputMode === 'wrong-writer') return { payload: { ...value, writer: { id: 'caller' } } }
+  if (outputMode === 'wrong-request') return { payload: { ...value, requestId: 'different-request' } }
+  if (outputMode === 'refused-without-failure') return { payload: { ...value, state: 'refused' } }
+  throw new Error(`unsupported fixture output mode: ${outputMode}`)
+}
+
+function readState(host, file) {
+  const state = JSON.parse(host.readTextFile(file))
+  if (!isObject(state) || !Array.isArray(state.history)) throw new Error('invalid fixture state')
+  return state
+}
+
+function writeState(host, file, state) {
+  host.writeTextFile(file, `${JSON.stringify(state, null, 2)}\n`)
+}
+
+function applyPause(state, component) {
+  if (component === 'database-admission') state.admissionPaused = true
+  else if (component === 'worker-scheduling') state.schedulingPaused = true
+  else return false
+  return true
+}
+
+function applyResume(state, component) {
+  if (component === 'database-admission') state.admissionPaused = false
+  else if (component === 'worker-scheduling') state.schedulingPaused = false
+  else return false
+  return true
+}
+
+function servingRevision(state) {
+  const traffic = state.traffic
+  if (!isObject(traffic)) return null
+  if (traffic.incumbentPercent === 100 && traffic.candidatePercent === 0) {
+    return traffic.incumbentRevision
+  }
+  if (traffic.candidatePercent === 100 && traffic.incumbentPercent === 0) {
+    return traffic.candidateRevision
+  }
+  return null
+}
+
+async function execute(request, config, host) {
+  if (request.schemaVersion !== 1 || !isObject(config) || typeof config.stateFile !== 'string'
+      || typeof host?.readTextFile !== 'function' || typeof host?.writeTextFile !== 'function') {
+    throw new Error('invalid fixture request')
+  }
+  const state = readState(host, config.stateFile)
+  const signature = operationSignature(request)
+  const prior = state.history.find((entry) => entry.requestId === request.requestId)
+  if (prior) {
+    const replay = prior.signature === signature
+      ? prior.receipt
+      : receipt(request, 'refused', state, { replay: true }, ['e:request-id-conflict'])
+    return wrap(config.outputMode, replay)
+  }
+
+  let result
+  if (request.operation === 'status') {
+    result = receipt(request, 'observed', state, {
+      admissionPaused: state.admissionPaused,
+      schedulingPaused: state.schedulingPaused,
+      blockers: state.blockers,
+      traffic: state.traffic,
+    })
+  } else if (
+    request.expectedGeneration !== state.generation
+    || request.expectedFence !== state.fence
+  ) {
+    result = receipt(request, 'refused', state, { casMatched: false }, ['e:stale-generation'])
+  } else if (request.operation === 'quiescence') {
+    result = receipt(request, 'observed', state, { blockers: state.blockers })
+  } else if (
+    request.operation === 'pause'
+    && request.component === 'worker-scheduling'
+    && state.refuseScheduling === true
+  ) {
+    result = receipt(request, 'refused', state, { applied: false }, ['e:scheduling-pause-refused'])
+  } else if (
+    request.operation === 'pause'
+    && request.component === 'worker-scheduling'
+    && state.admissionPaused !== true
+  ) {
+    result = receipt(request, 'refused', state, { applied: false }, ['e:pause-order-violation'])
+  } else if (request.operation === 'pause' && applyPause(state, request.component)) {
+    state.generation += 1
+    state.fence = `fence-${state.generation}`
+    result = receipt(request, 'applied', state, {
+      paused: true,
+      admissionPaused: state.admissionPaused,
+      schedulingPaused: state.schedulingPaused,
+    })
+  } else if (request.operation === 'resume' && servingRevision(state) !== request.servingRevision) {
+    result = receipt(request, 'refused', state, {
+      applied: false,
+      servingRevision: servingRevision(state),
+    }, ['e:serving-revision-unproven'])
+  } else if (
+    request.operation === 'resume'
+    && request.component === 'database-admission'
+    && state.schedulingPaused !== false
+  ) {
+    result = receipt(request, 'refused', state, { applied: false }, ['e:resume-order-violation'])
+  } else if (request.operation === 'resume' && applyResume(state, request.component)) {
+    state.generation += 1
+    state.fence = `fence-${state.generation}`
+    result = receipt(request, 'applied', state, {
+      resumed: true,
+      servingRevision: request.servingRevision,
+      admissionPaused: state.admissionPaused,
+      schedulingPaused: state.schedulingPaused,
+    })
+  } else {
+    result = receipt(request, 'refused', state, { applied: false }, ['e:unsupported-operation'])
+  }
+  state.history.push({ requestId: request.requestId, signature, receipt: result })
+  writeState(host, config.stateFile, state)
+  return wrap(config.outputMode, result)
+}