void
TAO_FT_Naming_Server::combine_iors (FT_Naming::EntityKind kind, CORBA::Object_ptr peer)
{
size_t local = ROOT;
size_t combo = FT_ROOT;
if (kind == FT_Naming::obj_grp)
{
local = GROUP;
combo = FT_GROUP;
}
CORBA::Object_var IORM =
this->orb_->resolve_initial_references (TAO_OBJID_IORMANIPULATION, 0);
TAO_IOP::TAO_IOR_Manipulation_var iorm =
TAO_IOP::TAO_IOR_Manipulation::_narrow (IORM.in ());
bool peer_nil = CORBA::is_nil (peer);
bool local_nil = CORBA::is_nil (this->iors_[local].ref_.in ());
if (peer_nil || local_nil)
{
if (peer_nil)
{
this->assign (combo, false, this->iors_[local].ref_.in());
}
}
else
{
if (this->server_role_ == PRIMARY)
{
this->assign (combo, false, iorm->add_profiles (this->iors_[local].ref_.in (),
peer));
}
else
{
this->assign (combo, false, iorm->add_profiles (peer,
this->iors_[local].ref_.in ()));
}
}
if (CORBA::is_nil (this->iors_[combo].ref_.in ()) && TAO_debug_level > 0)
{
ORBSVCS_ERROR((LM_ERROR,
ACE_TEXT("(%P|%t) ERROR: could not combine")
ACE_TEXT(" primary and backup IORs for")
ACE_TEXT(" fault tolerant Naming Service.\n")));
}
this->write (size_t(combo));
}
CORBA::Object_ptr
make_iogr (const char* domain_id, CORBA::ULongLong group_id, CORBA::ULong group_version, Test::Hello_var *refs)
{
FT::TagFTGroupTaggedComponent ft_tag_component;
// Create the list
TAO_IOP::TAO_IOR_Manipulation::IORList iors (number_of_servers);
iors.length(number_of_servers);
for (CORBA::ULong i = 0; i < number_of_servers; ++i)
{
iors [i] = CORBA::Object::_duplicate (refs[i].in ());
}
CORBA::Object_var new_ref =
iorm->merge_iors (iors);
// Property values
// Major and Minor revision numbers
ft_tag_component.component_version.major = (CORBA::Octet) 1;
ft_tag_component.component_version.minor = (CORBA::Octet) 0;
// Domain id
//const char *id = "iogr_testing";
ft_tag_component.group_domain_id = domain_id;
// Object group id
ft_tag_component.object_group_id = group_id;
// Version
ft_tag_component.object_group_ref_version = group_version;
// Construct the IOGR Property class
TAO_FT_IOGR_Property iogr_prop (ft_tag_component);
// Set the property
CORBA::Boolean retval = iorm->set_property (&iogr_prop,
new_ref.in ());
// Set the primary
// See we are setting the second ior as the primary
if (retval != 0)
{
retval = iorm->set_primary (&iogr_prop,
refs[0].in (),
new_ref.in ());
}
return new_ref._retn ();
}
int
Manager::make_merged_iors (void)
{
// First server
this->object_primary_ =
this->orb_->string_to_object (first_ior);
//Second server
this->object_secondary_ =
this->orb_->string_to_object (second_ior);
// Get an object reference for the ORBs IORManipultion object!
CORBA::Object_var IORM =
this->orb_->resolve_initial_references (TAO_OBJID_IORMANIPULATION,
0);
iorm =
TAO_IOP::TAO_IOR_Manipulation::_narrow (IORM.in());
// Create the list
TAO_IOP::TAO_IOR_Manipulation::IORList iors (2);
iors.length(2);
iors [0] = CORBA::Object::_duplicate (this->object_primary_.in ());
iors [1] = CORBA::Object::_duplicate (this->object_secondary_.in ());
// Create a merged set 1;
merged_set_ =
iorm->merge_iors (iors);
return 0;
}
int
Manager::set_properties (void)
{
FT::TagFTGroupTaggedComponent ft_tag_component;
// Property values
// Major and Minor revision numbers
ft_tag_component.component_version.major = (CORBA::Octet) 1;
ft_tag_component.component_version.minor = (CORBA::Octet) 0;
// Domain id
const char *id = "iogr_testing";
ft_tag_component.group_domain_id = id;
// Object group id
ft_tag_component.object_group_id =
(CORBA::ULongLong) 10;
// Version
ft_tag_component.object_group_ref_version =
(CORBA::ULong) 5;
// Construct the IOGR Property class
TAO_FT_IOGR_Property iogr_prop (ft_tag_component);
// Set the property
CORBA::Boolean retval = iorm->set_property (&iogr_prop,
this->merged_set_.in ());
// Set the primary
// See we are setting the second ior as the primary
if (retval != 0)
{
retval = iorm->set_primary (&iogr_prop,
this->object_secondary_.in (),
this->merged_set_.in ());
}
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;
// Primary server
CORBA::Object_var object_primary =
orb->string_to_object (ior);
//Secondary server
CORBA::Object_var object_secondary =
orb->string_to_object (name);
// Get an object reference for the ORBs IORManipultion object!
CORBA::Object_var IORM =
orb->resolve_initial_references (TAO_OBJID_IORMANIPULATION, 0);
TAO_IOP::TAO_IOR_Manipulation_var iorm =
TAO_IOP::TAO_IOR_Manipulation::_narrow (IORM.in ());
TAO_IOP::TAO_IOR_Manipulation::IORList iors (2);
iors.length(2);
iors [0] = object_primary;
iors [1] = object_secondary;
CORBA::Object_var merged = iorm->merge_iors (iors);
CORBA::Object_var object =
orb->resolve_initial_references ("PolicyCurrent");
CORBA::PolicyCurrent_var policy_current =
CORBA::PolicyCurrent::_narrow (object.in ());
CORBA::Any timeout_as_any;
timeout_as_any <<= timeout_period;
CORBA::PolicyList policy_list (1);
policy_list.length (1);
policy_list[0] =
orb->create_policy (TAO::CONNECTION_TIMEOUT_POLICY_TYPE,
timeout_as_any);
policy_current->set_policy_overrides (policy_list,
CORBA::ADD_OVERRIDE);
for (CORBA::ULong l = 0;
l != policy_list.length ();
++l)
{
policy_list[l]->destroy ();
}
// Combined IOR stuff
Simple_Server_var server =
Simple_Server::_narrow (merged.in ());
if (CORBA::is_nil (server.in ()))
{
ACE_ERROR_RETURN ((LM_ERROR,
"Object reference <%s> is nil.\n",
ior),
1);
}
CORBA::ULongLong freq =
run_test (server.in ());
if (freq != 919263)
ACE_ERROR ((LM_ERROR,
ACE_TEXT ("(%P|%t) ERROR in the test\n")));
ACE_DEBUG ((LM_DEBUG,
ACE_TEXT ("(%P|%t) Shutting server down\n")));
server->shutdown ();
}
catch (const CORBA::Exception& ex)
{
ex._tao_print_exception ("Caught an exception\n");
return -1;
}
return 0;
}
int
ACE_TMAIN(int argc, ACE_TCHAR *argv[])
{
int Status = 0;
ACE_DEBUG ((LM_DEBUG, "---------------------------------------------\n"));
ACE_DEBUG ((LM_DEBUG, "Running the IORManipulation Tests.\n"));
try
{
// Retrieve the ORB.
CORBA::ORB_var orb_ = CORBA::ORB_init (argc,
argv);
// **********************************************************************
// Get an object reference for the ORBs IORManipulation object!
CORBA::Object_var IORM =
orb_->resolve_initial_references ("IORManipulation");
TAO_IOP::TAO_IOR_Manipulation_var iorm =
TAO_IOP::TAO_IOR_Manipulation::_narrow (IORM.in ());
// **********************************************************************
// Create a few fictitious IORs
CORBA::Object_var name1 =
orb_->string_to_object ("corbaloc:iiop:macarena.cs.wustl.edu:6060/xyz");
CORBA::Object_var name2 =
orb_->string_to_object ("corbaloc:iiop:tango.cs.wustl.edu:7070/xyz");
// **********************************************************************
CORBA::String_var name1_ior =
orb_->object_to_string (name1.in ());
ACE_DEBUG ((LM_DEBUG, "\tFirst made up IOR = %C\n", name1_ior.in ()));
CORBA::String_var name2_ior =
orb_->object_to_string (name2.in ());
ACE_DEBUG ((LM_DEBUG, "\tSecond made up IOR = %C\n", name2_ior.in ()));
// **********************************************************************
// Create IOR list for use with merge_iors.
TAO_IOP::TAO_IOR_Manipulation::IORList iors (2);
iors.length (2);
iors [0] = name1;
iors [1] = name2;
CORBA::Object_var merged = iorm->merge_iors (iors);
CORBA::String_var merged_ior =
orb_->object_to_string (merged.in ());
CORBA::ULong count1 = iorm->get_profile_count (iors [0]);
CORBA::ULong count2 = iorm->get_profile_count (iors [1]);
CORBA::ULong count = iorm->get_profile_count (merged.in ());
if (count != (count1 + count2))
ACE_DEBUG ((LM_ERROR,
"**ERROR (merge_profiles): "
"Merged profile count incorrect!\n"));
ACE_DEBUG ((LM_DEBUG, "\tMerged IOR(%d) = %C\n",
count,
merged_ior.in ()));
// is_in_ior throws an exception if the intersection of the two
// IORs is NULL.
CORBA::ULong in_count = iorm->is_in_ior (merged.in (),
name1.in ());
if (count1 != in_count)
ACE_DEBUG ((LM_ERROR,
"**ERROR (merge_iors): name1 is_in_ior returned profile "
"count bad (%d)!\n",
in_count));
in_count = iorm->is_in_ior (merged.in (),
name2.in ());
if (count2 != in_count)
ACE_DEBUG ((LM_ERROR,
"**ERROR (merge_iors): name2 is_in_ior returned profile "
"count bad (%d)!\n",
in_count));
// **********************************************************************
// Verify ability to remove profiles from an IOR
// First remove the second IOR from the merged IOR
CORBA::Object_var just1 =
iorm->remove_profiles (merged.in (), name2.in ());
CORBA::String_var just1_ior =
orb_->object_to_string (just1.in ());
count = iorm->get_profile_count (just1.in ());
if (count1 != count)
ACE_DEBUG ((LM_ERROR,
"**ERROR (merge_profiles): "
"removing last IOR after a merge_iors ()\n"));
ACE_DEBUG ((LM_DEBUG,
"\tJust 1 IOR(%d) = %C\n",
count,
just1_ior.in ()));
in_count = iorm->is_in_ior (just1.in (), name1.in ());
if (count1 != in_count)
ACE_DEBUG ((LM_ERROR,
"**ERROR (merge_profiles): incorrect count returned for "
"is_in_ior"
"\nafter removal (%d)\n",
in_count));
// **********************************************************************
// Now try the add_profiles interface.
CORBA::Object_var merged2 =
iorm->add_profiles (just1.in (), name2.in ());
count = iorm->get_profile_count (merged2.in ());
if (count != (count1 + count2))
ACE_DEBUG ((LM_ERROR,
"**ERROR: add_profile failed profile count test!\n"));
CORBA::String_var merged2_ior =
orb_->object_to_string (merged2.in ());
ACE_DEBUG ((LM_DEBUG,
"\tAdding 2 back in IOR(%d) = %C\n",
count,
merged2_ior.in ()));
// is_in_ior throws an exception if the intersection of the two
// IORs is NULL.
in_count = iorm->is_in_ior (merged2.in (), name1. in ());
if (count1 != in_count)
ACE_DEBUG ((LM_ERROR,
"**ERROR (add_profiles): is_in_ior returned profile "
"count bad (%d)!\n",
in_count));
in_count = iorm->is_in_ior (merged2.in (), name2.in ());
if (count2 != in_count)
ACE_DEBUG ((LM_ERROR,
"**ERROR (add_profiles): is_in_ior returned "
"profile count bad!\n"));
// **********************************************************************
CORBA::Object_var just2 =
iorm->remove_profiles (merged2.in (), name1.in ());
CORBA::String_var just2_ior =
orb_->object_to_string (just2.in ());
count = iorm->get_profile_count (just2.in ());
if (count2 != count)
ACE_DEBUG ((LM_ERROR,
"ERROR removing last IOR after a merge_iors ()\n"));
ACE_DEBUG ((LM_DEBUG, "\tJust 2 IOR(%d) = %C\n",
count,
just2_ior.in ()));
in_count = iorm->is_in_ior (just2.in (), name2.in ());
if (count2 != in_count)
ACE_DEBUG ((LM_ERROR,
"**ERROR (add_profiles): incorrect count (%d) "
"returned for is_in_ior after removal\n",
in_count));
// all the primary tests worked, set status to 1
Status = 1;
// Finally generate an exception and quit.
// This will generate a NotFound exception.
in_count = iorm->is_in_ior (just2.in (), name1.in ());
}
catch (const TAO_IOP::EmptyProfileList& userex)
{
userex._tao_print_exception ("Unexpected EmptyProfileList Exception!\n");
return -1;
}
catch (const TAO_IOP::NotFound& userex)
{
if (Status == 1)
{
Status = 2;
// @@ Don't use ACE_PRINT_EXCEPTION here since it will print
// "EXCEPTION" somewhere in the output which will make
// our auto-compile/test scripts think that an unexpected
// exception occurred. Instead, simply print the
// exception ID.
// -Ossama
ACE_DEBUG ((LM_DEBUG,
"Caught <TAO_IOP::TAO_IOR_Manipulation::NotFound> exception.\n"
"This exception was expected.\n\n"));
}
else
{
userex._tao_print_exception ("Unexpected NotFound Exception!\n");
return -1;
}
}
catch (const TAO_IOP::Duplicate& userex)
{
userex._tao_print_exception ("Unexpected Duplicate Exception!\n");
return -1;
}
catch (const TAO_IOP::Invalid_IOR& userex)
{
userex._tao_print_exception ("Unexpected Invalid_IOR Exception!\n");
return -1;
}
catch (const CORBA::SystemException& sysex)
{
sysex._tao_print_exception ("Unexpected system Exception!!\n");
return -1;
}
catch (const CORBA::Exception& ex)
{
ex._tao_print_exception ("Unexpected CORBA Exception!\n");
return -1;
}
if (Status == 1)
{
// then exception didn't work!
ACE_DEBUG ((LM_ERROR,
"**ERROR: Unable to generate the NotFound exception!\n"));
Status = 0;
}
if (Status == 0)
{
ACE_DEBUG ((LM_DEBUG, "An ERROR occured during the tests!\n"));
return -1;
}
else
ACE_DEBUG ((LM_DEBUG, "IORManipulation Tests Successfully Completed!\n"));
ACE_DEBUG ((LM_DEBUG, "---------------------------------------------\n"));
return 0;
}
void
add_ft_prop (CORBA::ORB_ptr o,
CORBA::Object_ptr obj1,
CORBA::Object_ptr obj2)
{
// Get an object reference for the ORBs IORManipultion object!
CORBA::Object_var IORM =
o->resolve_initial_references (TAO_OBJID_IORMANIPULATION,
0);
TAO_IOP::TAO_IOR_Manipulation_var iorm =
TAO_IOP::TAO_IOR_Manipulation::_narrow (IORM.in());
FT::TagFTGroupTaggedComponent ft_tag_component;
// Property values
// Major and Minor revision numbers
ft_tag_component.component_version.major = (CORBA::Octet) 1;
ft_tag_component.component_version.minor = (CORBA::Octet) 0;
// Domain id
const char *id = "version_testing";
ft_tag_component.group_domain_id = id;
// Object group id
ft_tag_component.object_group_id =
(CORBA::ULongLong) 10;
// Version
ft_tag_component.object_group_ref_version =
(CORBA::ULong) 1;
// Construct the IOGR Property class
TAO_FT_IOGR_Property iogr_prop (ft_tag_component);
// Set the property for object 1
CORBA::Boolean retval = iorm->set_property (&iogr_prop,
obj1);
if (retval != 0)
{
retval = iorm->set_primary (&iogr_prop,
obj1,
obj1);
}
// Set the property for object 2
// Change the version. That is the point of this test
// Version
ft_tag_component.object_group_ref_version = (CORBA::ULong) 5;
retval = iorm->set_property (&iogr_prop,
obj2);
if (retval != 0)
{
retval = iorm->set_primary (&iogr_prop,
obj2,
obj2);
}
return;
}
int
ACE_TMAIN(int argc, ACE_TCHAR *argv[])
{
ACE_DEBUG ((LM_DEBUG, "---------------------------------------------\n"));
ACE_DEBUG ((LM_DEBUG, "Running the IOGRManipulation Tests.\n"));
try
{
// Retrieve the ORB.
CORBA::ORB_var orb_ = CORBA::ORB_init (argc, argv);
// **********************************************************************
// Get an object reference for the ORBs IORManipulation object!
CORBA::Object_var IORM =
orb_->resolve_initial_references (TAO_OBJID_IORMANIPULATION, 0);
TAO_IOP::TAO_IOR_Manipulation_var iorm =
TAO_IOP::TAO_IOR_Manipulation::_narrow (IORM.in ());
// **********************************************************************
// Create a few fictitious IORs
CORBA::Object_var name1 =
orb_->string_to_object ("iiop://acme.cs.wustl.edu:6060/xyz");
CORBA::Object_var name2 =
orb_->string_to_object ("iiop://tango.cs.wustl.edu:7070/xyz");
// **********************************************************************
// Create IOR list for use with merge_iors.
TAO_IOP::TAO_IOR_Manipulation::IORList iors (2);
iors.length (2);
iors [0] = name1;
iors [1] = name2;
// **********************************************************************
CORBA::Object_var merged = iorm->merge_iors (iors);
// Check for set and get primaries
// Make a dummy property set
FT::TagFTGroupTaggedComponent ft_tag_component;
TAO_FT_IOGR_Property prop (ft_tag_component);
CORBA::Boolean retval =
iorm->set_primary (&prop, name2.in (), merged.in ());
if (retval != 0)
{
ACE_DEBUG ((LM_DEBUG,
ACE_TEXT ("\tThe primary has been set\n")));
}
else
{
ACE_ERROR ((LM_ERROR,
ACE_TEXT ("\tError in setting primary\n")));
return -1;
}
// Check whether a primary has been set
retval = iorm->is_primary_set (&prop, merged.in ());
if (retval)
{
ACE_DEBUG ((LM_DEBUG,
ACE_TEXT ("\tis_primary_set () returned true\n")));
}
else
{
ACE_ERROR ((LM_ERROR,
ACE_TEXT ("\tis_primary_set () returned false\n")));
ACE_ERROR ((LM_ERROR,
ACE_TEXT ("\tSo Exiting\n")));
return -1;
}
// Get the primary
CORBA::Object_var prim = iorm->get_primary (&prop, merged.in ());
// Check whether we got back the right primary
if (prim->_is_equivalent (name2.in ()))
{
ACE_DEBUG ((LM_DEBUG,
ACE_TEXT ("\tWe got the right primary back\n")));
}
else
{
ACE_ERROR ((LM_ERROR,
ACE_TEXT ("\tWe have a problem in getting the right primary\n")));
ACE_ERROR ((LM_ERROR,
ACE_TEXT ("\tSo exiting\n")));
return -1;
}
// **********************************************************************
// Set properties
// Property values
// Major and Minor revision numbers
ft_tag_component.component_version.major = (CORBA::Octet) 1;
ft_tag_component.component_version.minor = (CORBA::Octet) 0;
// Domain id
const char *id = "iogr_regression";
ft_tag_component.group_domain_id = id;
// Object group id
ft_tag_component.object_group_id = (CORBA::ULongLong) 10;
// Version
ft_tag_component.object_group_ref_version = (CORBA::ULong) 5;
// Set the property
retval = iorm->set_property (&prop, merged.in ());
/// Extract the property
FT::TagFTGroupTaggedComponent ftc;
TAO_FT_IOGR_Property tmp_prop;
retval = tmp_prop.get_tagged_component (merged.in (), ftc);
ACE_DEBUG ((LM_DEBUG,
"(%P|%t) Testing for tagged component\n"));
if ((ftc.object_group_ref_version != 5) &&
(ftc.object_group_id != 10))
ACE_ERROR ((LM_ERROR,
"%P|%t) Not working right\n"));
if (retval)
ACE_DEBUG ((LM_DEBUG,
ACE_TEXT ("\tWe have set the property\n")));
orb_->destroy ();
}
catch (const TAO_IOP::NotFound& userex)
{
userex._tao_print_exception (
ACE_TEXT ("Unexpected NotFound Exception!\n"));
return -1;
}
catch (const TAO_IOP::Duplicate& userex)
{
userex._tao_print_exception ("Unexpected Duplicate Exception!\n");
return -1;
}
catch (const TAO_IOP::Invalid_IOR& userex)
{
userex._tao_print_exception ("Unexpected Invalid_IOR Exception!\n");
return -1;
}
catch (const CORBA::SystemException& sysex)
{
sysex._tao_print_exception ("Unexpected system Exception!!\n");
return -1;
}
catch (const CORBA::Exception& ex)
{
ex._tao_print_exception ("Unexpected CORBA Exception!\n");
return -1;
}
ACE_DEBUG ((LM_DEBUG, "IORManipulation Tests Successfully Completed!\n"));
ACE_DEBUG ((LM_DEBUG, "---------------------------------------------\n"));
return 0;
}
int ACE_TMAIN (int argc, ACE_TCHAR *argv[])
{
try
{
// initialize the ORB
_orb = CORBA::ORB_init (argc, argv);
// Get the "RootPOA"
CORBA::Object_var obj = _orb->resolve_initial_references("RootPOA");
PortableServer::POA_var poa = PortableServer::POA::_narrow(obj.in ());
// activate its managers so it can handle incoming requests
poa->the_POAManager()->activate();
// get a thread going to handle incoming requests
ACE_Thread::spawn(RunFunc);
// we could also use the c_orbaloc syntax to get a reference to the
// object. This will cause the _orb to talk directly to the other
// _orb with no name service or common file involved.
obj = _orb->string_to_object("c_orbaloc::localhost:9999/Simple");
if (CORBA::is_nil(obj.in ()))
{
ACE_ERROR ((LM_ERROR, "could not get reference\n"));
return 1;
}
// narrow the reference to the particular type we wish to deal with
Simple_var simple = Simple::_narrow(obj.in ());
if (CORBA::is_nil(simple.in ()))
{
ACE_ERROR ((LM_ERROR, "could not get reference\n"));
return 1;
}
// create an object reference that has a bogus value for the first
// profile
obj = _orb->resolve_initial_references("IORManipulation");
TAO_IOP::TAO_IOR_Manipulation_var iorm =
TAO_IOP::TAO_IOR_Manipulation::_narrow(obj.in());
// Status: The following scenarios appear to work:
// - first profile invalid host name, second profile valid.
// - first profile invalid ip number, second profiel valid.
// - first profiel invalid port number, second profile valid.
//
// The following causes a core dump of the server:
// - first and second invalid
//
// Note that he iormanip is being used since it is not practical
// to have a test case that depends on a VPN being present.
//
CORBA::Object_var name1 =
_orb->string_to_object ("c_orbaloc:iiop:10.0.2.3:6060/xyz");
CORBA::Object_var name2 =
_orb->string_to_object ("c_orbaloc:iiop:daisnot:7070/xyz");
CORBA::String_var name1_ior = _orb->object_to_string(name1.in());
CORBA::String_var name2_ior = _orb->object_to_string(name2.in());
// create a callback object
Callee_i * callee_i = new Callee_i;
// get the CORBA reference
PortableServer::ObjectId_var id =
poa->activate_object (callee_i);
CORBA::Object_var object_act = poa->id_to_reference (id.in ());
Callee_var callee = Callee::_narrow (object_act.in ());
if (CORBA::is_nil(callee.in ()))
{
ACE_ERROR ((LM_ERROR, "could not get callback object\n"));
return 1;
}
else
{
CORBA::String_var str = _orb->object_to_string(callee.in ());
FILE *output_file= ACE_OS::fopen ("ior", "w");
if (output_file == 0)
ACE_ERROR_RETURN ((LM_ERROR,
"Cannot open output file for writing IOR: ior\n"),
1);
ACE_OS::fprintf (output_file, "%s", str.in ());
ACE_OS::fclose (output_file);
}
// create a reference with two profiles with the first on being
// bogus. If things work as they should the callback should be
// succesful with the ORB trying the second profile.
TAO_IOP::TAO_IOR_Manipulation::IORList iors (2);
iors.length (2);
iors [0] = name1;
iors [1] = name2;
CORBA::Object_var merged = iorm->merge_iors(iors);
Callee_var doubleCallee = Callee::_unchecked_narrow(merged.in());
ACE_DEBUG ((LM_DEBUG, "Profile count is %d\n",
iorm->get_profile_count(merged.in())));
simple->registerCallee(doubleCallee.in ());
ACE_OS::sleep(120);
ACE_DEBUG ((LM_DEBUG, "done sleeping\n"));
_orb->shutdown(1);
}
catch (const ::CORBA::Exception &ex)
{
ex._tao_print_exception("Caught unexpected CORBA exception :");
}
return 0;
}