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); }