~Quit_Handler () {
ACE_Event_Handler::remove_stdin_handler
(reactor (), ACE_Thread_Manager::instance ());
reactor ()->remove_handler (quit_seen_.handle (),
ACE_Event_Handler::DONT_CALL);
}
static void *
worker (void *)
{
if (evt.wait () == -1)
ACE_ERROR_RETURN ((LM_ERROR,
ACE_TEXT (" (%P|%t) %p\n"),
ACE_TEXT ("Failed waiting for pulse ()")),
0);
ACE_DEBUG ((LM_DEBUG,
ACE_TEXT (" (%P|%t) awake\n")));
if (++n_awoken < n_workers)
{
//FUZZ: disable check_for_lack_ACE_OS
ACE_Time_Value wait (1, 0); // Wait 10 sec
//FUZZ: enable check_for_lack_ACE_OS
ACE_Time_Value tv = ACE_OS::gettimeofday () + wait;
if (evt.wait (&tv) == -1)
{
// verify that we have ETIME
if (ACE_OS::last_error () == ETIME)
ACE_DEBUG ((LM_DEBUG, ACE_TEXT (" (%P|%t) timeout\n")));
else
ACE_ERROR ((LM_ERROR,
ACE_TEXT (" (%P|%t) wait failed %p\n"),
ACE_TEXT ("but not with ETIME")));
}
else
{
ACE_DEBUG ((LM_DEBUG,
ACE_TEXT (" (%P|%t) awake in time\n")));
if (++n_awoken2 >= (n_workers/2))
evt.reset (); // reset signal (rest times out)
}
// Check to ensure that an "infinite timeout" will work.
if (evt.wait (0) == -1)
{
//FUZZ: disable check_for_lack_ACE_OS
ACE_ERROR ((LM_ERROR,
ACE_TEXT (" (%P|%t) %p\n"),
ACE_TEXT ("Failed waiting for signal ()\n")));
//FUZZ: enable check_for_lack_ACE_OS
}
}
else
{
ACE_DEBUG ((LM_DEBUG,
ACE_TEXT (" (%P|%t) last awake; send signal\n")));
// last one wakes others
if (evt.signal () == -1)
ACE_ERROR ((LM_ERROR, ACE_TEXT (" (%P|%t) %p\n"), ACE_TEXT ("signal")));
ACE_OS::sleep (ACE_Time_Value (0, 200 * 1000)); // 200 msec
}
if (evt.wait () == -1)
{
//FUZZ: disable check_for_lack_ACE_OS
ACE_ERROR ((LM_ERROR,
ACE_TEXT (" (%P|%t) %p\n"),
ACE_TEXT ("Failed waiting for signal ()\n")));
//FUZZ: enable check_for_lack_ACE_OS
}
ACE_DEBUG ((LM_DEBUG, ACE_TEXT (" (%P|%t) worker finished\n")));
return 0;
}
int
ACE_TMAIN(int argc, ACE_TCHAR *argv[])
{
if (parse_args (argc,
argv) == -1)
return -1;
try
{
// Start the Naming Service tasks
NamingTask name_service ("NamingORBA", argc, argv);
name_service.activate();
// Wait for the Naming Service initialized.
name_service.waitInit();
ACE_Argv_Type_Converter satc (argc, argv);
CORBA::ORB_var sorb =
CORBA::ORB_init (satc.get_argc (),
satc.get_TCHAR_argv (),
server_orb.c_str ());
ACE_Manual_Event me;
Server_Task server_task (name_service.root (),
sorb.in (),
me,
ACE_Thread_Manager::instance ());
if (server_task.activate (THR_NEW_LWP | THR_JOINABLE,
1,
1) == -1)
{
ACE_ERROR ((LM_ERROR, "Error activating server task\n"));
}
// Wait for the server thread to do some processing
me.wait ();
ACE_Argv_Type_Converter catc (argc, argv);
CORBA::ORB_var corb =
CORBA::ORB_init (catc.get_argc (),
catc.get_TCHAR_argv (),
client_orb.c_str ());
Client_Task client_task (name_service.root (),
corb.in (),
ACE_Thread_Manager::instance (),
result);
if (client_task.activate (THR_NEW_LWP | THR_JOINABLE,
1,
1) == -1)
{
ACE_ERROR ((LM_ERROR, "Error activating client task\n"));
}
// Wait for the client and server to finish
ACE_Thread_Manager::instance ()->wait ();
// Now that all threads have completed we can destroy the ORB
sorb->destroy ();
if (server_orb != client_orb)
{
corb->destroy ();
}
}
catch (const CORBA::Exception&)
{
// Ignore exceptions..
}
return 0;
}
int
ACE_TMAIN(int argc, ACE_TCHAR *argv[])
{
try
{
ACE_Argv_Type_Converter main_args_s (argc, argv);
CORBA::ORB_var sorb =
CORBA::ORB_init (main_args_s.get_argc (),
main_args_s.get_TCHAR_argv (),
"Server_ORB");
// Parse command line
if (parse_args (argc, argv) == -1)
{
return -1;
}
ACE_Manual_Event me;
Server_Task server_task (ior_output_file,
sorb.in (),
me,
ACE_Thread_Manager::instance ());
if (server_task.activate (THR_JOINABLE, 1, 1) == -1)
{
ACE_ERROR ((LM_ERROR, "Error activating the server task."));
return -1;
}
// Wait for the server task to activate.
me.wait ();
ACE_Argv_Type_Converter main_args_c (argc, argv);
CORBA::ORB_var corb =
CORBA::ORB_init (main_args_c.get_argc (),
main_args_c.get_TCHAR_argv (),
"Client_ORB");
{
Client_Task client_task (ior_input_file,
corb.in (),
ACE_Thread_Manager::instance ());
if (client_task.activate (THR_JOINABLE, 1, 1) == -1)
{
ACE_ERROR ((LM_ERROR, "Error activating client thread.\n"));
return -1;
}
ACE_Thread_Manager::instance ()->wait ();
}
corb->destroy ();
}
catch (const CORBA::Exception&)
{
// ignore exceptions
}
ACE_DEBUG ((LM_DEBUG, "Threaded client ready.\n"));
return 0;
}
