Merge pull request #53 from kristapsk/ndg-sysupdates-head

kristapsk · web-flow · commit 4e7fb9258f41 · 2026-02-03T10:28:59.000+02:00
Display current git pulled sysupdates HEAD in UI
diff --git a/src/comm.zig b/src/comm.zig
@@ -95,7 +95,9 @@ pub const MessageTag = enum(u16) {
     screen_unlock_result = 0x18,
     // ngui -> nd: set or disable screenlock pin code
     slock_set_pincode = 0x19,
-    // next: 0x1a
+    // ngui -> nd: request current settings
+    get_settings = 0x1a,
+    // next: 0x1b
 };
 
 /// daemon and gui exchange messages of this type.
@@ -124,6 +126,7 @@ pub const Message = union(MessageTag) {
     unlock_screen: []const u8, // pincode
     screen_unlock_result: ScreenUnlockResult,
     slock_set_pincode: ?[]const u8,
+    get_settings: void,
 
     pub const WifiConnect = struct {
         ssid: []const u8,
@@ -266,6 +269,7 @@ pub const Message = union(MessageTag) {
         sysupdates: struct {
             url: []const u8,
             channel: SysupdatesChan,
+            head: []const u8 = "", // git commit hash
         },
     };
 
@@ -308,6 +312,7 @@ pub fn read(allocator: mem.Allocator, reader: anytype) !ParsedMessage {
             .poweroff => .{ .value = .{ .poweroff = {} } },
             .standby => .{ .value = .{ .standby = {} } },
             .wakeup => .{ .value = .{ .wakeup = {} } },
+            .get_settings => .{ .value = .{ .get_settings = {} } },
             else => Error.CommReadZeroLenInNonVoidTag,
         };
     }
@@ -319,6 +324,7 @@ pub fn read(allocator: mem.Allocator, reader: anytype) !ParsedMessage {
         .poweroff,
         .standby,
         .wakeup,
+        .get_settings,
         => unreachable, // handled above
         inline else => |t| {
             const bytes = try allocator.alloc(u8, len);
@@ -348,7 +354,7 @@ pub fn write(allocator: mem.Allocator, writer: anytype, msg: Message) !void {
     var data = types.ByteArrayList.init(allocator);
     defer data.deinit();
     switch (msg) {
-        .ping, .pong, .poweroff, .standby, .wakeup => {}, // zero length payload
+        .ping, .pong, .poweroff, .standby, .wakeup, .get_settings => {}, // zero length payload
         .wifi_connect => try json.stringify(msg.wifi_connect, .{}, data.writer()),
         .network_report => try json.stringify(msg.network_report, .{}, data.writer()),
         .get_network_report => try json.stringify(msg.get_network_report, .{}, data.writer()),
@@ -466,6 +472,7 @@ test "write/read void tags" {
         Message.poweroff,
         Message.standby,
         Message.wakeup,
+        Message.get_settings,
     };
 
     for (msg) |m| {
diff --git a/src/nd/Config.zig b/src/nd/Config.zig
@@ -12,7 +12,8 @@ const logger = std.log.scoped(.config);
 const SYSUPDATES_CRON_SCRIPT_PATH = "/etc/cron.hourly/sysupdate";
 /// must be the same as https://github.com/nakamochi/sysupdates/blob/master/update.sh
 const SYSUPDATES_RUN_SCRIPT_NAME = "update.sh";
-const SYSUPDATES_RUN_SCRIPT_PATH = "/ssd/sysupdates/" ++ SYSUPDATES_RUN_SCRIPT_NAME;
+pub const SYSUPDATES_LOCAL_REPO_PATH = "/ssd/sysupdates";
+const SYSUPDATES_RUN_SCRIPT_PATH = SYSUPDATES_LOCAL_REPO_PATH ++ "/" ++ SYSUPDATES_RUN_SCRIPT_NAME;
 const SYSUPDATES_DEFAULT_URL = "https://github.com/nakamochi/sysupdates.git";
 
 /// must be the same as https://github.com/nakamochi/sysupdates/tree/master/lnd
@@ -52,6 +53,7 @@ pub const Data = struct {
     syschannel: SysupdatesChannel,
     syscronscript: []const u8,
     sysrunscript: []const u8,
+    head: []const u8 = "", // current HEAD commit hash of local sysupdates repo
 };
 
 /// static data is interred at init and never changes except for hostname - see `setHostname`.
@@ -109,6 +111,8 @@ fn initData(allocator: std.mem.Allocator, filepath: []const u8) !Data {
 
 fn inferData(allocator: std.mem.Allocator) Data {
     const sysupdates_channel_data = inferSysupdatesChannel(allocator, SYSUPDATES_CRON_SCRIPT_PATH);
+    const sysupdates_current_state = inferCurrentUpdateState(allocator, SYSUPDATES_LOCAL_REPO_PATH);
+    logger.info("inferred sysupdates current HEAD: {s}", .{sysupdates_current_state});
     if (sysupdates_channel_data.channel == .disabled) {
         logger.info("sysupdates are disabled", .{});
     } else {
@@ -120,6 +124,7 @@ fn inferData(allocator: std.mem.Allocator) Data {
         .syschannel = sysupdates_channel_data.channel,
         .syscronscript = SYSUPDATES_CRON_SCRIPT_PATH,
         .sysrunscript = SYSUPDATES_RUN_SCRIPT_PATH,
+        .head = sysupdates_current_state,
     };
 }
 
@@ -161,6 +166,47 @@ fn inferSysupdatesChannel(allocator: std.mem.Allocator, cron_script_path: []cons
     return .{ .url = SYSUPDATES_DEFAULT_URL, .channel = .master };
 }
 
+fn inferCurrentUpdateState(allocator: std.mem.Allocator, local_repo_path: []const u8) []const u8 {
+    // In tests (or some deployments) the repo path may not exist.
+    // Treat that as "unknown" without logging an error.
+    {
+        var d = std.fs.cwd().openDir(local_repo_path, .{}) catch |err| switch (err) {
+            error.FileNotFound, error.NotDir => return "",
+            else => {
+                logger.debug("inferCurrentUpdateState: openDir({s}) failed: {any}", .{ local_repo_path, err });
+                return "";
+            },
+        };
+        d.close();
+    }
+
+    // TODO: there are git rev-parse calls both here and in Daemon.zig, refactor later to avoid duplication.
+    const res = std.process.Child.run(.{
+        .allocator = allocator,
+        .argv = &.{ "git", "-C", local_repo_path, "rev-parse", "--short", "HEAD" },
+    }) catch |err| {
+        // git missing or spawn error; keep it non-fatal/noisy.
+        logger.debug("inferCurrentUpdateState: failed to run git: {any}", .{err});
+        return "";
+    };
+    defer {
+        allocator.free(res.stdout);
+        allocator.free(res.stderr);
+    }
+
+    if (res.term != .Exited or res.term.Exited != 0) {
+        // Common cases: not a git repo, cannot chdir, etc. Avoid error logs in tests.
+        logger.debug(
+            "inferCurrentUpdateState: git rev-parse failed; term={any}; stderr: {s}",
+            .{ res.term, res.stderr },
+        );
+        return "";
+    }
+
+    const head = std.mem.trim(u8, res.stdout, &std.ascii.whitespace);
+    return allocator.dupe(u8, head) catch "";
+}
+
 fn inferStaticData(allocator: std.mem.Allocator) !StaticData {
     const hostname = try sys.hostname(allocator);
     const lnduser: ?std.process.UserInfo = blk: {
@@ -567,6 +613,7 @@ test "ndconfig: init existing" {
     try t.expectEqual(SysupdatesChannel.dev, conf.data.syschannel);
     try t.expectEqualStrings("/cron/sysupdates.sh", conf.data.syscronscript);
     try t.expectEqualStrings("/sysupdates/run.sh", conf.data.sysrunscript);
+    try t.expectEqualStrings("", conf.data.head);
 }
 
 test "ndconfig: init null" {
@@ -578,6 +625,7 @@ test "ndconfig: init null" {
     try t.expectEqual(SysupdatesChannel.disabled, conf.data.syschannel);
     try t.expectEqualStrings(SYSUPDATES_CRON_SCRIPT_PATH, conf.data.syscronscript);
     try t.expectEqualStrings(SYSUPDATES_RUN_SCRIPT_PATH, conf.data.sysrunscript);
+    try t.expectEqualStrings("", conf.data.head);
 }
 
 test "ndconfig: dump" {
@@ -611,6 +659,7 @@ test "ndconfig: dump" {
     try t.expectEqual(SysupdatesChannel.master, parsed.value.syschannel);
     try t.expectEqualStrings("cronscript.sh", parsed.value.syscronscript);
     try t.expectEqualStrings("runscript.sh", parsed.value.sysrunscript);
+    try t.expectEqualStrings("", parsed.value.head);
 }
 
 test "ndconfig: switch sysupdates and infer" {
diff --git a/src/nd/Daemon.zig b/src/nd/Daemon.zig
@@ -69,6 +69,8 @@ want_lnd_report: bool,
 lnd_timer: time.Timer,
 lnd_report_interval: u64 = 1 * time.ns_per_min,
 lnd_tls_reset_count: usize = 0,
+sysupdates_head: ?[]u8 = null,
+next_head_refresh_ns: i128 = 0,
 
 // TODO: move this to a sys.ServiceList
 /// system services actively managed by the daemon.
@@ -143,7 +145,7 @@ pub fn init(opt: InitOpt) !Daemon {
 
     logger.debug("conf = {any}", .{opt.conf});
 
-    return .{
+    var d: Daemon = .{
         .allocator = opt.allocator,
         .conf = opt.conf,
         .uireader = opt.uir,
@@ -164,14 +166,22 @@ pub fn init(opt: InitOpt) !Daemon {
         // report lightning status immediately on start
         .want_lnd_report = true,
         .lnd_timer = try time.Timer.start(),
+        .next_head_refresh_ns = 0,
+        .sysupdates_head = null,
     };
+
+    d.refreshSysupdatesHead();
+    return d;
 }
 
 /// releases all associated resources.
 /// the daemon must be stop'ed and wait'ed before deiniting.
 pub fn deinit(self: *Daemon) void {
     self.wpa_ctrl.close() catch |err| logger.err("deinit: wpa_ctrl.close: {any}", .{err});
     self.services.deinit(self.allocator);
+    if (self.sysupdates_head) |head| {
+        self.allocator.free(head);
+    }
 }
 
 /// start launches daemon threads and returns immediately.
@@ -338,16 +348,32 @@ fn mainThreadLoop(self: *Daemon) void {
     logger.info("exiting main thread loop", .{});
 }
 
+const HEAD_REFRESH_PERIOD_NS: i128 = 60 * std.time.ns_per_s;
+
 /// runs one cycle of the main thread loop iteration.
-/// the cycle holds self.mu for the whole duration.
+/// briefly locks self.mu to decide on refresh, then holds self.mu
 fn mainThreadLoopCycle(self: *Daemon) !void {
+    // decide whether to refresh (fast)
+    var do_refresh = false;
+    const now = std.time.nanoTimestamp();
+    self.mu.lock();
+    if (now >= self.next_head_refresh_ns) {
+        self.next_head_refresh_ns = now + HEAD_REFRESH_PERIOD_NS;
+        do_refresh = true;
+    }
+    self.mu.unlock();
+
+    if (do_refresh) self.refreshSysupdatesHead();
+
     self.mu.lock();
     defer self.mu.unlock();
 
     if (self.want_settings) {
-        const ok = self.conf.safeReadOnly(struct {
-            fn f(conf: Config.Data, static: Config.StaticData) bool {
-                const msg: comm.Message.Settings = .{
+        const head_override: ?[]const u8 = self.sysupdates_head;
+
+        const msg_opt = self.conf.safeReadOnly(struct {
+            fn f(conf: Config.Data, static: Config.StaticData) ?comm.Message.Settings {
+                return .{
                     .hostname = static.hostname,
                     .slock_enabled = conf.slock != null,
                     .sysupdates = .{
@@ -357,16 +383,23 @@ fn mainThreadLoopCycle(self: *Daemon) !void {
                             .master => .stable,
                             .disabled => .disabled,
                         },
+                        .head = conf.head, // temporary; caller may override
                     },
                 };
-                comm.pipeWrite(.{ .settings = msg }) catch |err| {
-                    logger.err("{}", .{err});
-                    return false;
-                };
-                return true;
             }
         }.f);
-        self.want_settings = !ok;
+
+        if (msg_opt) |msg_const| {
+            var msg = msg_const;
+            msg.sysupdates.head = if (head_override) |h| h else msg.sysupdates.head;
+
+            var ok = true;
+            comm.pipeWrite(.{ .settings = msg }) catch |err| {
+                logger.err("{}", .{err});
+                ok = false;
+            };
+            self.want_settings = !ok;
+        }
     }
 
     // network stats
@@ -539,6 +572,12 @@ fn commThreadLoop(self: *Daemon) void {
             .unlock_screen => |pincode| {
                 self.unlockScreen(pincode) catch |err| logger.err("unlockScreen: {!}", .{err});
             },
+            .get_settings => {
+                self.refreshSysupdatesHead();
+                self.mu.lock();
+                self.want_settings = true;
+                self.mu.unlock();
+            },
             else => |v| logger.warn("unhandled msg tag {s}", .{@tagName(v)}),
         }
 
@@ -1292,6 +1331,56 @@ fn allocSanitizeNodename(allocator: std.mem.Allocator, name: []const u8) ![]cons
     return allocator.dupe(u8, trimmed);
 }
 
+fn readGitHeadOwned(self: *Daemon) ?[]u8 {
+    std.fs.accessAbsolute(Config.SYSUPDATES_LOCAL_REPO_PATH, .{}) catch |err| switch (err) {
+        error.FileNotFound => return null,
+        else => {
+            logger.debug("readGitHeadOwned: access check failed: {any}", .{err});
+            // Proceed anyway; git command will provide a clearer error if needed
+        },
+    };
+
+    const res = std.process.Child.run(.{
+        .allocator = self.allocator,
+        .argv = &.{ "git", "-C", Config.SYSUPDATES_LOCAL_REPO_PATH, "rev-parse", "--short", "HEAD" },
+    }) catch |err| {
+        // In tests, git may not exist; keep this non-fatal.
+        logger.debug("readGitHeadOwned: git failed: {any}", .{err});
+        return null;
+    };
+    defer {
+        self.allocator.free(res.stdout);
+        self.allocator.free(res.stderr);
+    }
+
+    if (res.term != .Exited or res.term.Exited != 0) {
+        // If it's missing/not a repo, be quiet (or debug), not error.
+        logger.debug("readGitHeadOwned: git exit {any}; stderr={s}", .{ res.term, res.stderr });
+        return null;
+    }
+
+    const head = std.mem.trim(u8, res.stdout, &std.ascii.whitespace);
+    return self.allocator.dupe(u8, head) catch null;
+}
+
+fn refreshSysupdatesHead(self: *Daemon) void {
+    const new = self.readGitHeadOwned() orelse return;
+
+    self.mu.lock();
+    defer self.mu.unlock();
+
+    if (self.sysupdates_head) |old| {
+        if (std.mem.eql(u8, old, new)) {
+            self.allocator.free(new);
+            return;
+        }
+        logger.info("sysupdates head changed: {s} -> {s}", .{ old, new });
+        self.allocator.free(old);
+    }
+    self.sysupdates_head = new;
+    self.want_settings = true;
+}
+
 test "daemon: start-stop" {
     const t = std.testing;
 
diff --git a/src/ngui.zig b/src/ngui.zig
@@ -141,8 +141,12 @@ export fn nm_sys_shutdown() void {
 
 export fn nm_tab_settings_active() void {
     logger.info("starting wifi scan", .{});
+    // Force nd to refresh settings (incl sysupdates HEAD) on entering the settings tab.
+    comm.pipeWrite(comm.Message{ .get_settings = {} }) catch |err|
+        logger.err("nm_tab_settings_active: get_settings: {any}", .{err});
     const msg = comm.Message{ .get_network_report = .{ .scan = true } };
-    comm.pipeWrite(msg) catch |err| logger.err("nm_tab_settings_active: {any}", .{err});
+    comm.pipeWrite(msg) catch |err|
+        logger.err("nm_tab_settings_active: {any}", .{err});
 }
 
 export fn nm_request_network_status(t: *lvgl.LvTimer) void {
@@ -415,6 +419,9 @@ pub fn main() anyerror!void {
     // initialize global nd/ngui pipe plumbing.
     comm.initPipe(gpa, .{ .r = std.io.getStdIn(), .w = std.io.getStdOut() });
 
+    comm.pipeWrite(comm.Message{ .get_settings = {} }) catch |err|
+        logger.err("startup: get_settings: {any}", .{err});
+
     // initalizes display, input driver and finally creates the user interface.
     ui.init(.{ .allocator = gpa, .slock = flags.slock }) catch |err| {
         logger.err("ui.init: {any}", .{err});
diff --git a/src/test/guiplay.zig b/src/test/guiplay.zig
@@ -218,7 +218,7 @@ fn commWriteThread(gpa: std.mem.Allocator, w: anytype) !void {
             const sett: comm.Message.Settings = .{
                 .slock_enabled = state.slock_pincode != null,
                 .hostname = state.nodename.val(),
-                .sysupdates = .{ .url = "", .channel = .edge },
+                .sysupdates = .{ .url = "", .channel = .edge, .head = "" },
             };
             comm.write(gpa, w, .{ .settings = sett }) catch |err| {
                 logger.err("{}", .{err});
diff --git a/src/ui/settings.zig b/src/ui/settings.zig
