270 lines
9.2 KiB
C++
270 lines
9.2 KiB
C++
/**
|
|
* Copyright (c) 2021 OceanBase
|
|
* OceanBase CE is licensed under Mulan PubL v2.
|
|
* You can use this software according to the terms and conditions of the Mulan PubL v2.
|
|
* You may obtain a copy of Mulan PubL v2 at:
|
|
* http://license.coscl.org.cn/MulanPubL-2.0
|
|
* THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND,
|
|
* EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT,
|
|
* MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE.
|
|
* See the Mulan PubL v2 for more details.
|
|
*/
|
|
|
|
#define USING_LOG_PREFIX SHARE
|
|
#include "lib/string/ob_sql_string.h"
|
|
#include "lib/mysqlclient/ob_mysql_proxy.h"
|
|
#include "config/ob_server_config.h"
|
|
#include "share/ob_inner_config_root_addr.h"
|
|
#include "observer/ob_server_struct.h"
|
|
#include "common/ob_timeout_ctx.h"
|
|
#include "rootserver/ob_root_utils.h"
|
|
|
|
namespace oceanbase
|
|
{
|
|
using namespace common;
|
|
namespace share
|
|
{
|
|
int ObInnerConfigRootAddr::check_inner_stat() const
|
|
{
|
|
int ret = OB_SUCCESS;
|
|
if (!inited_) {
|
|
ret = OB_NOT_INIT;
|
|
LOG_WARN("not init", KR(ret));
|
|
} else if (OB_ISNULL(config_) || OB_ISNULL(proxy_)) {
|
|
ret = OB_ERR_UNEXPECTED;
|
|
LOG_WARN("ptr is null", KR(ret), KP_(config), KP_(proxy));
|
|
}
|
|
return ret;
|
|
}
|
|
|
|
int ObInnerConfigRootAddr::init(ObMySQLProxy &sql_proxy, ObServerConfig &config)
|
|
{
|
|
int ret = OB_SUCCESS;
|
|
if (inited_) {
|
|
ret = OB_INIT_TWICE;
|
|
LOG_WARN("init twice", K(ret));
|
|
} else if (OB_FAIL(ObRootAddrAgent::init(config))) {
|
|
LOG_WARN("init root addr agent failed", K(ret));
|
|
} else {
|
|
proxy_ = &sql_proxy;
|
|
inited_ = true;
|
|
}
|
|
return ret;
|
|
}
|
|
|
|
// update root server list if %addr_list not same with config_->rootservice_list
|
|
int ObInnerConfigRootAddr::store(const ObIAddrList &addr_list, const ObIAddrList &readonly_addr_list,
|
|
const bool force, const common::ObClusterRole cluster_role,
|
|
const int64_t timestamp)
|
|
{
|
|
// TODO: Currently there is no local cache of the read copy location of __all_core_table
|
|
UNUSED(readonly_addr_list);
|
|
UNUSED(cluster_role);
|
|
UNUSED(timestamp);
|
|
UNUSED(force);
|
|
int ret = OB_SUCCESS;
|
|
bool need_update = false;
|
|
char addr_buf[MAX_IP_PORT_LENGTH] = "";
|
|
if (OB_FAIL(check_inner_stat())) {
|
|
LOG_WARN("fail to check inner stat", KR(ret));
|
|
} else if (addr_list.count() <= 0) {
|
|
ret = OB_INVALID_ARGUMENT;
|
|
LOG_WARN("invalid argument", K(ret), "addr count", addr_list.count());
|
|
} else {
|
|
if (addr_list.count() != config_->rootservice_list.size()) {
|
|
need_update = true;
|
|
} else {
|
|
ObAddr addr;
|
|
for (int64_t i = 0; OB_SUCC(ret) && !need_update
|
|
&& i < config_->rootservice_list.size(); ++i) {
|
|
addr.reset();
|
|
int64_t sql_port = 0;
|
|
if (OB_FAIL(config_->rootservice_list.get(
|
|
static_cast<int32_t>(i), addr_buf, sizeof(addr_buf)))) {
|
|
LOG_WARN("rootservice_list get failed", K(i), K(ret));
|
|
} else if (OB_FAIL(parse_rs_addr(addr_buf, addr, sql_port))) {
|
|
LOG_WARN("parse_rs_addr failed", KCSTRING(addr_buf), K(ret));
|
|
} else {
|
|
bool found = false;
|
|
FOREACH_CNT_X(a, addr_list, !found) {
|
|
if (addr == a->get_server() && sql_port == a->get_sql_port()) {
|
|
found = true;
|
|
}
|
|
}
|
|
if (!found) {
|
|
need_update = true;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
if (OB_SUCC(ret)) {
|
|
if (need_update) {
|
|
ObSqlString sql;
|
|
if (OB_FAIL(sql.assign("ALTER SYSTEM SET rootservice_list = '"))) {
|
|
LOG_WARN("assign sql failed", K(ret));
|
|
} else if (OB_FAIL(format_rootservice_list(addr_list, sql))) {
|
|
LOG_WARN("fail to format rootservice list", KR(ret), K(addr_list), K(sql));
|
|
}
|
|
|
|
int64_t affected_rows = 0;
|
|
ObTimeoutCtx ctx;
|
|
if (OB_FAIL(ret)) {
|
|
} else if (OB_FAIL(sql.append_fmt("'"))) {
|
|
LOG_WARN("append sql failed", K(ret));
|
|
} else if (OB_FAIL(rootserver::ObRootUtils::get_rs_default_timeout_ctx(ctx))) {
|
|
LOG_WARN("fail to get timeout ctx", K(ret), K(ctx));
|
|
} else if (OB_FAIL(proxy_->write(OB_SYS_TENANT_ID, sql.ptr(), affected_rows))) {
|
|
LOG_WARN("execute sql failed", K(ret), K(sql));
|
|
} else {
|
|
LOG_INFO("ALTER SYSTEM SET rootservice_list succeed", K(addr_list), K(force));
|
|
}
|
|
}
|
|
}
|
|
|
|
return ret;
|
|
}
|
|
|
|
int ObInnerConfigRootAddr::format_rootservice_list(const ObIAddrList &addr_list, ObSqlString &str)
|
|
{
|
|
int ret = OB_SUCCESS;
|
|
for (int64_t i = 0; OB_SUCC(ret) && i < addr_list.count(); ++i) {
|
|
char ip_buf[OB_IP_STR_BUFF] = "";
|
|
const ObRootAddr &rs = addr_list.at(i);
|
|
ObAddr addr = rs.get_server();
|
|
// If it is not the last RS, add a separator at the end
|
|
const bool need_append_delimiter = (i != addr_list.count() - 1);
|
|
|
|
if (OB_UNLIKELY(!addr.ip_to_string(ip_buf, sizeof(ip_buf)))) {
|
|
ret = OB_ERR_UNEXPECTED;
|
|
LOG_WARN("convert ip to string failed", KR(ret), K(rs));
|
|
} else if (OB_FAIL(str.append_fmt("%s%s%s:%d:%ld%s",
|
|
addr.using_ipv4() ? "" : "[",
|
|
ip_buf,
|
|
addr.using_ipv4() ? "" : "]",
|
|
addr.get_port(),
|
|
rs.get_sql_port(),
|
|
need_append_delimiter ? ";" : ""))) {
|
|
LOG_WARN("fail to append_fmt", KR(ret), K(str));
|
|
}
|
|
}
|
|
return ret;
|
|
}
|
|
|
|
int ObInnerConfigRootAddr::fetch(
|
|
ObIAddrList &addr_list,
|
|
ObIAddrList &readonly_addr_list)
|
|
{
|
|
int ret = OB_SUCCESS;
|
|
char addr_buf[MAX_IP_PORT_LENGTH] = "";
|
|
const int64_t local_cluster_id = GCONF.cluster_id;
|
|
if (OB_FAIL(check_inner_stat())) {
|
|
LOG_WARN("fail to check inner stat", KR(ret));
|
|
} else {
|
|
addr_list.reuse();
|
|
// TODO: The location of the read-only copy of __all_core_table is not cached locally, so it cannot be read
|
|
readonly_addr_list.reuse();
|
|
ObAddr addr;
|
|
ObRootAddr rs_addr;
|
|
for (int64_t i = 0; OB_SUCC(ret) && i < config_->rootservice_list.size(); ++i) {
|
|
addr.reset();
|
|
int64_t sql_port = 0;
|
|
if (OB_FAIL(config_->rootservice_list.get(
|
|
static_cast<int>(i), addr_buf, sizeof(addr_buf)))) {
|
|
LOG_WARN("get rs failed", K(ret), K(i));
|
|
} else if (OB_FAIL(parse_rs_addr(addr_buf, addr, sql_port))) {
|
|
LOG_WARN("parse_rs_addr failed", K(addr_buf), K(ret));
|
|
} else if (OB_FAIL(rs_addr.init(addr, FOLLOWER, sql_port))) {
|
|
LOG_WARN("failed to simple init rs_addr", KR(ret), K(addr), K(sql_port));
|
|
} else if (OB_FAIL(addr_list.push_back(rs_addr))) {
|
|
LOG_WARN("add rs address to array failed", K(ret));
|
|
}
|
|
}
|
|
LOG_TRACE("fetch addr_list &readonly_addr_list", K(ret),
|
|
K(addr_list), K(readonly_addr_list));
|
|
}
|
|
return ret;
|
|
}
|
|
|
|
int ObInnerConfigRootAddr::parse_rs_addr(char *addr_buf, ObAddr &addr, int64_t &sql_port)
|
|
{
|
|
int ret = OB_SUCCESS;
|
|
if (nullptr == addr_buf) {
|
|
ret = OB_INVALID_ARGUMENT;
|
|
LOG_WARN("invalid argument", K(ret), KP(addr_buf));
|
|
} else {
|
|
int64_t rpc_port = 0;
|
|
bool use_ipv6 = false;
|
|
char *ip_str = nullptr;
|
|
char *port_str = nullptr;
|
|
char *sql_port_str = nullptr;
|
|
char *save_ptr = nullptr;
|
|
|
|
/*
|
|
* ipv4格式: a.b.c.d:port1:port2, proxy只使用一个port
|
|
* ipv6格式: [a:b:c:d:e:f:g:h]:port1:port2, proxy只使用一个port
|
|
*
|
|
*/
|
|
if ('[' != addr_buf[0]) { /* ipv4 */
|
|
if (OB_ISNULL(ip_str = strtok_r(addr_buf, ":", &save_ptr))) {
|
|
ret = OB_INVALID_ARGUMENT;
|
|
LOG_WARN("parse ipv4 failed", K(addr_buf), K(ret));
|
|
} else if (OB_ISNULL(port_str = strtok_r(nullptr, ":", &save_ptr))) {
|
|
ret = OB_INVALID_ARGUMENT;
|
|
LOG_WARN("parse port failed", K(addr_buf), K(ret));
|
|
}
|
|
} else { /* ipv6 */
|
|
use_ipv6 = true;
|
|
ip_str = addr_buf + 1;
|
|
port_str = strrchr(addr_buf, ']');
|
|
if (OB_NOT_NULL(port_str)) {
|
|
*(port_str++) = '\0';
|
|
if (':' != *port_str) {
|
|
ret = OB_INVALID_ARGUMENT;
|
|
LOG_WARN("parse port failed", K(addr_buf), K(ret));
|
|
} else {
|
|
port_str++;
|
|
if (OB_ISNULL(port_str = strtok_r(port_str, ":", &save_ptr))) {
|
|
ret = OB_INVALID_ARGUMENT;
|
|
LOG_WARN("parse port failed", K(addr_buf), K(ret));
|
|
}
|
|
}
|
|
} else {
|
|
ret = OB_INVALID_ARGUMENT;
|
|
LOG_WARN("parse ipv6 failed", K(addr_buf), K(ret));
|
|
}
|
|
}
|
|
|
|
if (OB_SUCC(ret)) {
|
|
// for compatible with obproxy
|
|
// observer rs list format-->ip:rpc_port:sql_port
|
|
// obporoxy rs list format-->ip:sql_port
|
|
if (OB_ISNULL(sql_port_str = strtok_r(nullptr, ":", &save_ptr))) {
|
|
sql_port_str = port_str;
|
|
port_str = nullptr;
|
|
LOG_INFO("only has one port, used for obproxy", K(sql_port_str), K(addr_buf));
|
|
} else if (OB_NOT_NULL(strtok_r(nullptr, ":", &save_ptr))) {
|
|
ret = OB_INVALID_ARGUMENT;
|
|
LOG_WARN("addr in rs_list not in right format", K(addr_buf), K(ret));
|
|
}
|
|
if (OB_SUCC(ret)) {
|
|
if (nullptr != port_str) {
|
|
rpc_port = atoi(port_str);
|
|
} else {
|
|
rpc_port = 1; // fake rpc port, for obproxy, will never be used
|
|
}
|
|
sql_port = atoi(sql_port_str);
|
|
if (!addr.set_ip_addr(ip_str, static_cast<int32_t>(rpc_port))) {
|
|
ret = OB_ERR_UNEXPECTED;
|
|
LOG_WARN("set ip address failed", K(ret), K(ip_str), K(rpc_port));
|
|
}
|
|
}
|
|
}
|
|
}
|
|
return ret;
|
|
}
|
|
|
|
} // end namespace share
|
|
} // end oceanbase
|