mirror of
https://github.com/whyour/qinglong.git
synced 2026-09-21 00:38:14 +08:00
1273 lines
37 KiB
JavaScript
1273 lines
37 KiB
JavaScript
#!/usr/bin/env node
|
|
|
|
'use strict';
|
|
|
|
const crypto = require('node:crypto');
|
|
const fs = require('node:fs');
|
|
const path = require('node:path');
|
|
const { spawnSync } = require('node:child_process');
|
|
|
|
const {
|
|
consumeLocalServiceManagerOutcome,
|
|
prepareLocalServiceManagerIntent,
|
|
} = require('../packages/ql3-local-owner-cli/dist/deployment/service-manager/serviceManagerIntent.js');
|
|
const {
|
|
consumeLocalServiceManagerCutoverOutcome,
|
|
} = require('../packages/ql3-local-owner-cli/dist/deployment/service-manager/serviceCutoverConsumer.js');
|
|
const {
|
|
cutoverDigest,
|
|
} = require('../packages/ql3-local-owner-cli/dist/deployment/cutover/targetEvidence.js');
|
|
const {
|
|
runLocalServiceBridgeCommandFile,
|
|
} = require('../packages/ql3-local-owner-cli/dist/deployment/service-manager/serviceBridge.js');
|
|
const {
|
|
runLocalServiceManagerLegacyRollbackBridgeCommandFile,
|
|
} = require('../packages/ql3-local-owner-cli/dist/deployment/service-manager/legacy-rollback/bridge.js');
|
|
const {
|
|
localServiceManagerLegacyStartOutcomePath,
|
|
} = require('../packages/ql3-local-owner-cli/dist/deployment/service-manager/legacy-rollback/contract.js');
|
|
|
|
const OWNER_DEPLOYMENT_CLI = path.resolve(
|
|
__dirname,
|
|
'../packages/ql3-local-owner-cli/dist/deployment/localDeploymentCli.js',
|
|
);
|
|
const NON_ROOT_SERVICE_UID = 10001;
|
|
|
|
class QingLong3ServiceManagerBridgeLiveActorError extends Error {
|
|
constructor(message) {
|
|
super(message);
|
|
this.name = 'QingLong3ServiceManagerBridgeLiveActorError';
|
|
}
|
|
}
|
|
|
|
function fail(message) {
|
|
throw new QingLong3ServiceManagerBridgeLiveActorError(message);
|
|
}
|
|
|
|
function run(executable, args, accepted = [0]) {
|
|
const result = spawnSync(executable, args, {
|
|
encoding: 'utf8',
|
|
timeout: 30_000,
|
|
maxBuffer: 64 * 1024,
|
|
});
|
|
if (
|
|
result.error ||
|
|
result.signal !== null ||
|
|
!accepted.includes(result.status)
|
|
) {
|
|
fail(
|
|
`${path.basename(executable)} ${args.join(' ')} failed: ${String(
|
|
result.stderr ?? '',
|
|
).slice(0, 512)}`,
|
|
);
|
|
}
|
|
return String(result.stdout ?? '');
|
|
}
|
|
|
|
function responseLossManager(request) {
|
|
const result = spawnSync(request.executable, [...request.args], {
|
|
encoding: 'utf8',
|
|
env: {
|
|
PATH: '/usr/sbin:/usr/bin:/sbin:/bin',
|
|
LANG: 'C',
|
|
LC_ALL: 'C',
|
|
},
|
|
timeout: request.timeoutMs,
|
|
maxBuffer: 64 * 1024,
|
|
});
|
|
const legacyStart =
|
|
(request.args[0] === 'start' && request.args[1] === 'qinglong.service') ||
|
|
(request.args[0] === 'qinglong' && request.args[1] === 'start');
|
|
return {
|
|
status: legacyStart ? null : result.status,
|
|
signal: result.signal,
|
|
stdout: String(result.stdout ?? ''),
|
|
stderr: String(result.stderr ?? ''),
|
|
responseLost:
|
|
legacyStart || result.error !== undefined || result.status === null,
|
|
};
|
|
}
|
|
|
|
function executable(candidates, label) {
|
|
for (const candidate of candidates) {
|
|
if (fs.existsSync(candidate)) return fs.realpathSync(candidate);
|
|
}
|
|
fail(`${label} executable is unavailable`);
|
|
}
|
|
|
|
function writePrivate(filePath, contents, mode = 0o600, uid = 0, gid = 0) {
|
|
fs.writeFileSync(filePath, contents, { flag: 'wx', mode });
|
|
fs.chownSync(filePath, uid, gid);
|
|
fs.chmodSync(filePath, mode);
|
|
}
|
|
|
|
function descriptor(kind, uid, gid, root, adopted = false) {
|
|
const command = adopted ? fs.realpathSync(process.execPath) : '/bin/sleep';
|
|
const commandArgs = adopted
|
|
? `/workspace/scripts/ql3-service-manager-adopted-live-service.cjs ${root}/local-application.json`
|
|
: '300';
|
|
if (kind === 'systemd') {
|
|
return [
|
|
'[Unit]',
|
|
'Description=QingLong 3 bridge live gate',
|
|
'',
|
|
'[Service]',
|
|
'Type=simple',
|
|
`User=${uid}`,
|
|
`Group=${gid}`,
|
|
`ExecStart=${command} ${commandArgs}`,
|
|
'Restart=no',
|
|
'',
|
|
'[Install]',
|
|
'WantedBy=multi-user.target',
|
|
'',
|
|
].join('\n');
|
|
}
|
|
return [
|
|
'#!/sbin/openrc-run',
|
|
'name="qinglong3"',
|
|
'description="QingLong 3 bridge live gate"',
|
|
`command="${command}"`,
|
|
`command_args="${commandArgs}"`,
|
|
`command_user="${uid}:${gid}"`,
|
|
'supervisor="supervise-daemon"',
|
|
'retry="TERM/5/KILL/2"',
|
|
'',
|
|
].join('\n');
|
|
}
|
|
|
|
function legacyDescriptor(kind, uid, gid, port) {
|
|
const nodeExecutable = fs.realpathSync(process.execPath);
|
|
const commandArgs = `/workspace/scripts/ql3-service-manager-legacy-live-service.cjs ${port}`;
|
|
if (kind === 'systemd') {
|
|
return [
|
|
'[Unit]',
|
|
'Description=QingLong 2 legacy rollback live gate',
|
|
'',
|
|
'[Service]',
|
|
'Type=simple',
|
|
`User=${uid}`,
|
|
`Group=${gid}`,
|
|
`ExecStart=${nodeExecutable} ${commandArgs}`,
|
|
'Restart=no',
|
|
'',
|
|
'[Install]',
|
|
'WantedBy=multi-user.target',
|
|
'',
|
|
].join('\n');
|
|
}
|
|
return [
|
|
'#!/sbin/openrc-run',
|
|
'name="qinglong"',
|
|
'description="QingLong 2 legacy rollback live gate"',
|
|
`command="${nodeExecutable}"`,
|
|
`command_args="${commandArgs}"`,
|
|
`command_user="${uid}:${gid}"`,
|
|
'supervisor="supervise-daemon"',
|
|
'retry="TERM/5/KILL/2"',
|
|
'',
|
|
].join('\n');
|
|
}
|
|
|
|
function manager(kind) {
|
|
if (kind === 'systemd') {
|
|
return {
|
|
kind,
|
|
executable: executable(
|
|
['/usr/bin/systemctl', '/bin/systemctl'],
|
|
'systemctl',
|
|
),
|
|
};
|
|
}
|
|
return {
|
|
kind,
|
|
serviceExecutable: executable(
|
|
['/sbin/rc-service', '/usr/sbin/rc-service'],
|
|
'rc-service',
|
|
),
|
|
updateExecutable: executable(
|
|
['/sbin/rc-update', '/usr/sbin/rc-update'],
|
|
'rc-update',
|
|
),
|
|
};
|
|
}
|
|
|
|
function actionId(kind, suffix) {
|
|
const prefix = kind === 'systemd' ? '51' : '61';
|
|
return `123e4567-e89b-42d3-a456-42661417${prefix}${suffix}`;
|
|
}
|
|
|
|
function ownerCli(uid, gid, operation, commandPath) {
|
|
const result = spawnSync(
|
|
process.execPath,
|
|
[OWNER_DEPLOYMENT_CLI, operation, '--command-file', commandPath],
|
|
{
|
|
uid,
|
|
gid,
|
|
encoding: 'utf8',
|
|
timeout: 30_000,
|
|
maxBuffer: 64 * 1024,
|
|
},
|
|
);
|
|
if (result.error || result.signal !== null || result.status !== 0) {
|
|
fail(
|
|
`Owner ${operation} failed: ${String(result.stderr ?? '').slice(0, 512)}`,
|
|
);
|
|
}
|
|
return JSON.parse(String(result.stdout ?? ''));
|
|
}
|
|
|
|
function prepare(
|
|
root,
|
|
kind,
|
|
suffix,
|
|
action,
|
|
uid,
|
|
gid,
|
|
lineage = { mode: 'fresh' },
|
|
) {
|
|
const command = {
|
|
schemaVersion: 1,
|
|
operation: 'local.deployment.service-manager.intent.prepare',
|
|
options: { deploymentRoot: root, allowRootService: uid === 0 },
|
|
request: {
|
|
actionId: actionId(kind, suffix),
|
|
action,
|
|
serviceKind: kind,
|
|
lineage,
|
|
requestedAtMs: Date.now(),
|
|
},
|
|
};
|
|
if (uid === 0) return prepareLocalServiceManagerIntent(command);
|
|
const commandPath = path.join(
|
|
root,
|
|
`${actionId(kind, suffix)}.owner-intent.json`,
|
|
);
|
|
writePrivate(
|
|
commandPath,
|
|
`${JSON.stringify(command, null, 2)}\n`,
|
|
0o600,
|
|
uid,
|
|
gid,
|
|
);
|
|
return ownerCli(uid, gid, 'service-intent-prepare', commandPath);
|
|
}
|
|
|
|
function replacePrivate(filePath, contents, mode, uid, gid) {
|
|
fs.rmSync(filePath, { force: true });
|
|
writePrivate(filePath, contents, mode, uid, gid);
|
|
}
|
|
|
|
function adoptedFixture(root, kind, uid, gid) {
|
|
const cutoverId = `${kind}-${uid === 0 ? 'root' : 'nonroot'}-cutover`;
|
|
const journal = path.join(root, 'service', 'cutovers', cutoverId);
|
|
fs.mkdirSync(journal, { recursive: true, mode: 0o700 });
|
|
fs.chownSync(path.join(root, 'service', 'cutovers'), uid, gid);
|
|
fs.chownSync(journal, uid, gid);
|
|
const sourcePath = path.join(root, 'legacy.sqlite');
|
|
const targetPath = path.join(root, 'target.sqlite');
|
|
const recoveryPath = path.join(root, 'recovery.sqlite');
|
|
const manifestPath = path.join(root, 'manifest.json');
|
|
const activationPath = path.join(root, 'activation.json');
|
|
writePrivate(sourcePath, 'legacy\n', 0o600, uid, gid);
|
|
writePrivate(targetPath, 'target\n', 0o600, uid, gid);
|
|
writePrivate(recoveryPath, 'legacy\n', 0o600, uid, gid);
|
|
const manifestPayload = {
|
|
schemaVersion: 1,
|
|
kind: 'qinglong3-local-adoption-manifest-live-fixture',
|
|
};
|
|
const manifestDigest = cutoverDigest(manifestPayload);
|
|
writePrivate(
|
|
manifestPath,
|
|
`${JSON.stringify({ ...manifestPayload, manifestDigest })}\n`,
|
|
0o600,
|
|
uid,
|
|
gid,
|
|
);
|
|
const target = fs.statSync(targetPath, { bigint: true });
|
|
const activationPayload = {
|
|
schemaVersion: 1,
|
|
kind: 'qinglong3-local-sqlite-activation',
|
|
state: 'prepared',
|
|
profile: 'edge',
|
|
createdAtMs: Date.now(),
|
|
adoptionManifestDigest: manifestDigest,
|
|
planDigest: '2'.repeat(64),
|
|
sourcePathDigest: crypto
|
|
.createHash('sha256')
|
|
.update(sourcePath)
|
|
.digest('hex'),
|
|
sourceSha256: crypto
|
|
.createHash('sha256')
|
|
.update(fs.readFileSync(sourcePath))
|
|
.digest('hex'),
|
|
recoverySha256: crypto
|
|
.createHash('sha256')
|
|
.update(fs.readFileSync(recoveryPath))
|
|
.digest('hex'),
|
|
targetSha256: crypto
|
|
.createHash('sha256')
|
|
.update(fs.readFileSync(targetPath))
|
|
.digest('hex'),
|
|
targetPathDigest: crypto
|
|
.createHash('sha256')
|
|
.update(targetPath)
|
|
.digest('hex'),
|
|
targetDevice: target.dev.toString(),
|
|
targetInode: target.ino.toString(),
|
|
};
|
|
const activationDigest = cutoverDigest(activationPayload);
|
|
writePrivate(
|
|
activationPath,
|
|
`${JSON.stringify({ ...activationPayload, activationDigest })}\n`,
|
|
0o600,
|
|
uid,
|
|
gid,
|
|
);
|
|
const commitmentPayload = {
|
|
schemaVersion: 1,
|
|
kind: 'qinglong3-local-legacy-silence-commitment',
|
|
state: 'legacy_stopped',
|
|
cutoverId,
|
|
profile: 'edge',
|
|
instanceId: `${kind}-${uid === 0 ? 'root' : 'nonroot'}-live-edge`,
|
|
activationDigest,
|
|
requestedAtMs: Date.now(),
|
|
observedAtMs: Date.now(),
|
|
previousRecordDigest: '3'.repeat(64),
|
|
controller: {
|
|
kind: 'docker',
|
|
endpointDigest: '4'.repeat(64),
|
|
legacyContainerId: '5'.repeat(64),
|
|
legacyContainerIdentityDigest: '6'.repeat(64),
|
|
legacySourceBindingDigest: '7'.repeat(64),
|
|
},
|
|
};
|
|
const commitmentDigest = cutoverDigest(commitmentPayload);
|
|
const commitmentPath = path.join(journal, '0002-legacy-stopped.json');
|
|
writePrivate(
|
|
commitmentPath,
|
|
`${JSON.stringify({ ...commitmentPayload, commitmentDigest })}\n`,
|
|
0o600,
|
|
uid,
|
|
gid,
|
|
);
|
|
replacePrivate(
|
|
path.join(root, 'local-application.json'),
|
|
`${JSON.stringify({
|
|
schema: 'qinglong/local-application-process@v3',
|
|
instanceId: commitmentPayload.instanceId,
|
|
profile: 'edge',
|
|
storage: {
|
|
mode: 'adopted',
|
|
sourcePath,
|
|
targetPath,
|
|
recoveryPath,
|
|
manifestPath,
|
|
activationPath,
|
|
expectedActivationDigest: activationDigest,
|
|
},
|
|
runtime: {},
|
|
pluginPackages: {},
|
|
ai: { deployment: 'excluded' },
|
|
cutover: {
|
|
cutoverId,
|
|
commitmentPath,
|
|
expectedCommitmentDigest: commitmentDigest,
|
|
},
|
|
})}\n`,
|
|
0o600,
|
|
uid,
|
|
gid,
|
|
);
|
|
replacePrivate(
|
|
path.join(
|
|
root,
|
|
'service',
|
|
kind === 'systemd' ? 'qinglong3.service' : 'qinglong3.openrc',
|
|
),
|
|
descriptor(kind, uid, gid, root, true),
|
|
kind === 'systemd' ? 0o600 : 0o700,
|
|
uid,
|
|
gid,
|
|
);
|
|
const instanceRoot = path.join(root, 'service', 'cutover-instances');
|
|
const instanceDirectory = path.join(
|
|
instanceRoot,
|
|
commitmentPayload.instanceId,
|
|
);
|
|
fs.mkdirSync(instanceDirectory, { recursive: true, mode: 0o700 });
|
|
fs.chownSync(instanceRoot, uid, gid);
|
|
fs.chownSync(instanceDirectory, uid, gid);
|
|
const initialPayload = {
|
|
schema: 'qinglong3-local-cutover-instance-head',
|
|
schemaVersion: 1,
|
|
revision: 1,
|
|
instanceId: commitmentPayload.instanceId,
|
|
profile: 'edge',
|
|
cutoverId,
|
|
activationDigest,
|
|
state: 'legacy_stop_requested',
|
|
generation: 0,
|
|
previousHeadDigest: '0'.repeat(64),
|
|
sourceRecordDigest: '8'.repeat(64),
|
|
updatedAtMs: Date.now(),
|
|
};
|
|
const initialHeadDigest = cutoverDigest(initialPayload);
|
|
const headPayload = {
|
|
...initialPayload,
|
|
revision: 2,
|
|
state: 'legacy_stopped',
|
|
previousHeadDigest: initialHeadDigest,
|
|
sourceRecordDigest: commitmentDigest,
|
|
};
|
|
writePrivate(
|
|
path.join(instanceDirectory, 'head.json'),
|
|
`${JSON.stringify(
|
|
{
|
|
...headPayload,
|
|
headDigest: cutoverDigest(headPayload),
|
|
},
|
|
null,
|
|
2,
|
|
)}\n`,
|
|
0o600,
|
|
uid,
|
|
gid,
|
|
);
|
|
return {
|
|
cutoverId,
|
|
instanceId: commitmentPayload.instanceId,
|
|
activationDigest,
|
|
commitmentDigest,
|
|
};
|
|
}
|
|
|
|
async function consumeCutover(root, prepared, uid, gid) {
|
|
const command = {
|
|
schemaVersion: 1,
|
|
operation: 'local.deployment.service-manager.cutover.consume',
|
|
options: {
|
|
deploymentRoot: root,
|
|
allowRootService: uid === 0,
|
|
startupTimeoutMs: 30_000,
|
|
startupPollMs: 50,
|
|
},
|
|
request: {
|
|
actionId: prepared.actionId,
|
|
expectedIntentDigest: prepared.intentDigest,
|
|
},
|
|
};
|
|
if (uid === 0) return consumeLocalServiceManagerCutoverOutcome(command);
|
|
const commandPath = path.join(
|
|
root,
|
|
`${prepared.actionId}.owner-cutover-consume.json`,
|
|
);
|
|
writePrivate(
|
|
commandPath,
|
|
`${JSON.stringify(command, null, 2)}\n`,
|
|
0o600,
|
|
uid,
|
|
gid,
|
|
);
|
|
return ownerCli(uid, gid, 'service-cutover-consume', commandPath);
|
|
}
|
|
|
|
function prepareAdoptedRollback(root, adopted, stopped, uid, gid) {
|
|
const command = {
|
|
schemaVersion: 1,
|
|
operation: 'local.deployment.service-manager.legacy-rollback.prepare',
|
|
options: { deploymentRoot: root, allowRootService: uid === 0 },
|
|
request: {
|
|
cutoverId: adopted.cutoverId,
|
|
profile: 'edge',
|
|
instanceId: adopted.instanceId,
|
|
generation: 1,
|
|
expectedActivationDigest: adopted.activationDigest,
|
|
expectedStoppedRecordDigest: stopped.recordDigest,
|
|
expectedInstanceHeadDigest: stopped.instanceHeadDigest,
|
|
requestedAtMs: Date.now(),
|
|
},
|
|
};
|
|
const commandPath = path.join(root, 'owner-legacy-rollback-prepare.json');
|
|
writePrivate(
|
|
commandPath,
|
|
`${JSON.stringify(command, null, 2)}\n`,
|
|
0o600,
|
|
uid,
|
|
gid,
|
|
);
|
|
return {
|
|
commandPath,
|
|
result: ownerCli(uid, gid, 'service-legacy-rollback-prepare', commandPath),
|
|
};
|
|
}
|
|
|
|
function authorizeAdoptedRollback(root, adopted, prepared, uid, gid) {
|
|
const command = {
|
|
schemaVersion: 1,
|
|
operation: 'local.deployment.service-manager.legacy-rollback.authorize',
|
|
options: { deploymentRoot: root, allowRootService: uid === 0 },
|
|
request: {
|
|
cutoverId: adopted.cutoverId,
|
|
profile: 'edge',
|
|
instanceId: adopted.instanceId,
|
|
generation: 1,
|
|
expectedActivationDigest: adopted.activationDigest,
|
|
expectedPreparationDigest: prepared.preparationDigest,
|
|
expectedInstanceHeadDigest: prepared.instanceHeadDigest,
|
|
requestedAtMs: Date.now(),
|
|
},
|
|
};
|
|
const commandPath = path.join(root, 'owner-legacy-rollback-authorize.json');
|
|
writePrivate(
|
|
commandPath,
|
|
`${JSON.stringify(command, null, 2)}\n`,
|
|
0o600,
|
|
uid,
|
|
gid,
|
|
);
|
|
return {
|
|
commandPath,
|
|
result: ownerCli(
|
|
uid,
|
|
gid,
|
|
'service-legacy-rollback-authorize',
|
|
commandPath,
|
|
),
|
|
};
|
|
}
|
|
|
|
function installLegacyService(kind, managerOptions, uid, gid, port) {
|
|
const descriptorPath =
|
|
kind === 'systemd'
|
|
? '/etc/systemd/system/qinglong.service'
|
|
: '/etc/init.d/qinglong';
|
|
fs.rmSync(descriptorPath, { force: true });
|
|
writePrivate(
|
|
descriptorPath,
|
|
legacyDescriptor(kind, uid, gid, port),
|
|
kind === 'systemd' ? 0o644 : 0o755,
|
|
0,
|
|
0,
|
|
);
|
|
if (kind === 'systemd') {
|
|
run(managerOptions.executable, ['daemon-reload']);
|
|
}
|
|
}
|
|
|
|
function executeLegacyRollback(
|
|
root,
|
|
controllerRoot,
|
|
managerOptions,
|
|
adopted,
|
|
prepared,
|
|
authorized,
|
|
uid,
|
|
gid,
|
|
) {
|
|
const command = {
|
|
schemaVersion: 1,
|
|
operation: 'local.deployment.service-manager.legacy-rollback.execute',
|
|
options: {
|
|
deploymentRoot: root,
|
|
controllerRoot,
|
|
allowRootController: true,
|
|
manager: managerOptions,
|
|
},
|
|
request: {
|
|
cutoverId: adopted.cutoverId,
|
|
generation: 1,
|
|
expectedAuthorizationDigest: authorized.authorizationDigest,
|
|
},
|
|
};
|
|
const commandPath = path.join(root, 'root-legacy-rollback-command.json');
|
|
writePrivate(commandPath, `${JSON.stringify(command, null, 2)}\n`);
|
|
const result = runLocalServiceManagerLegacyRollbackBridgeCommandFile(
|
|
commandPath,
|
|
{ runManager: responseLossManager },
|
|
);
|
|
const replay =
|
|
runLocalServiceManagerLegacyRollbackBridgeCommandFile(commandPath);
|
|
const consumeCommand = {
|
|
schemaVersion: 1,
|
|
operation: 'local.deployment.service-manager.legacy-rollback.consume',
|
|
options: { deploymentRoot: root, allowRootService: uid === 0 },
|
|
request: {
|
|
cutoverId: adopted.cutoverId,
|
|
profile: 'edge',
|
|
instanceId: adopted.instanceId,
|
|
generation: 1,
|
|
expectedActivationDigest: adopted.activationDigest,
|
|
expectedPreparationDigest: prepared.preparationDigest,
|
|
expectedAuthorizationDigest: authorized.authorizationDigest,
|
|
expectedAuthorizationHeadDigest: authorized.instanceHeadDigest,
|
|
requestedAtMs: Date.now(),
|
|
},
|
|
};
|
|
const consumePath = path.join(root, 'owner-legacy-rollback-consume.json');
|
|
writePrivate(
|
|
consumePath,
|
|
`${JSON.stringify(consumeCommand, null, 2)}\n`,
|
|
0o600,
|
|
uid,
|
|
gid,
|
|
);
|
|
const consumed = ownerCli(
|
|
uid,
|
|
gid,
|
|
'service-legacy-rollback-consume',
|
|
consumePath,
|
|
);
|
|
const outcome = JSON.parse(
|
|
fs.readFileSync(
|
|
localServiceManagerLegacyStartOutcomePath(root, adopted.cutoverId, 1),
|
|
'utf8',
|
|
),
|
|
);
|
|
return { commandPath, result, replay, consumed, outcome };
|
|
}
|
|
|
|
function proveLegacyReadiness(
|
|
root,
|
|
adopted,
|
|
consumed,
|
|
uid,
|
|
gid,
|
|
legacyHttpPort,
|
|
) {
|
|
const command = {
|
|
schemaVersion: 1,
|
|
operation: 'local.deployment.cutover.legacy-readiness-probe',
|
|
options: { deploymentRoot: root, allowRootService: uid === 0 },
|
|
request: {
|
|
cutoverId: adopted.cutoverId,
|
|
profile: 'edge',
|
|
instanceId: adopted.instanceId,
|
|
generation: 1,
|
|
expectedActivationDigest: adopted.activationDigest,
|
|
expectedInstanceHeadDigest: consumed.instanceHeadDigest,
|
|
expectedLegacyRunningRecordDigest: consumed.completionDigest,
|
|
legacyHttpPort,
|
|
expectedLegacyVersion: '2.21.0',
|
|
requestedAtMs: Date.now(),
|
|
},
|
|
};
|
|
const commandPath = path.join(root, 'owner-legacy-readiness-probe.json');
|
|
writePrivate(
|
|
commandPath,
|
|
`${JSON.stringify(command, null, 2)}\n`,
|
|
0o600,
|
|
uid,
|
|
gid,
|
|
);
|
|
const result = ownerCli(
|
|
uid,
|
|
gid,
|
|
'cutover-legacy-readiness-probe',
|
|
commandPath,
|
|
);
|
|
const replay = ownerCli(
|
|
uid,
|
|
gid,
|
|
'cutover-legacy-readiness-probe',
|
|
commandPath,
|
|
);
|
|
return { commandPath, result, replay };
|
|
}
|
|
|
|
function executeLegacyRollbackBarrierCrash(
|
|
root,
|
|
controllerRoot,
|
|
managerOptions,
|
|
adopted,
|
|
prepared,
|
|
authorized,
|
|
uid,
|
|
gid,
|
|
) {
|
|
const command = {
|
|
schemaVersion: 1,
|
|
operation: 'local.deployment.service-manager.legacy-rollback.execute',
|
|
options: {
|
|
deploymentRoot: root,
|
|
controllerRoot,
|
|
allowRootController: true,
|
|
manager: managerOptions,
|
|
},
|
|
request: {
|
|
cutoverId: adopted.cutoverId,
|
|
generation: 1,
|
|
expectedAuthorizationDigest: authorized.authorizationDigest,
|
|
},
|
|
};
|
|
const commandPath = path.join(
|
|
root,
|
|
'root-legacy-rollback-barrier-crash-command.json',
|
|
);
|
|
writePrivate(commandPath, `${JSON.stringify(command, null, 2)}\n`);
|
|
let interrupted = false;
|
|
try {
|
|
runLocalServiceManagerLegacyRollbackBridgeCommandFile(commandPath, {
|
|
afterBarrier() {
|
|
throw new QingLong3ServiceManagerBridgeLiveActorError(
|
|
'simulated crash after legacy start barrier',
|
|
);
|
|
},
|
|
});
|
|
} catch (error) {
|
|
interrupted =
|
|
error instanceof QingLong3ServiceManagerBridgeLiveActorError &&
|
|
error.message === 'simulated crash after legacy start barrier';
|
|
}
|
|
if (!interrupted) fail('legacy start barrier crash was not observed');
|
|
const result =
|
|
runLocalServiceManagerLegacyRollbackBridgeCommandFile(commandPath);
|
|
const replay =
|
|
runLocalServiceManagerLegacyRollbackBridgeCommandFile(commandPath);
|
|
const consumeCommand = {
|
|
schemaVersion: 1,
|
|
operation: 'local.deployment.service-manager.legacy-rollback.consume',
|
|
options: { deploymentRoot: root, allowRootService: uid === 0 },
|
|
request: {
|
|
cutoverId: adopted.cutoverId,
|
|
profile: 'edge',
|
|
instanceId: adopted.instanceId,
|
|
generation: 1,
|
|
expectedActivationDigest: adopted.activationDigest,
|
|
expectedPreparationDigest: prepared.preparationDigest,
|
|
expectedAuthorizationDigest: authorized.authorizationDigest,
|
|
expectedAuthorizationHeadDigest: authorized.instanceHeadDigest,
|
|
requestedAtMs: Date.now(),
|
|
},
|
|
};
|
|
const consumePath = path.join(
|
|
root,
|
|
'owner-legacy-rollback-barrier-crash-consume.json',
|
|
);
|
|
writePrivate(
|
|
consumePath,
|
|
`${JSON.stringify(consumeCommand, null, 2)}\n`,
|
|
0o600,
|
|
uid,
|
|
gid,
|
|
);
|
|
const consumed = ownerCli(
|
|
uid,
|
|
gid,
|
|
'service-legacy-rollback-consume',
|
|
consumePath,
|
|
);
|
|
const outcome = JSON.parse(
|
|
fs.readFileSync(
|
|
localServiceManagerLegacyStartOutcomePath(root, adopted.cutoverId, 1),
|
|
'utf8',
|
|
),
|
|
);
|
|
return { commandPath, result, replay, consumed, outcome };
|
|
}
|
|
|
|
function execute(root, controllerRoot, managerOptions, prepared, uid, gid) {
|
|
const command = {
|
|
schemaVersion: 1,
|
|
operation: 'local.deployment.service-manager.execute',
|
|
options: {
|
|
controllerRoot,
|
|
allowRootController: true,
|
|
manager: managerOptions,
|
|
},
|
|
request: {
|
|
intentPath: prepared.intentPath,
|
|
expectedIntentDigest: prepared.intentDigest,
|
|
},
|
|
};
|
|
const commandPath = path.join(root, `${prepared.actionId}.root-command.json`);
|
|
writePrivate(commandPath, `${JSON.stringify(command, null, 2)}\n`);
|
|
const result = runLocalServiceBridgeCommandFile(commandPath);
|
|
const consumeCommand = {
|
|
schemaVersion: 1,
|
|
operation: 'local.deployment.service-manager.outcome.consume',
|
|
options: { deploymentRoot: root, allowRootService: uid === 0 },
|
|
request: {
|
|
actionId: prepared.actionId,
|
|
expectedIntentDigest: prepared.intentDigest,
|
|
},
|
|
};
|
|
let consumed;
|
|
if (uid === 0) {
|
|
consumed = consumeLocalServiceManagerOutcome(consumeCommand);
|
|
} else {
|
|
const consumePath = path.join(
|
|
root,
|
|
`${prepared.actionId}.owner-consume.json`,
|
|
);
|
|
writePrivate(
|
|
consumePath,
|
|
`${JSON.stringify(consumeCommand, null, 2)}\n`,
|
|
0o600,
|
|
uid,
|
|
gid,
|
|
);
|
|
consumed = ownerCli(uid, gid, 'service-outcome-consume', consumePath);
|
|
}
|
|
return { commandPath, result, consumed };
|
|
}
|
|
|
|
function serviceProcessUid(
|
|
kind,
|
|
outcome,
|
|
expectedCommand = '/bin/sleep',
|
|
expectedArguments = ['300'],
|
|
) {
|
|
let pid = kind === 'systemd' ? outcome.observation.mainPid : 0;
|
|
if (kind === 'openrc') {
|
|
for (const entry of fs.readdirSync('/proc')) {
|
|
if (!/^\d+$/.test(entry)) continue;
|
|
try {
|
|
const command = fs
|
|
.readFileSync(`/proc/${entry}/cmdline`, 'utf8')
|
|
.split('\0');
|
|
if (
|
|
command[0] === expectedCommand &&
|
|
expectedArguments.every(
|
|
(argument, index) => command[index + 1] === argument,
|
|
)
|
|
) {
|
|
pid = Number(entry);
|
|
break;
|
|
}
|
|
} catch {
|
|
// Processes can disappear during the bounded scan.
|
|
}
|
|
}
|
|
}
|
|
if (!Number.isSafeInteger(pid) || pid < 1) fail('service PID is unproved');
|
|
const status = fs.readFileSync(`/proc/${pid}/status`, 'utf8');
|
|
const match = /^Uid:\s+(\d+)\s/m.exec(status);
|
|
if (!match) fail('service process UID is unavailable');
|
|
return Number(match[1]);
|
|
}
|
|
|
|
function cleanup(kind, managerOptions) {
|
|
if (kind === 'systemd') {
|
|
for (const serviceName of ['qinglong', 'qinglong3']) {
|
|
spawnSync(
|
|
managerOptions.executable,
|
|
['disable', '--now', `${serviceName}.service`],
|
|
{ timeout: 10_000 },
|
|
);
|
|
fs.rmSync(`/etc/systemd/system/${serviceName}.service`, { force: true });
|
|
}
|
|
spawnSync(managerOptions.executable, ['daemon-reload'], {
|
|
timeout: 10_000,
|
|
});
|
|
return;
|
|
}
|
|
for (const serviceName of ['qinglong', 'qinglong3']) {
|
|
spawnSync(managerOptions.serviceExecutable, [serviceName, 'stop'], {
|
|
timeout: 10_000,
|
|
});
|
|
spawnSync(
|
|
managerOptions.updateExecutable,
|
|
['del', serviceName, 'default'],
|
|
{ timeout: 10_000 },
|
|
);
|
|
fs.rmSync(`/etc/init.d/${serviceName}`, { force: true });
|
|
}
|
|
}
|
|
|
|
async function main(argv) {
|
|
if (process.getuid?.() !== 0 || process.geteuid?.() !== 0) {
|
|
fail('live actor must run as root');
|
|
}
|
|
const kind = argv[0];
|
|
const identityMode = argv[1];
|
|
const scenario = argv[2] ?? 'success';
|
|
if (
|
|
(kind !== 'systemd' && kind !== 'openrc') ||
|
|
(identityMode !== 'root' && identityMode !== 'nonroot') ||
|
|
(scenario !== 'success' && scenario !== 'barrier-crash')
|
|
) {
|
|
fail(
|
|
'usage: ql3-service-manager-bridge-live-actor.cjs <systemd|openrc> <root|nonroot> [success|barrier-crash]',
|
|
);
|
|
}
|
|
const uid = identityMode === 'root' ? 0 : NON_ROOT_SERVICE_UID;
|
|
const gid = uid;
|
|
const legacyHttpPort = 15_700;
|
|
const root = `/var/lib/ql3-service-manager-${kind}-${identityMode}`;
|
|
const controllerRoot = `/var/lib/ql3-service-bridge-${kind}-${identityMode}`;
|
|
fs.rmSync(root, { force: true, recursive: true });
|
|
fs.rmSync(controllerRoot, { force: true, recursive: true });
|
|
fs.mkdirSync(root, { mode: 0o700 });
|
|
fs.mkdirSync(path.join(root, 'service'), { mode: 0o700 });
|
|
fs.chownSync(root, uid, gid);
|
|
fs.chownSync(path.join(root, 'service'), uid, gid);
|
|
writePrivate(
|
|
path.join(root, 'local-application.json'),
|
|
`${JSON.stringify({
|
|
schema: 'qinglong/local-application-process@v2',
|
|
instanceId: `${kind}-${identityMode}-live-edge`,
|
|
profile: 'edge',
|
|
storage: { mode: 'fresh' },
|
|
})}\n`,
|
|
0o600,
|
|
uid,
|
|
gid,
|
|
);
|
|
writePrivate(
|
|
path.join(
|
|
root,
|
|
'service',
|
|
kind === 'systemd' ? 'qinglong3.service' : 'qinglong3.openrc',
|
|
),
|
|
descriptor(kind, uid, gid),
|
|
kind === 'systemd' ? 0o600 : 0o700,
|
|
uid,
|
|
gid,
|
|
);
|
|
const managerOptions = manager(kind);
|
|
try {
|
|
const install = prepare(root, kind, '01', 'install-enable-start', uid, gid);
|
|
const installed = execute(
|
|
root,
|
|
controllerRoot,
|
|
managerOptions,
|
|
install,
|
|
uid,
|
|
gid,
|
|
);
|
|
if (
|
|
installed.result.state !== 'active' ||
|
|
installed.consumed.state !== 'active'
|
|
) {
|
|
fail(
|
|
`install-enable-start did not prove active: ${JSON.stringify(
|
|
installed,
|
|
)} outcome=${fs.readFileSync(install.outcomePath, 'utf8').trim()}`,
|
|
);
|
|
}
|
|
const installedOutcome = JSON.parse(
|
|
fs.readFileSync(install.outcomePath, 'utf8'),
|
|
);
|
|
const installedUid = serviceProcessUid(kind, installedOutcome);
|
|
if (installedUid !== uid) {
|
|
fail(`installed service process UID drifted: ${installedUid} != ${uid}`);
|
|
}
|
|
const replay = runLocalServiceBridgeCommandFile(installed.commandPath);
|
|
if (replay.status !== 'existing' || replay.state !== 'active') {
|
|
fail('exact replay did not reuse the durable outcome');
|
|
}
|
|
const restartRequired = kind !== 'openrc' || identityMode === 'root';
|
|
let restarted;
|
|
if (restartRequired) {
|
|
const restart = prepare(root, kind, '02', 'restart', uid, gid);
|
|
restarted = execute(
|
|
root,
|
|
controllerRoot,
|
|
managerOptions,
|
|
restart,
|
|
uid,
|
|
gid,
|
|
);
|
|
if (
|
|
restarted.result.state !== 'active' ||
|
|
restarted.consumed.state !== 'active'
|
|
) {
|
|
fail('restart did not prove active');
|
|
}
|
|
const restartedOutcome = JSON.parse(
|
|
fs.readFileSync(restart.outcomePath, 'utf8'),
|
|
);
|
|
const restartedUid = serviceProcessUid(kind, restartedOutcome);
|
|
if (restartedUid !== uid) {
|
|
fail(
|
|
`restarted service process UID drifted: ${restartedUid} != ${uid}`,
|
|
);
|
|
}
|
|
}
|
|
const stop = prepare(root, kind, '03', 'stop', uid, gid);
|
|
const stopped = execute(
|
|
root,
|
|
controllerRoot,
|
|
managerOptions,
|
|
stop,
|
|
uid,
|
|
gid,
|
|
);
|
|
if (
|
|
stopped.result.state !== 'stopped' ||
|
|
stopped.consumed.state !== 'stopped'
|
|
) {
|
|
fail('stop did not prove stopped');
|
|
}
|
|
cleanup(kind, managerOptions);
|
|
const adopted = adoptedFixture(root, kind, uid, gid);
|
|
const adoptedStart = prepare(
|
|
root,
|
|
kind,
|
|
'11',
|
|
'install-enable-start',
|
|
uid,
|
|
gid,
|
|
{
|
|
mode: 'adopted',
|
|
cutoverId: adopted.cutoverId,
|
|
generation: 1,
|
|
expectedActivationDigest: adopted.activationDigest,
|
|
previousRecordDigest: adopted.commitmentDigest,
|
|
},
|
|
);
|
|
const adoptedStarted = execute(
|
|
root,
|
|
controllerRoot,
|
|
managerOptions,
|
|
adoptedStart,
|
|
uid,
|
|
gid,
|
|
);
|
|
const adoptedActive = await consumeCutover(root, adoptedStart, uid, gid);
|
|
if (
|
|
adoptedStarted.result.state !== 'active' ||
|
|
adoptedActive.state !== 'target_active'
|
|
) {
|
|
fail('adopted service did not commit target_active');
|
|
}
|
|
const adoptedStop = prepare(root, kind, '13', 'stop', uid, gid, {
|
|
mode: 'adopted',
|
|
cutoverId: adopted.cutoverId,
|
|
generation: 1,
|
|
expectedActivationDigest: adopted.activationDigest,
|
|
previousRecordDigest: adoptedActive.recordDigest,
|
|
});
|
|
const adoptedStoppedManager = execute(
|
|
root,
|
|
controllerRoot,
|
|
managerOptions,
|
|
adoptedStop,
|
|
uid,
|
|
gid,
|
|
);
|
|
const adoptedStopped = await consumeCutover(root, adoptedStop, uid, gid);
|
|
if (
|
|
adoptedStoppedManager.result.state !== 'stopped' ||
|
|
adoptedStopped.state !== 'target_stopped'
|
|
) {
|
|
fail('adopted service did not commit target_stopped');
|
|
}
|
|
const adoptedRollback = prepareAdoptedRollback(
|
|
root,
|
|
adopted,
|
|
adoptedStopped,
|
|
uid,
|
|
gid,
|
|
);
|
|
const adoptedRollbackReplay = ownerCli(
|
|
uid,
|
|
gid,
|
|
'service-legacy-rollback-prepare',
|
|
adoptedRollback.commandPath,
|
|
);
|
|
if (
|
|
adoptedRollback.result.status !== 'prepared' ||
|
|
adoptedRollback.result.state !== 'rollback_prepared' ||
|
|
adoptedRollback.result.rollbackDisposition !== 'rollback_candidate' ||
|
|
adoptedRollbackReplay.status !== 'existing' ||
|
|
adoptedRollbackReplay.preparationDigest !==
|
|
adoptedRollback.result.preparationDigest
|
|
) {
|
|
fail('adopted rollback preparation did not converge exactly');
|
|
}
|
|
const adoptedAuthorization = authorizeAdoptedRollback(
|
|
root,
|
|
adopted,
|
|
adoptedRollback.result,
|
|
uid,
|
|
gid,
|
|
);
|
|
const adoptedAuthorizationReplay = ownerCli(
|
|
uid,
|
|
gid,
|
|
'service-legacy-rollback-authorize',
|
|
adoptedAuthorization.commandPath,
|
|
);
|
|
if (
|
|
adoptedAuthorization.result.status !== 'prepared' ||
|
|
adoptedAuthorization.result.state !== 'legacy_restart_requested' ||
|
|
adoptedAuthorizationReplay.status !== 'existing' ||
|
|
adoptedAuthorizationReplay.authorizationDigest !==
|
|
adoptedAuthorization.result.authorizationDigest
|
|
) {
|
|
fail('adopted rollback authorization did not converge exactly');
|
|
}
|
|
installLegacyService(kind, managerOptions, uid, gid, legacyHttpPort);
|
|
const adoptedLegacyStarted =
|
|
scenario === 'success'
|
|
? executeLegacyRollback(
|
|
root,
|
|
controllerRoot,
|
|
managerOptions,
|
|
adopted,
|
|
adoptedRollback.result,
|
|
adoptedAuthorization.result,
|
|
uid,
|
|
gid,
|
|
)
|
|
: executeLegacyRollbackBarrierCrash(
|
|
root,
|
|
controllerRoot,
|
|
managerOptions,
|
|
adopted,
|
|
adoptedRollback.result,
|
|
adoptedAuthorization.result,
|
|
uid,
|
|
gid,
|
|
);
|
|
let adoptedLegacyReadiness;
|
|
if (scenario === 'success') {
|
|
if (
|
|
adoptedLegacyStarted.result.state !== 'legacy_running' ||
|
|
adoptedLegacyStarted.replay.status !== 'existing' ||
|
|
adoptedLegacyStarted.replay.state !== 'legacy_running' ||
|
|
adoptedLegacyStarted.consumed.state !== 'legacy_running' ||
|
|
adoptedLegacyStarted.outcome.mutationDisposition !==
|
|
'response-loss-inspected' ||
|
|
adoptedLegacyStarted.outcome.targetObservation.activeState !==
|
|
'inactive' ||
|
|
adoptedLegacyStarted.outcome.legacyObservation.activeState !== 'active'
|
|
) {
|
|
fail('adopted legacy rollback did not converge to legacy_running');
|
|
}
|
|
const legacyUid = serviceProcessUid(
|
|
kind,
|
|
{
|
|
observation: adoptedLegacyStarted.outcome.legacyObservation,
|
|
},
|
|
fs.realpathSync(process.execPath),
|
|
[
|
|
'/workspace/scripts/ql3-service-manager-legacy-live-service.cjs',
|
|
String(legacyHttpPort),
|
|
],
|
|
);
|
|
if (legacyUid !== uid) {
|
|
fail(`legacy service process UID drifted: ${legacyUid} != ${uid}`);
|
|
}
|
|
adoptedLegacyReadiness = proveLegacyReadiness(
|
|
root,
|
|
adopted,
|
|
adoptedLegacyStarted.consumed,
|
|
uid,
|
|
gid,
|
|
legacyHttpPort,
|
|
);
|
|
if (
|
|
adoptedLegacyReadiness.result.status !== 'prepared' ||
|
|
adoptedLegacyReadiness.result.state !== 'legacy_ready' ||
|
|
adoptedLegacyReadiness.replay.status !== 'existing' ||
|
|
adoptedLegacyReadiness.replay.state !== 'legacy_ready' ||
|
|
adoptedLegacyReadiness.replay.receiptDigest !==
|
|
adoptedLegacyReadiness.result.receiptDigest ||
|
|
adoptedLegacyReadiness.replay.instanceHeadDigest !==
|
|
adoptedLegacyReadiness.result.instanceHeadDigest
|
|
) {
|
|
fail('legacy readiness proof did not converge exactly');
|
|
}
|
|
} else if (
|
|
adoptedLegacyStarted.result.state !== 'manual_required' ||
|
|
adoptedLegacyStarted.result.status !== 'prepared' ||
|
|
adoptedLegacyStarted.replay.status !== 'existing' ||
|
|
adoptedLegacyStarted.replay.state !== 'manual_required' ||
|
|
adoptedLegacyStarted.consumed.state !== 'manual_required' ||
|
|
adoptedLegacyStarted.outcome.mutationDisposition !== 'replay-inspected' ||
|
|
adoptedLegacyStarted.outcome.manualReason !== 'manager_state_unproved' ||
|
|
adoptedLegacyStarted.outcome.targetObservation.activeState !==
|
|
'inactive' ||
|
|
adoptedLegacyStarted.outcome.legacyObservation.activeState !== 'inactive'
|
|
) {
|
|
fail('legacy barrier replay did not fail closed without a second start');
|
|
}
|
|
const payload = {
|
|
schemaVersion: 1,
|
|
evidenceClass: 'qinglong3_service_manager_bridge_live_actor',
|
|
managerKind: kind,
|
|
identityMode,
|
|
scenario,
|
|
serviceUid: uid,
|
|
manager: managerOptions,
|
|
actions: [
|
|
installed.result,
|
|
replay,
|
|
...(restarted ? [restarted.result] : []),
|
|
stopped.result,
|
|
],
|
|
adoptedCutover: {
|
|
active: adoptedActive,
|
|
stopped: adoptedStopped,
|
|
rollbackPrepared: adoptedRollback.result,
|
|
rollbackReplay: adoptedRollbackReplay,
|
|
rollbackAuthorized: adoptedAuthorization.result,
|
|
rollbackAuthorizationReplay: adoptedAuthorizationReplay,
|
|
legacyStarted: adoptedLegacyStarted.result,
|
|
legacyStartReplay: adoptedLegacyStarted.replay,
|
|
legacyConsumed: adoptedLegacyStarted.consumed,
|
|
legacyReadiness: adoptedLegacyReadiness?.result ?? null,
|
|
legacyReadinessReplay: adoptedLegacyReadiness?.replay ?? null,
|
|
},
|
|
gates: {
|
|
rootCommandFile: true,
|
|
descriptorInstalled: true,
|
|
enabledAndStarted: true,
|
|
exactReplay: true,
|
|
restartRequired,
|
|
restarted: restarted !== undefined,
|
|
stopped: true,
|
|
ownerOutcomeVerified: true,
|
|
serviceProcessIdentity: true,
|
|
adoptedCutoverActive: true,
|
|
adoptedCutoverStopped: true,
|
|
adoptedRollbackPrepared: true,
|
|
adoptedRollbackReplay: true,
|
|
adoptedRollbackCandidate: true,
|
|
adoptedRollbackAuthorized: true,
|
|
adoptedRollbackAuthorizationReplay: true,
|
|
adoptedLegacyStarted: scenario === 'success',
|
|
adoptedLegacyStartReplay: true,
|
|
adoptedLegacyConsumed: true,
|
|
adoptedTargetRemainedStopped: true,
|
|
adoptedLegacyProcessIdentity: scenario === 'success',
|
|
adoptedLegacyResponseLossInspected: scenario === 'success',
|
|
adoptedLegacyReady: scenario === 'success',
|
|
adoptedLegacyReadinessReplay: scenario === 'success',
|
|
adoptedLegacyBarrierCrash: scenario === 'barrier-crash',
|
|
adoptedLegacyInspectOnlyConvergence: scenario === 'barrier-crash',
|
|
adoptedLegacyRemainedStopped: scenario === 'barrier-crash',
|
|
adoptedLegacyManualConsumed: scenario === 'barrier-crash',
|
|
},
|
|
};
|
|
process.stdout.write(
|
|
`${JSON.stringify({
|
|
...payload,
|
|
sha256: crypto
|
|
.createHash('sha256')
|
|
.update(JSON.stringify(payload))
|
|
.digest('hex'),
|
|
})}\n`,
|
|
);
|
|
} finally {
|
|
cleanup(kind, managerOptions);
|
|
fs.rmSync(root, { force: true, recursive: true });
|
|
fs.rmSync(controllerRoot, { force: true, recursive: true });
|
|
}
|
|
}
|
|
|
|
main(process.argv.slice(2)).catch((error) => {
|
|
process.stderr.write(
|
|
`${JSON.stringify({
|
|
code: 'QL3_SERVICE_MANAGER_BRIDGE_LIVE_ACTOR_FAILED',
|
|
name: error?.name ?? 'Error',
|
|
message: error?.message ?? 'live actor failed',
|
|
})}\n`,
|
|
);
|
|
process.exitCode = 1;
|
|
});
|