better shutdown via ipc

Author: obfuscatedgenerated

package-lock.json

@@ -1,6 +1,6 @@
 {
   "name": "ollieos",
-  "version": "2.5.3",
+  "version": "2.5.4",
   "description": "",
   "main": "server.js",
   "scripts": {

package.json

@@ -639,6 +639,30 @@ export class Kernel {
         });
     }
 
+    power_off() {
+        // dispose of all terminals of any remaining processes, including the kernel terminal
+        const proc_mgr = this.get_process_manager();
+        const pids = proc_mgr.list_pids();
+
+        for (const pid of pids) {
+            const proc = proc_mgr.get_process(pid);
+            proc.terminal.dispose();
+        }
+
+        this.#term.dispose();
+
+        proc_mgr.dispose_all();
+    }
+
+    reboot() {
+        this.power_off();
+
+        if (typeof window !== "undefined") {
+            // TODO: more formal reboot here, calling boot again with clean state somehow
+            window.location.reload();
+        }
+    }
+
     constructor(term: AbstractTerminal, fs: AbstractFileSystem, prog_registry?: ProgramRegistry, sound_registry?: SoundRegistry, wm?: AbstractWindowManager, net_manager?: AbstractNetworkManager) {
         this.#term = term;
         this.#fs = fs;

src/kernel/index.ts

@@ -183,6 +183,63 @@ export default {
                         }
                     }
                         break;
+                    case "power": {
+                        const power_msg = payload as IgnitionIPCPowerMessage;
+                        switch (power_msg.action) {
+                            case "shutdown": {
+                                ipc.channel_send(channel_id, process.pid, {
+                                    type: "response",
+                                    message: power_msg.hard ? "Hard shutdown initiated." : "Shutdown initiated."
+                                });
+
+                                // TODO: stop services in reverse order
+
+                                // kill all processes except for init in reverse order of creation
+                                // TODO: polite shutdown signal first (need to add) then force kill after timeout (or instantly based on force flag)
+                                const proc_mgr = kernel.get_process_manager();
+                                const pids = proc_mgr.list_pids().reverse();
+                                for (const pid of pids) {
+                                    if (pid !== process.pid) {
+                                        const proc = proc_mgr.get_process(pid);
+                                        if (proc) {
+                                            proc.kill();
+                                        }
+                                    }
+                                }
+
+                                kernel.power_off();
+                                break;
+                            }
+                            case "reboot": {
+                                ipc.channel_send(channel_id, process.pid, {
+                                    type: "response",
+                                    message: power_msg.hard ? "Hard reboot initiated." : "Reboot initiated."
+                                });
+
+                                // TODO: stop services in reverse order
+
+                                // kill all processes except for init in reverse order of creation
+                                const proc_mgr = kernel.get_process_manager();
+                                const pids = proc_mgr.list_pids().reverse();
+                                for (const pid of pids) {
+                                    if (pid !== process.pid) {
+                                        const proc = proc_mgr.get_process(pid);
+                                        if (proc) {
+                                            proc.kill();
+                                        }
+                                    }
+                                }
+
+                                kernel.reboot();
+                                break;
+                            }
+                            default:
+                                ipc.channel_send(channel_id, process.pid, {
+                                    type: "error",
+                                    message: `Unknown power action: ${power_msg.action}`
+                                });
+                        }
+                    }
                     default:
                         ipc.channel_send(channel_id, process.pid, {
                             type: "error",

src/programs/core/ignition/index.ts

@@ -16,7 +16,7 @@ export default {
     // TODO: completion
     main: async (data) => {
         // extract from data to make code less verbose
-        const { kernel, shell, args, term } = data;
+        const { kernel, shell, args, term, process } = data;
 
         // extract from ANSI to make code less verbose
         const { FG, STYLE } = ANSI;
@@ -68,15 +68,20 @@ export default {
             term.writeln(`${FG.red}Shutting down...${STYLE.reset_all}`);
         }
 
-        setTimeout(() => {
-            if (restart) {
-                window.location.reload();
-            } else {
-                // TODO: need to dispose ALL terminals. def easier to manage in igntion but could make a kernel.dispose() method
-                // TODO: send kill signal to all processes to allow them to clean up before shutdown
-                // TODO: this behaviour should be moved to either kernel or ignition
-                term.dispose();
+        process.create_timeout(() => {
+            // talk to ignition over ipc
+            const ipc = kernel.get_ipc();
+            const channel_id = ipc.create_channel("init");
+
+            if (!channel_id) {
+                term.writeln(`${FG.red}Failed to communicate with ignition.${STYLE.reset_all}`);
+                return;
             }
+
+            ipc.channel_send(channel_id, {
+                type: "power",
+                action: restart ? "reboot" : "shutdown",
+            });
         }, time);
 
         // hang the terminal until it is shut down or restarted (dont allow any more commands)
@@ -85,4 +90,3 @@ export default {
     }
 } as Program;
 
-// TODO: move this to talk to ignition to perform a soft (or hard) shutdown via IPC