// 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 }