在本专题之前的文章中，对配置项和系统变量的源码进行了解析。在新增配置项和系统变量时，往往会指定一个取值范围，或者定义一个合法性检查函数。本文将会介绍在不同的场景下，如何对配置项和系统变量进行合法性检查。

配置项的合法性检查

配置项一般可以直接指定取值范围，也可以自定义合法性检查函数，还有一些需要访问特定的配置项甚至系统变量，才能确定是否满足修改条件。

常规检查

在定义配置项时，对于基础类型的数据，一般会指定一个“取值范围”。比如[0,100]"表示0到100之间的整数，方括号表示包含0和100；"[0M,)"表示范围从0到无穷大，"M"是数据的单位，它还可以是"K"、"G"等。

DEF_INT(cpu_count, OB_CLUSTER_PARAMETER, "0", "[0,]",
        "the number of CPU\\'s in the system. "
        "If this parameter is set to zero, the number will be set according to sysconf; "
        "otherwise, this parameter is used. Range: [0,+∞) in integer",
        ObParameterAttr(Section::OBSERVER, Source::DEFAULT, EditLevel::DYNAMIC_EFFECTIVE));

cpu_count 合法性检查示例：

对于有的配置项，无法用一个简单的字符串来描述它的取值范围，就需要定义一个专门的检查函数。

DEF_STR_WITH_CHECKER(default_compress_func, OB_CLUSTER_PARAMETER, "zstd_1.3.8",
                     common::ObConfigCompressFuncChecker,
                     "default compress function name for create new table, "
                     "values: none, lz4_1.0, snappy_1.0, zlib_1.0, zstd_1.0, zstd_1.3.8",
                     ObParameterAttr(Section::OBSERVER, Source::DEFAULT, EditLevel::DYNAMIC_EFFECTIVE));

合法性检查类有固定的模板可以使用，只需模仿已有的结构定义即可。关键在于check函数的功能，比如 ObConfigCompressFuncChecker::check 函数，会去检查传入的值是否在指定的 compress_funcs 数组中，如果不是则返回 is_valid = false，表示参数不合法，那么最终就会修改失败。

bool ObConfigCompressFuncChecker::check(const ObConfigItem &t) const
{
  bool is_valid = false;
  for (int i = 0; i < ARRAYSIZEOF(common::compress_funcs) && !is_valid; ++i) {
    if (0 == ObString::make_string(compress_funcs[i]).case_compare(t.str())) {
      is_valid = true;
    }
  }
  return is_valid;
}

// 在某个头文件中定义
const char *const compress_funcs[] =
{
  "lz4_1.0",
  "none",
  "snappy_1.0",
  "zstd_1.0",
  "zstd_1.3.8",
  "lz4_1.9.1",
};

default_compress_func 合法性检查示例：

特殊检查

检查集群配置项

有的配置项可能会依赖其他配置项的值，比如A必须大于B、A*B要小于C等要求，这时候就需要在检查函数中访问其他配置项的值，从而判断当前传入的新值是否符合要求。

例如租户配置项 max_stale_time_for_weak_consistency，不能小于集群配置项 weak_read_version_refresh_interval（超时时间必须大于刷新时间，不然来不及刷新很可能会超时），那么在它的 check 函数中，可以通过全局的 GCONF 对象访问集群配置项的值。

bool ObConfigStaleTimeChecker::check(const ObConfigItem &t) const
{
  bool is_valid = false;
  int64_t stale_time = ObConfigTimeParser::get(t.str(), is_valid);
  if (is_valid) {
    is_valid = (stale_time >= GCONF.weak_read_version_refresh_interval);
    if (!is_valid) {
      LOG_USER_ERROR(OB_NOT_SUPPORTED, "max_stale_time_for_weak_consistency violate"
          " weak_read_version_refresh_interval,");
    }
  }
  return is_valid;
}

max_stale_time_for_weak_consistency 合法性检查示例：

检查租户配置项

对于某些配置项，可能需要跟另一个租户配置项进行对比，而租户配置项存在多个实例，显然无法直接通过 GCONF 访问。

以 partition_balance_schedule_interval 为例，首先定义一个常量字符串 PARTITION_BALANCE_SCHEDULE_INTERVAL 来表示该配置项，在配置项预检查函数 set_config_pre_hook 中，如果 strcmp 匹配到该配置项，则可以进行后续的检查。遍历本次更新涉及到的所有 tenant_id（注意不是所有租户，只是当前修改命令涉及的租户），依次获取每个租户的 tenant_config，从中取出配置项 balancer_idle_time，然后与传入的值进行对比，若所有租户全部检查通过则可以修改。

	} else if (0 == STRCMP(item->name_.ptr(), PARTITION_BALANCE_SCHEDULE_INTERVAL)) {
      const int64_t DEFAULT_BALANCER_IDLE_TIME = 10 * 1000 * 1000L; // 10s
      for (int i = 0; i < item->tenant_ids_.count() && valid; i++) {
        const uint64_t tenant_id = item->tenant_ids_.at(i);
        omt::ObTenantConfigGuard tenant_config(TENANT_CONF(tenant_id));
        int64_t balancer_idle_time = tenant_config.is_valid() ? tenant_config->balancer_idle_time : DEFAULT_BALANCER_IDLE_TIME;
        int64_t interval = ObConfigTimeParser::get(item->value_.ptr(), valid);
        if (valid) {
          if (0 == interval) {
            valid = true;
          } else if (interval >= balancer_idle_time) {
            valid = true;
          } else {
            valid = false;
            char err_msg[DEFAULT_BUF_LENGTH];
            (void)snprintf(err_msg, sizeof(err_msg), "partition_balance_schedule_interval of tenant %ld, "
                "it should not be less than balancer_idle_time", tenant_id);
            LOG_USER_ERROR(OB_INVALID_ARGUMENT, err_msg);
          }
        }
        if (!valid) {
          ret = OB_INVALID_ARGUMENT;
          LOG_WARN("config invalid", KR(ret), K(*item), K(balancer_idle_time), K(tenant_id));
        }
      }

partition_balance_schedule_interval 合法性检查示例：

1. 修改所有租户的 partition_balance_schedule_interval = 1800s 失败，因为其中一个租户 perf 的 balancer_idle_time = 2000s，而 partition_balance_schedule_interval 不能小于 balancer_idle_time，所以 perf 租户无法修改，导致整个修改操作失败；
2. 修改 test 租户的 partition_balance_schedule_interval = 1800s 成功，因为 test 租户的 balancer_idle_time = 10s，满足要求；
3. 修改 perf 租户的 partition_balance_schedule_interval = 1800s 失败，因为 perf 租户的 balancer_idle_time = 2000s，不满足要求；
4. 修改 sys 租户（当前租户为sys租户）的 partition_balance_schedule_interval = 1800s 成功，因为 sys 租户的 balancer_idle_time = 10s，满足要求；

检查全局系统变量

配置项还可能受到系统变量的影响，有时也需要检查全局系统变量的值，这就要从schema中获取系统变量进行比较。

以 max_stale_time_for_weak_consistency为例，同样地，首先为目标配置项定义一个常量字符串 WEAK_READ_VERSION_REFRESH_INTERVAL。在配置项预检查函数 set_config_pre_hook 中，如果 strcmp 匹配到该配置项，则可以进行后续的检查，代码较多的情况下可以封装一个函数（check_weak_read_version_refresh_interval）用于检查合法性。

const char* const WEAK_READ_VERSION_REFRESH_INTERVAL = "weak_read_version_refresh_interval";

int ObRootService::set_config_pre_hook(obrpc::ObAdminSetConfigArg &arg)
{
    } else if (0 == STRCMP(item->name_.ptr(), WEAK_READ_VERSION_REFRESH_INTERVAL)) {
      int64_t refresh_interval = ObConfigTimeParser::get(item->value_.ptr(), valid);
      if (valid && OB_FAIL(check_weak_read_version_refresh_interval(refresh_interval, valid))) {
        LOG_WARN("check refresh interval failed ", KR(ret), K(*item));
      } else if (!valid) {
        ret = OB_INVALID_ARGUMENT;
        LOG_WARN("config invalid", KR(ret), K(*item));
      }

check_weak_read_version_refresh_interval 函数先从 schema_service_中获取所有租户的 id，然后对于每个租户，依次从 schema_service_中获取 ob_max_read_stale_time 的值，再与当前传入的值进行对比，如果不合法则返回 false，所以租户都检查通过则返回 true。

int ObRootService::check_weak_read_version_refresh_interval(int64_t refresh_interval, bool &valid)
{
  ......
  if (OB_FAIL(GCTX.schema_service_->get_tenant_schema_guard(OB_SYS_TENANT_ID, sys_schema_guard))) {
    LOG_WARN("get sys schema guard failed", KR(ret));
  } else if (OB_FAIL(sys_schema_guard.get_tenant_ids(tenant_ids))) {
    LOG_WARN("get tenant ids failed", KR(ret));
  } else {
    ......
    for (int64_t i = 0; OB_SUCC(ret) && valid && i < tenant_ids.count(); i++) {
      tenant_id = tenant_ids[i];
      if (OB_FAIL(GCTX.schema_service_->get_tenant_schema_guard(tenant_id, schema_guard))) {
        LOG_WARN("get schema guard failed", KR(ret), K(tenant_id));
      } else if (OB_FAIL(schema_guard.get_tenant_system_variable(tenant_id,
                         OB_SV_MAX_READ_STALE_TIME, var_schema))) {
        LOG_WARN("get tenant system variable failed", KR(ret), K(tenant_id));
      } else if (OB_FAIL(var_schema->get_value(NULL, NULL, obj))) {
        LOG_WARN("get value failed", KR(ret), K(tenant_id), K(obj));
      } else if (OB_FAIL(obj.get_int(session_max_stale_time))) {
        LOG_WARN("get int failed", KR(ret), K(tenant_id), K(obj));
      } else if (session_max_stale_time != share::ObSysVarFactory::INVALID_MAX_READ_STALE_TIME
                 && refresh_interval > session_max_stale_time) {
        valid = false;
        LOG_USER_ERROR(OB_INVALID_ARGUMENT,
                       "weak_read_version_refresh_interval is larger than ob_max_read_stale_time");
      }
    }
  }

weak_read_version_refresh_interval 合法性检查示例：

1. 修改 session 变量 ob_max_read_stale_time = 2s，然后修改 weak_read_version_refresh_interval = 3s 成功，因为session变量不影响配置项的修改；
2. 修改 global 变量 ob_max_read_stale_time = 2s 失败，因为 ob_max_read_stale_time（系统变量）需要大于等于 weak_read_version_refresh_interval（配置项）；
3. 修改 global 变量 ob_max_read_stale_time = 3s，然后修改 weak_read_version_refresh_interval = 4s 失败，因为global变量的值可以影响配置项的修改；

系统变量的合法性检查

系统变量同样支持多种合法性检查方式，以便应对不同场景的需求。

常规检查

与配置项类似，在定义系统变量时也可以指定取值范围。

例如 connect_timeout，设置了"min_val"和"max_val"字段，取值范围就是[2, 31536000]，不需要自己增加额外的代码，现有的框架会自动进行范围检查。

"connect_timeout": {
    "id": 22,
    "name": "connect_timeout",
    "default_value": "10",
    "base_value": "10",
    "data_type": "int",
    "info": " ",
    "flags": "GLOBAL",
    "min_val": "2",
    "max_val": "31536000",
    "publish_version": "",
    "info_cn": "",
    "background_cn": "",
    "ref_url": ""
  },

connect_timeout 范围检查示例：

有的系统变量是字符串类型，无法用简单的数值表示取值范围，可以在 update_global_variables 函数中增加额外的检查代码。例如 ob_log_level，调用 OB_LOGGER.parse_check 函数进行检查，返回 OB_SUCCESS 表示检查通过。

	} else if (set_var.var_name_ == OB_SV_LOG_LEVEL) {
      ObString log_level;
      if (OB_FAIL(val.get_varchar(log_level))) {
        LOG_WARN("fail get varchar", K(val), K(ret));
      } else if (0 == log_level.case_compare("disabled")) {
        //allowed for variables
      } else if (OB_FAIL(OB_LOGGER.parse_check(log_level.ptr(), log_level.length()))) {
        LOG_WARN("Log level parse check error", K(log_level), K(ret));
      }

ob_log_level 合法性检查示例：

特殊检查

同样的，系统变量也需要访问其他的配置项或者变量，从而判断传入值的合法性。

检查集群配置项

以 ob_max_read_stale_time 为例，如果是global变量，可以在 update_global_variables 函数中，通过 GCONF 获取其他集群级别配置项的值，对比当前传入的值是否合法，不合法则返回 OB_INVALID_ARGUMENT。

int ObVariableSetExecutor::update_global_variables(
{
	......
	} else if (set_var.var_name_ == OB_SV_MAX_READ_STALE_TIME) {
      int64_t max_read_stale_time = 0;
      if (OB_FAIL(val.get_int(max_read_stale_time))) {
        LOG_WARN("fail to get int value", K(ret), K(val));
      } else if (max_read_stale_time != ObSysVarFactory::INVALID_MAX_READ_STALE_TIME &&
                 max_read_stale_time < GCONF.weak_read_version_refresh_interval) {
        ret = OB_INVALID_ARGUMENT;
        LOG_USER_ERROR(OB_INVALID_ARGUMENT,
                       "max_read_stale_time is smaller than weak_read_version_refresh_interval");
      }

ob_max_read_stale_time 合法性检查示例：

如果是session变量，则可以在 process_session_variable 函数中调用相应的处理函数，相关的判断逻辑与global变量一致即可。

OB_INLINE int ObBasicSessionInfo::process_session_variable(ObSysVarClassType var, const ObObj &val,
    const bool check_timezone_valid/*true*/, const bool is_update_sys_var/*false*/)
{
  int ret = OB_SUCCESS;
  switch (var) {
    case SYS_VAR_OB_LOG_LEVEL: {
      OZ (process_session_log_level(val), val);
      break;
    }

检查租户配置项

目前代码中没有这样的例子，如果需要在更新系统变量时检查租户配置项，可以参考更新配置项时的做法。而且，系统变量只涉及当前租户，所以也只需要获取当前租户的配置项进行合法性检查。

检查系统变量

对于global变量，可以在 update_global_variables 函数中，先获取当前租户的 schema，然后取得需要的系统变量的值。获取的方式与“更新配置项时检查全局系统变量”类似，不再赘述。

对于session变量，在 process_session_variable 函数中，通过 sys_vars_cache_.get_xxx() 的方式获取其缓存值，检查通过后直接调用 sys_vars_cache_.set_xxx() 函数更新变量值即可。

小结

通过自定义的合法性检查手段，对配置项和系统变量的值进行检查，可以有效避免用户设置无效的、超出正常边界的值，进而影响系统稳定性和可用性。

至此，关于配置项和系统变量的使用方法和源码分析已经介绍完了，接下来还会有一些应用和问题排查相关的文章，感兴趣的同学可以关注下。

参考文档

如何新增配置项？

如何新增系统变量？

OceanBase 里的 schema 是什么？