CORBA::Object_ptr TAO::Object_Group_Creator::create_infrastructure_managed_group ( const char * type_id) { CORBA::Object_var group = CORBA::Object::_nil (); if (this->have_replication_manager_) { // set typeid properties PortableGroup::Properties properties (1); properties.length (3); properties[0].nam.length (1); properties[0].nam[0].id = PortableGroup::PG_MEMBERSHIP_STYLE; properties[0].val <<= PortableGroup::MEMB_INF_CTRL; PortableGroup::InitialNumberMembersValue inm(2); properties[1].nam.length (1); properties[1].nam[0].id = PortableGroup::PG_INITIAL_NUMBER_MEMBERS; properties[1].val <<= inm; PortableGroup::MinimumNumberMembersValue mnm(1); properties[2].nam.length (1); properties[2].nam[0].id = PortableGroup::PG_MINIMUM_NUMBER_MEMBERS; properties[2].val <<= mnm; this->replication_manager_->set_type_properties ( type_id, properties); ::PortableGroup::GenericFactory::FactoryCreationId_var creation_id; PortableGroup::Criteria criteria (1); criteria.length (1); criteria[0].nam.length (1); criteria[0].nam[0].id = PortableGroup::PG_MEMBERSHIP_STYLE; criteria[0].val <<= PortableGroup::MEMB_APP_CTRL; group = this->replication_manager_->create_object ( type_id, criteria, creation_id ); } else { ACE_ERROR ((LM_ERROR, ACE_TEXT("%T %n (%P|%t): Object_Group_Creator: infrastructure managed group requires Replication Manager\n") )); } return group._retn (); }
PortableGroup::ObjectGroup_ptr TAO_PG_ObjectGroupManager::create_object_group ( CORBA::ULong group_id, const PortableServer::ObjectId &oid, const char * type_id, const PortableGroup::Criteria & the_criteria) { if (CORBA::is_nil (this->poa_.in ())) throw CORBA::INTERNAL (); // Create a reference for the ObjectGroup corresponding to the // RepositoryId of the object being created. CORBA::Object_var object_group = this->poa_->create_reference_with_id (oid, type_id); TAO_PG_ObjectGroup_Map_Entry * group_entry = 0; ACE_NEW_THROW_EX (group_entry, TAO_PG_ObjectGroup_Map_Entry, CORBA::NO_MEMORY ( CORBA::SystemException::_tao_minor_code ( TAO::VMCID, ENOMEM), CORBA::COMPLETED_NO)); auto_ptr<TAO_PG_ObjectGroup_Map_Entry> safe_group_entry (group_entry); // Set the RepositoryId associated with the created ObjectGroup_Map // entry. group_entry->type_id = CORBA::string_dup (type_id); group_entry->group_id = group_id; group_entry->object_group = object_group; CORBA::ULong len = the_criteria.length (); group_entry->properties.length (len); for (CORBA::ULong i = 0; i < len; ++i) group_entry->properties[i] = the_criteria[i]; { ACE_GUARD_RETURN (TAO_SYNCH_MUTEX, guard, this->lock_, 0); if (this->object_group_map_.bind (oid, group_entry) != 0) throw PortableGroup::ObjectNotCreated (); } (void) safe_group_entry.release (); return object_group._retn (); }
int LB_server::create_object_group (void) { try { const char *repository_id = "IDL:Test/Basic:1.0"; PortableGroup::Criteria criteria (1); criteria.length (1); PortableGroup::Property &property = criteria[0]; property.nam.length (1); property.nam[0].id = CORBA::string_dup ("org.omg.PortableGroup.MembershipStyle"); PortableGroup::MembershipStyleValue msv = PortableGroup::MEMB_APP_CTRL; property.val <<= msv; this->object_group_ = this->lm_->create_object (repository_id, criteria, this->fcid_.out ()); CORBA::String_var ior = this->orb_->object_to_string (this->object_group_.in ()); this->write_ior_to_file (ior.in ()); } catch (const CORBA::Exception& ex) { ex._tao_print_exception ( "Exception raised while creating object group"); return -1; } return 1; }
CORBA::Object_ptr TAO::Object_Group_Creator::create_group ( const char * role, int write_iors) { CORBA::Object_var group = CORBA::Object::_nil (); PortableGroup::ObjectGroupId group_id = 0; CORBA::String_var type_id; ::PortableGroup::FactoryInfos_var infos = this->registry_->list_factories_by_role (role, type_id); CORBA::ULong count = infos->length (); ACE_ERROR ((LM_INFO, ACE_TEXT ("%T %n (%P|%t): Object_Group_Creator: ") ACE_TEXT ("found %u factories for %s : %s\n"), static_cast<unsigned> (count), role, type_id.in ())); if (count > 0) { /////////////////////////// // Begin with an empty IOGR ::PortableGroup::GenericFactory::FactoryCreationId_var creation_id; if (this->have_replication_manager_) { ////////////////////////////////////////////////////// // note infrastructure controlled because we want the // ReplicationManager to manage the object after it's created. // Initial number members = 0 because we do not want the Replication // Manager to populate the group. // Minimum number of members = 0 because we do not want the // Replication Manager to replace failed members. // Semi-active, because that's what we do. PortableGroup::Criteria criteria (3); criteria.length (4); criteria[0].nam.length (1); criteria[0].nam[0].id = PortableGroup::PG_MEMBERSHIP_STYLE; criteria[0].val <<= PortableGroup::MEMB_INF_CTRL; criteria[1].nam.length (1); criteria[1].nam[0].id = PortableGroup::PG_INITIAL_NUMBER_MEMBERS; criteria[1].val <<= PortableGroup::InitialNumberMembersValue (0); criteria[2].nam.length (1); criteria[2].nam[0].id = PortableGroup::PG_MINIMUM_NUMBER_MEMBERS; criteria[2].val <<= PortableGroup::MinimumNumberMembersValue (0); criteria[3].nam.length (1); criteria[3].nam[0].id = FT::FT_REPLICATION_STYLE; criteria[3].val <<= FT::SEMI_ACTIVE; group = this->replication_manager_->create_object ( type_id.in (), criteria, creation_id ); //@@ this is a bit of a hack creation_id >>= group_id; }
CORBA::Object_ptr join_object_group (CORBA::ORB_ptr orb, CosLoadBalancing::LoadManager_ptr lm, const PortableGroup::Location & location) { CORBA::Object_var ns_object = orb->resolve_initial_references ("NameService"); CosNaming::NamingContext_var nc = CosNaming::NamingContext::_narrow (ns_object.in ()); CosNaming::Name name (1); name.length (1); name[0].id = "RoundtripObjectGroup"; name[0].kind = "Object Group"; CORBA::Object_var group; try { group = nc->resolve (name); } catch (const CosNaming::NamingContext::NotFound& ) { // Object group not created. Create one. const char repository_id[] = "IDL:Test/Roundtrip:1.0"; PortableGroup::Criteria criteria (1); criteria.length (1); PortableGroup::Property & property = criteria[0]; property.nam.length (1); property.nam[0].id = CORBA::string_dup ("org.omg.PortableGroup.MembershipStyle"); PortableGroup::MembershipStyleValue msv = PortableGroup::MEMB_APP_CTRL; property.val <<= msv; PortableGroup::GenericFactory::FactoryCreationId_var fcid; group = lm->create_object (repository_id, criteria, fcid.out ()); try { nc->bind (name, group.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; strategy_info.name = CORBA::string_dup (strategy); if (ACE_OS::strcasecmp (strategy, "LeastLoaded") == 0 && (reject_threshold != 0 || critical_threshold != 0 || dampening != 0)) { CORBA::ULong len = 1; PortableGroup::Properties & props = strategy_info.props; if (reject_threshold != 0) { const CORBA::ULong i = len - 1; props.length (len++); props[i].nam.length (1); props[i].nam[0].id = CORBA::string_dup ("org.omg.CosLoadBalancing.Strategy.LeastLoaded.RejectThreshold"); props[i].val <<= reject_threshold; } if (critical_threshold != 0) { const CORBA::ULong i = len - 1; props.length (len++); props[i].nam.length (1); props[i].nam[0].id = CORBA::string_dup ("org.omg.CosLoadBalancing.Strategy.LeastLoaded.CriticalThreshold"); props[i].val <<= critical_threshold; } if (dampening != 0) { const CORBA::ULong i = len - 1; props.length (len++); props[i].nam.length (1); props[i].nam[0].id = CORBA::string_dup ("org.omg.CosLoadBalancing.Strategy.LeastLoaded.Dampening"); props[i].val <<= dampening; } } props[0].val <<= strategy_info; lm->set_default_properties (props); } catch (const CosNaming::NamingContext::AlreadyBound& ) { // Somebody beat us to creating the object group. Clean up // the one we created. lm->delete_object (fcid.in ()); group = nc->resolve (name); } } Roundtrip * roundtrip_impl; ACE_NEW_THROW_EX (roundtrip_impl, Roundtrip (orb), CORBA::NO_MEMORY ()); PortableServer::ServantBase_var owner_transfer (roundtrip_impl); Test::Roundtrip_var roundtrip = roundtrip_impl->_this (); group = lm->add_member (group.in (), location, roundtrip.in ()); return group._retn (); }
int NS_group_svc::group_create ( const ACE_TCHAR* group_name, const ACE_TCHAR* policy ) { if (group_name == 0 || policy == 0 ) { ORBSVCS_ERROR_RETURN ((LM_ERROR, ACE_TEXT ("group_create args not provided\n")), -2); } /// Validate load balancing strategy policy string FT_Naming::LoadBalancingStrategyValue strategy; if (false == determine_policy_string (policy, strategy)) { ORBSVCS_ERROR_RETURN ((LM_ERROR, ACE_TEXT ("%s is not a valid policy.\n"), policy), -2); } try { /// Verify that the group does not already exist /// Group names must be unique if ( true == group_exist (group_name)) { ORBSVCS_ERROR_RETURN ((LM_ERROR, ACE_TEXT ("Group %s already exists\n"), group_name), -1); } PortableGroup::Criteria criteria (1); criteria.length (1); PortableGroup::Property &property = criteria[0]; property.nam.length (1); property.nam[0].id = CORBA::string_dup ( "org.omg.PortableGroup.MembershipStyle"); PortableGroup::MembershipStyleValue msv = PortableGroup::MEMB_APP_CTRL; property.val <<= msv; CORBA::Object_var obj = this->naming_manager_->create_object_group ( ACE_TEXT_ALWAYS_CHAR (group_name), strategy, criteria); if (CORBA::is_nil (obj.in ())) { ORBSVCS_ERROR_RETURN ((LM_ERROR, ACE_TEXT ("\nUnable to create group %s.\n"), group_name), -1); } } catch (const CORBA::Exception&) { ORBSVCS_ERROR_RETURN ((LM_ERROR, ACE_TEXT ("\nUnable to create group %s\n"), group_name), -1); } return 0; }
CORBA::Boolean TAO_LB_ObjectReferenceFactory::find_object_group ( const char * repository_id, CORBA::ULong & index, PortableGroup::ObjectGroup_out object_group) { if (!this->load_managed_object (repository_id, index)) return false; PortableGroup::ObjectGroup_var group; if (this->table_.find (repository_id, group) != 0) { if (ACE_OS::strcasecmp (this->object_groups_[index], "CREATE") == 0) { PortableGroup::Criteria criteria (1); criteria.length (1); PortableGroup::Property & property = criteria[0]; property.nam.length (1); property.nam[0].id = CORBA::string_dup ("org.omg.PortableGroup.MembershipStyle"); // Configure for application-controlled membership. PortableGroup::MembershipStyleValue msv = PortableGroup::MEMB_APP_CTRL; property.val <<= msv; PortableGroup::GenericFactory::FactoryCreationId_var fcid; group = this->lm_->create_object (repository_id, criteria, fcid.out ()); CORBA::ULong const len = this->fcids_.size (); this->fcids_.size (len + 1); // Incremental growth. Yuck! this->fcids_[len] = fcid; } else { group = this->orb_->string_to_object (this->object_groups_[index]); } if (this->table_.bind (repository_id, group) != 0) { if (TAO_debug_level > 0) ORBSVCS_ERROR ((LM_ERROR, "TAO_LB_ObjectReferenceFactory::" "find_object_group - " "Couldn't bind object group reference.\n")); throw CORBA::INTERNAL (); } object_group = group._retn (); } return 1; }