Skip to content

An open-source, privacy-first, self-hosted knowledge workspace where humans and AI agents work together 开源、隐私优先、自托管的知识工作空间,让人与智能体在此协作

:bug: Recognize exited kernels during system shutdown https://github.com/siyuan-note/siyuan/issues/20825

Daniel01a548a2b65a
diff --git a/app/electron/kernelBoot.test.js b/app/electron/kernelBoot.test.js
index 94df755e10..858bacf544 100644
--- a/app/electron/kernelBoot.test.js
+++ b/app/electron/kernelBoot.test.js
@@ -72,7 +72,7 @@ const setup = (progress, options = {}) => {
localKernelStartups: new Map(), showWindow: () => events.push("show-existing"),
bootIndexPath: "app/electron/boot.html",
loadBootWindow: () => events.push("resume-boot"),
- kernelProcesses: new Map(), expectedKernelExitPorts: new Set(),
+ kernelProcesses: new Map(), expectedKernelExitPorts: new Set(), exitedKernelPorts: new Set(),
createBootWindow: () => {
events.push("create-boot");
const current = windows.length ? makeWindow() : window;
@@ -138,6 +138,16 @@ const setup = (progress, options = {}) => {
const exits = fixture => fixture.events.filter(event => Array.isArray(event) && event[0] === "exit-kernel");
+test("kernel startup clears stale exit evidence and records its own process closure", async () => {
+ const state = setup(() => 100);
+ state.context.exitedKernelPorts.add("6806");
+ assert.equal(await state.run(), 6806);
+ assert.equal(state.context.exitedKernelPorts.has("6806"), false);
+ state.closeKernel(0);
+ assert.equal(state.context.exitedKernelPorts.has("6806"), true);
+ assert.equal(state.context.kernelProcesses.has("6806"), false);
+});
+
test("repeated requests reuse startup before port allocation and during kernel boot", async () => {
let allocate;
let version;
diff --git a/app/electron/main.js b/app/electron/main.js
index 1e4247f56d..3334f5a6ef 100644
--- a/app/electron/main.js
+++ b/app/electron/main.js
@@ -159,6 +159,7 @@ const expectedRendererExitIds = new Set();
const expectedKernelExitPorts = new Set();
const handledCrashWebContents = new Set();
const kernelProcesses = new Map();
+const exitedKernelPorts = new Set();
const localKernelStartups = new Map();
const bootWindows = new Set();
let bootWindow;
@@ -1984,6 +1985,10 @@ const getSystemShutdownPorts = () => {
};
const requestGracefulKernelExit = async (port) => {
+ const portKey = port.toString();
+ if (exitedKernelPorts.has(portKey)) {
+ return true;
+ }
const abortController = new AbortController();
const timeout = setTimeout(() => abortController.abort(), systemShutdownExitTimeout);
try {
@@ -1993,19 +1998,19 @@ const requestGracefulKernelExit = async (port) => {
execInstallPkg: 1,
}, abortController.signal);
if (!response) {
- return false;
+ return exitedKernelPorts.has(portKey);
}
const apiData = await response.json();
if (apiData.code !== 0) {
writeLog("graceful system shutdown failed [port=" + port + ", code=" + apiData.code + "]");
- return false;
+ return exitedKernelPorts.has(portKey);
}
writeLog("graceful system shutdown succeeded [port=" + port + "]");
return true;
} catch (error) {
writeLog("parse graceful system shutdown response failed [port=" + port + "]: " + error);
- return false;
+ return exitedKernelPorts.has(portKey);
} finally {
clearTimeout(timeout);
}
@@ -2838,6 +2843,7 @@ const initKernelAttempt = (workspace, port, lang, safeMode, preparedBoot, startu
writeLog("spawned kernel process [" + (Date.now() - spawnStartedAt) + "ms]");
const kernelPortKey = currentKernelPort.toString();
+ exitedKernelPorts.delete(kernelPortKey);
kernelProcesses.set(kernelPortKey, kernelProcess);
startup.kernelRunning = true;
startup.process = kernelProcess;
@@ -2847,6 +2853,7 @@ const initKernelAttempt = (workspace, port, lang, safeMode, preparedBoot, startu
if (startup.process === kernelProcess) startup.kernelRunning = false;
if (kernelProcesses.get(kernelPortKey) === kernelProcess) {
kernelProcesses.delete(kernelPortKey);
+ exitedKernelPorts.add(kernelPortKey);
}
const expectedExit = expectedKernelExitPorts.delete(kernelPortKey);
writeLog(`kernel [pid=${kernelProcess.pid}, port=${currentKernelPort}] exited with code [${code}], signal [${signal}], expected [${expectedExit}]`);
diff --git a/app/electron/systemShutdown.test.js b/app/electron/systemShutdown.test.js
new file mode 100644
index 0000000000..32e5886c54
--- /dev/null
+++ b/app/electron/systemShutdown.test.js
@@ -0,0 +1,67 @@
+const assert = require("node:assert/strict");
+const {readFileSync} = require("node:fs");
+const path = require("node:path");
+const {test} = require("node:test");
+const vm = require("node:vm");
+
+const source = readFileSync(path.join(__dirname, "main.js"), "utf8");
+const handler = source.slice(source.indexOf("const requestGracefulKernelExit ="),
+ source.indexOf("const resetSystemShutdown ="));
+
+const setup = () => {
+ const timers = new Map();
+ const context = vm.createContext({
+ exitedKernelPorts: new Set(), AbortController, systemShutdownExitTimeout: 30000,
+ setTimeout: callback => { timers.set(1, callback); return 1; },
+ clearTimeout: id => timers.delete(id), writeLog() {},
+ requestKernelExit: async () => ({json: async () => ({code: 0})}),
+ });
+ vm.runInContext(handler, context);
+ return {context, timers, run: () => vm.runInContext("requestGracefulKernelExit(6806)", context)};
+};
+
+test("system shutdown accepts an observed kernel exit without requesting its closed port", async () => {
+ const state = setup();
+ state.context.exitedKernelPorts.add("6806");
+ state.context.requestKernelExit = () => { throw new Error("closed port was requested"); };
+ assert.equal(await state.run(), true);
+ assert.equal(state.timers.size, 0);
+});
+
+test("transport and response failures require an observed exit of the same kernel", async () => {
+ for (const failed of ["transport", "parse", "api", "timeout"]) {
+ for (const exited of [false, true]) {
+ const state = setup();
+ state.context.exitedKernelPorts.add("6807");
+ state.context.requestKernelExit = async (_port, _options, signal) => {
+ if (exited) state.context.exitedKernelPorts.add("6806");
+ if (failed === "transport") return undefined;
+ if (failed === "timeout") {
+ state.timers.get(1)();
+ assert.equal(signal.aborted, true);
+ return undefined;
+ }
+ return {json: async () => {
+ if (failed === "parse") throw new Error("closed response");
+ return {code: 1};
+ }};
+ };
+ assert.equal(await state.run(), exited, `${failed}, exited=${exited}`);
+ assert.equal(state.timers.size, 0);
+ }
+ }
+});
+
+test("successful graceful exits still use the non-forced API request", async () => {
+ const state = setup();
+ state.context.requestKernelExit = async (port, options, signal) => {
+ assert.equal(port, 6806);
+ assert.deepEqual(JSON.parse(JSON.stringify(options)), {
+ force: false, setCurrentWorkspace: false, execInstallPkg: 1,
+ });
+ assert.equal(signal.aborted, false);
+ return {json: async () => ({code: 0})};
+ };
+ assert.equal(await state.run(), true);
+ assert.equal(state.timers.size, 0);
+});