LCOV - code coverage report
Current view: top level - dns/mgr - dns_mgr.h (source / functions) Hit Total Coverage
Test: OpenSDN C/C++ coverage (all TARGET_SET jobs) Lines: 9 16 56.2 %
Date: 2026-11-09 02:10:49 Functions: 1 5 20.0 %
Legend: Lines: hit not hit

          Line data    Source code
       1             : /*
       2             :  * Copyright (c) 2013 Juniper Networks, Inc. All rights reserved.
       3             :  * Copyright Contributors to the OpenSDN project
       4             :  */
       5             : 
       6             : #ifndef __dns_manager_h__
       7             : #define __dns_manager_h__
       8             : 
       9             : #include <mutex>
      10             : 
      11             : #include <base/index_allocator.h>
      12             : #include <mgr/dns_oper.h>
      13             : #include <bind/named_config.h>
      14             : #include <cfg/dns_config.h>
      15             : #include <config_client_manager.h>
      16             : 
      17             : class DB;
      18             : class DBGraph;
      19             : struct VirtualDnsConfig;
      20             : struct VirtualDnsRecordConfig;
      21             : 
      22             : class DnsManager {
      23             : public:
      24             :     static const int max_records_per_sandesh = 100;
      25             :     static const int kEndOfConfigCheckTime = 1000; // msec
      26             :     static const uint16_t kMaxRetransmitCount = 6;
      27             :     static const uint16_t kPendingRecordReScheduleTime = 1000; //msec
      28             :     static const uint16_t kNamedLoWaterMark = 8192; //pow(2,13);
      29             :     static const uint16_t kNamedHiWaterMark = 32768;  //pow(2,15);
      30             :     static const uint16_t kMaxIndexAllocator = 65535;
      31             : 
      32             :     struct PendingList {
      33             :         uint16_t xid;
      34             :         std::string view;
      35             :         std::string zone;
      36             :         DnsItems items;
      37             :         BindUtil::Operation op;
      38             :         uint32_t retransmit_count;
      39             : 
      40          44 :         PendingList(uint16_t id, const std::string &v, const std::string &z,
      41             :                     const DnsItems &it, BindUtil::Operation o,
      42          44 :                     uint32_t recount = 0) {
      43          44 :             xid = id;
      44          44 :             view = v;
      45          44 :             zone = z;
      46          44 :             items = it;
      47          44 :             op = o;
      48          44 :             retransmit_count = recount;
      49          44 :         }
      50             :     };
      51             :     typedef std::map<uint16_t, PendingList> PendingListMap;
      52             :     typedef std::pair<uint16_t, PendingList> PendingListPair;
      53             : 
      54             :     typedef std::map<uint16_t, PendingList> DeportedPendingListMap;
      55             :     typedef std::pair<uint16_t, PendingList> DeportedPendingListPair;
      56             : 
      57             :     DnsManager();
      58             :     virtual ~DnsManager();
      59             :     void Initialize(DB *config_db, DBGraph *config_graph,
      60             :                     const std::string& named_config_dir,
      61             :                     const std::string& named_config_file,
      62             :                     const std::string& named_log_file,
      63             :                     const std::string& rndc_config_file,
      64             :                     const std::string& rndc_secret,
      65             :                     const std::string& named_max_cache_size,
      66             :                     const uint16_t named_max_retransmissions,
      67             :                     const uint16_t named_retransmission_interval);
      68             :     void Shutdown();
      69             :     void DnsView(const DnsConfig *config, DnsConfig::DnsConfigEvent ev);
      70             :     void DnsPtrZone(const Subnet &subnet, const VirtualDnsConfig *vdns,
      71             :                     DnsConfig::DnsConfigEvent ev);
      72             :     void DnsRecord(const DnsConfig *config, DnsConfig::DnsConfigEvent ev);
      73             :     void HandleUpdateResponse(uint8_t *pkt, std::size_t length);
      74             :     DnsConfigManager &GetConfigManager() { return config_mgr_; }
      75             :     bool SendUpdate(BindUtil::Operation op, const std::string &view,
      76             :                     const std::string &zone, DnsItems &items);
      77             :     void SendRetransmit(uint16_t xid, BindUtil::Operation op,
      78             :                         const std::string &view, const std::string &zone,
      79             :                         DnsItems &items, uint32_t retranmit_count);
      80             :     void UpdateAll();
      81             :     void StartEndofConfigTimer();
      82             :     void BindEventHandler(BindStatus::Event ev);
      83             : 
      84             :     template <typename ConfigType>
      85             :     void ProcessConfig(IFMapNodeProxy *proxy, const std::string &name,
      86             :                        DnsConfigManager::EventType event);
      87             :     void ProcessAgentUpdate(BindUtil::Operation event, const std::string &name,
      88             :                             const std::string &vdns_name, const DnsItem &item);
      89             :     bool IsBindStatusUp() { return bind_status_.IsUp(); }
      90             : 
      91             :     void set_config_manager(ConfigClientManager *config_manager) {
      92             :         config_client_manager_ = config_manager;
      93             :     }
      94           0 :     ConfigClientManager* get_config_manager() { return config_client_manager_; }
      95           0 :     bool IsEndOfConfig() {
      96           0 :         if (config_client_manager_)
      97           0 :             return (config_client_manager_->GetEndOfRibComputed());
      98           0 :         return (true);
      99             :     }
     100           0 :     PendingListMap GetDeportedPendingListMap() { return dp_pending_map_; }
     101           0 :     void ClearDeportedPendingList() { dp_pending_map_.clear(); }
     102             :     void NotifyThrottledDnsRecords();
     103             :     void DnsConfigMsgHandler(const std::string &key, const std::string &context) const;
     104             :     void VdnsRecordsMsgHandler(const std::string &key, const std::string &context, bool show_all = false) const;
     105             :     void BindPendingMsgHandler(const std::string &key, const std::string &context) const;
     106             :     void VdnsServersMsgHandler(const std::string &key, const std::string &context) const;
     107             :     void MakeSandeshPageReq(PageReqData *req, VirtualDnsConfig::DataMap &vdns, VirtualDnsConfig::DataMap::iterator vdns_it,
     108             :                         VirtualDnsConfig::DataMap::iterator vdns_iter, const std::string &key, const std::string &req_name) const;
     109             : private:
     110             :     friend class DnsBindTest;
     111             :     friend class DnsManagerTest;
     112             : 
     113             :     bool SendRecordUpdate(BindUtil::Operation op,
     114             :                           const VirtualDnsRecordConfig *config);
     115             :     bool PendingDone(uint16_t xid);
     116             :     bool ResendRecordsinBatch();
     117             :     bool AddPendingList(uint16_t xid, const std::string &view,
     118             :                                     const std::string &zone, const DnsItems &items,
     119             :                                     BindUtil::Operation op);
     120             :     void UpdatePendingList(const std::string &view,
     121             :                                        const std::string &zone,
     122             :                                        const DnsItems &items,
     123             :                                        BindUtil::Operation op);
     124             :     void DeletePendingList(uint16_t xid);
     125             :     void ClearPendingList();
     126             :     void PendingListViewDelete(const VirtualDnsConfig *config);
     127             :     bool CheckZoneDelete(ZoneList &zones, PendingList &pend);
     128             :     void PendingListZoneDelete(const Subnet &subnet,
     129             :                                const VirtualDnsConfig *config);
     130             :     void PendingListReverseDelete(const VirtualDnsConfig *config);
     131             :     /* Pending Record List transmitted to named */
     132             :     void StartPendingTimer(int);
     133             :     void CancelPendingTimer();
     134             :     bool PendingTimerExpiry();
     135             : 
     136             :     void CancelEndofConfigTimer();
     137             :     bool EndofConfigTimerExpiry();
     138             : 
     139             :     void NotifyAllDnsRecords(const VirtualDnsConfig *config,
     140             :                              DnsConfig::DnsConfigEvent ev);
     141             :     void NotifyReverseDnsRecords(const VirtualDnsConfig *config,
     142             :                                  DnsConfig::DnsConfigEvent ev, bool notify);
     143             :     inline uint16_t GetTransId();
     144             :     void ResetTransId(uint16_t);
     145             :     inline bool CheckName(std::string rec_name, std::string name);
     146             : 
     147             :     std::mutex mutex_;
     148             :     BindStatus bind_status_;
     149             :     DnsConfigManager config_mgr_;
     150             :     ConfigClientManager *config_client_manager_;
     151             :     static uint16_t g_trans_id_;
     152             :     PendingListMap pending_map_;
     153             :     DeportedPendingListMap dp_pending_map_;
     154             :     Timer *pending_timer_;
     155             :     Timer *end_of_config_check_timer_;
     156             :     bool end_of_config_;
     157             :     uint32_t record_send_count_;
     158             :     uint16_t named_max_retransmissions_;
     159             :     uint16_t named_retransmission_interval_;
     160             :     uint16_t named_lo_watermark_;
     161             :     uint16_t named_hi_watermark_;
     162             :     bool named_send_throttled_;
     163             :     WorkQueue<uint16_t> pending_done_queue_;
     164             :     IndexAllocator idx_;
     165             : 
     166             :     DISALLOW_COPY_AND_ASSIGN(DnsManager);
     167             : };
     168             : 
     169             : #endif // __dns_manager_h__

Generated by: LCOV version 1.14