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_get(session);
// Shutdown client connection and cleanup
KineticClient_DestroySession(session);
KineticClient_Shutdown(client);
return 0;
}
void test_KineticClient_Init_should_initialize_the_message_bus_and_return_a_new_client(void)
{
KineticClient client;
KineticClientConfig config = {
.logFile = "stdout",
.logLevel = 3,
};
KineticCalloc_ExpectAndReturn(1, sizeof(KineticClient), &client);
KineticBus_Init_ExpectAndReturn(&client, &config, true);
KineticClient * result = KineticClient_Init(&config);
TEST_ASSERT_EQUAL(&client, result);
}
void test_KineticClient_Init_should_return_null_if_calloc_returns_null(void)
{
KineticClientConfig config = {
.logFile = "stdout",
.logLevel = 3,
};
KineticCalloc_ExpectAndReturn(1, sizeof(KineticClient), NULL);
KineticClient * result = KineticClient_Init(&config);
TEST_ASSERT_NULL(result);
}
void test_KineticClient_Init_should_free_client_if_bus_init_fails(void)
{
KineticClient client;
KineticClientConfig config = {
.logFile = "stdout",
.logLevel = 3,
};
KineticCalloc_ExpectAndReturn(1, sizeof(KineticClient), &client);
KineticBus_Init_ExpectAndReturn(&client, &config, false);
KineticFree_Expect(&client);
KineticClient * result = KineticClient_Init(&config);
TEST_ASSERT_NULL(result);
}
static void ConnectSession(void)
{
KineticClient client;
client.bus = &MessageBus;
HmacKey = ByteArray_CreateWithCString("some hmac key");
KineticSessionConfig config = {
.host = "localhost",
.port = KINETIC_PORT,
.clusterVersion = ClusterVersion,
.identity = Identity,
.hmacKey = HmacKey,
};
Session.connected = false; // Ensure gets set appropriately by internal connect call
Session.config = config;
KineticSession* session;
KineticAllocator_NewSession_ExpectAndReturn(&MessageBus, &config, &Session);
KineticSession_Create_ExpectAndReturn(&Session, &client, KINETIC_STATUS_SUCCESS);
KineticSession_Connect_ExpectAndReturn(&Session, KINETIC_STATUS_SUCCESS);
KineticStatus status = KineticClient_CreateSession(&config, &client, &session);
TEST_ASSERT_EQUAL_KineticStatus(KINETIC_STATUS_SUCCESS, status);
}
void test_KineticClient_CreateSession_should_configure_a_session_and_connect_to_specified_host(void)
{
ConnectSession();
}
void test_KineticClient_CreateSession_should_return_KINETIC_STATUS_SESSION_EMPTY_upon_NULL_session_config(void)
{
KineticStatus status = KineticClient_CreateSession(NULL, NULL, NULL);
TEST_ASSERT_EQUAL_KineticStatus(KINETIC_STATUS_SESSION_INVALID, status);
}
KineticClient * KineticAdminClient_Init(KineticClientConfig *config)
{
return KineticClient_Init(config);
}
void test_KineticClient_Init_should_initialize_the_logger(void)
{
KineticClient_Init("./some_file.log", 3);
KineticClient_Init("stdout", 1);
KineticClient_Init(NULL, -1);
}
KineticStatus status = KineticAdminClient_SecureErase(Fixture.adminSession, InitPin);
TEST_ASSERT_EQUAL_KineticStatus(KINETIC_STATUS_SUCCESS, status);
}
}
void SystemTestSetupWithIdentity(int log_level, int64_t identity,
const uint8_t *key, size_t key_size)
{
KineticClientConfig clientConfig = {
.logFile = "stdout",
.logLevel = log_level,
};
Fixture = (SystemTestFixture) {
.connected = false,
.client = KineticClient_Init(&clientConfig),
};
KineticSessionConfig config = {
.clusterVersion = SESSION_CLUSTER_VERSION,
.identity = identity,
.hmacKey = ByteArray_Create((void *)key, key_size),
};
strncpy((char*)config.host, GetSystemTestHost1(), sizeof(config.host)-1);
config.port = GetSystemTestPort1();
strncpy((char*)config.keyData, SESSION_HMAC_KEY, sizeof(config.keyData)-1);
KineticStatus status = KineticClient_CreateSession(&config, Fixture.client, &Fixture.session);
TEST_ASSERT_EQUAL_KineticStatus(KINETIC_STATUS_SUCCESS, status);
KineticSessionConfig adminConfig = {
.clusterVersion = SESSION_CLUSTER_VERSION,
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;
}
//------------------------------------------------------------------------------
// Main Entry Point Definition
int main(int argc, char** argv)
{
struct UtilConfig cfg;
memset(&cfg, 0, sizeof(cfg));
// Parse command line options
ParseOptions(argc, argv, &cfg);
if (cfg.opID == OPT_NONE) {
fprintf(stderr, "No operation specified!\n");
PrintUsage(argv[0]);
exit(1);
}
// Create a client instance
KineticClientConfig client_config = {
.logFile = "stdout",
.logLevel = cfg.logLevel,
};
cfg.client = KineticClient_Init(&client_config);
if (cfg.client == NULL) {
fprintf(stderr, "Failed creating a client instance!\n");
return 1;
}
// Establish a session with the Kinetic Device
KineticStatus status = KineticClient_CreateSession(&cfg.config, cfg.client, &cfg.session);
if (status != KINETIC_STATUS_SUCCESS) {
fprintf(stderr, "Failed connecting to host %s:%d (status: %s)\n",
cfg.config.host, cfg.config.port,
Kinetic_GetStatusDescription(status));
return 1;
}
// Establish an admin session with the Kinetic Device
cfg.adminConfig.useSsl = true;
status = KineticClient_CreateSession(&cfg.adminConfig, cfg.client, &cfg.adminSession);
if (status != KINETIC_STATUS_SUCCESS) {
fprintf(stderr, "Failed connecting to host %s:%d (status: %s)\n",
cfg.config.host, cfg.config.port,
Kinetic_GetStatusDescription(status));
return 1;
}
// Execute the specified operation
// ReportConfiguration(cmd, &cfg);
status = ExecuteOperation(&cfg);
if (status != KINETIC_STATUS_SUCCESS) {
fprintf(stderr, "Failed executing operation!\n");
return 1;
}
return 0;
}
static void PrintEntry(KineticEntry * entry)
{
assert(entry);
entry->key.array.data[entry->key.bytesUsed] = '\0';
entry->value.array.data[entry->value.bytesUsed] = '\0';
printf(
"Kinetic Entry:\n"
" key: %s\n"
" value: %s\n",
(char*)entry->key.array.data,
(char*)entry->value.array.data);
}
void test_KineticClient_Init_should_initialize_the_logger(void)
{
KineticClient_Init("./some_file.log");
KineticClient_Init(NULL);
KineticClient_Init("NONE");
}
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);
}
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);
}
// Read in file contents to store
const char* dataFile = "test/support/data/test.data";
struct stat st;
stat(dataFile, &st);
char* buf = malloc(st.st_size);
int fd = open(dataFile, O_RDONLY);
long dataLen = read(fd, buf, st.st_size);
close(fd);
if (dataLen <= 0) {
fprintf(stderr, "Failed reading data file to store: %s\n", dataFile);
exit(-1);
}
write_args* writeArgs = calloc(1, sizeof(write_args));
writeArgs->session = session;
// Create a ByteBuffer for consuming chunks of data out of for overlapped PUTs
writeArgs->data = ByteBuffer_Create(buf, dataLen, 0);
// Configure common meta-data for the entries
struct timeval now;
gettimeofday(&now, NULL);
snprintf(writeArgs->keyPrefix, sizeof(writeArgs->keyPrefix), "%010ld_", now.tv_sec);
ByteBuffer verBuf = ByteBuffer_Create(writeArgs->version, sizeof(writeArgs->version), 0);
ByteBuffer_AppendCString(&verBuf, "v1.0");
ByteBuffer tagBuf = ByteBuffer_Create(writeArgs->tag, sizeof(writeArgs->tag), 0);
ByteBuffer_AppendCString(&tagBuf, "some_value_tag...");
writeArgs->entry = (KineticEntry) {
.key = ByteBuffer_Create(writeArgs->key, sizeof(writeArgs->key), 0),
// .newVersion = verBuf,
.tag = tagBuf,
.algorithm = KINETIC_ALGORITHM_SHA1,
.value = ByteBuffer_Create(writeArgs->value, sizeof(writeArgs->value), 0),
.synchronization = KINETIC_SYNCHRONIZATION_WRITEBACK,
};
strcpy(writeArgs->ip, sessionConfig.host);
// Store the data
printf("\nWriting data file to the Kinetic device...\n");
store_data(writeArgs);
// Shutdown client connection and cleanup
KineticClient_DestroySession(writeArgs->session);
KineticClient_Shutdown(client);
free(writeArgs);
free(buf);
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));
return -1;
}
// Read in file contents to store
const char* dataFile = "test/support/data/test.data";
struct stat st;
stat(dataFile, &st);
char* buf = malloc(st.st_size);
int fd = open(dataFile, O_RDONLY);
long dataLen = read(fd, buf, st.st_size);
close(fd);
if (dataLen <= 0) {
fprintf(stderr, "Failed reading data file to store: %s\n", dataFile);
exit(-1);
}
write_args* writeArgs = calloc(NUM_FILES, sizeof(write_args));
if (writeArgs == NULL) {
fprintf(stderr, "Failed allocating overlapped thread arguments!\n");
}
// Kick off a thread for each file to store
for (int i = 0; i < NUM_FILES; i++) {
// Establish connection
status = KineticClient_CreateSession(&sessionConfig, client, &writeArgs[i].session);
if (status != KINETIC_STATUS_SUCCESS) {
fprintf(stderr, "Failed connecting to the Kinetic device w/status: %s\n",
Kinetic_GetStatusDescription(status));
return -1;
}
strcpy(writeArgs[i].ip, sessionConfig.host);
// Create a ByteBuffer for consuming chunks of data out of for overlapped PUTs
writeArgs[i].data = ByteBuffer_Create(buf, dataLen, 0);
// Configure common entry attributes
struct timeval now;
gettimeofday(&now, NULL);
snprintf(writeArgs[i].keyPrefix, sizeof(writeArgs[i].keyPrefix), "%010llu_%02d_",
(unsigned long long)now.tv_sec, i);
ByteBuffer valBuf = ByteBuffer_Create(writeArgs[i].value, sizeof(writeArgs[i].value), 0);
writeArgs[i].entry = (KineticEntry) {
.key = ByteBuffer_CreateAndAppendCString(
writeArgs[i].key, sizeof(writeArgs[i].key), writeArgs[i].keyPrefix),
.tag = ByteBuffer_CreateAndAppendCString(
writeArgs[i].tag, sizeof(writeArgs[i].tag), "some_value_tag..."),
.algorithm = KINETIC_ALGORITHM_SHA1,
.value = valBuf,
};
// Store the entry
int threadCreateStatus = pthread_create(&writeArgs[i].threadID, NULL, store_data, &writeArgs[i]);
REPORT_ERRNO(threadCreateStatus, "pthread_create");
if (threadCreateStatus != 0) {
fprintf(stderr, "pthread create failed!\n");
exit(-2);
}
}
// Wait for all PUT operations to complete and cleanup
for (int i = 0; i < NUM_FILES; i++) {
int joinStatus = pthread_join(writeArgs[i].threadID, NULL);
if (joinStatus != 0) {
fprintf(stderr, "pthread join failed!\n");
}
KineticClient_DestroySession(writeArgs[i].session);
}
// Shutdown client connection and cleanup
KineticClient_Shutdown(client);
free(writeArgs);
free(buf);
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);
}
// 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;
}
