// This is an example for using the Call() method to Put and then Get
// a value for a given key.
func ExampleKV_Call() {
// Using built-in test server for this example code.
serv := StartTestServer(nil)
defer serv.Stop()
// Replace with actual host:port address string (ex "localhost:8080") for server cluster.
serverAddress := serv.HTTPAddr
// Key Value Client initialization.
sender := client.NewHTTPSender(serverAddress, &http.Transport{
TLSClientConfig: rpc.LoadInsecureTLSConfig().Config(),
})
kvClient := client.NewKV(sender, nil)
kvClient.User = storage.UserRoot
defer kvClient.Close()
key := proto.Key("a")
value := []byte{1, 2, 3, 4}
// Store test value.
putResp := &proto.PutResponse{}
if err := kvClient.Call(proto.Put, proto.PutArgs(key, value), putResp); err != nil {
log.Fatal(err)
}
// Retrieve test value using same key.
getResp := &proto.GetResponse{}
if err := kvClient.Call(proto.Get, proto.GetArgs(key), getResp); err != nil {
log.Fatal(err)
}
// Data validation.
if getResp.Value == nil {
log.Fatal("No value returned.")
}
if !bytes.Equal(value, getResp.Value.Bytes) {
log.Fatal("Data mismatch on retrieved value.")
}
fmt.Println("Client example done.")
// Output: Client example done.
}
// createTestClient creates a new KV client which connects using
// an HTTP sender to the server at addr.
func createTestClient(addr string) *client.KV {
sender := newNotifyingSender(client.NewHTTPSender(addr, &http.Transport{
TLSClientConfig: rpc.LoadInsecureTLSConfig().Config(),
}))
return client.NewKV(sender, nil)
}
// This is an example for using the RunTransaction() method to submit
// multiple Key Value API operations inside a transaction.
func ExampleKV_RunTransaction() {
// Using built-in test server for this example code.
serv := StartTestServer(nil)
defer serv.Stop()
// Replace with actual host:port address string (ex "localhost:8080") for server cluster.
serverAddress := serv.HTTPAddr
// Key Value Client initialization.
sender := client.NewHTTPSender(serverAddress, &http.Transport{
TLSClientConfig: rpc.LoadInsecureTLSConfig().Config(),
})
kvClient := client.NewKV(sender, nil)
kvClient.User = storage.UserRoot
defer kvClient.Close()
// Create test data.
numKVPairs := 10
keys := make([]string, numKVPairs)
values := make([][]byte, numKVPairs)
for i := 0; i < numKVPairs; i++ {
keys[i] = fmt.Sprintf("testkey-%03d", i)
values[i] = []byte(fmt.Sprintf("testvalue-%03d", i))
}
// Insert all KV pairs inside a transaction.
putOpts := client.TransactionOptions{Name: "example put"}
err := kvClient.RunTransaction(&putOpts, func(txn *client.KV) error {
for i := 0; i < numKVPairs; i++ {
txn.Prepare(proto.Put, proto.PutArgs(proto.Key(keys[i]), values[i]), &proto.PutResponse{})
}
// Note that the KV client is flushed automatically on transaction
// commit. Invoking Flush after individual API methods is only
// required if the result needs to be received to take conditional
// action.
return nil
})
if err != nil {
log.Fatal(err)
}
// Read back KV pairs inside a transaction.
getResponses := make([]proto.GetResponse, numKVPairs)
getOpts := client.TransactionOptions{Name: "example get"}
err = kvClient.RunTransaction(&getOpts, func(txn *client.KV) error {
for i := 0; i < numKVPairs; i++ {
txn.Prepare(proto.Get, proto.GetArgs(proto.Key(keys[i])), &getResponses[i])
}
return nil
})
if err != nil {
log.Fatal(err)
}
// Check results.
for i, getResp := range getResponses {
if getResp.Value == nil {
log.Fatal("No value returned for ", keys[i])
} else {
if !bytes.Equal(values[i], getResp.Value.Bytes) {
log.Fatal("Data mismatch for ", keys[i], ", got: ", getResp.Value.Bytes)
}
}
}
fmt.Println("Transaction example done.")
// Output: Transaction example done.
}
// This is an example for using the Prepare() method to submit
// multiple Key Value API operations to be run in parallel. Flush() is
// then used to begin execution of all the prepared operations.
func ExampleKV_Prepare() {
// Using built-in test server for this example code.
serv := StartTestServer(nil)
defer serv.Stop()
// Replace with actual host:port address string (ex "localhost:8080") for server cluster.
serverAddress := serv.HTTPAddr
// Key Value Client initialization.
sender := client.NewHTTPSender(serverAddress, &http.Transport{
TLSClientConfig: rpc.LoadInsecureTLSConfig().Config(),
})
kvClient := client.NewKV(sender, nil)
kvClient.User = storage.UserRoot
defer kvClient.Close()
// Insert test data.
batchSize := 12
keys := make([]string, batchSize)
values := make([][]byte, batchSize)
for i := 0; i < batchSize; i++ {
keys[i] = fmt.Sprintf("key-%03d", i)
values[i] = []byte(fmt.Sprintf("value-%03d", i))
putReq := proto.PutArgs(proto.Key(keys[i]), values[i])
putResp := &proto.PutResponse{}
kvClient.Prepare(proto.Put, putReq, putResp)
}
// Flush all puts for parallel execution.
if err := kvClient.Flush(); err != nil {
log.Fatal(err)
}
// Scan for the newly inserted rows in parallel.
numScans := 3
rowsPerScan := batchSize / numScans
scanResponses := make([]proto.ScanResponse, numScans)
for i := 0; i < numScans; i++ {
firstKey := proto.Key(keys[i*rowsPerScan])
lastKey := proto.Key(keys[((i+1)*rowsPerScan)-1])
kvClient.Prepare(proto.Scan, proto.ScanArgs(firstKey, lastKey.Next(), int64(rowsPerScan)), &scanResponses[i])
}
// Flush all scans for parallel execution.
if err := kvClient.Flush(); err != nil {
log.Fatal(err)
}
// Check results which may be returned out-of-order from creation.
var matchCount int
for i := 0; i < numScans; i++ {
for _, keyVal := range scanResponses[i].Rows {
currKey := keyVal.Key
currValue := keyVal.Value.Bytes
for j, origKey := range keys {
if bytes.Equal(currKey, proto.Key(origKey)) && bytes.Equal(currValue, values[j]) {
matchCount++
}
}
}
}
if matchCount != batchSize {
log.Fatal("Data mismatch.")
}
fmt.Println("Prepare Flush example done.")
// Output: Prepare Flush example done.
}