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; }