remove print and sleep

[zighttp] / src / http.zig

diff --git a/src/http.zig b/src/http.zig
index 8c2ae0bbec1b3a89a5b2330babe7be1dfbbcd134..378bca7cd68079ec165eb9572e7ca7e983228927 100644 (file)
--- a/src/http.zig
+++ b/src/http.zig
@@ -59,10 +59,10 @@ pub const Server = struct {
                 errdefer posix.close(client_socket);
                 var event = linux.epoll_event{ .events = linux.EPOLL.IN, .data = .{ .fd = client_socket } };
                 try posix.epoll_ctl(self.efd, linux.EPOLL.CTL_ADD, client_socket, &event);
-                var addr: std.c.sockaddr = undefined;
+                var addr: std.os.linux.sockaddr = undefined;
                 var addr_size: std.c.socklen_t = @sizeOf(std.c.sockaddr);
                 _ = std.c.getpeername(client_socket, &addr, &addr_size);
-                std.debug.print("new connection from {}\n", .{addr});
+                // std.debug.print("new connection from {} [{}/{}]\n", .{ addr, @sizeOf(std.os.linux.sockaddr), addr_size });
             } else {
                 var closed = false;
                 var req = Request{ .fd = ready_socket };
@@ -73,6 +73,8 @@ pub const Server = struct {
                     read += newly_read;
                     if (newly_read == 0)
                         break;
+                    // std.debug.print("[[{}/{}]]\n", .{ newly_read, read });
+                    // std.time.sleep(100000000);
                 }
                 if (read == 0) {
                     closed = true;
@@ -335,7 +337,7 @@ pub const Response = struct {
     pub fn add_header(self: *Response, name: []const u8, value: anytype) !void {
         const header = try self.extra_headers.addOne();
         try header.name.writer().writeAll(name);
-        if (@typeInfo(@TypeOf(value)).Struct.fields.len < 2 or @sizeOf(@TypeOf(value[1])) == 0) {
+        if (@typeInfo(@TypeOf(value)).@"struct".fields.len < 2 or @sizeOf(@TypeOf(value[1])) == 0) {
             try header.value.writer().writeAll(value[0]);
         } else {
             try std.fmt.format(header.value.writer(), value[0], value[1]);
@@ -354,7 +356,7 @@ pub const Response = struct {
     pub fn write(self: *Response, comptime fmt: []const u8, args: anytype) !void {
         const writer = self.stream_body.writer();
 
-        if (@sizeOf(@TypeOf(args)) == 0) {
+        if (@typeInfo(@TypeOf(args)).@"struct".fields.len == 0) {
             try writer.writeAll(fmt);
         } else {
             try std.fmt.format(writer, fmt, args);
@@ -364,20 +366,23 @@ pub const Response = struct {
     pub fn send(self: *Response) !void {
         // TODO: Provisorium
         const compress = false;
-        var compress_buffer = try std.BoundedArray(u8, 1024 * 32).init(0);
+        const CompressBuffer = struct {
+            var compress_buffer: std.BoundedArray(u8, 1024 * 32) = undefined;
+        };
+        try CompressBuffer.compress_buffer.resize(0);
 
         // write head
         const writer = self.stream_head.writer();
 
         if (compress) {
             var cfbs = std.io.fixedBufferStream(self.stream_body.getWritten());
-            var compressor = try std.compress.gzip.compressor(compress_buffer.writer(), .{ .level = .default });
+            var compressor = try std.compress.gzip.compressor(CompressBuffer.compress_buffer.writer(), .{ .level = .default });
             try compressor.compress(cfbs.reader());
             // try compressor.flush();
             try compressor.finish();
             try std.fmt.format(writer, "HTTP/1.1 {} {?s}\r\n" ++
                 "Content-Length: {}\r\n" ++
-                "Content-Encoding: gzip\r\n", .{ @intFromEnum(self.status), self.status.phrase(), compress_buffer.constSlice().len });
+                "Content-Encoding: gzip\r\n", .{ @intFromEnum(self.status), self.status.phrase(), CompressBuffer.compress_buffer.constSlice().len });
         } else {
             try std.fmt.format(writer, "HTTP/1.1 {} {?s}\r\n" ++
                 "Content-Length: {}\r\n", .{ @intFromEnum(self.status), self.status.phrase(), self.stream_body.pos });
@@ -391,9 +396,9 @@ pub const Response = struct {
 
         // write body to head
         if (compress) {
-            try std.fmt.format(writer, "{s}", .{compress_buffer.constSlice()});
+            try writer.writeAll(CompressBuffer.compress_buffer.constSlice());
         } else {
-            try std.fmt.format(writer, "{s}", .{self.stream_body.getWritten()});
+            try writer.writeAll(self.stream_body.getWritten());
         }
 
         // send