r2corba 1.4.1

data/ext/librpoa/servant.h

@@ -0,0 +1,116 @@
+/*--------------------------------------------------------------------
+# servant.h - R2TAO CORBA Servant support
+#
+# Author: Martin Corino
+#
+# This program is free software; you can redistribute it and/or
+# modify it under the terms of the R2CORBA LICENSE which is
+# included with this program.
+#
+# Copyright (c) Remedy IT Expertise BV
+# Chamber of commerce Rotterdam nr.276339, The Netherlands
+#------------------------------------------------------------------*/
+
+#if ((TAO_MAJOR_VERSION < 2) || (TAO_MAJOR_VERSION == 2 && TAO_MINOR_VERSION == 0 && TAO_BETA_VERSION <= 1))
+# define RPOA_NEED_DSI_FIX  1
+
+# include "srvreq_fix.h"
+
+# define R2CORBA_ServerRequest  R2CORBA::ServerRequest
+# define R2CORBA_ServerRequest_ptr  R2CORBA::ServerRequest_ptr
+#else
+# define R2CORBA_ServerRequest  CORBA::ServerRequest
+# define R2CORBA_ServerRequest_ptr  CORBA::ServerRequest_ptr
+#endif
+
+//-------------------------------------------------------------------
+//  R2TAO Servant class
+//
+//===================================================================
+
+class DSI_Servant : public PortableServer::DynamicImplementation
+{
+public:
+  DSI_Servant (VALUE rbServant);
+  // ctor
+  virtual ~DSI_Servant ();
+  // dtor
+
+  virtual void invoke (CORBA::ServerRequest_ptr request);
+      //ACE_THROW_SPEC ((CORBA::SystemException));
+#if RPOA_NEED_DSI_FIX
+  void invoke_fix (R2CORBA::ServerRequest_ptr request);
+#endif
+
+  virtual CORBA::RepositoryId _primary_interface (
+      const PortableServer::ObjectId &oid,
+      PortableServer::POA_ptr poa);
+
+  virtual CORBA::Boolean _is_a (const char *logical_type_id);
+
+  virtual CORBA::Boolean _non_existent (void);
+
+  //virtual CORBA::InterfaceDef_ptr _get_interface (void);
+
+  virtual CORBA::Object_ptr _get_component (void);
+
+  virtual char * _repository_id (void);
+
+  enum METHOD {
+    NONE,
+    IS_A,
+    NON_EXISTENT,
+    GET_INTERFACE,
+    GET_COMPONENT,
+    REPOSITORY_ID
+  };
+
+  VALUE rbServant () {
+    return this->rbServant_;
+  }
+
+  void free_servant ();
+
+  void activate_servant ();
+
+protected:
+  virtual const char *_interface_repository_id (void) const;
+
+#if RPOA_NEED_DSI_FIX
+  /// Turns around and calls invoke.
+  virtual void _dispatch (TAO_ServerRequest &request, void *context);
+#endif
+
+  void register_with_servant ();
+
+  void cleanup_servant ();
+  void inner_cleanup_servant ();
+
+  METHOD  method_id (const char* method);
+
+  virtual void inner_invoke (R2CORBA_ServerRequest_ptr request);
+
+  void invoke_SI (R2CORBA_ServerRequest_ptr request);
+  void invoke_DSI (R2CORBA_ServerRequest_ptr request);
+
+  static VALUE _invoke_implementation(VALUE args);
+
+private:
+  VALUE rbServant_;
+  // The Ruby Servant
+
+  CORBA::String_var repo_id_;
+
+  struct ThreadSafeArg
+  {
+    ThreadSafeArg (DSI_Servant* srv,
+                   R2CORBA_ServerRequest_ptr req)
+      : servant_(srv), request_(req) {}
+    DSI_Servant* servant_;
+    R2CORBA_ServerRequest_ptr request_;
+  };
+
+  static void* thread_safe_invoke (void * arg);
+  static void* thread_safe_cleanup (void* arg);
+};
+

data/ext/librpoa/srvreq_fix.cpp

@@ -0,0 +1,283 @@
+/*--------------------------------------------------------------------
+# srvreq_fix.h - R2TAO CORBA Servant support
+#
+# Author: Martin Corino
+#
+# This program is free software; you can redistribute it and/or
+# modify it under the terms of the R2CORBA LICENSE which is
+# included with this program.
+#
+# Copyright (c) Remedy IT Expertise BV
+# Chamber of commerce Rotterdam nr.276339, The Netherlands
+#------------------------------------------------------------------*/
+
+#ifndef __SRVREQ_FIX_CPP__
+#define __SRVREQ_FIX_CPP__
+
+#include "tao/DynamicInterface/DII_Arguments.h"
+#include "tao/DynamicInterface/Unknown_User_Exception.h"
+#include "tao/PortableServer/Collocated_Arguments_Converter.h"
+#include "tao/AnyTypeCode/NVList.h"
+#include "tao/GIOP_Utils.h"
+#include "tao/AnyTypeCode/Marshal.h"
+#include "tao/AnyTypeCode/TypeCode.h"
+#include "tao/AnyTypeCode/Any_Impl.h"
+#include "tao/operation_details.h"
+#include "tao/SystemException.h"
+
+// Reference counting for DSI ServerRequest object.
+
+CORBA::ULong
+R2CORBA::ServerRequest::_incr_refcount (void)
+{
+  return ++this->refcount_;
+}
+
+CORBA::ULong
+R2CORBA::ServerRequest::_decr_refcount (void)
+{
+  CORBA::ULong const new_count = --this->refcount_;
+
+  if (new_count == 0)
+    delete this;
+
+  return new_count;
+}
+
+R2CORBA::ServerRequest::ServerRequest (TAO_ServerRequest &orb_server_request)
+  : lazy_evaluation_ (0),
+    ctx_ (CORBA::Context::_nil ()),
+    params_ (CORBA::NVList::_nil ()),
+    retval_ (0),
+    exception_ (0),
+    refcount_ (1),
+    orb_server_request_ (orb_server_request),
+    sent_gateway_exception_ (false)
+{
+  this->orb_server_request_.is_dsi ();
+}
+
+R2CORBA::ServerRequest::~ServerRequest (void)
+{
+  if (this->params_ != 0)
+    {
+      ::CORBA::release (this->params_);
+    }
+
+  delete this->retval_;
+  delete this->exception_;
+}
+
+// Unmarshal in/inout params, and set up to marshal the appropriate
+// inout/out/return values later on.
+void
+R2CORBA::ServerRequest::arguments (CORBA::NVList_ptr &list)
+{
+  // arguments() must be called before either of these.
+  if (this->params_ != 0 || this->exception_ != 0)
+    {
+      throw ::CORBA::BAD_INV_ORDER (CORBA::OMGVMCID | 7, CORBA::COMPLETED_NO);
+    }
+
+  // In a collocated situation there will not be an incoming CDR stream
+  // in which case we can get the arguments from the
+  // operation_details using the 'collocated argument converter'.
+  if (this->orb_server_request_.collocated ())
+  {
+    this->params_ = list;
+
+    if (this->orb_server_request_.operation_details ()->cac () != 0)
+      {
+        TAO_OutputCDR output;
+        this->orb_server_request_.operation_details ()->cac (
+                )->dsi_convert_request (this->orb_server_request_,
+                                        output);
+
+        TAO_InputCDR input(output);
+        this->params_->_tao_decode (input, CORBA::ARG_IN | CORBA::ARG_INOUT);
+      }
+  }
+  else
+  {
+    // Save params for later use when marshaling the reply.
+    this->params_ = list;
+
+    // sometimes there is no incoming stream
+    if (this->orb_server_request_.incoming ())
+    {
+      this->params_->_tao_incoming_cdr (*this->orb_server_request_.incoming (),
+                                        CORBA::ARG_IN | CORBA::ARG_INOUT,
+                                        this->lazy_evaluation_);
+
+      // Pass this alignment back to the TAO_ServerRequest.
+      this->orb_server_request_.dsi_nvlist_align (
+                                    this->params_->_tao_target_alignment ());
+    }
+  }
+}
+
+// Store the result value.  There's either an exception, or a result,
+// but not both of them.  Results can be reported (at most once)
+// only after the parameter list has been provided (maybe empty).
+void
+R2CORBA::ServerRequest::set_result (const CORBA::Any &value
+                                  )
+{
+  // Setting a result when another result already exists or if an exception
+  // exists or before the args have been processeed is an error.
+  if (this->retval_ != 0 || this->exception_ != 0 || this->params_ == 0)
+    {
+      throw ::CORBA::BAD_INV_ORDER (CORBA::OMGVMCID | 8, CORBA::COMPLETED_NO);
+    }
+
+  ACE_NEW_THROW_EX (this->retval_,
+                    CORBA::Any (value),
+                    CORBA::NO_MEMORY ());
+}
+
+  // NOTE: if "" is set, there has been a system exception,
+  // and it will take precedence over exceptions reported using the
+  // set_exception() mechanism of the ServerRequest, which we assume
+  // the application writer will use to report only user exceptions.
+  // If both types of exception happen on the same invocation, the user
+  // exception will be lost.
+
+// Store the exception value.
+void
+R2CORBA::ServerRequest::set_exception (const CORBA::Any &value)
+{
+  CORBA::TypeCode_var tc = value.type ();
+
+  CORBA::TCKind const kind = tc->kind ();
+
+  // set_exception() can be called at any time, but the Any arg MUST
+  // contain an exception.
+  if (kind != CORBA::tk_except)
+    {
+      throw ::CORBA::BAD_PARAM (CORBA::OMGVMCID | 21, CORBA::COMPLETED_MAYBE);
+    }
+
+  ACE_NEW_THROW_EX (this->exception_,
+                    CORBA::Any (value),
+                    CORBA::NO_MEMORY ());
+
+  this->orb_server_request_.reply_status (GIOP::USER_EXCEPTION);
+}
+
+// This method will be utilized by the DSI servant to marshal outgoing
+// parameters.
+void
+R2CORBA::ServerRequest::dsi_marshal (void)
+{
+  // There was a user exception, no need to marshal any parameters.
+  if (this->sent_gateway_exception_)
+    {
+      return;
+    }
+
+  // In a collocated situation there is no outgoing CDR stream.
+  // So, in case of an exception we just raise the UnknownUserException
+  // and for a regular reply we use the 'collocated argument converter'.
+  if (this->orb_server_request_.collocated ())
+  {
+    if (this->orb_server_request_.reply_status () == GIOP::USER_EXCEPTION)
+      {
+        throw CORBA::UnknownUserException (*this->exception_);
+      }
+    else if (this->orb_server_request_.operation_details ()->cac () != 0)
+      {
+        TAO_OutputCDR output;
+        // marshal the return value if any
+        if (this->retval_ != 0)
+          {
+            this->retval_->impl ()->marshal_value (output);
+          }
+
+        // marshal the "inout" and "out" parameters.
+        if (this->params_ != 0)
+          {
+            this->params_->_tao_encode (
+                              output,
+                              CORBA::ARG_INOUT | CORBA::ARG_OUT);
+          }
+
+        TAO_InputCDR input (output);
+        // set reply parameters
+        this->orb_server_request_.operation_details ()->cac (
+                )->dsi_convert_reply (this->orb_server_request_,
+                                      input);
+      }
+  }
+  else
+  {
+    if (this->orb_server_request_.reply_status () == GIOP::NO_EXCEPTION)
+      {
+        // In DSI, we can't rely on the skeleton to do this.
+        if (this->retval_ == 0 && this->params_ == 0)
+          {
+          this->orb_server_request_.argument_flag (false);
+          }
+
+        this->orb_server_request_.init_reply ();
+
+        // Send the return value, if any.
+        if (this->retval_ != 0)
+          {
+            this->retval_->impl ()->marshal_value (
+                                        *this->orb_server_request_.outgoing ());
+          }
+
+        // Send the "inout" and "out" parameters.
+        if (this->params_ != 0)
+          {
+            this->params_->_tao_encode (
+                              *this->orb_server_request_.outgoing (),
+                              CORBA::ARG_INOUT | CORBA::ARG_OUT);
+          }
+      }
+    else
+      {
+      // This defaults to true, but just to be safe...
+      this->orb_server_request_.argument_flag (true);
+
+        // Write the reply header to the ORB request's outgoing CDR stream.
+        this->orb_server_request_.init_reply ();
+
+        this->exception_->impl ()->marshal_value (
+                                      *this->orb_server_request_.outgoing ());
+      }
+  }
+
+  // do not send in case of deferred reply
+  if (!this->orb_server_request_.deferred_reply ())
+  {
+    this->orb_server_request_.tao_send_reply ();
+  }
+}
+
+void
+R2CORBA::ServerRequest::gateway_exception_reply (ACE_CString &raw_exception)
+{
+  // This defaults to 1, but just to be safe...
+  this->orb_server_request_.argument_flag (true);
+
+  // This reply path handles only user exceptions.
+  this->orb_server_request_.reply_status (GIOP::USER_EXCEPTION);
+
+  this->orb_server_request_.init_reply ();
+
+  // We know nothing about this exception, so we marshal it as a block
+  // of bytes. The outgoing stream's byte order has already been matched
+  // to the original source of the reply.
+  this->orb_server_request_.outgoing ()->write_octet_array (
+      reinterpret_cast<const CORBA::Octet *> (raw_exception.fast_rep ()),
+      static_cast<CORBA::ULong> (raw_exception.length () + ACE_CDR::MAX_ALIGNMENT)
+    );
+
+  // This will prevent the marshaling of any parameters into this reply.
+  this->sent_gateway_exception_ = true;
+
+  this->orb_server_request_.tao_send_reply ();
+}
+
+#endif

data/ext/librpoa/srvreq_fix.h

@@ -0,0 +1,149 @@
+/*--------------------------------------------------------------------
+# srvreq_fix.h - R2TAO CORBA Servant support
+#
+# Author: Martin Corino
+#
+# This program is free software; you can redistribute it and/or
+# modify it under the terms of the R2CORBA LICENSE which is
+# included with this program.
+#
+# Copyright (c) Remedy IT Expertise BV
+# Chamber of commerce Rotterdam nr.276339, The Netherlands
+#------------------------------------------------------------------*/
+
+#ifndef __SRVREQ_FIX_H__
+#define __SRVREQ_FIX_H__
+
+#include "tao/TAO_Server_Request.h"
+#include "tao/CDR.h"
+#include "ace/Atomic_Op.h"
+
+namespace R2CORBA
+{
+  class ServerRequest;
+  typedef ServerRequest *ServerRequest_ptr;
+
+  typedef TAO_Pseudo_Var_T<ServerRequest> ServerRequest_var;
+  typedef TAO_Pseudo_Out_T<ServerRequest> ServerRequest_out;
+
+  /**
+   * @class ServerRequest
+   *
+   * @brief Class representing the CORBA ServerRequest pseudo-object.
+   *
+   * R2CORBA fixed version for older (< 6.0.2) TAO versions
+   */
+  class ServerRequest
+  {
+  public:
+    ServerRequest (TAO_ServerRequest &orb_server_request);
+
+    ~ServerRequest (void);
+
+    void arguments (CORBA::NVList_ptr &list);
+
+    void set_result (const CORBA::Any &value);
+
+    void set_exception (const CORBA::Any &value);
+
+    void dsi_marshal (void);
+
+    CORBA::Context_ptr ctx (void) const;
+
+    void ctx (CORBA::Context_ptr);
+
+    const char *operation (void) const;
+
+    static ServerRequest_ptr _duplicate (ServerRequest_ptr);
+    static ServerRequest_ptr _nil (void);
+
+    CORBA::ULong _incr_refcount (void);
+    CORBA::ULong _decr_refcount (void);
+
+    void _tao_lazy_evaluation (bool lazy_evaluation);
+
+    int _tao_incoming_byte_order (void) const;
+
+    void _tao_reply_byte_order (int byte_order);
+
+    TAO_ServerRequest & _tao_server_request (void);
+
+    void gateway_exception_reply (ACE_CString &raw_exception);
+
+    typedef R2CORBA::ServerRequest_ptr _ptr_type;
+    typedef R2CORBA::ServerRequest_var _var_type;
+    typedef R2CORBA::ServerRequest_out _out_type;
+
+  private:
+    bool lazy_evaluation_;
+    CORBA::Context_ptr ctx_;
+    CORBA::NVList_ptr params_;
+    CORBA::Any_ptr retval_;
+    CORBA::Any_ptr exception_;
+    ACE_Atomic_Op<TAO_SYNCH_MUTEX, unsigned long> refcount_;
+    TAO_ServerRequest &orb_server_request_;
+    bool sent_gateway_exception_;
+  };
+} // End R2CORBA namespace
+
+inline R2CORBA::ServerRequest_ptr
+R2CORBA::ServerRequest::_duplicate (R2CORBA::ServerRequest_ptr x)
+{
+  if (x != 0)
+    {
+      x->_incr_refcount ();
+    }
+
+  return x;
+}
+
+inline R2CORBA::ServerRequest_ptr
+R2CORBA::ServerRequest::_nil (void)
+{
+  return static_cast <R2CORBA::ServerRequest_ptr>(0);
+}
+
+inline CORBA::Context_ptr
+R2CORBA::ServerRequest::ctx (void) const
+{
+  return this->ctx_;
+}
+
+inline void
+R2CORBA::ServerRequest::ctx (CORBA::Context_ptr ctx)
+{
+  this->ctx_ = ctx;
+}
+
+inline const char *
+R2CORBA::ServerRequest::operation (void) const
+{
+  return this->orb_server_request_.operation ();
+}
+
+inline void
+R2CORBA::ServerRequest::_tao_lazy_evaluation (bool lazy_evaluation)
+{
+  this->lazy_evaluation_ = lazy_evaluation;
+}
+
+inline int
+R2CORBA::ServerRequest::_tao_incoming_byte_order (void) const
+{
+  return this->orb_server_request_.incoming ()->byte_order ();
+}
+
+inline void
+R2CORBA::ServerRequest::_tao_reply_byte_order (int byte_order)
+{
+  this->orb_server_request_.outgoing ()->reset_byte_order (byte_order);
+}
+
+
+inline TAO_ServerRequest &
+R2CORBA::ServerRequest::_tao_server_request (void)
+{
+  return this->orb_server_request_;
+}
+
+#endif