TAO_Optimized_Connection_Endpoint_Selector Class Reference

More efficient connection strategy for endpoint selection. More...

#include <Optimized_Connection_Endpoint_Selector.h>

Inheritance diagram for TAO_Optimized_Connection_Endpoint_Selector:

[legend]Collaboration diagram for TAO_Optimized_Connection_Endpoint_Selector:

[legend]List of all members.

Public Member Functions
	TAO_Optimized_Connection_Endpoint_Selector (const ACE_Time_Value &tv)
	Constructor.
virtual	~TAO_Optimized_Connection_Endpoint_Selector (void)
	Destructor.
virtual void	select_endpoint (TAO::Profile_Transport_Resolver *, ACE_Time_Value *max_wait_time)
Static Public Member Functions
static void	hook (TAO_ORB_Core *, TAO_Stub *, bool &has_timeout, ACE_Time_Value &tv)
Private Member Functions
int	check_profile (TAO_Profile *, TAO::Profile_Transport_Resolver *)
Static Private Attributes
static ACE_Time_Value	timeout_

---

Detailed Description

More efficient connection strategy for endpoint selection.

This strategy builds on the default by first querying the connection cache for all potential endpoints before iterating over the list to attempt to create new connections.

Definition at line 51 of file Optimized_Connection_Endpoint_Selector.h.

---

Constructor & Destructor Documentation

TAO_Optimized_Connection_Endpoint_Selector::TAO_Optimized_Connection_Endpoint_Selector

(

const ACE_Time_Value &

tv

)

Constructor.

Definition at line 26 of file Optimized_Connection_Endpoint_Selector.cpp.

References ACE_DEBUG, ACE_TEXT, TAO_ORB_Core::connection_timeout_hook(), hook(), LM_DEBUG, TAO_debug_level, timeout_, and ACE_Time_Value::zero.

{
  TAO_Optimized_Connection_Endpoint_Selector::timeout_ = tv;
  if (TAO_debug_level)
    {
      ACE_DEBUG ((LM_DEBUG,
                  ACE_TEXT ("TAO(%P|%t) Optimized Connection Enpoint Selector: ")
                  ACE_TEXT ("Initializing timeout hook tv = %d sec, %d usec\n"),
              tv.sec(), tv.usec()));
    }
  if (tv > ACE_Time_Value::zero)
    {
      TAO_ORB_Core::connection_timeout_hook
        (TAO_Optimized_Connection_Endpoint_Selector::hook);
    }
}

TAO_Optimized_Connection_Endpoint_Selector::~TAO_Optimized_Connection_Endpoint_Selector

(

void

)

[virtual]

Destructor.

Definition at line 44 of file Optimized_Connection_Endpoint_Selector.cpp.

{
}

---

Member Function Documentation

int TAO_Optimized_Connection_Endpoint_Selector::check_profile	(	TAO_Profile *	,
		TAO::Profile_Transport_Resolver *
	)			[private]

Definition at line 63 of file Optimized_Connection_Endpoint_Selector.cpp.

References TAO_Profile::endpoint(), and TAO_Profile::endpoint_count().

{
  TAO_Endpoint *effective_endpoint = 0;

  r->profile(p);
  effective_endpoint = p->endpoint ();
  size_t endpoint_count = p->endpoint_count();
  for (size_t i = 0; i < endpoint_count; ++i)
    {
      TAO_Base_Transport_Property desc (effective_endpoint);
      if (r->find_transport(&desc))
        return 1;
      // Go to the next endpoint in this profile
      effective_endpoint = effective_endpoint->next();
    }
  return 0;
}

void TAO_Optimized_Connection_Endpoint_Selector::hook	(	TAO_ORB_Core *	,
		TAO_Stub *	,
		bool &	has_timeout,
		ACE_Time_Value &	tv
	)			[static]

Definition at line 50 of file Optimized_Connection_Endpoint_Selector.cpp.

References timeout_, and ACE_Time_Value::zero.

Referenced by TAO_Optimized_Connection_Endpoint_Selector().

{
  has_timeout =
    TAO_Optimized_Connection_Endpoint_Selector::
    timeout_ > ACE_Time_Value::zero;
  if (has_timeout)
    tv = TAO_Optimized_Connection_Endpoint_Selector::timeout_;
}

void TAO_Optimized_Connection_Endpoint_Selector::select_endpoint	(	TAO::Profile_Transport_Resolver *	,
		ACE_Time_Value *	max_wait_time
	)			[virtual]

Reimplemented from TAO_Default_Endpoint_Selector.

Definition at line 84 of file Optimized_Connection_Endpoint_Selector.cpp.

References CORBA::COMPLETED_NO, TAO_Profile::endpoint_count(), TAO_Stub::forward_profiles(), TAO_MProfile::get_profile(), TAO_Stub::next_profile_retry(), CORBA::OMGVMCID, TAO_MProfile::profile_count(), TAO_Stub::profile_in_use(), and TAO_Stub::reset_profiles().

{
  TAO_Stub *stub = r->stub();
  TAO_Profile *p = stub->profile_in_use();

  // first, look for the endpoints for the current profile in use.
  // if that is available then go for it.

  if (this->check_profile (p, r) != 0)
    return;

  // next, look for any other profiles. If the stub has any forward profiles,
  // use those, otherwise look at the base profiles. This separation is
  // necessary to avoid re-using a corbaloc or other previously forwarded
  // profile.

  const TAO_MProfile *profiles = stub->forward_profiles();
  if (profiles != 0)
    {
      for (CORBA::ULong count = 0; count <  profiles->profile_count(); count++)
        {
          p = const_cast<TAO_Profile *>(profiles->get_profile(count));
          if (this->check_profile (p, r) != 0)
            {
              if (stub->profile_in_use() != p)
                {
                  // thread-safe way to coerse stub to this profile.
                  stub->reset_profiles();
                  while (stub->profile_in_use() != p)
                    if (stub->next_profile_retry() == 0)
                      break;
                }
              return;
            }
        }
    }
  else
    {
      do
        {
          p = stub->profile_in_use();
          if (this->check_profile(p, r) != 0)
            return;
        }
      while (stub->next_profile_retry () != 0);
    }



  // at this point, we do not have an existing transport, so we must
  // reset the profile list and try establishing connections via the
  // connector(s).

  do
    {
      r->profile (r->stub ()->profile_in_use ());

      // Check whether we need to do a blocked wait or we have a
      // non-blocked wait and we support that.  If this is not the
      // case we can't use this profile so try the next.
      if (r->blocked_connect () ||
         (!r->blocked_connect () && r->profile ()->supports_non_blocking_oneways ()))
        {
          const size_t endpoint_count = r->profile ()->endpoint_count ();

          TAO_Endpoint *ep = r->profile ()->endpoint ();

          for (size_t i = 0; i < endpoint_count; ++i)
            {
              TAO_Base_Transport_Property desc (ep);
              const bool retval = r->try_connect (&desc, max_wait_time);

              // Check if the connect has completed.
              if (retval)
                return;

              // Go to the next endpoint in this profile.
              ep = ep->next ();
            }
        }
    }
  while (r->stub ()->next_profile_retry () != 0);

  // If we get here, we completely failed to find an endpoint selector
  // that we know how to use, so throw an exception.
  throw ::CORBA::TRANSIENT (CORBA::OMGVMCID | 2, CORBA::COMPLETED_NO);
}

---

Member Data Documentation

TAO_BEGIN_VERSIONED_NAMESPACE_DECL ACE_Time_Value TAO_Optimized_Connection_Endpoint_Selector::timeout_ [static, private]

Definition at line 73 of file Optimized_Connection_Endpoint_Selector.h.

Referenced by hook(), and TAO_Optimized_Connection_Endpoint_Selector().

---

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

• Optimized_Connection_Endpoint_Selector.h
• Optimized_Connection_Endpoint_Selector.cpp

---