void setUp(void)
{
SystemTestSetup(1, false);
uint8_t version_data[DEFAULT_SIZE], tag_data[DEFAULT_SIZE];
ByteBuffer version_buffer, tag_buffer;
version_buffer = ByteBuffer_CreateAndAppendCString(version_data, sizeof(version_data), "v1.0");
tag_buffer = ByteBuffer_CreateAndAppendCString(tag_data, sizeof(tag_data), "SomeTagValue");
ByteBuffer key_buffers[TOTAL_PUT_KEYS];
ByteBuffer value_buffers[TOTAL_PUT_KEYS];
unsigned int i;
for (i=0; i<TOTAL_PUT_KEYS; i++)
{
key_buffers[i] = generate_entry_key_by_index(i);
printf("key: %s", (char *)key_buffers[i].array.data);
value_buffers[i] = generate_entry_value_by_index(i);
KineticEntry putEntry = {
.key = key_buffers[i],
.tag = tag_buffer,
.newVersion = version_buffer,
.algorithm = KINETIC_ALGORITHM_SHA1,
.value = value_buffers[i],
.force = true,
.synchronization = KINETIC_SYNCHRONIZATION_WRITETHROUGH,
};
KineticStatus status = KineticClient_Put(Fixture.session, &putEntry, NULL);
TEST_ASSERT_EQUAL_KineticStatus(KINETIC_STATUS_SUCCESS, status);
ByteBuffer_Free(key_buffers[i]);
ByteBuffer_Free(value_buffers[i]);
}
}
void tearDown(void)
{
SystemTestShutDown();
}
void test_media_scan_should_succeed_for_existing_key_range(void)
{
KineticMediaScan_Operation mediascan_operation = {"my_key 1","my_key 5", true, true};
KineticCommand_Priority priority = PRIORITY_NORMAL;
KineticStatus status = KineticAdminClient_MediaScan(Fixture.session, &mediascan_operation, priority);
TEST_ASSERT_EQUAL_KineticStatus(KINETIC_STATUS_SUCCESS, status);
}
void test_put_get_delete_one_entry_by_one_entry(void)
{
uint8_t version_data[DEFAULT_BUFFER_SIZE], tag_data[DEFAULT_BUFFER_SIZE], value_data[DEFAULT_BUFFER_SIZE];
ByteBuffer version_buffer, tag_buffer, value_buffer;
version_buffer = ByteBuffer_CreateAndAppendCString(version_data, sizeof(version_data), "v1.0");
ExpectedVersionBuffer = ByteBuffer_CreateAndAppendCString(version_data, sizeof(version_data), "v1.0");
tag_buffer = ByteBuffer_CreateAndAppendCString(tag_data, sizeof(tag_data), "SomeTagValue");
ExpectedTagBuffer = ByteBuffer_CreateAndAppendCString(tag_data, sizeof(tag_data), "SomeTagValue");
value_buffer = ByteBuffer_Create(value_data, DEFAULT_BUFFER_SIZE, 0);
unsigned int i;
for (i=0; i<KV_PAIRS_PER_GROUP; i++)
{
// put object
KineticEntry putEntry = {
.key = generate_entry_key_by_index(i),
.tag = tag_buffer,
.newVersion = version_buffer,
.algorithm = KINETIC_ALGORITHM_SHA1,
.value = generate_entry_value_by_index(i),
.force = true,
.synchronization = KINETIC_SYNCHRONIZATION_WRITETHROUGH,
};
KineticStatus status = KineticClient_Put(Fixture.session, &putEntry, NULL);
TEST_ASSERT_EQUAL_KineticStatus(KINETIC_STATUS_SUCCESS, status);
ByteBuffer_Reset(&value_buffer);
// get object
value_buffer = ByteBuffer_Create(value_data, DEFAULT_BUFFER_SIZE, 0);
KineticEntry getEntry = {
.key = generate_entry_key_by_index(i),
.dbVersion = version_buffer,
.tag = tag_buffer,
.value = value_buffer,
};
status = KineticClient_Get(Fixture.session, &getEntry, NULL);
TEST_ASSERT_EQUAL_KineticStatus(KINETIC_STATUS_SUCCESS, status);
TEST_ASSERT_EQUAL_ByteBuffer(ExpectedVersionBuffer, getEntry.dbVersion);
TEST_ASSERT_ByteBuffer_NULL(getEntry.newVersion);
TEST_ASSERT_EQUAL_ByteBuffer(generate_entry_key_by_index(i), getEntry.key);
TEST_ASSERT_EQUAL_ByteBuffer(ExpectedTagBuffer, getEntry.tag);
TEST_ASSERT_EQUAL(KINETIC_ALGORITHM_SHA1, getEntry.algorithm);
TEST_ASSERT_EQUAL_ByteBuffer(generate_entry_value_by_index(i), getEntry.value);
TEST_ASSERT_EQUAL_ByteBuffer(ExpectedVersionBuffer, version_buffer);
// delete object
KineticEntry deleteEntry = {
.key = generate_entry_key_by_index(i),
.dbVersion = version_buffer,
};
TEST_ASSERT_EQUAL_ByteBuffer(ExpectedVersionBuffer, version_buffer);
status = KineticClient_Delete(Fixture.session, &deleteEntry, NULL);
TEST_ASSERT_EQUAL_KineticStatus(KINETIC_STATUS_SUCCESS, status);
TEST_ASSERT_EQUAL(0, deleteEntry.value.bytesUsed);
// get object again
status = KineticClient_Get(Fixture.session, &getEntry, NULL);
TEST_ASSERT_EQUAL_KineticStatus(KINETIC_STATUS_NOT_FOUND, status);
}
}
void test_put_get_delete_one_group_by_one_group(void)
{
uint8_t version_data[DEFAULT_BUFFER_SIZE], tag_data[DEFAULT_BUFFER_SIZE], value_data[DEFAULT_BUFFER_SIZE];
ByteBuffer version_buffer, tag_buffer, value_buffer;
version_buffer = ByteBuffer_CreateAndAppendCString(version_data, sizeof(version_data), "v1.0");
ExpectedVersionBuffer = ByteBuffer_CreateAndAppendCString(version_data, sizeof(version_data), "v1.0");
tag_buffer = ByteBuffer_CreateAndAppendCString(tag_data, sizeof(tag_data), "SomeTagValue");
ExpectedTagBuffer = ByteBuffer_CreateAndAppendCString(tag_data, sizeof(tag_data), "SomeTagValue");
value_buffer = ByteBuffer_Create(value_data, DEFAULT_BUFFER_SIZE, 0);
unsigned int i, j;
for (i =0; i<TOTAL_GROUPS; i++)
{
KineticStatus status;
// put a group of entries
for (j=0; j<KV_PAIRS_PER_GROUP; j++)
{
KineticEntry putEntry = {
.key = generate_entry_key_by_index(i*KV_PAIRS_PER_GROUP + j),
.tag = tag_buffer,
.newVersion = version_buffer,
.algorithm = KINETIC_ALGORITHM_SHA1,
.value = generate_entry_value_by_index(i*KV_PAIRS_PER_GROUP + j),
.force = true,
.synchronization = KINETIC_SYNCHRONIZATION_WRITETHROUGH,
};
status = KineticClient_Put(Fixture.session, &putEntry, NULL);
TEST_ASSERT_EQUAL_KineticStatus(KINETIC_STATUS_SUCCESS, status);
}
// get key_range
KineticKeyRange range = {
.startKey = generate_entry_key_by_index(i*KV_PAIRS_PER_GROUP),
.endKey = generate_entry_key_by_index(i*KV_PAIRS_PER_GROUP + KV_PAIRS_PER_GROUP -1),
.startKeyInclusive = true,
.endKeyInclusive = true,
.maxReturned = KV_PAIRS_PER_GROUP,
};
ByteBuffer keyBuff[KV_PAIRS_PER_GROUP];
uint8_t keysData[KV_PAIRS_PER_GROUP][DEFAULT_BUFFER_SIZE];
for (j = 0; j < KV_PAIRS_PER_GROUP; j++) {
memset(&keysData[j], 0, DEFAULT_BUFFER_SIZE);
keyBuff[j] = ByteBuffer_Create(&keysData[j], DEFAULT_BUFFER_SIZE, 0);
}
ByteBufferArray keys = {.buffers = keyBuff, .count = KV_PAIRS_PER_GROUP, .used = 0};
status = KineticClient_GetKeyRange(Fixture.session, &range, &keys, NULL);
TEST_ASSERT_EQUAL_KineticStatus(KINETIC_STATUS_SUCCESS, status);
TEST_ASSERT_EQUAL(KV_PAIRS_PER_GROUP, keys.used);
for (j = 0; j < KV_PAIRS_PER_GROUP; j++)
{
TEST_ASSERT_EQUAL_ByteBuffer(generate_entry_key_by_index(i*KV_PAIRS_PER_GROUP + j), keys.buffers[j]);
}
// delete a group of entries
for (j=0; j<KV_PAIRS_PER_GROUP; j++)
{
ByteBuffer_Reset(&value_buffer);
// get object
value_buffer = ByteBuffer_Create(value_data, DEFAULT_BUFFER_SIZE, 0);
KineticEntry getEntry = {
.key = generate_entry_key_by_index(i*KV_PAIRS_PER_GROUP + j),
.dbVersion = version_buffer,
.tag = tag_buffer,
.value = value_buffer,
};
status = KineticClient_Get(Fixture.session, &getEntry, NULL);
TEST_ASSERT_EQUAL_KineticStatus(KINETIC_STATUS_SUCCESS, status);
TEST_ASSERT_EQUAL_ByteBuffer(ExpectedVersionBuffer, getEntry.dbVersion);
TEST_ASSERT_ByteBuffer_NULL(getEntry.newVersion);
TEST_ASSERT_EQUAL_ByteBuffer(generate_entry_key_by_index(i*KV_PAIRS_PER_GROUP + j), getEntry.key);
TEST_ASSERT_EQUAL_ByteBuffer(ExpectedTagBuffer, getEntry.tag);
TEST_ASSERT_EQUAL(KINETIC_ALGORITHM_SHA1, getEntry.algorithm);
TEST_ASSERT_EQUAL_ByteBuffer(generate_entry_value_by_index(i*KV_PAIRS_PER_GROUP + j), getEntry.value);
TEST_ASSERT_EQUAL_ByteBuffer(ExpectedVersionBuffer, version_buffer);
}
// delete a group of entries
for (j=0; j<KV_PAIRS_PER_GROUP; j++)
{
// delete object
KineticEntry deleteEntry = {
.key = generate_entry_key_by_index(i*KV_PAIRS_PER_GROUP + j),
.dbVersion = version_buffer,
};
TEST_ASSERT_EQUAL_ByteBuffer(ExpectedVersionBuffer, version_buffer);
status = KineticClient_Delete(Fixture.session, &deleteEntry, NULL);
TEST_ASSERT_EQUAL_KineticStatus(KINETIC_STATUS_SUCCESS, status);
TEST_ASSERT_EQUAL(0, deleteEntry.value.bytesUsed);
// get object again
ByteBuffer_Reset(&value_buffer);
// get object
value_buffer = ByteBuffer_Create(value_data, DEFAULT_BUFFER_SIZE, 0);
KineticEntry getEntry = {
.key = generate_entry_key_by_index(i*KV_PAIRS_PER_GROUP + j),
.dbVersion = version_buffer,
.tag = tag_buffer,
.value = value_buffer,
};
status = KineticClient_Get(Fixture.session, &getEntry, NULL);
TEST_ASSERT_EQUAL_KineticStatus(KINETIC_STATUS_NOT_FOUND, status);
}
}
}
void test_Flush_should_flush_pending_PUTs_and_DELETEs(void)
{
// Arguments shared between entries
uint8_t TagData[1024];
ByteBuffer tagBuffer = ByteBuffer_CreateAndAppendCString(TagData, sizeof(TagData), "tag_val");
uint8_t key1[10];
ByteBuffer keyBuffer1 = ByteBuffer_CreateAndAppendCString(key1, sizeof(key1), "key1");
uint8_t value1[10];
ByteBuffer valueBuffer1 = ByteBuffer_CreateAndAppendCString(value1, sizeof(value1), "value1");
uint8_t key2[10];
ByteBuffer keyBuffer2 = ByteBuffer_CreateAndAppendCString(key2, sizeof(key2), "key2");
uint8_t value2[10];
ByteBuffer valueBuffer2 = ByteBuffer_CreateAndAppendCString(value2, sizeof(value2), "value2");
// Do a blocking PUT ("key1" => "value1") so we can delete it later
KineticEntry Entry = (KineticEntry) {
.key = keyBuffer1,
.tag = tagBuffer,
.algorithm = KINETIC_ALGORITHM_SHA1,
.value = valueBuffer1,
.synchronization = KINETIC_SYNCHRONIZATION_WRITEBACK,
.force = true,
};
KineticStatus status = KineticClient_Put(Fixture.session, &Entry, NULL);
TEST_ASSERT_EQUAL_KineticStatus(KINETIC_STATUS_SUCCESS, status);
Entry = (KineticEntry) {
.key = keyBuffer2,
.tag = tagBuffer,
.algorithm = KINETIC_ALGORITHM_SHA1,
.value = valueBuffer2,
.synchronization = KINETIC_SYNCHRONIZATION_WRITEBACK,
.force = true,
};
status = KineticClient_Put(Fixture.session, &Entry, NULL);
TEST_ASSERT_EQUAL_KineticStatus(KINETIC_STATUS_SUCCESS, status);
// Do an async DELETE so we can flush to complete it
KineticEntry deleteEntry = {
.key = keyBuffer1,
.synchronization = KINETIC_SYNCHRONIZATION_WRITETHROUGH,
};
KineticCompletionClosure no_op_closure = {
.callback = &no_op_callback,
};
status = KineticClient_Delete(Fixture.session, &deleteEntry, &no_op_closure);
/* Now do a blocking flush and confirm that (key1,value1) has been
* DELETEd and (key2,value2) have been PUT. */
status = KineticClient_Flush(Fixture.session, NULL);
TEST_ASSERT_EQUAL_KineticStatus(KINETIC_STATUS_SUCCESS, status);
// GET key1 --> expect NOT FOUND
KineticEntry getEntry1 = {
.key = keyBuffer1,
.tag = tagBuffer,
.value = valueBuffer1,
};
status = KineticClient_Get(Fixture.session, &getEntry1, NULL);
TEST_ASSERT_EQUAL_KineticStatus(KINETIC_STATUS_NOT_FOUND, status);
// GET key2 --> present
KineticEntry getEntry2 = {
.key = keyBuffer2,
.tag = tagBuffer,
.value = valueBuffer2,
};
status = KineticClient_Get(Fixture.session, &getEntry2, NULL);
TEST_ASSERT_EQUAL_KineticStatus(KINETIC_STATUS_SUCCESS, status);
}
void setUp(void)
{
SystemTestSetup(0, true);
KeyBuffer = ByteBuffer_CreateAndAppendCString(KeyData, sizeof(KeyData), strKey);
ExpectedKeyBuffer = ByteBuffer_CreateAndAppendCString(ExpectedKeyData, sizeof(ExpectedKeyData), strKey);
TagBuffer = ByteBuffer_CreateAndAppendCString(TagData, sizeof(TagData), "SomeTagValue");
ExpectedTagBuffer = ByteBuffer_CreateAndAppendCString(ExpectedTagData, sizeof(ExpectedTagData), "SomeTagValue");
TestValue = ByteArray_CreateWithCString("lorem ipsum... blah blah blah... etc.");
ValueBuffer = ByteBuffer_CreateAndAppendArray(ValueData, sizeof(ValueData), TestValue);
// Setup to write some test data
KineticEntry putEntry = {
.key = KeyBuffer,
.tag = TagBuffer,
.algorithm = KINETIC_ALGORITHM_SHA1,
.value = ValueBuffer,
.force = true,
.synchronization = KINETIC_SYNCHRONIZATION_FLUSH,
};
KineticStatus status = KineticClient_Put(Fixture.session, &putEntry, NULL);
if (status != KINETIC_STATUS_SUCCESS) {
failing = true;
TEST_ASSERT_EQUAL_KineticStatus(KINETIC_STATUS_SUCCESS, status);
}
// Validate the object exists initially
KineticEntry getEntry = {
.key = KeyBuffer,
.tag = TagBuffer,
.algorithm = KINETIC_ALGORITHM_SHA1,
.value = ValueBuffer,
.force = true,
.synchronization = KINETIC_SYNCHRONIZATION_WRITETHROUGH,
};
status = KineticClient_Get(Fixture.session, &getEntry, NULL);
TEST_ASSERT_EQUAL_KineticStatus(KINETIC_STATUS_SUCCESS, status);
TEST_ASSERT_EQUAL_ByteArray(putEntry.key.array, getEntry.key.array);
TEST_ASSERT_EQUAL_ByteArray(putEntry.tag.array, getEntry.tag.array);
TEST_ASSERT_EQUAL(putEntry.algorithm, getEntry.algorithm);
TEST_ASSERT_EQUAL_ByteBuffer(putEntry.value, getEntry.value);
TEST_ASSERT_EQUAL_KineticStatus(KINETIC_STATUS_SUCCESS, status);
// Set the erase PIN to something non-empty
strcpy(NewPinData, SESSION_PIN);
OldPin = ByteArray_Create(OldPinData, 0);
NewPin = ByteArray_Create(NewPinData, strlen(NewPinData));
status = KineticAdminClient_SetErasePin(Fixture.adminSession,
OldPin, NewPin);
TEST_ASSERT_EQUAL_KineticStatus(KINETIC_STATUS_SUCCESS, status);
}
void tearDown(void)
{
KineticStatus status = KINETIC_STATUS_INVALID;
if (failing) { return; }
// Validate the object no longer exists
KineticEntry regetEntryMetadata = {
.key = KeyBuffer,
.tag = TagBuffer,
.metadataOnly = true,
};
status = KineticClient_Get(Fixture.session, ®etEntryMetadata, NULL);
TEST_ASSERT_EQUAL_KineticStatus(KINETIC_STATUS_NOT_FOUND, status);
TEST_ASSERT_ByteArray_EMPTY(regetEntryMetadata.value.array);
SystemTestShutDown();
}
void test_SecureErase_should_erase_device_contents(void)
{
KineticStatus status = KineticAdminClient_SecureErase(Fixture.adminSession, NewPin);
TEST_ASSERT_EQUAL_KineticStatus(KINETIC_STATUS_SUCCESS, status);
}
void test_InstantErase_should_erase_device_contents(void)
{
KineticStatus status = KineticAdminClient_InstantErase(Fixture.adminSession, NewPin);
TEST_ASSERT_EQUAL_KineticStatus(KINETIC_STATUS_SUCCESS, status);
}
void setUp(void)
{
NewPinSet = false;
Locked = false;
SystemTestSetup(1, true);
KeyBuffer = ByteBuffer_CreateAndAppendCString(KeyData, sizeof(KeyData), strKey);
ExpectedKeyBuffer = ByteBuffer_CreateAndAppendCString(ExpectedKeyData, sizeof(ExpectedKeyData), strKey);
TagBuffer = ByteBuffer_CreateAndAppendCString(TagData, sizeof(TagData), "SomeTagValue");
ExpectedTagBuffer = ByteBuffer_CreateAndAppendCString(ExpectedTagData, sizeof(ExpectedTagData), "SomeTagValue");
TestValue = ByteArray_CreateWithCString("lorem ipsum... blah blah blah... etc.");
ValueBuffer = ByteBuffer_CreateAndAppendArray(ValueData, sizeof(ValueData), TestValue);
// Setup to write some test data
KineticEntry putEntry = {
.key = KeyBuffer,
.tag = TagBuffer,
.algorithm = KINETIC_ALGORITHM_SHA1,
.value = ValueBuffer,
.force = true,
.synchronization = KINETIC_SYNCHRONIZATION_FLUSH,
};
KineticStatus status = KineticClient_Put(Fixture.session, &putEntry, NULL);
// Validate the object exists initially
KineticEntry getEntry = {
.key = KeyBuffer,
.tag = TagBuffer,
.algorithm = KINETIC_ALGORITHM_SHA1,
.value = ValueBuffer,
.force = true,
.synchronization = KINETIC_SYNCHRONIZATION_WRITETHROUGH,
};
status = KineticClient_Get(Fixture.session, &getEntry, NULL);
TEST_ASSERT_EQUAL_KineticStatus(KINETIC_STATUS_SUCCESS, status);
TEST_ASSERT_EQUAL_ByteArray(putEntry.key.array, getEntry.key.array);
TEST_ASSERT_EQUAL_ByteArray(putEntry.tag.array, getEntry.tag.array);
TEST_ASSERT_EQUAL(putEntry.algorithm, getEntry.algorithm);
TEST_ASSERT_EQUAL_ByteBuffer(putEntry.value, getEntry.value);
TEST_ASSERT_EQUAL_KineticStatus(KINETIC_STATUS_SUCCESS, status);
// Set the erase PIN to something non-empty
strcpy(NewPinData, SESSION_PIN);
OldPin = ByteArray_Create(OldPinData, 0);
NewPin = ByteArray_Create(NewPinData, strlen(NewPinData));
status = KineticAdminClient_SetLockPin(Fixture.adminSession,
OldPin, NewPin);
TEST_ASSERT_EQUAL_KineticStatus(KINETIC_STATUS_SUCCESS, status);
NewPinSet = true;
}
void tearDown(void)
{
KineticStatus status;
// Unlock if for some reason we are still locked in order to
// prevent the device from staying in a locked/unusable state
if (Locked) {
status = KineticAdminClient_UnlockDevice(Fixture.adminSession, NewPin);
TEST_ASSERT_EQUAL_KineticStatus(KINETIC_STATUS_SUCCESS, status);
Locked = false;
}
// Set the lock PIN back to empty
if (NewPinSet) {
status = KineticAdminClient_SetLockPin(Fixture.adminSession, NewPin, OldPin);
TEST_ASSERT_EQUAL_KineticStatus(KINETIC_STATUS_SUCCESS, status);
NewPinSet = false;
}
SystemTestShutDown();
}
void test_KineticAdmin_should_lock_and_unlock_a_device(void)
{
KineticStatus status;
status = KineticAdminClient_LockDevice(Fixture.adminSession, NewPin);
TEST_ASSERT_EQUAL_KineticStatus(KINETIC_STATUS_SUCCESS, status);
Locked = true;
/* Currently, the device appears to just hang up on us rather than
* returning DEVICE_LOCKED (unlike the simulator). Some sort of
* command here to confirm that the device lock succeeded would
* be a better test. We need to check if the drive has another
* interface that exposes this. */
if (SystemTestIsUnderSimulator()) {
// Validate the object cannot being accessed while locked
KineticEntry getEntry = {
.key = KeyBuffer,
.tag = TagBuffer,
.value = ValueBuffer,
.force = true,
};
status = KineticClient_Get(Fixture.session, &getEntry, NULL);
TEST_ASSERT_EQUAL_KineticStatus(KINETIC_STATUS_DEVICE_LOCKED, status);
}
status = KineticAdminClient_UnlockDevice(Fixture.adminSession, NewPin);
TEST_ASSERT_EQUAL_KineticStatus(KINETIC_STATUS_SUCCESS, status);
Locked = false;
}
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;
}
void ConfigureEntry(struct UtilConfig * cfg, const char* key, const char* tag,
const char* version, KineticAlgorithm algorithm, bool force, const char* value)
{
assert(cfg != NULL);
// Setup to write some test data
cfg->entry = (KineticEntry) {
.key = ByteBuffer_CreateAndAppendCString(cfg->keyData, sizeof(cfg->keyData), key),
.tag = ByteBuffer_CreateAndAppendCString(cfg->tagData, sizeof(cfg->tagData), tag),
.newVersion = ByteBuffer_CreateAndAppendCString(cfg->newVersionData, sizeof(cfg->newVersionData), version),
.dbVersion = ByteBuffer_Create(cfg->versionData, sizeof(cfg->versionData), 0),
.algorithm = algorithm,
.value = ByteBuffer_CreateAndAppendCString(cfg->valueData, sizeof(cfg->valueData), value),
.force = force,
};
}
int ParseOptions(
const int argc,
char** const argv,
struct UtilConfig * cfg)
{
// Create an ArgP processor to parse arguments
struct {
OptionID opID;
int logLevel;
char host[HOST_NAME_MAX];
int port;
int tlsPort;
int64_t clusterVersion;
int64_t identity;
char hmacKey[KINETIC_MAX_KEY_LEN];
char logType[64];
char deviceLogName[64];
char key[64];
char version[64];
char tag[64];
KineticAlgorithm algorithm;
bool force;
char value[1024];
} opts = {
.logLevel = 0,
.host = "localhost",
.port = KINETIC_PORT,
.tlsPort = KINETIC_TLS_PORT,
.clusterVersion = 0,
.identity = 1,
.hmacKey = "asdfasdf",
.logType = "utilizations",
.key = "foo",
.tag = "SomeTagValue",
.algorithm = KINETIC_ALGORITHM_SHA1,
.force = true,
.value = "Hello!",
};
// Create configuration for long format options
struct option long_options[] = {
// Help
{"help", no_argument, 0, OPT_HELP},
// Commands
{"noop", no_argument, 0, OPT_NOOP},
{"put", no_argument, 0, OPT_PUT},
{"get", no_argument, 0, OPT_GET},
{"delete", no_argument, 0, OPT_DELETE},
{"getnext", no_argument, 0, OPT_GETNEXT},
{"getprevious", no_argument, 0, OPT_GETPREVIOUS},
{"getlog", no_argument, 0, OPT_GETLOG},
{"getdevicespecificlog", no_argument, 0, OPT_GETDEVICESPECIFICLOG},
{"seterasepin", no_argument, 0, OPT_SETERASEPIN},
{"instanterase", no_argument, 0, OPT_INSTANTERASE},
{"secureerase", no_argument, 0, OPT_SECUREERASE},
{"setlockpin", no_argument, 0, OPT_SETLOCKPIN},
{"lockdevice", no_argument, 0, OPT_LOCKDEVICE},
{"unlockdevice", no_argument, 0, OPT_UNLOCKDEVICE},
{"setclusterversion", no_argument, 0, OPT_SETCLUSTERVERSION},
{"setacl", no_argument, 0, OPT_SETACL},
{"updatefirmware", no_argument, 0, OPT_UPDATEFIRMWARE},
// Options
{"loglevel", required_argument, 0, OPT_LOGLEVEL},
{"host", required_argument, 0, OPT_HOST},
{"port", required_argument, 0, OPT_PORT},
{"tlsport", required_argument, 0, OPT_TLSPORT},
{"identity", required_argument, 0, OPT_IDENTITY},
{"hmackey", required_argument, 0, OPT_HMACKEY},
{"clusterversion", required_argument, 0, OPT_CLUSTERVERSION},
{"file", required_argument, 0, OPT_FILE},
{"newclusterversion", required_argument, 0, OPT_NEWCLUSTERVERSION},
{"pin", required_argument, 0, OPT_PIN},
{"newpin", required_argument, 0, OPT_NEWPIN},
{"logtype", required_argument, 0, OPT_LOGTYPE},
{"devicelogname", required_argument, 0, OPT_DEVICELOGNAME},
{"key", required_argument, 0, OPT_KEY},
{"value", required_argument, 0, OPT_VALUE},
{0, 0, 0, 0},
};
// Parse the options from the command line
extern char *optarg;
extern int optind;
int option, optionIndex = 0;
while ((option = getopt_long(argc, argv, "?lhptics:", long_options, &optionIndex)) != -1) {
switch (option) {
case 0:
// If this option, just set the flag
if (long_options[optionIndex].flag != 0) {break;}
// assert(false);
// break;
case OPT_LOGLEVEL:
opts.logLevel = atoi(optarg);
break;
case OPT_HOST:
strncpy(opts.host, optarg, sizeof(opts.host));
break;
case OPT_PORT:
opts.port = atoi(optarg);
break;
case OPT_TLSPORT:
opts.tlsPort = atoi(optarg);
break;
case OPT_IDENTITY:
opts.identity = atoi(optarg);
break;
case OPT_HMACKEY:
strncpy(opts.hmacKey, optarg, sizeof(opts.hmacKey)-1);
break;
case OPT_KEY:
strncpy(opts.key, optarg, sizeof(opts.key)-1);
break;
case OPT_VALUE:
strncpy(opts.value, optarg, sizeof(opts.value)-1);
break;
case OPT_CLUSTERVERSION:
opts.clusterVersion = (int64_t)atol(optarg);
break;
case OPT_NEWCLUSTERVERSION:
cfg->newClusterVersion = (int64_t)atol(optarg);
break;
case OPT_FILE:
strncpy(cfg->file, optarg, sizeof(cfg->file)-1);
break;
case OPT_PIN:
strncpy(cfg->pin, optarg, sizeof(cfg->pin)-1);
break;
case OPT_NEWPIN:
strncpy(cfg->newPin, optarg, sizeof(cfg->newPin)-1);
break;
case OPT_LOGTYPE:
strncpy(opts.logType, optarg, sizeof(opts.logType)-1);
break;
case OPT_DEVICELOGNAME:
strncpy(cfg->deviceLogName, optarg, sizeof(cfg->deviceLogName)-1);
break;
case OPT_NOOP:
case OPT_PUT:
case OPT_GET:
case OPT_DELETE:
case OPT_GETNEXT:
case OPT_GETPREVIOUS:
case OPT_GETLOG:
case OPT_GETDEVICESPECIFICLOG:
case OPT_SETERASEPIN:
case OPT_INSTANTERASE:
case OPT_SECUREERASE:
case OPT_SETLOCKPIN:
case OPT_LOCKDEVICE:
case OPT_UNLOCKDEVICE:
case OPT_SETCLUSTERVERSION:
case OPT_SETACL:
case OPT_UPDATEFIRMWARE:
if ((int)opts.opID == 0) {
opts.opID = option;
break;
}
fprintf(stderr, "Multiple operations specified!\n");
PrintUsage(argv[0]);
exit(-1);
case OPT_HELP:
PrintUsage(argv[0]);
exit(0);
default:
PrintUsage(argv[0]);
exit(-1);
}
}
// Configure client
cfg->logLevel = opts.logLevel;
// Configure session
cfg->config = (KineticSessionConfig) {
.port = opts.port,
.clusterVersion = opts.clusterVersion,
.identity = opts.identity,
.hmacKey = ByteArray_Create(cfg->hmacKeyData, strlen(opts.hmacKey)),
};
memcpy(cfg->hmacKeyData, opts.hmacKey, strlen(opts.hmacKey));
strncpy(cfg->config.host, opts.host, sizeof(cfg->config.host)-1);
// Configure admin session
cfg->adminConfig = cfg->config;
cfg->adminConfig.port = opts.tlsPort;
cfg->adminConfig.useSsl = true;
// Populate and configure the entry to be used for operations
ConfigureEntry(cfg,
opts.key, opts.tag, opts.version, opts.algorithm, opts.force, opts.value);
cfg->opID = opts.opID;
// Parse log type from string
if (strcmp("utilizations", opts.logType) == 0) {
cfg->logType = KINETIC_DEVICE_INFO_TYPE_UTILIZATIONS;
}
else if (strcmp("temperatures", opts.logType) == 0) {
cfg->logType = KINETIC_DEVICE_INFO_TYPE_TEMPERATURES;
}
else if (strcmp("capacities", opts.logType) == 0) {
cfg->logType = KINETIC_DEVICE_INFO_TYPE_CAPACITIES;
}
else if (strcmp("configuration", opts.logType) == 0) {
cfg->logType = KINETIC_DEVICE_INFO_TYPE_CONFIGURATION;
}
else if (strcmp("statistics", opts.logType) == 0) {
cfg->logType = KINETIC_DEVICE_INFO_TYPE_STATISTICS;
}
else if (strcmp("messages", opts.logType) == 0) {
cfg->logType = KINETIC_DEVICE_INFO_TYPE_MESSAGES;
}
else if (strcmp("limits", opts.logType) == 0) {
cfg->logType = KINETIC_DEVICE_INFO_TYPE_LIMITS;
}
else {
fprintf(stderr, "Invalid log info type: %s\n", opts.logType);
exit(1);
}
return optind;
}
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;
}
