oceanbase

1
import pymysql as mysql
2
import argparse
3
import time
4
import datetime
5
import subprocess
6
import os
7
import logging
8

9
def kill_server():
10
    kill_observer_cmd = "ps -ef | grep observer | grep -v grep | grep -v init_store_for_fast_start.py | awk '{print $2}' | xargs kill -9"
11
    kill_res = subprocess.call(kill_observer_cmd, shell=True)
12
    if kill_res != 0:
13
        logging.warn("kill observer failed")
14
        exit(-1)
15
    logging.info("kill observer ok")
16

17
def check_file_or_path_exist(bin_abs_path, home_abs_path, store_tar_file_path, etc_dest_dir):
18
    if not os.path.isfile(bin_abs_path):
19
        logging.warn("invalid bin path")
20
        return False
21
    if not os.path.isdir(home_abs_path):
22
        logging.warn("invalid home path")
23
        return False
24
    if not os.path.isdir(store_tar_file_path):
25
        logging.warn("invalid store tar file path")
26
        return False
27
    if not os.path.isdir(etc_dest_dir):
28
        logging.warn(etc_dest_dir)
29
        logging.warn("invalid etc dest dir")
30
        return False
31
    return True
32

33
if __name__ == "__main__":
34
    logging.basicConfig(level=logging.INFO)
35

36
    cur_path = os.curdir
37
    cur_path = os.path.abspath(cur_path)
38
    logging.info("=================== cur_path: %s ==============" % cur_path)
39
    parser = argparse.ArgumentParser()
40
    parser.add_argument("observer_bin_path", type=str, help="the path of observer binary file")
41
    parser.add_argument("observer_home_path", type=str, help="the path of sys log / config file / sql.sock / audit info")
42
    parser.add_argument("store_tar_file_dir", type=str, help="store dir zip target dir")
43
    parser.add_argument("etc_dest_dir", type=str, help="the dest dir to save etc config files")
44
    parser.add_argument("--only_build_env", action='store_true', help="build env & start observer without bootstrap and basic check")
45
    parser.add_argument("-p", dest="mysql_port", type=str, default="@OB_MYSQL_PORT@")
46
    parser.add_argument("-P", dest="rpc_port", type=str, default="@OB_RPC_PORT@")
47
    parser.add_argument("-z", dest="zone", type=str, default="zone1")
48
    parser.add_argument("-c", dest="cluster_id", type=str, default="1")
49
    parser.add_argument("-d", dest="data_path", type=str, default="/data/store")
50
    parser.add_argument("-r", dest="rootservice", type=str, default="@OB_SERVER_IP@:@OB_RPC_PORT@")
51
    parser.add_argument("-I", dest="ip", type=str, default="@OB_SERVER_IP@")
52
    parser.add_argument("-l", dest="log_level", type=str, default="INFO")
53
    parser.add_argument("-o", dest="opt_str", type=str, default="__min_full_resource_pool_memory=2147483648,memory_limit=6G,system_memory=1G,datafile_size=256M,log_disk_size=5G,cpu_count=16")
54
    parser.add_argument("-N", dest="daemon", type=str, default="1")
55
    parser.add_argument("--tenant_name", type=str, default="@OB_TENANT_NAME@")
56
    parser.add_argument("--tenant_lower_case_table_names", type=int, default="@OB_TENANT_LOWER_CASE_TABLE_NAMES@")
57
    parser.add_argument("--max_cpu", type=float, default=7.0)
58
    parser.add_argument("--min_cpu", type=float, default=7.0)
59
    parser.add_argument("--memory_size", type=int, default=3221225472)
60
    parser.add_argument("--log_disk_size", type=int, default=3221225472)
61
    args = parser.parse_args()
62

63
    bin_abs_path = os.path.abspath(args.observer_bin_path)
64
    home_abs_path = os.path.abspath(args.observer_home_path)
65
    data_abs_path = os.path.abspath(args.data_path)
66
    store_tar_file_path = os.path.abspath(args.store_tar_file_dir)
67
    etc_dest_dir = os.path.abspath(args.etc_dest_dir)
68

69
    if not check_file_or_path_exist(bin_abs_path, home_abs_path, store_tar_file_path, etc_dest_dir):
70
        logging.warn("check file / path exist failed")
71
        exit(-1)
72

73
    rebuild_env_cmd = "sh ./env.sh %s %s %s -C true && sh ./env.sh %s %s %s -B true" % (bin_abs_path, home_abs_path, data_abs_path, \
74
                                                                                       bin_abs_path, home_abs_path, data_abs_path) if bin_abs_path != home_abs_path + "/observer" else \
75
                      "sh ./env.sh %s %s %s -C && sh ./env.sh %s %s %s -B" % (bin_abs_path, home_abs_path, data_abs_path, \
76
                                                                              bin_abs_path, home_abs_path, data_abs_path)
77

78
    # prepare environment for observer
79
    env_prepare = subprocess.call(rebuild_env_cmd, shell=True)
80
    if env_prepare != 0:
81
        logging.warn("prepare env failed")
82
        exit(-1)
83

84
    # prepare observer start parameters
85
    daemon_option = "-N" if args.daemon=="1" else ""
86
    observer_args = "-p %s -P %s -z %s -c %s -d %s -r %s -I %s -l %s -o %s %s" % (args.mysql_port, args.rpc_port, args.zone, \
87
                                                                                  args.cluster_id, data_abs_path, \
88
                                                                                  args.rootservice, args.ip, args.log_level, args.opt_str, \
89
                                                                                  daemon_option)
90
    os.chdir(home_abs_path)
91
    observer_cmd = "./observer %s" % (observer_args)
92
    subprocess.Popen(observer_cmd, shell=True)
93

94
    # bootstrap observer
95
    time.sleep(4)
96
    try:
97
        db = mysql.connect(host=args.ip, user="root", port=int(args.mysql_port), passwd="")
98
        cursor = db.cursor(cursor=mysql.cursors.DictCursor)
99
        logging.info('connection success!')
100
        if not args.only_build_env:
101
            logging.info("waiting for bootstrap...")
102
            bootstrap_begin = datetime.datetime.now()
103
            cursor.execute("ALTER SYSTEM BOOTSTRAP ZONE '%s' SERVER '%s'" % (args.zone, args.rootservice))
104
            bootstrap_end = datetime.datetime.now()
105
            logging.info('bootstrap success: %s ms' % ((bootstrap_end - bootstrap_begin).total_seconds() * 1000))
106
            # checkout server status
107
            cursor.execute("select * from oceanbase.__all_server")
108
            server_status = cursor.fetchall()
109
            if len(server_status) != 1 or server_status[0]['status'] != 'ACTIVE':
110
                logging.warn("get server status failed")
111
                exit(-1)
112
            logging.info('check server status ok')
113
            # create test tenant
114
            cursor.execute("create resource unit %s_unit max_cpu %s, memory_size %s, min_cpu %s, log_disk_size %s" % ( \
115
                            args.tenant_name, args.max_cpu, args.memory_size, args.min_cpu, args.log_disk_size))
116
            cursor.execute("create resource pool %s_pool unit='%s_unit', unit_num=1, zone_list=('%s')" % ( \
117
                            args.tenant_name, args.tenant_name, args.zone))
118
            logging.info("waiting for create tenant...")
119
            create_tenant_begin = datetime.datetime.now()
120
            cursor.execute("create tenant %s replica_num=1,zone_list=('%s'),primary_zone='RANDOM',resource_pool_list=('%s_pool') set ob_tcp_invited_nodes='%%', ob_compatibility_mode = 'mysql', lower_case_table_names=%d" % ( \
121
                            args.tenant_name, args.zone, args.tenant_name, args.tenant_lower_case_table_names))
122
            create_tenant_end = datetime.datetime.now()
123
            logging.info('create tenant success: %s ms' % ((create_tenant_end - create_tenant_begin).total_seconds() * 1000))
124
        db.close()
125
    except mysql.err.Error as e:
126
        logging.warn("deploy observer failed")
127
        kill_server()
128
        exit(-1)
129

130
    # grant privilege
131
    try:
132
        db = mysql.connect(host=args.ip, user="root@%s" % (args.tenant_name), port=int(args.mysql_port), passwd="")
133
        cursor = db.cursor(cursor=mysql.cursors.DictCursor)
134
        logging.info('connect by common tenant success!')
135
        cursor.execute("CREATE USER '%s'@'%%'" % (args.tenant_name))
136
        cursor.execute("GRANT ALL ON *.* TO '%s'@'%%'" % (args.tenant_name))
137
        logging.info("grant privilege success!")
138
    except mysql.err.Error as e:
139
        logging.warn("grant privilege for common tenant failed")
140
        kill_server()
141
        exit(-1)
142

143
    # stop observer
144
    kill_server()
145

146
    # record block cnt
147
    record_block_cnt_cmd = "cd %s/clog/log_pool && echo $[ `ls | wc -l` - 1 ] > %s/block_cnt" % (data_abs_path, store_tar_file_path)
148
    record_res = subprocess.call(record_block_cnt_cmd, shell=True)
149
    if record_res != 0:
150
        logging.warn("record block cnt failed")
151
        exit(-1)
152
    logging.info("record block cnt ok")
153

154
    # build store tar file
155
    build_store_tar_cmd = "cd %s/clog/log_pool && ls | grep '[0-9]' | xargs rm && cd %s/.. && \
156
                           tar -Sczvf %s/store.tar.gz ./store" % (data_abs_path, data_abs_path, store_tar_file_path)
157
    build_res = subprocess.call(build_store_tar_cmd, shell=True)
158
    if build_res != 0:
159
        logging.warn("build store tar file failed")
160
        exit(-1)
161
    logging.info("build store tar file ok")
162

163
    # copy config files to etc_dest_dir
164
    cp_config_cmd = "cp -r %s/etc/* %s" % (home_abs_path, etc_dest_dir)
165
    cp_config_res = subprocess.call(cp_config_cmd, shell=True)
166
    if cp_config_res != 0:
167
        logging.warn("cp config failed")
168
        exit(-1)
169
    logging.info("cp config ok")
170

171
    # clean env
172
    os.chdir(cur_path)
173
    clean_env_cmd = "sh ./env.sh %s %s %s -C true" % (bin_abs_path, home_abs_path, data_abs_path) if bin_abs_path != home_abs_path + "/observer" else \
174
                    "sh ./env.sh %s %s %s -C" % (bin_abs_path, home_abs_path, data_abs_path)
175
    clean_res = subprocess.call(clean_env_cmd, shell=True)
176
    if clean_res != 0:
177
        logging.warn("clean env failed")
178
        exit(-1)
179
    logging.info("clean all env ok")
180