mtsManagerGlobal.h

Go to the documentation of this file.

/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*-    */
/* ex: set filetype=cpp softtabstop=4 shiftwidth=4 tabstop=4 cindent expandtab: */

/*

  Author(s):  Min Yang Jung
  Created on: 2009-11-12

  (C) Copyright 2009-2011 Johns Hopkins University (JHU), All Rights
  Reserved.

--- begin cisst license - do not edit ---

This software is provided "as is" under an open source license, with
no warranty.  The complete license can be found in license.txt and
http://www.cisst.org/cisst/license.txt.

--- end cisst license ---
*/

#ifndef _mtsManagerGlobal_h
#define _mtsManagerGlobal_h

#include <cisstCommon/cmnClassRegister.h>
#include <cisstCommon/cmnNamedMap.h>

#include <cisstOSAbstraction/osaMutex.h>
#include <cisstOSAbstraction/osaGetTime.h>
#include <cisstOSAbstraction/osaThread.h>

#include <cisstMultiTask/mtsManagerLocalInterface.h>
#include <cisstMultiTask/mtsManagerGlobalInterface.h>
#include <cisstMultiTask/mtsParameterTypes.h>
#include <cisstMultiTask/mtsConnection.h>
#include <cisstMultiTask/mtsForwardDeclarations.h>

#include <cisstMultiTask/mtsExport.h>

// Forward declaration
class mtsManagerComponentServer;

class CISST_EXPORT mtsManagerGlobal : public mtsManagerGlobalInterface
{
    friend class mtsManagerGlobalTest;
    friend class mtsManagerLocalTest;

    CMN_DECLARE_SERVICES(CMN_NO_DYNAMIC_CREATION, CMN_LOG_ALLOW_DEFAULT);

protected:
    //-------------------------------------------------------------------------
    //  Data Structure of Process Map
    //-------------------------------------------------------------------------
    /*
        P1 - C1 - p1 - r1   Process Map: (P, ComponentMap)
        |    |    |    |    Component Map: (C, InterfaceMap)
        |    |    |    r2   Interface Map: { (PI, ConnectionMap) where PI is Provided Interface
        |    |    |                          (RI, ConnectionMap) where RI is Required Interface }
        |    |    p2 - r3   Connection Map: (name of connected interface, list of connection id(s))
        |    |    |
        |    |    r1 - p1
        |    |
        |    C2 - r1 - p2
        |
        P2 - C1
             |
             C2
    */

    //typedef cmnNamedMap<mtsManagerGlobal::ConnectedInterfaceInfo> ConnectionMapType;
    typedef std::vector<ConnectionIDType> ConnectionIDListType;

    //typedef cmnNamedMap<ConnectionIDListType> ConnectedInterfaceMapType;
    typedef cmnNamedMap<ConnectionIDListType> InterfaceMapElementType;

    typedef struct {
        //ConnectedInterfaceMapType InterfaceProvidedOrOutputMap;
        //ConnectedInterfaceMapType InterfaceRequiredOrInputMap;
        InterfaceMapElementType InterfaceProvidedOrOutputMap;
        InterfaceMapElementType InterfaceRequiredOrInputMap;
    } InterfaceMapType;

    typedef cmnNamedMap<InterfaceMapType> ComponentMapType;

    typedef cmnNamedMap<ComponentMapType> ProcessMapType;
    ProcessMapType ProcessMap;

    typedef std::map<ConnectionIDType, mtsConnection> ConnectionMapType;
    ConnectionMapType ConnectionMap;

    mtsManagerLocal * LocalManager;
    mtsManagerLocalInterface * LocalManagerConnected;

    osaMutex ProcessMapChange;    // for thread-safe ProcessMap update
    osaMutex ConnectionMapChange; // for thread-safe ConnectionMap update
    osaMutex ConnectionChange;    // to process Connect() request one-by-one
    osaMutex DisconnectedProcessCleanupMapChange; // for thread-safe DisconnectedProcessCleanupMap update

    ConnectionIDType ConnectionID;

    mtsManagerProxyServer * ProxyServer;

    mtsManagerComponentServer * ManagerComponentServer;

    typedef std::map<ConnectionIDType, ConnectionIDType> DisconnectQueueType;
    DisconnectQueueType QueueDisconnectWaiting;
    DisconnectQueueType QueueDisconnected;

    osaMutex QueueDisconnectWaitingChange;
    osaMutex QueueDisconnectedChange;

    osaThread ThreadDisconnect;
    osaThreadSignal ThreadDisconnectFinished;
    bool ThreadDisconnectRunning;
    void * ThreadDisconnectProcess(void * arg);

    typedef struct CleanupElementType {
        std::string ProcessName;
        std::string ComponentProxyName;
    } CleanupElementType;
    typedef std::list<CleanupElementType> CleanupElementListType;
    typedef cmnNamedMap<CleanupElementListType> DisconnectedProcessCleanupMapType;
    DisconnectedProcessCleanupMapType DisconnectedProcessCleanupMap;

    void ShowInternalStructure(void);

    //-------------------------------------------------------------------------
    //  Processing Methods
    //-------------------------------------------------------------------------
    void Cleanup(void);

    ConnectionIDListType * GetConnectionsOfInterfaceProvidedOrOutput(
        const std::string & serverProcessName, const std::string & serverComponentName,
        const std::string & interfaceName) const;

    ConnectionIDListType * GetConnectionsOfInterfaceProvidedOrOutput(
        const std::string & serverProcessName, const std::string & serverComponentName,
        const std::string & interfaceName, InterfaceMapType ** interfaceMap) const;

    ConnectionIDListType * GetConnectionsOfInterfaceRequiredOrInput(
        const std::string & clientProcessName, const std::string & clientComponentName,
        const std::string & interfaceName) const;

    ConnectionIDListType * GetConnectionsOfInterfaceRequiredOrInput(
        const std::string & clientProcessName, const std::string & clientComponentName,
        const std::string & interfaceName, InterfaceMapType ** interfaceMap) const;

    bool AddConnectionToInterfaceProvidedOrOutput(
        const std::string & serverProcessName, const std::string & serverComponentName,
        const std::string & interfaceName, const ConnectionIDType connectionID);

    bool AddConnectionToInterfaceRequiredOrInput(
        const std::string & clientProcessName, const std::string & clientComponentName,
        const std::string & interfaceName, const ConnectionIDType connectionID);

    bool RemoveConnectionOfInterfaceProvidedOrOutput(
        const std::string & serverProcessName, const std::string & serverComponentName,
        const std::string & interfaceName, const ConnectionIDType connectionID);

    bool RemoveConnectionOfInterfaceRequiredOrInput(
        const std::string & clientProcessName, const std::string & clientComponentName,
        const std::string & interfaceName, const ConnectionIDType connectionID);

    bool CleanupDisconnectedProcess(const std::string & nameOfProcessDisconnected);

    bool IsAlreadyConnected(const mtsDescriptionConnection & description) const;

    int GetNumberOfInterfaces(const std::string & processName, const std::string & componentName, const bool includeInternalInterface = true) const;

    ConnectionIDType GetConnectionID(const std::string & clientProcessName,
        const std::string & clientComponentName, const std::string & interfaceName) const;

    mtsConnection * GetConnectionInformation(const ConnectionIDType connectionID);

    void DisconnectInternal(void);

    void AddToDisconnectedProcessCleanup(const std::string & sourceProcessName,
        const std::string & targetProcessName, const std::string & targetComponentProxyName);

public:
    mtsManagerGlobal();
    ~mtsManagerGlobal();

    void SetMCS(mtsManagerComponentServer *mcs) { ManagerComponentServer = mcs; }

    //-------------------------------------------------------------------------
    //  Process Management
    //-------------------------------------------------------------------------
    bool AddProcess(const std::string & processName);

    bool AddProcessObject(mtsManagerLocalInterface * localManagerObject, const bool isManagerProxyServer = false);

    bool FindProcess(const std::string & processName) const;

    bool RemoveProcess(const std::string & processName, const bool networkDisconnect = false);

    //-------------------------------------------------------------------------
    //  Component Management
    //-------------------------------------------------------------------------
    bool AddComponent(const std::string & processName, const std::string & componentName);

    bool FindComponent(const std::string & processName, const std::string & componentName) const;

    bool RemoveComponent(const std::string & processName, const std::string & componentName, const bool lock = true);

    //-------------------------------------------------------------------------
    //  Interface Management
    //-------------------------------------------------------------------------
    bool AddInterfaceProvidedOrOutput(const std::string & processName, const std::string & componentName, const std::string & interfaceName);

    bool AddInterfaceRequiredOrInput(const std::string & processName, const std::string & componentName, const std::string & interfaceName);

    bool FindInterfaceProvidedOrOutput(const std::string & processName, const std::string & componentName, const std::string & interfaceName) const;

    bool FindInterfaceRequiredOrInput(const std::string & processName, const std::string & componentName, const std::string & interfaceName) const;

    bool RemoveInterfaceProvidedOrOutput(const std::string & processName, const std::string & componentName, const std::string & interfaceName, const bool lock = true);

    bool RemoveInterfaceRequiredOrInput(const std::string & processName, const std::string & componentName, const std::string & interfaceName, const bool lock = true);

    //-------------------------------------------------------------------------
    //  Connection Management
    //-------------------------------------------------------------------------
    ConnectionIDType Connect(const std::string & requestProcessName,
        const std::string & clientProcessName, const std::string & clientComponentName, const std::string & clientInterfaceName,
        const std::string & serverProcessName, const std::string & serverComponentName, const std::string & serverInterfaceName);

    bool ConnectConfirm(const ConnectionIDType connectionID);

    bool Disconnect(const ConnectionIDType connectionID);

    bool Disconnect(const mtsDescriptionConnection & connection);

    bool Disconnect(
        const std::string & clientProcessName, const std::string & clientComponentName, const std::string & clientInterfaceName,
        const std::string & serverProcessName, const std::string & serverComponentName, const std::string & serverInterfaceName);

    bool InitiateConnect(const ConnectionIDType connectionID);

    bool ConnectServerSideInterfaceRequest(const ConnectionIDType connectionID);

    void GetListOfConnections(std::vector<mtsDescriptionConnection> & list) const;

    //-------------------------------------------------------------------------
    //  Getters
    //-------------------------------------------------------------------------
    inline static std::string GetName(void) {
        return "GlobalComponentManager";
    }

    std::vector<std::string> GetIPAddress(void) const;
    void GetIPAddress(std::vector<std::string> & ipAddresses) const;

    void GetNamesOfProcesses(std::vector<std::string>& namesOfProcesses) const;

    void GetNamesOfComponents(const std::string & processName,
                              std::vector<std::string>& namesOfComponents) const;

    void GetNamesOfInterfacesProvidedOrOutput(const std::string & processName,
                                              const std::string & componentName,
                                              std::vector<std::string> & namesOfInterfacesProvided) const;

    void GetNamesOfInterfacesRequiredOrInput(const std::string & processName,
                                             const std::string & componentName,
                                             std::vector<std::string> & namesOfInterfacesRequired) const;

    void GetNamesOfCommands(const std::string & processName,
                            const std::string & componentName,
                            const std::string & providedInterfaceName,
                            std::vector<std::string>& namesOfCommands) const;

    void GetNamesOfEventGenerators(const std::string & processName,
                                   const std::string & componentName,
                                   const std::string & providedInterfaceName,
                                   std::vector<std::string>& namesOfEventGenerators) const;

    void GetNamesOfFunctions(const std::string & processName,
                             const std::string & componentName,
                             const std::string & requiredInterfaceName,
                             std::vector<std::string>& namesOfFunctions) const;

    void GetNamesOfEventHandlers(const std::string & processName,
                                 const std::string & componentName,
                                 const std::string & requiredInterfaceName,
                                 std::vector<std::string>& namesOfEventHandlers) const;

    void GetDescriptionOfCommand(const std::string & processName,
                                 const std::string & componentName,
                                 const std::string & providedInterfaceName,
                                 const std::string & commandName,
                                 std::string & description) const;

    void GetDescriptionOfEventGenerator(const std::string & processName,
                                        const std::string & componentName,
                                        const std::string & providedInterfaceName,
                                        const std::string & eventGeneratorName,
                                        std::string & description) const;

    void GetDescriptionOfFunction(const std::string & processName,
                                  const std::string & componentName,
                                  const std::string & requiredInterfaceName,
                                  const std::string & functionName,
                                  std::string & description) const;

    void GetDescriptionOfEventHandler(const std::string & processName,
                                      const std::string & componentName,
                                      const std::string & requiredInterfaceName,
                                      const std::string & eventHandlerName,
                                      std::string & description) const;

    static bool IsProxyComponent(const std::string & componentName);

    static const std::string GetComponentProxyName(const std::string & processName, const std::string & componentName);

    mtsManagerLocalInterface * GetProcessObject(const std::string & processName) const;

    static const std::string GetInterfaceUID(
        const std::string & processName, const std::string & componentName, const std::string & interfaceName);

    //-------------------------------------------------------------------------
    //  Networking
    //-------------------------------------------------------------------------
    bool StartServer(void);

    bool StopServer(void);

    bool SetInterfaceProvidedProxyAccessInfo(const ConnectionIDType connectionID, const std::string & endpointInfo);

    bool GetInterfaceProvidedProxyAccessInfo(const ConnectionIDType connectionID, std::string & endpointInfo);

    bool GetInterfaceProvidedProxyAccessInfo(const std::string & clientProcessName,
        const std::string & serverProcessName, const std::string & serverComponentName,
        const std::string & serverInterfaceName, std::string & endpointInfo);

    void CheckConnectConfirmTimeout(void);
};

CMN_DECLARE_SERVICES_INSTANTIATION(mtsManagerGlobal)

#endif // _mtsManagerGlobal_h