TAO: Connection_Timeout_Policy

Go to the documentation of this file.
00001 //$Id: Connection_Timeout_Policy_i.cpp 81436 2008-04-25 09:10:41Z johnnyw $
00002 
00003 #include "tao/Messaging/Connection_Timeout_Policy_i.h"
00004 #include "tao/ORB_Core.h"
00005 #include "tao/Stub.h"
00006 #include "tao/debug.h"
00007 #include "tao/SystemException.h"
00008 #include "tao/AnyTypeCode/Any.h"
00009 #include "ace/Truncate.h"
00010 
00011 ACE_RCSID (Messaging,
00012            Connection_Timeout_Policy_i,
00013            "$Id: Connection_Timeout_Policy_i.cpp 81436 2008-04-25 09:10:41Z johnnyw $")
00014 
00015 
00016 #if (TAO_HAS_CONNECTION_TIMEOUT_POLICY == 1)
00017 
00018 TAO_BEGIN_VERSIONED_NAMESPACE_DECL
00019 
00020 TAO_ConnectionTimeoutPolicy::TAO_ConnectionTimeoutPolicy (
00021   const TimeBase::TimeT& relative_expiry)
00022   : ::CORBA::Object ()
00023   , ::CORBA::Policy ()
00024   , TAO::ConnectionTimeoutPolicy ()
00025   , ::CORBA::LocalObject ()
00026   , relative_expiry_ (relative_expiry)
00027 {
00028 }
00029 
00030 TAO_ConnectionTimeoutPolicy::TAO_ConnectionTimeoutPolicy (
00031   const TAO_ConnectionTimeoutPolicy &rhs)
00032   : ::CORBA::Object ()
00033   , ::CORBA::Policy ()
00034   , TAO::ConnectionTimeoutPolicy ()
00035   , ::CORBA::LocalObject ()
00036   , relative_expiry_ (rhs.relative_expiry_)
00037 {
00038 }
00039 
00040 TimeBase::TimeT
00041 TAO_ConnectionTimeoutPolicy::relative_expiry (void)
00042 {
00043   return this->relative_expiry_;
00044 }
00045 
00046 CORBA::PolicyType
00047 TAO_ConnectionTimeoutPolicy::policy_type (void)
00048 {
00049   return TAO::CONNECTION_TIMEOUT_POLICY_TYPE;
00050 }
00051 
00052 void
00053 TAO_ConnectionTimeoutPolicy::hook (TAO_ORB_Core *orb_core,
00054                                    TAO_Stub *stub,
00055                                    bool &has_timeout,
00056                                    ACE_Time_Value &time_value)
00057 {
00058   try
00059     {
00060       CORBA::Policy_var policy = CORBA::Policy::_nil ();
00061 
00062       if (stub == 0)
00063         {
00064           policy =
00065             orb_core->get_cached_policy_including_current (
00066               TAO_CACHED_POLICY_CONNECTION_TIMEOUT);
00067         }
00068       else
00069         {
00070           policy =
00071             stub->get_cached_policy (TAO_CACHED_POLICY_CONNECTION_TIMEOUT);
00072         }
00073 
00074       if (CORBA::is_nil (policy.in ()))
00075         {
00076           has_timeout = false;
00077           return;
00078         }
00079 
00080       TAO::ConnectionTimeoutPolicy_var p =
00081         TAO::ConnectionTimeoutPolicy::_narrow (policy.in ());
00082 
00083       TimeBase::TimeT const t = p->relative_expiry ();
00084       TimeBase::TimeT const seconds = t / 10000000u;
00085       TimeBase::TimeT const microseconds = (t % 10000000u) / 10;
00086       time_value.set (ACE_Utils::truncate_cast<time_t> (seconds),
00087                       ACE_Utils::truncate_cast<suseconds_t> (microseconds));
00088 
00089       // Set the flag once all operations complete successfully
00090       has_timeout = true;
00091 
00092       if (TAO_debug_level > 0)
00093         {
00094           ACE_UINT64 msecs;
00095           const_cast<ACE_Time_Value const &> (time_value).msec (msecs);
00096           ACE_DEBUG ((LM_DEBUG,
00097                       ACE_TEXT ("TAO (%P|%t) - Connect timeout is ")
00098                       ACE_TEXT ("%Q milliseconds\n"),
00099                       msecs));
00100         }
00101     }
00102   catch (const ::CORBA::Exception&)
00103     {
00104       // Ignore all exceptions...
00105     }
00106 }
00107 
00108 CORBA::Policy_ptr
00109 TAO_ConnectionTimeoutPolicy::create (const CORBA::Any& val)
00110 {
00111   // Future policy implementors: notice how the following code is
00112   // exception safe!
00113 
00114   TimeBase::TimeT value;
00115   if ((val >>= value) == 0)
00116     throw ::CORBA::PolicyError (CORBA::BAD_POLICY_VALUE);
00117 
00118   TAO_ConnectionTimeoutPolicy *tmp = 0;
00119   ACE_NEW_THROW_EX (tmp,
00120                     TAO_ConnectionTimeoutPolicy (value),
00121                     CORBA::NO_MEMORY (TAO::VMCID,
00122                                       CORBA::COMPLETED_NO));
00123 
00124   return tmp;
00125 }
00126 
00127 TAO_ConnectionTimeoutPolicy *
00128 TAO_ConnectionTimeoutPolicy::clone (void) const
00129 {
00130   TAO_ConnectionTimeoutPolicy *copy = 0;
00131   ACE_NEW_RETURN (copy,
00132                   TAO_ConnectionTimeoutPolicy (*this),
00133                   0);
00134   return copy;
00135 }
00136 
00137 CORBA::Policy_ptr
00138 TAO_ConnectionTimeoutPolicy::copy (void)
00139 {
00140   // Future policy implementors: notice how the following code is
00141   // exception safe!
00142   TAO_ConnectionTimeoutPolicy* tmp = 0;
00143   ACE_NEW_THROW_EX (tmp,
00144                     TAO_ConnectionTimeoutPolicy (*this),
00145                     CORBA::NO_MEMORY (TAO::VMCID,
00146                                       CORBA::COMPLETED_NO));
00147 
00148   return tmp;
00149 }
00150 
00151 void
00152 TAO_ConnectionTimeoutPolicy::destroy (void)
00153 {
00154 }
00155 
00156 TAO_Cached_Policy_Type
00157 TAO_ConnectionTimeoutPolicy::_tao_cached_type (void) const
00158 {
00159   return TAO_CACHED_POLICY_CONNECTION_TIMEOUT;
00160 }
00161 
00162 void
00163 TAO_ConnectionTimeoutPolicy::set_time_value (ACE_Time_Value &time_value)
00164 {
00165   TimeBase::TimeT const t = this->relative_expiry_;
00166   TimeBase::TimeT const seconds = t / 10000000u;
00167   TimeBase::TimeT const microseconds = (t % 10000000u) / 10;
00168   time_value.set (ACE_Utils::truncate_cast<time_t> (seconds),
00169                   ACE_Utils::truncate_cast<suseconds_t> (microseconds));
00170 
00171   if (TAO_debug_level > 0)
00172     {
00173       ACE_UINT64 msecs;
00174       const_cast<ACE_Time_Value const &> (time_value).msec (msecs);
00175       ACE_DEBUG ((LM_DEBUG,
00176                   ACE_TEXT ("TAO (%P|%t) - Connect timeout is ")
00177                   ACE_TEXT ("%Q milliseconds\n"),
00178                   msecs));
00179     }
00180 }
00181 
00182 TAO_END_VERSIONED_NAMESPACE_DECL
00183 
00184 #endif /* TAO_HAS_RELATIVE_ROUNDTRIP_TIMEOUT_POLICY == 1 */