Artifactspublic-v0

curl

master
ply4 git calls36 ms289 KiB3 cachedprotocol v2
241 lines6.2 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#define THREADS 2
28/* struct containing data of a thread */
29struct t586_Tdata {
30 CURLSH *share;
31 const char *url;
32};
34struct t586_userdata {
35 const char *text;
36 int counter;
37};
39/* lock callback */
40static void t586_test_lock(CURL *curl, curl_lock_data data,
41 curl_lock_access laccess, void *useptr)
43 const char *what;
44 struct t586_userdata *user = (struct t586_userdata *)useptr;
46 (void)curl;
47 (void)laccess;
49 switch(data) {
50 case CURL_LOCK_DATA_SHARE:
51 what = "share";
52 break;
53 case CURL_LOCK_DATA_DNS:
54 what = "dns";
55 break;
56 case CURL_LOCK_DATA_COOKIE:
57 what = "cookie";
58 break;
59 case CURL_LOCK_DATA_SSL_SESSION:
60 what = "ssl_session";
61 break;
62 default:
63 curl_mfprintf(stderr, "lock: no such data: %d\n", (int)data);
64 return;
65 }
66 curl_mprintf("lock: %-6s [%s]: %d\n", what, user->text, user->counter);
67 user->counter++;
70/* unlock callback */
71static void t586_test_unlock(CURL *curl, curl_lock_data data, void *useptr)
73 const char *what;
74 struct t586_userdata *user = (struct t586_userdata *)useptr;
75 (void)curl;
76 switch(data) {
77 case CURL_LOCK_DATA_SHARE:
78 what = "share";
79 break;
80 case CURL_LOCK_DATA_DNS:
81 what = "dns";
82 break;
83 case CURL_LOCK_DATA_COOKIE:
84 what = "cookie";
85 break;
86 case CURL_LOCK_DATA_SSL_SESSION:
87 what = "ssl_session";
88 break;
89 default:
90 curl_mfprintf(stderr, "unlock: no such data: %d\n", (int)data);
91 return;
92 }
93 curl_mprintf("unlock: %-6s [%s]: %d\n", what, user->text, user->counter);
94 user->counter++;
97/* the dummy thread function */
98static void *t586_test_fire(void *ptr)
100 CURLcode result;
101 struct t586_Tdata *tdata = (struct t586_Tdata *)ptr;
102 CURL *curl;
104 curl = curl_easy_init();
105 if(!curl) {
106 curl_mfprintf(stderr, "curl_easy_init() failed\n");
107 return NULL;
108 }
110 curl_easy_setopt(curl, CURLOPT_SSL_VERIFYPEER, 0L);
111 curl_easy_setopt(curl, CURLOPT_VERBOSE, 1L);
112 curl_easy_setopt(curl, CURLOPT_URL, tdata->url);
113 curl_mprintf("CURLOPT_SHARE\n");
114 curl_easy_setopt(curl, CURLOPT_SHARE, tdata->share);
116 curl_mprintf("PERFORM\n");
117 result = curl_easy_perform(curl);
118 if(result != CURLE_OK) {
119 int i = 0;
120 curl_mfprintf(stderr, "perform URL '%s' repeat %d failed, curlcode %d\n",
121 tdata->url, i, (int)result);
122 }
124 curl_mprintf("CLEANUP\n");
125 curl_easy_cleanup(curl);
127 return NULL;
130/* test function */
131static CURLcode test_lib586(const char *URL)
133 CURLcode result = CURLE_OK;
134 CURLSHcode scode = CURLSHE_OK;
135 struct t586_Tdata tdata;
136 CURL *curl;
137 CURLSH *share;
138 int i;
139 struct t586_userdata user;
141 user.text = "Pigs in space";
142 user.counter = 0;
144 curl_mprintf("GLOBAL_INIT\n");
145 if(curl_global_init(CURL_GLOBAL_ALL) != CURLE_OK) {
146 curl_mfprintf(stderr, "curl_global_init() failed\n");
147 return TEST_ERR_MAJOR_BAD;
148 }
150 /* prepare share */
151 curl_mprintf("SHARE_INIT\n");
152 share = curl_share_init();
153 if(!share) {
154 curl_mfprintf(stderr, "curl_share_init() failed\n");
155 curl_global_cleanup();
156 return TEST_ERR_MAJOR_BAD;
157 }
159 if(CURLSHE_OK == scode) {
160 curl_mprintf("CURLSHOPT_LOCKFUNC\n");
161 scode = curl_share_setopt(share, CURLSHOPT_LOCKFUNC, t586_test_lock);
162 }
163 if(CURLSHE_OK == scode) {
164 curl_mprintf("CURLSHOPT_UNLOCKFUNC\n");
165 scode = curl_share_setopt(share, CURLSHOPT_UNLOCKFUNC, t586_test_unlock);
166 }
167 if(CURLSHE_OK == scode) {
168 curl_mprintf("CURLSHOPT_USERDATA\n");
169 scode = curl_share_setopt(share, CURLSHOPT_USERDATA, &user);
170 }
171 if(CURLSHE_OK == scode) {
172 curl_mprintf("CURL_LOCK_DATA_SSL_SESSION\n");
173 scode = curl_share_setopt(share, CURLSHOPT_SHARE,
174 CURL_LOCK_DATA_SSL_SESSION);
175 }
177 if(CURLSHE_OK != scode) {
178 curl_mfprintf(stderr, "curl_share_setopt() failed\n");
179 curl_share_cleanup(share);
180 curl_global_cleanup();
181 return TEST_ERR_MAJOR_BAD;
182 }
184 /* start treads */
185 for(i = 1; i <= THREADS; i++) {
187 /* set thread data */
188 tdata.url = URL;
189 tdata.share = share;
191 /* simulate thread, direct call of "thread" function */
192 curl_mprintf("*** run %d\n", i);
193 t586_test_fire(&tdata);
194 }
196 /* fetch another one */
197 curl_mprintf("*** run %d\n", i);
198 curl = curl_easy_init();
199 if(!curl) {
200 curl_mfprintf(stderr, "curl_easy_init() failed\n");
201 curl_share_cleanup(share);
202 curl_global_cleanup();
203 return TEST_ERR_MAJOR_BAD;
204 }
206 easy_setopt(curl, CURLOPT_URL, URL);
207 curl_mprintf("CURLOPT_SHARE\n");
208 easy_setopt(curl, CURLOPT_SHARE, share);
210 curl_mprintf("PERFORM\n");
211 result = curl_easy_perform(curl);
213 /* try to free share, expect to fail because share is in use */
214 curl_mprintf("try SHARE_CLEANUP...\n");
215 scode = curl_share_cleanup(share);
216 if(scode == CURLSHE_OK) {
217 curl_mfprintf(stderr, "curl_share_cleanup succeed but error expected\n");
218 share = NULL;
219 }
220 else {
221 curl_mprintf("SHARE_CLEANUP failed, correct\n");
222 }
224test_cleanup:
226 /* clean up last handle */
227 curl_mprintf("CLEANUP\n");
228 curl_easy_cleanup(curl);
230 /* free share */
231 curl_mprintf("SHARE_CLEANUP\n");
232 scode = curl_share_cleanup(share);
233 if(scode != CURLSHE_OK)
234 curl_mfprintf(stderr, "curl_share_cleanup failed, code errno %d\n",
235 (int)scode);
237 curl_mprintf("GLOBAL_CLEANUP\n");
238 curl_global_cleanup();
240 return result;
Diagnostics4 git calls · 36 ms
CallStatusSizeTime036 ms
discover200152 B2 ms
git.upload-pack discover
http.response.status_code=200
git.upstream.cf_ray=-
git.upstream.phase=ls-refs
git.upstream.dur_ms=2
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 · hit2 ms
git.upload-pack ls-refs
http.response.status_code=200
git.upstream.cf_ray=-
git.upstream.phase=ls-refs
git.upstream.dur_ms=2
git.response.bytes=149
git.response.cache=HIT
git.response.duration_ms=2
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.0 KiB · hit31 ms
git.upload-pack fetch
http.response.status_code=200
git.upstream.cf_ray=-
git.upstream.phase=fetch
git.upstream.dur_ms=31
git.response.bytes=2004
git.response.cache=HIT
git.response.duration_ms=31
git.fetch.wants=29eab1844362a332bbfcfb13b4053b2a3104f6d2
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=2004
git.pkt.payload.max=1983
git.sideband.band1.bytes=1982
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
a5e3165aed6dcf5b
Request
e3bf3b2c…
Protocol
v2 · sha1
Agent
gitty/1.0
Filter
advertised
Fetch
shallow filter sideband-all
Capabilities
agent ls-refs fetch object-format