func TestMultiplePutsGetsSequentially(t *testing.T) { const num_ops = 100 keyPrefix := "row3" headers := map[string][]string{"cf": nil} c := gohbase.NewClient(*host) err := performNPuts(keyPrefix, num_ops) if err != nil { t.Errorf("Put returned an error: %v", err) } for i := num_ops - 1; i >= 0; i-- { key := keyPrefix + fmt.Sprintf("%d", i) get, err := hrpc.NewGetStr(context.Background(), table, key, hrpc.Families(headers)) rsp, err := c.Get(get) if err != nil { t.Errorf("Get returned an error: %v", err) } if len(rsp.Result.Cell) != 1 { t.Errorf("Incorrect number of cells returned by Get: %d", len(rsp.Result.Cell)) } rsp_value := rsp.Result.Cell[0].GetValue() if !bytes.Equal(rsp_value, []byte(fmt.Sprintf("%d", i))) { t.Errorf("Get returned an incorrect result. Expected: %v, Got: %v", []byte(fmt.Sprintf("%d", i)), rsp_value) } } }
func TestCreateTable(t *testing.T) { testTableName := "test1_" + getTimestampString() t.Log("testTableName=" + testTableName) ac := gohbase.NewAdminClient(*host) crt := hrpc.NewCreateTable(context.Background(), []byte(testTableName), cFamilies) if err := ac.CreateTable(crt); err != nil { t.Errorf("CreateTable returned an error: %v", err) } // check in hbase:meta if there's a region for the table c := gohbase.NewClient(*host) metaKey := testTableName + ",," keyFilter := filter.NewPrefixFilter([]byte(metaKey)) scan, err := hrpc.NewScanStr(context.Background(), metaTableName, hrpc.Filters(keyFilter)) if err != nil { t.Fatalf("Failed to create Scan request: %s", err) } rsp, err := c.Scan(scan) if err != nil { t.Errorf("Scan returned an error: %v", err) } if len(rsp) != 1 { t.Errorf("Meta returned %s rows for prefix '%s' , want 1", len(rsp), metaKey) } }
func TestPutMultipleCells(t *testing.T) { key := "row2.5" values := map[string]map[string][]byte{"cf": map[string][]byte{}, "cf2": map[string][]byte{}} values["cf"]["a"] = []byte("a") values["cf"]["b"] = []byte("b") values["cf2"]["a"] = []byte("a") c := gohbase.NewClient(*host) putRequest, err := hrpc.NewPutStr(context.Background(), table, key, values) _, err = c.Put(putRequest) if err != nil { t.Errorf("Put returned an error: %v", err) } families := map[string][]string{"cf": nil, "cf2": nil} get, err := hrpc.NewGetStr(context.Background(), table, key, hrpc.Families(families)) rsp, err := c.Get(get) if err != nil { t.Errorf("Get returned an error: %v", err) } cells := rsp.GetResult().Cell if len(cells) != 3 { t.Errorf("Get expected 3 cells. Received: %d", len(cells)) } for _, cell := range cells { if !bytes.Equal(cell.GetQualifier(), cell.GetValue()) { t.Errorf("Get returned an incorrect result. Expected: %v, Received: %v", cell.GetQualifier(), cell.GetValue()) } } }
func TestGetMultipleCells(t *testing.T) { key := "row1.75" c := gohbase.NewClient(*host, gohbase.FlushInterval(time.Millisecond*2)) err := insertKeyValue(c, key, "cf", []byte("cf")) if err != nil { t.Errorf("Put returned an error: %v", err) } err = insertKeyValue(c, key, "cf2", []byte("cf2")) if err != nil { t.Errorf("Put returned an error: %v", err) } families := map[string][]string{"cf": nil, "cf2": nil} get, err := hrpc.NewGetStr(context.Background(), table, key, hrpc.Families(families)) rsp, err := c.Get(get) cells := rsp.GetResult().Cell num_results := len(cells) if num_results != 2 { t.Errorf("Get expected 2 cells. Received: %d", num_results) } for _, cell := range cells { if !bytes.Equal(cell.GetFamily(), cell.GetValue()) { t.Errorf("Get returned an incorrect result. Expected: %v, Received: %v", cell.GetFamily(), cell.GetValue()) } } }
func TestIncrement(t *testing.T) { c := gohbase.NewClient(*host) key := "row102" // test incerement incRequest, err := hrpc.NewIncStrSingle(context.Background(), table, key, "cf", "a", 1) result, err := c.Increment(incRequest) if err != nil { t.Fatalf("Increment returned an error: %v", err) } if result != 1 { t.Fatalf("Increment's result is %d, want 1", result) } incRequest, err = hrpc.NewIncStrSingle(context.Background(), table, key, "cf", "a", 5) result, err = c.Increment(incRequest) if err != nil { t.Fatalf("Increment returned an error: %v", err) } if result != 6 { t.Fatalf("Increment's result is %d, want 6", result) } }
// Note: This function currently causes an infinite loop in the client throwing the error - // 2015/06/19 14:34:11 Encountered an error while reading: Failed to read from the RS: EOF func TestChangingRegionServers(t *testing.T) { key := "row8" val := []byte("1") headers := map[string][]string{"cf": nil} if host == nil { t.Fatal("Host is not set!") } c := gohbase.NewClient(*host) err := insertKeyValue(c, key, "cf", val) if err != nil { t.Errorf("Put returned an error: %v", err) } // RegionServer 1 hosts all the current regions. // Now launch servers 2,3 test.LaunchRegionServers([]string{"2", "3"}) // Now (gracefully) stop servers 1,2. // All regions should now be on server 3. test.StopRegionServers([]string{"1", "2"}) get, err := hrpc.NewGetStr(context.Background(), table, key, hrpc.Families(headers)) rsp, err := c.Get(get) if err != nil { t.Errorf("Get returned an error: %v", err) } rsp_value := rsp.Result.Cell[0].GetValue() if !bytes.Equal(rsp_value, val) { t.Errorf("Get returned an incorrect result. Expected: %v, Received: %v", val, rsp_value) } // Clean up by re-launching RS1 and closing RS3 test.LaunchRegionServers([]string{"1"}) test.StopRegionServers([]string{"3"}) }
func TestDeleteTimestamp(t *testing.T) { key := "TestDeleteTimestamp" c := gohbase.NewClient(*host) var putTs uint64 = 50 timestamp := time.Unix(0, int64(putTs*1e6)) err := insertKeyValue(c, key, "cf", []byte("1"), hrpc.Timestamp(timestamp)) if err != nil { t.Fatalf("Put failed: %s", err) } deleteRequest, err := hrpc.NewDelStr(context.Background(), table, key, map[string]map[string][]byte{"cf": map[string][]byte{"a": nil}}, hrpc.Timestamp(timestamp)) _, err = c.Delete(deleteRequest) if err != nil { t.Fatalf("Delete failed: %s", err) } get, err := hrpc.NewGetStr(context.Background(), table, key, hrpc.Families(map[string][]string{"cf": nil})) rsp, err := c.Get(get) if err != nil { t.Fatalf("Get failed: %s", err) } if len(rsp.Cells) != 0 { t.Errorf("Timestamp wasn't deleted, get result length: %d", len(rsp.Cells)) } }
func main() { client := gohbase.NewClient(*zkquorum) err := client.CheckTable(context.Background(), "aeris") if err != nil { log.Fatalf("Fail: %s", err) } log.Printf("get returned") }
func TestGetTimeRangeVersions(t *testing.T) { key := "TestGetTimeRangeVersions" c := gohbase.NewClient(*host) err := insertKeyValue(c, key, "cf", []byte("1"), hrpc.Timestamp(time.Unix(0, 50*1e6))) if err != nil { t.Fatalf("Put failed: %s", err) } err = insertKeyValue(c, key, "cf", []byte("1"), hrpc.Timestamp(time.Unix(0, 51*1e6))) if err != nil { t.Fatalf("Put failed: %s", err) } err = insertKeyValue(c, key, "cf", []byte("1"), hrpc.Timestamp(time.Unix(0, 49*1e6))) if err != nil { t.Fatalf("Put failed: %s", err) } var maxVersions uint32 = 2 get, err := hrpc.NewGetStr(context.Background(), table, key, hrpc.Families(map[string][]string{"cf": nil}), hrpc.TimeRange(time.Unix(0, 0), time.Unix(0, 51*1e6)), hrpc.MaxVersions(maxVersions)) rsp, err := c.Get(get) if err != nil { t.Fatalf("Get failed: %s", err) } if uint32(len(rsp.Cells)) != maxVersions { t.Fatalf("Expected versions: %d, Got versions: %d", maxVersions, len(rsp.Cells)) } getTs1 := *rsp.Cells[0].Timestamp if getTs1 != 50 { t.Errorf("Timestamps are not the same. Expected Time: %v, Got Time: %v", 50, getTs1) } getTs2 := *rsp.Cells[1].Timestamp if getTs2 != 49 { t.Errorf("Timestamps are not the same. Expected Time: %v, Got Time: %v", 49, getTs2) } // get with no versions set get, err = hrpc.NewGetStr(context.Background(), table, key, hrpc.Families(map[string][]string{"cf": nil}), hrpc.TimeRange(time.Unix(0, 0), time.Unix(0, 51*1e6))) rsp, err = c.Get(get) if err != nil { t.Fatalf("Get failed: %s", err) } if uint32(len(rsp.Cells)) != 1 { t.Fatalf("Expected versions: %d, Got versions: %d", 1, len(rsp.Cells)) } getTs1 = *rsp.Cells[0].Timestamp if getTs1 != 50 { t.Errorf("Timestamps are not the same. Expected Time: %v, Got Time: %v", 50, getTs1) } }
// Helper function. Given a key_prefix, num_ops, performs num_ops. func performNPuts(keyPrefix string, num_ops int) error { c := gohbase.NewClient(*host) for i := 0; i < num_ops; i++ { key := keyPrefix + fmt.Sprintf("%d", i) err := insertKeyValue(c, key, "cf", []byte(fmt.Sprintf("%d", i))) if err != nil { return err } } return nil }
func TestCheckAndPutNotPut(t *testing.T) { key := "row101" c := gohbase.NewClient(*host) values := map[string]map[string][]byte{"cf": map[string][]byte{"a": []byte("lol")}} appRequest, err := hrpc.NewAppStr(context.Background(), table, key, values) _, err = c.CheckAndPut(appRequest, "cf", "a", []byte{}) if err == nil { t.Error("CheckAndPut: should not allow anything but Put request") } }
func testTsunaHbaseClientStablity(concurrency, interval int) { client := gohbase.NewClient("172.16.13.94:2181,172.16.13.94:2182,172.16.13.94:2183") st := time.Now().Unix() // actions := []string{"get",} actions := []string{"get", "put", "delete"} res := map[string]map[string]*int64{} for _, action := range actions { total, failed := int64(0), int64(0) res[action] = map[string]*int64{ "total": &total, "failed": &failed, } } wg := &sync.WaitGroup{} wg.Add(concurrency) failCount := make([]int, concurrency) for j := 0; j < concurrency; j++ { go func(seq int) { defer wg.Done() for { actionIndex, _ := IntRange(0, len(actions)) action := actions[actionIndex] atomic.AddInt64(res[action]["total"], 1) err := doTest(client, action) if err != nil { atomic.AddInt64(res[action]["failed"], 1) // return } if interval > 0 { time.Sleep(time.Duration(int64(interval)) * time.Millisecond) } // fmt.Printf("getRes is %v", getRes) } }(j) } go func() { for { time.Sleep(10 * time.Second) for action, actionRes := range res { fmt.Printf("action %s total %d failed %d\n", action, *actionRes["total"], *actionRes["failed"]) } } }() wg.Wait() failCountSum := 0 for _, curFailCount := range failCount { failCountSum += curFailCount } et := time.Now().Unix() fmt.Printf("cost: %d, total: %d, failed: %d\n", et-st, 1, failCountSum) }
func TestCheckAndPut(t *testing.T) { c := gohbase.NewClient(*host) key := "row100" ef := "cf" eq := "a" var castests = []struct { inValues map[string]map[string][]byte inExpectedValue []byte out bool }{ {map[string]map[string][]byte{"cf": map[string][]byte{"b": []byte("2")}}, nil, true}, // nil instead of empty byte array {map[string]map[string][]byte{"cf": map[string][]byte{"a": []byte("1")}}, []byte{}, true}, {map[string]map[string][]byte{"cf": map[string][]byte{"a": []byte("1")}}, []byte{}, false}, {map[string]map[string][]byte{"cf": map[string][]byte{"a": []byte("2")}}, []byte("1"), true}, {map[string]map[string][]byte{"cf": map[string][]byte{"b": []byte("2")}}, []byte("2"), true}, // put diff column {map[string]map[string][]byte{"cf": map[string][]byte{"b": []byte("2")}}, []byte{}, false}, // diff column {map[string]map[string][]byte{"cf": map[string][]byte{ "b": []byte("100"), "a": []byte("100"), }}, []byte("2"), true}, // multiple values } for _, tt := range castests { putRequest, err := hrpc.NewPutStr(context.Background(), table, key, tt.inValues) if err != nil { t.Fatalf("NewPutStr returned an error: %v", err) } casRes, err := c.CheckAndPut(putRequest, ef, eq, tt.inExpectedValue) if err != nil { t.Fatalf("CheckAndPut error: %s", err) } if casRes != tt.out { t.Errorf("CheckAndPut with put values=%q and expectedValue=%q returned %v, want %v", tt.inValues, tt.inExpectedValue, casRes, tt.out) } } // TODO: check the resulting state by performing a Get request }
func BenchmarkGet(b *testing.B) { b.ReportAllocs() keyPrefix := "row10" err := performNPuts(keyPrefix, b.N) if err != nil { b.Errorf("Put returned an error: %v", err) } c := gohbase.NewClient(*host) b.ResetTimer() headers := map[string][]string{"cf": nil} for i := 0; i < b.N; i++ { key := keyPrefix + fmt.Sprintf("%d", i) get, _ := hrpc.NewGetStr(context.Background(), table, key, hrpc.Families(headers)) c.Get(get) } }
func TestGetBadColumnFamily(t *testing.T) { key := "row1.625" c := gohbase.NewClient(*host) err := insertKeyValue(c, key, "cf", []byte("Bad!")) if err != nil { t.Errorf("Put returned an error: %v", err) } families := map[string][]string{"badcf": nil} get, err := hrpc.NewGetStr(context.Background(), table, key, hrpc.Families(families)) rsp, err := c.Get(get) if err == nil { t.Errorf("Get didn't return an error! (It should have)") } if rsp.GetResult() != nil { t.Errorf("Get expected no result. Received: %v", rsp.GetResult()) } }
func TestCheckAndPutParallel(t *testing.T) { c := gohbase.NewClient(*host) keyPrefix := "row100.5" // TODO: Currently have to CheckTable before initiating the requests // otherwise we face runaway client generation - one for each request. c.CheckTable(context.Background(), table) values := map[string]map[string][]byte{"cf": map[string][]byte{"a": []byte("1")}} capTestFunc := func(p *hrpc.Mutate, ch chan bool) { casRes, err := c.CheckAndPut(p, "cf", "a", []byte{}) if err != nil { t.Errorf("CheckAndPut error: %s", err) } ch <- casRes } // make 10 pairs of CheckAndPut requests for i := 0; i < 10; i++ { ch := make(chan bool, 2) putRequest1, err := hrpc.NewPutStr(context.Background(), table, keyPrefix+string(i), values) if err != nil { t.Fatalf("NewPutStr returned an error: %v", err) } putRequest2, err := hrpc.NewPutStr(context.Background(), table, keyPrefix+string(i), values) if err != nil { t.Fatalf("NewPutStr returned an error: %v", err) } go capTestFunc(putRequest1, ch) go capTestFunc(putRequest2, ch) first := <-ch second := <-ch if first && second { t.Error("CheckAndPut: both requests cannot succeed") } if !first && !second { t.Error("CheckAndPut: both requests cannot fail") } } }
func TestGet(t *testing.T) { key := "row1" val := []byte("1") headers := map[string][]string{"cf": nil} if host == nil { t.Fatal("Host is not set!") } c := gohbase.NewClient(*host) err := insertKeyValue(c, key, "cf", val) if err != nil { t.Errorf("Put returned an error: %v", err) } get, err := hrpc.NewGetStr(context.Background(), table, key, hrpc.Families(headers)) if err != nil { t.Fatalf("Failed to create Get request: %s", err) } rsp, err := c.Get(get) if err != nil { t.Errorf("Get returned an error: %v", err) } rsp_value := rsp.Result.Cell[0].GetValue() if !bytes.Equal(rsp_value, val) { t.Errorf("Get returned an incorrect result. Expected: %v, Got: %v", val, rsp_value) } get.ExistsOnly() rsp, err = c.Get(get) if err != nil { t.Errorf("Get returned an error: %v", err) } else if !*rsp.Result.Exists { t.Error("Get claimed that our row didn't exist") } ctx, _ := context.WithTimeout(context.Background(), 0) get, err = hrpc.NewGetStr(ctx, table, key, hrpc.Families(headers)) if err != nil { t.Fatalf("Failed to create Get request: %s", err) } _, err = c.Get(get) if err != gohbase.ErrDeadline { t.Errorf("Get ignored the deadline") } }
// DeleteTable finds the HBase shell via the HBASE_HOME environment variable, // and disables and drops the given table func DeleteTable(host, table string) error { // TODO: We leak this client. ac := gohbase.NewClient(host, gohbase.Admin()) dit := hrpc.NewDisableTable(context.Background(), []byte(table)) _, err := ac.SendRPC(dit) if err != nil { if !strings.Contains(err.Error(), "TableNotEnabledException") { return err } } det := hrpc.NewDeleteTable(context.Background(), []byte(table)) _, err = ac.SendRPC(det) if err != nil { return err } return nil }
func TestGetDoesntExist(t *testing.T) { key := "row1.5" c := gohbase.NewClient(*host) headers := map[string][]string{"cf": nil} get, err := hrpc.NewGetStr(context.Background(), table, key, hrpc.Families(headers)) rsp, err := c.Get(get) if err != nil { t.Errorf("Get returned an error: %v", err) } else if results := len(rsp.GetResult().Cell); results != 0 { t.Errorf("Get expected 0 cells. Received: %d", results) } get.ExistsOnly() rsp, err = c.Get(get) if err != nil { t.Errorf("Get returned an error: %v", err) } else if *rsp.Result.Exists { t.Error("Get claimed that our non-existent row exists") } }
func TestPut(t *testing.T) { key := "row2" values := map[string]map[string][]byte{"cf": map[string][]byte{"a": []byte("1")}} if host == nil { t.Fatal("Host is not set!") } c := gohbase.NewClient(*host) putRequest, err := hrpc.NewPutStr(context.Background(), table, key, values) _, err = c.Put(putRequest) if err != nil { t.Errorf("Put returned an error: %v", err) } ctx, _ := context.WithTimeout(context.Background(), 0) putRequest, err = hrpc.NewPutStr(ctx, table, key, values) _, err = c.Put(putRequest) if err != gohbase.ErrDeadline { t.Errorf("Put ignored the deadline") } }
func TestPutTimestamp(t *testing.T) { key := "TestPutTimestamp" c := gohbase.NewClient(*host) var putTs uint64 = 50 timestamp := time.Unix(0, int64(putTs*1e6)) err := insertKeyValue(c, key, "cf", []byte("1"), hrpc.Timestamp(timestamp)) if err != nil { t.Fatalf("Put failed: %s", err) } get, err := hrpc.NewGetStr(context.Background(), table, key, hrpc.Families(map[string][]string{"cf": nil})) rsp, err := c.Get(get) if err != nil { t.Fatalf("Get failed: %s", err) } getTs := *rsp.Cells[0].Timestamp if getTs != putTs { t.Errorf("Timestamps are not the same. Put Time: %v, Get Time: %v", putTs, getTs) } }
func TestAppend(t *testing.T) { key := "row7" c := gohbase.NewClient(*host) // Inserting "Hello" insertErr := insertKeyValue(c, key, "cf", []byte("Hello")) if insertErr != nil { t.Errorf("Put returned an error: %v", insertErr) } // Appending " my name is Dog." values := map[string]map[string][]byte{"cf": map[string][]byte{}} values["cf"]["a"] = []byte(" my name is Dog.") appRequest, err := hrpc.NewAppStr(context.Background(), table, key, values) appRsp, err := c.Append(appRequest) if err != nil { t.Errorf("Append returned an error: %v", err) } if appRsp.GetResult() == nil { t.Errorf("Append doesn't return updated value.") } // Verifying new result is "Hello my name is Dog." result := appRsp.GetResult().Cell[0].GetValue() if !bytes.Equal([]byte("Hello my name is Dog."), result) { t.Errorf("Append returned an incorrect result. Expected: %v, Receieved: %v", []byte("Hello my name is Dog."), result) } // Make sure the change was actually committed. headers := map[string][]string{"cf": nil} get, err := hrpc.NewGetStr(context.Background(), table, key, hrpc.Families(headers)) rsp, err := c.Get(get) cells := rsp.GetResult().Cell if len(cells) != 1 { t.Errorf("Get expected 1 cells. Received: %d", len(cells)) } result = cells[0].GetValue() if !bytes.Equal([]byte("Hello my name is Dog."), result) { t.Errorf("Append returned an incorrect result. Expected: %v, Receieved: %v", []byte("Hello my name is Dog."), result) } }
func TestMultiplePutsGetsParallel(t *testing.T) { const num_ops = 1000 keyPrefix := "row3.5" headers := map[string][]string{"cf": nil} c := gohbase.NewClient(*host) // TODO: Currently have to CheckTable before initiating the N requests // otherwise we face runaway client generation - one for each request. c.CheckTable(context.Background(), table) var wg sync.WaitGroup for i := 0; i < num_ops; i++ { wg.Add(1) go func(client *gohbase.Client, key string) { defer wg.Done() err := insertKeyValue(client, key, "cf", []byte(key)) if err != nil { t.Errorf("(Parallel) Put returned an error: %v", err) } }(c, keyPrefix+fmt.Sprintf("%d", i)) } wg.Wait() // All puts are complete. Now do the same for gets. for i := num_ops - 1; i >= 0; i-- { wg.Add(1) go func(client *gohbase.Client, key string) { defer wg.Done() get, err := hrpc.NewGetStr(context.Background(), table, key, hrpc.Families(headers)) rsp, err := c.Get(get) if err != nil { t.Errorf("(Parallel) Get returned an error: %v", err) } else { rsp_value := rsp.Result.Cell[0].GetValue() if !bytes.Equal(rsp_value, []byte(key)) { t.Errorf("Get returned an incorrect result.") } } }(c, keyPrefix+fmt.Sprintf("%d", i)) } wg.Wait() }
func TestTimestampIncreasing(t *testing.T) { key := "row4" c := gohbase.NewClient(*host) var oldTime uint64 = 0 headers := map[string][]string{"cf": nil} for i := 0; i < 10; i++ { insertKeyValue(c, key, "cf", []byte("1")) get, err := hrpc.NewGetStr(context.Background(), table, key, hrpc.Families(headers)) rsp, err := c.Get(get) if err != nil { t.Errorf("Get returned an error: %v", err) break } newTime := rsp.GetResult().Cell[0].GetTimestamp() if newTime <= oldTime { t.Errorf("Timestamps are not increasing. Old Time: %v, New Time: %v", oldTime, newTime) } oldTime = newTime time.Sleep(time.Millisecond) } }
func main() { client := gohbase.NewClient("localhost", gohbase.RpcQueueSize(1), gohbase.FlushInterval(time.Nanosecond)) t := time.Now() for i := 0; i < 100; i++ { // Values maps a ColumnFamily -> Qualifiers -> Values. values := map[string]map[string][]byte{"cf": map[string][]byte{"ab": []byte("kmztest")}} putRequest, err := hrpc.NewPutStr(context.Background(), "test", "key"+strconv.Itoa(i), values) checkErr(err) _, err = client.Put(putRequest) checkErr(err) } fmt.Println(float64(time.Now().UnixNano()-t.UnixNano()) / 1000000) fmt.Println("=====================") getRequest, err := hrpc.NewGetStr(context.Background(), "test", "row") checkErr(err) getRsp, err := client.Get(getRequest) checkErr(err) fmt.Println(getRsp) }
func testTsunaHbaseClient(concurrency, eachCount int) { client := gohbase.NewClient("172.16.13.94:2181,172.16.13.94:2182,172.16.13.94:2183") getReq, err := hrpc.NewGetStr(context.Background(), "t", "10001") if err != nil { fmt.Printf("hrpc.NewGetStr failed, err is %v", err) return } st := time.Now().Unix() wg := &sync.WaitGroup{} wg.Add(concurrency) failCount := make([]int, concurrency) for j := 0; j < concurrency; j++ { go func(seq int) { curFailCount := 0 defer wg.Done() for i := 0; i < eachCount; i++ { getRes, err := client.Get(getReq) if err != nil { fmt.Printf("client.Get failed, err is %v", err) curFailCount += 1 // return } // fmt.Printf("getRes is %v", getRes) _ = getRes } failCount[seq] = curFailCount }(j) } wg.Wait() failCountSum := 0 for _, curFailCount := range failCount { failCountSum += curFailCount } et := time.Now().Unix() fmt.Printf("cost: %d, total: %d, failed: %d\n", et-st, concurrency*eachCount, failCountSum) }
func TestIncrementParallel(t *testing.T) { c := gohbase.NewClient(*host) key := "row102.5" // TODO: Currently have to CheckTable before initiating N requests // otherwise we face runaway client generation - one for each request. c.CheckTable(context.Background(), table) numParallel := 10 // test incerement var wg sync.WaitGroup for i := 0; i < numParallel; i++ { wg.Add(1) go func() { defer wg.Done() incRequest, err := hrpc.NewIncStrSingle(context.Background(), table, key, "cf", "a", 1) _, err = c.Increment(incRequest) if err != nil { t.Errorf("Increment returned an error: %v", err) } }() } wg.Wait() // do one more to check if there's a correct value incRequest, err := hrpc.NewIncStrSingle(context.Background(), table, key, "cf", "a", 1) result, err := c.Increment(incRequest) if err != nil { t.Fatalf("Increment returned an error: %v", err) } if result != int64(numParallel+1) { t.Fatalf("Increment's result is %d, want %d", result, numParallel+1) } }
func TestPutReflection(t *testing.T) { key := "row2.25" number := 150 data := struct { AnInt int `hbase:"cf:a"` AnInt8 int8 `hbase:"cf:b"` AnInt16 int16 `hbase:"cf:c"` AnInt32 int32 `hbase:"cf:d"` AnInt64 int64 `hbase:"cf:e"` AnUInt uint `hbase:"cf:f"` AnUInt8 uint8 `hbase:"cf:g"` AnUInt16 uint16 `hbase:"cf:h"` AnUInt32 uint32 `hbase:"cf:i"` AnUInt64 uint64 `hbase:"cf:j"` AFloat32 float32 `hbase:"cf:k"` AFloat64 float64 `hbase:"cf:l"` AComplex64 complex64 `hbase:"cf:m"` AComplex128 complex128 `hbase:"cf:n"` APointer *int `hbase:"cf:o"` AnArray [6]uint8 `hbase:"cf:p"` ASlice []uint8 `hbase:"cf:q"` AString string `hbase:"cf:r"` }{ AnInt: 10, AnInt8: 20, AnInt16: 30, AnInt32: 40, AnInt64: 50, AnUInt: 60, AnUInt8: 70, AnUInt16: 80, AnUInt32: 90, AnUInt64: 100, AFloat32: 110, AFloat64: 120, AComplex64: 130, AComplex128: 140, APointer: &number, AnArray: [6]uint8{4, 8, 15, 26, 23, 42}, ASlice: []uint8{1, 1, 3, 5, 8, 13, 21, 34, 55}, AString: "This is a test string.", } if host == nil { t.Fatal("Host is not set!") } c := gohbase.NewClient(*host) putRequest, err := hrpc.NewPutStrRef(context.Background(), table, key, data) if err != nil { t.Errorf("NewPutStrRef returned an error: %v", err) } _, err = c.Put(putRequest) if err != nil { t.Errorf("Put returned an error: %v", err) } headers := map[string][]string{"cf": nil} get, err := hrpc.NewGetStr(context.Background(), table, key, hrpc.Families(headers)) if err != nil { t.Fatalf("Failed to create Get request: %s", err) } rsp, err := c.Get(get) if err != nil { t.Errorf("Get returned an error: %v", err) } expected := map[string][]byte{ "a": []byte{10}, "b": []byte{20}, "c": []byte{30, 0}, "d": []byte{40, 0, 0, 0}, "e": []byte{50, 0, 0, 0, 0, 0, 0, 0}, "f": []byte{60}, "g": []byte{70}, "h": []byte{80, 0}, "i": []byte{90, 0, 0, 0}, "j": []byte{100, 0, 0, 0, 0, 0, 0, 0}, "k": []byte{0, 0, 220, 66}, "l": []byte{0, 0, 0, 0, 0, 0, 94, 64}, "m": []byte{0, 0, 2, 67, 0, 0, 0, 0}, "n": []byte{0, 0, 0, 0, 0, 128, 97, 64, 0, 0, 0, 0, 0, 0, 0, 0}, "o": []byte{150}, "p": []byte{4, 8, 15, 26, 23, 42}, "q": []byte{1, 1, 3, 5, 8, 13, 21, 34, 55}, "r": []byte("This is a test string."), } for _, cell := range rsp.Cells { want, ok := expected[string(cell.Qualifier)] if !ok { t.Errorf("Unexpected qualifier: %q in %#v", cell.Qualifier, rsp) } else if !bytes.Equal(cell.Value, want) { t.Errorf("qualifier %q didn't match: wanted %q, but got %q", cell.Qualifier, want, cell.Value) } } }
func TestScanTimeRangeVersions(t *testing.T) { key := "TestScanTimeRangeVersions" c := gohbase.NewClient(*host) err := insertKeyValue(c, key+"1", "cf", []byte("1"), hrpc.Timestamp(time.Unix(0, 50*1e6))) if err != nil { t.Fatalf("Put failed: %s", err) } err = insertKeyValue(c, key+"1", "cf", []byte("1"), hrpc.Timestamp(time.Unix(0, 51*1e6))) if err != nil { t.Fatalf("Put failed: %s", err) } err = insertKeyValue(c, key+"2", "cf", []byte("1"), hrpc.Timestamp(time.Unix(0, 51*1e6))) if err != nil { t.Fatalf("Put failed: %s", err) } err = insertKeyValue(c, key+"2", "cf", []byte("1"), hrpc.Timestamp(time.Unix(0, 52*1e6))) if err != nil { t.Fatalf("Put failed: %s", err) } var maxVersions uint32 = 2 scan, err := hrpc.NewScanRangeStr(context.Background(), table, "TestScanTimeRangeVersions1", "TestScanTimeRangeVersions3", hrpc.Families(map[string][]string{"cf": nil}), hrpc.TimeRange(time.Unix(0, 50*1e6), time.Unix(0, 53*1e6)), hrpc.MaxVersions(maxVersions)) if err != nil { t.Fatalf("Scan req failed: %s", err) } rsp, err := c.Scan(scan) if err != nil { t.Fatalf("Scan failed: %s", err) } if len(rsp) != 2 { t.Fatalf("Expected rows: %d, Got rows: %d", maxVersions, len(rsp)) } if uint32(len(rsp[0].Cells)) != maxVersions { t.Fatalf("Expected versions: %d, Got versions: %d", maxVersions, len(rsp[0].Cells)) } scan1 := *rsp[0].Cells[0] if string(scan1.Row) != "TestScanTimeRangeVersions1" && *scan1.Timestamp != 51 { t.Errorf("Timestamps are not the same. Expected Time: %v, Got Time: %v", 51, *scan1.Timestamp) } scan2 := *rsp[0].Cells[1] if string(scan2.Row) != "TestScanTimeRangeVersions1" && *scan2.Timestamp != 50 { t.Errorf("Timestamps are not the same. Expected Time: %v, Got Time: %v", 50, *scan2.Timestamp) } if uint32(len(rsp[1].Cells)) != maxVersions { t.Fatalf("Expected versions: %d, Got versions: %d", maxVersions, len(rsp[1].Cells)) } scan3 := *rsp[1].Cells[0] if string(scan3.Row) != "TestScanTimeRangeVersions2" && *scan3.Timestamp != 52 { t.Errorf("Timestamps are not the same. Expected Time: %v, Got Time: %v", 52, *scan3.Timestamp) } scan4 := *rsp[1].Cells[1] if string(scan4.Row) != "TestScanTimeRangeVersions2" && *scan4.Timestamp != 51 { t.Errorf("Timestamps are not the same. Expected Time: %v, Got Time: %v", 51, *scan4.Timestamp) } // scan with no versions set scan, err = hrpc.NewScanRangeStr(context.Background(), table, "TestScanTimeRangeVersions1", "TestScanTimeRangeVersions3", hrpc.Families(map[string][]string{"cf": nil}), hrpc.TimeRange(time.Unix(0, 50*1e6), time.Unix(0, 53*1e6))) if err != nil { t.Fatalf("Scan req failed: %s", err) } rsp, err = c.Scan(scan) if err != nil { t.Fatalf("Scan failed: %s", err) } if len(rsp) != 2 { t.Fatalf("Expected rows: %d, Got rows: %d", 2, len(rsp)) } if len(rsp[0].Cells) != 1 { t.Fatalf("Expected versions: %d, Got versions: %d", 2, len(rsp[0].Cells)) } if len(rsp[1].Cells) != 1 { t.Fatalf("Expected versions: %d, Got versions: %d", 2, len(rsp[0].Cells)) } }