connectMgr.h

Go to the documentation of this file.

/*********************************************************************
** Copyright (c) 1998 MaK Technologies, Inc.
** All rights reserved.
*********************************************************************/
/*********************************************************************
** $RCSfile: connectMgr.h,v $ $Revision: 1.78 $ $State: Exp $
*********************************************************************/

#ifndef connectMgr_H_
#define connectMgr_H_



#include "rtiMsConfig.h"
#include "RIDparams.h"
#include "rtiMsgCbMgr.h"
#include "rtiMsgFact.h"
#include "fedWrapChain.h"
#include "dfltMsgFact.h"
#include "connection.h"
#include "metadata.h"

#include <vlutil/vlFedTarget.h> 
#include <vlutil/vlMutex.h>
#include <vlutil/vlStringUtil.h>
#include <vlutil/vlLockfreeMpmcQueue.h>

#if !defined(DtIFSPEC13) && !defined(DtIFSPEC1516) && !defined(DtIFSPEC1516E)
#include <RTI/auth/AuthorizationResult.h>
#endif

class DtRetractInfoList;
class DtRtiMsg;
class DtRtiConnection;
class DtFedAmbWrapper;
class DtRtiMsgQueue;
class DtLogicalTimeFactory;
class DtMessageThrottle;
class DtFederateMgr;
class DtMulticastEntry;
class DtRtiAssistantLrcClient;
class DtPartnerMgr;
class DtConnectMsg;
class DtAuthorizationResultMsg;

#if !defined(DtIFSPEC13) && !defined(DtIFSPEC1516)
namespace RTI_API
{
   class FederateAmbassador;
}
#endif


typedef MAKRti::DtLockfreeMpmcQueue<DtRtiMsg*> DtMessageQueueType;

class DT_DLL_LRC DtConnectionMgr
{
public:
   typedef DtConnectionMgr*
      (*DtConnectionMgrCreator)(DtRIDParameters* p,  bool isFederate, 
      std::shared_ptr<DtRtiAssistantLrcClient> assistantClient);

protected:

   DtConnectionMgr(DtRIDParameters* params, bool isFederate = false, 
      std::shared_ptr<DtRtiAssistantLrcClient> assistantClient = 
      std::shared_ptr<DtRtiAssistantLrcClient>());

public:

   virtual ~DtConnectionMgr();

private:
   
   DtConnectionMgr(DtConnectionMgr const& );

   DtConnectionMgr& operator= (DtConnectionMgr const& );

public:

   virtual int init(DtRIDParameters* params);

   virtual void initParams(DtRIDParameters* params);

   virtual void enableSmartForwarding(bool enableSmartForwarding, bool enableInternalMessageSmartForwarding, int maxNumFederates);

   virtual DtRIDParameters* params();

   virtual void setFederateMgr( DtFederateMgr* fedMgrPtr );

   virtual void shutdown();

   virtual bool isShuttingDown();

#if !defined(DtIFSPEC13) && !defined(DtIFSPEC1516)
   virtual void setFederateAmbassador( RTI_API::FederateAmbassador* fedAmb );
#endif

#if !defined(DtIFSPEC13) && !defined(DtIFSPEC1516) && !defined(DtIFSPEC1516E)
   virtual RTI_API::AuthorizationResult::Code authorizationResult() const;

   virtual const MAKRti::DtString& authorizationMessage() const;
#endif

   virtual bool authorizationIsEnabled() const;

   virtual bool isAuthorized() const;


   virtual int send(const DtRtiMsg& msg, 
                    MAKRti::DtTransportType transport,
                    const MAKRti::DtInetAddr& addr = MAKRti::DtInetAddr::inaddrAny());

   virtual int sendStamped(const DtRtiMsg& msg, 
      MAKRti::DtTransportType transport,
      const MAKRti::DtInetAddr& = MAKRti::DtInetAddr::inaddrAny());

   virtual int sendStampedAnonymous(const DtRtiMsg& msg, 
                                    MAKRti::DtTransportType transport,
                                    const MAKRti::DtInetAddr& addr = MAKRti::DtInetAddr::inaddrAny());

   virtual int sendAndDelete(DtRtiMsg* msg, 
                             MAKRti::DtTransportType transport,
                             const MAKRti::DtInetAddr& addr = MAKRti::DtInetAddr::inaddrAny());
   
   virtual int sendDirectedAndDelete(DtRtiMsg* msg, 
      MAKRti::DtTransportType transport, DtFederateHandle fedHandle,
      const MAKRti::DtInetAddr& addr = MAKRti::DtInetAddr::inaddrAny());

   virtual int sendStampedAndDelete(DtRtiMsg* msg, 
                                    MAKRti::DtTransportType transport,
                                    const MAKRti::DtInetAddr& = MAKRti::DtInetAddr::inaddrAny());

   virtual int sendDirectedStampedAndDelete(DtRtiMsg* msg, 
      MAKRti::DtTransportType transport, DtFederateHandle fedHandle,
      const MAKRti::DtInetAddr& = MAKRti::DtInetAddr::inaddrAny());
   virtual int sendDirectedStampedAndDelete(DtRtiMsg* msg, 
      MAKRti::DtTransportType transport, DtBitMask *sendMask,
      const MAKRti::DtInetAddr& = MAKRti::DtInetAddr::inaddrAny());

   virtual int sendStampedAnonymousAndDelete(DtRtiMsg* msg, 
                                             MAKRti::DtTransportType transport,
                                             const MAKRti::DtInetAddr& addr = MAKRti::DtInetAddr::inaddrAny());
   virtual int sendDirectedStampedAnonymousAndDelete(DtRtiMsg* msg, 
      MAKRti::DtTransportType transport, DtFederateHandle fedHandle,
      const MAKRti::DtInetAddr& addr = MAKRti::DtInetAddr::inaddrAny());

   virtual void sendLoopback(DtRtiMsg* msg);

   virtual bool flush();

   virtual bool drainBacklog( MAKRti::DtTime timeout = 0.0 );

   virtual void activateTransmitDelay();

   virtual bool delayTransmit() const;

   virtual void testTransmitDelay();

   virtual void activateAutoProvideDelay();

   virtual bool delayAutoProvide() const;

   bool allProvideUpdateRequestsDelayed() const;

   virtual void testAutoProvideDelay();
   
   virtual void processThrottledMessages();

   virtual void flushThrottledMessages();

   virtual unsigned long incrementServiceCallCount() const;

   virtual unsigned long serviceCallCount() const;


   virtual void setProcessingTick(bool processingTick);
   virtual bool processingTick() const;


   virtual void setEvokingCallbacks(bool evokingCbs);
   virtual bool evokingCallbacks() const;


   virtual bool tick();

   virtual bool processConnectionsInCallback();

   virtual bool processConnection( DtRtiConnection* conn,
      MAKRti::DtTransportType trans);

   virtual bool processConnections();

   virtual DtRtiMsg* getMessage();

   virtual void addPendingMsg(DtRtiMsg* msg);
   virtual bool processPendingMsg();
   virtual DtRtiMsg* nextPendingMsg();
   virtual void emptyPendingMsgList();
   inline bool isPendingMsgQueueEmpty()
   {
      return myPendingMessages.empty();
   }

   virtual void updateBufferSizes();

   virtual DtNetReadStatus handleMsg( DtRtiMsg& msg );

   virtual DtNetReadStatus processMsg(const DtRtiMsg& msg);
   virtual DtNetReadStatus momProcessMsg(const DtRtiMsg& msg);

   DtFederateMgr* fedMgr();

   DtPartnerMgr* partnerMgr();

   virtual int readFileDescriptor(DtRtiApiTransportationType transport);

#if defined(_WIN32)
   virtual WSAEVENT readFileEvent(DtRtiApiTransportationType transport);
#endif

   virtual void addMsgCallback(DtRtiMsgKind msgKind, DtRtiMsgCbMgr::DtCallbackFcn fcn,
      void *usr, bool isMomCallback=false);
   virtual void removeMsgCallback(DtRtiMsgKind msgKind, DtRtiMsgCbMgr::DtCallbackFcn fcn,
      void *usr, bool isMomCallback=false);
   virtual void addWildcardMsgCallback(DtRtiMsgCbMgr::DtCallbackFcn fcn,
      void *usr, bool isMomCallback=false);
   virtual void removeWildcardMsgCallback(DtRtiMsgCbMgr::DtCallbackFcn fcn,
      void *usr, bool isMomCallback=false);



   virtual DtRtiConnection* reliableConn() const;

   virtual DtRtiConnection* bestEffortConn() const;

   virtual MAKRti::DtTransportType internalTransportType() const;
   
   virtual bool setupSelectParams(DtSelectParam* params);

   virtual bool hasTransport(MAKRti::DtTransportType trans);

   virtual DtRtiMsg* create(DtRtiMsgKind kind);

   virtual void setMsgFactory(DtRtiMsgFactory* fact);
   virtual DtRtiMsgFactory* msgFactory() const;

   virtual void listenToMulticastGroup(const MAKRti::DtInetAddr& addr, const MAKRti::DtInetAddr& netInterface = MAKRti::DtInetAddr::inaddrAny());
   virtual void dropMulticastGroup(const MAKRti::DtInetAddr& addr, const MAKRti::DtInetAddr& netInterface = MAKRti::DtInetAddr::inaddrAny());

   virtual void forceDropMulticastGroup(const MAKRti::DtInetAddr& addr, const MAKRti::DtInetAddr& netInterface = MAKRti::DtInetAddr::inaddrAny());

   virtual void connectFederation(
#if defined(DtIFSPEC13) || defined(DtIFSPEC1516)
      RTI_API::FederateAmbassador* fedAmb,
#endif
      DtLogicalTimeFactory* logicalTimeFactoryPtr,
      MAKRti::DtString fedExName, 
      DtFederateHandle federateHandle,
      int fedExHandle);

   virtual void prepareToDisconnect();

   virtual void disconnectFederation();



   virtual bool lockServiceCall();

   virtual void unlockServiceCall();

   virtual bool serviceCallLocked();

   virtual bool enterServiceCall();

   virtual void exitServiceCall();

   virtual bool inServiceCall();

   virtual RTI_API::FederateAmbassador* fedAmb() const;
   

   virtual void addFedAmbWrapper(MAKRti::DtString const& name, DtFedAmbWrapper* fedAmb);

   virtual bool addFedAmbWrapperAtFront( MAKRti::DtString const& name, DtFedAmbWrapper* fedAmb );

   virtual DtFedAmbWrapper* removeFedAmbWrapper(MAKRti::DtString const& name);

   virtual unsigned long connectionId() const;
   
   virtual DtFederateHandle fedHandle() const;

   virtual unsigned long fedExHandle() const;

   virtual const MAKRti::DtString& fedExName() const;

   virtual void setFederateHandle(DtFederateHandle handle);

   virtual RTI_API::FederateHandle apiFederateHandle(DtFederateHandle handle) const;

   virtual RTI_API::FederateHandle apiFederateHandle() const;

   virtual DtLogicalTimeFactory* logicalTimeFactory(
      DtFederationHandle federationHandle=0) const;

   virtual void addLogicalTimeFactory(DtFederationHandle federationHandle,
      DtLogicalTimeFactory* timeFactory);

   virtual void removeLogicalTimeFactory(DtFederationHandle federationHandle);

   virtual DtRtiMsgQueue* msgQueue();
   virtual void setMsgQueue(DtRtiMsgQueue* msgQueuePtr);

   virtual DtRetractInfoList* retractList();
   virtual void setRetractList(DtRetractInfoList* listPtr);

   virtual bool wait(MAKRti::DtTime periodInSeconds, bool unlockWhileWaiting = false);

   virtual void yield();

   virtual bool saveInProgress() const;
   virtual void setSaveInProgress(bool saveIsInProgress);

   virtual bool restoreInProgress() const;
   virtual void setRestoreInProgress(bool saveIsInProgress);

   virtual bool saveRestoreInProgress() const;

   virtual void setMetadataControl( DtMetadataType type, bool onOff );
   virtual bool isMetadataEnabled( DtMetadataType type );

   virtual void sendShutdownForwarderMsg();

   virtual unsigned long sequenceNumber() const;

   virtual void incrementSequenceNumber();


   virtual bool connectionLost();

   virtual void resetConnectionLost();

protected:


   virtual bool doWait(MAKRti::DtTime period);

   virtual int initConnections();

   virtual bool createBestEffortConn();

   virtual void destroyBestEffortConn();

   virtual bool createRelConn();   

   virtual void destroyRelConn();   

   virtual unsigned int createAncillaryRelConns();

   virtual void destroyAncillaryRelConn(DtRtiConnection* conn);

   virtual void destroyAncillaryRelConns();

   virtual unsigned int ancillaryReliableConnsCount() const;

   virtual bool checkRelConn();

   virtual bool repairFederationConnection();

   virtual bool doConnectionRepair();

   virtual void processReadResult(int readError);

   virtual int sendStampedUtilityFunction( DtRtiMsg* msg,                      
                                    MAKRti::DtTransportType transport,
                                    bool performDelete,
                                    bool isAnonymous,
                                    const MAKRti::DtInetAddr& addr );

   virtual void handleConnectMessage(const DtConnectMsg* message);

   virtual void handleAuthorizationMessage(const DtAuthorizationResultMsg* resultMessage);

public:
 
   static DtConnectionMgr* create(DtRIDParameters* p, bool isFederate = false, 
      std::shared_ptr<DtRtiAssistantLrcClient> assistantClient = 
      std::shared_ptr<DtRtiAssistantLrcClient>());

   static void setCreatorFunction(DtConnectionMgrCreator fn);

   static void setInternalCreatorFunction(DtConnectionMgrCreator fn);

protected:

   DtRtiMsgFactory* myMsgFactory;
   
   DtRtiConnection* myBestEffortConn;

   DtRtiConnection* myPrimaryReliableConn;

   typedef std::list< DtRtiConnection* >   DtRtiConnectionList;
   DtRtiConnectionList                     myReliableConns;

   DtRIDParameters* myParams;

   DtFederateMgr* myFedMgr;

   std::map<MAKRti::DtInetAddr, DtMulticastEntry*> myMulticastGroups;

   DtFedAmbWrapperChain myFedAmbChain;

   DtDfltMsgFactory myDfltMsgFactory;

   DtRtiMsgCbMgr myMsgCbMgr;

   DtRtiMsgCbMgr myMomMsgCbMgr;

   MAKRti::DtTransportType myInternalTransportType;

   bool myAddTransportTypeMetadata;
   bool myAddMcastMetadata;

   std::map<DtFederationHandle, DtLogicalTimeFactory*> myLogicalTimeFactories;

   DtRtiMsgQueue* myMsgQueue;

   DtRetractInfoList* myRetractList;

   DtMessageQueueType myPendingMessages;

   bool myConnectionLost;

   bool mySaveInProgress;

   bool myRestoreInProgress;

   bool myAuthorizationIsEnabled;

#if !defined(DtIFSPEC13) && !defined(DtIFSPEC1516) && !defined(DtIFSPEC1516E)
   RTI_API::AuthorizationResult::Code myAuthorizationResult;
#endif

   MAKRti::DtString myAuthorizationMessage;

   bool myDisconnectPending;

   unsigned long myConnectionId;

   MAKRti::DtString myFedExName;

   DtFederateHandle myFedExHandle;

   DtFederateHandle myFederateHandle;

   unsigned long myReceivedMsgCount;

   unsigned long mySentMsgCount;

   MAKRti::DtList myWorkingMsgId;

   DtMessageThrottle* myMessageThrottle;

   bool myAllProvideUpdateRequestsDelayed;

   DtMutex* myCallbackMutex;

   unsigned int myLockService;

   unsigned int myInService;

   MAKRti::DtClock myClock;

   std::shared_ptr<DtRtiAssistantLrcClient> myAssistantClient;

   bool myIsFederate;

#if defined(_WIN32)
   WSAEVENT myBestEffortEvent;

   WSAEVENT myReliableEvent;
#endif

   unsigned long myVersionConflictCount;
   MAKRti::DtTime myVersionConflictNoticationTimer;

   unsigned long mySizeMismatchCount;
   MAKRti::DtTime mySizeMismatchNoticationTimer;

   DtPartnerMgr* myPartnerMgr;

   mutable unsigned long myServiceCallCount;

   bool myProcessingTick;

   bool myEvokingCallbacks;

   bool myProcessingMessage;

   bool myShutdown;

   bool mySendShuttingDown;
   bool myReceiveShuttingDown;

   unsigned long myTickCount;

protected:
   static DtConnectionMgrCreator theCreator;

   static DtConnectionMgrCreator theInternalCreator;

   const DtRtiApiTransportationType myBestEffortTransportType;
   const DtRtiApiTransportationType myReliableTransportType;
};


class DtMulticastEntry
{
public:
   DtMulticastEntry() :
         addr(MAKRti::DtInetAddr::inaddrAny()),
         netInterface(MAKRti::DtInetAddr::inaddrAny()),
         count(0)
   {};
   DtMulticastEntry(
      MAKRti::DtInetAddr addrVal,
      MAKRti::DtInetAddr netInterfaceVal,
      int countVal=0) :
         addr(addrVal),
         netInterface(netInterfaceVal),
         count(countVal)
   {};

   MAKRti::DtInetAddr addr;

   MAKRti::DtInetAddr netInterface;

   int count;
};

#endif