gzDistSessionServer.h

Go to the documentation of this file.

//*****************************************************************************
// File         : gzDistSessionServer.h
// Module       : gzDistribution
// Description  : Internal session server definitions
// Author       : Christian Andersson, Anders Sandblad
// Product      : GizmoDistribution 2.1.1
//
// Copyright © 2004 - Saab Training Systems AB, Sweden
//          
// NOTE:    GizmoDistribution is a toolkit used for implementing distributed 
//          objects and events in C++
//
//
// Revision History...
//
// Who  Date    Description
//
// CAN  040217  Created file
//
//*****************************************************************************
#ifndef __GZ_DIST_SESSION_SERVER_H__
#define __GZ_DIST_SESSION_SERVER_H__

// Includes
#include "gzDistBase.h"
#include "gzDistServer.h"
#include "gzDistServerInternal.h"

// Forward declarations
class gzDistSessionMessage;
class gzDistSessionServerEngine;
class gzDistObjectAttribute;

// Session message types
enum gzDistSessionMessageType
{
    GZ_DIST_SESSION_MESSAGE_TYPE_EVENT,
    GZ_DIST_SESSION_MESSAGE_TYPE_ADD_OBJECT,
    GZ_DIST_SESSION_MESSAGE_TYPE_ADD_OBJECT_REQUEST,
    GZ_DIST_SESSION_MESSAGE_TYPE_REMOVE_OBJECT,
    GZ_DIST_SESSION_MESSAGE_TYPE_REMOVE_OBJECT_REQUEST,
    GZ_DIST_SESSION_MESSAGE_TYPE_UPDATE_OBJECT,
    GZ_DIST_SESSION_MESSAGE_TYPE_UPDATE_OBJECT_REQUEST,
    GZ_DIST_SESSION_MESSAGE_TYPE_REMOVE_ATTRIBUTES,
    GZ_DIST_SESSION_MESSAGE_TYPE_REMOVE_ATTRIBUTES_REQUEST,
    GZ_DIST_SESSION_MESSAGE_TYPE_SYNCHRONIZE_OBJECT,
    GZ_DIST_SESSION_MESSAGE_TYPE_REQUEST_OWNERSHIP,
    GZ_DIST_SESSION_MESSAGE_TYPE_SET_OWNERSHIP,
    GZ_DIST_SESSION_MESSAGE_TYPE_DROP_OWNERSHIP,
    GZ_DIST_SESSION_MESSAGE_TYPE_PULL_OWNERSHIP,
    GZ_DIST_SESSION_MESSAGE_TYPE_REMOVE_INSTANCE
};


//----------------------- gzDistSessionServerMessage --------------------------

GZ_DIST_DECLARE_MEMBASE(gzDistSessionMessage);

//*****************************************************************************
// Class    : gzDistSessionMessage
//                                  
// Purpose  : Session message class
//                                  
// Notes    : - 
//                                  
// Revision History...                          
//                                  
// Who  Date    Description                     
//                                  
// CAN  040217  Created 
//                                  
//*****************************************************************************
// Internal messages used by the session server
class gzDistSessionMessage GZ_DIST_MEMBASE_SINGLE(gzDistSessionMessage)
{
    public:

        GZ_DIST_MEMBASE_IMP(gzDistSessionMessage);

        GZ_DIST_MEMBASE_CALL(gzDistSessionMessage);
    
        // Constructor
        gzDistSessionMessage(gzDistSessionMessageType type);

        // Destructor
        virtual ~gzDistSessionMessage();

        // Set an object name in message;
        gzVoid setObjectName(const gzString& name);
        
        // Get the object name in message.
        const gzString& getObjectName();    

        // Get the attribute name in message;
        const gzString& getAttributeName();

        // Set an attribute name in message;
        gzVoid setAttributeName(const gzString& name);  

        // Set an event in message.
        gzVoid setEvent(gzDistEvent* event);

        // Get event from message.
        gzDistEvent* getEvent();

        // Set an object in message.
        gzVoid setObject(gzDistObject* object);

        // Get object from message.
        gzDistObject* getObject();

        // Set client ID in message.
        gzVoid setClientID(const gzDistClientID& id);

        // Get client ID from message.
        const gzDistClientID& getClientID();

        // Get transaction from message
        gzDistTransaction* getTransaction();

        // Set transaction to message
        gzVoid setTransaction(gzDistTransaction* transaction);

        // Set prio.
        gzVoid setPrio(gzBool prio);

        gzBool getPrio();

    // Members:

        // A reference to data that will be sent (object, event etc.)
        gzDistThreadSafeReferencePtr reference;

        // A reference to a transaction or attribute.
        gzDistThreadSafeReferencePtr additional_ref;

        // The name of an object.
        gzString* objectName;

        // The name of an attribute.
        gzString* attributeName;

        // An id to a client.
        gzDistClientID clientID;

        // The type of message.
        gzDistSessionMessageType type;

        // Tells if the message has gone through its own session.
        gzBool m_throughSession;

        // Priority
        gzBool m_highPrio;
};


//------------------------- gzDistInstanceUpdate ------------------------

// *****************************************************************************
// Class    : gzDistInstanceUpdate
//                                  
// Purpose  : Session server class
//                                  
// Notes    : - 
//                                  
// Revision History...                          
//                                  
// Who  Date    Description                     
//                                  
// CAN  040406  Created 
//                                  
// *****************************************************************************
// Internal instance update
class gzDistInstanceUpdate
{
    public:
        gzDistInstanceUpdate();
        gzDistInstanceUpdate(const gzDistInstanceID& id, gzDistServerMessageType type);
        ~gzDistInstanceUpdate();

        gzDistInstanceID m_instanceID;
        gzDistServerMessageType m_type;
};


//---------------------------- gzDistSessionServer ---------------------------

//*****************************************************************************
// Class    : gzDistSessionServer
//                                  
// Purpose  : Session server class
//                                  
// Notes    : - 
//                                  
// Revision History...                          
//                                  
// Who  Date    Description                     
//                                  
// CAN  040217  Created 
//                                  
//*****************************************************************************
// Internal session server for global sessions
class gzDistSessionServer
{
    public:
        
        // Constructor
        gzDistSessionServer(gzDistSession* session, gzDistServerPriority priority);
    
        // Destructor
        ~gzDistSessionServer();

        // Get the name of the session
        gzString getSessionName() const;

        // Returns TRUE if current instance is the activeserver.
        gzBool isActive() const;
        
        // Is the server installed ?
        gzBool isInstalled() const;

        // Send the event on network.
        /* \param event     The event to send.
           \param clientId  The identification of the sending client.*/
        gzVoid sendEvent(gzDistEvent* event, const gzDistClientID& clientId);

        // Distribute the object globaly if server.
        /* If not server, ask current server to add object.
            \param object   The object to add.
            \param clientId The identification of the sending client.*/
        gzVoid addObject(gzDistObject* object, const gzDistClientID& clientId);

        // Distribute the transaction globaly if server.
        // If not server, ask current server to do the transaction.
        gzVoid updateObject(gzDistTransaction* transaction, gzDistObject* object, const gzDistClientID& clientId);

        // Remove object globaly if server.
        // If not server, ask current server to remove the object.
        gzVoid removeObject(gzDistObject* object, const gzDistClientID& clientId);

        // Remove attributes from object globaly if server.
        // If not server, ask current server to remove the attributes.
        gzVoid removeAttributes(gzDistTransaction* transaction, gzDistObject* object, const gzDistClientID& clientId);

        // If server, distribute the drop globaly to nextOwner.
        // If not server, ask current server to drop it.
        gzVoid dropOwnership(gzDistObjectAttribute* attribute, gzDistObject* object, const gzDistClientID& clientId);

        // If server, distribute the request globaly.
        // Note: This message must always be received and processed by itself.
        // If not server, ask current server to do the request globaly.
        gzVoid requestOwnership(gzDistObjectAttribute* attribute, gzDistObject* object, const gzDistClientID& clientId);

        // If server, distribute the request globaly.
        // Note: This message must always be received and processed by itself.
        // If not server, ask current server to do the pull globaly.
        gzVoid pullOwnership(gzDistObjectAttribute* attribute, gzDistObject* object, const gzDistClientID& clientId);
        
        // Delete all messages in list;
        void clearMessages(gzList<gzDistSessionMessage>* list);

        // Gives m_sessionSendList to caller and gets an empty list.
        void getReceivedData(gzList<gzDistSessionMessage>** list);

        gzDistSessionMessage* getPriorityMessage();

        // Puts a message in m_sessionReceiveList that will be processed by the gzDistSessionServer.
        gzVoid sendServerMessage(gzDistSessionMessage* message);

        // Tell the server to shut down.
        gzVoid shutDown();

        // Check if there are any messages to or from the sessionserver.
        gzBool hasPendingData();

        // Check if the session is synchronized.
//      gzBool isSynchronized();

        //------ engine callbacks ------

        // Server engine install callback
        gzVoid onInstall();

        // Tick engine callback
        // Return TRUE if it has more data to process.
        gzBool onTick();

        // Server engine uninstall callback
        gzVoid onUninstall();

        // Remote message receive callback
        gzVoid onReceiveMessage(gzDistRemoteMessageSession* message);

    private:

        // Process a message from its session.
        // Returns TRUE if the message should be deleted.
        gzBool processSessionMessage(gzDistSessionMessage* message);

        gzVoid processServerMessage(gzDistServerMessage* serverMessage);

        gzVoid sendSessionMessage(gzDistSessionMessage* message);

        gzVoid sendObject(gzDistRemoteMessageSession* remoteMessage, gzDistSessionMessage* sessionMessage);

        gzVoid sendTransaction(gzDistRemoteMessageSession* remoteMessage, gzDistSessionMessage* sessionMessage);

        gzVoid storeSessionBodyHeader(const gzString& sessionName, const char* typeName, const gzDistClientID& id);

        gzVoid requestUpdate(const gzDistInstanceID& id, gzDistServerMessageType type);

        // Return TRUE if it has more data to process.
        gzBool processInstanceUpdates();

        gzVoid sendObject(gzDistObject* object);

        gzVoid sendEndDispatch();

        gzVoid onTransaction(gzDistSessionMessageType messageType, gzDistRemoteMessageSession* message);

        gzBool processReceivedMessages();

        gzBool processReceivedMessage(gzDistRemoteMessageSession* message);

        // Messages from session.
        gzList<gzDistSessionMessage>* m_sessionReceiveList;

        // List used when processing received data.
        gzList<gzDistSessionMessage>* m_processList;

        // Locker for m_sessionReceiveList
        gzMutex m_sessionReceiveListLocker;

        // Received remote messages
        gzRefList<gzDistRemoteMessageSession> m_receivedRemoteMessages;

        // Messages to session.
        gzList<gzDistSessionMessage>* m_sessionSendList;

        // Locker for m_sessionSendList
        gzMutex m_sessionSendListLocker;

        // High priority messages from session.
        gzList<gzDistSessionMessage> m_sessionHighPrioMessages;

        gzList<gzDistSessionMessage> m_receivedHighPrioMessages;
    
        // A adapter used for serializing data.
        gzDistSerializeAdapterMemory m_memoryAdapter;

        // The engine
        gzDistSessionServerEngine* m_serverEngine;

        // The name of the session
        gzString m_sessionName;

        // My session.
        gzDistSession* m_session;
        
        // The server part
        gzDistServerImpl* m_server;

        // Reference to current gzDistManager
        gzDistManagerPtr m_manager;

        gzList<gzDistServerMessage>* m_serverMessageList;

        // The id of current active server.
        gzDistInstanceID m_activeServerID;

        // Contains all instances that has requested an update or synchronization.
        gzList<gzDistInstanceUpdate> m_instancesToUpdate;

        // The instance that is updating from this process at the moment.
        gzDistInstanceUpdate m_updatingInstance;

        // This list contains object that are requested by other processes.
        // The list will normaly be empty i.e. when no synch or update is going on.
        gzRefList<gzDistObject> m_sessionObjectsToDispatch;

        // Is the server installed?
        gzBool m_installed;

        // Is this instance the active session server?
        gzBool m_active;

        // In the startup phase we need to wait until the server is installed.
        // No work will be done until this flag is set to TRUE.
        gzBool m_initialized;
};


//------------------------- gzDistSessionServerEngine ------------------------

//*****************************************************************************
// Class    : gzDistSessionServerEngine
//                                  
// Purpose  : Session server engine class
//                                  
// Notes    : - 
//                                  
// Revision History...                          
//                                  
// Who  Date    Description                     
//                                  
// XAA  040227  Created 
//                                  
//*****************************************************************************
// Internal thread engine for the session server
class gzDistSessionServerEngine : protected gzThread
{
    public:
    
        // Create and start the singleton engine instance
        static gzDistSessionServerEngine* startEngine(gzDistRemoteChannelInterface* sessionChannel);

        // Get the singleton engine instance
        static gzDistSessionServerEngine* getEngine();

        // Trigger the engine thread.
        static gzVoid trigger();

        // Shutdown the engine
        gzVoid shutDown();

        // Install server
        gzBool install(gzDistSessionServer* server);

        // Uninstall server
        gzBool uninstall(gzDistSessionServer* server);

        // Send remote message
        gzBool send(gzDistRemoteMessageSession* message);

        // Get the size of current protocol header.
        gzUInt getProtocolHeaderSize();

        gzBool hasPendingData();

    public:

        gzDistSessionServerEngine(gzDistRemoteChannelInterface* sessionChannel);

        virtual ~gzDistSessionServerEngine();
    
    private:
    
        // Engine thread
        gzVoid process();
        gzVoid processServers();
        gzULong receiveMessages();
        gzVoid checkNewRemovedServers();
        
        // Remote distribution server channel
        gzDistRemoteChannelInterface* m_sessionChannel;

        // Servers to be installed
        gzList<gzDistSessionServer> m_installList;
        gzMutex m_installLocker;
        
        // Servers to be uninstalled
        gzList<gzDistSessionServer> m_uninstallList;
        gzMutex m_uninstallLocker;
        
        // Installed servers (to be ticked)
        gzDict<gzString, gzDistSessionServer> m_serverDict;

        // Singleton instance
        static gzDistSessionServerEngine* m_instance;
        static gzMutex m_instanceLocker;

        // Disable copy and assignment
        gzDistSessionServerEngine(const gzDistSessionServerEngine&);
        gzDistSessionServerEngine operator=(const gzDistSessionServerEngine&);

        // A trigger used to trigger the engine thread.
        gzDistTrigger m_trigger;

        gzBool m_hasPendingServer;
};

#endif

---