vclientsession.h

Go to the documentation of this file.

/*
Copyright c1997-2014 Trygve Isaacson. All rights reserved.
This file is part of the Code Vault version 4.1
http://www.bombaydigital.com/
License: MIT. See LICENSE.md in the Vault top level directory.
*/

#ifndef vclientsession_h
#define vclientsession_h

#include "vstring.h"
#include "vmutex.h"
#include "vmutexlocker.h"
#include "vmessagequeue.h"
#include "vsocketstream.h"
#include "vbinaryiostream.h"

class VMessageInputThread;
class VMessageOutputThread;
class VManagementInterface;
class VSocket;
class VSocketThread;
class VListenerThread;
class VMessage;
class VMessageHandlerTask;
class VServer;
class VBentoNode;

typedef std::vector<const VMessageHandlerTask*> SessionTaskList;

class VClientSession : public VEnableSharedFromThis<VClientSession> {
    public:

        VClientSession(const VString& sessionBaseName, VServer* server, const VString& clientType, VSocket* socket, VMessageInputThread* inputThread, VMessageOutputThread* outputThread, const VDuration& standbyTimeLimit, Vs64 maxQueueDataSize);

        virtual void initIOThreads();

        const VString& getName() const { return mName; }

        const VString& getClientType() const { return mClientType; }
        VMessageInputThread* getInputThread() const { return mInputThread; }
        VMessageOutputThread* getOutputThread() const { return mOutputThread; }

        virtual bool isClientOnline() const = 0;
        virtual bool isClientGoingOffline() const = 0;
        virtual void shutdown(VThread* callingThread);
        void postOutputMessage(VMessagePtr message, bool isForBroadcast = false);
        void postBroadcastOutputMessage(VMessagePtr message) { this->postOutputMessage(message, true); }
        void sendMessageToClient(VMessagePtr message, const VString& sessionLabel, VBinaryIOStream& out);
        virtual const VString& getClientAddress() const { return mClientAddress; }

        virtual VBentoNode* getSessionInfo() const;

    protected:

        virtual ~VClientSession(); // protected because only friend class VServer may delete us (when garbage collecting)

        void _moveStandbyMessagesToAsyncOutputQueue();  
        int _getOutputQueueSize() const; 

        virtual void _postStandbyMessageToAsyncOutputQueue(VMessagePtr message);

        VString                 mName;          
        VString                 mLoggerName;    
        VMutex                  mMutex;         
        VServer*                mServer;        
        VString                 mClientType;    
        VString                 mClientIP;      
        int                     mClientPort;    
        VString                 mClientAddress; 
        VMessageInputThread*    mInputThread;   
        VMessageOutputThread*   mOutputThread;  
        bool                    mIsShuttingDown;

    private:

        VClientSession(const VClientSession&); // not copyable
        VClientSession& operator=(const VClientSession&); // not assignable

        void _releaseQueuedClientMessages();   

        VMessageQueue   mStartupStandbyQueue;   
        VInstant        mStandbyStartTime;      
        VDuration       mStandbyTimeLimit;      
        Vs64            mMaxClientQueueDataSize;

        // We only access the socket i/o stream if postOutputMessage() is called
        // and we are not set up to use a separate output message thread. However, we are responsible
        // for deleting the socket object.
        VSocket*        mSocket;        
        VSocketStream   mSocketStream;  
        VBinaryIOStream mIOStream;      
};

typedef VSharedPtr<VClientSession> VClientSessionPtr;
typedef VSharedPtr<const VClientSession> VClientSessionConstPtr;
typedef std::vector<VClientSessionPtr> VClientSessionList;

class VClientSessionFactory {
    public:

        VClientSessionFactory(VManagementInterface* manager, VServer* server) : mManager(manager), mServer(server) {}
        virtual ~VClientSessionFactory() {}

        virtual VClientSessionPtr createSession(VSocket* socket, VListenerThread* ownerThread) = 0;

        void addSessionToServer(VClientSessionPtr session);

        void setManager(VManagementInterface* manager) { mManager = manager; }

    protected:

        VClientSessionFactory(const VClientSessionFactory&); // not copyable
        VClientSessionFactory& operator=(const VClientSessionFactory&); // not assignable

        VManagementInterface*   mManager;   
        VServer*                mServer;    
};

#endif /* vclientsession_h */