def post(self):
requestParam = {}
args = self.request.arguments
for key in args:
requestParam.setdefault(key, args[key][0])
if not requestParam:
raise HTTPAPIErrorException("params is empty")
#TODO:
'''1.judge throwing code reuse rate is very low.
2.thrown error code directly, automatically reads the type of error, error messages, and so on.'''
if "zkAddress" not in requestParam or 'zkPort' not in requestParam:
raise HTTPAPIErrorException(
"zkaddress or port is empty, please check it!")
if self.confOpers.ipFormatChk(requestParam['zkAddress']):
raise HTTPAPIErrorException("zkaddress is illegal",
status_code=417)
self.confOpers.setValue(options.mcluster_manager_cnf, requestParam)
self.adminOpers.sync_info_from_zk(requestParam['zkAddress'][0])
result = {}
# dict.setdefault("code", '000000')
result.setdefault("message", "admin conf successful!")
self.finish(result)
def delete(self, dbName, userName, ipAddress):
if not dbName:
raise HTTPAPIErrorException("when remove db's user, no specify the database name,\
please specify the database name.",
status_code=417)
if not userName:
raise HTTPAPIErrorException("when remove db's user, no specify the user name,\
please specify the user name.",
status_code=417)
if not ipAddress:
raise HTTPAPIErrorException("when remove db's user, no specify the ip address,\
please specify the ip address.",
status_code=417)
conn = self.dba_opers.get_mysql_connection()
try:
self.dba_opers.delete_user(conn, userName, ipAddress)
finally:
conn.close()
# check if exist cluster
zkOper = self.retrieve_zkOper()
clusterUUID = zkOper.getClusterUUID()
zkOper.remove_db_user(clusterUUID, dbName, userName, ipAddress)
result = {}
result.setdefault("message", "removed user successfully!")
result.setdefault("user_name", userName)
result.setdefault("ip_address", ipAddress)
self.finish(result)
def get(self):
args = self.request.arguments
forceInit = args['forceInit'][0]
isLock = False
lock = None
try:
zkOper = self.retrieve_zkOper()
#existCluster = zkOper.existCluster()
isLock,lock = zkOper.lock_init_node_action()
dataNodeProKeyValue = self.confOpers.getValue(options.data_node_property, ['dataNodeIp','dataNodeName'])
data_node_ip = dataNodeProKeyValue['dataNodeIp']
data_node_name = dataNodeProKeyValue['dataNodeName']
clusterProKeyValue = self.confOpers.getValue(options.cluster_property, ['clusterUUID','clusterName'])
clusterUUID = clusterProKeyValue['clusterUUID']
#check if cluster has odd data node
if not forceInit:
dataNodeNumber = zkOper.getDataNodeNumber(clusterUUID)
if dataNodeNumber / 2 == 0:
raise HTTPAPIErrorException("the number should be not odd number,please add 1 or 3 data node into cluster!",
status_code=417)
clusterName = clusterProKeyValue['clusterName']
clusterAddress = 'gcomm://%s' % (data_node_ip)
requestParam = {'wsrep_cluster_name': clusterName, 'wsrep_node_address': data_node_ip, 'wsrep_cluster_address':clusterAddress, 'wsrep_node_name':data_node_name}
self.confOpers.setValue(options.mysql_cnf_file_name, requestParam)
sst_user_password = self.invokeCommand.runBootstrapScript()
mysql_cnf_text = self.confOpers.retrieveFullText(options.mysql_cnf_file_name)
zkOper.writeMysqlCnf(clusterUUID, mysql_cnf_text)
zkOper.write_started_node(data_node_ip)
except kazoo.exceptions.LockTimeout:
raise HTTPAPIErrorException("the mysql cluster is initing,please wait for the completion of other machine join this cluster.",
status_code=417)
finally:
if isLock:
zkOper.unLock_init_node_action(lock)
result = {}
# dict.setdefault("code", '000000')
result.setdefault("message", "init cluster successful!")
result.setdefault("sst_user_password", sst_user_password)
self.finish(result)
def post(self):
zkOper = self.retrieve_zkOper()
backup_type = self.get_argument("backup_type")
if not backup_type:
raise HTTPAPIErrorException(
"backup_type params is not given, please check 'backup_type' params.",
status_code=417)
result = {"message": "%s backup is starting" % backup_type}
backup_info = zkOper.retrieve_type_backup_status_info(backup_type)
# 不要问我从哪里来，我的故乡在远方。翻翻历史便可知。
_tmp_type = 'backup' if backup_type == 'full' else 'incr_backup'
backup_start_time = backup_info['{tmp_type}_start_time:'.format(
tmp_type=_tmp_type)]
backup_status = backup_info['{tmp_type}_status:'.format(
tmp_type=_tmp_type)]
backup_time = datetime.datetime.strptime(
backup_start_time, "%Y-%m-%d %H:%M:%S").strftime('%Y%m%d%H%M%S')
local_backup_result = get_local_backup_status(backup_type, backup_time)
_msgs = {
'backup_succecced': "{backup_type} backup success",
'backup_starting': "{backup_type} backup is starting",
'backup_failed': "{backup_type} backup is failed"
}
if local_backup_result:
result["message"] = _msgs[backup_status].format(
backup_type=backup_type)
self.finish(result)
def post(self):
args = self.request.arguments
requestParam = {}
for key in args:
requestParam.setdefault(key, args[key][0])
cluster_flag = requestParam.get('cluster_flag')
if cluster_flag != 'new' and cluster_flag != 'old':
raise HTTPAPIErrorException("arguments are wrong, retry again.", status_code=417)
try:
self.mysql_service_opers.start(cluster_flag, None)
except kazoo.exceptions.LockTimeout:
raise HTTPAPIErrorException("current operation is using by other people, please wait a moment to try again!",
status_code=578)
result = {}
# dict.setdefault("code", '000000')
result.setdefault("message", "due to start cluster need a large of times, please wait to finished and email to you, when cluster have started!")
self.finish(result)
def get(self, ip_address):
if ip_address is None:
error_message = "you should specify the ip address need to sync"
raise HTTPAPIErrorException(error_message, status_code=417)
zkOper = self.retrieve_zkOper()
return_result = zkOper.retrieve_data_node_info(ip_address)
self.confOpers.setValue(options.data_node_property, return_result)
result = {}
# dict.setdefault("code", "000000")
result.setdefault("message", "sync data node info to local successful!")
self.finish(result)
def post(self):
requestParam = {}
args = self.request.arguments
logging.info("args :" + str(args))
if not args:
raise HTTPAPIErrorException("params is empty")
for key in args:
value = args[key][0]
if key == 'adminPassword':
value = base64.encodestring(value).strip('\n')
requestParam.setdefault(key, value)
if "adminUser" not in requestParam or 'adminPassword' not in requestParam:
raise HTTPAPIErrorException(
"admin user or password is empty, please check it!")
self.confOpers.setValue(options.cluster_property, requestParam)
result = {}
# dict.setdefault("code", '000000')
result.setdefault("message", "creating admin user successful!")
self.finish(result)
def post(self):
backup_type = self.get_argument("backup_type")
incr_basedir = self.get_arguments("incr_basedir")
if not backup_type:
raise HTTPAPIErrorException(
"backup params is not transmit, please check 'backup_type' params.",
status_code=417)
backup_worker = BackupWorkers(backup_type, incr_basedir)
backup_worker.start()
result = {}
result.setdefault("message",
"inner backup process is running, please waiting")
self.finish(result)
def get_local_backup_status(full_type, time_path):
result = False
if full_type == 'full':
file_name = FULL_LOG_FILE_PATH + time_path + '_script.log'
else:
file_name = INCR_LOG_FILE_PATH + time_path + '_incr_script.log'
try:
with open(file_name, 'r') as f:
for line in f.readlines():
if line.find('backup is completed ==') != -1:
result = True
return result
except Exception,e:
raise HTTPAPIErrorException("no such a backup file", status_code=500)
def get(self):
try:
zkOper = self.retrieve_zkOper()
existCluster = zkOper.existCluster()
cluster_status = zkOper.retrieveClusterStatus()
cluster_started_nodes = zkOper.retrieve_started_nodes()
except kazoo.exceptions.LockTimeout:
raise HTTPAPIErrorException("current operation is using by other people, please wait a moment to try again!",
status_code=578)
result = {}
# dict.setdefault("code", '000000')
result['message'] = cluster_status['_status']
result['nodelist'] = cluster_started_nodes
self.finish(result)
def post(self):
incr_basedir = self.get_argument("incr_basedir", None)
backup_type = self.get_argument("backup_type")
if not backup_type:
raise HTTPAPIErrorException(
"backup params is not given, please check 'backup_type' params.",
status_code=417)
zkOper = Requests_ZkOpers()
zkOper.write_backup_backup_info({"backup type": "backup is building"})
worker = DispatchBackupWorker(backup_type, incr_basedir)
worker.start()
result = {}
result.setdefault("message",
"backup process is running, please waiting")
self.finish(result)
def post(self):
#check if exist cluster
zkOper = self.retrieve_zkOper()
existCluster = zkOper.existCluster()
if existCluster:
if zkOper.judgeClusterStatus("remove"):
zkOper.remove_zk_info(CLUSTER_NAME)
else:
raise HTTPAPIErrorException("server has belong to a cluster,should be not create new cluster!", status_code=417)
requestParam = {}
args = self.request.arguments
logging.info("args :" + str(args))
if not args:
raise HTTPAPIErrorException("params is empty")
for key in args:
value = args[key][0]
requestParam.setdefault(key, value)
if "clusterName" not in requestParam or 'dataNodeName' not in requestParam:
raise HTTPAPIErrorException("cluster_name or node_name is empty, please check it!")
if 'dataNodeIp' not in requestParam:
raise HTTPAPIErrorException("node_ip is empty, please check it!")
cluster_name = requestParam['clusterName']
if len(cluster_name) >= 33:
raise HTTPAPIErrorException("Cluster name is too long, please use name whoes length is less than 33 characters",
status_code=417)
if self.confOpers.ipFormatChk(requestParam['dataNodeIp']):
raise HTTPAPIErrorException("dataNodeIp is illegal", status_code=417)
clusterUUID = cluster_name + '/' + str(uuid.uuid1())
requestParam.setdefault("clusterUUID",clusterUUID)
if requestParam != {}:
self.confOpers.setValue(options.cluster_property, requestParam)
self.confOpers.setValue(options.data_node_property, requestParam)
clusterProps = self.confOpers.getValue(options.cluster_property)
dataNodeProprs = self.confOpers.getValue(options.data_node_property)
zkOper.writeClusterInfo(clusterUUID, clusterProps)
zkOper.writeDataNodeInfo(clusterUUID, dataNodeProprs)
result = {}
# dict.setdefault("code", '000000')
result.setdefault("message", "creating cluster successful!")
self.finish(result)
def get(self):
zkOper = self.retrieve_zkOper()
if not is_monitoring(get_localhost_ip(), zkOper):
self.finish("true")
return
try:
check_result = self.dba_opers.retrieve_wsrep_status()
logging.info("check_wsrepstatus : %s" % (check_result))
except:
error_message = "connection break down"
raise HTTPAPIErrorException(error_message, status_code=417)
if not check_result:
self.finish("false")
return
self.finish("true")
def get(self):
try:
self.mysql_service_opers.stop()
except kazoo.exceptions.LockTimeout:
raise HTTPAPIErrorException("current operation is using by other people, please wait a moment to try again!",
status_code=578)
status_dict = {}
status_dict['_status'] = 'stopping'
zkOper = self.retrieve_zkOper()
existCluster = zkOper.existCluster()
zkOper.writeClusterStatus(status_dict)
result = {}
#dict.setdefault("code", '000000')
result.setdefault("message", "due to stop cluster need a large of times, please wait to finished and email to you, when cluster have stoped!")
self.finish(result)
def delete(self, dbName):
if not dbName:
raise HTTPAPIErrorException(
"when remove the db, no have database name,\
please provide database name you want to removed!",
status_code=417)
zkOper = self.retrieve_zkOper()
clusterUUID = zkOper.getClusterUUID()
user_ipAddress_map = zkOper.retrieve_db_user_prop(clusterUUID, dbName)
conn = self.dba_opers.get_mysql_connection()
try:
if user_ipAddress_map is not None:
for (user_name, ip_address) in user_ipAddress_map.items():
self.dba_opers.delete_user(conn, user_name, ip_address)
self.dba_opers.drop_database(conn, dbName)
finally:
conn.close()
user_name_list = ''
if user_ipAddress_map is not None:
for (user_name, ip_address) in user_ipAddress_map.items():
zkOper.remove_db_user(clusterUUID, dbName, user_name,
ip_address)
user_name_list += user_name + ","
zkOper.remove_db(clusterUUID, dbName)
result = {}
result.setdefault("message", "database remove successful!")
result.setdefault("removed_db_name", dbName)
result.setdefault("removed_user_with_db_name", user_name_list)
self.finish(result)
self.finish(return_flag)
return
finally:
if not conn:
conn.close()
t_threshold = options.delta_time
n_stamp_time = time.time()
record_stamp_time = time.mktime(time.strptime(record_time,
TIME_FORMAT))
delta_time = n_stamp_time - record_stamp_time
if delta_time > t_threshold:
error_message = 'delta_time between read and write exceed the threshold time, the delta_time is %s' % (
delta_time)
raise HTTPAPIErrorException(error_message, status_code=500)
return_flag = 'true'
self.finish(return_flag)
# retrieve the database stat with innotop
# eg. curl "http://localhost:8888/db/all/stat"
class DBStat(APIHandler):
stat_opers = DBStatOpers()
@asynchronous
@engine
def get(self):
args = self.request.arguments
def post(self):
role = self.get_argument("role", None)
dbName = self.get_argument("dbName", None)
userName = self.get_argument("userName", None)
user_password = self.get_argument("user_password", None)
ip_address = self.get_argument("ip_address", '%')
max_queries_per_hour = self.get_argument("max_queries_per_hour", 0)
max_updates_per_hour = self.get_argument("max_updates_per_hour", 0)
max_connections_per_hour = self.get_argument("max_connections_per_hour", 0)
max_user_connections = self.get_argument("max_user_connections", 200)
dict = {}
dict = self.request.arguments
if dict.has_key("user_password"):
del dict["user_password"]
logging.info(str(dict))
if role is None:
raise HTTPAPIErrorException("when create db's user, no specify the user role, please specify the user role.",
status_code=417)
if dbName is None:
raise HTTPAPIErrorException("when create db's user, no specify the database name, please specify the database name.",
status_code=417)
if userName is None:
raise HTTPAPIErrorException("when create db's user, no specify the user name, please specify the user name.",
status_code=417)
if ip_address is None:
raise HTTPAPIErrorException("when create db's user, no specify the ip address, please specify the ip address.",
status_code=417)
if user_password is None:
user_password = get_random_password()
existed_flag = "true"
conn = self.dba_opers.get_mysql_connection()
try:
existed_flag = self.dba_opers.check_if_existed_database(conn, dbName)
if existed_flag == "false":
raise HTTPAPIErrorException("Please create database " + dbName + " first",
status_code=417)
self.dba_opers.create_user(conn, userName, user_password, ip_address)
if 'manager' == role:
self.dba_opers.grant_manager_privileges(conn, userName, user_password, dbName, ip_address,
max_queries_per_hour,
max_updates_per_hour,
max_connections_per_hour,
max_user_connections)
elif 'wr' == role:
self.dba_opers.grant_wr_privileges(conn, userName, user_password, dbName, ip_address,
max_queries_per_hour,
max_updates_per_hour,
max_connections_per_hour,
max_user_connections)
elif 'ro' == role:
max_updates_per_hour = 1
self.dba_opers.grant_readonly_privileges(conn, userName, user_password, dbName, ip_address,
max_queries_per_hour,
max_connections_per_hour,
max_user_connections)
else:
# use try catch to close the conn
# conn.close()
raise HTTPAPIErrorException("please valid the specified role, the type is [manager,ro,wr]", status_code=417)
self.dba_opers.flush_privileges(conn)
finally:
conn.close()
# check if exist cluster
zkOper = self.retrieve_zkOper()
clusterUUID = zkOper.getClusterUUID()
userProps = {'role': role,
'max_queries_per_hour': max_queries_per_hour,
'max_updates_per_hour': max_updates_per_hour,
'max_connections_per_hour': max_connections_per_hour,
'max_user_connections': max_user_connections}
zkOper.write_user_info(clusterUUID, dbName, userName, ip_address, userProps)
result = {}
# dict.setdefault("code", '000000')
result.setdefault("message", "user has been created successful!")
result.setdefault("user_role", role)
result.setdefault("user_name", userName)
result.setdefault("user_password", user_password)
self.finish(result)
def post(self):
requestParam = {}
args = self.request.arguments
logging.info("args :" + str(args))
if not args:
raise HTTPAPIErrorException("params is empty")
for key in args:
value = args[key][0]
requestParam.setdefault(key, value)
if "dataNodeName" not in requestParam or "dataNodeIp" not in requestParam:
raise HTTPAPIErrorException("dataNodeName or dataNodeIp is empty, please check it!")
if self.confOpers.ipFormatChk(requestParam['dataNodeIp']):
raise HTTPAPIErrorException("dataNodeIp is illegal", status_code=417)
self.confOpers.setValue(options.data_node_property, requestParam)
dataNodeProprs = self.confOpers.getValue(options.data_node_property)
zkOper = self.retrieve_watch_zkOper()
clusterUUID = zkOper.getClusterUUID()
zkOper.writeDataNodeInfo(clusterUUID, dataNodeProprs)
data, _ = zkOper.retrieveClusterProp(clusterUUID)
self.confOpers.setValue(options.cluster_property, eval(data))
fullText, _ = zkOper.retrieveMysqlProp(clusterUUID)
self.confOpers.writeFullText(options.mysql_cnf_file_name, fullText)
data_node_ip = requestParam.get('dataNodeIp')
mycnfParam = self.confOpers.getValue(options.mysql_cnf_file_name)
orginal_cluster_address = mycnfParam['wsrep_cluster_address']
index = orginal_cluster_address.find("//")
ip_str = orginal_cluster_address[index + 2:]
ip_lists = ip_str.rstrip().split(",")
if data_node_ip in ip_lists:
error_message = "this node have add to cluster, no need to add it!"
raise HTTPAPIErrorException(error_message, status_code=417)
new_cluster_address = orginal_cluster_address + "," + str(data_node_ip)
data_node_name = requestParam.get('dataNodeName')
# mysql_cnf_full_text = self.confOpers.retrieveFullText(options.mysql_cnf_file_name)
# self.confOpers.writeFullText(options.mysql_cnf_file_name, mysql_cnf_full_text)
keyValueMap = {}
keyValueMap.setdefault('wsrep_cluster_address', new_cluster_address)
keyValueMap.setdefault('wsrep_node_name', str(data_node_name))
keyValueMap.setdefault('wsrep_node_address', str(data_node_ip))
self.confOpers.setValue(options.mysql_cnf_file_name, keyValueMap)
mysql_cnf_full_text = self.confOpers.retrieveFullText(options.mysql_cnf_file_name)
zkOper.writeMysqlCnf(clusterUUID, mysql_cnf_full_text)
result = {}
# dict.setdefault("code", "000000")
result.setdefault("message", "add data node into cluster successful!")
self.finish(result)
def put(self):
dbName = self.get_argument("dbName", None)
userName = self.get_argument("userName", None)
ip_address = self.get_argument("ip_address", '%')
max_queries_per_hour = self.get_argument("max_queries_per_hour", None)
max_updates_per_hour = self.get_argument("max_updates_per_hour", None)
max_connections_per_hour = self.get_argument("max_connections_per_hour", None)
max_user_connections = self.get_argument("max_user_connections", None)
role = self.get_argument("role", None)
if dbName is None:
raise HTTPAPIErrorException("when modify db's user, no specify the database name, please specify the database name.",
status_code=417)
if userName is None:
raise HTTPAPIErrorException("when modify db's user, no specify the user name, please specify the user name.",
status_code=417)
if ip_address is None:
raise HTTPAPIErrorException("when modify db's user, no specify the ip address, please specify the ip address.",
status_code=417)
if max_queries_per_hour is None and max_updates_per_hour is None and max_connections_per_hour is None and max_user_connections is None:
raise HTTPAPIErrorException("when modify db's user, no specify any modified parameter, please specify the ip address.\
please specify any one or all of following parameter:[max_queries_per_hour,\
max_updates_per_hour,max_connections_per_hour,max_user_connections]",
status_code=417)
if role is None:
raise HTTPAPIErrorException("when modify db's user, no specify the role, please specify the role.",
status_code=417)
conn = self.dba_opers.get_mysql_connection()
try:
zkOper = self.retrieve_zkOper()
clusterUUID = zkOper.getClusterUUID()
user_limit_map = {}
if not max_queries_per_hour or not max_updates_per_hour or not max_connections_per_hour or not max_user_connections:
user_limit_map = zkOper.retrieve_user_limit_props(clusterUUID, dbName, userName, ip_address)
if not user_limit_map:
raise HTTPAPIErrorException("when modify db's user, no found specified user!\
please check the valid of the specified user, because the system no found the user!",
status_code=417)
if max_queries_per_hour is None:
max_queries_per_hour = user_limit_map.get('max_queries_per_hour')
if max_updates_per_hour is None:
max_updates_per_hour = user_limit_map.get('max_updates_per_hour')
if max_connections_per_hour is None:
max_connections_per_hour = user_limit_map.get('max_connections_per_hour')
if max_user_connections is None:
max_user_connections = user_limit_map.get('max_user_connections')
self.dba_opers.grant_resource_limit(conn, userName, dbName, ip_address, role,
max_queries_per_hour,
max_updates_per_hour,
max_connections_per_hour,
max_user_connections)
self.dba_opers.flush_privileges(conn)
userProps = {'role': user_limit_map.get('role'),
'max_queries_per_hour': max_queries_per_hour,
'max_updates_per_hour': max_updates_per_hour,
'max_connections_per_hour': max_connections_per_hour,
'max_user_connections': max_user_connections}
zkOper.write_user_info(clusterUUID, dbName, userName, ip_address, userProps)
finally:
conn.close()
result = {}
result.setdefault("message", "modify the user's resource limit successfully!")
result.setdefault("db_name", dbName)
result.setdefault("user_name", userName)
self.finish(result)
def _check_backup_stat(self):
zkOper = self.retrieve_zkOper()
backup_info = zkOper.retrieve_backup_status_info()
result = {}
if not backup_info:
raise HTTPAPIErrorException(
"this cluster is not backup, please full backup!",
status_code=417)
if 'backup type' in backup_info and 'backup is building' == backup_info[
'backup type']:
result.setdefault("message", 'backup is processing')
return result
if 'recently_backup_ip: ' not in backup_info:
raise HTTPAPIErrorException("last time backup is not successed",
status_code=417)
last_backup_ip = backup_info['recently_backup_ip: ']
last_backup_time = backup_info['time: ']
last_backup_type = {'backup_type': backup_info['backup_type: ']}
time = long(datetime.datetime.now().strftime('%Y%m%d%H%M%S'))
backup_time = long(
datetime.datetime.strptime(
last_backup_time,
"%Y-%m-%d %H:%M:%S").strftime('%Y%m%d%H%M%S'))
url_post = "/backup/checker"
if (time - backup_time) / 10000 > 30:
result.setdefault("message", "last backup expired")
else:
response_message = get_response_request(last_backup_ip, url_post,
last_backup_type)
logging.info(response_message)
if response_message["meta"]["code"] == 417:
result.setdefault(
"message", "inner backup interface params transmit failed")
elif response_message["meta"]["code"] == 200:
message = response_message['response']
if -1 != message['message'].find('success'):
result.setdefault(
"message", '%s backup success, backup ip: %s' %
(last_backup_type['backup_type'], last_backup_ip))
if -1 != message['message'].find('starting'):
result.setdefault(
"message",
'last time %s backup is processing, backup ip: %s' %
(last_backup_type['backup_type'], last_backup_ip))
else:
result.setdefault(
"message",
'last time %s backup failed, backup ip: %s' %
(last_backup_type['backup_type'], last_backup_ip))
else:
result.setdefault(
"message", 'last time %s backup failed, backup ip: %s' %
(last_backup_type['backup_type'], last_backup_ip))
return result
def do(self, isNewCluster):
try:
self.mysql_service_opers.start(isNewCluster)
except Exception, kazoo.exceptions.LockTimeout:
raise HTTPAPIErrorException("current operation is using by other people, please wait a moment to try again!",
status_code=417)
