gzDistServerInternal.h

Go to the documentation of this file.

//*****************************************************************************
// File         : gzDistServerInternal.h
// Module       : gzDistribution
// Description  : Definition of internal server classes
// Author       : 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                     
//                                  
// XAA  040226  Created file    
//
//******************************************************************************
#ifndef __GZ_DIST_SERVER_INTERNAL_H__
#define __GZ_DIST_SERVER_INTERNAL_H__

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


// Forward declarations
class gzDistServerEngine;


//----------------------------- gzDistServerData ------------------------------

//*****************************************************************************
// Class    : gzDistServerData
//                                  
// Purpose  : Server instance data
//                                  
// Notes    : - 
//                                  
// Revision History...                          
//                                  
// Who  Date    Description                     
//                                  
// XAA  031030  Created 
//                                  
//*****************************************************************************
// Internal server instance data
class gzDistServerData : public gzDistThreadSafeReference
{
    public:

        gzDistServerData();

        explicit gzDistServerData(const gzDistInstanceID& id,
                                    gzDistServerPriority prio = GZ_DIST_SERVER_PRIO_NORMAL,
                                    gzDistServerStatus stat = GZ_DIST_SERVER_STATUS_IDLE);

        explicit gzDistServerData(const gzDistRemoteMessageServer* message);

        virtual ~gzDistServerData() {};

        gzReference* clone() const;

        gzBool useDeepCopy() { return FALSE; };


        gzDistInstanceID instanceID;

        gzDistServerStatus status : 8;

        gzDistServerPriority priority : 8;

        gzDouble lastPingTime;

};


// Reference pointer type declaration
GZ_DIST_PTR(gzDistServerData);

// Pointer list type declaration
GZ_DIST_LIST(gzDistServerData);


//--------------------------- gzDistServerMessage -----------------------------

// Server message type
enum gzDistServerMessageType
{
    GZ_DIST_SERVER_MESSAGE_UNKNOWN = 0,

    // from server
    GZ_DIST_SERVER_MESSAGE_NEW_INSTANCE,        // When a new remote instance has been discovered
    GZ_DIST_SERVER_MESSAGE_INSTANCE_SHUTDOWN,   // When a remote instance has been removed after shutdown
    GZ_DIST_SERVER_MESSAGE_INSTANCE_TIMEOUT,    // When a remote instance has been removed after timeout
    GZ_DIST_SERVER_MESSAGE_INSTANCE_ACTIVE,     // When a remote instance has entered active state
    GZ_DIST_SERVER_MESSAGE_UPDATE_STATUS,       // When the status of the local instance has changed 

    // to server
    GZ_DIST_SERVER_MESSAGE_SHUTDOWN,            // Enter passive state before uninstall (optionally)
    GZ_DIST_SERVER_MESSAGE_BEGIN_SYNCHRONIZE,   // When a passive instance need to be synchronized
    GZ_DIST_SERVER_MESSAGE_BEGIN_UPDATE,        // When two active instances need to be synchronized

    // from server
    GZ_DIST_SERVER_MESSAGE_END_SYNCHRONIZE,     // When the passive instance has been syncronized
    GZ_DIST_SERVER_MESSAGE_END_UPDATE           // When the active instances has been syncronized
};


//*****************************************************************************
// Class    : gzDistServerMessage
//                                  
// Purpose  : Priority based distributed server support
//                                  
// Notes    : - 
//                                  
// Revision History...                          
//                                  
// Who  Date    Description                     
//                                  
// XAA  040226  Created 
//                                  
//*****************************************************************************
// Internal server message
class gzDistServerMessage
{
    public:
        
        gzDistServerMessage();
        
        gzDistServerMessage(gzDistServerMessageType t, const gzDistInstanceID& id, gzDistServerStatus s = GZ_DIST_SERVER_STATUS_UNKNOWN);

        gzDistServerMessage(gzDistServerMessageType t, gzDistServerData* d);

        virtual ~gzDistServerMessage();
        
        
        gzDistServerMessageType type;
                        
        gzDistInstanceID instanceID;

        gzDistServerStatus status : 8;


};


//--------------------------- gzDistServerImpl --------------------------------

//*****************************************************************************
// Class    : gzDistServerImpl
//                                  
// Purpose  : Priority based distributed server support internal implementation
//                                  
// Notes    : - 
//                                  
// Revision History...                          
//                                  
// Who  Date    Description                     
//                                  
// XAA  031030  Created 
//                                  
//*****************************************************************************
// Internal server implementation
class gzDistServerImpl
{
    public:

        // Constructor
        gzDistServerImpl(const gzString& functionID, gzDistServerPriority prio);

        // Destructor
        virtual ~gzDistServerImpl();

        
        // Install server
        gzBool install();

        // Uninstall server
        gzBool uninstall();


        // Is the server installed ?
        gzBool isInstalled() const { return m_installed; };

        // Has the server got an error ?
        gzBool hasError() const { return (m_instance->status == GZ_DIST_SERVER_STATUS_ERROR); };

        // Get function ID
        const gzString& getFunctionID() const { return m_functionID; };

        // Get priority
        gzDistServerPriority getPriority() const { return m_instance->priority; };

        // Get current status
        gzDistServerStatus getStatus() const { return m_instance->status; };

        // Set current status
        gzVoid setStatus(gzDistServerStatus status) { m_instance->status = status; };

        // Get the id of current active server
        gzVoid getCurrentActiveID(gzDistInstanceID& id);

        // Call this when requested synchronize is finished
        gzVoid endSynchronize(const gzDistInstanceID& id);

        // Call this when requested update is finished
        gzVoid endUpdate(const gzDistInstanceID& id);

        // Call this to (optionally) enter the shutdown state before uninstallation
        gzVoid shutDown();

        // Swap outgoing message buffer
        gzVoid swapMessages(gzList<gzDistServerMessage>** list);


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

        // Server engine install callback
        gzVoid onInstall();

        // Tick engine callback
        gzVoid onTick();

        // Server engine uninstall callback
        gzVoid onUninstall();

        // Remote message receive callback
        gzVoid onRemoteMessage(gzDistRemoteMessageServer* message);


    private:

        // Process server
        gzVoid processServer();

        // Process messages
        gzVoid processMessages();

        // Handle received ping message
        gzVoid receivePing(const gzDistRemoteMessageServer* message);

        // Handle received synchronize request
        gzVoid receiveRequestSynchronize(const gzDistRemoteMessageServer* message);

        // Handle received synchronize end
        gzVoid receiveEndSynchronize(const gzDistRemoteMessageServer* message);

        // Handle received update request
        gzVoid receiveRequestUpdate(const gzDistRemoteMessageServer* message);

        // Handle received update end
        gzVoid receiveEndUpdate(const gzDistRemoteMessageServer* message);


        // Send ping
        gzVoid sendPing();

        // Send synchronize request
        gzVoid sendRequestSynchronize(const gzDistInstanceID& destination);

        // Send synchronize end
        gzVoid sendEndSynchronize(const gzDistInstanceID& destination);

        // Send update request
        gzVoid sendRequestUpdate(const gzDistInstanceID& destination);

        // Send update end
        gzVoid sendEndUpdate(const gzDistInstanceID& destination);


        // Create remote message
        gzDistRemoteMessageServerPtr createMessage(gzDistRemoteMessageType type, const gzDistInstanceID& destination = GZ_DIST_NULL_INSTANCE);


        // Update current status
        gzVoid updateStatus(gzDistServerStatus status, gzBool send = TRUE);

        // Set the current active server instance, and notify to client
        gzVoid setCurrentActiveInstance(gzDistServerData* instance);

        // Find instance data
        gzDistServerDataPtr findInstance(const gzDistInstanceID& id);

        // Add instance data
        gzVoid addInstance(gzDistServerData* newInstance);

        // Remove instance data
        gzVoid removeInstance(gzDistServerData* newInstance);

        // Check status of instances
        gzVoid checkInstances();
    
        // Add message to out queue (notify client)
        gzVoid notify(gzDistServerMessageType type, gzDistServerData* data);

        // Check if the local instance is in a running state (passive or active)
        gzBool isRunningState() const;


        // Debugging
        gzVoid traceStatus(const gzDistServerData* instance);
        gzVoid traceInstances();


    private:

        // The engine
        gzDistServerEngine* m_engine;

        // Incoming messages
        gzMutex m_inMessageLocker;
        gzList<gzDistServerMessage>* m_inMessageList;
        gzList<gzDistServerMessage>* m_inMessageListLocal;
        
        // Outgoing messages
        gzMutex m_outMessageLocker;
        gzList<gzDistServerMessage>* m_outMessageList;

        // Local server data
        const gzString m_functionID;
        gzDouble m_startTime;
        gzDouble m_lastCheckTime;
        gzDouble m_lastActiveTime;
        gzUShort m_synchronizing;
        gzUShort m_updating;
        gzBool m_shutdownPending;
        gzBool m_activeWarning;
        gzBool m_installed;


        // Instance data
        gzDistServerDataPtr m_instance;         // me
        gzDistServerDataList m_instanceList;    // others
        gzULong m_potentialActiveInstances;
        gzDistServerDataPtr m_activeInstance;   // current active
        gzMutex m_activeInstanceLocker;


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


//--------------------------- gzDistServerEngine ------------------------------

//*****************************************************************************
// Class    : gzDistServerEngine
//                                  
// Purpose  : The internal manager/engine for distributed servers
//                                  
// Notes    : - 
//                                  
// Revision History...                          
//                                  
// Who  Date    Description                     
//                                  
// XAA  031030  Created 
//                                  
//*****************************************************************************
// The internal thread engine for servers
class gzDistServerEngine : protected gzThread
{
    public:

        // Create and start the singleton engine instance
        static gzDistServerEngine* startEngine(gzDistRemoteChannelInterface* serverChannel);

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

        // Shutdown the engine
        gzVoid shutDown();

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

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


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


    protected:

        // Constructor
        gzDistServerEngine(gzDistRemoteChannelInterface* serverChannel);

        // Destructor
        virtual ~gzDistServerEngine();


    private:

        // Engine thread
        gzVoid process();
        gzVoid processServers();
        gzULong receiveMessages();
        
        // Instance ID for this process
        gzDistInstanceID m_instanceID;
        
        // Remote distribution server channel
        gzDistRemoteChannelInterface* m_serverChannel;

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

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

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

};


#endif // __GZ_DIST_SERVER_INTERNAL_H__

---