static void test_for_spin (ACE_Reactor &reactor) { Handler handler (reactor, true); // This should trigger a call to <handle_input>. ssize_t result = ACE::send_n (handler.pipe_.write_handle (), message, ACE_OS::strlen (message)); if (result != ssize_t (ACE_OS::strlen (message))) ACE_ERROR ((LM_ERROR, ACE_TEXT ("Handler sent %b bytes; should be %B\n"), result, ACE_OS::strlen (message))); reactor.run_reactor_event_loop (); if (0 != reactor.remove_handler (handler.pipe_.read_handle (), ACE_Event_Handler::ALL_EVENTS_MASK | ACE_Event_Handler::DONT_CALL)) ACE_ERROR ((LM_ERROR, ACE_TEXT ("%p\n"), ACE_TEXT ("test_for_spin, remove pipe"))); if (0 == reactor.remove_handler (handler.other_pipe_.write_handle (), ACE_Event_Handler::ALL_EVENTS_MASK | ACE_Event_Handler::DONT_CALL)) ACE_ERROR ((LM_ERROR, ACE_TEXT ("test_for_spin remove other_pipe succeeded ") ACE_TEXT ("but shouldn't\n"))); }
void Locator_Repository::teardown_multicast () { ACE_Reactor* r = ior_multicast_.reactor (); if (r != 0) { r->remove_handler (&ior_multicast_, ACE_Event_Handler::READ_MASK); ior_multicast_.reactor (0); } }
int MyTask::svc() { ACE_DEBUG ((LM_INFO, ACE_TEXT ("(%t) enter MyTask::svc()\n\n"))); //initialization selector = new ACE_Select_Reactor; ACE_Reactor* reactor = new ACE_Reactor(selector); ACE_Reactor::instance(reactor); //then, ACE_Reactor::instance() is reactor this->reactor(reactor); //this reactor_ of ACE_Event_Handler can not be set //register socket handler Handler handler(UDP_PORT); if (reactor->register_handler(&handler, ACE_Event_Handler::READ_MASK) == -1) { ACE_ERROR((LM_ERROR, "%p\n", "cant't register with Reactor in MyTask::svc()\n")); return -1; } //spawn mytask2 mytask2::instance()->open(&handler); //handle_events in forever-loop until receive two data packets from socket, then, it will notify the MY_EXIT_HANDLER while (exit_flag == 0) { int result = reactor->handle_events(); //timeout will not occur at all if (result) { ACE_DEBUG ((LM_INFO, ACE_TEXT ("(%t) handle_events() succeed, result = %d\n\n"), result)); if (RECV_COUNT == handler.get_count()) { ACE_DEBUG ((LM_INFO, ACE_TEXT ("(%t) MyTask::svc() notify the exit handler\n"))); ACE_Reactor::instance()->notify(&handler, ACE_Event_Handler::EXCEPT_MASK); } if (handler.get_flag()) exit_flag = 1; } else { ACE_ERROR((LM_ERROR, "%p\n", "handle_events() failed\n")); return -1; } } if (reactor->remove_handler(&handler, ACE_Event_Handler::READ_MASK | ACE_Event_Handler::DONT_CALL) == -1) { ACE_ERROR((LM_ERROR, "%p\n", "cant't remove handler from Reactor\n")); return -1; } delete reactor; reactor = NULL; ACE_DEBUG ((LM_INFO, ACE_TEXT ("(%t) exit MyTask::svc()\n\n"))); return 0; }
void RtpsUdpReceiveStrategy::stop_i() { ACE_Reactor* reactor = link_->get_reactor(); if (reactor == 0) { ACE_ERROR((LM_ERROR, ACE_TEXT("(%P|%t) ERROR: ") ACE_TEXT("RtpsUdpReceiveStrategy::stop_i: ") ACE_TEXT("NULL reactor reference!\n"))); return; } reactor->remove_handler(link_->unicast_socket().get_handle(), ACE_Event_Handler::READ_MASK); if (link_->config()->use_multicast_) { reactor->remove_handler(link_->multicast_socket().get_handle(), ACE_Event_Handler::READ_MASK); } }
int Sender::handle_close (ACE_HANDLE, ACE_Reactor_Mask) { ACE_Reactor * TPReactor = ACE_Reactor::instance (); TPReactor->remove_handler (this, ACE_Event_Handler::ALL_EVENTS_MASK | ACE_Event_Handler::DONT_CALL); // Don't call handle_close this->reactor (0); this->destroy (); return 0; }
void UdpReceiveStrategy::stop_i() { ACE_Reactor* reactor = this->link_->get_reactor(); if (reactor == 0) { ACE_ERROR((LM_ERROR, ACE_TEXT("(%P|%t) ERROR: ") ACE_TEXT("UdpReceiveStrategy::stop_i: ") ACE_TEXT("NULL reactor reference!\n"))); return; } reactor->remove_handler(this, ACE_Event_Handler::READ_MASK); }
int TAO_Acceptor::handle_accept_error (ACE_Event_Handler* base_acceptor) { if (errno == EMFILE || errno == ENFILE) { if (TAO_debug_level > 0) TAOLIB_DEBUG ((LM_DEBUG, "TAO (%P|%t) - " "TAO_Acceptor::handle_accept_error - " "Too many files open\n")); // If the user has decided to stop accepting when the file handles // run out, just return -1; if (this->error_retry_delay_ == 0) return -1; // Get the reactor. If there isn't one, which isn't very likely, // then just return -1. ACE_Reactor* reactor = base_acceptor->reactor (); if (reactor == 0) return -1; // So that the reactor doesn't completely remove this handler from // the reactor, register it with the except mask. It should be // removed in the timer handler. reactor->register_handler (base_acceptor, ACE_Event_Handler::EXCEPT_MASK); // Remove the handler so that the reactor doesn't attempt to // process this handle again (and tightly spin). reactor->remove_handler (base_acceptor, ACE_Event_Handler::ACCEPT_MASK | ACE_Event_Handler::DONT_CALL); // Schedule a timer so that we can resume the handler in hopes // that some file handles have freed up. ACE_Time_Value timeout (this->error_retry_delay_); reactor->schedule_timer (base_acceptor, 0, timeout); } // We want to keep accepting in all other situations. return 0; }
TAO_IFR_Server::~TAO_IFR_Server (void) { // Get reactor instance from TAO. ACE_Reactor *reactor = this->orb_->orb_core ()->reactor (); if ( this->ior_multicast_ ) { // Remove event handler for the ior multicast. if (reactor->remove_handler (this->ior_multicast_, ACE_Event_Handler::READ_MASK) == -1) { ORBSVCS_DEBUG (( LM_DEBUG, ACE_TEXT ("Interface Repository: cannot remove handler\n") )); } } delete this->config_; delete this->ior_multicast_; }
template <class SVC_HANDLER, ACE_PEER_ACCEPTOR_1> int ACE_Oneshot_Acceptor<SVC_HANDLER, ACE_PEER_ACCEPTOR_2>::handle_input (ACE_HANDLE) { ACE_TRACE ("ACE_Oneshot_Acceptor<SVC_HANDLER, ACE_PEER_ACCEPTOR_2>::handle_input"); int result = 0; // Cancel any timer that might be pending. this->cancel (); // Try to find out if the implementation of the reactor that we are // using requires us to reset the event association for the newly // created handle. This is because the newly created handle will // inherit the properties of the listen handle, including its event // associations. ACE_Reactor *reactor = this->reactor (); bool reset_new_handle = false; // There is a use-case whereby this object will be gone upon return // from shared_accept - if the Svc_Handler deletes this Oneshot_Acceptor // during the shared_accept/activation steps. So, do whatever we need // to do with this object before calling shared_accept. if (reactor) { reset_new_handle = reactor->uses_event_associations (); reactor->remove_handler (this, ACE_Event_Handler::ACCEPT_MASK | ACE_Event_Handler::DONT_CALL); } if (this->shared_accept (this->svc_handler_, // stream 0, // remote address 0, // timeout this->restart_, // restart reset_new_handle // reset new handle ) == -1) result = -1; return result; }
int ACE_Process_Manager::remove_proc (size_t i) { ACE_TRACE ("ACE_Process_Manager::remove_proc"); // If there's an exit_notify_ <Event_Handler> for this pid, call its // <handle_close> method. if (this->process_table_[i].exit_notify_ != 0) { this->process_table_[i].exit_notify_->handle_close (this->process_table_[i].process_->gethandle(), 0); this->process_table_[i].exit_notify_ = 0; } #if defined (ACE_WIN32) ACE_Reactor *r = this->reactor (); if (r != 0) r->remove_handler (this->process_table_[i].process_->gethandle (), ACE_Event_Handler::DONT_CALL); #endif /* ACE_WIN32 */ this->process_table_[i].process_->unmanage (); this->process_table_[i].process_ = 0; this->current_count_--; if (this->current_count_ > 0) // Compact the table by moving the last item into the slot vacated // by the index being removed (this is a structure assignment). this->process_table_[i] = this->process_table_[this->current_count_]; return 0; }
int TAO_Acceptor::handle_expiration (ACE_Event_Handler* base_acceptor) { // Get the reactor. If there isn't one, which isn't very likely, then // just return -1; ACE_Reactor* reactor = base_acceptor->reactor (); if (reactor == 0) return -1; if (TAO_debug_level > 0) TAOLIB_DEBUG ((LM_DEBUG, "TAO (%P|%t) - " "TAO_Acceptor::handle_expiration - " "Re-registering the acceptor\n")); // Try again to allow incoming connections reactor->register_handler (base_acceptor, ACE_Event_Handler::ACCEPT_MASK); // Remove the except mask that was added during the handling of the // accept() error. That is the only reason that we're in this method // in the first place. reactor->remove_handler (base_acceptor, ACE_Event_Handler::EXCEPT_MASK | ACE_Event_Handler::DONT_CALL); return 0; }
static bool test_reactor_dispatch_order (ACE_Reactor &reactor) { Handler handler (reactor); if (!handler.ok_) { ACE_ERROR ((LM_ERROR, ACE_TEXT ("Error initializing test; abort.\n"))); return false; } bool ok_to_go = true; // This should trigger a call to <handle_input>. ssize_t result = ACE::send_n (handler.pipe_.write_handle (), message, ACE_OS::strlen (message)); if (result != ssize_t (ACE_OS::strlen (message))) { ACE_ERROR ((LM_ERROR, ACE_TEXT ("Handler sent %b bytes; should be %B\n"), result, ACE_OS::strlen (message))); ok_to_go = false; } // This should trigger a call to <handle_timeout>. if (-1 == reactor.schedule_timer (&handler, 0, ACE_Time_Value (0))) { ACE_ERROR ((LM_ERROR, ACE_TEXT ("%p\n"), ACE_TEXT ("schedule_timer"))); ok_to_go = false; } // Suspend the handlers - only the timer should be dispatched ACE_Time_Value tv (1); reactor.suspend_handlers (); reactor.run_reactor_event_loop (tv); // only the timer should have fired if (handler.dispatch_order_ != 2) { ACE_ERROR ((LM_ERROR, ACE_TEXT ("Incorrect number fired %d\n"), handler.dispatch_order_)); ok_to_go = false; } // Reset the dispatch_order_ count and schedule another timer handler.dispatch_order_ = 1; if (-1 == reactor.schedule_timer (&handler, 0, ACE_Time_Value (0))) { ACE_ERROR ((LM_ERROR, ACE_TEXT ("%p\n"), ACE_TEXT ("schedule_timer"))); ok_to_go = false; } // Resume the handlers - things should work now reactor.resume_handlers (); if (ok_to_go) { reactor.run_reactor_event_loop (tv); } if (0 != reactor.remove_handler (handler.pipe_.read_handle (), ACE_Event_Handler::ALL_EVENTS_MASK | ACE_Event_Handler::DONT_CALL)) ACE_ERROR ((LM_ERROR, ACE_TEXT ("%p\n"), ACE_TEXT ("remover_handler pipe"))); if (handler.dispatch_order_ != 4) { ACE_ERROR ((LM_ERROR, ACE_TEXT ("Incorrect number fired %d\n"), handler.dispatch_order_)); ok_to_go = false; } return ok_to_go; }
int ACE_TMAIN(int argc, ACE_TCHAR *argv[]) { if (parse_args (argc, argv) == -1) return -1; ACE_Select_Reactor sr; ACE_Reactor reac (&sr); ACE_Reactor::instance (&reac); ACE_SOCK_Stream stream[iter]; ACE_SOCK_Connector connector[iter]; Purging_Handler ph[iter]; ACE_INET_Addr addr (port, host); ACE_Reactor *singleton = ACE_Reactor::instance (); for (int i = 0; i != iter; ++i) { if (connector[i].connect (stream[i], addr) == -1) ACE_ERROR_RETURN ((LM_ERROR, "Error while connecting: %p\n", "client"), -1); if (stream[i].get_handle () == ACE_INVALID_HANDLE) ACE_ERROR_RETURN ((LM_ERROR, "Got invalid handles after connecting the [%d] time\n",i), -1); if (singleton->register_handler (stream[i].get_handle (), &ph[i], ACE_Event_Handler::READ_MASK) == -1) ACE_ERROR_RETURN ((LM_ERROR, "Registration failed\n"), -1); // ACE_Time_Value tv (1); // while (singleton->handle_events (&tv) >= 1); } // Handle events moved to here to prevent this test taking best part // of a minute ACE_Time_Value tv (3); while (singleton->handle_events (&tv) >= 1) { // No action. } // Remove the handlers to avoid the possibility of the reactor // using any of them after they leave the scope (those that haven't // been closed and removed already, that is). for (int j = 0; j != iter; ++j) { singleton->remove_handler (stream[j].get_handle (), ACE_Event_Handler::READ_MASK); } if ((iter - purged_handles) > 20) ACE_ERROR_RETURN ((LM_ERROR, "(%P|%t) Purging hasnt worked at all\n"), -1); return 0; }