mirror of
https://github.com/whyour/qinglong.git
synced 2026-11-02 15:56:59 +08:00
whyour
e8b6a30bd9
Package production dependencies per architecture for online and offline upgrades. Validate dependencies and isolated backend startup before readiness, repair once when permitted, and preserve service/data through failed preparation or rollback. Publish release bundles with master images and expose an opt-in develop build sharing the development index across Alpine and Debian images.
321 lines
12 KiB
JavaScript
321 lines
12 KiB
JavaScript
#!/usr/bin/env node
|
|
// Also published as a standalone, bundled installer for devices with Node only.
|
|
const fs = require('node:fs/promises');
|
|
const path = require('node:path');
|
|
const os = require('node:os');
|
|
const { randomUUID } = require('node:crypto');
|
|
const { promisify } = require('node:util');
|
|
const execute = promisify(require('node:child_process').execFile);
|
|
const { parseArgs } = require('node:util');
|
|
const artifacts = require('../cli/src/internal/maintenance/upgradeArtifacts.cjs');
|
|
const jobs = require('../cli/src/internal/maintenance/panelUpgrade.cjs');
|
|
const {
|
|
nodeRuntimeArgs,
|
|
} = require('../cli/src/internal/maintenance/platformBundle.cjs');
|
|
|
|
async function runInstallerMain(argv = process.argv.slice(2)) {
|
|
const flags = nodeRuntimeArgs();
|
|
if (!flags.length || process.execArgv.includes('--jitless'))
|
|
return installBundle(argv);
|
|
const child = require('node:child_process').spawn(
|
|
process.execPath,
|
|
[...flags, __filename, ...argv],
|
|
{ stdio: 'inherit', env: process.env },
|
|
);
|
|
const interrupt = () => child.kill('SIGINT');
|
|
const terminate = () => child.kill('SIGTERM');
|
|
process.once('SIGINT', interrupt);
|
|
process.once('SIGTERM', terminate);
|
|
try {
|
|
await new Promise((resolve, reject) => {
|
|
child.once('error', reject);
|
|
child.once('exit', (code, signal) => {
|
|
if (code === 0) resolve();
|
|
else reject(new Error(`Offline installer exited: ${signal || code}`));
|
|
});
|
|
});
|
|
} finally {
|
|
process.removeListener('SIGINT', interrupt);
|
|
process.removeListener('SIGTERM', terminate);
|
|
}
|
|
}
|
|
|
|
async function installBundle(argv = process.argv.slice(2), env = process.env) {
|
|
const { values } = parseArgs({
|
|
args: argv,
|
|
options: {
|
|
root: { type: 'string' },
|
|
file: { type: 'string' },
|
|
'download-only': { type: 'boolean' },
|
|
install: { type: 'boolean' },
|
|
'repair-deps': { type: 'boolean' },
|
|
},
|
|
});
|
|
if (!values.file || !(values.root || env.QL_DIR))
|
|
throw new Error(
|
|
'Usage: node install-bundle.cjs --root /path/to/qinglong --file /path/to/bundle.tar.gz [--download-only | --install] [--repair-deps]',
|
|
);
|
|
if (values.install && values['download-only'])
|
|
throw new Error('Choose --install or --download-only');
|
|
const root = path.resolve(values.root || env.QL_DIR);
|
|
const existing = await fs.readdir(root).catch((error) => {
|
|
if (error.code !== 'ENOENT') throw error;
|
|
return [];
|
|
});
|
|
if (values.install && existing.length)
|
|
throw new Error('--install requires an empty installation directory');
|
|
if (!values.install) await fs.access(path.join(root, 'shell/share.sh'));
|
|
let environment = {
|
|
...env,
|
|
QL_DIR: root,
|
|
QL_UPGRADE_FILE: path.resolve(values.file),
|
|
};
|
|
if (!values.install) {
|
|
const captured = await execute(
|
|
'bash',
|
|
[
|
|
'--noprofile',
|
|
'--norc',
|
|
'-c',
|
|
'. "$1/shell/share.sh"\n. "$1/shell/env.sh"\nimport_config\nexport QlPort="${ql_port:-${QlPort:-5700}}" QlBaseUrl="${ql_base_url:-${QlBaseUrl:-/}}"\nenv -0',
|
|
'ql-offline',
|
|
root,
|
|
],
|
|
{ env: environment, maxBuffer: 1024 * 1024 },
|
|
);
|
|
const loaded = Object.fromEntries(
|
|
captured.stdout.split('\0').flatMap((line) => {
|
|
const match = /^([A-Za-z_][A-Za-z_0-9]*)=([\s\S]*)$/.exec(line);
|
|
return match ? [[match[1], match[2]]] : [];
|
|
}),
|
|
);
|
|
environment = {
|
|
...environment,
|
|
...loaded,
|
|
QL_DIR: root,
|
|
QL_UPGRADE_FILE: path.resolve(values.file),
|
|
};
|
|
}
|
|
environment.QL_UPGRADE_REPAIR_DEPS = values['repair-deps'] ? '1' : '0';
|
|
const freshWorkspace = values.install
|
|
? await fs.mkdtemp(path.join(os.tmpdir(), 'ql-offline-install-'))
|
|
: undefined;
|
|
const tmp = freshWorkspace || path.join(root, '.tmp');
|
|
const controller = new AbortController();
|
|
const abort = () => controller.abort(new Error('离线升级已中断'));
|
|
process.once('SIGINT', abort);
|
|
process.once('SIGTERM', abort);
|
|
try {
|
|
const operation = () =>
|
|
artifacts.withUpgradeLock(
|
|
tmp,
|
|
async () => {
|
|
let state;
|
|
const report = async (patch) => {
|
|
if (patch.phase) console.log(patch.phase);
|
|
if (state) {
|
|
state = {
|
|
...state,
|
|
...patch,
|
|
pid: process.pid,
|
|
updatedAt: Date.now(),
|
|
};
|
|
await jobs.saveState(tmp, state);
|
|
}
|
|
};
|
|
if (!values.install) {
|
|
const previous = await jobs.getStatus(tmp);
|
|
if (['starting', 'running', 'restarting'].includes(previous.status))
|
|
throw new Error('已有更新或重载正在执行。');
|
|
state = {
|
|
id: randomUUID(),
|
|
action: values['download-only'] ? 'download' : 'apply',
|
|
status: 'running',
|
|
phase: 'verifying',
|
|
startedAt: Date.now(),
|
|
};
|
|
await report({});
|
|
await fs.writeFile(
|
|
path.join(tmp, 'panel-upgrade.log'),
|
|
'Offline bundle verification\n',
|
|
{ mode: 0o600 },
|
|
);
|
|
}
|
|
try {
|
|
const selected = await artifacts.stageUpgrade({
|
|
root,
|
|
tmp,
|
|
env: environment,
|
|
run: (program, args, capture) =>
|
|
artifacts.runProcess(
|
|
environment,
|
|
program,
|
|
args,
|
|
capture,
|
|
controller.signal,
|
|
),
|
|
signal: controller.signal,
|
|
onProgress: report,
|
|
install: async () => {
|
|
throw new Error(
|
|
'Offline bundles never install npm dependencies',
|
|
);
|
|
},
|
|
});
|
|
if (state)
|
|
await report({
|
|
status: 'ready',
|
|
phase: 'ready',
|
|
...(await jobs.stagedMetadata(selected)),
|
|
});
|
|
if (values['download-only']) {
|
|
console.log('更新已就绪；执行 ql reload system 应用更新。');
|
|
return selected;
|
|
}
|
|
if (values.install) {
|
|
// Build beside the destination, then atomically replace only an empty root.
|
|
await fs.mkdir(path.dirname(root), { recursive: true });
|
|
const publication = await fs.mkdtemp(
|
|
path.join(path.dirname(root), '.qinglong-install-'),
|
|
);
|
|
try {
|
|
await fs.chmod(publication, 0o755);
|
|
await fs.cp(selected.source, publication, {
|
|
recursive: true,
|
|
verbatimSymlinks: true,
|
|
});
|
|
await fs.cp(selected.static, path.join(publication, 'static'), {
|
|
recursive: true,
|
|
});
|
|
await fs.copyFile(
|
|
path.join(publication, '.env.example'),
|
|
path.join(publication, '.env'),
|
|
require('node:fs').constants.COPYFILE_EXCL,
|
|
);
|
|
await fs.chmod(path.join(publication, '.env'), 0o600);
|
|
controller.signal.throwIfAborted();
|
|
await fs.rename(publication, root);
|
|
} finally {
|
|
await fs.rm(publication, { recursive: true, force: true });
|
|
}
|
|
await fs.rm(path.dirname(selected.source), {
|
|
recursive: true,
|
|
force: true,
|
|
});
|
|
await fs.rm(
|
|
path.join(
|
|
tmp,
|
|
`upgrade-ready-${artifacts.releaseBranch(environment)}.json`,
|
|
),
|
|
{ force: true },
|
|
);
|
|
console.log(
|
|
`离线安装完成，保留现有 Node ${
|
|
process.version
|
|
}。启动服务：QL_DIR=${JSON.stringify(
|
|
root,
|
|
)} QL_DATA_DIR=${JSON.stringify(
|
|
path.join(root, 'data'),
|
|
)} bash ${JSON.stringify(
|
|
path.join(root, 'shell/start-simplify.sh'),
|
|
)}`,
|
|
);
|
|
return;
|
|
}
|
|
const result = await jobs.withPanelLifecycle(
|
|
root,
|
|
tmp,
|
|
environment,
|
|
async (hook, prepareSelection) => {
|
|
const expected = await jobs.stagedMetadata(selected);
|
|
const previous = await jobs
|
|
.readRunningBuild(environment)
|
|
.catch(() => undefined);
|
|
const selection = await prepareSelection?.(selected);
|
|
try {
|
|
return await artifacts.reloadSystem({
|
|
root,
|
|
tmp,
|
|
env: environment,
|
|
data: environment.dir_data || path.join(root, 'data'),
|
|
staticRoot: path.join(root, 'static'),
|
|
config:
|
|
environment.dir_config || path.join(root, 'data/config'),
|
|
lifecycle: {
|
|
signal: controller.signal,
|
|
stop: async (recover) => {
|
|
await report({
|
|
status: 'restarting',
|
|
phase: 'restarting',
|
|
});
|
|
await hook(
|
|
'stop',
|
|
[],
|
|
recover ? undefined : controller.signal,
|
|
);
|
|
},
|
|
start: async (recover) => {
|
|
await hook(
|
|
'start',
|
|
[],
|
|
recover ? undefined : controller.signal,
|
|
);
|
|
await artifacts.waitForHealth(
|
|
environment,
|
|
undefined,
|
|
recover ? undefined : controller.signal,
|
|
);
|
|
if (!recover)
|
|
await jobs.verifyRunningVersion(
|
|
environment,
|
|
expected,
|
|
previous,
|
|
);
|
|
},
|
|
},
|
|
additionalReplacements: selection
|
|
? [{ source: selection.source, target: selection.target }]
|
|
: [],
|
|
});
|
|
} finally {
|
|
if (selection)
|
|
await fs.rm(selection.directory, {
|
|
recursive: true,
|
|
force: true,
|
|
});
|
|
}
|
|
},
|
|
controller.signal,
|
|
);
|
|
await report({ status: 'completed', phase: 'completed' });
|
|
console.log('升级成功，已保留现有 Node 并运行更新后的版本。');
|
|
return result;
|
|
} catch (error) {
|
|
if (state) await report({ status: 'failed', error: error.message });
|
|
throw error;
|
|
}
|
|
},
|
|
environment,
|
|
);
|
|
return values.install
|
|
? await operation()
|
|
: await artifacts.withUpgradeLock(
|
|
path.join(tmp, 'panel-job-launch'),
|
|
operation,
|
|
environment,
|
|
);
|
|
} finally {
|
|
process.removeListener('SIGINT', abort);
|
|
process.removeListener('SIGTERM', abort);
|
|
if (freshWorkspace)
|
|
await fs.rm(freshWorkspace, { recursive: true, force: true });
|
|
}
|
|
}
|
|
|
|
module.exports = { installBundle, runInstallerMain };
|
|
if (require.main === module)
|
|
runInstallerMain().catch((error) => {
|
|
console.error(error.message);
|
|
process.exitCode = 1;
|
|
});
|