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();
}
