~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;
}
