void test_kinetic_client_should_store_a_binary_object_split_across_entries_via_overlapped_asynchronous_IO_operations(void)
{
ByteBuffer test_data = ByteBuffer_Malloc(PAYLOAD_SIZE);
ByteBuffer_AppendDummyData(&test_data, test_data.array.len);
uint8_t tag_data[] = {0x00, 0x01, 0x02, 0x03};
ByteBuffer tag = ByteBuffer_Create(tag_data, sizeof(tag_data), sizeof(tag_data));
for (size_t i = 0; i < NUM_PUTS; i++) {
put_statuses[i] = (PutStatus) {
.sem = KineticSemaphore_Create(),
.status = KINETIC_STATUS_INVALID,
};
};
printf("Waiting for put finish\n");
struct timeval start_time;
gettimeofday(&start_time, NULL);
for (uint32_t put = 0; put < NUM_PUTS; put++) {
keys[put] = put;
ByteBuffer key = ByteBuffer_Create(&keys[put], sizeof(keys[put]), sizeof(keys[put]));
KineticSynchronization sync = (put == NUM_PUTS - 1)
? KINETIC_SYNCHRONIZATION_FLUSH
: KINETIC_SYNCHRONIZATION_WRITEBACK;
entries[put] = (KineticEntry) {
.key = key,
.tag = tag,
.algorithm = KINETIC_ALGORITHM_SHA1,
.value = test_data,
.synchronization = sync,
};
KineticStatus status = KineticClient_Put(Fixture.session,
&entries[put],
&(KineticCompletionClosure) {
.callback = put_finished,
.clientData = &put_statuses[put],
}
);
if (status != KINETIC_STATUS_SUCCESS) {
fprintf(stderr, "PUT failed w/status: %s\n", Kinetic_GetStatusDescription(status));
TEST_FAIL();
}
}
static void do_put_and_getprevious_getnext(KineticSession *session) {
for (int i = 0; i < 3; i++) {
char key[] = "keyX";
key[3] = '0' + i;
ByteBuffer put_key_buf = ByteBuffer_MallocAndAppend(key, strlen(key));
uint8_t value[] = "valueX";
value[5] = '0' + i;
ByteBuffer put_value_buf = ByteBuffer_MallocAndAppend(value, sizeof(value));
/* Populate tag with SHA1 of value */
ByteBuffer put_tag_buf = ByteBuffer_Malloc(20);
uint8_t sha1[20];
SHA1(put_value_buf.array.data, put_value_buf.bytesUsed, &sha1[0]);
ByteBuffer_Append(&put_tag_buf, sha1, sizeof(sha1));
KineticEntry put_entry = {
.key = put_key_buf,
.value = put_value_buf,
.tag = put_tag_buf,
.algorithm = KINETIC_ALGORITHM_SHA1,
/* Set sync to WRITETHROUGH, which will wait to complete
* until the drive has persistend the write. (WRITEBACK
* returns as soon as the drive has buffered the write.) */
.synchronization = KINETIC_SYNCHRONIZATION_WRITETHROUGH,
};
/* Put "keyX" => "valueX", where 'X' is 0..4.
* This will block, because the callback field (arg 3) is NULL. */
KineticStatus status = KineticClient_Put(session, &put_entry, NULL);
printf("Put status: %s\n", Kinetic_GetStatusDescription(status));
ByteBuffer_Free(put_key_buf);
ByteBuffer_Free(put_value_buf);
ByteBuffer_Free(put_tag_buf);
}
printf("\n\n\n");
for (int i = 1; i < 3; i++) {
KineticStatus status = KINETIC_STATUS_INVALID;
static const ssize_t sz = 100;
char key_buf[sz];
char tag_buf[sz];
char value_buf[sz];
ByteBuffer keyBuffer = ByteBuffer_CreateAndAppendFormattedCString(key_buf, sz, "key%d", i);
ByteBuffer tagBuffer = ByteBuffer_CreateAndAppendFormattedCString(tag_buf, sz, "tag%d", i);
ByteBuffer valueBuffer = ByteBuffer_Create(value_buf, sz, 0);
KineticEntry entry = {
.key = keyBuffer,
.tag = tagBuffer,
.value = valueBuffer,
.algorithm = KINETIC_ALGORITHM_SHA1,
};
if (i > 0) {
status = KineticClient_GetPrevious(session, &entry, NULL);
printf("GetPrevious status: %s\n", Kinetic_GetStatusDescription(status));
if (status == KINETIC_STATUS_SUCCESS) {
printf("Previous key before 'key%d': '%s', value '%s'\n",
i, key_buf, value_buf);
}
}
}
for (int i = 0; i < 2; i++) {
KineticStatus status = KINETIC_STATUS_INVALID;
static const ssize_t sz = 100;
char key_buf[sz];
char tag_buf[sz];
char value_buf[sz];
ByteBuffer keyBuffer = ByteBuffer_CreateAndAppendFormattedCString(key_buf, sz, "key%d", i);
ByteBuffer tagBuffer = ByteBuffer_CreateAndAppendFormattedCString(tag_buf, sz, "tag%d", i);
ByteBuffer valueBuffer = ByteBuffer_Create(value_buf, sz, 0);
KineticEntry entry = {
.key = keyBuffer,
.tag = tagBuffer,
.value = valueBuffer,
.algorithm = KINETIC_ALGORITHM_SHA1,
};
if (i < 2) {
status = KineticClient_GetNext(session, &entry, NULL);
printf("GetNext status: %s\n", Kinetic_GetStatusDescription(status));
if (status == KINETIC_STATUS_SUCCESS) {
printf("Next key after 'key%d': '%s', value '%s'\n",
i, key_buf, value_buf);
}
}
}
/* No cleanup necessary */
}
static void do_put_and_getkeyrange(KineticSession * const session) {
for (int i = 0; i < 5; i++) {
char key[] = "keyX";
key[3] = '0' + i;
ByteBuffer put_key_buf = ByteBuffer_MallocAndAppend(key, strlen(key));
uint8_t value[] = "valueX";
value[5] = '0' + i;
ByteBuffer put_value_buf = ByteBuffer_MallocAndAppend(value, sizeof(value));
/* Populate tag with SHA1 of value */
ByteBuffer put_tag_buf = ByteBuffer_Malloc(20);
uint8_t sha1[20];
SHA1(put_value_buf.array.data, put_value_buf.bytesUsed, &sha1[0]);
ByteBuffer_Append(&put_tag_buf, sha1, sizeof(sha1));
KineticEntry put_entry = {
.key = put_key_buf,
.value = put_value_buf,
.tag = put_tag_buf,
.algorithm = KINETIC_ALGORITHM_SHA1,
/* Set sync to WRITETHROUGH, which will wait to complete
* until the drive has persistend the write. (WRITEBACK
* returns as soon as the drive has buffered the write.) */
.synchronization = KINETIC_SYNCHRONIZATION_WRITETHROUGH,
};
/* Put "keyX" => "valueX", where 'X' is 0..4.
* This will block, because the callback field (arg 3) is NULL. */
KineticStatus status = KineticClient_Put(session, &put_entry, NULL);
printf("Put status: %s\n", Kinetic_GetStatusDescription(status));
ByteBuffer_Free(put_key_buf);
ByteBuffer_Free(put_value_buf);
ByteBuffer_Free(put_tag_buf);
}
const size_t max_key_count = 5;
const size_t max_key_length = 64;
uint8_t first_key[max_key_length];
uint8_t last_key[max_key_length];
KineticKeyRange range = {
.startKey = ByteBuffer_CreateAndAppendCString(first_key, sizeof(first_key), "key"),
.endKey = ByteBuffer_CreateAndAppendCString(last_key, sizeof(last_key), "key\xFF"),
.startKeyInclusive = true,
.endKeyInclusive = true,
.maxReturned = max_key_count,
};
uint8_t key_mem[max_key_count][max_key_length];
memset(key_mem, 0, sizeof(key_mem));
ByteBuffer key_buffers[max_key_count];
for (size_t i = 0; i < max_key_count; i++) {
key_buffers[i] = ByteBuffer_Create(&key_buffers[i], max_key_length, 0);
}
ByteBufferArray keys = {
.buffers = key_buffers,
.count = max_key_count,
};
/* Request the key range as specified in &range, populating the keys in &keys. */
KineticStatus status = KineticClient_GetKeyRange(session, &range, &keys, NULL);
printf("GetKeyRange status: %s\n", Kinetic_GetStatusDescription(status));
if (status == KINETIC_STATUS_SUCCESS) {
for (size_t i = 0; i < max_key_count; i++) {
printf("%zd: %s\n", i, key_buffers[i].array.data);
}
}
/* No cleanup necessary */
}
int main(int argc, char** argv)
{
(void)argc;
(void)argv;
// Initialize kinetic-c and configure sessions
KineticSession* session;
KineticClientConfig clientConfig = {
.logFile = "stdout",
.logLevel = 1,
};
KineticClient * client = KineticClient_Init(&clientConfig);
if (client == NULL) { return 1; }
const char HmacKeyString[] = "asdfasdf";
KineticSessionConfig sessionConfig = {
.host = "localhost",
.port = KINETIC_PORT,
.clusterVersion = 0,
.identity = 1,
.hmacKey = ByteArray_CreateWithCString(HmacKeyString),
};
KineticStatus status = KineticClient_CreateSession(&sessionConfig, client, &session);
if (status != KINETIC_STATUS_SUCCESS) {
fprintf(stderr, "Failed connecting to the Kinetic device w/status: %s\n",
Kinetic_GetStatusDescription(status));
exit(1);
}
do_put_and_getkeyrange(session);
// Shutdown client connection and cleanup
KineticClient_DestroySession(session);
KineticClient_Shutdown(client);
return 0;
}
int main(int argc, char** argv)
{
(void)argc;
(void)argv;
// Initialize kinetic-c and configure sessions
KineticSession* session;
KineticClientConfig clientConfig = {
.logFile = "stdout",
.logLevel = 1,
};
KineticClient * client = KineticClient_Init(&clientConfig);
if (client == NULL) { return 1; }
const char HmacKeyString[] = "asdfasdf";
KineticSessionConfig sessionConfig = {
.host = "localhost",
.port = KINETIC_PORT,
.clusterVersion = 0,
.identity = 1,
.hmacKey = ByteArray_CreateWithCString(HmacKeyString),
};
KineticStatus status = KineticClient_CreateSession(&sessionConfig, client, &session);
if (status != KINETIC_STATUS_SUCCESS) {
fprintf(stderr, "Failed connecting to the Kinetic device w/status: %s\n",
Kinetic_GetStatusDescription(status));
exit(1);
}
// some dummy data to PUT
uint8_t value_data[] = { 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0A, 0x0B, 0x0C, 0x0D, 0x0E, 0x0F };
ByteBuffer value = ByteBuffer_MallocAndAppend(value_data, sizeof(value_data));
// a dummy key
uint8_t key_data[] = {0x00, 0x01, 0x02, 0x03, 0x04};
ByteBuffer key = ByteBuffer_MallocAndAppend(key_data, sizeof(key_data));
// Populate tag with SHA1
ByteBuffer tag = ByteBuffer_Malloc(20);
uint8_t sha1[20];
SHA1(value.array.data, value.bytesUsed, &sha1[0]);
ByteBuffer_Append(&tag, sha1, sizeof(sha1));
KineticEntry entry = {
.key = key,
.tag = tag,
.algorithm = KINETIC_ALGORITHM_SHA1,
.value = value,
.synchronization = KINETIC_SYNCHRONIZATION_WRITETHROUGH,
};
// Do a blocking put to make sure there is something there to read back
KineticStatus put_status = KineticClient_Put(session, &entry, NULL);
if (put_status != KINETIC_STATUS_SUCCESS) {
fprintf(stderr, "Put failed w/status: %s\n", Kinetic_GetStatusDescription(put_status));
return 1;
}
// Create structure to populate with GET status in callback
// a semaphore is used to notify the main thread that it's
// safe to proceed.
GetStatus get_status = {
.sem = KineticSemaphore_Create(),
.status = KINETIC_STATUS_INVALID,
};
ByteBuffer getTag = ByteBuffer_Malloc(tag.bytesUsed);
ByteBuffer getValue = ByteBuffer_Malloc(value.bytesUsed);
// Because I'm passing a pointer to this entry to KineticClient_Put(), this entry must not
// go out of scope until the GET completes
KineticEntry get_entry = {
.key = key,
.tag = getTag,
.algorithm = KINETIC_ALGORITHM_SHA1,
.value = getValue,
.force = true,
};
status = KineticClient_Get(
session,
&get_entry,
&(KineticCompletionClosure) {
.callback = get_finished,
.clientData = &get_status,
}
);
if (status != KINETIC_STATUS_SUCCESS) {
fprintf(stderr, "Get failed w/status: %s\n", Kinetic_GetStatusDescription(status));
return 1;
}
// Wait for GET to finish
KineticSemaphore_WaitForSignalAndDestroy(get_status.sem);
if (get_status.status != KINETIC_STATUS_SUCCESS) {
fprintf(stderr, "GET failed w/status: %s\n", Kinetic_GetStatusDescription(get_status.status));
return 1;
}
if ((value.bytesUsed == getValue.bytesUsed) &&
(memcmp(value.array.data, getValue.array.data, getValue.bytesUsed) != 0)) {
fprintf(stderr, "GET completed but returned unexpected value");
return 1;
}
printf("GET completed successfully!\n");
// Free malloc'd buffers
ByteBuffer_Free(value);
ByteBuffer_Free(key);
ByteBuffer_Free(tag);
ByteBuffer_Free(getValue);
ByteBuffer_Free(getTag);
// Shutdown client connection and cleanup
KineticClient_DestroySession(session);
KineticClient_Shutdown(client);
return 0;
}
static void get_finished(KineticCompletionData* kinetic_data, void* clientData)
{
GetStatus * get_status = clientData;
// Save GET result status
get_status->status = kinetic_data->status;
// Signal that we're done
KineticSemaphore_Signal(get_status->sem);
}
static void do_put_and_get(KineticSession *session) {
const char key[] = "key";
ByteBuffer put_key_buf = ByteBuffer_MallocAndAppend(key, strlen(key));
const uint8_t value[] = "value\x01\x02\x03\x04";
ByteBuffer put_value_buf = ByteBuffer_MallocAndAppend(value, sizeof(value));
/* Populate tag with SHA1 of value */
ByteBuffer put_tag_buf = ByteBuffer_Malloc(20);
uint8_t sha1[20];
SHA1(put_value_buf.array.data, put_value_buf.bytesUsed, &sha1[0]);
ByteBuffer_Append(&put_tag_buf, sha1, sizeof(sha1));
KineticEntry put_entry = {
.key = put_key_buf,
.value = put_value_buf,
.tag = put_tag_buf,
.algorithm = KINETIC_ALGORITHM_SHA1,
/* Set sync to WRITETHROUGH, which will wait to complete
* until the drive has persistend the write. (WRITEBACK
* returns as soon as the drive has buffered the write.) */
.synchronization = KINETIC_SYNCHRONIZATION_WRITETHROUGH,
};
/* Put "key" => "value\x01\x02\x03\x04".
* This will block, because the callback field (arg 3) is NULL. */
KineticStatus status = KineticClient_Put(session, &put_entry, NULL);
printf("Put status: %s\n", Kinetic_GetStatusDescription(status));
/* Allocate a tag large enough for the SHA1. */
ByteBuffer get_tag_buf = ByteBuffer_Malloc(put_tag_buf.bytesUsed);
/* Allocate a buffer large enough for the value. */
ByteBuffer get_value_buf = ByteBuffer_Malloc(put_value_buf.bytesUsed);
KineticEntry get_entry = {
.key = put_key_buf,
.value = get_value_buf,
.tag = get_tag_buf,
.algorithm = KINETIC_ALGORITHM_SHA1,
};
status = KineticClient_Get(session, &get_entry, NULL);
printf("Get status: %s\n", Kinetic_GetStatusDescription(status));
printf("Get value: %zd bytes\n ", get_entry.value.bytesUsed);
for (size_t i = 0; i < get_entry.value.bytesUsed; i++) {
printf("%02x ", get_entry.value.array.data[i]);
}
printf(" ");
for (size_t i = 0; i < get_entry.value.bytesUsed; i++) {
char c = get_entry.value.array.data[i];
printf("%c", isprint(c) ? c : '.');
}
printf("\n");
/* Cleanup */
ByteBuffer_Free(put_key_buf);
ByteBuffer_Free(put_value_buf);
ByteBuffer_Free(put_tag_buf);
ByteBuffer_Free(get_entry.value);
ByteBuffer_Free(get_tag_buf);
}
void run_throughput_tests(KineticClient * client, size_t num_ops, size_t value_size)
{
LOGF0("STRESS THREAD: object_size: %zu bytes, count: %zu entries", value_size, num_ops);
// Configure and establish a session with the specified device
KineticSession* session;
const char HmacKeyString[] = "asdfasdf";
KineticSessionConfig config = {
.clusterVersion = 0,
.identity = 1,
.hmacKey = ByteArray_CreateWithCString(HmacKeyString),
};
strncpy(config.host, GetSystemTestHost1(), sizeof(config.host)-1);
config.port = GetSystemTestPort1();
KineticStatus status = KineticClient_CreateSession(&config, client, &session);
if (status != KINETIC_STATUS_SUCCESS) {
char msg[128];
sprintf(msg, "Failed connecting to the Kinetic device w/status: %s", Kinetic_GetStatusDescription(status));
TEST_FAIL_MESSAGE(msg);
}
// Generate test entry data
ByteBuffer test_data = ByteBuffer_Malloc(value_size);
ByteBuffer_AppendDummyData(&test_data, test_data.array.len);
uint8_t tag_data[] = {0x00, 0x01, 0x02, 0x03};
ByteBuffer tag = ByteBuffer_Create(tag_data, sizeof(tag_data), sizeof(tag_data));
uint64_t r = rand();
uint64_t keys[num_ops];
KineticEntry entries[num_ops];
for (uint32_t put = 0; put < num_ops; put++) {
keys[put] = put | (r << 16);
}
// Measure PUT performance
{
OpStatus put_statuses[num_ops];
for (size_t i = 0; i < num_ops; i++) {
put_statuses[i] = (OpStatus){
.sem = KineticSemaphore_Create(),
.status = KINETIC_STATUS_INVALID,
};
};
struct timeval start_time;
gettimeofday(&start_time, NULL);
for (uint32_t put = 0; put < num_ops; put++) {
ByteBuffer key = ByteBuffer_Create(&keys[put], sizeof(keys[put]), sizeof(keys[put]));
KineticSynchronization sync = (put == num_ops - 1)
? KINETIC_SYNCHRONIZATION_FLUSH
: KINETIC_SYNCHRONIZATION_WRITEBACK;
entries[put] = (KineticEntry) {
.key = key,
.tag = tag,
.algorithm = KINETIC_ALGORITHM_SHA1,
.value = test_data,
.synchronization = sync,
};
KineticStatus status = KineticClient_Put(
session,
&entries[put],
&(KineticCompletionClosure) {
.callback = op_finished,
.clientData = &put_statuses[put],
}
);
if (status != KINETIC_STATUS_SUCCESS) {
char msg[128];
sprintf(msg, "PUT failed w/status: %s", Kinetic_GetStatusDescription(status));
TEST_FAIL_MESSAGE(msg);
}
}
for (size_t i = 0; i < num_ops; i++)
{
KineticSemaphore_WaitForSignalAndDestroy(put_statuses[i].sem);
if (put_statuses[i].status != KINETIC_STATUS_SUCCESS) {
char msg[128];
sprintf(msg, "PUT failed w/status: %s", Kinetic_GetStatusDescription(put_statuses[i].status));
TEST_FAIL_MESSAGE(msg);
}
}
struct timeval stop_time;
gettimeofday(&stop_time, NULL);
size_t bytes_written = num_ops * test_data.array.len;
int64_t elapsed_us = ((stop_time.tv_sec - start_time.tv_sec) * 1000000)
+ (stop_time.tv_usec - start_time.tv_usec);
float elapsed_ms = elapsed_us / 1000.0f;
float bandwidth = (bytes_written * 1000.0f) / (elapsed_ms * 1024 * 1024);
LOGF0("PUT Performance: wrote: %.1f kB, duration: %.3f sec, throughput: %.2f MB/sec",
bytes_written / 1024.0f, elapsed_ms / 1000.0f, bandwidth);
}
// Measure GET performance
{
OpStatus get_statuses[num_ops];
for (size_t i = 0; i < num_ops; i++) {
get_statuses[i] = (OpStatus){
.sem = KineticSemaphore_Create(),
.status = KINETIC_STATUS_INVALID,
};
};
ByteBuffer test_get_datas[num_ops];
for (size_t i = 0; i < num_ops; i++)
{
test_get_datas[i] = ByteBuffer_Malloc(value_size);
}
struct timeval start_time;
gettimeofday(&start_time, NULL);
for (uint32_t get = 0; get < num_ops; get++) {
ByteBuffer key = ByteBuffer_Create(&keys[get], sizeof(keys[get]), sizeof(keys[get]));
entries[get] = (KineticEntry) {
.key = key,
.tag = tag,
.value = test_get_datas[get],
};
KineticStatus status = KineticClient_Get(
session,
&entries[get],
&(KineticCompletionClosure) {
.callback = op_finished,
.clientData = &get_statuses[get],
}
);
if (status != KINETIC_STATUS_SUCCESS) {
char msg[128];
sprintf(msg, "GET failed w/status: %s", Kinetic_GetStatusDescription(status));
TEST_FAIL_MESSAGE(msg);
}
}
size_t bytes_read = 0;
for (size_t i = 0; i < num_ops; i++)
{
KineticSemaphore_WaitForSignalAndDestroy(get_statuses[i].sem);
if (get_statuses[i].status != KINETIC_STATUS_SUCCESS) {
char msg[128];
sprintf(msg, "GET failed w/status: %s", Kinetic_GetStatusDescription(get_statuses[i].status));
TEST_FAIL_MESSAGE(msg);
}
else
{
bytes_read += entries[i].value.bytesUsed;
}
}
// Check data for integrity
size_t numFailures = 0;
for (size_t i = 0; i < num_ops; i++) {
int res = memcmp(test_data.array.data, test_get_datas[i].array.data, test_data.array.len);
if (res != 0) {
LOGF0("Failed validating data in object %zu of %zu!", i+1, num_ops);
numFailures++;
}
}
TEST_ASSERT_EQUAL_MESSAGE(0, numFailures, "DATA INTEGRITY CHECK FAILED UPON READBACK!");
// Calculate and report performance
struct timeval stop_time;
gettimeofday(&stop_time, NULL);
int64_t elapsed_us = ((stop_time.tv_sec - start_time.tv_sec) * 1000000)
+ (stop_time.tv_usec - start_time.tv_usec);
float elapsed_ms = elapsed_us / 1000.0f;
float bandwidth = (bytes_read * 1000.0f) / (elapsed_ms * 1024 * 1024);
LOGF0("GET Performance: read: %.1f kB, duration: %.3f sec, throughput: %.2f MB/sec",
bytes_read / 1024.0f, elapsed_ms / 1000.0f, bandwidth);
for (size_t i = 0; i < num_ops; i++) {
ByteBuffer_Free(test_get_datas[i]);
}
}
int main(int argc, char** argv)
{
(void)argc;
(void)argv;
// Initialize kinetic-c and configure sessions
KineticSession* session;
KineticClientConfig clientConfig = {
.logFile = "stdout",
.logLevel = 1,
};
KineticClient * client = KineticClient_Init(&clientConfig);
if (client == NULL) { return 1; }
const char HmacKeyString[] = "asdfasdf";
KineticSessionConfig sessionConfig = {
.host = "localhost",
.port = KINETIC_PORT,
.clusterVersion = 0,
.identity = 1,
.hmacKey = ByteArray_CreateWithCString(HmacKeyString),
};
KineticStatus status = KineticClient_CreateSession(&sessionConfig, client, &session);
if (status != KINETIC_STATUS_SUCCESS) {
fprintf(stderr, "Failed connecting to the Kinetic device w/status: %s\n",
Kinetic_GetStatusDescription(status));
exit(1);
}
// Create some entries so that we can query the keys
printf("Storing some entries on the device...\n");
const size_t numKeys = 3;
if (!create_entries(session, numKeys)) {
return 2;
}
// Query a range of keys
const size_t keyLen = 64;
uint8_t startKeyData[keyLen], endKeyData[keyLen];
KineticKeyRange range = {
.startKey = ByteBuffer_CreateAndAppendCString(startKeyData, sizeof(startKeyData), "key_prefix_00"),
.endKey = ByteBuffer_CreateAndAppendCString(endKeyData, sizeof(endKeyData), "key_prefix_01"),
.startKeyInclusive = true,
.endKeyInclusive = true,
.maxReturned = 3,
};
uint8_t keysData[numKeys][keyLen];
ByteBuffer keyBuff[] = {
ByteBuffer_Create(&keysData[0], keyLen, 0),
ByteBuffer_Create(&keysData[1], keyLen, 0),
ByteBuffer_Create(&keysData[2], keyLen, 0),
};
ByteBufferArray keys = {.buffers = &keyBuff[0], .count = numKeys};
status = KineticClient_GetKeyRange(session, &range, &keys, NULL);
if (status != KINETIC_STATUS_SUCCESS) {
fprintf(stderr, "FAILURE: Failed retrieving key range from device!\n");
return 3;
}
if (keys.used != 2) {
fprintf(stderr, "FAILURE: Unexpected number of keys in returned range!\n");
return 4;
};
if (keyBuff[0].bytesUsed != strlen("key_prefix_00")) {
fprintf(stderr, "FAILURE: Key 0 length check failed!\n");
return 4;
}
if (keyBuff[1].bytesUsed != strlen("key_prefix_01")) {
fprintf(stderr, "FAILURE: Key 1 length check failed!\n");
return 4;
}
if (keyBuff[2].bytesUsed != 0) {
fprintf(stderr, "FAILURE: Key 2 was not empty as expected!\n");
return 4;
}
// Shutdown client connection and cleanup
KineticClient_DestroySession(session);
KineticClient_Shutdown(client);
printf("Key range retrieved successfully!\n");
return 0;
}
static bool create_entries(KineticSession * const session, const int count)
{
static const ssize_t sz = 20;
char key_buf[sz];
char value_buf[sz];
for (int i = 0; i < count; i++) {
ByteBuffer KeyBuffer = ByteBuffer_CreateAndAppendFormattedCString(key_buf, sz, "key_prefix_%02d", i);
ByteBuffer ValueBuffer = ByteBuffer_CreateAndAppendFormattedCString(value_buf, sz, "val_%02d", i);
/* Populate tag with SHA1 of value */
ByteBuffer put_tag_buf = ByteBuffer_Malloc(20);
uint8_t sha1[20];
SHA1(ValueBuffer.array.data, ValueBuffer.bytesUsed, &sha1[0]);
ByteBuffer_Append(&put_tag_buf, sha1, sizeof(sha1));
KineticEntry entry = {
.key = KeyBuffer,
.value = ValueBuffer,
.tag = put_tag_buf,
.algorithm = KINETIC_ALGORITHM_SHA1,
.force = true,
.synchronization = KINETIC_SYNCHRONIZATION_WRITETHROUGH,
};
KineticStatus status = KineticClient_Put(session, &entry, NULL);
if (KINETIC_STATUS_SUCCESS != status) { return false; }
}
return true;
}
