// TODO(tschottdorf): this method is somewhat awkward but unless we want to // give this error back to the client, our options are limited. We'll have to // run the whole thing for them, or any restart will still end up at the client // which will not be prepared to be handed a Txn. func (tc *TxnCoordSender) resendWithTxn( ba roachpb.BatchRequest, ) (*roachpb.BatchResponse, *roachpb.Error) { ctx := tc.AnnotateCtx(context.TODO()) // Run a one-off transaction with that single command. if log.V(1) { log.Infof(ctx, "%s: auto-wrapping in txn and re-executing: ", ba) } // TODO(bdarnell): need to be able to pass other parts of DBContext // through here. dbCtx := client.DefaultDBContext() dbCtx.UserPriority = ba.UserPriority tmpDB := client.NewDBWithContext(tc, dbCtx) var br *roachpb.BatchResponse err := tmpDB.Txn(ctx, func(txn *client.Txn) error { txn.SetDebugName("auto-wrap", 0) b := txn.NewBatch() b.Header = ba.Header for _, arg := range ba.Requests { req := arg.GetInner() b.AddRawRequest(req) } err := txn.CommitInBatch(b) br = b.RawResponse() return err }) if err != nil { return nil, roachpb.NewError(err) } br.Txn = nil // hide the evidence return br, nil }
// createTestNotifyClient creates a new client which connects using an HTTP // sender to the server at addr. It contains a waitgroup to allow waiting. func createTestNotifyClient( t *testing.T, s serverutils.TestServerInterface, priority roachpb.UserPriority, ) (*client.DB, *notifyingSender) { db := createTestClient(t, s) sender := ¬ifyingSender{wrapped: db.GetSender()} dbCtx := client.DefaultDBContext() dbCtx.UserPriority = priority return client.NewDBWithContext(sender, dbCtx), sender }
// createTestNotifyClient creates a new client which connects using an HTTP // sender to the server at addr. It contains a waitgroup to allow waiting. func createTestNotifyClient( t *testing.T, stopper *stop.Stopper, addr string, priority roachpb.UserPriority, ) (*client.DB, *notifyingSender) { db := createTestClient(t, stopper, addr) sender := ¬ifyingSender{wrapped: db.GetSender()} dbCtx := client.DefaultDBContext() dbCtx.UserPriority = priority return client.NewDBWithContext(sender, dbCtx), sender }
// Start starts the test cluster by bootstrapping an in-memory store // (defaults to maximum of 50M). The server is started, launching the // node RPC server and all HTTP endpoints. Use the value of // TestServer.Addr after Start() for client connections. Use Stop() // to shutdown the server after the test completes. func (ltc *LocalTestCluster) Start(t util.Tester, baseCtx *base.Config, initSender InitSenderFn) { ambient := log.AmbientContext{Tracer: tracing.NewTracer()} nc := &base.NodeIDContainer{} ambient.AddLogTag("n", nc) nodeID := roachpb.NodeID(1) nodeDesc := &roachpb.NodeDescriptor{NodeID: nodeID} ltc.tester = t ltc.Manual = hlc.NewManualClock(0) ltc.Clock = hlc.NewClock(ltc.Manual.UnixNano) ltc.Stopper = stop.NewStopper() rpcContext := rpc.NewContext(ambient, baseCtx, ltc.Clock, ltc.Stopper) server := rpc.NewServer(rpcContext) // never started ltc.Gossip = gossip.New(ambient, nc, rpcContext, server, nil, ltc.Stopper, metric.NewRegistry()) ltc.Eng = engine.NewInMem(roachpb.Attributes{}, 50<<20) ltc.Stopper.AddCloser(ltc.Eng) ltc.Stores = storage.NewStores(ambient, ltc.Clock) ltc.Sender = initSender(nodeDesc, ambient.Tracer, ltc.Clock, ltc.Latency, ltc.Stores, ltc.Stopper, ltc.Gossip) if ltc.DBContext == nil { dbCtx := client.DefaultDBContext() ltc.DBContext = &dbCtx } ltc.DB = client.NewDBWithContext(ltc.Sender, *ltc.DBContext) transport := storage.NewDummyRaftTransport() cfg := storage.TestStoreConfig() if ltc.RangeRetryOptions != nil { cfg.RangeRetryOptions = *ltc.RangeRetryOptions } cfg.AmbientCtx = ambient cfg.Clock = ltc.Clock cfg.DB = ltc.DB cfg.Gossip = ltc.Gossip cfg.Transport = transport cfg.MetricsSampleInterval = metric.TestSampleInterval ltc.Store = storage.NewStore(cfg, ltc.Eng, nodeDesc) if err := ltc.Store.Bootstrap(roachpb.StoreIdent{NodeID: nodeID, StoreID: 1}); err != nil { t.Fatalf("unable to start local test cluster: %s", err) } ltc.Stores.AddStore(ltc.Store) if err := ltc.Store.BootstrapRange(nil); err != nil { t.Fatalf("unable to start local test cluster: %s", err) } if err := ltc.Store.Start(context.Background(), ltc.Stopper); err != nil { t.Fatalf("unable to start local test cluster: %s", err) } nc.Set(context.TODO(), nodeDesc.NodeID) if err := ltc.Gossip.SetNodeDescriptor(nodeDesc); err != nil { t.Fatalf("unable to set node descriptor: %s", err) } }
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) }