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))
}
}
