int kvstore_put_overwrite(void) {
char *retval;
int ret;
ret = kvstore_put(&teststore, "mykey", "initial value");
ret += kvstore_put(&teststore, "mykey", "updated value");
ret += kvstore_get(&teststore, "mykey", &retval);
ASSERT_STRING_EQUAL(retval, "updated value");
free(retval);
ASSERT_EQUAL(ret, 0);
return 1;
}
int kvstore_put_oversized_fields(void) {
char oversizedkey[MAX_KEYLEN + 2], oversizedvalue[MAX_VALLEN + 2];
int ret, i;
strcpy(oversizedkey, "a");
strcpy(oversizedvalue, "v");
for (i = 1; i < MAX_KEYLEN + 1; i++)
strcat(oversizedkey, "a");
for (i = 1; i < MAX_VALLEN + 1; i++)
strcat(oversizedvalue, "v");
ret = kvstore_put(&teststore, oversizedkey, "normal value");
ASSERT_EQUAL(ret, ERRKEYLEN);
ret = kvstore_put(&teststore, "normal key", oversizedvalue);
ASSERT_EQUAL(ret, ERRVALLEN);
return 1;
}
/* Inserts the given KEY, VALUE pair into this server's store
* Returns 0 if successful, else a negative error code. */
int tpcfollower_put(tpcfollower_t *server, char *key, char *value) {
int ret;
if ((ret = tpcfollower_put_check(server, key, value)) < 0)
return ret;
ret = kvstore_put(&server->store, key, value);
return ret;
}
int kvstore_multiple_put_get(void) {
char *retval;
int ret;
ret = kvstore_put(&teststore, "KEY1", "VALUE1");
ret += kvstore_put(&teststore, "KEY2", "VALUE2");
ret += kvstore_put(&teststore, "KEY3", "VALUE3");
ret += kvstore_get(&teststore, "KEY1", &retval);
ASSERT_STRING_EQUAL(retval, "VALUE1");
free(retval);
ret += kvstore_get(&teststore, "KEY2", &retval);
ASSERT_STRING_EQUAL(retval, "VALUE2");
free(retval);
ret += kvstore_get(&teststore, "KEY3", &retval);
ASSERT_STRING_EQUAL(retval, "VALUE3");
free(retval);
ASSERT_EQUAL(ret, 0);
return 1;
}
int kvstore_get_put_uninitialized(void) {
char *retval;
int ret;
kvstore_clean(&teststore);
ret = kvstore_get(&teststore, "KEY", &retval);
ASSERT_EQUAL(ret, ERRFILACCESS);
ret = kvstore_put(&teststore, "KEY", "VALUE");
ASSERT_EQUAL(ret, ERRFILACCESS);
return 1;
}
int kvstore_put_get_blank_value(void) {
char *retval;
int ret;
ret = kvstore_put(&teststore, "valid key", "");
ret += kvstore_get(&teststore, "valid key", &retval);
ASSERT_STRING_EQUAL(retval, "");
ASSERT_EQUAL(ret, 0);
free(retval);
return 1;
}
int kvstore_single_put_get(void) {
char *retval;
int ret;
ret = kvstore_put(&teststore, "MYKEY", "MYVALUE");
ASSERT_EQUAL(ret, 0);
ret = kvstore_get(&teststore, "MYKEY", &retval);
ASSERT_EQUAL(ret, 0);
ASSERT_STRING_EQUAL(retval, "MYVALUE");
free(retval);
return 1;
}
int kvstore_get_put_with_hash_conflicts(void) {
/* hash("abD") == hash("aae") == hash("ac#") */
char *retval, *key1 = "abD", *key2 = "aae", *key3 = "ac#";
int ret;
ret = kvstore_put(&teststore, key1, "value1");
ret += kvstore_put(&teststore, key2, "value2");
ret += kvstore_put(&teststore, key3, "value3");
ret += kvstore_get(&teststore, key1, &retval);
ASSERT_STRING_EQUAL(retval, "value1");
free(retval);
ret += kvstore_get(&teststore, key2, &retval);
ASSERT_STRING_EQUAL(retval, "value2");
free(retval);
ret += kvstore_get(&teststore, key3, &retval);
ASSERT_STRING_EQUAL(retval, "value3");
free(retval);
/* Clean the store and do it again in a different order to ensure that
the above success wasn't just because of a lucky ordering. */
kvstore_clean(&teststore);
kvstore_init(&teststore, KVSTORE_DIRNAME);
ret = kvstore_put(&teststore, key2, "value2");
ret += kvstore_put(&teststore, key3, "value3");
ret += kvstore_put(&teststore, key1, "value1");
ret += kvstore_get(&teststore, key1, &retval);
ASSERT_STRING_EQUAL(retval, "value1");
free(retval);
ret += kvstore_get(&teststore, key2, &retval);
ASSERT_STRING_EQUAL(retval, "value2");
free(retval);
ret += kvstore_get(&teststore, key3, &retval);
ASSERT_STRING_EQUAL(retval, "value3");
free(retval);
ASSERT_EQUAL(ret, 0);
return 1;
}
/* Inserts the given KEY, VALUE pair into this server's store and cache. Access
* to the cache should be concurrent if the keys are in different cache sets.
* Returns 0 if successful, else a negative error code. */
int kvserver_put(kvserver_t *server, char *key, char *value) {
// OUR CODE HERE
int success;
pthread_rwlock_t *lock = kvcache_getlock(&server->cache, key);
if (lock == NULL) return ERRKEYLEN;
pthread_rwlock_wrlock(lock);
if ((success = kvcache_put(&server->cache, key, value)) < 0) {
pthread_rwlock_unlock(lock);
return success;
}
pthread_rwlock_unlock(lock);
return kvstore_put(&server->store, key, value);
}
int kvstore_del_simple(void) {
char *retval;
int ret;
ret = kvstore_put(&teststore, "key", "val");
ret += kvstore_get(&teststore, "key", &retval);
ASSERT_STRING_EQUAL(retval, "val");
free(retval);
ret += kvstore_del(&teststore, "key");
ASSERT_EQUAL(ret, 0);
retval = NULL;
ret = kvstore_get(&teststore, "key", &retval);
ASSERT_EQUAL(ret, ERRNOKEY);
ASSERT_PTR_NULL(retval);
return 1;
}
int kvstore_del_hash_conflicts(void) {
/* hash("abD") == hash("aae") == hash("ac#") */
char *retval = NULL, *key1 = "abD", *key2 = "aae", *key3 = "ac#";
int ret;
ret = kvstore_put(&teststore, key1, "value1");
ret += kvstore_put(&teststore, key2, "value2");
ret += kvstore_put(&teststore, key3, "value3");
ret += kvstore_del(&teststore, key2);
ASSERT_EQUAL(ret, 0);
ret = kvstore_get(&teststore, key2, &retval);
ASSERT_PTR_NULL(retval);
ASSERT_EQUAL(ret, ERRNOKEY);
ret = kvstore_get(&teststore, key1, &retval);
ASSERT_STRING_EQUAL(retval, "value1");
free(retval);
ret += kvstore_get(&teststore, key3, &retval);
ASSERT_STRING_EQUAL(retval, "value3");
free(retval);
ASSERT_EQUAL(ret, 0);
/* Clean store and do operations again with a different insertion order to
* help ensure that success wasn't due to a lucky ordering. */
kvstore_clean(&teststore);
kvstore_init(&teststore, KVSTORE_DIRNAME);
ret = kvstore_put(&teststore, key2, "value2");
ret += kvstore_put(&teststore, key1, "value1");
ret += kvstore_put(&teststore, key3, "value3");
ret += kvstore_del(&teststore, key2);
ASSERT_EQUAL(ret, 0);
retval = NULL;
ret = kvstore_get(&teststore, key2, &retval);
ASSERT_PTR_NULL(retval);
ASSERT_EQUAL(ret, ERRNOKEY);
ret = kvstore_get(&teststore, key1, &retval);
ASSERT_STRING_EQUAL(retval, "value1");
free(retval);
ret += kvstore_get(&teststore, key3, &retval);
ASSERT_STRING_EQUAL(retval, "value3");
free(retval);
ASSERT_EQUAL(ret, 0);
return 1;
}
