mtsManagerLocal.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-12-07

  (C) Copyright 2009-2013 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 _mtsManagerLocal_h
#define _mtsManagerLocal_h

#include <cisstCommon/cmnNamedMap.h>
#include <cisstCommon/cmnUnits.h>
#include <cisstOSAbstraction/osaThreadBuddy.h>
#include <cisstOSAbstraction/osaMutex.h>
#include <cisstOSAbstraction/osaThread.h>
#include <cisstMultiTask/mtsForwardDeclarations.h>
#include <cisstMultiTask/mtsComponentState.h>
#include <cisstMultiTask/mtsManagerLocalInterface.h>
#include <cisstMultiTask/mtsManagerGlobalInterface.h>

#include <stack>

#include <cisstMultiTask/mtsExport.h>

// Helper macro (useful to connect interfaces in main.cpp)
#define CONNECT_LOCAL(_clientComp, _reqInt, _serverComp, _prvInt)\
    if (!mtsManagerLocal::GetInstance()->Connect(_clientComp, _reqInt, _serverComp, _prvInt)) {\
        CMN_LOG_INIT_ERROR << "Failed to connect: "\
                           << _clientComp << ":" << _reqInt << " - "\
                           << _serverComp << ":" << _prvInt << std::endl;\
        exit(1);\
    }

#define CONNECT_REMOTE(_clientProc, _clientComp, _reqInt, _serverProc, _serverComp, _prvInt)\
    if (!mtsManagerLocal::GetInstance()->Connect(_clientProc, _clientComp, _reqInt, _serverProc, _serverComp, _prvInt)) {\
        CMN_LOG_INIT_ERROR << "Failed to connect: "\
                           << _clientProc << ":" << _clientComp << ":" << _reqInt << " - "\
                           << _serverProc << ":" << _serverComp << ":" << _prvInt << std::endl;\
        exit(1);\
    }

class CISST_EXPORT mtsManagerLocal: public mtsManagerLocalInterface
{
    // for unit-testing
    friend class mtsManagerLocalTest;
    friend class mtsManagerGlobalTest;
    // for internal access to manage proxy objects
    friend class mtsManagerGlobal;
    friend class mtsManagerProxyClient;
    // for dynamic creation of a component
    friend class mtsManagerComponentClient;
    // for reconfiguration
    friend class mtsComponentProxy;

    CMN_DECLARE_SERVICES(CMN_NO_DYNAMIC_CREATION, CMN_LOG_ALLOW_DEFAULT);

public:
    enum ConfigurationType {
        // Standalone mode: supports only local components/connections
        LCM_CONFIG_STANDALONE,
        // Networked mode: supports both local and remote components/connections
        LCM_CONFIG_NETWORKED,
        // Networked mode with global component manager: basically identical to
        // LCM_CONFIG_NETWORKED configuration except that LCM runs with the
        // global component manager on the same process.
        LCM_CONFIG_NETWORKED_WITH_GCM
    };


private:
    static mtsManagerLocal * Instance;

    osaThreadId MainThreadId;

    std::stack<std::string> MainTaskNames;

    mtsTaskContinuous * CurrentMainTask;

    static bool UnitTestEnabled;

    static bool UnitTestNetworkProxyEnabled;

    ConfigurationType Configuration;

    static mtsManagerLocal * InstanceReconfiguration;
    static mtsManagerLocal * GetSafeInstance(void);

    typedef cmnNamedMap<mtsComponent> ComponentMapType;
    ComponentMapType ComponentMap;

    // MJ: Move this to mtsManagerLocal.cpp (for system-wide logging)
    //osaTimeServer TimeServer;

    std::string ProcessName;

    const std::string GlobalComponentManagerIP;

    std::string ProcessIP;

    std::vector<std::string> ProcessIPList;

    osaMutex ComponentMapChange;

    static osaMutex ConfigurationChange;

    mtsManagerGlobalInterface * ManagerGlobal;

    struct {
        mtsManagerComponentClient * Client;
        mtsManagerComponentServer * Server;
    } ManagerComponent;

    bool GCMConnected;

    osaThread       LogThead;
    osaThreadSignal LogTheadFinished;
    bool            LogThreadFinishWaiting;
    void*           LogDispatchThread(void * arg);

    void SetupSystemLogger(void);

    bool MCCReadyForLogForwarding(void) const;

public:
    static void LogDispatcher(const char * str, int len);

    static void SetLogForwarding(bool activate);

    static void GetLogForwardingState(bool & state);
    static bool GetLogForwardingState(void);

    static bool IsLogForwardingEnabled(void);

    static bool IsLogAllowed(void);

protected:
    mtsManagerLocal(void);

    mtsManagerLocal(const std::string & globalComponentManagerIP,
                    const std::string & thisProcessName,
                    const std::string & thisProcessIP);
    mtsManagerLocal(mtsManagerGlobal & globalComponentManager);

    virtual ~mtsManagerLocal();

    void Initialize(void);
    void InitializeLocal(void);

    bool CreateManagerComponents(void);

    bool AddManagerComponent(const std::string & processName, const bool isServer = false);

    bool ConnectManagerComponentClientToServer(void);

    bool ConnectToManagerComponentClient(const std::string & componentName);

    void SetIPAddress(void);

    bool ConnectToGlobalComponentManager(void);

    bool RegisterInterfaces(mtsComponent * component);
    bool RegisterInterfaces(const std::string & componentName);

    // PK: following two methods were part of Connect method
    ConnectionIDType ConnectSetup(const std::string & clientComponentName, const std::string & clientInterfaceRequiredName,
                                  const std::string & serverComponentName, const std::string & serverInterfaceProvidedName);

    bool ConnectNotify(ConnectionIDType connectionId,
                       const std::string & clientComponentName, const std::string & clientInterfaceRequiredName,
                       const std::string & serverComponentName, const std::string & serverInterfaceProvidedName);

    bool RemoveComponent(mtsComponent * component, const bool notifyGCM);
    bool RemoveComponent(const std::string & componentName, const bool notifyGCM);

    // MJ: Current implemention should be reviwed -- interfaces have to be removed in a thread-safe way
    bool RemoveInterfaceProvided(const std::string & componentName, const std::string & interfaceProvidedName);

    // MJ: Current implemention should be reviwed -- interfaces have to be removed in a thread-safe way
    bool RemoveInterfaceRequired(const std::string & componentName, const std::string & interfaceRequiredName);

    //-------------------------------------------------------------------------
    //  Methods required by mtsManagerLocalInterface
    //
    //  See mtsManagerLocalInterface.h for detailed documentation.
    //-------------------------------------------------------------------------
    bool CreateComponentProxy(const std::string & componentProxyName, const std::string & listenerID = "");

    bool RemoveComponentProxy(const std::string & componentProxyName, const std::string & listenerID = "");

    bool CreateInterfaceProvidedProxy(
        const std::string & serverComponentProxyName,
        const mtsInterfaceProvidedDescription & providedInterfaceDescription, const std::string & listenerID = "");

    bool CreateInterfaceRequiredProxy(
        const std::string & clientComponentProxyName,
        const mtsInterfaceRequiredDescription & requiredInterfaceDescription, const std::string & listenerID = "");

    bool RemoveInterfaceProvidedProxy(
        const std::string & componentProxyName, const std::string & providedInterfaceProxyName, const std::string & listenerID = "");

    bool RemoveInterfaceRequiredProxy(
        const std::string & componentProxyName, const std::string & requiredInterfaceProxyName, const std::string & listenerID = "");

    bool ConnectServerSideInterface(const mtsDescriptionConnection & description, const std::string & listenerID = "");

    bool ConnectClientSideInterface(const mtsDescriptionConnection & description, const std::string & listenerID = "");

    bool GetInterfaceProvidedDescription(
        const std::string & serverComponentName,
        const std::string & providedInterfaceName,
        mtsInterfaceProvidedDescription & providedInterfaceDescription, const std::string & listenerID = "");

    bool GetInterfaceRequiredDescription(
        const std::string & componentName,
        const std::string & requiredInterfaceName,
        mtsInterfaceRequiredDescription & requiredInterfaceDescription, const std::string & listenerID = "");

    inline void SetGCMConnected(const bool connected) {
        GCMConnected = connected;
    }

public:
    //-------------------------------------------------------------------------
    //  Component Management
    //-------------------------------------------------------------------------
    mtsComponent * CreateComponentDynamically(const std::string & className, const std::string & componentName,
                                              const std::string & constructorArgSerialized);

    bool AddComponent(mtsComponent * component);
    bool CISST_DEPRECATED AddTask(mtsTask * component); // For backward compatibility
    bool CISST_DEPRECATED AddDevice(mtsComponent * component); // For backward compatibility

    bool RemoveComponent(mtsComponent * component);
    bool RemoveComponent(const std::string & componentName);

    mtsComponent * GetComponent(const std::string & componentName) const;
    mtsTask * GetComponentAsTask(const std::string & componentName) const;

    mtsComponent CISST_DEPRECATED * GetDevice(const std::string & deviceName); // For backward compatibility
    mtsTask CISST_DEPRECATED * GetTask(const std::string & taskName); // For backward compatibility

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

    bool WaitForStateAll(mtsComponentState desiredState, double timeout = 3.0 * cmn_minute) const;

    void CreateAll(void);

    bool CreateAllAndWait(double timeoutInSeconds);

    void StartAll(void);

    bool StartAllAndWait(double timeoutInSeconds);

    void KillAll(void);

    bool KillAllAndWait(double timeoutInSeconds);

    void Cleanup(void);

    //-------------------------------------------------------------------------
    //  Connection Management
    //-------------------------------------------------------------------------
    bool Connect(const std::string & clientComponentName, const std::string & clientInterfaceRequiredName,
                 const std::string & serverComponentName, const std::string & serverInterfaceProvidedName);

    bool Connect(const std::string & clientProcessName, const std::string & clientComponentName,
                 const std::string & clientInterfaceRequiredName,
                 const std::string & serverProcessName, const std::string & serverComponentName,
                 const std::string & serverInterfaceProvidedName,
                 const unsigned int retryCount = 10);

    bool Disconnect(const ConnectionIDType connectionID);

    bool Disconnect(const std::string & clientComponentName, const std::string & clientInterfaceRequiredName,
                    const std::string & serverComponentName, const std::string & serverInterfaceProvidedName);

    bool Disconnect(const std::string & clientProcessName, const std::string & clientComponentName,
                    const std::string & clientInterfaceRequiredName,
                    const std::string & serverProcessName, const std::string & serverComponentName,
                    const std::string & serverInterfaceProvidedName);

    //-------------------------------------------------------------------------
    //  Getters and Utilities
    //-------------------------------------------------------------------------
    static const std::string ProcessNameOfLCMDefault;

    static const std::string ProcessNameOfLCMWithGCM;

    static mtsManagerLocal * GetInstance(void);

    static mtsManagerLocal * GetInstance(const std::string & globalComponentManagerIP,
                                         const std::string & thisProcessName = "",
                                         const std::string & thisProcessIP = "");

    static mtsManagerLocal * GetInstance(mtsManagerGlobal & globalComponentManager);

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

#if 0
    inline const osaTimeServer & GetTimeServer(void) const {
        return TimeServer;
    }
#endif
    const osaTimeServer & GetTimeServer(void) const;

    inline const std::string GetProcessName(const std::string & CMN_UNUSED(listenerID) = "") const {
        return ProcessName;
    }

    ConfigurationType GetConfiguration(void) const {
        return Configuration;
    }

    inline bool IsGCMActive(void) const {
        return GCMConnected;
    }

    void SetMainThreadId(void) { MainThreadId = osaGetCurrentThreadId(); }

    void SetMainThreadId(const osaThreadId &threadId) { MainThreadId = threadId; }

    osaThreadId GetMainThreadId(void) const { return MainThreadId; }

    void PushCurrentMainTask(mtsTaskContinuous *cur);

    mtsTaskContinuous *PopCurrentMainTask();

    mtsTaskContinuous *GetCurrentMainTask(void) const { return CurrentMainTask; }

    void GetNamesOfCommands(std::vector<std::string>& namesOfCommands,
                            const std::string & componentName,
                            const std::string & providedInterfaceName,
                            const std::string & CMN_UNUSED(listenerID) = "");

    void GetNamesOfEventGenerators(std::vector<std::string>& namesOfEventGenerators,
                                   const std::string & componentName,
                                   const std::string & providedInterfaceName,
                                   const std::string & CMN_UNUSED(listenerID) = "");

    void GetNamesOfFunctions(std::vector<std::string>& namesOfFunctions,
                             const std::string & componentName,
                             const std::string & requiredInterfaceName,
                             const std::string & CMN_UNUSED(listenerID) = "");

    void GetNamesOfEventHandlers(std::vector<std::string>& namesOfEventHandlers,
                                 const std::string & componentName,
                                 const std::string & requiredInterfaceName,
                                 const std::string & CMN_UNUSED(listenerID) = "");

    void GetDescriptionOfCommand(std::string & description,
                                 const std::string & componentName,
                                 const std::string & providedInterfaceName,
                                 const std::string & commandName,
                                 const std::string & CMN_UNUSED(listenerID) = "");

    void GetDescriptionOfEventGenerator(std::string & description,
                                        const std::string & componentName,
                                        const std::string & providedInterfaceName,
                                        const std::string & eventGeneratorName,
                                        const std::string & CMN_UNUSED(listenerID) = "");

    void GetDescriptionOfFunction(std::string & description,
                                  const std::string & componentName,
                                  const std::string & requiredInterfaceName,
                                  const std::string & functionName,
                                  const std::string & CMN_UNUSED(listenerID) = "");

    void GetDescriptionOfEventHandler(std::string & description,
                                      const std::string & componentName,
                                      const std::string & requiredInterfaceName,
                                      const std::string & eventHandlerName,
                                      const std::string & CMN_UNUSED(listenerID) = "");

    inline const std::string & GetIPAddress(void) const { return ProcessIP; }

    static std::vector<std::string> GetIPAddressList(void);
    static void GetIPAddressList(std::vector<std::string> & ipAddresses);

    inline const std::string GetName(void) const {
        return GetProcessName();
    }

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

    //returns the list or processes in the system and their absolute time differences relative to GCM
    bool GetGCMProcTimeSyncInfo(std::vector<std::string> &processNames, std::vector<double> &timeOffsets);

    void /*CISST_DEPRECATED*/ ToStream(std::ostream & outputStream) const;

    void /*CISST_DEPRECATED*/ ToStreamDot(std::ostream & outputStream) const;
};

CMN_DECLARE_SERVICES_INSTANTIATION(mtsManagerLocal)

#endif // _mtsManagerLocal_h