Commit 5c8a22ca authored by Scott Vokes's avatar Scott Vokes
Browse files

Merge remote-tracking branch 'origin/develop' into develop

parents dbfddeea cad0f03c

Makefile

+13 −3
Original line number Diff line number Diff line
@@ -70,6 +70,7 @@ LIB_OBJS = \ 
	$(OUT_DIR)/kinetic_types_internal.o \

	$(OUT_DIR)/kinetic_types.o \

	$(OUT_DIR)/kinetic_memory.o \

	$(OUT_DIR)/kinetic_semaphore.o \

	$(OUT_DIR)/byte_array.o \

	$(OUT_DIR)/kinetic_client.o \

	$(OUT_DIR)/threadpool.o \
@@ -226,6 +227,8 @@ install: $(KINETIC_LIB) $(KINETIC_SO_DEV) 
	$(INSTALL) -d $(PREFIX)/include/

	$(INSTALL) -c $(PUB_INC)/$(API_NAME).h $(PREFIX)/include/

	$(INSTALL) -c $(PUB_INC)/kinetic_types.h $(PREFIX)/include/

	$(INSTALL) -c $(PUB_INC)/kinetic_semaphore.h $(PREFIX)/include/

	$(INSTALL) -c $(PUB_INC)/byte_array.h $(PREFIX)/include/



uninstall:

	@echo
@@ -237,6 +240,8 @@ uninstall: 
	$(RM) -f $(PREFIX)${LIBDIR}/lib$(PROJECT)*.so

	$(RM) -f $(PREFIX)/include/${API_NAME}.h

	$(RM) -f $(PREFIX)/include/kinetic_types.h

	$(RM) -f $(PREFIX)/include/kinetic_semaphore.h

	$(RM) -f $(PREFIX)/include/byte_array.h

	$(RM) -f $(PREFIX)/include/kinetic_proto.h

	$(RM) -f $(PREFIX)/include/protobuf-c/protobuf-c.h

	$(RM) -f $(PREFIX)/include/protobuf-c.h
@@ -269,7 +274,7 @@ stop_simulator: 


SYSTEST_SRC = ./test/system

SYSTEST_OUT = $(BIN_DIR)/systest

SYSTEST_LDFLAGS += -lm -L${OPENSSL_PATH}/lib -lssl -lcrypto $(KINETIC_LIB) -l pthread

SYSTEST_LDFLAGS += -lm $(KINETIC_LIB) -L${OPENSSL_PATH}/lib -lssl -lcrypto -lpthread

SYSTEST_WARN = -Wall -Wextra -Werror -Wstrict-prototypes -pedantic -Wno-missing-field-initializers -Werror=strict-prototypes

SYSTEST_CFLAGS += -std=c99 -fPIC -g $(SYSTEST_WARN) $(CDEFS) $(OPTIMIZE) -DTEST

UNITY_INC = ./vendor/unity/src
@@ -355,7 +360,7 @@ UTILITY = kinetic-c-util 
UTIL_DIR = ./src/utility

UTIL_EXEC = $(BIN_DIR)/$(UTILITY)

UTIL_OBJ = $(OUT_DIR)/main.o

UTIL_LDFLAGS += -lm -L${OPENSSL_PATH}/lib -lssl $(KINETIC_LIB) -lcrypto -lpthread

UTIL_LDFLAGS += -lm $(KINETIC_LIB) -L${OPENSSL_PATH}/lib -lssl -lcrypto -lpthread



$(UTIL_OBJ): $(UTIL_DIR)/main.c

	$(CC) -c -o $@ $< $(CFLAGS) -I$(PUB_INC) -I$(UTIL_DIR)
@@ -400,6 +405,7 @@ run: $(UTIL_EXEC) start_simulator 


EXAMPLE_SRC = ./src/examples

EXAMPLE_LDFLAGS += -lm -l ssl $(KINETIC_LIB) -l crypto -l pthread

EXAMPLE_CFLAGS += -Wno-deprecated-declarations

EXAMPLES = write_file_blocking

VALGRIND = valgrind

VALGRIND_ARGS = --track-origins=yes #--leak-check=full
@@ -412,7 +418,7 @@ $(BIN_DIR)/examples/%: $(EXAMPLE_SRC)/%.c $(KINETIC_LIB) 
	@echo ================================================================================

	@echo Building example: '$<'

	@echo --------------------------------------------------------------------------------

	$(CC) -o $@ $< $(CFLAGS) -I$(PUB_INC) $(UTIL_LDFLAGS) $(KINETIC_LIB)

	$(CC) -o $@ $< $(CFLAGS) $(EXAMPLE_CFLAGS) -I$(PUB_INC) $(UTIL_LDFLAGS) $(KINETIC_LIB)

	@echo ================================================================================

	@echo
@@ -452,6 +458,8 @@ setup_examples: $(example_executables) \ 


examples: setup_examples \

	start_simulator \

	run_example_put_nonblocking \

	run_example_get_nonblocking \

	run_example_write_file_blocking \

	run_example_write_file_blocking_threads \

	run_example_write_file_nonblocking \
@@ -461,6 +469,8 @@ examples: setup_examples \ 


valgrind_examples: setup_examples \

	start_simulator \

	valgrind_put_nonblocking \

	valgrind_get_nonblocking \

	valgrind_example_write_file_blocking \

	valgrind_example_write_file_blocking_threads \

	valgrind_example_write_file_nonblocking \

include/byte_array.h

+4 −0
Original line number Diff line number Diff line
@@ -51,6 +51,7 @@ ByteBuffer ByteBuffer_CreateAndAppend(void* data, size_t max_len, const void* va 
ByteBuffer ByteBuffer_CreateAndAppendArray(void* data, size_t max_len, const ByteArray value);

ByteBuffer ByteBuffer_CreateAndAppendCString(void* data, size_t max_len, const char* value);

ByteBuffer ByteBuffer_CreateAndAppendFormattedCString(void* data, size_t max_len, const char * format, ...);

ByteBuffer ByteBuffer_CreateAndAppendDummyData(void* data, size_t max_len, size_t len);

void ByteBuffer_Reset(ByteBuffer* buffer);

long ByteBuffer_BytesRemaining(const ByteBuffer buffer);

ByteArray ByteBuffer_Consume(ByteBuffer* buffer, size_t max_len);
@@ -61,5 +62,8 @@ ByteBuffer* ByteBuffer_AppendCString(ByteBuffer* buffer, const char* data); 
ByteBuffer* ByteBuffer_AppendFormattedCString(ByteBuffer* buffer, const char * format, ...);

ByteBuffer* ByteBuffer_AppendDummyData(ByteBuffer* buffer, size_t len);

bool ByteBuffer_IsNull(ByteBuffer const buffer);

ByteBuffer ByteBuffer_Malloc(size_t size);

ByteBuffer ByteBuffer_MallocAndAppend(const void* data, size_t len);

void ByteBuffer_Free(ByteBuffer buffer);



#endif // _BYTE_ARRAY_H

include/kinetic_semaphore.h

0 → 100644
+14 −0
Original line number Diff line number Diff line 
#ifndef _KINETIC_SEMAPHORE_H

#define _KINETIC_SEMAPHORE_H



struct _KineticSemaphore;

typedef struct _KineticSemaphore KineticSemaphore;



KineticSemaphore * KineticSemaphore_Create(void);

void KineticSemaphore_Lock(KineticSemaphore * sem);

void KineticSemaphore_Unlock(KineticSemaphore * sem);

void KineticSemaphore_Signal(KineticSemaphore * sem);

void KineticSemaphore_WaitForSignalAndDestroy(KineticSemaphore * sem);



#endif // _KINETIC_SEMAPHORE_H

src/examples/get_nonblocking.c

0 → 100644
+145 −0
Original line number Diff line number Diff line 
#include "kinetic_client.h"

#include "kinetic_types.h"

#include "kinetic_semaphore.h"

#include <stdlib.h>

#include <sys/param.h>

#include <openssl/sha.h>

#include <pthread.h>



typedef struct {

    KineticSemaphore * sem;

    KineticStatus status;

} GetStatus;



static void get_finished(KineticCompletionData* kinetic_data, void* clientData);



int main(int argc, char** argv)

{

    (void)argc;

    (void)argv;



    // Initialize kinetic-c and establish session

    KineticClient * client = KineticClient_Init("stdout", 0);

    if (client == NULL) { return 1; }

    const char HmacKeyString[] = "asdfasdf";

    KineticSession session = {.config = {

        .host = "localhost",

        .port = KINETIC_PORT,

        .clusterVersion = 0,

        .identity = 1,

        .hmacKey = ByteArray_CreateWithCString(HmacKeyString),

    }};



    KineticStatus connect_status = KineticClient_CreateConnection(&session, client);

    if (connect_status != KINETIC_STATUS_SUCCESS) {

        fprintf(stderr, "Failed connecting to the Kinetic device w/status: %s\n",

            Kinetic_GetStatusDescription(connect_status));

        return 1;

    }



    // some dummy data to PUT

    uint8_t value_data[] = { 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0A, 0x0B, 0x0C, 0x0D, 0x0E, 0x0F };

    ByteBuffer value = ByteBuffer_MallocAndAppend(value_data, sizeof(value_data));



    // a dummy key

    uint8_t key_data[] = {0x00, 0x01, 0x02, 0x03, 0x04};

    ByteBuffer key = ByteBuffer_MallocAndAppend(key_data, sizeof(key_data));



    // Populate tag with SHA1

    ByteBuffer tag = ByteBuffer_Malloc(20);

    uint8_t sha1[20];

    SHA1(value.array.data, value.bytesUsed, &sha1[0]);

    ByteBuffer_Append(&tag, sha1, sizeof(sha1));



    KineticEntry entry = {

        .key = key,

        .tag = tag,

        .algorithm = KINETIC_ALGORITHM_SHA1,

        .value = value,

        .synchronization = KINETIC_SYNCHRONIZATION_WRITETHROUGH,

    };



    // Do a blocking put to make sure there is something there to read back

    KineticStatus put_status = KineticClient_Put(&session, &entry, NULL);



    if (put_status != KINETIC_STATUS_SUCCESS) {

        fprintf(stderr, "Put failed w/status: %s\n", Kinetic_GetStatusDescription(put_status));

        return 1;

    }



    // Create structure to populate with GET status in callback

    //   a semaphore is used to notify the main thread that it's

    //   safe to proceed.

    GetStatus get_status = {

        .sem = KineticSemaphore_Create(),

        .status = KINETIC_STATUS_INVALID,

    };



    ByteBuffer getTag = ByteBuffer_Malloc(tag.bytesUsed);

    ByteBuffer getValue = ByteBuffer_Malloc(value.bytesUsed);



    // Because I'm passing a pointer to this entry to KineticClient_Put(), this entry must not

    //   go out of scope until the GET completes

    KineticEntry get_entry = {

        .key = key,

        .tag = getTag,

        .algorithm = KINETIC_ALGORITHM_SHA1,

        .value = getValue,

        .force = true,

    };



    KineticStatus status = KineticClient_Get(

        &session,

        &get_entry,

        &(KineticCompletionClosure) {

            .callback = get_finished,

            .clientData = &get_status,

        }

    );

    if (status != KINETIC_STATUS_SUCCESS) {

        fprintf(stderr, "Get failed w/status: %s\n", Kinetic_GetStatusDescription(status));

        return 1;

    }



    // Wait for GET to finish

    KineticSemaphore_WaitForSignalAndDestroy(get_status.sem);



    if (get_status.status != KINETIC_STATUS_SUCCESS) {

        fprintf(stderr, "GET failed w/status: %s\n", Kinetic_GetStatusDescription(get_status.status));

        return 1;

    }



    if ((value.bytesUsed == getValue.bytesUsed) &&

        (memcmp(value.array.data, getValue.array.data, getValue.bytesUsed) != 0)) {

        fprintf(stderr, "GET completed but returned unexpected value");

        return 1;

    }

    printf("GET completed successfully!\n");



    // Free malloc'd buffers

    ByteBuffer_Free(value);

    ByteBuffer_Free(key);

    ByteBuffer_Free(tag);



    ByteBuffer_Free(getValue);

    ByteBuffer_Free(getTag);

    



    // Shutdown client connection and cleanup

    KineticClient_DestroyConnection(&session);

    KineticClient_Shutdown(client);



    return 0;

}



static void get_finished(KineticCompletionData* kinetic_data, void* clientData)

{

    GetStatus * get_status = clientData;



    KineticSemaphore_Lock(get_status->sem);

    // Save GET result status

    get_status->status = kinetic_data->status;

    // Signal that we're done

    KineticSemaphore_Signal(get_status->sem);

    KineticSemaphore_Unlock(get_status->sem);

}

src/examples/put_nonblocking.c

0 → 100644
+116 −0
Original line number Diff line number Diff line 
#include "kinetic_client.h"

#include "kinetic_types.h"

#include "kinetic_semaphore.h"

#include <stdlib.h>

#include <openssl/sha.h>

#include <pthread.h>



typedef struct {

    KineticSemaphore * sem;

    KineticStatus status;

} PutStatus;



static void put_finished(KineticCompletionData* kinetic_data, void* clientData);



int main(int argc, char** argv)

{

    (void)argc;

    (void)argv;



    // Initialize kinetic-c and establish session

    KineticClient * client = KineticClient_Init("stdout", 0);

    if (client == NULL) { return 1; }

    const char HmacKeyString[] = "asdfasdf";

    KineticSession session = {.config = {

        .host = "localhost",

        .port = KINETIC_PORT,

        .clusterVersion = 0,

        .identity = 1,

        .hmacKey = ByteArray_CreateWithCString(HmacKeyString),

    }};



    KineticStatus connect_status = KineticClient_CreateConnection(&session, client);

    if (connect_status != KINETIC_STATUS_SUCCESS) {

        fprintf(stderr, "Failed connecting to the Kinetic device w/status: %s\n",

            Kinetic_GetStatusDescription(connect_status));

        return 1;

    }



    // Create structure to populate with PUT status in callback

    //   a semaphore is used to notify the main thread that it's

    //   safe to proceed.

    PutStatus put_status = {

        .sem = KineticSemaphore_Create(),

        .status = KINETIC_STATUS_INVALID,

    };



    // some dummy data to PUT

    uint8_t value_data[] = { 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0A, 0x0B, 0x0C, 0x0D, 0x0E, 0x0F };

    ByteBuffer value = ByteBuffer_MallocAndAppend(value_data, sizeof(value_data));



    // a dummy key

    uint8_t key_data[] = {0x00, 0x01, 0x02, 0x03, 0x04};

    ByteBuffer key = ByteBuffer_MallocAndAppend(key_data, sizeof(key_data));



    // Populate tag with SHA1

    ByteBuffer tag = ByteBuffer_Malloc(20);

    uint8_t sha1[20];

    SHA1(value.array.data, value.bytesUsed, &sha1[0]);

    ByteBuffer_Append(&tag, sha1, sizeof(sha1));



    // Because I'm passing a pointer to this entry to KineticClient_Put(), this entry must not

    //   go out of scope until the PUT completes

    KineticEntry entry = {

        .key = key,

        .tag = tag,

        .algorithm = KINETIC_ALGORITHM_SHA1,

        .value = value,

        .synchronization = KINETIC_SYNCHRONIZATION_WRITETHROUGH,

    };



    KineticStatus status = KineticClient_Put(

        &session,

        &entry,

        &(KineticCompletionClosure) {

            .callback = put_finished,

            .clientData = &put_status,

        }

    );



    if (status != KINETIC_STATUS_SUCCESS) {

        fprintf(stderr, "PUT failed w/status: %s\n", Kinetic_GetStatusDescription(status));

        return 1;

    }



    // Wait for PUT to finish

    KineticSemaphore_WaitForSignalAndDestroy(put_status.sem);



    if (put_status.status != KINETIC_STATUS_SUCCESS) {

        fprintf(stderr, "PUT failed w/status: %s\n", Kinetic_GetStatusDescription(put_status.status));

        return 1;

    }

    printf("PUT completed successfully!\n");



    // Free malloc'd buffers

    ByteBuffer_Free(value);

    ByteBuffer_Free(key);

    ByteBuffer_Free(tag);



    // Shutdown client connection and cleanup

    KineticClient_DestroyConnection(&session);

    KineticClient_Shutdown(client);



    return 0;

}



static void put_finished(KineticCompletionData* kinetic_data, void* clientData)

{

    PutStatus * put_status = clientData;



    KineticSemaphore_Lock(put_status->sem);

    // Save PUT result status

    put_status->status = kinetic_data->status;

    // Signal that we're done

    KineticSemaphore_Signal(put_status->sem);

    KineticSemaphore_Unlock(put_status->sem);

}