int ChatServer::handle_data(ACE_SOCK_Stream *client)
{
if (DLOG)
{
printf("\n");
Util::log("[ChatServer::handle_data] START\n");
}
// Place the connection into blocking mode since this
// thread isn't doing anything except handling this client.
client->disable(ACE_NONBLOCK);
PacketHandler handler = PacketHandler(*client);
ServerPacketListener spl = ServerPacketListener(handler);
// Keep handling chat messages until client closes connection
// or this thread is asked to cancel itself.
ACE_Thread_Manager *mgr = ACE_Thread_Manager::instance();
ACE_thread_t me = ACE_Thread::self();
while (!mgr->testcancel(me) &&
handler.processPacket(spl) != 0)
continue;
handler.close();
if (DLOG) Util::log("[ChatServer::handle_data] END\n");
return 0;
}
int
FrameStoreUpdaterSvc::svc()
{
// set up RAPID frame-updaters
rapid::FsConfigUpdater fsConfigUpdater(*m_frameStore);
typedef kn::shared_ptr<rapid::FsPositionUpdater> FsPositionUpdaterPtr;
typedef kn::shared_ptr<rapid::FsJointUpdater> FsJointUpdaterPtr;
std::vector<FsPositionUpdaterPtr> fsPositionUpdaters;
std::vector<FsJointUpdaterPtr> fsJointUpdaters;
kn::DdsEventLoop eventLoop(svcName);
// connect RAPID frame-updaters for local-robot updates
if (m_params->frameStoreConfig.enabled) {
eventLoop.connect<rapid::FrameStoreConfig>(&fsConfigUpdater, rapid::FRAMESTORE_CONFIG_TOPIC +
m_params->frameStoreConfig.topicSuffix,
m_params->frameStoreConfig.parentNode,
m_params->frameStoreConfig.profile,
m_params->frameStoreConfig.library);
}
for (unsigned int i = 0; i < m_params->positionUpdaters.size(); ++i) {
fsPositionUpdaters.push_back(FsPositionUpdaterPtr(new rapid::FsPositionUpdater(*m_frameStore,
m_params->positionUpdaters[i])));
fsPositionUpdaters.back()->connect(eventLoop);
}
for (unsigned int i = 0; i < m_params->jointUpdaters.size(); ++i) {
fsJointUpdaters.push_back(FsJointUpdaterPtr(new rapid::FsJointUpdater(*m_frameStore,
m_params->jointUpdaters[i])));
fsJointUpdaters.back()->connect(eventLoop);
}
// enter processing loop
MIRO_LOG(LL_NOTICE, "Entering (detached) rapid framestore update loop.");
ACE_Thread_Manager * mgr = this->thr_mgr();
while (!mgr->testcancel(mgr->thr_self())) {
// 10Hz processing
eventLoop.processEvents(kn::microseconds(100000));
}
MIRO_LOG(LL_NOTICE, "Exiting (detached) rapid framestore updater loop.");
return 0;
}
int Thread_Per_Connection_Logging_Server::handle_data(ACE_SOCK_Stream *client)
{
ACE_FILE_IO log_file;
make_log_file(log_file, client);
client->disable(ACE_NONBLOCK);
Logging_Handler logging_handler(log_file, *client);
ACE_Thread_Manager *tm = ACE_Thread_Manager::instance();
ACE_thread_t me = ACE_OS::thr_self();
while (!tm->testcancel(me) && logging_handler.log_record() != -1)
continue;
log_file.close();
return 0;
}
//
// Now the svc() method where everything interesting happens.
//
int
ReactorTask::svc()
{
MIRO_DBG_OSTR(MIRO, LL_DEBUG,
"[Miro::ReactorTask] 0x" << (void*)this <<
" starts in thread " << ACE_Thread::self());
ACE_Time_Value timeout(0, 100000); // wait for 100 msec
ACE_Time_Value delta; // uninitialized time value
// set the given thread scheduling policy
if (ACE_OS::sched_params(schedp_) == -1) {
MIRO_LOG_OSTR(LL_ERROR, "[Miro::ReactorTask] Could not set sched parameters." << std::endl
<< "[Miro::ReactorTask] Maybe suid root is missing." << std::endl
<< "[Miro::ReactorTask] Will work on default scheduling policy." << std::endl);
}
// set the thread to be the owner of the reactor,
//otherwise we will get errors
reactor_.owner(ACE_OS::thr_self());
ACE_Thread_Manager * mgr = this->thr_mgr();
try {
while (!mgr->testcancel(mgr->thr_self())) {
// set delta to timeout
// handle_events decrements the timeout
delta = timeout;
// trigger message handling
reactor_.handle_events(delta);
}
}
catch (const Miro::Exception& e) {
MIRO_LOG_OSTR(LL_ERROR, "ReactorTask.handleMessage() - Uncaught Miro exception: " << e << std::endl);
conditionalShutdown();
}
catch (...) {
MIRO_LOG(LL_ERROR, "[Miro::HwReactor] task terminated due to unknown exception.");
conditionalShutdown();
}
return 0;
}
int
Thread_Per_Connection_Logging_Server::handle_data (ACE_SOCK_Stream *client)
{
ACE_FILE_IO log_file;
// Client's hostname is logfile name.
make_log_file (log_file, client);
// Place the connection into blocking mode since this
// thread isn't doing anything except handling this client.
client->disable (ACE_NONBLOCK);
Logging_Handler logging_handler (log_file, *client);
// Keep handling log records until client closes connection
// or this thread is asked to cancel itself.
ACE_Thread_Manager *mgr = ACE_Thread_Manager::instance ();
ACE_thread_t me = ACE_Thread::self ();
while (!mgr->testcancel (me) &&
logging_handler.log_record () != -1)
continue;
log_file.close ();
return 0;
}
