func TestMain(m *testing.M) { security.SetReadFileFn(securitytest.Asset) randutil.SeedForTests() serverutils.InitTestServerFactory(server.TestServerFactory) serverutils.InitTestClusterFactory(testcluster.TestClusterFactory) os.Exit(m.Run()) }
func TestQuit(t *testing.T) { defer leaktest.AfterTest(t)() c := newCLITest() c.Run("quit") // Wait until this async command stops the server. <-c.Stopper().IsStopped() // Manually run the cleanup functions. c.cleanupFunc() security.SetReadFileFn(securitytest.Asset) }
// maybeStartLocalServer will start a temporary local server if no database URL has been // provided. func maybeStartLocalServer() *server.TestServer { if *dbURL != "" { return nil } // Start a local test server. security.SetReadFileFn(securitytest.Asset) serv := server.StartTestServer(nil) *dbURL = "https://root@" + serv.ServingAddr() + "?certs=test_certs" return serv }
func main() { stopper := stop.NewStopper() defer stopper.Stop() fmt.Printf("A simple program that keeps moving money between bank accounts.\n\n") flag.Parse() if *numAccounts < 2 { fmt.Fprintf(os.Stderr, "At least two accounts are required to transfer money.\n") os.Exit(1) } if *numParallelTransfers < 1 { fmt.Fprintf(os.Stderr, "At least one transfer routine must be active.\n") os.Exit(1) } if !*useTransaction { fmt.Printf("Use of transactions has been disabled.\n") } // Initialize the bank. var bank Bank bank.firstAccount = *firstAccount bank.numAccounts = *numAccounts if *dbName == "" { // Run a test cockroach instance to represent the bank. security.SetReadFileFn(securitytest.Asset) serv := server.StartTestServer(nil) defer serv.Stop() *dbName = fmt.Sprintf("rpcs://%s@%s?certs=test_certs", security.NodeUser, serv.ServingAddr()) } // Create a database handle. db, err := client.Open(stopper, *dbName) if err != nil { log.Fatal(err) } bank.db = db // Initialize all the bank accounts. const initCash = 1000 totalCash := bank.initBankAccounts(initCash) // Start all the money transfer routines. for i := 0; i < *numParallelTransfers; i++ { // Keep transferring upto 10% of initCash between accounts. go bank.continuouslyTransferMoney(initCash / 10) } go bank.periodicallyReportStats() bank.periodicallyCheckBalances(totalCash) }
func main() { var dbDriver string flag.StringVar(&dbDriver, "db-driver", "cockroach", "database driver to use") var dbAddr string flag.StringVar(&dbAddr, "db-addr", "", "database address. defaults to ephemeral cockroach instance") numChannels := flag.Int("num-channels", 100, "number of channels") numWriters := flag.Int("num-writers", 2, "number of writers") flag.Parse() if dbAddr == "" { security.SetReadFileFn(securitytest.Asset) srv := server.StartTestServer(nil) defer srv.Stop() dbDriver = "cockroach" dbAddr = fmt.Sprintf("https://root@%s?certs=test_certs", srv.ServingAddr()) } db, err := sql.Open(dbDriver, dbAddr) if err != nil { log.Fatal(err) } if err := createTables(db); err != nil { log.Fatal(err) } var stats statistics var wg sync.WaitGroup for i := 0; i < *numWriters; i++ { wg.Add(1) w := writer{db, *numChannels, &wg, &stats} go w.run() } go stats.report() wg.Wait() }
func init() { security.SetReadFileFn(securitytest.Asset) }
func (c cliTest) stop() { c.cleanupFunc() security.SetReadFileFn(securitytest.Asset) c.Stop() }
func main() { flag.Parse() var db *sql.DB var err error var url string if *usePostgres { if db, err = sql.Open("postgres", "dbname=postgres sslmode=disable"); err != nil { log.Fatal(err) } } else { security.SetReadFileFn(securitytest.Asset) serv := server.StartTestServer(nil) defer serv.Stop() url = "https://root@" + serv.ServingAddr() + "?certs=test_certs" if db, err = sql.Open("cockroach", url); err != nil { log.Fatal(err) } } if _, err := db.Exec("CREATE DATABASE bank"); err != nil { if pqErr, ok := err.(*pq.Error); *usePostgres && (!ok || pqErr.Code.Name() != "duplicate_database") { log.Fatal(err) } } db.Close() // Open db client with database settings. if *usePostgres { if db, err = sql.Open("postgres", "dbname=bank sslmode=disable"); err != nil { log.Fatal(err) } } else { if db, err = sql.Open("cockroach", url+"&database=bank"); err != nil { log.Fatal(err) } } // concurrency + 1, for this thread and the "concurrency" number of // goroutines that move money db.SetMaxOpenConns(*concurrency + 1) if _, err = db.Exec("CREATE TABLE IF NOT EXISTS accounts (id BIGINT PRIMARY KEY, balance BIGINT NOT NULL)"); err != nil { log.Fatal(err) } if _, err = db.Exec("TRUNCATE TABLE accounts"); err != nil { log.Fatal(err) } for i := 0; i < *numAccounts; i++ { if _, err = db.Exec("INSERT INTO accounts (id, balance) VALUES ($1, $2)", i, 1000); err != nil { log.Fatal(err) } } verifyBank(db) lastNow := time.Now() readings := make(chan measurement, 10000) for i := 0; i < *concurrency; i++ { go moveMoney(db, readings) } for range time.NewTicker(*balanceCheckInterval).C { now := time.Now() elapsed := time.Since(lastNow) lastNow = now transfers := len(readings) log.Infof("%d transfers were executed at %.1f/second.", transfers, float64(transfers)/elapsed.Seconds()) if transfers > 0 { var aggr measurement for i := 0; i < transfers; i++ { reading := <-readings aggr.read += reading.read aggr.write += reading.write aggr.total += reading.total } d := time.Duration(transfers) log.Infof("read time: %v, write time: %v, txn time: %v", aggr.read/d, aggr.write/d, aggr.total/d) } verifyBank(db) } }
func init() { security.SetReadFileFn(securitytest.Asset) tracing.SetTestTracing() }
func main() { flag.Parse() var db *sql.DB var err error var url string if *usePostgres { if db, err = sql.Open("postgres", "dbname=postgres sslmode=disable"); err != nil { log.Fatal(err) } } else { security.SetReadFileFn(securitytest.Asset) serv := server.StartTestServer(nil) defer serv.Stop() url = "https://root@" + serv.ServingAddr() + "?certs=test_certs" if db, err = sql.Open("cockroach", url); err != nil { log.Fatal(err) } } if _, err := db.Exec("CREATE DATABASE bank"); err != nil { if pqErr, ok := err.(*pq.Error); *usePostgres && (!ok || pqErr.Code.Name() != "duplicate_database") { log.Fatal(err) } } db.Close() // Open db client with database settings. if *usePostgres { if db, err = sql.Open("postgres", "dbname=bank sslmode=disable"); err != nil { log.Fatal(err) } } else { if db, err = sql.Open("cockroach", url+"&database=bank"); err != nil { log.Fatal(err) } } // concurrency + 1, for this thread and the "concurrency" number of // goroutines that move money db.SetMaxOpenConns(*concurrency + 1) if _, err = db.Exec("CREATE TABLE IF NOT EXISTS accounts (id BIGINT PRIMARY KEY, balance BIGINT NOT NULL)"); err != nil { log.Fatal(err) } if _, err = db.Exec("TRUNCATE TABLE accounts"); err != nil { log.Fatal(err) } for i := 0; i < *numAccounts; i++ { if _, err = db.Exec("INSERT INTO accounts (id, balance) VALUES ($1, $2)", i, 0); err != nil { log.Fatal(err) } } verifyBank(db) var lastNumTransfers uint64 lastNow := time.Now() for i := 0; i < *concurrency; i++ { go moveMoney(db) } for range time.NewTicker(*balanceCheckInterval).C { now := time.Now() elapsed := time.Since(lastNow) numTransfers := atomic.LoadUint64(&numTransfers) log.Infof("%d transfers were executed at %.1f/second.", (numTransfers - lastNumTransfers), float64(numTransfers-lastNumTransfers)/elapsed.Seconds()) verifyBank(db) lastNumTransfers = numTransfers lastNow = now } }
func TestMain(m *testing.M) { security.SetReadFileFn(securitytest.Asset) serverutils.InitTestServerFactory(server.TestServerFactory) os.Exit(m.Run()) }
// ResetTest sets up the test environment. In particular, it embeds the // EmbeddedCertsDir folder and makes the tls package load from there. func ResetTest() { security.SetReadFileFn(securitytest.Asset) }
func main() { flag.Usage = usage flag.Parse() if flag.NArg() != 1 { usage() os.Exit(2) } mountpoint := flag.Arg(0) security.SetReadFileFn(securitytest.Asset) serv := server.StartTestServer(nil) defer serv.Stop() url := "https://root@" + serv.ServingAddr() + "?certs=test_certs" // Open DB connection first. db, err := sql.Open("cockroach", url) if err != nil { log.Fatal(err) } defer func() { _ = db.Close() }() if err := initSchema(db); err != nil { log.Fatal(err) } cfs := CFS{db} { // For testing only. if err := cfs.create(rootNodeID, "myfile", cfs.newFileNode()); err != nil { log.Fatal(err) } if err := cfs.create(rootNodeID, "mydir", cfs.newDirNode()); err != nil { log.Fatal(err) } results, err := cfs.list(0) if err != nil { log.Fatal(err) } log.Print(results) } // Mount filesystem. c, err := fuse.Mount( mountpoint, fuse.FSName("CockroachFS"), fuse.Subtype("CockroachFS"), fuse.LocalVolume(), fuse.VolumeName(""), ) if err != nil { log.Fatal(err) } defer func() { _ = c.Close() }() go func() { sig := make(chan os.Signal, 1) signal.Notify(sig, os.Interrupt) for range sig { if err := fuse.Unmount(mountpoint); err != nil { log.Printf("Signal received, but could not unmount: %s", err) } else { break } } }() // Serve root. err = fs.Serve(c, cfs) if err != nil { log.Fatal(err) } // check if the mount process has an error to report <-c.Ready if err := c.MountError; err != nil { log.Fatal(err) } }