WsfCommProtocolOSPF.hpp

Go to the documentation of this file.

// ****************************************************************************
// CUI
//
// The Advanced Framework for Simulation, Integration, and Modeling (AFSIM)
//
// Copyright 2018 Infoscitex, a DCS Company. All rights reserved.
//
// The use, dissemination or disclosure of data in this file is subject to
// limitation or restriction. See accompanying README and LICENSE for details.
// ****************************************************************************
 
#ifndef WSFCOMMPROTOCOLOSPF_HPP
#define WSFCOMMPROTOCOLOSPF_HPP
 
#include "wsf_export.h"
 
#include <memory>
 
#include "UtCallbackHolder.hpp"
#include "WsfCommRouterProtocolInterface.hpp"
#include "WsfEvent.hpp"
#include "WsfRandomVariable.hpp"
 
namespace wsf
{
namespace comm
{
namespace router
{

class OSPF_Area;

class WSF_EXPORT ProtocolOSPF : public ProtocolInterface
{
public:
   using ProtocolVector = std::vector<ProtocolOSPF*>;

   using AreaVector = std::vector<std::shared_ptr<OSPF_Area>>;

   using AreaGraphMap = std::map<Address, std::unique_ptr<graph::Graph>>;


   static constexpr const char* cOSPF_ALL_HELLO   = "OSPF_ALL_HELLO";
   static constexpr const char* cOSPF_ALL_DROP    = "OSPF_ALL_DROP";
   static constexpr const char* cOSPF_ALL_DR_DROP = "OSPF_ALL_DR_DROP";
   static constexpr const char* cOSPF_ALL_DR_ADD  = "OSPF_ALL_DR_ADD";
 
   enum class RouterAreaType : size_t
   {
      cNONE,   
      cNORMAL, 
      cABR,    
      cASBR    
   };
 
   static ProtocolOSPF* Find(const Router& aParent);
   static ProtocolOSPF* FindOrCreate(Router& aParent);
 
   ProtocolOSPF()           = default;
   ~ProtocolOSPF() override = default;
   ProtocolOSPF(const ProtocolOSPF& aSrc);


   WsfComponent* CloneComponent() const override;
   const int*    GetComponentRoles() const override;
   void*         QueryInterface(int aRole) override;
   int           GetPriority() const override;
   ProtocolOSPF* Clone() const override;
   const char*   GetScriptClassName() const override { return "WsfCommProtocolOSPF"; }


   void Setup() override;
   bool ProcessInput(UtInput& aInput) override;
   bool Initialize(double aSimTime) override;


   bool Send(double aSimTime, Router::SendData& aData) override;
 
   bool Receive(double aSimTime, const Address& aReceivingInterface, Message& aMessage, bool& aOverrideForward) override;
 
   std::vector<Address> Routing(double         aSimTime,
                                const Address& aSendingInterface,
                                size_t&        aHopNumber,
                                double&        aCost,
                                const Message& aMessage) override;



   graph::Graph* GetGraph() const override;
   graph::Graph* GetGraph(const Address& aArea);
   bool          ShouldPropagateTruth() const override { return false; }
   void          SetGraph(const Address& aArea, std::unique_ptr<graph::Graph> aGraph);
 
   AreaVector&                 GetAreas() { return mAreas; }
   OSPF_Area*                  GetArea(const Address& aAreaAddress);
   const std::vector<Address>& GetInputAreas() const { return mInputAreas; }
   const Address&              GetInputBackbone() const { return mInputBackbone; }
   bool                        IsSetup() const { return mSetup; }
   void                        SetSetup(bool aSetup) { mSetup = aSetup; }
   RouterAreaType              GetAreaType() const { return mAreaType; }
   void                        SetAreaType(RouterAreaType aType) { mAreaType = aType; }
   size_t                      GetPriorityDR() const { return mPriorityDR; }

   Comm* GetPriorityInterface(const std::string aNetwork) const;

   void PlatformInitialized(double aSimTime, WsfPlatform* aPlatformPtr);

   struct LinkStateData
   {
      Address     mLocalInterface{};
      Address     mRemoteInterface{};
      std::string mLocalNetwork{};
      std::string mRemoteNetwork{};
      double      mLastUpdateTime{};
   };

   using LinkStateMap = std::map<Address, std::vector<LinkStateData>>;
   using LinkStateIt  = LinkStateMap::iterator;
 
protected:
   ProtocolVector GetAllOSPF();

   std::set<std::shared_ptr<OSPF_Area>> GetAllAreas();

   void SetRouterRoleType(ProtocolOSPF& aProtocol);

   void VerifyBackboneConnections(const AreaVector& aAreas);

   void InitializeLinkState(const AreaVector& aAreas, graph::Graph& aGraph);

   Address InterfaceInContiguousOSPF(const Address&     aDestinationInterface,
                                     ProtocolOSPF&      aProtocol,
                                     std::set<Address>& aCheckedAreas);

   std::set<ProtocolOSPF*> GetAllASBR(ProtocolOSPF& aProtocol, std::set<Address>& aCheckedAreas);



   std::vector<Address> RouteToBackbone(ProtocolOSPF& aProtocol, const Address& aSendingAddress, double& aCost, size_t& aHops);

   std::vector<Address> RouteFromBackbone(ProtocolOSPF&  aProtocol,
                                          const Address& aSendingAddress,
                                          const Address& aDestinationAddress,
                                          double&        aCost,
                                          size_t&        aHops);

   std::pair<std::vector<Address>, Comm*> RouteExternallyASBR(const Message& aMessage);

   std::vector<Address> MyMessage(Message& aMessage) const;
 

   void ScheduleEvent(std::unique_ptr<WsfEvent> aEvent) const;


   void SendHello(double aSimTime);
   void ReceiveHello(double                      aSimTime,
                     const Address&              aReceiverAddress,
                     const std::vector<Address>& aValidAreas,
                     Message&                    aMessage);
 
   void SendDR_GraphAdd(double aSimTime, const Address& aReceivingInterface, const std::vector<Address>& aTraceRoute);
   void ReceiveDR_GraphAdd(double                      aSimTime,
                           const Address&              aReceivingInterface,
                           const std::vector<Address>& aValidAreas,
                           Message&                    aMessage);
   void SendDR_GraphDrop(double             aSimTime,
                         const Address&     aReceivingInterface,
                         const Address&     aDroppedInterface,
                         const std::string& aDroppedInterfaceNetwork);
   void ReceiveDR_GraphDrop(double                      aSimTime,
                            const Address&              aReceivingInterface,
                            const std::vector<Address>& aValidAreas,
                            Message&                    aMessage);
 

   void DR_GraphAdd(graph::Graph& aGraph, const Address& aReceivingInterface, const std::vector<Address>& aTraceRoute);

   void DR_GraphDrop(graph::Graph&      aGraph,
                     const Address&     aArea,
                     const Address&     aDroppedInterface,
                     const std::string& aDroppedNetwork);
 

   void TimeoutUpdate(double aSimTime, bool aCalledFromEvent);
 
 
   void           AddLinkState(const Address& aAreaAddress, const LinkStateData& aData);
   LinkStateData* FindLinkState(const Address& aAreaAddress, const Address& aLocalAddress, const Address& aRemoteAddress);

   std::vector<LinkStateData> FindLinkState(const Address& aAreaAddress, const Address& aRemoteAddress);
   bool RemoveLinkState(const Address& aAreaAddress, const Address& aLocalAddress, const Address& aRemoteAddress);
 
   const LinkStateMap& GetLinkStates() const { return mLinkStates; }
   LinkStateMap&       GetLinkStates() { return mLinkStates; }
 
 
private:
   Address              mInputBackbone{};
   std::vector<Address> mInputAreas{};
   AreaVector           mAreas{};
   size_t               mPriorityDR{std::numeric_limits<size_t>::max()};
   RouterAreaType       mAreaType{RouterAreaType::cNORMAL};

   WsfRandomVariable mHelloInterval{10.0, WsfRandomVariable::cNON_NEGATIVE};

   WsfRandomVariable mHoldTimer{40.0, WsfRandomVariable::cNON_NEGATIVE};

   WsfRandomVariable mRandomInterval{0.0, 0.1, WsfRandomVariable::cNON_NEGATIVE};

   bool mSetup{false};

   AreaGraphMap mGraph{};

   LinkStateMap mLinkStates{};

   std::shared_ptr<int> mContext{nullptr};

   UtCallbackHolder mCallbacks{};
};

class WSF_EXPORT OSPF_Area
{
public:
   using ProtocolVector = std::vector<ProtocolOSPF*>;

   using ProtocolMapDR = std::map<std::string, ProtocolOSPF*>;

   using RemovedNetworkInterfaces = std::map<std::string, std::vector<Address>>;
 
   OSPF_Area()          = default;
   virtual ~OSPF_Area() = default;
 
   void                      SetAddress(const Address& aAddress) { mArea = aAddress; }
   void                      SetBackbone(bool aIsBackbone) { mIsBackbone = aIsBackbone; }
   const Address&            GetAddress() const { return mArea; }
   bool                      IsBackbone() const { return mIsBackbone; }
   RemovedNetworkInterfaces& GetRemovedInterfacesDR() { return mRemovedInterfacesDR; }
   void                      AddRemovedInterfaceDR(Comm* aInterfacePtr);
   RemovedNetworkInterfaces& GetRemovedInterfacesBDR() { return mRemovedInterfacesBDR; }
   void                      AddRemovedInterfaceBDR(Comm* aInterfacePtr);
 
   const ProtocolMapDR& GetDRs() const { return mMapDR; }
   const ProtocolMapDR& GetBDRs() const { return mMapBDR; }
 
   ProtocolVector& GetProtocols() { return mProtocols; }

   ProtocolVector GetProtocols(const std::string& aNetwork);
 
   std::set<std::string>& GetNetworks() { return mNetworks; }

   void SetDRs();

   void PlatformDeleted(double aSimTime, WsfPlatform* aPlatformPtr);

   void InitializeGraphData(graph::Graph& aGraph);

   std::vector<std::pair<Comm*, ProtocolOSPF*>> GetInterfaces();

   void ElectionDR(double aSimTime, const std::string aNetwork, const Address& aArea, bool aElectionDR);
 
   void InitializeCallbacks(WsfSimulation& aSim);

   void SetNetworks();
 
private:
   ProtocolMapDR            mMapDR{};
   ProtocolMapDR            mMapBDR{};
   Address                  mArea{};
   bool                     mIsBackbone{false};
   ProtocolVector           mProtocols{};
   std::set<std::string>    mNetworks{};
   RemovedNetworkInterfaces mRemovedInterfacesDR{};
   RemovedNetworkInterfaces mRemovedInterfacesBDR{};

   UtCallbackHolder mCallbacks{};
};
 
} // namespace router
} // namespace comm
} // namespace wsf
 
WSF_DECLARE_COMPONENT_ROLE_TYPE(wsf::comm::router::ProtocolOSPF, cWSF_COMPONENT_COMM_ROUTER_PROTOCOL_OSPF);
 
#endif