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 := codec.TLSDialHTTP(
c.addr.NetworkField, c.addr.AddressField, base.NetworkTimeout, 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
}
// 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
}
