rtiAssistantPeer.h

Go to the documentation of this file.

/*********************************************************************
** Copyright (c) 2008 MaK Technologies, Inc.
** All rights reserved.
*********************************************************************/
/*********************************************************************
** $RCSfile: rtiAssistantPeer.h,v $ $Revision: 1.51 $ $State: Exp $
*********************************************************************/

#ifndef rtiAssistantPeer_H_
#define rtiAssistantPeer_H_


#include <rtiUtil.h>
#include <rtiVersion.h>
#include <vlutil/vlUtil.h>
#include <vlutil/vlTime.h>
#include <vlutil/vlPrint.h>
#include <vlutil/vlSmartPointers.h>

#include "assistantDefaultMsgFact.h"
#include "assistantMsgCbMgr.h"
#include "assistantLicServerInfo.h"
#include "assistantConnectionInfo.h"
#include "assistantConnMsg.h"
#include "connectionAndConfiguration.h"
#include "rtiAssistantClient.h"
#include "assistantInfo.h"
#include "assistantInfoMsg.h"
#include "assistantNetStatsStringReqMsg.h"
#include "assistantNetStatsEnums.h"

class DtAssistantQueryMsg;
class DtAssistantInfoMsg;
class DtAssistantRemovalMsg;
class DtAssistantLightweightInfoMsg;
class DtAssistantConfig;
class DtAssistantFederationInfo;
class DtRtiConnectionConfigurationInfo;
class DtUdpMsgSocket;
class DtAssistantFederateInfo;

typedef void (*DtInterfaceFoundCb)( void* );

#define DtCbInfoStruct( cbType )                 \
struct cbType##Info                              \
{                                                \
   cbType##Info( cbType cb, void* usr )  :       \
      myCb(cb),                                  \
      myUsr(usr)                                 \
      { };                                       \
   cbType myCb;                                  \
   void* myUsr;                                  \
};


class DT_DLL_ASSISTANT DtRtiAssistantPeer
{
public:
   DtRtiAssistantPeer( int id, int port = DtASSISTANT_DEFAULT_PORT,
      const MAKRti::DtInetAddr& ipv4Addr = DtASSISTANT_DEFAULT_IPV4_ADDR,
      const MAKRti::DtInetAddr& ipv6Addr = DtASSISTANT_DEFAULT_IPV6_ADDR, 
      int ttl = DtASSISTANT_DEFAULT_TTL );

   virtual ~DtRtiAssistantPeer();

   virtual bool tick( unsigned int timeout = 0 );

   virtual void setMsgFactory(DtAssistantMessageFactory* fact);

   virtual DtAssistantMessageFactory* msgFactory() const;



   virtual void addMsgCallback(DtAssistantMsgKind msgKind, DtAssistantMsgCbMgr::DtCallbackFcn fcn,
      void *usr );
   virtual void removeMsgCallback(DtAssistantMsgKind msgKind, DtAssistantMsgCbMgr::DtCallbackFcn fcn,
      void *usr );

   virtual void addInterfaceFoundCallback( DtInterfaceFoundCb cb, 
      void* usr );
   virtual void removeInterfaceFoundCallback( DtInterfaceFoundCb cb,
      void* usr );


   virtual void sendQueryMsg();

   virtual void sendInfoMsg( const DtRtiConnectionAndConfiguration& connsAndConfigs,
      unsigned memoryPeriod, bool acceptRemoteCommands, bool removal);

   virtual void sendLightweightInfoMsg( const DtRtiConnectionAndConfiguration& connsAndConfigs,
      unsigned memoryPeriod);

   virtual void sendLicServerInfoMsg( const DtLicServerSet& licServers,
      bool removal);

   virtual void sendStartRtiexecMsg( const DtRtiConnectionInfoDataPair& conn,
      const DtRtiConnectionConfigurationInfo& config );

   virtual void sendObserveFederationsMsg( const DtRtiConnectionInfo& conn,
      bool observe, const DtAssistantInfo& assistant = DtAssistantInfo(),
      int compId = -1 );

   virtual void sendObserveRtiExecLogMsg( const DtAssistantInfo& assistant,
      int compId, bool observe );

   virtual void sendObserveRtiexecRspMsg( const MAKRti::DtInetAddr& webSpyAddr,
      int webSpyPort, DtNotifyLevelType notifyLevel, int compId,
      const DtAssistantInfo& destination );

   virtual void sendObserveRtiForwarderMsg( const DtRtiConnectionInfo& conn, 
      bool observe, const DtAssistantInfo& assistant, int compId );

   virtual void sendFederationStateMsg( const DtRtiConnectionInfoDataPair& conn,
      const DtAssistantFederationInfo& federation, bool isRemoval );

   virtual void sendNoFederationMsg( const DtRtiConnectionInfoDataPair& conn );

   virtual void sendFederateResignMsg( const DtAssistantInfo& assistant,
      int compId, int federationHdl, int federateHdl );

   virtual void sendFederationDestroyMsg( const DtAssistantInfo& assistant,
      int compId, int federationHdl );

   virtual void sendRidParamsRequestMsg( const DtAssistantInfo& assistant,
      int compId );

   virtual void sendLogRequestMsg( const DtAssistantInfo& assistant,
      int compId, unsigned maxLogSize );

   virtual bool sendLatencyTestRequestMsg( const DtAssistantInfo& assistant,
      int compId, int federationHdl, int federateHdl, bool runTest,
      bool continuous, bool shouldHalt, bool observing, 
      unsigned int interactionPeriod, unsigned int numInteractions,
      unsigned int payloadBytes );

   virtual void sendNetworkTestEnableMsg( const DtAssistantInfo& assistant,
      int compId, int federationHdl, bool enable );

   virtual void sendRtiexecExitMsg( const DtAssistantInfo& assistant,
      int compId );

   virtual void sendNotifyObserveMsg(bool isObserving);

   virtual void sendNotifyMsg(const MAKRti::DtString& text,
      DtNotifyLevelType notifyLevel, const MAKRti::DtString& sourceName );

   virtual void sendRemovalMsg();

   virtual void sendFederateInfoReqMsg(const DtAssistantInfo& astnt,
      const DtRtiConnectionInfo& conn,
      const MAKRti::DtString& federation = MAKRti::DtString::nullString(),
      unsigned federateHandle = 0 );

   virtual void sendFederateInfoRespMsg(const DtRtiConnectionInfo& conn, 
      std::vector<const DtAssistantFederateInfo*> federates);


   virtual void sendNetStatsObservationRequestMsg(const DtAssistantInfo& astnt, DtAssistantObservationType observationType,
      int compId, bool observe = false, unsigned int interval = 0);

   virtual void sendNetStatsObservationResponseMsg(const DtAssistantInfo& astnt, DtAssistantObservationType observationType,
      int compId, bool observe);
   
   virtual void sendNetStatsStringUpdateReqMsg(const DtAssistantInfo& assistant, int compId, 
      DtAssistantHandleType handletype, const std::set<DtU32>& handles);
   
   virtual void sendNetStatsStringUpdate(const DtAssistantInfo& assistant, int compId, 
      DtAssistantHandleType handletype, const std::vector<DtU32>& objectInstanceHandles, 
      const std::vector<MAKRti::DtString>& objectInstanceNames);

   virtual void forwardNetStatsUpdate(const DtAssistantMsg &msg, const std::set<DtAssistantInfo>& observers);

   virtual void sendFedDisconnectNetStatsObsRespMsg(DtAssistantObservationType observationType, 
      int compId, const std::set<DtAssistantInfo>& observers);

   virtual void sendNetStatsInitStateRequestMsg(const DtAssistantInfo& astnt,
      DtAssistantObservationType observationType, int compId);

   virtual void sendFomTreeData(const DtAssistantInfo& astnt,
      int compId, const std::vector<MAKRti::DtU32>& objectClassHandles,
      const std::vector<MAKRti::DtU32>& parentObjectClassHandles,
      const std::vector<MAKRti::DtString>& objectClassNames,
      const std::vector<MAKRti::DtU32>& interactionClassHandles,
      const std::vector<MAKRti::DtU32>& parentInteractionClassHandles,
      const std::vector<MAKRti::DtString>& interactionClassNames);

   virtual void sendNetStatsAttrStringUpdate(const DtAssistantInfo& astnt,
      int compId, const std::vector<MAKRti::DtU32>& objectClassHandles,
      const std::vector<MAKRti::DtU32>& attributeHandles,
      const std::vector<MAKRti::DtString>& attributeNames,
      const std::vector<MAKRti::DtU32>& parentClassHandles,
      const std::vector<MAKRti::DtU32>& totalObjHandles);
   virtual void sendNetStatsParamStringUpdate(const DtAssistantInfo& astnt,
      int compId, const std::vector<MAKRti::DtU32>& interClassHandles,
      const std::vector<MAKRti::DtU32>& parameterHandles,
      const std::vector<MAKRti::DtString>& parameterNames,
      const std::vector<MAKRti::DtU32>& parentInterHandles,
      const std::vector<MAKRti::DtU32>& totalInterHandles);
   virtual void sendNetStatsAttrParamStringUpdate(const DtAssistantInfo& astnt,
      int compId, const std::vector<MAKRti::DtU32>& objectClassHandles,
      const std::vector<MAKRti::DtU32>& attributeHandles,
      const std::vector<MAKRti::DtString>& attributeNames,
      const std::vector<MAKRti::DtU32>& parentClassHandles,
      const std::vector<MAKRti::DtU32>& totalObjHandles,
      DtAssistantHandleType objInterType, DtAssistantHandleType attrParamType,
      DtAssistantHandleType parentClassType );
   virtual void sendNetStatsFomAttrParamUpdate(const DtAssistantInfo& astnt,
      int compId, DtAssistantHandleType handleType, bool isInit,
      const std::vector<MAKRti::DtU32>& objectClassHandles,
      const std::vector<MAKRti::DtU32>& attributeHandles,
      const std::vector<bool>& attributePub,
      const std::vector<bool>& attributeSub,
      const std::vector<DtTransportType>& attributeTransport,
      const std::vector<DtOrderType>& attributeOrder,
      const std::vector<bool>& objectPub, const std::vector<bool>& objectSub,
      const std::vector<MAKRti::DtU32>& objPubSubHandles );

   virtual void forwardMsg( const DtAssistantMsg& msg, int astntCompId,
      const DtAssistantInfo& dest = DtAssistantInfo() );

   virtual int port() const;

   virtual MAKRti::DtInetAddr ipv4Address() const;

   virtual MAKRti::DtInetAddr ipv6Address() const;

   virtual int id() const;

   virtual const MAKRti::DtInetAddr& currentNetworkInterfaceAddr() const;

   virtual void getMsgStats( unsigned& totalRecv, double& recvPerSecOverall,
      double& recvPerSecCurr, unsigned& totalProc, double& procPerSecOverall,
      double& procPerSecCurr, unsigned& totalSent, double& sentPerSecOverall,
      double& sentPerSecCurr );

   virtual DtU32 maxMsgSize() const;

   void sendMsgToAssistant( const DtAssistantInfo& ifAddr,
      DtAssistantMsg& msg );

#ifdef DtDIAGNOSTIC

   void enableMsgDiagnostics( bool enable );

#endif

protected:

   bool needsProcessing( const DtAssistantMsg& msg );

   bool addSocketsForInterfaces();

   bool readAndProcess( DtTime maxTime );

   void calculateMsgStatistics();

   void sendMsgOnInterface( const MAKRti::DtInetAddr& ifAddr,
      DtAssistantMsg& msg );

   void sendMsg( std::map< MAKRti::DtInetAddr, DtUdpMsgSocket*>::iterator sockIter, DtAssistantMsg& msg );

   void sendMsgToAll( DtAssistantMsg& msg );

   std::auto_ptr<DtAssistantMsg> netRead( DtUdpMsgSocket* sock, int *retCode ) const;
public:

   DtCbInfoStruct(DtInterfaceFoundCb)

protected:

   int myPort;

   MAKRti::DtInetAddr myIpv4Addr;

   MAKRti::DtInetAddr myIpv6Addr;

   int myTtl;

   int myId;

   std::map< MAKRti::DtInetAddr, DtUdpMsgSocket*> mySockets;

   std::map< MAKRti::DtInetAddr, DtUdpMsgSocket*>::iterator mySocketIter;

   MAKRti::DtInetAddr myCurrNetworkInterfaceAddr;

   DtAssistantMsgCbMgr myMsgCbMgr;

   DtAssistantMessageFactory* myMessageFactory;

   DtAssistantDfltMsgFactory myDefaultMessageFactory;

   DtClock myClock;

   DtTime myNextCheckInterfacesTime;

   DtTime myCheckInterfacesInterval;

   DtTime myBeginProcessingTime;

   DtTime myNextStatsTime;

   DtTime myLastStatsTime;

   struct DtPeerMsgStats
   {
      DtPeerMsgStats() :
         numMsgsCurrPeriod(0), numMsgsTotal(0), 
         msgsPerSecLastPeriod(0), msgsPerSecOverall(0) {}

      unsigned numMsgsCurrPeriod;
      unsigned numMsgsTotal;
      double msgsPerSecLastPeriod;
      double msgsPerSecOverall;
   };

   DtPeerMsgStats myReceivedMsgStats;

   DtPeerMsgStats myProcessedMsgStats;

   DtPeerMsgStats mySentMsgStats;

   std::list<DtInterfaceFoundCbInfo> myInterfaceFoundCallbacks;

   static const DtTime theStatisticsInterval;

   bool myUsingIpv4;

   bool myUsingIpv6;

#ifdef DtDIAGNOSTIC
   bool myDiagnosticsEnabled;
#endif
};


#endif // rtiAssistantPeer_H_