Artifactspublic-v0

curl

master
ply4 git calls141 ms289 KiB2 cachedprotocol v2
218 lines6.4 KiBRaw
1/***************************************************************************
2 * _ _ ____ _
3 * Project ___| | | | _ \| |
4 * / __| | | | |_) | |
5 * | (__| |_| | _ <| |___
6 * \___|\___/|_| \_\_____|
7 *
8 * Copyright (C) Daniel Stenberg, <daniel@haxx.se>, et al.
9 *
10 * This software is licensed as described in the file COPYING, which
11 * you should have received as part of this distribution. The terms
12 * are also available at https://curl.se/docs/copyright.html.
13 *
14 * You may opt to use, copy, modify, merge, publish, distribute and/or sell
15 * copies of the Software, and permit persons to whom the Software is
16 * furnished to do so, under the terms of the COPYING file.
17 *
18 * This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY
19 * KIND, either express or implied.
20 *
21 * SPDX-License-Identifier: curl
22 *
23 ***************************************************************************/
24#include "first.h"
26#if defined(HAVE_SOCKETPAIR) && defined(AF_UNIX) && \
27 !defined(CURL_DISABLE_WEBSOCKETS)
29/* libcurl does not check Sec-WebSocket-Accept, so any value works */
30static const char ws_upgrade[] =
31 "HTTP/1.1 101 Switching Protocols\r\n"
32 "Upgrade: websocket\r\n"
33 "Connection: Upgrade\r\n"
34 "Sec-WebSocket-Accept: s3pPLMBiTxaQ9kYGzzhZRbK+xOo=\r\n"
35 "\r\n";
37struct wsctx {
38 curl_socket_t sock[2]; /* [0] is curl's end, [1] is the "server" end */
39};
41static curl_socket_t ws_opensocket(void *clientp, curlsocktype purpose,
42 struct curl_sockaddr *address)
44 struct wsctx *ctx = clientp;
45 (void)purpose;
46 (void)address;
47 return ctx->sock[0];
50static int ws_sockopt(void *clientp, curl_socket_t curlfd,
51 curlsocktype purpose)
53 (void)clientp;
54 (void)curlfd;
55 (void)purpose;
56 return CURL_SOCKOPT_ALREADY_CONNECTED;
59static int ws_closesocket(void *clientp, curl_socket_t item)
61 (void)clientp;
62 (void)item;
63 return 0; /* closed at the end of the test */
66/* queue the upgrade response before the request goes out */
67static int ws_prereq(void *clientp, char *conn_primary_ip,
68 char *conn_local_ip, int conn_primary_port,
69 int conn_local_port)
71 struct wsctx *ctx = clientp;
72 (void)conn_primary_ip;
73 (void)conn_local_ip;
74 (void)conn_primary_port;
75 (void)conn_local_port;
77 if(swrite(ctx->sock[1], ws_upgrade, sizeof(ws_upgrade) - 1) !=
78 (ssize_t)(sizeof(ws_upgrade) - 1))
79 return CURL_PREREQFUNC_ABORT;
80 return CURL_PREREQFUNC_OK;
83/* the "server" reads and drops everything libcurl has sent so far */
84static void ws_drain(struct wsctx *ctx)
86 char buf[16384];
87 while(sread(ctx->sock[1], buf, sizeof(buf)) > 0)
88 ;
91static int ws_run_one(const char *name, const unsigned char *payload,
92 size_t plen, curl_off_t loops)
94 struct wsctx ctx;
95 struct curltime start;
96 struct curltime end;
97 timediff_t us;
98 long long hn;
99 curl_off_t loop;
100 CURLcode result;
101 CURL *curl;
102 int size = 256 * 1024;
103 int rc = 0;
105 memset(&ctx, 0, sizeof(ctx));
106 if(CURL_SOCKETPAIR(AF_UNIX, SOCK_STREAM, 0, ctx.sock)) {
107 curl_mfprintf(stderr, "socketpair() failed\n");
108 return 1;
109 }
110 if(curlx_nonblock(ctx.sock[1], TRUE)) {
111 curl_mfprintf(stderr, "curlx_nonblock() failed\n");
112 rc = 1;
113 goto out;
114 }
115 /* fewer round trips to the drain with larger buffers */
116 (void)setsockopt(ctx.sock[0], SOL_SOCKET, SO_SNDBUF,
117 (void *)&size, sizeof(size));
118 (void)setsockopt(ctx.sock[1], SOL_SOCKET, SO_RCVBUF,
119 (void *)&size, sizeof(size));
121 curl = curl_easy_init();
122 if(!curl) {
123 rc = 1;
124 goto out;
125 }
126 curl_easy_setopt(curl, CURLOPT_URL, "ws://127.0.0.1:1/");
127 curl_easy_setopt(curl, CURLOPT_PROXY, "");
128 curl_easy_setopt(curl, CURLOPT_CONNECT_ONLY, 2L);
129 curl_easy_setopt(curl, CURLOPT_OPENSOCKETFUNCTION, ws_opensocket);
130 curl_easy_setopt(curl, CURLOPT_OPENSOCKETDATA, &ctx);
131 curl_easy_setopt(curl, CURLOPT_SOCKOPTFUNCTION, ws_sockopt);
132 curl_easy_setopt(curl, CURLOPT_CLOSESOCKETFUNCTION, ws_closesocket);
133 curl_easy_setopt(curl, CURLOPT_PREREQFUNCTION, ws_prereq);
134 curl_easy_setopt(curl, CURLOPT_PREREQDATA, &ctx);
136 result = curl_easy_perform(curl);
137 if(result) {
138 curl_mfprintf(stderr, "%s: upgrade failed: %s\n", name,
139 curl_easy_strerror(result));
140 rc = 1;
141 goto cleanup;
142 }
143 ws_drain(&ctx); /* the upgrade request */
145 start = curlx_now();
146 for(loop = 0; loop < loops; loop++) {
147 size_t off = 0;
148 while(off < plen) {
149 size_t sent = 0;
150 result = curl_ws_send(curl, payload + off, plen - off, &sent, 0,
151 CURLWS_BINARY);
152 if(result == CURLE_AGAIN)
153 ws_drain(&ctx);
154 else if(result) {
155 curl_mfprintf(stderr, "%s: frame %" CURL_FORMAT_CURL_OFF_T
156 " failed: %s\n", name, loop,
157 curl_easy_strerror(result));
158 rc = 1;
159 goto cleanup;
160 }
161 else if(sent < plen - off)
162 ws_drain(&ctx);
163 off += sent;
164 }
165 }
166 end = curlx_now();
167 us = curlx_timediff_us(end, start); /* how many microseconds */
168 hn = loop ? us * 100000 / loop : 0; /* 100 times too big */
169 curl_mprintf("%-8s %" CURL_FORMAT_CURL_OFF_T " frames, %lld usecs, "
170 "%lld.%02lld ns/frame, %lld MB/s\n",
171 name, loop, (long long)us,
172 (long long)hn / 100, (long long)hn % 100,
173 us ? (long long)(loop * (curl_off_t)plen / us) : 0LL);
174cleanup:
175 curl_easy_cleanup(curl);
176out:
177 sclose(ctx.sock[0]);
178 sclose(ctx.sock[1]);
179 return rc;
182static int test_wssend(int argc, const char **argv)
184 static unsigned char payload[16384];
185 curl_off_t loops = 500000;
186 size_t i;
187 int rc = 0;
189 if(argc > 1) {
190 const char *ptr = argv[1];
191 curl_off_t num;
192 if(!curlx_str_number(&ptr, &num, CURL_OFF_T_MAX) && !*ptr)
193 loops = num;
194 }
196 for(i = 0; i < sizeof(payload); i++)
197 payload[i] = (unsigned char)i;
199 curl_global_init(CURL_GLOBAL_ALL);
200 rc |= ws_run_one("16", payload, 16, loops);
201 rc |= ws_run_one("125", payload, 125, loops);
202 rc |= ws_run_one("1024", payload, 1024, loops);
203 rc |= ws_run_one("16384", payload, 16384, loops / 16);
204 curl_global_cleanup();
205 return rc;
208#else
210static int test_wssend(int argc, const char **argv)
212 (void)argc;
213 (void)argv;
214 curl_mfprintf(stderr, "wssend needs socketpair() and WebSocket support\n");
215 return 0;
218#endif
Diagnostics4 git calls · 141 ms
CallStatusSizeTime0141 ms
discover200152 B4 ms
git.upload-pack discover
http.response.status_code=200
git.upstream.cf_ray=-
git.upstream.phase=ls-refs
git.upstream.dur_ms=4
git.response.bytes=152
git.server.agent=gitty/1.0
git.server.object_format=sha1
git.server.caps=agent ls-refs fetch object-format
git.server.fetch=shallow filter sideband-all
git.protocol.version=2
git.pkt.frames=8
git.pkt.data=6
git.pkt.flush=2
git.pkt.delim=0
git.pkt.bytes=152
git.pkt.payload.max=34
ls-refs200149 B · hit4 ms
git.upload-pack ls-refs
http.response.status_code=200
git.upstream.cf_ray=-
git.upstream.phase=ls-refs
git.upstream.dur_ms=4
git.response.bytes=149
git.response.cache=HIT
git.response.duration_ms=4
git.protocol.version=2
git.pkt.frames=3
git.pkt.data=2
git.pkt.flush=1
git.pkt.delim=0
git.pkt.bytes=149
git.pkt.payload.max=78
git.ls_refs.count=2
git.ls_refs.head=refs/heads/master
fetchblob:none · deepen 10200287 KiB · hit3 ms
git.upload-pack fetch
http.response.status_code=200
git.upstream.cf_ray=-
git.upstream.phase=fetch
git.upstream.dur_ms=3
git.response.bytes=293470
git.response.cache=HIT
git.response.duration_ms=3
git.fetch.filter=blob:none
git.fetch.filter.requested=tree:0
git.fetch.filter.fallback=blob:none
git.fetch.filter.learned=false
git.fetch.wants=31c911efe5652725e930f4d2e60c9060e5f6646d
git.fetch.haves.count=0
git.fetch.deepen=10
git.fetch.thin_pack=false
git.fetch.ofs_delta=true
git.protocol.version=2
git.pkt.frames=10
git.pkt.data=8
git.pkt.flush=1
git.pkt.delim=1
git.pkt.bytes=293470
git.pkt.payload.max=65516
git.sideband.band1.bytes=293354
git.sideband.band2.bytes=0
git.sideband.band3.bytes=0
git.pack.objects=87
git.pack.bytes=293354
git.pack.ofs_delta=0
git.pack.ref_delta=1
git.pack.chain.max=1
git.pack.trailer=6a646bcda6740bab42e321b51998b52ea15146c0
git.pack.full=86
Open pack map
fetch2002.5 KiB134 ms
git.upload-pack fetch
http.response.status_code=200
git.upstream.cf_ray=-
git.upstream.phase=fetch
git.upstream.dur_ms=134
git.response.bytes=2604
git.response.cache=MISS
git.response.duration_ms=134
git.fetch.wants=57de11818c6b7bc1ac47f17278b99a8a4565df7a
git.fetch.haves.count=0
git.fetch.deepen=0
git.fetch.thin_pack=false
git.fetch.ofs_delta=true
git.protocol.version=2
git.pkt.frames=3
git.pkt.data=2
git.pkt.flush=1
git.pkt.delim=0
git.pkt.bytes=2604
git.pkt.payload.max=2583
git.sideband.band1.bytes=2582
git.sideband.band2.bytes=0
git.sideband.band3.bytes=0

Each row is one HTTP round trip ply made to the git server for this page, on one timeline. discover asks what the server speaks, ls-refs lists branch tips, fetch brings objects by id. A hit was served by Workers Cache. Tap a row for its wire details.

Remote
https://5ad2236b39de4c8bd8f6270ea63f3ea9.artifacts.cloudflare.net/git/public-v0/curl.git
Ref
refs/heads/master
Commit
31c911efe5652725e930f4d2e60c9060e5f6646d
cf-ray
a5e317be5b1ecf5b
Request
69e8c4e4…
Protocol
v2 · sha1
Agent
gitty/1.0
Filter
advertised
Fetch
shallow filter sideband-all
Capabilities
agent ls-refs fetch object-format