// rpcCallTablet wil execute the RPC on the remote server.
func (client *GoRpcTabletManagerClient) rpcCallTablet(ctx context.Context, tablet *topo.TabletInfo, name string, args, reply interface{}) error {
// create the RPC client, using ctx.Deadline if set, or no timeout.
var connectTimeout time.Duration
deadline, ok := ctx.Deadline()
if ok {
connectTimeout = deadline.Sub(time.Now())
if connectTimeout < 0 {
return fmt.Errorf("Timeout connecting to TabletManager.%v on %v", name, tablet.Alias)
}
}
rpcClient, err := bsonrpc.DialHTTP("tcp", tablet.Addr(), connectTimeout, nil)
if err != nil {
return fmt.Errorf("RPC error for %v: %v", tablet.Alias, err.Error())
}
defer rpcClient.Close()
// use the context Done() channel. Will handle context timeout.
call := rpcClient.Go(ctx, "TabletManager."+name, args, reply, nil)
select {
case <-ctx.Done():
return fmt.Errorf("Timeout waiting for TabletManager.%v to %v", name, tablet.Alias)
case <-call.Done:
if call.Error != nil {
return fmt.Errorf("Remote error for %v: %v", tablet.Alias, call.Error.Error())
} else {
return nil
}
}
}
func (client *GoRpcTabletManagerClient) Snapshot(ctx context.Context, tablet *topo.TabletInfo, sa *actionnode.SnapshotArgs, waitTime time.Duration) (<-chan *logutil.LoggerEvent, tmclient.SnapshotReplyFunc, error) {
rpcClient, err := bsonrpc.DialHTTP("tcp", tablet.Addr(), waitTime, nil)
if err != nil {
return nil, nil, err
}
logstream := make(chan *logutil.LoggerEvent, 10)
rpcstream := make(chan *gorpcproto.SnapshotStreamingReply, 10)
result := &actionnode.SnapshotReply{}
c := rpcClient.StreamGo("TabletManager.Snapshot", sa, rpcstream)
go func() {
for ssr := range rpcstream {
if ssr.Log != nil {
logstream <- ssr.Log
}
if ssr.Result != nil {
*result = *ssr.Result
}
}
close(logstream)
rpcClient.Close()
}()
return logstream, func() (*actionnode.SnapshotReply, error) {
return result, c.Error
}, nil
}
func connect() *rpcplus.Client {
rpcClient, err := bsonrpc.DialHTTP("tcp", *server, *timeout, nil)
if err != nil {
log.Fatalf("Can't connect to zkocc: %v", err)
}
return rpcClient
}
func goRpcMysqlctlClientFactory(network, addr string, dialTimeout time.Duration) (mysqlctlclient.MysqlctlClient, error) {
// create the RPC client
rpcClient, err := bsonrpc.DialHTTP(network, addr, dialTimeout, nil)
if err != nil {
return nil, fmt.Errorf("RPC error for %v: %v", addr, err)
}
return &goRpcMysqlctlClient{rpcClient}, nil
}
func (client *GoRpcTabletManagerClient) Restore(ctx context.Context, tablet *topo.TabletInfo, sa *actionnode.RestoreArgs, waitTime time.Duration) (<-chan *logutil.LoggerEvent, tmclient.ErrFunc, error) {
rpcClient, err := bsonrpc.DialHTTP("tcp", tablet.Addr(), waitTime, nil)
if err != nil {
return nil, nil, err
}
logstream := make(chan *logutil.LoggerEvent, 10)
c := rpcClient.StreamGo("TabletManager.Restore", sa, logstream)
return logstream, func() error {
rpcClient.Close()
return c.Error
}, nil
}
// From the addr (of the form server1:port1,server2:port2,server3:port3:...)
// splits it on commas, randomizes the list, and tries to connect
// to the servers, stopping at the first successful connection
func DialZkocc(addr string, connectTimeout time.Duration) (zkocc *ZkoccConn, err error) {
servers := strings.Split(addr, ",")
perm := rand.Perm(len(servers))
for _, index := range perm {
server := servers[index]
rpcClient, err := bsonrpc.DialHTTP("tcp", server, connectTimeout, nil)
if err == nil {
return &ZkoccConn{rpcClient: rpcClient}, nil
}
log.Infof("zk conn cache: zkocc connection to %v failed: %v", server, err)
}
return nil, fmt.Errorf("zkocc connect failed: %v", addr)
}
// DialTablet creates and initializes TabletBson.
func DialTablet(ctx context.Context, endPoint topo.EndPoint, keyspace, shard string, timeout time.Duration) (tabletconn.TabletConn, error) {
var addr string
var config *tls.Config
if *tabletBsonEncrypted {
port, ok := endPoint.NamedPortMap["vts"]
if !ok {
port = endPoint.NamedPortMap["_vts"]
}
addr = fmt.Sprintf("%v:%v", endPoint.Host, port)
config = &tls.Config{}
config.InsecureSkipVerify = true
} else {
port, ok := endPoint.NamedPortMap["vt"]
if !ok {
port = endPoint.NamedPortMap["_vtocc"]
}
addr = fmt.Sprintf("%v:%v", endPoint.Host, port)
}
conn := &TabletBson{endPoint: endPoint}
var err error
if *tabletBsonUsername != "" {
conn.rpcClient, err = bsonrpc.DialAuthHTTP("tcp", addr, *tabletBsonUsername, *tabletBsonPassword, timeout, config)
} else {
conn.rpcClient, err = bsonrpc.DialHTTP("tcp", addr, timeout, config)
}
if err != nil {
return nil, tabletError(err)
}
var sessionInfo tproto.SessionInfo
if err = conn.rpcClient.Call(ctx, "SqlQuery.GetSessionId", tproto.SessionParams{Keyspace: keyspace, Shard: shard}, &sessionInfo); err != nil {
conn.rpcClient.Close()
return nil, tabletError(err)
}
conn.sessionID = sessionInfo.SessionId
return conn, nil
}
func (client *GoRpcBinlogPlayerClient) Dial(addr string, connTimeout time.Duration) error {
var err error
client.Client, err = bsonrpc.DialHTTP("tcp", addr, connTimeout, nil)
return err
}