added a test for the length RPC

Makefile.am

@@ -5,11 +5,12 @@ CLIENT_LiBS=@CLIENT_LIBS@
 
 AM_CPPFLAGS = -I${srcdir}/src
 
-bin_PROGRAMS = bin/sdskv-server-daemon \
-	       bin/sdskv-shutdown \
-	       test/sdskv-open-test \
-	       test/sdskv-put-test \
-	       test/sdskv-get-test \
+bin_PROGRAMS = bin/sdskv-server-daemon 	\
+	       bin/sdskv-shutdown 	\
+	       test/sdskv-open-test 	\
+	       test/sdskv-put-test 	\
+	       test/sdskv-length-test 	\
+	       test/sdskv-get-test 	\
 	       test/sdskv-list-keys-test
 
 bin_sdskv_server_daemon_SOURCES = src/sdskv-server-daemon.c
@@ -66,6 +67,7 @@ include_HEADERS = src/sds-keyval.h \
 		  src/sds-keyval-group.h
 
 noinst_HEADERS = src/datastore/datastore.h \
+		 src/datastore/map_datastore.h \
 		 src/datastore/bwtree_datastore.h \
 		 src/datastore/leveldb_datastore.h \
 		 src/datastore/berkeleydb_datastore.h \
@@ -81,10 +83,11 @@ lib_libkvgroupserver_la_SOURCES = src/kvgroup-server.cc
 
 check_PROGRAMS = test/sdskv-open-test
 
-TESTS = test/basic.sh \
-	test/open-test.sh \
-       	test/put-test.sh \
-	test/get-test.sh \
+TESTS = test/basic.sh 		\
+	test/open-test.sh 	\
+       	test/put-test.sh 	\
+	test/length-test.sh 	\
+	test/get-test.sh 	\
 	test/list-keys-test.sh
 
 TESTS_ENVIRONMENT = TIMEOUT="$(TIMEOUT)" \
@@ -98,6 +101,10 @@ test_sdskv_put_test_SOURCES = test/sdskv-put-test.cc
 test_sdskv_put_test_DEPENDENCIES = lib/libsdskv-client.la
 test_sdskv_put_test_LDFLAGS = -Llib -lsdskv-client
 
+test_sdskv_length_test_SOURCES = test/sdskv-length-test.cc
+test_sdskv_length_test_DEPENDENCIES = lib/libsdskv-client.la
+test_sdskv_length_test_LDFLAGS = -Llib -lsdskv-client
+
 test_sdskv_get_test_SOURCES = test/sdskv-get-test.cc
 test_sdskv_get_test_DEPENDENCIES = lib/libsdskv-client.la
 test_sdskv_get_test_LDFLAGS = -Llib -lsdskv-client

test/length-test.sh

+#!/bin/bash -x
+
+if [ -z $srcdir ]; then
+    echo srcdir variable not set.
+    exit 1
+fi
+source $srcdir/test/test-util.sh
+
+# start a server with 2 second wait,
+# 20s timeout, and my_test_db as database
+test_start_server 2 20 my_test_db
+
+sleep 1
+
+#####################
+
+run_to 20 test/sdskv-length-test $svr_addr 1 my_test_db 10
+if [ $? -ne 0 ]; then
+    wait
+    exit 1
+fi
+
+wait
+
+echo cleaning up $TMPBASE
+rm -rf $TMPBASE
+
+exit 0

test/sdskv-length-test.cc

+/*
+ * (C) 2015 The University of Chicago
+ * 
+ * See COPYRIGHT in top-level directory.
+ */
+
+#include <stdio.h>
+#include <assert.h>
+#include <unistd.h>
+#include <margo.h>
+#include <string>
+#include <vector>
+#include <algorithm>
+#include <map>
+
+#include "sdskv-client.h"
+
+static std::string gen_random_string(size_t len);
+
+int main(int argc, char *argv[])
+{
+    char cli_addr_prefix[64] = {0};
+    char *sdskv_svr_addr_str;
+    char *db_name;
+    margo_instance_id mid;
+    hg_addr_t svr_addr;
+    uint8_t mplex_id;
+    uint32_t num_keys;
+    sdskv_client_t kvcl;
+    sdskv_provider_handle_t kvph;
+    hg_return_t hret;
+    int ret;
+
+    if(argc != 5)
+    {
+        fprintf(stderr, "Usage: %s <sdskv_server_addr> <mplex_id> <db_name> <num_keys>\n", argv[0]);
+        fprintf(stderr, "  Example: %s tcp://localhost:1234 1 foo 1000\n", argv[0]);
+        return(-1);
+    }
+    sdskv_svr_addr_str = argv[1];
+    mplex_id          = atoi(argv[2]);
+    db_name           = argv[3];
+    num_keys          = atoi(argv[4]);
+
+    /* initialize Margo using the transport portion of the server
+     * address (i.e., the part before the first : character if present)
+     */
+    for(unsigned i=0; (i<63 && sdskv_svr_addr_str[i] != '\0' && sdskv_svr_addr_str[i] != ':'); i++)
+        cli_addr_prefix[i] = sdskv_svr_addr_str[i];
+
+    /* start margo */
+    mid = margo_init(cli_addr_prefix, MARGO_SERVER_MODE, 0, 0);
+    if(mid == MARGO_INSTANCE_NULL)
+    {
+        fprintf(stderr, "Error: margo_init()\n");
+        return(-1);
+    }
+
+    ret = sdskv_client_init(mid, &kvcl);
+    if(ret != 0)
+    {
+        fprintf(stderr, "Error: sdskv_client_init()\n");
+        margo_finalize(mid);
+        return -1;
+    }
+
+    /* look up the SDSKV server address */
+    hret = margo_addr_lookup(mid, sdskv_svr_addr_str, &svr_addr);
+    if(hret != HG_SUCCESS)
+    {
+        fprintf(stderr, "Error: margo_addr_lookup()\n");
+        sdskv_client_finalize(kvcl);
+        margo_finalize(mid);
+        return(-1);
+    }
+
+    /* create a SDSKV provider handle */
+    ret = sdskv_provider_handle_create(kvcl, svr_addr, mplex_id, &kvph);
+    if(ret != 0)
+    {
+        fprintf(stderr, "Error: sdskv_provider_handle_create()\n");
+        margo_addr_free(mid, svr_addr);
+        sdskv_client_finalize(kvcl);
+        margo_finalize(mid);
+        return(-1);
+    }
+
+    /* open the database */
+    sdskv_database_id_t db_id;
+    ret = sdskv_open(kvph, db_name, &db_id);
+    if(ret == 0) {
+        printf("Successfuly open database %s, id is %ld\n", db_name, db_id);
+    } else {
+        fprintf(stderr, "Error: could not open database %s\n", db_name);
+        sdskv_provider_handle_release(kvph);
+        margo_addr_free(mid, svr_addr);
+        sdskv_client_finalize(kvcl);
+        margo_finalize(mid);
+        return(-1);
+    }
+
+    /* **** put keys ***** */
+    std::vector<std::string> keys;
+    std::map<std::string, std::string> reference;
+    size_t max_value_size = 8000;
+
+    for(unsigned i=0; i < num_keys; i++) {
+        auto k = gen_random_string(16);
+        // half of the entries will be put using bulk
+        auto v = gen_random_string(rand() % max_value_size);
+        ret = sdskv_put(kvph, db_id,
+                (const void *)k.data(), k.size()+1,
+                (const void *)v.data(), v.size()+1);
+        if(ret != 0) {
+            fprintf(stderr, "Error: sdskv_put() failed (iteration %d)\n", i);
+            sdskv_shutdown_service(kvcl, svr_addr);
+            sdskv_provider_handle_release(kvph);
+            margo_addr_free(mid, svr_addr);
+            sdskv_client_finalize(kvcl);
+            margo_finalize(mid);
+            return -1;
+        }
+        reference[k] = v;
+        keys.push_back(k);
+    }
+    printf("Successfuly inserted %d keys\n", num_keys);
+
+    /* **** get keys **** */
+    for(unsigned i=0; i < num_keys; i++) {
+        auto k = keys[rand() % keys.size()];
+        size_t value_size = 0;
+        ret = sdskv_length(kvph, db_id,
+                (const void *)k.data(), k.size()+1, &value_size);
+        if(ret != 0) {
+            fprintf(stderr, "Error: sdskv_length() failed (key was %s)\n", k.c_str());
+            sdskv_shutdown_service(kvcl, svr_addr);
+            sdskv_provider_handle_release(kvph);
+            margo_addr_free(mid, svr_addr);
+            sdskv_client_finalize(kvcl);
+            margo_finalize(mid);
+            return -1;
+        }
+        if(value_size != reference[k].size()+1) {
+            fprintf(stderr, "Error: sdskv_length() returned a value different from the reference\n");
+            sdskv_shutdown_service(kvcl, svr_addr);
+            sdskv_provider_handle_release(kvph);
+            margo_addr_free(mid, svr_addr);
+            sdskv_client_finalize(kvcl);
+            margo_finalize(mid);
+            return -1;
+        }
+    }
+
+    /* shutdown the server */
+    ret = sdskv_shutdown_service(kvcl, svr_addr);
+
+    /**** cleanup ****/
+    sdskv_provider_handle_release(kvph);
+    margo_addr_free(mid, svr_addr);
+    sdskv_client_finalize(kvcl);
+    margo_finalize(mid);
+    return(ret);
+}
+
+static std::string gen_random_string(size_t len) {
+    static const char alphanum[] =
+                "0123456789"
+                "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
+                "abcdefghijklmnopqrstuvwxyz";
+    std::string s(len, ' ');
+    for (unsigned i = 0; i < len; ++i) {
+        s[i] = alphanum[rand() % (sizeof(alphanum) - 1)];
+    }
+    return s;
+}