Filled out admin API and implemented building off all admin ops except SetAcl and UpdateFirmware (f23f14fd) · Commits · kinetic-archive / kinetic-c

include/kinetic_admin_client.h

+100 −52

Original line number	Diff line number	Diff line
		@@ -25,15 +25,22 @@
		#include "kinetic_client.h"

		/**
		* Initializes the Kinetic API and configures logging destination.
		* Initializes the Kinetic Admin API and configures logging.
		*
		* @param log_file (path to log file, 'stdout' to log to STDOUT, NULL to disable logging)
		* @param log_level Logging level (-1:none, 0:error, 1:info, 2:verbose, 3:full)
		*
		* @return Returns a pointer to a `KineticClient`. You need to pass
		* this pointer to KineticClient_CreateConnection() to create
		* new connections.
		* Once you are finished will the `KineticClient`, and there
		* are no active connections. The pointer should be release
		* with KineticClient_Shutdown()
		*/
		void KineticAdminClient_Init(const char* log_file, int log_level);
		KineticClient * KineticAdminClient_Init(const char* log_file, int log_level);

		/**
		* @brief Performs shutdown/cleanup of the kinetic-c client lib
		* @brief Performs shutdown/cleanup of the kinetic-c client library
		*/
		void KineticAdminClient_Shutdown(KineticClient * const client);

		@@ -58,7 +65,8 @@ void KineticAdminClient_Shutdown(KineticClient * const client);
		* order to shutdown a connection and cleanup resources when
		* done using a KineticSession.
		*/
		KineticStatus KineticAdminClient_CreateConnection(KineticSession * const session, KineticClient * const client);
		KineticStatus KineticAdminClient_CreateConnection(KineticSession * const session,
		KineticClient * const client);

		/**
		* @brief Closes the connection to a host.
		@@ -71,6 +79,62 @@ KineticStatus KineticAdminClient_CreateConnection(KineticSession * const session
		*/
		KineticStatus KineticAdminClient_DestroyConnection(KineticSession * const session);

		/**
		* @brief Sets the erase PIN of the Kinetic Device.
		*
		* @param pin New erase PIN to set.
		*
		* @return Returns the resulting KineticStatus.
		*/
		KineticStatus KineticAdminClient_SetErasePin(KineticSession const * const session,
		ByteArray pin);

		/**
		* @brief Executes a SecureErase command to erase all data from the Kinetic device.
		*
		* @param session The connected KineticSession to use for the operation.
		*
		* @return Returns the resulting KineticStatus.
		*/
		KineticStatus KineticAdminClient_SecureErase(KineticSession const * const session);

		/**
		* @brief Executes an InstantErase command to erase all data from the Kinetic device.
		*
		* @param session The connected KineticSession to use for the operation.
		*
		* @return Returns the resulting KineticStatus.
		*/
		KineticStatus KineticAdminClient_InstantErase(KineticSession const * const session);

		/**
		* @brief Sets the lock PIN of the Kinetic Device.
		*
		* @param pin New lock PIN to set.
		*
		* @return Returns the resulting KineticStatus.
		*/
		KineticStatus KineticAdminClient_SetLockPin(KineticSession const * const session,
		ByteArray pin);

		/**
		* @brief Executes a LOCK command to lock the Kinetic device.
		*
		* @param session The connected KineticSession to use for the operation.
		*
		* @return Returns the resulting KineticStatus.
		*/
		KineticStatus KineticAdminClient_LockDevice(KineticSession const * const session);

		/**
		* @brief Executes an UNLOCK command to unlock the Kinetic device.
		*
		* @param session The connected KineticSession to use for the operation.
		*
		* @return Returns the resulting KineticStatus.
		*/
		KineticStatus KineticAdminClient_UnlockDevice(KineticSession const * const session);

		/**
		* @brief Executes a GETLOG command to retrieve specific configuration and/or
		* operational data from the Kinetic Device.
		@@ -94,53 +158,37 @@ KineticStatus KineticAdminClient_GetLog(KineticSession const * const session,
		KineticDeviceInfo** info,
		KineticCompletionClosure* closure);

		// def setClusterVersion(self, args, *kwargs):

		// def updateFirmware(self, args, *kwargs):

		// @withPin @requiresSsl
		// def unlock(self, args, *kwargs):

		// @withPin @requiresSsl
		// def lock(self, args, *kwargs):

		// @withPin @requiresSsl
		// def erase(self, args, *kwargs):

		// @withPin @requiresSsl
		// def instantSecureErase(self, args, *kwargs):

		// @requiresSsl
		// Set the access control lists to lock users out of different permissions.
		// Arguments: aclList -> A list of ACL (Access Control List) objects.
		// def setSecurity(self, args, *kwargs):

		/**
		* @brief Executes a SecureErase command to erase all data from the Kinetic device.
		* @brief Executes a SECURITY command to define/set the access control list
		* (ACL) for the Kinetic device.
		*
		* @param session The connected KineticSession to use for the operation.
		* @param acl_path Path to ACL definitions per identity in JSON format.
		*
		* @return Returns the resulting KineticStatus.
		*/
		KineticStatus KineticAdminClient_SecureErase(KineticSession const * const session);
		KineticStatus KineticAdminClient_SetAcl(KineticSession const * const session,
		char const * const acl_path);

		/**
		* @brief Executes an InstantErase command to erase all data from the Kinetic device.
		* @brief Updates the cluster version of the Kinetic Device.
		*
		* @param session The connected KineticSession to use for the operation.
		* @param version New cluster version.
		*
		* @return Returns the resulting KineticStatus.
		*/
		KineticStatus KineticAdminClient_InstantErase(KineticSession const * const session);
		KineticStatus KineticAdminClient_SetClusterVersion(KineticSession const * const session,
		int64_t version);

		/**
		* @brief Updates the cluster version.
		* @brief Executes a Firmware Download command to update the firmware on the Kinetic device.
		*
		* @param newClusterVersion New cluster version.
		* @param session The connected KineticSession to use for the operation.
		* @param fw_path Path to firmware update image file.
		*
		* @return Returns the resulting KineticStatus.
		*/
		KineticStatus KineticAdminClient_SetClusterVersion(KineticSession const * const session,
		int64_t newClusterVersion);
		KineticStatus KineticAdminClient_UpdateFirmware(KineticSession const * const session,
		char const * const fw_path);

		#endif // _KINETIC_ADMIN_CLIENT_H

include/kinetic_client.h

+4 −3

Original line number	Diff line number	Diff line
		@@ -39,7 +39,7 @@
		KineticClient * KineticClient_Init(const char* log_file, int log_level);

		/**
		* @brief Performs shutdown/cleanup of the kinetic-c client lib
		* @brief Performs shutdown/cleanup of the kinetic-c client library
		*
		* @param client The pointer returned from `KineticClient_Init`
		*
		@@ -58,6 +58,7 @@ void KineticClient_Shutdown(KineticClient * const client);
		* .clusterVersion Cluster version to use for the session
		* .identity Identity to use for the session
		* .hmacKey Key to use for HMAC calculations (NULL-terminated string)
		* .pin PIN to use for PIN-based operations
		* .connection Pointer to dynamically allocated connection which will be
		* populated upon establishment of a connection.
		*

src/lib/kinetic_admin_client.c

+95 −18

Original line number	Diff line number	Diff line
		@@ -24,9 +24,9 @@
		#include "kinetic_operation.h"
		#include "kinetic_auth.h"

		void KineticAdminClient_Init(const char* log_file, int log_level)
		KineticClient * KineticAdminClient_Init(const char* log_file, int log_level)
		{
		KineticClient_Init(log_file, log_level);
		return KineticClient_Init(log_file, log_level);
		}

		void KineticAdminClient_Shutdown(KineticClient * const client)
		@@ -34,7 +34,8 @@ void KineticAdminClient_Shutdown(KineticClient * const client)
		KineticClient_Shutdown(client);
		}

		KineticStatus KineticAdminClient_CreateConnection(KineticSession* const session, KineticClient * const client)
		KineticStatus KineticAdminClient_CreateConnection(KineticSession* const session,
		KineticClient * const client)
		{
		return KineticClient_CreateConnection(session, client);
		}
		@@ -45,26 +46,63 @@ KineticStatus KineticAdminClient_DestroyConnection(KineticSession* const session
		}


		KineticStatus KineticAdminClient_GetLog(KineticSession const * const session,
		KineticDeviceInfo_Type type,
		KineticDeviceInfo** info,
		KineticCompletionClosure* closure)
		KineticStatus KineticAdminClient_SetErasePin(KineticSession const * const session,
		ByteArray pin)
		{
		(void)pin;
		assert(session != NULL);
		assert(session->connection != NULL);
		assert(info != NULL);
		return KINETIC_STATUS_INVALID;
		}

		KineticStatus KineticAdminClient_SecureErase(KineticSession const * const session)
		{
		assert(session != NULL);
		assert(session->connection != NULL);

		KineticStatus status;
		status = KineticAuth_EnsurePinSupplied(&session->config);
		if (status != KINETIC_STATUS_SUCCESS) {return status;}
		status = KineticAuth_EnsureSslEnabled(&session->config);
		if (status != KINETIC_STATUS_SUCCESS) {return status;}

		KineticOperation* operation = KineticOperation_Create(session);
		if (operation == NULL) {return KINETIC_STATUS_MEMORY_ERROR;}

		// Initialize request
		KineticOperation_BuildGetLog(operation, type, info);
		KineticOperation_BuildErase(operation, true);
		return KineticController_ExecuteOperation(operation, NULL);
		}

		// Execute the operation
		return KineticController_ExecuteOperation(operation, closure);
		KineticStatus KineticAdminClient_InstantErase(KineticSession const * const session)
		{
		assert(session != NULL);
		assert(session->connection != NULL);

		KineticStatus status;
		status = KineticAuth_EnsurePinSupplied(&session->config);
		if (status != KINETIC_STATUS_SUCCESS) {return status;}
		status = KineticAuth_EnsureSslEnabled(&session->config);
		if (status != KINETIC_STATUS_SUCCESS) {return status;}

		KineticOperation* operation = KineticOperation_Create(session);
		if (operation == NULL) {return KINETIC_STATUS_MEMORY_ERROR;}

		KineticOperation_BuildErase(operation, false);
		return KineticController_ExecuteOperation(operation, NULL);
		}

		KineticStatus KineticAdminClient_SecureErase(KineticSession const * const session)

		KineticStatus KineticAdminClient_SetLockPin(KineticSession const * const session,
		ByteArray pin)
		{
		assert(session != NULL);
		assert(session->connection != NULL);
		(void)session;
		(void)pin;
		return KINETIC_STATUS_INVALID;
		}

		KineticStatus KineticAdminClient_LockDevice(KineticSession const * const session)
		{
		assert(session != NULL);
		assert(session->connection != NULL);
		@@ -78,11 +116,11 @@ KineticStatus KineticAdminClient_SecureErase(KineticSession const * const sessio
		KineticOperation* operation = KineticOperation_Create(session);
		if (operation == NULL) {return KINETIC_STATUS_MEMORY_ERROR;}

		KineticOperation_BuildSecureErase(operation);
		KineticOperation_BuildLockUnlock(operation, true);
		return KineticController_ExecuteOperation(operation, NULL);
		}

		KineticStatus KineticAdminClient_InstantErase(KineticSession const * const session)
		KineticStatus KineticAdminClient_UnlockDevice(KineticSession const * const session)
		{
		assert(session != NULL);
		assert(session->connection != NULL);
		@@ -96,12 +134,41 @@ KineticStatus KineticAdminClient_InstantErase(KineticSession const * const sessi
		KineticOperation* operation = KineticOperation_Create(session);
		if (operation == NULL) {return KINETIC_STATUS_MEMORY_ERROR;}

		KineticOperation_BuildInstantErase(operation);
		KineticOperation_BuildLockUnlock(operation, false);
		return KineticController_ExecuteOperation(operation, NULL);
		}

		KineticStatus KineticAdminClient_GetLog(KineticSession const * const session,
		KineticDeviceInfo_Type type,
		KineticDeviceInfo** info,
		KineticCompletionClosure* closure)
		{
		assert(session != NULL);
		assert(session->connection != NULL);
		assert(info != NULL);

		KineticOperation* operation = KineticOperation_Create(session);
		if (operation == NULL) {return KINETIC_STATUS_MEMORY_ERROR;}

		// Initialize request
		KineticOperation_BuildGetLog(operation, type, info);

		// Execute the operation
		return KineticController_ExecuteOperation(operation, closure);
		}

		KineticStatus KineticAdminClient_SetAcl(KineticSession const * const session,
		char const * const acl_path)
		{
		assert(session != NULL);
		assert(session->connection != NULL);
		(void)session;
		(void)acl_path;
		return KINETIC_STATUS_INVALID;
		}

		KineticStatus KineticAdminClient_SetClusterVersion(KineticSession const * const session,
		int64_t newClusterVersion)
		int64_t version)
		{
		assert(session != NULL);
		assert(session->connection != NULL);
		@@ -113,6 +180,16 @@ KineticStatus KineticAdminClient_SetClusterVersion(KineticSession const * const
		KineticOperation* operation = KineticOperation_Create(session);
		if (operation == NULL) {return KINETIC_STATUS_MEMORY_ERROR;}

		KineticOperation_BuildSetClusterVersion(operation, newClusterVersion);
		KineticOperation_BuildSetClusterVersion(operation, version);
		return KineticController_ExecuteOperation(operation, NULL);
		}

		KineticStatus KineticAdminClient_UpdateFirmware(KineticSession const * const session,
		char const * const fw_path)
		{
		assert(session != NULL);
		assert(session->connection != NULL);
		(void)session;
		(void)fw_path;
		return KINETIC_STATUS_INVALID;
		}

src/lib/kinetic_operation.c

+48 −38

Original line number	Diff line number	Diff line
		@@ -63,7 +63,6 @@ KineticOperation* KineticOperation_Create(KineticSession const * const session)
		return operation;
		}

		static void KineticOperation_ValidateOperation(KineticOperation* operation);
		static KineticStatus KineticOperation_SendRequestInner(KineticOperation* const operation);

		KineticStatus KineticOperation_SendRequest(KineticOperation* const operation)
		@@ -211,6 +210,35 @@ KineticStatus KineticOperation_GetStatus(const KineticOperation* const operation
		return status;
		}

		static void KineticOperation_ValidateOperation(KineticOperation* operation)
		{
		assert(operation != NULL);
		assert(operation->connection != NULL);
		assert(operation->request != NULL);
		assert(operation->request->command != NULL);
		assert(operation->request->command->header != NULL);
		assert(operation->request->command->header->has_sequence);
		}

		void KineticOperation_Complete(KineticOperation* operation, KineticStatus status)
		{
		assert(operation != NULL);
		// ExecuteOperation should ensure a callback exists (either a user supplied one, or the a default)
		if (operation->closure.callback == NULL) { return; }
		KineticCompletionData completionData = {.status = status};

		KineticCountingSemaphore_Give(operation->connection->outstandingOperations);

		operation->closure.callback(&completionData, operation->closure.clientData);

		KineticAllocator_FreeOperation(operation);
		}


		/*******************************************************************************
		* Client Operations
		*******************************************************************************/

		KineticStatus KineticOperation_NoopCallback(KineticOperation* const operation, KineticStatus const status)
		{
		assert(operation != NULL);
		@@ -510,7 +538,6 @@ void KineticOperation_BuildGetLog(KineticOperation* const operation,
		operation->callback = &KineticOperation_GetLogCallback;
		}


		void destroy_p2pOp(KineticProto_Command_P2POperation* proto_p2pOp)
		{
		if (proto_p2pOp != NULL) {
		@@ -540,7 +567,6 @@ void destroy_p2pOp(KineticProto_Command_P2POperation* proto_p2pOp)
		}
		}


		KineticProto_Command_P2POperation* build_p2pOp(uint32_t nestingLevel, KineticP2P_Operation const * const p2pOp)
		{
		// limit nesting level to 10000
		@@ -640,7 +666,6 @@ static void populateP2PStatusCodes(KineticP2P_Operation* const p2pOp, KineticPro
		}
		}


		KineticStatus KineticOperation_P2POperationCallback(KineticOperation* const operation, KineticStatus const status)
		{
		KineticP2P_Operation* const p2pOp = operation->p2pOp;
		@@ -681,7 +706,13 @@ KineticStatus KineticOperation_BuildP2POperation(KineticOperation* const operati
		return KINETIC_STATUS_SUCCESS;
		}

		KineticStatus KineticOperation_SecureEraseCallback(KineticOperation* const operation, KineticStatus const status)


		/*******************************************************************************
		* Admin Client Operations
		*******************************************************************************/

		KineticStatus KineticOperation_EraseCallback(KineticOperation* const operation, KineticStatus const status)
		{
		assert(operation != NULL);
		assert(operation->connection != NULL);
		@@ -690,7 +721,7 @@ KineticStatus KineticOperation_SecureEraseCallback(KineticOperation* const opera
		return status;
		}

		void KineticOperation_BuildSecureErase(KineticOperation* operation)
		void KineticOperation_BuildErase(KineticOperation* const operation, bool secure_erase)
		{
		KineticOperation_ValidateOperation(operation);
		KineticSession_IncrementSequence(operation->connection->session);
		@@ -700,26 +731,28 @@ void KineticOperation_BuildSecureErase(KineticOperation* operation)
		operation->request->command->body = &operation->request->message.body;
		operation->request->command->body->pinOp = &operation->request->message.pinOp;

		operation->request->command->body->pinOp->pinOpType = KINETIC_PROTO_COMMAND_PIN_OPERATION_PIN_OP_TYPE_SECURE_ERASE_PINOP;
		operation->request->command->body->pinOp->pinOpType = secure_erase ?
		KINETIC_PROTO_COMMAND_PIN_OPERATION_PIN_OP_TYPE_SECURE_ERASE_PINOP :
		KINETIC_PROTO_COMMAND_PIN_OPERATION_PIN_OP_TYPE_ERASE_PINOP;
		operation->request->command->body->pinOp->has_pinOpType = true;

		operation->valueEnabled = false;
		operation->sendValue = false;
		operation->callback = &KineticOperation_SecureEraseCallback;
		operation->callback = &KineticOperation_EraseCallback;
		operation->request->pinOp = true;
		operation->timeoutSeconds = 180;
		}

		KineticStatus KineticOperation_InstantEraseCallback(KineticOperation* const operation, KineticStatus const status)
		KineticStatus KineticOperation_LockUnlockCallback(KineticOperation* const operation, KineticStatus const status)
		{
		assert(operation != NULL);
		assert(operation->connection != NULL);
		LOGF3("InstantErase callback w/ operation (0x%0llX) on connection (0x%0llX)",
		LOGF3("LockUnlockCallback callback w/ operation (0x%0llX) on connection (0x%0llX)",
		operation, operation->connection);
		return status;
		}

		void KineticOperation_BuildInstantErase(KineticOperation* operation)
		void KineticOperation_BuildLockUnlock(KineticOperation* const operation, bool lock)
		{
		KineticOperation_ValidateOperation(operation);
		KineticSession_IncrementSequence(operation->connection->session);
		@@ -729,14 +762,15 @@ void KineticOperation_BuildInstantErase(KineticOperation* operation)
		operation->request->command->body = &operation->request->message.body;
		operation->request->command->body->pinOp = &operation->request->message.pinOp;

		operation->request->command->body->pinOp->pinOpType = KINETIC_PROTO_COMMAND_PIN_OPERATION_PIN_OP_TYPE_ERASE_PINOP;
		operation->request->command->body->pinOp->pinOpType = lock ?
		KINETIC_PROTO_COMMAND_PIN_OPERATION_PIN_OP_TYPE_LOCK_PINOP :
		KINETIC_PROTO_COMMAND_PIN_OPERATION_PIN_OP_TYPE_UNLOCK_PINOP;
		operation->request->command->body->pinOp->has_pinOpType = true;

		operation->valueEnabled = false;
		operation->sendValue = false;
		operation->callback = &KineticOperation_InstantEraseCallback;
		operation->callback = &KineticOperation_LockUnlockCallback;
		operation->request->pinOp = true;
		operation->timeoutSeconds = 180;
		}

		KineticStatus KineticOperation_SetClusterVersionCallback(KineticOperation* const operation, KineticStatus const status)
		@@ -768,27 +802,3 @@ void KineticOperation_BuildSetClusterVersion(KineticOperation* operation, int64_
		operation->callback = &KineticOperation_SetClusterVersionCallback;
		operation->request->pinOp = false;
		}

		static void KineticOperation_ValidateOperation(KineticOperation* operation)
		{
		assert(operation != NULL);
		assert(operation->connection != NULL);
		assert(operation->request != NULL);
		assert(operation->request->command != NULL);
		assert(operation->request->command->header != NULL);
		assert(operation->request->command->header->has_sequence);
		}

		void KineticOperation_Complete(KineticOperation* operation, KineticStatus status)
		{
		assert(operation != NULL);
		// ExecuteOperation should ensure a callback exists (either a user supplied one, or the a default)
		if (operation->closure.callback == NULL) { return; }
		KineticCompletionData completionData = {.status = status};

		KineticCountingSemaphore_Give(operation->connection->outstandingOperations);

		operation->closure.callback(&completionData, operation->closure.clientData);

		KineticAllocator_FreeOperation(operation);
		}

src/lib/kinetic_operation.h

+28 −18

Original line number	Diff line number	Diff line
		@@ -24,14 +24,14 @@
		#include "kinetic_types_internal.h"

		KineticOperation* KineticOperation_Create(KineticSession const * const session);

		KineticStatus KineticOperation_SendRequest(KineticOperation* const operation);
		KineticOperation* KineticOperation_AssociateResponseWithOperation(KineticPDU* response);
		KineticStatus KineticOperation_GetStatus(const KineticOperation* const operation);
		void KineticOperation_Complete(KineticOperation* operation, KineticStatus status);

		struct timeval KineticOperation_GetTimeoutTime(KineticOperation* const operation);
		void KineticOperation_SetTimeoutTime(KineticOperation* const operation, uint32_t const timeout_in_sec);

		KineticStatus KineticOperation_GetStatus(const KineticOperation* const operation);
		/*******************************************************************************
		* Client Operations
		*******************************************************************************/

		KineticStatus KineticOperation_NoopCallback(KineticOperation* const operation, KineticStatus const status);
		void KineticOperation_BuildNoop(KineticOperation* operation);
		@@ -60,25 +60,35 @@ KineticStatus KineticOperation_GetKeyRangeCallback(KineticOperation* const opera
		void KineticOperation_BuildGetKeyRange(KineticOperation* const operation,
		KineticKeyRange* range, ByteBufferArray* buffers);

		KineticStatus KineticOperation_GetLogCallback(KineticOperation* const operation, KineticStatus const status);
		void KineticOperation_BuildGetLog(KineticOperation* const operation,
		KineticDeviceInfo_Type type,
		KineticDeviceInfo** info);

		KineticStatus KineticOperation_P2POperationCallback(KineticOperation* const operation, KineticStatus const status);
		KineticStatus KineticOperation_BuildP2POperation(KineticOperation* const operation,
		KineticP2P_Operation* const p2pOp);

		KineticStatus KineticOperation_SecureEraseCallback(KineticOperation* const operation, KineticStatus const status);
		void KineticOperation_BuildSecureErase(KineticOperation* operation);

		KineticStatus KineticOperation_InstantEraseCallback(KineticOperation* const operation, KineticStatus const status);
		void KineticOperation_BuildInstantErase(KineticOperation* operation);
		/*******************************************************************************
		* Admin Client Operations
		*******************************************************************************/

		KineticStatus KineticOperation_SetClusterVersionCallback(KineticOperation* const operation, KineticStatus const status);
		void KineticOperation_BuildSetClusterVersion(KineticOperation* operation, int64_t newClusterVersion);
		KineticStatus KineticOperation_SetPinCallback(KineticOperation* const operation, KineticStatus const status);
		void KineticOperation_BuildSetPin(KineticOperation* const operation, bool unlock);

		void KineticOperation_Complete(KineticOperation* operation, KineticStatus status);
		void KineticOperation_TimeoutOperations(KineticConnection* const connection);
		KineticStatus KineticOperation_EraseCallback(KineticOperation* const operation, KineticStatus const status);
		void KineticOperation_BuildErase(KineticOperation* const operation, bool secure_erase);

		KineticStatus KineticOperation_LockUnlockCallback(KineticOperation* const operation, KineticStatus const status);
		void KineticOperation_BuildLockUnlock(KineticOperation* const operation, bool lock);

		KineticStatus KineticOperation_GetLogCallback(KineticOperation* const operation, KineticStatus const status);
		void KineticOperation_BuildGetLog(KineticOperation* const operation,
		KineticDeviceInfo_Type type,
		KineticDeviceInfo** info);

		KineticStatus KineticOperation_SetAclCallback(KineticOperation* const operation, KineticStatus const status);
		void KineticOperation_BuildSetAcl(KineticOperation* const operation,
		KineticDeviceInfo_Type type,
		KineticDeviceInfo** info);

		KineticStatus KineticOperation_SetClusterVersionCallback(KineticOperation* const operation, KineticStatus const status);
		void KineticOperation_BuildSetClusterVersion(KineticOperation* const operation, int64_t newClusterVersion);

		#endif // _KINETIC_OPERATION_H