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_