Use new Io interface

Author: sdzx-1

examples/simple.zig

@@ -1,6 +1,5 @@
 const std = @import("std");
 const ps = @import("polysession");
-const net = std.net;
 const channel = @import("channel.zig");
 const StreamChannel = channel.StreamChannel;
 const core = @import("core.zig");
@@ -43,22 +42,27 @@ pub fn main() !void {
     }
 
     //Server
-    const localhost = try net.Address.parseIp("127.0.0.1", 0);
 
-    var server = try localhost.listen(.{});
-    defer server.deinit();
+    var threaded = std.Io.Threaded.init(gpa);
+    const io = threaded.io();
+
+    const net = std.Io.net;
+    const localhost = try net.IpAddress.parse("127.0.0.1", 8881);
+
+    var server = try localhost.listen(io, .{});
+    defer server.deinit(io);
     //
 
     const S = struct {
-        fn clientFn(server_address: net.Address, dir: std.fs.Dir) !void {
-            const socket = try net.tcpConnectToAddress(server_address);
-            defer socket.close();
+        fn clientFn(io_: std.Io, server_address: net.IpAddress, dir: std.fs.Dir) !void {
+            const socket = try server_address.connect(io_, .{ .mode = .stream });
+            defer socket.close(io_);
 
             var reader_buf: [1024 * 1024 * 2]u8 = undefined;
             var writer_buf: [1024 * 1024 * 2]u8 = undefined;
 
-            var stream_reader = socket.reader(&reader_buf);
-            var stream_writer = socket.writer(&writer_buf);
+            var stream_reader = socket.reader(io_, &reader_buf);
+            var stream_writer = socket.writer(io_, &writer_buf);
 
             const write_file = try dir.createFile("test_write", .{});
             defer write_file.close();
@@ -79,7 +83,7 @@ pub fn main() !void {
                 true,
                 .{
                     .server = StreamChannel{
-                        .reader = stream_reader.interface(),
+                        .reader = &stream_reader.interface,
                         .writer = &stream_writer.interface,
                         .log = false,
                     },
@@ -90,26 +94,26 @@ pub fn main() !void {
         }
     };
 
-    const t = try std.Thread.spawn(.{}, S.clientFn, .{ server.listen_address, tmp_dir });
-    defer t.join();
+    var t = try io.concurrent(S.clientFn, .{ io, localhost, tmp_dir });
+    defer t.await(io) catch unreachable;
 
     //
 
-    var client = try server.accept();
-    defer client.stream.close();
+    var client = try server.accept(io);
+    defer client.close(io);
 
     var reader_buf: [1024 * 1024 * 2]u8 = undefined;
     var writer_buf: [1024 * 1024 * 2]u8 = undefined;
 
-    var stream_reader = client.stream.reader(&reader_buf);
-    var stream_writer = client.stream.writer(&writer_buf);
+    var stream_reader = client.reader(io, &reader_buf);
+    var stream_writer = client.writer(io, &writer_buf);
 
     var file_reader_buf: [1024 * 1024 * 2]u8 = undefined;
 
     const read_file = try tmp_dir.openFile("test_read", .{});
     defer read_file.close();
 
-    var file_reader = read_file.reader(&file_reader_buf);
+    var file_reader = read_file.reader(io, &file_reader_buf);
 
     var server_context: ServerContext = .{
         .pingpong = .{ .server_counter = 0 },
@@ -124,7 +128,7 @@ pub fn main() !void {
         true,
         .{
             .client = StreamChannel{
-                .reader = stream_reader.interface(),
+                .reader = &stream_reader.interface,
                 .writer = &stream_writer.interface,
                 .log = false,
             },

examples/two_phase_commit_generic.zig

@@ -69,15 +69,18 @@ pub fn main() !void {
         }
     };
 
-    const alice_thread = try std.Thread.spawn(.{}, alice.clientFn, .{&mvar_channel_map});
-    const bob_thread = try std.Thread.spawn(.{}, bob.clientFn, .{&mvar_channel_map});
-    const charlie_thread = try std.Thread.spawn(.{}, charlie.clientFn, .{&mvar_channel_map});
-    const selector_thread = try std.Thread.spawn(.{}, selector.clientFn, .{&mvar_channel_map});
-
-    alice_thread.join();
-    bob_thread.join();
-    charlie_thread.join();
-    selector_thread.join();
+    var threaded = std.Io.Threaded.init(gpa);
+    const io = threaded.io();
+
+    var alice_thread = try io.concurrent(alice.clientFn, .{&mvar_channel_map});
+    var bob_thread = try io.concurrent(bob.clientFn, .{&mvar_channel_map});
+    var charlie_thread = try io.concurrent(charlie.clientFn, .{&mvar_channel_map});
+    var selector_thread = try io.concurrent(selector.clientFn, .{&mvar_channel_map});
+
+    try alice_thread.await(io);
+    try bob_thread.await(io);
+    try charlie_thread.await(io);
+    try selector_thread.await(io);
 }
 
 //