func (lt *localRPCTransport) getClient(id roachpb.StoreID) (*netrpc.Client, error) {
lt.mu.Lock()
defer lt.mu.Unlock()
select {
case <-lt.closed:
return nil, util.Errorf("transport is closed")
default:
}
client, ok := lt.clients[id]
if ok {
return client, nil
}
srvWithAddr, ok := lt.servers[id]
if !ok {
return nil, util.Errorf("unknown peer %v", id)
}
address := srvWithAddr.addr.String()
// If this wasn't test code we wouldn't want to call Dial while holding the lock.
conn, err := codec.TLSDialHTTP("tcp", address, base.NetworkTimeout, nil)
if err != nil {
return nil, err
}
client = netrpc.NewClientWithCodec(codec.NewClientCodec(conn))
lt.clients[id] = client
return client, err
}
// connect attempts a single connection attempt. On success, updates `c.conn`.
func (c *Client) connect() error {
conn, err := tlsDialHTTP(c.addr.NetworkField, c.addr.StringField, c.tlsConfig)
if err != nil {
return err
}
c.conn.Store(internalConn{
conn: conn,
client: rpc.NewClientWithCodec(codec.NewClientCodec(conn)),
})
return nil
}
// connect attempts a single connection attempt. On success, updates `c.conn`.
func (c *Client) connect() error {
conn, err := tlsDialHTTP(c.addr.NetworkField, c.addr.StringField, c.tlsConfig)
if err != nil {
return err
}
if oldConn := (*internalConn)(atomic.SwapPointer(&c.conn, unsafe.Pointer(&internalConn{
conn: conn,
client: rpc.NewClientWithCodec(codec.NewClientCodec(conn)),
}))); oldConn != nil {
oldConn.conn.Close()
}
return nil
}
// connect dials the connection in a backoff/retry loop.
func (c *Client) connect(opts *retry.Options, context *Context) error {
// Attempt to dial connection.
retryOpts := clientRetryOptions
if opts != nil {
retryOpts = *opts
}
retryOpts.Stopper = context.Stopper
for r := retry.Start(retryOpts); r.Next(); {
tlsConfig, err := context.GetClientTLSConfig()
if err != nil {
// Problem loading the TLS config. Retrying will not help.
return err
}
conn, err := tlsDialHTTP(c.addr.Network(), c.addr.String(), tlsConfig)
if err != nil {
// Retry if the error is temporary, otherwise fail fast.
if t, ok := err.(net.Error); ok && t.Temporary() {
if log.V(1) {
log.Warning(err)
}
continue
}
return err
}
c.mu.Lock()
c.Client = rpc.NewClientWithCodec(codec.NewClientCodec(conn))
c.lAddr = conn.LocalAddr()
c.mu.Unlock()
if c.lAddr == nil {
return errClosed
}
// Ensure at least one heartbeat succeeds before exiting the
// retry loop. If it fails, don't retry: The node is probably
// dead.
if err = c.heartbeat(); err != nil {
return err
}
return nil
}
return util.Errorf("system is stopping")
}
// connect dials the connection in a backoff/retry loop.
func (c *Client) connect(opts *retry.Options, context *Context) error {
// Attempt to dial connection.
retryOpts := clientRetryOptions
if opts != nil {
retryOpts = *opts
}
retryOpts.Tag = fmt.Sprintf("client %s connection", c.addr)
retryOpts.Stopper = context.Stopper
if err := retry.WithBackoff(retryOpts, func() (retry.Status, error) {
tlsConfig, err := context.GetClientTLSConfig()
if err != nil {
// Problem loading the TLS config. Retrying will not help.
return retry.Break, err
}
conn, err := tlsDialHTTP(c.addr.Network(), c.addr.String(), tlsConfig)
if err != nil {
// Retry if the error is temporary, otherwise fail fast.
if t, ok := err.(net.Error); ok && t.Temporary() {
return retry.Continue, err
}
return retry.Break, err
}
c.mu.Lock()
c.Client = rpc.NewClientWithCodec(codec.NewClientCodec(conn))
c.lAddr = conn.LocalAddr()
c.mu.Unlock()
// Ensure at least one heartbeat succeeds before exiting the
// retry loop. If it fails, don't retry: The node is probably
// dead.
if err = c.heartbeat(); err != nil {
return retry.Break, err
}
return retry.Break, nil
}); err != nil {
return err
}
return nil
}
// newRPCSender returns a new instance of rpcSender.
func newRPCSender(server string, context *base.Context, retryOpts retry.Options) (*rpcSender, error) {
addr, err := net.ResolveTCPAddr("tcp", server)
if err != nil {
return nil, err
}
tlsConfig, err := context.GetClientTLSConfig()
if err != nil {
return nil, err
}
conn, err := codec.TLSDialHTTP(addr.Network(), addr.String(), base.NetworkTimeout, tlsConfig)
if err != nil {
return nil, err
}
client := rpc.NewClientWithCodec(codec.NewClientCodec(conn))
return &rpcSender{
user: context.User,
client: client,
retryOpts: retryOpts,
}, nil
}
