Line data    Source code

       1             : /*
       2             :  * Copyright (c) 2013 Juniper Networks, Inc. All rights reserved.
       3             :  */
       4             : 
       5             : #ifndef SRC_BGP_IPEER_H_
       6             : #define SRC_BGP_IPEER_H_
       7             : 
       8             : #include <atomic>
       9             : #include "bgp/bgp_proto.h"
      10             : #include "base/address.h"
      11             : 
      12             : class DBTablePartBase;
      13             : class BgpPath;
      14             : class BgpRoute;
      15             : class BgpServer;
      16             : class BgpTable;
      17             : class IPeer;
      18             : class PeerCloseManager;
      19             : 
      20             : class IPeerUpdate {
      21             : public:
      22    12625126 :     virtual ~IPeerUpdate() { }
      23        8975 :     virtual bool send_ready() const { return true; }
      24             : 
      25             :     // Printable name
      26             :     virtual const std::string &ToString() const = 0;
      27             : 
      28             :     // Send an update.
      29             :     // Returns true if the peer can send additional messages.
      30             :     virtual bool SendUpdate(const uint8_t *msg, size_t msgsize) = 0;
      31       10472 :     virtual bool SendUpdate(const uint8_t *msg, size_t msgsize,
      32             :                             const std::string *msg_str) {
      33       10472 :         return SendUpdate(msg, msgsize);
      34             :     }
      35             : 
      36             :     // Flush any accumulated updates.
      37             :     // Returns true if the peer can send additional messages.
      38       10115 :     virtual bool FlushUpdate() { return true; }
      39             : };
      40             : 
      41             : class IPeerDebugStats {
      42             : public:
      43             :     struct ProtoStats {
      44       32086 :         ProtoStats() {
      45       32086 :             total = 0;
      46       32086 :             open = 0;
      47       32086 :             keepalive = 0;
      48       32086 :             notification = 0;
      49       32086 :             update = 0;
      50       32086 :             close = 0;
      51       32086 :         }
      52             :         uint64_t total;
      53             :         uint64_t open;
      54             :         uint64_t keepalive;
      55             :         uint64_t notification;
      56             :         uint64_t update;
      57             :         uint64_t close;
      58             :     };
      59             : 
      60             :     struct ErrorStats {
      61       15599 :         ErrorStats() {
      62       15599 :             connect_error = 0;
      63       15599 :             connect_timer = 0;
      64       15599 :             hold_timer = 0;
      65       15599 :             open_error = 0;
      66       15599 :             update_error = 0;
      67       15599 :         }
      68             :         uint64_t connect_error;
      69             :         uint64_t connect_timer;
      70             :         uint64_t hold_timer;
      71             :         uint64_t open_error;
      72             :         uint64_t update_error;
      73             :     };
      74             : 
      75             :     struct RxErrorStats {
      76         175 :         RxErrorStats() {
      77         175 :             inet6_bad_xml_token_count = 0;
      78         175 :             inet6_bad_prefix_count = 0;
      79         175 :             inet6_bad_nexthop_count = 0;
      80         175 :             inet6_bad_afi_safi_count = 0;
      81         175 :         }
      82             :         uint64_t inet6_bad_xml_token_count;
      83             :         uint64_t inet6_bad_prefix_count;
      84             :         uint64_t inet6_bad_nexthop_count;
      85             :         uint64_t inet6_bad_afi_safi_count;
      86             :     };
      87             : 
      88             :     struct RxRouteStats {
      89         175 :         RxRouteStats() {
      90         175 :             total_path_count = 0;
      91         175 :             primary_path_count = 0;
      92         175 :         }
      93             :         uint64_t total_path_count;
      94             :         uint64_t primary_path_count;
      95             :     };
      96             : 
      97             :     struct UpdateStats {
      98       32436 :         UpdateStats() {
      99       32436 :             end_of_rib = 0;
     100       32436 :             total = 0;
     101       32436 :             reach = 0;
     102       32436 :             unreach = 0;
     103       32436 :         }
     104             :         uint64_t end_of_rib;
     105             :         uint64_t total;
     106             :         uint64_t reach;
     107             :         uint64_t unreach;
     108             :     };
     109             : 
     110             :     struct SocketStats {
     111         543 :         SocketStats() {
     112         543 :             calls = 0;
     113         543 :             bytes = 0;
     114         543 :             blocked_count = 0;
     115         543 :             blocked_duration_usecs = 0;
     116         543 :         }
     117             :         uint64_t calls;
     118             :         uint64_t bytes;
     119             :         uint64_t blocked_count;
     120             :         uint64_t blocked_duration_usecs;
     121             :     };
     122             : 
     123       20403 :     virtual ~IPeerDebugStats() { }
     124             : 
     125             :     // Reset all counters
     126             :     virtual void Clear() = 0;
     127             :     // Printable name
     128             :     virtual std::string ToString() const = 0;
     129             :     // Previous State of the peer
     130             :     virtual std::string last_state() const = 0;
     131             :     // Last state change At
     132             :     virtual std::string last_state_change_at() const = 0;
     133             :     // Last error on this peer
     134             :     virtual std::string last_error() const = 0;
     135             :     // Last Event on this peer
     136             :     virtual std::string last_event() const = 0;
     137             :     // When was the Last
     138             :     virtual std::string last_flap() const = 0;
     139             :     // Total number of flaps
     140             :     virtual uint64_t num_flaps() const = 0;
     141             : 
     142             :     virtual void GetRxProtoStats(ProtoStats *stats) const = 0;
     143             :     virtual void GetRxRouteUpdateStats(UpdateStats *stats) const = 0;
     144             :     virtual void GetRxSocketStats(SocketStats *stats) const = 0;
     145             :     virtual void GetRxErrorStats(RxErrorStats *stats) const = 0;
     146             :     virtual void GetRxRouteStats(RxRouteStats *stats) const = 0;
     147             : 
     148             :     virtual void GetTxProtoStats(ProtoStats *stats) const = 0;
     149             :     virtual void GetTxRouteUpdateStats(UpdateStats *stats) const = 0;
     150             :     virtual void GetTxSocketStats(SocketStats *stats) const = 0;
     151             : 
     152             :     virtual void UpdateTxReachRoute(uint64_t count) = 0;
     153             :     virtual void UpdateTxUnreachRoute(uint64_t count) = 0;
     154             : };
     155             : 
     156             : // Interface for PeerCloseManager clients
     157             : class IPeerClose {
     158             : public:
     159             :     typedef std::set<Address::Family> Families;
     160             : 
     161      225089 :     virtual ~IPeerClose() { }
     162             :     virtual void Close(bool graceful) = 0;
     163             :     virtual bool IsCloseGraceful() const = 0;
     164             :     virtual bool IsCloseLongLivedGraceful() const = 0;
     165             :     virtual void CustomClose() = 0;
     166             :     virtual void CloseComplete() = 0;
     167             :     virtual void Delete() = 0;
     168             :     virtual void GracefulRestartStale() = 0;
     169             :     virtual void LongLivedGracefulRestartStale() = 0;
     170             :     virtual void GracefulRestartSweep() = 0;
     171             :     virtual void GetGracefulRestartFamilies(Families *) const = 0;
     172             :     virtual int GetGracefulRestartTime() const = 0;
     173             :     virtual int GetLongLivedGracefulRestartTime() const = 0;
     174             :     virtual void GetLongLivedGracefulRestartFamilies(Families *) const = 0;
     175             :     virtual bool IsReady() const = 0;
     176             :     virtual IPeer *peer() const = 0;
     177             :     virtual void ReceiveEndOfRIB(Address::Family family) = 0;
     178             :     virtual void MembershipRequestCallbackComplete() = 0;
     179             :     virtual const char *GetTaskName() const = 0;
     180             :     virtual int GetTaskInstance() const = 0;
     181             :     virtual PeerCloseManager *GetManager() const = 0;
     182             :     virtual void UpdateRouteStats(Address::Family family,
     183             :         const BgpPath *old_path, uint32_t path_flags) const = 0;
     184             : };
     185             : 
     186             : class IPeer : public IPeerUpdate {
     187             : public:
     188       36792 :     virtual ~IPeer() { }
     189             :     // Printable name
     190             :     virtual const std::string &ToString() const = 0;
     191             :     virtual const std::string &ToUVEKey() const = 0;
     192             :     virtual BgpServer *server() = 0;
     193             :     virtual BgpServer *server() const = 0;
     194             :     virtual IPeerClose *peer_close() const = 0;
     195             :     virtual IPeerClose *peer_close() = 0;
     196             :     virtual IPeerDebugStats *peer_stats() = 0;
     197             :     virtual const IPeerDebugStats *peer_stats() const = 0;
     198             :     virtual bool IsReady() const = 0;
     199             :     virtual bool IsXmppPeer() const = 0;
     200             :     virtual bool IsRouterTypeBGPaaS() const = 0;
     201             :     //
     202             :     // Whether the peer must register to a table
     203             :     // before it could push the route to VRF.
     204             :     // Control is mostly required in MockPeer in unit tests.
     205             :     //
     206             :     virtual bool IsRegistrationRequired() const = 0;
     207             :     virtual void Close(bool graceful) = 0;
     208             :     virtual BgpProto::BgpPeerType PeerType() const = 0;
     209             :     virtual uint32_t bgp_identifier() const = 0;
     210             :     virtual const std::string GetStateName() const = 0;
     211             :     virtual void UpdateTotalPathCount(int count) const = 0;
     212             :     virtual int GetTotalPathCount() const = 0;
     213             :     virtual bool IsAs4Supported() const = 0;
     214             :     virtual void ProcessPathTunnelEncapsulation(const BgpPath *path,
     215             :         BgpAttr *attr, ExtCommunityDB *extcomm_db,
     216             :         const BgpTable *table) const = 0;
     217             :     virtual const std::vector<std::string> GetDefaultTunnelEncap(
     218             :         const Address::Family family) const = 0;
     219             :     virtual void UpdatePrimaryPathCount(int count,
     220             :         Address::Family family = Address::UNSPEC) const = 0;
     221             :     virtual int GetPrimaryPathCount() const = 0;
     222             :     virtual void MembershipRequestCallback(BgpTable *table) = 0;
     223             :     virtual bool MembershipPathCallback(DBTablePartBase *tpart,
     224             :         BgpRoute *route, BgpPath *path) = 0;
     225             :     virtual bool CanUseMembershipManager() const = 0;
     226             :     virtual bool IsInGRTimerWaitState() const = 0;
     227             :     virtual void UpdateCloseRouteStats(Address::Family family,
     228             :         const BgpPath *old_path, uint32_t path_flags) const = 0;
     229       37226 :     virtual bool CheckSplitHorizon(uint32_t cluster_id = 0,
     230             :             uint32_t ribout_cid = 0) const {
     231       37226 :         return PeerType() == BgpProto::IBGP;
     232             :     }
     233             : };
     234             : 
     235             : #endif  // SRC_BGP_IPEER_H_