client_conn_pool.go

Documentation: golang.org/x/net/http2

     1  // Copyright 2015 The Go Authors. All rights reserved.
     2  // Use of this source code is governed by a BSD-style
     3  // license that can be found in the LICENSE file.
     4  
     5  // Transport code's client connection pooling.
     6  
     7  package http2
     8  
     9  import (
    10  	"context"
    11  	"crypto/tls"
    12  	"errors"
    13  	"net/http"
    14  	"sync"
    15  )
    16  
    17  // ClientConnPool manages a pool of HTTP/2 client connections.
    18  type ClientConnPool interface {
    19  	// GetClientConn returns a specific HTTP/2 connection (usually
    20  	// a TLS-TCP connection) to an HTTP/2 server. On success, the
    21  	// returned ClientConn accounts for the upcoming RoundTrip
    22  	// call, so the caller should not omit it. If the caller needs
    23  	// to, ClientConn.RoundTrip can be called with a bogus
    24  	// new(http.Request) to release the stream reservation.
    25  	GetClientConn(req *http.Request, addr string) (*ClientConn, error)
    26  	MarkDead(*ClientConn)
    27  }
    28  
    29  // clientConnPoolIdleCloser is the interface implemented by ClientConnPool
    30  // implementations which can close their idle connections.
    31  type clientConnPoolIdleCloser interface {
    32  	ClientConnPool
    33  	closeIdleConnections()
    34  }
    35  
    36  var (
    37  	_ clientConnPoolIdleCloser = (*clientConnPool)(nil)
    38  	_ clientConnPoolIdleCloser = noDialClientConnPool{}
    39  )
    40  
    41  // TODO: use singleflight for dialing and addConnCalls?
    42  type clientConnPool struct {
    43  	t *Transport
    44  
    45  	mu sync.Mutex // TODO: maybe switch to RWMutex
    46  	// TODO: add support for sharing conns based on cert names
    47  	// (e.g. share conn for googleapis.com and appspot.com)
    48  	conns        map[string][]*ClientConn // key is host:port
    49  	dialing      map[string]*dialCall     // currently in-flight dials
    50  	keys         map[*ClientConn][]string
    51  	addConnCalls map[string]*addConnCall // in-flight addConnIfNeeded calls
    52  }
    53  
    54  func (p *clientConnPool) GetClientConn(req *http.Request, addr string) (*ClientConn, error) {
    55  	return p.getClientConn(req, addr, dialOnMiss)
    56  }
    57  
    58  const (
    59  	dialOnMiss   = true
    60  	noDialOnMiss = false
    61  )
    62  
    63  func (p *clientConnPool) getClientConn(req *http.Request, addr string, dialOnMiss bool) (*ClientConn, error) {
    64  	// TODO(dneil): Dial a new connection when t.DisableKeepAlives is set?
    65  	if isConnectionCloseRequest(req) && dialOnMiss {
    66  		// It gets its own connection.
    67  		traceGetConn(req, addr)
    68  		const singleUse = true
    69  		cc, err := p.t.dialClientConn(req.Context(), addr, singleUse)
    70  		if err != nil {
    71  			return nil, err
    72  		}
    73  		return cc, nil
    74  	}
    75  	for {
    76  		p.mu.Lock()
    77  		for _, cc := range p.conns[addr] {
    78  			if cc.ReserveNewRequest() {
    79  				// When a connection is presented to us by the net/http package,
    80  				// the GetConn hook has already been called.
    81  				// Don't call it a second time here.
    82  				if !cc.getConnCalled {
    83  					traceGetConn(req, addr)
    84  				}
    85  				cc.getConnCalled = false
    86  				p.mu.Unlock()
    87  				return cc, nil
    88  			}
    89  		}
    90  		if !dialOnMiss {
    91  			p.mu.Unlock()
    92  			return nil, ErrNoCachedConn
    93  		}
    94  		traceGetConn(req, addr)
    95  		call := p.getStartDialLocked(req.Context(), addr)
    96  		p.mu.Unlock()
    97  		<-call.done
    98  		if shouldRetryDial(call, req) {
    99  			continue
   100  		}
   101  		cc, err := call.res, call.err
   102  		if err != nil {
   103  			return nil, err
   104  		}
   105  		if cc.ReserveNewRequest() {
   106  			return cc, nil
   107  		}
   108  	}
   109  }
   110  
   111  // dialCall is an in-flight Transport dial call to a host.
   112  type dialCall struct {
   113  	_ incomparable
   114  	p *clientConnPool
   115  	// the context associated with the request
   116  	// that created this dialCall
   117  	ctx  context.Context
   118  	done chan struct{} // closed when done
   119  	res  *ClientConn   // valid after done is closed
   120  	err  error         // valid after done is closed
   121  }
   122  
   123  // requires p.mu is held.
   124  func (p *clientConnPool) getStartDialLocked(ctx context.Context, addr string) *dialCall {
   125  	if call, ok := p.dialing[addr]; ok {
   126  		// A dial is already in-flight. Don't start another.
   127  		return call
   128  	}
   129  	call := &dialCall{p: p, done: make(chan struct{}), ctx: ctx}
   130  	if p.dialing == nil {
   131  		p.dialing = make(map[string]*dialCall)
   132  	}
   133  	p.dialing[addr] = call
   134  	go call.dial(call.ctx, addr)
   135  	return call
   136  }
   137  
   138  // run in its own goroutine.
   139  func (c *dialCall) dial(ctx context.Context, addr string) {
   140  	const singleUse = false // shared conn
   141  	c.res, c.err = c.p.t.dialClientConn(ctx, addr, singleUse)
   142  
   143  	c.p.mu.Lock()
   144  	delete(c.p.dialing, addr)
   145  	if c.err == nil {
   146  		c.p.addConnLocked(addr, c.res)
   147  	}
   148  	c.p.mu.Unlock()
   149  
   150  	close(c.done)
   151  }
   152  
   153  // addConnIfNeeded makes a NewClientConn out of c if a connection for key doesn't
   154  // already exist. It coalesces concurrent calls with the same key.
   155  // This is used by the http1 Transport code when it creates a new connection. Because
   156  // the http1 Transport doesn't de-dup TCP dials to outbound hosts (because it doesn't know
   157  // the protocol), it can get into a situation where it has multiple TLS connections.
   158  // This code decides which ones live or die.
   159  // The return value used is whether c was used.
   160  // c is never closed.
   161  func (p *clientConnPool) addConnIfNeeded(key string, t *Transport, c *tls.Conn) (used bool, err error) {
   162  	p.mu.Lock()
   163  	for _, cc := range p.conns[key] {
   164  		if cc.CanTakeNewRequest() {
   165  			p.mu.Unlock()
   166  			return false, nil
   167  		}
   168  	}
   169  	call, dup := p.addConnCalls[key]
   170  	if !dup {
   171  		if p.addConnCalls == nil {
   172  			p.addConnCalls = make(map[string]*addConnCall)
   173  		}
   174  		call = &addConnCall{
   175  			p:    p,
   176  			done: make(chan struct{}),
   177  		}
   178  		p.addConnCalls[key] = call
   179  		go call.run(t, key, c)
   180  	}
   181  	p.mu.Unlock()
   182  
   183  	<-call.done
   184  	if call.err != nil {
   185  		return false, call.err
   186  	}
   187  	return !dup, nil
   188  }
   189  
   190  type addConnCall struct {
   191  	_    incomparable
   192  	p    *clientConnPool
   193  	done chan struct{} // closed when done
   194  	err  error
   195  }
   196  
   197  func (c *addConnCall) run(t *Transport, key string, tc *tls.Conn) {
   198  	cc, err := t.NewClientConn(tc)
   199  
   200  	p := c.p
   201  	p.mu.Lock()
   202  	if err != nil {
   203  		c.err = err
   204  	} else {
   205  		cc.getConnCalled = true // already called by the net/http package
   206  		p.addConnLocked(key, cc)
   207  	}
   208  	delete(p.addConnCalls, key)
   209  	p.mu.Unlock()
   210  	close(c.done)
   211  }
   212  
   213  // p.mu must be held
   214  func (p *clientConnPool) addConnLocked(key string, cc *ClientConn) {
   215  	for _, v := range p.conns[key] {
   216  		if v == cc {
   217  			return
   218  		}
   219  	}
   220  	if p.conns == nil {
   221  		p.conns = make(map[string][]*ClientConn)
   222  	}
   223  	if p.keys == nil {
   224  		p.keys = make(map[*ClientConn][]string)
   225  	}
   226  	p.conns[key] = append(p.conns[key], cc)
   227  	p.keys[cc] = append(p.keys[cc], key)
   228  }
   229  
   230  func (p *clientConnPool) MarkDead(cc *ClientConn) {
   231  	p.mu.Lock()
   232  	defer p.mu.Unlock()
   233  	for _, key := range p.keys[cc] {
   234  		vv, ok := p.conns[key]
   235  		if !ok {
   236  			continue
   237  		}
   238  		newList := filterOutClientConn(vv, cc)
   239  		if len(newList) > 0 {
   240  			p.conns[key] = newList
   241  		} else {
   242  			delete(p.conns, key)
   243  		}
   244  	}
   245  	delete(p.keys, cc)
   246  }
   247  
   248  func (p *clientConnPool) closeIdleConnections() {
   249  	p.mu.Lock()
   250  	defer p.mu.Unlock()
   251  	// TODO: don't close a cc if it was just added to the pool
   252  	// milliseconds ago and has never been used. There's currently
   253  	// a small race window with the HTTP/1 Transport's integration
   254  	// where it can add an idle conn just before using it, and
   255  	// somebody else can concurrently call CloseIdleConns and
   256  	// break some caller's RoundTrip.
   257  	for _, vv := range p.conns {
   258  		for _, cc := range vv {
   259  			cc.closeIfIdle()
   260  		}
   261  	}
   262  }
   263  
   264  func filterOutClientConn(in []*ClientConn, exclude *ClientConn) []*ClientConn {
   265  	out := in[:0]
   266  	for _, v := range in {
   267  		if v != exclude {
   268  			out = append(out, v)
   269  		}
   270  	}
   271  	// If we filtered it out, zero out the last item to prevent
   272  	// the GC from seeing it.
   273  	if len(in) != len(out) {
   274  		in[len(in)-1] = nil
   275  	}
   276  	return out
   277  }
   278  
   279  // noDialClientConnPool is an implementation of http2.ClientConnPool
   280  // which never dials. We let the HTTP/1.1 client dial and use its TLS
   281  // connection instead.
   282  type noDialClientConnPool struct{ *clientConnPool }
   283  
   284  func (p noDialClientConnPool) GetClientConn(req *http.Request, addr string) (*ClientConn, error) {
   285  	return p.getClientConn(req, addr, noDialOnMiss)
   286  }
   287  
   288  // shouldRetryDial reports whether the current request should
   289  // retry dialing after the call finished unsuccessfully, for example
   290  // if the dial was canceled because of a context cancellation or
   291  // deadline expiry.
   292  func shouldRetryDial(call *dialCall, req *http.Request) bool {
   293  	if call.err == nil {
   294  		// No error, no need to retry
   295  		return false
   296  	}
   297  	if call.ctx == req.Context() {
   298  		// If the call has the same context as the request, the dial
   299  		// should not be retried, since any cancellation will have come
   300  		// from this request.
   301  		return false
   302  	}
   303  	if !errors.Is(call.err, context.Canceled) && !errors.Is(call.err, context.DeadlineExceeded) {
   304  		// If the call error is not because of a context cancellation or a deadline expiry,
   305  		// the dial should not be retried.
   306  		return false
   307  	}
   308  	// Only retry if the error is a context cancellation error or deadline expiry
   309  	// and the context associated with the call was canceled or expired.
   310  	return call.ctx.Err() != nil
   311  }
   312
View as plain text