int
ACE_TMAIN(int argc, ACE_TCHAR *argv[])
{
try
{
CORBA::ORB_var orb =
CORBA::ORB_init (argc,
argv);
CORBA::Object_var poa_object =
orb->resolve_initial_references ("RootPOA");
PortableServer::POA_var root_poa =
PortableServer::POA::_narrow (poa_object.in ());
PortableServer::POAManager_var poa_manager =
root_poa->the_POAManager ();
poa_manager->activate ();
if (parse_args (argc, argv) != 0)
return -1;
test_i servant (orb.in ());
PortableServer::ObjectId_var id =
root_poa->activate_object (&servant);
CORBA::Object_var object = root_poa->id_to_reference (id.in ());
test_var server =
test::_narrow (object.in ());
CORBA::String_var ior =
orb->object_to_string (server.in ());
ACE_DEBUG ((LM_DEBUG, "Activated as <%C>\n", ior.in ()));
FILE *output_file = ACE_OS::fopen (ior_output_file, "w");
if (output_file == 0)
ACE_ERROR_RETURN ((LM_ERROR,
"Cannot open output file for writing IOR: %s",
ior_output_file),
-1);
ACE_OS::fprintf (output_file, "%s", ior.in ());
ACE_OS::fclose (output_file);
Event_Loop_Task event_loop_task (orb.in ());
if (event_loop_task.activate (THR_NEW_LWP | THR_JOINABLE,
number_of_event_loop_threads) != 0)
ACE_ERROR_RETURN ((LM_ERROR,
"Cannot activate event_loop threads\n"),
-1);
event_loop_task.thr_mgr ()->wait ();
ACE_DEBUG ((LM_DEBUG, "Server: Event loop finished\n"));
root_poa->destroy (1,
1);
}
catch (const CORBA::Exception& ex)
{
ex._tao_print_exception ("Exception caught:");
return -1;
}
return 0;
}
int
ACE_TMAIN (int argc, ACE_TCHAR *argv[])
{
try
{
CORBA::ORB_var orb = CORBA::ORB_init (argc, argv);
CORBA::Object_var poa_object =
orb->resolve_initial_references ("RootPOA");
if (CORBA::is_nil (poa_object.in ()))
ACE_ERROR_RETURN ((LM_ERROR,
" (%P|%t) Unable to initialize the POA.\n"),
1);
PortableServer::POA_var root_poa =
PortableServer::POA::_narrow (poa_object.in ());
PortableServer::POAManager_var poa_manager = root_poa->the_POAManager ();
// Policies for the childPOA to be created.
CORBA::PolicyList policies (1);
policies.length (1);
CORBA::Any pol;
pol <<= BiDirPolicy::BOTH;
policies[0] =
orb->create_policy (BiDirPolicy::BIDIRECTIONAL_POLICY_TYPE, pol);
// Create POA as child of RootPOA with the above policies. This POA
// will receive request in the same connection in which it sent
// the request
PortableServer::POA_var child_poa =
root_poa->create_POA ("childPOA", poa_manager.in (), policies);
// Creation of childPOA is over. Destroy the Policy objects.
for (CORBA::ULong i = 0; i < policies.length (); ++i)
{
policies[i]->destroy ();
}
poa_manager->activate ();
if (parse_args (argc, argv) != 0)
return 1;
CORBA::Object_var object = orb->string_to_object (ior);
Simple_Server_var server = Simple_Server::_narrow (object.in ());
if (CORBA::is_nil (server.in ()))
{
ACE_ERROR_RETURN ((LM_ERROR,
"Object reference <%C> is nil\n",
ior),
1);
}
Callback_i callback_impl (orb.in ());
PortableServer::ObjectId_var id =
PortableServer::string_to_ObjectId ("client_callback");
child_poa->activate_object_with_id (id.in (), &callback_impl);
CORBA::Object_var callback_object =
child_poa->id_to_reference (id.in ());
Callback_var callback = Callback::_narrow (callback_object.in ());
CORBA::String_var ior = orb->object_to_string (callback.in ());
ACE_DEBUG ((LM_DEBUG, "(%P|%t) Client callback activated as <%C>\n",
ior.in ()));
// Send the calback object to the server
server->callback_object (callback.in ());
int pre_call_connections =
orb->orb_core ()->lane_resources ().transport_cache ().current_size ();
// A method to kickstart callbacks from the server
CORBA::Long r = server->test_method (1);
if (r != 0)
{
ACE_DEBUG ((LM_DEBUG,
"(%P|%t) unexpected result = %d ",
r));
}
orb->run ();
int cur_connections =
orb->orb_core ()->lane_resources ().transport_cache ().current_size ();
if (cur_connections > pre_call_connections)
{
ACE_ERROR ((LM_ERROR,
"(%P|%t) Expected %d "
"connections in the transport cache, but found "
"%d instead. Aborting.\n",
pre_call_connections,
cur_connections));
ACE_OS::abort ();
}
root_poa->destroy (1, 1);
}
catch (CORBA::Exception &excep)
{
excep._tao_print_exception ("Caught exception:");
return 1;
}
return 0;
}
int
ACE_TMAIN(int argc, ACE_TCHAR *argv[])
{
ACE_DEBUG ((LM_DEBUG,
"Middle (%P|%t) started\n"));
try
{
CORBA::ORB_var orb =
CORBA::ORB_init (argc,
argv);
if ( ! parse_args (argc, argv))
{
return -1;
}
///////////////////////////////
// Prepare to be a CORBA server
CORBA::Object_var poa_object =
orb->resolve_initial_references ("RootPOA");
PortableServer::POA_var root_poa =
PortableServer::POA::_narrow (poa_object.in ());
PortableServer::POAManager_var poa_manager =
root_poa->the_POAManager ();
///////////////////////////////
// Prepare to be a CORBA client
FILE *input_file = ACE_OS::fopen (ior_input_file, "r");
if (input_file == 0)
{
ACE_ERROR_RETURN ((LM_ERROR,
"Cannot open input IOR file: %s",
ior_input_file),
-1);
}
ACE_OS::fread (input_ior, 1, sizeof(input_ior), input_file);
ACE_OS::fclose (input_file);
// Convert the IOR to an object reference.
CORBA::Object_var object =
orb->string_to_object (input_ior);
// narrow the object reference to a ThreeTier reference
ThreeTier_var target = ThreeTier::_narrow (object.in ());
if (CORBA::is_nil (target.in ()))
{
ACE_ERROR_RETURN ((LM_ERROR,
"IOR does not refer to a ThreeTier implementation"),
-1);
}
// We should have a good connection now
// temporary: check it out
//target->tick();
//target->tock();
Middle_i middle (orb.in(), target.in ());
if (middle.parse_args (argc, argv) )
{
/////////////////////////////////
// Activate server side mechanism
PortableServer::ObjectId_var id =
root_poa->activate_object (&middle);
CORBA::Object_var object = root_poa->id_to_reference (id.in ());
ThreeTier_var server =
ThreeTier::_narrow (object.in ());
CORBA::String_var ior =
orb->object_to_string (server.in ());
FILE *output_file = ACE_OS::fopen (ior_output_file, "w");
if (output_file == 0)
ACE_ERROR_RETURN ((LM_ERROR,
"Cannot open output file for writing IOR: %s",
ior_output_file),
-1);
ACE_OS::fprintf (output_file, "%s", ior.in ());
ACE_OS::fclose (output_file);
poa_manager->activate ();
orb->run ();
}
}
catch (const CORBA::UserException& userex)
{
userex._tao_print_exception ("Middle: User Exception in main");
return -1;
}
catch (const CORBA::SystemException& sysex)
{
sysex._tao_print_exception ("Middle: System Exception in main");
return -1;
}
ACE_DEBUG ((LM_DEBUG,
"Middle (%P|%t) exits\n"));
return 0;
}
int ACE_TMAIN (int argc, ACE_TCHAR* argv[])
{
try {
// Initialze the ORB.
CORBA::ORB_var orb = CORBA::ORB_init (argc, argv);
// Get a reference to the RootPOA.
CORBA::Object_var obj = orb->resolve_initial_references ("RootPOA");
// Get the POA_var object from Object_var.
PortableServer::POA_var root_poa =
PortableServer::POA::_narrow (obj.in ());
// Get the POAManager of the RootPOA.
PortableServer::POAManager_var poa_manager =
root_poa->the_POAManager ();
poa_manager->activate ();
// Policies for the childPOA to be created.
CORBA::PolicyList policies;
policies.length (2);
policies[0] =
root_poa->create_id_assignment_policy (PortableServer::USER_ID);
policies[1] =
root_poa->create_lifespan_policy (PortableServer::PERSISTENT);
// Create the childPOA under the RootPOA.
PortableServer::POA_var child_poa =
root_poa->create_POA ("childPOA",
poa_manager.in (),
policies);
// Destroy the policy objects
for (CORBA::ULong i = 0; i != policies.length (); ++i) {
policies[i]->destroy ();
}
// Create an instance of class Quoter_Stock_Factory_i.
Quoter_Stock_Factory_i stock_factory_i;
// Get the Object ID.
PortableServer::ObjectId_var oid =
PortableServer::string_to_ObjectId ("Stock_Factory");
// Activate the Stock_Factory object.
child_poa->activate_object_with_id (oid.in (),
&stock_factory_i);
// Get the object reference.
CORBA::Object_var stock_factory =
child_poa->id_to_reference (oid.in ());
CORBA::Object_var table_object =
orb->resolve_initial_references ("IORTable");
// Stringify all the object referencs.
CORBA::String_var ior = orb->object_to_string (stock_factory.in ());
IORTable::Table_var adapter =
IORTable::Table::_narrow (table_object.in ());
if (CORBA::is_nil (adapter.in ()))
{
ACE_ERROR ((LM_ERROR, "Nil IORTable\n"));
}
else
{
CORBA::String_var ior =
orb->object_to_string (stock_factory.in ());
adapter->bind ("childPOA", ior.in ());
}
orb->run ();
// Destroy POA, waiting until the destruction terminates.
root_poa->destroy (1, 1);
orb->destroy ();
}
catch (const CORBA::Exception &) {
cerr << "CORBA exception raised !" << endl;
}
return 0;
}
int
ACE_TMAIN(int argc, ACE_TCHAR *argv[])
{
try
{
CORBA::ORB_var orb =
CORBA::ORB_init (argc, argv);
CORBA::Object_var poa_object =
orb->resolve_initial_references ("RootPOA");
if (CORBA::is_nil (poa_object.in ()))
ACE_ERROR_RETURN ((LM_ERROR,
" (%P|%t) Unable to initialize the POA.\n"),
1);
PortableServer::POA_var root_poa =
PortableServer::POA::_narrow (poa_object.in ());
PortableServer::POAManager_var poa_manager =
root_poa->the_POAManager ();
// Policies for the childPOA to be created.
CORBA::PolicyList policies (1);
policies.length (1);
CORBA::Any pol;
pol <<= BiDirPolicy::BOTH;
policies[0] =
orb->create_policy (BiDirPolicy::BIDIRECTIONAL_POLICY_TYPE,
pol);
// Create POA as child of RootPOA with the above policies. This POA
// will receive request in the same connection in which it sent
// the request
PortableServer::POA_var child_poa =
root_poa->create_POA ("childPOA",
poa_manager.in (),
policies);
// Creation of childPOA is over. Destroy the Policy objects.
for (CORBA::ULong i = 0;
i < policies.length ();
++i)
{
policies[i]->destroy ();
}
poa_manager->activate ();
if (parse_args (argc, argv) != 0)
return 1;
Simple_Server_i server_impl (orb.in (),
no_iterations);
PortableServer::ObjectId_var id =
PortableServer::string_to_ObjectId ("simple_server");
child_poa->activate_object_with_id (id.in (),
&server_impl);
CORBA::Object_var obj =
child_poa->id_to_reference (id.in ());
CORBA::String_var ior =
orb->object_to_string (obj.in ());
ACE_DEBUG ((LM_DEBUG, "Activated as <%C>\n", ior.in ()));
// If the ior_output_file exists, output the ior to it
if (ior_output_file != 0)
{
FILE *output_file= ACE_OS::fopen (ior_output_file, "w");
if (output_file == 0)
ACE_ERROR_RETURN ((LM_ERROR,
"Cannot open output file for writing IOR: %s",
ior_output_file),
1);
ACE_OS::fprintf (output_file, "%s", ior.in ());
ACE_OS::fclose (output_file);
}
int retval = 0;
while (retval == 0)
{
// Just process one upcall. We know that we would get the
// clients IOR in that call.
CORBA::Boolean pending =
orb->work_pending();
if (pending)
{
orb->perform_work();
}
// Now that hopefully we have the clients IOR, just start
// making remote calls to the client.
retval = server_impl.call_client ();
}
ACE_DEBUG ((LM_DEBUG, "event loop finished\n"));
root_poa->destroy (1, 1);
}
catch (const CORBA::Exception& ex)
{
ex._tao_print_exception ("Caught exception:");
return 1;
}
return 0;
}
int ACE_TMAIN (int argc, ACE_TCHAR *argv[])
{
try {
// Initialize orb
CORBA::ORB_var orb = CORBA::ORB_init(argc, argv);
if (parse_args (argc, argv) != 0)
return 1;
//Get reference to Root POA
CORBA::Object_var obj = orb->resolve_initial_references("RootPOA");
PortableServer::POA_var poa = PortableServer::POA::_narrow(obj.in());
// Activate POA Manager
PortableServer::POAManager_var mgr = poa->the_POAManager();
mgr->activate();
// Find the Naming Service
obj = orb->resolve_initial_references("NameService");
CosNaming::NamingContextExt_var root =
CosNaming::NamingContextExt::_narrow(obj.in());
if (CORBA::is_nil(root.in())) {
std::cerr << "Nil Naming Context reference" << std::endl;
return 1;
}
// Bind a new context.
CosNaming::Name name;
name.length( 1 );
name[0].id = CORBA::string_dup( "root.esc-dot" );
name[0].kind = CORBA::string_dup( "kind1" );
try {
obj = root->resolve(name);
}
catch(const CosNaming::NamingContext::NotFound&) {
CosNaming::NamingContext_var dummy = root->bind_new_context(name);
}
name.length( 2 );
name[1].id = CORBA::string_dup( "leaf/esc-slash" );
name[1].kind = CORBA::string_dup( "kind2" );
// Create an object
PortableServer::Servant_var<Messenger_i> servant = new Messenger_i;
PortableServer::ObjectId_var oid = poa->activate_object(servant.in());
CORBA::Object_var messenger_obj = poa->id_to_reference(oid.in());
root->rebind(name, messenger_obj.in());
// Also try rebinding to a simple path.
CosNaming::Name_var simp_name = root->to_name("Simple");
try {
obj = root->resolve(simp_name.in());
}
catch(const CosNaming::NamingContext::NotFound&) {
CosNaming::NamingContext_var dummy =
root->bind_new_context(simp_name.in());
}
simp_name = root->to_name("Simple/Messenger");
root->rebind(simp_name.in(), messenger_obj.in());
// Convert Name to String Name.
CORBA::String_var str_name = root->to_string(name);
std::cout << "str_name: " << str_name.in() << std::endl;
CORBA::String_var str_simple = root->to_string(simp_name.in());
std::cout << "simple: " << str_simple.in() << std::endl;
// Convert String Name to Name.
CosNaming::Name_var tname = root->to_name(str_name.in());
std::cout << "converted back to a CosNaming::Name: " << std::endl;
std::cout << " name[0] = " << (* tname)[0].id.in() << " , "
<< (* tname)[0].kind.in() << std::endl;
std::cout << " name[1] = " << (* tname)[1].id.in() << " , "
<< (* tname)[1].kind.in() << std::endl;
// Find the application object by resolve_str.
try {
obj = root->resolve_str(str_name.in());
}
catch(const CosNaming::NamingContext::NotFound&) {
std::cerr<<"Couldn't resolve the string name: " << str_name << std::endl;
return 1;
}
ACE_CString base_address (":");
base_address += ACE_TEXT_ALWAYS_CHAR (hostname);
base_address += ":";
base_address += ACE_TEXT_ALWAYS_CHAR (port);
ACE_CString addr ("");
addr = base_address + "/key/str";
// Create an URL string for application object.
CORBA::String_var address = CORBA::string_dup (addr.c_str());
std::cout << "call to_url(\"" << address.in() << "\"" << std::endl;
std::cout << " ,\"" << str_simple.in() << "\")"<< std::endl;
CORBA::String_var url_string = root->to_url(address.in(), str_simple.in());
std::cout << "to_url result: " << url_string.in() << std::endl;
// Write NS url to a file to let client read NS URL to get
// NamingContext reference.
CORBA::String_var ns_addr = CORBA::string_dup(base_address.c_str());
std::cout << "call to_url(\"" <<ns_addr.in() << "\",\""
<< str_simple.in() << "\")"<< std::endl;
CORBA::String_var url = root->to_url(ns_addr.in(), str_simple.in());
std::cout << "to_url result: " << url.in() << std::endl;
std::ofstream iorFile(ACE_TEXT_ALWAYS_CHAR (ior_output_file));
iorFile << url.in() << std::endl;
iorFile.close();
std::cout << "Naming Service URL written to file " << ior_output_file << std::endl;
// Accept requests
orb->run();
orb->destroy();
}
catch(const CORBA::Exception& ex) {
std::cerr << "Caught a CORBA::Exception: " << ex << std::endl;
return 1;
}
return 0;
}
int
Server::svc (void)
{
ACE_hthread_t current;
ACE_Thread::self (current);
int native_priority;
ACE_Thread::getprio (current, native_priority);
ACE_DEBUG ((LM_DEBUG,
"Server orb thread (%t): corba_priority = %d"
" actual native priority = %d\n",
priority_,
native_priority));
try
{
char orb_name[64];
ACE_OS::sprintf (orb_name, "%d", this->priority_);
CORBA::ORB_var orb =
CORBA::ORB_init (argc_, argv_, orb_name);
CORBA::Object_var poa_object =
orb->resolve_initial_references("RootPOA");
if (CORBA::is_nil (poa_object.in ()))
ACE_ERROR_RETURN ((LM_ERROR,
" (%P|%t) Unable to initialize the POA.\n"),
1);
PortableServer::POA_var root_poa =
PortableServer::POA::_narrow (poa_object.in ());
PortableServer::POAManager_var poa_manager =
root_poa->the_POAManager ();
PortableServer::ObjectId_var oid =
root_poa->activate_object (this->server_);
CORBA::Object_var obj =
root_poa->id_to_reference (oid.in ());
CORBA::String_var ior =
orb->object_to_string (obj.in ());
ACE_DEBUG ((LM_DEBUG, "Activated as <%C>\n", ior.in ()));
// Get the file name to store the ior.
char file_name[100];
ACE_OS::sprintf (file_name,
"%s_%d",
ACE_TEXT_ALWAYS_CHAR (ior_output_file_base),
this->priority_);
// Output the ior to a file.
FILE *output_file= ACE_OS::fopen (file_name, "w");
if (output_file == 0)
ACE_ERROR_RETURN ((LM_ERROR,
"Cannot open output file for writing IOR: %s",
file_name),
1);
ACE_OS::fprintf (output_file, "%s", ior.in ());
ACE_OS::fclose (output_file);
// Start orb event loop.
poa_manager->activate ();
orb->run ();
}
catch (const CORBA::Exception& ex)
{
char message[100];
ACE_OS::sprintf (message,
"ORB_per_Priority::server: Exception in thread with priority = %d",
this->priority_);
ex._tao_print_exception (message);
}
return 0;
}
void
TAO_Offer_Iterator_Collection::destroy (void)
{
// Destroy all iterators in the collection.
for (Offer_Iters::ITERATOR iters_iter (this->iters_);
! iters_iter.done ();
iters_iter.advance ())
{
CosTrading::OfferIterator** iter = 0;
iters_iter.next (iter);
(*iter)->destroy ();
}
// Remove self from POA
PortableServer::POA_var poa =
this->_default_POA ();
PortableServer::ObjectId_var id =
poa->servant_to_id (this);
poa->deactivate_object (id.in ());
}
static CCS::Thermometer_ptr
make_dref (PortableServer::POA_ptr poa, CCS::AssetType anum)
{
// Convert asset number to OID.
ostrstream ostr;
ostr << anum << ends;
char * anum_str = ostr.str ();
PortableServer::ObjectId_var oid
= PortableServer::string_to_ObjectId (anum_str);
delete[] anum_str;
// Look at the model via the network to determine
// the repository ID.
char buf[32];
assert (ICP_get (anum, "model", buf, sizeof (buf)) == 0);
const char * rep_id = ACE_OS::strcmp (buf, "Sens-A-Temp") == 0
? "IDL:acme.com/CCS/Thermometer:1.0"
: "IDL:acme.com/CCS/Thermostat:1.0";
// Make a new reference.
CORBA::Object_var obj
= poa->create_reference_with_id (oid.in (), rep_id);
return CCS::Thermometer::_narrow (obj.in ());
}
void
test_i::deactivate_self (void)
{
PortableServer::POA_var poa = this->_default_POA ();
PortableServer::ObjectId_var id = poa->servant_to_id (this);
if (debug)
ACE_DEBUG ((LM_DEBUG, "(%t) Deactivating servant\n"));
poa->deactivate_object (id.in ());
if (debug)
ACE_DEBUG ((LM_DEBUG, "(%t) Deactivation complete: signaling main thread and going to sleep\n"));
int result = this->event_.signal ();
ACE_ASSERT (result == 0);
ACE_UNUSED_ARG (result);
ACE_OS::sleep (3);
if (debug)
ACE_DEBUG ((LM_DEBUG, "(%t) test_i::deactivate_self complete\n"));
}
int
ACE_TMAIN(int argc, ACE_TCHAR *argv[])
{
try
{
CORBA::ORB_var orb =
CORBA::ORB_init (argc, argv);
if (parse_args (argc, argv) != 0)
return 1;
CORBA::Object_var object =
orb->string_to_object (ior);
A::AMI_Test_var server = A::AMI_Test::_narrow (object.in ());
if (CORBA::is_nil (server.in ()))
{
ACE_ERROR_RETURN ((LM_ERROR,
"Object reference <%s> is nil.\n",
ior),
1);
}
// Activate POA to handle the call back.
CORBA::Object_var poa_object =
orb->resolve_initial_references("RootPOA");
if (CORBA::is_nil (poa_object.in ()))
ACE_ERROR_RETURN ((LM_ERROR,
" (%P|%t) Unable to initialize the POA.\n"),
1);
PortableServer::POA_var root_poa =
PortableServer::POA::_narrow (poa_object.in ());
PortableServer::POAManager_var poa_manager =
root_poa->the_POAManager ();
poa_manager->activate ();
// Let the client perform the test in a separate thread
Handler* handler = 0;
ACE_NEW_RETURN (handler,
Handler,
1);
PortableServer::ServantBase_var owner_transfer(handler);
PortableServer::ObjectId_var id =
root_poa->activate_object (handler);
CORBA::Object_var object2 = root_poa->id_to_reference (id.in ());
A::AMI_AMI_TestHandler_var hello = A::AMI_AMI_TestHandler::_narrow (object2.in ());
object2 = CORBA::Object::_nil ();
server->shutdown (); // oneway, so returns here immediately but server waits 5 sec
Client client (server.in (), niterations, hello.in ());
if (client.activate (THR_NEW_LWP | THR_JOINABLE,
nthreads) != 0)
ACE_ERROR_RETURN ((LM_ERROR,
"Cannot activate client threads\n"),
1);
// Main thread collects replies. It needs to collect
// <nthreads*niterations> replies.
number_of_replies = nthreads *niterations;
if (debug)
{
ACE_DEBUG ((LM_DEBUG,
"(%P|%t) : Entering perform_work loop to receive <%d> replies\n",
number_of_replies));
}
// ORB loop.
ACE_Time_Value tv (1,0);
orb->run (tv);
if (debug)
{
ACE_DEBUG ((LM_DEBUG,
"(%P|%t) : Exited perform_work loop Received <%d> replies\n",
(nthreads*niterations) - number_of_replies));
}
ACE_DEBUG ((LM_DEBUG, "threads finished\n"));
client.wait ();
tv = ACE_Time_Value (1,0);
orb->run (tv);
root_poa->deactivate_object (id.in ());
root_poa->destroy (1, // ethernalize objects
0); // wait for completion
hello = A::AMI_AMI_TestHandler::_nil ();
root_poa = PortableServer::POA::_nil ();
poa_object = CORBA::Object::_nil ();
object = CORBA::Object::_nil ();
server = A::AMI_Test::_nil ();
poa_manager = PortableServer::POAManager::_nil ();
client.clear ();
orb->shutdown ();
orb->destroy ();
CORBA::ULong ref_count = orb->_refcount();
if (ref_count > 1)
{
ACE_DEBUG ((LM_DEBUG, ACE_TEXT("Refcount orb %d\n"), ref_count));
++parameter_corruption;
}
else
{
TAO_ORB_Core* core = orb->orb_core ();
if (core != 0)
{
ACE_DEBUG ((LM_DEBUG, ACE_TEXT("Core <> null\n")));
++parameter_corruption;
}
}
orb = CORBA::ORB::_nil ();
}
catch (const CORBA::Exception& ex)
{
ex._tao_print_exception ("Caught exception:");
return 1;
}
return parameter_corruption;
}
int
ACE_TMAIN(int argc, ACE_TCHAR *argv[])
{
try
{
CORBA::ORB_var orb =
CORBA::ORB_init (argc, argv);
CORBA::Object_var object_var =
orb->resolve_initial_references ("RootPOA");
PortableServer::POA_var poa_var =
PortableServer::POA::_narrow (object_var.in ());
PortableServer::POAManager_var poa_manager_var =
poa_var->the_POAManager ();
poa_manager_var->activate ();
if (parse_args (argc, argv) != 0)
return 1;
// We reuse the object_var smart pointer!
CORBA::Object_var ior_object = orb->string_to_object (ior);
A::AMI_Test_var ami_test_var =
A::AMI_Test::_narrow (ior_object.in ());
if (CORBA::is_nil (ami_test_var.in ()))
{
ACE_ERROR_RETURN ((LM_ERROR,
"Object reference <%s> is nil.\n",
ior),
1);
}
// Instantiate the ReplyHandler and register that with the POA.
Handler handler;
PortableServer::ObjectId_var id =
poa_var->activate_object (&handler);
CORBA::Object_var object = poa_var->id_to_reference (id.in ());
A::AMI_AMI_TestHandler_var the_handler_var =
A::AMI_AMI_TestHandler::_narrow (object.in ());
CORBA::Long l = 931247;
A::Payload payload (payload_size);
payload.length (payload_size);
for (CORBA::ULong j = 0; j != payload_size; ++j)
{
payload[j] = j % 256;
}
for (ssize_t ni = 0; ni < niterations; ni++)
{
if (debug)
{
ACE_DEBUG ((LM_DEBUG,
"Sending asynch message: %d\n",
ni));
}
ami_test_var->sendc_foo (the_handler_var.in (),
l,
"Let's talk AMI.",
payload);
}
if (debug)
{
ACE_DEBUG ((LM_DEBUG,
"<%d> Asynchronous methods issued\n",
niterations));
}
if (debug)
{
ACE_DEBUG ((LM_DEBUG,
"Issuing a synchronous method to collect the AMI replies\n"));
}
CORBA::Long number = ami_test_var->foo (l,
l,
"Let's talk SMI.",
payload);
if (debug)
{
ACE_DEBUG ((LM_DEBUG,
"Received the following number: %d\n",
number));
}
if (shutdown_flag)
{
ami_test_var->shutdown ();
}
poa_var->destroy (1, // ethernalize objects
0 // wait for completion
);
orb->destroy ();
}
catch (const CORBA::Exception& ex)
{
ex._tao_print_exception ("Caught exception:");
return 1;
}
return 0;
}
int ACE_TMAIN (int argc, ACE_TCHAR *argv[])
{
CORBA::ORB_var orb;
try
{
orb = CORBA::ORB_init (argc, argv);
CORBA::Object_var root_poa_o =
orb->resolve_initial_references ("RootPOA");
PortableServer::POA_var rootPOA =
PortableServer::POA::_narrow (root_poa_o.in ());
if (CORBA::is_nil (rootPOA.in ()))
{
ACE_ERROR_RETURN ((LM_ERROR,
" (%P|%t) Panic: nil RootPOA\n"), 1);
}
PortableServer::POAManager_var poaMgr = rootPOA->the_POAManager ();
poaMgr->activate ();
CORBA::PolicyList policies;
policies.length (3);
policies[0] = rootPOA->create_id_assignment_policy (
PortableServer::SYSTEM_ID);
policies[1] = rootPOA->create_implicit_activation_policy (
PortableServer::NO_IMPLICIT_ACTIVATION);
policies[2] = rootPOA->create_lifespan_policy (
PortableServer::TRANSIENT);
PortableServer::POA_var fooPoa = rootPOA->create_POA (
"FOO_POA", poaMgr.in (), policies );
for (CORBA::ULong i = 0; i < policies.length (); ++i)
{
policies[i]->destroy ();
}
Foo_i servant;
PortableServer::ObjectId_var oid = fooPoa->activate_object( &servant );
CORBA::Object_var obj = fooPoa->id_to_reference (oid.in ());
foo_var client = foo::_narrow (obj.in());
client->check();
if (vc_check(client.in()))
{
orb->destroy();
return 1;
}
fooPoa->deactivate_object (oid.in () ); //servant is gone
if (vc_check(client.in(), false)) //exception expected
{
orb->destroy();
return 2;
}
}
catch(...)
{
return 3;
}
return 0;
}
void UAKGQueryBase::destroy() throw (CORBA::SystemException)
{
PortableServer::ObjectId_var oid = getPOA_()->servant_to_id(this);
getPOA_()->deactivate_object(oid.in());
}
int main (int argc, char* argv[])
{
try
{
// Initialize the ORB.
CORBA::ORB_var orb = CORBA::ORB_init(argc, argv);
// Find the Naming Service.
CORBA::Object_var obj = orb->resolve_initial_references("NameService");
CosNaming::NamingContextExt_var naming_client = CosNaming::NamingContextExt::_narrow(obj.in());
// Get the Event Channel using Naming Services
obj = naming_client->resolve_str("EventService");
// Downcast the object reference to an EventChannel reference.
RtecEventChannelAdmin::EventChannel_var ec =
RtecEventChannelAdmin::EventChannel::_narrow(obj.in());
if (CORBA::is_nil(ec.in())) {
cerr << "Could not resolve EchoEventChannel." << endl;
return 1;
}
// Get a SupplierAdmin object from the EventChannel.
RtecEventChannelAdmin::SupplierAdmin_var admin = ec->for_suppliers();
// Get a ProxyPushConsumer from the SupplierAdmin.
RtecEventChannelAdmin::ProxyPushConsumer_var consumer =
admin->obtain_push_consumer();
// Get the RootPOA.
obj = orb->resolve_initial_references("RootPOA");
PortableServer::POA_var poa = PortableServer::POA::_narrow(obj.in());
// Instantiate an EchoEventConsumer_i servant.
EchoEventSupplier_i servant(orb.in());
// Register it with the RootPOA.
PortableServer::ObjectId_var oid = poa->activate_object(&servant);
CORBA::Object_var supplier_obj = poa->id_to_reference(oid.in());
RtecEventComm::PushSupplier_var supplier =
RtecEventComm::PushSupplier::_narrow(supplier_obj.in());
// Publish the events the supplier provides.
ACE_SupplierQOS_Factory qos;
qos.insert (MY_SOURCE_ID, // Supplier's unique id
MY_EVENT_TYPE, // Event type
0, // handle to the rt_info structure
1); // number of calls
// Connect as a supplier of the published events.
consumer->connect_push_supplier (supplier.in (),
qos.get_SupplierQOS ());
// Activate the POA via its POAManager.
PortableServer::POAManager_var poa_manager = poa->the_POAManager();
poa_manager->activate();
// Create an event (just a string in this case).
const CORBA::String_var eventData = CORBA::string_dup("Hello, world.");
// Create an event set for one event
RtecEventComm::EventSet events (1);
events.length (1);
// Initialize event header.
events[0].header.source = MY_SOURCE_ID;
events[0].header.type = MY_EVENT_TYPE;
// Initialize data fields in event.
events[0].data.any_value <<= eventData;
cout << "Supplier starting sending of events" << endl;
while (1) {
consumer->push (events);
ACE_Time_Value tv(0, 1000 * EVENT_DELAY_MS);
orb->run(tv);
}
orb->destroy();
return 0;
}
catch (CORBA::Exception& ex)
{
cerr << "Supplier::main() Caught CORBA::Exception" << endl << ex << endl;
}
return 1;
}
int
ACE_TMAIN (int argc, ACE_TCHAR *argv[])
{
try
{
CORBA::ORB_var orb = CORBA::ORB_init (argc, argv);
if (parse_args (argc, argv) != 0)
ACE_ERROR_RETURN ((LM_ERROR,
ACE_TEXT ("ERROR: wrong arguments\n")),
-1);
CORBA::Object_var poa_object =
orb->resolve_initial_references("RootPOA");
PortableGroup::GOA_var root_goa =
PortableGroup::GOA::_narrow (poa_object.in ());
if (CORBA::is_nil (root_goa.in ()))
ACE_ERROR_RETURN ((LM_ERROR,
ACE_TEXT ("ERROR: nil RootPOA\n")),
-1);
PortableServer::POAManager_var poa_manager = root_goa->the_POAManager ();
// Create UIPMC reference.
CORBA::Object_var obj = orb->string_to_object (uipmc_url);
// Create id.
PortableServer::ObjectId_var id =
root_goa->create_id_for_reference (obj.in ());
// Activate UIPMC Object.
UIPMC_Object_Impl* uipmc_impl;
ACE_NEW_RETURN (uipmc_impl,
UIPMC_Object_Impl (orb.in (), threads),
-1);
PortableServer::ServantBase_var owner_transfer1 (uipmc_impl);
root_goa->activate_object_with_id (id.in (), uipmc_impl);
Test::UIPMC_Object_var uipmc_obj =
Test::UIPMC_Object::_unchecked_narrow (obj.in ());
if (CORBA::is_nil (uipmc_obj.in ()))
ACE_ERROR_RETURN ((LM_ERROR,
ACE_TEXT ("ERROR: nil Hello object\n")),
-1);
CORBA::String_var ior = orb->object_to_string (obj.in ());
ACE_DEBUG ((LM_DEBUG, ACE_TEXT ("MIOP object is <%C>\n"), ior.in ()));
//obj = hello_impl->_this ();
// If the ior_output_file exists, output the ior to it.
if (ior_output_file != 0)
{
FILE *output_file= ACE_OS::fopen (ior_output_file, "w");
if (output_file == 0)
{
ACE_ERROR_RETURN ((LM_ERROR,
ACE_TEXT ("Cannot open output file ")
ACE_TEXT ("for writing IOR: %s"),
ior_output_file),
-1);
}
ACE_OS::fprintf (output_file, "%s", ior.in ());
ACE_OS::fclose (output_file);
}
poa_manager->activate ();
{
ACE_DEBUG ((LM_DEBUG, ACE_TEXT ("Starting %u thread, thread pool\n"), (unsigned) threads));
// start server thread pool
OrbThread orb_thr (orb.in ());
orb_thr.activate (THR_NEW_LWP | THR_JOINABLE, threads);
orb_thr.wait ();
ACE_DEBUG ((LM_DEBUG, ACE_TEXT ("Stopping thread pool\n")));
}
root_goa->destroy (1, 1);
orb->destroy ();
}
catch (const CORBA::Exception& ex)
{
ex._tao_print_exception ("Exception caught in server main ():");
return -1;
}
ACE_DEBUG ((LM_DEBUG,
ACE_TEXT ("\nServer finished successfully.\n")));
return 0;
}
int
ACE_TMAIN(int argc, ACE_TCHAR *argv[])
{
try
{
CORBA::ORB_var orb =
CORBA::ORB_init (argc, argv);
CORBA::Object_var poa_object =
orb->resolve_initial_references("RootPOA");
PortableServer::POA_var root_poa =
PortableServer::POA::_narrow (poa_object.in ());
if (CORBA::is_nil (root_poa.in ()))
ACE_ERROR_RETURN ((LM_ERROR,
" (%P|%t) Panic: nil RootPOA\n"),
1);
PortableServer::POAManager_var poa_manager =
root_poa->the_POAManager ();
if (parse_args (argc, argv) != 0)
return 1;
CORBA::Object_var tmp =
orb->string_to_object(ior);
Test::Oneway_Buffering_Admin_var admin =
Test::Oneway_Buffering_Admin::_narrow(tmp.in ());
if (CORBA::is_nil (admin.in ()))
{
ACE_ERROR_RETURN ((LM_DEBUG,
"Nil Oneway_Buffering_Admin reference <%s>\n",
ior),
1);
}
Oneway_Buffering *oneway_buffering_impl;
ACE_NEW_RETURN (oneway_buffering_impl,
Oneway_Buffering (orb.in (),
admin.in ()),
1);
PortableServer::ServantBase_var owner_transfer(oneway_buffering_impl);
PortableServer::ObjectId_var id =
root_poa->activate_object (oneway_buffering_impl);
CORBA::Object_var object = root_poa->id_to_reference (id.in ());
Test::Oneway_Buffering_var oneway_buffering =
Test::Oneway_Buffering::_narrow (object.in ());
CORBA::String_var ior =
orb->object_to_string (oneway_buffering.in ());
// If the ior_output_file exists, output the ior to it
FILE *output_file= ACE_OS::fopen (ior_output_file, "w");
if (output_file == 0)
ACE_ERROR_RETURN ((LM_ERROR,
"Cannot open output file for writing IOR: %s",
ior_output_file),
1);
ACE_OS::fprintf (output_file, "%s", ior.in ());
ACE_OS::fclose (output_file);
poa_manager->activate ();
orb->run ();
ACE_DEBUG ((LM_DEBUG, "(%P|%t) server - event loop finished\n"));
root_poa->destroy (1, 1);
orb->destroy ();
}
catch (const CORBA::Exception& ex)
{
ex._tao_print_exception ("Exception caught in server:");
return 1;
}
return 0;
}
int
ACE_TMAIN(int argc, ACE_TCHAR *argv[])
{
try
{
CORBA::ORB_var orb =
CORBA::ORB_init (argc, argv);
if (argc < 2)
{
// Paranoia, we should have an auto_ptr-like gadget for
// this.
orb->destroy ();
ACE_ERROR_RETURN ((LM_ERROR,
"Usage: %s <ior>\n",
argv[0]), 1);
}
CORBA::Object_var object =
orb->string_to_object (argv[1]);
Test::Startup_Callback_var startup_callback =
Test::Startup_Callback::_narrow (object.in ());
if (CORBA::is_nil (startup_callback.in ()))
{
ACE_ERROR_RETURN ((LM_ERROR,
"ERROR: nil startup callback\n"),
1);
}
CORBA::Object_var poa_object =
orb->resolve_initial_references("RootPOA");
PortableServer::POA_var root_poa =
PortableServer::POA::_narrow (poa_object.in ());
if (CORBA::is_nil (root_poa.in ()))
ACE_ERROR_RETURN ((LM_ERROR,
" (%P|%t) Panic: nil RootPOA\n"),
1);
PortableServer::POAManager_var poa_manager =
root_poa->the_POAManager ();
Process *process_impl = 0;
ACE_NEW_RETURN (process_impl,
Process (orb.in ()),
1);
PortableServer::ServantBase_var owner_transfer(process_impl);
PortableServer::ObjectId_var id =
root_poa->activate_object (process_impl);
CORBA::Object_var object_act = root_poa->id_to_reference (id.in ());
Test::Process_var process =
Test::Process::_narrow (object_act.in ());
poa_manager->activate ();
startup_callback->started (process.in ());
ACE_Time_Value tv (50, 0);
orb->run (tv);
root_poa->destroy (1, 1);
orb->destroy ();
}
catch (const CORBA::Exception&)
{
// Do not print error messages, they only make the test output
// confusing.
return 1;
}
return 0;
}
void
PubDriver::initialize(int& argc, char *argv[])
{
::DDS::DomainParticipantFactory_var dpf = TheParticipantFactoryWithArgs(argc, argv);
// Activate the PubDriver servant and write its ior to a file.
PortableServer::POA_var poa = TheServiceParticipant->the_poa ();
CORBA::ORB_var orb = TheServiceParticipant->get_ORB ();
PortableServer::ObjectId_var id = poa->activate_object(this);
CORBA::Object_var object = poa->id_to_reference(id.in());
CORBA::String_var ior_string = orb->object_to_string (object.in ());
//
// Write the IOR to a file.
//
FILE *output_file= ACE_OS::fopen (pub_driver_ior_.c_str (), "w");
if (output_file == 0)
{
ACE_ERROR ((LM_ERROR,
ACE_TEXT("Cannot open output file for writing IOR\n")));
}
ACE_OS::fprintf (output_file, "%s", ior_string.in ());
ACE_OS::fclose (output_file);
::DDS::ReturnCode_t ret = ::DDS::RETCODE_OK;
::Xyz::FooTypeSupport_var fts (new ::Xyz::FooTypeSupportImpl);
participant_ =
dpf->create_participant(MY_DOMAIN,
PARTICIPANT_QOS_DEFAULT,
::DDS::DomainParticipantListener::_nil());
TEST_CHECK (! CORBA::is_nil (participant_.in ()));
if (::DDS::RETCODE_OK != fts->register_type(participant_.in (), MY_TYPE))
{
ACE_ERROR ((LM_ERROR,
ACE_TEXT ("Failed to register the FooTypeSupport.")));
}
::DDS::TopicQos default_topic_qos;
participant_->get_default_topic_qos(default_topic_qos);
::DDS::TopicQos new_topic_qos = default_topic_qos;
new_topic_qos.reliability.kind = ::DDS::RELIABLE_RELIABILITY_QOS;
//The SunOS compiler had problem resolving operator in a namespace.
//To resolve the compilation errors, the operator is called explicitly.
TEST_CHECK (! (new_topic_qos == default_topic_qos));
participant_->set_default_topic_qos(new_topic_qos);
topic_ = participant_->create_topic (MY_TOPIC,
MY_TYPE,
TOPIC_QOS_DEFAULT,
::DDS::TopicListener::_nil());
TEST_CHECK (! CORBA::is_nil (topic_.in ()));
publisher_ =
participant_->create_publisher(PUBLISHER_QOS_DEFAULT,
::DDS::PublisherListener::_nil());
TEST_CHECK (! CORBA::is_nil (publisher_.in ()));
publisher_servant_
= dynamic_cast<OpenDDS::DCPS::PublisherImpl*>
(publisher_.in ());
attach_to_transport ();
::DDS::PublisherQos pub_qos_got;
publisher_->get_qos (pub_qos_got);
::DDS::PublisherQos default_pub_qos;
participant_->get_default_publisher_qos (default_pub_qos);
TEST_CHECK (pub_qos_got == default_pub_qos);
::DDS::PublisherQos new_pub_qos = pub_qos_got;
// This qos is not supported, so it's invalid qos.
new_pub_qos.presentation.access_scope = ::DDS::GROUP_PRESENTATION_QOS;
TEST_CHECK (! (new_pub_qos == default_pub_qos));
ret = publisher_->set_qos (new_pub_qos);
TEST_CHECK (ret == ::DDS::RETCODE_INCONSISTENT_POLICY);
::DDS::DomainParticipant_var participant
= publisher_->get_participant ();
TEST_CHECK (participant.in () == participant_.in ());
::DDS::DataWriterQos default_dw_qos;
publisher_->get_default_datawriter_qos (default_dw_qos);
::DDS::DataWriterQos new_default_dw_qos = default_dw_qos;
new_default_dw_qos.reliability.kind = ::DDS::RELIABLE_RELIABILITY_QOS;
TEST_CHECK (! (new_default_dw_qos == default_dw_qos));
TEST_CHECK (publisher_->set_default_datawriter_qos (new_default_dw_qos)
== ::DDS::RETCODE_OK);
// Create datawriter to test copy_from_topic_qos.
datawriter_
= publisher_->create_datawriter(topic_.in (),
DATAWRITER_QOS_USE_TOPIC_QOS,
::DDS::DataWriterListener::_nil());
TEST_CHECK (! CORBA::is_nil (datawriter_.in ()));
::DDS::DataWriterQos dw_qos_use_topic_qos;
datawriter_->get_qos (dw_qos_use_topic_qos);
::DDS::DataWriterQos copied_from_topic = default_dw_qos;
ret = publisher_->copy_from_topic_qos (copied_from_topic, new_topic_qos);
TEST_CHECK (ret == ::DDS::RETCODE_OK);
TEST_CHECK (dw_qos_use_topic_qos == copied_from_topic);
// Delete the datawriter.
publisher_->delete_datawriter (datawriter_.in ());
// Create datawriter to test DATAWRITER_QOS_DEFAULT/get_publisher
// get_qos/set_qos/get_default_datawriter_qos.
datawriter_
= publisher_->create_datawriter(topic_.in (),
DATAWRITER_QOS_DEFAULT,
::DDS::DataWriterListener::_nil());
TEST_CHECK (! CORBA::is_nil (datawriter_.in ()));
::DDS::Topic_var topic_got
= datawriter_->get_topic ();
// the topics should point to the same servant
// but not the same Object Reference.
TopicImpl* topic_got_servant
= dynamic_cast<TopicImpl*> (topic_got.in ());
TopicImpl* topic_servant
= dynamic_cast<TopicImpl*> (topic_.in ());
TEST_CHECK (topic_got_servant == topic_servant);
::DDS::Publisher_var pub_got
= datawriter_->get_publisher ();
TEST_CHECK (pub_got.in () == publisher_.in ());
::DDS::DataWriterQos dw_qos_got;
datawriter_->get_qos (dw_qos_got);
TEST_CHECK (dw_qos_got == new_default_dw_qos);
::DDS::DataWriterQos new_dw_qos = dw_qos_got;
new_dw_qos.reliability.kind = ::DDS::RELIABLE_RELIABILITY_QOS;
new_dw_qos.resource_limits.max_samples_per_instance = 2;
new_dw_qos.history.kind = ::DDS::KEEP_ALL_HISTORY_QOS;
TEST_CHECK (! (dw_qos_got == new_dw_qos));
ret = datawriter_->set_qos (new_dw_qos);
TEST_CHECK (ret == ::DDS::RETCODE_IMMUTABLE_POLICY);
// Delete the datawriter.
publisher_->delete_datawriter (datawriter_.in ());
// Create datawriter to test register/unregister/dispose and etc.
::DDS::DataWriterQos dw_qos;
publisher_->get_default_datawriter_qos (dw_qos);
dw_qos.history.depth = history_depth_;
if (test_to_run_ == LIVELINESS_TEST)
{
dw_qos.liveliness.lease_duration.sec = lease_duration_sec;
dw_qos.liveliness.lease_duration.nanosec = 0;
}
datawriter_
= publisher_->create_datawriter(topic_.in (),
dw_qos,
::DDS::DataWriterListener::_nil());
TEST_CHECK (! CORBA::is_nil (datawriter_.in ()));
datawriter_servant_
= dynamic_cast<OpenDDS::DCPS::DataWriterImpl*> (datawriter_.in ());
foo_datawriter_
= ::Xyz::FooDataWriter::_narrow(datawriter_.in ());
TEST_CHECK (! CORBA::is_nil (foo_datawriter_.in ()));
foo_datawriter_servant_
= dynamic_cast<Xyz::FooDataWriterImpl*>
(foo_datawriter_.in ());
TEST_CHECK (foo_datawriter_servant_ != 0);
}
int
ACE_TMAIN(int argc, ACE_TCHAR *argv[])
{
try
{
// Create the ORB initializer.
Server_ORBInitializer *temp_initializer = 0;
ACE_NEW_RETURN (temp_initializer,
Server_ORBInitializer,
-1);
PortableInterceptor::ORBInitializer_var initializer =
temp_initializer;
PortableInterceptor::register_orb_initializer (initializer.in ());
// Now initialize the ORB.
CORBA::ORB_var orb = CORBA::ORB_init (argc, argv,
"Remote_Server_ORB");
CORBA::Object_var poa_object =
orb->resolve_initial_references ("RootPOA");
if (CORBA::is_nil (poa_object.in ()))
{
ACE_ERROR_RETURN ((LM_ERROR,
" (%P|%t) Unable to initialize the POA.\n" ),
1);
}
PortableServer::POA_var root_poa =
PortableServer::POA::_narrow (poa_object.in ());
PortableServer::POAManager_var poa_manager =
root_poa->the_POAManager ();
poa_manager->activate ();
if (parse_args (argc, argv) != 0)
{
return 1;
}
// Create the interceptor.
Echo_Server_Request_Interceptor * server_interceptor =
temp_initializer->server_interceptor();
if (server_interceptor == 0)
{
ACE_ERROR_RETURN ((LM_ERROR,
"(%P|%t) Could not obtain reference to "
"server request interceptor.\n"),
-1);
}
// Pull in the ior from the remote server to use as the forward location.
CORBA::Object_var forward_location = orb->string_to_object (ior_input_file);
if (CORBA::is_nil (forward_location.in ()))
{
ACE_ERROR_RETURN ((LM_ERROR,
"Object reference <%s> is nil\n",
ior_input_file),
1);
}
server_interceptor->forward_reference (forward_location.in ());
Bug1495_i server_impl (orb.in ());
PortableServer::ObjectId_var id =
root_poa->activate_object (&server_impl);
CORBA::Object_var test_obj =
root_poa->id_to_reference (id.in ());
Bug1495_Regression::Bug1495_var server =
Bug1495_Regression::Bug1495::_narrow (test_obj.in ());
CORBA::String_var ior =
orb->object_to_string (server.in ());
// Output the server IOR to a file
if (ior_output_file != 0)
{
FILE *output_file = ACE_OS::fopen (ior_output_file, "w");
if (output_file == 0)
{
ACE_ERROR_RETURN ((LM_ERROR,
"Cannot open output file for writing the "
"server IOR: %s", ior_output_file),
1);
}
ACE_OS::fprintf (output_file, "%s", ior.in ());
ACE_OS::fclose (output_file);
}
ACE_Time_Value tv (15, 0);
orb->run (tv);
if (server_interceptor->forward_location_done() == false)
{
ACE_ERROR ((LM_ERROR, "ERROR: Forward location has not occurred!\n"));
}
ACE_DEBUG ((LM_DEBUG, "Threaded Server event loop finished\n"));
root_poa->destroy (1, 1);
orb->destroy ();
}
catch (const CORBA::Exception& ex)
{
ex._tao_print_exception ("Caught an exception in server:");
return 1;
}
ACE_DEBUG ((LM_DEBUG, "Threaded Server ready\n"));
return 0;
}
int
ACE_TMAIN(int argc, ACE_TCHAR *argv[])
{
try
{
CORBA::ORB_var orb =
CORBA::ORB_init (argc,
argv);
CORBA::Object_var poa_object =
orb->resolve_initial_references ("RootPOA");
if (CORBA::is_nil (poa_object.in ()))
{
ACE_ERROR_RETURN ((LM_ERROR,
" (%P|%t) Unable to initialize the POA.\n"),
1);
}
PortableServer::POA_var root_poa =
PortableServer::POA::_narrow (poa_object.in ());
PortableServer::POAManager_var poa_manager =
root_poa->the_POAManager ();
if (parse_args (argc, argv) != 0)
return 1;
test_i servant (orb.in ());
PortableServer::ObjectId_var id =
root_poa->activate_object (&servant);
CORBA::Object_var object = root_poa->id_to_reference (id.in ());
test_var server =
test::_narrow (object.in ());
CORBA::String_var ior =
orb->object_to_string (server.in ());
ACE_DEBUG ((LM_DEBUG,
"Activated as <%C>\n",
ior.in ()));
// If the ior_output_file exists, output the ior to it
if (ior_output_file != 0)
{
FILE *output_file= ACE_OS::fopen (ior_output_file, "w");
if (output_file == 0)
{
ACE_ERROR_RETURN ((LM_ERROR,
"Can't open output file for writing IOR: %s",
ior_output_file),
1);
}
ACE_OS::fprintf (output_file,
"%s",
ior.in ());
ACE_OS::fclose (output_file);
}
poa_manager->activate ();
orb->run ();
root_poa->destroy (1, 1);
}
catch (const CORBA::Exception& ex)
{
ex._tao_print_exception ("Server: exception caught - ");
return 1;
}
return 0;
}
int
ACE_TMAIN(int argc, ACE_TCHAR *argv[])
{
try
{
CORBA::ORB_var orb =
CORBA::ORB_init (argc, argv);
CORBA::Object_var poa_object =
orb->resolve_initial_references ("RootPOA");
if (CORBA::is_nil (poa_object.in ()))
ACE_ERROR_RETURN ((LM_ERROR,
" (%P|%t) Unable to initialize the POA.\n"),
1);
PortableServer::POA_var root_poa =
PortableServer::POA::_narrow (poa_object.in ());
PortableServer::POAManager_var poa_manager =
root_poa->the_POAManager ();
if (parse_args (argc, argv) != 0)
return 1;
Simple_Server_i *server_impl = 0;
ACE_NEW_RETURN (server_impl,
Simple_Server_i (orb.in ()),
-1);
PortableServer::ServantBase_var owner_transfer(server_impl);
PortableServer::ObjectId_var id =
root_poa->activate_object (server_impl);
CORBA::Object_var object = root_poa->id_to_reference (id.in ());
Simple_Server_var server =
Simple_Server::_narrow (object.in ());
CORBA::String_var ior =
orb->object_to_string (server.in ());
ACE_DEBUG ((LM_DEBUG, "Activated as <%C>\n", ior.in ()));
// If the ior_output_file exists, output the ior to it
if (ior_output_file != 0)
{
FILE *output_file= ACE_OS::fopen (ior_output_file, "w");
if (output_file == 0)
ACE_ERROR_RETURN ((LM_ERROR,
"(%P|%t) Cannot open output file for writing IOR: %s",
ior_output_file),
1);
ACE_OS::fprintf (output_file, "%s", ior.in ());
ACE_OS::fclose (output_file);
}
poa_manager->activate ();
Worker worker (orb.in ());
if (worker.activate (THR_NEW_LWP | THR_JOINABLE,
nthreads) != 0)
ACE_ERROR_RETURN ((LM_ERROR,
"(%P|%t) Cannot activate client threads\n"),
1);
SelfClient selfabuse (orb.in(), server.in(), niterations);
if (selfabuse.activate (THR_NEW_LWP | THR_JOINABLE,
nclient_threads) != 0)
ACE_ERROR_RETURN ((LM_ERROR,
"(%P|%t) Cannot activate abusive threads\n"),
1);
selfabuse.thr_mgr()->wait();
worker.thr_mgr ()->wait ();
ACE_DEBUG ((LM_DEBUG,
"(%P|%t) event loop finished\n"));
}
catch (const CORBA::Exception& ex)
{
ex._tao_print_exception ("Exception caught:");
return 1;
}
return 0;
}
int
ACE_TMAIN(int argc, ACE_TCHAR *argv[])
{
try
{
CORBA::ORB_var orb =
CORBA::ORB_init (argc, argv);
CORBA::Object_var poa_object =
orb->resolve_initial_references("RootPOA");
PortableServer::POA_var root_poa =
PortableServer::POA::_narrow (poa_object.in ());
if (CORBA::is_nil (root_poa.in ()))
ACE_ERROR_RETURN ((LM_ERROR,
" (%P|%t) Panic: nil RootPOA\n"),
1);
PortableServer::POAManager_var poa_manager =
root_poa->the_POAManager ();
if (parse_args (argc, argv) != 0)
return 1;
Process_Factory *process_factory_impl = 0;
ACE_NEW_RETURN (process_factory_impl,
Process_Factory (orb.in ()),
1);
PortableServer::ServantBase_var owner_transfer(process_factory_impl);
PortableServer::ObjectId_var id =
root_poa->activate_object (process_factory_impl);
CORBA::Object_var object = root_poa->id_to_reference (id.in ());
Test::Process_Factory_var process =
Test::Process_Factory::_narrow (object.in ());
CORBA::String_var ior =
orb->object_to_string (process.in ());
// If the ior_output_file exists, output the ior to it
FILE *output_file= ACE_OS::fopen (ior_output_file, "w");
if (output_file == 0)
ACE_ERROR_RETURN ((LM_ERROR,
"Cannot open output file for writing IOR: %s",
ior_output_file),
1);
ACE_OS::fprintf (output_file, "%s", ior.in ());
ACE_OS::fclose (output_file);
poa_manager->activate ();
Server_Task server_task (orb.in (),
ACE_Thread_Manager::instance ());
if (server_task.activate (THR_NEW_LWP | THR_JOINABLE, 8, 1) == -1)
{
ACE_ERROR ((LM_ERROR, "Error activating server task\n"));
}
ACE_Thread_Manager::instance ()->wait ();
ACE_DEBUG ((LM_DEBUG, "(%P|%t) server - event loop finished\n"));
root_poa->destroy (1, 1);
orb->destroy ();
}
catch (const CORBA::Exception& ex)
{
ex._tao_print_exception ("Exception caught:");
return 1;
}
return 0;
}
int
ACE_TMAIN(int argc, ACE_TCHAR *argv[])
{
try
{
#if TAO_HAS_INTERCEPTORS == 1
Server_ORBInitializer *temp_initializer = 0;
ACE_NEW_RETURN (temp_initializer,
Server_ORBInitializer,
-1); // No exceptions yet!
PortableInterceptor::ORBInitializer_var orb_initializer =
temp_initializer;
PortableInterceptor::register_orb_initializer (orb_initializer.in ());
#endif /* TAO_HAS_INTERCEPTORS == 1 */
CORBA::ORB_var orb =
CORBA::ORB_init (argc, argv, "Server ORB");
CORBA::Object_var poa_object =
orb->resolve_initial_references ("RootPOA");
if (CORBA::is_nil (poa_object.in ()))
ACE_ERROR_RETURN ((LM_ERROR,
" (%P|%t) Unable to initialize the POA.\n"),
1);
PortableServer::POA_var root_poa =
PortableServer::POA::_narrow (poa_object.in ());
PortableServer::POAManager_var poa_manager =
root_poa->the_POAManager ();
if (::parse_args (argc, argv) != 0)
return -1;
test_i *test_impl;
ACE_NEW_RETURN (test_impl, test_i (number, orb.in ()), 1);
PortableServer::ServantBase_var owner_transfer (test_impl);
PortableServer::ObjectId_var id =
root_poa->activate_object (test_impl);
CORBA::Object_var object = root_poa->id_to_reference (id.in ());
RedirectionTest::test_var test =
RedirectionTest::test::_narrow (object.in ());
CORBA::String_var ior =
orb->object_to_string (test.in ());
FILE *output_file= ACE_OS::fopen (ior_file, "w");
if (output_file == 0)
ACE_ERROR_RETURN ((LM_ERROR,
"Cannot open output file <%s> for writing "
"IOR: %C\n",
ior_file, ior.in ()),
1);
ACE_OS::fprintf (output_file, "%s", ior.in ());
ACE_OS::fclose (output_file);
if (server_number == 2)
ACE_OS::exit (1);
poa_manager->activate ();
// Run the ORB event loop.
orb->run ();
root_poa->destroy (1, 1);
orb->destroy ();
ACE_DEBUG ((LM_DEBUG, "Event loop finished.\n"));
}
catch (const CORBA::Exception& ex)
{
ex._tao_print_exception ("Caught exception:");
return -1;
}
return 0;
}
int
ACE_TMAIN(int argc, ACE_TCHAR *argv[])
{
try
{
CORBA::ORB_var orb =
CORBA::ORB_init (argc, argv);
CORBA::Object_var poa_object =
orb->resolve_initial_references("RootPOA");
PortableServer::POA_var root_poa =
PortableServer::POA::_narrow (poa_object.in ());
if (CORBA::is_nil (root_poa.in ()))
ACE_ERROR_RETURN ((LM_ERROR,
" (%P|%t) Panic: nil RootPOA\n"),
1);
PortableServer::POAManager_var poa_manager =
root_poa->the_POAManager ();
if (parse_args (argc, argv) != 0)
return 1;
Hello *hello_impl;
ACE_NEW_RETURN (hello_impl,
Hello (orb.in ()),
1);
PortableServer::ServantBase_var owner_transfer(hello_impl);
PortableServer::ObjectId_var id =
root_poa->activate_object (hello_impl);
CORBA::Object_var object = root_poa->id_to_reference (id.in ());
Test::Hello_var hello =
Test::Hello::_narrow (object.in ());
CORBA::String_var ior =
orb->object_to_string (hello.in ());
// Output the IOR to the <ior_output_file>
FILE *output_file= ACE_OS::fopen (ior_output_file, "w");
if (output_file == 0)
ACE_ERROR_RETURN ((LM_ERROR,
"Cannot open output file for writing IOR: %s",
ior_output_file),
1);
ACE_OS::fprintf (output_file, "%s", ior.in ());
ACE_OS::fclose (output_file);
poa_manager->activate ();
orb->run ();
ACE_DEBUG ((LM_DEBUG, "(%P|%t) server - event loop finished\n"));
root_poa->destroy (1, 1);
orb->destroy ();
}
catch (const CORBA::Exception& ex)
{
ex._tao_print_exception ("Exception caught:");
return 1;
}
return 0;
}
int ACE_TMAIN (int argc, ACE_TCHAR *argv[])
{
try
{
// Initialize the EC Factory so we can customize the EC
TAO_EC_Default_Factory::init_svcs ();
// Initialize the ORB.
CORBA::ORB_var orb = CORBA::ORB_init(argc, argv);
const ACE_TCHAR* ecname = ACE_TEXT ("EventService");
const ACE_TCHAR* remote_ecname = 0;
const ACE_TCHAR* iorfile = 0;
for (int i = 0; argv[i] != 0; i++) {
if (ACE_OS::strcmp(argv[i], ACE_TEXT("-ecname")) == 0) {
if (argv[i+1] != 0) {
i++;
ecname = argv[i];
} else {
std::cerr << "Missing Event channel name" << std::endl;
}
}
if (ACE_OS::strcmp(argv[i], ACE_TEXT("-gateway")) == 0) {
if (argv[i+1] != 0) {
i++;
remote_ecname = argv[i];
} else {
std::cerr << "Missing Event channel name" << std::endl;
}
}
if (ACE_OS::strcmp(argv[i], ACE_TEXT("-iorfile")) == 0) {
if (argv[i+1] != 0) {
i++;
iorfile = argv[i];
}
}
}
// Get the POA
CORBA::Object_var object = orb->resolve_initial_references ("RootPOA");
PortableServer::POA_var poa = PortableServer::POA::_narrow (object.in ());
PortableServer::POAManager_var poa_manager = poa->the_POAManager ();
poa_manager->activate ();
// Spawn a thread for the orb
ACE_Thread_Manager *thread_mgr = ACE_Thread_Manager::instance();
thread_mgr->spawn(orb_thread, orb.in());
// Create a local event channel and register it with the RootPOA.
TAO_EC_Event_Channel_Attributes attributes (poa.in (), poa.in ());
PortableServer::Servant_var<TAO_EC_Event_Channel> ec_impl =
new TAO_EC_Event_Channel(attributes);
ec_impl->activate ();
PortableServer::ObjectId_var oid = poa->activate_object(ec_impl.in());
CORBA::Object_var ec_obj = poa->id_to_reference(oid.in());
RtecEventChannelAdmin::EventChannel_var ec =
RtecEventChannelAdmin::EventChannel::_narrow(ec_obj.in());
// Find the Naming Service.
object = orb->resolve_initial_references("NameService");
CosNaming::NamingContextExt_var root_context = CosNaming::NamingContextExt::_narrow(object.in());
CosNaming::Name_var name = root_context->to_name (ACE_TEXT_ALWAYS_CHAR (ecname));
root_context->rebind(name.in(), ec.in());
// Get a SupplierAdmin object from the EventChannel.
RtecEventChannelAdmin::SupplierAdmin_var admin = ec->for_suppliers();
// Get a ProxyPushConsumer from the SupplierAdmin.
RtecEventChannelAdmin::ProxyPushConsumer_var consumer =
admin->obtain_push_consumer();
// Instantiate an EchoEventSupplier_i servant.
PortableServer::Servant_var<EchoEventSupplier_i> servant =
new EchoEventSupplier_i(orb.in());
// Register it with the RootPOA.
oid = poa->activate_object(servant.in());
CORBA::Object_var supplier_obj = poa->id_to_reference(oid.in());
RtecEventComm::PushSupplier_var supplier =
RtecEventComm::PushSupplier::_narrow(supplier_obj.in());
// Publish the events the supplier provides.
ACE_SupplierQOS_Factory qos;
qos.insert (MY_SOURCE_ID, // Supplier's unique id
MY_EVENT_TYPE, // Event type
0, // handle to the rt_info structure
1); // number of calls
// Connect as a supplier of the published events.
consumer->connect_push_supplier (supplier.in (),
qos.get_SupplierQOS ());
// Create an event (just a string in this case).
const CORBA::String_var eventData = CORBA::string_dup (ACE_TEXT_ALWAYS_CHAR (ecname));
// Create an event set for one event
RtecEventComm::EventSet event (1);
event.length (1);
// Initialize event header.
event[0].header.source = MY_SOURCE_ID;
event[0].header.ttl = 1;
event[0].header.type = MY_EVENT_TYPE;
// Initialize data fields in event.
event[0].data.any_value <<= eventData;
PortableServer::Servant_var<TAO_EC_Gateway_IIOP> gateway =
new TAO_EC_Gateway_IIOP;
int gateway_initialized = 0;
std::cout << "Supplier starting sending of events.\n";
while (1) {
consumer->push (event);
ACE_Time_Value tv(0, 1000 * EVENT_DELAY_MS);
orb->run(tv);
if ((remote_ecname != 0) && (!gateway_initialized)) {
try {
// Get the remote event channel object
CORBA::Object_var obj = root_context->resolve_str (ACE_TEXT_ALWAYS_CHAR (remote_ecname));
RtecEventChannelAdmin::EventChannel_var remote_ec =
RtecEventChannelAdmin::EventChannel::_narrow(obj.in());
int ok = 0;
if (!CORBA::is_nil(remote_ec.in())) {
// Now check if we can talk to it...
try {
RtecEventChannelAdmin::SupplierAdmin_var adm =
remote_ec->for_suppliers();
ok = 1;
} catch(const CORBA::UserException&) {
// What is the correct exception(s) to catch here?
}
}
// There is a good remote event channel so initialize the
// gateway.
if (ok) {
gateway->init(remote_ec.in(), ec.in());
PortableServer::ObjectId_var gateway_oid =
poa->activate_object(gateway.in());
CORBA::Object_var gateway_obj =
poa->id_to_reference(gateway_oid.in());
RtecEventChannelAdmin::Observer_var obs =
RtecEventChannelAdmin::Observer::_narrow(gateway_obj.in());
RtecEventChannelAdmin::Observer_Handle local_ec_obs_handle =
ec->append_observer (obs.in ());
ACE_UNUSED_ARG (local_ec_obs_handle);
gateway_initialized = 1;
std::cout << "Gateway initialized\n";
if (iorfile != 0) {
CORBA::String_var str = orb->object_to_string( ec.in() );
std::ofstream iorFile( ACE_TEXT_ALWAYS_CHAR(iorfile) );
iorFile << str.in() << std::endl;
iorFile.close();
}
}
} catch(const CosNaming::NamingContext::NotFound&) {
// Try again later...
}
}
}
orb->destroy();
return 0;
}
catch(const CORBA::Exception& exc)
{
std::cerr << "Caught CORBA::Exception" << std::endl << exc << std::endl;
}
return 1;
}
int
ImR_Activator_i::init_with_orb (CORBA::ORB_ptr orb, const Activator_Options& opts)
{
ACE_ASSERT(! CORBA::is_nil (orb));
orb_ = CORBA::ORB::_duplicate (orb);
debug_ = opts.debug ();
notify_imr_ = opts.notify_imr ();
induce_delay_ = opts.induce_delay ();
env_buf_len_ = opts.env_buf_len ();
max_env_vars_ = opts.max_env_vars ();
if (opts.name ().length () > 0)
{
name_ = opts.name();
}
try
{
CORBA::Object_var obj = orb->resolve_initial_references ("RootPOA");
ACE_ASSERT (! CORBA::is_nil (obj.in ()));
this->root_poa_ = PortableServer::POA::_narrow (obj.in ());
ACE_ASSERT (! CORBA::is_nil(this->root_poa_.in ()));
// The activator must use a persistent POA so that it can be started before the
// locator in some scenarios, such as when the locator persists its database, and
// wants to reconnect to running activators to auto_start some servers.
this->imr_poa_ = createPersistentPOA (this->root_poa_.in (),
"ImR_Activator");
ACE_ASSERT (! CORBA::is_nil(this->imr_poa_.in ()));
// Activate ourself
PortableServer::ObjectId_var id = PortableServer::string_to_ObjectId ("ImR_Activator");
this->imr_poa_->activate_object_with_id (id.in (), this);
obj = this->imr_poa_->id_to_reference (id.in ());
ImplementationRepository::ActivatorExt_var activator =
ImplementationRepository::ActivatorExt::_narrow (obj.in ());
ACE_ASSERT(! CORBA::is_nil (activator.in ()));
CORBA::String_var ior = this->orb_->object_to_string (activator.in ());
if (this->debug_ > 0)
ORBSVCS_DEBUG((LM_DEBUG, "ImR Activator: Starting %s\n", name_.c_str ()));
// initialize our process manager.
// This requires a reactor that has signal handling.
ACE_Reactor *reactor = ACE_Reactor::instance ();
if (reactor != 0)
{
if (this->process_mgr_.open (ACE_Process_Manager::DEFAULT_SIZE, reactor) == -1)
{
ORBSVCS_ERROR_RETURN ((LM_ERROR,
"The ACE_Process_Manager didnt get initialized\n"), -1);
}
}
this->register_with_imr (activator.in ()); // no throw
PortableServer::POAManager_var poaman =
this->root_poa_->the_POAManager ();
poaman->activate ();
if (this->debug_ > 1)
{
ORBSVCS_DEBUG ((LM_DEBUG,
"ImR Activator: The Activator IOR is: <%s>\n", ior.in ()));
}
// The last thing we do is write out the ior so that a test program can assume
// that the activator is ready to go as soon as the ior is written.
if (opts.ior_filename ().length () > 0)
{
FILE* fp = ACE_OS::fopen (opts.ior_filename ().c_str (), "w");
if (fp == 0)
{
ORBSVCS_ERROR_RETURN ((LM_ERROR,
"ImR Activator: Could not open file: %s\n", opts.ior_filename ().c_str ()), -1);
}
ACE_OS::fprintf (fp, "%s", ior.in ());
ACE_OS::fclose (fp);
}
}
catch (const CORBA::Exception& ex)
{
ex._tao_print_exception (
"ImR_Activator_i::init_with_orb");
throw;
}
return 0;
}
int
ACE_TMAIN (int argc, ACE_TCHAR *argv[])
{
try
{
CORBA::ORB_var orb =
CORBA::ORB_init (argc, argv);
CORBA::Object_var obj =
orb->resolve_initial_references ("RootPOA");
PortableServer::POA_var root_poa =
PortableServer::POA::_narrow (obj.in ());
PortableServer::POAManager_var poa_manager =
root_poa->the_POAManager ();
poa_manager->activate ();
CORBA::PolicyList policies;
CORBA::ULong current_length = 0;
policies.length (current_length + 1);
policies[current_length++] =
root_poa->create_request_processing_policy (PortableServer::USE_SERVANT_MANAGER);
PortableServer::POA_var child_poa =
root_poa->create_POA ("child",
poa_manager.in (),
policies);
Servant_Activator servant_activator (child_poa.in ());
child_poa->set_servant_manager (&servant_activator);
CORBA::Object_var first_object =
child_poa->create_reference ("IDL:test:1.0");
test_var first_test =
test::_narrow (first_object.in ());
PortableServer::ObjectId_var id =
child_poa->reference_to_id (first_object.in ());
ACE_Thread_Manager thread_manager;
Object_Activator object_activator (thread_manager,
child_poa.in ());
global_object_activator =
&object_activator;
first_test->method ();
child_poa->deactivate_object (id.in ());
// Wait for the Object_Activator thread to exit.
thread_manager.wait ();
root_poa->destroy (1,
1);
orb->destroy ();
}
catch (const CORBA::Exception& ex)
{
ex._tao_print_exception ("Exception caught");
return -1;
}
return 0;
}
int
ACE_TMAIN(int argc, ACE_TCHAR *argv[])
{
try
{
CORBA::ORB_var orb = CORBA::ORB_init (argc,
argv);
if (parse_args (argc, argv) != 0)
return 1;
Test_i servant (orb.in ());
// Obtain RootPOA.
CORBA::Object_var object =
orb->resolve_initial_references ("RootPOA");
PortableServer::POA_var root_poa =
PortableServer::POA::_narrow (object.in ());
// Get the POAManager of the RootPOA.
PortableServer::POAManager_var poa_manager =
root_poa->the_POAManager ();
PortableServer::ObjectId_var id =
root_poa->activate_object (&servant);
CORBA::Object_var object_act = root_poa->id_to_reference (id.in ());
Test_var Test_object =
Test::_narrow (object_act.in ());
CORBA::String_var ior =
orb->object_to_string (Test_object.in ());
// If the ior_output_file exists, output the ior to it
if (ior_output_file != 0)
{
FILE *output_file =
ACE_OS::fopen (ior_output_file, "w");
if (output_file == 0)
ACE_ERROR_RETURN ((LM_ERROR,
"Cannot open output file for writing IOR: %s",
ior_output_file),
1);
ACE_OS::fprintf (output_file,
"%s",
ior.in ());
ACE_OS::fclose (output_file);
}
poa_manager->activate ();
orb->run ();
ACE_DEBUG ((LM_DEBUG,
"event loop finished\n"));
root_poa->destroy (true, true);
orb->destroy ();
}
catch (const CORBA::Exception& ex)
{
ex._tao_print_exception ("Exception in setting up server");
ACE_ASSERT (0);
}
return 0;
}
Test::Process_ptr
Process_Factory::create_new_process (void)
{
Startup_Callback *startup_callback_impl;
ACE_NEW_THROW_EX (startup_callback_impl,
Startup_Callback,
CORBA::NO_MEMORY ());
PortableServer::ServantBase_var owner_transfer(startup_callback_impl);
CORBA::Object_var poa_object =
this->orb_->resolve_initial_references("RootPOA");
PortableServer::POA_var root_poa =
PortableServer::POA::_narrow (poa_object.in ());
PortableServer::ObjectId_var id =
root_poa->activate_object (startup_callback_impl);
CORBA::Object_var object = root_poa->id_to_reference (id.in ());
Test::Startup_Callback_var startup_callback =
Test::Startup_Callback::_narrow (object.in ());
CORBA::String_var ior =
this->orb_->object_to_string (startup_callback.in ());
const ACE_TCHAR* argv[3] = {
ACE_TEXT("child"),
ACE_TEXT_CHAR_TO_TCHAR(ior.in ()),
0};
ACE_Process_Options options;
#if !defined(ACE_WIN32)
options.avoid_zombies (1);
#endif /* ACE_WIN32 */
options.command_line (argv);
ACE_Process child_process;
pid_t pid =
child_process.spawn (options);
if (pid == -1)
{
ACE_DEBUG ((LM_DEBUG,
"(%P|%t) Process_Factory::create_new_process, "
" spawn call failed (%d)\n",
ACE_ERRNO_GET));
throw Test::Spawn_Failed ();
}
int process_has_started = 0;
Test::Process_var the_process;
for (int i = 0; i != 500 && !process_has_started; ++i)
{
ACE_Time_Value interval (0, 10000);
this->orb_->perform_work (interval);
process_has_started =
startup_callback_impl->process_has_started (the_process.out ());
}
try
{
PortableServer::POA_var poa =
startup_callback_impl->_default_POA ();
PortableServer::ObjectId_var id =
poa->servant_to_id (startup_callback_impl);
poa->deactivate_object (id.in ());
}
catch (const CORBA::Exception&)
{
}
if (process_has_started == 0)
{
ACE_DEBUG ((LM_DEBUG,
"(%P|%t) Process_Factory::create_new_process, "
" timeout while waiting for child\n"));
(void) child_process.terminate ();
throw Test::Spawn_Failed ();
}
return the_process._retn ();
}