int ACE_TMAIN (int argc, ACE_TCHAR *argv[])
{
try {
// Initialize the ORB.
CORBA::ORB_var orb = CORBA::ORB_init(argc, argv);
// Create a MessengerServer object.
MessengerServer * server = new MessengerServer (orb.in());
ACE_Auto_Ptr<MessengerServer> safe_ptr (server);
// Parse arguments to determine how we should shutdown.
if (server->parse_args (argc, argv) != 0)
return 1;
//Get reference to the RootPOA.
CORBA::Object_var obj = orb->resolve_initial_references( "RootPOA" );
PortableServer::POA_var poa = PortableServer::POA::_narrow( obj.in() );
// Activate the POAManager.
PortableServer::POAManager_var mgr = poa->the_POAManager();
mgr->activate();
// Create a servant.
Messenger_i messenger_servant (orb.in());
// Register the servant with the RootPOA, obtain its object
// reference, stringify it, and write it to a file.
PortableServer::ObjectId_var oid =
poa->activate_object( &messenger_servant );
CORBA::Object_var messenger_obj = poa->id_to_reference( oid.in() );
CORBA::String_var str = orb->object_to_string( messenger_obj.in() );
std::ofstream iorFile(ACE_TEXT_ALWAYS_CHAR (ior_output_file.c_str ()));
iorFile << str.in() << std::endl;
iorFile.close();
std::cout << "IOR written to file " <<
ACE_TEXT_ALWAYS_CHAR (ior_output_file.c_str ()) << std::endl;
switch (s_method)
{
// shutdown on client invocation
case MessengerServer::s_client_call:
std::cout << "Will shutdown on client invocation." << std::endl;
server->run ();
break;
// shutdown after some iterations through loop
case MessengerServer::s_polling_loop:
server->poll (loop_iterations);
break;
// schedule a timer to shutdown
case MessengerServer::s_timer:
server->schedule_shutdown_timer (timeout);
server->run ();
break;
// shutdown on console input
case MessengerServer::s_console_input:
server->shutdown_on_console_input ();
server->run ();
break;
// use CORBA::ORB::run() with time value
case MessengerServer::s_run_time_value:
server->run (timeout);
break;
}
}
catch(const CORBA::Exception& ex) {
std::cerr << "CORBA exception: " << ex << std::endl;
return 1;
}
return 0;
}
pid_t
ACE_OS::fork_exec (ACE_TCHAR *argv[])
{
# if defined (ACE_WIN32)
ACE_TCHAR *buf = 0;
ACE_Auto_Basic_Array_Ptr<ACE_TCHAR> safe_ptr (buf);
if (ACE_OS::argv_to_string (argv, buf) != -1)
{
PROCESS_INFORMATION process_info;
# if !defined (ACE_HAS_WINCE)
ACE_TEXT_STARTUPINFO startup_info;
ACE_OS::memset ((void *) &startup_info,
0,
sizeof startup_info);
startup_info.cb = sizeof startup_info;
if (ACE_TEXT_CreateProcess (0,
buf,
0, // No process attributes.
0, // No thread attributes.
TRUE, // Allow handle inheritance.
0, // Don't create a new console window.
0, // No environment.
0, // No current directory.
&startup_info,
&process_info))
# else
if (ACE_TEXT_CreateProcess (0,
buf,
0, // No process attributes.
0, // No thread attributes.
FALSE, // Can's inherit handles on CE
0, // Don't create a new console window.
0, // No environment.
0, // No current directory.
0, // Can't use startup info on CE
&process_info))
# endif /* ! ACE_HAS_WINCE */
{
// Free resources allocated in kernel.
ACE_OS::close (process_info.hThread);
ACE_OS::close (process_info.hProcess);
// Return new process id.
return process_info.dwProcessId;
}
}
// CreateProcess failed.
return -1;
# else
pid_t const result = ACE_OS::fork ();
# if defined (ACE_USES_WCHAR)
// Wide-char builds need to convert the command-line args to
// narrow char strings for execv ().
char **cargv = 0;
int arg_count;
# endif /* ACE_HAS_WCHAR */
switch (result)
{
case -1:
// Error.
return -1;
case 0:
// Child process.
# if defined (ACE_USES_WCHAR)
for (arg_count = 0; argv[arg_count] != 0; ++arg_count)
;
++arg_count; // Need a 0-pointer end-of-array marker
ACE_NEW_NORETURN (cargv, char*[arg_count]);
if (cargv == 0)
ACE_OS::exit (errno);
--arg_count; // Back to 0-indexed
cargv[arg_count] = 0;
while (--arg_count >= 0)
cargv[arg_count] = ACE_Wide_To_Ascii::convert (argv[arg_count]);
// Don't worry about freeing the cargv or the strings it points to.
// Either the process will be replaced, or we'll exit.
if (ACE_OS::execv (cargv[0], cargv) == -1)
ACE_OS::exit (errno);
# else
if (ACE_OS::execv (argv[0], argv) == -1)
{
// The OS layer should not print stuff out
// ACE_ERROR ((LM_ERROR,
// "%p Exec failed\n"));
// If the execv fails, this child needs to exit.
ACE_OS::exit (errno);
}
# endif /* ACE_HAS_WCHAR */
default:
// Server process. The fork succeeded.
return result;
}
# endif /* ACE_WIN32 */
}
