Line data    Source code

       1             : /*
       2             :  * Copyright (c) 2016 Juniper Networks, Inc. All rights reserved.
       3             :  */
       4             : 
       5             : #ifndef config_db_client_h
       6             : #define config_db_client_h
       7             : 
       8             : #include <string>
       9             : #include <vector>
      10             : #include <atomic>
      11             : #include <tbb/spin_rw_mutex.h>
      12             : 
      13             : #include "base/regex.h"
      14             : #include "base/timer.h"
      15             : #include "base/task_annotations.h"
      16             : #include "config_client_manager.h"
      17             : 
      18             : struct ConfigClientOptions;
      19             : struct ConfigDBConnInfo;
      20             : struct ConfigDBUUIDCacheEntry;
      21             : struct ConfigDBFQNameCacheEntry;
      22             : 
      23             : class ObjectProcessReq {
      24             :  public:
      25      129610 :     ObjectProcessReq(std::string oper,
      26             :                      std::string uuid_str,
      27      129610 :                      std::string value) : oper_(oper),
      28      129610 :     uuid_str_(uuid_str), value_(value) {
      29      129610 :     }
      30             : 
      31             :     std::string oper_;
      32             :     std::string uuid_str_;
      33             :     std::string value_; // obj_type for Cassandra/json_value for ETCD
      34             : 
      35             :  private:
      36             :     DISALLOW_COPY_AND_ASSIGN(ObjectProcessReq);
      37             : };
      38             : 
      39             : /*
      40             :  * This is the base class for interactions with a database that stores the user
      41             :  * configuration.
      42             :  */
      43             : class ConfigDbClient {
      44             : public:
      45             :     // wait time before retrying in seconds
      46             :     static const uint64_t kInitRetryTimeUSec = 5000000;
      47             : 
      48             :     // Number of requests to handle in one config reader task execution
      49             :     static const int kMaxRequestsToYield = 512;
      50             : 
      51             :     // Number of config entries to read in one read request
      52             :     static const int kNumEntriesToRead = 4096;
      53             : 
      54             :     ConfigDbClient(ConfigClientManager *mgr,
      55             :                    EventManager *evm,
      56             :                    const ConfigClientOptions &options);
      57             :     virtual ~ConfigDbClient();
      58             : 
      59             :     typedef std::pair<std::string, std::string> ObjTypeFQNPair;
      60             : 
      61             :     const std::string& config_db_user() const;
      62             :     const std::string& config_db_password() const;
      63             :     const std::vector<std::string>& config_db_ips() const;
      64             :     int GetFirstConfigDbPort() const;
      65             :     virtual void PostShutdown() = 0;
      66             :     virtual void InitDatabase() = 0;
      67             :     virtual void EnqueueUUIDRequest(std::string uuid_str, std::string obj_type,
      68             :                                     std::string oper) = 0;
      69             : 
      70             :     virtual bool UUIDToObjCacheShow(
      71             :         const std::string &search_string, int inst_num,
      72             :         const std::string &last_uuid, uint32_t num_entries,
      73             :         std::vector<ConfigDBUUIDCacheEntry> *entries) const = 0;
      74             : 
      75             :     virtual bool IsListOrMapPropEmpty(const std::string &uuid_key,
      76             :                                    const std::string &lookup_key) = 0;
      77             : 
      78             :      // FQ Name Cache
      79             :     virtual void AddFQNameCache(const std::string &uuid,
      80             :                    const std::string &obj_type, const std::string &fq_name);
      81             :     virtual std::string FindFQName(const std::string &uuid) const;
      82             :     virtual void InvalidateFQNameCache(const std::string &uuid);
      83             :     virtual void PurgeFQNameCache(const std::string &uuid);
      84           0 :     virtual void ClearFQNameCache() {
      85           0 :         fq_name_cache_.clear();
      86           0 :     }
      87             :     ObjTypeFQNPair UUIDToFQName(const std::string &uuid_str,
      88             :                              bool deleted_ok = true) const;
      89             : 
      90             :     virtual bool UUIDToFQNameShow(
      91             :         const std::string &search_string, const std::string &last_uuid,
      92             :         uint32_t num_entries,
      93             :         std::vector<ConfigDBFQNameCacheEntry> *entries) const;
      94             : 
      95             :     virtual std::string uuid_str(const std::string &uuid);
      96      251957 :     virtual std::string GetUUID(const std::string &key) const {
      97      251957 :         return key;
      98             :     }
      99             : 
     100             :     virtual void InitConnectionInfo();
     101             :     virtual void UpdateConnectionInfo(bool success,
     102             :                                       bool force);
     103             :     virtual void GetConnectionInfo(ConfigDBConnInfo &status) const;
     104             : 
     105             :     virtual bool IsTaskTriggered() const;
     106             :     virtual void StartWatcher();
     107             : 
     108      272282 :     ConfigClientManager *mgr() { return mgr_; }
     109             :     const ConfigClientManager *mgr() const { return mgr_; }
     110             : 
     111             : protected:
     112             :    // UUID to FQName mapping
     113             :     struct FQNameCacheType {
     114       23642 :         FQNameCacheType(std::string in_obj_type, std::string in_fq_name)
     115       23642 :             : obj_type(in_obj_type), fq_name(in_fq_name), deleted(false) {
     116       23642 :         }
     117             :         std::string obj_type;
     118             :         std::string fq_name;
     119             :         bool deleted;
     120             :     };
     121             :     typedef std::map<std::string, FQNameCacheType> FQNameCacheMap;
     122             : 
     123             :     virtual void FillFQNameCacheInfo(
     124             :                           const std::string &uuid,
     125             :                           FQNameCacheMap::const_iterator it,
     126             :                           ConfigDBFQNameCacheEntry *entry) const;
     127             : 
     128        1115 :     virtual const int GetMaxRequestsToYield() const {
     129        1115 :         return kMaxRequestsToYield;
     130             :     }
     131           0 :     virtual const uint64_t GetInitRetryTimeUSec() const {
     132           0 :         return kInitRetryTimeUSec;
     133             :     }
     134             : 
     135             :     virtual uint32_t GetNumReadRequestToBunch() const;
     136           6 :     EventManager *event_manager() { return  evm_; }
     137             : 
     138             : private:
     139             :     ConfigClientManager *mgr_;
     140             :     EventManager *evm_;
     141             :     std::string config_db_user_;
     142             :     std::string config_db_password_;
     143             :     std::vector<std::string> config_db_ips_;
     144             :     std::vector<int> config_db_ports_;
     145             :     FQNameCacheMap fq_name_cache_;
     146             :     mutable tbb::spin_rw_mutex rw_mutex_;
     147             :     std::atomic<bool> client_connection_up_;
     148             :     std::atomic<uint64_t> connection_status_change_at_;
     149             : };
     150             : 
     151             : class ObjectCacheEntry {
     152             :  public:
     153       23487 :     ObjectCacheEntry(uint64_t last_read_tstamp)
     154       23487 :         : last_read_tstamp_(last_read_tstamp) {
     155       23487 :     }
     156             : 
     157       23487 :     ~ObjectCacheEntry() {};
     158             : 
     159       10709 :     virtual void SetLastReadTimeStamp(uint64_t ts) {
     160       10709 :         last_read_tstamp_ = ts;
     161       10709 :     }
     162          36 :     virtual uint64_t GetLastReadTimeStamp() const {
     163          36 :         return last_read_tstamp_;
     164             :     }
     165             : 
     166       34172 :     virtual void SetFQName(std::string fq_name) {
     167       34172 :         fq_name_ = fq_name;
     168       34172 :     }
     169          68 :     virtual const std::string &GetFQName() const {
     170          68 :         return fq_name_;
     171             :     }
     172             : 
     173       34172 :     virtual void SetObjType(std::string obj_type) {
     174       34172 :         obj_type_ = obj_type;
     175       34172 :     }
     176          76 :     virtual const std::string &GetObjType() const {
     177          76 :         return obj_type_;
     178             :     }
     179             : 
     180             :  private:
     181             :     std::string obj_type_;
     182             :     std::string fq_name_;
     183             :     uint64_t last_read_tstamp_;
     184             : };
     185             : #endif  // config_db_client_h