ServerTransport.hpp

//******************************************************************************
// RCF - Remote Call Framework
//
// Copyright (c) 2005 - 2013, Delta V Software. All rights reserved.
// http://www.deltavsoft.com
//
// RCF is distributed under dual licenses - closed source or GPL.
// Consult your particular license for conditions of use.
//
// If you have not purchased a commercial license, you are using RCF 
// under GPL terms.
//
// Version: 2.0
// Contact: support <at> deltavsoft.com 
//
//******************************************************************************

#ifndef INCLUDE_RCF_SERVERTRANSPORT_HPP
#define INCLUDE_RCF_SERVERTRANSPORT_HPP

#include <memory>
#include <set>
#include <string>
#include <vector>

#include <boost/enable_shared_from_this.hpp>
#include <boost/shared_ptr.hpp>

#include <RCF/ByteBuffer.hpp>
#include <RCF/Enums.hpp>
#include <RCF/Export.hpp>
#include <RCF/Filter.hpp>
#include <RCF/ThreadLibrary.hpp>

namespace RCF {

    class Filter;
    class Endpoint;
    class ClientTransport;
    class SessionState;
    class StubEntry;
    class RcfSession;

    typedef boost::shared_ptr<Filter>               FilterPtr;
    typedef std::auto_ptr<ClientTransport>        ClientTransportAutoPtr;
    typedef boost::shared_ptr<StubEntry>            StubEntryPtr;

    class ServerTransport;
    typedef boost::shared_ptr<ServerTransport>    ServerTransportPtr;
    typedef std::auto_ptr<ServerTransport>        ServerTransportAutoPtr;

    typedef boost::shared_ptr<RcfSession>           RcfSessionPtr;

    class RemoteAddress
    {
    public:
        virtual ~RemoteAddress()
        {}

        virtual std::string string() const
        {
            return "";
        }
    };

    class NoRemoteAddress : public RemoteAddress
    {};
   
    class SessionState : public boost::enable_shared_from_this<SessionState>
    {
    public:

        SessionState();
        virtual ~SessionState();

        virtual void        postRead() = 0;
        virtual ByteBuffer  getReadByteBuffer() = 0;
        virtual void        postWrite(std::vector<ByteBuffer> &byteBuffers) = 0;
        virtual void        postClose() = 0;
       
        virtual ServerTransport & 
                            getServerTransport() = 0;

        virtual const RemoteAddress & 
                            getRemoteAddress() = 0;

        virtual bool        isConnected() = 0;


        virtual void        setTransportFilters(const std::vector<FilterPtr> &filters) = 0;
        virtual void        getTransportFilters(std::vector<FilterPtr> &filters) = 0;
        void                setEnableReconnect(bool enableReconnect);
        bool                getEnableReconnect();

        boost::uint64_t     getTotalBytesReceived() const;
        boost::uint64_t     getTotalBytesSent() const;

        RcfSessionPtr       getSessionPtr() const;

    protected:
        bool                    mEnableReconnect;
        boost::uint64_t         mBytesReceivedCounter;
        boost::uint64_t         mBytesSentCounter;

        RcfSessionPtr           mSessionPtr;

    };

    typedef boost::shared_ptr<SessionState>   SessionStatePtr;
    typedef boost::weak_ptr<SessionState>     SessionStateWeakPtr;

    class RcfSession;
    typedef boost::shared_ptr<RcfSession>       RcfSessionPtr;
    
    typedef RcfSession                          I_Session;
    typedef RcfSessionPtr                       SessionPtr;

    class ThreadPool;
    typedef boost::shared_ptr<ThreadPool>       ThreadPoolPtr;

    enum RpcProtocol
    {
        Rp_Rcf = 0,
        Rp_JsonRpc = 1,
    };

    class RCF_EXPORT ServerTransport
    {
    public:
        ServerTransport();

        virtual ~ServerTransport() {}

        virtual ServerTransportPtr 
                        clone() = 0;

        // Deprecated - use setMaxIncomingMessageLength()/getMaxIncomingMessageLength() instead.
        ServerTransport & setMaxMessageLength(std::size_t maxMessageLength);
        std::size_t         getMaxMessageLength() const;

        // *** SWIG BEGIN ***

        virtual TransportType getTransportType() = 0;

        ServerTransport & setMaxIncomingMessageLength(std::size_t maxMessageLength);

        std::size_t         getMaxIncomingMessageLength() const;

        ServerTransport & setConnectionLimit(std::size_t connectionLimit);

        std::size_t         getConnectionLimit() const;

        ServerTransport & setInitialNumberOfConnections(std::size_t initialNumberOfConnections);

        std::size_t         getInitialNumberOfConnections() const;

        ServerTransport & setThreadPool(ThreadPoolPtr threadPoolPtr);

        ServerTransport & setSupportedProtocols(const std::vector<TransportProtocol> & protocols);

        const std::vector<TransportProtocol> & getSupportedProtocols() const;

        // *** SWIG END ***

        void                setRpcProtocol(RpcProtocol rpcProtocol);
        RpcProtocol         getRpcProtocol() const;

        
    protected:

        RpcProtocol                 mRpcProtocol;
        bool                        mCustomFraming;

    private:

        mutable ReadWriteMutex      mReadWriteMutex;
        std::size_t                 mMaxMessageLength;
        std::size_t                 mConnectionLimit;       
        std::size_t                 mInitialNumberOfConnections;

        std::vector<TransportProtocol> mSupportedProtocols;

    protected:

        Mutex                           mSessionsMutex;
        std::set<SessionStateWeakPtr>   mSessions;

    public:

        template<typename Iter>
        void enumerateSessions(const Iter & iter)
        {
            Lock lock(mSessionsMutex);
            std::copy(mSessions.begin(), mSessions.end(), iter);
        }

    };

    class ServerTransportEx
    {
    public:

        virtual ~ServerTransportEx() {}

        virtual ClientTransportAutoPtr 
            createClientTransport(
                const Endpoint &endpoint) = 0;
       
        virtual SessionPtr 
            createServerSession(
                ClientTransportAutoPtr & clientTransportAutoPtr,
                StubEntryPtr stubEntryPtr,
                bool keepClientConnection) = 0;

        virtual ClientTransportAutoPtr 
            createClientTransport(
                SessionPtr sessionPtr) = 0;
       
        virtual bool 
            reflect(
                const SessionPtr &sessionPtr1,
                const SessionPtr &sessionPtr2) = 0;       
    };   

    RCF_EXPORT std::size_t  getDefaultMaxMessageLength();

    RCF_EXPORT void         setDefaultMaxMessageLength(
                                std::size_t maxMessageLength);

} // namespace RCF

#endif // ! INCLUDE_RCF_SERVERTRANSPORT_HPP