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
{
// Initialize the ORB
CORBA::ORB_var orb = CORBA::ORB_init (argc, argv);
// Get the POA from the ORB.
CORBA::Object_var poa_obj = orb->resolve_initial_references ("RootPOA");
// Narrow to the POA interface
PortableServer::POA_var root_poa = PortableServer::POA::_narrow (poa_obj.in ());
// Create a Stock Quoter implementation object
Stock_Quoter_i* stock_quoter = new Stock_Quoter_i (orb.in ());
UDPTest_i* UDP = new UDPTest_i ();
// Activate the Stock Quoter in the RootPOA.
PortableServer::ObjectId_var oid = root_poa->activate_object (stock_quoter);
CORBA::Object_var sq_obj = root_poa->id_to_reference (oid.in());
PortableServer::ObjectId_var oid1 = root_poa->activate_object (UDP);
CORBA::Object_var udp_obj1 = root_poa->id_to_reference (oid1.in());
CORBA::String_var ior =
orb->object_to_string (udp_obj1.in ());
ACE_DEBUG ((LM_DEBUG, "Activated as <%C>\n", ior.in ()));
// Also make the Stock Quoter object available via corbaloc
// ObjectURL by binding it to a simple ObjectKey in the IORTable.
CORBA::Object_var table_obj = orb->resolve_initial_references ("IORTable");
IORTable::Table_var table = IORTable::Table::_narrow (table_obj.in());
CORBA::String_var quoter_ior_string = orb->object_to_string (sq_obj.in());
CORBA::String_var UDP_ior_string = orb->object_to_string (udp_obj1.in());
table->bind ("UDPTest", UDP_ior_string.in());
table->bind ("MyStockQuoter", quoter_ior_string.in());
// Activate the POA Manager
PortableServer::POAManager_var poa_mgr = root_poa->the_POAManager ();
poa_mgr->activate ();
cout << "Server ready" << endl;
orb->run ();
if (!UDP->received_send_)
{
ACE_ERROR_RETURN ((LM_ERROR, "Not received send\n"), 1);
}
}
catch (const CORBA::Exception& e)
{
e._tao_print_exception ("Exception caught:");
return 1;
}
return 0;
}
// Add the ObjectID:IOR mapping to the IOR table of
// the ORB. Ignore this method if you are not testing for
// the InterOperable Naming Service.
template <class Servant> int
Server<Servant>::test_for_ins (const char *ior)
{
CORBA::ORB_var orb = this->orb_manager_.orb ();
if (TAO_debug_level > 0)
ACE_DEBUG ((LM_DEBUG,
ACE_TEXT ("Adding (KEY:IOR) %s:%C\n"),
this->ins_,
ior));
try
{
CORBA::Object_var table_object =
orb->resolve_initial_references ("IORTable");
IORTable::Table_var adapter =
IORTable::Table::_narrow (table_object.in ());
if (CORBA::is_nil (adapter.in ()))
{
ACE_ERROR_RETURN ((LM_ERROR,
ACE_TEXT ("Nil IORTable\n")),
-1);
}
adapter->bind (ACE_TEXT_ALWAYS_CHAR (this->ins_), ior);
}
catch (const CORBA::Exception& ex)
{
ex._tao_print_exception ("ERROR: test_for_ins failed\n");
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 obj = orb->resolve_initial_references("RootPOA");
PortableServer::POA_var root_poa = PortableServer::POA::_narrow(obj.in());
PortableServer::POAManager_var mgr = root_poa->the_POAManager();
const char* poa_name = "TestService";
PortableServer::POA_var test_poa = createPOA(root_poa.in(), poa_name);
Terminator terminator;
if (terminator.open (0) == -1)
ACE_ERROR_RETURN((LM_ERROR,
ACE_TEXT ("main Error opening terminator\n")),-1);
PortableServer::Servant_var<Test_i> test_servant =
new Test_i(terminator);
PortableServer::ObjectId_var object_id =
PortableServer::string_to_ObjectId("test_object");
test_poa->activate_object_with_id(object_id.in(), test_servant.in());
TAO_Root_POA* tpoa = dynamic_cast<TAO_Root_POA*>(test_poa.in());
obj = tpoa->id_to_reference_i(object_id.in(), false);
CORBA::String_var test_ior = orb->object_to_string(obj.in());
obj = orb->resolve_initial_references("IORTable");
IORTable::Table_var table = IORTable::Table::_narrow(obj.in());
table->bind(poa_name, test_ior.in());
mgr->activate();
std::cout << "Test server ready." << std::endl;
orb->run();
std::cout << "Test server shutting down." << std::endl;
root_poa->destroy(1,1);
orb->destroy();
ACE_Message_Block *mb;
ACE_NEW_RETURN(mb, ACE_Message_Block(0, ACE_Message_Block::MB_HANGUP), -1);
terminator.putq(mb);
terminator.wait();
}
catch(const CORBA::Exception& ex) {
std::cerr << "Server main() Caught CORBA::Exception" << ex << std::endl;
return 1;
}
return 0;
}
int
ACE_TMAIN (int argc, ACE_TCHAR *argv[])
{
int ec = 0;
try {
CORBA::ORB_var orb = CORBA::ORB_init(argc, argv);
int max_run = 0;
int server_num = 0;
int init_delay_secs = 0;
const ACE_TCHAR *ior_file_name = ACE_TEXT ("");
ACE_Get_Opt get_opts (argc, argv, ACE_TEXT ("d:m:n:o:?"));
int c;
while ((c = get_opts ()) != -1)
switch (c)
{
case 'd':
init_delay_secs = ACE_OS::atoi (get_opts.opt_arg ());
break;
case 'm':
max_run = ACE_OS::atoi (get_opts.opt_arg ());
break;
case 'n':
server_num = ACE_OS::atoi (get_opts.opt_arg ());
break;
case 'o':
ior_file_name = get_opts.opt_arg ();
break;
case '?':
ACE_DEBUG ((LM_DEBUG,
ACE_TEXT ("usage: %s ")
ACE_TEXT ("-d <seconds to delay before initializing POA> ")
ACE_TEXT ("-n Number of the server\n"),
argv[0]));
return 1;
break;
}
ACE_OS::sleep (init_delay_secs);
CORBA::Object_var obj = orb->resolve_initial_references("RootPOA");
PortableServer::POA_var root_poa = PortableServer::POA::_narrow(obj.in());
PortableServer::POAManager_var mgr = root_poa->the_POAManager();
ACE_CString poa_name = ACE_CString("TestObject_") + toStr (server_num);
PortableServer::POA_var test_poa = createPOA(root_poa.in(), poa_name.c_str ());
Test_i *impl = new Test_i(orb.in());
PortableServer::Servant_var<Test_i> test_servant = impl;
PortableServer::ObjectId_var object_id =
PortableServer::string_to_ObjectId("test_object");
//
// Activate the servant with the test POA,
// obtain its object reference, and get a
// stringified IOR.
//
test_poa->activate_object_with_id(object_id.in(), test_servant.in());
//
// Create binding between "TestService" and
// the test object reference in the IOR Table.
// Use a TAO extension to get the non imrified poa
// to avoid forwarding requests back to the ImR.
TAO_Root_POA* tpoa = dynamic_cast<TAO_Root_POA*>(test_poa.in());
obj = tpoa->id_to_reference_i(object_id.in(), false);
CORBA::String_var test_ior = orb->object_to_string(obj.in());
obj = orb->resolve_initial_references("IORTable");
IORTable::Table_var table = IORTable::Table::_narrow(obj.in());
table->bind(poa_name.c_str (), test_ior.in());
if (ACE_OS::strlen (ior_file_name) > 0)
{
obj = test_poa->id_to_reference (object_id.in ());
test_ior = orb->object_to_string (obj.in ());
FILE *f = ACE_OS::fopen (ior_file_name, ACE_TEXT ("w"));
ACE_OS::fprintf (f, "%s", test_ior.in ());
ACE_OS::fclose (f);
}
//
// This server is now ready to run.
// This version does not create an IOR
// file as demonstrated in the
// Developer's Guide. It assumes that
// users create IORs for the client using
// the tao_imr utility.
//
//
// Stop discarding requests.
//
mgr->activate();
ACE_DEBUG ((LM_DEBUG,
ACE_TEXT ("Started Server <%C> pid = %d\n"),
poa_name.c_str(), ACE_OS::getpid ()));
ACE_CString pid_file = "server.pid";
{
ofstream out(pid_file.c_str (), ios_base::app);
out << ACE_OS::getpid () << endl;
out.close ();
}
ACE_DEBUG ((LM_DEBUG,
ACE_TEXT ("Server <%C> pid = %d closed pidfile\n"),
poa_name.c_str(), ACE_OS::getpid ()));
if (max_run > 0)
{
ACE_Time_Value tv (max_run,0);
orb->run (tv);
}
else
{
orb->run ();
}
ec = impl->exit_code ();
root_poa->destroy(1,1);
orb->destroy();
// ACE_OS::unlink (pid_file.c_str ());
}
catch(const CORBA::Exception& ex) {
ex._tao_print_exception (ACE_TEXT ("Server main()"));
return 1;
}
return ec;
}
int
Airplane_Server_i::init (int argc, ACE_TCHAR** argv)
{
try
{
// Initialize the ORB
this->orb_ = CORBA::ORB_init (argc, argv);
// Save pointers to the command line arguments
this->argc_ = argc;
this->argv_ = argv;
// Now check the arguments for our options
int retval = this->parse_args ();
if (retval != 0)
return retval;
// Get the POA from the ORB.
CORBA::Object_var obj =
this->orb_->resolve_initial_references ("RootPOA");
ACE_ASSERT(! CORBA::is_nil (obj.in ()));
// Narrow the object to a POA.
root_poa_ = PortableServer::POA::_narrow (obj.in ());
// Get the POA_Manager.
this->poa_manager_ = this->root_poa_->the_POAManager ();
// We now need to create a POA with the persistent and user_id policies,
// since they are need for use with the Implementation Repository.
CORBA::PolicyList policies (2);
policies.length (2);
policies[0] =
this->root_poa_->create_id_assignment_policy (PortableServer::USER_ID);
policies[1] =
this->root_poa_->create_lifespan_policy (PortableServer::PERSISTENT);
// Since the Implementation Repository keys off of the POA name, we need
// to use the server_name_ as the POA's name.
this->airplane_poa_ =
this->root_poa_->create_POA (this->server_name_.c_str(),
this->poa_manager_.in (),
policies);
// Creation of the new POA is over, so destroy the Policy_ptr's.
for (CORBA::ULong i = 0; i < policies.length (); ++i)
{
CORBA::Policy_ptr policy = policies[i];
policy->destroy ();
}
ACE_NEW_RETURN (this->server_impl_, Airplane_i, -1);
PortableServer::ObjectId_var server_id =
PortableServer::string_to_ObjectId ("server");
this->airplane_poa_->activate_object_with_id (server_id.in (),
this->server_impl_);
obj = this->airplane_poa_->id_to_reference (server_id.in ());
CORBA::String_var ior =
this->orb_->object_to_string (obj.in ());
if (TAO_debug_level > 0)
ACE_DEBUG ((LM_DEBUG, "The ImRified IOR is: <%C>\n", ior.in ()));
TAO_Root_POA* tmp_poa = dynamic_cast<TAO_Root_POA*>(airplane_poa_.in());
obj = tmp_poa->id_to_reference_i (server_id.in (), false);
CORBA::String_var plain_ior =
this->orb_->object_to_string (obj.in ());
if (TAO_debug_level > 0)
ACE_DEBUG ((LM_DEBUG, "The plain IOR is: <%C>\n", plain_ior.in ()));
// Note : The IORTable will only be used for those clients who try to
// invoke indirectly using a simple object_key reference
// like "corbaloc::localhost:8888/airplane_server".
obj = this->orb_->resolve_initial_references ("IORTable");
IORTable::Table_var adapter =
IORTable::Table::_narrow (obj.in ());
ACE_ASSERT(! CORBA::is_nil (adapter.in ()));
adapter->bind (this->server_name_.c_str(), plain_ior.in ());
this->poa_manager_->activate ();
if (this->ior_output_file_)
{
ACE_OS::fprintf (this->ior_output_file_, "%s", ior.in ());
ACE_OS::fclose (this->ior_output_file_);
}
if (this->pid_output_file_)
{
int pid = static_cast<int> (ACE_OS::getpid ());
ACE_OS::fprintf (this->pid_output_file_, "%d\n", pid);
ACE_OS::fclose (this->pid_output_file_);
}
}
catch (const CORBA::Exception& ex)
{
ex._tao_print_exception ("Airplane_Server_i::init");
throw;
}
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;
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);
Hello *hello_impl = 0;
ACE_NEW_RETURN (hello_impl,
Hello (orb.in ()),
1);
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::Object_var table_obj = orb->resolve_initial_references("IORTable");
IORTable::Table_var table = IORTable::Table::_narrow(table_obj.in());
for (int i = 1; i <= cache_size; ++i)
{
CORBA::String_var ior_string = orb->object_to_string (object.in());
ACE_DEBUG((LM_DEBUG, ACE_TEXT("Registering object %d with IOR string: %C\n"),
i, ior_string.in ()));
char identifier[256];
ACE_OS::sprintf (identifier, "TransportCacheTest%d", i);
table->bind(identifier, ior_string.in());
}
PortableServer::POAManager_var poa_manager = root_poa->the_POAManager ();
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
{
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) Unable to initialize the POA.\n"),
1);
PortableServer::POAManager_var poa_manager =
root_poa->the_POAManager ();
if (parse_args (argc, argv) != 0)
return 1;
Simple_Server_i server_impl (orb.in ());
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 ());
CORBA::Object_var table_object =
orb->resolve_initial_references("IORTable");
IORTable::Table_var table =
IORTable::Table::_narrow (table_object.in ());
if (CORBA::is_nil (table.in ()))
ACE_ERROR_RETURN ((LM_ERROR,
" (%P|%t) Unable to initialize the IORTable.\n"),
1);
table->bind ("Simple_Server", ior.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);
poa_manager->activate ();
orb->run ();
ACE_DEBUG ((LM_DEBUG, "(%P|%t)server: event loop finished\n"));
// If expect_servant_calls is 0, it means it's the request forward looping case so the
// servant continue receiving calls from a single request. We can not determine how many
// servant calls but it should be more than the number of requests.
if ((expect_servant_calls == 0 && (server_impl.ncalls () > num_requests))
|| (expect_servant_calls > 0 && (server_impl.ncalls () == expect_servant_calls)))
{
return 0;
}
else
ACE_ERROR_RETURN ((LM_ERROR,
"server: Test failed - expected %d servant calls but got %d calls \n",
expect_servant_calls, server_impl.ncalls ()),
1);
}
catch (const CORBA::Exception& ex)
{
ex._tao_print_exception ("Exception caught:");
return 1;
}
return 0;
}
int
TAO_IFR_Server::create_repository (void)
{
TAO_ComponentRepository_i *impl = 0;
ACE_NEW_THROW_EX (
impl,
TAO_ComponentRepository_i (
this->orb_.in (),
this->root_poa_,
this->config_
),
CORBA::NO_MEMORY ()
);
auto_ptr<TAO_ComponentRepository_i> safety (impl);
TAO_IFR_Service_Utils::repo_ = impl;
POA_CORBA::ComponentIR::Repository_tie<TAO_ComponentRepository_i> *impl_tie
= 0;
ACE_NEW_THROW_EX (
impl_tie,
POA_CORBA::ComponentIR::Repository_tie<TAO_ComponentRepository_i> (
impl,
this->repo_poa_,
1
),
CORBA::NO_MEMORY ()
);
PortableServer::ServantBase_var tie_safety (impl_tie);
safety.release ();
this->repo_poa_->set_servant (impl_tie);
PortableServer::ObjectId_var oid =
PortableServer::string_to_ObjectId ("");
CORBA::Object_var obj =
this->repo_poa_->create_reference_with_id (
oid.in (),
"IDL:omg.org/CORBA/ComponentIR/ComponentRepository:1.0"
);
CORBA::Repository_ptr repo_ref =
CORBA::Repository::_narrow (obj.in ());
// Initialize the repository.
int status = impl->repo_init (repo_ref,
this->repo_poa_);
if (status != 0)
{
return -1;
}
// Save and output the IOR string.
this->ifr_ior_ =
this->orb_->object_to_string (repo_ref);
CORBA::Object_var table_object =
this->orb_->resolve_initial_references ("IORTable");
IORTable::Table_var adapter =
IORTable::Table::_narrow (table_object.in ());
if (CORBA::is_nil (adapter.in ()))
{
ORBSVCS_ERROR_RETURN ((LM_ERROR, "Nil IORTable\n"), -1);
}
else
{
adapter->bind ("InterfaceRepository",
this->ifr_ior_.in ());
}
// Add the repository to the ORB's table of initialized object references.
this->orb_->register_initial_reference ("InterfaceRepository",
repo_ref);
// Write our IOR to a file.
FILE *output_file_ =
ACE_OS::fopen (OPTIONS::instance ()->ior_output_file (),
ACE_TEXT ("w"));
if (output_file_ == 0)
{
ORBSVCS_ERROR_RETURN ((LM_ERROR,
ACE_TEXT ("TAO_IFR_Server::create_repository - ")
ACE_TEXT ("can't open IOR output ")
ACE_TEXT ("file for writing\n")),
-1);
}
ACE_OS::fprintf (output_file_,
"%s\n",
this->ifr_ior_.in ());
ACE_OS::fclose (output_file_);
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 mgr = root_poa->the_POAManager();
const char* poa_name = "MessengerService";
PortableServer::POA_var messenger_poa = createPOA(root_poa.in(), poa_name);
Terminator terminator;
if (terminator.open (0) == -1)
ACE_ERROR_RETURN((LM_ERROR,
ACE_TEXT ("main Error opening terminator\n")),-1);
PortableServer::Servant_var<Messenger_i> messenger_servant =
new Messenger_i(orb.in(), terminator);
PortableServer::ObjectId_var object_id =
PortableServer::string_to_ObjectId("messenger_object");
//
// Activate the servant with the messenger POA,
// obtain its object reference, and get a
// stringified IOR.
//
messenger_poa->activate_object_with_id(object_id.in(), messenger_servant.in());
//
// Create binding between "MessengerService" and
// the messenger object reference in the IOR Table.
// Use a TAO extension to get the non imrified poa
// to avoid forwarding requests back to the ImR.
TAO_Root_POA* tpoa = dynamic_cast<TAO_Root_POA*>(messenger_poa.in());
obj = tpoa->id_to_reference_i(object_id.in(), false);
CORBA::String_var messenger_ior = orb->object_to_string(obj.in());
obj = orb->resolve_initial_references("IORTable");
IORTable::Table_var table = IORTable::Table::_narrow(obj.in());
table->bind(poa_name, messenger_ior.in());
//
// This server is now ready to run.
// This version does not create an IOR
// file as demonstrated in the
// Developer's Guide. It assumes that
// users create IORs for the client using
// the tao_imr utility.
//
//
// Stop discarding requests.
//
mgr->activate();
std::cout << "Messenger server ready." << std::endl;
orb->run();
std::cout << "Messenger server shutting down." << std::endl;
root_poa->destroy(1,1);
orb->destroy();
ACE_Message_Block *mb;
ACE_NEW_RETURN(mb, ACE_Message_Block(0, ACE_Message_Block::MB_HANGUP), -1);
terminator.putq(mb);
terminator.wait();
}
catch(const CORBA::Exception& ex) {
std::cerr << "Server main() Caught CORBA::Exception" << ex << std::endl;
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) Unable to initialize the POA.\n"),
1);
PortableServer::POAManager_var poa_manager =
root_poa->the_POAManager ();
if (parse_args (argc, argv) != 0)
return 1;
Simple_Server_i server_impl (orb.in ());
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 ());
CORBA::Object_var table_object =
orb->resolve_initial_references("IORTable");
IORTable::Table_var table =
IORTable::Table::_narrow (table_object.in ());
if (CORBA::is_nil (table.in ()))
ACE_ERROR_RETURN ((LM_ERROR,
" (%P|%t) Unable to initialize the IORTable.\n"),
1);
table->bind ("Simple_Server", ior.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);
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;
}
void
InfoRepo::init()
{
ACE_Argv_Type_Converter cvt(this->federatorConfig_.argc(),
this->federatorConfig_.argv());
this->orb_ = CORBA::ORB_init(cvt.get_argc(), cvt.get_ASCII_argv(), "");
this->info_servant_ =
new TAO_DDS_DCPSInfo_i(this->orb_, this->resurrect_, this,
this->federatorConfig_.federationId());
// Install the DCPSInfo_i into the Federator::Manager.
this->federator_.info() = this->info_servant_.in();
CORBA::Object_var obj =
this->orb_->resolve_initial_references("RootPOA");
PortableServer::POA_var root_poa = PortableServer::POA::_narrow(obj);
PortableServer::POAManager_var poa_manager = root_poa->the_POAManager();
// Use persistent and user id POA policies so the Info Repo's
// object references are consistent.
CORBA::PolicyList policies(2);
policies.length(2);
policies[0] = root_poa->create_id_assignment_policy(PortableServer::USER_ID);
policies[1] = root_poa->create_lifespan_policy(PortableServer::PERSISTENT);
PortableServer::POA_var info_poa = root_poa->create_POA("InfoRepo",
poa_manager,
policies);
// Creation of the new POAs over, so destroy the Policy_ptr's.
for (CORBA::ULong i = 0; i < policies.length(); ++i) {
policies[i]->destroy();
}
PortableServer::ObjectId_var oid =
PortableServer::string_to_ObjectId("InfoRepo");
info_poa->activate_object_with_id(oid, this->info_servant_.in());
obj = info_poa->id_to_reference(oid);
// the object is created locally, so it is safe to do an
// _unchecked_narrow, this was needed to prevent an exception
// when dealing with ImR-ified objects
OpenDDS::DCPS::DCPSInfo_var info_repo =
OpenDDS::DCPS::DCPSInfo::_unchecked_narrow(obj);
CORBA::String_var objref_str =
orb_->object_to_string(info_repo);
// Initialize the DomainParticipantFactory
DDS::DomainParticipantFactory_var dpf =
TheParticipantFactoryWithArgs(cvt.get_argc(),
cvt.get_TCHAR_argv());
// We need parse the command line options for DCPSInfoRepo after parsing DCPS specific
// command line options.
// Check the non-ORB arguments.
this->parse_args(cvt.get_argc(), cvt.get_TCHAR_argv());
// Activate the POA manager before initialize built-in-topics
// so invocations can be processed.
poa_manager->activate();
if (this->use_bits_) {
if (this->info_servant_->init_transport(this->listen_address_given_,
this->listen_address_str_.c_str())
!= 0 /* init_transport returns 0 for success */) {
ACE_ERROR((LM_ERROR, ACE_TEXT("(%P|%t) ERROR: DCPSInfoRepo::init: ")
ACE_TEXT("Unable to initialize transport.\n")));
throw InitError("Unable to initialize transport.");
}
} else {
TheServiceParticipant->set_BIT(false);
}
// This needs to be done after initialization since we create the reference
// to ourselves in the service here.
OpenDDS::DCPS::Service_Participant* serv_part = TheServiceParticipant;
serv_part->set_repo_ior(objref_str, OpenDDS::DCPS::Discovery::DEFAULT_REPO);
OpenDDS::DCPS::Discovery_rch disc = serv_part->get_discovery(0 /*domainId*/);
OpenDDS::DCPS::InfoRepoDiscovery_rch ird =
OpenDDS::DCPS::static_rchandle_cast<OpenDDS::DCPS::InfoRepoDiscovery>(disc);
if (!ird->set_ORB(orb_)) {
ACE_ERROR((LM_ERROR, ACE_TEXT("(%P|%t) ERROR: DCPSInfoRepo::init: ")
ACE_TEXT("Unable to set the ORB in InfoRepoDiscovery.\n")));
throw InitError("Unable to set the ORB in InfoRepoDiscovery.");
}
// Initialize persistence _after_ initializing the participant factory
// and intializing the transport.
if (!this->info_servant_->init_persistence()) {
ACE_ERROR((LM_ERROR, ACE_TEXT("(%P|%t) ERROR: DCPSInfoRepo::init: ")
ACE_TEXT("Unable to initialize persistence.\n")));
throw InitError("Unable to initialize persistence.");
}
// Initialize reassociation.
if (this->reassociate_delay_ != ACE_Time_Value::zero &&
!this->info_servant_->init_reassociation(this->reassociate_delay_)) {
ACE_ERROR((LM_ERROR, ACE_TEXT("(%P|%t) ERROR: DCPSInfoRepo::init: ")
ACE_TEXT("Unable to initialize reassociation.\n")));
throw InitError("Unable to initialize reassociation.");
}
// Initialize dispatch checking
if (this->dispatch_cleanup_delay_ != ACE_Time_Value::zero &&
!this->info_servant_->init_dispatchChecking(this->dispatch_cleanup_delay_)) {
ACE_ERROR((LM_ERROR, ACE_TEXT("(%P|%t) ERROR: DCPSInfoRepo::init: ")
ACE_TEXT("Unable to initialize Dispatch checking.\n")));
throw InitError("Unable to initialize dispatch checking.");
}
// Fire up the federator.
OpenDDS::Federator::Manager_var federator;
CORBA::String_var federator_ior;
if (federator_.id().overridden()) {
oid = PortableServer::string_to_ObjectId("Federator");
info_poa->activate_object_with_id(oid, &federator_);
obj = info_poa->id_to_reference(oid);
federator = OpenDDS::Federator::Manager::_narrow(obj);
federator_ior = orb_->object_to_string(federator);
// Add a local repository reference that can be returned via a
// remote call to a peer.
this->federator_.localRepo(info_repo);
// It should be safe to initialize the federation mechanism at this
// point. What we really needed to wait for is the initialization of
// the service components - like the DomainParticipantFactory and the
// repository bindings.
// N.B. This is done *before* being added to the IOR table to avoid any
// races with an eager client.
this->federator_.orb(this->orb_);
//
// Add the federator to the info_servant update manager as an
// additional updater interface to be called.
// N.B. This needs to be done *after* the call to load_domains()
// since that is where the update manager is initialized in the
// info startup sequencing.
this->info_servant_->add(&this->federator_);
}
// Grab the IOR table.
CORBA::Object_var table_object =
this->orb_->resolve_initial_references("IORTable");
IORTable::Table_var adapter = IORTable::Table::_narrow(table_object);
if (CORBA::is_nil(adapter)) {
ACE_ERROR((LM_ERROR, ACE_TEXT("Nil IORTable\n")));
} else {
adapter->bind(OpenDDS::Federator::REPOSITORY_IORTABLE_KEY, objref_str);
if (this->federator_.id().overridden()) {
// Bind to '/Federator'
adapter->bind(OpenDDS::Federator::FEDERATOR_IORTABLE_KEY, federator_ior);
// Bind to '/Federator/1382379631'
std::stringstream buffer(OpenDDS::Federator::FEDERATOR_IORTABLE_KEY);
buffer << "/" << std::dec << this->federatorConfig_.federationDomain();
adapter->bind(buffer.str().c_str(), federator_ior);
}
}
FILE* output_file = ACE_OS::fopen(this->ior_file_.c_str(), ACE_TEXT("w"));
if (output_file == 0) {
ACE_ERROR((LM_ERROR, ACE_TEXT("ERROR: Unable to open IOR file: %s\n"),
ior_file_.c_str()));
throw InitError("Unable to open IOR file.");
}
ACE_OS::fprintf(output_file, "%s", objref_str.in());
ACE_OS::fclose(output_file);
// Initial federation join if specified on command line.
if (this->federator_.id().overridden()
&& !this->federatorConfig_.federateIor().empty()) {
if (OpenDDS::DCPS::DCPS_debug_level > 0) {
ACE_DEBUG((LM_DEBUG,
ACE_TEXT("(%P|%t) INFO: DCPSInfoRepo::init() - ")
ACE_TEXT("joining federation with repository %s\n"),
this->federatorConfig_.federateIor().c_str()));
}
obj = this->orb_->string_to_object(
this->federatorConfig_.federateIor().c_str());
if (CORBA::is_nil(obj)) {
ACE_ERROR((LM_ERROR,
ACE_TEXT("(%P|%t) ERROR: could not resolve %s for initial federation.\n"),
this->federatorConfig_.federateIor().c_str()));
throw InitError("Unable to resolve IOR for initial federation.");
}
OpenDDS::Federator::Manager_var peer =
OpenDDS::Federator::Manager::_narrow(obj);
if (CORBA::is_nil(peer)) {
ACE_ERROR((LM_ERROR,
ACE_TEXT("(%P|%t) ERROR: could not narrow %s.\n"),
this->federatorConfig_.federateIor().c_str()));
throw InitError("Unable to narrow peer for initial federation.");
}
// Actually join.
peer->join_federation(federator,
this->federatorConfig_.federationDomain());
}
}
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);
CORBA::Object_var table_object =
orb->resolve_initial_references ("IORTable");
IORTable::Table_var adapter =
IORTable::Table::_narrow (table_object.in ());
if (CORBA::is_nil (adapter.in ()))
{
ACE_ERROR ((LM_ERROR, "Nil IORTable\n"));
}
else
{
adapter->bind ("pcs_test", ior.in());
}
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 main(int argc, char *argv[])
{
int c, instance = -1;
ACE_CString daemonRef;
ACE_CString hostName;
ACE_CString additional;
for (;;) {
int option_index = 0;
c = getopt_long(argc, argv, "hi:d:H:a:",
long_options, &option_index);
if (c == -1)
break;
switch (c) {
case 'h':
usage(argv[0]);
return 0;
case 'i':
instance = ACE_OS::atoi(optarg);
break;
case 'd':
daemonRef = optarg;
break;
case 'H':
hostName = optarg;
break;
case 'a':
additional = optarg;
break;
}
}
if (instance == -1) {
ACE_OS::printf("Error: instance is a mandatory option try %s -h\n",
argv[0]);
return -1;
}
#define DEFAULT_LOG_FILE_NAME "acs_local_log"
ACE_CString daemonsLogFileName = getTempFileName(0, DEFAULT_LOG_FILE_NAME);
// replace "ACS_INSTANCE.x" with "acsdaemonStartAcs_" + <timestamp>
ACE_CString daemonsDir = "acsdaemonStartAcs_" + getStringifiedTimeStamp();
ACE_CString instancePart("ACS_INSTANCE.");
ACE_CString::size_type pos = daemonsLogFileName.find(instancePart);
daemonsLogFileName =
daemonsLogFileName.substring(0, pos) +
daemonsDir +
daemonsLogFileName.substring(pos + instancePart.length() + 1); // +1 for skipping instance number
ACE_OS::setenv("ACS_LOG_FILE", daemonsLogFileName.c_str(), 1);
LoggingProxy *logger = new LoggingProxy(0, 0, 31);
if (logger) {
LoggingProxy::init(logger);
LoggingProxy::ProcessName(argv[0]);
LoggingProxy::ThreadName("main");
} else
ACS_SHORT_LOG((LM_INFO, "Failed to initialize logging."));
StartCallback* sc = new StartCallback();
try {
// Initialize the ORB.
CORBA::ORB_var orb = CORBA::ORB_init(argc, argv, "TAO");
// get a reference to the RootPOA
CORBA::Object_var pobj = orb->resolve_initial_references("RootPOA");
PortableServer::POA_var root_poa = PortableServer::POA::_narrow(pobj.in());
PortableServer::POAManager_var poa_manager = root_poa->the_POAManager();
// create policies
CORBA::PolicyList policy_list;
policy_list.length(5);
policy_list[0] = root_poa->create_request_processing_policy(PortableServer::USE_DEFAULT_SERVANT);
policy_list[1] = root_poa->create_id_uniqueness_policy(PortableServer::MULTIPLE_ID);
policy_list[2] = root_poa->create_id_assignment_policy(PortableServer::USER_ID);
policy_list[3] = root_poa->create_servant_retention_policy(PortableServer::NON_RETAIN);
policy_list[4] = root_poa->create_lifespan_policy(PortableServer::PERSISTENT);
// create a ACSDaemon POA with policies
PortableServer::POA_var poa = root_poa->create_POA("DaemonCallback", poa_manager.in(), policy_list);
// destroy policies
for (CORBA::ULong i = 0; i < policy_list.length(); ++i)
{
CORBA::Policy_ptr policy = policy_list[i];
policy->destroy();
}
// set as default servant
poa->set_servant(sc);
// create reference
PortableServer::ObjectId_var oid = PortableServer::string_to_ObjectId("DaemonCallback");
pobj = poa->create_reference_with_id (oid.in(), sc->_interface_repository_id());
CORBA::String_var m_ior = orb->object_to_string(pobj.in());
// bind to IOR table
CORBA::Object_var table_object = orb->resolve_initial_references("IORTable");
IORTable::Table_var adapter = IORTable::Table::_narrow(table_object.in());
if (CORBA::is_nil(adapter.in()))
{
ACS_SHORT_LOG ((LM_ERROR, "Nil IORTable"));
return -1;
}
else
{
adapter->bind("DaemonCallback", m_ior.in());
}
// activate POA
poa_manager->activate();
ACS_SHORT_LOG((LM_INFO, "%s is waiting for incoming requests.", "DaemonCallback"));
// construct default one
if (daemonRef.length() == 0) {
if (hostName.length() == 0) {
hostName = ACSPorts::getIP();
}
daemonRef = "corbaloc::";
daemonRef =
daemonRef + hostName + ":" +
ACSPorts::getServicesDaemonPort().c_str() +
"/" + ::acsdaemon::servicesDaemonServiceName;
ACS_SHORT_LOG((LM_INFO,
"Using local ACS Services Daemon reference: '%s'",
daemonRef.c_str()));
} else {
ACS_SHORT_LOG((LM_INFO,
"ACS Services Daemon reference obtained via command line: '%s'",
daemonRef.c_str()));
}
CORBA::Object_var obj = orb->string_to_object(daemonRef.c_str());
if (CORBA::is_nil(obj.in())) {
ACS_SHORT_LOG((LM_INFO, "Failed to resolve reference '%s'.",
daemonRef.c_str()));
return -1;
}
acsdaemon::ServicesDaemon_var daemon =
acsdaemon::ServicesDaemon::_narrow(obj.in());
if (CORBA::is_nil(daemon.in())) {
ACS_SHORT_LOG((LM_INFO, "Failed to narrow reference '%s'.",
daemonRef.c_str()));
return -1;
}
// @todo implement support for callback and wait for completion call
acsdaemon::DaemonSequenceCallback_var dummyCallback = sc->_this();
ACS_SHORT_LOG((LM_INFO, "Calling start_acs(%d, %s, dummyCallback).", instance,
additional.c_str()));
daemon->start_acs(dummyCallback.in(), instance, additional.c_str());
ACS_SHORT_LOG((LM_INFO, "ACS start message issued."));
while(!sc->isComplete())
{
if (orb->work_pending())
orb->perform_work();
}
}
catch(ACSErrTypeCommon::BadParameterEx & ex) {
ACSErrTypeCommon::BadParameterExImpl exImpl(ex);
exImpl.log();
return -1;
}
catch(CORBA::Exception & ex) {
ACS_SHORT_LOG((LM_INFO, "Failed."));
ex._tao_print_exception("Caught unexpected exception:");
return -1;
}
return 0;
}
int
ACE_TMAIN (int argc, ACE_TCHAR *argv[])
{
try
{
int server_num = 0;
int die_on_ping = 1;
int ping_count = 0;
for (int i = 1; i < argc; i++)
{
ACE_TCHAR *c = argv[i];
if (ACE_OS::strcasecmp (ACE_TEXT ("-n"), c) == 0)
{
server_num = ACE_OS::atoi (argv[++i]);
}
else if (ACE_OS::strcasecmp (ACE_TEXT ("-?"),c) == 0)
{
ACE_DEBUG ((LM_DEBUG,
ACE_TEXT ("usage: %C ")
ACE_TEXT ("-n Number of the server\n"),
argv[0]));
return 1;
}
}
Server_ORBInitializer * temp_initializer;
ACE_NEW_RETURN (temp_initializer,
Server_ORBInitializer (&ping_count),
-1); // No exceptions yet!
PortableInterceptor::ORBInitializer_var initializer =
temp_initializer;
PortableInterceptor::register_orb_initializer (initializer.in ());
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 mgr = root_poa->the_POAManager();
ACE_CString poa_name_base = ACE_CString("TestObject_") + toStr (server_num);
PortableServer::POA_var test_poa;
test_poa = createPOA(root_poa.in (), true, poa_name_base.c_str ());
temp_initializer->set_poa (test_poa.in());
mgr->activate();
PortableServer::Servant_var<Test_i> test_servant =
new Test_i(server_num);
PortableServer::ObjectId_var object_id =
PortableServer::string_to_ObjectId("test_object");
//
// Activate the servant with the test POA,
// obtain its object reference, and get a
// stringified IOR.
//
test_poa->activate_object_with_id(object_id.in(), test_servant.in());
//
// Create binding between "TestService" and
// the test object reference in the IOR Table.
// Use a TAO extension to get the non imrified poa
// to avoid forwarding requests back to the ImR.
TAO_Root_POA* tpoa = dynamic_cast<TAO_Root_POA*>(test_poa.in());
obj = tpoa->id_to_reference_i(object_id.in(), false);
CORBA::String_var test_ior = orb->object_to_string(obj.in());
obj = orb->resolve_initial_references("IORTable");
IORTable::Table_var table = IORTable::Table::_narrow(obj.in());
table->bind(poa_name_base.c_str (), test_ior.in());
ACE_DEBUG ((LM_DEBUG, "Started Server %s \n",
poa_name_base.c_str()));
{
ACE_CString status_file = poa_name_base + ACE_CString(".status");
ofstream out(status_file.c_str ());
out << "started" << endl;
}
while (ping_count < die_on_ping)
{
orb->perform_work ();
}
root_poa->destroy(1,1);
orb->destroy();
}
catch(const CORBA::Exception& ex) {
ex._tao_print_exception ("Server main()");
return 1;
}
return 0;
}
int
ACE_TMAIN (int argc, ACE_TCHAR *argv[])
{
try {
CORBA::ORB_var orb = CORBA::ORB_init(argc, argv);
const ACE_TCHAR *iorfile = ACE_TEXT ("");
ACE_Get_Opt get_opts (argc, argv, ACE_TEXT ("o:?"));
int c;
while ((c = get_opts ()) != -1)
switch (c)
{
case 'o':
iorfile = get_opts.opt_arg ();
break;
case '?':
ACE_DEBUG ((LM_DEBUG,
"usage: %s "
"-d <seconds to delay before initializing POA> "
"-n Number of the server\n",
argv[0]));
return 1;
break;
}
CORBA::Object_var obj = orb->resolve_initial_references ("RootPOA");
root_poa = PortableServer::POA::_narrow (obj.in ());
// TAO_Root_POA::imr_client_adapter_name ("Test_Imr_Adapter");
ACE_CString base = ACE_CString ("TestObject");
createPOAs (base);
PortableServer::Servant_var<Test_i> test_servant = new Test_i ();
PortableServer::ObjectId_var object_id =
PortableServer::string_to_ObjectId (base.c_str());
poa_a->activate_object_with_id (object_id.in(), test_servant.in ());
obj = poa_a->id_to_reference (object_id.in());
Test_var tva = Test::_narrow (obj.in());
if (ACE_OS::strlen (iorfile) > 0)
{
CORBA::String_var ior = orb->object_to_string (obj.in());
FILE *output_file= ACE_OS::fopen (iorfile, "w");
if (output_file == 0)
ACE_ERROR_RETURN ((LM_ERROR,
"Cannot open output file for writing IOR: %s\n",
iorfile),
1);
ACE_OS::fprintf (output_file, "%s", ior.in ());
ACE_OS::fclose (output_file);
}
poa_b->activate_object_with_id (object_id.in(), test_servant.in ());
obj = poa_b->id_to_reference (object_id.in());
Test_var tvb = Test::_narrow (obj.in());
// object_id = root_poa->activate_object (test_servant.in());
//
// This server is now ready to run.
// This version does not create an IOR
// file as demonstrated in the
// Developer's Guide. It assumes that
// users create IORs for the client using
// the tao_imr utility.
//
//
// Stop discarding requests.
//
activatePOAs ();
//
// Create binding between "TestService" and
// the test object reference in the IOR Table.
// Use a TAO extension to get the non imrified poa
// to avoid forwarding requests back to the ImR.
TAO_Root_POA* tpoa = dynamic_cast<TAO_Root_POA*> (poa_a.in ());
ACE_ASSERT (tpoa != 0);
obj = tpoa->id_to_reference_i (object_id.in (), false);
CORBA::String_var test_ior = orb->object_to_string (obj.in ());
obj = orb->resolve_initial_references("IORTable");
IORTable::Table_var table = IORTable::Table::_narrow (obj.in ());
table->bind(base.c_str (), test_ior.in ());
{
ACE_CString status_file = base + ACE_CString(".status");
ofstream out(status_file.c_str ());
out << "started" << endl;
}
test_ior = orb->object_to_string (tva.in());
base += "_a";
ACE_DEBUG ((LM_DEBUG, "%s:\n%s\n", base.c_str(), test_ior.in()));
table->bind (base.c_str (), test_ior.in ());
base[base.length()-1] = 'b';
test_ior = orb->object_to_string (tvb.in());
ACE_DEBUG ((LM_DEBUG, "%s:\n%s\n", base.c_str(), test_ior.in()));
table->bind (base.c_str (), test_ior.in ());
ACE_DEBUG ((LM_DEBUG,
"Started Server %s \n",
base.c_str()));
orb->run();
root_poa->destroy(1,1);
orb->destroy();
}
catch(const CORBA::Exception& ex) {
ex._tao_print_exception ("Server main()");
return 1;
}
return 0;
}
int
TAO_Notify_Service_Driver::init (int argc, ACE_TCHAR *argv[])
{
// Check if -ORBDaemon is specified and if so, daemonize at this moment,
// -ORBDaemon in the ORB core is faulty, see bugzilla 3335
TAO_Daemon_Utility::check_for_daemon (argc, argv);
if (this->parse_args(argc, argv) != 0)
return -1;
// initalize the ORB.
if (this->init_ORB (argc, argv) != 0)
return -1;
this->notify_service_ = TAO_Notify_Service::load_default ();
if (this->notify_service_ == 0)
{
if (TAO_debug_level > 0)
{
ORBSVCS_ERROR ((LM_ERROR,
ACE_TEXT ("Service not found. Check service ")
ACE_TEXT ("configurator file.\n")));
}
return -1;
}
if (this->separate_dispatching_orb_)
{
if (this->init_dispatching_ORB (argc, argv) != 0)
{
return -1;
}
this->notify_service_->init_service2 (this->orb_.in (), this->dispatching_orb_.in());
}
else
{
this->notify_service_->init_service (this->orb_.in ());
}
this->logging_worker_.start();
if (this->nthreads_ > 0) // we have chosen to run in a thread pool.
{
if (TAO_debug_level > 0)
{
ORBSVCS_DEBUG ((LM_DEBUG,
ACE_TEXT("Running %d ORB threads\n"),
this->nthreads_));
}
worker_.orb (this->orb_.in ());
// Task activation flags.
long const flags =
THR_NEW_LWP |
THR_JOINABLE |
this->orb_->orb_core ()->orb_params ()->thread_creation_flags ();
int const priority =
ACE_Sched_Params::priority_min (ACE_Utils::truncate_cast<ACE_Sched_Params::Policy> (this->orb_->orb_core ()->orb_params ()->sched_policy ()),
ACE_Utils::truncate_cast<int> (this->orb_->orb_core ()->orb_params ()->scope_policy ()));
if (worker_.activate (flags,
this->nthreads_, 0, priority) != 0)
{
ORBSVCS_ERROR_RETURN ((LM_ERROR,
"Cannot activate client threads\n"), -1);
}
}
// Check first if the naming service
if (this->use_name_svc_)
{
// Resolve the naming service.
int const ns_ret = this->resolve_naming_service ();
if (ns_ret != 0)
return -1;
}
if (TAO_debug_level > 0)
{
ORBSVCS_DEBUG ((LM_DEBUG,
ACE_TEXT("\nStarting up the Notification Service...\n")));
}
// Activate the factory
this->notify_factory_ =
notify_service_->create (this->poa_.in (),
this->notify_factory_name_.c_str ());
ACE_ASSERT (!CORBA::is_nil (this->notify_factory_.in ()));
if (this->bootstrap_) // Enable corbaloc usage
{
CORBA::Object_var table_object =
this->orb_->resolve_initial_references ("IORTable");
IORTable::Table_var adapter =
IORTable::Table::_narrow (table_object.in ());
if (CORBA::is_nil (adapter.in ()))
{
if (TAO_debug_level > 0)
{
ORBSVCS_ERROR ((LM_ERROR,
"Nil IORTable. corbaloc support not enabled.\n"));
}
}
else
{
CORBA::String_var ior =
this->orb_->object_to_string (this->notify_factory_.in ());
adapter->bind (this->notify_factory_name_.c_str (), ior.in ());
}
}
// Register with the Name service, if asked
if (this->use_name_svc_ && !CORBA::is_nil (this->naming_.in ()))
{
CosNaming::Name_var name =
this->naming_->to_name (this->notify_factory_name_.c_str ());
this->naming_->rebind (name.in (),
this->notify_factory_.in ());
if (TAO_debug_level > 0)
{
ORBSVCS_DEBUG ((LM_DEBUG,
"Registered with the naming service as: %C\n",
this->notify_factory_name_.c_str()));
}
if (this->register_event_channel_)
{
// If we don't have any name configured, default to the standard name
if (this->notify_channel_name_.is_empty ())
{
notify_channel_name_.insert (NOTIFY_CHANNEL_NAME);
}
for (ACE_Unbounded_Set<ACE_CString>::const_iterator ci (
this->notify_channel_name_); !ci.done(); ci++)
{
// create an event channel
CosNotifyChannelAdmin::ChannelID id;
CosNotification::QoSProperties initial_qos;
CosNotification::AdminProperties initial_admin;
CosNotifyChannelAdmin::EventChannel_var ec;
TAO_Notify_EventChannelFactory* factory_impl =
dynamic_cast<TAO_Notify_EventChannelFactory*> (
this->notify_factory_->_servant ());
if (factory_impl == 0)
{
ec = this->notify_factory_->create_channel (initial_qos,
initial_admin,
id);
}
else
{
ec = factory_impl->create_named_channel (
initial_qos, initial_admin,id,
(*ci).c_str ());
}
name = this->naming_->to_name ((*ci).c_str ());
this->naming_->rebind (name.in (), ec.in ());
if (TAO_debug_level > 0)
{
ORBSVCS_DEBUG ((LM_DEBUG,
"Registered an Event Channel with the naming "
"service as: %C\n",
(*ci).c_str()));
}
}
}
}
// Write IOR to a file, if asked.
// Note: do this last to ensure that we're up and running before the file is written
CORBA::String_var str =
this->orb_->object_to_string (this->notify_factory_.in ());
if (this->ior_output_file_name_)
{
FILE* ior_output_file = ACE_OS::fopen (ior_output_file_name_,
ACE_TEXT("w"));
if (ior_output_file == 0)
{
ORBSVCS_ERROR_RETURN ((LM_ERROR,
"Unable to open %s for writing: %p\n",
this->ior_output_file_name_, "Notify_Service"),
-1);
}
ACE_OS::fprintf (ior_output_file, "%s", str.in ());
ACE_OS::fclose (ior_output_file);
}
else if (TAO_debug_level > 0)
{
ORBSVCS_DEBUG ((LM_DEBUG,
ACE_TEXT ("The Notification Event Channel Factory IOR is <%C>\n"),
str.in ()));
}
return 0;
}
bool ServiceOptions::bindServiceObject(CORBA::ORB_ptr orb,
CORBA::Object_ptr object,
PortableServer::Servant p_servant,
const char* objName,
bool rebind)
{
if(is_set("with-naming")) {
CosNaming::Name name;
name.length(1);
name[0].id=CORBA::string_dup(objName);
name[0].kind=CORBA::string_dup("");
CORBA::Object_var obj ;
try {
obj = orb->resolve_initial_references("NameService");
}catch(const CORBA::ORB::InvalidName& ex){
std::cerr << argv()[0] << ": can't resolve `NameService'" << std::endl;
return false;
}
CosNaming::NamingContext_var nc;
try {
nc = CosNaming::NamingContext::_narrow(obj.in());
}catch(const CORBA::SystemException& ex){
std::cerr << argv()[0] << ": can't narrow naming service" << std::endl;
return false;
}
try {
if(rebind){
nc->rebind(name,object);
}else{
try{
nc->bind(name,object);
}catch(const CosNaming::NamingContext::AlreadyBound&){
std::cerr<<argv()[0]<<":can't bind "<<objName<<" (AlreadyBound)"<< std::endl;
return false;
}
}
}catch(const CosNaming::NamingContext::CannotProceed&){
std::cerr<<argv()[0]<<": can't bind "<<objName<<" (CannotProceed)"<< std::endl;
return false;
}catch(const CosNaming::NamingContext::InvalidName&){
std::cerr<<argv()[0]<<":can't bind "<<objName<<" (InvalidName)"<< std::endl;
return false;
}
std::cout<<argv()[0]<<": binding completed successfully"<<std::endl;
}
CORBA::String_var ior ;
try {
ior = orb->object_to_string(object);
}catch(const CORBA::SystemException& ex){
#ifdef CORBA_SYSTEM_EXCEPTION_IS_STREAMBLE
std::cerr << ex << std::endl;
#else
std::cerr << "CORBA::SystemException" << std::endl;
#endif
return false;
}
const char* fname = get_ior_fname(objName);
if (fname!=NULL && strcmp(fname,"")!=0) {
std::ofstream ofs (fname);
if (ofs.bad()) {
std::cerr << argv()[0] << ": can't open file " << fname << std::endl;
perror(argv()[0]);
return false;
}
ofs << ior.in();
ofs.close();
}
if (is_set("ior-stdout")) {
std::cout << ior << std::flush;
}
#ifdef ORBACUS
CORBA::Object_var bmgrObj = orb->resolve_initial_references("BootManager");
OB::BootManager_var bootManager = OB::BootManager::_narrow(bmgrObj);
PortableServer::ObjectId_var oid = PortableServer::string_to_ObjectId(objName);
bootManager -> add_binding(oid.in(),object);
#elif defined(OMNIORB)
PortableServer::POA_var objPOA = p_servant->_default_POA();
CORBA::String_var objPOAName = objPOA->the_name();
if (strcmp(objPOAName.in(),"omniINSPOA")!=0) {
CORBA::Object_var insPOAObj = orb->resolve_initial_references("omniINSPOA");
PortableServer::POA_var insPOA = PortableServer::POA::_narrow(insPOAObj);
PortableServer::POAManager_var insPOAManager=insPOA->the_POAManager();
insPOAManager->activate();
PortableServer::ObjectId_var oid =
PortableServer::string_to_ObjectId(objName);
insPOA->activate_object_with_id(oid.in(),p_servant);
}
#elif defined(RSSH_TAO)
#ifdef TAO_HAVE_IORTABLE_ADAPTER
CORBA::Object_var table = orb->resolve_initial_references ("IORTable");
IORTable::Table_var adapter = IORTable::Table::_narrow (table.in());
if (CORBA::is_nil(adapter.in())) {
cerr<<argv()[0]<<": nil IORTable reference"<<endl;
} else {
adapter->bind (objName, ior.in ());
}
#else
ACE_CString ins(objName);
if (orb->_tao_add_to_IOR_table(ins,object)!=0) {
return false;
}
#endif
#elif defined(MICO)
// create persistent POA with name as service name if we have no one.
PortableServer::POA_var objPOA = p_servant->_default_POA();
CORBA::String_var objPOAName = objPOA->the_name();
std::cerr << "existent OBJPOAName=" << objPOAName.in() << std::endl;
std::cerr << "objName=" << objName << std::endl;
if (strcmp(objPOAName.in(),objName)!=0) {
CORBA::Object_var rootPOAObj = orb->resolve_initial_references ("RootPOA");
PortableServer::POA_var rootPOA = PortableServer::POA::_narrow(rootPOAObj);
CORBA::PolicyList pl;
pl.length (2);
pl[0] = rootPOA->create_lifespan_policy (PortableServer::PERSISTENT);
pl[1] = rootPOA->create_id_assignment_policy (PortableServer::USER_ID);
PortableServer::POA_var objPOA = rootPOA->create_POA(objName,
PortableServer::POAManager::_nil (),
pl);
PortableServer::POAManager_var objPOAManager = objPOA->the_POAManager ();
PortableServer::ObjectId_var objId =
PortableServer::string_to_ObjectId (objName);
objPOA->activate_object_with_id (objId.in(), p_servant);
objPOAManager->activate();
}else{
//PortbaobjPOA
}
#endif
return true;
}
int ACE_TMAIN (int argc, ACE_TCHAR *argv[])
{
try
{
//init the orb
CORBA::ORB_var orb=CORBA::ORB_init(argc, argv);
//get the root poa
CORBA::Object_var poa_object = orb->resolve_initial_references ("RootPOA");
PortableServer::POA_var poa = PortableServer::POA::_narrow (poa_object.in ());
PortableServer::POAManager_var poa_manager = poa->the_POAManager ();
if (parse_args (argc, argv) != 0)
return 1;
poa_manager->activate ();
// Get a reference to the IOR Table
CORBA::Object_var tobj = orb->resolve_initial_references("IORTable");
IORTable::Table_var table = IORTable::Table::_narrow(tobj.in());
//get an object id for the name
PortableServer::ObjectId_var oid =
PortableServer::string_to_ObjectId ("Messenger");
//activate the object for the given id
Messenger_i messenger (orb.in ());
poa->activate_object_with_id(oid.in (), &messenger);
CORBA::Object_var messenger_obj = poa->id_to_reference (oid.in ());
//bind the ior string to the name
CORBA::String_var messenger_ior_string = orb->object_to_string(messenger_obj.in());
table->bind("Messenger", messenger_ior_string.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\n",
ior_output_file),
1);
ACE_OS::fprintf (output_file, "%s", messenger_ior_string.in ());
ACE_OS::fclose (output_file);
orb->run ();
ACE_DEBUG ((LM_DEBUG, "(%P|%t) server - event loop finished\n"));
poa->destroy (1, 1);
orb->destroy ();
}
catch (const CORBA::Exception& ex)
{
ex._tao_print_exception ("Exception caught:");
return 1;
}
return 0;
}
int main(int argc, char *argv[])
{
CosNaming::NamingContext_var naming_context;
int nargc=0;
char **nargv=0;
const char *hn=ACSPorts::getIP();
ACE_CString iorFile;
if (argc>=2 && !ACE_OS_String::strcmp(argv[1], "-?")) {
ACE_OS::printf ("USAGE: acsLogSvc [-ORBInitRef NameService=iiop://yyy:xxxx/NameService] [-ORBEndpoint iiop://ip:port] [-o iorfile] [-silent]\n");
return -1;
}
// here we have to unset ACS_LOG_CENTRAL that we prevent filtering of log messages
char *logCent=getenv("ACS_LOG_CENTRAL");
if (logCent)
{
unsetenv("ACS_LOG_CENTRAL");
printf("Unset ACS_LOG_CENTRAL which was previously set to %s\n", logCent);
}//if
// create logging proxy
LoggingProxy::ProcessName(argv[0]);
ACE_Log_Msg::instance()->local_host(hn);
LoggingProxy m_logger (0, 0, 31, 0);
LoggingProxy::init (&m_logger);
ACS_SHORT_LOG((LM_INFO, "Logging proxy successfully created !"));
ACE_CString argStr;
for(int i=1; i<argc; i++)
{
argStr += argv[i];
argStr += " ";
if (!ACE_OS_String::strcmp(argv[i], "-o") && (i+1)<argc)
{
iorFile = argv[i+1];
}//if
}//for
if (argStr.find ("-ORBEndpoint")==ACE_CString::npos)
{
argStr = argStr + "-ORBEndpoint iiop://" + hn + ":" + ACSPorts::getLogPort().c_str();
}
ACS_SHORT_LOG((LM_INFO, "New command line is: %s", argStr.c_str()));
ACE_OS::string_to_argv ((ACE_TCHAR*)argStr.c_str(), nargc, nargv);
ACE_OS::signal(SIGINT, TerminationSignalHandler); // Ctrl+C
ACE_OS::signal(SIGTERM, TerminationSignalHandler); // termination request
try
{
// Initialize the ORB
ACE_OS::printf ("Initialising ORB ... \n");
orb = CORBA::ORB_init (nargc, nargv, 0);
ACE_OS::printf ("ORB initialsed !\n");
}
catch( CORBA::Exception &ex )
{
ex._tao_print_exception("Failed to initalise ORB");
return -1;
}
if (!ACSError::init(orb.in()))
{
ACS_SHORT_LOG ((LM_ERROR, "Failed to initalise the ACS Error System"));
return -1;
}
// resolve naming service
try
{
ACS_SHORT_LOG((LM_INFO, "Trying to connect to the Naming Service ...."));
CORBA::Object_var naming_obj = orb->resolve_initial_references ("NameService");
if (!CORBA::is_nil (naming_obj.in ()))
{
naming_context = CosNaming::NamingContext::_narrow (naming_obj.in ());
ACS_SHORT_LOG((LM_INFO, "Connected to the Name Service"));
}
else
{
ACS_SHORT_LOG((LM_ERROR, "Could not connect the Name Service!"));
return -1;
}//if-else
}
catch( CORBA::Exception &_ex )
{
ACS_SHORT_LOG((LM_ERROR, "Could not connect the Name Service!"));
return -1;
}
// logging service
try
{
CORBA::Object_var log_obj;
/*
if (argStr.find ("-ORBInitRef NameService=")!=ACE_CString::npos)
{
// Initialize the ORB
ACE_OS::printf ("Initialising ORB ... \n");
orb = CORBA::ORB_init (nargc, nargv, 0);
ACE_OS::printf ("ORB initialsed !\n");
//Naming Service
ACE_OS::printf ("Resolving Naming service ... \n");
CORBA::Object_var naming_obj =
orb->resolve_initial_references ("NameService");
if (!CORBA::is_nil (naming_obj.in ()))
{
CosNaming::NamingContext_var naming_context =
CosNaming::NamingContext::_narrow (naming_obj.in ());
ACE_OS::printf ( "Naming Service resolved !\n");
*/
ACE_OS::printf ( "Resolving Logging Service from Naming service ...\n");
CosNaming::Name name;
name.length(1);
name[0].id = CORBA::string_dup("Log");
log_obj = naming_context->resolve(name);
/*
}
else
{
ACS_LOG(LM_SOURCE_INFO, "main", (LM_ERROR, "Failed to initialise the Name Service!"));
}
}//if naming Service
else
{
ACE_OS::printf ("Getting Log from the Manager... \n");
CORBA::ULong status;
maci::Manager_ptr manager = maci::MACIHelper::resolveManager (orb.in(), nargc, nargv, 0, 0);
log_obj = manager->get_COB(0, "Log", true, status);
}
*/
if (!CORBA::is_nil (log_obj.in()))
{
Logging::AcsLogService_var logger = Logging::AcsLogService::_narrow(log_obj.in());
ACE_OS::printf ( "Logging Service resolved !\n");
m_logger.setCentralizedLogger(logger.in());
}
else
{
ACS_LOG(LM_SOURCE_INFO, "main", (LM_ERROR, "Failed to initialise the Logging Service!"));
return -1;
}//if-else
}
catch( CORBA::Exception &__ex )
{
__ex._tao_print_exception("Failed to get and set the centralized logger");
return -1;
}
try
{
//Get a reference to the RootPOA
ACE_OS::printf("Creating POA ... \n");
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();
CORBA::PolicyList policy_list;
policy_list.length(5);
policy_list[0] = root_poa->create_request_processing_policy (PortableServer::USE_DEFAULT_SERVANT);
policy_list[1] = root_poa->create_id_uniqueness_policy (PortableServer::MULTIPLE_ID);
policy_list[2] = root_poa->create_id_assignment_policy(PortableServer::USER_ID);
policy_list[3] = root_poa->create_servant_retention_policy(PortableServer::NON_RETAIN);
policy_list[4] = root_poa->create_lifespan_policy (PortableServer::PERSISTENT);
printf("policies are created !\n");
PortableServer::POA_var poa = root_poa->create_POA("ACSLogSvc", poa_manager.in(), policy_list);
ACE_OS::printf("POA created !\n");
for (CORBA::ULong i = 0; i < policy_list.length (); ++i) {
CORBA::Policy_ptr policy = policy_list[i];
policy->destroy ();
}
printf("Policies are destroyed !\n");
ACSLogImpl acsLogSvc (m_logger);
poa->set_servant (&acsLogSvc);
PortableServer::ObjectId_var oid = PortableServer::string_to_ObjectId ("ACSLogSvc");
obj = poa->create_reference_with_id (oid.in(), acsLogSvc._interface_repository_id());
CORBA::String_var ior = orb->object_to_string (obj.in());
// if ther is file name write ior in it
if (iorFile.length()!=0)
{
FILE *output_file = ACE_OS::fopen (iorFile.c_str(), "w");
if (output_file == 0)
{
ACS_SHORT_LOG ((LM_ERROR,
"Cannot open output files for writing IOR: ior.ior"));
return -1;
}//if
int result = ACE_OS::fprintf (output_file, "%s", ior.in());
if (result < 0)
{
ACS_SHORT_LOG ((LM_ERROR,
"ACE_OS::fprintf failed while writing %s to ior.ior", ior.in()));
return -1;
}//if
ACE_OS::fclose (output_file);
ACS_SHORT_LOG((LM_INFO, "ACSLogSvc's IOR has been written into: %s", iorFile.c_str()));
}//if
// adding ACSLog to NamingService
if (!CORBA::is_nil (naming_context.in ()))
{
// register cdb server in Naming service
CosNaming::Name name (1);
name.length (1);
name[0].id = CORBA::string_dup ("ACSLogSvc");
naming_context->rebind (name, obj.in ());
ACS_SHORT_LOG((LM_INFO, "ACSLogSvc service registered with Naming Services"));
}//if
CORBA::Object_var table_object =
orb->resolve_initial_references ("IORTable");
IORTable::Table_var adapter =
IORTable::Table::_narrow (table_object.in ());
if (CORBA::is_nil (adapter.in ()))
{
ACS_SHORT_LOG ((LM_ERROR, "Nil IORTable"));
}
else
{
adapter->bind ("ACSLogSvc", ior.in ());
}
poa_manager->activate ();
ACS_SHORT_LOG((LM_INFO, "ACSLogSvc is waiting for incoming log messages ..."));
if (argStr.find ("-ORBEndpoint")!=ACE_CString::npos)
m_logger.setStdio(31);
orb->run ();
ACSError::done();
LoggingProxy::done();
}
catch( CORBA::Exception &ex )
{
ex. _tao_print_exception("EXCEPTION CAUGHT");
return -1;
}
return 0;
}
CORBA::Object_ptr
DAnCE_TargetManager_Module::init (CORBA::ORB_ptr orb,
int argc,
ACE_TCHAR *argv[])
{
DANCE_TRACE ("DAnCE_TargetManager_Module::init");
try
{
if (CORBA::is_nil(orb))
{
DANCE_ERROR (DANCE_LOG_TERMINAL_ERROR, (LM_ERROR, DLINFO ACE_TEXT ("DAnCE_TargetManager_Module::init - ")
ACE_TEXT ("Attempted to create Target Manager with a nil orb.\n")));
return CORBA::Object::_nil();
}
else
{
this->orb_ = CORBA::ORB::_duplicate (orb);
}
if (ACE_OS::strcmp(orb->id(), this->orb_->id()) != 0)
{
DANCE_TRACE_LOG (DANCE_LOG_TRACE, (LM_TRACE, DLINFO ACE_TEXT ("DAnCE_TargetManager_Module::init - ")
ACE_TEXT ("Resetting TM's orb.\n")));
this->orb_ = CORBA::ORB::_duplicate (orb);
this->domain_nc_ = CosNaming::NamingContext::_nil();
}
if (!this->parse_args (argc, argv))
{
return CORBA::Object::_nil ();
}
this->create_poas ();
if (this->options_.domain_nc_)
{
try
{
DANCE_TRACE_LOG (DANCE_LOG_TRACE, (LM_TRACE, DLINFO ACE_TEXT ("DAnCE_TargetManager_Module::init - ")
ACE_TEXT ("Resolving DomainNC.\n")));
CORBA::Object_var domain_obj = this->orb_->string_to_object (this->options_.domain_nc_);
if (!CORBA::is_nil (domain_obj.in ()))
{
this->domain_nc_ = CosNaming::NamingContext::_narrow (domain_obj.in());
if (CORBA::is_nil (this->domain_nc_.in ()))
{
DANCE_ERROR (DANCE_LOG_TERMINAL_ERROR, (LM_ERROR,DLINFO ACE_TEXT ("DAnCE_TargetManager_Module::init - ")
ACE_TEXT ("Narrow to NamingContext return nil for DomainNC.\n")));
return CORBA::Object::_nil ();
}
}
}
catch (CORBA::Exception&)
{
DANCE_DEBUG (DANCE_LOG_ERROR,
(LM_WARNING, DLINFO ACE_TEXT ("DAnCE_TargetManager_Module::init - ")
ACE_TEXT ("DomainNC context not found!\n")));
}
}
DANCE_TRACE_LOG (DANCE_LOG_TRACE, (LM_TRACE, DLINFO ACE_TEXT ("DAnCE_TargetManager_Module::init - ")
ACE_TEXT ("Initializing the IOR Table\n")));
// Initialize IOR table
CORBA::Object_var table_object = orb->resolve_initial_references ("IORTable");
IORTable::Table_var adapter = IORTable::Table::_narrow (table_object.in ());
if (CORBA::is_nil (adapter.in ()))
{
DANCE_ERROR (DANCE_LOG_TERMINAL_ERROR, (LM_ERROR, DLINFO ACE_TEXT ("DAnCE_TargetManager_Module::init - ")
ACE_TEXT ("Unable to RIR the IORTable.\n")));
return CORBA::Object::_nil ();
}
//Creating repository manager servant
DAnCE::TargetManagerDaemon_i * rm = new DAnCE::TargetManagerDaemon_i (orb);
PortableServer::ServantBase_var safe_svt (rm);
ACE_CString repository_manager_oid;
if (this->options_.name_ == 0)
{
repository_manager_oid = "TargetManager";
}
else
{
repository_manager_oid = ACE_TEXT_ALWAYS_CHAR (this->options_.name_);
repository_manager_oid += ".TargetManager";
}
// Registering servant in poa
PortableServer::ObjectId_var oid =
PortableServer::string_to_ObjectId (repository_manager_oid.c_str());
this->rm_poa_->activate_object_with_id (oid, rm);
// Getting repository manager ior
CORBA::Object_var nm_obj = this->rm_poa_->id_to_reference (oid.in ());
CORBA::String_var ior = orb->object_to_string (nm_obj.in ());
// Binding ior to IOR Table
adapter->bind (repository_manager_oid.c_str (), ior.in ());
// Binding repository manager to DomainNC
if (!CORBA::is_nil (this->domain_nc_.in ()))
{
ACE_CString ns_name;
if (this->options_.name_ == 0)
{
ns_name = "TargetManager";
}
else
{
ns_name = ACE_TEXT_ALWAYS_CHAR (this->options_.name_);
}
DANCE_DEBUG (DANCE_LOG_MINOR_EVENT,
(LM_TRACE, DLINFO ACE_TEXT ("DAnCE_TargetManager_Module::init - ")
ACE_TEXT ("Registering NM in NC as \"%C\".\n"), ns_name.c_str ()));
CosNaming::Name name (1);
name.length (1);
name[0].id = CORBA::string_dup (ns_name.c_str ());
name[0].kind = CORBA::string_dup ("TargetManager");
this->domain_nc_->rebind (name, nm_obj.in ());
}
// Writing ior to file
if (0 != this->options_.ior_file_)
{
DANCE_DEBUG (DANCE_LOG_MINOR_EVENT, (LM_TRACE, DLINFO ACE_TEXT ("DAnCE_TargetManager_Module::init - ")
ACE_TEXT ("Writing RM IOR %C to file %C.\n"), this->options_.ior_file_, ior.in ()));
if (!DAnCE::Target_Manager::write_IOR (this->options_.ior_file_, ior.in ()))
DANCE_ERROR (DANCE_LOG_ERROR, (LM_ERROR, DLINFO ACE_TEXT ("DAnCE_TargetManager_Module::init - ")
ACE_TEXT ("Error: Unable to write IOR to file %C\n"),
this->options_.ior_file_));
}
// Activate POA manager
PortableServer::POAManager_var mgr = this->root_poa_->the_POAManager ();
mgr->activate ();
// Finishing Deployment part
DANCE_DEBUG (DANCE_LOG_MAJOR_EVENT, (LM_NOTICE, DLINFO ACE_TEXT ("DAnCE_TargetManager_Module::init - ")
ACE_TEXT ("DAnCE_TargetManager is running...\n")));
DANCE_DEBUG (DANCE_LOG_MAJOR_DEBUG_INFO, (LM_DEBUG, DLINFO ACE_TEXT ("DAnCE_TargetManager_Module::init - ")
ACE_TEXT ("TargetManager IOR: %s\n"), ior.in ()));
return nm_obj._retn ();
}
catch (const CORBA::Exception& ex)
{
DANCE_ERROR (DANCE_LOG_TERMINAL_ERROR,
(LM_EMERGENCY,
ACE_TEXT ("Caught CORBA Exception: %C\n"),
ex._info ().c_str ()));
return CORBA::Object::_nil ();
}
}
int
TAO_MonitorManager::ORBTask::svc (void)
{
try
{
if (CORBA::is_nil (this->orb_.in ()))
{
ORBSVCS_ERROR_RETURN ((LM_ERROR,
"(%P|%t) TAO_MonitorManager: Unable to "
"initialize the ORB\n"),
1);
}
PortableServer::POA_var poa;
{
ACE_GUARD_RETURN (TAO_SYNCH_MUTEX, guard, this->mutex_, -1);
CORBA::Object_var obj =
this->orb_->resolve_initial_references ("RootPOA");
poa = PortableServer::POA::_narrow (obj.in ());
if (CORBA::is_nil (poa.in ()))
{
ORBSVCS_ERROR_RETURN ((LM_ERROR,
"(%P|%t) TAO_MonitorManager: Unable to "
"resolve the RootPOA\n"),
1);
}
PortableServer::POAManager_var poa_manager = poa->the_POAManager ();
poa_manager->activate ();
// Activate the object
NotificationServiceMonitor_i* servant;
ACE_NEW_RETURN (servant,
NotificationServiceMonitor_i (this->orb_.in ()), 1);
PortableServer::ServantBase_var owner_transfer(servant);
PortableServer::ObjectId_var id = poa->activate_object (servant);
// Register the object with the IORTable
obj = poa->id_to_reference (id.in ());
CosNotification::NotificationServiceMonitorControl_var monitor =
CosNotification::NotificationServiceMonitorControl::_narrow (obj.in ());
CORBA::String_var ior = this->orb_->object_to_string (monitor.in ());
obj = this->orb_->resolve_initial_references ("IORTable");
IORTable::Table_var iortable = IORTable::Table::_narrow (obj.in ());
if (CORBA::is_nil (iortable.in ()))
{
ORBSVCS_ERROR_RETURN ((LM_ERROR,
"(%P|%t) TAO_MonitorManager: Unable to "
"resolve the IORTable\n"),
1);
}
iortable->bind(ACE_TEXT_ALWAYS_CHAR(mc_orb_name_.c_str()), ior.in ());
if (this->use_name_svc_)
{
TAO_Naming_Client nc;
nc.init (this->orb_.in ());
CosNaming::Name name (1);
name.length (1);
name[0].id = CORBA::string_dup (ACE_TEXT_ALWAYS_CHAR(mc_orb_name_.c_str()));
nc->rebind (name, monitor.in ());
}
if (this->ior_output_.length () > 0)
{
FILE* fp = ACE_OS::fopen (this->ior_output_.c_str (), "w");
if (fp == 0)
{
ORBSVCS_ERROR_RETURN ((LM_ERROR,
ACE_TEXT ("(%P|%t) TAO_MonitorManager: "
ACE_TEXT ("Unable to write to %s\n")),
this->ior_output_.c_str ()),
1);
}
else
{
ACE_OS::fprintf (fp, "%s", ior.in ());
ACE_OS::fclose (fp);
}
}
}
// R1: race condition (partially fixed):
// TAO_MonitorManager::fini() is called directly after
// TAO_MonitorManager::run(), the shutdown call on the ORB could
// happen but the ORB::run() loop won't exit.
startup_barrier_.wait ();
this->orb_->run ();
ACE_GUARD_RETURN (TAO_SYNCH_MUTEX, guard, this->mutex_, -1);
// Destroy the POA and ORB
if (!CORBA::is_nil (poa.in ()))
{
poa->destroy (true, true);
}
this->orb_->destroy ();
// Set to nil to avoid double shutdown in TAO_MonitorManager::fini()
this->orb_ = CORBA::ORB::_nil ();
}
catch (const CORBA::Exception& ex)
{
if (!CORBA::is_nil (this->orb_.in ()))
{
try
{
this->orb_->shutdown ();
}
catch (...)
{
}
this->orb_ = CORBA::ORB::_nil ();
}
ex._tao_print_exception ("Caught in "
"TAO_MonitorManager::ORBTask::svc");
}
catch (...)
{
if (!CORBA::is_nil (this->orb_.in ()))
{
try
{
this->orb_->shutdown ();
}
catch (...)
{
}
this->orb_ = CORBA::ORB::_nil ();
}
ORBSVCS_ERROR ((LM_ERROR,
"Unexpected exception type caught "
"in TAO_MonitorManager::ORBTask::svc"));
}
return 0;
}
int
TAO_Naming_Server::init_new_naming (CORBA::ORB_ptr orb,
PortableServer::POA_ptr poa,
const ACE_TCHAR *persistence_location,
void *base_addr,
size_t context_size,
int enable_multicast,
int use_storable_context,
int round_trip_timeout,
int use_round_trip_timeout)
{
try
{
#if defined (CORBA_E_MICRO)
ACE_UNUSED_ARG (persistence_location);
ACE_UNUSED_ARG (base_addr);
ACE_UNUSED_ARG (use_storable_context);
#else
if (use_storable_context)
{
// In lieu of a fully implemented service configurator version
// of this Reader and Writer, let's just take something off the
// command line for now.
TAO::Storable_Factory* pf = 0;
ACE_CString directory (ACE_TEXT_ALWAYS_CHAR (persistence_location));
ACE_NEW_RETURN (pf, TAO::Storable_FlatFileFactory (directory), -1);
auto_ptr<TAO::Storable_Factory> persFactory(pf);
// Use an auto_ptr to ensure that we clean up the factory in the case
// of a failure in creating and registering the Activator.
TAO_Storable_Naming_Context_Factory* cf =
this->storable_naming_context_factory (context_size);
// Make sure we got a factory
if (cf == 0) return -1;
auto_ptr<TAO_Storable_Naming_Context_Factory> contextFactory (cf);
// This instance will either get deleted after recreate all or,
// in the case of a servant activator's use, on destruction of the
// activator.
// Was a location specified?
if (persistence_location == 0)
{
// No, assign the default location "NameService"
persistence_location = ACE_TEXT ("NameService");
}
// Now make sure this directory exists
if (ACE_OS::access (persistence_location, W_OK|X_OK))
{
ORBSVCS_ERROR_RETURN ((LM_ERROR, "Invalid persistence directory\n"), -1);
}
#if (TAO_HAS_MINIMUM_POA == 0) && !defined (CORBA_E_COMPACT)
if (this->use_servant_activator_)
{
ACE_NEW_THROW_EX (this->servant_activator_,
TAO_Storable_Naming_Context_Activator (orb,
persFactory.get(),
contextFactory.get (),
persistence_location),
CORBA::NO_MEMORY ());
this->ns_poa_->set_servant_manager(this->servant_activator_);
}
#endif /* TAO_HAS_MINIMUM_POA */
try { // The following might throw an exception.
this->naming_context_ =
TAO_Storable_Naming_Context::recreate_all (orb,
poa,
TAO_ROOT_NAMING_CONTEXT,
context_size,
0,
contextFactory.get (),
persFactory.get (),
use_redundancy_);
}
catch (const CORBA::Exception& ex)
{
// The activator already took over the factories so we need to release the auto_ptr
if (this->use_servant_activator_)
{
// The context factory is now owned by the activator
// so we should release it
contextFactory.release ();
// If using a servant activator, the activator now owns the
// factory, so we should release it
persFactory.release ();
}
// Print out the exception and return failure
ex._tao_print_exception (
"TAO_Naming_Server::init_new_naming");
return -1;
}
// Kind of a duplicate of the above here, but we must also release the
// factory autoptrs in the good case as well.
if (this->use_servant_activator_)
{
// The context factory is now owned by the activator
// so we should release it
contextFactory.release ();
// If using a servant activator, the activator now owns the
// factory, so we should release it
persFactory.release ();
}
}
else if (persistence_location != 0)
//
// Initialize Persistent Naming Service.
//
{
// Create Naming Context Implementation Factory to be used for the creation of
// naming contexts by the TAO_Persistent_Context_Index
TAO_Persistent_Naming_Context_Factory *naming_context_factory =
this->persistent_naming_context_factory ();
// Make sure we got a factory.
if (naming_context_factory == 0) return -1;
// Allocate and initialize Persistent Context Index.
ACE_NEW_RETURN (this->context_index_,
TAO_Persistent_Context_Index (orb, poa, naming_context_factory),
-1);
if (this->context_index_->open (persistence_location,
base_addr) == -1
|| this->context_index_->init (context_size) == -1)
{
if (TAO_debug_level >0)
ORBSVCS_DEBUG ((LM_DEBUG,
"TAO_Naming_Server: context_index initialization failed\n"));
return -1;
}
// Set the root Naming Context reference.
this->naming_context_ =
this->context_index_->root_context ();
}
else
#endif /* CORBA_E_MICRO */
{
//
// Initialize Transient Naming Service.
//
this->naming_context_ =
TAO_Transient_Naming_Context::make_new_context (poa,
TAO_ROOT_NAMING_CONTEXT,
context_size);
}
#if !defined (CORBA_E_MICRO)
// Register with the ORB's resolve_initial_references()
// mechanism. Primarily useful for dynamically loaded Name
// Services.
orb->register_initial_reference ("NameService",
this->naming_context_.in ());
#endif /* CORBA_E_MICRO */
// Set the ior of the root Naming Context.
this->naming_service_ior_=
orb->object_to_string (this->naming_context_.in ());
CORBA::Object_var table_object =
orb->resolve_initial_references ("IORTable");
IORTable::Table_var adapter =
IORTable::Table::_narrow (table_object.in ());
if (CORBA::is_nil (adapter.in ()))
{
ORBSVCS_ERROR ((LM_ERROR, "Nil IORTable\n"));
}
else
{
CORBA::String_var ior =
orb->object_to_string (this->naming_context_.in ());
adapter->bind ("NameService", ior.in ());
}
#if defined (ACE_HAS_IP_MULTICAST)
if (enable_multicast)
{
// @@ Marina: is there anyway to implement this stuff
// without using ORB_Core_instance()? For example can you
// pass the ORB as an argument?
//
// Install ior multicast handler.
//
// Get reactor instance from TAO.
ACE_Reactor *reactor = orb->orb_core()->reactor ();
// See if the -ORBMulticastDiscoveryEndpoint option was specified.
ACE_CString mde (orb->orb_core ()->orb_params ()->mcast_discovery_endpoint ());
// First, see if the user has given us a multicast port number
// on the command-line;
u_short port =
orb->orb_core ()->orb_params ()->service_port (TAO::MCAST_NAMESERVICE);
if (port == 0)
{
// Check environment var. for multicast port.
const char *port_number =
ACE_OS::getenv ("NameServicePort");
if (port_number != 0)
port = static_cast<u_short> (ACE_OS::atoi (port_number));
}
// Port wasn't specified on the command-line or in environment -
// use the default.
if (port == 0)
port = TAO_DEFAULT_NAME_SERVER_REQUEST_PORT;
// Instantiate a handler which will handle client requests for
// the root Naming Context ior, received on the multicast port.
ACE_NEW_RETURN (this->ior_multicast_,
TAO_IOR_Multicast (),
-1);
if (mde.length () != 0)
{
if (this->ior_multicast_->init (this->naming_service_ior_.in (),
mde.c_str (),
TAO_SERVICEID_NAMESERVICE) == -1)
return -1;
}
else
{
if (this->ior_multicast_->init (this->naming_service_ior_.in (),
port,
#if defined (ACE_HAS_IPV6)
ACE_DEFAULT_MULTICASTV6_ADDR,
#else
ACE_DEFAULT_MULTICAST_ADDR,
#endif /* ACE_HAS_IPV6 */
TAO_SERVICEID_NAMESERVICE) == -1)
return -1;
}
// Register event handler for the ior multicast.
if (reactor->register_handler (this->ior_multicast_,
ACE_Event_Handler::READ_MASK) == -1)
{
if (TAO_debug_level > 0)
ORBSVCS_DEBUG ((LM_DEBUG,
"TAO_Naming_Server: cannot register Event handler\n"));
return -1;
}
if (TAO_debug_level > 0)
ORBSVCS_DEBUG ((LM_DEBUG,
"TAO_Naming_Server: The multicast server setup is done.\n"));
}
#else
ACE_UNUSED_ARG (enable_multicast);
#endif /* ACE_HAS_IP_MULTICAST */
#if defined (TAO_HAS_CORBA_MESSAGING) && TAO_HAS_CORBA_MESSAGING != 0
if (use_round_trip_timeout == 1)
{
TimeBase::TimeT roundTripTimeoutVal = round_trip_timeout;
CORBA::Any anyObjectVal;
anyObjectVal <<= roundTripTimeoutVal;
CORBA::PolicyList polList (1);
polList.length (1);
polList[0] = orb->create_policy (Messaging::RELATIVE_RT_TIMEOUT_POLICY_TYPE,
anyObjectVal);
// set a timeout on the orb
//
CORBA::Object_var orbPolicyManagerObj =
orb->resolve_initial_references ("ORBPolicyManager");
CORBA::PolicyManager_var orbPolicyManager =
CORBA::PolicyManager::_narrow (orbPolicyManagerObj.in ());
orbPolicyManager->set_policy_overrides (polList, CORBA::SET_OVERRIDE);
polList[0]->destroy ();
polList[0] = CORBA::Policy::_nil ();
}
#else
ACE_UNUSED_ARG (use_round_trip_timeout);
ACE_UNUSED_ARG (round_trip_timeout);
#endif /* TAO_HAS_CORBA_MESSAGING */
}
catch (const CORBA::Exception& ex)
{
ex._tao_print_exception (
"TAO_Naming_Server::init_new_naming");
return -1;
}
return 0;
}
int
Server_i::init (int &argc,
ACE_TCHAR **argv)
{
this->argc_ = argc;
this->argv_ = argv;
try
{
// First initialize the ORB, that will remove some arguments...
this->orb_ =
CORBA::ORB_init (this->argc_, this->argv_);
// Get a reference to the RootPOA.
CORBA::Object_var poa_object =
this->orb_->resolve_initial_references ("RootPOA");
// Narrow down to the correct reference.
PortableServer::POA_var poa =
PortableServer::POA::_narrow (poa_object.in ());
// Set a POA Manager.
PortableServer::POAManager_var poa_manager =
poa->the_POAManager ();
// Activate the POA Manager.
poa_manager->activate ();
CORBA::String_var ior;
// Create the servant
MCast_Server_i server_i;
// Activate it to obtain the reference
MCast::Server_var mcast_server =
server_i._this ();
CORBA::Object_var table_object =
this->orb_->resolve_initial_references ("IORTable");
IORTable::Table_var adapter =
IORTable::Table::_narrow (table_object.in ());
if (CORBA::is_nil (adapter.in ()))
{
ACE_ERROR ((LM_ERROR, "Nil IORTable\n"));
}
else
{
ior =
this->orb_->object_to_string (mcast_server.in ());
adapter->bind ("MCASTServer", ior.in ());
}
// Enable such that the server can listen for multicast requests
// at the specified address.
if (this->enable_multicast (ior.in ()) != 0)
{
ACE_ERROR ((LM_ERROR,
"ERROR: Unable to enable multicast "
"on specified address.\n"));
throw CORBA::INTERNAL ();
}
// Run the ORB
this->orb_->run ();
//Destroy the POA, waiting until the destruction terminates.
poa->destroy (1, 1);
this->orb_->destroy ();
}
catch (const CORBA::Exception& ex)
{
ex._tao_print_exception ("client");
return 1;
}
return 0;
}
CORBA::Object_ptr
TAO_Trading_Loader::create_object (CORBA::ORB_ptr orb_ptr,
int argc,
ACE_TCHAR *argv[])
{
// Duplicate the ORB
CORBA::ORB_var orb = CORBA::ORB::_duplicate (orb_ptr);
// Activating the poa manager
this->orb_manager_.activate_poa_manager ();
// Create a Trader Object and set its Service Type Repository.
auto_ptr<TAO_Trader_Factory::TAO_TRADER> auto_trader (TAO_Trader_Factory::create_trader (argc, argv));
this->trader_ = auto_trader;
TAO_Support_Attributes_i &sup_attr =
this->trader_->support_attributes ();
TAO_Trading_Components_i &trd_comp =
this->trader_->trading_components ();
sup_attr.type_repos (this->type_repos_._this ());
// The Spec says: return a reference to the Lookup interface from
// the resolve_initial_references method.
CosTrading::Lookup_ptr lookup =
trd_comp.lookup_if ();
this->ior_ =
orb->object_to_string (lookup);
// Parse the args
if (this->parse_args (argc, argv) == -1)
return CORBA::Object::_nil ();
// Dump the ior to a file.
if (this->ior_output_file_ != 0)
{
ACE_OS::fprintf (this->ior_output_file_,
"%s",
this->ior_.in ());
ACE_OS::fclose (this->ior_output_file_);
}
CORBA::Object_var table_object =
orb->resolve_initial_references ("IORTable");
IORTable::Table_var adapter =
IORTable::Table::_narrow (table_object.in ());
if (CORBA::is_nil (adapter.in ()))
{
ORBSVCS_ERROR ((LM_ERROR, "Nil IORTable\n"));
}
else
{
adapter->bind ("TradingService",
this->ior_.in ());
}
if (this->federate_)
{
// Only become a multicast server if we're the only trader
// on the multicast network.
// @@ Could do other things. For example, every timeout
// period try to federate again, but let's not hardcode that
// policy.
int rc = this->bootstrap_to_federation ();
if (rc == -1)
this->init_multicast_server ();
}
else
this->init_multicast_server ();
return CORBA::Object::_nil ();
}
int
ACE_TMAIN(int argc, ACE_TCHAR *argv[])
{
try
{
ACE_DEBUG ((LM_DEBUG, "(%P|%t) server - ORB_init\n"));
CORBA::ORB_var orb =
CORBA::ORB_init (argc, argv);
ACE_DEBUG ((LM_DEBUG, "(%P|%t) server - Obtain RootPOA\n"));
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 ();
ACE_DEBUG ((LM_DEBUG, "(%P|%t) server - parse args\n"));
if (parse_args (argc, argv) != 0)
return 1;
ACE_DEBUG ((LM_DEBUG, "(%P|%t) server - init hello\n"));
Hello *hello_impl = 0;
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 ());
ACE_DEBUG ((LM_DEBUG, "(%P|%t) server - Create the forwarding loop\n"));
CORBA::Object_var iorTableObj =
orb->resolve_initial_references ("IORTable");
IORTable::Table_var iorTable
= IORTable::Table::_narrow (iorTableObj.in ());
// We are using this test with ObjRefStyle == URL ... or at
// least we better be. The IOR is therefore a corbaloc
ACE_CString full_corbaloc (ior.in (), 0, 1);
// Create a corbaloc for an IOR table binding that points to
// itself. Acessing this will make the server reply with LOCATION_FORWARD
// indefinitely.
ACE_DEBUG ((LM_DEBUG, "(%P|%t) server - Corbaloc is\n \"%C\"\n", full_corbaloc.c_str()));
// Get the endpoint info only...
CORBA::ULong first_slash = full_corbaloc.find ("/", 0);
ACE_CString forward_forever = full_corbaloc.substring (0,
first_slash);
// .. add the string we are going to bind against and then bind
forward_forever += "/hello";
iorTable->bind("hello", forward_forever.c_str ());
ACE_DEBUG ((LM_DEBUG, "(%P|%t) server - Forward forever is\n \"%C\"\n", forward_forever.c_str()));
// Output the IORs
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\n",
ior_output_file),
1);
ACE_OS::fprintf (output_file, "%s", ior.in ());
ACE_OS::fclose (output_file);
output_file = ACE_OS::fopen (ior_output_file2, "w");
if (output_file == 0)
ACE_ERROR_RETURN ((LM_ERROR,
"Cannot open output file for writing IOR: %s\n",
ior_output_file2),
1);
ACE_OS::fprintf (output_file, "%s", forward_forever.c_str ());
ACE_OS::fclose (output_file);
poa_manager->activate ();
ACE_DEBUG ((LM_DEBUG, "(%P|%t) server - orb->run()\n"));
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
Event_Logging_Service::init (int argc, ACE_TCHAR *argv[])
{
// initialize the ORB.
this->init_ORB (argc, argv);
if (this->parse_args (argc, argv) == -1)
return -1;
// Activate the event log factory
ACE_NEW_THROW_EX (this->event_log_factory_,
TAO_EventLogFactory_i (),
CORBA::NO_MEMORY ());
DsEventLogAdmin::EventLogFactory_var obj =
this->event_log_factory_->activate (this->orb_.in (),
this->poa_.in ());
ACE_ASSERT (!CORBA::is_nil (obj.in ()));
CORBA::String_var ior =
this->orb_->object_to_string (obj.in ());
if (true)
{
CORBA::Object_var table_object =
this->orb_->resolve_initial_references ("IORTable");
IORTable::Table_var adapter =
IORTable::Table::_narrow (table_object.in ());
adapter->bind("EventLogService", ior.in ());
}
if (this->ior_file_name_ != 0)
{
FILE* iorf = ACE_OS::fopen (this->ior_file_name_, ACE_TEXT("w"));
if (iorf == 0)
{
ORBSVCS_ERROR_RETURN ((LM_ERROR,
"Cannot open output file for writing IOR: %s",
this->ior_file_name_),
-1);
}
ACE_OS::fprintf (iorf, "%s\n", ior.in ());
ACE_OS::fclose (iorf);
}
if (this->pid_file_name_ != 0)
{
FILE* pidf = ACE_OS::fopen (this->pid_file_name_, ACE_TEXT("w"));
if (pidf != 0)
{
ACE_OS::fprintf (pidf,
"%ld\n",
static_cast<long> (ACE_OS::getpid ()));
ACE_OS::fclose (pidf);
}
}
if (this->bind_to_naming_service_)
{
// Resolve the naming service.
this->resolve_naming_service ();
// Register the Event Log Factory.
CosNaming::Name name (1);
name.length (1);
name[0].id = CORBA::string_dup (this->service_name_.c_str ());
this->naming_->rebind (name, obj.in ());
}
return 0;
}
int
ACE_TMAIN (int argc, ACE_TCHAR *argv[])
{
try {
CORBA::ORB_var orb = CORBA::ORB_init(argc, argv);
int init_delay_secs = 0;
int num_requests_expected = 0;
ACE_Get_Opt get_opts (argc, argv, ACE_TEXT ("d:n:?"));
int c;
while ((c = get_opts ()) != -1)
switch (c)
{
case 'd':
init_delay_secs = ACE_OS::atoi (get_opts.opt_arg ());
break;
case 'n':
num_requests_expected = ACE_OS::atoi (get_opts.opt_arg ());
break;
case '?':
ACE_DEBUG ((LM_DEBUG,
"usage: %s "
"-d <seconds to delay before initializing POA> ",
"-n <number of expected requests> \n",
argv[0]));
return 1;
break;
}
ACE_DEBUG ((LM_DEBUG,
"Delaying in initialization for %d seconds\n",
init_delay_secs));
ACE_OS::sleep (init_delay_secs);
ACE_DEBUG ((LM_DEBUG,
"Done with delay\n"));
CORBA::Object_var obj = orb->resolve_initial_references("RootPOA");
PortableServer::POA_var root_poa = PortableServer::POA::_narrow(obj.in());
PortableServer::POAManager_var mgr = root_poa->the_POAManager();
ACE_CString poa_name("TestObject");
PortableServer::POA_var test_poa = createPOA(root_poa.in(),
poa_name.c_str ());
PortableServer::Servant_var<Test_i> test_servant =
new Test_i(num_requests_expected);
PortableServer::ObjectId_var object_id =
PortableServer::string_to_ObjectId("test_object");
//
// Activate the servant with the test POA,
// obtain its object reference, and get a
// stringified IOR.
//
test_poa->activate_object_with_id(object_id.in(), test_servant.in());
//
// Create binding between "TestService" and
// the test object reference in the IOR Table.
// Use a TAO extension to get the non imrified poa
// to avoid forwarding requests back to the ImR.
TAO_Root_POA* tpoa = dynamic_cast<TAO_Root_POA*>(test_poa.in());
if (!tpoa)
{
ACE_ERROR ((LM_ERROR,
ACE_TEXT ("Could not cast POA to root POA")
));
return -1;
}
obj = tpoa->id_to_reference_i(object_id.in(), false);
CORBA::String_var test_ior = orb->object_to_string(obj.in());
obj = orb->resolve_initial_references("IORTable");
IORTable::Table_var table = IORTable::Table::_narrow(obj.in());
table->bind(poa_name.c_str (), test_ior.in());
//
// This server is now ready to run.
// This version does not create an IOR
// file as demonstrated in the
// Developer's Guide. It assumes that
// users create IORs for the client using
// the tao_imr utility.
//
//
// Stop discarding requests.
//
mgr->activate();
ACE_DEBUG ((LM_DEBUG,
"\n Started Server %s \n",
poa_name.c_str()));
{
ACE_CString status_file = poa_name + ACE_CString(".status");
ofstream out(status_file.c_str ());
out << "started" << endl;
}
orb->run();
root_poa->destroy(1,1);
orb->destroy();
}
catch(const CORBA::Exception& ex) {
ex._tao_print_exception ("Server main()");
return 1;
}
bool expected_requests_made = Test_i::expected_requests_made ();
if (!expected_requests_made)
{
ACE_ERROR ((LM_ERROR,
"ERROR: Expected number of requests were not made\n"));
}
int status = expected_requests_made ? 0 : -1;
return status;
}
int
ACE_TMAIN (int argc, ACE_TCHAR *argv[])
{
try
{
// The usual server side boilerplate code.
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 ();
// "built-in" strategies are the following:
// 0 = RoundRobin
// 1 = Random
// 2 = LeastLoaded
int default_strategy = 1;
// Check the non-ORB arguments.
::parse_args (argc,
argv,
default_strategy);
TAO_LB_LoadManager * lm = 0;
ACE_NEW_THROW_EX (lm,
TAO_LB_LoadManager(::ping_timeout_milliseconds,
::ping_interval_seconds),
CORBA::NO_MEMORY (
CORBA::SystemException::_tao_minor_code (
TAO::VMCID,
ENOMEM),
CORBA::COMPLETED_NO));
PortableServer::ServantBase_var safe_lm = lm;
// Initalize the LoadManager servant.
lm->initialize (orb->orb_core ()->reactor (),
orb.in (),
root_poa.in ());
PortableGroup::Properties props (1);
props.length (1);
props[0].nam.length (1);
props[0].nam[0].id =
CORBA::string_dup ("org.omg.CosLoadBalancing.StrategyInfo");
CosLoadBalancing::StrategyInfo strategy_info;
switch (default_strategy)
{
case 0:
strategy_info.name = CORBA::string_dup ("RoundRobin");
break;
case 1:
strategy_info.name = CORBA::string_dup ("Random");
break;
case 2:
strategy_info.name = CORBA::string_dup ("LeastLoaded");
break;
default:
ORBSVCS_ERROR_RETURN ((LM_ERROR,
ACE_TEXT ("ERROR: LoadBalancer internal error.\n")
ACE_TEXT (" Unknown built-in strategy.\n")),
-1);
}
props[0].val <<= strategy_info;
lm->set_default_properties (props);
CosLoadBalancing::LoadManager_var load_manager =
lm->_this ();
CORBA::String_var str =
orb->object_to_string (load_manager.in ());
// to support corbaloc
// Get a reference to the IOR table.
CORBA::Object_var tobj = orb->resolve_initial_references ("IORTable");
IORTable::Table_var table = IORTable::Table::_narrow (tobj.in ());
// bind your stringified IOR in the IOR table
table->bind ("LoadManager", str.in ());
FILE * lm_ior = ACE_OS::fopen (lm_ior_file, "w");
ACE_OS::fprintf (lm_ior, "%s", str.in ());
ACE_OS::fclose (lm_ior);
#if defined (linux) && defined (ACE_HAS_THREADS)
if (ACE_Thread_Manager::instance ()->spawn (::TAO_LB_run_load_manager,
orb.in ()) == -1)
{
ORBSVCS_ERROR_RETURN ((LM_ERROR,
"ERROR: Unable to spawn TAO LoadManager's "
"ORB thread.\n"),
-1);
}
ACE_Sig_Set sigset;
sigset.sig_add (SIGINT);
sigset.sig_add (SIGTERM);
int signum = -1;
// Block waiting for the registered signals.
if (ACE_OS::sigwait (sigset, &signum) == -1)
{
ORBSVCS_ERROR_RETURN ((LM_ERROR,
"(%P|%t) %p\n",
"ERROR waiting on signal"),
-1);
}
ACE_ASSERT (signum == SIGINT || signum == SIGTERM);
#else
// Activate/register the signal handler that (attempts) to
// ensure graceful shutdown of the LoadManager so that remote
// resources created by the LoadManager can be cleaned up.
TAO_LB_Signal_Handler signal_handler (orb.in (), root_poa.in ());
if (signal_handler.activate () != 0)
{
ORBSVCS_ERROR_RETURN ((LM_ERROR,
"Error: can't activate LB signal handler, exiting.\n"),
-1);
}
// @@ There is a subtle race condition here. If the signal
// handler thread shuts down the ORB before it is run, the
// below call to ORB::run() will throw a CORBA::BAD_INV_ORDER
// exception.
orb->run ();
// Wait for the signal handler thread to finish
// before the process exits.
signal_handler.wait ();
#endif /* linux && ACE_HAS_THREADS */
orb->destroy ();
}
// catch (const PortableGroup::InvalidProperty& ex)
// {
// ORBSVCS_DEBUG ((LM_DEBUG, "Property ----> %s\n", ex.nam[0].id.in ()));
// }
catch (const CORBA::Exception& ex)
{
ex._tao_print_exception ("TAO Load Manager");
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;
MyInterfaceImpl *test_impl = 0;
ACE_NEW_RETURN (test_impl,
MyInterfaceImpl (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 ());
MyInterface_var test_ref =
MyInterface::_narrow (object.in ());
CORBA::String_var ior =
orb->object_to_string (test_ref.in ());
// Output the IOR to the <ior_output_file>
FILE *output_file= ACE_OS::fopen (ior_output_file, "w");
if (output_file != 0)
{
ACE_OS::fprintf (output_file, "%s", ior.in ());
ACE_OS::fclose (output_file);
}
poa_manager->activate ();
CORBA::Object_var table_object =
orb->resolve_initial_references ("IORTable");
IORTable::Table_var adapter =
IORTable::Table::_narrow (table_object.in ());
if (CORBA::is_nil (adapter.in ()))
{
ACE_ERROR ((LM_ERROR, "Nil IORTable\n"));
}
else
{
adapter->bind ("collocated_ior_bound_in_remote_iortable",
ACE_TEXT_ALWAYS_CHAR(client_ior));
}
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;
}