gzDistManager.h

Go to the documentation of this file.

//*****************************************************************************
// File         : gzDistributionManager.h
// Module       : gzDistribution
// Description  : Distribution manager
// Author       : Christian Andersson
// 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  040108  Created file
//
//*****************************************************************************
#ifndef __GZ_DIST_MANAGER_H__
#define __GZ_DIST_MANAGER_H__

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

// Forward declarations
class gzDistManagerMessage;
class gzDistRemoteChannelInterface;
class gzDistDebugClient;



//----------------------------- gzDistManager ---------------------------------


class gzDistManager : public gzDistThreadSafeReference, protected gzThread
{
    friend class gzDistSession;
    friend class gzDistSessionIterator;
    friend class gzDistClientInterface;

    public:


        GZ_DIST_EXPORT gzBool start(gzDistRemoteChannelInterface* sessionChannel = NULL,
                                    gzDistRemoteChannelInterface* serverChannel = NULL);


        GZ_DIST_EXPORT gzVoid shutDown(gzBool wait = FALSE);


        GZ_DIST_EXPORT gzBool isRunning();


        GZ_DIST_EXPORT gzDistSessionPtr getSession(const gzString& sessionName, const gzBool create = FALSE, gzBool global = FALSE, gzDistServerPriority prio = GZ_DIST_SERVER_PRIO_NORMAL);



        GZ_DIST_EXPORT gzVoid registerFactory(const gzDistEventPtr& event); 


        GZ_DIST_EXPORT gzVoid registerFactory(const gzDistObjectPtr& object);


        GZ_DIST_EXPORT gzVoid unregisterFactory(gzType* classType);


        GZ_DIST_EXPORT gzVoid clearEventFactories();


        GZ_DIST_EXPORT gzVoid clearObjectFactories();
        

        GZ_DIST_EXPORT gzDistObject* getObject(const gzString& className, const gzString& objectName = GZ_DIST_NO_NAME);


        GZ_DIST_EXPORT gzDistEvent* getEvent(const gzString& className);


        GZ_DIST_EXPORT gzType* getObjectType(const gzString& className);


        GZ_DIST_EXPORT gzType* getEventType(const gzString& className);


        GZ_DIST_EXPORT gzBool processCustomThreadClients(gzBool waitForTrigger = FALSE);


        GZ_DIST_EXPORT gzBool enableDebug(gzBool enable);


        GZ_DIST_EXPORT gzBool hasPendingData();


//      GZ_DIST_EXPORT gzBool isSessionServer(const gzString& sessionName);

    // Statics:


        GZ_DIST_EXPORT static gzDistManagerPtr getManager(gzBool create = FALSE);
    

        GZ_DIST_EXPORT static gzBool enableFastMemory(gzUInt size = 10);


        GZ_DIST_EXPORT static gzVoid trigger();
    
    protected:


        gzDistManager();

        virtual ~gzDistManager();
    
    private:

    // --- Interface calls ---

        // Sign up to the manager and a thread pool.
        gzBool registerClient(gzDistClientInterface* client, gzULong poolId, gzDistThreadInterface*& thread);

        // Resign the manager and thread pool.
        gzBool unregisterClient(gzDistClientInterface* client, gzULong poolId);

        // Subscribe on new/removed sessions.
        gzBool subscribeSessions(gzDistClientInterface* client, gzBool notifyExisting = FALSE, gzInt timeOut = GZ_DIST_ASYNCHRONOUS);

        // Unsubscribe on new/removed sessions.
        gzBool unsubscribeSessions(gzDistClientInterface* client, gzInt timeOut = GZ_DIST_SYNCHRONOUS);

    // ------

        // The kernel thread implementation
        gzVoid process();

        // Process all sessions.
        gzBool processSessions();

        // Process messages that are posted to manager.
        // Returns TRUE if messages are processed, otherwise FALSE.
        gzBool processManagerMessages();

        // Process a single manager message.
        gzVoid processManagerMessage(gzDistManagerMessage* message);

        // Process all messages from all clients.
        gzBool processClients();

        // Process a single client message.
        gzBool processClientMessage(gzDistClientInterface* client, gzDistClientMessage* message);

        // Create a session. The created session is placed in "session" (parameter one).
        gzVoid createSession(gzDistSessionPtr& session, const gzString& sessionName, gzBool global, gzDistServerPriority prio);

        // Add a message to m_managerMessages
        gzVoid addManagerMessage(gzDistManagerMessage* message);

        // Notify all subscribers of new/removed sessions of the session.
        // If newSession is TRUE, the session is new otherwise it is removed.
        gzVoid notifySessionSubscribers(gzDistSession* session, gzBool newSession);

        // Add a message to the manager queue.
        gzVoid addManagerMessager(gzDistManagerMessage* message);

        // Wait until operation is complete or timeout has elapsed,
        // if the message was an acknowledge message.
        gzBool waitAck(gzDistManagerMessage* message, const gzInt timeOut);

        // Removes the session if session has no clients.
        // Returns TRUE if session is removed.
        gzBool checkRemoveSession(gzDistSession* session);

        // Send a shutdown message to all initialized clients.
        gzVoid shutDownClients();

        // See hasPendingData().
        gzBool checkPendingData();

        // Unsubscribe an attribute value an debug in if debugger is enabled.
        gzBool unsubscribeAttributeValue(const gzString& attrName, gzDistObject* object, gzDistSession* session, gzDistClientInterface* client);

    // Debug methods:

        // Send session subscribers to debugger.
        gzVoid debugSessionSubscribers(gzDistClientInterface* subscriber, gzBool newClient);

        // Send initialized clients to debugger.
        gzVoid debugManagerClients(gzDistClientInterface* subscriber, gzBool newClient);

        // Send joined/resigned clients to debugger.
        gzVoid debugJoinedClients(gzDistClientInterface* subscriber, gzDistSession* session, gzBool newClient);

        // Send object type subscribers to debugger.
        gzVoid debugObjectSubscribers(gzType* objectType, gzDistSession* session, gzDistClientInterface* subscriber, gzBool newClient);

        // Send event type subscribers to debugger.
        gzVoid debugEventSubscribers(gzType* eventType, gzDistSession* session, gzDistClientInterface* subscriber, gzBool newClient);

    // Members:

        // This dictionary contains all sessions.
        gzRefDict<gzString, gzDistSession> m_sessions;

        // The thread lock for m_sessions.
        gzMutex m_sessionsLocker;

        // Containing clients which are interested in new and removed sessions.
        gzList<gzDistClientInterface> m_sessionSubscribers;

        // Messages to the manager will be placed here.
        gzRefList<gzDistManagerMessage> m_managerMessages;

        // This list contain all initialized clients.
        gzList<gzDistClientInterface> m_clients;

        // Thread locker for m_managerMessages.
        gzMutex m_managerMessagesLocker;

        // The client thread pool
        gzDistClientThreadPool m_clientThreadPool;

        // The dictionary all registered event classes are stored.
        gzRefDict<gzString, gzDistEvent> m_eventFactory;

        // Mutex for m_eventFactory
        gzMutex m_eventFactoryLocker;

        // The dictionary all registered object classes are stored.
        gzRefDict<gzString, gzDistObject> m_objectFactory;

        // Mutex for m_objectFactory
        gzMutex m_objectFactoryLocker;

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

        // Debug client
        gzDistDebugClient* m_debugClient;

        // Will be set to TRUE when the manager is shutting down.
        gzBool m_closing;

        // Is TRUE when the worker thread is active
        gzBool m_workerThreadActive;

        // Tells if the manager has an error. Check last error to get the error.
        gzBool m_error;

        // Tells if remote channels were provided.
        gzBool m_hasRemoteChannels;
        gzBool m_remoteChannelWarning;

        gzRefList<gzDistManagerMessage> m_pendingManagerMessages;

        gzDict<gzString, gzVoid> m_missedObjectFactories;

        gzDict<gzString, gzVoid> m_missedEventFactories;

    // Static members:

        // Reference to current distribution manager
        static gzDistManagerPtr m_instance;

        // Mutex for m_instance
        static gzMutex m_instanceLocker;
};


//-------------------------- gzDistManagerMessage -----------------------------

// Manager message types
enum gzDistManagerMessageType
{
    GZ_DIST_MANAGER_MESSAGE_TYPE_CREATE_SESSION = 1,
    GZ_DIST_MANAGER_MESSAGE_TYPE_REMOVE_SESSION,
    GZ_DIST_MANAGER_MESSAGE_TYPE_SUBSCRIBE_SESSIONS,
    GZ_DIST_MANAGER_MESSAGE_TYPE_UNSUBSCRIBE_SESSIONS,
    GZ_DIST_MANAGER_MESSAGE_TYPE_REGISTER_CLIENT,
    GZ_DIST_MANAGER_MESSAGE_TYPE_UNREGISTER_CLIENT,
    GZ_DIST_MANAGER_MESSAGE_TYPE_ENABLE_DEBUG,
    GZ_DIST_MANAGER_MESSAGE_TYPE_CHECK_PENDING_DATA
//  GZ_DIST_MANAGER_MESSAGE_TYPE_IS_SESSION_SERVER
//  GZ_DIST_MANAGER_MESSAGE_TYPE_CLEAR_SESSION
};


// Message to/from the manager thread. For internal use.
class gzDistManagerMessage : public gzDistThreadSafeReference
{
    public:

        // Constructor
        gzDistManagerMessage(const gzDistManagerMessageType type);

        // Constructor
        gzDistManagerMessage(const gzDistManagerMessageType type, const gzString& sessionName);
        
        // Constructor
        gzDistManagerMessage(const gzDistManagerMessageType type, const gzString& sessionName, gzBool global, gzDistServerPriority prio);

        // Constructor
        gzDistManagerMessage(const gzDistManagerMessageType type, gzDistClientInterface* client, gzULong poolId);

        // Constructor
        gzDistManagerMessage(const gzDistManagerMessageType type, gzDistClientInterface* client, gzBool notifyExisting);

        // Destructor
        virtual ~gzDistManagerMessage();

        // --- Set/Get methods ---
        gzDistThreadInterface* getThread();

        gzVoid setThread(gzDistThreadInterface* thread);

        gzVoid setDebugInterface(gzDistDebugClient* client);

        gzDistDebugClient* getDebugInterface();
        // ---

        // The name of the session that shall be created.
        gzString m_sessionName;
        
        // This member will have a reference to the created session.
        gzDistSessionPtr m_reference;

        // The client who created the message.
        gzDistClientInterface* m_client;

        // Used to return a thread pointer to client or a debug client.
        gzVoid* m_void;

        // Type of message.
        gzDistManagerMessageType m_messageType;

        // Used to store thread pool id, session size etc.
        gzULong m_intData;

        // The id of the calling thread. This must be known to avoid a deadlock if uninitialize is called from a client thread.
        gzULong m_threadId;

        // The priority a sessionserver shall have in a global session.
        gzDistServerPriority m_priority;

        // Tells if a subscription shall generate notification on existing data.
        gzBool m_notifyExisting;

        // This member is set to TRUE if a synchronous message is desired. The manager will zero this flag when operation is complete.
        gzBool m_acknowledge;

        // Tells if a session should be created as a glohbal session.
        gzBool m_global;

        // The manager puts the result here.
        gzBool m_result;
};


#endif // __GZ_DIST_MANAGER_H__

---