Create basic TCP server for main and adapt to jsruntime arena change

Signed-off-by: Francis Bouvier <francis.bouvier@gmail.com>

src/main.zig

@@ -1,27 +1,85 @@
 const std = @import("std");
 
-const runtime = @import("jsruntime");
+const jsruntime = @import("jsruntime");
 
-const EventTarget = @import("dom/event_target.zig").EventTarget;
+const DOM = @import("dom.zig");
-const Node = @import("dom/node.zig").Node;
+
-const Document = @import("dom/document.zig").Document;
+const html = @import("html.zig").html;
+
+const socket_path = "/tmp/browsercore-server.sock";
+
+var doc: DOM.HTMLDocument = undefined;
+var server: std.net.StreamServer = undefined;
+
+fn execJS(
+    alloc: std.mem.Allocator,
+    js_env: *jsruntime.Env,
+    comptime apis: []jsruntime.API,
+) !void {
+
+    // start JS env
+    js_env.start();
+    defer js_env.stop();
+
+    // add document object
+    try js_env.addObject(apis, doc, "document");
+
+    while (true) {
+
+        // read cmd
+        const conn = try server.accept();
+        var buf: [100]u8 = undefined;
+        const read = try conn.stream.read(&buf);
+        const cmd = buf[0..read];
+        std.debug.print("<- {s}\n", .{cmd});
+        if (std.mem.eql(u8, cmd, "exit")) {
+            break;
+        }
+
+        const res = try js_env.execTryCatch(alloc, cmd, "cdp");
+        if (res.success) {
+            std.debug.print("-> {s}\n", .{res.result});
+        }
+        _ = try conn.stream.write(res.result);
+    }
+}
 
 pub fn main() !void {
 
-    // // generate APIs
+    // generate APIs
-    // _ = comptime runtime.compile(.{ EventTarget, Node, Document });
+    const apis = jsruntime.compile(DOM.Interfaces);
 
-    // // create v8 vm
+    // create v8 vm
-    // const vm = runtime.VM.init();
+    const vm = jsruntime.VM.init();
-    // defer vm.deinit();
+    defer vm.deinit();
 
-    // // document
+    // document
-    // var doc = Document.init();
+    doc = DOM.HTMLDocument.init();
-    // defer doc.deinit();
+    defer doc.deinit();
-    // var html: []const u8 = "<div><a href='foo'>OK</a><p>blah-blah-blah</p></div>";
+    try doc.parse(html);
-    // try doc.parse(html);
-
-    // try doc.proto.make_tree();
 
     std.debug.print("ok\n", .{});
+
+    // remove socket file of internal server
+    // reuse_address (SO_REUSEADDR flag) does not seems to work on unix socket
+    // see: https://gavv.net/articles/unix-socket-reuse/
+    // TODO: use a lock file instead
+    std.os.unlink(socket_path) catch |err| {
+        if (err != error.FileNotFound) {
+            return err;
+        }
+    };
+
+    // alloc
+    var arena = std.heap.ArenaAllocator.init(std.heap.page_allocator);
+    defer _ = arena.deinit();
+
+    // server
+    var addr = try std.net.Address.initUnix(socket_path);
+    server = std.net.StreamServer.init(.{});
+    defer server.deinit();
+    try server.listen(addr);
+    std.debug.print("Listening on: {s}...\n", .{socket_path});
+
+    try jsruntime.loadEnv(&arena, execJS, apis);
 }

src/main_shell.zig

@@ -32,10 +32,9 @@ pub fn main() !void {
     const apis = jsruntime.compile(DOM.Interfaces);
 
     // document
-    var base_doc = DOM.Document.init();
+    doc = DOM.HTMLDocument.init();
-    defer base_doc.deinit();
+    defer doc.deinit();
-    try base_doc.parse(html);
+    try doc.parse(html);
-    doc = DOM.HTMLDocument{ .proto = base_doc };
 
     // create JS vm
     const vm = jsruntime.VM.init();
@@ -44,8 +43,9 @@ pub fn main() !void {
     // alloc
     var gpa = std.heap.GeneralPurposeAllocator(.{}){};
     defer _ = gpa.deinit();
-    const alloc = gpa.allocator();
+    var arena = std.heap.ArenaAllocator.init(gpa.allocator());
+    defer arena.deinit();
 
     // launch shell
-    try jsruntime.shell(alloc, false, apis, execJS, .{ .app_name = "browsercore" });
+    try jsruntime.shell(&arena, apis, execJS, .{ .app_name = "browsercore" });
 }