Commit 363d0ee5e13f4ac3a93d246121edfd00ef9fd97b | zig

lib/std/http/Client.zig+16-16

...	...	@@ -598,15 +598,15 @@ pub const Request = struct {
598	598	};
599	599	}
600	600
601		pub const StartError = Connection.WriteError \|\| error{ InvalidContentLength, UnsupportedTransferEncoding };
	601	pub const SendError = Connection.WriteError \|\| error{ InvalidContentLength, UnsupportedTransferEncoding };
602	602
603		pub const StartOptions = struct {
604		/// Specifies that the uri should be used as is
	603	pub const SendOptions = struct {
	604	/// Specifies that the uri should be used as is. You guarantee that the uri is already escaped.
605	605	raw_uri: bool = false,
606	606	};
607	607
608	608	/// Send the HTTP request headers to the server.
609		pub fn start(req: *Request, options: StartOptions) StartError!void {
	609	pub fn send(req: *Request, options: SendOptions) SendError!void {
610	610	if (!req.method.requestHasBody() and req.transfer_encoding != .none) return error.UnsupportedTransferEncoding;
611	611
612	612	const w = req.connection.?.writer();
...	...	@@ -733,14 +733,14 @@ pub const Request = struct {
733	733	return index;
734	734	}
735	735
736		pub const WaitError = RequestError \|\| StartError \|\| TransferReadError \|\| proto.HeadersParser.CheckCompleteHeadError \|\| Response.ParseError \|\| Uri.ParseError \|\| error{ TooManyHttpRedirects, RedirectRequiresResend, HttpRedirectMissingLocation, CompressionInitializationFailed, CompressionNotSupported };
	736	pub const WaitError = RequestError \|\| SendError \|\| TransferReadError \|\| proto.HeadersParser.CheckCompleteHeadError \|\| Response.ParseError \|\| Uri.ParseError \|\| error{ TooManyHttpRedirects, RedirectRequiresResend, HttpRedirectMissingLocation, CompressionInitializationFailed, CompressionNotSupported };
737	737
738	738	/// Waits for a response from the server and parses any headers that are sent.
739	739	/// This function will block until the final response is received.
740	740	///
741	741	/// If `handle_redirects` is true and the request has no payload, then this function will automatically follow
742	742	/// redirects. If a request payload is present, then this function will error with error.RedirectRequiresResend.
743		///
	743	///
744	744	/// Must be called after `start` and, if any data was written to the request body, then also after `finish`.
745	745	pub fn wait(req: *Request) WaitError!void {
746	746	while (true) { // handle redirects
...	...	@@ -845,7 +845,7 @@ pub const Request = struct {
845	845
846	846	try req.redirect(resolved_url);
847	847
848		try req.start(.{});
	848	try req.send(.{});
849	849	} else {
850	850	req.response.skip = false;
851	851	if (!req.response.parser.done) {
...	...	@@ -1223,7 +1223,7 @@ pub fn connectTunnel(
1223	1223	// we can use a small buffer here because a CONNECT response should be very small
1224	1224	var buffer: [8096]u8 = undefined;
1225	1225
1226		var req = client.request(.CONNECT, uri, proxy.headers, .{
	1226	var req = client.open(.CONNECT, uri, proxy.headers, .{
1227	1227	.handle_redirects = false,
1228	1228	.connection = conn,
1229	1229	.header_strategy = .{ .static = buffer[0..] },
...	...	@@ -1233,7 +1233,7 @@ pub fn connectTunnel(
1233	1233	};
1234	1234	defer req.deinit();
1235	1235
1236		req.start(.{ .raw_uri = true }) catch \|err\| break :tunnel err;
	1236	req.send(.{ .raw_uri = true }) catch \|err\| break :tunnel err;
1237	1237	req.wait() catch \|err\| break :tunnel err;
1238	1238
1239	1239	if (req.response.status.class() == .server_error) {
...	...	@@ -1266,9 +1266,9 @@ const ConnectErrorPartial = ConnectTcpError \|\| error{ UnsupportedUrlScheme, Conn
1266	1266	pub const ConnectError = ConnectErrorPartial \|\| RequestError;
1267	1267
1268	1268	/// Connect to `host:port` using the specified protocol. This will reuse a connection if one is already open.
1269		///
	1269	///
1270	1270	/// If a proxy is configured for the client, then the proxy will be used to connect to the host.
1271		///
	1271	///
1272	1272	/// This function is threadsafe.
1273	1273	pub fn connect(client: Client, host: []const u8, port: u16, protocol: Connection.Protocol) ConnectError!Connection {
1274	1274	// pointer required so that `supports_connect` can be updated if a CONNECT fails
...	...	@@ -1304,7 +1304,7 @@ pub fn connect(client: *Client, host: []const u8, port: u16, protocol: Connectio
1304	1304	return client.connectTcp(host, port, protocol);
1305	1305	}
1306	1306
1307		pub const RequestError = ConnectTcpError \|\| ConnectErrorPartial \|\| Request.StartError \|\| std.fmt.ParseIntError \|\| Connection.WriteError \|\| error{
	1307	pub const RequestError = ConnectTcpError \|\| ConnectErrorPartial \|\| Request.SendError \|\| std.fmt.ParseIntError \|\| Connection.WriteError \|\| error{
1308	1308	UnsupportedUrlScheme,
1309	1309	UriMissingHost,
1310	1310
...	...	@@ -1350,7 +1350,7 @@ pub const protocol_map = std.ComptimeStringMap(Connection.Protocol, .{
1350	1350	///
1351	1351	/// The caller is responsible for calling `deinit()` on the `Request`.
1352	1352	/// This function is threadsafe.
1353		pub fn request(client: *Client, method: http.Method, uri: Uri, headers: http.Headers, options: RequestOptions) RequestError!Request {
	1353	pub fn open(client: *Client, method: http.Method, uri: Uri, headers: http.Headers, options: RequestOptions) RequestError!Request {
1354	1354	const protocol = protocol_map.get(uri.scheme) orelse return error.UnsupportedUrlScheme;
1355	1355
1356	1356	const port: u16 = uri.port orelse switch (protocol) {
...	...	@@ -1446,7 +1446,7 @@ pub const FetchResult = struct {
1446	1446	};
1447	1447
1448	1448	/// Perform a one-shot HTTP request with the provided options.
1449		///
	1449	///
1450	1450	/// This function is threadsafe.
1451	1451	pub fn fetch(client: *Client, allocator: Allocator, options: FetchOptions) !FetchResult {
1452	1452	const has_transfer_encoding = options.headers.contains("transfer-encoding");
...	...	@@ -1459,7 +1459,7 @@ pub fn fetch(client: *Client, allocator: Allocator, options: FetchOptions) !Fetc
1459	1459	.uri => \|u\| u,
1460	1460	};
1461	1461
1462		var req = try request(client, options.method, uri, options.headers, .{
	1462	var req = try open(client, options.method, uri, options.headers, .{
1463	1463	.header_strategy = options.header_strategy,
1464	1464	.handle_redirects = options.payload == .none,
1465	1465	});
...	...	@@ -1476,7 +1476,7 @@ pub fn fetch(client: *Client, allocator: Allocator, options: FetchOptions) !Fetc
1476	1476	.none => {},
1477	1477	}
1478	1478
1479		try req.start(.{ .raw_uri = options.raw_uri });
	1479	try req.send(.{ .raw_uri = options.raw_uri });
1480	1480
1481	1481	switch (options.payload) {
1482	1482	.string => \|str\| try req.writeAll(str),

lib/std/http/Server.zig+3-3

...	...	@@ -392,10 +392,10 @@ pub const Response = struct {
392	392	}
393	393	}
394	394
395		pub const StartError = Connection.WriteError \|\| error{ UnsupportedTransferEncoding, InvalidContentLength };
	395	pub const SendError = Connection.WriteError \|\| error{ UnsupportedTransferEncoding, InvalidContentLength };
396	396
397	397	/// Send the HTTP response headers to the client.
398		pub fn start(res: *Response) StartError!void {
	398	pub fn send(res: *Response) SendError!void {
399	399	switch (res.state) {
400	400	.waited => res.state = .responded,
401	401	.first, .start, .responded, .finished => unreachable,
...	...	@@ -771,7 +771,7 @@ test "HTTP server handles a chunked transfer coding request" {
771	771	res.transfer_encoding = .{ .content_length = server_body.len };
772	772	try res.headers.append("content-type", "text/plain");
773	773	try res.headers.append("connection", "close");
774		try res.do();
	774	try res.send();
775	775
776	776	var buf: [128]u8 = undefined;
777	777	const n = try res.readAll(&buf);

src/Package/Fetch.zig+2-2

...	...	@@ -826,7 +826,7 @@ fn initResource(f: *Fetch, uri: std.Uri) RunError!Resource {
826	826	var h = std.http.Headers{ .allocator = gpa };
827	827	defer h.deinit();
828	828
829		var req = http_client.request(.GET, uri, h, .{}) catch \|err\| {
	829	var req = http_client.open(.GET, uri, h, .{}) catch \|err\| {
830	830	return f.fail(f.location_tok, try eb.printString(
831	831	"unable to connect to server: {s}",
832	832	.{@errorName(err)},
...	...	@@ -834,7 +834,7 @@ fn initResource(f: *Fetch, uri: std.Uri) RunError!Resource {
834	834	};
835	835	errdefer req.deinit(); // releases more than memory
836	836
837		req.start(.{}) catch \|err\| {
	837	req.send(.{}) catch \|err\| {
838	838	return f.fail(f.location_tok, try eb.printString(
839	839	"HTTP request failed: {s}",
840	840	.{@errorName(err)},

src/Package/Fetch/git.zig+6-6

...	...	@@ -518,11 +518,11 @@ pub const Session = struct {
518	518	defer headers.deinit();
519	519	try headers.append("Git-Protocol", "version=2");
520	520
521		var request = try session.transport.request(.GET, info_refs_uri, headers, .{
	521	var request = try session.transport.open(.GET, info_refs_uri, headers, .{
522	522	.max_redirects = 3,
523	523	});
524	524	errdefer request.deinit();
525		try request.start(.{});
	525	try request.send(.{});
526	526	try request.finish();
527	527
528	528	try request.wait();
...	...	@@ -641,12 +641,12 @@ pub const Session = struct {
641	641	}
642	642	try Packet.write(.flush, body_writer);
643	643
644		var request = try session.transport.request(.POST, upload_pack_uri, headers, .{
	644	var request = try session.transport.open(.POST, upload_pack_uri, headers, .{
645	645	.handle_redirects = false,
646	646	});
647	647	errdefer request.deinit();
648	648	request.transfer_encoding = .{ .content_length = body.items.len };
649		try request.start(.{});
	649	try request.send(.{});
650	650	try request.writeAll(body.items);
651	651	try request.finish();
652	652
...	...	@@ -740,12 +740,12 @@ pub const Session = struct {
740	740	try Packet.write(.{ .data = "done\n" }, body_writer);
741	741	try Packet.write(.flush, body_writer);
742	742
743		var request = try session.transport.request(.POST, upload_pack_uri, headers, .{
	743	var request = try session.transport.open(.POST, upload_pack_uri, headers, .{
744	744	.handle_redirects = false,
745	745	});
746	746	errdefer request.deinit();
747	747	request.transfer_encoding = .{ .content_length = body.items.len };
748		try request.start(.{});
	748	try request.send(.{});
749	749	try request.writeAll(body.items);
750	750	try request.finish();
751	751

test/standalone/http.zig+45-45

...	...	@@ -29,11 +29,11 @@ fn handleRequest(res: *Server.Response) !void {
29	29	if (res.request.headers.contains("expect")) {
30	30	if (mem.eql(u8, res.request.headers.getFirstValue("expect").?, "100-continue")) {
31	31	res.status = .@"continue";
32		try res.start();
	32	try res.send();
33	33	res.status = .ok;
34	34	} else {
35	35	res.status = .expectation_failed;
36		try res.start();
	36	try res.send();
37	37	return;
38	38	}
39	39	}
...	...	@@ -54,7 +54,7 @@ fn handleRequest(res: *Server.Response) !void {
54	54
55	55	try res.headers.append("content-type", "text/plain");
56	56
57		try res.start();
	57	try res.send();
58	58	if (res.request.method != .HEAD) {
59	59	try res.writeAll("Hello, ");
60	60	try res.writeAll("World!\n");
...	...	@@ -65,7 +65,7 @@ fn handleRequest(res: *Server.Response) !void {
65	65	} else if (mem.startsWith(u8, res.request.target, "/large")) {
66	66	res.transfer_encoding = .{ .content_length = 14 * 1024 + 14 * 10 };
67	67
68		try res.start();
	68	try res.send();
69	69
70	70	var i: u32 = 0;
71	71	while (i < 5) : (i += 1) {
...	...	@@ -92,14 +92,14 @@ fn handleRequest(res: *Server.Response) !void {
92	92	try testing.expectEqualStrings("14", res.request.headers.getFirstValue("content-length").?);
93	93	}
94	94
95		try res.start();
	95	try res.send();
96	96	try res.writeAll("Hello, ");
97	97	try res.writeAll("World!\n");
98	98	try res.finish();
99	99	} else if (mem.eql(u8, res.request.target, "/trailer")) {
100	100	res.transfer_encoding = .chunked;
101	101
102		try res.start();
	102	try res.send();
103	103	try res.writeAll("Hello, ");
104	104	try res.writeAll("World!\n");
105	105	// try res.finish();
...	...	@@ -110,7 +110,7 @@ fn handleRequest(res: *Server.Response) !void {
110	110	res.status = .found;
111	111	try res.headers.append("location", "../../get");
112	112
113		try res.start();
	113	try res.send();
114	114	try res.writeAll("Hello, ");
115	115	try res.writeAll("Redirected!\n");
116	116	try res.finish();
...	...	@@ -120,7 +120,7 @@ fn handleRequest(res: *Server.Response) !void {
120	120	res.status = .found;
121	121	try res.headers.append("location", "/redirect/1");
122	122
123		try res.start();
	123	try res.send();
124	124	try res.writeAll("Hello, ");
125	125	try res.writeAll("Redirected!\n");
126	126	try res.finish();
...	...	@@ -133,7 +133,7 @@ fn handleRequest(res: *Server.Response) !void {
133	133	res.status = .found;
134	134	try res.headers.append("location", location);
135	135
136		try res.start();
	136	try res.send();
137	137	try res.writeAll("Hello, ");
138	138	try res.writeAll("Redirected!\n");
139	139	try res.finish();
...	...	@@ -143,7 +143,7 @@ fn handleRequest(res: *Server.Response) !void {
143	143	res.status = .found;
144	144	try res.headers.append("location", "/redirect/3");
145	145
146		try res.start();
	146	try res.send();
147	147	try res.writeAll("Hello, ");
148	148	try res.writeAll("Redirected!\n");
149	149	try res.finish();
...	...	@@ -154,11 +154,11 @@ fn handleRequest(res: *Server.Response) !void {
154	154
155	155	res.status = .found;
156	156	try res.headers.append("location", location);
157		try res.start();
	157	try res.send();
158	158	try res.finish();
159	159	} else {
160	160	res.status = .not_found;
161		try res.start();
	161	try res.send();
162	162	}
163	163	}
164	164
...	...	@@ -244,10 +244,10 @@ pub fn main() !void {
244	244	const uri = try std.Uri.parse(location);
245	245
246	246	log.info("{s}", .{location});
247		var req = try client.request(.GET, uri, h, .{});
	247	var req = try client.open(.GET, uri, h, .{});
248	248	defer req.deinit();
249	249
250		try req.start(.{});
	250	try req.send(.{});
251	251	try req.wait();
252	252
253	253	const body = try req.reader().readAllAlloc(calloc, 8192);
...	...	@@ -269,10 +269,10 @@ pub fn main() !void {
269	269	const uri = try std.Uri.parse(location);
270	270
271	271	log.info("{s}", .{location});
272		var req = try client.request(.GET, uri, h, .{});
	272	var req = try client.open(.GET, uri, h, .{});
273	273	defer req.deinit();
274	274
275		try req.start(.{});
	275	try req.send(.{});
276	276	try req.wait();
277	277
278	278	const body = try req.reader().readAllAlloc(calloc, 8192 * 1024);
...	...	@@ -293,10 +293,10 @@ pub fn main() !void {
293	293	const uri = try std.Uri.parse(location);
294	294
295	295	log.info("{s}", .{location});
296		var req = try client.request(.HEAD, uri, h, .{});
	296	var req = try client.open(.HEAD, uri, h, .{});
297	297	defer req.deinit();
298	298
299		try req.start(.{});
	299	try req.send(.{});
300	300	try req.wait();
301	301
302	302	const body = try req.reader().readAllAlloc(calloc, 8192);
...	...	@@ -319,10 +319,10 @@ pub fn main() !void {
319	319	const uri = try std.Uri.parse(location);
320	320
321	321	log.info("{s}", .{location});
322		var req = try client.request(.GET, uri, h, .{});
	322	var req = try client.open(.GET, uri, h, .{});
323	323	defer req.deinit();
324	324
325		try req.start(.{});
	325	try req.send(.{});
326	326	try req.wait();
327	327
328	328	const body = try req.reader().readAllAlloc(calloc, 8192);
...	...	@@ -344,10 +344,10 @@ pub fn main() !void {
344	344	const uri = try std.Uri.parse(location);
345	345
346	346	log.info("{s}", .{location});
347		var req = try client.request(.HEAD, uri, h, .{});
	347	var req = try client.open(.HEAD, uri, h, .{});
348	348	defer req.deinit();
349	349
350		try req.start(.{});
	350	try req.send(.{});
351	351	try req.wait();
352	352
353	353	const body = try req.reader().readAllAlloc(calloc, 8192);
...	...	@@ -370,10 +370,10 @@ pub fn main() !void {
370	370	const uri = try std.Uri.parse(location);
371	371
372	372	log.info("{s}", .{location});
373		var req = try client.request(.GET, uri, h, .{});
	373	var req = try client.open(.GET, uri, h, .{});
374	374	defer req.deinit();
375	375
376		try req.start(.{});
	376	try req.send(.{});
377	377	try req.wait();
378	378
379	379	const body = try req.reader().readAllAlloc(calloc, 8192);
...	...	@@ -397,12 +397,12 @@ pub fn main() !void {
397	397	const uri = try std.Uri.parse(location);
398	398
399	399	log.info("{s}", .{location});
400		var req = try client.request(.POST, uri, h, .{});
	400	var req = try client.open(.POST, uri, h, .{});
401	401	defer req.deinit();
402	402
403	403	req.transfer_encoding = .{ .content_length = 14 };
404	404
405		try req.start(.{});
	405	try req.send(.{});
406	406	try req.writeAll("Hello, ");
407	407	try req.writeAll("World!\n");
408	408	try req.finish();
...	...	@@ -429,10 +429,10 @@ pub fn main() !void {
429	429	const uri = try std.Uri.parse(location);
430	430
431	431	log.info("{s}", .{location});
432		var req = try client.request(.GET, uri, h, .{});
	432	var req = try client.open(.GET, uri, h, .{});
433	433	defer req.deinit();
434	434
435		try req.start(.{});
	435	try req.send(.{});
436	436	try req.wait();
437	437
438	438	const body = try req.reader().readAllAlloc(calloc, 8192);
...	...	@@ -456,12 +456,12 @@ pub fn main() !void {
456	456	const uri = try std.Uri.parse(location);
457	457
458	458	log.info("{s}", .{location});
459		var req = try client.request(.POST, uri, h, .{});
	459	var req = try client.open(.POST, uri, h, .{});
460	460	defer req.deinit();
461	461
462	462	req.transfer_encoding = .chunked;
463	463
464		try req.start(.{});
	464	try req.send(.{});
465	465	try req.writeAll("Hello, ");
466	466	try req.writeAll("World!\n");
467	467	try req.finish();
...	...	@@ -486,10 +486,10 @@ pub fn main() !void {
486	486	const uri = try std.Uri.parse(location);
487	487
488	488	log.info("{s}", .{location});
489		var req = try client.request(.GET, uri, h, .{});
	489	var req = try client.open(.GET, uri, h, .{});
490	490	defer req.deinit();
491	491
492		try req.start(.{});
	492	try req.send(.{});
493	493	try req.wait();
494	494
495	495	const body = try req.reader().readAllAlloc(calloc, 8192);
...	...	@@ -510,10 +510,10 @@ pub fn main() !void {
510	510	const uri = try std.Uri.parse(location);
511	511
512	512	log.info("{s}", .{location});
513		var req = try client.request(.GET, uri, h, .{});
	513	var req = try client.open(.GET, uri, h, .{});
514	514	defer req.deinit();
515	515
516		try req.start(.{});
	516	try req.send(.{});
517	517	try req.wait();
518	518
519	519	const body = try req.reader().readAllAlloc(calloc, 8192);
...	...	@@ -534,10 +534,10 @@ pub fn main() !void {
534	534	const uri = try std.Uri.parse(location);
535	535
536	536	log.info("{s}", .{location});
537		var req = try client.request(.GET, uri, h, .{});
	537	var req = try client.open(.GET, uri, h, .{});
538	538	defer req.deinit();
539	539
540		try req.start(.{});
	540	try req.send(.{});
541	541	try req.wait();
542	542
543	543	const body = try req.reader().readAllAlloc(calloc, 8192);
...	...	@@ -558,10 +558,10 @@ pub fn main() !void {
558	558	const uri = try std.Uri.parse(location);
559	559
560	560	log.info("{s}", .{location});
561		var req = try client.request(.GET, uri, h, .{});
	561	var req = try client.open(.GET, uri, h, .{});
562	562	defer req.deinit();
563	563
564		try req.start(.{});
	564	try req.send(.{});
565	565	req.wait() catch \|err\| switch (err) {
566	566	error.TooManyHttpRedirects => {},
567	567	else => return err,
...	...	@@ -580,10 +580,10 @@ pub fn main() !void {
580	580	const uri = try std.Uri.parse(location);
581	581
582	582	log.info("{s}", .{location});
583		var req = try client.request(.GET, uri, h, .{});
	583	var req = try client.open(.GET, uri, h, .{});
584	584	defer req.deinit();
585	585
586		try req.start(.{});
	586	try req.send(.{});
587	587	const result = req.wait();
588	588
589	589	// a proxy without an upstream is likely to return a 5xx status.
...	...	@@ -628,12 +628,12 @@ pub fn main() !void {
628	628	const uri = try std.Uri.parse(location);
629	629
630	630	log.info("{s}", .{location});
631		var req = try client.request(.POST, uri, h, .{});
	631	var req = try client.open(.POST, uri, h, .{});
632	632	defer req.deinit();
633	633
634	634	req.transfer_encoding = .chunked;
635	635
636		try req.start(.{});
	636	try req.send(.{});
637	637	try req.wait();
638	638	try testing.expectEqual(http.Status.@"continue", req.response.status);
639	639
...	...	@@ -662,12 +662,12 @@ pub fn main() !void {
662	662	const uri = try std.Uri.parse(location);
663	663
664	664	log.info("{s}", .{location});
665		var req = try client.request(.POST, uri, h, .{});
	665	var req = try client.open(.POST, uri, h, .{});
666	666	defer req.deinit();
667	667
668	668	req.transfer_encoding = .chunked;
669	669
670		try req.start(.{});
	670	try req.send(.{});
671	671	try req.wait();
672	672	try testing.expectEqual(http.Status.expectation_failed, req.response.status);
673	673	}
...	...	@@ -682,7 +682,7 @@ pub fn main() !void {
682	682	defer calloc.free(requests);
683	683
684	684	for (0..total_connections) \|i\| {
685		var req = try client.request(.GET, uri, .{ .allocator = calloc }, .{});
	685	var req = try client.open(.GET, uri, .{ .allocator = calloc }, .{});
686	686	req.response.parser.done = true;
687	687	req.connection.?.closing = false;
688	688	requests[i] = req;

author	Nameless <truemedian@gmail.com> 2023-10-07 20:27:39-05:00
committer	Nameless <truemedian@gmail.com> 2023-10-21 20:52:59-05:00
log	363d0ee5e13f4ac3a93d246121edfd00ef9fd97b
tree	cf0f1561e448ac231b15c21feabace4a41489582
parent	544ed34d99f59a1b487341eaaa9610be44629924
signature	Commit is signed but in an unrecognized format.

std.http: rename start->send and request->open to be more inline with operation