def cluster_resoure(self, cluster, resource_type):
zkOper = Requests_ZkOpers()
exists = zkOper.check_containerCluster_exists(cluster)
if not exists:
error_message = 'container cluster %s not exist, please check your cluster name' % cluster
raise HTTPAPIError(status_code=417, error_detail=error_message,
notification="direct",
log_message=error_message,
response=error_message)
container_node_list = zkOper.retrieve_container_list(cluster)
result = []
for container_node in container_node_list:
resource = {}
resource_value = zkOper.retrieve_container_resource(cluster, container_node, resource_type)
host_ip = self.container_opers.get_host_ip_from_zk(cluster, container_node)
container_name = self.container_opers.get_container_name_from_zk(cluster, container_node)
resource.setdefault('value', resource_value)
resource.setdefault('hostIp', host_ip)
resource.setdefault('containerName', container_name)
result.append(resource)
return result
def create_result(self, containerClusterName, container_names=[]):
create_successful = {'code': "000000"}
creating = {'code': "000001"}
create_failed = {'code': "000002", 'status': Status.create_failed}
zkOper = Requests_ZkOpers()
exists = zkOper.check_containerCluster_exists(containerClusterName)
if not exists:
raise UserVisiableException('containerCluster %s not existed' %
containerClusterName)
result = {}
container_cluster_info = zkOper.retrieve_container_cluster_info(
containerClusterName)
start_flag = container_cluster_info.get('start_flag')
if start_flag == Status.failed:
result.update(create_failed)
result.setdefault('error_msg', 'create containers failed!')
elif start_flag == Status.succeed:
create_info = self.__created_info(containerClusterName,
container_names)
result.update(create_successful)
result.update(create_info)
else:
result.update(creating)
return result
def sync(self):
clusters_zk_info = self.get_clusters_zk()
clusters = []
for cluster_name, nodes in clusters_zk_info.items():
try:
cluster, nodeInfo = {}, []
logging.info('sync action, cluster name:%s' % cluster)
cluster_status = self.component_container_cluster_validator.container_cluster_status_validator(
cluster_name)
cluster.update(cluster_status)
cluster.setdefault('clusterName', cluster_name)
zkOper = Requests_ZkOpers()
cluster_info = zkOper.retrieve_container_cluster_info(
cluster_name)
_type = cluster_info.get('type')
cluster.setdefault('type', _type)
for _, node_value in nodes.items():
container_info = node_value.get('container_info')
con = Container_Model()
create_info = con.create_info(container_info)
nodeInfo.append(create_info)
cluster.setdefault('nodeInfo', nodeInfo)
clusters.append(cluster)
except:
self.threading_exception_queue.put(sys.exc_info())
continue
return clusters
def get_server_resource(host_ip, resource_type):
zk_opers = Requests_ZkOpers()
result = {}
resource_value = zk_opers.retrieve_server_resource(
host_ip, resource_type)
result.setdefault(resource_type, resource_value)
return result
def get_clusters_zk(self):
zkOper = Requests_ZkOpers()
cluster_name_list = zkOper.retrieve_cluster_list()
clusters_zk_info = {}
for cluster_name in cluster_name_list:
cluster_info_dict = self.get_cluster_zk(cluster_name)
clusters_zk_info.setdefault(cluster_name, cluster_info_dict)
return clusters_zk_info
def check(self, containerClusterName):
zkOper = Requests_ZkOpers()
exists = zkOper.check_containerCluster_exists(containerClusterName)
if not exists:
raise UserVisiableException('containerCluster %s not existed' %
containerClusterName)
cluster_status = self.component_container_cluster_validator.container_cluster_status_validator(
containerClusterName)
return cluster_status
def get(self):
args = self.get_all_arguments()
host_ip = args.get('hostIp')
logging.info('get server %s ports' % host_ip)
zkOper = Requests_ZkOpers()
ports = zkOper.get_ports_from_portPool(host_ip)
result = {}
result.setdefault('ports', ports)
self.finish(result)
def get(self):
zkOper = Requests_ZkOpers()
clusterUUID = zkOper.getClusterUUID()
data, _ = zkOper.retrieveClusterProp(clusterUUID)
self.confOpers.setValue(options.server_cluster_property, eval(data))
result = {}
result.setdefault("message",
"sync server cluster info to local successful!")
self.finish(result)
def get_container_resource(self, container_name, resource_type):
zk_opers = Requests_ZkOpers()
result = {}
cluster_name = get_containerClusterName_from_containerName(
container_name)
node_name = self.container_opers.get_container_node_from_container_name(
cluster_name, container_name)
resource_value = zk_opers.retrieve_container_resource(
cluster_name, node_name, resource_type)
result.setdefault('value', resource_value)
result.setdefault('containerName', container_name)
return result
def post(self):
requestParam = self.get_all_arguments()
zkOper = Requests_ZkOpers()
existCluster = zkOper.existCluster()
if existCluster:
clusterUUID = zkOper.getClusterUUID()
else:
clusterUUID = str(uuid.uuid1())
requestParam.setdefault("clusterUUID", clusterUUID)
if requestParam != {}:
self.confOpers.setValue(options.server_cluster_property,
requestParam)
self.confOpers.setValue(options.data_node_property, requestParam)
clusterProps = self.confOpers.getValue(options.server_cluster_property)
dataNodeProprs = self.confOpers.getValue(options.data_node_property)
zkOper.writeClusterInfo(clusterUUID, clusterProps)
zkOper.writeDataNodeInfo(clusterUUID, dataNodeProprs)
return_message = {}
return_message.setdefault("message",
"creating server cluster successful!")
self.finish(return_message)
def get_cluster_zk(self, cluster_name):
cluster_zk_info = {}
zkOper = Requests_ZkOpers()
container_ip_list = zkOper.retrieve_container_list(cluster_name)
for container_ip in container_ip_list:
container_node = {}
create_info = zkOper.retrieve_container_node_value(
cluster_name, container_ip)
status = zkOper.retrieve_container_status_value(
cluster_name, container_ip)
container_node.setdefault('container_info', create_info)
container_node.setdefault('status', status)
cluster_zk_info.setdefault(container_ip, container_node)
return cluster_zk_info
def __cluster_created_info(self, cluster):
zkOper = Requests_ZkOpers()
message_list = []
container_node_list = zkOper.retrieve_container_list(cluster)
result = {}
for container_node in container_node_list:
container_node_value = zkOper.retrieve_container_node_value(
cluster, container_node)
con = Container_Model()
create_info = con.create_info(container_node_value)
message_list.append(create_info)
result.setdefault('containers', message_list)
return result
def do(self):
zkOper = Requests_ZkOpers()
monitor_types = zkOper.retrieve_monitor_type()
stat_dict = {}
for monitor_type in monitor_types:
monitor_status_list = zkOper.retrieve_monitor_status_list(
monitor_type)
monitor_type_sub_dict = {}
for monitor_status_key in monitor_status_list:
monitor_status_value = zkOper.retrieve_monitor_status_value(
monitor_type, monitor_status_key)
monitor_type_sub_dict.setdefault(monitor_status_key,
monitor_status_value)
stat_dict.setdefault(monitor_type, monitor_type_sub_dict)
return stat_dict
def __created_info(self, cluster, container_names=[]):
zkOper = Requests_ZkOpers()
message_list, container_nodes = [], []
if container_names:
for container_name in container_names:
container_node = self.container_opers.get_container_node_from_container_name(
cluster, container_name)
if not container_node:
raise UserVisiableException('container :%s not existed' %
container_name)
container_nodes.append(container_node)
else:
container_nodes = zkOper.retrieve_container_list(cluster)
result = {}
for container_node in container_nodes:
container_node_value = zkOper.retrieve_container_node_value(
cluster, container_node)
con = Container_Model()
create_info = con.create_info(container_node_value)
message_list.append(create_info)
result.setdefault('containers', message_list)
return result
def __update_white_list(self, conf_dict):
error_msg = ''
conf_white_str = conf_dict.get('servers')
ip_pattern = '(((2[0-4]\d|25[0-5]|[01]?\d\d?)\.){3}(2[0-4]\d|25[0-5]|[01]?\d\d?),)+((2[0-4]\d|25[0-5]|[01]?\d\d?)\.){3}(2[0-4]\d|25[0-5]|[01]?\d\d?)'
if not re.match(ip_pattern, conf_white_str):
error_msg = 'the values of the params is not correct'
logging.error(error_msg)
return error_msg
zkOper = Requests_ZkOpers()
conf_white_list = conf_white_str.split(',')
privs_white_list = zkOper.retrieve_servers_white_list()
add = list(set(conf_white_list) - set(privs_white_list))
delete = list(set(privs_white_list) - set(conf_white_list))
both = list(set(privs_white_list) & set(conf_white_list))
for item in add:
zkOper.add_server_into_white_list(item)
for item in delete:
zkOper.del_server_from_white_list(item)
return error_msg
def get(self):
zkOper = Requests_ZkOpers()
ips = zkOper.get_ips_from_ipPool()
result = {}
result.setdefault('ips', ips)
self.finish(result)
