void Logger::setThresholdFromLoggingProperties(log4cplus::Logger logger) {
// if logging.properties exists, attempt to set the
// appropriate level for the given logger
if (fileExists(PROP_FILE_LOC)) {
Properties props(PROP_FILE_LOC);
string loggerName = logger.getName();
string logLevelKey = loggerName + ".level";
if (props.isSet(logLevelKey)) {
string level = props.get(logLevelKey);
int l4cpLevel = log4cplus::getLogLevelManager().fromString(level);
if (l4cpLevel != log4cplus::NOT_SET_LOG_LEVEL) {
LOG4CPLUS_INFO(
logger,
LOG4CPLUS_TEXT(
"Configuring logger " + loggerName
+ " with level " + level));
logger.setLogLevel(l4cpLevel);
} else {
LOG4CPLUS_INFO(
logger,
LOG4CPLUS_TEXT(
"Unable to configure logger " + loggerName
+ " with level " + level
+ "; no such level found."));
}
}
}
}
//---------------------------------------------------------//
void CServer::initialize_logger(log4cplus::Logger& my_logger, IniReader::Section& section)
{
using namespace log4cplus;
my_logger.removeAllAppenders();
std::string log_pattern;
section.get_value("LOG_PATTERN", log_pattern, "%D{%c} [%t] [%p]: %m%n");
std::string log_file_name;
section.get_value("LOG_FILE_NAME", log_file_name, "Server.log");
long log_parts;
section.get_value("LOG_PARTS", log_parts, 3);
long log_file_size;
section.get_value("LOG_FILE_SIZE", log_file_size, 100);
long log_level;
section.get_value("LOG_LEVEL", log_level, long(log4cplus::FATAL_LOG_LEVEL));
SharedAppenderPtr appender(new RollingFileAppender( log_file_name,
log_file_size * 1024 * 1024,
log_parts));
appender->setName(_T("log_appender"));
appender->setLayout(std::auto_ptr<Layout>(new PatternLayout(log_pattern)));
my_logger.setLogLevel(LogLevel(log_level));
my_logger.addAppender(appender);
};
std::string CFileLogger::GetFileAppenderName(log4cplus::Logger& logger)
{
std::string appedname = logger.getName() + "-f-";
appedname += T2S(__LINE__);
return appedname;
}
bool CFileLogger::AddSameFileLogger(log4cplus::Logger& sublogger, log4cplus::Logger& mainlogger, int loglevel)
{
if ( &sublogger == &mainlogger )
{
return true;
}
SharedAppenderPtr append = mainlogger.getAppender(LOG4CPLUS_TEXT(GetFileAppenderName(mainlogger)));
if (append)
{
sublogger.addAppender(append);
}
sublogger.setLogLevel(loglevel);
return true;
}
bool CFileLogger::AddLogger(log4cplus::Logger& logger, const std::string& logpath, int loglevel)
{
if (!logpath.empty())
{
SharedAppenderPtr append(new DailyRollingFileAppender(LOG4CPLUS_TEXT(logpath), DAILY, true, 100));
append->setName(LOG4CPLUS_TEXT(GetFileAppenderName(logger)));
std::auto_ptr<Layout> layout(new PatternLayout(logpattern));
append->setLayout(layout);
logger.addAppender(append);
}
logger.setLogLevel(loglevel);
return true;
}
namespace Logger {
void init(const char*);
extern log4cplus::Logger logger;
template<typename T>
void sprintf(std::stringstream& stream, T val) {
stream << val;
}
template<typename T, typename... params>
void sprintf(std::stringstream& stream, T val, params... args) {
stream << val;
sprintf(stream, args...);
}
template <typename ... params>
void log(const char* file, int line, log4cplus::LogLevel level, params... args) {
if (logger.isEnabledFor(level)) {
std::stringstream stream;
sprintf(stream, args...);
logger.forcedLog(level, stream.str().c_str(), file, line);
}
}
}
int
main()
{
{
//LoggerConfig();
}
Log::open("/home/jan.hoelscher/devel/mec/res");
LOGDEBUG("twest");
logger.setLogLevel(log4cplus::TRACE_LOG_LEVEL);
cout << "*** calling printMessages() with TRACE set: ***" << endl;
printMessages();
logger.setLogLevel(log4cplus::DEBUG_LOG_LEVEL);
cout << "\n*** calling printMessages() with DEBUG set: ***" << endl;
printMessages();
logger.setLogLevel(log4cplus::INFO_LOG_LEVEL);
cout << "\n*** calling printMessages() with INFO set: ***" << endl;
printMessages();
logger.setLogLevel(log4cplus::WARN_LOG_LEVEL);
cout << "\n*** calling printMessages() with WARN set: ***" << endl;
printMessages();
logger.setLogLevel(log4cplus::ERROR_LOG_LEVEL);
cout << "\n*** calling printMessages() with ERROR set: ***" << endl;
printMessages();
logger.setLogLevel(log4cplus::FATAL_LOG_LEVEL);
cout << "\n*** calling printMessages() with FATAL set: ***" << endl;
printMessages();
//log4cplus::Logger::shutdown();
return 0;
}
void CFileLogger::SetLogger(log4cplus::Logger& logger, int loglevel)
{
logger.setLogLevel(loglevel);
}
int main( int argc, const char** argv )
{
daemon_active = true;
bool noDaemon = false;
bool clockOn = false;
std::string logFile;
int topn;
std::string configFile;
std::string country;
TCLAP::CmdLine cmd("OpenAlpr Daemon", ' ', Alpr::getVersion());
TCLAP::ValueArg<std::string> countryCodeArg("c","country","Country code to identify (either us for USA or eu for Europe). Default=us",false, "us" ,"country_code");
TCLAP::ValueArg<std::string> configFileArg("","config","Path to the openalpr.conf file.",false, "" ,"config_file");
TCLAP::ValueArg<int> topNArg("n","topn","Max number of possible plate numbers to return. Default=25",false, 25 ,"topN");
TCLAP::ValueArg<std::string> logFileArg("l","log","Log file to write to. Default=" + DEFAULT_LOG_FILE_PATH,false, DEFAULT_LOG_FILE_PATH ,"topN");
TCLAP::SwitchArg daemonOffSwitch("f","foreground","Set this flag for debugging. Disables forking the process as a daemon and runs in the foreground. Default=off", cmd, false);
TCLAP::SwitchArg clockSwitch("","clock","Display timing information to log. Default=off", cmd, false);
try
{
cmd.add( countryCodeArg );
cmd.add( topNArg );
cmd.add( configFileArg );
cmd.add( logFileArg );
if (cmd.parse( argc, argv ) == false)
{
// Error occured while parsing. Exit now.
return 1;
}
country = countryCodeArg.getValue();
configFile = configFileArg.getValue();
logFile = logFileArg.getValue();
topn = topNArg.getValue();
noDaemon = daemonOffSwitch.getValue();
clockOn = clockSwitch.getValue();
}
catch (TCLAP::ArgException &e) // catch any exceptions
{
std::cerr << "error: " << e.error() << " for arg " << e.argId() << std::endl;
return 1;
}
log4cplus::BasicConfigurator config;
config.configure();
if (noDaemon == false)
{
// Fork off into a separate daemon
daemon(0, 0);
log4cplus::SharedAppenderPtr myAppender(new log4cplus::RollingFileAppender(logFile));
myAppender->setName("alprd_appender");
// Redirect std out to log file
logger = log4cplus::Logger::getInstance(LOG4CPLUS_TEXT("alprd"));
logger.addAppender(myAppender);
LOG4CPLUS_INFO(logger, "Running OpenALPR daemon in daemon mode.");
}
else
{
//log4cplus::SharedAppenderPtr myAppender(new log4cplus::ConsoleAppender());
//myAppender->setName("alprd_appender");
// Redirect std out to log file
logger = log4cplus::Logger::getInstance(LOG4CPLUS_TEXT("alprd"));
//logger.addAppender(myAppender);
LOG4CPLUS_INFO(logger, "Running OpenALPR daemon in the foreground.");
}
CSimpleIniA ini;
ini.SetMultiKey();
ini.LoadFile(DAEMON_CONFIG_FILE_PATH.c_str());
std::vector<std::string> stream_urls;
CSimpleIniA::TNamesDepend values;
ini.GetAllValues("daemon", "stream", values);
// sort the values into the original load order
values.sort(CSimpleIniA::Entry::LoadOrder());
// output all of the items
CSimpleIniA::TNamesDepend::const_iterator i;
for (i = values.begin(); i != values.end(); ++i) {
stream_urls.push_back(i->pItem);
}
if (stream_urls.size() == 0)
{
LOG4CPLUS_FATAL(logger, "No video streams defined in the configuration.");
return 1;
}
bool storePlates = ini.GetBoolValue("daemon", "store_plates", false);
std::string imageFolder = ini.GetValue("daemon", "store_plates_location", "/tmp/");
bool uploadData = ini.GetBoolValue("daemon", "upload_data", false);
std::string upload_url = ini.GetValue("daemon", "upload_address", "");
std::string site_id = ini.GetValue("daemon", "site_id", "");
LOG4CPLUS_INFO(logger, "Using: " << imageFolder << " for storing valid plate images");
pid_t pid;
for (int i = 0; i < stream_urls.size(); i++)
{
pid = fork();
if (pid == (pid_t) 0)
{
// This is the child process, kick off the capture data and upload threads
CaptureThreadData* tdata = new CaptureThreadData();
tdata->stream_url = stream_urls[i];
tdata->camera_id = i + 1;
tdata->config_file = configFile;
tdata->output_images = storePlates;
tdata->output_image_folder = imageFolder;
tdata->country_code = country;
tdata->site_id = site_id;
tdata->top_n = topn;
tdata->clock_on = clockOn;
tthread::thread* thread_recognize = new tthread::thread(streamRecognitionThread, (void*) tdata);
if (uploadData)
{
// Kick off the data upload thread
UploadThreadData* udata = new UploadThreadData();
udata->upload_url = upload_url;
tthread::thread* thread_upload = new tthread::thread(dataUploadThread, (void*) udata );
}
break;
}
// Parent process will continue and spawn more children
}
while (daemon_active)
{
usleep(30000);
}
}
void log(const char* file, int line, log4cplus::LogLevel level, params... args) {
if (logger.isEnabledFor(level)) {
std::stringstream stream;
sprintf(stream, args...);
logger.forcedLog(level, stream.str().c_str(), file, line);
}
}