Line data    Source code

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