KineticStatus KineticClient_Put(KineticSession* const session,
KineticEntry* const entry,
KineticCompletionClosure* closure)
{
KINETIC_ASSERT(session);
KINETIC_ASSERT(entry);
// Assert non-NULL value upon non-zero length
if (entry->value.array.len > 0) {
KINETIC_ASSERT(entry->value.array.data);
}
KineticOperation* operation = KineticAllocator_NewOperation(session);
if (operation == NULL) {return KINETIC_STATUS_MEMORY_ERROR;}
KINETIC_ASSERT(operation->session == session);
// Initialize request
KineticStatus status = KineticBuilder_BuildPut(operation, entry);
if (status != KINETIC_STATUS_SUCCESS) {
KineticAllocator_FreeOperation(operation);
return status;
}
// Execute the operation
KineticStatus res = KineticController_ExecuteOperation(operation, closure);
return res;
}
KineticStatus KineticAdminClient_SetACL(KineticSession * const session,
const char *ACLPath) {
KINETIC_ASSERT(session != NULL);
if (ACLPath == NULL) {
return KINETIC_STATUS_INVALID_REQUEST;
}
#ifndef TEST
struct ACL *ACLs = NULL;
#endif
KineticACLLoadResult acl_res = KineticACL_LoadFromFile(ACLPath, &ACLs);
if (acl_res != ACL_OK) {
return KINETIC_STATUS_ACL_ERROR;
}
KineticOperation* operation = KineticAllocator_NewOperation(session);
if (operation == NULL) {
printf("!operation\n");
return KINETIC_STATUS_MEMORY_ERROR;
}
// Initialize request
KineticBuilder_BuildSetACL(operation, ACLs);
KineticStatus status = KineticController_ExecuteOperation(operation, NULL);
return status;
}
static KineticStatus KineticClient_CreateOperation(
KineticOperation** operation,
KineticSessionHandle handle)
{
if (handle == KINETIC_HANDLE_INVALID) {
LOG0("Specified session has invalid handle value");
return KINETIC_STATUS_SESSION_EMPTY;
}
KineticConnection* connection = KineticConnection_FromHandle(handle);
if (connection == NULL) {
LOG0("Specified session is not associated with a connection");
return KINETIC_STATUS_SESSION_INVALID;
}
LOGF1("\n"
"--------------------------------------------------\n"
"Building new operation on connection @ 0x%llX", connection);
*operation = KineticAllocator_NewOperation(connection);
if (*operation == NULL) {
return KINETIC_STATUS_MEMORY_ERROR;
}
if ((*operation)->request == NULL) {
return KINETIC_STATUS_NO_PDUS_AVAVILABLE;
}
return KINETIC_STATUS_SUCCESS;
}
KineticStatus KineticClient_NoOp(KineticSession* const session)
{
KINETIC_ASSERT(session);
KineticOperation* operation = KineticAllocator_NewOperation(session);
if (operation == NULL) {return KINETIC_STATUS_MEMORY_ERROR;}
KineticBuilder_BuildNoop(operation);
return KineticController_ExecuteOperation(operation, NULL);
}
KineticStatus KineticAdminClient_SetClusterVersion(KineticSession * const session,
int64_t version)
{
KINETIC_ASSERT(session != NULL);
KineticOperation* operation = KineticAllocator_NewOperation(session);
if (operation == NULL) {return KINETIC_STATUS_MEMORY_ERROR;}
KineticBuilder_BuildSetClusterVersion(operation, version);
return KineticController_ExecuteOperation(operation, NULL);
}
void test_KineticAllocator_NewOperation_should_return_null_and_free_operation_if_calloc_returns_null_for_request(void)
{
KineticOperation op;
op.session = &Session;
KineticCalloc_ExpectAndReturn(1, sizeof(KineticOperation), &op);
KineticCalloc_ExpectAndReturn(1, sizeof(KineticRequest), NULL);
KineticFree_Expect(&op);
KineticOperation * operation = KineticAllocator_NewOperation(&Session);
TEST_ASSERT_NULL(operation);
}
KineticStatus KineticClient_Flush(KineticSession* const session,
KineticCompletionClosure* closure)
{
KINETIC_ASSERT(session);
KineticOperation* operation = KineticAllocator_NewOperation(session);
if (operation == NULL) { return KINETIC_STATUS_MEMORY_ERROR; }
// Initialize request
KineticBuilder_BuildFlush(operation);
// Execute the operation
return KineticController_ExecuteOperation(operation, closure);
}
KineticStatus KineticAdminClient_UpdateFirmware(KineticSession * const session,
char const * const fw_path)
{
KINETIC_ASSERT(session != NULL);
KineticOperation* operation = KineticAllocator_NewOperation(session);
if (operation == NULL) {return KINETIC_STATUS_MEMORY_ERROR;}
KineticStatus status = KineticBuilder_BuildUpdateFirmware(operation, fw_path);
if (status != KINETIC_STATUS_SUCCESS) {
return status;
}
return KineticController_ExecuteOperation(operation, NULL);
}
KineticStatus KineticAdminClient_MediaOptimize(KineticSession * const session,
const KineticMediaOptimize_Operation* mediaoptimize_operation, KineticCommand_Priority priority) {
KINETIC_ASSERT(session != NULL);
KineticOperation* operation = KineticAllocator_NewOperation(session);
if (operation == NULL) {return KINETIC_STATUS_MEMORY_ERROR;}
KineticStatus status = KineticBuilder_BuildMediaOptimize(operation, mediaoptimize_operation, priority);
if (status != KINETIC_STATUS_SUCCESS) {
return status;
}
return KineticController_ExecuteOperation(operation, NULL);
}
KineticStatus KineticAdminClient_GetDeviceSpecificLog(KineticSession * const session,
ByteArray name,
KineticLogInfo** info,
KineticCompletionClosure* closure)
{
KINETIC_ASSERT(session != NULL);
KINETIC_ASSERT(info != NULL);
KineticOperation* operation = KineticAllocator_NewOperation(session);
if (operation == NULL) {return KINETIC_STATUS_MEMORY_ERROR;}
// Initialize request
KineticBuilder_BuildGetLog(operation, COM__SEAGATE__KINETIC__PROTO__COMMAND__GET_LOG__TYPE__DEVICE, name, info);
// Execute the operation
return KineticController_ExecuteOperation(operation, closure);
}
void test_KineticAllocator_NewOperation_should_initialize_operation_and_request(void)
{
Session.timeoutSeconds = 423;
KineticOperation op = {.session = NULL};
KineticRequest request;
KineticCalloc_ExpectAndReturn(1, sizeof(KineticOperation), &op);
KineticCalloc_ExpectAndReturn(1, sizeof(KineticRequest), &request);
KineticRequest_Init_Expect(&request, &Session);
KineticOperation * operation = KineticAllocator_NewOperation(&Session);
TEST_ASSERT_EQUAL_PTR(operation, &op);
TEST_ASSERT_EQUAL_PTR(&Session, operation->session);
TEST_ASSERT_EQUAL_PTR(&request, operation->request);
TEST_ASSERT_NULL(operation->response);
TEST_ASSERT_EQUAL(423, operation->timeoutSeconds);
}
KineticStatus KineticAdminClient_SetErasePin(KineticSession * const session,
ByteArray old_pin, ByteArray new_pin)
{
KineticStatus status;
status = KineticAuth_EnsureSslEnabled(&session->config);
if (status != KINETIC_STATUS_SUCCESS) {return status;}
// Ensure PIN arrays have data if non-empty
if ((old_pin.len > 0 && old_pin.data == NULL) ||
(new_pin.len > 0 && new_pin.data == NULL)) {
return KINETIC_STATUS_MISSING_PIN;
}
KineticOperation* operation = KineticAllocator_NewOperation(session);
if (operation == NULL) {return KINETIC_STATUS_MEMORY_ERROR;}
KineticBuilder_BuildSetPin(operation, old_pin, new_pin, false);
return KineticController_ExecuteOperation(operation, NULL);
}
KineticStatus KineticClient_GetKeyRange(KineticSession* const session,
KineticKeyRange* range,
ByteBufferArray* keys,
KineticCompletionClosure* closure)
{
KINETIC_ASSERT(session);
KINETIC_ASSERT(range);
KINETIC_ASSERT(keys);
KINETIC_ASSERT(keys->buffers);
KINETIC_ASSERT(keys->count > 0);
KineticOperation* operation = KineticAllocator_NewOperation(session);
if (operation == NULL) {return KINETIC_STATUS_MEMORY_ERROR;}
// Initialize request
KineticBuilder_BuildGetKeyRange(operation, range, keys);
// Execute the operation
return KineticController_ExecuteOperation(operation, closure);
}
KineticStatus KineticAdminClient_InstantErase(KineticSession * const session,
ByteArray pin)
{
KINETIC_ASSERT(session != NULL);
KineticStatus status;
status = KineticAuth_EnsureSslEnabled(&session->config);
if (status != KINETIC_STATUS_SUCCESS) {return status;}
// Ensure PIN array has data if non-empty
if (pin.len > 0 && pin.data == NULL) {
return KINETIC_STATUS_MISSING_PIN;
}
KineticOperation* operation = KineticAllocator_NewOperation(session);
if (operation == NULL) {return KINETIC_STATUS_MEMORY_ERROR;}
KineticBuilder_BuildErase(operation, false, &pin);
return KineticController_ExecuteOperation(operation, NULL);
}
KineticStatus KineticClient_P2POperation(KineticSession* const session,
KineticP2P_Operation* const p2pOp,
KineticCompletionClosure* closure)
{
KINETIC_ASSERT(session);
KINETIC_ASSERT(p2pOp);
KineticOperation* operation = KineticAllocator_NewOperation(session);
if (operation == NULL) {return KINETIC_STATUS_MEMORY_ERROR;}
// Initialize request
KineticStatus status = KineticBuilder_BuildP2POperation(operation, p2pOp);
if (status != KINETIC_STATUS_SUCCESS) {
// TODO we need to find a more generic way to handle errors on command construction
if (closure != NULL) {
operation->closure = *closure;
}
return status;
}
// Execute the operation
return KineticController_ExecuteOperation(operation, closure);
}
KineticStatus KineticAdminClient_GetLog(KineticSession * const session,
KineticLogInfo_Type type,
KineticLogInfo** info,
KineticCompletionClosure* closure)
{
KINETIC_ASSERT(session != NULL);
KINETIC_ASSERT(info != NULL);
Com__Seagate__Kinetic__Proto__Command__GetLog__Type protoType =
KineticLogInfo_Type_to_Com__Seagate__Kinetic__Proto__Command__GetLog__Type(type);
if (protoType == COM__SEAGATE__KINETIC__PROTO__COMMAND__GET_LOG__TYPE__INVALID_TYPE) {
return KINETIC_STATUS_INVALID_LOG_TYPE;
}
KineticOperation* operation = KineticAllocator_NewOperation(session);
if (operation == NULL) {return KINETIC_STATUS_MEMORY_ERROR;}
// Initialize request
KineticBuilder_BuildGetLog(operation, protoType, BYTE_ARRAY_NONE, info);
// Execute the operation
return KineticController_ExecuteOperation(operation, closure);
}
static KineticStatus handle_get_command(GET_COMMAND cmd,
KineticSession* const session,
KineticEntry* const entry,
KineticCompletionClosure* closure)
{
KINETIC_ASSERT(session);
KINETIC_ASSERT(entry);
if (!has_key(entry)) {return KINETIC_STATUS_MISSING_KEY;}
if (!has_value_buffer(entry) && !entry->metadataOnly) {
return KINETIC_STATUS_MISSING_VALUE_BUFFER;
}
KineticOperation* operation = KineticAllocator_NewOperation(session);
if (operation == NULL) {
return KINETIC_STATUS_MEMORY_ERROR;
}
// Initialize request
switch (cmd)
{
case CMD_GET:
KineticBuilder_BuildGet(operation, entry);
break;
case CMD_GET_NEXT:
KineticBuilder_BuildGetNext(operation, entry);
break;
case CMD_GET_PREVIOUS:
KineticBuilder_BuildGetPrevious(operation, entry);
break;
default:
KINETIC_ASSERT(false);
}
// Execute the operation
return KineticController_ExecuteOperation(operation, closure);
}
void test_KineticAllocator_NewOperation_should_return_null_if_calloc_returns_null_for_operation(void)
{
KineticCalloc_ExpectAndReturn(1, sizeof(KineticOperation), NULL);
KineticOperation * operation = KineticAllocator_NewOperation(&Session);
TEST_ASSERT_NULL(operation);
}
