shelving this version for a bit

src/main.zig

@@ -14,12 +14,6 @@ const std = @import("std");
 //
 // A - means immediately, a + means eventually.
 
-var global_connection: ?std.net.Server.Connection = null;
-var global_websocket: ?*std.http.WebSocket = null;
-
-var global_send_buf: ?[]u8 = null;
-var global_recv_buf: ?[]align(4) u8 = null;
-
 pub fn main() !void {
     var gpa = std.heap.GeneralPurposeAllocator(.{}){};
     defer _ = gpa.deinit();
@@ -28,30 +22,33 @@ pub fn main() !void {
     var vlc = try VLC.init(allocator, try std.Uri.parse("http://localhost:8080"));
     defer vlc.deinit();
 
-    var tz_file = try std.fs.openFileAbsolute("/etc/localtime", .{});
+    // var tz_file = try std.fs.openFileAbsolute("/etc/localtime", .{});
-    defer tz_file.close();
+    // defer tz_file.close();
-    var tz = try std.tz.Tz.parse(allocator, tz_file.reader());
+    // var tz = try std.tz.Tz.parse(allocator, tz_file.reader());
-    defer tz.deinit();
+    // defer tz.deinit();
 
     var server = try std.net.Address.initIp4(.{ 127, 0, 0, 1 }, 8009).listen(.{});
     defer server.deinit();
 
-    // while (true) : (std.time.sleep(1_000_000_000)) { // sleep 500ms
+    var clients = std.ArrayList(Client).init(allocator);
-    //     try updateTime(tz);
+    defer {
-    //     try updateStatus(allocator, &vlc);
+        for (0..clients.items.len) |i| clients.items[i].deinit(allocator);
-    //     // scroll += 1;
+        clients.deinit();
-    // }
+    }
 
-    defer if (global_connection) |conn| conn.stream.close();
+    // var delay: u8 = 0;
-    defer if (global_send_buf) |buf| allocator.free(buf);
-    defer if (global_recv_buf) |buf| allocator.free(buf);
-
-    var delay: u8 = 0;
     while (true) {
-        var pollfds = [_]std.posix.pollfd{.{ .fd = server.stream.handle, .events = std.posix.POLL.IN, .revents = 0 }};
+        var pollfds = std.ArrayList(std.posix.pollfd).init(allocator);
-        const num = try std.posix.poll(&pollfds, 100);
+        defer pollfds.deinit();
-        std.debug.print("num pollfds {d}\nrevents {d}\n", .{ num, pollfds[0].revents });
+        try pollfds.append(.{ .fd = server.stream.handle, .events = std.posix.POLL.IN, .revents = 0 });
-        if (pollfds[0].revents != 0) {
+        for (clients.items, 0..) |client, i| {
+            std.debug.print("appending client {d} to poll()\n", .{i});
+            try pollfds.append(.{ .fd = client.connection.stream.handle, .events = std.posix.POLL.IN, .revents = 0 });
+        }
+        const num = try std.posix.poll(pollfds.items, 100);
+        // std.debug.print("num pollfds {d}\n", .{num});
+        _ = num;
+        if (pollfds.items[0].revents != 0) {
             const read_buf = try allocator.alloc(u8, 1024 * 32);
             defer allocator.free(read_buf);
 
@@ -64,24 +61,26 @@ pub fn main() !void {
 
             var websocket: std.http.WebSocket = undefined;
 
-            global_send_buf = try allocator.alloc(u8, 1024 * 32);
+            const send_buf = try allocator.alloc(u8, 1024 * 32);
-            global_recv_buf = try allocator.alignedAlloc(u8, 4, 1024 * 32);
+            errdefer allocator.free(send_buf);
+            const recv_buf = try allocator.alignedAlloc(u8, 4, 1024 * 32);
+            errdefer allocator.free(recv_buf);
 
-            const is_websocket = try websocket.init(&request, global_send_buf.?, global_recv_buf.?);
+            const is_websocket = try websocket.init(&request, send_buf, recv_buf);
             if (is_websocket) {
+                // if websocket, we clean up at the end of main(), not the end of the block
                 try websocket.response.flush();
                 std.debug.print("is a websocket now\n", .{});
-                global_connection = connection;
-                global_websocket = &websocket;
-                // const msg = try websocket.readSmallMessage();
-                // std.debug.print("{any}\n{s}\n", .{ msg, msg.data });
 
-                // try websocket.writeMessage("dude i cant believe you just ate that", .text);
+                const client = Client{
-                // // try websocket.writeMessage("", .ping);
+                    .connection = connection,
-                // std.time.sleep(5_000_000_000);
+                    .websocket = websocket,
-                // try websocket.writeMessage("dude why did i just eat that now", .text);
+                    .send_buf = send_buf,
-                // std.debug.print("sent second one\n", .{});
+                    .recv_buf = recv_buf,
+                };
+                try clients.append(client);
             } else {
+                // if normal HTTP, clean up at the end of the block
                 defer connection.stream.close();
                 switch (request.head.method) {
                     .GET, .HEAD => {
@@ -104,43 +103,57 @@ pub fn main() !void {
             }
         }
 
-        delay += 1;
+        const status_string = try getStatusString(allocator, &vlc);
-        if (delay == 10) {
+        defer allocator.free(status_string);
-            delay = 0;
+        for (1..pollfds.items.len) |i| {
-            try updateStatus(allocator, &vlc);
+            const pollfd = pollfds.items[i];
+            var client = &clients.items[i - 1];
+            std.debug.print("client idx {d} for status update\nrevents {d}\n", .{ i - 1, pollfd.revents });
+            // try std.http.WebSocket.writeMessage(&client.websocket, status_string, .text);
+            if (pollfd.revents & std.posix.POLL.IN != 0) {
+                const data = std.http.WebSocket.readSmallMessage(&client.websocket) catch |e| switch (e) {
+                    error.EndOfStream => continue,
+                    error.ConnectionClose => continue,
+                    else => return e,
+                };
+                std.debug.print("recieved opcode: {any} with data {s}\n", .{ data.opcode, data.data });
+            }
         }
+
+        std.Thread.sleep(1_000_000_000);
     }
 }
 
+const Client = struct {
+    connection: std.net.Server.Connection,
+    websocket: std.http.WebSocket,
+    send_buf: []u8,
+    recv_buf: []align(4) u8,
+
+    pub fn deinit(self: *Client, allocator: std.mem.Allocator) void {
+        allocator.free(self.send_buf);
+        allocator.free(self.recv_buf);
+        self.connection.stream.close();
+    }
+};
+
 const base64_encoder = std.base64.standard.Encoder;
 
 // TODO make the URL something short like jeevio.xyz/streamboy
 const topic = "Something Fun For Everyone With Streamboy!!!!!!!! git.jeevio.xyz/jeeves/streamboy";
 
-// var scroll: usize = 0;
+fn getStatusString(allocator: std.mem.Allocator, vlc: *VLC) ![]u8 {
+    var song_info = try vlc.getSongInfo();
+    defer song_info.deinit();
 
-fn updateStatus(allocator: std.mem.Allocator, vlc: *VLC) !void {
+    const string = try std.fmt.allocPrint(allocator, "{s}    |    ♪ {s} - {s}    |    ", .{
-    // var stream_info_file = try std.fs.createFileAbsolute("/tmp/streaminfo", .{ .truncate = true });
+        topic,
-    // defer stream_info_file.close();
+        song_info.title orelse "Unknown Title",
-    if (global_websocket) |ws| {
+        song_info.artist orelse "Unknown Artist",
-        var song_info = try vlc.getSongInfo();
+    });
-        defer song_info.deinit();
+    errdefer allocator.free(string);
 
-        const string = try std.fmt.allocPrint(allocator, "{s}    |    ♪ {s} - {s}    |    ", .{
+    return string;
-            topic,
-            song_info.title orelse "Unknown Title",
-            song_info.artist orelse "Unknown Artist",
-        });
-        defer allocator.free(string);
-
-        try ws.writeMessage(string, .text);
-    }
-
-    // if (scroll > string.len) scroll = 0;
-    // if (scroll == 0) try stream_info_file.writeAll(string) else {
-    //     for (string[scroll..]) |char| try stream_info_file.writer().writeByte(char);
-    //     for (string[0..scroll]) |char| try stream_info_file.writer().writeByte(char);
-    // }
 }
 
 pub const VLC = struct {
@@ -159,6 +172,7 @@ pub const VLC = struct {
         const authorization = try std.fmt.allocPrint(allocator, "Basic {s}", .{base64_encoder.encode(base64_userpass, userpass)});
         errdefer allocator.free(authorization);
 
+        // TODO actually launch VLC
         // var vlc = std.process.Child.init(&[_][]const u8{
         //     "vlc",
         //     "--intf",
@@ -226,7 +240,6 @@ pub const VLC = struct {
         album: ?[]const u8,
         artist: ?[]const u8,
 
-        // TODO move allocator into struct
         pub fn deinit(self: *SongInfo) void {
             if (self.title) |b| self.allocator.free(b);
             if (self.album) |b| self.allocator.free(b);

src/web/statusline.js

@@ -2,11 +2,18 @@ const statusLineElement = document.getElementById("status-line");
 
 const socket = new WebSocket("ws://localhost:8009");
 
-// socket.addEventListener("open", (event) => {
-//   socket.send("Hello Server!");
-// });
-
 socket.addEventListener("message", (event) => {
-  console.log("Message from server ", event.data);
+  console.log(event);
   statusLineElement.textContent = event.data;
 });
+
+// const status = {
+//   blocks: [
+//     "Something Fun For Everyone With Streamboy!!!!!!!! git.jeevio.xyz/jeeves/streamboy",
+//     "♪ Bonhomme de Neige (EarthBound) - Ridley Snipes feat. Earth Kid",
+//   ],
+// };
+
+// setInterval(() => {
+//   // statusText = "Something Fun For Everyone With Streamboy!!!!!!!! git.jeevio.xyz/jeeves/streamboy | ♪ Bonhomme de Neige (EarthBound) - Ridley Snipes feat. Earth Kid | ";
+// }, 5000);

src/web/style.css

@@ -13,4 +13,16 @@ body {
 #status-line {
   font-size: 16px;
   margin: 0px;
+  white-space: nowrap;
+  animation: marquee 5s linear infinite;
+  max-width: none;
+}
+
+@keyframes marquee {
+  from {
+    left: -100%;
+  }
+  to {
+    left: 100%;
+  }
 }