connInfoMgr.h

Go to the documentation of this file.

/****************************************************************************
 * Copyright (c) 2016 VT MAK
 * All rights reserved.
 ****************************************************************************/


#pragma once

#include "rtiMsConfig.h"
#include "assistantMgr.h"
#include "assistantLicServerInfo.h"
#include "assistantMsgQueue.h"
#include "connectionsCache.h"
#include "rtiAssistantClient.h"
#include "connectionAndConfiguration.h"
#include <assistant/assistantInfo.h>
#include <boost/uuid/uuid.hpp>
#include "assistantAppUtil.h"

class DtRtiAssistantServer;
class DtRtiAssistantPeer;
class DtAssistantSignalRouter;
class DtAssistantQueryMsg;
class DtAssistantLightweightInfoMsg;
class DtAssistantInfoMsg;
class DtAssistantRemovalMsg;
class DtAssistantStartRtiexecMsg;
class DtAssistantStartRtiForwarderMsg;
class DtAssistantComponentInfo;

struct DtAssistantState
{
   DtAssistantState() : heartbeated(true), lightweightInactivePeriod(120),
      assistantInactivePeriod(10), acceptsRemoteCommands(true) {}
   bool heartbeated;
   unsigned int lightweightInactivePeriod;
   unsigned int assistantInactivePeriod;
   bool acceptsRemoteCommands;
   std::map<int, DtRtiConnectionInfo> rtiexecs;
   std::map<int, DtRtiConnectionInfo> forwarders;
};

class DT_DLL_ASSISTANTAPP DtAssistantConnectionInfoMgr : public DtAssistantMgr
{  Q_OBJECT;
public:

   DtAssistantConnectionInfoMgr( DtBoost::shared_ptr<DtRtiAssistantServer> server,
      DtBoost::shared_ptr<DtRtiAssistantPeer> peer,
      DtAssistantSignalRouter& signalRouter,
      const MAKRti::DtFilename& configDir,
      const MAKRti::DtString& logFileName);

   virtual ~DtAssistantConnectionInfoMgr();

   struct cmpByBoostUuid {
      bool operator()(const DtAssistantInfo& a, const DtAssistantInfo& b) const {
         return *reinterpret_cast<const boost::uuids::uuid*>(&a.uuid()) < *reinterpret_cast<const boost::uuids::uuid*>(&b.uuid());
      }
   };
   typedef std::map< DtAssistantInfo, DtAssistantState, cmpByBoostUuid > DtAssistantStateMap;
   typedef std::pair< DtAssistantInfo, DtAssistantState > DtAssistantStatePair;

private:

   DtAssistantConnectionInfoMgr(DtAssistantConnectionInfoMgr const& );

   DtAssistantConnectionInfoMgr& operator= (DtAssistantConnectionInfoMgr const& );

public:

   virtual void initialize();

   virtual void tick();

   virtual void startShutdown();

   virtual bool isCacheFileVersionOld() const;

   virtual unsigned int lightweightMemoryPeriod() const;

   virtual unsigned int lightweightHeartbeatInterval() const;

   virtual unsigned int assistantMemoryPeriod() const;

   virtual unsigned int assistantHeartbeatInterval() const;

   virtual unsigned int requestedAssistantHeartbeatInterval() const;

   virtual bool acceptRemoteCommands() const;

   virtual bool sendForeignQuery() const;

   virtual bool remoteAssistantAcceptsCommands( const DtAssistantInfo& assistant ) const;

   virtual bool hostHasARemoteAssistantThatAcceptsCommands(
      const DtHostNameAddress& host, const DtInetAddr& publicAddr, const MAKRti::DtInetAddr& interfaceAddr) const;

   virtual int getRemoteAssistants(const DtString& hostName, DtAssistantInfoSet& assistants) const;

   virtual int getRemoteAssistants(const DtInetAddr& hostIp, DtAssistantInfoSet& assistants) const;

   virtual const DtAssistantInfo* remoteAssistant(const DtString& hostName) const;

   virtual const DtAssistantInfo* remoteAssistant(const DtInetAddr& hostIp) const;

   virtual const DtAssistantInfo* remoteAssistant(const DtAssistantUuid& uuid) const;
   
   virtual const DtInetAddr& assistantPublicAddress(const DtInetAddr& inetAddr) const;

   virtual int localRtiexecCompId( const DtRtiConnectionInfo& conn ) const;

   //1 or returns -1 if not found.
   virtual int localRtiForwarderCompId( const DtRtiConnectionInfo& conn ) const;

   virtual bool getRemoteRtiexecLocation( const DtRtiConnectionInfo& conn,
      DtAssistantInfo& assistant, int& id ) const;

   virtual bool getRtiExecConnection(const DtRtiConnectionInfo& conn, DtRtiConnectionInfo& rtiExecConn) const;

   virtual bool getRemoteRtiForwarderLocation( const DtRtiConnectionInfo& conn,
      DtAssistantInfo& assistant, int& id ) const;

   virtual bool getRemoteRtiexecConnInfo( const DtAssistantInfo& assistant,
      int id, DtRtiConnectionInfoDataPair& conn ) const;

   virtual bool getRemoteForwarderConnInfo( const DtAssistantInfo& assistant,
      int id, DtRtiConnectionInfoDataPair& conn ) const;

   virtual bool getChosenConnection( DtRtiConnectionInfoDataPair& conn );

   virtual bool getChosenConfiguration( DtRtiConfigurationInfoDataPair& config );

   virtual bool getConnectionInfo( DtRtiConnectionInfoDataPair& conn );

   virtual bool getConfigurationForConn( const DtRtiConnectionInfo& conn,
      DtRtiConfigurationInfoDataPair& config );

   virtual MAKRti::DtString connectionName( const DtRtiConnectionInfo& conn );

   virtual bool isStillDefaultChosen() const;

   virtual const DtRtiConnectionAndConfiguration& connectionsAndConfigurations();

   virtual void addUserDefinedConnections( const DtRtiConnectionAndConfiguration& conns );

   virtual void removeUserDeletedConnections( const DtRtiConnectionAndConfiguration& conns );

   virtual void removeAllLocalRtiexecsForwarders();

   virtual void removeAllLocalLightweightConns();

   virtual bool isConnConflicting( const DtRtiConnectionInfo& conn,
      MAKRti::DtString& reason ) const;

   void saveConnections();

   DtNetU128 rawUuid() const;

protected:


   static void processQueryMsg(const DtAssistantQueryMsg& queryMsg, void* usr);
   virtual void processQueryMsg(const DtAssistantQueryMsg& queryMsg);

   static void processInfoMsg(const DtAssistantInfoMsg& infoMsg, void* usr);
   virtual void processInfoMsg(const DtAssistantInfoMsg& infoMsg);

   static void processLightweightInfoMsg(const DtAssistantLightweightInfoMsg& infoMsg, void* usr);
   virtual void processLightweightInfoMsg(const DtAssistantLightweightInfoMsg& infoMsg);

   static void processRemovalMsg(const DtAssistantRemovalMsg& remMsg, void* usr);
   virtual void processRemovalMsg(const DtAssistantRemovalMsg& remMsg);

   static void processStartRtiexecMsg(const DtAssistantStartRtiexecMsg& msg, void* usr);
   virtual void processStartRtiexecMsg(const DtAssistantStartRtiexecMsg& msg );

   static void processStartRtiForwarderMsg(const DtAssistantStartRtiForwarderMsg& msg, void* usr);
   virtual void processStartRtiForwarderMsg(const DtAssistantStartRtiForwarderMsg& msg );


   static void processInterfaceFound( void* usr );

   virtual void processInterfaceFound();

signals:

   void heartbeat();

   void prune();

   void connectionsAddedOrUpdated( const DtRtiConnectionAndConfiguration& conns );

   void connectionsAboutToBeRemoved( const DtRtiConnectionAndConfiguration& conns );

   void connectionsRemoved( const DtRtiConnectionAndConfiguration& conns );

   void assistantFound( const DtAssistantInfo& info );

   void assistantLost( const DtAssistantInfo& info );

   void rtiexecStartupRequested( const DtRtiConnectionInfoDataPair&,
      const DtRtiConnectionConfigurationInfo&, bool );

   void rtiForwarderStartupRequested( const DtRtiConnectionInfoDataPair&,
      const DtRtiConnectionConfigurationInfo&, bool );
   
   void assistantConnectionInformationUpdated(const DtAssistantConnectionStruct&, const DtAssistantConnectionStruct&);

public slots:

   void processLocalRtiComponentConnected( const DtAssistantComponentInfo* compInfo );

   void processLocalRtiComponentNotConnected( const DtAssistantComponentInfo* compInfo );

   void processLocalForwarderHasRtiexec( const DtAssistantComponentInfo* compInfo );

   void processLocalForwarderHasNoRtiexec( const DtAssistantComponentInfo* compInfo );

   void processNewChosenConnection( const DtRtiConnectionInfo& conn );

   void processNewChosenConfiguration( const DtRtiConnectionConfigurationInfo& config );

   void processLocalInterfaceConfiguration(const DtRtiConnectionInfoDataPair& config, const DtRtiConnectionConfigurationInfo& configInfo);

   void processClearChosenConnection();

   void setLightweightMemory( unsigned int newVal );

   void setAssistantUpdateInterval( unsigned int newVal );

   void setAcceptRemoteCommands( bool newVal );

   void setSendForeignQuery( bool newVal );

   void provideAssistantInfo(const DtAssistantUuid& assistantUuid, DtAssistantInfo* infoIn);

   void recoverConnection(const DtRtiConnectionInfo& connInfo, DtRtiConnectionInfo& recoveredConn);

   virtual void addAssistantConnection(const DtAssistantConnectionStruct& connection);
   virtual bool remoteAddAssistantConnection(const DtAssistantConnectionStruct& connection);
   virtual void removeAssistantConnection(const DtAssistantConnectionStruct& connection);

   virtual bool isRemoteAddressAssistantConnection(const DtInetAddr& localDeviceAddr, const DtInetAddr& remoteAddr);

   void assistantToAssistantConnectionUpdated(const DtAssistantConnectionStruct&, DtAssistantConnectionState);
protected:

   virtual void heartbeatAssistant();

   virtual void heartbeatLightweightConnections();

   virtual void pruneStaleLightweightConns();

   virtual void checkForStaleAssistantsExecsFwrdrs();

   virtual void pruneStaleAssistantExecsFwrdrs(DtRtiConnectionAndConfiguration& connsToRemove,
      DtRtiConnectionAndConfiguration& updatedConns);

   virtual void determineHeartbeatIntervals();

   virtual DtAssistantStateMap::iterator addRemoteAssistant( const DtAssistantInfo& assistant);

   virtual void unverifyRtiexecsForwardersForAssistant(const DtAssistantState& assistantState,
      DtRtiConnectionAndConfiguration& connsToRemove,
      DtRtiConnectionAndConfiguration& updatedConns );

   virtual void unverifyListedRtiexecsForwardersForAssistant(
      const DtRtiConnectionAndConfiguration& removeList,
      DtAssistantStateMap::iterator astntIter,
      DtRtiConnectionAndConfiguration& connsToRemove,
      DtRtiConnectionAndConfiguration& updatedConns );

   virtual void addListedRtiexecsForwardersForAssistant(
      const DtRtiConnectionAndConfiguration& addList,
      DtAssistantStateMap::iterator astntIter,
      DtRtiConnectionAndConfiguration& connsToRemove,
      DtRtiConnectionAndConfiguration& updatedConns );

   virtual void checkForConflictingConns( DtRtiConnectionAndConfiguration& updatedConns );

   virtual void removeConnections( const DtRtiConnectionAndConfiguration& connsToRemove );

   virtual void setInterfaceForPredefinedConns( const MAKRti::DtInetAddr& interfaceAddr );


protected:

   DtBoost::shared_ptr<DtConnectionCache> myConnectionCache;

   bool myAcceptRemoteCmds;

   bool mySendForeignQuery;

   DtClock myClock;

   DtTime myNextAssistantHeartbeatTime;

   DtTime myNextLightweightHeartbeatTime;

   DtTime myNextAssistantInfoRemovalTime;

   DtTime myNextLightweightRemovalTime;

   unsigned int myAssistantHeartbeatInterval;

   unsigned int myLightweightHeartbeatInterval;

   unsigned int myAssistantInfoRemovalPeriod;

   unsigned int myLightweightRemovalPeriod;

   MAKRti::DtString myHostName;

   DtRtiConnectionAndConfiguration myRemovedLocalExecsAndFwrdrs;

   DtAssistantStateMap myRemoteAssistantStates;

   DtRtiConnectionAndConfiguration myConnsAndConfigs;

   bool myStillDefaultChosen;

   bool myPredefinedConnsNeedInterface;

   MAKRti::DtInetAddr myPotentialPredefinedConnsInterface;

   DtTime mySetPredefinedConnsInterfaceTime;

   MAKRti::DtString myLogFileName;

};