namespace_opt.py

'''
@Descripttion: 命名空间底层操作
@Author: guohb65
@Email: guohb65@chinaunicom.cn
@Date: 2019-12-11 09:39:22
@LastEditors: guohb65
@LastEditTime: 2019-12-12 16:11:52
'''

from cucc_common_pkg.util_pkg.common_func import CommonFunc
from cucc_common_pkg.util_pkg.const import ConstGen, K8SRestUrl, RequestMethod, K8SObjStr, NamespaceStatus, \
    K8SRestStr
from cucc_common_pkg.util_pkg.resource_obj_opt import ResourceObjOpt

NS_NAME_STR = "ns_name"
NS_STATUS_STR = "ns_status"
CREATE_TIME_STR = "create_time"
NS_DESC_STR = "ns_desc"
API_VERSION_VAL = "v1"
KIND_STR = "kind"
NAMESPACE_STR = "Namespace"
HEADERS = "headers"
DATA_STR = "data"


class NamespaceOPT(object):

    def namespace_is_exist(self, api_server, namespace, token=None):
        """
        查询namespace是否已经在集群中存在
        :param api_server:
        :param namespace:
        :param token:
        :return:
        """
        if namespace is not None:
            ret = self.namespace_list(api_server, token)
            if ret[ConstGen.RET_CODE] is ConstGen.SUCCESS_CODE:
                namespaces_list = ret[ConstGen.DATA_ROWS_STR]
                i = 0
                namespaces_name_list = []
                while i < len(namespaces_list):
                    ns_obj = namespaces_list[i]
                    namespaces_name_list.append(ns_obj[NS_NAME_STR])
                    i += 1
                if namespace in namespaces_name_list:
                    return True
                else:
                    return False
            else:
                print(ret[ConstGen.RET_VAL])
                return None
        else:
            print("[namespace]参数缺失")
            return None

    def namespace_list(self, api_server, token=None):
        """
        查询namespace列表
        :param api_server:
        :param token:
        :return:
        """
        if api_server is not None:
            ret = ResourceObjOpt().object_list(api_server, K8SRestUrl.NAMESPACES_REST_URL, None, K8SRestStr.NAMESPACES,
                                               token, None)
            if ConstGen.RET_CODE in ret and ret[ConstGen.RET_CODE] is ConstGen.SUCCESS_CODE:
                ret_dict = ret[ConstGen.DATA_ROWS_STR]
                namespaces_list = []
                if K8SObjStr.ITEM_KEY in ret_dict:
                    i = 0
                    while i < len(ret_dict[K8SObjStr.ITEM_KEY]):
                        meta_data = ret_dict[K8SObjStr.ITEM_KEY][i][
                            K8SObjStr.METADATA_KEY]
                        namespace = {NS_NAME_STR: meta_data[K8SObjStr.NAME_KEY]}
                        ns_status = ret_dict[K8SObjStr.ITEM_KEY][i][
                            K8SObjStr.STATUS_KEY][K8SObjStr.PHASE_KEY]
                        namespace[NS_STATUS_STR] = NamespaceStatus[ns_status].value
                        namespace[CREATE_TIME_STR] = CommonFunc().create_time_format(
                            meta_data[K8SObjStr.CREATE_TIME_KEY])
                        if K8SObjStr.ANNOTATIONS_KEY in meta_data:
                            annotations_data = meta_data[K8SObjStr.ANNOTATIONS_KEY]
                            if K8SObjStr.NS_DESC_KEY in annotations_data:
                                namespace[NS_DESC_STR] = annotations_data[K8SObjStr.NS_DESC_KEY]
                        namespaces_list.append(namespace)
                        i += 1
                return CommonFunc().gen_inner_resp_data(ConstGen.SUCCESS_CODE, ConstGen.SUCCESS_STR, namespaces_list)
            else:
                return CommonFunc().gen_inner_resp_data(ret[ConstGen.RET_CODE], ret[ConstGen.RET_VAL])
        else:
            return CommonFunc().gen_inner_resp_data(ConstGen.FAIL_CODE, "[api_server]缺失")

    def namespace_add(self, api_server, ns_name, ns_desc, token=None):
        """
        新增namespace
        :param api_server:
        :param ns_name:
        :param ns_desc:
        :param token:
        :param ca_crt_data:
        :param client_crt_data:
        :param client_key_data:
        :return:
        """
        if api_server is not None:
            is_exist = self.namespace_is_exist(api_server, ns_name, token)
            if is_exist is True:
                ret = CommonFunc.gen_inner_resp_data(ConstGen.FAIL_CODE, "命名空间已存在")
            else:
                body_data = {}
                meta_data = {}
                annotations = {K8SObjStr.NS_DESC_KEY: ns_desc}
                meta_data[K8SObjStr.NAME_KEY] = ns_name
                meta_data[K8SObjStr.ANNOTATIONS_KEY] = annotations
                body_data[K8SObjStr.API_VERSION_STR] = API_VERSION_VAL
                body_data[KIND_STR] = NAMESPACE_STR
                body_data[K8SObjStr.METADATA_KEY] = meta_data
                ret = ResourceObjOpt().object_create(api_server, K8SRestUrl.NAMESPACES_REST_URL, None,
                                                     K8SRestStr.NAMESPACES, body_data, token)

        else:
            ret = CommonFunc.gen_inner_resp_data(ConstGen.FAIL_CODE, "[api_server]缺失")
        return ret

    @staticmethod
    def namespace_delete(api_server, namespace, token=None):
        """
        删除namespace
        :param api_server:
        :param namespace:
        :param token:
        :return:
        """
        if api_server is not None and namespace is not None:
            ret = ResourceObjOpt().object_opt(api_server, K8SRestUrl.NAMESPACES_REST_URL, RequestMethod.DELETE.value,
                                              None, K8SRestStr.NAMESPACES, namespace, None, token)
        else:
            ret = CommonFunc.gen_inner_resp_data(ConstGen.FAIL_CODE, "[api_server或namespace]缺失")
        return ret