oceanbase

1
/**
2
 * Copyright (c) 2021 OceanBase
3
 * OceanBase CE is licensed under Mulan PubL v2.
4
 * You can use this software according to the terms and conditions of the Mulan PubL v2.
5
 * You may obtain a copy of Mulan PubL v2 at:
6
 *          http://license.coscl.org.cn/MulanPubL-2.0
7
 * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND,
8
 * EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT,
9
 * MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE.
10
 * See the Mulan PubL v2 for more details.
11
 */
12

13
#define USING_LOG_PREFIX RS
14

15
#include "ob_vtable_location_getter.h"
16

17
#include "lib/container/ob_array_serialization.h"
18
#include "lib/container/ob_array_iterator.h"
19
#include "rootserver/ob_unit_manager.h"
20
#include "share/ob_all_server_tracer.h"
21
#include "share/ob_unit_table_operator.h"
22
#include "rootserver/ob_root_utils.h"
23

24
namespace oceanbase
25
{
26
using namespace common;
27
using namespace share;
28
namespace rootserver
29
{
30
ObVTableLocationGetter::ObVTableLocationGetter(ObUnitManager &unit_mgr) : unit_mgr_(unit_mgr)
31
{
32
}
33

34

35
ObVTableLocationGetter::~ObVTableLocationGetter()
36
{
37
}
38

39
// **FIXME (linqiucen.lqc): in the future, we can remove unit_mgr_,
40
// **                       then this func can be executed locally on observers
41
int ObVTableLocationGetter::get(const ObVtableLocationType &vtable_type,
42
                                ObSArray<common::ObAddr> &servers)
43
{
44
  int ret = OB_SUCCESS;
45
  servers.reuse();
46
  if (OB_UNLIKELY(!vtable_type.is_valid()
47
      || vtable_type.is_only_local())) {
48
    ret = OB_INVALID_ARGUMENT;
49
    LOG_WARN("input is invalid", KR(ret), K(vtable_type));
50
  } else if (vtable_type.is_only_rs()) {
51
    if (OB_FAIL(get_only_rs_vtable_location_(vtable_type, servers))) {
52
      LOG_WARN("get_only_rs_vtable_location failed", KR(ret), K(vtable_type));
53
    }
54
  } else if (vtable_type.is_cluster_distributed()) {
55
    if (OB_FAIL(get_global_vtable_location_(vtable_type, servers))) {
56
      LOG_WARN("get_global_vtable_location failed", KR(ret), K(vtable_type));
57
    }
58
  } else if (vtable_type.is_tenant_distributed()) {
59
    if (OB_FAIL(get_tenant_vtable_location_(vtable_type, servers))) {
60
      LOG_WARN("get_tenant_vtable_location failed", KR(ret), K(vtable_type));
61
    }
62
  } else {
63
    ret = OB_ERR_UNEXPECTED;
64
    LOG_ERROR("expected not to run here", KR(ret), K(vtable_type));
65
  }
66
  if (OB_SUCC(ret) && OB_UNLIKELY(servers.count() <= 0)) {
67
    ret = OB_LOCATION_NOT_EXIST;
68
    LOG_WARN("servers are empty", KR(ret), K(vtable_type), K(servers));
69
  }
70
  return ret;
71
}
72

73
int ObVTableLocationGetter::get_only_rs_vtable_location_(
74
    const ObVtableLocationType &vtable_type,
75
    ObSArray<ObAddr> &servers)
76
{
77
  int ret = OB_SUCCESS;
78
  servers.reuse();
79
  ObAddr rs_addr;
80
  if (OB_UNLIKELY(!vtable_type.is_only_rs())) {
81
    ret = OB_INVALID_ARGUMENT;
82
    LOG_WARN("vtable_type is invalid", K(vtable_type), KR(ret));
83
  } else if (OB_ISNULL(GCTX.rs_mgr_)) {
84
    ret = OB_ERR_UNEXPECTED;
85
    LOG_WARN("GCTX.rs_mgr_ is null", KP(GCTX.rs_mgr_));
86
  } else if (OB_FAIL(GCTX.rs_mgr_->get_master_root_server(rs_addr))) {
87
    LOG_WARN("fail to get master root server", KR(ret), KP(GCTX.rs_mgr_));
88
  } else if (OB_UNLIKELY(!rs_addr.is_valid() || rs_addr != GCTX.self_addr())) {
89
    ret = OB_ENTRY_NOT_EXIST;
90
    LOG_WARN("rs_addr is invalid or not equal to self_addr", KR(ret), K(rs_addr), K(GCTX.self_addr()));
91
  } else if (OB_FAIL(servers.push_back(rs_addr))) {
92
    LOG_WARN("push_back failed", KR(ret), K(rs_addr));
93
  }
94
  return ret;
95
}
96

97
int ObVTableLocationGetter::get_global_vtable_location_(
98
    const ObVtableLocationType &vtable_type,
99
    ObSArray<ObAddr> &servers)
100
{
101
  int ret = OB_SUCCESS;
102
  servers.reuse();
103
  ObZone zone; // empty zone means all zones
104
  if (OB_UNLIKELY(!(vtable_type.is_cluster_distributed()))) {
105
    ret = OB_INVALID_ARGUMENT;
106
    LOG_WARN("vtable_type is invalid", K(vtable_type), KR(ret));
107
  } else if (OB_FAIL(SVR_TRACER.get_alive_servers(zone, servers))) {
108
    LOG_WARN("get_alive_servers failed", KR(ret), KP(GCTX.sql_proxy_));
109
  }
110
  return ret;
111
}
112

113
int ObVTableLocationGetter::get_tenant_vtable_location_(
114
    const ObVtableLocationType &vtable_type,
115
    ObSArray<ObAddr> &servers)
116
{
117
  int ret = OB_SUCCESS;
118
  const uint64_t tenant_id = vtable_type.get_tenant_id();
119
  if (OB_UNLIKELY(!vtable_type.is_valid()
120
      || !vtable_type.is_tenant_distributed()
121
      || is_sys_tenant(tenant_id))) { // sys_tenant should get cluster location
122
    ret = OB_INVALID_ARGUMENT;
123
    LOG_WARN("vtable_type is invalid", KR(ret), K(vtable_type));
124
  } else if (OB_FAIL(unit_mgr_.get_tenant_alive_servers_non_block(tenant_id, servers))) {
125
    LOG_WARN("failed to get tenant alive servers", KR(ret), K(tenant_id));
126
  }
127
  return ret;
128
}
129

130
}//end namespace rootserver
131
}//end namespace oceanbase
132