~ServerInstance() { udpReactor.end_reactor_event_loop(); tcpReactor.end_reactor_event_loop(); if(tcp_thread >= 0) ACE_Thread_Manager::instance ()->wait_grp(tcp_thread); ACE_Thread_Manager::instance ()->wait_grp(udp_thread); }
void TAO_Thread_Lane_Resources::shutdown_reactor (void) { TAO_Leader_Follower &leader_follower = this->leader_follower (); ACE_GUARD (TAO_SYNCH_MUTEX, ace_mon, leader_follower.lock ()); ACE_Reactor *reactor = leader_follower.reactor (); // Wakeup all the threads waiting blocked in the event loop, this // does not guarantee that they will all go away, but reduces the // load on the POA.... // If there are some client threads running we have to wait until // they finish, when the last one does it will shutdown the reactor // for us. Meanwhile no new requests will be accepted because the // POA will not process them. if (!this->orb_core_.resource_factory ()->drop_replies_during_shutdown () && leader_follower.has_clients ()) { reactor->wakeup_all_threads (); } else { // End the reactor if we want shutdown dropping replies along the // way. reactor->end_reactor_event_loop (); } }
bool testit (ACE_Reactor_Impl *ri) { int ret = 0; ACE_Reactor r (ri); ACE_Time_Value one (1); r.end_reactor_event_loop (); if ((ret = r.handle_events (one)) != -1) { ACE_ERROR ((LM_ERROR, ACE_TEXT ("Return value %d should be -1\n"), ret)); return false; } if (errno != ESHUTDOWN) { ACE_ERROR ((LM_ERROR, ACE_TEXT ("errno %d should be %d (ESHUTDOWN)\n"), errno, ESHUTDOWN)); return false; } return true; }
int run_main (int argc, ACE_TCHAR *argv[]) { int retval = 0; MCT_Config config; retval = config.open (argc, argv); if (retval != 0) return 1; const ACE_TCHAR *temp = ACE_TEXT ("Multicast_Test"); ACE_TString test = temp; u_long role = config.role (); if (ACE_BIT_DISABLED (role, MCT_Config::PRODUCER) || ACE_BIT_DISABLED (role, MCT_Config::CONSUMER)) { if (ACE_BIT_ENABLED (role, MCT_Config::PRODUCER)) test += ACE_TEXT ("-PRODUCER"); else test += ACE_TEXT ("-CONSUMER"); } // Start test only if options are valid. ACE_START_TEST (test.c_str ()); // Register a signal handler to close down application gracefully. ACE_Sig_Action sa ((ACE_SignalHandler) handler, SIGINT); // Dump the configuration info to the log if caller passed debug option. if (config.debug ()) config.dump (); ACE_Reactor *reactor = ACE_Reactor::instance (); MCT_Task *task = new MCT_Task (config, reactor); if (ACE_BIT_ENABLED (role, MCT_Config::CONSUMER)) { ACE_DEBUG ((LM_INFO, ACE_TEXT ("Starting consumer...\n"))); // Open makes it an active object. retval += task->open (); } // now produce the datagrams... if (ACE_BIT_ENABLED (role, MCT_Config::PRODUCER)) retval += producer (config); if (ACE_BIT_ENABLED (role, MCT_Config::CONSUMER)) { // and wait for everything to finish ACE_DEBUG ((LM_INFO, ACE_TEXT ("start waiting for consumer to finish...\n"))); // Wait for the threads to exit. // But, wait for a limited time since we could hang if the last udp // message isn't received. ACE_Time_Value max_wait ( config.wait ()/* seconds */); ACE_Time_Value wait_time (ACE_OS::gettimeofday () + max_wait); ACE_Time_Value *ptime = ACE_BIT_ENABLED (role, MCT_Config::PRODUCER) ? &wait_time : 0; if (ACE_Thread_Manager::instance ()->wait (ptime) == -1) { // We will no longer wait for this thread, so we must // force it to exit otherwise the thread will be referencing // deleted memory. finished = 1; reactor->end_reactor_event_loop (); if (errno == ETIME) ACE_ERROR ((LM_ERROR, ACE_TEXT ("maximum wait time of %d msec exceeded\n"), max_wait.msec ())); else ACE_OS::perror (ACE_TEXT ("wait")); ++error; // This should exit now that we ended the reactor loop. task->wait (); } } delete task; ACE_END_TEST; return (retval == 0 && error == 0) ? 0 : 1; }