int main ( int argc, char* argv[] ) { // To prevent process from being dropped by SIG_PIPE sigset(SIGPIPE, SIG_IGN); // Verify that the version of the library that we linked against is // compatible with the version of the headers we compiled against. GOOGLE_PROTOBUF_VERIFY_VERSION; log4cplus::BasicConfigurator config; config.configure(); log4cplus::Logger logger = log4cplus::Logger::getInstance(LOG4CPLUS_TEXT("main")); LOG4CPLUS_INFO(logger, LOG4CPLUS_TEXT("netsynth version " << version << " started")); int port = 12345; if (argc > 1) { port = atoi( argv[1] ); if (port <= 0 || port >= 65536) { LOG4CPLUS_FATAL(logger, LOG4CPLUS_TEXT(argv[0] << ": Invalid port number: " << argv[1])); return 1; } } const char* rackURL = "file:/file_modules/fileRack"; if (argc > 2) { rackURL = argv[2]; } if (!initialize(rackURL)) { LOG4CPLUS_FATAL(logger, LOG4CPLUS_TEXT("Server initialization failed.")); return 1; } // Launch the service listener listener = new Listener(port, NULL /* new SynthSessionFactory() */); if (!listener->initialize()) { LOG4CPLUS_FATAL(logger, LOG4CPLUS_TEXT("Failed to start listening")); } // Launch the listener if (listener->acceptLoop()) { LOG4CPLUS_FATAL(logger, LOG4CPLUS_TEXT("Could not launch the listener.")); return 1; } // Waiting for shutdown of listener thread listener->waitForShutdown(); return 0; }
void ChannelServer::threadFunc() { sync_test("start testing"); smoke_test(); sync_test("after smoke_test"); allocate_same_name_twice(); sync_test("after alloc_same_name_twice"); send_data_stress_test_with_confirmation(); sync_test("after send_data_stress_test_with_confirmation"); send_data_stress_test_no_confirmation(); sync_test("after send_data_stress_test_no_confirmation"); //send_big_data_test();sync_test("after send_big_data_test"); alloc_dealloc_stress_test_with_confirmation(); sync_test("after alloc_dealloc_stress_test_with_confirmation"); alloc_dealloc_stress_test_no_confirmation(); sync_test("after alloc_dealloc_stress_test_no_confirmation"); smoke_test(); sync_test("after smoke_test_with_errors"); if(alloc_empty_name()) { sync_test("after alloc_empty_name"); } else { LOG4CPLUS_FATAL(logger, "alloc_empty_name failed!"); exit(1); } sync_test("end"); }
void CServiceManager::loadDb() { LOG4CPLUS_TRACE_METHOD(msLogger, __PRETTY_FUNCTION__); std::string path = mXmlPath #ifndef ANDROID + "HeadUnitServices.xml"; #else + "AndroidServices.xml"; #endif //ANDROID pugi::xml_document doc; LOG4CPLUS_INFO(msLogger, "path = " + path); pugi::xml_parse_result result = doc.load_file(path.c_str()); if (result) { pugi::xml_node device_node = doc.child("device"); mSystemServicesMutex.lock(); for (pugi::xml_node service_node = device_node.child("service"); service_node; service_node = service_node.next_sibling("service")) { if (strcmp(service_node.attribute("name").value(), "") != 0) { mSystemServices.insert(Service::Uid(service_node.attribute("name").value())); } } mSystemServicesMutex.unlock(); } else { LOG4CPLUS_FATAL(msLogger, "xml error: " + std::string(result.description())); } }
SystemControllerMsg::SystemControllerMsg() : SystemControllerMsgProxy("SysCtrl_PrflMngr") , mEventFactory(NULL) , mLogger(Logger::getInstance(LOG4CPLUS_TEXT("profileManager.PMP.SystemControllerMsg"))) { LOG4CPLUS_TRACE_METHOD(mLogger, __PRETTY_FUNCTION__ ); bool noError = false; for (int i = 0; i < 5; ++i) { LOG4CPLUS_INFO(mLogger, "Try to connect to System Controller number " + convertIntegerToString(i)); if (connect().isNoError()) { noError = true; break; } usleep(250000); } if (!noError) { LOG4CPLUS_FATAL(mLogger, "Can't connect to system controller"); killProcess(1); } }
static void ForwardString(log4cplus::Logger &app_instance, LogLevel log_level, const char *out_string) { if (out_string == NULL) out_string = ""; #ifdef _Windows # pragma warning(push) # pragma warning(disable:4127) #endif // #ifdef _Windows switch (log_level) { case LogLevel_Literal : LOG4CPLUS_TRACE(app_instance, out_string); break; case LogLevel_Spam : LOG4CPLUS_TRACE(app_instance, out_string); break; case LogLevel_Minutiae : LOG4CPLUS_TRACE(app_instance, out_string); break; case LogLevel_Debug : LOG4CPLUS_DEBUG(app_instance, out_string); break; case LogLevel_Detail : LOG4CPLUS_DEBUG(app_instance, out_string); break; case LogLevel_Info : LOG4CPLUS_INFO(app_instance, out_string); break; case LogLevel_Notice : LOG4CPLUS_WARN(app_instance, out_string); break; case LogLevel_Warning : LOG4CPLUS_WARN(app_instance, out_string); break; case LogLevel_Error : LOG4CPLUS_ERROR(app_instance, out_string); break; case LogLevel_Critical : LOG4CPLUS_ERROR(app_instance, out_string); break; case LogLevel_Alert : LOG4CPLUS_ERROR(app_instance, out_string); break; case LogLevel_Emergency : LOG4CPLUS_ERROR(app_instance, out_string); break; case LogLevel_Fatal : LOG4CPLUS_FATAL(app_instance, out_string); break; default : LOG4CPLUS_ERROR(app_instance, out_string); break; #ifdef _Windows # pragma warning(pop) #endif // #ifdef _Windows } }
JNIEXPORT jint JNICALL JNI_OnLoad(JavaVM *jvm_init, void *reserved) { // cache the jvm-handle jvm = jvm_init; // inilialize COM HRESULT hr = ::CoInitializeEx(NULL, COINIT_MULTITHREADED); if (FAILED(hr)) { char buffer[1024]; GetErrorMessage(buffer, sizeof(buffer), "Initializing COM failed!", hr); LOG4CPLUS_FATAL(logger, buffer); return JNI_ERR; } // register own component IJavaInputStream etc. hr = ::CoRegisterClassObject(CLSID_JavaInputStream, &classFactory, CLSCTX_SERVER, REGCLS_MULTIPLEUSE, &dwRegister); if (FAILED(hr)) { char buffer[1024]; GetErrorMessage(buffer, sizeof(buffer), "Registering component \"JavaInputStream\" failed!", hr); LOG4CPLUS_FATAL(logger, buffer); return JNI_ERR; } hr = ::CoRegisterClassObject(CLSID_ErrorLog, &classFactory, CLSCTX_SERVER, REGCLS_MULTIPLEUSE, &dwRegister); if (FAILED(hr)) { char buffer[1024]; GetErrorMessage(buffer, sizeof(buffer), "Registering component \"ErrorLog\" failed!", hr); LOG4CPLUS_FATAL(logger, buffer); return JNI_ERR; } return JNI_VERSION_1_6; }
void CRunApp::useService(const Service::Uid & service, bool use) { LOG4CPLUS_TRACE_METHOD(msLogger, __PRETTY_FUNCTION__ ); std::string strUse =use ? std::string("true") : std::string("false"); LOG4CPLUS_FATAL(msLogger, "service: " + service.value() + "use : " + strUse); if (use) { mServices.insert(service); } else { mServices.erase(service); } }
void ClogCPP::init() { log4cplus::initialize (); LogLog::getLogLog()->setInternalDebugging(false); try { PropertyConfigurator::doConfigure(LOG4CPLUS_TEXT(LOG4CPLUSCONF)); } catch(...) { tcout << "Exception..." << endl; LOG4CPLUS_FATAL(m_logger, "Exception occured..."); } }
void ServiceRepository::init() { LOG4CPLUS_TRACE_METHOD(mLogger, __PRETTY_FUNCTION__ ); std::string repoPath; #ifndef ANDROID char buf[256]; getcwd(buf,255); repoPath = std::string(buf)+"/../database/services/"; #else repoPath = mConfigurator->getParam("path_to_services"); #endif //ANDROID std::string dbPath = repoPath #ifndef ANDROID + "HeadUnitServices.xml"; #else + "AndroidServices.xml"; #endif //ANDROID LOG4CPLUS_INFO(mLogger, "services xml path = " + repoPath); LOG4CPLUS_INFO(mLogger, "DB path = " + dbPath); pugi::xml_document doc; pugi::xml_parse_result result = doc.load_file(dbPath.c_str()); if (result) { pugi::xml_node device_node = doc.child("device"); for (pugi::xml_node service_node = device_node.child("service"); service_node; service_node = service_node.next_sibling("service")) { if (strcmp(service_node.attribute("name").value(), "") != 0) { Service::Uid sid = Service::Uid(service_node.attribute("name").value()); std::string maniPath = repoPath + sid.value() + std::string(".xml"); UInt32 prio = atoi(service_node.attribute("priority").value()); mServices.insert(std::make_pair(sid,new ServiceInfo(maniPath, prio))); } } } else { LOG4CPLUS_FATAL(mLogger, "Service repository load error: " + std::string(result.description())); killProcess(1); } }
void Log::execute(fsm::Context * ctx, const log4cplus::Logger & log, const std::string & sessionId)const { std::string loginfo = m_strExpr; if (ctx && m_Type.compare("script") == 0) { Json::Value jsonval = ctx->eval(m_strExpr, m_strFileName, m_lineNo/*,m_node*/); if (jsonval.isString() || jsonval.isBool() || jsonval.isNull()){ loginfo = jsonval.asString(); } else if (jsonval.isInt()){ loginfo = std::to_string(jsonval.asInt()); } else if (jsonval.isUInt()){ loginfo = std::to_string(jsonval.asUInt()); } else if (jsonval.isDouble()){ loginfo = std::to_string(jsonval.asDouble()); } else if (jsonval.isObject()) { loginfo = jsonval.toStyledString(); } } if (m_strLevel.compare("trace") == 0){ LOG4CPLUS_TRACE(log, "." + sessionId, m_strFileName << ":" << m_lineNo << "," << loginfo); } else if (m_strLevel.compare("debug") == 0){ LOG4CPLUS_DEBUG(log, "." + sessionId, m_strFileName << ":" << m_lineNo << "," << loginfo); } else if (m_strLevel.compare("info") == 0){ LOG4CPLUS_INFO(log, "." + sessionId, m_strFileName << ":" << m_lineNo << "," << loginfo); } else if (m_strLevel.compare("warn") == 0){ LOG4CPLUS_WARN(log, "." + sessionId, m_strFileName << ":" << m_lineNo << "," << loginfo); } else if (m_strLevel.compare("error") == 0){ LOG4CPLUS_ERROR(log, "." + sessionId, m_strFileName << ":" << m_lineNo << "," << loginfo); } else if (m_strLevel.compare("fatal") == 0){ LOG4CPLUS_FATAL(log, "." + sessionId, m_strFileName << ":" << m_lineNo << "," << loginfo); } else{ LOG4CPLUS_INFO(log, "." + sessionId, m_strFileName << ":" << m_lineNo << "," << loginfo); } }
bool InitLogs( const string& strConfigPath) { // ϵͳÈÕÖ¾ log4cplus::Logger logger; string strLog4cplusConfig(strConfigPath + "BusStopTerminal.properties"); helpers::LogLog::getLogLog()->setInternalDebugging(true); Logger root = Logger::getRoot(); try { PropertyConfigurator::doConfigure(LOG4CPLUS_TEXT(strLog4cplusConfig)); logger = Logger::getInstance(LOG4CPLUS_TEXT("BusStopTerminal")); } catch(...) { cout << "Exception..." << endl; LOG4CPLUS_FATAL(root, "Exception occured..."); return false; } return true; }
void art_log(LOG_LEVEL level, const char *fmt, ...) { va_list ap; char log_buffer[1024]; if (fmt == NULL || *fmt == '\0') { return; } va_start(ap, fmt); vsnprintf(log_buffer, 1024, fmt, ap); va_end(ap); switch (level) { case TRACE: LOG4CPLUS_TRACE(Log::_logger, log_buffer); break; case DEBUG: LOG4CPLUS_DEBUG(Log::_logger, log_buffer); break; case INFO: LOG4CPLUS_INFO(Log::_logger, log_buffer); break; case WARN: LOG4CPLUS_WARN(Log::_logger, log_buffer); break; case ERROR: LOG4CPLUS_ERROR(Log::_logger, log_buffer); break; case FATAL: LOG4CPLUS_FATAL(Log::_logger, log_buffer); break; default: break; } return; }
void AuthenticationStateMachine::onInitDone(iviLink::ELaunchInfo launcher) { LOG4CPLUS_TRACE_METHOD(sLogger, __PRETTY_FUNCTION__); if (iviLink::LAUNCHED_BY_USER == launcher) { LOG4CPLUS_INFO(sLogger, "started by user"); registerProfileCallbacks(iviLink::Profile::ApiUid("AuthenticationProfile_PAPI_UID"), this); if(loadService(iviLink::Service::Uid("AuthenticationService")).isNoError()) { LOG4CPLUS_INFO(sLogger, "started by user - service loaded!"); } else { LOG4CPLUS_FATAL(sLogger, "could not load the service!"); onProfileError(); } mKeygenThread->start(); //generates keys and sends public key and uid to the other side } else { LOG4CPLUS_INFO(sLogger, "started by iviLink"); } }
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); } }
int profileManagerEntryPoint(const std::string& pathToProfileRepository, const std::string& pathToServiceRepository) #endif //ANDROID { Logger logger = Logger::getInstance(LOG4CPLUS_TEXT("profileManager.PMP.process.main")); WatchdogThread watchdogThread(iviLink::SystemController::PROFILE_MANAGER); watchdogThread.start(); iviLink::conf::Configurator config(""); #ifndef ANDROID PropertyConfigurator::doConfigure(LOG4CPLUS_TEXT("log4cplus.properties")); int option_index = 0; int c; while (true) { c = getopt_long(argc, argv, "x:u:r:p:", long_options, &option_index); if (-1 == c) { break; } switch (c) { case 'x': strncpy(cs_sock_path.begin(), optarg, cs_sock_path.size()); cs_sock_path[cs_sock_path.size() - 1] = 0; break; case 'u': strncpy(ca_sock_path.begin(), optarg, ca_sock_path.size()); ca_sock_path[ca_sock_path.size() - 1] = 0; break; case 'r': strncpy(repo_sock_path.begin(), optarg, repo_sock_path.size()); repo_sock_path[repo_sock_path.size() - 1] = 0; break; case 'p': strncpy(pmp_sock_path.begin(), optarg, pmp_sock_path.size()); pmp_sock_path[pmp_sock_path.size() - 1] = 0; break; default: LOG4CPLUS_FATAL(logger, "unknown param"); exit(1); break; } } if (ca_sock_path[0] != 0) { extern char const * gpCA_UNIX_SOCK_PATH; gpCA_UNIX_SOCK_PATH = ca_sock_path.begin(); } if (ca_sock_path[0] != 0) { extern char const * gpNEGOTIATOR_IPC_ADDR; gpNEGOTIATOR_IPC_ADDR = cs_sock_path.begin(); } if (repo_sock_path[0] != 0) { config.setParam("pmp_repo_ipc_address", repo_sock_path.begin()); } if (pmp_sock_path[0] != 0) { config.setParam("pmp_ipc_address", pmp_sock_path.begin()); } #else config.setParam("path_to_database", pathToProfileRepository); config.setParam("path_to_services", pathToServiceRepository); #endif //ANDROID iviLink::PMP::PmpComponentManager manager(&config); manager.initPmp(); manager.wait(); manager.uninitPmp(); return 0; }
void PmpComponentManager::endInitialization() { LOG4CPLUS_TRACE_METHOD(mLogger, __PRETTY_FUNCTION__ ); assert(mIpcProtocol); assert(mAmpClient); if (mInitializationDone) { LOG4CPLUS_WARN(mLogger, "Initialization done"); return; } mInitializationDone = true; if (!mIpcProtocol->connect()) { LOG4CPLUS_FATAL(mLogger, "Can't connect IPC protocol"); killProcess(1); } LOG4CPLUS_INFO(mLogger, "IPC protocol connected"); if (mSCMsg) { mSCMsg->requestConnected(); LOG4CPLUS_INFO(mLogger, "Sent request to SC"); } else { LOG4CPLUS_WARN(mLogger, "Started without SC connection possibility"); } bool res = false; for(int i=0; i<30; ++i) { LOG4CPLUS_INFO(mLogger, "Connecting to AMP..."); if (mAmpClient->connect()) { res = true; break; } usleep(250000); } if (!res) { LOG4CPLUS_FATAL(mLogger, "No AMP connection"); killProcess(1); } LOG4CPLUS_INFO(mLogger, "AMP connected"); char macAddr[13] = ""; bool mres = get_mac(macAddr); int mac = mres ? atoi(macAddr) : 0; srand(mac + time(NULL) + getpid()); negotiateRole(); if (-1 != mOtherRoleNumber) { onNegotiateRole(mOtherRoleNumber); } }
void PmpComponentManager::initPmp() { LOG4CPLUS_TRACE_METHOD(mLogger, __PRETTY_FUNCTION__ ); assert(mConfig); assert(mProfileRepository); assert(mServiceRepository); assert(mCore); assert(mPim); assert(mInteractionProtocol); assert(mIpcProtocol); assert(mAmpClient); assert(mEventHandler); assert(mEventFactory); assert(mSessionManager); if (! mSCMsg) { LOG4CPLUS_WARN(mLogger, "No CS MSG!!!"); } mCore->init(mPim, mInteractionProtocol->coreProtocol(), mEventFactory); mCore->reloadProfilesFromRepository(); mCore->print(); mPim->setIpc(mIpcProtocol); mPim->setCore(mCore); mPim->setEventFactory(mEventFactory); mPim->setPimProtocol(mInteractionProtocol->pimProtocol()); mPim->setAmp(mAmpClient); mInteractionProtocol->init(mEventFactory); LOG4CPLUS_INFO(mLogger, "initPmp - subcomponents inited"); if (mSCMsg) { mSCMsg->init(mEventFactory); } LOG4CPLUS_INFO(mLogger, "initPmp - SC inited"); std::string ipcAddr; if (mConfig) { ipcAddr = mConfig->getParam("pmp_ipc_address"); } LOG4CPLUS_INFO(mLogger, "initPmp - subcomponents inited"); mIpcProtocol->init(mEventFactory->getIpcPimHandler(), mEventFactory->getIpcCoreHandler(), ipcAddr.empty() ? NULL : ipcAddr.c_str()); mAmpClient->init(mEventFactory->getAmpHandler()); if (!mInteractionProtocol->connect()) { LOG4CPLUS_FATAL(mLogger, "Can't connect interaction protocol"); killProcess(1); } if (!mInteractionProtocol->ready()) { LOG4CPLUS_FATAL(mLogger, "Can't send ready"); killProcess(1); } mSessionManager->init(mEventFactory,mInteractionProtocol->sessionProtocol(), mServiceRepository, mAmpClient); mEventHandler->init(); }