def remove(self, args):
"""
remove node in some cluster
"""
cluster = args.get('containerClusterName')
if not cluster:
raise UserVisiableException(
'params containerClusterName not be given, please check the params!'
)
containers = args.get('containerNameList')
if not containers:
raise UserVisiableException(
'params containerNameList not be given, please check the params!'
)
_containers = containers.split(',')
zkOper = Container_ZkOpers()
exists = zkOper.check_containerCluster_exists(cluster)
if not exists:
raise UserVisiableException(
'containerCluster %s not existed, no need to remove' % cluster)
containerCluster_remove_node_action = ContainerCluster_RemoveNode_Action(
cluster, _containers)
containerCluster_remove_node_action.start()
def add(self, args):
cluster = args.get('containerClusterName', None)
if not cluster:
raise UserVisiableException(
'params containerClusterName not be given, please check the params!'
)
node_count = args.get('nodeCount')
if not node_count:
raise UserVisiableException(
'params nodeCount not be given, please check the params!')
if not args.has_key('networkMode'):
raise UserVisiableException(
'params networkMode not be given, please check the params!')
component_type = args.get('componentType', None)
if not component_type:
raise UserVisiableException(
'params componentType not be given, please check the params!')
zkOper = Container_ZkOpers()
exists = zkOper.check_containerCluster_exists(cluster)
if not exists:
raise UserVisiableException(
'cluster %s not exist, you should give a existed cluster when add node to it!'
% cluster)
container_names = self.container_opers.generate_container_names(
component_type, node_count, cluster)
args.setdefault('container_names', container_names)
containerCluster_create_action = ContainerCluster_Add_Action(args)
containerCluster_create_action.start()
return container_names
def create(self, params):
if params == {} or params is None:
raise UserVisiableException("please set the componentNode info!")
dataNodeInternalPort = params.get('dataNodeInternalPort')
if dataNodeInternalPort is not None:
raise UserVisiableException(
"no need to set the dataNodeInternalPort param!")
zkOper = Common_ZkOpers()
local_uuid = getClusterUUID()
existCluster = zkOper.existCluster(local_uuid)
if not existCluster:
raise UserVisiableException(
"sync componentCluster info error! please check if sync uuid is right!"
)
params.setdefault("dataNodeInternalPort", options.port)
dataNodeExternalPort = params.get('dataNodeExternalPort')
if dataNodeExternalPort is None or '' == dataNodeExternalPort:
params.setdefault("dataNodeExternalPort", options.port)
self.confOpers.setValue(options.data_node_property, params)
dataNodeProprs = self.confOpers.getValue(options.data_node_property)
zkOper.writeDataNodeInfo(local_uuid, dataNodeProprs)
result = {}
result.setdefault(
"message",
"Configuration on this componentNode has been done successfully")
return result
def start(self):
zkOper = Common_ZkOpers()
existCluster = zkOper.existCluster()
if not existCluster:
raise UserVisiableException("Nginx componentCluster does't exist")
total_nginx_nodes = zkOper.retrieve_nginx_node_list()
started_nodes = zkOper.retrieve_started_nodes()
if len(total_nginx_nodes) == len(started_nodes):
raise UserVisiableException(
"all nginx nodes have started. No need to start them.")
logging.info("all nginx nodes: %s" % (total_nginx_nodes))
to_start_nginx_nodes = list(
set(total_nginx_nodes) - set(started_nodes))
logging.info("nginx needed to start: " + str(to_start_nginx_nodes))
node_infos = []
for node in to_start_nginx_nodes:
info = zkOper.retrieve_nginx_node_info(node)
node_infos.append(info)
self.baseOpers(node_infos, OperType.start)
result_dict = {
'message': 'cluster start processing, please wait for a moment!'
}
return result_dict
def destory(self, containerClusterName):
if not containerClusterName:
raise UserVisiableException('no containerClusterName param')
zkOper = Container_ZkOpers()
exists = zkOper.check_containerCluster_exists(containerClusterName)
if not exists:
raise UserVisiableException(
'containerCluster %s not existed, no need to remove' %
containerClusterName)
containerCluster_destroy_action = ContainerCluster_destroy_Action(
containerClusterName)
containerCluster_destroy_action.start()
def set_container_cpuset(self, args):
container_name = args.get('containerName')
exists = self.check_container_exists(container_name)
if not exists:
raise UserVisiableException("container(name:%s) dont's existed!" %
(container_name))
cpus = args.get('cpus')
if not cpus:
raise UserVisiableException("params cpus should be given!")
add_ret = {}
state_opers = StateOpers(container_name)
cpuset_value = state_opers.set_cpuset(cpus)
add_ret.setdefault(container_name, cpuset_value)
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 statistic(self):
if not re.match("\d+\:\d+", self.dev_number):
raise UserVisiableException('get device number wrong :%s' % self.dev_number)
_file = self.file % self._container_id
with open_with_error(_file) as (f, err):
if not err:
content = f.read()
else:
logging.error(err)
return
_read, _write = 0, 0
_readpattern = '%s Read (\d+ ?)' % self.dev_number
_writepattern = '%s Write (\d+ ?)' % self.dev_number
if re.search(_readpattern, content) and \
re.search(_writepattern, content):
_read = re.findall(_readpattern, content)[0]
_read = int(_read)
_write = re.findall(_writepattern, content)[0]
_write = int(_write)
if self._total_read_bytes and self._total_write_bytes:
self._read_iops = (_read - self._total_read_bytes)/options.container_gather_duration
self._write_iops = (_write - self._total_write_bytes)/options.container_gather_duration
self._total_read_bytes = _read
self._total_write_bytes = _write
def create(self, args):
require_args = ('containerClusterName', 'networkMode', 'componentType')
for arg in require_args:
if not args.get(arg):
raise UserVisiableException(
'Params %s invalid or not be given!' % arg)
cluster_name = args.get('containerClusterName', None)
zkOper = Container_ZkOpers()
exists = zkOper.check_containerCluster_exists(cluster_name)
if exists:
raise UserVisiableException(
'containerCluster %s has existed, choose another containerCluster name'
% cluster_name)
containerCluster_create_action = ContainerCluster_create_Action(args)
containerCluster_create_action.start()
def __extend_memsw(self, times):
memsw_value = self.get_con_limit_memsw()
extend_value = int(memsw_value) * int(times)
if not self.echo_value_to_file(extend_value, self.limit_memsw_path):
raise UserVisiableException(
'extend container: %s memroy swap faild, please check!' %
self.container_name)
return extend_value
def set_container_cpushares(self, args):
container_name = args.get('containerName')
exists = self.check_container_exists(container_name)
if not exists:
raise UserVisiableException("container(name:%s) dont's existed!" %
container_name)
times = args.get('times')
if not times:
raise UserVisiableException("params times should be given!")
add_ret = {}
cpushares = 1024 * eval(times)
state_opers = StateOpers(container_name)
cpushares_value = state_opers.set_cpushares(int(cpushares))
add_ret.setdefault(container_name, cpushares_value)
return add_ret
def syncExistedCluster(self, params):
if params == {}:
error_message = "please fill the cluster uuid!"
raise UserVisiableException(error_message)
clusterUUID = params['clusterUUID']
zkOper = Common_ZkOpers()
existCluster = zkOper.existCluster(clusterUUID)
if not existCluster:
error_message = "Nginx componentCluster does't exist(cluster id:%s), \
please specify the right cluster uuid!" % (clusterUUID)
raise UserVisiableException(error_message)
data, _ = zkOper.retrieveClusterProp(clusterUUID)
logging.info("data in zk %s" % (data))
json_str_data = data.replace("'", "\"")
dict_data = json.loads(json_str_data)
self.confOpers.setValue(options.cluster_property, dict_data)
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 stop(self, containerClusterName):
zkOper = Container_ZkOpers()
exists = zkOper.check_containerCluster_exists(containerClusterName)
if not exists:
raise UserVisiableException(
'containerCluster %s not existed, choose another containerCluster name'
% containerClusterName)
containerCluster_stop_action = ContainerCluster_stop_Action(
containerClusterName)
containerCluster_stop_action.start()
def open_containers_under_oom(self, container_name_list):
result = {}
containers = self._get_containers(container_name_list)
for container in containers:
conl = StateOpers(container)
ret = conl.open_container_under_oom()
if not ret:
raise UserVisiableException(
'container %s under oom value open failed' % container)
result.setdefault(container, ret)
return result
def createCluster(self, params):
if params == {} or params is None:
raise UserVisiableException("please set the componentNode info!")
dataNodeInternalPort = params.get('dataNodeInternalPort')
if dataNodeInternalPort:
raise UserVisiableException(
"no need to set the dataNodeInternalPort param!")
zkOper = ZkOpers()
try:
existCluster = zkOper.existCluster()
if existCluster:
raise UserVisiableException(
"server has belong to a componentCluster,should be not create new componentCluster!"
)
clusterUUID = str(uuid.uuid1())
params.setdefault("clusterUUID", clusterUUID)
params.setdefault("dataNodeInternalPort", options.port)
dataNodeExternalPort = params.get('dataNodeExternalPort')
if dataNodeExternalPort is None or '' == dataNodeExternalPort:
params.setdefault("dataNodeExternalPort", options.port)
self.confOpers.setValue(options.cluster_property, params)
self.confOpers.setValue(options.data_node_property, params)
clusterProps = self.confOpers.getValue(options.cluster_property)
dataNodeProprs = self.confOpers.getValue(
options.data_node_property)
zkOper.writeClusterInfo(clusterUUID, clusterProps)
zkOper.writeDataNodeInfo(clusterUUID, dataNodeProprs)
finally:
zkOper.close()
return clusterUUID
def set_containers_disk_bps(self,
container_name_list,
container_type,
method='write',
data=0):
result = {}
containers = self._get_containers(container_name_list)
for container in containers:
stat_op = StateOpers(container)
ret = stat_op.set_container_disk_bps(container_type, method, data)
if not ret:
raise UserVisiableException(
'container %s set disk bps failed' % container)
result.setdefault(container, {'bps': ret})
return result
def check(self, container_name):
exists = self.check_container_exists(container_name)
if not exists:
raise UserVisiableException("container(name:%s) dont's existed!" %
(container_name))
container_operation_record = self.retrieve_container_status_from_containerName(
container_name)
status = container_operation_record.get('status')
message = container_operation_record.get('message')
result = {}
result.setdefault('status', status)
result.setdefault('message', message)
return result
def stop(self):
zkOper = Common_ZkOpers()
node_infos = []
started_nodes_list = zkOper.retrieve_started_nodes()
if not started_nodes_list:
raise UserVisiableException(
'cluster has been stopped, no need to do this!')
for nginx_node in started_nodes_list:
info = zkOper.retrieve_nginx_node_info(nginx_node)
node_infos.append(info)
self.baseOpers(node_infos, OperType.stop)
result_dict = {
'message': 'cluster stop processing, please wait for a moment!'
}
return result_dict
def disable(self):
zkOper = Common_ZkOpers()
node_infos = []
_nodes_list = zkOper.retrieve_nginx_node_list()
if not _nodes_list:
raise UserVisiableException(
"cluster has not node, please check the cluster's node!")
for _node in _nodes_list:
info = zkOper.retrieve_nginx_node_info(_node)
node_infos.append(info)
self.baseOpers(node_infos, OperType.disable)
result_dict = {
'message':
'cluster proxy disable processing, please wait for a moment!'
}
return result_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 set_cpuset(self, cpus):
if not self.echo_value_to_file(cpus, self.cpuset_path):
raise UserVisiableException(
'set container :%s cpus value:%s failed' %
(self.container_name, cpus))
return self.get_cpuset_value()
def set_cpushares(self, cpushares="1024"):
if not self.echo_value_to_file(cpushares, self.cpushares_path):
raise UserVisiableException(
'set container :%s cpu.shares value:% failed' %
(self.container_name, cpushares))
return self.get_cpushares_value()
