it_bus_pdk/messaging_transport.h

#ifndef _IT_BUS_PDK_MESSAGING_TRANSPORT_H_
#define _IT_BUS_PDK_MESSAGING_TRANSPORT_H_

// @Copyright 2004 IONA Technologies, Plc. All Rights Reserved.
//

#include <orbix/workqueue.hh>
#include <it_bus/types.h>
#include <it_bus/api_defines.h>
#include <it_bus/connect_exception.h>
#include <it_bus/transport_exception.h>
#include <it_bus/port.h>
#include <it_bus/threading_model.h>
#include <it_bus/operation.h>

#include <it_wsdl/wsdl_factory.h>
#include <it_wsdl/wsdl_port.h>
#include <it_wsdl/wsdl_operation.h>
#include <it_wsdl/wsdl_extension_factory.h>
#include <it_wsdl/wsdl_extension_element.h>

namespace WS_Addressing_2004
{
    class AttributedURI;
}

namespace IT_Bus
{
    enum ThreadingResourcesPolicy
    {
        MESSAGING_PORT_DRIVEN = 0,
        BORROWS_WORKQUEUE_SELF_DRIVEN,
        EXTERNALLY_DRIVEN
    };

    class IT_BUS_API TransportPolicyList
    {
      public:
        virtual ~TransportPolicyList();

        virtual void
        set_policy_threading_resources(
            const ThreadingResourcesPolicy policy
        ) = 0;

        virtual const ThreadingResourcesPolicy
        get_policy_threading_resources() const = 0;

        virtual void
        set_policy_messaging_port_threading(
            const ThreadingModel policy
        ) = 0;

        virtual const ThreadingModel
        get_policy_messaging_port_threading() const = 0;

        virtual void
        set_policy_requires_stack_unwind(
            const bool policy
        ) = 0;

        virtual const bool
        get_policy_requires_stack_unwind() const = 0;
    };

    class ContextContainer;
    class IT_BUS_API ClientTransport
    {
      public:
        ClientTransport() {}
        virtual ~ClientTransport();

        virtual void
        initialize(
            const IT_WSDL::WSDLPort& Configuration
        ) = 0;

        virtual IT_WSDL::WSDLExtensionElement&
        get_configuration() = 0;

        virtual void
        connect(
            ContextContainer* out_context_container
        ) = 0;

        virtual void
        disconnect() = 0;

        virtual void
        invoke_oneway(
            const IT_WSDL::WSDLOperation& wsdl_operation,
            const BinaryBuffer&           request_buffer,
            ContextContainer*             out_container,
            ContextContainer*             in_container
        ) = 0;

        virtual void
        invoke(
            const IT_WSDL::WSDLOperation& wsdl_operation,
            const BinaryBuffer&           request_buffer,
            BinaryBuffer&                 response_buffer,
            ContextContainer*             out_container,
            ContextContainer*             in_container
        ) = 0;

        virtual const WS_Addressing_2004::AttributedURI&
        get_address();
    };

    class IT_BUS_API DispatchInfo
    {
      public:

        virtual CorrelationId
        get_correlation_id() const = 0;

        virtual ContextContainer&
        get_incoming_context_container() = 0;

        virtual ContextContainer&
        get_outgoing_context_container() = 0;

        virtual bool
        is_oneway() const = 0;

        virtual const IT_Bus::Exception*
        get_exception() = 0;

        virtual void
        provide_response_buffer(
            BinaryBuffer& response_buffer
        ) = 0;

        virtual bool
        is_transactional_transport() = 0;

      protected:
        DispatchInfo() {}
        virtual ~DispatchInfo();

      private:
        // private and unimplemented to prevent copying
        DispatchInfo(const DispatchInfo&);
        void operator=(const DispatchInfo&);
    };

    class IT_BUS_API TransportCallback
    {
      public:
        TransportCallback() {}
        virtual ~TransportCallback();

        //
        // Called by ServerTransport upon completion of
        // activation.
        //
        virtual void
        transport_activated() = 0;

        //
        // Called by ServerTransport upon pause of listeners/message queue
        //
        virtual void
        transport_deactivated() = 0;

        virtual void
        transport_activation_failed(
            const TransportException& ex
        ) = 0;

        virtual void
        asynchronous_exception(
            IT_Bus::Exception& ex
        ) = 0;

        //
        // Called by ServerTransport upon completion of
        // shutdown.
        //
        virtual void
        transport_shutdown_complete() = 0;

        //
        // Called by ServerTransport get a DispatchInfo.
        // This call also assigns a Port-specific
        // unique correlation ID for the request.
        // It's called before the call to dispatch().
        //
        virtual DispatchInfo&
        get_dispatch_context() = 0;

        //
        // Called by ServerTransport to push the request
        // up the dispatch stack. It creates a WorkItem
        // representing the server-side dispatch.
        // It then either executes the WorkItem, or enqueues it
        // to a (mostly Service's) WorkQueue.
        //
        virtual void
        dispatch(
            BinaryBuffer& request_message,
            DispatchInfo& dispatch_context,
            bool          dispatch_acynchronously_if_possible = 0
        ) = 0;
    };

    class IT_BUS_API ServerTransport
    {
      public:
        ServerTransport() {}
        virtual ~ServerTransport();

        virtual void
        activate(
            TransportCallback&          callback,
            IT_WorkQueue::WorkQueue_ptr work_queue = 0
        ) = 0;

        virtual void
        deactivate() = 0;

        virtual IT_WSDL::WSDLExtensionElement&
        get_configuration() = 0;

        virtual void
        shutdown() = 0;

        //
        // The MessageInterceptor closest to ServerTransport
        // calls this method to pass the reply to the transport.
        //
        virtual void
        send(
            BinaryBuffer& reply_message,
            DispatchInfo& dispatch_context
        ) = 0;

        virtual void
        run();

        // Multiaddress Dispatching
        //
        // We don't do anything in the base versions.
        // This is to avoid source incompatibility
        // with existing transport implementations
        //

        /*
         * Set the multiaddress dispatching mode.
         * Called by the MessagingPort at the time of transport instantion.
         * Used by the transport while upcalling to populate the
         * AddressContext used for distinguishing between instances.
         */
        virtual void
        set_multiaddress_dispatch()
        {
        }

        /*
         * Called by the MessagingPort to create a Reference with the given
         * Addressing information. The transport level addressing information
         * is distinguished on the different instance ids
         * This method is used internally by the runtime when a user
         * calls get_reference_with_id on a Service instance.
         * @param String to be used when creating new address.
         * @param WSDLPort to be populated by the Transport
         */
        virtual void
        get_address_from_id(
            const String& /*instance_id*/,
            IT_WSDL::WSDLPort& /*wsdl_port*/
        )
        {
        }

        virtual void
        activate(
            TransportCallback&                       callback,
            IT_WorkQueue::WorkQueue_ptr              work_queue,
            const WS_Addressing_2004::AttributedURI& listento_address
        );

        virtual const WS_Addressing_2004::AttributedURI&
        get_address();
    };

    class IT_BUS_API ClientTransactionalTransport
      : public ClientTransport,
        public TransactionInterface
    {
    };

    class IT_BUS_API ServerTransactionalTransport
      : public ServerTransport,
        public TransactionInterface
    {
    };

    class IT_BUS_API TransportFactory
    {
      public:

        virtual ClientTransport*
        create_client_transport() = 0;

        virtual void
        destroy_client_transport(
            ClientTransport * transport
        ) = 0;

        virtual ThreadingModel
        get_client_threading_model() = 0;

        virtual ServerTransport*
        create_server_transport(
            const IT_WSDL::WSDLPort& configuration
        ) = 0;

        virtual void
        destroy_server_transport(
            ServerTransport* transport
        ) = 0;

        virtual void
        register_wsdl_extension_factories(
            IT_WSDL::WSDLFactory & factory
        ) const = 0;

        virtual void
        deregister_wsdl_extension_factories(
            IT_WSDL::WSDLFactory & factory
        ) const = 0;

        virtual const TransportPolicyList*
        get_policies() = 0;

      protected:
        TransportFactory() {}
        virtual ~TransportFactory();

      private:
        // private and unimplemented to prevent copying
        TransportFactory(const TransportFactory&);
        void operator=(const TransportFactory&);
    };
}

#endif  

---