TAO/tao/Strategies/Optimized_Connection_Endpoint_Selector.cpp

   1 // -*- C++ -*-
   2 #include "tao/Strategies/Optimized_Connection_Endpoint_Selector.h"
   3
   4 #include "tao/debug.h"
   5 #include "tao/Stub.h"
   6 #include "tao/Profile.h"
   7 #include "tao/Endpoint.h"
   8 #include "tao/Base_Transport_Property.h"
   9 #include "tao/ORB_Core.h"
  10 #include "tao/Transport.h"
  11 #include "tao/Profile_Transport_Resolver.h"
  12 #include "tao/SystemException.h"
  13
  14 TAO_BEGIN_VERSIONED_NAMESPACE_DECL
  15
  16 // ****************************************************************
  17
  18 ACE_Time_Value TAO_Optimized_Connection_Endpoint_Selector::timeout_;
  19
  20 TAO_Optimized_Connection_Endpoint_Selector::
  21 TAO_Optimized_Connection_Endpoint_Selector (const ACE_Time_Value &tv)
  22 {
  23   TAO_Optimized_Connection_Endpoint_Selector::timeout_ = tv;
  24   if (TAO_debug_level)
  25     {
  26       TAOLIB_DEBUG ((LM_DEBUG,
  27                   ACE_TEXT ("TAO(%P|%t) Optimized Connection Enpoint Selector: ")
  28                   ACE_TEXT ("Initializing timeout hook tv = %d sec, %d usec\n"),
  29               tv.sec(), tv.usec()));
  30     }
  31   if (tv > ACE_Time_Value::zero)
  32     {
  33       TAO_ORB_Core::connection_timeout_hook
  34         (TAO_Optimized_Connection_Endpoint_Selector::hook);
  35     }
  36 }
  37
  38 TAO_Optimized_Connection_Endpoint_Selector::
  39 ~TAO_Optimized_Connection_Endpoint_Selector ()
  40 {
  41 }
  42
  43
  44 void
  45 TAO_Optimized_Connection_Endpoint_Selector::hook (TAO_ORB_Core *,
  46                                                   TAO_Stub *,
  47                                                   bool &has_timeout,
  48                                                   ACE_Time_Value &tv)
  49 {
  50   has_timeout =
  51     TAO_Optimized_Connection_Endpoint_Selector::
  52     timeout_ > ACE_Time_Value::zero;
  53   if (has_timeout)
  54     tv = TAO_Optimized_Connection_Endpoint_Selector::timeout_;
  55 }
  56
  57 int
  58 TAO_Optimized_Connection_Endpoint_Selector::check_profile (TAO_Profile *p,
  59                                                            TAO::Profile_Transport_Resolver *r)
  60 {
  61   TAO_Endpoint *effective_endpoint = 0;
  62
  63   r->profile(p);
  64   effective_endpoint = p->endpoint ();
  65   size_t endpoint_count = p->endpoint_count();
  66   for (size_t i = 0; i < endpoint_count; ++i)
  67     {
  68       TAO_Base_Transport_Property desc (effective_endpoint);
  69       if (r->find_transport(&desc))
  70         return 1;
  71       // Go to the next endpoint in this profile
  72       effective_endpoint = effective_endpoint->next();
  73     }
  74   return 0;
  75 }
  76
  77 void
  78 TAO_Optimized_Connection_Endpoint_Selector::select_endpoint
  79   (TAO::Profile_Transport_Resolver *r,
  80    ACE_Time_Value *max_wait_time)
  81 {
  82   TAO_Stub *stub = r->stub();
  83   TAO_Profile *p = stub->profile_in_use();
  84
  85   // first, look for the endpoints for the current profile in use.
  86   // if that is available then go for it.
  87
  88   if (this->check_profile (p, r) != 0)
  89     return;
  90
  91   // next, look for any other profiles. If the stub has any forward profiles,
  92   // use those, otherwise look at the base profiles. This separation is
  93   // necessary to avoid re-using a corbaloc or other previously forwarded
  94   // profile.
  95
  96   const TAO_MProfile *profiles = stub->forward_profiles();
  97   if (profiles != 0)
  98     {
  99       for (CORBA::ULong count = 0; count <  profiles->profile_count(); count++)
 100         {
 101           p = const_cast<TAO_Profile *>(profiles->get_profile(count));
 102           if (this->check_profile (p, r) != 0)
 103             {
 104               if (stub->profile_in_use() != p)
 105                 {
 106                   // thread-safe way to coerse stub to this profile.
 107                   stub->reset_profiles();
 108                   while (stub->profile_in_use() != p)
 109                     if (stub->next_profile_retry() == 0)
 110                       break;
 111                 }
 112               return;
 113             }
 114         }
 115     }
 116   else
 117     {
 118       do
 119         {
 120           p = stub->profile_in_use();
 121           if (this->check_profile(p, r) != 0)
 122             return;
 123         }
 124       while (stub->next_profile_retry () != 0);
 125     }
 126
 127
 128   // at this point, we do not have an existing transport, so we must
 129   // reset the profile list and try establishing connections via the
 130   // connector(s).
 131
 132   do
 133     {
 134       r->profile (r->stub ()->profile_in_use ());
 135
 136       // Check whether we need to do a blocked wait or we have a
 137       // non-blocked wait and we support that.  If this is not the
 138       // case we can't use this profile so try the next.
 139       if (r->blocked_connect () ||
 140          (!r->blocked_connect () && r->profile ()->supports_non_blocking_oneways ()))
 141         {
 142           const size_t endpoint_count = r->profile ()->endpoint_count ();
 143
 144           TAO_Endpoint *ep = r->profile ()->endpoint ();
 145
 146           for (size_t i = 0; i < endpoint_count; ++i)
 147             {
 148               TAO_Base_Transport_Property desc (ep);
 149               const bool retval = r->try_connect (&desc, max_wait_time);
 150
 151               // Check if the connect has completed.
 152               if (retval)
 153                 return;
 154
 155               // Go to the next endpoint in this profile.
 156               ep = ep->next ();
 157             }
 158         }
 159     }
 160   while (r->stub ()->next_profile_retry () != 0);
 161
 162   // If we get here, we completely failed to find an endpoint
 163   // that we know how to use. We used to throw an exception
 164   // but that would prevent any request interception points
 165   // being called. They may know how to fix the problem so
 166   // we wait to throw the exception in
 167   // Synch_Twoway_Invocation::remote_twoway and
 168   // Synch_Oneway_Invocation::remote_oneway instead.
 169 }
 170
 171 TAO_END_VERSIONED_NAMESPACE_DECL