func verifyBank(db *sql.DB) { var sum int64 if *aggregate { if err := db.QueryRow("SELECT SUM(balance) FROM accounts").Scan(&sum); err != nil { log.Fatal(err) } } else { tx, err := db.Begin() if err != nil { log.Fatal(err) } rows, err := tx.Query("SELECT balance FROM accounts") if err != nil { log.Fatal(err) } for rows.Next() { var balance int64 if err = rows.Scan(&balance); err != nil { log.Fatal(err) } sum += balance } if err = tx.Commit(); err != nil { log.Fatal(err) } } if sum == 0 { log.Info("The bank is in good order.") } else { log.Fatalf("The bank is not in good order. Total value: %d", sum) } }
// bootstrapStores bootstraps uninitialized stores once the cluster // and node IDs have been established for this node. Store IDs are // allocated via a sequence id generator stored at a system key per // node. func (n *Node) bootstrapStores(bootstraps *list.List, stopper *stop.Stopper) { log.Infof("bootstrapping %d store(s)", bootstraps.Len()) if n.ClusterID == "" { panic("ClusterID missing during store bootstrap of auxiliary store") } // Bootstrap all waiting stores by allocating a new store id for // each and invoking store.Bootstrap() to persist. inc := int64(bootstraps.Len()) firstID, err := allocateStoreIDs(n.Descriptor.NodeID, inc, n.ctx.DB) if err != nil { log.Fatal(err) } sIdent := roachpb.StoreIdent{ ClusterID: n.ClusterID, NodeID: n.Descriptor.NodeID, StoreID: firstID, } for e := bootstraps.Front(); e != nil; e = e.Next() { s := e.Value.(*storage.Store) if err := s.Bootstrap(sIdent, stopper); err != nil { log.Fatal(err) } if err := s.Start(stopper); err != nil { log.Fatal(err) } n.stores.AddStore(s) sIdent.StoreID++ log.Infof("bootstrapped store %s", s) // Done regularly in Node.startGossip, but this cuts down the time // until this store is used for range allocations. s.GossipStore() } }
// SimulateNetwork runs until the simCallback returns false. // // At each cycle, every node gossips a key equal to its address (unique) // with the cycle as the value. The received cycle value can be used // to determine the aging of information between any two nodes in the // network. // // At each cycle of the simulation, node 0 gossips the sentinel. // // The simulation callback receives the cycle and the network as arguments. func (n *Network) SimulateNetwork(simCallback func(cycle int, network *Network) bool) { nodes := n.Nodes for cycle := 1; simCallback(cycle, n); cycle++ { // Node 0 gossips sentinel & cluster ID every cycle. if err := nodes[0].Gossip.AddInfo( gossip.KeySentinel, encoding.EncodeUint64Ascending(nil, uint64(cycle)), time.Hour); err != nil { log.Fatal(err) } if err := nodes[0].Gossip.AddInfo(gossip.KeyClusterID, encoding.EncodeUint64Ascending(nil, uint64(cycle)), 0*time.Second); err != nil { log.Fatal(err) } // Every node gossips cycle. for _, node := range nodes { if err := node.Gossip.AddInfo( node.Addr.String(), encoding.EncodeUint64Ascending(nil, uint64(cycle)), time.Hour); err != nil { log.Fatal(err) } node.Gossip.SimulationCycle() } time.Sleep(5 * time.Millisecond) } log.Infof("gossip network simulation: total infos sent=%d, received=%d", n.infosSent(), n.infosReceived()) }
func main() { if err := parseFlags(); err != nil { log.Fatal(err) } serv := maybeStartLocalServer() if serv != nil { defer serv.Stop() } db, err := setupDatabase() if err != nil { log.Fatal(err) } lastNow := time.Now() var lastNumDumps uint64 writers := make([]blockWriter, *concurrency) for i := range writers { writers[i] = newBlockWriter(db) go writers[i].run() } for range time.Tick(*outputInterval) { now := time.Now() elapsed := time.Since(lastNow) dumps := atomic.LoadUint64(&numBlocks) log.Infof("%d dumps were executed at %.1f/second.", (dumps - lastNumDumps), float64(dumps-lastNumDumps)/elapsed.Seconds()) lastNumDumps = dumps lastNow = now } }
// bootstrapStores bootstraps uninitialized stores once the cluster // and node IDs have been established for this node. Store IDs are // allocated via a sequence id generator stored at a system key per // node. func (n *Node) bootstrapStores(bootstraps []*storage.Store, stopper *stop.Stopper) { if n.ClusterID == *uuid.EmptyUUID { panic("ClusterID missing during store bootstrap of auxiliary store") } // Bootstrap all waiting stores by allocating a new store id for // each and invoking store.Bootstrap() to persist. inc := int64(len(bootstraps)) firstID, err := allocateStoreIDs(n.Descriptor.NodeID, inc, n.ctx.DB) if err != nil { log.Fatal(err) } sIdent := roachpb.StoreIdent{ ClusterID: n.ClusterID, NodeID: n.Descriptor.NodeID, StoreID: firstID, } for _, s := range bootstraps { if err := s.Bootstrap(sIdent, stopper); err != nil { log.Fatal(err) } if err := s.Start(stopper); err != nil { log.Fatal(err) } n.stores.AddStore(s) sIdent.StoreID++ log.Infof("bootstrapped store %s", s) // Done regularly in Node.startGossip, but this cuts down the time // until this store is used for range allocations. s.GossipStore() } }
// NewNetwork creates nodeCount gossip nodes. func NewNetwork(nodeCount int) *Network { clock := hlc.NewClock(hlc.UnixNano) log.Infof("simulating gossip network with %d nodes", nodeCount) n := &Network{ Nodes: []*Node{}, Stopper: stop.NewStopper(), } n.rpcContext = rpc.NewContext(&base.Context{Insecure: true}, clock, n.Stopper) var err error n.tlsConfig, err = n.rpcContext.GetServerTLSConfig() if err != nil { log.Fatal(err) } for i := 0; i < nodeCount; i++ { node, err := n.CreateNode() if err != nil { log.Fatal(err) } // Build a resolver for each instance or we'll get data races. r, err := resolver.NewResolverFromAddress(n.Nodes[0].Addr) if err != nil { log.Fatalf("bad gossip address %s: %s", n.Nodes[0].Addr, err) } node.Gossip.SetResolvers([]resolver.Resolver{r}) if err := n.StartNode(node); err != nil { log.Fatal(err) } } return n }
func (z *zeroSum) setup() uint32 { db := z.db[0] if _, err := db.Exec("CREATE DATABASE IF NOT EXISTS zerosum"); err != nil { log.Fatal(context.Background(), err) } accounts := ` CREATE TABLE IF NOT EXISTS accounts ( id INT PRIMARY KEY, balance INT NOT NULL ) ` if _, err := db.Exec(accounts); err != nil { log.Fatal(context.Background(), err) } tableIDQuery := ` SELECT tables.id FROM system.namespace tables JOIN system.namespace dbs ON dbs.id = tables.parentid WHERE dbs.name = $1 AND tables.name = $2 ` var tableID uint32 if err := db.QueryRow(tableIDQuery, "zerosum", "accounts").Scan(&tableID); err != nil { log.Fatal(context.Background(), err) } return tableID }
// NewNetwork creates nodeCount gossip nodes. func NewNetwork(nodeCount int, createResolvers bool) *Network { log.Infof(context.TODO(), "simulating gossip network with %d nodes", nodeCount) n := &Network{ Nodes: []*Node{}, Stopper: stop.NewStopper(), } n.rpcContext = rpc.NewContext(&base.Context{Insecure: true}, nil, n.Stopper) var err error n.tlsConfig, err = n.rpcContext.GetServerTLSConfig() if err != nil { log.Fatal(context.TODO(), err) } for i := 0; i < nodeCount; i++ { node, err := n.CreateNode() if err != nil { log.Fatal(context.TODO(), err) } // Build a resolver for each instance or we'll get data races. if createResolvers { r, err := resolver.NewResolverFromAddress(n.Nodes[0].Addr()) if err != nil { log.Fatalf(context.TODO(), "bad gossip address %s: %s", n.Nodes[0].Addr(), err) } node.Gossip.SetResolvers([]resolver.Resolver{r}) } } return n }
func (c *cluster) freeze(nodeIdx int, freeze bool) { addr := c.rpcAddr(nodeIdx) conn, err := c.rpcCtx.GRPCDial(addr) if err != nil { log.Fatalf(context.Background(), "unable to dial: %s: %v", addr, err) } adminClient := serverpb.NewAdminClient(conn) stream, err := adminClient.ClusterFreeze( context.Background(), &serverpb.ClusterFreezeRequest{Freeze: freeze}) if err != nil { log.Fatal(context.Background(), err) } for { resp, err := stream.Recv() if err != nil { if err == io.EOF { break } log.Fatal(context.Background(), err) } fmt.Println(resp.Message) } fmt.Println("ok") }
// newDockerClient constructs a new docker client using the best available // method. If DOCKER_HOST is set, initialize the client using DOCKER_TLS_VERIFY // and DOCKER_CERT_PATH. If DOCKER_HOST is not set, look for the unix domain // socket in /run/docker.sock and /var/run/docker.sock. func newDockerClient() dockerclient.Client { if host := os.Getenv("DOCKER_HOST"); host != "" { if os.Getenv("DOCKER_TLS_VERIFY") == "" { c, err := dockerclient.NewDockerClient(host, nil) if err != nil { log.Fatal(err) } return c } c, err := dockerclient.NewDockerClient(host, getTLSConfig()) if err != nil { log.Fatal(err) } return c } for _, l := range []string{"/run/docker.sock", "/var/run/docker.sock"} { if _, err := os.Stat(l); err != nil { continue } c, err := dockerclient.NewDockerClient("unix://"+l, nil) if err != nil { return nil } return c } log.Fatal("docker not configured") return nil }
// startAdminServer launches a new admin server using minimal engine // and local database setup. Returns the new http test server, which // should be cleaned up by caller via httptest.Server.Close(). The // Cockroach KV client address is set to the address of the test server. func startAdminServer() (string, *stop.Stopper) { stopper := stop.NewStopper() db, err := BootstrapCluster("cluster-1", []engine.Engine{engine.NewInMem(proto.Attributes{}, 1<<20)}, stopper) if err != nil { log.Fatal(err) } admin := newAdminServer(db, stopper) mux := http.NewServeMux() mux.Handle(adminEndpoint, admin) mux.Handle(debugEndpoint, admin) httpServer := httptest.NewUnstartedServer(mux) tlsConfig, err := testContext.GetServerTLSConfig() if err != nil { log.Fatal(err) } httpServer.TLS = tlsConfig httpServer.StartTLS() stopper.AddCloser(httpServer) if strings.HasPrefix(httpServer.URL, "http://") { testContext.Addr = strings.TrimPrefix(httpServer.URL, "http://") } else if strings.HasPrefix(httpServer.URL, "https://") { testContext.Addr = strings.TrimPrefix(httpServer.URL, "https://") } return httpServer.URL, stopper }
// initNodeID updates the internal NodeDescriptor with the given ID. If zero is // supplied, a new NodeID is allocated with the first invocation. For all other // values, the supplied ID is stored into the descriptor (unless one has been // set previously, in which case a fatal error occurs). // // Upon setting a new NodeID, the descriptor is gossiped and the NodeID is // stored into the gossip instance. func (n *Node) initNodeID(id roachpb.NodeID) { if id < 0 { log.Fatalf("NodeID must not be negative") } if o := n.Descriptor.NodeID; o > 0 { if id == 0 { return } log.Fatalf("cannot initialize NodeID to %d, already have %d", id, o) } var err error if id == 0 { id, err = allocateNodeID(n.ctx.DB) log.Infof("new node allocated ID %d", id) if err != nil { log.Fatal(err) } if id == 0 { log.Fatal("new node allocated illegal ID 0") } n.ctx.Gossip.SetNodeID(id) } else { log.Infof("node ID %d initialized", id) } // Gossip the node descriptor to make this node addressable by node ID. n.Descriptor.NodeID = id if err = n.ctx.Gossip.SetNodeDescriptor(&n.Descriptor); err != nil { log.Fatalf("couldn't gossip descriptor for node %d: %s", n.Descriptor.NodeID, err) } }
// NewNetwork creates nodeCount gossip nodes. The networkType should // be set to either "tcp" or "unix". The gossipInterval should be set // to a compressed simulation timescale, though large enough to give // the concurrent goroutines enough time to pass data back and forth // in order to yield accurate estimates of how old data actually ends // up being at the various nodes (e.g. DefaultTestGossipInterval). // TODO: This method should take `stopper` as an argument. func NewNetwork(nodeCount int, networkType string, gossipInterval time.Duration) *Network { clock := hlc.NewClock(hlc.UnixNano) log.Infof("simulating gossip network with %d nodes", nodeCount) stopper := stop.NewStopper() rpcContext := rpc.NewContext(&base.Context{Insecure: true}, clock, stopper) nodes := make([]*Node, nodeCount) for i := range nodes { server := rpc.NewServer(util.CreateTestAddr(networkType), rpcContext) if err := server.Start(); err != nil { log.Fatal(err) } nodes[i] = &Node{Server: server} } var numResolvers int if len(nodes) > 3 { numResolvers = 3 } else { numResolvers = len(nodes) } for i, leftNode := range nodes { // Build new resolvers for each instance or we'll get data races. var resolvers []resolver.Resolver for _, rightNode := range nodes[:numResolvers] { resolvers = append(resolvers, resolver.NewResolverFromAddress(rightNode.Server.Addr())) } gossipNode := gossip.New(rpcContext, gossipInterval, resolvers) addr := leftNode.Server.Addr() if err := gossipNode.SetNodeDescriptor(&roachpb.NodeDescriptor{ NodeID: roachpb.NodeID(i + 1), Address: util.MakeUnresolvedAddr(addr.Network(), addr.String()), }); err != nil { log.Fatal(err) } gossipNode.Start(leftNode.Server, stopper) stopper.AddCloser(leftNode.Server) leftNode.Gossip = gossipNode } return &Network{ Nodes: nodes, NetworkType: networkType, GossipInterval: gossipInterval, Stopper: stopper, } }
// NewNetwork creates nodeCount gossip nodes. The networkType should // be set to either "tcp" or "unix". func NewNetwork(nodeCount int, networkType string) *Network { clock := hlc.NewClock(hlc.UnixNano) log.Infof("simulating gossip network with %d nodes", nodeCount) stopper := stop.NewStopper() rpcContext := rpc.NewContext(&base.Context{Insecure: true}, clock, stopper) tlsConfig, err := rpcContext.GetServerTLSConfig() if err != nil { log.Fatal(err) } nodes := make([]*Node, nodeCount) for i := range nodes { server := rpc.NewServer(rpcContext) testAddr := util.CreateTestAddr(networkType) ln, err := util.ListenAndServe(stopper, server, testAddr, tlsConfig) if err != nil { log.Fatal(err) } nodes[i] = &Node{Server: server, Addr: ln.Addr()} } for i, leftNode := range nodes { // Build new resolvers for each instance or we'll get data races. resolvers := []resolver.Resolver{resolver.NewResolverFromAddress(nodes[0].Addr)} gossipNode := gossip.New(rpcContext, resolvers) addr := leftNode.Addr gossipNode.SetNodeID(roachpb.NodeID(i + 1)) if err := gossipNode.SetNodeDescriptor(&roachpb.NodeDescriptor{ NodeID: roachpb.NodeID(i + 1), Address: util.MakeUnresolvedAddr(addr.Network(), addr.String()), }); err != nil { log.Fatal(err) } if err := gossipNode.AddInfo(addr.String(), encoding.EncodeUint64(nil, 0), time.Hour); err != nil { log.Fatal(err) } gossipNode.Start(leftNode.Server, addr, stopper) gossipNode.EnableSimulationCycler(true) leftNode.Gossip = gossipNode } return &Network{ Nodes: nodes, NetworkType: networkType, Stopper: stopper, } }
func main() { if err := parseFlags(); err != nil { log.Fatal(err) } serv := maybeStartLocalServer() if serv != nil { defer serv.Stop() } db, err := setupDatabase() if err != nil { log.Fatal(err) } lastNow := time.Now() var lastNumDumps uint64 writers := make([]blockWriter, *concurrency) errCh := make(chan error) for i := range writers { writers[i] = newBlockWriter(db) go writers[i].run(errCh) } var numErr int for range time.Tick(*outputInterval) { now := time.Now() elapsed := time.Since(lastNow) dumps := atomic.LoadUint64(&numBlocks) log.Infof("%d dumps were executed at %.1f/second (%d total errors)", (dumps - lastNumDumps), float64(dumps-lastNumDumps)/elapsed.Seconds(), numErr) for { select { case err := <-errCh: numErr++ if !*tolerateErrors { log.Fatal(err) } else { log.Warning(err) } continue default: } break } lastNumDumps = dumps lastNow = now } }
func newCLITest() cliTest { // Reset the client context for each test. We don't reset the // pointer (because they are tied into the flags), but instead // overwrite the existing struct's values. baseCtx.InitDefaults() cliCtx.InitCLIDefaults() osStderr = os.Stdout s, err := serverutils.StartServerRaw(base.TestServerArgs{}) if err != nil { log.Fatalf(context.Background(), "Could not start server: %v", err) } tempDir, err := ioutil.TempDir("", "cli-test") if err != nil { log.Fatal(context.Background(), err) } // Copy these assets to disk from embedded strings, so this test can // run from a standalone binary. // Disable embedded certs, or the security library will try to load // our real files as embedded assets. security.ResetReadFileFn() assets := []string{ filepath.Join(security.EmbeddedCertsDir, security.EmbeddedCACert), filepath.Join(security.EmbeddedCertsDir, security.EmbeddedCAKey), filepath.Join(security.EmbeddedCertsDir, security.EmbeddedNodeCert), filepath.Join(security.EmbeddedCertsDir, security.EmbeddedNodeKey), filepath.Join(security.EmbeddedCertsDir, security.EmbeddedRootCert), filepath.Join(security.EmbeddedCertsDir, security.EmbeddedRootKey), } for _, a := range assets { securitytest.RestrictedCopy(nil, a, tempDir, filepath.Base(a)) } return cliTest{ TestServer: s.(*server.TestServer), certsDir: tempDir, cleanupFunc: func() { if err := os.RemoveAll(tempDir); err != nil { log.Fatal(context.Background(), err) } }, } }
func (l *Cluster) startNode(i int) *Container { gossipNodes := []string{} for i := 0; i < l.numNodes; i++ { gossipNodes = append(gossipNodes, fmt.Sprintf("%s:%d", node(i), cockroachPort)) } cmd := []string{ "start", "--stores=ssd=" + data(i), "--certs=/certs", "--addr=" + fmt.Sprintf("%s:%d", node(i), cockroachPort), "--gossip=" + strings.Join(gossipNodes, ","), "--scan-max-idle-time=200ms", // set low to speed up tests } if len(l.LogDir) > 0 { dockerDir := "/logs/" + node(i) localDir := l.LogDir + "/" + node(i) if !exists(localDir) { if err := os.Mkdir(localDir, 0777); err != nil { log.Fatal(err) } } log.Infof("Logs for node %s are located at %s.", node(i), localDir) cmd = append( cmd, "--log-dir="+dockerDir, "--logtostderr=false", "--alsologtostderr=true") } c := l.createRoach(i, cmd...) maybePanic(c.Start(nil, l.dns, l.vols)) c.Name = node(i) log.Infof("started %s: https://%s", c.Name, c.Addr("")) return c }
func (c *cluster) makeNode(nodeIdx int, extraArgs []string) *node { name := fmt.Sprintf("%d", nodeIdx+1) dir := filepath.Join(dataDir, name) logDir := filepath.Join(dir, "logs") if err := os.MkdirAll(logDir, 0755); err != nil { log.Fatal(context.Background(), err) } args := []string{ cockroachBin, "start", "--insecure", fmt.Sprintf("--port=%d", c.rpcPort(nodeIdx)), fmt.Sprintf("--http-port=%d", c.httpPort(nodeIdx)), fmt.Sprintf("--store=%s", dir), fmt.Sprintf("--cache=256MiB"), fmt.Sprintf("--logtostderr"), } if nodeIdx > 0 { args = append(args, fmt.Sprintf("--join=localhost:%d", c.rpcPort(0))) } args = append(args, extraArgs...) node := &node{ LogDir: logDir, Args: args, } node.start() return node }
func createTestClient(addr string) *client.DB { db, err := client.Open("https://root@" + addr + "?certs=" + security.EmbeddedCertsDir) if err != nil { log.Fatal(err) } return db }
// Serve accepts and services connections on the already started // listener. func (s *Server) Serve(handler http.Handler) { s.handler = handler s.activeConns = make(map[net.Conn]struct{}) server := &http.Server{ Handler: s, ConnState: func(conn net.Conn, state http.ConnState) { s.mu.Lock() defer s.mu.Unlock() switch state { case http.StateNew: s.activeConns[conn] = struct{}{} case http.StateHijacked, http.StateClosed: delete(s.activeConns, conn) } }, } s.context.Stopper.RunWorker(func() { if err := server.Serve(s.listener); err != nil { if !strings.HasSuffix(err.Error(), "use of closed network connection") { log.Fatal(err) } } }) s.context.Stopper.RunWorker(func() { <-s.context.Stopper.ShouldStop() s.Close() }) }
// Serve accepts and services connections on the already started // listener. func (s *Server) Serve(handler http.Handler) { s.handler = handler s.activeConns = make(map[net.Conn]struct{}) server := &http.Server{ Handler: s, ConnState: func(conn net.Conn, state http.ConnState) { s.mu.Lock() defer s.mu.Unlock() switch state { case http.StateNew: if s.closed { conn.Close() return } s.activeConns[conn] = struct{}{} case http.StateClosed: delete(s.activeConns, conn) } }, } s.context.Stopper.RunWorker(func() { if err := server.Serve(s.listener); err != nil && !isClosedConnection(err) { log.Fatal(err) } }) s.context.Stopper.RunWorker(func() { <-s.context.Stopper.ShouldStop() s.Close() }) }
// SimulateNetwork creates nodeCount gossip nodes. The network should // be set to either "tcp" or "unix". The gossipInterval should be set // to a compressed simulation timescale, though large enough to give // the concurrent goroutines enough time to pass data back and forth // in order to yield accurate estimates of how old data actually ends // up being at the various nodes. After each gossipInterval period, // simCallback is invoked; when it returns false, the simulation // ends. If it returns true, the simulation continues another cycle. // // Node0 gossips the node count as well as the gossip sentinel. The // gossip bootstrap hosts are set to the first three nodes (or fewer if // less than three are available). // // At each cycle of the simulation, node 0 gossips the sentinel. If // the simulation requires other nodes to gossip, this should be done // via simCallback. // // The simulation callback receives a map of nodes, keyed by node address. func SimulateNetwork(nodeCount int, network string, gossipInterval time.Duration, simCallback func(cycle int, nodes map[string]*Gossip) bool) { // seed the random number generator for non-determinism across // multiple runs. rand.Seed(time.Now().UTC().UnixNano()) tlsConfig := rpc.LoadInsecureTLSConfig() log.Infof("simulating network with %d nodes", nodeCount) servers := make([]*rpc.Server, nodeCount) addrs := make([]net.Addr, nodeCount) for i := 0; i < nodeCount; i++ { addr := util.CreateTestAddr(network) servers[i] = rpc.NewServer(addr, tlsConfig) if err := servers[i].Start(); err != nil { log.Fatal(err) } addrs[i] = servers[i].Addr() } var bootstrap []net.Addr if nodeCount < 3 { bootstrap = addrs } else { bootstrap = addrs[:3] } nodes := make(map[string]*Gossip, nodeCount) for i := 0; i < nodeCount; i++ { node := New(tlsConfig) node.Name = fmt.Sprintf("Node%d", i) node.SetBootstrap(bootstrap) node.SetInterval(gossipInterval) node.Start(servers[i]) // Node 0 gossips node count. if i == 0 { node.AddInfo(KeyNodeCount, int64(nodeCount), time.Hour) } nodes[addrs[i].String()] = node } gossipTimeout := time.Tick(gossipInterval) var complete bool for cycle := 0; !complete; cycle++ { select { case <-gossipTimeout: // Node 0 gossips sentinel every cycle. nodes[addrs[0].String()].AddInfo(KeySentinel, int64(cycle), time.Hour) if !simCallback(cycle, nodes) { complete = true } } } // Stop all servers & nodes. for i := 0; i < nodeCount; i++ { servers[i].Close() nodes[addrs[i].String()].Stop() } }
func (lt *localInterceptableTransport) handleMessage(msg *RaftMessageRequest) { ack := make(chan struct{}) iMsg := &interceptMessage{ args: msg, ack: ack, } // The following channel ops are not protected by a select with // ShouldStop since we are running under a StartTask and leaving // things partially complete here could prevent other components // from shutting down cleanly. lt.Events <- iMsg <-ack lt.mu.Lock() srv, ok := lt.listeners[msg.ToReplica.StoreID] lt.mu.Unlock() if !ok { return } _, err := srv.RaftMessage(msg) if err == ErrStopped { return } else if err != nil { log.Fatal(err) } }
// request returns the result of performing a http get request. func request(url string, httpClient *http.Client) ([]byte, bool) { for r := retry.Start(retryOptions); r.Next(); { req, err := http.NewRequest("GET", url, nil) if err != nil { log.Fatal(err) return nil, false } req.Header.Set(util.AcceptHeader, util.JSONContentType) resp, err := httpClient.Do(req) if err != nil { log.Infof("could not GET %s - %s", url, err) continue } defer resp.Body.Close() body, err := ioutil.ReadAll(resp.Body) if err != nil { log.Infof("could not ready body for %s - %s", url, err) continue } if resp.StatusCode != http.StatusOK { log.Infof("could not GET %s - statuscode: %d - body: %s", url, resp.StatusCode, body) continue } returnedContentType := resp.Header.Get(util.ContentTypeHeader) if returnedContentType != util.JSONContentType { log.Infof("unexpected content type: %v", returnedContentType) continue } log.Infof("OK response from %s", url) return body, true } log.Warningf("There was an error retrieving %s", url) return nil, false }
func (l *LocalCluster) runDockerSpy() { l.panicOnStop() create := func() (*Container, error) { return createContainer(l, container.Config{ Image: dockerspyImage + ":" + dockerspyTag, Cmd: strslice.New("--dns-domain=" + domain), }, container.HostConfig{ Binds: []string{"/var/run/docker.sock:/var/run/docker.sock"}, PublishAllPorts: true, }, "docker-spy", ) } c, err := create() if dockerclient.IsErrImageNotFound(err) { if err := pullImage(l, types.ImagePullOptions{ImageID: dockerspyImage, Tag: dockerspyTag}); err != nil { log.Fatal(err) } c, err = create() } maybePanic(err) maybePanic(c.Start()) l.dns = c if ci, err := c.Inspect(); err != nil { log.Error(err) } else { log.Infof("started %s: %s", c.Name(), ci.NetworkSettings.IPAddress) } }
func (r *Replica) leasePostCommitTrigger( ctx context.Context, trigger PostCommitTrigger, replicaID roachpb.ReplicaID, prevLease *roachpb.Lease, // TODO(tschottdorf): could this not be nil? ) { if prevLease.Replica.StoreID != trigger.lease.Replica.StoreID { // The lease is changing hands. Is this replica the new lease holder? if trigger.lease.Replica.ReplicaID == replicaID { // If this replica is a new holder of the lease, update the low water // mark of the timestamp cache. Note that clock offset scenarios are // handled via a stasis period inherent in the lease which is documented // in on the Lease struct. // // The introduction of lease transfers implies that the previous lease // may have been shortened and we are now applying a formally overlapping // lease (since the old lease holder has promised not to serve any more // requests, this is kosher). This means that we don't use the old // lease's expiration but instead use the new lease's start to initialize // the timestamp cache low water. log.Infof(ctx, "new range lease %s following %s [physicalTime=%s]", trigger.lease, prevLease, r.store.Clock().PhysicalTime()) r.mu.Lock() r.mu.tsCache.SetLowWater(trigger.lease.Start) r.mu.Unlock() // Gossip the first range whenever its lease is acquired. We check to // make sure the lease is active so that a trailing replica won't process // an old lease request and attempt to gossip the first range. if r.IsFirstRange() && trigger.lease.Covers(r.store.Clock().Now()) { func() { r.mu.Lock() defer r.mu.Unlock() r.gossipFirstRangeLocked(ctx) }() } } else if trigger.lease.Covers(r.store.Clock().Now()) { if err := r.withRaftGroup(func(raftGroup *raft.RawNode) error { if raftGroup.Status().RaftState == raft.StateLeader { // If this replica is the raft leader but it is not the new lease // holder, then try to transfer the raft leadership to match the // lease. log.Infof(ctx, "range %v: replicaID %v transfer raft leadership to replicaID %v", r.RangeID, replicaID, trigger.lease.Replica.ReplicaID) raftGroup.TransferLeader(uint64(trigger.lease.Replica.ReplicaID)) } return nil }); err != nil { // An error here indicates that this Replica has been destroyed // while lacking the necessary synchronization (or even worse, it // fails spuriously - could be a storage error), and so we avoid // sweeping that under the rug. // // TODO(tschottdorf): this error is not handled any more // at this level. log.Fatal(ctx, NewReplicaCorruptionError(err)) } } } }
func ExampleDB_Put_insecure() { s := &server.TestServer{} s.Ctx = server.NewTestContext() s.Ctx.Insecure = true if pErr := s.Start(); pErr != nil { log.Fatalf("Could not start server: %v", pErr) } defer s.Stop() db, err := client.Open(s.Stopper(), "rpc://foo@"+s.ServingAddr()) if err != nil { log.Fatal(err) } if pErr := db.Put("aa", "1"); pErr != nil { panic(pErr) } result, pErr := db.Get("aa") if pErr != nil { panic(pErr) } fmt.Printf("aa=%s\n", result.ValueBytes()) // Output: // aa=1 }
// Read the balances in all the accounts and return them. func (bank *Bank) sumAllAccounts() int64 { var result int64 err := bank.db.Txn(func(txn *client.Txn) error { rows, err := txn.Scan(bank.makeAccountID(0), bank.makeAccountID(bank.numAccounts), int64(bank.numAccounts)) if err != nil { return err } if len(rows) != bank.numAccounts { return fmt.Errorf("Could only read %d of %d rows of the database.\n", len(rows), bank.numAccounts) } // Sum up the balances. for i := 0; i < bank.numAccounts; i++ { account := &Account{} err := account.decode(rows[i].ValueBytes()) if err != nil { return err } // fmt.Printf("Account %d contains %d$\n", bank.firstAccount+i, account.Balance) result += account.Balance } return nil }) if err != nil { log.Fatal(err) } return result }
func createTestClientFor(stopper *stop.Stopper, addr, user string) *client.DB { db, err := client.Open(stopper, "rpcs://"+user+"@"+addr+"?certs="+security.EmbeddedCertsDir) if err != nil { log.Fatal(err) } return db }
func ExampleDB_Insecure() { s := &server.TestServer{} s.Ctx = server.NewTestContext() s.Ctx.Insecure = true if err := s.Start(); err != nil { log.Fatalf("Could not start server: %v", err) } log.Infof("Test server listening on %s: %s", s.Ctx.RequestScheme(), s.ServingAddr()) defer s.Stop() db, err := client.Open("http://root@" + s.ServingAddr()) if err != nil { log.Fatal(err) } if err := db.Put("aa", "1"); err != nil { panic(err) } result, err := db.Get("aa") if err != nil { panic(err) } fmt.Printf("aa=%s\n", result.ValueBytes()) // Output: // aa=1 }