Commit 4d559e81 authored by Greg Williams's avatar Greg Williams
Browse files

Incorporated return of KineticStatus for all public API methods for... 

Incorporated return of KineticStatus for all public API methods for consistency. Made progress on allocation of connections per session, and also allocation of PDUs per operation.
parent ad5e5e91

include/kinetic_client.h

+24 −15
Original line number Diff line number Diff line
@@ -36,50 +36,59 @@ 
 *  .hmacKey        Key to use for HMAC calculations (NULL-terminated string)

 *  .logFile        Path to log file. Defaults to STDOUT if unspecified

 *

 * @return          Returns 0 upon succes, -1 or Kinetic status upon failure

 * @return          Returns the resulting KineticStatus

 */

int KineticClient_Connect(KineticSession* session);

KineticStatus KineticClient_Connect(const KineticSession* session);



/**

 * @brief Closes the connection to a host.

 *

 * @param session   KineticSession instance to terminate

 * @param session   KineticSession instance

 *

 * @return              Returns the resulting KineticStatus

 */

void KineticClient_Disconnect(KineticSession* session);

KineticStatus KineticClient_Disconnect(const KineticSession* session);



/**

 * @brief Executes a NOOP command to test whether the Kinetic Device is operational

 *

 * @param operation     KineticOperation instance to use for the operation

 * @param operation     KineticOperation to use for the operation.

 *                      If operation is already allocated, it will be reused

 *                      If operation is empty, one will be allocated, if available.

 *

 * @return              Returns 0 upon succes, -1 or the Kinetic status code upon failure

 * @return              Returns the resulting KineticStatus

 */

KineticStatus KineticClient_NoOp(KineticSession* session);

KineticStatus KineticClient_NoOp(const KineticSession* session,

    const KineticOperation* operation);



/**

 * @brief Executes a PUT command to store/update an entry on the Kinetic Device

 *

 * @param operation     KineticOperation instance to use for the operation

 * @param operation     KineticOperation to use for the operation.

 *                      If operation is already allocated, it will be reused

 *                      If operation is empty, one will be allocated, if available.

 * @param metadata      Key/value metadata for object to store. 'value' must

 *                      specify the data to be stored.

 *

 * @return              Returns 0 upon succes, -1 or the Kinetic status code

 *                      upon failure

 * @return              Returns the resulting KineticStatus

 */

KineticStatus KineticClient_Put(KineticSession* session,

    const KineticOperation* operation,

    const KineticKeyValue* metadata);



/**

 * @brief Executes a DELETE command to delete an entry from the Kinetic Device

 *

 * @param operation     KineticOperation instance to use for the operation

 * @param operation     KineticOperation to use for the operation.

 *                      If operation is already allocated, it will be reused

 *                      If operation is empty, one will be allocated, if available.

 * @param metadata      Key/value metadata for object to delete. 'value' is

 *                      not used for this operation.

 *

 * @return              Returns 0 upon succes, -1 or the Kinetic status code

 *                      upon failure

 * @return              Returns the resulting KineticStatus

 */

KineticStatus KineticClient_Delete(KineticSession* session,

    KineticKeyValue* metadata);

KineticStatus KineticClient_Delete(const KineticSession* session,

    const KineticOperation* operation,

    const KineticKeyValue* metadata);



#endif // _KINETIC_CLIENT_H

include/kinetic_types.h

+35 −9
Original line number Diff line number Diff line
@@ -153,6 +153,26 @@ typedef struct _KineticSession 
    // Session instance handle (0 = none/invalid session)

    int     handle;

} KineticSession;

#define KINETIC_SESSION_INIT(_session, \

    _host, _clusterVersion, _identity, _hmacKey) { \

    *(_session) = (KineticSession) { \

        .logFile = "", \

        .port = KINETIC_PORT, \

        .clusterVersion = (_clusterVersion), \

        .identity = (_identity), \

        .hmacKey = {.data = (_session)->keyData, .len = (_hmacKey).len}, \

    }; \

    memcpy((_session)->hmacKey.data, (_hmacKey).data, (_hmacKey).len); \

}





// Kinetic Operation

typedef struct _KineticOperation

{

    KineticConnection* session; // Associated KineticSession

    int requestHandle;          // Handle to allocated request

    int responseHandle;         // Handle to allocated response

} KineticOperation;





// Kinetic Status Codes
@@ -160,18 +180,24 @@ typedef enum 
{

    KINETIC_STATUS_INVALID = -1,        // Status not available (no reponse/status available)

    KINETIC_STATUS_SUCCESS = 0,         // Operation successful

    KINETIC_STATUS_SESSION_EMPTY,       // Session was NULL in request

    KINETIC_STATUS_SESSION_INVALID,     // Session configuration was invalid or NULL

    KINETIC_STATUS_HOST_EMPTY,          // Host was empty in request

    KINETIC_STATUS_HMAC_EMPTY,          // HMAC key is empty or NULL

    KINETIC_STATUS_NO_PDUS_AVAVILABLE   // All PDUs for the session have been allocated

    KINETIC_STATUS_DEVICE_BUSY,         // Device busy (retry later)

    KINETIC_STATUS_CONNECTION_ERROR,    // No connection/disconnected

    KINETIC_STATUS_INVALID_REQUEST,     // Something about the request is invalid

    KINETIC_STATUS_OPERATION_INVALID,   // Operation was invalid

    KINETIC_STATUS_OPERATION_FAILED,    // Device reported an operation error

    KINETIC_STATUS_VERSION_FAILURE,     // Basically a VERSION_MISMATCH error for a PUT

    KINETIC_STATUS_DATA_ERROR,       // Device reported data error, no spaces, HMAC failure

    KINETIC_STATUS_DATA_ERROR,          // Device reported data error, no space or HMAC failure

} KineticStatus;

extern const int KineticStatusDescriptorCount;

extern const char* KineticStatusDescriptor[];





// KeyValue meta-data

// KeyValue data

typedef struct _KineticKeyValue

{

    ByteArray key;

src/lib/kinetic_client.c

+73 −68
Original line number Diff line number Diff line
@@ -26,9 +26,44 @@ 
#include "kinetic_message.h"

#include "kinetic_pdu.h"

#include "kinetic_logger.h"

#include <stdio.h>



#if 0

static KineticOperation KineticClient_CreateOperation(

    KineticConnection* connection,

    KineticPDU* request,

    KineticPDU* response)

{

    KineticOperation op;



    if (connection == NULL)

    {

        LOG("Specified KineticConnection is NULL!");

        assert(connection != NULL);

    }



    if (request == NULL)

    {

        LOG("Specified KineticPDU request is NULL!");

        assert(request != NULL);

    }



    if (response == NULL)

    {

        LOG("Specified KineticPDU response is NULL!");

        assert(response != NULL);

    }



    KineticPDU_Init(request, connection);

    KINETIC_PDU_INIT_WITH_MESSAGE(request, connection);

    KineticPDU_Init(response, connection);



    op.connection = connection;

    op.request = request;

    op.request->proto = &op.request->protoData.message.proto;

    op.response = response;



    return op;

}



static KineticStatus KineticClient_ExecuteOperation(KineticOperation* operation)

{

    KineticStatus status = KINETIC_STATUS_INVALID;
@@ -48,105 +83,77 @@ static KineticStatus KineticClient_ExecuteOperation(KineticOperation* operation) 


    return status;

}

#endif



int KineticClient_Connect(KineticSession* session)

KineticStatus KineticClient_Connect(KineticSession* session)

{

    if (session == NULL)

    {

        LOG("Specified KineticSession is NULL!");

        return -1;

        return KINETIC_STATUS_SESSION_EMPTY;

    }



    if (strlen(session->host) == 0)

    {

        LOG("Session host is empty!");

        return -1;

        return KINETIC_STATUS_HOST_EMPTY;

    }



    if (session->hmacKey.len < 1)

    if (session->hmacKey.len < 1 || session->hmacKey.data == NULL)

    {

        LOG("Specified HMAC key is empty!");

        return -1;

    }



    if (session->hmacKey.data == NULL)

    {

        LOG("Specified HMAC key is NULL!");

        return -1;

        LOG("HMAC key is NULL or empty!");

        return KINETIC_STATUS_HMAC_EMPTY;

    }



    KineticConnection* connection = KineticConnection_NewConnection(session);

    if (connection == NULL)

    {

        LOG("Failed connecting to device (connection is NULL)!");

        return -1;

        return KINETIC_STATUS_SESSION_INVALID;

    }



    if (!KineticConnection_Connect(connection))

    {

        LOGF("Failed creating connection to %s:%d",

            session->host, session->port);

        return -1;

        return KINETIC_STATUS_CONNECTION_ERROR;

    }



    return 0;

    return KINETIC_STATUS_SUCCESS;

}



void KineticClient_Disconnect(KineticSession* session)

KineticStatus KineticClient_Disconnect(KineticSession* session)

{

    (void)session;

    // KineticConnection_Disconnect(connection);

    // KineticConnection_FreeConnection(connection->session);

}



/**

 * @brief Creates and initializes a Kinetic operation.

 *

 * @param connection    KineticConnection instance to associate with operation

 * @param request       KineticPDU instance to use for request

 * @param response      KineticPDU instance to use for reponse

 *

 * @return              Returns a configured operation instance

 */

KineticOperation KineticClient_CreateOperation(KineticConnection* connection,

    KineticPDU* request,

    KineticPDU* response)

    if (session == NULL)

    {

    KineticOperation op;



        LOG("Specified KineticSession is NULL!");

        return KINETIC_STATUS_SESSION_EMPTY;

    }

    KineticConnection* connection = KineticConnection_GetFromSession(session);

    if (connection == NULL)

    {

        LOG("Specified KineticConnection is NULL!");

        assert(connection != NULL);

        return KINETIC_STATUS_SESSION_INVALID;

    }

    KineticConnection_Disconnect(connection);

    KineticConnection_FreeConnection(session);

    return KINETIC_STATUS_SUCCESS;

}



    if (request == NULL)

KineticOperation KineticClient_NewOperation(KineticSession* session)

{

        LOG("Specified KineticPDU request is NULL!");

        assert(request != NULL);

    KineticOperation operation;

    if (session == NULL)

    {

        operation = (KineticOperation) {.session = NULL};

    }



    if (response == NULL)

    else

    {

        LOG("Specified KineticPDU response is NULL!");

        assert(response != NULL);

        KINETIC_OPERATION_INIT(&operation, session);

        KineticOperation_Create(&operation, session);

    }



    KineticPDU_Init(request, connection);

    KINETIC_PDU_INIT_WITH_MESSAGE(request, connection);

    KineticPDU_Init(response, connection);



    op.connection = connection;

    op.request = request;

    op.request->proto = &op.request->protoData.message.proto;

    op.response = response;



    return op;

    return operation;

}



#if 0

KineticStatus KineticClient_NoOp(KineticOperation* session)

KineticStatus KineticClient_NoOp(const KineticOperation* operation)

{

    assert(operation->connection != NULL);

    assert(operation->request != NULL);
@@ -159,8 +166,8 @@ KineticStatus KineticClient_NoOp(KineticOperation* session) 
    return KineticClient_ExecuteOperation(operation);

}



KineticStatus KineticClient_Put(KineticOperation* operation,

    const KineticKeyValue* metadata)

KineticStatus KineticClient_Put(const KineticOperation* operation,

    const KineticKeyValue* const metadata)

{

    assert(operation->connection != NULL);

    assert(operation->request != NULL);
@@ -176,8 +183,8 @@ KineticStatus KineticClient_Put(KineticOperation* operation, 
    return KineticClient_ExecuteOperation(operation);

}



KineticStatus KineticClient_Get(KineticOperation* operation,

    KineticKeyValue* metadata)

KineticStatus KineticClient_Get(const KineticOperation* operation,

    const KineticKeyValue* metadata)

{

    assert(operation->connection != NULL);

    assert(operation->request != NULL);
@@ -216,7 +223,7 @@ KineticStatus KineticClient_Get(KineticOperation* operation, 
}



KineticStatus KineticClient_Delete(KineticOperation* operation,

    KineticKeyValue* metadata)

    const KineticKeyValue* const metadata)

{

    assert(operation->connection != NULL);

    assert(operation->request != NULL);
@@ -237,5 +244,3 @@ KineticStatus KineticClient_Delete(KineticOperation* operation, 


    return status;

}
 
#endif

src/lib/kinetic_connection.c

+7 −0
Original line number Diff line number Diff line
@@ -75,6 +75,13 @@ void KineticConnection_FreeConnection(KineticSession* session) 
    session->handle = SESSION_HANDLE_INVALID;

}



KineticConnection* KineticConnection_GetFromSession(KineticSession* session)

{

    assert(session);

    assert(session->handle > SESSION_HANDLE_INVALID);

    assert(session->handle <= KINETIC_SESSIONS_MAX);

    return Connections[session->handle];

}



bool KineticConnection_Connect(KineticConnection* const connection)

{

src/lib/kinetic_connection.h

+3 −0
Original line number Diff line number Diff line
@@ -24,7 +24,10 @@ 
#include "kinetic_types_internal.h"



KineticConnection* KineticConnection_NewConnection(KineticSession* session);

KineticConnection* KineticConnection_GetFromSession(KineticSession* session);

void KineticConnection_FreeConnection(KineticSession* session);

KineticPDU* KineticConnection_AllocatePDU(KineticSession* session);

void KineticConnection_FreePDU(KineticSession* session, KineticPDU* pdu);

bool KineticConnection_Connect(KineticConnection* const connection);

void KineticConnection_Disconnect(KineticConnection* const connection);

void KineticConnection_IncrementSequence(KineticConnection* const connection);