federationsInfoMgr.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 "assistantInfo.h"
#include "federationInfo.h"
#include "connectionAndConfiguration.h"
#include <vlutil/vlSmartPointers.h>
#include <vlutil/vlTime.h>

class DtRtiAssistantServer;
class DtRtiAssistantPeer;
class DtAssistantMsg;
class DtAssistantFederationStateMsg;
class DtAssistantFederateStateMsg;
class DtAssistantTimeStateMsg;
class DtAssistantSyncPtUpdateMsg;
class DtAssistantStateObserveMsg;
class DtAssistantCommandMsg;
class DtAssistantDeleteFederateMsg;
class DtAssistantDeleteFederationMsg;
class DtAssistantExecStateMsg;
class DtAssistantNotifyMsg;
class DtAssistantPopupMsg;
class DtAssistantLogMsg;
class DtAssistantLogRequestMsg;
class DtAssistantSignalTickedMsg;
class DtAssistantExecObserveRspMsg;
class DtAssistantExitMsg;
class DtAssistantFederateReqMsg;
class DtAssistantFederateRespMsg;
class DtAssistantComponentMgr;
class DtAssistantRidConfigInfoMgr;
class DtAssistantConnectionInfoMgr;
class DtAssistantSignalRouter;
class DtAssistantComponentInfo;
class DtAssistantForwarderCompInfoMgr;

class DT_DLL_ASSISTANTAPP DtAssistantFederationsInfoMgr : public DtAssistantMgr
{  Q_OBJECT;
public:

   DtAssistantFederationsInfoMgr( DtBoost::shared_ptr<DtRtiAssistantServer> server,
      DtBoost::shared_ptr<DtRtiAssistantPeer> peer, DtAssistantSignalRouter& signalRouter,
      DtBoost::shared_ptr<DtAssistantComponentMgr> compMgr,
      DtBoost::shared_ptr<DtAssistantRidConfigInfoMgr> ridInfoMgr,
      DtBoost::shared_ptr<DtAssistantConnectionInfoMgr> connInfoMgr,
      DtBoost::shared_ptr<DtAssistantForwarderCompInfoMgr> netConnInfoMgr );

   virtual ~DtAssistantFederationsInfoMgr();

public:


   virtual const DtFederationStateByNameMap* federations(const DtRtiConnectionInfo& conn, bool checkPeers) const;
   virtual DtFederationStateByNameMap* federations(const DtRtiConnectionInfo& conn, bool checkPeers);

   virtual const DtAssistantFederationInfo* federationInfo(
      const DtRtiConnectionInfo& conn, const MAKRti::DtString& name, bool checkPeers) const;

   virtual const DtAssistantFederateInfo* federateInfo(
      const DtRtiConnectionInfo& conn, const MAKRti::DtString& federationName,
      unsigned federateHandle);

   virtual const DtFederateInfoByHandleMap* federates(
      const DtRtiConnectionInfo& conn, const MAKRti::DtString& federationName ) const;

   virtual bool isLocalRtiexecViewedRemotely( const DtRtiConnectionInfo& conn ) const;

   virtual void tick();

   virtual void requestSingleUpdateFromConnectedRtiexecs( int id );

   virtual void pruneTimedOutSingleUpdates();

   virtual void viewFederationsForConnection( const DtRtiConnectionInfo& conn );

   virtual void print(DtOutputStream& outputStream);



   static void processObserveMsg( const DtAssistantStateObserveMsg& msg, void* usr );

   virtual void processObserveMsg( const DtAssistantStateObserveMsg& msg );

   static void processExecObserveRspMsg( const DtAssistantExecObserveRspMsg& msg, void* usr );

   virtual void processExecObserveRspMsg( const DtAssistantExecObserveRspMsg& msg );

   static void processRemoteRtiexecPopupMsg( const DtAssistantPopupMsg& msg, void* usr );

   virtual void processRemoteRtiexecPopupMsg( const DtAssistantPopupMsg& msg );

   static void processFederationStateMsg( const DtAssistantFederationStateMsg& msg, void* usr );

   virtual void processFederationStateMsg( const DtAssistantFederationStateMsg& msg );

   static void processFederateStateMsg( const DtAssistantFederateStateMsg& msg, void* usr );

   virtual void processFederateStateMsg( const DtAssistantFederateStateMsg& msg );

   static void processExecStateMsgForConnection(
      const DtAssistantExecStateMsg& msg, void* usr );

   virtual void processExecStateMsgForConnection( const DtAssistantExecStateMsg& msg );

   static void processTimeStateMsg( const DtAssistantTimeStateMsg& msg, void* usr );

   virtual void processTimeStateMsg( const DtAssistantTimeStateMsg& msg );

   static void processSyncPtStateMsg( const DtAssistantSyncPtUpdateMsg& msg, void* usr );

   virtual void processSyncPtStateMsg( const DtAssistantSyncPtUpdateMsg& msg );

   static void processAssistantCommandMsg(const DtAssistantCommandMsg& msg, void* usr);

   virtual void processAssistantCommandMsg(const DtAssistantCommandMsg& msg);

   static void processFederateDeleteMsg( const DtAssistantDeleteFederateMsg& msg, void* usr );

   static void processFederationDeleteMsg( const DtAssistantDeleteFederationMsg& msg, void* usr );

   static void processFederateRequestMsg( const DtAssistantFederateReqMsg& msg, void* usr );

   virtual void processFederateRequestMsg( const DtAssistantFederateReqMsg& msg );

   static void processFederateResponseMsg( const DtAssistantFederateRespMsg& msg, void* usr );

   virtual void processFederateResponseMsg( const DtAssistantFederateRespMsg& msg );

   static void forwardRtiexecNotifyMsg( const DtAssistantNotifyMsg& msg, void* usr );

   static void forwardRtiexecPopupMsg( const DtAssistantPopupMsg& msg, void* usr );

   static void forwardRtiexecLogMsg( const DtAssistantLogMsg& msg, void* usr );

   static void forwardLogRequestMsg( const DtAssistantLogRequestMsg& msg, void* usr );

   static void forwardRtiexecExitMsg( const DtAssistantExitMsg& msg, void* usr );

   virtual void forwardMsgToLocalRtiexec( const DtAssistantMsg& msg,
      bool sendOnlyIfCommandsAccepted = false );

   virtual void forwardMsgFromLocalRtiexec( const DtAssistantMsg& msg );

   static void processSignalTickedMsg( const DtAssistantSignalTickedMsg& msg, void* usr );

   virtual void processSignalTickedMsg( const DtAssistantSignalTickedMsg& msg );


public slots:

   void processLocalFederateJoined( const DtAssistantComponentInfo* info,
      const MAKRti::DtString& federateType, const MAKRti::DtString& federateName,
      unsigned federateHandle, const MAKRti::DtString& federationName,
      unsigned federationHandle, DtHlaVersionId hlaVersion );

   void processLocalFederateResigned( const DtAssistantComponentInfo* );

   void processConnectionsUpdate( const DtRtiConnectionAndConfiguration& conns );

   void processConnectionsRemoval( const DtRtiConnectionAndConfiguration& conns );

   void sendAllFederationInfo();

   void pruneStaleFederationsAndObservers();

   void startRtiexec( const DtRtiConnectionInfoDataPair& conn,
      const DtRtiConnectionConfigurationInfo& config,
      bool requestedRemotely );

   void startRtiForwarder( const DtRtiConnectionInfoDataPair& conn,
      const DtRtiConnectionConfigurationInfo& config,
      bool requestedRemotely );

   void updateFederateWarningTickInterval( float interval );

   void sendObserveFederationsMsg();

   void provideFederateInfo( const DtRtiConnectionInfo& conn,
      const MAKRti::DtString& federationName, unsigned federateHandle,
      const DtAssistantFederateInfo** info );

   void provideFederationInfo( const DtRtiConnectionInfo& conn,
      const MAKRti::DtString& federationName,
      const DtAssistantFederationInfo** info );

   void requestFederateLoc( const DtRtiConnectionInfo& connInfo,
      const MAKRti::DtString& federationName, unsigned federateHdl );

   void removeFederationsForRtiexec( const DtAssistantComponentInfo* );

   void forwarderHasShutdown( const DtRtiConnectionInfo& conn );


signals:

   void federationAdded( const DtRtiConnectionInfo& conn,
      const MAKRti::DtString& federationName );

   void federationUpdated( const DtRtiConnectionInfo& conn,
      const MAKRti::DtString& federationName );

   void federationRemoved( const DtRtiConnectionInfo& conn,
      const MAKRti::DtString& federationName );

   void federateAdded( const DtRtiConnectionInfo& conn,
      const MAKRti::DtString& federationName,
      unsigned federateHandle );

   void federateUpdated( const DtRtiConnectionInfo& conn,
      const MAKRti::DtString& federationName,
      unsigned federateHandle );

   void federateRemoved( const DtRtiConnectionInfo& conn,
      const MAKRti::DtString& federationName,
      unsigned federateHandle );

   void rtiexecHasNoFederations( const DtRtiConnectionInfo& conn );

   void federateLocReceived( const DtRtiConnectionInfo& connInfo,
      const MAKRti::DtString& federationName, unsigned federateHdl,
      const DtAssistantInfo& astnt, unsigned compId );

protected:

   struct cmpConnectionWithoutLocalIntf
   {
      bool operator()(const DtRtiConnectionInfo& left, const DtRtiConnectionInfo& right) const
      {
         return (left.useRtiexec() < right.useRtiexec() || (left.useRtiexec() == right.useRtiexec()
            && (
            (!left.useRtiexec() // Lightweight connections
               && (left.udpPort() < right.udpPort() || (left.udpPort() == right.udpPort()
               && left.udpAddress() < right.udpAddress())))
            ||
            (left.useRtiexec() // RTI Exec connections
               && (left.tcpPort() < right.tcpPort() || (left.tcpPort() == right.tcpPort()
               && (left.udpPort() < right.udpPort() || (left.udpPort() == right.udpPort()
               && (left.forwarderPort() < right.forwarderPort() || (left.forwarderPort() == right.forwarderPort()
               && (left.udpAddress() < right.udpAddress() || (left.udpAddress() == right.udpAddress()
               && (left.hostNameAddress() < right.hostNameAddress()))))))))))
            )));
      }
   };

   typedef std::map<DtAssistantInfo,bool> DtRemoteObserversMap;
   typedef std::map<DtRtiConnectionInfo,DtRemoteObserversMap> DtConnToObserversMap;
   typedef std::map<DtRtiConnectionInfo, int> DtConnToCompIdMap;
   typedef std::map<DtRtiConnectionInfo, DtFederationStateByNameMap, cmpConnectionWithoutLocalIntf> DtConnToFederationStateMap;

   virtual void refreshFederateLocationInfo(const DtRtiConnectionInfo& federationConnection, const DtString& federationName,
      DtFederateInfoByHandleMap& federates);

   virtual void processRtiexecConnUpdate( const DtRtiConnectionInfoDataPair& rtiexec );

   virtual void processLightweightConnUpdate( const DtRtiConnectionInfoDataPair& conn );

   virtual void processConnectionRemoval( const DtRtiConnectionInfoDataPair& conn );

   virtual bool localFederateInfo( int compId, const DtAssistantFederateInfo** federate,
      DtAssistantFederationInfo** federation );

   virtual void startRtiexecOrForwarderProcess( const DtRtiConnectionInfoDataPair& conn,
      const DtRtiConnectionConfigurationInfo& config, const QString& processName,
      const QStringList* specificCmds = 0 );

   virtual bool unObserveRtiexecConnection(const DtRtiConnectionInfo& conn);

   virtual void unObserveConnection(const DtRtiConnectionInfo& conn);

   virtual void observeConnection(const DtRtiConnectionInfo& conn);


private:

   DtAssistantFederationsInfoMgr( const DtAssistantFederationsInfoMgr& );

   DtAssistantFederationsInfoMgr& operator = ( const DtAssistantFederationsInfoMgr& );

protected:

   DtBoost::shared_ptr<DtAssistantComponentMgr> myCompMgr;

   DtBoost::shared_ptr<DtAssistantRidConfigInfoMgr> myRidInfoMgr;

   DtBoost::shared_ptr<DtAssistantConnectionInfoMgr> myConnInfoMgr;

   DtBoost::shared_ptr<DtAssistantForwarderCompInfoMgr> myNetCompInfoMgr;

   DtConnToFederationStateMap myKnownFederations;

   DtConnToCompIdMap myLocalRtiexecConns;

   std::set<DtRtiConnectionInfo> myRtiForwardersRequestedForRemoteStart;

   std::set<DtRtiConnectionInfo> myRtiexecsRequestedForRemoteStart;

   std::set<DtRtiConnectionInfo> myRtiForwardersStartedByRemoteRequest;

   std::set<DtRtiConnectionInfo> myRtiexecsStartedByRemoteRequest;

   DtConnToObserversMap myRemotelyViewedConnections;

   std::set<DtRtiConnectionInfo> myRemotelyViewedConnectionsNeedingUpdate;

   DtRtiConnectionInfo myViewedConnection;

   DtRtiConnectionInfo myToBeViewedConnection;

   MAKRti::DtClock myClock;

   unsigned int myTimeStateUpdateInterval;

   std::map< std::pair<int,MAKRti::DtTime>, std::map<int,MAKRti::DtString> > myRequestedRtiexecUpdates;

   float myWarningTickInterval;

   MAKRti::DtTime myLastTickTime;

   std::map<int,bool> myFederateSignalTickMessages;

   typedef std::pair<MAKRti::DtString,unsigned> DtFedexFederatePair;
   typedef std::map< DtRtiConnectionInfo, std::set<DtFedexFederatePair> > DtFedsByConn;
   DtFedsByConn myFederateLocQueries;

   static const int theTimeToWaitForExecInfo;

   typedef std::map<int,DtAssistantFederateInfo> DtFedInfoByCompIdMap;
   typedef std::pair<MAKRti::DtString,unsigned int>DtFederationNameFederateHandlePair;
   typedef std::pair<DtRtiConnectionInfo, DtFederationNameFederateHandlePair> DtConnectionFederationNameFedHandleTriple;
   typedef std::map<DtConnectionFederationNameFedHandleTriple,DtAssistantFederateInfo> DtFedInfoByConnFederationPairMap;

   DtFedInfoByCompIdMap myLocalJoinedFederatesByCompIdMap;
   DtFedInfoByConnFederationPairMap myLocalJoinedFederatesByConnFederationNameMap;

};