void
athenaTransportLinkAdapter_SetLogLevel(AthenaTransportLinkAdapter *athenaTransportLinkAdapter, const PARCLogLevel level)
{
// set log level on main athena module
parcLog_SetLevel(athenaTransportLinkAdapter->log, level);
// set log level on all modules
if (athenaTransportLinkAdapter->moduleList) {
for (int index = 0; index < parcArrayList_Size(athenaTransportLinkAdapter->moduleList); index++) {
AthenaTransportLinkModule *athenaTransportLinkModule = parcArrayList_Get(athenaTransportLinkAdapter->moduleList, index);
athenaTransportLinkModule_SetLogLevel(athenaTransportLinkModule, level);
}
}
// set log level on all instances
if (athenaTransportLinkAdapter->listenerList) {
for (int index = 0; index < parcArrayList_Size(athenaTransportLinkAdapter->listenerList); index++) {
AthenaTransportLink *athenaTransportLink = parcArrayList_Get(athenaTransportLinkAdapter->listenerList, index);
athenaTransportLink_SetLogLevel(athenaTransportLink, level);
}
}
// set log level on all listener instances
if (athenaTransportLinkAdapter->instanceList) {
for (int index = 0; index < parcArrayList_Size(athenaTransportLinkAdapter->instanceList); index++) {
AthenaTransportLink *athenaTransportLink = parcArrayList_Get(athenaTransportLinkAdapter->instanceList, index);
if (athenaTransportLink) {
athenaTransportLink_SetLogLevel(athenaTransportLink, level);
}
}
}
}
LONGBOW_TEST_CASE(Global, parcLog_Message)
{
PARCLog *log = (PARCLog *) longBowTestCase_GetClipBoardData(testCase);
parcLog_SetLevel(log, PARCLogLevel_Alert);
assertTrue(parcLog_Message(log, PARCLogLevel_Alert, 0, "This is an alert message"),
"Expected message to be logged");
}
LONGBOW_TEST_CASE(Global, parcLog_Info_WrongLevel)
{
PARCLog *log = (PARCLog *) longBowTestCase_GetClipBoardData(testCase);
parcLog_SetLevel(log, PARCLogLevel_Off);
assertFalse(parcLog_Info(log, "This is a debug message"),
"Expected message to not be logged");
}
LONGBOW_TEST_CASE(Global, parcLog_IsLoggable_False)
{
PARCLog *log = (PARCLog *) longBowTestCase_GetClipBoardData(testCase);
parcLog_SetLevel(log, PARCLogLevel_Off);
assertFalse(parcLog_IsLoggable(log, PARCLogLevel_Alert), "Expected parcLog_IsLoggable to be true.");
}
LONGBOW_TEST_CASE(Global, parcLog_Emergency_WrongLevel)
{
PARCLog *log = (PARCLog *) longBowTestCase_GetClipBoardData(testCase);
parcLog_SetLevel(log, PARCLogLevel_Off);
// Even if the log level is set to off, you cannot block an emergency message.
assertTrue(parcLog_Emergency(log, "This is an emergency message"),
"Expected message to not be logged");
}
static PARCLog *
_parc_logger_create(const char *name)
{
PARCLogReporter *reporter = parcLogReporterTextStdout_Create();
PARCLog *log = parcLog_Create("localhost", "athenaTransportLinkModule", name, reporter);
parcLogReporter_Release(&reporter);
parcLog_SetLevel(log, PARCLogLevel_Info);
return log;
}
static CCNxMetaMessage *
_Control_Command_Set(Athena *athena, CCNxName *ccnxName, const char *command)
{
CCNxMetaMessage *responseMessage = NULL;
if (ccnxName_GetSegmentCount(ccnxName) <= (AthenaCommandSegment + 2)) {
responseMessage = _create_response(athena, ccnxName, "Athena set arguments required <name> <value>");
return responseMessage;
}
// Check for required set name argument
CCNxNameSegment *nameSegment = ccnxName_GetSegment(ccnxName, AthenaCommandSegment + 1);
char *name = ccnxNameSegment_ToString(nameSegment);
if (strcasecmp(name, AthenaCommand_LogLevel) == 0) {
// Check the level to set the log to
nameSegment = ccnxName_GetSegment(ccnxName, AthenaCommandSegment + 2);
char *level = ccnxNameSegment_ToString(nameSegment);
if (strcasecmp(level, AthenaCommand_LogDebug) == 0) {
athenaTransportLinkAdapter_SetLogLevel(athena->athenaTransportLinkAdapter, PARCLogLevel_Debug);
parcLog_SetLevel(athena->log, PARCLogLevel_Debug);
athenaInterestControl_LogConfigurationChange(athena, ccnxName, NULL);
responseMessage = _create_response(athena, ccnxName, "set athena logging level to %s", AthenaCommand_LogDebug);
} else if (strcasecmp(level, AthenaCommand_LogInfo) == 0) {
athenaTransportLinkAdapter_SetLogLevel(athena->athenaTransportLinkAdapter, PARCLogLevel_Info);
parcLog_SetLevel(athena->log, PARCLogLevel_Info);
athenaInterestControl_LogConfigurationChange(athena, ccnxName, NULL);
responseMessage = _create_response(athena, ccnxName, "set athena logging level to %s", AthenaCommand_LogInfo);
} else if (strcasecmp(level, AthenaCommand_LogOff) == 0) {
athenaTransportLinkAdapter_SetLogLevel(athena->athenaTransportLinkAdapter, PARCLogLevel_Off);
parcLog_SetLevel(athena->log, PARCLogLevel_Off);
athenaInterestControl_LogConfigurationChange(athena, ccnxName, NULL);
responseMessage = _create_response(athena, ccnxName, "set athena logging level to %s", AthenaCommand_LogOff);
} else if (strcasecmp(level, AthenaCommand_LogAll) == 0) {
athenaTransportLinkAdapter_SetLogLevel(athena->athenaTransportLinkAdapter, PARCLogLevel_All);
parcLog_SetLevel(athena->log, PARCLogLevel_All);
athenaInterestControl_LogConfigurationChange(athena, ccnxName, NULL);
responseMessage = _create_response(athena, ccnxName, "set athena logging level to %s", AthenaCommand_LogAll);
} else if (strcasecmp(level, AthenaCommand_LogError) == 0) {
athenaTransportLinkAdapter_SetLogLevel(athena->athenaTransportLinkAdapter, PARCLogLevel_Error);
parcLog_SetLevel(athena->log, PARCLogLevel_Error);
athenaInterestControl_LogConfigurationChange(athena, ccnxName, NULL);
responseMessage = _create_response(athena, ccnxName, "set athena logging level to %s", AthenaCommand_LogError);
} else if (strcasecmp(level, AthenaCommand_LogNotice) == 0) {
athenaTransportLinkAdapter_SetLogLevel(athena->athenaTransportLinkAdapter, PARCLogLevel_Notice);
parcLog_SetLevel(athena->log, PARCLogLevel_Notice);
athenaInterestControl_LogConfigurationChange(athena, ccnxName, NULL);
responseMessage = _create_response(athena, ccnxName, "set athena logging level to %s", AthenaCommand_LogNotice);
} else {
responseMessage = _create_response(athena, ccnxName, "unknown logging level (%s)", level);
}
parcMemory_Deallocate(&level);
} else {
responseMessage = _create_response(athena, ccnxName, "Athena unknown set name (%s)", name);
}
parcMemory_Deallocate(&name);
return responseMessage;
}
static PARCLog *
_parc_logger_create(const char *name)
{
PARCFileOutputStream *fileOutput = parcFileOutputStream_Create(dup(STDOUT_FILENO));
PARCOutputStream *output = parcFileOutputStream_AsOutputStream(fileOutput);
parcFileOutputStream_Release(&fileOutput);
PARCLogReporter *reporter = parcLogReporterFile_Create(output);
parcOutputStream_Release(&output);
PARCLog *log = parcLog_Create("localhost", "athenaTransport", name, reporter);
parcLogReporter_Release(&reporter);
parcLog_SetLevel(log, PARCLogLevel_Info);
return log;
}
static PARCLog *
_athena_logger_create(void)
{
PARCFileOutputStream *fileOutput = parcFileOutputStream_Create(dup(STDOUT_FILENO));
PARCOutputStream *output = parcFileOutputStream_AsOutputStream(fileOutput);
parcFileOutputStream_Release(&fileOutput);
PARCLogReporter *reporter = parcLogReporterFile_Create(output);
parcOutputStream_Release(&output);
PARCLog *log = parcLog_Create("localhost", "athena", NULL, reporter);
parcLogReporter_Release(&reporter);
parcLog_SetLevel(log, PARCLogLevel_Info);
return log;
}
static _CCNxPortalRTAContext *
_ccnxPortalRTAContext_Create(RTATransport *rtaTransport, const CCNxTransportConfig *configuration, int fileId)
{
_CCNxPortalRTAContext *result = parcObject_CreateInstance(_CCNxPortalRTAContext);
if (result != NULL) {
result->rtaTransport = rtaTransport;
result->configuration = configuration;
result->fileId = fileId;
PARCLogReporter *reporter = parcLogReporterTextStdout_Create();
result->logger = parcLog_Create(NULL, "ccnxPortalRTA", NULL, reporter);
parcLogReporter_Release(&reporter);
parcLog_SetLevel(result->logger, PARCLogLevel_Debug);
}
return result;
}
AthenaTransportLink *
athenaTransportLink_Clone(AthenaTransportLink *athenaTransportLink,
const char *name,
AthenaTransportLink_SendMethod *sendMethod,
AthenaTransportLink_ReceiveMethod *receiveMethod,
AthenaTransportLink_CloseMethod *closeMethod)
{
AthenaTransportLink *newTransportLink = athenaTransportLink_Create(name, sendMethod, receiveMethod, closeMethod);
if (newTransportLink != NULL) {
newTransportLink->addLink = athenaTransportLink->addLink;
newTransportLink->addLinkContext = athenaTransportLink->addLinkContext;
newTransportLink->removeLink = athenaTransportLink->removeLink;
newTransportLink->removeLinkContext = athenaTransportLink->removeLinkContext;
newTransportLink->forceLocal = athenaTransportLink->forceLocal;
newTransportLink->eventFd = -1;
parcLog_SetLevel(newTransportLink->log, parcLog_GetLevel(athenaTransportLink->log));
}
return newTransportLink;
}
static void
_parseCommandLine(Athena *athena, int argc, char **argv)
{
int c;
bool interfaceConfigured = false;
while ((c = getopt_long(argc, argv, "hs:c:vd", options, NULL)) != -1) {
switch (c) {
case 's': {
int sizeInMB = atoi(optarg);
if (athenaContentStore_SetCapacity(athena->athenaContentStore, sizeInMB) != true) {
parcLog_Error(athena->log, "Unable to resize content store to %d (MB)", sizeInMB);
}
_contentStoreSizeInMB = sizeInMB;
break;
}
case 'c': {
PARCURI *connectionURI = parcURI_Parse(optarg);
const char *result = athenaTransportLinkAdapter_Open(athena->athenaTransportLinkAdapter, connectionURI);
if (result == NULL) {
parcLog_Error(athena->log, "Unable to configure %s: %s", optarg, strerror(errno));
parcURI_Release(&connectionURI);
exit(EXIT_FAILURE);
}
parcURI_Release(&connectionURI);
interfaceConfigured = true;
break;
}
case 'v':
printf("%s\n", athenaAbout_Version());
exit(0);
case 'd':
athenaTransportLinkAdapter_SetLogLevel(athena->athenaTransportLinkAdapter, PARCLogLevel_Debug);
parcLog_SetLevel(athena->log, PARCLogLevel_Debug);
break;
case 'h':
default:
_usage();
exit(EXIT_FAILURE);
break;
}
}
if (argc - optind) {
parcLog_Error(athena->log, "Bad arguments");
_usage();
exit(EXIT_FAILURE);
}
if (interfaceConfigured != true) {
PARCURI *connectionURI = parcURI_Parse(_athenaDefaultConnectionURI);
if (athenaTransportLinkAdapter_Open(athena->athenaTransportLinkAdapter, connectionURI) == NULL) {
parcLog_Error(athena->log, "Unable to configure an interface. Exiting...");
parcURI_Release(&connectionURI);
exit(EXIT_FAILURE);
}
parcURI_Release(&connectionURI);
struct utsname name;
if (uname(&name) == 0) {
char nodeURIspecification[MAXPATHLEN];
sprintf(nodeURIspecification, "tcp://%s:%d/listener",
name.nodename, AthenaDefaultListenerPort);
PARCURI *nodeURI = parcURI_Parse(nodeURIspecification);
if (athenaTransportLinkAdapter_Open(athena->athenaTransportLinkAdapter, nodeURI) == NULL) {
parcURI_Release(&nodeURI);
}
}
}
}
void
athenaTransportLink_SetLogLevel(AthenaTransportLink *athenaTransportLink, const PARCLogLevel level)
{
parcLog_SetLevel(athenaTransportLink->log, level);
}
void
athenaTransportLinkModule_SetLogLevel(AthenaTransportLinkModule *athenaTransportLinkModule, const PARCLogLevel level)
{
parcLog_SetLevel(athenaTransportLinkModule->log, level);
}
