TAO/tao/TAO_Server_Request.h

   1 // -*- C++ -*-
   2
   3 //=============================================================================
   4 /**
   5 *  @file    TAO_Server_Request.h
   6 *
   7 *  Header file for CORBA's Server Skeleton Interface's
   8 *  "Server Request" type.
   9 *
  10 *
  11 * @author Copyright 1994-1995 by Sun Microsystems Inc.
  12 * @author Chris Cleeland
  13 * @author Aniruddha Gokhale
  14 */
  15 //=============================================================================
  16
  17 #ifndef TAO_SERVER_REQUEST_H
  18 #define TAO_SERVER_REQUEST_H
  19
  20 #include /**/ "ace/pre.h"
  21 #include "ace/SString.h"
  22
  23 #if !defined (ACE_LACKS_PRAGMA_ONCE)
  24 # pragma once
  25 #endif /* ACE_LACKS_PRAGMA_ONCE */
  26
  27 #include "tao/Tagged_Profile.h"
  28 #include "tao/Service_Context.h"
  29 #include "tao/Object.h"
  30 #include "tao/Transport_Selection_Guard.h"
  31 #include "tao/GIOPC.h"
  32
  33 #if TAO_HAS_INTERCEPTORS == 1
  34
  35 TAO_BEGIN_VERSIONED_NAMESPACE_DECL
  36
  37 namespace TAO
  38 {
  39   class PICurrent;
  40   class PICurrent_Impl;
  41 }
  42 TAO_END_VERSIONED_NAMESPACE_DECL
  43
  44 #include "tao/PortableInterceptorC.h"
  45
  46 #endif  /* TAO_HAS_INTERCEPTORS == 1 */
  47
  48 TAO_BEGIN_VERSIONED_NAMESPACE_DECL
  49
  50 class TAO_GIOP_Message_Base;
  51 class TAO_Transport;
  52 class TAO_AMH_Response_Handler;
  53
  54 namespace CORBA
  55 {
  56   class ORB;
  57   typedef ORB *ORB_ptr;
  58
  59   class Exception;
  60 }
  61
  62 namespace TAO
  63 {
  64   namespace CSD
  65   {
  66     class FW_Server_Request_Wrapper;
  67   }
  68 }
  69
  70 class TAO_Operation_Details;
  71
  72 /**
  73  * @class TAO_ServerRequest
  74  *
  75  * @brief Class representing a ServerRequest object.
  76  *
  77  * Encapsulates CDR, transport and pluggable messaging
  78  * components on the server side.
  79 */
  80 class TAO_Export TAO_ServerRequest
  81 {
  82 public:
  83   /// Declare FW_Server_Request_Wrapper a friend
  84   /// This friendship makes the FW_Server_Request_Wrapper be able to
  85   /// clone the TAO_ServerRequest.
  86   friend class TAO::CSD::FW_Server_Request_Wrapper;
  87
  88   /// Declare TAO_AMH_Response_Handler a friend
  89   /**
  90    * The TAO_AMH_Response_Handler class needs to copy part of the
  91    * state in a TAO_ServerRequest, however, we do not want to expose
  92    * that state as public members of this class, neither do we want to
  93    * add modifiers to the TAO_AMH_Response_Handler class that would
  94    * allow us (the TAO_ServerRequest class) to set the state.
  95    *
  96    * Lucky for us, C++ is a language for adult developers, and allow
  97    * us to use the evil "friend" declaration.
  98    *
  99    */
 100   friend class TAO_AMH_Response_Handler;
 101
 102   // Constructors.
 103
 104   TAO_ServerRequest (TAO_GIOP_Message_Base *mesg_base,
 105                      TAO_InputCDR &input,
 106                      TAO_OutputCDR &output,
 107                      TAO_Transport *transport,
 108                      TAO_ORB_Core *orb_core);
 109
 110   TAO_ServerRequest (TAO_GIOP_Message_Base *mesg_base,
 111                      CORBA::ULong request_id,
 112                      CORBA::Boolean response_expected,
 113                      CORBA::Boolean deferred_flag,
 114                      TAO::ObjectKey &object_key,
 115                      const char *operation,
 116                      TAO_OutputCDR &output,
 117                      TAO_Transport *transport,
 118                      TAO_ORB_Core *orb_core,
 119                      int &parse_error);
 120
 121   /// Constructor used by thru-POA collocated invocation path.
 122   TAO_ServerRequest (TAO_ORB_Core * orb_core,
 123                      TAO_Operation_Details const & details,
 124                      CORBA::Object_ptr target);
 125
 126   /// Destructor.
 127   ~TAO_ServerRequest ();
 128
 129   /**
 130    * @name Request attributes.
 131    */
 132   //@{
 133   /// Return the operation name.
 134   const char *operation () const;
 135
 136   /// Set the operation name.
 137   void operation (const char *operation, size_t length, int release);
 138
 139   /// Return the length of the operation.
 140   size_t operation_length () const;
 141   //@}
 142
 143   /// Return the underlying ORB.
 144   CORBA::ORB_ptr orb ();
 145
 146   /// Return the ORB core pointer member.
 147   TAO_ORB_Core *orb_core () const;
 148
 149   /// Start a Reply message.
 150   void init_reply ();
 151
 152   /// Retrieve the incoming stream.
 153   TAO_InputCDR * incoming () const;
 154
 155   /// Retrieve the outgoing stream.
 156   TAO_OutputCDR * outgoing () const;
 157
 158   /// Is the response expected?
 159   CORBA::Boolean response_expected () const;
 160
 161   /// Should the reply be deferred?
 162   CORBA::Boolean deferred_reply () const;
 163
 164   /// Set the response expected flag.
 165   void response_expected (CORBA::Boolean response);
 166
 167   /// Should we return before dispatching the servant?
 168   CORBA::Boolean sync_with_server () const;
 169
 170   /// Set the sync_with_server flag.
 171   void sync_with_server (CORBA::Boolean sync_flag);
 172
 173   /// Is the request at risk of being queued?
 174   CORBA::Boolean is_queued () const;
 175
 176   /// Set the queued flag.
 177   void is_queued (CORBA::Boolean qeueued_flag);
 178
 179   /// Send a sync reply if needed after _dispatch is called
 180   void sync_after_dispatch ();
 181
 182   /// Send a sync reply if needed before _dispatch is called to avoid
 183   /// possible queuing first.
 184   void sync_before_dispatch ();
 185
 186   /// Used with reliable oneway requests.
 187   void send_no_exception_reply ();
 188
 189   TAO::ObjectKey &object_key ();
 190
 191   /// Return the request TAO_Service_Context
 192   TAO_Service_Context &request_service_context ();
 193
 194   /// Return the reply TAO_Service_Context
 195   TAO_Service_Context &reply_service_context ();
 196
 197   IOP::ServiceContextList &reply_service_info ();
 198
 199   IOP::ServiceContextList &request_service_info ();
 200
 201   /// Return the underlying transport
 202   TAO_Transport *transport ();
 203
 204   /// To handle System Exceptions at the lowest level, a method
 205   /// returning the request_id_ is needed.
 206   //@{
 207   CORBA::ULong request_id ();
 208   void request_id (CORBA::ULong req);
 209   //@}
 210
 211   /**
 212    * Set the reference to the object the request should be forwarded
 213    * to.  This reference will only be used if set prior to calling
 214    * init_reply().
 215    */
 216   void forward_location (CORBA::Object_ptr forward_reference);
 217
 218   /// Get the forward_location.
 219   CORBA::Object_ptr forward_location ();
 220
 221   /**
 222    * Since forward location is allowed to be nil then this is a proper
 223    * method to check if the request is being forwarded.
 224    */
 225   bool is_forwarded () const;
 226
 227   /// Get the reply status
 228   GIOP::ReplyStatusType reply_status ();
 229
 230   /// Set the reply status
 231   void reply_status (GIOP::ReplyStatusType except_type);
 232
 233   /// Set the requesting principal
 234   void requesting_principal (const CORBA::OctetSeq & principal);
 235
 236   /// Return the reference to the tagged profile
 237   TAO_Tagged_Profile &profile ();
 238
 239   void tao_send_reply ();
 240
 241   void tao_send_reply_exception (const CORBA::Exception& ex);
 242
 243   /// Set the boolean member to true.
 244   void is_dsi ();
 245
 246   /// Set the member.
 247   void dsi_nvlist_align (ptrdiff_t alignment);
 248
 249   /// Get the operation details for the current request.
 250   TAO_Operation_Details const * operation_details () const;
 251
 252   /// Set the argument_flag
 253   void argument_flag (CORBA::Boolean flag);
 254
 255   /// Get the argument_flag
 256   CORBA::Boolean argument_flag ();
 257
 258   /// Returns @c true if the current request is collocated.
 259   bool collocated () const;
 260
 261 #if TAO_HAS_INTERCEPTORS == 1
 262   /// Send cached reply. Used in scenarios where the FTORB thinks that
 263   /// this request is a duplicate
 264   void send_cached_reply (CORBA::OctetSeq &ocs);
 265
 266   /// Return a reference to the number of interceptors pushed on to
 267   /// the current interceptor flow stack.
 268   /**
 269    * @note It is a reference since the Portable Interceptor flow stack
 270    *       code must be able to modify this value and use that value
 271    *       at a later time without being forced to use TSS.
 272    */
 273   size_t & interceptor_count ();
 274
 275   /// Return a reference to the "request scope" PICurrent object.
 276   TAO::PICurrent_Impl *rs_pi_current ();
 277
 278   CORBA::Exception *caught_exception ();
 279
 280   void caught_exception (CORBA::Exception *exception);
 281
 282   /// Set the status of the received reply.
 283   void pi_reply_status (PortableInterceptor::ReplyStatus s);
 284
 285   /// Get the status of the received reply.
 286   PortableInterceptor::ReplyStatus pi_reply_status ();
 287 #endif  /* TAO_HAS_INTERCEPTORS == 1 */
 288
 289 #if TAO_HAS_ZIOP == 1
 290   CORBA::Policy_ptr clientCompressionEnablingPolicy ();
 291   void clientCompressionEnablingPolicy (CORBA::Policy_ptr);
 292   CORBA::Policy_ptr clientCompressorIdLevelListPolicy ();
 293   void clientCompressorIdLevelListPolicy (CORBA::Policy_ptr);
 294 #endif /* TAO_HAS_ZIOP == 1 */
 295
 296 private:
 297   /// Default ctor only used to create a TAO_ServerRequest that is about
 298   /// to be the target of a clone operation.
 299   TAO_ServerRequest ();
 300
 301   TAO_GIOP_Message_Base *mesg_base_;
 302
 303   /// Operation name.
 304   const char* operation_;
 305
 306   /// Operation length.
 307   size_t operation_len_;
 308
 309   /// Do we own the memory associated with operation_?
 310   bool release_operation_;
 311
 312   CORBA::Object_var forward_location_;
 313
 314   bool is_forwarded_;
 315
 316   /// Incoming stream.
 317   TAO_InputCDR *incoming_;
 318
 319   /// Outgoing stream.
 320   TAO_OutputCDR *outgoing_;
 321
 322   /// false: oneway (SYNC_NONE or SYNC_WITH_TRANSPORT)
 323   /// true: twoway, or oneway (SYNC_WITH_SERVER or SYNC_WITH_TARGET)
 324   CORBA::Boolean response_expected_;
 325
 326   /**
 327    * false: Reply would be sent by the object of this class which is the
 328    *    default.
 329    * true: Reply would not be prepared by this class and it would be
 330    *    deferred for somebody.
 331    */
 332   CORBA::Boolean deferred_reply_;
 333
 334   /// true: oneway (SYNC_WITH_SERVER)
 335   /// false: anything else
 336   CORBA::Boolean sync_with_server_;
 337
 338   /// true: this request is (or may be) queued by the POA
 339   /// false: no POA queuing involved
 340   CORBA::Boolean is_queued_;
 341
 342   /// Did we get passed to a CORBA::ServerRequest?
 343   CORBA::Boolean is_dsi_;
 344
 345   /// Reply status (will be NO_EXCEPTION in the majority of the cases).
 346   GIOP::ReplyStatusType reply_status_;
 347
 348   /// A pointer to the ORB Core for the context where the request was
 349   /// created.
 350   TAO_ORB_Core *orb_core_;
 351
 352   /// Service Context info
 353   TAO_Service_Context request_service_context_;
 354   TAO_Service_Context reply_service_context_;
 355
 356   /// Unique identifier for a request.
 357   CORBA::ULong request_id_;
 358
 359   /// The tagged profile that has the addressing information.
 360   TAO_Tagged_Profile profile_;
 361
 362   /// Identifies the requester.
 363   CORBA::OctetSeq_var requesting_principal_;
 364
 365   /// Used to pad CDR stream if we have used DSI.
 366   ptrdiff_t dsi_nvlist_align_;
 367
 368   TAO_Operation_Details const * operation_details_;
 369
 370   /**
 371    * An argument flag to indicate whether there is any data that is
 372    * going to get marshaled along as a reply. The default will be true
 373    * which indicates that we have some data that needs to be sent back
 374    * to the client.
 375    */
 376   CORBA::Boolean argument_flag_;
 377
 378 #if TAO_HAS_INTERCEPTORS == 1
 379   /// The number of interceptors pushed on to the current interceptor
 380   /// flow stack.
 381   size_t interceptor_count_;
 382
 383   /// The "Request Scope Current" (RSC) object, as required by
 384   /// Portable Interceptors.
 385   TAO::PICurrent_Impl *rs_pi_current_;
 386
 387   /// Pointer to the caught exception.
 388   CORBA::Exception * caught_exception_;
 389
 390   /// Reply status for the current request.
 391   PortableInterceptor::ReplyStatus pi_reply_status_;
 392 #endif  /* TAO_HAS_INTERCEPTORS == 1 */
 393
 394   ///// Transport class.
 395   /// An RAII (resource acquisition is initialization) class instance
 396   /// for interfacing with TSS storage for the "current" transport.
 397   TAO::Transport_Selection_Guard transport_;
 398
 399 #if TAO_HAS_ZIOP == 1
 400   CORBA::Policy_var clientCompressionEnablingPolicy_;
 401   CORBA::Policy_var clientCompressorIdLevelListPolicy_;
 402 #endif /* TAO_HAS_ZIOP == 1 */
 403 };
 404
 405 TAO_END_VERSIONED_NAMESPACE_DECL
 406
 407 #if defined (__ACE_INLINE__)
 408 # include "tao/TAO_Server_Request.inl"
 409 #endif /* __ACE_INLINE__ */
 410
 411 #include /**/ "ace/post.h"
 412
 413 #endif /* TAO_SERVER_REQUEST_H */