bool TestManager::runTestsWithFilter(const std::string & incl, const std::string & excl)
{
// Keep current assertion handler and setup ours
setupAssertionHandler();
setupLogCapturingHandler();
// Prepare tags for filtering
auto included_tags = detail::SplitString(incl, ' ');
auto excluded_tags = detail::SplitString(excl, ' ');
_test_log.clearLogData();
logHeader("== " + _test_manager_name + " Unit Tests Log");
if (included_tags.size() > 0 || excluded_tags.size() > 0) {
if (included_tags.size()) {
logMessage(detail::FormattedString(" * included tags : %s", incl.c_str()));
}
if (excluded_tags.size()) {
logMessage(detail::FormattedString(" * excluded tags : %s", excl.c_str()));
}
logSeparator();
}
bool tests_result = true;
double elapsed_time = 0.0;
if (_registered_tests.size() > 0) {
//
PerformanceTimer timer;
tests_result = executeFilteredTests(included_tags, excluded_tags);
elapsed_time = timer.elapsedTime();
//
} else {
//
logMessage("WARNING: There's no registered test!");
//
}
// Keep elapsed time & report results to log
tl().setElapsedTime(elapsed_time);
TestLogData::Counters log_data_counters = tl().logDataCounters();
logHeader(detail::FormattedString("== RESULTS: %d passed, %d failed, %d skipped, time %s",
log_data_counters.passed_tests,
log_data_counters.failed_tests,
log_data_counters.skipped_tests,
PerformanceTimer::humanReadableTime(elapsed_time).c_str()));
// Set previous assertion handler back
restoreLogCapturingHandler();
restoreAssertionHandler();
return tests_result;
}
void startLoggingMotionData() {
logHeader();
while (true) {
logMotionData();
sleep(1);
}
}
void debug(Level level, const int line, const char* file, const char* msg, Args&&... args) const
{
#ifndef LOGME_DISABLED
#ifdef LOGME_USE_LOCKS
sf::Lock lock(sMutex);
#endif
// Test current level of verbosity
if (!checkVerbosity(level)) {
return;
}
if (sUseAnsiColorSequences) {
*sStream << "\033[" << logLevelToColor(level) << "m";
}
logHeader(level);
*sStream << " " << std::left << std::setw(32) << mOwner << " ";
// TODO: std::forward?
printf(*sStream, msg, args...);
if (sLogSourcePosition) {
*sStream << "\t[" << file << ":"
<< line << "]";
}
if (sUseAnsiColorSequences) {
*sStream << "\033[0m";
}
*sStream << std::endl;
#endif
}
void ex_queue::logRemoveHead()
{
#if 0
#if (!defined (__EID) && !defined(NA_C89))
ex_queue_entry *qe = &queue_[head_ & mask_];
logHeader();
cerr << "remove ";
if (upDown_ == UP_QUEUE)
{
switch (qe->upState.status)
{
case Q_OK_MMORE:
cerr << "Q_OK_MMORE";
break;
case Q_SQLERROR:
cerr << "Q_SQLERROR";
break;
case Q_NO_DATA:
cerr << "Q_NO_DATA";
break;
default:
cerr << "unknown";
break;
}
cerr << ", pi " << qe->upState.parentIndex;
}
else
{
switch (qe->downState.request)
{
case GET_ALL:
cerr << "GET_ALL";
break;
case GET_N:
cerr << "GET_N";
break;
case GET_EOD:
cerr << "GET_EOD";
break;
case GET_NOMORE:
cerr << "GET_NOMORE";
break;
default:
cerr << "unknown";
break;
}
cerr << ", pi " << qe->downState.parentIndex;
}
cerr << endl;
#endif
#endif
}
void CLogger::logLine(const char* fmt, ...)
{
va_list va;
va_start(va,fmt);
logHeader();
logva(fmt, va);
if (fmt[strlen(fmt)-1]!='\n')
log("\n");
va_end(va);
}
void sendFinished(deluge_app* app, comBuf* pkt, uint8_t port)
{
/*deluge_foot_command* command = (deluge_foot_command*)pkt->data;
command->seq = ++seqNo;
command->command = DELUGE_COMMAND_FINISHED;
command->to = -1;
command->id = mos_node_id_get();
command->type = DELUGE_PACKET_COMMAND;
pkt->size = sizeof(deluge_foot_command);
net_send(pkt, DELUGE_PROTO_ID, port, port);*/
logHeader(&spkt, DELUGE_COMMAND_FINISHED);
com_send(IFACE_SERIAL, &spkt);
}
bool LogWriter::log(ELogLevel l, const char* format, ...) {
if (l > level_) {
return false;
}
char* bPtr;
va_list ap;
va_start(ap, format);
int blen = ::vasprintf(&bPtr, format, ap);
if (blen < 0) {
va_end(ap);
return false;
}
va_end(ap);
char header[100] = { 0 };
int hlen = 0;
logHeader(header, hlen, l);
INIT_IOV(2);
SET_IOV_LEN(header, hlen);
SET_IOV_LEN(bPtr, blen);
if (inode_ != fileNode() || !inode_) {
rwlock_.WLock();
if (inode_ != fileNode() || !inode_) {
logclose();
loginit(level_, logFile_);
}
rwlock_.UnLock();
}
bool ret = true;
rwlock_.RLock();
if (::writev(fd_, iovs, 2) <= 0) {
ret = false;
}
rwlock_.UnLock();
free(bPtr);
return ret;
}
int goahead_main(int argc, char **argv)
{
char *argp, *home, *documents, *endpoints, *endpoint, *route, *auth, *tok, *lspec;
int argind;
#if WINDOWS
if (windowsInit() < 0) {
return 0;
}
#endif
route = "/nand/route.txt";
auth = "/nand/auth.txt";
for (argind = 1; argind < argc; argind++) {
argp = argv[argind];
if (*argp != '-') {
break;
} else if (smatch(argp, "--auth") || smatch(argp, "-a")) {
auth = argv[++argind];
#if ME_UNIX_LIKE && !MACOSX
} else if (smatch(argp, "--background") || smatch(argp, "-b")) {
websSetBackground(1);
#endif
} else if (smatch(argp, "--debugger") || smatch(argp, "-d") || smatch(argp, "-D")) {
websSetDebug(1);
} else if (smatch(argp, "--home")) {
if (argind >= argc) usage();
home = argv[++argind];
if (chdir(home) < 0) {
error("Can't change directory to %s", home);
exit(-1);
}
} else if (smatch(argp, "--log") || smatch(argp, "-l")) {
if (argind >= argc) usage();
logSetPath(argv[++argind]);
} else if (smatch(argp, "--verbose") || smatch(argp, "-v")) {
logSetPath("stdout:2");
} else if (smatch(argp, "--route") || smatch(argp, "-r")) {
route = argv[++argind];
} else if (smatch(argp, "--version") || smatch(argp, "-V")) {
printf("%s\n", ME_VERSION);
exit(0);
} else if (*argp == '-' && isdigit((uchar) argp[1])) {
lspec = sfmt("stdout:%s", &argp[1]);
logSetPath(lspec);
wfree(lspec);
} else {
usage();
}
}
documents = ME_GOAHEAD_DOCUMENTS;
if (argc > argind) {
documents = argv[argind++];
}
initPlatform();
if (websOpen(documents, route) < 0) {
error("Can't initialize server. Exiting.");
return -1;
}
if (websLoad(auth) < 0) {
error("Can't load %s", auth);
return -1;
}
logHeader();
if (argind < argc) {
while (argind < argc) {
endpoint = argv[argind++];
if (websListen(endpoint) < 0) {
return -1;
}
}
} else {
endpoints = sclone(ME_GOAHEAD_LISTEN);
for (endpoint = stok(endpoints, ", \t", &tok); endpoint; endpoint = stok(NULL, ", \t,", &tok)) {
#if !ME_COM_SSL
if (strstr(endpoint, "https")) continue;
#endif
if (websListen(endpoint) < 0) {
return -1;
}
}
wfree(endpoints);
}
#if ME_ROM && KEEP
/*
If not using a route/auth config files, then manually create the routes like this:
If custom matching is required, use websSetRouteMatch. If authentication is required, use websSetRouteAuth.
*/
websAddRoute("/", "file", 0);
#endif
#if ME_UNIX_LIKE && !MACOSX
/*
Service events till terminated
*/
if (websGetBackground()) {
if (daemon(0, 0) < 0) {
error("Can't run as daemon");
return -1;
}
}
#endif
websServiceEvents(&finished);
logmsg(1, "Instructed to exit");
websClose();
#if WINDOWS
windowsClose();
#endif
return 0;
}
MAIN(goahead, int argc, char **argv, char **envp)
{
char *argp, *auth, *home, *documents, *endpoints, *endpoint, *route, *tok;
int argind;
route = "route.txt";
auth = "auth.txt";
for (argind = 1; argind < argc; argind++) {
argp = argv[argind];
if (*argp != '-') {
break;
} else if (smatch(argp, "--auth") || smatch(argp, "-a")) {
if (argind >= argc) usage();
auth = argv[++argind];
} else if (smatch(argp, "--background") || smatch(argp, "-b")) {
websSetBackground(1);
} else if (smatch(argp, "--debugger") || smatch(argp, "-d") || smatch(argp, "-D")) {
websSetDebug(1);
} else if (smatch(argp, "--home")) {
if (argind >= argc) usage();
home = argv[++argind];
if (chdir(home) < 0) {
error("Can't change directory to %s", home);
exit(-1);
}
} else if (smatch(argp, "--log") || smatch(argp, "-l")) {
if (argind >= argc) usage();
logSetPath(argv[++argind]);
} else if (smatch(argp, "--verbose") || smatch(argp, "-v")) {
logSetPath("stdout:2");
} else if (smatch(argp, "--route") || smatch(argp, "-r")) {
route = argv[++argind];
} else if (smatch(argp, "--version") || smatch(argp, "-V")) {
printf("%s: %s-%s\n", BIT_PRODUCT, BIT_VERSION, BIT_BUILD_NUMBER);
exit(0);
} else {
usage();
}
}
documents = BIT_GOAHEAD_DOCUMENTS;
if (argc > argind) {
documents = argv[argind++];
}
initPlatform();
if (websOpen(documents, route) < 0) {
error("Can't initialize server. Exiting.");
return -1;
}
logHeader();
if (websLoad(auth) < 0) {
error("Can't load %s", auth);
return -1;
}
if (argind < argc) {
while (argind < argc) {
endpoint = argv[argind++];
if (websListen(endpoint) < 0) {
return -1;
}
}
} else {
endpoints = sclone(BIT_GOAHEAD_LISTEN);
for (endpoint = stok(endpoints, ", \t", &tok); endpoint; endpoint = stok(NULL, ", \t,", &tok)) {
if (websListen(endpoint) < 0) {
return -1;
}
}
wfree(endpoints);
}
websDefineHandler("test", testHandler, 0, 0);
websAddRoute("/test", "test", 0);
#if BIT_GOAHEAD_LEGACY
websUrlHandlerDefine("/legacy/", 0, 0, legacyTest, 0);
#endif
#if BIT_GOAHEAD_JAVASCRIPT
websDefineJst("aspTest", aspTest);
websDefineJst("bigTest", bigTest);
#endif
websDefineAction("test", actionTest);
websDefineAction("sessionTest", sessionTest);
websDefineAction("showTest", showTest);
#if BIT_GOAHEAD_UPLOAD
websDefineAction("uploadTest", uploadTest);
#endif
#if BIT_UNIX_LIKE
/*
Service events till terminated
*/
if (websGetBackground()) {
if (daemon(0, 0) < 0) {
error("Can't run as daemon");
return -1;
}
}
#endif
websServiceEvents(&finished);
trace(1, "Instructed to exit\n");
websClose();
return 0;
}
LoggerStream StorageHandler::error() const
{
return mLog.error(logHeader());
}
LoggerStream StorageHandler::warning() const
{
return mLog.warning(logHeader());
}
LoggerStream StorageHandler::info() const
{
return mLog.info(logHeader());
}
void handleCommand(deluge_app* app, comBuf* pkt, uint8_t port)
{
deluge_foot_command* command = (deluge_foot_command*)
&pkt->data[pkt->size - sizeof(deluge_foot_command)];
#ifdef DELUGE_PRINT_PACKETS
printf_P(sRecvComm, command->seq, command->command, command->to);
#endif
if (checkCache(command->id, command->seq)) return;
// Temporarily switch to max power to make sure the command gets through
/*uint8_t oldPower;
com_ioctl(IFACE_RADIO, CC1000_GET_TX_POWER, &oldPower);
com_ioctl(IFACE_RADIO, CC1000_TX_POWER, 0xFF);*/
// If the command is not specifically addessed to us, forward it now
/*if (command->to != mos_node_id_get())
net_send(pkt, DELUGE_PROTO_ID, port, port);*/
if (command->to != -1 && command->to != mos_node_id_get()) {
//com_ioctl(IFACE_RADIO, CC1000_TX_POWER, oldPower);
return;
}
//extern mutex epromLock;
switch(command->command) {
case DELUGE_COMMAND_HELLO:
printf_P(sHello);
logHeader(&spkt, DELUGE_COMMAND_HELLO);
com_send(IFACE_SERIAL, &spkt);
break;
//case DELUGE_COMMAND_SEQNO: seqNo = 0; break;
/*case DELUGE_COMMAND_STOPALL:
//app->dcb.codeSize;
//app->dcb.programcrc;
memset(app->dcb.pagesNeeded, 0, sizeof(app->dcb.pagesNeeded));
//app->dcb.version;
app->dcb.incomingPage = app->dcb.highPage = app->dcb.goalPage;
deluge_saveState(app);
deluge_app_init(app, app->index);
break;*/
#ifdef DELUGE_KEEP_STATS
case DELUGE_COMMAND_CLEARSTATS:
#ifdef DELUGE_PRINT_EVENT
printf_P(sClearStats);
//printf_P(sClearTimer); // reset timer
#endif
memset(packet_counts, 0, sizeof(packet_counts));
logHeader(&spkt, DELUGE_COMMAND_CLEARSTATS);
com_send(IFACE_SERIAL, &spkt);
break;
case DELUGE_COMMAND_STARTRECORD:
#ifdef DELUGE_PRINT_EVENT
printf_P(sStartRec);
//printf_P(sClearTimer); // reset timer
#endif
logHeader(&spkt, DELUGE_COMMAND_STARTRECORD);
com_send(IFACE_SERIAL, &spkt);
deluge_recordstats = 1;
break;
case DELUGE_COMMAND_ENDRECORD:
#ifdef DELUGE_PRINT_EVENT
//printf_P(sDisplayTime); // display timer
printf_P(sStopRec);
#endif
deluge_recordstats = 0;
/*mos_mutex_lock(&epromLock);
dev_ioctl(DEV_AVR_EEPROM, DEV_SEEK, DELUGE_STATS_ADDR);
dev_write(DEV_AVR_EEPROM, (uint8_t*)packet_counts, sizeof(packet_counts));
mos_mutex_unlock(&epromLock);*/
logHeader(&spkt, DELUGE_COMMAND_ENDRECORD);
com_send(IFACE_SERIAL, &spkt);
break;
case DELUGE_COMMAND_SENDSTATS:
if (-1 != command->to && !sendingStats) { // it's addressed to us
sendingStats = 1;
statsPort = port;
// This is a slow procedure that requires multiple packets to
// reply, so run it in another thread.
//mos_thread_new(statsThread, 256, PRIORITY_NORMAL);
uint8_t r = 0;
uint8_t i = 0;
for (r=0; r<DELUGE_STATS_COUNT;)
{
logHeader(&spkt, DELUGE_COMMAND_SENDSTATS_REPLY);
spkt.data[spkt.size++] = r;
for (i=0; i<4 && r+i<DELUGE_STATS_COUNT; i++)
{
uint8_t j;
for (j=0; j<4; j++)
{
uint16_t stat = packet_counts[r+i][j];
spkt.data[spkt.size++] = (uint8_t)(stat >> 8);
spkt.data[spkt.size++] = (uint8_t)(stat);
}
}
r += i;
com_send(IFACE_SERIAL, &spkt);
}
sendingStats = 0;
}
break;
#endif
case DELUGE_COMMAND_VERSION:
#ifdef DELUGE_PRINT_EVENT
printf_P(sChangeVer, pkt->data[0]);
printf_P(sClearTimer); // clear timer
#endif
mos_mutex_lock(&app->delugeLock);
app->dcb.version = pkt->data[0];
deluge_saveState(app);
app->detectedInconsistency = 1;
stateTransition(app, DELUGE_STATE_MAINTAIN);
mos_mutex_unlock(&app->delugeLock);
if (command->to != -1) {
/*command->seq = ++seqNo;
command->command = DELUGE_COMMAND_VERSION_REPLY;
command->to = command->id;
command->id = mos_node_id_get();
command->type = DELUGE_PACKET_COMMAND;
mos_thread_sleep(1000);
net_send(pkt, DELUGE_PROTO_ID, port, port);*/
logHeader(&spkt, DELUGE_COMMAND_VERSION_REPLY);
com_send(IFACE_SERIAL, &spkt);
}
break;
#ifdef DELUGE_SYMMETRIC_LINKS
/*case DELUGE_COMMAND_NEIGHBORS:
if (-1 != command->to) { // it's addressed to us
memcpy(pkt->data, app->neighbors, sizeof(app->neighbors));
pkt->size = sizeof(app->neighbors);
//memcpy(&pkt->data[pkt->size], app->symdtbs, sizeof(app->symdtbs));
//pkt->size += sizeof(app->symdtbs);
command = (deluge_foot_command*)&pkt->data[pkt->size];
command->seq = ++seqNo;
command->command = DELUGE_COMMAND_NEIGHBORS_REPLY;
command->to = -1;
command->id = mos_node_id_get();
command->type = DELUGE_PACKET_COMMAND;
pkt->size += sizeof(deluge_foot_command);
mos_thread_sleep(1000);
net_send(pkt, DELUGE_PROTO_ID, port, port);
}
break;*/
#endif
/*case DELUGE_COMMAND_WIPE: {
com_mode(IFACE_RADIO, IF_OFF);
deluge_suspend();
#ifdef DELUGE_PRINT_EVENT
printf_P(sWipe);
#endif
uint16_t zero = 0;
uint16_t addr;
mos_mutex_lock(&epromLock);
for (addr = DELUGE_CONTROL_BLOCK_ADDR; addr < SIMPLE_FS_ADDR; addr += 2)
{
dev_ioctl(DEV_AVR_EEPROM, DEV_SEEK, addr);
dev_write(DEV_AVR_EEPROM, (uint8_t*)&zero, 2);
}
simple_fs_format();
uint8_t default_portmap[DELUGE_INSTANCE_COUNT];
uint8_t i;
for (i=0; i<DELUGE_INSTANCE_COUNT; i++)
default_portmap[i] = i+1;
dev_ioctl(DEV_AVR_EEPROM, DEV_SEEK, DELUGE_DIRECTORY_ADDR);
dev_write(DEV_AVR_EEPROM, default_portmap, sizeof (default_portmap));
mos_mutex_unlock(&epromLock);
#ifdef DELUGE_PRINT_EVENT
printf_P(sDone);
#endif
deluge_init();
com_mode(IFACE_RADIO, IF_LISTEN);
break;
}*/
case DELUGE_COMMAND_BOOT: {
mos_mutex_lock(&app->delugeLock);
com_mode(IFACE_RADIO, IF_OFF);
deluge_suspend();
if (pkt->data[0]==0) {
// Just reboot
reboot();
break;
}
// Open the requested backup image
char name[4] = { 'b', 'k', '0'+pkt->data[0], 0 };
mos_file* file = mos_file_open(name);
if (!file) {
printf_P(sFileErr, name);
deluge_resume();
com_mode(IFACE_RADIO, IF_LISTEN);
break;
}
// We keep our current state, but we boot the backup image
deluge_saveState(app);
// Reboot. This function will copy the file location into the
// boot control block for reprogramming
app->image_file = file;
runReprogram(app);
// We shouldn't return from runReprogram
mos_mutex_unlock(&app->delugeLock);
break;
}
#if DELUGE_CACHE_PAGES > 1
case DELUGE_COMMAND_CACHESIZE: {
if (pkt->data[0] >= DELUGE_CACHE_PAGES) break;
#ifdef DELUGE_PRINT_EVENT
printf_P(sChangeCache, pkt->data[0]);
#endif
mos_mutex_lock(&app->delugeLock);
app->cacheSize = pkt->data[0];
int8_t i;
for (i=0; i<DELUGE_CACHE_PAGES; i++)
app->cache_map[i] = -1;
app->outgoingCachePage = 0;
app->incomingCachePage = 0;
stateTransition(app, DELUGE_STATE_MAINTAIN);
mos_mutex_unlock(&app->delugeLock);
break;
}
#endif
case DELUGE_COMMAND_POWER: {
#ifdef DELUGE_PRINT_EVENT
printf_P(sChangeTx, pkt->data[0]);
#endif
//oldPower = pkt->data[0]; // Will get changed at the end
com_ioctl(IFACE_RADIO, CC1000_TX_POWER, pkt->data[0]);
break;
}
default:
break;
}
MAIN(goahead, int argc, char **argv, char **envp)
{
char *argp, *auth, *home, *documents, *endpoints, *endpoint, *route, *tok, *lspec;
int argind, duration;
route = "route.txt";
auth = "auth.txt";
duration = 0;
for (argind = 1; argind < argc; argind++) {
argp = argv[argind];
if (*argp != '-') {
break;
} else if (smatch(argp, "--auth") || smatch(argp, "-a")) {
if (argind >= argc) usage();
auth = argv[++argind];
#if ME_UNIX_LIKE && !MACOSX
} else if (smatch(argp, "--background") || smatch(argp, "-b")) {
websSetBackground(1);
#endif
} else if (smatch(argp, "--debugger") || smatch(argp, "-d") || smatch(argp, "-D")) {
websSetDebug(1);
} else if (smatch(argp, "--duration")) {
if (argind >= argc) usage();
duration = atoi(argv[++argind]);
} else if (smatch(argp, "--home")) {
if (argind >= argc) usage();
home = argv[++argind];
if (chdir(home) < 0) {
error("Cannot change directory to %s", home);
exit(-1);
}
} else if (smatch(argp, "--log") || smatch(argp, "-l")) {
if (argind >= argc) usage();
logSetPath(argv[++argind]);
} else if (smatch(argp, "--verbose") || smatch(argp, "-v")) {
logSetPath("stdout:2");
} else if (smatch(argp, "--route") || smatch(argp, "-r")) {
route = argv[++argind];
} else if (smatch(argp, "--version") || smatch(argp, "-V")) {
printf("%s\n", ME_VERSION);
exit(0);
} else if (*argp == '-' && isdigit((uchar) argp[1])) {
lspec = sfmt("stdout:%s", &argp[1]);
logSetPath(lspec);
wfree(lspec);
} else {
usage();
}
}
documents = ME_GOAHEAD_DOCUMENTS;
if (argc > argind) {
documents = argv[argind++];
}
initPlatform();
if (websOpen(documents, route) < 0) {
error("Cannot initialize server. Exiting.");
return -1;
}
logHeader();
if (websLoad(auth) < 0) {
error("Cannot load %s", auth);
return -1;
}
if (argind < argc) {
while (argind < argc) {
endpoint = argv[argind++];
if (websListen(endpoint) < 0) {
return -1;
}
}
} else {
endpoints = sclone(ME_GOAHEAD_LISTEN);
for (endpoint = stok(endpoints, ", \t", &tok); endpoint; endpoint = stok(NULL, ", \t,", &tok)) {
if (websListen(endpoint) < 0) {
return -1;
}
}
wfree(endpoints);
}
websDefineHandler("test", testHandler, 0, 0, 0);
websAddRoute("/test", "test", 0);
#if ME_GOAHEAD_LEGACY
websUrlHandlerDefine("/legacy/", 0, 0, legacyTest, 0);
#endif
#if ME_GOAHEAD_JAVASCRIPT
websDefineJst("aspTest", aspTest);
websDefineJst("bigTest", bigTest);
#endif
websDefineAction("test", actionTest);
websDefineAction("sessionTest", sessionTest);
websDefineAction("showTest", showTest);
#if ME_GOAHEAD_UPLOAD && !ME_ROM
websDefineAction("uploadTest", uploadTest);
#endif
#if ME_UNIX_LIKE && !MACOSX
/*
Service events till terminated
*/
if (websGetBackground()) {
if (daemon(0, 0) < 0) {
error("Cannot run as daemon");
return -1;
}
}
#endif
if (duration) {
printf("Running for %d secs\n", duration);
websStartEvent(duration * 1000, (WebsEventProc) exitProc, 0);
}
websServiceEvents(&finished);
logmsg(1, "Instructed to exit\n");
websClose();
return 0;
}
LoggerStream PaymentOperationStateHandler::warning() const
{
return mLog.warning(logHeader());
}
LoggerStream PaymentOperationStateHandler::info() const
{
return mLog.info(logHeader());
}
