Ceph Observer动态更新配置参数

ceph Observer(观察者模式)，可以动态的更改系统配置参数，而不需重启服务。

md_config_t:
//multimap 类型key为option，value为关注该可以的对象。
    observers     (typedef std::multimap <std::string, md_config_obs_t*> obs_map_t)
//发生变动的option
    changed        (typedef std::set < std::string >)

//将观察者与其观察的key放入observer中。

void md_config_t::add_observer(md_config_obs_t* observer_)
{
  Mutex::Locker l(lock);
const char **keys = observer_->get_tracked_conf_keys();
for (const char ** k = keys; *k; ++k) {
    obs_map_t::value_type val(*k, observer_);
    observers.insert(val);
  }
}

//将制定的观察者从observers集合中去除

void md_config_t::remove_observer(md_config_obs_t* observer_)
{
Mutex::Locker l(lock);
  bool found_obs = false;
for (obs_map_t::iterator o = observers.begin(); o != observers.end(); ) {
if (o->second == observer_) {
      observers.erase(o++);
      found_obs = true;
    }
else {
      ++o;
    }
  }
  assert(found_obs);
}

//获取observer的配置参数集，不同的的子系统实现不同

get_tracked_conf_keys()

//更新全局配置参数，然后把发生变动的参数的key放入到changed集合中
//配置参数集合大致可以分为两类，一：与子系统相关的日志级别参数、二: 普通服务配置参数

//set_val()->set_val_impl()->set_val_impl()
int set_val(const char *key, const string& s, bool meta=true, bool safe=true) {
return set_val(key, s.c_str(), meta, safe);
  }


int md_config_t::set_val(const char *key, const char *val, bool meta, bool safe)
{
  Mutex::Locker l(lock);
if (!key)
return -EINVAL;
if (!val)
return -EINVAL;

std::string v(val);
if (meta)
    expand_meta(v, &std::cerr);

string k(ConfFile::normalize_key_name(key));

// subsystems?
if (strncmp(k.c_str(), "debug_", 6) == 0) {
for (int o = 0; o < subsys.get_num(); o++) {
std::string as_option = "debug_" + subsys.get_name(o);
if (k == as_option) {
int log, gather;
int r = sscanf(v.c_str(), "%d/%d", &log, &gather);
if (r >= 1) {
if (r < 2)
        gather = log;
// cout << "subsys " << subsys.get_name(o) << " log " << log << " gather " << gather << std::endl;
      subsys.set_log_level(o, log);
      subsys.set_gather_level(o, gather);
return 0;
    }
return -EINVAL;
      }
    }   
  }

for (int i = 0; i < NUM_CONFIG_OPTIONS; ++i) {
    config_option *opt = &config_optionsp[i];
if (strcmp(opt->name, k.c_str()) == 0) {
if (safe && internal_safe_to_start_threads) {
// If threads have been started...
if ((opt->type == OPT_STR) || (opt->type == OPT_ADDR) ||
        (opt->type == OPT_UUID)) {
// And this is NOT an integer valued variable....
if (observers.find(opt->name) == observers.end()) {
// And there is no observer to safely change it...
// You lose.
return -ENOSYS;
      }
    }
      }
return set_val_impl(v.c_str(), opt);
    }
  }

// couldn't find a configuration option with key 'key'
return -ENOENT;
}

int md_config_t::set_val_impl(const char *val, const config_option *opt)
{
  assert(lock.is_locked());
int ret = set_val_raw(val, opt);
if (ret)
return ret;
  changed.insert(opt->name);
return 0;
}

int md_config_t::set_val_raw(const char *val, const config_option *opt)
{
  assert(lock.is_locked());
switch (opt->type) {
case OPT_INT: {
std::string err;
int f = strict_si_cast<int>(val, &err);
if (!err.empty())
return -EINVAL;
      *(int*)opt->conf_ptr(this) = f;
return 0;
    }
case OPT_LONGLONG: {
std::string err;
long long f = strict_si_cast<long long>(val, &err);
if (!err.empty())
return -EINVAL;
      *(long long*)opt->conf_ptr(this) = f;
return 0;
    }
case OPT_STR:
      *(std::string*)opt->conf_ptr(this) = val ? val : "";
return 0;
case OPT_FLOAT: {
std::string err;
float f = strict_strtof(val, &err);
if (!err.empty())
return -EINVAL;
      *(float*)opt->conf_ptr(this) = f;
return 0;
    }
  ....
case OPT_UUID: {
      uuid_d *u = (uuid_d*)opt->conf_ptr(this);
if (!u->parse(val))
return -EINVAL;
return 0;
    }
  }
return -ENOSYS;
}

void md_config_t::apply_changes(std::ostream *oss)
{
  Mutex::Locker l(lock);
  _apply_changes(oss);
}

void md_config_t::_apply_changes(std::ostream *oss)
{
/* Maps observers to the configuration options that they care about which
 * have changed. */
typedef std::map < md_config_obs_t*, std::set <std::string> > rev_obs_map_t;

  expand_all_meta();

// create the reverse observer mapping, mapping observers to the set of
// changed keys that they'll get.
  rev_obs_map_t robs;
std::set <std::string> empty_set;
char buf[128];
char *bufptr = (char*)buf;
//将更新后的配置参数与oberver相关联。
for (changed_set_t::const_iterator c = changed.begin();
       c != changed.end(); ++c) {
const std::string &key(*c);
if ((oss) &&
    (!_get_val(key.c_str(), &bufptr, sizeof(buf))) &&
    !_internal_field(key)) {
      (*oss) << key << " = '" << buf << "' ";
    }
    pair < obs_map_t::iterator, obs_map_t::iterator >
      range(observers.equal_range(key));
for (obs_map_t::iterator r = range.first; r != range.second; ++r) {
      rev_obs_map_t::value_type robs_val(r->second, empty_set);
      pair < rev_obs_map_t::iterator, bool > robs_ret(robs.insert(robs_val));
std::set <std::string> &keys(robs_ret.first->second);
      keys.insert(key);
    }
  }

// Make any pending observer callbacks
//调用observer的回调函数handle_conf_change() 更新系统参数。
for (rev_obs_map_t::const_iterator r = robs.begin(); r != robs.end(); ++r) {
    md_config_obs_t *obs = r->first;
    obs->handle_conf_change(this, r->second);
  }

  changed.clear();
}