TAO/tao/Profile_Transport_Resolver.h

   1 // -*- C++ -*-
   2
   3 //=============================================================================
   4 /**
   5  *  @file    Profile_Transport_Resolver.h
   6  *
   7  *  @author Balachandran Natarajan <bala@dre.vanderbilt.edu>
   8  */
   9 //=============================================================================
  10
  11 #ifndef TAO_PROFILE_TRANSPORT_RESOLVER_H
  12 #define TAO_PROFILE_TRANSPORT_RESOLVER_H
  13
  14 #include /**/ "ace/pre.h"
  15 #include "ace/Global_Macros.h"
  16
  17 #if !defined (ACE_LACKS_PRAGMA_ONCE)
  18 # pragma once
  19 #endif /* ACE_LACKS_PRAGMA_ONCE */
  20
  21 #include "tao/Transport_Selection_Guard.h"
  22
  23 ACE_BEGIN_VERSIONED_NAMESPACE_DECL
  24 class ACE_Time_Value;
  25 ACE_END_VERSIONED_NAMESPACE_DECL
  26
  27 TAO_BEGIN_VERSIONED_NAMESPACE_DECL
  28
  29 class TAO_Stub;
  30 class TAO_Profile;
  31 class TAO_Transport;
  32 class TAO_Endpoint;
  33 class TAO_Transport_Descriptor_Interface;
  34
  35 namespace CORBA
  36 {
  37   class Object;
  38   class PolicyList;
  39
  40   class Object;
  41   typedef Object *Object_ptr;
  42 }
  43
  44 namespace TAO
  45 {
  46   class Synch_Twoway_Invocation;
  47
  48   /**
  49    * @class Profile_Transport_Resolver
  50    *
  51    * @brief Chooses the profile and a transport for a target object on
  52    * which an invocation can be made.
  53    *
  54    * A target object is represented by multiple profiles, which
  55    * theoretically provides multiple paths to the same target
  56    * object. This class helps in choosing the right profile, and pick
  57    * a transport from cache (or create a new transport if needed) that
  58    * represents the profile.
  59    */
  60   class TAO_Export Profile_Transport_Resolver
  61   {
  62   public:
  63     /// Constructor
  64     /**
  65      * With @a block we tell whether this resolved should always deliver
  66      * a connection by blocking or unblock before the connection is
  67      * completely established. Please note that this has *nothing* to
  68      * do with the synchronous or asynch connect strategy used for
  69      * making connections. This is a local flag used by the clients of
  70      * this to dictate some local behavior.
  71      */
  72     Profile_Transport_Resolver (CORBA::Object *p,
  73                                 TAO_Stub *stub,
  74                                 bool block = true);
  75
  76     ~Profile_Transport_Resolver ();
  77
  78     /// Method where the bunch of the action takes place.
  79     /**
  80      * This is the entry point from the TAO::Invocation_Adapter
  81      * class. This method accesses the endpoint selector factory from
  82      * the ORB_Core to decide on the strategy to be used for selecting
  83      * the profile.
  84      */
  85     void resolve (ACE_Time_Value *val);
  86
  87     //@{
  88     /**
  89      * @name Accessors and mutators for this class. The following methods
  90      * are used by the clients of this class to access strategies and
  91      * other internal workings.
  92      */
  93
  94     /// Mutator for profile.
  95     void profile (TAO_Profile *pfile);
  96
  97     /// Accessor for profile.
  98     TAO_Profile *profile () const;
  99
 100     /// Accessor for TAO_Stub
 101     TAO_Stub *stub () const;
 102
 103     /// Accessor for the target in use
 104     CORBA::Object *object () const;
 105
 106     /// Accessor for the transport reserved for this invocation.
 107     TAO_Transport *transport () const;
 108
 109     /// See if the transport cache has an available transport and
 110     /// use that one rather than trying to connect via the connector.
 111     /// Separating this functionality enables the look up of many
 112     /// endpoints before trying the more time-consuming trip through
 113     /// the actual connector.
 114     int find_transport (TAO_Transport_Descriptor_Interface *);
 115
 116     /// Accessor to indicate whether we should block while
 117     /// establishing a connection.
 118     bool blocked_connect () const;
 119     //@}
 120
 121     /// Signal to let the resolver know that the transport has been
 122     /// released back to the cache.
 123     void transport_released () const;
 124
 125     /// This is a callback method used by the endpoint selectors to
 126     /// delegate the responsibility of reserving a transport from the
 127     /// connection cache for this invocation. When the descriptor
 128     /// contains more than one endpoint (as part of a linked list) and
 129     /// the parallel flag is true then the connector will look for a
 130     /// connection on any of the endpoints if it supports that
 131     /// behavior, otherwise an ENOTSUP errno will be set and the
 132     /// method will return false.
 133     bool try_connect (TAO_Transport_Descriptor_Interface *desc,
 134                       ACE_Time_Value *val);
 135
 136     bool try_parallel_connect (TAO_Transport_Descriptor_Interface *desc,
 137                                ACE_Time_Value *val);
 138
 139     /// This method wraps a call to the orb core to see if parallel
 140     /// connection attempts are even desired. This is controlled by
 141     /// the -ORBUseParallelConnects 1|0 commandline option.
 142     bool use_parallel_connect () const;
 143
 144     /// Initialize the inconsistent policy list that this object has
 145     /// cached.
 146     void init_inconsistent_policies ();
 147
 148     CORBA::PolicyList *inconsistent_policies () const;
 149
 150     CORBA::PolicyList *steal_inconsistent_policies ();
 151   private:
 152     /// Helper method to access get the connection timeout from the
 153     /// ORB.
 154     bool get_connection_timeout (ACE_Time_Value &max_wait_time);
 155
 156     void operator= (const Profile_Transport_Resolver &);
 157     Profile_Transport_Resolver (const Profile_Transport_Resolver &);
 158
 159   private:
 160     bool try_connect_i (TAO_Transport_Descriptor_Interface *desc,
 161                         ACE_Time_Value *val,
 162                         bool parallel);
 163
 164     /// Target object
 165     mutable CORBA::Object *obj_;
 166
 167     /// Stub object for the target object.
 168     TAO_Stub *stub_;
 169
 170     /// The transport selected for this invocation.
 171
 172     /// Using the wrapper guard ensures it is available for use with
 173     /// the Transport Current interfaces.
 174     TAO::Transport_Selection_Guard transport_;
 175
 176     /// The profile that has been selected for this invocation.
 177     TAO_Profile *profile_;
 178
 179     /// List of inconsistent policies
 180     /**
 181      * If current effective policies cause the invocation to raise
 182      * CORBA::INV_POLICY exception, the conflicting/problematic policies
 183      * are stored in this list.  This is used by
 184      * Object::_validate_connection() method to inform clients about
 185      * causes of invocation failure.
 186      * @par
 187      * Conflicting policies are only stored in this list if
 188      * init_inconsistent_policies() method has been called prior to the
 189      * beginning of invocation.  This saves extra work of conflicting
 190      * policies 'logging' when it's not needed.
 191      *
 192      * @note We don't use _var with a reason. Using _var would
 193      * involve including the  header file for at least
 194      * Policy_ForwardC.h, and that is what we precisely want to
 195      * avoid.
 196      */
 197     CORBA::PolicyList *inconsistent_policies_;
 198
 199     /// Has the transport been idle?
 200     mutable bool is_released_;
 201
 202     /// Should we block while trying to make a connection
 203     bool const blocked_;
 204   };
 205 } // TAO namespace end
 206
 207 TAO_END_VERSIONED_NAMESPACE_DECL
 208
 209 #if defined (__ACE_INLINE__)
 210 # include "tao/Profile_Transport_Resolver.inl"
 211 #endif /* __ACE_INLINE__ */
 212
 213 #include /**/ "ace/post.h"
 214
 215 #endif /*TAO_PROFILE_TRANSPORT_RESOLVER_H*/