feature_flags.cc

Go to the documentation of this file.

/*
 * Copyright (c) 2019 Juniper Networks, Inc. All rights reserved.
 */
 
#include <string>
#include <base/feature_flags.h>
#include <assert.h>
#include <map>
#include <iostream>
#include <sstream>
 
using namespace std;
using contrail_rapidjson::Document;
using contrail_rapidjson::Value;
 
namespace process {
 
bool debug_ = true;
 
#define FLAG_DEBUG(args...) if (process::debug_) LOG(DEBUG, ##args)
#define FLAG_WARN(args...) if (process::debug_) LOG(WARN, ##args)
#define FLAG_ERROR(args...) if (process::debug_) LOG(ERROR, ##args)
 
Flag::Flag(FlagManager *manager, const string &name,
           const string &description, bool enabled,
           ContextVec &context_infos)
    : name_(name),
      description_(description),
      enabled_(enabled),
      context_infos_(context_infos),
      flag_state_cb_(NULL),
      manager_(manager)
{
    manager_->Register(this);
}
 
Flag::Flag(const Flag& flag, FlagStateCb callback)
    : name_(flag.name_),
      description_(flag.description_),
      enabled_(flag.enabled_),
      context_infos_(flag.context_infos_),
      flag_state_cb_(callback),
      manager_(flag.manager_)
{
    manager_->Register(this);
}
 
Flag::~Flag() {
    if (manager_) {
        manager_->Unregister(this);
    }
}
 
void Flag::InvokeCb() {
    if (!flag_state_cb_.empty()) {
        flag_state_cb_();
    }
}
 
bool Flag::operator == (const Flag &rhs) const {
    if (!(name_ == rhs.name_))
        return false;
    if (!(description_ == rhs.description_))
        return false;
    if (!(enabled_ == rhs.enabled_))
        return false;
    if (!(context_infos_ == rhs.context_infos_))
        return false;
    return true;
}
 
bool Flag::operator != (const Flag &rhs) const {
  return !(*this == rhs);
}
 
boost::scoped_ptr<FlagUveManager> FlagUveManager::instance_;
 
FlagUveManager::FlagUveManager(FlagManager *manager,
                               FlagUveCb flag_uve_cb)
    : flag_manager_(manager),
      flag_uve_cb_(flag_uve_cb) {
}
 
void FlagUveManager::CreateInstance(FlagManager *manager,
                                    FlagUveCb flag_uve_cb) {
    assert(instance_ == NULL);
    instance_.reset(new FlagUveManager(manager, flag_uve_cb));
}
 
FlagUveManager* FlagUveManager::GetInstance() {
    if (instance_ == NULL) {
        instance_.reset(new FlagUveManager(NULL, NULL));
    }
    return instance_.get();
}
 
void FlagUveManager::SendUVE() {
    if (!flag_uve_cb_.empty()) {
        flag_uve_cb_();
    } else {
        FLAG_WARN("SendUVE cb not set");
    }
}
 
FlagConfigVec FlagUveManager::GetFlagInfos(bool lock) const {
    if (lock) {
        return (flag_manager_->GetFlagInfos());
    } else {
        return (flag_manager_->GetFlagInfosUnlocked());
    }
}
 
boost::scoped_ptr<FlagConfigManager> FlagConfigManager::instance_;
string FlagConfigManager::version_;
 
FlagConfigManager::FlagConfigManager(FlagManager* manager)
    : flag_manager_(manager) {
}
 
void FlagConfigManager::Initialize(const string &build_info) {
    if (instance_ == NULL) {
        instance_.reset(new FlagConfigManager(FlagManager::GetInstance()));
    }
 
    Document d;
    if ( d.Parse<0>(build_info.c_str()).HasParseError() ) {
        FLAG_WARN("Parsing error");
    } else {
        const Value &v = d["build-info"];
        version_ = v[0]["build-version"].GetString();
    }
}
 
FlagConfigManager* FlagConfigManager::GetInstance() {
    if (instance_ == NULL) {
        instance_.reset(new FlagConfigManager(FlagManager::GetInstance()));
    }
    return instance_.get();
}
 
void FlagConfigManager::Set(const string &name,
                            const string &version, bool enabled,
                            FlagState::Type state,
                            ContextVec &context_infos) {
    if (version_ != version) {
        FLAG_DEBUG("Flag " << name << "'s version " << version <<
            " does not match with module version " << version_ <<
            " Ignoring.");
        return;
    }
    flag_manager_->Set(name, version, enabled, state, context_infos);
    FlagUveManager::GetInstance()->SendUVE();
}
 
void FlagConfigManager::Unset(const string &name) {
    flag_manager_->Unset(name);
    FlagUveManager::GetInstance()->SendUVE();
}
 
boost::scoped_ptr<FlagManager> FlagManager::instance_;
 
FlagManager* FlagManager::GetInstance() {
    if (instance_ == NULL) {
        instance_.reset(new FlagManager());
    }
    return instance_.get();
}
 
void FlagManager::ClearFlags() {
    flag_map_.clear();
}
 
size_t FlagManager::GetFlagMapCount() const {
    return (flag_map_.size());
}
 
void FlagManager::Set(const string &name, const string &version,
                      bool enabled, FlagState::Type state,
                      ContextVec &context_infos) {
    context_iterator c_itr;
    bool changed = false;
 
    FlagConfig flag_cfg(name, version, enabled, state, context_infos);
 
    tbb::mutex::scoped_lock lock(mutex_);
    flag_map_itr fmap_itr = flag_map_.find(name);
    if (fmap_itr != flag_map_.end()) {
        FlagConfig old_cfg = fmap_itr->second;
 
        FLAG_DEBUG("Flag " << name << "Already Present\n");
        FLAG_DEBUG(" EXISTING INFO:\n "
             << " Version: " << old_cfg.version()
             << " Enabled: " << string(old_cfg.enabled() ? "True " : "False ")
             << " State: " << FlagState::ToString(old_cfg.state()));
        const ContextVec c_vec = old_cfg.context_infos();
        FLAG_DEBUG("Context Info: ");
        for (c_itr = c_vec.begin(); c_itr != c_vec.end(); ++c_itr) {
            FLAG_DEBUG("Description: " << c_itr->desc
                       << " Value: " << c_itr->value);
        }
 
        if (old_cfg != flag_cfg) {
            FLAG_DEBUG("Flag " << name << " updated\n");
            changed = true;
            fmap_itr->second = flag_cfg;
        } else {
            FLAG_DEBUG("No change in flag " << name << " configuration\n");
        }
    } else {
        changed = true;
        FLAG_DEBUG("New flag configured. Name: " << name);
        flag_map_.insert(make_pair(name, flag_cfg));
    }
 
    FLAG_DEBUG(" NEW INFO:\n "
      << " Version: " << flag_cfg.version()
      << " Enabled: " << string(flag_cfg.enabled() ? "True " : "False ")
      << " State: " << FlagState::ToString(flag_cfg.state()));
    const ContextVec c_vec = flag_cfg.context_infos();
    FLAG_DEBUG("Context Info: ");
    for (c_itr = c_vec.begin(); c_itr != c_vec.end(); ++c_itr) {
        FLAG_DEBUG("Description: " << c_itr->desc
                   << " Value: " << c_itr->value);
    }
 
    if (changed) {
        bool enabled;
        pair <int_map_itr, int_map_itr> ret;
        ret = int_map_.equal_range(name);
        for (int_map_itr it = ret.first; it != ret.second; ++it) {
            enabled = false;
            Flag *f = it->second;
            enabled = IsFlagEnabled(name, f->enabled(), f->context_infos());
            f->set_enabled(enabled);
            f->InvokeCb();
        }
    }
}
 
void FlagManager::Unset(const string &name) {
    flag_map_.erase(name);
 
    pair <int_map_itr, int_map_itr> ret;
    ret = int_map_.equal_range(name);
    for (int_map_itr it = ret.first; it != ret.second; ++it) {
        Flag *f = it->second;
        f->set_enabled(false);
        f->InvokeCb();
    }
}
 
bool FlagManager::IsFlagEnabled(const string &name,
                                bool default_state,
                                const ContextVec &c_vec) const {
    flag_map_citr fitr;
    bool result = false;
    context_iterator c_itr, f_itr;
 
    FLAG_DEBUG("Checking if flag with name: " << name
               << " is enabled for context");
    for (c_itr = c_vec.begin(); c_itr != c_vec.end(); ++c_itr) {
        FLAG_DEBUG("Description: " << c_itr->desc
                   << " Value: " << c_itr->value);
    }
 
    fitr = flag_map_.find(name);
    if (fitr != flag_map_.end()) {
        FlagConfig flag_cfg = fitr->second;
 
        if (flag_cfg.enabled()) {
            result = true;
        }
 
        const ContextVec f_vec = flag_cfg.context_infos();
        if (c_vec.empty() && !f_vec.empty()) {
            result = false;
        }
        for (c_itr = c_vec.begin(); c_itr != c_vec.end(); ++c_itr) {
            f_itr = find(f_vec.begin(), f_vec.end(), *c_itr);
            if (f_itr == f_vec.end()) {
                result = false;
            }
        }
    } else {
        result = default_state;
    }
 
    FLAG_DEBUG("Flag enabled: " << string(result ? "True" : "False"));
 
    return result;
}
 
void FlagManager::Register(Flag *flag) {
    int_map_itr itr;
    flag_map_citr fitr;
 
    tbb::mutex::scoped_lock lock(mutex_);
 
    string name = flag->name();
 
    FLAG_DEBUG("Module interested in flag. Name: " << name <<
               " \nAdding to InterestMap");
 
    fitr = flag_map_.find(name);
    if (fitr != flag_map_.end()) {
        FLAG_DEBUG("Flag Name: " << name <<
                   " already present in FlagMap");
        bool value = IsFlagEnabled(name, flag->enabled(),
                                   flag->context_infos());
        flag->set_enabled(value);
        flag->InvokeCb();
    }
 
    itr = int_map_.insert(make_pair(name, flag));
}
 
void FlagManager::Unregister(const Flag *flag) {
    pair <int_map_itr, int_map_itr> ret;
    const string name = flag->name();
    ret = int_map_.equal_range(name);
 
    FLAG_DEBUG("Module not interested in flag. Name: " << name <<
               " \nRemoving from InterestMap");
 
    tbb::mutex::scoped_lock lock(mutex_);
 
    int_map_itr it = ret.first;
    while (it != ret.second) {
        if (it->second == flag) {
            int_map_.erase(it);
            break;
        } else {
            ++it;
        }
    }
}
 
bool FlagManager::IsRegistered(const Flag *flag) const {
    pair <int_map_const_itr, int_map_const_itr> ret;
 
    tbb::mutex::scoped_lock lock(mutex_);
 
    ret = int_map_.equal_range(flag->name());
    for (int_map_const_itr it = ret.first; it != ret.second; ++it) {
        if (it->second == flag) {
            return true;
        }
    }
    return false;
}
 
size_t FlagManager::GetIntMapCount() const {
    return (int_map_.size());
}
 
FlagConfigVec FlagManager::GetFlagInfosUnlocked() const {
    flag_map_citr fitr;
    int_map_const_itr iitr;
    FlagConfigVec flag_infos;
 
    for (fitr = flag_map_.begin(); fitr != flag_map_.end(); ++fitr) {
        FlagConfig flag_cfg = fitr->second;
        iitr = int_map_.find(flag_cfg.name());
        if (iitr != int_map_.end()) {
            flag_infos.push_back(flag_cfg);
        }
    }
 
    return flag_infos;
}
 
FlagConfigVec FlagManager::GetFlagInfos() const {
    tbb::mutex::scoped_lock lock(mutex_);
    return GetFlagInfosUnlocked();
}
 
} // namespace process