Debian Codegraph @

pkg/util/proxy/streamtunnel_test.go

raw
1 /*
2 Copyright 2024 The Kubernetes Authors.
3
4 Licensed under the Apache License, Version 2.0 (the "License");
5 you may not use this file except in compliance with the License.
6 You may obtain a copy of the License at
7
8 http://www.apache.org/licenses/LICENSE-2.0
9
10 Unless required by applicable law or agreed to in writing, software
11 distributed under the License is distributed on an "AS IS" BASIS,
12 WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 See the License for the specific language governing permissions and
14 limitations under the License.
15 */
16
17 package proxy
18
19 import (
20 "bytes"
21 "crypto/rand"
22 "fmt"
23 "io"
24 "net"
25 "net/http"
26 "net/http/httptest"
27 "net/url"
28 "strings"
29 "testing"
30 "time"
31
32 "github.com/stretchr/testify/assert"
33 "github.com/stretchr/testify/require"
34
35 "k8s.io/apimachinery/pkg/runtime"
36 "k8s.io/apimachinery/pkg/util/httpstream"
37 "k8s.io/apimachinery/pkg/util/httpstream/spdy"
38 constants "k8s.io/apimachinery/pkg/util/portforward"
39 "k8s.io/apimachinery/pkg/util/proxy"
40 "k8s.io/apimachinery/pkg/util/wait"
41 "k8s.io/apiserver/pkg/registry/rest"
42 "k8s.io/apiserver/pkg/util/proxy/metrics"
43 restconfig "k8s.io/client-go/rest"
44 "k8s.io/client-go/tools/portforward"
45 "k8s.io/component-base/metrics/legacyregistry"
46 "k8s.io/component-base/metrics/testutil"
47 )
48
49 func TestTunnelingHandler_UpgradeStreamingAndTunneling(t *testing.T) {
50 metrics.Register()
51 metrics.ResetForTest()
52 t.Cleanup(metrics.ResetForTest)
53 // Create fake upstream SPDY server, with channel receiving SPDY streams.
54 streamChan := make(chan httpstream.Stream)
55 defer close(streamChan)
56 stopServerChan := make(chan struct{})
57 defer close(stopServerChan)
58 spdyServer := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, req *http.Request) {
59 _, err := httpstream.Handshake(req, w, []string{constants.PortForwardV1Name})
60 if err != nil {
61 t.Errorf("unexpected error %v", err)
62 return
63 }
64 upgrader := spdy.NewResponseUpgrader()
65 conn := upgrader.UpgradeResponse(w, req, justQueueStream(streamChan))
66 if conn == nil {
67 t.Error("connect is unexpected nil")
68 return
69 }
70 defer conn.Close() //nolint:errcheck
71 <-stopServerChan
72 }))
73 defer spdyServer.Close()
74 // Create UpgradeAwareProxy handler, with url/transport pointing to upstream SPDY. Then
75 // create TunnelingHandler by injecting upgrade handler. Create TunnelingServer.
76 url, err := url.Parse(spdyServer.URL)
77 require.NoError(t, err)
78 transport, err := fakeTransport()
79 require.NoError(t, err)
80 upgradeHandler := proxy.NewUpgradeAwareHandler(url, transport, false, true, proxy.NewErrorResponder(&fakeResponder{}))
81 tunnelingHandler := NewTunnelingHandler(upgradeHandler)
82 tunnelingServer := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, req *http.Request) {
83 tunnelingHandler.ServeHTTP(w, req)
84 }))
85 defer tunnelingServer.Close()
86 // Create SPDY client connection containing a TunnelingConnection by upgrading
87 // a request to TunnelingHandler using new portforward version 2.
88 tunnelingURL, err := url.Parse(tunnelingServer.URL)
89 require.NoError(t, err)
90 dialer, err := portforward.NewSPDYOverWebsocketDialer(tunnelingURL, &restconfig.Config{Host: tunnelingURL.Host})
91 require.NoError(t, err)
92 spdyClient, protocol, err := dialer.Dial(constants.PortForwardV1Name)
93 require.NoError(t, err)
94 assert.Equal(t, constants.PortForwardV1Name, protocol)
95 defer spdyClient.Close() //nolint:errcheck
96 // Create a SPDY client stream, which will queue a SPDY server stream
97 // on the stream creation channel. Send random data on the client stream
98 // reading off the SPDY server stream, and validating it was tunneled.
99 randomSize := 1024 * 1024
100 randomData := make([]byte, randomSize)
101 _, err = rand.Read(randomData)
102 require.NoError(t, err)
103 var actual []byte
104 go func() {
105 clientStream, err := spdyClient.CreateStream(http.Header{})
106 if err != nil {
107 t.Errorf("unexpected error %v", err)
108 return
109 }
110 _, err = io.Copy(clientStream, bytes.NewReader(randomData))
111 if err != nil {
112 t.Errorf("unexpected error %v", err)
113 return
114 }
115 clientStream.Close() //nolint:errcheck
116 }()
117 select {
118 case serverStream := <-streamChan:
119 actual, err = io.ReadAll(serverStream)
120 require.NoError(t, err)
121 defer serverStream.Close() //nolint:errcheck
122 case <-time.After(wait.ForeverTestTimeout):
123 t.Fatalf("timeout waiting for spdy stream to arrive on channel.")
124 }
125 assert.Equal(t, randomData, actual, "error validating tunneled random data")
126
127 // Validate the streamtunnel metrics; should be one 101 Switching Protocols.
128 metricNames := []string{"apiserver_stream_tunnel_requests_total"}
129 expected := `
130 # HELP apiserver_stream_tunnel_requests_total [ALPHA] Total number of requests that were handled by the StreamTunnelProxy, which processes streaming PortForward/V2
131 # TYPE apiserver_stream_tunnel_requests_total counter
132 apiserver_stream_tunnel_requests_total{code="101"} 1
133 `
134 if err := testutil.GatherAndCompare(legacyregistry.DefaultGatherer, strings.NewReader(expected), metricNames...); err != nil {
135 t.Fatal(err)
136 }
137 }
138
139 func TestTunnelingHandler_BadRequestWithoutProtcols(t *testing.T) {
140 metrics.Register()
141 metrics.ResetForTest()
142 t.Cleanup(metrics.ResetForTest)
143 // Create TunnelingHandler with empty upstream URL and fake transport. An error should
144 // be returned before the upstream proxying to SPDY occurs, so a test SPDY server is not needed.
145 transport, err := fakeTransport()
146 require.NoError(t, err)
147 upgradeHandler := proxy.NewUpgradeAwareHandler(&url.URL{}, transport, false, true, proxy.NewErrorResponder(&fakeResponder{}))
148 tunnelingHandler := NewTunnelingHandler(upgradeHandler)
149 tunnelingServer := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, req *http.Request) {
150 tunnelingHandler.ServeHTTP(w, req)
151 }))
152 defer tunnelingServer.Close()
153 // Create SPDY client connection containing a TunnelingConnection by upgrading
154 // a request to TunnelingHandler using new portforward version 2.
155 tunnelingURL, err := url.Parse(tunnelingServer.URL)
156 require.NoError(t, err)
157 dialer, err := portforward.NewSPDYOverWebsocketDialer(tunnelingURL, &restconfig.Config{Host: tunnelingURL.Host})
158 require.NoError(t, err)
159 // Request without subprotocols--causing a bad request to be returned.
160 _, protocol, err := dialer.Dial("")
161 require.Error(t, err)
162 assert.Equal(t, "", protocol)
163
164 // Validate the streamtunnel metrics; should be one 400 failure.
165 metricNames := []string{"apiserver_stream_tunnel_requests_total"}
166 expected := `
167 # HELP apiserver_stream_tunnel_requests_total [ALPHA] Total number of requests that were handled by the StreamTunnelProxy, which processes streaming PortForward/V2
168 # TYPE apiserver_stream_tunnel_requests_total counter
169 apiserver_stream_tunnel_requests_total{code="400"} 1
170 `
171 if err := testutil.GatherAndCompare(legacyregistry.DefaultGatherer, strings.NewReader(expected), metricNames...); err != nil {
172 t.Fatal(err)
173 }
174 }
175
176 func TestTunnelingHandler_BadHandshakeError(t *testing.T) {
177 metrics.Register()
178 metrics.ResetForTest()
179 t.Cleanup(metrics.ResetForTest)
180 // Create fake upstream SPDY server, returning forbidden for bad handshake.
181 spdyServer := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, req *http.Request) {
182 // Handshake fails.
183 _, err := httpstream.Handshake(req, w, []string{constants.PortForwardV1Name})
184 if err == nil {
185 t.Errorf("handshake should have returned an error %v", err)
186 return
187 }
188 assert.ErrorContains(t, err, "unable to negotiate protocol")
189 w.WriteHeader(http.StatusForbidden)
190 }))
191 defer spdyServer.Close()
192 // Create UpgradeAwareProxy handler, with url/transport pointing to upstream SPDY. Then
193 // create TunnelingHandler by injecting upgrade handler. Create TunnelingServer.
194 url, err := url.Parse(spdyServer.URL)
195 require.NoError(t, err)
196 transport, err := fakeTransport()
197 require.NoError(t, err)
198 upgradeHandler := proxy.NewUpgradeAwareHandler(url, transport, false, true, proxy.NewErrorResponder(&fakeResponder{}))
199 tunnelingHandler := NewTunnelingHandler(upgradeHandler)
200 tunnelingServer := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, req *http.Request) {
201 tunnelingHandler.ServeHTTP(w, req)
202 }))
203 defer tunnelingServer.Close()
204 // Create SPDY client connection containing a TunnelingConnection by upgrading
205 // a request to TunnelingHandler using new portforward version 2.
206 tunnelingURL, err := url.Parse(tunnelingServer.URL)
207 require.NoError(t, err)
208 dialer, err := portforward.NewSPDYOverWebsocketDialer(tunnelingURL, &restconfig.Config{Host: tunnelingURL.Host})
209 require.NoError(t, err)
210 // Handshake will fail, returning a 400-level response.
211 _, protocol, err := dialer.Dial("UNKNOWN_SUBPROTOCOL")
212 require.Error(t, err)
213 assert.Equal(t, "", protocol)
214
215 // Validate the streamtunnel metrics; should be one 400 failure.
216 metricNames := []string{"apiserver_stream_tunnel_requests_total"}
217 expected := `
218 # HELP apiserver_stream_tunnel_requests_total [ALPHA] Total number of requests that were handled by the StreamTunnelProxy, which processes streaming PortForward/V2
219 # TYPE apiserver_stream_tunnel_requests_total counter
220 apiserver_stream_tunnel_requests_total{code="400"} 1
221 `
222 if err := testutil.GatherAndCompare(legacyregistry.DefaultGatherer, strings.NewReader(expected), metricNames...); err != nil {
223 t.Fatal(err)
224 }
225 }
226
227 func TestTunnelingHandler_UpstreamSPDYServerErrorPropagated(t *testing.T) {
228 metrics.Register()
229 metrics.ResetForTest()
230 t.Cleanup(metrics.ResetForTest)
231
232 // Validate that various 500-level errors are propagated and incremented in metrics.
233 for statusCode, codeStr := range map[int]string{
234 http.StatusInternalServerError: "500",
235 http.StatusBadGateway: "502",
236 http.StatusServiceUnavailable: "503",
237 } {
238 // Create fake upstream SPDY server, which returns a 500-level error.
239 spdyServer := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, req *http.Request) {
240 _, err := httpstream.Handshake(req, w, []string{constants.PortForwardV1Name})
241 if err != nil {
242 t.Errorf("handshake should have succeeded %v", err)
243 return
244 }
245 // Returned status code should be incremented in metrics.
246 w.WriteHeader(statusCode)
247 }))
248 defer spdyServer.Close()
249 // Create UpgradeAwareProxy handler, with url/transport pointing to upstream SPDY. Then
250 // create TunnelingHandler by injecting upgrade handler. Create TunnelingServer.
251 url, err := url.Parse(spdyServer.URL)
252 require.NoError(t, err)
253 transport, err := fakeTransport()
254 require.NoError(t, err)
255 upgradeHandler := proxy.NewUpgradeAwareHandler(url, transport, false, true, proxy.NewErrorResponder(&fakeResponder{}))
256 tunnelingHandler := NewTunnelingHandler(upgradeHandler)
257 tunnelingServer := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, req *http.Request) {
258 tunnelingHandler.ServeHTTP(w, req)
259 }))
260 defer tunnelingServer.Close()
261 // Create SPDY client connection containing a TunnelingConnection by upgrading
262 // a request to TunnelingHandler using new portforward version 2.
263 tunnelingURL, err := url.Parse(tunnelingServer.URL)
264 require.NoError(t, err)
265 dialer, err := portforward.NewSPDYOverWebsocketDialer(tunnelingURL, &restconfig.Config{Host: tunnelingURL.Host})
266 require.NoError(t, err)
267 _, protocol, err := dialer.Dial(constants.PortForwardV1Name)
268 require.Error(t, err)
269 assert.Equal(t, "", protocol)
270
271 // Validate the streamtunnel metrics are incrementing 500-level status codes.
272 metricNames := []string{"apiserver_stream_tunnel_requests_total"}
273 expected := `
274 # HELP apiserver_stream_tunnel_requests_total [ALPHA] Total number of requests that were handled by the StreamTunnelProxy, which processes streaming PortForward/V2
275 # TYPE apiserver_stream_tunnel_requests_total counter
276 apiserver_stream_tunnel_requests_total{code="` + codeStr + `"} 1
277 `
278 if err := testutil.GatherAndCompare(legacyregistry.DefaultGatherer, strings.NewReader(expected), metricNames...); err != nil {
279 t.Fatal(err)
280 }
281 metrics.ResetForTest()
282 }
283 }
284
285 func TestTunnelingResponseWriter_Hijack(t *testing.T) {
286 // Regular hijack returns connection, nil bufio, and no error.
287 trw := &tunnelingResponseWriter{conn: &mockConn{}}
288 assert.False(t, trw.hijacked, "hijacked field starts false before Hijack()")
289 assert.False(t, trw.written, "written field startes false before Hijack()")
290 actual, bufio, err := trw.Hijack()
291 assert.NoError(t, err, "Hijack() does not return error")
292 assert.NotNil(t, actual, "conn returned from Hijack() is not nil")
293 assert.Nil(t, bufio, "bufio returned from Hijack() is always nil")
294 assert.True(t, trw.hijacked, "hijacked field becomes true after Hijack()")
295 assert.False(t, trw.written, "written field stays false after Hijack()")
296 // Hijacking after writing to response writer is an error.
297 trw = &tunnelingResponseWriter{written: true}
298 _, _, err = trw.Hijack()
299 assert.Error(t, err, "Hijack after writing to response writer is error")
300 assert.ErrorContains(t, err, "connection has already been written to")
301 // Hijacking after already hijacked is an error.
302 trw = &tunnelingResponseWriter{hijacked: true}
303 _, _, err = trw.Hijack()
304 assert.Error(t, err, "Hijack after writing to response writer is error")
305 assert.ErrorContains(t, err, "connection has already been hijacked")
306 }
307
308 func TestTunnelingResponseWriter_DelegateResponseWriter(t *testing.T) {
309 // Validate Header() for delegate response writer.
310 expectedHeader := http.Header{}
311 expectedHeader.Set("foo", "bar")
312 trw := &tunnelingResponseWriter{w: &mockResponseWriter{header: expectedHeader}}
313 assert.Equal(t, expectedHeader, trw.Header(), "")
314 // Validate Write() for delegate response writer.
315 expectedWrite := []byte("this is a test write string")
316 assert.False(t, trw.written, "written field is before Write()")
317 _, err := trw.Write(expectedWrite)
318 assert.NoError(t, err, "No error expected after Write() on tunneling response writer")
319 assert.True(t, trw.written, "written field is set after writing to tunneling response writer")
320 // Writing to response writer after hijacked is an error.
321 trw.hijacked = true
322 _, err = trw.Write(expectedWrite)
323 assert.Error(t, err, "Writing to ResponseWriter after Hijack() is an error")
324 require.ErrorIs(t, err, http.ErrHijacked, "Hijacked error returned if writing after hijacked")
325 // Validate WriteHeader().
326 trw = &tunnelingResponseWriter{w: &mockResponseWriter{}}
327 expectedStatusCode := 201
328 assert.False(t, trw.written, "Written field originally false in delegate response writer")
329 trw.WriteHeader(expectedStatusCode)
330 assert.Equal(t, expectedStatusCode, trw.w.(*mockResponseWriter).statusCode, "Expected written status code is correct")
331 assert.True(t, trw.written, "Written field set to true after writing delegate response writer")
332 // Response writer already written to does not write status.
333 trw = &tunnelingResponseWriter{w: &mockResponseWriter{}}
334 trw.written = true
335 trw.WriteHeader(expectedStatusCode)
336 assert.Equal(t, 0, trw.w.(*mockResponseWriter).statusCode, "No status code for previously written response writer")
337 // Hijacked response writer does not write status.
338 trw = &tunnelingResponseWriter{w: &mockResponseWriter{}}
339 trw.hijacked = true
340 trw.WriteHeader(expectedStatusCode)
341 assert.Equal(t, 0, trw.w.(*mockResponseWriter).statusCode, "No status code written to hijacked response writer")
342 assert.False(t, trw.written, "Hijacked response writer does not write status")
343 // Writing "101 Switching Protocols" status is an error, since it should happen via hijacked connection.
344 trw = &tunnelingResponseWriter{w: &mockResponseWriter{header: http.Header{}}}
345 trw.WriteHeader(http.StatusSwitchingProtocols)
346 assert.Equal(t, http.StatusInternalServerError, trw.w.(*mockResponseWriter).statusCode, "Internal server error written")
347 }
348
349 func TestTunnelingWebsocketUpgraderConn_LocalRemoteAddress(t *testing.T) {
350 expectedLocalAddr := &net.TCPAddr{
351 IP: net.IPv4(127, 0, 0, 1),
352 Port: 80,
353 }
354 expectedRemoteAddr := &net.TCPAddr{
355 IP: net.IPv4(127, 0, 0, 2),
356 Port: 443,
357 }
358 tc := &tunnelingWebsocketUpgraderConn{
359 conn: &mockConn{
360 localAddr: expectedLocalAddr,
361 remoteAddr: expectedRemoteAddr,
362 },
363 }
364 assert.Equal(t, expectedLocalAddr, tc.LocalAddr(), "LocalAddr() returns expected TCPAddr")
365 assert.Equal(t, expectedRemoteAddr, tc.RemoteAddr(), "RemoteAddr() returns expected TCPAddr")
366 // Connection nil, returns empty address
367 tc.conn = nil
368 assert.Equal(t, noopAddr{}, tc.LocalAddr(), "nil connection, LocalAddr() returns noopAddr")
369 assert.Equal(t, noopAddr{}, tc.RemoteAddr(), "nil connection, RemoteAddr() returns noopAddr")
370 // Validate the empty strings from noopAddr
371 assert.Equal(t, "", noopAddr{}.Network(), "noopAddr Network() returns empty string")
372 assert.Equal(t, "", noopAddr{}.String(), "noopAddr String() returns empty string")
373 }
374
375 func TestTunnelingWebsocketUpgraderConn_SetDeadline(t *testing.T) {
376 tc := &tunnelingWebsocketUpgraderConn{conn: &mockConn{}}
377 expected := time.Now()
378 assert.NoError(t, tc.SetDeadline(expected), "SetDeadline does not return error")
379 assert.Equal(t, expected, tc.conn.(*mockConn).readDeadline, "SetDeadline() sets read deadline")
380 assert.Equal(t, expected, tc.conn.(*mockConn).writeDeadline, "SetDeadline() sets write deadline")
381 expected = time.Now()
382 assert.NoError(t, tc.SetWriteDeadline(expected), "SetWriteDeadline does not return error")
383 assert.Equal(t, expected, tc.conn.(*mockConn).writeDeadline, "Expected write deadline set")
384 expected = time.Now()
385 assert.NoError(t, tc.SetReadDeadline(expected), "SetReadDeadline does not return error")
386 assert.Equal(t, expected, tc.conn.(*mockConn).readDeadline, "Expected read deadline set")
387 expectedErr := fmt.Errorf("deadline error")
388 tc = &tunnelingWebsocketUpgraderConn{conn: &mockConn{deadlineErr: expectedErr}}
389 expected = time.Now()
390 actualErr := tc.SetDeadline(expected)
391 assert.Equal(t, expectedErr, actualErr, "SetDeadline() expected error returned")
392 // Connection nil, returns nil error.
393 tc.conn = nil
394 assert.NoError(t, tc.SetDeadline(expected), "SetDeadline() with nil connection always returns nil error")
395 assert.NoError(t, tc.SetWriteDeadline(expected), "SetWriteDeadline() with nil connection always returns nil error")
396 assert.NoError(t, tc.SetReadDeadline(expected), "SetReadDeadline() with nil connection always returns nil error")
397 }
398
399 var expectedContentLengthHeaders = http.Header{
400 "Content-Length": []string{"25"},
401 "Date": []string{"Sun, 25 Feb 2024 08:09:25 GMT"},
402 "Split-Point": []string{"split"},
403 "X-App-Protocol": []string{"portforward.k8s.io"},
404 }
405
406 const contentLengthHeaders = "HTTP/1.1 400 Error\r\n" +
407 "Content-Length: 25\r\n" +
408 "Date: Sun, 25 Feb 2024 08:09:25 GMT\r\n" +
409 "Split-Point: split\r\n" +
410 "X-App-Protocol: portforward.k8s.io\r\n" +
411 "\r\n"
412
413 const contentLengthBody = "0123456789split0123456789"
414
415 var contentLengthHeadersAndBody = contentLengthHeaders + contentLengthBody
416
417 var expectedResponseHeaders = http.Header{
418 "Date": []string{"Sun, 25 Feb 2024 08:09:25 GMT"},
419 "Split-Point": []string{"split"},
420 "X-App-Protocol": []string{"portforward.k8s.io"},
421 }
422
423 const responseHeaders = "HTTP/1.1 101 Switching Protocols\r\n" +
424 "Date: Sun, 25 Feb 2024 08:09:25 GMT\r\n" +
425 "Split-Point: split\r\n" +
426 "X-App-Protocol: portforward.k8s.io\r\n" +
427 "\r\n"
428
429 const responseBody = "This is extra split data.\n"
430
431 var responseHeadersAndBody = responseHeaders + responseBody
432
433 const invalidResponseData = "INVALID/1.1 101 Switching Protocols\r\n" +
434 "Date: Sun, 25 Feb 2024 08:09:25 GMT\r\n" +
435 "Split-Point: split\r\n" +
436 "X-App-Protocol: portforward.k8s.io\r\n" +
437 "\r\n"
438
439 func TestTunnelingHandler_HeaderInterceptingConn(t *testing.T) {
440 // Basic http response is intercepted correctly; no extra data sent to net.Conn.
441 t.Run("simple-no-body", func(t *testing.T) {
442 testConnConstructor := &mockConnInitializer{mockConn: &mockConn{}, initializeWriteConn: &mockConn{}}
443 hic := &headerInterceptingConn{initializableConn: testConnConstructor}
444 _, err := hic.Write([]byte(responseHeaders))
445 require.NoError(t, err)
446 assert.True(t, hic.initialized, "successfully parsed http response headers")
447 assert.Equal(t, expectedResponseHeaders, testConnConstructor.resp.Header)
448 assert.Equal(t, "101 Switching Protocols", testConnConstructor.resp.Status)
449 assert.Equal(t, "portforward.k8s.io", testConnConstructor.resp.Header.Get("X-App-Protocol"))
450 assert.Equal(t, responseHeaders, string(testConnConstructor.initializeWriteConn.written), "only headers are written in initializeWrite")
451 assert.Equal(t, "", string(testConnConstructor.mockConn.written))
452 })
453
454 // Extra data after response headers should be sent to net.Conn.
455 t.Run("simple-single-write", func(t *testing.T) {
456 testConnConstructor := &mockConnInitializer{mockConn: &mockConn{}, initializeWriteConn: &mockConn{}}
457 hic := &headerInterceptingConn{initializableConn: testConnConstructor}
458 _, err := hic.Write([]byte(responseHeadersAndBody))
459 require.NoError(t, err)
460 assert.True(t, hic.initialized)
461 assert.Equal(t, expectedResponseHeaders, testConnConstructor.resp.Header)
462 assert.Equal(t, "101 Switching Protocols", testConnConstructor.resp.Status)
463 assert.Equal(t, responseHeaders, string(testConnConstructor.initializeWriteConn.written), "only headers are written in initializeWrite")
464 assert.Equal(t, responseBody, string(testConnConstructor.mockConn.written), "extra data written to net.Conn")
465 })
466
467 // Partially written headers are buffered and decoded
468 t.Run("simple-byte-by-byte", func(t *testing.T) {
469 testConnConstructor := &mockConnInitializer{mockConn: &mockConn{}, initializeWriteConn: &mockConn{}}
470 hic := &headerInterceptingConn{initializableConn: testConnConstructor}
471 // write one byte at a time
472 for _, b := range []byte(responseHeadersAndBody) {
473 _, err := hic.Write([]byte{b})
474 require.NoError(t, err)
475 }
476 assert.True(t, hic.initialized)
477 assert.Equal(t, expectedResponseHeaders, testConnConstructor.resp.Header)
478 assert.Equal(t, "101 Switching Protocols", testConnConstructor.resp.Status)
479 assert.Equal(t, responseHeaders, string(testConnConstructor.initializeWriteConn.written), "only headers are written in initializeWrite")
480 assert.Equal(t, responseBody, string(testConnConstructor.mockConn.written), "extra data written to net.Conn")
481 })
482
483 // Writes spanning the header/body breakpoint are buffered and decoded
484 t.Run("simple-span-headerbody", func(t *testing.T) {
485 testConnConstructor := &mockConnInitializer{mockConn: &mockConn{}, initializeWriteConn: &mockConn{}}
486 hic := &headerInterceptingConn{initializableConn: testConnConstructor}
487 // write one chunk at a time
488 for i, chunk := range strings.Split(responseHeadersAndBody, "split") {
489 if i > 0 {
490 n, err := hic.Write([]byte("split"))
491 require.Len(t, "split", n)
492 require.NoError(t, err)
493 }
494 n, err := hic.Write([]byte(chunk))
495 require.Len(t, chunk, n)
496 require.NoError(t, err)
497 }
498 assert.True(t, hic.initialized)
499 assert.Equal(t, expectedResponseHeaders, testConnConstructor.resp.Header)
500 assert.Equal(t, "101 Switching Protocols", testConnConstructor.resp.Status)
501 assert.Equal(t, responseHeaders, string(testConnConstructor.initializeWriteConn.written), "only headers are written in initializeWrite")
502 assert.Equal(t, responseBody, string(testConnConstructor.mockConn.written), "extra data written to net.Conn")
503 })
504
505 // Tolerate header separators of \n instead of \r\n, and extra data after response headers should be sent to net.Conn.
506 t.Run("simple-tolerate-lf", func(t *testing.T) {
507 testConnConstructor := &mockConnInitializer{mockConn: &mockConn{}, initializeWriteConn: &mockConn{}}
508 hic := &headerInterceptingConn{initializableConn: testConnConstructor}
509 _, err := hic.Write([]byte(strings.ReplaceAll(responseHeadersAndBody, "\r", "")))
510 require.NoError(t, err)
511 assert.True(t, hic.initialized)
512 assert.Equal(t, expectedResponseHeaders, testConnConstructor.resp.Header)
513 assert.Equal(t, "101 Switching Protocols", testConnConstructor.resp.Status)
514 assert.Equal(t, strings.ReplaceAll(responseHeaders, "\r", ""), string(testConnConstructor.initializeWriteConn.written), "only normalized headers are written in initializeWrite")
515 assert.Equal(t, responseBody, string(testConnConstructor.mockConn.written), "extra data written to net.Conn")
516 })
517
518 // Content-Length handling
519 t.Run("content-length-body", func(t *testing.T) {
520 testConnConstructor := &mockConnInitializer{mockConn: &mockConn{}, initializeWriteConn: &mockConn{}}
521 hic := &headerInterceptingConn{initializableConn: testConnConstructor}
522 _, err := hic.Write([]byte(contentLengthHeadersAndBody))
523 require.NoError(t, err)
524 assert.True(t, hic.initialized, "successfully parsed http response headers")
525 assert.Equal(t, expectedContentLengthHeaders, testConnConstructor.resp.Header)
526 assert.Equal(t, "400 Error", testConnConstructor.resp.Status)
527 assert.Equal(t, contentLengthHeaders, string(testConnConstructor.initializeWriteConn.written), "headers and content are written in initializeWrite")
528 assert.Equal(t, contentLengthBody, string(testConnConstructor.mockConn.written))
529 })
530
531 // Content-Length separately written headers and body
532 t.Run("content-length-headers-body", func(t *testing.T) {
533 testConnConstructor := &mockConnInitializer{mockConn: &mockConn{}, initializeWriteConn: &mockConn{}}
534 hic := &headerInterceptingConn{initializableConn: testConnConstructor}
535 _, err := hic.Write([]byte(contentLengthHeaders))
536 require.NoError(t, err)
537 _, err = hic.Write([]byte(contentLengthBody))
538 require.NoError(t, err)
539 assert.True(t, hic.initialized, "successfully parsed http response headers")
540 assert.Equal(t, expectedContentLengthHeaders, testConnConstructor.resp.Header)
541 assert.Equal(t, "400 Error", testConnConstructor.resp.Status)
542 assert.Equal(t, contentLengthHeaders, string(testConnConstructor.initializeWriteConn.written), "headers and content are written in initializeWrite")
543 assert.Equal(t, contentLengthBody, string(testConnConstructor.mockConn.written))
544 })
545
546 // Content-Length accumulating byte-by-byte
547 t.Run("content-length-byte-by-byte", func(t *testing.T) {
548 testConnConstructor := &mockConnInitializer{mockConn: &mockConn{}, initializeWriteConn: &mockConn{}}
549 hic := &headerInterceptingConn{initializableConn: testConnConstructor}
550 for _, b := range []byte(contentLengthHeadersAndBody) {
551 _, err := hic.Write([]byte{b})
552 require.NoError(t, err)
553 }
554 assert.True(t, hic.initialized, "successfully parsed http response headers")
555 assert.Equal(t, expectedContentLengthHeaders, testConnConstructor.resp.Header)
556 assert.Equal(t, "400 Error", testConnConstructor.resp.Status)
557 assert.Equal(t, contentLengthHeaders, string(testConnConstructor.initializeWriteConn.written), "headers and content are written in initializeWrite")
558 assert.Equal(t, contentLengthBody, string(testConnConstructor.mockConn.written))
559 })
560
561 // Content-Length writes spanning headers / body
562 t.Run("content-length-span-headerbody", func(t *testing.T) {
563 testConnConstructor := &mockConnInitializer{mockConn: &mockConn{}, initializeWriteConn: &mockConn{}}
564 hic := &headerInterceptingConn{initializableConn: testConnConstructor}
565 // write one chunk at a time
566 for i, chunk := range strings.Split(contentLengthHeadersAndBody, "split") {
567 if i > 0 {
568 n, err := hic.Write([]byte("split"))
569 require.Len(t, "split", n)
570 require.NoError(t, err)
571 }
572 n, err := hic.Write([]byte(chunk))
573 require.Len(t, chunk, n)
574 require.NoError(t, err)
575 }
576 assert.True(t, hic.initialized, "successfully parsed http response headers")
577 assert.Equal(t, expectedContentLengthHeaders, testConnConstructor.resp.Header)
578 assert.Equal(t, "400 Error", testConnConstructor.resp.Status)
579 assert.Equal(t, contentLengthHeaders, string(testConnConstructor.initializeWriteConn.written), "headers and content are written in initializeWrite")
580 assert.Equal(t, contentLengthBody, string(testConnConstructor.mockConn.written))
581 })
582
583 // Invalid response returns error.
584 t.Run("invalid-single-write", func(t *testing.T) {
585 testConnConstructor := &mockConnInitializer{mockConn: &mockConn{}, initializeWriteConn: &mockConn{}}
586 hic := &headerInterceptingConn{initializableConn: testConnConstructor}
587 _, err := hic.Write([]byte(invalidResponseData))
588 assert.Error(t, err, "expected error from invalid http response")
589 })
590
591 // Invalid response written byte by byte returns error.
592 t.Run("invalid-byte-by-byte", func(t *testing.T) {
593 testConnConstructor := &mockConnInitializer{mockConn: &mockConn{}, initializeWriteConn: &mockConn{}}
594 hic := &headerInterceptingConn{initializableConn: testConnConstructor}
595 var err error
596 for _, b := range []byte(invalidResponseData) {
597 _, err = hic.Write([]byte{b})
598 if err != nil {
599 break
600 }
601 }
602 assert.Error(t, err, "expected error from invalid http response")
603 })
604 }
605
606 type mockConnInitializer struct {
607 resp *http.Response
608 initializeWriteConn *mockConn
609 *mockConn
610 }
611
612 func (m *mockConnInitializer) InitializeWrite(backendResponse *http.Response, backendResponseBytes []byte) error {
613 m.resp = backendResponse
614 _, err := m.initializeWriteConn.Write(backendResponseBytes)
615 return err
616 }
617
618 // mockConn implements "net.Conn" interface.
619 var _ net.Conn = &mockConn{}
620
621 type mockConn struct {
622 written []byte
623 localAddr *net.TCPAddr
624 remoteAddr *net.TCPAddr
625 readDeadline time.Time
626 writeDeadline time.Time
627 deadlineErr error
628 }
629
630 func (mc *mockConn) Write(p []byte) (int, error) {
631 mc.written = append(mc.written, p...)
632 return len(p), nil
633 }
634
635 func (mc *mockConn) Read(p []byte) (int, error) { return 0, nil }
636 func (mc *mockConn) Close() error { return nil }
637 func (mc *mockConn) LocalAddr() net.Addr { return mc.localAddr }
638 func (mc *mockConn) RemoteAddr() net.Addr { return mc.remoteAddr }
639 func (mc *mockConn) SetDeadline(t time.Time) error {
640 mc.SetReadDeadline(t) //nolint:errcheck
641 mc.SetWriteDeadline(t) // nolint:errcheck
642 return mc.deadlineErr
643 }
644 func (mc *mockConn) SetReadDeadline(t time.Time) error { mc.readDeadline = t; return mc.deadlineErr }
645 func (mc *mockConn) SetWriteDeadline(t time.Time) error { mc.writeDeadline = t; return mc.deadlineErr }
646
647 // mockResponseWriter implements "http.ResponseWriter" interface
648 type mockResponseWriter struct {
649 header http.Header
650 written []byte
651 statusCode int
652 }
653
654 func (mrw *mockResponseWriter) Header() http.Header { return mrw.header }
655 func (mrw *mockResponseWriter) Write(p []byte) (int, error) {
656 mrw.written = append(mrw.written, p...)
657 return len(p), nil
658 }
659 func (mrw *mockResponseWriter) WriteHeader(statusCode int) { mrw.statusCode = statusCode }
660
661 // fakeResponder implements "rest.Responder" interface.
662 var _ rest.Responder = &fakeResponder{}
663
664 type fakeResponder struct{}
665
666 func (fr *fakeResponder) Object(statusCode int, obj runtime.Object) {}
667 func (fr *fakeResponder) Error(err error) {}
668
669 // justQueueStream skips the usual stream validation before
670 // queueing the stream on the stream channel.
671 func justQueueStream(streams chan httpstream.Stream) func(httpstream.Stream, <-chan struct{}) error {
672 return func(stream httpstream.Stream, replySent <-chan struct{}) error {
673 streams <- stream
674 return nil
675 }
676 }