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;
}
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);
}
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_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_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_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);
}
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 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_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_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);
}
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);
}
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_KineticController_ExecuteOperation_should_carry_out_an_operation_with_closure_specified_as_asynchronous(void)
{
KineticSession session = {.connected = true};
KineticRequest request;
KineticOperation operation = {
.session = &session,
.request = &request,
};
KineticCompletionClosure closure;
KineticSession_GetTerminationStatus_ExpectAndReturn(&session, KINETIC_STATUS_SUCCESS);
KineticOperation_SendRequest_ExpectAndReturn(&operation, KINETIC_STATUS_SUCCESS);
KineticStatus status = KineticController_ExecuteOperation(&operation, &closure);
TEST_ASSERT_EQUAL_KineticStatus(KINETIC_STATUS_SUCCESS, status);
}
void test_KineticController_ExecuteOperation_should_carry_out_an_operation_with_no_closure_specified_as_synchronous(void)
{
KineticSession session = {.connected = true};
KineticRequest request;
KineticOperation operation = {
.session = &session,
.request = &request,
};
KineticCompletionClosure closure;
KineticSession_GetTerminationStatus_ExpectAndReturn(&session, KINETIC_STATUS_SUCCESS);
