func getAdminClient() *bigtable.AdminClient { if adminClient == nil { var err error adminClient, err = bigtable.NewAdminClient(context.Background(), config.Project, config.Zone, config.Cluster) if err != nil { log.Fatalf("Making bigtable.AdminClient: %v", err) } } return adminClient }
func main() { flag.Parse() if *tableName == prototypeTableName { log.Fatal("Can't use " + prototypeTableName + " as your table.") } // Let the library get credentials from file. os.Setenv("GOOGLE_APPLICATION_CREDENTIALS", *credFile) // Make an admin client. var err error if adminClient, err = bigtable.NewAdminClient(context.Background(), *project, *zone, *cluster); err != nil { log.Fatal("Bigtable NewAdminClient:", err) } // Make a regular client. client, err = bigtable.NewClient(context.Background(), *project, *zone, *cluster) if err != nil { log.Fatal("Bigtable NewClient:", err) } // Open the table. table = client.Open(*tableName) // Rebuild the table if the command-line flag is set. if *rebuild { if err := rebuildTable(); err != nil { log.Fatal(err) } } // Set up HTML handlers, and start the web server. http.HandleFunc("/search", handleSearch) http.HandleFunc("/content", handleContent) http.HandleFunc("/add", handleAddDoc) http.HandleFunc("/clearindex", handleClear) http.HandleFunc("/", handleMain) log.Fatal(http.ListenAndServe(":8080", nil)) }
func main() { ctx := context.Background() // Set up admin client, tables, and column families. // NewAdminClient uses Application Default Credentials to authenticate. adminClient, err := bigtable.NewAdminClient(ctx, project, zone, cluster) if err != nil { log.Fatalf("Unable to create a table admin client. %v", err) } tables, err := adminClient.Tables(ctx) if err != nil { log.Fatalf("Unable to fetch table list. %v", err) } if !sliceContains(tables, tableName) { if err := adminClient.CreateTable(ctx, tableName); err != nil { log.Fatalf("Unable to create table: %v. %v", tableName, err) } } tblInfo, err := adminClient.TableInfo(ctx, tableName) if err != nil { log.Fatalf("Unable to read info for table: %v. %v", tableName, err) } if !sliceContains(tblInfo.Families, familyName) { if err := adminClient.CreateColumnFamily(ctx, tableName, familyName); err != nil { log.Fatalf("Unable to create column family: %v. %v", familyName, err) } } adminClient.Close() // Set up Bigtable data operations client. // NewClient uses Application Default Credentials to authenticate. client, err = bigtable.NewClient(ctx, project, zone, cluster) if err != nil { log.Fatalf("Unable to create data operations client. %v", err) } http.Handle("/", appHandler(mainHandler)) appengine.Main() // Never returns. }
func main() { var err error config, err = cbtrc.Load() if err != nil { log.Fatal(err) } config.RegisterFlags() flag.Parse() if err := config.CheckFlags(); err != nil { log.Fatal(err) } if config.Creds != "" { os.Setenv("GOOGLE_APPLICATION_CREDENTIALS", config.Creds) } if flag.NArg() != 0 { flag.Usage() os.Exit(1) } log.Printf("Dialing connections...") client, err = bigtable.NewClient(context.Background(), config.Project, config.Zone, config.Cluster) if err != nil { log.Fatalf("Making bigtable.Client: %v", err) } defer client.Close() adminClient, err = bigtable.NewAdminClient(context.Background(), config.Project, config.Zone, config.Cluster) if err != nil { log.Fatalf("Making bigtable.AdminClient: %v", err) } defer adminClient.Close() // Create a scratch table. log.Printf("Setting up scratch table...") if err := adminClient.CreateTable(context.Background(), *scratchTable); err != nil { log.Fatalf("Making scratch table %q: %v", *scratchTable, err) } if err := adminClient.CreateColumnFamily(context.Background(), *scratchTable, "f"); err != nil { log.Fatalf("Making scratch table column family: %v", err) } // Upon a successful run, delete the table. Don't bother checking for errors. defer adminClient.DeleteTable(context.Background(), *scratchTable) log.Printf("Starting load test... (run for %v)", *runFor) tbl := client.Open(*scratchTable) sem := make(chan int, 100) // limit the number of requests happening at once var reads, writes stats stopTime := time.Now().Add(*runFor) var wg sync.WaitGroup for time.Now().Before(stopTime) { sem <- 1 wg.Add(1) go func() { defer wg.Done() defer func() { <-sem }() ok := true opStart := time.Now() var stats *stats defer func() { stats.Record(ok, time.Since(opStart)) }() row := fmt.Sprintf("row%d", rand.Intn(100)) // operate on 1 of 100 rows switch rand.Intn(10) { default: // read stats = &reads _, err := tbl.ReadRow(context.Background(), row, bigtable.RowFilter(bigtable.LatestNFilter(1))) if err != nil { log.Printf("Error doing read: %v", err) ok = false } case 0, 1, 2, 3, 4: // write stats = &writes mut := bigtable.NewMutation() mut.Set("f", "col", bigtable.Now(), bytes.Repeat([]byte("0"), 1<<10)) // 1 KB write if err := tbl.Apply(context.Background(), row, mut); err != nil { log.Printf("Error doing mutation: %v", err) ok = false } } }() } wg.Wait() log.Printf("Reads (%d ok / %d tries):\n%v", reads.ok, reads.tries, newAggregate(reads.ds)) log.Printf("Writes (%d ok / %d tries):\n%v", writes.ok, writes.tries, newAggregate(writes.ds)) }