forwarderNode.h

Go to the documentation of this file.

/*******************************************************************************
** Copyright (c) 2005 MaK Technologies, Inc.
** All rights reserved.
*******************************************************************************/
/*******************************************************************************
** $RCSfile: forwarderNode.h,v $ $Revision: 1.14 $ $State: Exp $
*******************************************************************************/

#ifndef DtForwarderNode_H_
#define DtForwarderNode_H_

#include "forwarderPort.h"
#include "messageProcessor.h"
#include "rtiMsConfig.h"

#include <vlutil/vlConfig.h>
#include <vlutil/vlUtil.h>
#include <vlutil/vlTime.h>
#include <metadata.h>


class DtRIDParameters;
class DtRouteMap;
class DtForwarderFaultProcessor;
class DtRtiMsg;
class DtInOutForwarderPort;


typedef void (*DtTickCbFn)(void* usr);


class DtTickCallbackInfo
{
public:
   DtTickCallbackInfo(DtTickCbFn fn, void* data, MAKRti::DtTime interval) :
      myData(data), myFn(fn), myInterval(interval), myNextExecutionTime(0) {}

      bool operator<(const DtTickCallbackInfo& other) const
      {
         return ( myData < other.myData ||
            myData == other.myData && myFn < other.myFn );
      }

      void* myData;
      DtTickCbFn myFn;
      MAKRti::DtTime myInterval;
      MAKRti::DtTime myNextExecutionTime;
};

#define DtForwarderIntfcIn    0x01
#define DtForwarderIntfcOut   0x02
#define DtForwarderIntfcLan   0x04


class DT_DLL_FORWARDER DtForwarderNode
{
public:
   
   typedef DtMessageProcessor< DtInetAddrAndPort, DtForwarderPort::DtForwarderMsg >
      DtForwarderMessageProcessor;

protected:

   DtForwarderNode( const DtRIDParameters* params,
                    DtForwarderMessageProcessor* toOutProcessor,
                    DtForwarderMessageProcessor* toLanProcessor,
                    int forwarderPort,
                    const MAKRti::DtInetEndpoint& forwarderAddrToConnectTo,
                    bool writeToPipeWhenReady );

public:

   virtual ~DtForwarderNode();

   virtual int tick( double maxTime = 0.0f );


   virtual void addTickCallback(DtTickCbFn fn, void* usr, MAKRti::DtTime interval );
   virtual void removeTickCallback(DtTickCbFn fn, void* usr );

   virtual inline bool ready() const;

   virtual inline const DtRIDParameters* params() const;

   virtual inline std::shared_ptr<DtRouteMap> routeMap() const;

   virtual inline DtForwarderPort*  inPort() const;
   virtual inline DtForwarderPort* lanPort() const;
   virtual inline DtForwarderPort* outPort() const;

   virtual void selectParams( MAKRti::DtSelectParamWithWrite& selectParams );

   virtual unsigned long localNodeId() const;

   const DtInetAddrAndPort& localNodeAddress() const;

   virtual MAKRti::DtString localNodeName() const;

   virtual MAKRti::DtString localNodeHostName() const;

   virtual void processInToLanMsg( DtForwarderPort::DtAddressMsgPair& msg );
   
   virtual void processInToOutMsg( DtForwarderPort::DtAddressMsgPair& msg );

   virtual void processLanToOutMsg( DtForwarderPort::DtAddressMsgPair& msg );

   virtual void sendToLanPort( DtForwarderPort::DtAddressMsgPair& msg );
   
   virtual void sendToOutPort( DtForwarderPort::DtAddressMsgPair& msg );

   virtual void sendToOutPort( DtForwarderPort::DtAddressMsgPair& msg,
                               const DtRouteMap::DtAddressPortList& destinations );

   virtual void registerOutPortProcessor( DtForwarderMessageProcessor::Filter* processor );
   virtual void unregisterOutPortProcessor( DtForwarderMessageProcessor::Filter* processor );
   
   virtual void registerLanPortProcessor( DtForwarderMessageProcessor::Filter* processor );
   virtual void unregisterLanPortProcessor( DtForwarderMessageProcessor::Filter* processor ); 
   
   virtual void packageAndSendReliable( DtRtiMsg& msg, unsigned int sendViaIntfc );
   virtual void packageAndSendReliable( DtRtiMsg& msg, unsigned int sendViaIntfc,
                                        const DtRouteMap::DtAddressPortList& destinations );

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

   virtual void lanPortListenToMulticastGroup( const MAKRti::DtInetAddr& mcastAddr );
   virtual void lanPortDropMulticastGroup( const MAKRti::DtInetAddr& mcastAddr );

   virtual bool lanPortUpdateFederateConnectionId( unsigned long orig, 
                                                   unsigned long final );

   virtual DtInetAddrAndPort nextForwarderOnRoute( const DtInetAddrAndPort& target );
   virtual DtInetAddrAndPort nextForwarderOnRoute( const MAKRti::DtString& targetGroupName );

   virtual DtInetAddrAndPort rootForwarder();

   virtual DtInetAddrAndPort nextHopToExec();

   virtual void abortPendingConnections();

   virtual unsigned int abortedConnections();

   virtual bool connectionInformation(
      unsigned int& numForwarderToForwarderConns,
      std::vector<MAKRti::DtString>& forwarderIdentifiers,
      std::vector<MAKRti::DtString>& forwarderConnectionHostNames,
      std::vector<DtInetAddrAndPort>& forwarderConnectionAddrs,
      unsigned int& numForwarderExecConns,
      unsigned int& numForwarderClientConns,
      std::vector<MAKRti::DtString>& clientConnectionHostNames,
      std::vector<MAKRti::DtInetAddr>& clientConnectionAddrs);

   virtual void continueWithoutUnconnectedFws();

   virtual void connectForwarder(const DtString& host, const MAKRti::DtInetAddr& ipAddress, int port);


   static int forwarderToForwarderConnectionChanged( 
      const MAKRti::DtString& connName, const MAKRti::DtString& hostName,
      unsigned int oldConnID, unsigned int newConnID,
      const DtInetAddrAndPort& connAddr, void* usr );
   virtual int forwarderToForwarderConnectionChanged( 
      const MAKRti::DtString& connName, const MAKRti::DtString& hostName,
      unsigned int oldConnID, unsigned int newConnID, const DtInetAddrAndPort& connAddr );

public:

   typedef DtForwarderNode* (*DtForwarderNodeCreatorFcn)( const DtRIDParameters*,
                                                          DtForwarderMessageProcessor*,
                                                          DtForwarderMessageProcessor*,
                                                          int forwarderPort,
                                                          MAKRti::DtInetEndpoint forwarderAddrToConnectTo,
                                                          bool writeToPipeWhenReady );
   
   static DtForwarderNode* create( const DtRIDParameters* params,
                                   DtForwarderMessageProcessor* toOutProcessor,
                                   DtForwarderMessageProcessor* toLanProcessor,
                                   int forwarderPort,
                                   MAKRti::DtInetEndpoint forwarderAddrToConnectTo,
                                   bool writeToPipeWhenReady );
   
   static void setCreatorFunction( DtForwarderNodeCreatorFcn creator );

   static int newInPortConnection( const MAKRti::DtString& connName, const MAKRti::DtString& hostName,
      unsigned int connID, const std::pair<DtInetAddrAndPort, DtInetAddrAndPort>& connAddr, void* usr);
   static int newOutPortConnection( const MAKRti::DtString& connName, const MAKRti::DtString& hostName,
      unsigned int connID, const std::pair<DtInetAddrAndPort, DtInetAddrAndPort>& connAddr, void* usr);
   static int lostInPortConnection( const MAKRti::DtString& connName, const MAKRti::DtString& hostName,
      unsigned int connID, const std::pair<DtInetAddrAndPort, DtInetAddrAndPort>& connAddr, void* usr);
   static int lostOutPortConnection( const MAKRti::DtString& connName, const MAKRti::DtString& hostName,
      unsigned int connID, const std::pair<DtInetAddrAndPort, DtInetAddrAndPort>& connAddr, void* usr);
   static void inOutForwarderPortReady( unsigned long forwarderNodeId, void* usr);


protected:

   DtForwarderNode();
   DtForwarderNode( const DtForwarderNode& orig );
   DtForwarderNode& operator=( const DtForwarderNode& orig );


   int refreshConnections();

   void writeMessageToPipe( const MAKRti::DtString& msg );

   int newInPortConnection( const MAKRti::DtString& connName, const MAKRti::DtString& hostName,
      unsigned int connID, const std::pair<DtInetAddrAndPort, DtInetAddrAndPort>& connAddr);
   int newOutPortConnection( const MAKRti::DtString& connName, const MAKRti::DtString& hostName,
      unsigned int connID, const std::pair<DtInetAddrAndPort, DtInetAddrAndPort>& connAddr);
   int lostInPortConnection( const MAKRti::DtString& connName, const MAKRti::DtString& hostName,
      unsigned int connID, const std::pair<DtInetAddrAndPort, DtInetAddrAndPort>& connAddr);
   int lostOutPortConnection( const MAKRti::DtString& connName, const MAKRti::DtString& hostName,
      unsigned int connID, const std::pair<DtInetAddrAndPort, DtInetAddrAndPort>& connAddr);
   void inOutForwarderPortReady(unsigned long forwarderNodeId);

   
protected:

   const DtRIDParameters* myParams;

   DtForwarderMessageProcessor* myToOutMsgProcessor;
   DtForwarderMessageProcessor* myToLanMsgProcessor;

   DtForwarderFaultProcessor* myFaultProcessor;

   DtClock myClock;

   bool myIsReady;
   
   std::shared_ptr<DtRouteMap> myRoutes;

   DtForwarderPort* myRemoteInputPort;

   DtForwarderPort* myRemoteOutputPort;

   DtInOutForwarderPort* myRemoteInOutPort;

   DtForwarderPort* myLocalPort;

   DtInetAddrAndPort myLocalNodeAddress;

   bool myAddTcpDestinationListMetadata;
   bool myAddUdpDestinationListMetadata;
   bool myAddTransportTypeMetadata;
   bool myAddMcastMetadata;

   bool myWriteToPipeWhenReady;

   static const MAKRti::DtInetAddr theFirstHostInetAddr;

   std::list<DtTickCallbackInfo> myTickCallbacks;

protected:

   static DtForwarderNodeCreatorFcn theCreator;
   
};


inline bool DtForwarderNode::ready() const
{
   return myIsReady;
}

inline const DtRIDParameters* DtForwarderNode::params() const
{
   return myParams;
}

inline std::shared_ptr<DtRouteMap> DtForwarderNode::routeMap() const
{
   return myRoutes;
}

inline DtForwarderPort* DtForwarderNode::inPort() const
{
   return myRemoteInputPort;
}

inline DtForwarderPort* DtForwarderNode::lanPort() const
{
   return myLocalPort;
}

inline DtForwarderPort* DtForwarderNode::outPort() const
{
   return myRemoteOutputPort;
}

inline unsigned int DtForwarderNode::abortedConnections()
{
   return (outPort()->pendingConnectionsAborted() + lanPort()->pendingConnectionsAborted());
}

#endif