RcfServer.hpp

Go to the documentation of this file.

//******************************************************************************
// RCF - Remote Call Framework
//
// Copyright (c) 2005 - 2023, Delta V Software. All rights reserved.
// https://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: 3.4
// Contact: support <at> deltavsoft.com 
//
//******************************************************************************


#ifndef INCLUDE_RCF_RCFSERVER_HPP
#define INCLUDE_RCF_RCFSERVER_HPP

#include <functional>
#include <map>
#include <memory>
#include <string>
#include <vector>

#include <RCF/Export.hpp>
#include <RCF/RcfClient.hpp>
#include <RCF/ServerTransport.hpp>
#include <RCF/ThreadLibrary.hpp>

#if RCF_FEATURE_FILETRANSFER==1
#include <RCF/FileTransferService.hpp>
#endif

#if RCF_FEATURE_PUBSUB==1
#include <RCF/PublishingService.hpp>
#include <RCF/SubscriptionService.hpp>
#endif

#include <RCF/ServerObjectService.hpp>
#include <RCF/ServerStub.hpp>

namespace RCF {

    
    class RCF_EXPORT RcfServer : Noncopyable
    {
    public:

        typedef std::function<void(RcfServer&)> StartCallback;

    public:



        RcfServer();
        
        RcfServer(const Endpoint &endpoint);

        RcfServer(ServerTransportPtr serverTransportPtr);

        ~RcfServer();




        ServerTransport &       addEndpoint(const Endpoint & endpoint);

        void                    start();

        void                    stop();

        bool                    isStarted();

        void                    enumerateProxyEndpoints(std::vector<std::string>& endpoints);


        void                    setSupportedTransportProtocols(
                                    const std::vector<TransportProtocol> & protocols);

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

        void                    setThreadPool(ThreadPoolPtr threadPoolPtr);

        ThreadPoolPtr           getThreadPool();



        // Waits for the RcfServer to stop. Can be called from any thread.
        void                    waitForStopEvent();

        // Waits for the RcfServer to start.  Can be called from any thread.
        void                    waitForStartEvent();

        ServerTransport &       getServerTransport();

        IpServerTransport &     getIpServerTransport();





        template<typename InterfaceT, typename ImplementationT>
        ServerBindingPtr        bind(ImplementationT & servantObj, const std::string &name = "")
        { 
            std::reference_wrapper<ImplementationT> refWrapper(servantObj);

            RcfClientPtr rcfClientPtr = createServerStub( 
                (InterfaceT *) 0,
                (ImplementationT *) 0, refWrapper);

            return bindImpl( 
                name.empty() ? 
                    InterfaceT::getInterfaceName() :
                    name , 
                rcfClientPtr); 
        }

        template<typename InterfaceT>
        bool                    unbind(const std::string &name = "")
        {
            const std::string &name_ = (name == "") ?
                getInterfaceName((InterfaceT *) NULL) :
                name;

            WriteLock writeLock(mStubMapMutex);
            mStubMap.erase(name_);
            return true;
        }
        



        void                    setCertificate(CertificatePtr certificatePtr);

        CertificatePtr          getCertificate();

        void                    setOpenSslCipherSuite(const std::string & cipherSuite);

        std::string             getOpenSslCipherSuite() const;

        void                    setCaCertificate(CertificatePtr certificatePtr);

        CertificatePtr          getCaCertificate();

        void                    setCertificateValidationCallback(CertificateValidationCallback certificateValidationCb);

        const CertificateValidationCallback & 
                                getCertificateValidationCallback() const;

        void                    setEnableSchannelCertificateValidation(const tstring & peerName);

        tstring                 getEnableSchannelCertificateValidation() const;

        void                    setSslImplementation(SslImplementation sslImplementation);

        SslImplementation       getSslImplementation() const;

#if RCF_FEATURE_SSPI==1
        void                    setSchannelEnabledProtocols(DWORD enabledProtocols);
        DWORD                   getSchannelEnabledProtocols() const;

        void                    setSchannelContextRequirements(ULONG contextRequirements);
        ULONG                   getSchannelContextRequirements() const;
#endif





        void                    setConnectionIdleTimeoutMs(std::uint32_t idleConnectionTimeoutMs);

        std::uint32_t           getConnectionIdleTimeoutMs();


        void                    setConnectionIdleScanIntervalMs(std::uint32_t idleConnectionScanIntervalMs);

        std::uint32_t           getConnectionIdleScanIntervalMs();


        void                    setHttpSessionTimeoutMs(std::uint32_t httpSessionTimeoutMs);

        std::uint32_t           getHttpSessionTimeoutMs();

        void                    setHttpServerHeader(const std::string & httpServerHeader);

        std::string             getHttpServerHeader() const;

#if RCF_FEATURE_HTTP==1
        void                    setHttpMessageVerifier(HttpMessageVerifierPtr verifierPtr);
        HttpMessageVerifierPtr  getHttpMessageVerifier() const;
#endif

        void                    setHealthCheckResponse(int statusCode, std::string statusMessage, std::string content);
        void                    getHealthCheckResponse(int& statusCode, std::string& statusMessage, std::string& content);




        std::uint32_t getServerObjectHarvestingIntervalS() const;

        void setServerObjectHarvestingIntervalS(std::uint32_t harvestingIntervalS);

        template<typename T>
        std::shared_ptr<T> queryServerObject(
            const std::string & objectKey)
        {
            return mServerObjectServicePtr->queryServerObject<T>(objectKey);
        }

        template<typename T>
        std::shared_ptr<T> getServerObject(
            const std::string & objectKey,
            std::uint32_t timeoutMs)
        {
            return mServerObjectServicePtr->getServerObject<T>(objectKey, timeoutMs);
        }

        void deleteServerObject(const std::string & objectKey);


#if RCF_FEATURE_PUBSUB==1




        template<typename Interface>
        std::shared_ptr< Publisher<Interface> > createPublisher()
        {
            PublisherParms parms;
            return mPublishingServicePtr->createPublisher<Interface>(parms);
        }


        template<typename Interface>
        std::shared_ptr< Publisher<Interface> > createPublisher(
            const PublisherParms & parms)
        {
            return mPublishingServicePtr->createPublisher<Interface>(parms);
        }


        template<typename Interface, typename T>
        std::shared_ptr< Subscription > createSubscription(
            T &                             servantObj, 
            const RCF::Endpoint &           publisherEp)
        {
            RCF_ASSERT(mStarted);
            SubscriptionParms parms;
            parms.setPublisherEndpoint(publisherEp);
            return mSubscriptionServicePtr->createSubscription<Interface>(servantObj, publisherEp);
        }


        template<typename Interface, typename T>
        std::shared_ptr< Subscription > createSubscription(
            T &                             servantObj,
            const SubscriptionParms &       parms)
        {
            RCF_ASSERT(mStarted);
            return mSubscriptionServicePtr->createSubscription<Interface>(servantObj, parms);
        }


#endif

        void                setEnableProxyEndpoints(bool enable);

        bool                getEnableProxyEndpoints() const;

#if RCF_FEATURE_FILETRANSFER==1



        void                setUploadBandwidthLimit(std::uint32_t uploadQuotaBps);

        std::uint32_t       getUploadBandwidthLimit() const;

        void                setDownloadBandwidthLimit(std::uint32_t downloadQuotaBps);

        std::uint32_t       getDownloadBandwidthLimit() const;

        void                setUploadDirectory(const Path & uploadDir);

        Path                getUploadDirectory() const;

        void                setDownloadProgressCallback(DownloadProgressCallback downloadProgressCb);

        void                setUploadProgressCallback(UploadProgressCallback uploadProgressCb);

        void                setUploadBandwidthQuotaCallback(UploadBandwidthQuotaCallback uploadQuotaCb);

        void                setDownloadBandwidthQuotaCallback(DownloadBandwidthQuotaCallback downloadQuotaCb);


#endif


        
        // For internal use.
        std::uint32_t           getRuntimeVersion();
        void                    setRuntimeVersion(std::uint32_t version);

        std::uint32_t           getArchiveVersion();

        void                    setArchiveVersion(std::uint32_t version);

        void setOnCallbackConnectionCreated(OnCallbackConnectionCreated onCallbackConnectionCreated);
        OnCallbackConnectionCreated getOnCallbackConnectionCreated();


    private:

        void init();

    public:


        I_Service &             
                getServerTransportService();

        ServerTransportPtr      
                getServerTransportPtr();

    private:

        bool    addService(
                    ServicePtr servicePtr);

        bool    removeService(
                    ServicePtr servicePtr);

    public:

        PingBackServicePtr 
                getPingBackServicePtr();

        FileTransferServicePtr
                getFileTransferServicePtr();

        SessionTimeoutServicePtr 
                getSessionTimeoutServicePtr();

        PublishingServicePtr
                getPublishingServicePtr();

        SubscriptionServicePtr
                getSubscriptionServicePtr();

        FilterServicePtr getFilterServicePtr();

        bool    addServerTransport(
                    ServerTransportPtr serverTransportPtr);

        bool    removeServerTransport(
                    ServerTransportPtr serverTransportPtr);

        ServerTransport * 
                findTransportCompatibleWith(ClientTransport & clientTransport);

        ServerTransport * queryForTransport(RCF::TransportType transportType);
        
        void    setStartCallback(const StartCallback &startCallback);       
        
    private:
        void    invokeStartCallback();

    private:
        ServerBindingPtr bindImpl(
                    const std::string &name, 
                    RcfClientPtr rcfClientPtr);

        //*************************************
        // async io transport interface

    public:
        SessionPtr  createSession();
        void        onReadCompleted(SessionPtr sessionPtr);
        void        onWriteCompleted(SessionPtr sessionPtr);


        //*************************************
        // transports, queues and threads

    public:


        template<typename Iter>
        void enumerateSessions(const Iter & iter)
        {
            for (std::size_t i=0; i<mServerTransports.size(); ++i)
            {
                mServerTransports[i]->enumerateSessions(iter);
            }
        }

        //*************************************
        // stub management

    private:
        ReadWriteMutex                                  mStubMapMutex;
        typedef std::map<std::string, RcfClientPtr>     StubMap;
        StubMap                                         mStubMap;


        typedef std::function<void(const JsonRpcRequest &, JsonRpcResponse &)> JsonRpcMethod;
        typedef std::map<std::string, JsonRpcMethod>    JsonRpcMethods;
        JsonRpcMethods                                  mJsonRpcMethods;

        friend class RcfSession;



        //*************************************
        // service management

    private:
        std::vector<ServerTransportPtr>                 mServerTransports;
        std::vector<ServicePtr>                         mServices;
        FilterServicePtr                                mFilterServicePtr;
        PingBackServicePtr                              mPingBackServicePtr;
        FileTransferServicePtr                          mFileTransferServicePtr;
        SessionTimeoutServicePtr                        mSessionTimeoutServicePtr;
        PublishingServicePtr                            mPublishingServicePtr;
        SubscriptionServicePtr                          mSubscriptionServicePtr;
        CallbackConnectionServicePtr                    mCallbackConnectionServicePtr;
        ProxyEndpointServicePtr                         mProxyEndpointServicePtr;
        ServerObjectServicePtr                          mServerObjectServicePtr;

        void startService(ServicePtr servicePtr) const;
        void stopService(ServicePtr servicePtr) const;
        void resolveServiceThreadPools(ServicePtr servicePtr) const;

        friend class AsioNetworkSession;
        FilterPtr createFilter(int filterId);

        // start/stop functionality
        StartCallback                                   mStartCallback;
        Condition                                       mStartEvent;
        Condition                                       mStopEvent;

        Mutex                                           mStartStopMutex;
        bool                                            mStarted;      

    private:
        ThreadPoolPtr                                   mThreadPoolPtr;


        // TODO: get rid of this hack
    private:
        friend class MethodInvocationRequest;

    private:
        std::uint32_t                                 mRuntimeVersion;
        std::uint32_t                                 mArchiveVersion;


    public:

#if RCF_FEATURE_FILETRANSFER==1


        Path getUploadPath(const std::string & uploadId);

    private:

        DownloadProgressCallback            mOnFileDownloadProgress;
        UploadProgressCallback              mOnFileUploadProgress;

        Path                                mFileUploadDirectory;

        std::uint32_t                       mFileUploadQuota;
        UploadBandwidthQuotaCallback        mFileUploadQuotaCb;

        std::uint32_t                       mFileDownloadQuota;
        DownloadBandwidthQuotaCallback      mFileDownloadQuotaCb;

        friend class FileTransferService;

#endif

    private:

        mutable ReadWriteMutex          mPropertiesMutex;

        std::vector<TransportProtocol>  mSupportedProtocols;
        CertificatePtr                  mCertificatePtr;
        std::string                     mOpenSslCipherSuite;

        CertificatePtr                  mCaCertificatePtr;
        CertificateValidationCallback   mCertificateValidationCb;
        tstring                         mSchannelCertificateValidation;

        SslImplementation               mSslImplementation;

        std::uint32_t                   mSessionTimeoutMs;
        std::uint32_t                   mSessionHarvestingIntervalMs;

        std::uint32_t                   mHttpSessionTimeoutMs;

        std::string                     mHttpServerHeader;

        std::uint32_t                   mHttpHealthCheckStatus = 0;
        std::string                     mHttpHealthCheckStatusMessage;
        std::string                     mHttpHealthCheckContent;

        OnCallbackConnectionCreated     mOnCallbackConnectionCreated;

#if RCF_FEATURE_SSPI==1
        DWORD                           mSchannelEnabledProtocols = 0;
        ULONG                           mSchannelContextRequirements = 0;
#endif

    public:


    private:

        std::uint32_t                           mServerObjectHarvestingIntervalS;

        friend class HttpSessionFilter;

        HttpSessionPtr  attachHttpSession(const std::string & httpSessionId, bool allowCreate, ExceptionPtr & ePtr);
        void            detachHttpSession(HttpSessionPtr httpSessionPtr);
        
        friend class ServerObjectService;
        void            harvestHttpSessions();

#if RCF_FEATURE_HTTP==1
        Mutex                                   mHttpSessionMapMutex;
        std::map<std::string, HttpSessionPtr>   mHttpSessionMap;

        HttpMessageVerifierPtr  mHttpMessageVerifierPtr;

#endif

    public:


    private:
        friend class ProxyEndpoint;
        ClientTransportUniquePtr makeProxyEndpointConnection(const std::string& proxyEndpointName);

        bool                                    mEnableProxyEndpoints = false;

    };

} // namespace RCF

#endif // ! INCLUDE_RCF_RCFSERVER_HPP