inOutForwarderPort.h

Go to the documentation of this file.

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

#ifndef DtInOutForwarderPort_H_
#define DtInOutForwarderPort_H_

#include "forwarderPort.h"
#include "routeMap.h"
#include "rtiMsConfig.h"
#include "peerToPeerSockMgr.h"
#include <vlutil/vlTime.h>
#include <udpMsgSocket.h>
#include <map>

class DtRIDParameters;
class DtRouteMap;
class DtTcpSocketMgr__vl__;
class DtForwarderNodeInfoMsg;
class DtMacAddrMsg;

class DT_DLL_FORWARDER DtInOutForwarderPort : public DtForwarderPort
{

protected:

   DtInOutForwarderPort( const DtRIDParameters* params,
      DtBoost::shared_ptr<DtRouteMap> routes,
      const MAKRti::DtInetAddr& host,
      int forwarderPort,
      const MAKRti::DtInetAddr& forwarderAddrToConnectTo  );

public:

   virtual ~DtInOutForwarderPort();

   virtual bool isReady() const;

   virtual DtAddressMsgPair getNextMsg();

   virtual bool getInitializationMsgs( DtForwarderPort::DtSocketSet& socks,
      std::list<DtAddressMsgPair>& msgs, bool printBeDestMetadata);

   virtual bool getInitializationMsg( DtMsgSocket* sock,
      DtAddressMsgPair& msg, bool printBeDestMetadata);

   virtual void sendByTransport( const DtForwarderMsg& msg ) const;

   virtual void sendToAllReliable( const DtForwarderMsg& msg ) const;

   virtual void sendToListReliable( const DtForwarderMsg& msg,
      const DtAddressPortList& destinations ) const;

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

   virtual void updateRoutes();

   // Retrieve and process initialization messages if necessary.
   virtual void processInitializationMessages();

   virtual int checkConnectionStatus( const DtInetAddrAndPort* target = 0 );

   virtual void clearNeededConnections();

   virtual unsigned int abortPendingConnections();

   virtual unsigned int pendingConnectionsAborted();

   virtual DtAddressPortList connections() const;
   
   virtual void listenToMulticastGroup( const MAKRti::DtInetAddr& mcastAddr ){};
   virtual void dropMulticastGroup( const MAKRti::DtInetAddr& mcastAddr ){};

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

   virtual bool flush();   
   
   virtual bool flushOnly();
   
   virtual MAKRti::DtString connectionListToString( const char* separator = " : " ) const;

   virtual bool populateConnectionInformation(
      unsigned int& numForwarderToForwarderConns,
      std::vector<MAKRti::DtString>& forwarderIdentifiers,
      std::vector<MAKRti::DtString>& forwarderConnectionHostNames,
      std::vector<DtInetAddrAndPort>& forwarderConnectionAddrs) const;

public:

   static DtForwarderPort* create( const DtRIDParameters* params,
      const DtBoost::shared_ptr<DtRouteMap> routes,
      const MAKRti::DtInetAddr& host, int forwarderPort,
      const MAKRti::DtInetAddr& additionalForwarderToConnectTo );

   static void setCreatorFunction( DtForwarderPortCreatorFcn creator );


   static void socketAdditionCb( DtTcpMsgSocket* sock, void* usr );
   virtual void socketAdditionCb( DtTcpMsgSocket* sock );

   virtual void sendMacAddrMsg( DtTcpMsgSocket* sock );

   virtual void sendPortMsg( DtTcpMsgSocket* sock );

   static void socketEstablishedCb( DtTcpMsgSocket* sock, void* usr );
   virtual void socketEstablishedCb( DtTcpMsgSocket* sock );

   static void socketRemovalCb( DtTcpMsgSocket* sock, void* usr );
   virtual void socketRemovalCb( DtTcpMsgSocket* sock );

   virtual void processForwarderNodeInfoMsg(const DtForwarderPort::DtAddressMsgPair& msg);   
   virtual void processMacAddrMsg(const DtForwarderPort::DtAddressMsgPair& msg);

   virtual void processPortMsg(const DtForwarderPort::DtAddressMsgPair& msgPair);

   void sendForwarderNodeInfoMsg( DtTcpMsgSocket* sock );
   void sendForwarderNodeInfoMsg();

protected:

   virtual void initializeConnections();

   virtual bool connectToPeer( const DtInetAddrAndPort& addrToConnectTo );
 
   virtual int processLostConnection( DtTcpMsgSocket* sock );

   void connectionCompleted( const DtInetAddrAndPort& addrAndPort,
      DtTcpMsgSocket* sock );


   void addSocketUsingRoutesFile(DtTcpMsgSocket* sock,
      const DtInetAddrAndPort& addrAndPort);

   bool addSocketDynamically(DtTcpMsgSocket* sock);

   //Store / remove connection and update dependencies.
   void addConnection( const DtInetAddrAndPort& newConn, DtTcpMsgSocket* sock );
   void removeConnection( DtAddrToConnMap::iterator pos );

protected:

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

   bool removeFromPendingList( DtTcpMsgSocket* addr );

   void becomeRootForwarderNode();

protected:


   bool                                             myIsReady;
   DtPeerToPeerTcpSockMgr*                          myConnectionMgr;
   DtForwarderPort::DtAddrToConnMap                 myConnections;   
   DtForwarderPort::DtAddrToConnMap::const_iterator myNextConnection;
   DtForwarderPort::DtAddrToConnMap::const_iterator myLastConnection;

   std::map<DtInetAddrAndPort, DtTcpMsgSocket*>     myAddrToSockMap;

   DtForwarderPort::DtSocketSet                     myPendingConnections;
   DtForwarderPort::DtSocketSet                     myPrePendingConnections;
   DtForwarderPort::DtSocketSet                     myPostPendingConnections;
   DtForwarderPort::DtSocketSet                     myUnknownPortConnections;

   std::map<DtInetAddrAndPort, DtString>            myNeededConnections;

   std::map<DtInetAddrAndPort, DtString>            myStillNeededConnections;

   std::map<DtInetAddrAndPort, DtInetAddrAndPort>   myUsedToListeningMap;


   DtForwarderPort::DtSocketList                    myInitiatedConnections;
   DtForwarderPort::DtSocketSet                     myExpiredConnections;
   DtForwarderPort::DtSocketSet                     myDiscardedRemoteSockets;

   DtUdpMsgSocket*                                  myLegacyUdpConnection;
   std::map<DtInetAddrAndPort, unsigned long long>  myMacAddrsOfConnectedForwardersMap;
   bool                                             myIsRootForwarderNode;

   MAKRti::DtClock                                  myClock;
   mutable std::map< DtTcpMsgSocket*, MAKRti::DtTime > mySktSendTimeMap;

   MAKRti::DtInetDevice myHostIf;

   int myCompressionLevel;

protected:

   static DtForwarderPortCreatorFcn theCreator;

};

inline bool DtInOutForwarderPort::updateFederateConnectionId( unsigned long orig, 
                                                              unsigned long final )
{
   return false;
}

#endif