// NewClient implements the Cluster interface. func (f *Farmer) NewClient(ctx context.Context, t testing.TB, i int) *client.DB { conn, err := f.RPCContext.GRPCDial(f.Addr(ctx, i, base.DefaultPort)) if err != nil { t.Fatal(err) } return client.NewDB(client.NewSender(conn)) }
func (c *Cluster) makeClient(nodeIdx int) *client.DB { sender, err := client.NewSender(c.rpcCtx, c.RPCAddr(nodeIdx)) if err != nil { log.Fatalf(context.Background(), "failed to initialize KV client: %s", err) } return client.NewDB(sender) }
// MakeDBClient creates a kv client for use in cli tools. func MakeDBClient() (*client.DB, *stop.Stopper, error) { conn, stopper, err := getGRPCConn() if err != nil { return nil, nil, err } return client.NewDB(client.NewSender(conn)), stopper, nil }
// NewClient implements the Cluster interface. func (f *Farmer) NewClient(ctx context.Context, i int) (*client.DB, error) { conn, err := f.RPCContext.GRPCDial(f.Addr(ctx, i, base.DefaultPort)) if err != nil { return nil, err } return client.NewDB(client.NewSender(conn)), nil }
func newKVNative(b *testing.B) kvInterface { enableTracing := tracing.Disable() s, _, _ := serverutils.StartServer(b, base.TestServerArgs{}) // TestServer.DB() returns the TxnCoordSender wrapped client. But that isn't // a fair comparison with SQL as we want these client requests to be sent // over the network. sender, err := client.NewSender( rpc.NewContext(log.AmbientContext{}, &base.Config{ User: security.NodeUser, SSLCA: filepath.Join(security.EmbeddedCertsDir, security.EmbeddedCACert), SSLCert: filepath.Join(security.EmbeddedCertsDir, "node.crt"), SSLCertKey: filepath.Join(security.EmbeddedCertsDir, "node.key"), }, nil, s.Stopper()), s.ServingAddr()) if err != nil { b.Fatal(err) } return &kvNative{ db: client.NewDB(sender), doneFn: func() { s.Stopper().Stop() enableTracing() }, } }
// NewClient implements the Cluster interface. func (f *Farmer) NewClient(t *testing.T, i int) (*client.DB, *stop.Stopper) { stopper := stop.NewStopper() rpcContext := rpc.NewContext(log.AmbientContext{}, &base.Config{ Insecure: true, User: security.NodeUser, }, nil, stopper) sender, err := client.NewSender(rpcContext, f.Addr(i, base.DefaultPort)) if err != nil { t.Fatal(err) } return client.NewDB(sender), stopper }
// NewClient implements the Cluster interface. func (l *LocalCluster) NewClient(ctx context.Context, i int) (*roachClient.DB, error) { rpcContext := rpc.NewContext(log.AmbientContext{}, &base.Config{ User: security.NodeUser, SSLCA: filepath.Join(l.CertsDir, security.EmbeddedCACert), SSLCert: filepath.Join(l.CertsDir, security.EmbeddedNodeCert), SSLCertKey: filepath.Join(l.CertsDir, security.EmbeddedNodeKey), }, hlc.NewClock(hlc.UnixNano, 0), l.stopper) conn, err := rpcContext.GRPCDial(l.Nodes[i].Addr(ctx, DefaultTCP).String()) if err != nil { return nil, err } return roachClient.NewDB(roachClient.NewSender(conn)), nil }
func createTestClientForUser(t *testing.T, stopper *stop.Stopper, addr, user string) *client.DB { var ctx base.Config ctx.InitDefaults() ctx.User = user ctx.SSLCA = filepath.Join(security.EmbeddedCertsDir, security.EmbeddedCACert) ctx.SSLCert = filepath.Join(security.EmbeddedCertsDir, fmt.Sprintf("%s.crt", user)) ctx.SSLCertKey = filepath.Join(security.EmbeddedCertsDir, fmt.Sprintf("%s.key", user)) sender, err := client.NewSender(rpc.NewContext(log.AmbientContext{}, &ctx, nil, stopper), addr) if err != nil { t.Fatal(err) } return client.NewDB(sender) }
// NewClient implements the Cluster interface. func (l *LocalCluster) NewClient(t *testing.T, i int) (*roachClient.DB, *stop.Stopper) { stopper := stop.NewStopper() rpcContext := rpc.NewContext(log.AmbientContext{}, &base.Config{ User: security.NodeUser, SSLCA: filepath.Join(l.CertsDir, security.EmbeddedCACert), SSLCert: filepath.Join(l.CertsDir, security.EmbeddedNodeCert), SSLCertKey: filepath.Join(l.CertsDir, security.EmbeddedNodeKey), }, hlc.NewClock(hlc.UnixNano, 0), stopper) conn, err := rpcContext.GRPCDial(l.Nodes[i].Addr(DefaultTCP).String()) if err != nil { t.Fatal(err) } return roachClient.NewDB(roachClient.NewSender(conn)), stopper }
func createTestClientForUser( t *testing.T, s serverutils.TestServerInterface, user string, ) *client.DB { var ctx base.Config ctx.InitDefaults() ctx.User = user ctx.SSLCA = filepath.Join(security.EmbeddedCertsDir, security.EmbeddedCACert) ctx.SSLCert = filepath.Join(security.EmbeddedCertsDir, fmt.Sprintf("%s.crt", user)) ctx.SSLCertKey = filepath.Join(security.EmbeddedCertsDir, fmt.Sprintf("%s.key", user)) conn, err := rpc.NewContext(log.AmbientContext{}, &ctx, s.Clock(), s.Stopper()).GRPCDial(s.ServingAddr()) if err != nil { t.Fatal(err) } return client.NewDB(client.NewSender(conn)) }
func createTestClientForUser( t *testing.T, s serverutils.TestServerInterface, user string, dbCtx client.DBContext, ) *client.DB { rpcContext := rpc.NewContext(log.AmbientContext{}, &base.Config{ User: user, SSLCA: filepath.Join(security.EmbeddedCertsDir, security.EmbeddedCACert), SSLCert: filepath.Join(security.EmbeddedCertsDir, fmt.Sprintf("%s.crt", user)), SSLCertKey: filepath.Join(security.EmbeddedCertsDir, fmt.Sprintf("%s.key", user)), }, s.Clock(), s.Stopper()) conn, err := rpcContext.GRPCDial(s.ServingAddr()) if err != nil { t.Fatal(err) } return client.NewDBWithContext(client.NewSender(conn), dbCtx) }
func createTestClientForUser( t *testing.T, stopper *stop.Stopper, addr, user string, dbCtx client.DBContext, ) *client.DB { rpcContext := rpc.NewContext(log.AmbientContext{}, &base.Config{ User: user, SSLCA: filepath.Join(security.EmbeddedCertsDir, security.EmbeddedCACert), SSLCert: filepath.Join(security.EmbeddedCertsDir, fmt.Sprintf("%s.crt", user)), SSLCertKey: filepath.Join(security.EmbeddedCertsDir, fmt.Sprintf("%s.key", user)), }, nil, stopper) sender, err := client.NewSender(rpcContext, addr) if err != nil { t.Fatal(err) } return client.NewDBWithContext(sender, dbCtx) }
func newKVNative(b *testing.B) kvInterface { enableTracing := tracing.Disable() s, _, _ := serverutils.StartServer(b, base.TestServerArgs{}) // TestServer.KVClient() returns the TxnCoordSender wrapped client. But that // isn't a fair comparison with SQL as we want these client requests to be // sent over the network. rpcContext := s.RPCContext() conn, err := rpcContext.GRPCDial(s.ServingAddr()) if err != nil { b.Fatal(err) } return &kvNative{ db: client.NewDB(client.NewSender(conn)), doneFn: func() { s.Stopper().Stop() enableTracing() }, } }
func makeDBClient() (*client.DB, *stop.Stopper, error) { stopper := stop.NewStopper() cfg := &base.Config{ User: security.NodeUser, SSLCA: baseCfg.SSLCA, SSLCert: baseCfg.SSLCert, SSLCertKey: baseCfg.SSLCertKey, Insecure: baseCfg.Insecure, } addr, err := addrWithDefaultHost(baseCfg.Addr) if err != nil { return nil, nil, err } sender, err := client.NewSender( rpc.NewContext(log.AmbientContext{}, cfg, nil, stopper), addr, ) if err != nil { stopper.Stop() return nil, nil, errors.Wrap(err, "failed to initialize KV client") } return client.NewDB(sender), stopper, nil }