feature_flags.h

Go to the documentation of this file.

/*
 * Copyright (c) 2020 Juniper Networks, Inc. All rights reserved.
 */
 
#ifndef BASE_FEATURE_FLAGS_H_
#define BASE_FEATURE_FLAGS_H_
 
#include <string>
 
#include <boost/function.hpp>
#include <boost/scoped_ptr.hpp>
 
#include <base/logging.h>
#include <base/sandesh/process_info_constants.h>
#include <base/sandesh/process_info_types.h>
 
#include "rapidjson/document.h"
#include "rapidjson/stringbuffer.h"
#include "rapidjson/writer.h"
 
#include <tbb/mutex.h>
 
namespace process {
 
class FlagManager;
 
 
struct FlagState {
    enum Type {
      EXPERIMENTAL = 0,
      ALPHA = 1,
      BETA = 2,
      IN_PROGRESS = 3,
      PRE_RETIRED = 4,
      UNKNOWN = 5
    };
 
    static std::string ToString(Type state) {
        switch (state) {
        case EXPERIMENTAL:
            return "Experimental";
        break;
        case ALPHA:
            return "Alpha";
        break;
        case BETA:
            return "Beta";
        break;
        case IN_PROGRESS:
            return "In Progress";
        break;
        case PRE_RETIRED:
            return "Pre Retired";
        break;
        case UNKNOWN:
            return "Unknown";
        break;
        }
        return "Unknown";
    }
 
    static Type FromString(const std::string& type) {
        if (type == "Experimental") {
            return EXPERIMENTAL;
        }
        if (type == "Alpha") {
            return ALPHA;
        }
        if (type == "Beta") {
            return BETA;
        }
        if (type == "In-Progress") {
            return IN_PROGRESS;
        }
        if (type == "Pre-Retired") {
            return PRE_RETIRED;
        }
        if (type == "Unknown") {
            return UNKNOWN;
        }
        return UNKNOWN;
    }
};
 
struct FlagContext {
    FlagContext(const std::string& description, const std::string &val)
        : desc(description),
          value(val) {}
 
    bool operator == (const FlagContext & rhs) const {
      if (!(desc == rhs.desc))
        return false;
      if (!(value == rhs.value))
        return false;
      return true;
    }
    bool operator != (const FlagContext &rhs) const {
      return !(*this == rhs);
    }
 
    std::string desc;
    std::string value;
};
 
typedef std::vector<FlagContext> ContextVec;
typedef std::vector<FlagContext>::const_iterator context_iterator;
typedef std::vector<FlagContext>::size_type context_size;
 
class FlagConfig {
public:
    FlagConfig(const std::string &name,const std::string &version,
               bool enabled, FlagState::Type state, ContextVec &context_infos)
        : name_(name),
          version_(version),
          enabled_(enabled),
          state_(state),
          context_infos_(context_infos) {}
    ~FlagConfig() {};
 
    void set_name(const std::string &val) { name_ = val; }
    const std::string& name() const { return name_; }
 
    void set_version(const std::string &val) { version_ = val; }
    const std::string& version() const { return version_; }
 
    void set_enabled(bool val) { enabled_ = val; }
    bool enabled() const { return enabled_; }
 
    void set_state(const FlagState::Type &val) { state_ = val; }
    const FlagState::Type& state() const { return state_; }
 
    void set_context_infos(const ContextVec &val) { context_infos_ = val; }
    const ContextVec &context_infos() const { return context_infos_; }
 
    bool operator == (const FlagConfig &rhs) const {
        if (!(name_ == rhs.name_))
            return false;
        if (!(version_ == rhs.version_))
            return false;
        if (!(enabled_ == rhs.enabled_))
            return false;
        if (!(state_ == rhs.state_))
            return false;
        if (!(context_infos_ == rhs.context_infos_))
            return false;
        return true;
    }
 
    bool operator != (const FlagConfig &rhs) const {
        return !(*this == rhs);
    }
private:
    std::string name_;
    std::string version_;
    bool enabled_;
    FlagState::Type state_;
    ContextVec context_infos_;
};
 
typedef std::vector<FlagConfig> FlagConfigVec;
typedef std::vector<FlagConfig>::const_iterator flag_cfg_itr;
 
 
class Flag
{
public:
    typedef boost::function<void ()> FlagStateCb;
 
    Flag(FlagManager *manager, const std::string &name,
         const std::string &description, bool enabled,
         ContextVec &context_infos);
 
    Flag(const Flag& flag, FlagStateCb callback);
 
    Flag() {};
    ~Flag();
 
    void InvokeCb();
 
    void set_name(const std::string &val) { name_ = val; }
    const std::string& name() const { return name_; }
 
    void set_description(const std::string &val) { description_ = val; }
    const std::string& description() const { return description_; }
 
    void set_enabled(const bool val) { enabled_ = val; }
    const bool enabled() const { return enabled_; }
 
    void set_context_infos(const ContextVec &val) { context_infos_ = val; }
    const ContextVec &context_infos() const { return context_infos_; }
 
    bool operator == (const Flag &rhs) const;
    bool operator != (const Flag &rhs) const;
private:
    std::string name_;
    std::string description_;
    bool enabled_;
    ContextVec context_infos_;
 
    FlagStateCb flag_state_cb_;
    FlagManager *manager_;
 
    DISALLOW_COPY_AND_ASSIGN(Flag);
};
 
typedef std::vector<Flag> FlagVec;
 
class FlagConfigManager {
public:
    static FlagConfigManager* GetInstance();
    static void Initialize(const string &build_info);
 
    void Set(const std::string &name,const std::string &version_info,
             bool enabled, FlagState::Type state, ContextVec &context_infos);
 
    void Unset(const std::string &name);
 
private:
    // Singleton
    FlagConfigManager(FlagManager *manager);
 
    static boost::scoped_ptr<FlagConfigManager> instance_;
    FlagManager *flag_manager_;
 
    static std::string version_;
 
    DISALLOW_COPY_AND_ASSIGN(FlagConfigManager);
};
 
// ----------------------------------------------------------------------------
 
class FlagUveManager {
public:
    static FlagUveManager* GetInstance();
 
    void SendUVE();
 
    FlagConfigVec GetFlagInfos(bool lock) const;
private:
    friend class ConnectionStateManager;
 
    typedef boost::function<void (void)> FlagUveCb;
 
    // Singleton
    FlagUveManager(FlagManager *manager, FlagUveCb send_uve_cb);
    static void CreateInstance(FlagManager *mgr, FlagUveCb send_uve_cb);
 
    static boost::scoped_ptr<FlagUveManager> instance_;
    FlagManager *flag_manager_;
    FlagUveCb flag_uve_cb_;
 
    DISALLOW_COPY_AND_ASSIGN(FlagUveManager);
};
 
// ----------------------------------------------------------------------------
 
class FlagManager
{
public:
    static FlagManager* GetInstance();
 
    void Set(const std::string &name, const std::string &version, bool enabled,
             FlagState::Type state, ContextVec &context_infos);
 
    void Unset(const std::string &name);
 
    bool IsFlagEnabled(const std::string &name, bool default_state,
                       const ContextVec &c_vec) const;
 
    void ClearFlags();
 
    size_t GetFlagMapCount() const;
 
    void Register(Flag *flag);
 
    void Unregister(const Flag *flag);
 
    bool IsRegistered(const Flag *flag) const;
 
    size_t GetIntMapCount() const;
 
    FlagConfigVec GetFlagInfos() const;
 
private:
    friend class Flag;
    friend class FlagConfigManager;
    friend class FlagUveManager;
 
    FlagManager() {
    }
 
    typedef std::map<std::string, FlagConfig> FlagMap;
    typedef std::map<std::string, FlagConfig>::iterator flag_map_itr;
    typedef std::map<std::string, FlagConfig>::const_iterator flag_map_citr;
 
    typedef std::multimap<std::string, Flag *> InterestMap;
    typedef std::multimap<std::string, Flag *>::const_iterator int_map_const_itr;
    typedef std::multimap<std::string, Flag *>::iterator int_map_itr;
 
    // ==============================================================
 
    FlagConfigVec GetFlagInfosUnlocked() const;
 
    static boost::scoped_ptr<FlagManager> instance_;
    mutable tbb::mutex mutex_;
 
    FlagMap flag_map_; // map for capability-list/user-config
    InterestMap int_map_; // map for storing module interest
 
    DISALLOW_COPY_AND_ASSIGN(FlagManager);
};
 
 
} // namespace process
#endif // BASE_FEATURE_FLAGS_H_