From 0f4f6078143e67d50bfd66840e31cf3b38987261 Mon Sep 17 00:00:00 2001 From: Ryo Ota Date: Thu, 20 Apr 2023 22:03:01 +0900 Subject: fix http client build error --- lib/std/http/Client.zig | 12 ++++++------ 1 file changed, 6 insertions(+), 6 deletions(-) (limited to 'lib/std') diff --git a/lib/std/http/Client.zig b/lib/std/http/Client.zig index 4ff29a215a..3de15774d1 100644 --- a/lib/std/http/Client.zig +++ b/lib/std/http/Client.zig @@ -797,18 +797,18 @@ pub const Request = struct { /// Write `bytes` to the server. The `transfer_encoding` request header determines how data will be sent. pub fn write(req: *Request, bytes: []const u8) WriteError!usize { - switch (req.headers.transfer_encoding) { + switch (req.transfer_encoding) { .chunked => { - try req.connection.data.conn.writer().print("{x}\r\n", .{bytes.len}); - try req.connection.data.conn.writeAll(bytes); - try req.connection.data.conn.writeAll("\r\n"); + try req.connection.data.buffered.writer().print("{x}\r\n", .{bytes.len}); + try req.connection.data.buffered.writeAll(bytes); + try req.connection.data.buffered.writeAll("\r\n"); return bytes.len; }, .content_length => |*len| { if (len.* < bytes.len) return error.MessageTooLong; - const amt = try req.connection.data.conn.write(bytes); + const amt = try req.connection.data.buffered.write(bytes); len.* -= amt; return amt; }, @@ -828,7 +828,7 @@ pub const Request = struct { /// Finish the body of a request. This notifies the server that you have no more data to send. pub fn finish(req: *Request) FinishError!void { switch (req.transfer_encoding) { - .chunked => try req.connection.data.conn.writeAll("0\r\n\r\n"), + .chunked => try req.connection.data.buffered.writeAll("0\r\n\r\n"), .content_length => |len| if (len != 0) return error.MessageNotCompleted, .none => {}, } -- cgit v1.2.3 From 39c0c24b5659bbcaec0a6f5ba4acc8666e3b8086 Mon Sep 17 00:00:00 2001 From: Ryo Ota Date: Fri, 21 Apr 2023 01:08:15 +0900 Subject: fix memory leaks and add an HTTP test --- lib/std/http/Client.zig | 69 +++++++++++++++++++++++++++++++++++++++++++++++++ lib/std/http/Server.zig | 5 +++- 2 files changed, 73 insertions(+), 1 deletion(-) (limited to 'lib/std') diff --git a/lib/std/http/Client.zig b/lib/std/http/Client.zig index 3de15774d1..661dcaab5b 100644 --- a/lib/std/http/Client.zig +++ b/lib/std/http/Client.zig @@ -1046,3 +1046,72 @@ test { std.testing.refAllDecls(@This()); } + +test "client requests server" { + const builtin = @import("builtin"); + + // This test requires spawning threads. + if (builtin.single_threaded) { + return error.SkipZigTest; + } + + const native_endian = comptime builtin.cpu.arch.endian(); + if (builtin.zig_backend == .stage2_llvm and native_endian == .Big) { + // https://github.com/ziglang/zig/issues/13782 + return error.SkipZigTest; + } + + if (builtin.os.tag == .wasi) return error.SkipZigTest; + + const allocator = std.testing.allocator; + + const max_header_size = 8192; + var server = std.http.Server.init(allocator, .{ .reuse_address = true }); + defer server.deinit(); + + const address = try std.net.Address.parseIp("127.0.0.1", 0); + try server.listen(address); + const server_port = server.socket.listen_address.in.getPort(); + + const thread = try std.Thread.spawn(.{}, (struct { + fn apply(s: *std.http.Server) !void { + const res = try s.accept(.{ .dynamic = max_header_size }); + defer res.reset(); + try res.wait(); + + const server_body: []const u8 = "message from server!\n"; + res.transfer_encoding = .{ .content_length = server_body.len }; + try res.headers.append("content-type", "text/plain"); + try res.headers.append("connection", "close"); + try res.do(); + + var buf: [128]u8 = undefined; + const n = try res.readAll(&buf); + try testing.expect(std.mem.eql(u8, buf[0..n], "Hello, World!\n")); + _ = try res.writer().writeAll(server_body); + try res.finish(); + } + }).apply, .{&server}); + + var uri_buf: [22]u8 = undefined; + const uri = std.Uri.parse(try std.fmt.bufPrint(&uri_buf, "http://127.0.0.1:{d}", .{server_port})) catch unreachable; + var client = std.http.Client{ .allocator = allocator }; + defer client.deinit(); + var client_headers = std.http.Headers{ .allocator = allocator }; + defer client_headers.deinit(); + var client_req = try client.request(.POST, uri, client_headers, .{}); + defer client_req.deinit(); + + client_req.transfer_encoding = .{ .content_length = 14 }; // this will be checked to ensure you sent exactly 14 bytes + try client_req.start(); // this sends the request + try client_req.writeAll("Hello, "); + try client_req.writeAll("World!\n"); + try client_req.finish(); + try client_req.do(); // this waits for a response + + const body = try client_req.reader().readAllAlloc(allocator, 8192 * 1024); + defer allocator.free(body); + try testing.expect(std.mem.eql(u8, body, "message from server!\n")); + + thread.join(); +} diff --git a/lib/std/http/Server.zig b/lib/std/http/Server.zig index 445a10bf48..b1205594ad 100644 --- a/lib/std/http/Server.zig +++ b/lib/std/http/Server.zig @@ -338,6 +338,9 @@ pub const Response = struct { /// Reset this response to its initial state. This must be called before handling a second request on the same connection. pub fn reset(res: *Response) void { + res.request.headers.deinit(); + res.headers.deinit(); + switch (res.request.compression) { .none => {}, .deflate => |*deflate| deflate.deinit(), @@ -357,7 +360,7 @@ pub const Response = struct { res.request.parser.header_bytes.deinit(res.server.allocator); } - res.* = undefined; + res.server.allocator.destroy(res); } else { res.request.parser.reset(); } -- cgit v1.2.3 From 06763c4c8c35d2e984ee2315e674a01d5506ded1 Mon Sep 17 00:00:00 2001 From: Ryo Ota Date: Fri, 21 Apr 2023 09:36:45 +0900 Subject: move the HTTP test to lib/std/http/test.zig --- lib/std/http.zig | 1 + lib/std/http/Client.zig | 69 ----------------------------------------------- lib/std/http/test.zig | 71 +++++++++++++++++++++++++++++++++++++++++++++++++ 3 files changed, 72 insertions(+), 69 deletions(-) create mode 100644 lib/std/http/test.zig (limited to 'lib/std') diff --git a/lib/std/http.zig b/lib/std/http.zig index 364cc4eeda..2f0a20de8d 100644 --- a/lib/std/http.zig +++ b/lib/std/http.zig @@ -275,4 +275,5 @@ test { _ = Client; _ = Method; _ = Status; + _ = @import("http/test.zig"); } diff --git a/lib/std/http/Client.zig b/lib/std/http/Client.zig index 661dcaab5b..3de15774d1 100644 --- a/lib/std/http/Client.zig +++ b/lib/std/http/Client.zig @@ -1046,72 +1046,3 @@ test { std.testing.refAllDecls(@This()); } - -test "client requests server" { - const builtin = @import("builtin"); - - // This test requires spawning threads. - if (builtin.single_threaded) { - return error.SkipZigTest; - } - - const native_endian = comptime builtin.cpu.arch.endian(); - if (builtin.zig_backend == .stage2_llvm and native_endian == .Big) { - // https://github.com/ziglang/zig/issues/13782 - return error.SkipZigTest; - } - - if (builtin.os.tag == .wasi) return error.SkipZigTest; - - const allocator = std.testing.allocator; - - const max_header_size = 8192; - var server = std.http.Server.init(allocator, .{ .reuse_address = true }); - defer server.deinit(); - - const address = try std.net.Address.parseIp("127.0.0.1", 0); - try server.listen(address); - const server_port = server.socket.listen_address.in.getPort(); - - const thread = try std.Thread.spawn(.{}, (struct { - fn apply(s: *std.http.Server) !void { - const res = try s.accept(.{ .dynamic = max_header_size }); - defer res.reset(); - try res.wait(); - - const server_body: []const u8 = "message from server!\n"; - res.transfer_encoding = .{ .content_length = server_body.len }; - try res.headers.append("content-type", "text/plain"); - try res.headers.append("connection", "close"); - try res.do(); - - var buf: [128]u8 = undefined; - const n = try res.readAll(&buf); - try testing.expect(std.mem.eql(u8, buf[0..n], "Hello, World!\n")); - _ = try res.writer().writeAll(server_body); - try res.finish(); - } - }).apply, .{&server}); - - var uri_buf: [22]u8 = undefined; - const uri = std.Uri.parse(try std.fmt.bufPrint(&uri_buf, "http://127.0.0.1:{d}", .{server_port})) catch unreachable; - var client = std.http.Client{ .allocator = allocator }; - defer client.deinit(); - var client_headers = std.http.Headers{ .allocator = allocator }; - defer client_headers.deinit(); - var client_req = try client.request(.POST, uri, client_headers, .{}); - defer client_req.deinit(); - - client_req.transfer_encoding = .{ .content_length = 14 }; // this will be checked to ensure you sent exactly 14 bytes - try client_req.start(); // this sends the request - try client_req.writeAll("Hello, "); - try client_req.writeAll("World!\n"); - try client_req.finish(); - try client_req.do(); // this waits for a response - - const body = try client_req.reader().readAllAlloc(allocator, 8192 * 1024); - defer allocator.free(body); - try testing.expect(std.mem.eql(u8, body, "message from server!\n")); - - thread.join(); -} diff --git a/lib/std/http/test.zig b/lib/std/http/test.zig new file mode 100644 index 0000000000..7c053dc6b3 --- /dev/null +++ b/lib/std/http/test.zig @@ -0,0 +1,71 @@ +const std = @import("std"); +const expect = std.testing.expect; + +test "client requests server" { + const builtin = @import("builtin"); + + // This test requires spawning threads. + if (builtin.single_threaded) { + return error.SkipZigTest; + } + + const native_endian = comptime builtin.cpu.arch.endian(); + if (builtin.zig_backend == .stage2_llvm and native_endian == .Big) { + // https://github.com/ziglang/zig/issues/13782 + return error.SkipZigTest; + } + + if (builtin.os.tag == .wasi) return error.SkipZigTest; + + const allocator = std.testing.allocator; + + const max_header_size = 8192; + var server = std.http.Server.init(allocator, .{ .reuse_address = true }); + defer server.deinit(); + + const address = try std.net.Address.parseIp("127.0.0.1", 0); + try server.listen(address); + const server_port = server.socket.listen_address.in.getPort(); + + const server_thread = try std.Thread.spawn(.{}, (struct { + fn apply(s: *std.http.Server) !void { + const res = try s.accept(.{ .dynamic = max_header_size }); + defer res.reset(); + try res.wait(); + + const server_body: []const u8 = "message from server!\n"; + res.transfer_encoding = .{ .content_length = server_body.len }; + try res.headers.append("content-type", "text/plain"); + try res.headers.append("connection", "close"); + try res.do(); + + var buf: [128]u8 = undefined; + const n = try res.readAll(&buf); + try expect(std.mem.eql(u8, buf[0..n], "Hello, World!\n")); + _ = try res.writer().writeAll(server_body); + try res.finish(); + } + }).apply, .{&server}); + + var uri_buf: [22]u8 = undefined; + const uri = try std.Uri.parse(try std.fmt.bufPrint(&uri_buf, "http://127.0.0.1:{d}", .{server_port})); + var client = std.http.Client{ .allocator = allocator }; + defer client.deinit(); + var client_headers = std.http.Headers{ .allocator = allocator }; + defer client_headers.deinit(); + var client_req = try client.request(.POST, uri, client_headers, .{}); + defer client_req.deinit(); + + client_req.transfer_encoding = .{ .content_length = 14 }; // this will be checked to ensure you sent exactly 14 bytes + try client_req.start(); // this sends the request + try client_req.writeAll("Hello, "); + try client_req.writeAll("World!\n"); + try client_req.finish(); + try client_req.do(); // this waits for a response + + const body = try client_req.reader().readAllAlloc(allocator, 8192 * 1024); + defer allocator.free(body); + try expect(std.mem.eql(u8, body, "message from server!\n")); + + server_thread.join(); +} -- cgit v1.2.3 From afebef2465a828132f87cd2aeff0c5873ca10de5 Mon Sep 17 00:00:00 2001 From: Ryo Ota Date: Fri, 21 Apr 2023 10:17:16 +0900 Subject: create std.http.Server.Response.deinit to handle keepalive connections --- lib/std/http/Server.zig | 6 ++++-- lib/std/http/test.zig | 1 + 2 files changed, 5 insertions(+), 2 deletions(-) (limited to 'lib/std') diff --git a/lib/std/http/Server.zig b/lib/std/http/Server.zig index b1205594ad..59b76ea20d 100644 --- a/lib/std/http/Server.zig +++ b/lib/std/http/Server.zig @@ -336,6 +336,10 @@ pub const Response = struct { headers: http.Headers, request: Request, + pub fn deinit(res: *Response) void { + res.server.allocator.destroy(res); + } + /// Reset this response to its initial state. This must be called before handling a second request on the same connection. pub fn reset(res: *Response) void { res.request.headers.deinit(); @@ -359,8 +363,6 @@ pub const Response = struct { if (res.request.parser.header_bytes_owned) { res.request.parser.header_bytes.deinit(res.server.allocator); } - - res.server.allocator.destroy(res); } else { res.request.parser.reset(); } diff --git a/lib/std/http/test.zig b/lib/std/http/test.zig index 7c053dc6b3..ce55c21392 100644 --- a/lib/std/http/test.zig +++ b/lib/std/http/test.zig @@ -30,6 +30,7 @@ test "client requests server" { const server_thread = try std.Thread.spawn(.{}, (struct { fn apply(s: *std.http.Server) !void { const res = try s.accept(.{ .dynamic = max_header_size }); + defer res.deinit(); defer res.reset(); try res.wait(); -- cgit v1.2.3