TAO::Portable_Server::RequestProcessingStrategyServantActivator Class Reference

#include <RequestProcessingStrategyServantActivator.h>

Inheritance diagram for TAO::Portable_Server::RequestProcessingStrategyServantActivator:

[legend]Collaboration diagram for TAO::Portable_Server::RequestProcessingStrategyServantActivator:

[legend]List of all members.

Public Member Functions
	RequestProcessingStrategyServantActivator (void)
virtual void	strategy_cleanup (void)
PortableServer::ServantManager_ptr	get_servant_manager (void)
void	set_servant_manager (PortableServer::ServantManager_ptr imgr)
virtual TAO_SERVANT_LOCATION	locate_servant (const PortableServer::ObjectId &system_id, PortableServer::Servant &servant)
virtual PortableServer::Servant	locate_servant (const char *operation, const PortableServer::ObjectId &system_id, TAO::Portable_Server::Servant_Upcall &servant_upcall, TAO::Portable_Server::POA_Current_Impl &poa_current_impl, bool &wait_occurred_restart_call)
virtual void	cleanup_servant (PortableServer::Servant servant, const PortableServer::ObjectId &user_id)
virtual void	etherealize_objects (CORBA::Boolean etherealize_objects)
virtual void	post_invoke_servant_cleanup (const PortableServer::ObjectId &system_id, const TAO::Portable_Server::Servant_Upcall &servant_upcall)
Private Member Functions
PortableServer::Servant	incarnate_servant (const PortableServer::ObjectId &object_id)
void	etherealize_servant (const PortableServer::ObjectId &object_id, PortableServer::Servant servant, CORBA::Boolean cleanup_in_progress)
Private Attributes
PortableServer::ServantActivator_var	servant_activator_
CORBA::Boolean	etherealize_objects_

---

Detailed Description

Definition at line 35 of file RequestProcessingStrategyServantActivator.h.

---

Constructor & Destructor Documentation

TAO::Portable_Server::RequestProcessingStrategyServantActivator::RequestProcessingStrategyServantActivator

(

void

)

Definition at line 25 of file RequestProcessingStrategyServantActivator.cpp.

                                                                                              :
      etherealize_objects_ (true)
    {
    }

---

Member Function Documentation

void TAO::Portable_Server::RequestProcessingStrategyServantActivator::cleanup_servant	(	PortableServer::Servant	servant,
		const PortableServer::ObjectId &	user_id
	)			[virtual]

Implements TAO::Portable_Server::RequestProcessingStrategy.

Definition at line 241 of file RequestProcessingStrategyServantActivator.cpp.

References TAO_ServantBase::_remove_ref(), etherealize_servant(), and CORBA::is_nil().

    {
      // If a servant manager is associated with the POA,
      // ServantLocator::etherealize will be invoked with the oid and the
      // servant. (The deactivate_object operation does not wait for the
      // etherealize operation to complete before deactivate_object
      // returns.)
      //
      // Note: If the servant associated with the oid is serving multiple
      // Object Ids, ServantLocator::etherealize may be invoked multiple
      // times with the same servant when the other objects are
      // deactivated. It is the responsibility of the object
      // implementation to refrain from destroying the servant while it is
      // active with any Id.

      // If the POA has no ServantActivator associated with it, the POA
      // implementation calls _remove_ref when all operation invocations
      // have completed. If there is a ServantActivator, the Servant is
      // consumed by the call to ServantActivator::etherealize instead.

      // @bala, is this order correct, see 11.3.9.17 of the spec, it
      // says first remove from the map, then etherealize. not the
      // other way around
      // @@ Johnny, you are right! This will not show up until a
      // thread is trying to activate the object in another thread
      // using activate_object_with_id (). A test case is a must for
      // atleast this issue.
      if (servant)
        {
          if (this->etherealize_objects_ &&
              !CORBA::is_nil (this->servant_activator_.in ()))
            {
              this->etherealize_servant (user_id,
                                         servant,
                                         this->poa_->cleanup_in_progress ());
            }
          else
            {
              // ATTENTION: Trick locking here, see class header for details
              Non_Servant_Upcall non_servant_upcall (*this->poa_);
              ACE_UNUSED_ARG (non_servant_upcall);

              servant->_remove_ref ();
            }
        }

      // This operation causes the association of the Object Id specified
      // by the oid parameter and its servant to be removed from the
      // Active Object Map.
      if (this->poa_->unbind_using_user_id (user_id) != 0)
        throw ::CORBA::OBJ_ADAPTER ();
    }

void TAO::Portable_Server::RequestProcessingStrategyServantActivator::etherealize_objects

(

CORBA::Boolean

etherealize_objects

)

[virtual]

Implements TAO::Portable_Server::RequestProcessingStrategy.

Definition at line 298 of file RequestProcessingStrategyServantActivator.cpp.

References etherealize_objects_.

    {
      this->etherealize_objects_ = etherealize_objects;
    }

void TAO::Portable_Server::RequestProcessingStrategyServantActivator::etherealize_servant	(	const PortableServer::ObjectId &	object_id,
		PortableServer::Servant	servant,
		CORBA::Boolean	cleanup_in_progress
	)			[private]

Definition at line 191 of file RequestProcessingStrategyServantActivator.cpp.

References TAO::Portable_Server::RequestProcessingStrategy::poa_, servant_activator_, and TAO_Root_POA::servant_has_remaining_activations().

Referenced by cleanup_servant(), and locate_servant().

    {
      CORBA::Boolean remaining_activations =
        this->poa_->servant_has_remaining_activations (servant);

      // ATTENTION: Trick locking here, see class header for details
      Non_Servant_Upcall non_servant_upcall (*this->poa_);
      ACE_UNUSED_ARG (non_servant_upcall);

      // @todo This is not according to the spec. According to 11.3.6.2 at the
      // end when etherealize returns a system exception the POA ignores the
      // exception
      this->servant_activator_->etherealize (object_id,
                                             this->poa_,
                                             servant,
                                             cleanup_in_progress,
                                             remaining_activations);
    }

PortableServer::ServantManager_ptr TAO::Portable_Server::RequestProcessingStrategyServantActivator::get_servant_manager

(

void

)

[virtual]

Implements TAO::Portable_Server::RequestProcessingStrategy.

Definition at line 44 of file RequestProcessingStrategyServantActivator.cpp.

    {
      return PortableServer::ServantManager::_duplicate (this->servant_activator_.in ());
    }

PortableServer::Servant TAO::Portable_Server::RequestProcessingStrategyServantActivator::incarnate_servant

(

const PortableServer::ObjectId &

object_id

)

[private]

Definition at line 215 of file RequestProcessingStrategyServantActivator.cpp.

References CORBA::COMPLETED_NO, CORBA::OMGVMCID, and servant_activator_.

Referenced by locate_servant().

    {
      PortableServer::Servant servant = 0;

      // ATTENTION: Trick locking here, see class header for details
      Non_Servant_Upcall non_servant_upcall (*this->poa_);
      ACE_UNUSED_ARG (non_servant_upcall);

      // @@
      // Invocations of incarnate on the servant manager are serialized.
      // Invocations of etherealize on the servant manager are serialized.
      // Invocations of incarnate and etherealize on the servant manager are mutually exclusive.
      servant = this->servant_activator_->incarnate (object_id, this->poa_);

      if (servant == 0)
        {
          throw ::CORBA::OBJ_ADAPTER (CORBA::OMGVMCID | 7, CORBA::COMPLETED_NO);
        }
      else
        {
          return servant;
        }
    }

PortableServer::Servant TAO::Portable_Server::RequestProcessingStrategyServantActivator::locate_servant	(	const char *	operation,
		const PortableServer::ObjectId &	system_id,
		TAO::Portable_Server::Servant_Upcall &	servant_upcall,
		TAO::Portable_Server::POA_Current_Impl &	poa_current_impl,
		bool &	wait_occurred_restart_call
	)			[virtual]

Implements TAO::Portable_Server::RequestProcessingStrategy.

Definition at line 90 of file RequestProcessingStrategyServantActivator.cpp.

References etherealize_servant(), TAO_Root_POA::find_servant(), incarnate_servant(), TAO::Portable_Server::Servant_Upcall::increment_servant_refcount(), TAO_Root_POA::is_servant_activation_allowed(), TAO::Portable_Server::POA_Current_Impl::object_id(), TAO::Portable_Server::RequestProcessingStrategy::poa_, and TAO::Portable_Server::RequestProcessingStrategyServantManager::validate_servant_manager().

    {
      PortableServer::Servant servant = 0;

      servant = this->poa_->find_servant (system_id,
                                          servant_upcall,
                                          poa_current_impl);

      if (servant != 0)
        {
          return servant;
        }

      // If the POA has the USE_SERVANT_MANAGER policy, a servant manager
      // has been associated with the POA so the POA will invoke incarnate
      // or preinvoke on it to find a servant that may handle the
      // request. (The choice of method depends on the NON_RETAIN or
      // RETAIN policy of the POA.) If no servant manager has been
      // associated with the POA, the POA raises the OBJ_ADAPTER system
      // exception.
      //
      // If a servant manager is located and invoked, but the servant
      // manager is not directly capable of incarnating the object, it
      // (the servant manager) may deal with the circumstance in a variety
      // of ways, all of which are the application's responsibility.  Any
      // system exception raised by the servant manager will be returned
      // to the client in the reply. In addition to standard CORBA
      // exceptions, a servant manager is capable of raising a
      // ForwardRequest exception. This exception includes an object
      // reference.
      //

      this->validate_servant_manager (this->servant_activator_.in ());

      servant = this->incarnate_servant (poa_current_impl.object_id ());

      // If the incarnate operation returns a servant that is
      // already active for a different Object Id and if the POA
      // also has the UNIQUE_ID policy, the incarnate has violated
      // the POA policy and is considered to be in error. The POA
      // will raise an OBJ_ADAPTER system exception for the
      // request.
      bool may_activate =
        this->poa_->is_servant_activation_allowed (servant,
                                                   wait_occurred_restart_call);

      if (!may_activate)
        {
          // If we are not allowed to activate the servant, throw an exception
          // etherealize is not called because the servant is never added to
          // the active object map
          throw ::CORBA::OBJ_ADAPTER ();
        }

      // The POA enters the returned Servant value into the Active
      // Object Map so that subsequent requests with the same
      // ObjectId value will be delivered directly to that servant
      // without invoking the servant manager.  Only run if there
      // are no errors or if a restart is not required.
      if (!wait_occurred_restart_call)
        {
          int const result =
            this->poa_->
              rebind_using_user_id_and_system_id (servant,
                                                  poa_current_impl.object_id (),
                                                  system_id,
                                                  servant_upcall);
          if (result != 0)
            {
              // Throw an exception, etherealize is not called because servant
              // is not added to the active object map
              throw ::CORBA::OBJ_ADAPTER ();
            }

          // Increment the reference count on the servant upcall.
          servant_upcall.increment_servant_refcount ();
        }
      else
        {
          CORBA::Boolean cleanup_in_progress = 0;
          this->etherealize_servant (poa_current_impl.object_id (),
                                     servant,
                                     cleanup_in_progress);

          // We ended up waiting on a condition variable, the
          // POA state may have changed while we are waiting.
          // Therefore, we need to restart this call.
          return 0;
        }

      // Success
      return servant;
    }

TAO_SERVANT_LOCATION TAO::Portable_Server::RequestProcessingStrategyServantActivator::locate_servant	(	const PortableServer::ObjectId &	system_id,
		PortableServer::Servant &	servant
	)			[virtual]

Implements TAO::Portable_Server::RequestProcessingStrategy.

Definition at line 70 of file RequestProcessingStrategyServantActivator.cpp.

References CORBA::is_nil(), TAO::Portable_Server::RequestProcessingStrategy::poa_, TAO_Root_POA::servant_present(), TAO_SERVANT_MANAGER, and TAO_SERVANT_NOT_FOUND.

    {
      TAO_SERVANT_LOCATION location = TAO_SERVANT_NOT_FOUND;

      location = this->poa_->servant_present (system_id, servant);

      if (location == TAO_SERVANT_NOT_FOUND)
        {
          if (!CORBA::is_nil (this->servant_activator_.in ()))
            {
              location = TAO_SERVANT_MANAGER;
            }
        }

      return location;
    }

void TAO::Portable_Server::RequestProcessingStrategyServantActivator::post_invoke_servant_cleanup	(	const PortableServer::ObjectId &	system_id,
		const TAO::Portable_Server::Servant_Upcall &	servant_upcall
	)			[virtual]

Implements TAO::Portable_Server::RequestProcessingStrategy.

Definition at line 305 of file RequestProcessingStrategyServantActivator.cpp.

    {
    }

void TAO::Portable_Server::RequestProcessingStrategyServantActivator::set_servant_manager

(

PortableServer::ServantManager_ptr

imgr

)

[virtual]

Implements TAO::Portable_Server::RequestProcessingStrategy.

Definition at line 50 of file RequestProcessingStrategyServantActivator.cpp.

References CORBA::COMPLETED_NO, CORBA::is_nil(), CORBA::OMGVMCID, servant_activator_, and TAO::Portable_Server::RequestProcessingStrategyServantManager::validate_servant_manager().

    {
      // This operation sets the default servant manager associated with the
      // POA. This operation may only be invoked once after a POA has been
      // created. Attempting to set the servant manager after one has already
      // been set will result in the BAD_INV_ORDER system exception with
      // standard minor code 6 being raised (see 11.3.9.12 of the corba spec)
      if (!CORBA::is_nil (this->servant_activator_.in ()))
        {
          throw ::CORBA::BAD_INV_ORDER (CORBA::OMGVMCID | 6, CORBA::COMPLETED_NO);
        }

      this->servant_activator_ =
        PortableServer::ServantActivator::_narrow (imgr);

      this->validate_servant_manager (this->servant_activator_.in ());
    }

void TAO::Portable_Server::RequestProcessingStrategyServantActivator::strategy_cleanup

(

void

)

[virtual]

Reimplemented from TAO::Portable_Server::RequestProcessingStrategy.

Definition at line 31 of file RequestProcessingStrategyServantActivator.cpp.

References servant_activator_, and TAO::Portable_Server::RequestProcessingStrategy::strategy_cleanup().

    {
      {
        Non_Servant_Upcall non_servant_upcall (*this->poa_);
        ACE_UNUSED_ARG (non_servant_upcall);

        this->servant_activator_ = PortableServer::ServantActivator::_nil ();
      }

      RequestProcessingStrategy::strategy_cleanup ();
    }

---

Member Data Documentation

CORBA::Boolean TAO::Portable_Server::RequestProcessingStrategyServantActivator::etherealize_objects_ [private]

Definition at line 78 of file RequestProcessingStrategyServantActivator.h.

Referenced by etherealize_objects().

PortableServer::ServantActivator_var TAO::Portable_Server::RequestProcessingStrategyServantActivator::servant_activator_ [private]

Definition at line 77 of file RequestProcessingStrategyServantActivator.h.

Referenced by etherealize_servant(), incarnate_servant(), set_servant_manager(), and strategy_cleanup().

---

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

• RequestProcessingStrategyServantActivator.h
• RequestProcessingStrategyServantActivator.cpp

---