在“OceanBase 配置项&系统变量实现及应用详解”的系列文章中，我们已经对配置项和系统变量的源码进行了解析。当涉及到新增配置项或系统变量时，通常会为其指定一个明确的取值范围或定义一个专门的合法性检查函数。本文将详细阐述在不同情境下，应如何对配置项和系统变量进行合法性检查。

配置项的合法性检查

配置项通常可以直接设定其取值范围，或者根据需要自定义合法性检查函数。此外，在某些情况下，还需要通过访问特定的配置项甚至系统变量，才能确定是否满足修改条件

常规检查

在定义配置项时，对于基础类型的数据，一般会指定一个“取值范围”。比如[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 是什么？