int ACE_TMAIN (int argc, ACE_TCHAR *argv[])
{
if (argc > 1) // Running as a child.
{
ACE_OS::sleep (10);
}
else // Running as a parent.
{
// Get the processwide process manager.
ACE_Process_Manager* pm = ACE_Process_Manager::instance ();
// Specify the options for the new processes
// to be spawned.
ACE_Process_Options options;
options.command_line (ACE_TEXT ("%s a"), argv[0]);
// Spawn two child processes.
pid_t pids[NCHILDREN];
pm->spawn_n (NCHILDREN, options, pids);
// Destroy the first child.
pm->terminate (pids[0]);
// Wait for the child we just terminated.
ACE_exitcode status;
pm->wait (pids[0], &status);
// Get the results of the termination.
#if !defined(ACE_WIN32)
if (WIFSIGNALED (status) != 0)
ACE_DEBUG ((LM_DEBUG,
ACE_TEXT ("%d died because of a signal ")
ACE_TEXT ("of type %d\n"),
pids[0], WTERMSIG (status)));
#else
ACE_DEBUG
((LM_DEBUG,
ACE_TEXT ("The process terminated with exit code %d\n"),
status));
#endif /*ACE_WIN32*/
// Wait for all (only one left) of the
// children to exit.
pm->wait (0);
}
return 0;
}
int
run_main (int argc, ACE_TCHAR *argv[])
{
#if defined (ACE_HAS_WIN32_PRIORITY_CLASS)
ACE_Get_Opt get_opt (argc, argv, ACE_TEXT ("dp:"));
#else
ACE_Get_Opt get_opt (argc, argv, ACE_TEXT ("d"));
#endif
int opt;
while ((opt = get_opt ()) != EOF)
{
switch (opt)
{
case 'd':
debug_test = 1u;
break;
#if defined (ACE_HAS_WIN32_PRIORITY_CLASS)
case 'p':
process_id = ACE_OS::atoi (get_opt.opt_arg ());
break;
#endif
}
}
if (get_opt.opt_ind () == argc - 1)
{
// child process: sleep & exit
ACE_TCHAR lognm[MAXPATHLEN];
int const mypid (ACE_OS::getpid ());
ACE_OS::snprintf (lognm, MAXPATHLEN,
ACE_TEXT ("Process_Manager_Test-child-%d"), mypid);
ACE_START_TEST (lognm);
int const secs = ACE_OS::atoi (argv[get_opt.opt_ind ()]);
ACE_OS::sleep (secs ? secs : 1);
ACE_TCHAR prio[64];
#if defined (ACE_WIN32_HAS_PRIORITY_CLASS)
DWORD priority = ::GetPriorityClass (::GetCurrentProcess());
check_process_priority(priority);
if (priority == ABOVE_NORMAL_PRIORITY_CLASS)
ACE_OS::snprintf (prio, 64, ACE_TEXT ("and priority 'above normal'"));
else if (priority == BELOW_NORMAL_PRIORITY_CLASS)
ACE_OS::snprintf (prio, 64, ACE_TEXT ("and priority 'below normal'"));
else if (priority == HIGH_PRIORITY_CLASS)
ACE_OS::snprintf (prio, 64, ACE_TEXT ("and priority 'high'"));
else if (priority == IDLE_PRIORITY_CLASS)
ACE_OS::snprintf (prio, 64, ACE_TEXT ("and priority 'idle'"));
else if (priority == NORMAL_PRIORITY_CLASS)
ACE_OS::snprintf (prio, 64, ACE_TEXT ("and priority 'normal'"));
else if (priority == REALTIME_PRIORITY_CLASS)
ACE_OS::snprintf (prio, 64, ACE_TEXT ("and priority 'realtime'"));
#else
prio[0] = ACE_TEXT ('\0');
#endif
if (debug_test)
ACE_DEBUG ((LM_DEBUG,
ACE_TEXT ("%T: pid %P about to exit with code %d %s\n"),
secs,
prio));
ACE_END_LOG;
return secs;
}
if (get_opt.opt_ind () != argc) // incorrect usage
usage (argv[0]);
ACE_START_TEST (ACE_TEXT ("Process_Manager_Test"));
int test_status = 0;
#ifdef ACE_HAS_PROCESS_SPAWN
int result = 0;
if ((result = command_line_test ()) != 0)
test_status = result;
// Try the explicit <ACE_Process_Manager::wait> functions
ACE_Process_Manager mgr;
mgr.register_handler (new Exit_Handler ("default"));
ACE_exitcode exitcode;
// --------------------------------------------------
// wait for a specific PID
pid_t child1 = spawn_child (argc > 0 ? argv[0] : ACE_TEXT ("Process_Manager_Test"),
mgr,
1,
1);
result = mgr.wait (child1,
&exitcode);
if (result != child1)
{
ACE_ERROR ((LM_ERROR,
ACE_TEXT ("(%P) Error: expected to reap child1 (%d); got %d\n"),
child1,
result));
if (result == ACE_INVALID_PID)
ACE_ERROR ((LM_ERROR, ACE_TEXT ("(%P) %p\n"), ACE_TEXT ("error")));
test_status = 1;
}
else
ACE_DEBUG ((LM_DEBUG,
ACE_TEXT ("(%P) reaped child1, pid %d: %d\n"),
child1,
exitcode));
// --------------------------------------------------
// wait for a specific PID; another should finish first
pid_t child2 = spawn_child (argc > 0 ? argv[0] : ACE_TEXT ("Process_Manager_Test"),
mgr,
1,
2);
pid_t child3 = spawn_child (argc > 0 ? argv[0] : ACE_TEXT ("Process_Manager_Test"),
mgr,
4,
3);
result = mgr.wait (child3,
&exitcode);
if (result != child3)
{
ACE_ERROR ((LM_ERROR,
ACE_TEXT ("(%P) Error: expected to reap child3 (%d); got %d\n"),
child3,
result));
if (result == ACE_INVALID_PID)
ACE_ERROR ((LM_ERROR, ACE_TEXT ("(%P) %p\n"), ACE_TEXT ("error")));
test_status = 1;
}
else
ACE_DEBUG ((LM_DEBUG,
ACE_TEXT ("(%P) reaped child 3, pid %d: %d\n"),
child3,
exitcode));
// Now wait for any...should get the one that finished earlier.
result = mgr.wait (0, &exitcode);
if (result != child2)
{
ACE_ERROR ((LM_ERROR,
ACE_TEXT ("(%P) Error: expected to reap child2 (%d); got %d\n"),
child2,
result));
if (result == ACE_INVALID_PID)
ACE_ERROR ((LM_ERROR, ACE_TEXT ("(%P) %p\n"), ACE_TEXT ("error")));
test_status = 1;
}
else
ACE_DEBUG ((LM_DEBUG,
ACE_TEXT ("(%P) reaped child 2, pid %d: %d\n"),
result,
exitcode));
// --------------------------------------------------
// Try the timed wait functions
// This one shouldn't timeout:
pid_t child4 = spawn_child (argc > 0 ? argv[0] : ACE_TEXT ("Process_Manager_Test"),
mgr,
1,
4);
#if defined (ACE_HAS_CPP11)
result = mgr.wait (0, std::chrono::seconds (4), &exitcode);
#else
result = mgr.wait (0, ACE_Time_Value (4), &exitcode);
#endif
if (result != child4)
{
ACE_ERROR ((LM_ERROR,
ACE_TEXT ("(%P) Error: expected to reap child4 (%d); got %d\n"),
child4,
result));
if (result == ACE_INVALID_PID)
ACE_ERROR ((LM_ERROR, ACE_TEXT ("(%P) %p\n"), ACE_TEXT ("error")));
test_status = 1;
}
else
ACE_DEBUG ((LM_DEBUG,
ACE_TEXT ("(%P) reaped child 4 pid %d: %d\n"),
result,
exitcode));
// This one should timeout:
pid_t child5 = spawn_child (argc > 0 ? argv[0] : ACE_TEXT ("Process_Manager_Test"),
mgr,
4,
5);
result = mgr.wait (0, ACE_Time_Value (1), &exitcode);
if (result != 0)
{
ACE_ERROR ((LM_ERROR,
ACE_TEXT ("(%P) Error: expected wait to time out; got %d\n"),
result));
if (result == ACE_INVALID_PID)
ACE_ERROR ((LM_ERROR, ACE_TEXT ("(%P) %p\n"), ACE_TEXT ("error")));
test_status = 1;
}
else
ACE_DEBUG ((LM_DEBUG,
ACE_TEXT ("(%P) Correctly timed out wait at child 5\n")));
// Now wait indefinitely to clean up...
result = mgr.wait (0, &exitcode);
if (result != child5)
{
ACE_ERROR ((LM_ERROR,
ACE_TEXT ("Error: expected to reap child5 pid %d; got %d\n"),
child5,
result));
if (result == ACE_INVALID_PID)
ACE_ERROR ((LM_ERROR, ACE_TEXT ("(%P) %p\n"), ACE_TEXT ("error")));
test_status = 1;
}
else
ACE_DEBUG ((LM_DEBUG,
ACE_TEXT ("(%P) reaped child 5, pid %d: %d\n"),
result,
exitcode));
// Terminate a child process and make sure we can wait for it.
pid_t child6 = spawn_child (argc > 0 ? argv[0] : ACE_TEXT ("Process_Manager_Test"),
mgr,
5,
6);
ACE_exitcode status6;
if (-1 == mgr.terminate (child6))
{
ACE_ERROR ((LM_ERROR, ACE_TEXT ("(%P) %p\n"), ACE_TEXT ("terminate child6")));
test_status = 1;
mgr.wait (child6, &status6); // Wait for child to exit just to clean up
}
else
{
if (-1 == mgr.wait (child6, &status6))
{
ACE_ERROR ((LM_ERROR,
ACE_TEXT ("(%P) wait on child6 reported ACE_INVALID_PID\n")));
test_status = 1;
}
else
{
// Get the results of the termination.
#if !defined(ACE_WIN32)
if (WIFSIGNALED (status6) != 0)
ACE_DEBUG ((LM_DEBUG,
ACE_TEXT ("(%P) child6 died on signal %d - correct\n"),
WTERMSIG (status6)));
else
ACE_ERROR ((LM_ERROR,
ACE_TEXT ("(%P) child6 should have died on signal, ")
ACE_TEXT ("but didn't; exit status %d\n"),
WEXITSTATUS (status6)));
#else
ACE_DEBUG
((LM_DEBUG,
ACE_TEXT ("(%P) The process terminated with exit code %d\n"),
status6));
#endif /*ACE_WIN32*/
}
}
#ifdef ACE_HAS_THREADS
Process_Task task1 (argc > 0 ? argv[0] : ACE_TEXT ("Process_Manager_Test"), mgr, 3);
Process_Task task2 (argc > 0 ? argv[0] : ACE_TEXT ("Process_Manager_Test"), mgr, 2);
Process_Task task3 (argc > 0 ? argv[0] : ACE_TEXT ("Process_Manager_Test"), mgr, 1);
task1.open (0);
task2.open (0);
task3.open (0);
while (running_tasks!=0)
{
ACE_OS::sleep (1);
ACE_DEBUG ((LM_DEBUG, ACE_TEXT ("(%P) still running tasks\n")));
}
ACE_DEBUG ((LM_DEBUG,
ACE_TEXT ("(%P) result: '%C'\n"),
order.c_str ()));
if (order != "321123")
{
ACE_ERROR ((LM_ERROR,
ACE_TEXT ("(%P) wrong order of spawns ('%C', should be '321123')\n"),
order.c_str ()));
test_status = 1;
}
#endif /* ACE_HAS_THREADS */
#if !defined (ACE_OPENVMS) && \
(defined ACE_WIN32 || !defined ACE_LACKS_UNIX_SIGNALS)
// --------------------------------------------------
// Finally, try the reactor stuff...
mgr.open (ACE_Process_Manager::DEFAULT_SIZE,
ACE_Reactor::instance ());
pid_t child7 = spawn_child (argc > 0 ? argv[0] : ACE_TEXT ("Process_Manager_Test"),
mgr,
5,
7);
/* pid_t child8 = */ spawn_child (argc > 0 ? argv[0] : ACE_TEXT ("Process_Manager_Test"),
mgr,
6,
0);
mgr.register_handler (new Exit_Handler ("specific"),
child7);
ACE_Time_Value how_long (10);
ACE_Reactor::instance ()->run_reactor_event_loop (how_long);
ACE_DEBUG ((LM_DEBUG,
ACE_TEXT ("(%P) Reactor loop done!\n") ));
size_t const nr_procs = mgr.managed ();
if (nr_procs != 0)
ACE_ERROR ((LM_ERROR,
ACE_TEXT ("(%P) %d processes left in manager\n"),
nr_procs));
#endif /* !defined (ACE_OPENVMS) */
#endif // ACE_HAS_PROCESS_SPAWN
ACE_END_TEST;
return test_status;
}
