Revert an upstream Go change that broke us.

See golang/go#60818

Updates tailscale/corp#12296

Signed-off-by: Brad Fitzpatrick <brad@danga.com>

Author: bradfitz

http2/transport.go

@@ -1266,11 +1266,11 @@ func (cc *ClientConn) RoundTrip(req *http.Request) (*http.Response, error) {
 		return res, nil
 	}
 
-	cancelRequest := func(cs *clientStream, err error) error {
+	cancelRequest := func(cs *clientStream, markDoNotReuse bool, err error) error {
 		cs.cc.mu.Lock()
 		cs.abortStreamLocked(err)
 		bodyClosed := cs.reqBodyClosed
-		if cs.ID != 0 {
+		if markDoNotReuse && cs.ID != 0 {
 			// This request may have failed because of a problem with the connection,
 			// or for some unrelated reason. (For example, the user might have canceled
 			// the request without waiting for a response.) Mark the connection as
@@ -1318,12 +1318,12 @@ func (cc *ClientConn) RoundTrip(req *http.Request) (*http.Response, error) {
 				return handleResponseHeaders()
 			default:
 				waitDone()
-				return nil, cancelRequest(cs, cs.abortErr)
+				return nil, cancelRequest(cs, true, cs.abortErr)
 			}
 		case <-ctx.Done():
-			return nil, cancelRequest(cs, ctx.Err())
+			return nil, cancelRequest(cs, false, ctx.Err())
 		case <-cs.reqCancel:
-			return nil, cancelRequest(cs, errRequestCanceled)
+			return nil, cancelRequest(cs, false, errRequestCanceled)
 		}
 	}
 }

http2/transport_test.go

@@ -6374,87 +6374,3 @@ func (c *blockReadConn) Read(b []byte) (n int, err error) {
 	<-c.blockc
 	return c.Conn.Read(b)
 }
-
-func TestTransportReuseAfterError(t *testing.T) {
-	serverReqc := make(chan struct{}, 3)
-	st := newServerTester(t, func(w http.ResponseWriter, r *http.Request) {
-		serverReqc <- struct{}{}
-	}, optOnlyServer)
-	defer st.Close()
-
-	var (
-		unblockOnce sync.Once
-		blockc      = make(chan struct{})
-		connCountMu sync.Mutex
-		connCount   int
-	)
-	tr := &Transport{
-		TLSClientConfig: tlsConfigInsecure,
-		DialTLS: func(network, addr string, cfg *tls.Config) (net.Conn, error) {
-			// The first connection dialed will block on reads until blockc is closed.
-			connCountMu.Lock()
-			defer connCountMu.Unlock()
-			connCount++
-			conn, err := tls.Dial(network, addr, cfg)
-			if err != nil {
-				return nil, err
-			}
-			if connCount == 1 {
-				return &blockReadConn{
-					Conn:   conn,
-					blockc: blockc,
-				}, nil
-			}
-			return conn, nil
-		},
-	}
-	defer tr.CloseIdleConnections()
-	defer unblockOnce.Do(func() {
-		// Ensure that reads on blockc are unblocked if we return early.
-		close(blockc)
-	})
-
-	req, _ := http.NewRequest("GET", st.ts.URL, nil)
-
-	// Request 1 is made on conn 1.
-	// Reading the response will block.
-	// Wait until the server receives the request, and continue.
-	req1c := make(chan struct{})
-	go func() {
-		defer close(req1c)
-		res1, err := tr.RoundTrip(req.Clone(context.Background()))
-		if err != nil {
-			t.Errorf("request 1: %v", err)
-		} else {
-			res1.Body.Close()
-		}
-	}()
-	<-serverReqc
-
-	// Request 2 is also made on conn 1.
-	// Reading the response will block.
-	// The request is canceled once the server receives it.
-	// Conn 1 should now be flagged as unfit for reuse.
-	req2Ctx, cancel := context.WithCancel(context.Background())
-	go func() {
-		<-serverReqc
-		cancel()
-	}()
-	_, err := tr.RoundTrip(req.Clone(req2Ctx))
-	if err == nil {
-		t.Errorf("request 2 unexpectedly succeeded (want cancel)")
-	}
-
-	// Request 3 is made on a new conn, and succeeds.
-	res3, err := tr.RoundTrip(req.Clone(context.Background()))
-	if err != nil {
-		t.Fatalf("request 3: %v", err)
-	}
-	res3.Body.Close()
-
-	// Unblock conn 1, and verify that request 1 completes.
-	unblockOnce.Do(func() {
-		close(blockc)
-	})
-	<-req1c
-}