int Task::handle_input( ACE_HANDLE h ) { const size_t size = 2000; ACE_Message_Block * mb = new ACE_Message_Block( size ); ACE_Message_Block * pfrom = new ACE_Message_Block( sizeof( ACE_INET_Addr ) ); ACE_INET_Addr * addr = new ( pfrom->wr_ptr() ) ACE_INET_Addr(); int res = 0; if ( mcast_handler_ && ( h == mcast_handler_->get_handle() ) ) { mb->msg_type( constants::MB_MCAST ); res = mcast_handler_->recv( mb->wr_ptr(), size, *addr ); } if ( res == (-1) ) { DWORD err = GetLastError(); (void)err; ACE_Message_Block::release( mb ); ACE_Message_Block::release( pfrom ); return 0; } mb->length( res ); mb->cont( pfrom ); putq( mb ); return 0; }
virtual int svc (void) { ACE_Thread_ID id; thread_id_ = id; while (1) { ACE_Message_Block *mb = 0; if (this->getq (mb) == -1) ACE_ERROR_BREAK ((LM_ERROR, ACE_TEXT ("%p\n"), ACE_TEXT ("getq"))); if (mb->msg_type () == ACE_Message_Block::MB_HANGUP) { ACE_DEBUG ((LM_INFO, ACE_TEXT ("(%t) Shutting down\n"))); mb->release (); break; } // Process the message. process_message (mb); // Return to work. this->manager_->return_to_work (this); } return 0; }
//////////////////////////////////////////////////////////////////////// // Now the svc() method where everything interesting happens. // int LaserTask::svc() { MIRO_DBG_OSTR(SICK, LL_DEBUG, "("<<(void *) this <<"|"<<ACE_Thread::self ()<<") Task 0x%x starts in thread %u\n"); // Where we getq() the message ACE_Message_Block *message; LaserMessage * data; while (true) { // Get the message... if (getq (message) == -1) { throw Miro::Exception("LaserTask::svc: could not getq from message queue"); } // Is it a shutdown request? if (message->msg_type () == ACE_Message_Block::MB_HANGUP) { break; } // Get the LaserMessage pointer out of the ACE message block. data = (LaserMessage*)message->rd_ptr (); if (!data) throw Miro::Exception("LaserTask::svc: got empty message block"); doPkt( data ); // throw away message block message->release (); } MIRO_LOG(LL_NOTICE, "left service."); return (0); }
int Terminator::svc() { while (1) { ACE_Message_Block* mb = 0; if (this->getq(mb) == -1) { ACE_ERROR_RETURN ((LM_ERROR, "(%P|%t|%T) ERROR: Terminator::svc() could not get " "message block from queue"), -1); } if (mb->msg_type () == ACE_Message_Block::MB_HANGUP) { mb->release (); break; } int delay_secs = ACE_OS::atoi(mb->rd_ptr()); ACE_DEBUG ((LM_DEBUG, "(%P|%t|%T) Terminator::svc() Sleeping %d seconds before aborting\n", delay_secs)); ACE_OS::sleep(delay_secs); ACE_OS::abort(); } return 0; }
void ZigbeeSerialportService::connect_to_serialport() { ACE_Message_Block *b = new ACE_Message_Block(); b->msg_type(ZIGBEE_SERIAL_PORT_CMD_CONNECT_PORT); task_->message_queue.enqueue_tail(b); }
static ACE_Message_Block * put( const T& t, unsigned long msg_type = 0 ) { ACE_Message_Block * mb = new ACE_Message_Block( sizeof(T) ); *reinterpret_cast<T*>( mb->wr_ptr() ) = t; mb->wr_ptr( sizeof(T) ); if ( msg_type >= ACE_Message_Block::MB_USER ) mb->msg_type( msg_type ); return mb; }
void ZigbeeSerialportService::exit_and_wait_thread() { ACE_Message_Block *b = new ACE_Message_Block(); b->msg_type(ZIGBEE_SERIAL_PORT_CMD_EXIT_THREAD); task_->message_queue.enqueue_head(b); task_->wait(); }
void tofSession_i::tof_debug( const CORBA::WChar * text, const CORBA::WChar * key ) { ACE_OutputCDR cdr; cdr.write_wstring( text ); cdr.write_wstring( key ); ACE_Message_Block * mb = cdr.begin()->duplicate(); mb->msg_type( constants::MB_DEBUG ); pTask_->putq( mb ); }
void Logging::commit_to_task() { // Broker::EventLog, that is not EventLog if ( msg.get().format.in() && *msg.get().format.in() != 0 ) { TAO_OutputCDR cdr; cdr << msg.get(); ACE_Message_Block * mb = cdr.begin()->duplicate(); mb->msg_type( constants::MB_EVENTLOG ); iTask::instance()->putq( mb ); } }
virtual int put (ACE_Message_Block *mblk, ACE_Time_Value *) { for (ACE_Message_Block *temp = mblk; temp != 0; temp = temp->cont ()) { if (temp->msg_type () != ACE_Message_Block::MB_STOP) { format_data(temp); } } return put_next (mblk); }
void RASocket::commandFinished(void* callbackArg, bool /*success*/) { if (!callbackArg) return; RASocket* socket = static_cast<RASocket*>(callbackArg); ACE_Message_Block* mb = new ACE_Message_Block(); mb->msg_type(ACE_Message_Block::MB_BREAK); if (socket->putq(mb) == -1) { sLog.outRemote("Failed to enqueue command end message. Error is %s", ACE_OS::strerror(errno)); mb->release(); } }
void SiteWorkTask::StopTask() { if (_pSiteRenderTask) { _pSiteRenderTask->StopTask(); DEL_PTR(_pSiteRenderTask); } m_bStopped = true; ACE_Message_Block *mb = new ACE_Message_Block(); mb->msg_type( ACE_Message_Block::MB_STOP ); this->putq( mb ); }
int ZigbeeSerialportService::handle_input (ACE_HANDLE fd) { { ACE_Message_Block *b = new ACE_Message_Block(); b->msg_type(ZIGBEE_SERIAL_PORT_CMD_GET_RES); if (task_->message_queue.enqueue_tail(b)== -1 ) { ACE_DEBUG((LM_DEBUG, "faild to input reactor block into queue\n")); } reactor()->suspend_handler(this); } return 0; }
int SiteWorkTask::svc() { ImageCommRequestArgs *pImageCommRequestArgs = NULL; SetupDefaultComments(); while(true) { try { ACE_Message_Block *mb = NULL; if( getq(mb) == -1 ) { break; } if( mb->msg_type() == ACE_Message_Block::MB_STOP ) { mb->release(); break; } if (NULL == mb) { continue; } memcpy(&pImageCommRequestArgs, mb->rd_ptr(), sizeof(pImageCommRequestArgs)); onCommandRequest(pImageCommRequestArgs); delete pImageCommRequestArgs; mb->release(); if (_pSiteRenderTask) { _pSiteRenderTask->Process(); } } catch(...) { //throw "work task crashed"; LOG_ERROR("catch exception."); } } return 0; }
virtual int svc () { int stop = 0; for (ACE_Message_Block *mb; !stop && getq (mb) != -1; ) { if (mb->msg_type () == ACE_Message_Block::MB_STOP) { stop = 1; } else { ACE_DEBUG ((LM_DEBUG, "%s",mb->base())); } put_next (mb); } return 0; }
int ZigbeeSerialportService::send(ZigbeeRequest *req) { { ACE_Message_Block *b = new ACE_Message_Block(req->size()); ACE_OS::memcpy(b->base(), req->base(), req->size()); b->msg_type(ZIGBEE_SERIAL_PORT_CMD_SEND_REQ); if (task_->message_queue.enqueue_tail(b) == -1 ) { ACE_DEBUG((LM_DEBUG, "ZigbeeSerialportService faild to input node block into queue\n")); } delete req; } return 0; }
virtual int svc (void) { ACE_DEBUG ((LM_DEBUG, ACE_TEXT ("(%t) starting up %C\n"), name_)); ACE_OS::sleep (2); ACE_Message_Block *mb = 0; while (this->getq (mb) != -1) { if (mb->msg_type () == ACE_Message_Block::MB_BREAK) { mb->release (); break; } process_message (mb); mb->release (); } return 0; }
void RASocket::commandFinished(void* callbackArg, bool /*success*/) { if (!callbackArg) return; RASocket* socket = static_cast<RASocket*>(callbackArg); ACE_Message_Block* mb = new ACE_Message_Block(); mb->msg_type(ACE_Message_Block::MB_BREAK); // the message is 0 size control message to tell that command output is finished // hence we don't put timeout, because it shouldn't increase queue size and shouldn't block if (socket->putq(mb) == -1) { // getting here is bad, command can't be marked as complete sLog->outRemote("Failed to enqueue command end message. Error is %s", ACE_OS::strerror(errno)); mb->release(); } }
bool CLogManager::Dispose_Queue() { ACE_Message_Block* mb = NULL; ACE_OS::last_error(0); if (getq(mb, 0) == -1) { OUR_DEBUG((LM_ERROR, "[CLogManager::svc] get error errno = [%d].\n", ACE_OS::last_error())); m_blRun = false; return false; } else if (mb->msg_type() == ACE_Message_Block::MB_STOP) { m_mutex.acquire(); mb->release(); this->msg_queue()->deactivate(); m_cond.signal(); m_mutex.release(); m_blRun = false; return true; } else { _LogBlockInfo* pLogBlockInfo = *((_LogBlockInfo**)mb->base()); if (!pLogBlockInfo) { OUR_DEBUG((LM_ERROR, "[CLogManager::svc] CLogManager mb log == NULL!\n")); return true; } if (0 != ProcessLog(pLogBlockInfo)) { OUR_DEBUG((LM_ERROR, "[CLogManager::svc] ProcessLog is false.\n")); } //回收日志块 m_objLogBlockPool.ReturnBlockInfo(pLogBlockInfo); } return true; }
int AC_Output_Handler::svc () { ACE_Message_Block *chunk[ACE_IOV_MAX]; size_t message_index = 0; ACE_Time_Value time_of_last_send (ACE_OS::gettimeofday ()); ACE_Time_Value timeout; ACE_Sig_Action no_sigpipe ((ACE_SignalHandler) SIG_IGN); ACE_Sig_Action original_action; no_sigpipe.register_action (SIGPIPE, &original_action); for (;;) { if (message_index == 0) { timeout = ACE_OS::gettimeofday (); timeout += FLUSH_TIMEOUT; } ACE_Message_Block *mblk = 0; if (getq (mblk, &timeout) == -1) { if (errno == ESHUTDOWN) { if (connector_->reconnect () == -1) break; continue; } else if (errno != EWOULDBLOCK) break; else if (message_index == 0) continue; } else { if (mblk->size () == 0 && mblk->msg_type () == ACE_Message_Block::MB_STOP) { mblk->release (); break; } chunk[message_index] = mblk; ++message_index; } if (message_index >= ACE_IOV_MAX || (ACE_OS::gettimeofday () - time_of_last_send >= ACE_Time_Value(FLUSH_TIMEOUT))) { if (this->send (chunk, message_index) == -1) break; time_of_last_send = ACE_OS::gettimeofday (); } } if (message_index > 0) this->send (chunk, message_index); no_sigpipe.restore_action (SIGPIPE, original_action); return 0; }
int ACE_TMAIN (int, ACE_TCHAR **) { #if 0 // Just for the book... // Listing 1 code/ch12 ACE_Message_Block *mb; ACE_NEW_RETURN (mb, ACE_Message_Block (128), -1); const char *deviceAddr= "Dev#12"; mb->copy (deviceAddr, ACE_OS::strlen (deviceAddr)+1); // Listing 1 #endif /* 0 */ // Listing 2 code/ch12 ACE_Message_Block *mb; ACE_NEW_RETURN (mb, ACE_Message_Block (128), -1); const char *commandSeq= "CommandSeq#14"; ACE_OS::sprintf (mb->wr_ptr (), commandSeq); // Move the wr_ptr() forward in the buffer by the // amount of data we just put in. mb->wr_ptr (ACE_OS::strlen (commandSeq) +1); // Listing 2 // Listing 3 code/ch12 ACE_DEBUG((LM_DEBUG, ACE_TEXT ("Command Sequence --> %C\n"), mb->rd_ptr ())); mb->rd_ptr (ACE_OS::strlen (mb->rd_ptr ())+1); mb->release (); // Listing 3 // Listing 4 code/ch12 // Send a hangup notification to the receiver. ACE_NEW_RETURN (mb, ACE_Message_Block (128, ACE_Message_Block::MB_HANGUP), -1); // Send an error notification to the receiver. mb->msg_type (ACE_Message_Block::MB_ERROR); // Listing 4 mb->release (); return 0; }
int RASocket::process_command (const std::string& command) { if (command.length() == 0) return 0; sLog->outRemote("Got command: %s", command.c_str()); // handle quit, exit and logout commands to terminate connection if (command == "quit" || command == "exit" || command == "logout") { (void) send("Bye\r\n"); return -1; } CliCommandHolder* cmd = new CliCommandHolder(this, command.c_str(), &RASocket::zprint, &RASocket::commandFinished); sWorld->QueueCliCommand(cmd); // wait for result ACE_Message_Block* mb; for (;;) { if (getq(mb) == -1) return -1; if (mb->msg_type() == ACE_Message_Block::MB_BREAK) { mb->release(); break; } if (size_t(peer().send(mb->rd_ptr(), mb->length())) != mb->length()) { mb->release(); return -1; } mb->release(); } return 0; }
int RASocket::process_command(const std::string& command) { if (command.length() == 0) return 0; TC_LOG_INFO(LOG_FILTER_REMOTECOMMAND, "Received command: %s", command.c_str()); // handle quit, exit and logout commands to terminate connection if (command == "quit" || command == "exit" || command == "logout") { (void) send("Bye\r\n"); return -1; } _commandExecuting = true; CliCommandHolder* cmd = new CliCommandHolder(this, command.c_str(), &RASocket::zprint, &RASocket::commandFinished); sWorld->QueueCliCommand(cmd); // wait for result ACE_Message_Block* mb; for (;;) { if (getq(mb) == -1) return -1; if (mb->msg_type() == ACE_Message_Block::MB_BREAK) { mb->release(); break; } if (send(std::string(mb->rd_ptr(), mb->length())) == -1) { mb->release(); return -1; } mb->release(); } return 0; }
int Task::handle_timeout( const ACE_Time_Value& tv, const void * ) { do { ACE_Message_Block * mb = new ACE_Message_Block( sizeof( tv ) ); *reinterpret_cast< ACE_Time_Value *>(mb->wr_ptr()) = tv; mb->wr_ptr( sizeof(tv) ); putq( mb ); } while(0); do { TAO_OutputCDR cdr; cdr << constants::SESSION_QUERY_DEVICE; cdr << TOFConstants::ClassID_AnalyzerDeviceData; cdr << TOFConstants::ClassID_MSMethod; cdr << GlobalConstants::EOR; ACE_Message_Block * mb = cdr.begin()->duplicate(); mb->msg_type( constants::MB_QUERY_DEVICE ); this->putq( mb ); } while(0); return 0; }
// Listing 05 code/ch18 int CommandTask::close (u_long flags) { int rval = 0; if (flags == 1) { ACE_Message_Block *hangup = new ACE_Message_Block; hangup->msg_type (ACE_Message_Block::MB_HANGUP); if (this->putq (hangup->duplicate ()) == -1) { ACE_ERROR_RETURN ((LM_ERROR, ACE_TEXT ("%p\n"), ACE_TEXT ("Task::close() putq")), -1); } hangup->release (); rval = this->wait (); } return rval; }
void consume_item () { csema_.acquire (); if (!is_closed ()) { ACE_Message_Block *mb = 0; this->getq (mb); if (mb->msg_type () == ACE_Message_Block::MB_HANGUP) { this->shutdown (); mb->release (); return; } else { ACE_DEBUG ((LM_DEBUG, ACE_TEXT ("(%t) Consumed %d\n"), *((int*)mb->rd_ptr ()))); mb->release(); } psema_.release (); } }
int ZigbeeRequest::get() { ACE_Message_Block *b = new ACE_Message_Block(this->size()); if(b) { ACE_OS::memcpy(b->base(), this->base(), this->size()); b->msg_type(EventNotifyHandler::EventSerialportSendData); if ( -1 == _zigbeeHelper::instance()->eventQ()->putQ(b)) { b->release(); } delete this; } else { delete this; } return 0; }
//////////////////////////////////////////////////////////////////////// // Now the svc() method where everything interesting happens. // int LaserTask::svc() { #ifdef DEBUG ACE_DEBUG ((LM_DEBUG, "(%P|%t) Task 0x%x starts in thread %u\n", (void *) this, ACE_Thread::self ())); #endif // Where we getq() the message ACE_Message_Block *message; LaserMessage * data; while (true) { // Get the message... if (getq (message) == -1) { throw Miro::Exception("LaserTask::svc: could not getq from message queue"); } // Is it a shutdown request? if (message->msg_type () == ACE_Message_Block::MB_HANGUP) { break; } // Get the LaserMessage pointer out of the ACE message block. data = (LaserMessage*)message->rd_ptr (); if (!data) throw Miro::Exception("LaserTask::svc: got empty message block"); doPkt( data ); // throw away message block message->release (); } log(INFO, "left service."); return (0); }
virtual int svc (void) { thread_id_ = ACE_Thread::self (); while (1) { ACE_Message_Block *mb = NULL; ACE_ASSERT (this->getq (mb) != -1); if (mb->msg_type () == ACE_Message_Block::MB_HANGUP) { ACE_DEBUG ((LM_INFO, ACE_TEXT ("(%t) Shutting down\n"))); mb->release (); break; } // Process the message. process_message (mb); // Return to work. this->manager_->return_to_work (this); } return 0; }
int Task::svc() { barrier_.wait(); for ( ;; ) { ACE_Message_Block * mblk = 0; if ( this->getq( mblk ) == (-1) ) { if ( errno == ESHUTDOWN ) ACE_ERROR_RETURN((LM_ERROR, "(%t) queue is deactivated\n"), 0); else ACE_ERROR_RETURN((LM_ERROR, "(%t) %p\n", "putq"), -1); } if ( mblk->msg_type() == ACE_Message_Block::MB_HANGUP ) { this->putq( mblk ); // forward the request to any peer threads break; } doit( mblk ); ACE_Message_Block::release( mblk ); } return 0; }