302 lines
9.1 KiB
Python
302 lines
9.1 KiB
Python
# -*- coding: utf-8 -*-
|
|
#!/usr/bin/python
|
|
|
|
import os
|
|
import sys
|
|
import time
|
|
import json
|
|
import redis
|
|
import pymysql
|
|
import datetime
|
|
import pprint
|
|
import subprocess
|
|
from string import Template
|
|
|
|
CHAR_SET_UTF8MB4 = 'default character set utf8mb4 collate utf8mb4_unicode_ci'
|
|
|
|
config_obj = None
|
|
tools_conf_dir = '../tools_conf/'
|
|
is_test_env = False
|
|
if os.path.exists('../tools_conf_test'):
|
|
tools_conf_dir = '../tools_conf_test/'
|
|
is_test_env = True
|
|
|
|
def error(msg):
|
|
print('[ERROR]' + str(msg), flush = True)
|
|
|
|
def info(msg):
|
|
print('[INFO]' + str(msg), flush = True)
|
|
|
|
def warn(msg):
|
|
print('[WARN]' + str(msg), flush = True)
|
|
|
|
def checkDBOption(db):
|
|
dbs = db.split(',')
|
|
|
|
def printDBOption(db):
|
|
dbs = db.split(',')
|
|
for dbname in dbs:
|
|
pass
|
|
|
|
def parseOption(db):
|
|
dbs = db.split(',')
|
|
dbnames = []
|
|
server_hash = {}
|
|
for dbname in dbs:
|
|
if dbname.isdigit():
|
|
server_hash[int(dbname)] = 1
|
|
elif dbname.find('-') > -1:
|
|
begin_idx, end_idx = dbname.split('-')
|
|
for server_id in range(int(begin_idx), int(end_idx) + 1):
|
|
server_hash[server_id] = 1
|
|
else:
|
|
dbnames.append(dbname)
|
|
#end for dbs
|
|
server_list = []
|
|
for server_id in server_hash.keys():
|
|
server_list.append(server_id)
|
|
server_list.sort()
|
|
for server_id in server_list:
|
|
dbnames.append(str(server_id))
|
|
return dbnames
|
|
|
|
def readCombineRule():
|
|
json_data = json.loads(open('../tools_conf/combine_rule.json', 'r').read())
|
|
return json_data
|
|
|
|
def readRedisRule():
|
|
json_data = json.loads(open('../tools_conf/redis_rule.json', 'r').read())
|
|
return json_data
|
|
|
|
def readServerListConf():
|
|
json_data = json.loads(open('../tools_conf/server_list.json', 'r').read())
|
|
assert len(json_data) > 1
|
|
mysql_conf = getMysqlConf()
|
|
for svr in json_data:
|
|
svr['db_host'] = mysql_conf['db_host']
|
|
svr['db_port'] = int(mysql_conf['db_port'])
|
|
svr['db_user'] = mysql_conf['db_user']
|
|
svr['db_passwd'] = mysql_conf['db_passwd']
|
|
return json_data
|
|
|
|
def getGlobalRedisConf():
|
|
json_data = json.loads(open(tools_conf_dir + 'db_conf.json', 'r').read())
|
|
return json_data['global_redis']
|
|
|
|
def getMysqlConf():
|
|
json_data = json.loads(open(tools_conf_dir + 'db_conf.json', 'r').read())
|
|
return json_data['mysql']
|
|
|
|
def getGameConf(server_id):
|
|
global config_obj
|
|
conf = config_obj['game'][server_id]
|
|
assert conf
|
|
return conf
|
|
|
|
def _checkTables(rule_conf, rows):
|
|
assert(len(rule_conf) == len(rows))
|
|
for row in rows:
|
|
if row[0] not in rule_conf:
|
|
error(row[0])
|
|
assert False
|
|
|
|
def _checkColumns(table_name, a_columns, b_columans):
|
|
#print(table_name,a_columns,b_columans)
|
|
assert len(a_columns) > 0 and len(a_columns) == len(b_columans)
|
|
|
|
for a_col in a_columns:
|
|
found = False
|
|
for b_col in b_columans:
|
|
if a_col['Field'] == b_col['Field']:
|
|
found = True
|
|
break
|
|
#end for b_col
|
|
if not found:
|
|
print(a_col, b_col)
|
|
assert found
|
|
|
|
def checkDB(db_conf, rule_conf):
|
|
table_columns = {}
|
|
rolename_hash = {}
|
|
for conf in db_conf:
|
|
conn = pymysql.connect(host = conf['db_host'],
|
|
port = conf['db_port'],
|
|
user = conf['db_user'],
|
|
passwd = conf['db_passwd'],
|
|
db = 'legend_' + str(conf['serverid']),
|
|
charset = 'utf8'
|
|
)
|
|
assert conn
|
|
cursor = conn.cursor()
|
|
cursor.execute('SHOW TABLES;')
|
|
rows = cursor.fetchall()
|
|
_checkTables(rule_conf, rows)
|
|
|
|
cursor = conn.cursor(cursor = pymysql.cursors.DictCursor)
|
|
for rule in rule_conf.values():
|
|
cursor.execute('SHOW COLUMNS FROM %s;' % (rule['table_name']) )
|
|
rows = cursor.fetchall()
|
|
if rule['table_name'] in table_columns:
|
|
_checkColumns(rule['table_name'], table_columns[rule['table_name']], rows)
|
|
else:
|
|
table_columns[rule['table_name']] = rows
|
|
|
|
|
|
cursor = conn.cursor(cursor = pymysql.cursors.DictCursor)
|
|
cursor.execute('SELECT * FROM role;')
|
|
rows = cursor.fetchall()
|
|
for row in rows:
|
|
assert row['name'] not in rolename_hash
|
|
rolename_hash[row['name']] = row
|
|
# pprint.pprint(row)
|
|
|
|
conn.close()
|
|
|
|
def runLocalCmd(cmd):
|
|
p = subprocess.Popen(cmd, stdout=subprocess.PIPE, stderr=subprocess.PIPE, shell=True)
|
|
output, error_info = p.communicate()
|
|
info(output)
|
|
if p.returncode != 0:
|
|
errmsg = ''
|
|
if isinstance(error_info, list) or isinstance(error_info, tuple):
|
|
errmsg = error_info[0]
|
|
error(errmsg)
|
|
|
|
def dropDataBase(conf, dbname):
|
|
info('正在删除%s数据库 host:%s port:%d' % (dbname, conf['db_host'], conf['db_port']))
|
|
cmdline = 'mysql -h%s -u%s -p%s -e"drop database if exists %s"' % (
|
|
conf['db_host'],
|
|
conf['db_user'],
|
|
conf['db_passwd'],
|
|
dbname,
|
|
)
|
|
info(cmdline)
|
|
ret = runLocalCmd(cmdline)
|
|
return ret
|
|
|
|
def clearRedis(conf, redis_name):
|
|
info('正在删除%s host:%s port:%d' % (redis_name, conf['redis_host'], conf['redis_port']))
|
|
cmdline = 'redis-cli -h %s -p %s -n 0 flushdb' % (
|
|
conf['redis_host'],
|
|
conf['redis_port']
|
|
)
|
|
info(cmdline)
|
|
ret = runLocalCmd(cmdline)
|
|
|
|
def importMysql(conf, dbname, dumpfile, char_set, nodata = False):
|
|
info('正在删除%s数据库 host:%s port:%d' % (dbname, conf['db_host'], conf['db_port']))
|
|
cmdline = 'mysql -h%s -u%s -p%s -e"drop database if exists %s"' % (
|
|
conf['db_host'],
|
|
conf['db_user'],
|
|
conf['db_passwd'],
|
|
dbname,
|
|
)
|
|
info(cmdline)
|
|
ret = runLocalCmd(cmdline)
|
|
info('正在创建%s数据库 host:%s port:%d' % (dbname, conf['db_host'], conf['db_port']))
|
|
cmdline = 'mysql -h%s -u%s -p%s -e"create database %s %s"' % (
|
|
conf['db_host'],
|
|
conf['db_user'],
|
|
conf['db_passwd'],
|
|
dbname,
|
|
char_set
|
|
)
|
|
info(cmdline)
|
|
ret = runLocalCmd(cmdline)
|
|
if not nodata:
|
|
info('正在导入%s数据 host:%s port:%d' % (dbname, conf['db_host'], conf['db_port']))
|
|
cmdline = 'mysql -h%s -u%s -p%s %s -e"source %s"' % (
|
|
conf['db_host'],
|
|
conf['db_user'],
|
|
conf['db_passwd'],
|
|
dbname,
|
|
'../data/mysql/' + dumpfile
|
|
)
|
|
info(cmdline)
|
|
ret = runLocalCmd(cmdline)
|
|
|
|
def importRedis(conf, redis_name, rdbfile):
|
|
info('正在删除%s host:%s port:%d' % (redis_name, conf['redis_host'], conf['redis_port']))
|
|
cmdline = 'redis-cli -h %s -p %s -n 0 flushdb' % (
|
|
conf['redis_host'],
|
|
conf['redis_port']
|
|
)
|
|
info(cmdline)
|
|
ret = runLocalCmd(cmdline)
|
|
info('正在stop%s host:%s port:%d' % (redis_name, conf['redis_host'], conf['redis_port']))
|
|
cmdline = 'ssh %s "systemctl stop redis_%d.service"' % (
|
|
conf['redis_host'],
|
|
conf['redis_port']
|
|
)
|
|
info(cmdline)
|
|
ret = runLocalCmd(cmdline)
|
|
time.sleep(2)
|
|
assert os.path.exists('../data/redis/%s' % (rdbfile))
|
|
info('正在复制%s文件到 host:%s' % (rdbfile, conf['redis_host']))
|
|
cmdline = 'scp ../data/redis/%s root@%s:/data/logs/redis/dump_%d.rdb' % (
|
|
rdbfile,
|
|
conf['redis_host'],
|
|
conf['redis_port']
|
|
)
|
|
info(cmdline)
|
|
ret = runLocalCmd(cmdline)
|
|
cmd = 'ssh %s "chown -R kingsome. /data/logs/redis/"' % (conf['redis_host'])
|
|
runLocalCmd(cmd)
|
|
info('正在重启redis导入rdb_%d.rdb' % (conf['redis_port']))
|
|
if is_test_env:
|
|
cmdline = 'ssh %s "redis-server /etc/redis/redis_%d.conf"' % (
|
|
# cmdline = 'ssh %s "ls -al" && echo ok' % (
|
|
conf['redis_host'],
|
|
conf['redis_port'],
|
|
)
|
|
else:
|
|
cmdline = 'ssh %s "systemctl start redis_%d.service"' % (
|
|
conf['redis_host'],
|
|
conf['redis_port'],
|
|
)
|
|
info(cmdline)
|
|
ret = runLocalCmd(cmdline)
|
|
|
|
def _parseServerList():
|
|
server_list = json.loads(open(tools_conf_dir + 'server_list.json', 'r').read())
|
|
configObj = {
|
|
'group': {},
|
|
'admin': {},
|
|
'conf': {},
|
|
'cross': {},
|
|
'game': {},
|
|
'gate': {},
|
|
'global': {},
|
|
'load': {},
|
|
'logger': {},
|
|
'nginx': {},
|
|
'pay': {},
|
|
'stage': {},
|
|
}
|
|
global config_obj
|
|
config_obj = configObj
|
|
groupObj = configObj['group']
|
|
gameObj = configObj['game']
|
|
loggerObj = configObj['logger']
|
|
stageObj = configObj['stage']
|
|
confObj = configObj['conf']
|
|
mysql_conf = getMysqlConf()
|
|
for svr in server_list:
|
|
assert svr['serverid'] not in gameObj
|
|
gameObj[svr['serverid']] = {
|
|
'serverid': svr['serverid'],
|
|
'db_host': mysql_conf['db_host'],
|
|
'db_port': int(mysql_conf['db_port']),
|
|
'db_user': mysql_conf['db_user'],
|
|
'db_passwd': mysql_conf['db_passwd'],
|
|
'redis_host': svr['redis_host'],
|
|
'redis_port': int(svr['redis_port']),
|
|
'_i': svr
|
|
}
|
|
_checkServerList(configObj)
|
|
|
|
def _checkServerList(configObj):
|
|
pass
|
|
|
|
_parseServerList()
|