Completed GetLog operation (da1f11f5) · Commits · kinetic-archive / kinetic-c

include/kinetic_types.h

+22 −2

Original line number	Diff line number	Diff line
		@@ -245,27 +245,44 @@ typedef struct {
		char* protocolVersion;
		char* protocolCompilationDate;
		char* protocolSourceHash;
		KineticDeviceInfo_Interface** interfaces;
		KineticDeviceInfo_Interface* interfaces;
		size_t numInterfaces;
		int32_t port;
		int32_t tlsPort;
		} KineticDeviceInfo_Configuration;
		typedef enum {
		KINETIC_MESSAGE_TYPE_GET = 0,
		KINETIC_MESSAGE_TYPE_INVALID = 0,
		KINETIC_MESSAGE_TYPE_GET_RESPONSE,
		KINETIC_MESSAGE_TYPE_GET,
		KINETIC_MESSAGE_TYPE_PUT_RESPONSE,
		KINETIC_MESSAGE_TYPE_PUT,
		KINETIC_MESSAGE_TYPE_DELETE_RESPONSE,
		KINETIC_MESSAGE_TYPE_DELETE,
		KINETIC_MESSAGE_TYPE_GETNEXT_RESPONSE,
		KINETIC_MESSAGE_TYPE_GETNEXT,
		KINETIC_MESSAGE_TYPE_GETPREVIOUS_RESPONSE,
		KINETIC_MESSAGE_TYPE_GETPREVIOUS,
		KINETIC_MESSAGE_TYPE_GETKEYRANGE_RESPONSE,
		KINETIC_MESSAGE_TYPE_GETKEYRANGE,
		KINETIC_MESSAGE_TYPE_GETVERSION_RESPONSE,
		KINETIC_MESSAGE_TYPE_GETVERSION,
		KINETIC_MESSAGE_TYPE_SETUP_RESPONSE,
		KINETIC_MESSAGE_TYPE_SETUP,
		KINETIC_MESSAGE_TYPE_GETLOG_RESPONSE,
		KINETIC_MESSAGE_TYPE_GETLOG,
		KINETIC_MESSAGE_TYPE_SECURITY_RESPONSE,
		KINETIC_MESSAGE_TYPE_SECURITY,
		KINETIC_MESSAGE_TYPE_PEER2PEERPUSH_RESPONSE,
		KINETIC_MESSAGE_TYPE_PEER2PEERPUSH,
		KINETIC_MESSAGE_TYPE_NOOP_RESPONSE,
		KINETIC_MESSAGE_TYPE_NOOP,
		KINETIC_MESSAGE_TYPE_FLUSHALLDATA_RESPONSE,
		KINETIC_MESSAGE_TYPE_FLUSHALLDATA,
		KINETIC_MESSAGE_TYPE_PINOP_RESPONSE,
		KINETIC_MESSAGE_TYPE_PINOP,
		KINETIC_MESSAGE_TYPE_MEDIASCAN_RESPONSE,
		KINETIC_MESSAGE_TYPE_MEDIASCAN,
		KINETIC_MESSAGE_TYPE_MEDIAOPTIMIZE_RESPONSE,
		KINETIC_MESSAGE_TYPE_MEDIAOPTIMIZE,
		} KineticMessageType;
		typedef struct {
		@@ -303,6 +320,9 @@ typedef struct {
		KineticDeviceInfo_Limits* limits;
		KineticDeviceInfo_Device* device;
		} KineticDeviceInfo;

		const char* KineticMessageType_GetName(KineticMessageType type);

		#define KINETIC_DEVICE_INFO_SCRATCH_BUF_LEN (1024 * 1024 * 4) // Will get reallocated to actual/used size post-copy

		#endif // _KINETIC_TYPES_H

src/lib/kinetic_device_info.c

+166 −67

Original line number	Diff line number	Diff line
		@@ -23,53 +23,164 @@
		#include "kinetic_logger.h"
		#include <stdlib.h>

		// static size_t sizeof_KineticDeviceInfo_Utilizations(const KineticProto_Command_GetLog* getLog)
		// {
		// size_t size = 0;
		// size += getLog->n_utilizations * sizeof(KineticDeviceInfo_Utilization);
		// for (size_t i = 0; i < getLog->n_utilizations; i++) {
		// if (getLog->utilizations[i]->name != NULL) {
		// size += strlen(getLog->utilizations[i]->name) + 1;
		// }
		// }
		// return size;
		// }
		#define COPY_VALUE_OPTIONAL(_attr, _dest, _src) { \
		if (_src->has_##_attr) { _dest->_attr = _src->_attr; } }
		#define COPY_CSTRING(_attr, _dest, _src, _allocator) \
		if (_src->_attr != NULL) { \
		size_t len = strlen(_src->_attr)+1; \
		_dest->_attr = KineticSerialAllocator_AllocateChunk(_allocator, len); \
		memcpy(_dest->_attr, _src->_attr, len); \
		}
		#define COPY_BYTES_OPTIONAL(_attr, _dest, _src, _allocator) \
		if (_src->has_##_attr) { \
		_dest->_attr.data = KineticSerialAllocator_AllocateChunk(_allocator, _src->_attr.len); \
		memcpy(_dest->_attr.data, _src->_attr.data, _src->_attr.len); \
		_dest->_attr.len = _src->_attr.len; \
		}

		static void KineticDeviceInfo_ExtractUtilizations(
		KineticDeviceInfo* info,
		const KineticProto_Command_GetLog* getLog,
		KineticSerialAllocator* allocator)
		{
		info->numUtilizations = getLog->n_utilizations;
		if (info->numUtilizations > 0) {
		info->utilizations = KineticSerialAllocator_AllocateChunk(allocator,
		info->numUtilizations * sizeof(KineticDeviceInfo_Utilization));
		for (size_t i = 0; i < info->numUtilizations; i++) {
		KineticDeviceInfo_Utilization* destUtilization = &(info->utilizations[i]);
		COPY_CSTRING(name, destUtilization, getLog->utilizations[i], allocator);
		COPY_VALUE_OPTIONAL(value, destUtilization, getLog->utilizations[i]);
		}
		}
		}

		static void KineticDeviceInfo_ExtractTemperatures(
		KineticDeviceInfo* info,
		const KineticProto_Command_GetLog* getLog,
		KineticSerialAllocator* allocator)
		{
		if (getLog->n_temperatures > 0) {
		info->numTemperatures = getLog->n_temperatures;
		info->temperatures = KineticSerialAllocator_AllocateChunk(allocator,
		info->numTemperatures * sizeof(KineticDeviceInfo_Temperature));
		for (size_t i = 0; i < info->numTemperatures; i++) {
		KineticDeviceInfo_Temperature* destTemp = &info->temperatures[i];
		COPY_CSTRING(name, destTemp, getLog->temperatures[i], allocator);
		COPY_VALUE_OPTIONAL(current, destTemp, getLog->temperatures[i]);
		COPY_VALUE_OPTIONAL(minimum, destTemp, getLog->temperatures[i]);
		COPY_VALUE_OPTIONAL(maximum, destTemp, getLog->temperatures[i]);
		COPY_VALUE_OPTIONAL(target, destTemp, getLog->temperatures[i]);
		}
		}
		}

		// static size_t sizeof_KineticDeviceInfo_Temperatures(const KineticProto_Command_GetLog* getLog)
		// {
		// size_t size = 0;
		// return size;
		// }
		// static size_t sizeof_KineticDeviceInfo_Capacity(const KineticProto_Command_GetLog* getLog)
		// {
		// size_t size = 0;
		// return size;
		// }
		// static size_t sizeof_KineticDeviceInfo_Configuration(const KineticProto_Command_GetLog* getLog)
		// {
		// size_t size = 0;
		// return size;
		// }
		// static size_t sizeof_KineticDeviceInfo_Statistics(const KineticProto_Command_GetLog* getLog)
		// {
		// size_t size = 0;
		// return size;
		// }
		// static size_t sizeof_messages(const KineticProto_Command_GetLog* getLog)
		// {
		// size_t size = 0;
		// return size;
		// }
		// static size_t sizeof_KineticDeviceInfo_Limits(const KineticProto_Command_GetLog* getLog)
		// {
		// size_t size = 0;
		// return size;
		// }
		// static size_t sizeof_KineticDeviceInfo_Device(const KineticProto_Command_GetLog* getLog)
		// {
		// size_t size = 0;
		// return size;
		// }
		static void KineticDeviceInfo_ExtractCapacity(
		KineticDeviceInfo* info,
		const KineticProto_Command_GetLog* getLog,
		KineticSerialAllocator* allocator)
		{
		if (getLog->capacity != NULL) {
		info->capacity = KineticSerialAllocator_AllocateChunk(allocator, sizeof(KineticDeviceInfo_Capacity));
		COPY_VALUE_OPTIONAL(nominalCapacityInBytes, info->capacity, getLog->capacity);
		COPY_VALUE_OPTIONAL(portionFull, info->capacity, getLog->capacity);
		}
		}

		static void KineticDeviceInfo_ExtractConfiguration(
		KineticDeviceInfo* info,
		const KineticProto_Command_GetLog* getLog,
		KineticSerialAllocator* allocator)
		{
		if (getLog->configuration != NULL) {
		info->configuration = KineticSerialAllocator_AllocateChunk(allocator,
		sizeof(KineticDeviceInfo_Configuration));
		COPY_CSTRING(vendor, info->configuration, getLog->configuration, allocator);
		COPY_CSTRING(model, info->configuration, getLog->configuration, allocator);
		COPY_BYTES_OPTIONAL(serialNumber, info->configuration, getLog->configuration, allocator);
		COPY_BYTES_OPTIONAL(worldWideName, info->configuration, getLog->configuration, allocator);
		COPY_CSTRING(version, info->configuration, getLog->configuration, allocator);
		COPY_CSTRING(compilationDate, info->configuration, getLog->configuration, allocator);
		COPY_CSTRING(sourceHash, info->configuration, getLog->configuration, allocator);
		COPY_CSTRING(protocolVersion, info->configuration, getLog->configuration, allocator);
		COPY_CSTRING(protocolCompilationDate, info->configuration, getLog->configuration, allocator);
		COPY_CSTRING(protocolSourceHash, info->configuration, getLog->configuration, allocator);
		if (getLog->configuration->n_interface > 0) {
		info->configuration->interfaces = KineticSerialAllocator_AllocateChunk(allocator,
		sizeof(KineticDeviceInfo_Interface) * getLog->configuration->n_interface);
		info->configuration->numInterfaces = getLog->configuration->n_interface;
		for (size_t i = 0; i < getLog->configuration->n_interface; i++) {
		KineticDeviceInfo_Interface* destIface = &info->configuration->interfaces[i];
		KineticProto_Command_GetLog_Configuration_Interface* srcIface = getLog->configuration->interface[i];
		COPY_CSTRING(name, destIface, srcIface, allocator);
		COPY_BYTES_OPTIONAL(MAC, destIface, srcIface, allocator);
		COPY_BYTES_OPTIONAL(ipv4Address, destIface, srcIface, allocator);
		COPY_BYTES_OPTIONAL(ipv6Address, destIface, srcIface, allocator);
		}
		}
		COPY_VALUE_OPTIONAL(port, info->configuration, getLog->configuration);
		COPY_VALUE_OPTIONAL(tlsPort, info->configuration, getLog->configuration);
		}
		}

		static void KineticDeviceInfo_ExtractStatistics(
		KineticDeviceInfo* info,
		const KineticProto_Command_GetLog* getLog,
		KineticSerialAllocator* allocator)
		{
		if (getLog->statistics != NULL && getLog->n_statistics > 0) {
		info->numStatistics = getLog->n_statistics;
		info->statistics = KineticSerialAllocator_AllocateChunk(allocator,
		sizeof(KineticDeviceInfo_Statistics) * getLog->n_statistics);
		for (size_t i = 0; i < getLog->n_statistics; i++) {
		KineticDeviceInfo_Statistics* destStats = &info->statistics[i];
		KineticProto_Command_GetLog_Statistics* srcStats = getLog->statistics[i];
		destStats->messageType = KineticProto_Command_MessageType_to_KineticMessageType(srcStats->messageType);
		COPY_VALUE_OPTIONAL(count, destStats, srcStats);
		COPY_VALUE_OPTIONAL(bytes, destStats, srcStats);
		}
		}
		}

		static void KineticDeviceInfo_ExtractMessages(
		KineticDeviceInfo* info,
		const KineticProto_Command_GetLog* getLog,
		KineticSerialAllocator* allocator)
		{
		COPY_BYTES_OPTIONAL(messages, info, getLog, allocator);
		}

		static void KineticDeviceInfo_ExtractLimits(
		KineticDeviceInfo* info,
		const KineticProto_Command_GetLog* getLog,
		KineticSerialAllocator* allocator)
		{
		if (getLog->limits != NULL) {
		info->limits = KineticSerialAllocator_AllocateChunk(allocator, sizeof(KineticDeviceInfo_Limits));
		info->limits->maxKeySize = getLog->limits->maxKeySize;
		info->limits->maxValueSize = getLog->limits->maxValueSize;
		info->limits->maxVersionSize = getLog->limits->maxVersionSize;
		info->limits->maxTagSize = getLog->limits->maxTagSize;
		info->limits->maxConnections = getLog->limits->maxConnections;
		info->limits->maxOutstandingReadRequests = getLog->limits->maxOutstandingReadRequests;
		info->limits->maxOutstandingWriteRequests = getLog->limits->maxOutstandingWriteRequests;
		info->limits->maxMessageSize = getLog->limits->maxMessageSize;
		info->limits->maxKeyRangeCount = getLog->limits->maxKeyRangeCount;
		info->limits->maxIdentityCount = getLog->limits->maxIdentityCount;
		info->limits->maxPinSize = getLog->limits->maxPinSize;
		}
		}

		static void KineticDeviceInfo_ExtractDevice(
		KineticDeviceInfo* info,
		const KineticProto_Command_GetLog* getLog,
		KineticSerialAllocator* allocator)
		{
		if (getLog->device != NULL) {
		info->device = KineticSerialAllocator_AllocateChunk(allocator, sizeof(KineticDeviceInfo_Device));
		COPY_BYTES_OPTIONAL(name, info->device, getLog->device, allocator);
		}
		}

		KineticDeviceInfo* KineticDeviceInfo_Create(const KineticProto_Command_GetLog* getLog)
		{
		@@ -80,29 +191,17 @@ KineticDeviceInfo* KineticDeviceInfo_Create(const KineticProto_Command_GetLog* g

		// Copy data into the nested allocated structure tree
		KineticDeviceInfo* info = KineticSerialAllocator_AllocateChunk(&allocator, sizeof(KineticDeviceInfo));
		info->numUtilizations = getLog->n_utilizations;
		if (info->numUtilizations > 0) {
		info->utilizations = KineticSerialAllocator_AllocateChunk(&allocator,
		info->numUtilizations * sizeof(KineticDeviceInfo_Utilization));
		for (size_t i = 0; i < info->numUtilizations; i++) {
		// Copy name string
		const char* protoName = getLog->utilizations[i]->name;
		if (protoName != NULL) {
		size_t len = strlen(protoName) + 1;
		info->utilizations[i].name =
		KineticSerialAllocator_AllocateChunk(&allocator, len);
		memcpy(info->utilizations[i].name, protoName, len);
		}
		// Copy value
		if (getLog->utilizations[i]->has_value) {
		info->utilizations[i].value = getLog->utilizations[i]->value;
		}
		}
		}
		assert(info == KineticSerialAllocator_GetBuffer(&allocator));
		info->totalLength = allocator.used;
		KineticDeviceInfo_ExtractUtilizations(info, getLog, &allocator);
		KineticDeviceInfo_ExtractCapacity(info, getLog, &allocator);
		KineticDeviceInfo_ExtractTemperatures(info, getLog, &allocator);
		KineticDeviceInfo_ExtractConfiguration(info, getLog, &allocator);
		KineticDeviceInfo_ExtractStatistics(info, getLog, &allocator);
		KineticDeviceInfo_ExtractMessages(info, getLog, &allocator);
		KineticDeviceInfo_ExtractLimits(info, getLog, &allocator);
		KineticDeviceInfo_ExtractDevice(info, getLog, &allocator);

		// Trim the buffer prior to returning in order to free up unused memory
		info->totalLength = allocator.used;
		info->totalLength = KineticSerialAllocator_TrimBuffer(&allocator);
		info = KineticSerialAllocator_GetBuffer(&allocator);
		LOGF2("Created KineticDeviceInfo @ 0x%0llX w/ length=%zu", info, info->totalLength);

src/lib/kinetic_logger.c

+1 −6

Original line number	Diff line number	Diff line
		@@ -213,7 +213,7 @@ static int KineticLogger_u8toa(char* p_buf, uint8_t val)
		return width;
		}

		static int KineticLogger_ByteArraySliceToCString(char* p_buf,
		int KineticLogger_ByteArraySliceToCString(char* p_buf,
		const ByteArray bytes, const int start, const int count)
		{
		int len = 0;
		@@ -225,11 +225,6 @@ static int KineticLogger_ByteArraySliceToCString(char* p_buf,
		return len;
		}

		#define BYTES_TO_CSTRING(_buf_start, _array, _array_start, _count) { \
		ByteArray __array = {.data = _array.data, .len = (_array).len}; \
		KineticLogger_ByteArraySliceToCString((char*)(_buf_start), (__array), (_array_start), (_count)); \
		}

		// #define Proto_LogBinaryDataOptional(el, attr)
		// if ((el)->has_##(attr)) {
		// KineticLogger_LogByteArray(1, #attr, (el)->(attr));

src/lib/kinetic_logger.h

+6 −0

Original line number	Diff line number	Diff line
		@@ -40,6 +40,12 @@ void KineticLogger_LogStatus(int log_level, KineticProto_Command_Status* status)
		void KineticLogger_LogByteArray(int log_level, const char* title, ByteArray bytes);
		void KineticLogger_LogByteBuffer(int log_level, const char* title, ByteBuffer buffer);

		int KineticLogger_ByteArraySliceToCString(char* p_buf, const ByteArray bytes, const int start, const int count);
		#define BYTES_TO_CSTRING(_buf_start, _array, _array_start, _count) { \
		ByteArray __array = {.data = _array.data, .len = (_array).len}; \
		KineticLogger_ByteArraySliceToCString((char*)(_buf_start), (__array), (_array_start), (_count)); \
		}

		// #define LOG(message) KineticLogger_Log(2, message)
		#if !KINETIC_LOGGER_DISABLED

src/lib/kinetic_types.c

+79 −0

Original line number	Diff line number	Diff line
		@@ -57,3 +57,82 @@ const char* Kinetic_GetStatusDescription(KineticStatus status)
		}
		return KineticStatusDescriptor[(int)status];
		}

		const char* KineticMessageTypeNames[33] =
		{
		"<UNKNOWN>"
		"GET_RESPONSE",
		"GET",
		"PUT_RESPONSE",
		"PUT",
		"DELETE_RESPONSE",
		"DELETE",
		"GETNEXT_RESPONSE",
		"GETNEXT",
		"GETPREVIOUS_RESPONSE",
		"GETPREVIOUS",
		"GETKEYRANGE_RESPONSE",
		"GETKEYRANGE",
		"GETVERSION_RESPONSE",
		"GETVERSION",
		"SETUP_RESPONSE",
		"SETUP",
		"GETLOG_RESPONSE",
		"GETLOG",
		"SECURITY_RESPONSE",
		"SECURITY",
		"PEER2PEERPUSH_RESPONSE",
		"PEER2PEERPUSH",
		"NOOP_RESPONSE",
		"NOOP",
		"FLUSHALLDATA_RESPONSE",
		"FLUSHALLDATA",
		"PINOP_RESPONSE",
		"PINOP",
		"MEDIASCAN_RESPONSE",
		"MEDIASCAN",
		"MEDIAOPTIMIZE_RESPONSE",
		"MEDIAOPTIMIZE"
		};

		const char* KineticMessageType_GetName(KineticMessageType type)
		{
		switch(type) {
		case KINETIC_MESSAGE_TYPE_GET_RESPONSE:
		case KINETIC_MESSAGE_TYPE_GET:
		case KINETIC_MESSAGE_TYPE_PUT_RESPONSE:
		case KINETIC_MESSAGE_TYPE_PUT:
		case KINETIC_MESSAGE_TYPE_DELETE_RESPONSE:
		case KINETIC_MESSAGE_TYPE_DELETE:
		case KINETIC_MESSAGE_TYPE_GETNEXT_RESPONSE:
		case KINETIC_MESSAGE_TYPE_GETNEXT:
		case KINETIC_MESSAGE_TYPE_GETPREVIOUS_RESPONSE:
		case KINETIC_MESSAGE_TYPE_GETPREVIOUS:
		case KINETIC_MESSAGE_TYPE_GETKEYRANGE_RESPONSE:
		case KINETIC_MESSAGE_TYPE_GETKEYRANGE:
		case KINETIC_MESSAGE_TYPE_GETVERSION_RESPONSE:
		case KINETIC_MESSAGE_TYPE_GETVERSION:
		case KINETIC_MESSAGE_TYPE_SETUP_RESPONSE:
		case KINETIC_MESSAGE_TYPE_SETUP:
		case KINETIC_MESSAGE_TYPE_GETLOG_RESPONSE:
		case KINETIC_MESSAGE_TYPE_GETLOG:
		case KINETIC_MESSAGE_TYPE_SECURITY_RESPONSE:
		case KINETIC_MESSAGE_TYPE_SECURITY:
		case KINETIC_MESSAGE_TYPE_PEER2PEERPUSH_RESPONSE:
		case KINETIC_MESSAGE_TYPE_PEER2PEERPUSH:
		case KINETIC_MESSAGE_TYPE_NOOP_RESPONSE:
		case KINETIC_MESSAGE_TYPE_NOOP:
		case KINETIC_MESSAGE_TYPE_FLUSHALLDATA_RESPONSE:
		case KINETIC_MESSAGE_TYPE_FLUSHALLDATA:
		case KINETIC_MESSAGE_TYPE_PINOP_RESPONSE:
		case KINETIC_MESSAGE_TYPE_PINOP:
		case KINETIC_MESSAGE_TYPE_MEDIASCAN_RESPONSE:
		case KINETIC_MESSAGE_TYPE_MEDIASCAN:
		case KINETIC_MESSAGE_TYPE_MEDIAOPTIMIZE_RESPONSE:
		case KINETIC_MESSAGE_TYPE_MEDIAOPTIMIZE:
		return KineticMessageTypeNames[type];
		default:
		case KINETIC_MESSAGE_TYPE_INVALID:
		return KineticMessageTypeNames[0];
		};
		}