void KineticLogger_LogStatus(KineticProto_Status* status)
{
if (LogLevel < 0) {
return;
}
ProtobufCMessage* protoMessage = (ProtobufCMessage*)status;
KineticProto_Status_StatusCode code = status->code;
if (code == KINETIC_PROTO_STATUS_STATUS_CODE_SUCCESS) {
printf("Operation completed successfully\n");
}
else if (code == KINETIC_PROTO_STATUS_STATUS_CODE_INVALID_STATUS_CODE) {
printf("Operation was aborted!\n");
}
else {
// Output status code short name
const ProtobufCMessageDescriptor* protoMessageDescriptor = protoMessage->descriptor;
const ProtobufCFieldDescriptor* statusCodeDescriptor =
protobuf_c_message_descriptor_get_field_by_name(protoMessageDescriptor, "code");
const ProtobufCEnumDescriptor* statusCodeEnumDescriptor =
(ProtobufCEnumDescriptor*)statusCodeDescriptor->descriptor;
const ProtobufCEnumValue* eStatusCodeVal =
protobuf_c_enum_descriptor_get_value(statusCodeEnumDescriptor, code);
KineticLogger_LogPrintf("Operation completed but failed w/error: %s=%d(%s)\n",
statusCodeDescriptor->name, code, eStatusCodeVal->name);
// Output status message, if supplied
if (status->statusMessage) {
const ProtobufCFieldDescriptor* statusMsgFieldDescriptor =
protobuf_c_message_descriptor_get_field_by_name(protoMessageDescriptor, "statusMessage");
const ProtobufCMessageDescriptor* statusMsgDescriptor =
(ProtobufCMessageDescriptor*)statusMsgFieldDescriptor->descriptor;
KineticLogger_LogPrintf(" %s: '%s'", statusMsgDescriptor->name, status->statusMessage);
}
// Output detailed message, if supplied
if (status->has_detailedMessage) {
char tmp[8], msg[256];
const ProtobufCFieldDescriptor* statusDetailedMsgFieldDescriptor =
protobuf_c_message_descriptor_get_field_by_name(
protoMessageDescriptor, "detailedMessage");
const ProtobufCMessageDescriptor* statusDetailedMsgDescriptor =
(ProtobufCMessageDescriptor*)
statusDetailedMsgFieldDescriptor->descriptor;
sprintf(msg, " %s: ", statusDetailedMsgDescriptor->name);
for (size_t i = 0; i < status->detailedMessage.len; i++) {
sprintf(tmp, "%02hhX", status->detailedMessage.data[i]);
strcat(msg, tmp);
}
KineticLogger_LogPrintf(" %s", msg);
}
}
}
void KineticLogger_LogHeader(int log_level, const KineticPDUHeader* header)
{
if (header == NULL || !is_level_enabled(log_level)) {
return;
}
KineticLogger_Log(log_level, "PDU Header:");
KineticLogger_LogPrintf(log_level, " versionPrefix: %c", header->versionPrefix);
KineticLogger_LogPrintf(log_level, " protobufLength: %d", header->protobufLength);
KineticLogger_LogPrintf(log_level, " valueLength: %d", header->valueLength);
}
static void log_proto_level_start_array(const char* name, unsigned quantity)
{
KineticLogger_LogPrintf(0, "%s%s: (%u elements)", indent, name, quantity);
KineticLogger_LogPrintf(0, "%s[", (indent));
if (strlen(indent) < max_indent) {
strcat(indent, LOG_INDENT);
}
else {
indent_overflow++;
}
}
void KineticController_HandleUnexpectedResponse(void *msg,
int64_t seq_id,
void *bus_udata,
void *socket_udata)
{
KineticResponse * response = msg;
KineticSession* session = socket_udata;
bool connetionInfoReceived = false;
char const * statusTag = "[PDU RX STATUS]";
char const * unexpectedTag = "[PDU RX UNEXPECTED]";
char const * logTag = unexpectedTag;
int logAtLevel, protoLogAtLevel;
(void)bus_udata;
// Handle unsolicited status PDUs
if (response->proto->authtype == COM__SEAGATE__KINETIC__PROTO__MESSAGE__AUTH_TYPE__UNSOLICITEDSTATUS) {
int64_t connectionID = KineticResponse_GetConnectionID(response);
if (connectionID != 0)
{
// Store connectionID from unsolicited status message in the session for future requests
KineticSession_SetConnectionID(session, connectionID);
LOGF2("Extracted connection ID from unsolicited status PDU (id=%lld)", connectionID);
connetionInfoReceived = true;
logTag = statusTag;
logAtLevel = 2;
protoLogAtLevel = 3;
}
else {
LOG0("WARNING: Unsolicited status received. Connection being terminated by remote!");
logTag = statusTag;
logAtLevel = 0;
protoLogAtLevel = 0;
KineticStatus status = KineticResponse_GetStatus(response);
KineticSession_SetTerminationStatus(session, status);
}
}
else {
LOG0("WARNING: Received unexpected response!");
logTag = unexpectedTag;
logAtLevel = 0;
protoLogAtLevel = 0;
}
KineticLogger_LogPrintf(logAtLevel, "%s pdu: %p, session: %p, bus: %p, "
"fd: %6d, seq: %8lld, protoLen: %8u, valueLen: %8u",
logTag,
(void*)response, (void*)session,
(void*)session->messageBus,
session->socket, (long long)seq_id,
KineticResponse_GetProtobufLength(response),
KineticResponse_GetValueLength(response));
KineticLogger_LogProtobuf(protoLogAtLevel, response->proto);
KineticAllocator_FreeKineticResponse(response);
if (connetionInfoReceived) {
KineticResourceWaiter_SetAvailable(&session->connectionReady);
}
}
void test_KineticLogger_Log_should_write_log_message_to_file(void)
{
const char* msg = "Some really important message!";
KineticLogger_Init(TEST_LOG_FILE, 3);
KineticLogger_LogPrintf(0, msg);
// TEST_ASSERT_EQUAL_FILE_CONTENT(TEST_LOG_FILE, content, length);
TEST_ASSERT_FILE_EXISTS(TEST_LOG_FILE);
}
static void log_proto_level_end_array(void)
{
if (indent_overflow == 0) {
indent[strlen(indent) - 2] = '\0';
}
else {
indent_overflow--;
}
KineticLogger_LogPrintf(0, "%s]", indent);
}
static void log_proto_level_start(const char* name)
{
KineticLogger_LogPrintf(0, "%s%s {", indent, name); \
if (strlen(indent) < max_indent) {
strcat(indent, LOG_INDENT);
}
else {
indent_overflow++;
}
}
void KineticLogger_LogLocation(const char* filename, int line, const char* message)
{
if (filename == NULL || message == NULL) {
return;
}
if (KineticLogLevel >= 0) {
KineticLogger_LogPrintf(1, "[@%s:%d] %s", filename, line, message);
}
else {
printf("\n[@%s:%d] %s\n", filename, line, message);
fflush(stdout);
}
}
STATIC void log_cb(log_event_t event, int log_level, const char *msg, void *udata) {
(void)udata;
const char *event_str = Bus_LogEventStr(event);
KineticLogger_LogPrintf(log_level, "%s[%d] %s", event_str, log_level, msg);
}
void KineticLogger_Log(int log_level, const char* message)
{
KineticLogger_LogPrintf(log_level, "%s", message);
}
static void LogUnboxed(int log_level,
void const * const fieldData,
ProtobufCFieldDescriptor const * const fieldDesc,
size_t const i,
char* log_indent)
{
switch (fieldDesc->type) {
case PROTOBUF_C_TYPE_INT32:
case PROTOBUF_C_TYPE_SINT32:
case PROTOBUF_C_TYPE_SFIXED32:
{
int32_t const * value = (int32_t const *)fieldData;
KineticLogger_LogPrintf(log_level, "%s%s: %ld", log_indent, fieldDesc->name, value[i]);
}
break;
case PROTOBUF_C_TYPE_INT64:
case PROTOBUF_C_TYPE_SINT64:
case PROTOBUF_C_TYPE_SFIXED64:
{
int64_t* value = (int64_t*)fieldData;
KineticLogger_LogPrintf(log_level, "%s%s: %lld", log_indent, fieldDesc->name, value[i]);
}
break;
case PROTOBUF_C_TYPE_UINT32:
case PROTOBUF_C_TYPE_FIXED32:
{
uint32_t* value = (uint32_t*)fieldData;
KineticLogger_LogPrintf(log_level, "%s%s: %lu", log_indent, fieldDesc->name, value[i]);
}
break;
case PROTOBUF_C_TYPE_UINT64:
case PROTOBUF_C_TYPE_FIXED64:
{
uint64_t* value = (uint64_t*)fieldData;
KineticLogger_LogPrintf(log_level, "%s%s: %llu", log_indent, fieldDesc->name, value[i]);
}
break;
case PROTOBUF_C_TYPE_FLOAT:
{
float* value = (float*)fieldData;
KineticLogger_LogPrintf(log_level, "%s%s: %f", log_indent, fieldDesc->name, value[i]);
}
break;
case PROTOBUF_C_TYPE_DOUBLE:
{
double* value = (double*)fieldData;
KineticLogger_LogPrintf(log_level, "%s%s: %f", log_indent, fieldDesc->name, value[i]);
}
break;
case PROTOBUF_C_TYPE_BOOL:
{
protobuf_c_boolean* value = (protobuf_c_boolean*)fieldData;
KineticLogger_LogPrintf(log_level, "%s%s: %s", log_indent, fieldDesc->name, BOOL_TO_STRING(value[i]));
}
break;
case PROTOBUF_C_TYPE_STRING:
{
char** strings = (char**)fieldData;
KineticLogger_LogPrintf(log_level, "%s%s: %s", log_indent, fieldDesc->name, strings[i]);
}
break;
case PROTOBUF_C_TYPE_BYTES:
{
ProtobufCBinaryData* value = (ProtobufCBinaryData*)fieldData;
log_proto_level_start(fieldDesc->name);
KineticLogger_LogByteArray(log_level, log_indent,
(ByteArray){.data = value[i].data,
.len = value[i].len});
log_proto_level_end();
}
break;
case PROTOBUF_C_TYPE_ENUM:
{
int * value = (int*)fieldData;
ProtobufCEnumDescriptor const * enumDesc = fieldDesc->descriptor;
ProtobufCEnumValue const * enumVal = protobuf_c_enum_descriptor_get_value(enumDesc, value[i]);
KineticLogger_LogPrintf(log_level, "%s%s: %s", log_indent, fieldDesc->name, enumVal->name);
}
break;
case PROTOBUF_C_TYPE_MESSAGE: // nested message
{
ProtobufCMessage** msg = (ProtobufCMessage**)fieldData;
if (msg[i] != NULL)
{
log_proto_level_start(fieldDesc->name);
log_protobuf_message(log_level, msg[i], log_indent);
log_proto_level_end();
}
} break;
default:
KineticLogger_LogPrintf(log_level, "Invalid message field type!: %d", fieldDesc->type);
KINETIC_ASSERT(false); // should never get here!
break;
};
static void log_version_info(void)
{
KineticLogger_LogPrintf(1, "kinetic-c version: v%s (protocol: v%s, commit: %s)",
KINETIC_C_VERSION, KINETIC_C_PROTOCOL_VERSION, KINETIC_C_REPO_HASH);
}
