Shutting down an event loop in a thread

[RossComputerGuy]

I'm faced with a problem where loop.stop() before a thread.join() does not complete. This means, the event loop inside thread is still running. I need to gracefully shut down. I'm using the default backend selection which happens to be io_uring on Linux.

Code:
https://github.com/PipeletCloud/workflow-runner/blob/58ef1c275410aa55efed3654ea7393e63554acdf/src/Server.zig#L45-L49

[mitchellh]

I'm not 100% sure what's going on here, but Ghostty is multithreaded and each of our threads has an xev loop.

What you want to do is setup an xev.Async to trigger a shutdown, and from within the callback of the async call loop.stop. This will end the loop on that tick iteration and the run(.until_done) will return and the treat will properly exit.

In case it isn't clear, loop.stop MUST be called from the same thread that the loop is running on. The only thing in all of libxev that is safe to call multi-threaded is an xev.Async.

Take a look at src/termio/Thread.zig in Ghostty for more info.

[RossComputerGuy]

My particular problem is that I'm listening to a socket and when I send an HTTP request after I call the stop() and join(), then the join() completes. Will the xev.Async fix that?

[RossComputerGuy]

Just tried this and it does not work.

diff --git a/src/Server.zig b/src/Server.zig
index 92d8ae5..10ec592 100644
--- a/src/Server.zig
+++ b/src/Server.zig
@@ -43,7 +43,14 @@ pub fn init(self: *Self, alloc: std.mem.Allocator, addr: std.net.Address) !void
 }

 pub fn deinit(self: *Self, alloc: std.mem.Allocator) void {
-    self.loop.stop();
+    var stop = xev.Async.init() catch |err| std.debug.panic("Failed to create async: {}", .{err});
+    defer stop.deinit();
+
+    var stop_c: xev.Completion = undefined;
+    stop.wait(&self.loop, &stop_c, Self, self, stopCallback);
+
+    stop.notify() catch |err| std.debug.panic("Failed to notify: {}", .{err});
+
     self.server.deinit();
     self.thread.join();
     self.clients.deinit();
@@ -111,3 +118,14 @@ fn runThread(self: *Self) void {
     log.debug("Starting server on {}", .{self.address});
     self.loop.run(.until_done) catch |err| log.err("Failed to run event loop: {}", .{err});
 }
+
+fn stopCallback(
+    self: ?*Self,
+    _: *xev.Loop,
+    _: *xev.Completion,
+    r: xev.Async.WaitError!void,
+) xev.CallbackAction {
+    _ = r catch unreachable;
+    self.?.loop.stop();
+    return .disarm;
+}

The HTTP server continues to block the event loop from shutting down.