routeMap.h

Go to the documentation of this file.

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

#ifndef DtRouteMap_H_
#define DtRouteMap_H_

#include <vlutil/vlUtil.h>
#include <vlutil/vlString.h>
#include <vlutil/vlFilename.h>
#include <vlutil/vlInetAddr.h>
#include <mtl/mtl.h>
#include <vlutil/vlPrint.h>
#include <mtl/lispEnv.h>
#include <map>
#include <vector>
#include <rtiUtil.h>
#include "rtiMsConfig.h"

class DtRIDParameters;
class MAKRti::DtMtlEnvironment;
class DtRtiForwarderGroup;
struct DtForwarderNodeInfo;

typedef enum DtForwarderGroupInterconnectMethod_enum
{
   DtFwderGroupInterconnectManual,         
   DtFwderGroupInterconnectSinglePortal,   
   DtFwderGroupInterconnectLoadBalance     

} DtForwarderGroupInterconnectMethod;

const int DtUseDefaultForwarderPort = 0;

class DT_DLL_FORWARDER DtRouteMap
{
protected:
   DtRouteMap( const DtRIDParameters* params,
               const MAKRti::DtInetAddr& additionalForwarder );

public:

   virtual void rebuildRoutes();

   virtual bool isConfiguredViaRoutesFile() const;

   // Indicate if no routes have been added
   virtual bool isEmpty() const;

   typedef std::vector< DtInetAddrAndPort > DtAddressPortList;
   typedef std::vector<MAKRti::DtInetAddr>  DtAddressList;
   typedef std::vector< MAKRti::DtString >  DtNodeList;
   typedef std::set< MAKRti::DtInetAddr >   DtInterfaceAddrSet;
   typedef std::vector< DtRtiForwarderGroup* > DtForwarderGroupList;

   virtual ~DtRouteMap();

   virtual DtNodeList        nodeNames() const;
   virtual DtAddressPortList nodeAddresses() const;

   virtual unsigned long nodeIdByAddress( const DtInetAddrAndPort& address ) const;
   virtual unsigned long nodeIdByName( const MAKRti::DtString& name ) const;
   
   // set local nodeId.  Node Id is either statically calculated 
   // when configured via Routes file, or communicated by the 
   // first server forwarder (additionalForwardertoConnectTo) in dynamic configurations.
   virtual void setLocalNodeId(unsigned long newId );
   virtual unsigned long localNodeId() const;

   unsigned long lowestNodeId() const;

   virtual unsigned long consumeNextAvailableNodeId();

   virtual MAKRti::DtString   nodeNameByAddress( const DtInetAddrAndPort& address ) const;
   virtual MAKRti::DtString   nodeHostNameByAddres( const DtInetAddrAndPort& address ) const;
   virtual DtInetAddrAndPort  nodeAddress( const MAKRti::DtString& name ) const;

   // Return our node name.
   virtual const MAKRti::DtString& localNodeName() const;

   virtual DtForwarderGroupList forwarderGroups() const;

   virtual DtRtiForwarderGroup* localGroup() const;

   virtual void setForwarderPort( unsigned int port );
   virtual unsigned int forwarderPort() const;

   virtual inline void setForwarderInterfaceAddr( const MAKRti::DtInetAddr& addr );
   virtual inline const MAKRti::DtInetAddr& forwarderInterfaceAddr() const;

   virtual DtAddressPortList adjacencyList( const DtInetAddrAndPort& node ) const;
   virtual DtAddressPortList adjacencyList( const MAKRti::DtString& node ) const;
   
   virtual void destinationList( DtAddressPortList& destinations, 
                                 const DtInetAddrAndPort& srcNode, 
                                 const DtInetAddrAndPort& linkNode ) const;
   virtual void destinationList( DtAddressPortList& destinations,
                                 const MAKRti::DtString& srcNode, 
                                 const MAKRti::DtString& linkNode ) const;

   virtual void allLinkDestinations( DtAddressPortList& destinations, 
                                     const DtInetAddrAndPort& node ) const;
   virtual void allLinkDestinations( DtAddressPortList& destinations, 
                                     const MAKRti::DtString& node ) const;

   virtual void foreignPortalDestinations( DtAddressPortList& destinations, 
                                           const DtInetAddrAndPort& node ) const;
   virtual void foreignPortalDestinations( DtAddressPortList& destinations, 
                                           const MAKRti::DtString& node ) const;

   virtual void foreignGroupConnections( DtAddressPortList& foreignNodes, 
                                         const DtInetAddrAndPort& node ) const;
   virtual void foreignGroupConnections( DtAddressPortList& foreignNodes, 
                                         const MAKRti::DtString& node ) const;

   virtual void localGroupDestinations( DtAddressPortList& destinations, 
                                        const DtInetAddrAndPort& node ) const;
   virtual void localGroupDestinations( DtAddressPortList& destinations, 
                                        const MAKRti::DtString& node ) const;

   virtual const DtInterfaceAddrSet& getInterfaceAddrs() const;

   virtual bool addForwarder( const MAKRti::DtString& forwarderName,
      const MAKRti::DtInetAddr& forwarderAddr, int port );

   virtual bool addLocalForwarder( const MAKRti::DtString& forwarderName,
      const MAKRti::DtInetAddr& forwarderAddr, int port );

   virtual bool removeForwarder(const DtInetAddrAndPort& addr);

   virtual bool addForwarderConnection( const MAKRti::DtString& forwarderNameA,
      const MAKRti::DtString& forwarderNameB );

   virtual bool addForeignPortalConnection( const MAKRti::DtString& forwarder );

   virtual bool addForeignForwarderConnection( const MAKRti::DtString& forwarder );

   virtual bool addLocalGroupConnection( const MAKRti::DtString& peerForwarder );

   virtual bool addForwarderRoute( const MAKRti::DtString& linkForwarderName,
                                   const MAKRti::DtString& forwarderNameA,
                                   const MAKRti::DtString& forwarderNameB );

   virtual bool addInterfaceAddr( const MAKRti::DtInetAddr& interfaceAddr );

   virtual DtRtiForwarderGroup* addForwarderGroup( const MAKRti::DtString& groupName );

   virtual bool addForwarderToGroup( const MAKRti::DtString& groupName,
                                     const MAKRti::DtString& forwarderName,
                                     const MAKRti::DtString& url, int isPortal);

   virtual bool enableDistributedUdpForwarding( const MAKRti::DtString& forwarder );

   virtual bool isMulticastMonitoringAllowed() const;

   virtual bool enableCompression( const MAKRti::DtString& forwarder, int level );

   virtual bool enableBundling( const MAKRti::DtString& forwarder, int bundleSize );

   virtual int compressionLevel( const DtInetAddrAndPort& forwarder );

   virtual int bundleSize( const DtInetAddrAndPort& forwarder );

   virtual bool isLocalGroupMember( const DtInetAddrAndPort& forwarder ) const;

   virtual DtInetAddrAndPort locatePortal( const DtInetAddrAndPort& targetNode ) const;
   virtual DtInetAddrAndPort locatePortal( const MAKRti::DtString& targetGroupName ) const;

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

   virtual bool forwardRtiexecMsgs() const;

   virtual void concatAddressList( DtAddressPortList& final, const DtAddressPortList& src ) const;
   
   virtual void print() const;

   virtual void knownForwarderNodes(std::set<DtForwarderNodeInfo>& otherNodes) const;

   virtual void addKnownForwarder(const MAKRti::DtInetAddr& addr, unsigned long nodeId,
                                  const MAKRti::DtString& fwName, const MAKRti::DtString& hostname, 
                                  const std::set<DtForwarderNodeInfo>& peers );

   virtual bool updateForwarder(const MAKRti::DtInetAddr& fwAddr, unsigned long fwNodeId,
                                const MAKRti::DtString& fwName, const MAKRti::DtString& fwHostName,
                                const std::set<DtForwarderNodeInfo>& peers );

   virtual void updateForwarderNodeId(const MAKRti::DtInetAddr& fwAddr, unsigned long fwNodeId);


   virtual void addAddressAlias(const MAKRti::DtInetAddr& knownAddr,
      const MAKRti::DtInetAddr& aliasAddr);

   inline const MAKRti::DtInetAddr& addressAlias(const MAKRti::DtInetAddr& knownAddr) const;

public:
   typedef DtBoost::shared_ptr<DtRouteMap> (*DtRouteMapCreatorFcn)( 
      const DtRIDParameters*, const MAKRti::DtInetAddr& );
   
   static DtBoost::shared_ptr<DtRouteMap> create( const DtRIDParameters* params,
      const MAKRti::DtInetAddr& fwAddrToConnectTo );
   
   static void setCreatorFunction( DtRouteMapCreatorFcn creator );

protected:

   virtual void registerRoutesFileParams();
   
   virtual void setupDefaultRoutes();
   virtual void setupSinglePortalRoutes();
   virtual void setupLoadBalanceRoutes();
   
   virtual void openRoutesFile();

   virtual void initializeInterfaceList();

   virtual DtForwarderGroupInterconnectMethod setGroupInterconnectMethod( MAKRti::DtString methodString );

   DtRouteMap();
   DtRouteMap( const DtRouteMap& orig );

   virtual void setupNodeName(); 
   DtRouteMap& operator=( const DtRouteMap& orig );

   virtual void setupDestinationsMap();

protected:

   const DtRIDParameters* myParams;
   MAKRti::DtFilename             myRoutesFileName;
   MAKRti::DtMtlEnvironment*      myEnv;
   MAKRti::DtString               myNodeName;
   MAKRti::DtInetAddr             myRoutesFileNodeAddress;
   unsigned long          myNodeId;
   mutable unsigned long  myLowestNodeId;
   unsigned long          myNextAvailableNodeId;
   mutable bool           myLowestNodeIdIsDirty;
   bool                   myNodeIdIsSet;
   bool                   myIsConfiguredViaRoutesFile;

   int myDistributedForwarderPort;

   MAKRti::DtInetAddr myForwarderInterfaceAddr;

   DtForwarderGroupInterconnectMethod myGroupInterconnectMethod;

   DtNodeList myMulticastEnabledForwarderList;

   typedef std::map< DtInetAddrAndPort, MAKRti::DtString > DtConnectionAddrToNameMap;   
   typedef std::map< MAKRti::DtString, DtInetAddrAndPort > DtConnectionNameToAddrMap;
   typedef std::pair< std::vector< MAKRti::DtString >, DtAddressPortList > DtConnectionList;
   typedef std::map< DtInetAddrAndPort, DtConnectionList > DtAddrToConnectionListMap;
   typedef std::multimap< DtInetAddrAndPort, DtInetAddrAndPort > DtSrcToDestinationsMap;
   typedef std::map< DtInetAddrAndPort, DtInetAddrAndPort > DtDestinationToLinkMap;
   typedef std::map< MAKRti::DtInetAddr, MAKRti::DtInetAddr > DtInetAddrAliasMap;
   typedef std::map< DtInetAddrAndPort, DtSrcToDestinationsMap > DtRoutingTable;
   typedef std::map< MAKRti::DtString, DtRtiForwarderGroup* > DtGroupNameTable;
   typedef std::map< DtInetAddrAndPort, DtRtiForwarderGroup* > DtForwarderGroupConnectionTable;
   typedef std::map< MAKRti::DtString, int > DtForwarderCompressionMap;
   typedef std::map< MAKRti::DtString, int > DtForwarderBundlingMap;


   std::set<DtForwarderNodeInfo> myKnownForwarderNodes;
   
   DtConnectionNameToAddrMap myNameToAddrMap;
   DtConnectionAddrToNameMap myAddrToNameMap;
   DtAddrToConnectionListMap myConnectionsByAddr;
   DtAddrToConnectionListMap myForeignPortalConnections;
   DtAddrToConnectionListMap myForeignGroupConnections;
   DtAddrToConnectionListMap myLocalGroupConnections;
   DtRoutingTable            myRoutesByLinkAddrMap;
   DtDestinationToLinkMap    myLinksByDestinationMap;
   DtInterfaceAddrSet        myNicAddrs;

   DtRtiForwarderGroup*            myLocalForwarderGroup;   
   DtForwarderGroupList            myForwarderGroups;       
   DtGroupNameTable                myGroupNameTable;
   DtForwarderGroupConnectionTable myConnectionToGroupMap;

   DtInetAddrAliasMap        myInetAddrAliases;

   DtForwarderCompressionMap myCompressedForwarders;

   DtForwarderBundlingMap myBundledForwarders;

protected:

   
   static DtRouteMapCreatorFcn theCreator;

   
};

inline void DtRouteMap::setForwarderInterfaceAddr( const MAKRti::DtInetAddr& addr )
{
   myForwarderInterfaceAddr = addr;
}

inline const MAKRti::DtInetAddr& DtRouteMap::forwarderInterfaceAddr() const
{
   return myForwarderInterfaceAddr;
}

inline const MAKRti::DtInetAddr& DtRouteMap::addressAlias(const MAKRti::DtInetAddr& addr) const
{
   DtInetAddrAliasMap::const_iterator iter = myInetAddrAliases.find(addr);
   if(iter == myInetAddrAliases.end())
   {
      return MAKRti::DtInetAddr::inaddrAny();
   }
   else
   {
      return iter->second;
   }
}



#endif //! DtRouteMap_H_