TAO_PG_GenericFactory Class Reference

PortableGroup::GenericFactory implementation used by the load balancer when creating object groups. More...

#include <PG_GenericFactory.h>

Inheritance diagram for TAO_PG_GenericFactory:

[legend]Collaboration diagram for TAO_PG_GenericFactory:

[legend]List of all members.

Public Member Functions
	TAO_PG_GenericFactory (TAO_PG_ObjectGroupManager &object_group_map, TAO_PG_PropertyManager &property_manager)
	Constructor.
	~TAO_PG_GenericFactory (void)
	Destructor.
void	poa (PortableServer::POA_ptr p)
	Set the POA to use when creating object references.
void	delete_object_i (TAO_PG_Factory_Set &factory_set, CORBA::Boolean ignore_exceptions)
void	delete_member (CORBA::ULong group_id, const PortableGroup::Location &location)
void	check_minimum_number_members (PortableGroup::ObjectGroup_ptr object_group, CORBA::ULong group_id, const char *type_id)
	Verify that the MinimumNumberMembers criterion is satisfied.
PortableGroup::GenericFactory::FactoryCreationId *	create_member (PortableGroup::ObjectGroup_ptr object_group, const PortableGroup::FactoryInfo &factory_info, const char *type_id, const CORBA::Boolean propagate_member_already_present)
TAO_LoadBalancer::GenericFactory methods
virtual CORBA::Object_ptr	create_object (const char *type_id, const PortableGroup::Criteria &the_criteria, PortableGroup::GenericFactory::FactoryCreationId_out factory_creation_id)
virtual void	delete_object (const PortableGroup::GenericFactory::FactoryCreationId &factory_creation_id)
Private Member Functions
void	populate_object_group (PortableGroup::ObjectGroup_ptr object_group, const char *type_id, const PortableGroup::FactoryInfos &factory_infos, PortableGroup::InitialNumberMembersValue initial_number_members, TAO_PG_Factory_Set &factory_set)
void	get_ObjectId (CORBA::ULong fcid, PortableServer::ObjectId_out oid)
	Get a new ObjectId to be used when creating a new ObjectGroup.
void	process_criteria (const char *type_id, const PortableGroup::Criteria &criteria, PortableGroup::MembershipStyleValue &membership_style, PortableGroup::FactoriesValue &factory_infos, PortableGroup::InitialNumberMembersValue &initial_number_members, PortableGroup::MinimumNumberMembersValue &minimum_number_members)
Private Attributes
PortableServer::POA_var	poa_
	Reference to the POA used to create object group references.
TAO_PG_ObjectGroupManager &	object_group_manager_
	Reference to the ObjectGroup map.
TAO_PG_PropertyManager &	property_manager_
	Reference to the PropertyManager.
TAO_PG_Factory_Map	factory_map_
	Table that maps FactoryCreationId to TAO_PG_Factory_Set.
CORBA::ULong	next_fcid_
TAO_SYNCH_MUTEX	lock_

---

Detailed Description

PortableGroup::GenericFactory implementation used by the load balancer when creating object groups.

This GenericFactory creates an object group reference for given set of replicas. Those replicas will be created by this GenericFactory if the "infrastructure-controlled" membership style is configured.

Definition at line 50 of file PG_GenericFactory.h.

---

Constructor & Destructor Documentation

TAO_BEGIN_VERSIONED_NAMESPACE_DECL TAO_PG_GenericFactory::TAO_PG_GenericFactory	(	TAO_PG_ObjectGroupManager &	object_group_map,
		TAO_PG_PropertyManager &	property_manager
	)

Constructor.

Definition at line 19 of file PG_GenericFactory.cpp.

  : poa_ (),
    object_group_manager_ (object_group_manager),
    property_manager_ (property_manager),
    factory_map_ (TAO_PG_MAX_OBJECT_GROUPS),
    next_fcid_ (0),
    lock_ ()
{
  this->object_group_manager_.generic_factory (this);
}

TAO_PG_GenericFactory::~TAO_PG_GenericFactory

(

void

)

Destructor.

Definition at line 32 of file PG_GenericFactory.cpp.

References factory_map_.

{

  TAO_PG_Factory_Map::iterator end = this->factory_map_.end ();
  for (TAO_PG_Factory_Map::iterator i = this->factory_map_.begin ();
       i != end;
       ++i)
    {
      TAO_PG_Factory_Set & factory_set = (*i).int_id_;

      try
        {
          this->delete_object_i (factory_set,
                                 1 /* Ignore exceptions */);
        }
      catch (const CORBA::Exception&)
        {
          // Ignore all exceptions.
        }
    }

  (void) this->factory_map_.close ();
}

---

Member Function Documentation

void TAO_PG_GenericFactory::check_minimum_number_members	(	PortableGroup::ObjectGroup_ptr	object_group,
		CORBA::ULong	group_id,
		const char *	type_id
	)

Verify that the MinimumNumberMembers criterion is satisfied.

If the current number of members in the given object group is less than the MinimumNumberMembers criterion in effect for that group, the infrastructure will attempt create and add more members to the group by invoking any unused application-supplied GenericFactorys.

Definition at line 546 of file PG_GenericFactory.cpp.

References create_member(), TAO_PG_PropertyManager::get_properties(), TAO_PG::get_property_value(), TAO_PG_ObjectGroupManager::member_count(), object_group_manager_, property_manager_, ACE_Array_Base< T >::size(), and CORBA::string_dup().

Referenced by TAO_PG_ObjectGroupManager::remove_member().

{
  // Check if we've dropped below the MinimumNumberMembers threshold.
  // If so, attempt to create enough new members to fill the gap.

  // If no entry exists in the factory map, infrastructure (this
  // GenericFactory implementation) controlled membership was not
  // used.
  TAO_PG_Factory_Map::ENTRY *entry = 0;
  if (this->factory_map_.find (group_id, entry) != 0)
    return;

  TAO_PG_Factory_Set & factory_set = entry->int_id_;

  PortableGroup::Properties_var props =
    this->property_manager_.get_properties (object_group);

  PortableGroup::Name name (1);
  name.length (1);

  PortableGroup::Value value;

  // MinimumNumberMembers
  name[0].id =
    CORBA::string_dup ("org.omg.PortableGroup.MinimumNumberMembers");

  PortableGroup::MinimumNumberMembersValue minimum_number_members;

  if (TAO_PG::get_property_value (name, props.in (), value))
    {
      if (!(value >>= minimum_number_members))
        {
          // This only occurs if extraction of the actual value from
          // the Any fails.  It shouldn't fail at this point.
          throw CORBA::INTERNAL ();
        }

      const CORBA::ULong count =
        this->object_group_manager_.member_count (object_group);

      if (count >= static_cast<CORBA::ULong> (minimum_number_members))
        return;

      const CORBA::ULong gap =
        static_cast<CORBA::ULong> (minimum_number_members) - count;

      CORBA::ULong creation_count = 0;

      const size_t len = factory_set.size ();

      static const PortableGroup::GenericFactory::FactoryCreationId *
        nil_fcid = 0;

      for (size_t i = 0; i < len; ++i)
        {
          TAO_PG_Factory_Node & node = factory_set[i];

          PortableGroup::GenericFactory::FactoryCreationId * const tmp_fcid =
            node.factory_creation_id;

          // Check if the application supplied GenericFactory was
          // already invoked.
          if (tmp_fcid != nil_fcid)
            continue;

          try
            {
              const CORBA::Boolean propagate_member_already_present = 1;

              node.factory_creation_id =
                this->create_member (object_group,
                                     node.factory_info,
                                     type_id,
                                     propagate_member_already_present);

              ++creation_count;

              // Check if the MinimumNumberMembers threshold gap has
              // been filled.
              if (gap == creation_count)
                return;
            }
          catch (const PortableGroup::MemberAlreadyPresent&)
            {
              // Ignore this exception and continue.
            }
        }

      // @todo If we get this far, and the MinimumNumberMembers
      //       threshold gap hasn't been filled, what do we do?  Throw
      //       a CORBA::TRANSIENT?
    }
}

PortableGroup::GenericFactory::FactoryCreationId * TAO_PG_GenericFactory::create_member	(	PortableGroup::ObjectGroup_ptr	object_group,
		const PortableGroup::FactoryInfo &	factory_info,
		const char *	type_id,
		const CORBA::Boolean	propagate_member_already_present
	)

Note:

This method is only used by the infrastructure.

Definition at line 644 of file PG_GenericFactory.cpp.

References TAO_PG_ObjectGroupManager::_tao_add_member(), TAO_Pseudo_Var_T< T >::in(), CORBA::is_nil(), object_group_manager_, PortableGroup::FactoryInfo::the_criteria, PortableGroup::FactoryInfo::the_factory, and PortableGroup::FactoryInfo::the_location.

Referenced by check_minimum_number_members(), and populate_object_group().

{
  PortableGroup::GenericFactory::FactoryCreationId_var fcid;

  CORBA::Object_var member =
    factory_info.the_factory->create_object (type_id,
                                             factory_info.the_criteria,
                                             fcid.out ());

  try
    {
      // @@ Should an "_is_a()" be performed here?  While it
      //    appears to be the right thing to do, it can be
      //    expensive.
      //
      // Make sure an Object of the correct type was created.
      // It is possible that an object of the wrong type was
      // created if the type_id parameter does not match the
      // type of object the GenericFactory creates.
      CORBA::Boolean right_type_id =
        member->_is_a (type_id);

      // @todo Strategize this -- e.g. strict type checking.
      if (!right_type_id)
        {
          // An Object of incorrect type was created.  Delete
          // it, and throw a NoFactory exception.
          factory_info.the_factory->delete_object (fcid.in ());

          throw PortableGroup::NoFactory (factory_info.the_location, type_id);
        }

      this->object_group_manager_._tao_add_member (
        object_group,
        factory_info.the_location,
        member.in (),
        type_id,
        propagate_member_already_present);
    }
  catch (const CORBA::Exception&)
    {
      // If the member reference is not nil, then the factory
      // was successfully invoked.  Since an exception was
      // thrown, clean up the up created member.
      if (!CORBA::is_nil (member.in ()))
        {
          factory_info.the_factory->delete_object (fcid.in ());
        }

      throw;
    }

  return fcid._retn ();
}

CORBA::Object_ptr TAO_PG_GenericFactory::create_object	(	const char *	type_id,
		const PortableGroup::Criteria &	the_criteria,
		PortableGroup::GenericFactory::FactoryCreationId_out	factory_creation_id
	)			[virtual]

Create an object of the specified type that adheres to the restrictions defined by the provided Criteria. The out FactoryCreationId parameter may be passed to the delete_object() method to delete the object.

Definition at line 57 of file PG_GenericFactory.cpp.

References CORBA::Object::_nil(), CORBA::SystemException::_tao_minor_code(), ACE_GUARD_RETURN, ACE_NEW_THROW_EX, CORBA::COMPLETED_NO, TAO_PG_ObjectGroupManager::create_object_group(), delete_object_i(), TAO_PG_ObjectGroupManager::destroy_object_group(), get_ObjectId(), TAO_PG_PropertyManager::get_type_properties(), PortableGroup::MEMB_INF_CTRL, next_fcid_, object_group_manager_, populate_object_group(), process_criteria(), property_manager_, TAO_PG_INITIAL_NUMBER_MEMBERS, TAO_PG_MEMBERSHIP_STYLE, TAO_PG_MINIMUM_NUMBER_MEMBERS, TAO_SYNCH_MUTEX, and TAO::VMCID.

{
  PortableGroup::Properties_var properties =
    this->property_manager_.get_type_properties (type_id);

  PortableGroup::MembershipStyleValue membership_style =
    TAO_PG_MEMBERSHIP_STYLE;
  PortableGroup::FactoriesValue factory_infos(0);

  PortableGroup::InitialNumberMembersValue initial_number_members =
    TAO_PG_INITIAL_NUMBER_MEMBERS;
  PortableGroup::MinimumNumberMembersValue minimum_number_members =
    TAO_PG_MINIMUM_NUMBER_MEMBERS;

  // Make sure the criteria for the object group being created are
  // valid.
  this->process_criteria (type_id,
                          the_criteria,
                          membership_style,
                          factory_infos,
                          initial_number_members,
                          minimum_number_members);

  CORBA::ULong fcid = 0;

  {
    ACE_GUARD_RETURN (TAO_SYNCH_MUTEX,
                      guard,
                      this->lock_,
                      CORBA::Object::_nil ());

    // Start out with an initial value.
    fcid = this->next_fcid_;

    // Loop until a free FactoryCreationId is found, being careful to
    // search through the range of FactoryCreationIds only once.
    while (this->factory_map_.find (this->next_fcid_) == 0)
      {
        this->next_fcid_++;

        // If this is true, then no FactoryCreationIds are available.
        // This is highly unlikely since TAO implements a
        // FactoryCreationId as a 32 bit unsigned integer, meaning
        // that over 4 billion object groups are being managed by this
        // generic factory!
        if (this->next_fcid_ == fcid)
          throw PortableGroup::ObjectNotCreated ();
      }

    // Just in case this->next_fcid_ was modified in the above search,
    // reassign the value.
    fcid = this->next_fcid_;
  }

  // The ObjectId for the newly created object group is comprised
  // solely of the FactoryCreationId.
  PortableServer::ObjectId_var oid;
  this->get_ObjectId (fcid, oid.out ());

  PortableGroup::ObjectGroup_var object_group =
    this->object_group_manager_.create_object_group (fcid,
                                                     oid.in (),
                                                     type_id,
                                                     the_criteria);

  TAO_PG_Factory_Set factory_set;

  const CORBA::ULong factory_infos_count = factory_infos.length ();

  try
    {
      if (factory_infos_count > 0
          && membership_style == PortableGroup::MEMB_INF_CTRL)
        {
          this->populate_object_group (object_group.in (),
                                       type_id,
                                       factory_infos,
                                       initial_number_members,
                                       factory_set);

          if (this->factory_map_.bind (fcid, factory_set) != 0)
            throw PortableGroup::ObjectNotCreated ();

        }

      // Allocate a new FactoryCreationId for use as an "out" parameter.
      PortableGroup::GenericFactory::FactoryCreationId * tmp = 0;
      ACE_NEW_THROW_EX (tmp,
                        PortableGroup::GenericFactory::FactoryCreationId,
                        CORBA::NO_MEMORY (
                          CORBA::SystemException::_tao_minor_code (
                            TAO::VMCID,
                            ENOMEM),
                          CORBA::COMPLETED_NO));

      factory_creation_id = tmp;

      *tmp <<= fcid;
    }
  catch (const CORBA::Exception&)
    {
      this->delete_object_i (factory_set,
                             1 /* Ignore exceptions */);

      this->object_group_manager_.destroy_object_group (oid.in ());

      throw;
    }

  {
    ACE_GUARD_RETURN (TAO_SYNCH_MUTEX,
                      guard,
                      this->lock_,
                      CORBA::Object::_nil ());

    // Object group was successfully created.  Increment the next
    // FactoryCreationId in preparation for the next object group.
    this->next_fcid_++;
  }

  return object_group._retn ();
}

void TAO_PG_GenericFactory::delete_member	(	CORBA::ULong	group_id,
		const PortableGroup::Location &	location
	)

This method is only used by the TAO_PG_ObjectGroupManager class when ObjectGroupManager::remove_member() is explicitly called.

Definition at line 273 of file PG_GenericFactory.cpp.

References ACE_GUARD, TAO_SYNCH_MUTEX, PortableGroup::FactoryInfo::the_factory, and PortableGroup::FactoryInfo::the_location.

Referenced by TAO_PG_ObjectGroupManager::remove_member().

{
  ACE_GUARD (TAO_SYNCH_MUTEX, guard, this->lock_);

  // If no entry exists in the factory map, infrastructure
  // controlled membership was not used.
  TAO_PG_Factory_Map::ENTRY *entry = 0;
  if (this->factory_map_.find (group_id, entry) == 0)
    {
      TAO_PG_Factory_Set & factory_set = entry->int_id_;

      const size_t len = factory_set.size ();

      // Iterate through the factory_set until a location match
      // occurs.  If a location match occurs, the member was created
      // by the infrastructure, i.e. this GenericFactory
      // implementation.  If no location matches, the member was
      // created by the application, and no operation will be
      // performed.
      //
      // @todo This is linear search.  Change to use a container with
      //       better search times.
      for (size_t i = 0; i < len; ++i)
        {
          TAO_PG_Factory_Node & node = factory_set[i];
          PortableGroup::FactoryInfo & info = node.factory_info;

          if (info.the_location == location)
            {
              info.the_factory->delete_object (node.factory_creation_id.in ());

              // The member has been successfully deleted.  Reduce the
              // size of the factory_set accordingly.
              if (len > 1)
                {
                  // Move the last element to the location of the
                  // current one and reduce the size of the set by
                  // one.
                  const size_t new_len = len - 1;
                  node = factory_set[new_len]; // Memberwise copy
                  factory_set.size (new_len);
                }
              else
                {
                  // A copy isn't necessary if the last member was
                  // deleted.
                  factory_set.size (0);
                }

              return;
            }
        }
    }
}

void TAO_PG_GenericFactory::delete_object

(

const PortableGroup::GenericFactory::FactoryCreationId &

factory_creation_id

)

[virtual]

Delete the object corresponding to the provided FactoryCreationId. If the object is actually an ObjectGroup, then all members within the ObjectGroup will be deleted. Afterward, the ObjectGroup itself will be deleted.

Definition at line 184 of file PG_GenericFactory.cpp.

References ACE_GUARD, TAO_PG_ObjectGroupManager::destroy_object_group(), get_ObjectId(), object_group_manager_, and TAO_SYNCH_MUTEX.

{
  CORBA::ULong fcid = 0;

  if (factory_creation_id >>= fcid) // Extract the actual FactoryCreationId.
    {
      // Successfully extracted the FactoryCreationId.  Now find the
      // TAO_PG_Factory_Set corresponding to it.

      ACE_GUARD (TAO_SYNCH_MUTEX, guard, this->lock_);

      // If no entry exists in the factory map, infrastructure
      // controlled membership was not used.
      TAO_PG_Factory_Map::ENTRY *entry = 0;
      if (this->factory_map_.find (fcid, entry) == 0)
        {
          TAO_PG_Factory_Set & factory_set = entry->int_id_;

          this->delete_object_i (factory_set,
                                 0  /* Do not ignore exceptions */);

          if (this->factory_map_.unbind (fcid) != 0)
            throw CORBA::INTERNAL ();
        }
    }
  else
    throw PortableGroup::ObjectNotFound ();  // @@
                                                   //    CORBA::BAD_PARAM
                                                   //    instead?

  // The ObjectId for the newly created object group is comprised
  // solely of the FactoryCreationId.
  PortableServer::ObjectId_var oid;
  this->get_ObjectId (fcid, oid.out ());

  // Destroy the object group entry.
  this->object_group_manager_.destroy_object_group (
    oid.in ());
}

void TAO_PG_GenericFactory::delete_object_i	(	TAO_PG_Factory_Set &	factory_set,
		CORBA::Boolean	ignore_exceptions
	)

If ignore_exceptions is true, any exception returned from the delete_object() call on the remote factory will be ignored in order to allow other objects to be deleted via other registered factories.

Definition at line 227 of file PG_GenericFactory.cpp.

References TAO_PG_Factory_Node::factory_creation_id, TAO_PG_Factory_Node::factory_info, ACE_Array_Base< T >::size(), and PortableGroup::FactoryInfo::the_factory.

Referenced by create_object(), and TAO_PG_Group_Guard::~TAO_PG_Group_Guard().

{
  const size_t len = factory_set.size ();

  size_t ilen = len;
  for (size_t i = 0; i != len; ++i)
    {
      // Destroy the object group member in reverse order in case the
      // array list is only partially destroyed and another call to
      // GenericFactory::delete_object() occurs afterwards.
      --ilen;

      TAO_PG_Factory_Node & factory_node = factory_set[ilen];

      PortableGroup::GenericFactory_ptr factory =
        factory_node.factory_info.the_factory.in ();
      const PortableGroup::GenericFactory::FactoryCreationId & member_fcid =
        factory_node.factory_creation_id.in ();

      try
        {
          factory->delete_object (member_fcid);
        }
      catch (const CORBA::Exception&)
        {
          // Exceptions are generally only ignored when this
          // GenericFactory (not the one being invoked above) is
          // destroyed.  The idea is to allow the GenericFactory to be
          // destroyed regardless of whether or not all object group
          // members have been destroyed, and minimize the number of
          // object group members that have not been destroyed.
          if (!ignore_exceptions)
            throw;
        }

      // Since GenericFactory::delete_object() can throw an exception,
      // decrease the size of the factory array incrementally since
      // some object group members may not have been destroyed yet.
      // Note that this size reduction is fast since no memory is
      // actually deallocated.
      factory_set.size (ilen);
    }
}

void TAO_PG_GenericFactory::get_ObjectId	(	CORBA::ULong	fcid,
		PortableServer::ObjectId_out	oid
	)			[private]

Get a new ObjectId to be used when creating a new ObjectGroup.

An ObjectId created by this method will never be reused within the scope of a given ReplicationManager. A value suitable for use in a map association <ext_id> is also returned.

Definition at line 385 of file PG_GenericFactory.cpp.

References ACE_OS::sprintf(), and PortableServer::string_to_ObjectId().

Referenced by create_object(), and delete_object().

{
  // Since the POA used by the LoadManager uses the NON_RETAIN
  // policy, explicitly choose an ObjectId that is unique to a given
  // type.

  // Make the ObjectId be the next value of the number of types that
  // have been registered with the LoadManager.  For example, if two
  // types of objects have been registered with the LoadManager, then
  // the ObjectId for the object currently being registered will be
  // "3" since the object will be the third type of object registered
  // with the LoadManager.  Previously used values will not be reused
  // to ensure that a ServantLocator does not inadvertently return a
  // reference to an object that had a previously used ObjectId.
  // Specifcally, the numerical value used for the ObjectId increases
  // monotonically.

  // 4294967295UL -- Largest 32 bit unsigned integer
  // 123456789012 -- 10 digits
  //                + 2 for "UL"  (unnecessary, but let's be safe)
  //                + 1 for null terminator
  //                + 1 for good luck. :-)
  const size_t MAX_OID_LEN = 14;

  char oid_str[MAX_OID_LEN] = { 0 };
  ACE_OS::sprintf (oid_str,
                   "%ul",
                   fcid);

  oid = PortableServer::string_to_ObjectId (oid_str);
}

void TAO_PG_GenericFactory::poa

(

PortableServer::POA_ptr

p

)

Set the POA to use when creating object references.

Definition at line 331 of file PG_GenericFactory.cpp.

References ACE_ASSERT, CORBA::is_nil(), and poa_.

{
  ACE_ASSERT (CORBA::is_nil (this->poa_.in ())
              && !CORBA::is_nil (p));

  this->poa_ = PortableServer::POA::_duplicate (p);
}

void TAO_PG_GenericFactory::populate_object_group	(	PortableGroup::ObjectGroup_ptr	object_group,
		const char *	type_id,
		const PortableGroup::FactoryInfos &	factory_infos,
		PortableGroup::InitialNumberMembersValue	initial_number_members,
		TAO_PG_Factory_Set &	factory_set
	)			[private]

Populate the object group being created. Called when the infrastructure-controlled membership style is used for the object group being created.

Definition at line 340 of file PG_GenericFactory.cpp.

References create_member(), CORBA::is_nil(), ACE_Array_Base< T >::size(), PortableGroup::FactoryInfo::the_factory, and PortableGroup::FactoryInfo::the_location.

Referenced by create_object().

{
  CORBA::ULong factory_infos_count = factory_infos.length ();
  factory_set.size (factory_infos_count);

  for (CORBA::ULong j = 0; j < factory_infos_count; ++j)
    {
      TAO_PG_Factory_Node & factory_node = factory_set[j];

      const PortableGroup::FactoryInfo &factory_info = factory_infos[j];

      if (j < static_cast<CORBA::ULong> (initial_number_members))
        {
          PortableGroup::GenericFactory_ptr factory =
            factory_info.the_factory.in ();

          if (CORBA::is_nil (factory))
            {
              // @@ instead InvalidProperty?
              throw PortableGroup::NoFactory (
                factory_info.the_location,
                type_id);
            }

          // Do not allow the PortableGroup::MemberAlreadyPresent
          // exception to be propagated to this scope.
          const CORBA::Boolean propagate_member_already_present = 0;

          factory_node.factory_creation_id =
            this->create_member (object_group,
                                 factory_info,
                                 type_id,
                                 propagate_member_already_present);
        }

      factory_node.factory_info = factory_info;  // Memberwise copy
    }
}

void TAO_PG_GenericFactory::process_criteria	(	const char *	type_id,
		const PortableGroup::Criteria &	criteria,
		PortableGroup::MembershipStyleValue &	membership_style,
		PortableGroup::FactoriesValue &	factory_infos,
		PortableGroup::InitialNumberMembersValue &	initial_number_members,
		PortableGroup::MinimumNumberMembersValue &	minimum_number_members
	)			[private]

Only the MemberShipStyle, Factories, InitialNumberMembers and MinimumNumberMembers criteria/properties are defined by the PortableGroup IDL. Other services that implement the GenericFactory interface, such as load balancing and fault tolerance, may choose to support more.

The extracted criteria are object group-specific. In particular, they are the object group creation time criteria.

Definition at line 420 of file PG_GenericFactory.cpp.

References TAO_PG::get_property_value(), TAO_PG_PropertyManager::get_type_properties(), PortableGroup::MEMB_APP_CTRL, PortableGroup::MEMB_INF_CTRL, TAO_PG::override_properties(), property_manager_, and CORBA::string_dup().

Referenced by create_object().

{
  // Get type-specific properties.
  PortableGroup::Properties_var props =
    this->property_manager_.get_type_properties (type_id);

  // Merge the given criteria with the type-specific criteria.
  TAO_PG::override_properties (criteria, props.inout ());

  PortableGroup::Criteria unmet_criteria;
  unmet_criteria.length (4);  // The four criteria understood by this
                              // method.

  // Unmet criteria count.
  CORBA::ULong uc = 0;

  PortableGroup::Name name (1);
  name.length (1);

  PortableGroup::Value value;
  PortableGroup::Value value1;
  PortableGroup::Value value2;
  PortableGroup::Value value3;

  // MembershipStyle
  name[0].id = CORBA::string_dup ("org.omg.PortableGroup.MembershipStyle");
  if (TAO_PG::get_property_value (name, props.in (), value)
      && (!(value >>= membership_style)
          || (membership_style != PortableGroup::MEMB_APP_CTRL
              && membership_style != PortableGroup::MEMB_INF_CTRL)))
    {
      // This only occurs if extraction of the actual value from the
      // Any fails.
      throw PortableGroup::InvalidProperty (name, value);
    }

  // Factories
  const PortableGroup::FactoryInfos * factory_infos_tmp = 0;
  name[0].id = CORBA::string_dup ("org.omg.PortableGroup.Factories");
  if (TAO_PG::get_property_value (name, props.in (), value1)
      && !(value1 >>= factory_infos_tmp))
    {
      // This only occurs if extraction of the actual value from the
      // Any fails.
      throw PortableGroup::InvalidProperty (name, value1);
    }

  const CORBA::ULong factory_infos_count =
    (factory_infos_tmp == 0 ? 0 : factory_infos_tmp->length ());

  // InitialNumberMembers
  name[0].id =
    CORBA::string_dup ("org.omg.PortableGroup.InitialNumberMembers");
  if (TAO_PG::get_property_value (name, props.in (), value2)
      && !(value2 >>= initial_number_members))
    {
      // This only occurs if extraction of the actual value from the
      // Any fails.
      throw PortableGroup::InvalidProperty (name, value2);
    }

  if (membership_style == PortableGroup::MEMB_INF_CTRL)
    {
      // If the number of factories is less than the initial number of
      // members or the desired number of initial members cannot
      // possibly be created.

      if (factory_infos_count < static_cast<CORBA::ULong> (initial_number_members))
        {
          unmet_criteria[uc].nam = name;
          unmet_criteria[uc++].val = value2;
        }
    }

  // MinimumNumberMembers
  name[0].id =
    CORBA::string_dup ("org.omg.PortableGroup.MinimumNumberMembers");
  if (TAO_PG::get_property_value (name, props.in (), value3)
      && !(value3 >>= minimum_number_members))
    {
      // This only occurs if extraction of the actual value from the
      // Any fails.
      throw PortableGroup::InvalidProperty (name, value3);
    }

  // If the minimum number of members is less than the initial number
  // of members, the MinimumNumberMembers property is cannot be
  // initially met.
  //
  // @note This code is not part of the above "MEMB_INF_CTRL" criteria
  //       check since the "name" and "value" variables have been
  //       changed.
  if (membership_style == PortableGroup::MEMB_INF_CTRL)
    {
      if (minimum_number_members < initial_number_members
          || static_cast<CORBA::ULong> (minimum_number_members) > factory_infos_count)
        {
          unmet_criteria[uc].nam = name;
          unmet_criteria[uc++].val = value3;
        }
      else if (factory_infos_tmp != 0)
      {
        factory_infos.length (factory_infos_count);
        factory_infos = *factory_infos_tmp;
      }
    }

  if (uc > 0)
    {
      // Reduce the length of the unmet criteria sequence in an effort
      // to optimize the copying that will occur when the below
      // exception is thrown.  Reducing the length is fast since no
      // deallocations should occur.
      unmet_criteria.length (uc);

      throw PortableGroup::CannotMeetCriteria (unmet_criteria);
    }
}

---

Member Data Documentation

TAO_PG_Factory_Map TAO_PG_GenericFactory::factory_map_ [private]

Table that maps FactoryCreationId to TAO_PG_Factory_Set.

The TAO_PG_Factory_Set corresponding to a given FactoryCreationId contains the information necessary to clean up objects (members) that were created by the infrastructure, i.e. this GenericFactory. For example, this GenericFactory will invoke other application defined GenericFactorys when creating new object group members. The information returned from those application defined GenericFactorys is stored in a TAO_PG_Factory_Set, and thus this table.

Definition at line 202 of file PG_GenericFactory.h.

Referenced by ~TAO_PG_GenericFactory().

TAO_SYNCH_MUTEX TAO_PG_GenericFactory::lock_ [private]

Lock used to synchronize access to the factory creation id index (i.e. next_fcid_).

Definition at line 217 of file PG_GenericFactory.h.

CORBA::ULong TAO_PG_GenericFactory::next_fcid_ [private]

Value that is used when assigning a FactoryCreationId to the factory that was used to create a given ObjectGroup. The FactoryCreationId is typically comprised of this value in addition to another value that makes it unique to a given Load Balancer.

Definition at line 213 of file PG_GenericFactory.h.

Referenced by create_object().

TAO_PG_ObjectGroupManager& TAO_PG_GenericFactory::object_group_manager_ [private]

Reference to the ObjectGroup map.

Definition at line 186 of file PG_GenericFactory.h.

Referenced by check_minimum_number_members(), create_member(), create_object(), and delete_object().

PortableServer::POA_var TAO_PG_GenericFactory::poa_ [private]

Reference to the POA used to create object group references.

Definition at line 183 of file PG_GenericFactory.h.

Referenced by poa().

TAO_PG_PropertyManager& TAO_PG_GenericFactory::property_manager_ [private]

Reference to the PropertyManager.

Definition at line 189 of file PG_GenericFactory.h.

Referenced by check_minimum_number_members(), create_object(), and process_criteria().

---

The documentation for this class was generated from the following files:

• PG_GenericFactory.h
• PG_GenericFactory.cpp

---