GitLabgitlab-org

cli

main
ply6 git calls27 ms98 KiB4 cachedprotocol v2
243 lines7.4 KiBRaw
1//go:build !integration
3package api
5import (
6 "context"
7 "crypto/tls"
8 "encoding/pem"
9 "fmt"
10 "io"
11 "net"
12 "net/http"
13 "net/http/httptest"
14 "os"
15 "path/filepath"
16 "strings"
17 "sync/atomic"
18 "testing"
19 "time"
21 "github.com/stretchr/testify/assert"
22 "github.com/stretchr/testify/require"
24 "gitlab.com/gitlab-org/cli/internal/config"
27// newConnCountingServer starts a TLS server and reports how many TCP
28// connections clients have opened to it.
29func newConnCountingServer(t *testing.T, handler http.HandlerFunc) (*httptest.Server, *atomic.Int64) {
30 t.Helper()
32 var conns atomic.Int64
33 srv := httptest.NewUnstartedServer(handler)
34 srv.Config.ConnState = func(_ net.Conn, state http.ConnState) {
35 if state == http.StateNew {
36 conns.Add(1)
37 }
38 }
39 srv.StartTLS()
40 t.Cleanup(srv.Close)
41 return srv, &conns
44func serverHost(srv *httptest.Server) string {
45 return strings.TrimPrefix(srv.URL, "https://")
48// newServerConfig points host at srv and applies the extra host settings.
49func newServerConfig(t *testing.T, srv *httptest.Server, settings map[string]string) config.Config {
50 t.Helper()
52 host := serverHost(srv)
53 cfg := config.NewBlankConfig()
54 require.NoError(t, cfg.Set(host, "api_host", host))
55 require.NoError(t, cfg.Set(host, "token", "glpat-test"))
56 for key, value := range settings {
57 require.NoError(t, cfg.Set(host, key, value))
58 }
59 return cfg
62func writeServerCA(t *testing.T, srv *httptest.Server, path string) {
63 t.Helper()
65 pemBytes := pem.EncodeToMemory(&pem.Block{Type: "CERTIFICATE", Bytes: srv.Certificate().Raw})
66 require.NoError(t, os.WriteFile(path, pemBytes, 0o600))
69func mustGet(t *testing.T, client *Client, url string) {
70 t.Helper()
72 req, err := http.NewRequestWithContext(t.Context(), http.MethodGet, url, http.NoBody)
73 require.NoError(t, err)
74 resp, err := client.HTTPClient().Do(req)
75 require.NoError(t, err)
76 defer func() { require.NoError(t, resp.Body.Close()) }()
77 _, err = io.Copy(io.Discard, resp.Body)
78 require.NoError(t, err)
81func okHandler(w http.ResponseWriter, _ *http.Request) {
82 w.WriteHeader(http.StatusOK)
85func TestTransportCache_SameSettingsShareConnection(t *testing.T) {
86 t.Parallel()
88 srv, conns := newConnCountingServer(t, okHandler)
89 cfg := newServerConfig(t, srv, map[string]string{"skip_tls_verify": "true"})
90 cache := NewTransportCache()
92 first, err := NewClientFromConfig(serverHost(srv), cfg, false, "glab-test", WithTransportCache(cache))
93 require.NoError(t, err)
94 second, err := NewClientFromConfig(serverHost(srv), cfg, false, "glab-test", WithTransportCache(cache))
95 require.NoError(t, err)
97 mustGet(t, first, srv.URL)
98 mustGet(t, second, srv.URL)
100 assert.Equal(t, int64(1), conns.Load())
103func TestTransportCache_WithoutCacheClientsDoNotShareConnection(t *testing.T) {
104 t.Parallel()
106 srv, conns := newConnCountingServer(t, okHandler)
107 cfg := newServerConfig(t, srv, map[string]string{"skip_tls_verify": "true"})
109 first, err := NewClientFromConfig(serverHost(srv), cfg, false, "glab-test")
110 require.NoError(t, err)
111 second, err := NewClientFromConfig(serverHost(srv), cfg, false, "glab-test")
112 require.NoError(t, err)
114 mustGet(t, first, srv.URL)
115 mustGet(t, second, srv.URL)
117 assert.Equal(t, int64(2), conns.Load())
120func TestTransportCache_CloseIdleConnectionsKeepsSharedPool(t *testing.T) {
121 t.Parallel()
123 srv, conns := newConnCountingServer(t, okHandler)
124 cfg := newServerConfig(t, srv, map[string]string{"skip_tls_verify": "true"})
125 cache := NewTransportCache()
127 first, err := NewClientFromConfig(serverHost(srv), cfg, false, "glab-test", WithTransportCache(cache))
128 require.NoError(t, err)
129 second, err := NewClientFromConfig(serverHost(srv), cfg, false, "glab-test", WithTransportCache(cache))
130 require.NoError(t, err)
132 mustGet(t, first, srv.URL)
133 first.HTTPClient().CloseIdleConnections()
134 mustGet(t, second, srv.URL)
136 assert.Equal(t, int64(1), conns.Load())
139func TestTransportCache_DifferentSettingsDoNotShareConnection(t *testing.T) {
140 t.Parallel()
142 srv, conns := newConnCountingServer(t, okHandler)
143 cache := NewTransportCache()
144 caPath := filepath.Join(t.TempDir(), "ca.pem")
145 writeServerCA(t, srv, caPath)
146 insecureCfg := newServerConfig(t, srv, map[string]string{"skip_tls_verify": "true"})
147 caCfg := newServerConfig(t, srv, map[string]string{"ca_cert": caPath})
149 insecure, err := NewClientFromConfig(serverHost(srv), insecureCfg, false, "glab-test", WithTransportCache(cache))
150 require.NoError(t, err)
151 withCA, err := NewClientFromConfig(serverHost(srv), caCfg, false, "glab-test", WithTransportCache(cache))
152 require.NoError(t, err)
154 mustGet(t, insecure, srv.URL)
155 mustGet(t, withCA, srv.URL)
157 assert.Equal(t, int64(2), conns.Load())
160func TestTransportCache_CustomHeadersStayPerClient(t *testing.T) {
161 t.Parallel()
163 headers := make(chan string, 2)
164 srv, conns := newConnCountingServer(t, func(w http.ResponseWriter, r *http.Request) {
165 headers <- r.Header.Get("X-Custom")
166 w.WriteHeader(http.StatusOK)
167 })
168 cache := NewTransportCache()
169 plainCfg := newServerConfig(t, srv, map[string]string{"skip_tls_verify": "true"})
170 headerCfg := config.NewFromString(fmt.Sprintf(`hosts:
171 %q:
172 api_host: %q
173 token: glpat-test
174 skip_tls_verify: true
175 custom_headers:
176 - name: X-Custom
177 value: from-config
178`, serverHost(srv), serverHost(srv)))
180 withHeader, err := NewClientFromConfig(serverHost(srv), headerCfg, false, "glab-test", WithTransportCache(cache))
181 require.NoError(t, err)
182 plain, err := NewClientFromConfig(serverHost(srv), plainCfg, false, "glab-test", WithTransportCache(cache))
183 require.NoError(t, err)
185 mustGet(t, withHeader, srv.URL)
186 mustGet(t, plain, srv.URL)
188 assert.Equal(t, "from-config", <-headers)
189 assert.Empty(t, <-headers)
190 assert.Equal(t, int64(1), conns.Load())
193func TestTransportCache_BuildErrorIsNotCached(t *testing.T) {
194 t.Parallel()
196 srv, _ := newConnCountingServer(t, okHandler)
197 caPath := filepath.Join(t.TempDir(), "ca.pem")
198 cfg := newServerConfig(t, srv, map[string]string{"ca_cert": caPath})
199 cache := NewTransportCache()
201 _, err := NewClientFromConfig(serverHost(srv), cfg, false, "glab-test", WithTransportCache(cache))
202 require.ErrorContains(t, err, "error reading cert file")
204 writeServerCA(t, srv, caPath)
205 client, err := NewClientFromConfig(serverHost(srv), cfg, false, "glab-test", WithTransportCache(cache))
206 require.NoError(t, err)
207 mustGet(t, client, srv.URL)
210func TestProxyAwareTLSDialer_HandshakeTimeout(t *testing.T) {
211 t.Parallel()
213 // The listener never accepts, so the TCP connect succeeds and the TLS
214 // handshake waits for a ServerHello that never comes.
215 ln, err := net.Listen("tcp", "127.0.0.1:0")
216 require.NoError(t, err)
217 t.Cleanup(func() { _ = ln.Close() })
218 newDialer := func(timeout time.Duration) *proxyAwareTLSDialer {
219 return &proxyAwareTLSDialer{dialer: &net.Dialer{}, config: &tls.Config{}, handshakeTimeout: timeout}
220 }
222 t.Run("its own timeout reports a TLS handshake timeout", func(t *testing.T) {
223 t.Parallel()
225 _, err := newDialer(50*time.Millisecond).DialTLSContext(t.Context(), "tcp", ln.Addr().String())
227 require.EqualError(t, err, "net/http: TLS handshake timeout")
228 require.NotErrorIs(t, err, context.DeadlineExceeded)
229 var netErr net.Error
230 require.ErrorAs(t, err, &netErr)
231 assert.True(t, netErr.Timeout())
232 })
234 t.Run("the caller's deadline is reported as its own", func(t *testing.T) {
235 t.Parallel()
237 ctx, cancel := context.WithTimeout(t.Context(), 50*time.Millisecond)
238 defer cancel()
239 _, err := newDialer(time.Minute).DialTLSContext(ctx, "tcp", ln.Addr().String())
241 require.ErrorIs(t, err, context.DeadlineExceeded)
242 })
Diagnostics6 git calls · 27 ms
CallStatusSizeTime027 ms
discover200185 B4 ms
git.upload-pack discover
http.response.status_code=200
git.upstream.cf_ray=-
git.upstream.phase=fetch
git.upstream.dur_ms=2
git.response.bytes=185
git.server.agent=git/2.56.g1891de4-Linux
git.server.object_format=sha1
git.server.caps=agent ls-refs fetch server-option object-format
git.server.fetch=shallow wait-for-done filter
git.protocol.version=2
git.pkt.frames=9
git.pkt.data=7
git.pkt.flush=2
git.pkt.delim=0
git.pkt.bytes=185
git.pkt.payload.max=35
ls-refs20058 KiB3 ms
git.upload-pack ls-refs
http.response.status_code=200
git.upstream.cf_ray=-
git.upstream.phase=ls-refs
git.upstream.dur_ms=3
git.response.bytes=59849
git.response.cache=UPDATING
git.response.duration_ms=3
git.protocol.version=2
git.pkt.frames=731
git.pkt.data=730
git.pkt.flush=1
git.pkt.delim=0
git.pkt.bytes=59849
git.pkt.payload.max=143
git.ls_refs.count=730
git.ls_refs.head=refs/heads/main
fetchcombine:blob:none+tree:2 · deepen 12004.2 KiB · hit2 ms
git.upload-pack fetch
http.response.status_code=200
git.upstream.cf_ray=-
git.upstream.phase=fetch
git.upstream.dur_ms=2
git.response.bytes=4273
git.response.cache=HIT
git.response.duration_ms=2
git.fetch.filter=combine:blob:none+tree:2
git.fetch.wants=0dd7574dce9e385c5c30540e6c15657adc6bdce9
git.fetch.haves.count=0
git.fetch.deepen=1
git.fetch.thin_pack=false
git.fetch.ofs_delta=true
git.protocol.version=2
git.pkt.frames=7
git.pkt.data=5
git.pkt.flush=1
git.pkt.delim=1
git.pkt.bytes=4273
git.pkt.payload.max=4173
git.sideband.band1.bytes=4173
git.sideband.band2.bytes=0
git.sideband.band3.bytes=0
git.pack.objects=11
git.pack.bytes=4173
git.fetch.wide.objects=11
git.fetch.wide.extra_bytes=3930
git.fetch.wide.blobs=0
fetchtree:0 · deepen 1020032 KiB · hit2 ms
git.upload-pack fetch
http.response.status_code=200
git.upstream.cf_ray=-
git.upstream.phase=fetch
git.upstream.dur_ms=2
git.response.bytes=32926
git.response.cache=HIT
git.response.duration_ms=2
git.fetch.filter=tree:0
git.fetch.wants=0dd7574dce9e385c5c30540e6c15657adc6bdce9
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=22
git.pkt.data=20
git.pkt.flush=1
git.pkt.delim=1
git.pkt.bytes=32926
git.pkt.payload.max=32046
git.sideband.band1.bytes=32046
git.sideband.band2.bytes=0
git.sideband.band3.bytes=0
git.pack.objects=80
git.pack.bytes=32046
git.pack.ofs_delta=36
git.pack.ref_delta=0
git.pack.chain.max=2
git.pack.trailer=cb0bad5d7ffc514895d8b21c4dd470327f90bc91
git.pack.full=44
Open pack map
fetchtree:02001.1 KiB · hit2 ms
git.upload-pack fetch
http.response.status_code=200
git.upstream.cf_ray=-
git.upstream.phase=fetch
git.upstream.dur_ms=19
git.response.bytes=1165
git.response.cache=HIT
git.response.duration_ms=2
git.fetch.filter=tree:0
git.fetch.wants=71c8407e0ff0e0af10f6a041ae330f754b68e7eb
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=4
git.pkt.data=3
git.pkt.flush=1
git.pkt.delim=0
git.pkt.bytes=1165
git.pkt.payload.max=1138
git.sideband.band1.bytes=1138
git.sideband.band2.bytes=0
git.sideband.band3.bytes=0
git.pack.objects=1
git.pack.bytes=1138
git.pack.trailer=61886367c69619d8db2b2cf2d7d24dca2016141c
Open pack map
fetch2002.1 KiB · hit19 ms
git.upload-pack fetch
http.response.status_code=200
git.response.bytes=2129
git.response.cache=HIT
git.response.duration_ms=19
git.fetch.wants=74d42b0bd536dff41877a7b204d621f2c0fd1832
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=4
git.pkt.data=3
git.pkt.flush=1
git.pkt.delim=0
git.pkt.bytes=2129
git.pkt.payload.max=2102
git.sideband.band1.bytes=2102
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://gitlab.com/gitlab-org/cli
Ref
refs/heads/main
Commit
0dd7574dce9e385c5c30540e6c15657adc6bdce9
cf-ray
a5e135c57fe218aa
Request
d904fe1a…
Protocol
v2 · sha1
Agent
git/2.56.g1891de4-Linux
Filter
advertised
Fetch
shallow wait-for-done filter
Capabilities
agent ls-refs fetch server-option object-format