void TAO::PG_Property_Set::export_properties(PortableGroup::Properties & property_set) const
{
ValueMap merged_values;
this->merge_properties (merged_values);
property_set.length (merged_values.current_size ());
size_t pos = 0;
for (ValueMapIterator it = merged_values.begin ();
it != merged_values.end ();
++it)
{
const ACE_CString & name = (*it).ext_id_;
const PortableGroup::Value * value = (*it).int_id_;
PortableGroup::Property & property = property_set[pos];
CosNaming::Name & nsName = property.nam;
//@@ note assumption: single level name, no kind
nsName.length(1);
CosNaming::NameComponent & nc = nsName[0];
nc.id = CORBA::string_dup (name.c_str ());
PortableGroup::Value & val = property.val;
val = *value; // NOTE: Any assignment does a deep copy
++pos;
}
ACE_ASSERT (pos == property_set.length ());
}
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 ();
}
void
TAO_PG_PropertyManager::set_default_properties (
const PortableGroup::Properties & props)
{
// First verify that the "Factories" property is not in the
// Properties sequence. According to the spec, it is not allowed to
// be set as part of the default properties.
PortableGroup::Name factories;
factories.length (1);
factories[0].id = CORBA::string_dup ("org.omg.PortableGroup.Factories");
CORBA::ULong len = props.length ();
for (CORBA::ULong i = 0; i < len; ++i)
{
PortableGroup::Property property = props[i];
if (property.nam == factories)
throw PortableGroup::InvalidProperty (property.nam, property.val);
}
this->property_validator_.validate_property (props);
ACE_GUARD (TAO_SYNCH_MUTEX, guard, this->lock_);
this->default_properties_ = props;
}
void
TAO_PG_PropertyManager::remove_default_properties (
const PortableGroup::Properties &props)
{
if (props.length () == 0)
return; // @@ Throw CORBA::BAD_PARAM instead?
ACE_GUARD (TAO_SYNCH_MUTEX, guard, this->lock_);
this->remove_properties (props,
this->default_properties_);
}
void
TAO_PG_PropertyManager::remove_properties (
const PortableGroup::Properties & to_be_removed,
PortableGroup::Properties &properties)
{
const CORBA::ULong num_removed = to_be_removed.length ();
if (num_removed == 0)
return; // @@ Throw CORBA::BAD_PARAM instead?
const CORBA::ULong old_length = properties.length ();
const CORBA::ULong new_length = old_length - num_removed;
PortableGroup::Properties new_properties (new_length);
new_properties.length (new_length);
// @@ Slow O(n^2) operation. Switching to a faster container for
// the default properties might be a good idea at some point in
// the future.
CORBA::ULong n = 0;
for (CORBA::ULong i = 0; i < num_removed; ++i)
{
const CORBA::ULong old_n = n;
const PortableGroup::Property &remove = to_be_removed[i];
for (CORBA::ULong j = 0; j < old_length; ++j)
if (remove.nam != properties[j].nam)
new_properties[n++] = properties[j];
// The property to be removed doesn't exist in the current list
// of default properties.
if (n == old_n)
throw PortableGroup::InvalidProperty (remove.nam, remove.val);
}
// All properties were successfully removed, and the remaining ones
// were placed in the "new_properties" variable. Now copy that
// variable.
properties = new_properties;
}
void
TAO::PG_Property_Set::decode (const PortableGroup::Properties & property_set)
{
ACE_GUARD (TAO_SYNCH_MUTEX, guard, this->internals_);
size_t count = property_set.length ();
for (size_t nItem = 0; nItem < count; ++nItem)
{
const PortableGroup::Property & property = property_set[nItem];
const CosNaming::Name & nsName = property.nam;
// note assumption one level name with no kind
// @@ TODO: fix this
const CosNaming::NameComponent & nc = nsName[0];
this->set_property (static_cast<const char *> (nc.id),
property.val);
#if 0
ACE_CString name = static_cast<const char *> (nc.id);
const PortableGroup::Value * value_copy;
ACE_NEW_THROW_EX (value_copy,
PortableGroup::Value (property.val),
CORBA::NO_MEMORY ());
const PortableGroup::Value * replaced_value = 0;
if (0 == this->values_.rebind (name, value_copy, replaced_value))
{
if (0 != replaced_value)
{
delete replaced_value;
}
}
else
{
if (TAO_debug_level > 3)
{
ORBSVCS_ERROR ( (LM_ERROR,
"%n\n%T: Property_set: rebind failed.\n"
));
}
// @@ should throw something here
throw CORBA::NO_MEMORY ();
}
#endif
}
}
void
TAO_PG_PropertyManager::remove_type_properties (
const char * type_id,
const PortableGroup::Properties & props)
{
if (props.length () == 0)
return; // @@ Throw CORBA::BAD_PARAM instead?
ACE_GUARD (TAO_SYNCH_MUTEX, guard, this->lock_);
Type_Prop_Table::ENTRY * entry = 0;
if (this->type_properties_.find (type_id, entry) != 0)
throw CORBA::BAD_PARAM ();
PortableGroup::Properties & type_properties = entry->int_id_;
this->remove_properties (props,
type_properties);
}
void
TAO_PG_PropertyManager::set_type_properties (
const char * type_id,
const PortableGroup::Properties & overrides)
{
this->property_validator_.validate_property (overrides);
CORBA::ULong num_overrides = overrides.length ();
if (num_overrides == 0)
return; // Throw CORBA::BAD_PARAM exception instead?
ACE_GUARD (TAO_SYNCH_MUTEX, guard, this->lock_);
Type_Prop_Table::ENTRY * entry = 0;
if (this->type_properties_.find (type_id, entry) != 0)
throw CORBA::BAD_PARAM ();
PortableGroup::Properties & props = entry->int_id_;
props = overrides;
}
void TAO::PG_Property_Set::remove (const PortableGroup::Properties & property_set)
{
ACE_GUARD (TAO_SYNCH_MUTEX, guard, this->internals_);
size_t count = property_set.length ();
for (size_t nItem = 0; nItem < count; ++nItem)
{
const PortableGroup::Property & property = property_set[nItem];
const CosNaming::Name & nsName = property.nam;
// note assumption one level name with no kind
// @@ TODO: fix this
const CosNaming::NameComponent & nc = nsName[0];
ACE_CString name = static_cast<const char *> (nc.id);
const PortableGroup::Value * deleted_value;
if ( 0 == this->values_.unbind (name, deleted_value))
{
delete deleted_value;
}
else
{
// don't worry about it.
}
}
}
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;
}
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 ();
}
