Initial commit

cucc_common_pkg/util_pkg/cke_cluster_info.py

+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+'''
+@Descripttion: CKE集群信息查询
+@Author: guohb65
+@Email: guohb65@chinaunicom.cn
+@Date: 2020/4/15 10:21
+@LastEditors: guohb65
+@LastEditTime: 2020/4/15 10:21
+'''
+import json
+import os
+
+import requests
+import urllib3
+
+from cucc_common_pkg.util_pkg.common_func import CommonFunc
+from cucc_common_pkg.util_pkg.const import RequestMethod, ConstGen, ResponseCode
+
+CKE_DOMAIN = "CKE_DOMAIN"
+CKE_SVC_TIMEOUT = "CKE_SVC_TIMEOUT"
+ACCESS_TOKEN = "accessToken"
+CKE_URL_REGIONS = "/regions/"
+CKE_URL_CLUSTER_URL = "/k8s/v2/clusters"
+CKE_URL_ADMIN_TOKEN = "adminToken"
+CKE_KEY_API_SERVER = "apiserver"
+CKE_KEY_NETWORK = "network"
+CKE_KEY_VPC = "vpc"
+CKE_KEY_ADMIN_TOKEN = "AdminToken"
+
+
+class CkeClusterInfo(object):
+
+    def __init__(self, login_cookie=None):
+        env_dist = os.environ
+        common_mount_path = env_dist.get(ConstGen.COMMON_MOUNT_PATH)
+        common_conf_file = open(common_mount_path, 'r')
+        common_data_json = json.loads(common_conf_file.read())
+        common_conf_file.close()
+        self.cke_domain = common_data_json.get(CKE_DOMAIN)
+        if CKE_SVC_TIMEOUT in common_data_json:
+            self.cke_svc_timeout = int(common_data_json.get(CKE_SVC_TIMEOUT))
+        else:
+            self.cke_svc_timeout = 3
+        self.login_cookie = login_cookie
+
+    def get_cke_list(self, regions):
+        request_url = self.cke_domain + CKE_URL_REGIONS + regions + CKE_URL_CLUSTER_URL
+        urllib3.disable_warnings()
+        try:
+            resp = requests.request(RequestMethod.GET.value, request_url, cookies=self.login_cookie,
+                                    timeout=self.cke_svc_timeout, verify=False)
+        except Exception as e:
+            print("CKE请求异常：" + e.__str__())
+            return False, e.__str__(), 404
+        resp_code = resp.status_code
+        if resp_code == 200:
+            if ConstGen.CONTENT_TYPE_JSON in resp.headers.get(ConstGen.CONTENT_TYPE) and resp.text is not None:
+                resp_json = json.loads(resp.text)
+            else:
+                resp_json = []
+            cluster_data = []
+            for cluster in resp_json:
+                apiservers = cluster.get(CKE_KEY_API_SERVER)
+                apiserver_list = apiservers.split(";")
+                apiserver = apiserver_list[0]
+                if apiserver is not "":
+                    apiserver_tuple = apiserver.split(":")
+                    cluster_ip = apiserver_tuple[1][2:]
+                    cluster_port = apiserver_tuple[2]
+                    post_handle_cluster = {"cluster_name": cluster.get("name"), "cluster_ip": cluster_ip,
+                                           "cluster_port": cluster_port, "cluster_type": "CKE",
+                                           "cluster_apiserver": apiserver, "cluster_apiservers": apiserver_list}
+                    cluster_data.append(post_handle_cluster)
+            return True, cluster_data
+        else:
+            return False, resp.text
+
+    def list_cke_cluster(self, regions):
+        ret_tuple = self.get_cke_list(regions)
+        if ret_tuple[0]:
+            return CommonFunc().fabricate_response_data(ConstGen.SUCCESS_CODE, ResponseCode.OK.value,
+                                                        ConstGen.SUCCESS_STR, None, ret_tuple[1])
+        else:
+            return CommonFunc().fabricate_response_data(ConstGen.FAIL_CODE, ResponseCode.Failure.value, ret_tuple[1])
+
+    def get_cke_info(self, region_id, cluster_name):
+        cluster_type = "CKE"
+        cke_info = self.get_cke_rest_info(region_id, cluster_name)
+        token = self.get_cke_token(region_id, cluster_name)
+        if cke_info is not None and token is not None:
+            api_servers = json.loads(cke_info).get(CKE_KEY_API_SERVER)
+            apiserver_list = api_servers.split(";")
+            api_server = apiserver_list[0]
+            network = json.loads(cke_info).get(CKE_KEY_NETWORK)
+            vpc = json.loads(cke_info).get(CKE_KEY_VPC)
+            if type(api_server) is str and type(token) is str:
+                apiserver = api_server.split(":")
+                cluster_ip = apiserver[1][2:]
+                cluster_port = apiserver[2]
+                cluster_info = {"cluster_type": cluster_type, "cluster_ip": cluster_ip, "cluster_port": cluster_port,
+                                "cluster_token": token, "cluster_apiserver": api_server,
+                                "cluster_apiservers": apiserver_list}
+                if type(network) is str:
+                    cluster_info["cluster_network"] = network
+                if type(vpc) is str:
+                    cluster_info["cluster_vpc"] = vpc
+            else:
+                cluster_info = {}
+        else:
+            cluster_info = {}
+        print(cluster_info)
+        return cluster_info
+
+    def get_cke_apiserver(self, regions, cluster_name):
+        request_url = self.cke_domain + CKE_URL_REGIONS + regions + CKE_URL_CLUSTER_URL + "/" + cluster_name
+        print(request_url)
+        urllib3.disable_warnings()
+        try:
+            resp = requests.request(RequestMethod.GET.value, request_url, cookies=self.login_cookie, verify=False)
+        except Exception as e:
+            print("CKE请求异常：" + e.__str__())
+            return e.__str__()
+        resp_code = resp.status_code
+        if resp_code == 200:
+            if ConstGen.CONTENT_TYPE_JSON in resp.headers.get(ConstGen.CONTENT_TYPE) and resp.text is not None:
+                resp_json = json.loads(resp.text)
+                apiservers = resp_json.get(CKE_KEY_API_SERVER)
+                apiserver_list = apiservers.split(";")
+                return apiserver_list[0]
+            else:
+                return None
+        else:
+            return None
+
+    def get_cke_rest_info(self, regions, cluster_name):
+        if self.login_cookie is not None:
+            request_url = self.cke_domain + CKE_URL_REGIONS + regions + CKE_URL_CLUSTER_URL + "/" + cluster_name
+            print(request_url)
+            urllib3.disable_warnings()
+            try:
+                resp = requests.request(RequestMethod.GET.value, request_url, cookies=self.login_cookie, verify=False)
+                print(resp.text)
+            except Exception as e:
+                print("CKE请求异常：" + e.__str__())
+                return None
+            resp_code = resp.status_code
+            if resp_code == 200:
+                if ConstGen.CONTENT_TYPE_JSON in resp.headers.get(ConstGen.CONTENT_TYPE) and resp.text is not None:
+                    return resp.text
+                else:
+                    return None
+            else:
+                return None
+        else:
+            return None
+
+    def get_cke_token(self, regions, cluster_name):
+        if self.login_cookie is not None:
+            request_url = self.cke_domain + CKE_URL_REGIONS + regions + CKE_URL_CLUSTER_URL + "/" + cluster_name \
+                          + "/" + CKE_URL_ADMIN_TOKEN
+            urllib3.disable_warnings()
+            try:
+                resp = requests.request(RequestMethod.GET.value, request_url, cookies=self.login_cookie, verify=False)
+
+            except Exception as e:
+                print("CKE请求异常：" + e.__str__())
+                return None
+            resp_code = resp.status_code
+            if resp_code == 200:
+                if ConstGen.CONTENT_TYPE_JSON in resp.headers.get(ConstGen.CONTENT_TYPE) and resp.text is not None:
+                    resp_json = json.loads(resp.text)
+                    return resp_json.get(CKE_KEY_ADMIN_TOKEN)
+                else:
+                    return None
+            else:
+                return None
+        else:
+            return None

cucc_common_pkg/util_pkg/common_dao.py

+'''
+@Description: 通用数据操作类
+@Author: guohb65
+@Email: guohb65@chinaunicom.cn
+@Date: 2019-12-10 09:15:07
+@LastEditTime : 2019-12-18 14:30:58
+@LastEditors  : guohb65
+'''
+
+import json
+import uuid
+
+from .common_func import CommonFunc
+from .const import ConstGen
+
+COUNTS = "counts"
+
+
+class CommonDAO(object):
+
+    def simple_add(self, unique_data, others_data, table_name, primary_key="uid", primary_value=None):
+        """
+        新增
+        :param primary_key:
+        :param table_name:
+        :param others_data:
+        :param unique_data:
+        :return:
+        """
+        if self.data_is_exist(unique_data, table_name):
+            return CommonFunc.gen_inner_resp_data(ConstGen.FAIL_CODE, "名称重复")
+        else:
+            insert_data = dict(unique_data, **others_data)
+            trans_data = self.gen_insert_sql(
+                insert_data, table_name, primary_key, primary_value)
+            print(trans_data)
+            ret = CommonFunc().request_trans_service(
+                ConstGen.TRANS_SQL_URL, trans_data)
+            return self.simple_handle_ret_data(ret)
+
+    def simple_alter(self, update_data, update_condition, table_name):
+        """
+        修改
+        :param update_condition:
+        :param update_data:
+        :param table_name:
+        :return:
+        """
+        if ConstGen.UNIQUE_STR in update_data:
+            unique_data = update_data[ConstGen.UNIQUE_STR]
+            update_data.pop(ConstGen.UNIQUE_STR)
+            update_data = dict(update_data, **unique_data)
+            if self.data_is_exist_except_self(unique_data, update_condition, table_name):
+                return CommonFunc.gen_inner_resp_data(ConstGen.FAIL_CODE, "名称重复")
+        if ConstGen.OTHERS_STR in update_data:
+            others_data = update_data[ConstGen.OTHERS_STR]
+            update_data.pop(ConstGen.OTHERS_STR)
+            update_data = dict(update_data, **others_data)
+        trans_data = self.gen_update_sql(update_data, update_condition, table_name)
+        if trans_data is None:
+            return CommonFunc.gen_inner_resp_data(ConstGen.FAIL_CODE, "更新参数传输异常")
+        else:
+            ret = CommonFunc().request_trans_service(ConstGen.TRANS_SQL_URL, trans_data)
+            return self.simple_handle_ret_data(ret)
+
+    def simple_delete(self, delete_condition, table_name):
+        """
+        删除
+        :param delete_condition:
+        :param table_name:
+        :return:
+        """
+        trans_data = self.gen_delete_sql(delete_condition, table_name)
+        if trans_data is None:
+            return CommonFunc.gen_inner_resp_data(ConstGen.FAIL_CODE, "删除数据参数传输异常")
+        else:
+            ret = CommonFunc().request_trans_service(
+                ConstGen.TRANS_SQL_URL, trans_data)
+            return self.simple_handle_ret_data(ret)
+
+    def simple_query(self, request, table_name):
+        """
+        信息查询
+        :param table_name:
+        :param request:
+        :return:
+        """
+        data_params = CommonFunc().request_param2dict(request)
+        query_condition = data_params.get(ConstGen.CONDITION_STR)
+        trans_data = self.gen_query_all_sql(query_condition, None, table_name)
+        if trans_data is None:
+            return CommonFunc.gen_inner_resp_data(ConstGen.FAIL_CODE, "查询条件不存在")
+        else:
+            ret_data = CommonFunc().request_trans_service(
+                ConstGen.STANDER_SQL_URL, trans_data)
+            condition = json.loads(query_condition)
+            page_num = None
+            page_size = None
+            if ConstGen.PAGE_STR in condition:
+                page_info = condition.get(ConstGen.PAGE_STR)
+                if ConstGen.PAGE_NUM_STR in page_info:
+                    page_num = page_info[ConstGen.PAGE_NUM_STR]
+                if ConstGen.PAGE_SIZE_STR in page_info:
+                    page_size = page_info[ConstGen.PAGE_SIZE_STR]
+            if page_num is not None and page_size is not None:
+                ret_data = json.loads(ret_data)
+                start_index = (int(page_num) - 1) * int(page_size)
+                if int(ret_data[ConstGen.ROWCOUNT_STR]) < start_index:
+                    ret_data.pop(ConstGen.DATA_ROWS_STR)
+                    ret_data[ConstGen.PAGE_COUNT_STR] = "0"
+                else:
+                    if ConstGen.DATA_ROWS_STR in ret_data:
+                        all_data_rows = ret_data[ConstGen.DATA_ROWS_STR]
+                        data_rows = all_data_rows[start_index: start_index +
+                                                               int(page_size)]
+                        ret_data[ConstGen.DATA_ROWS_STR] = data_rows
+                        ret_data[ConstGen.PAGE_COUNT_STR] = len(data_rows)
+                    else:
+                        ret_data[ConstGen.PAGE_COUNT_STR] = '0'
+            return ret_data
+
+    @staticmethod
+    def simple_handle_ret_data(ret):
+        """
+        返回结果处理
+        :param ret:
+        :return:
+        """
+        if ret[ConstGen.RET_CODE] is ConstGen.SUCCESS_CODE:
+            ret.pop(ConstGen.DATA_ROWS_STR)
+        return ret
+
+    @staticmethod
+    def package_sql(sql_key, sql_str):
+        """
+        封装传输的sql数据格式
+        :param sql_str:
+        :param sql_key:
+        :return:
+        """
+        trans_sql_data = {}
+        trans_data = {}
+        if sql_key == ConstGen.TRANS_SQL_STR:
+            trans_sql_data[ConstGen.TRANS_SQL_STR] = sql_str
+            trans_data[ConstGen.TRANS_JSON_ARRAY_STR] = json.dumps(
+                [trans_sql_data])
+        if sql_key == ConstGen.SQL_STR:
+            trans_data[ConstGen.SQL_STR] = sql_str
+        return trans_data
+
+    @staticmethod
+    def package_write_sql_list(sql_list):
+        """
+        封装传输的sql数据格式
+        :param sql_str:
+        :param sql_key:
+        :return:
+        """
+        return {ConstGen.TRANS_JSON_ARRAY_STR: json.dumps(sql_list)}
+
+    def exec_query_sql(self, sql_string):
+        """
+        执行sql查询语句
+        :param sql_string:
+        :return:
+        """
+        trans_data = self.package_sql(
+            ConstGen.SQL_STR, sql_string)
+        print(trans_data)
+        return CommonFunc().request_trans_service(
+            ConstGen.STANDER_SQL_URL, trans_data)
+
+    def gen_insert_sql(self, dict_data, table_name, primary_key, primary_value=None):
+        """
+        参数字典转insertsql语句
+        :param dict_data:
+        :param table_name:
+        :param primary_key:
+        :param primary_value:
+        :return:
+        """
+        if primary_value is None:
+            primary_value = uuid.uuid1().__str__().replace('-', '')
+        insert_sql = "insert into " + table_name + "(" + primary_key + "," \
+                     + list(dict_data.keys()).__str__()[1:-1].replace('\'', '') \
+                     + ")values('" + primary_value + "'," \
+                     + list(dict_data.values()).__str__()[1:-1] + ")"
+        print(insert_sql)
+        return self.package_sql(ConstGen.TRANS_SQL_STR, insert_sql)
+
+    def gen_insert_transsql(self, dict_data, table_name, primary_key, primary_value=None):
+        """
+        参数字典转insertsql语句
+        :param dict_data:
+        :param table_name:
+        :param primary_key:
+        :param primary_value:
+        :return:
+        """
+        if primary_value is None:
+            primary_value = uuid.uuid1().__str__().replace('-', '')
+        insert_sql = "insert into " + table_name + "(" + primary_key + "," \
+                     + list(dict_data.keys()).__str__()[1:-1].replace('\'', '') \
+                     + ")values('" + primary_value + "'," \
+                     + list(dict_data.values()).__str__()[1:-1] + ")"
+        trans_sql_data = {ConstGen.TRANS_SQL_STR: insert_sql}
+        return trans_sql_data
+
+    def gen_update_sql(self, update_data, update_condition, table_name):
+        """
+        数据更新的sql语句生成
+        :param update_condition:
+        :param update_data:
+        :param table_name:
+        :return:
+        """
+
+        if update_condition:
+            update_sql = "update " + table_name + " set "
+            for k in update_data:
+                update_sql += k + "='" + self.reverse_injection_conversion(update_data[k]) + "',"
+            update_sql = update_sql[:-1]
+            update_sql += " where "
+            for k in update_condition:
+                update_sql += k + "='" + self.reverse_injection_conversion(update_condition[k]) + "' and "
+            update_sql += "1=1 "
+            print(update_sql)
+            return self.package_sql(ConstGen.TRANS_SQL_STR, update_sql)
+        else:
+            return None
+
+    def gen_update_tanssql(self, update_data, update_condition, table_name):
+        """
+        数据更新的sql语句生成
+        :param update_condition:
+        :param update_data:
+        :param table_name:
+        :return:
+        """
+
+        if update_condition:
+            update_sql = "update " + table_name + " set "
+            for k in update_data:
+                update_sql += k + "='" + self.reverse_injection_conversion(update_data[k]) + "',"
+            update_sql = update_sql[:-1]
+            update_sql += " where "
+            for k in update_condition:
+                update_sql += k + "='" + self.reverse_injection_conversion(update_condition[k]) + "' and "
+            update_sql += "1=1 "
+            print(update_sql)
+            trans_sql_data = {ConstGen.TRANS_SQL_STR: update_sql}
+            return trans_sql_data
+        else:
+            return None
+
+    def gen_delete_sql(self, delete_condition, table_name):
+        """
+        数据更新的sql语句生成
+        :param delete_condition:
+        :param table_name:
+        :return:
+        """
+        if delete_condition:
+            delete_sql = "delete from " + table_name + " where "
+            for k in delete_condition:
+                delete_sql += k + "='" + self.reverse_injection_conversion(delete_condition[k]) + "' and "
+            delete_sql += "1=1 "
+            print(delete_sql)
+            return self.package_sql(ConstGen.TRANS_SQL_STR, delete_sql)
+        else:
+            return None
+
+    def gen_delete_transsql(self, delete_condition, table_name):
+        """
+        数据更新的sql语句生成
+        :param delete_condition:
+        :param table_name:
+        :return:
+        """
+        if delete_condition:
+            delete_sql = "delete from " + table_name + " where "
+            for k in delete_condition:
+                delete_sql += k + "='" + delete_condition[k] + "' and "
+            delete_sql += "1=1 "
+            print(delete_sql)
+            trans_sql_data = {ConstGen.TRANS_SQL_STR: delete_sql}
+            return trans_sql_data
+        else:
+            return None
+
+    def gen_where_sql_substring(self, sql_str, query_condition, order_dict):
+        """
+        生成where后的sql语句
+        :return:
+        """
+        if query_condition is not None:
+            sql_str += " where "
+            if ConstGen.EXACT_STR in query_condition:
+                exact_condition = query_condition.get(ConstGen.EXACT_STR)
+                for k in exact_condition:
+                    sql_str += k + "='" + self.reverse_injection_conversion(exact_condition[k]) + "' and "
+            if ConstGen.FUZZY_STR in query_condition:
+                fuzzy_condition = query_condition.get(ConstGen.FUZZY_STR)
+                for j in fuzzy_condition:
+                    sql_str += j + " like '%" + \
+                               self.reverse_injection_conversion(fuzzy_condition[j]) + "%' and "
+            sql_str += "1=1 "
+            if order_dict is not None:
+                sql_str += "order by "
+                for order_key in order_dict:
+                    sql_str += order_key + " " + self.reverse_injection_conversion(order_dict[order_key]) + ","
+                sql_str += "1"
+        return sql_str
+
+    def gen_query_all_sql(self, query_condition, order_key, table_name):
+        """
+        数据查询所有字段的sql语句生成
+        :param order_key:
+        :param query_condition:
+        :param table_name:
+        :return:
+        """
+        select_all_sql = "select * from " + table_name
+        final_sql = self.gen_where_sql_substring(
+            select_all_sql, query_condition, order_key)
+        return final_sql
+
+    def gen_query_sql(self, query_condition, order_dict, table_name, query_key_list=None):
+        """
+        数据查询的sql语句生成
+        :param query_condition:
+        :param order_dict:
+        :param table_name:
+        :param query_key_list:
+        :return:
+        """
+        if query_key_list is None:
+            return self.gen_query_all_sql(query_condition, order_dict, table_name)
+        else:
+            select_all_sql = "select "
+            for key in query_key_list:
+                select_all_sql += key + ","
+            select_all_sql = select_all_sql[0:-1] + " from " + table_name
+        final_sql = self.gen_where_sql_substring(
+            select_all_sql, query_condition, order_dict)
+        return final_sql
+
+    def data_is_exist(self, data, table_name):
+        """
+        判断数据表中是否存在该数据
+        :param data:
+        :param table_name:
+        :return:
+        """
+
+        select_sql = "select count(*) as " + COUNTS + \
+                     " from " + table_name + " where "
+        for k in data:
+            select_sql += k + "='" + self.reverse_injection_conversion(data[k]) + "' and "
+        select_sql += "1=1 "
+        trans_data = self.package_sql(ConstGen.SQL_STR, select_sql)
+        ret_dict = CommonFunc().request_trans_service(
+            ConstGen.STANDER_SQL_URL, trans_data)
+        if ret_dict[ConstGen.RET_CODE] is ConstGen.SUCCESS_CODE:
+            counts = int(ret_dict[ConstGen.DATA_ROWS_STR][0][COUNTS])
+            if counts <= 0:
+                return False
+            else:
+                return True
+        else:
+            return None
+
+    def data_is_exist_except_self(self, data, except_data, table_name):
+        """
+        判断数据表中是否存在该数据
+        :param data:
+        :param table_name:
+        :return:
+        """
+
+        select_sql = "select count(*) as " + COUNTS + \
+                     " from " + table_name + " where "
+        for k in data:
+            select_sql += k + "='" + self.reverse_injection_conversion(data[k]) + "' and "
+        for k in except_data:
+            select_sql += k + "!='" + self.reverse_injection_conversion(except_data[k]) + "' and "
+        select_sql += "1=1 "
+        trans_data = self.package_sql(ConstGen.SQL_STR, select_sql)
+        print(trans_data)
+        ret_dict = CommonFunc().request_trans_service(
+            ConstGen.STANDER_SQL_URL, trans_data)
+        if ret_dict[ConstGen.RET_CODE] is ConstGen.SUCCESS_CODE:
+            counts = int(ret_dict[ConstGen.DATA_ROWS_STR][0][COUNTS])
+            if counts <= 0:
+                return False
+            else:
+                return True
+        else:
+            return None
+
+    @staticmethod
+    def reverse_injection_conversion(params):
+        return params.replace("\\", "\\\\").replace("'", "\\'")

cucc_common_pkg/util_pkg/common_func.py

+'''
+@Description: 通用函数
+@Author: guohb65
+@Email: guohb65@chinaunicom.cn
+@Date: 2019-12-10 10:58:53
+@LastEditTime : 2019-12-20 14:51:44
+@LastEditors  : guohb65
+'''
+import datetime
+import json
+import os
+
+import pytz
+import requests
+import urllib3
+from flask import make_response
+
+from cucc_common_pkg import httptrans
+from .const import ConstGen, ResponseCode, K8SOptJsonStr, K8SRestStr
+
+CSM_BS_CODE = 'csm-bs-code'
+CONTENT_TYPE = "Content-Type"
+CONTENT_TYPE_JSON = "application/json"
+RET_DATA = "data"
+ACCESS_MSG = "accessMsg"
+MESSAGE = "message"
+CODE = "code"
+CA_FLAG = "ca_flag"
+HEADERS = "headers"
+DATA_STR = "data"
+PARAMS_STR = "params"
+TZ = "Asia/Shanghai"
+
+
+class CommonFunc(object):
+
+    def params_verification(self, arg_params, verify_key_list):
+        """
+        参数校验
+        :param arg_params:
+        :param verify_key_list:
+        :return:
+        """
+        if arg_params is None:
+            return False, self.fabricate_response_data(ConstGen.FAIL_CODE, ResponseCode.MissingParameter.value,
+                                                       "参数不存在")
+        for key in verify_key_list:
+            if key not in arg_params:
+                return False, self.fabricate_response_data(ConstGen.FAIL_CODE,
+                                                           ResponseCode.MissingParameter.value, "参数不存在")
+        return True, None
+
+    @staticmethod
+    def gen_resp_data(code, msg, data_list=None):
+        """
+        构造返回数据格式
+        :param code:
+        :param msg:
+        :param data_list:
+        :return:
+        """
+        data = {ConstGen.CODE: code, ConstGen.MESSAGE: msg}
+        if data_list is not None:
+            data[ConstGen.DATA_STR] = data_list
+        return data
+
+    def return_data(self, ret_data):
+        """
+        返回数据处理(针对旧版数据格式)
+        :param ret_data:
+        :return:
+        """
+        if ConstGen.RET_CODE in ret_data:
+            csm_bs_code = ret_data[ConstGen.RET_CODE]
+        else:
+            csm_bs_code = ConstGen.FAIL_CODE
+        if ConstGen.RET_VAL in ret_data:
+            ret_message = ret_data[ConstGen.RET_VAL]
+        else:
+            ret_message = ret_data
+
+        if csm_bs_code is ConstGen.SUCCESS_CODE:
+            ret_code = ResponseCode.OK.value
+        else:
+            ret_code = ResponseCode.Failure.value
+        if "1" == ret_message:
+            ret_message = ConstGen.SUCCESS_STR
+        if ConstGen.DATA_ROWS_STR in ret_data:
+            data_row_list = ret_data[ConstGen.DATA_ROWS_STR]
+        else:
+            data_row_list = []
+        return self.fabricate_response_data(csm_bs_code, ret_code, ret_message, None, data_row_list)
+
+    def return_data_list(self, ret_data):
+        """
+        返回数据列表
+        :param ret_data:
+        :return:
+        """
+        if ConstGen.DATA_ROWS_STR in ret_data:
+            data_row_list = ret_data[ConstGen.DATA_ROWS_STR]
+        else:
+            data_row_list = []
+        return data_row_list
+
+    def user_info_error(self):
+        '''
+        返回用户信息错误
+        :return:
+        '''
+        return self.fabricate_response_data(ConstGen.FAIL_CODE, ResponseCode.AuthFailure.value, "用户信息不存在",
+                                            "用户未登录")
+
+    @staticmethod
+    def return_data_direct(ret_data):
+        response = make_response(ret_data)
+        response.headers[CONTENT_TYPE] = CONTENT_TYPE_JSON
+        return response
+
+    @staticmethod
+    def fabricate_response_data(csm_bs_code, ret_code, ret_message, ret_access_msg=None, data_row_list=None):
+        '''
+        构造响应数据包
+        :param csm_bs_code:
+        :param ret_code:
+        :param ret_message:
+        :param ret_access_msg:
+        :param data_row_list:
+        :return:
+        '''
+        data = {CODE: ret_code, MESSAGE: ret_message}
+        if ret_access_msg is not None:
+            data[ACCESS_MSG] = ret_access_msg
+        if data_row_list is not None:
+            data[RET_DATA] = data_row_list
+        response = make_response(json.dumps(data, ensure_ascii=False))
+        response.headers[CONTENT_TYPE] = CONTENT_TYPE_JSON
+        response.headers[CSM_BS_CODE] = csm_bs_code
+        return response
+
+    @staticmethod
+    def gen_inner_resp_data(ret_code, ret_val, data_row_list=None):
+        """
+        构造返回内部数据格式
+        :param ret_code:
+        :param ret_val:
+        :param data_row_list:
+        :return:
+        """
+        data = {ConstGen.RET_CODE: ret_code, ConstGen.RET_VAL: ret_val}
+        if data_row_list is not None:
+            data[ConstGen.DATA_ROWS_STR] = data_row_list
+        return data
+
+    @staticmethod
+    def datetime_as_timezone(date_time, time_zone):
+        """
+        将时间转换为某一时区时间
+        :param date_time:
+        :param time_zone:
+        :return:
+        """
+        tz = pytz.timezone(time_zone)
+        utc = pytz.timezone('UTC')
+        return date_time.replace(tzinfo=utc).astimezone(tz)
+
+    @staticmethod
+    def kube_time_format(date_time_str, format_pattern):
+        """
+        格式化kubenetes时间格式
+        :param date_time_str:
+        :param format_pattern:
+        :return:
+        """
+        return datetime.datetime.strptime(date_time_str, format_pattern)
+
+    @staticmethod
+    def datetime_format_tostr(date_time, format_pattern):
+        """
+        将时间格式格式化为字符串
+        :param date_time:
+        :param format_pattern:
+        :return:
+        """
+        format_pattern = "{0:" + format_pattern + "}"
+        return format_pattern.format(date_time)
+
+    @staticmethod
+    def create_time_format(create_time_tz_str):
+        """
+        命名空间创建时间格式化
+        :param create_time_tz_str:
+        :return:
+        """
+        ns_create_time_tz = CommonFunc().kube_time_format(
+            create_time_tz_str, ConstGen.pre_fmt)
+        ns_create_time = CommonFunc().datetime_as_timezone(ns_create_time_tz, TZ)
+        return CommonFunc().datetime_format_tostr(ns_create_time, ConstGen.post_fmt)
+
+    @staticmethod
+    def request_param2dict(request):
+        """
+        把请求参数封装到一个字典中
+        :param request:
+        :return:
+        """
+        arg_params = {}
+        for k in request.values:
+            arg_params[k] = request.values.get(k)
+        return arg_params
+
+    def request_trans_service(self, url, params):
+        """
+        封装请求传输
+        :param url:
+        :param params:
+        :return:
+        """
+        trans = httptrans.HttpTrans(None)
+        try:
+            print("请求地址：" + url)
+            ret = trans.post_encodedata(url, params, None)
+            print("返回结果：" + ret)
+        except BaseException as err:
+            print('[' + url + '] 请求异常:' + err.__str__())
+            return self.gen_inner_resp_data("0", err.__str__())
+        else:
+            return json.loads(ret)
+
+    @staticmethod
+    def exec_rest_api(method, api_url, params, timeout: int = None):
+        """
+        执行REST API操作
+        :param method:
+        :param api_url:
+        :param params:
+        :param timeout:
+        :return:
+        """
+        if timeout is None:
+            timeout = 240
+
+        if DATA_STR in params:
+            data = params[DATA_STR]
+        else:
+            data = None
+        if PARAMS_STR in params:
+            params_data = params[PARAMS_STR]
+        else:
+            params_data = None
+        if HEADERS in params:
+            headers = params[HEADERS]
+            urllib3.disable_warnings()
+            try:
+                print(api_url)
+                resp = requests.request(method, api_url, headers=headers, data=data, params=params_data, verify=False,
+                                        timeout=timeout)
+                resp.encoding = 'utf-8'
+            except Exception as e:
+                print("request请求异常" + e.__str__())
+                return False, "访问URL异常"
+        elif CA_FLAG in params:
+            ca_flag = params[CA_FLAG]
+            if ca_flag is True:
+                resp = requests.request(method, api_url,
+                                        cert=(K8SOptJsonStr.CLIENT_CRT_FILE_PATH, K8SOptJsonStr.CLIENT_KEY_FILE_PATH),
+                                        data=data, params=params_data, verify=K8SOptJsonStr.CA_CRT_FILE_PATH)
+            else:
+                return False, None
+        else:
+            return False, None
+        return True, resp
+
+    def ca_handle(self, ca_crt_data, client_crt_data, client_key_data):
+        """
+        CA处理
+        :param ca_crt_data:
+        :param client_crt_data:
+        :param client_key_data:
+        :return:
+        """
+        if ca_crt_data is not None and client_crt_data is not None and client_key_data is not None:
+
+            os.system('mkdir $(dirname ' + K8SOptJsonStr.CA_CRT_FILE_PATH + ')')
+            os.system(
+                'mkdir $(dirname ' + K8SOptJsonStr.CLIENT_CRT_FILE_PATH + ')')
+            os.system(
+                'mkdir $(dirname ' + K8SOptJsonStr.CLIENT_KEY_FILE_PATH + ')')
+            flag1 = self.generate_ca_crt_file(
+                K8SOptJsonStr.CA_CRT_FILE_PATH, ca_crt_data)
+            flag2 = self.generate_client_crt_file(
+                K8SOptJsonStr.CLIENT_CRT_FILE_PATH, client_crt_data)
+            flag3 = self.generate_client_key_file(
+                K8SOptJsonStr.CLIENT_KEY_FILE_PATH, client_key_data)
+            if flag1 and flag2 and flag3:
+                return True
+            else:
+                return False
+        else:
+            return False
+
+    @staticmethod
+    def header_handle(headers, token):
+        """
+        header处理
+        :param headers:
+        :param token:
+        :return:
+        """
+        if token is not None:
+            last_token = K8SRestStr.BEARER_STR + token
+            headers[K8SRestStr.AUTHORIZATION_STR] = last_token
+        return headers
+
+    @staticmethod
+    def generate_ca_crt_file(file_path, ca_crt_data):
+        """
+        生成CA证书文件
+        :param file_path:
+        :param ca_crt_data:
+        :return:
+        """
+        try:
+            kube_ca_crt_file = open(file_path, 'w')
+            kube_ca_crt_file.write(K8SOptJsonStr.BEGIN_CERTIFICATE + "\n")
+            kube_ca_crt_file.write(ca_crt_data + "\n")
+            kube_ca_crt_file.write(K8SOptJsonStr.END_CERTIFICATE)
+            kube_ca_crt_file.close()
+            return True
+        except Exception as e:
+            print(e)
+            return False
+
+    @staticmethod
+    def generate_client_crt_file(file_path, client_crt_data):
+        """
+        生成客户端证书文件
+        :param file_path:
+        :param client_crt_data:
+        :return:
+        """
+        try:
+            kube_client_crt_file = open(file_path, 'w')
+            kube_client_crt_file.write(K8SOptJsonStr.BEGIN_CERTIFICATE + "\n")
+            kube_client_crt_file.write(client_crt_data + "\n")
+            kube_client_crt_file.write(K8SOptJsonStr.END_CERTIFICATE)
+            kube_client_crt_file.close()
+            return True
+        except Exception as e:
+            print(e)
+            return False
+
+    @staticmethod
+    def generate_client_key_file(file_path, client_key_data):
+        """
+        生成客户端密钥文件
+        :param file_path:
+        :param client_key_data:
+        :return:
+        """
+        try:
+            kube_client_key_file = open(file_path, 'w')
+            kube_client_key_file.write(
+                K8SOptJsonStr.BEGIN_RSA_PRIVATE_KEY + "\n")
+            kube_client_key_file.write(client_key_data + "\n")
+            kube_client_key_file.write(K8SOptJsonStr.END_RSA_PRIVATE_KEY)
+            kube_client_key_file.close()
+        except Exception as e:
+            print(e)
+            return False
+
+    def pre_exec_rest_api(self, method, request_url, params=None, token=None, ca_crt_data=None, client_crt_data=None,
+                          client_key_data=None):
+        """
+        执行前预处理操作
+        :param method:
+        :param request_url:
+        :param params:
+        :param token:
+        :param ca_crt_data:
+        :param client_crt_data:
+        :param client_key_data:
+        :return:
+        """
+        if params is None:
+            params = {}
+        if token is not None:
+            if HEADERS in params:
+                headers = params[HEADERS]
+            else:
+                headers = {}
+            if "disable" != token:
+                post_headers = self.header_handle(headers, token=token)
+            else:
+                post_headers = headers
+            if post_headers is not None:
+                params[HEADERS] = post_headers
+            else:
+                return self.gen_inner_resp_data(ConstGen.FAIL_CODE, "headers数据不存在")
+        elif ca_crt_data is not None and client_crt_data is not None and client_key_data is not None:
+            flag = self.ca_handle(
+                ca_crt_data, client_crt_data, client_key_data)
+            if flag:
+                params[CA_FLAG] = flag
+            else:
+                return self.gen_inner_resp_data(ConstGen.FAIL_CODE, "生成CA证书数据失败")
+        else:
+            return self.gen_inner_resp_data(ConstGen.FAIL_CODE, "缺少TOKEN或CA证书数据")
+        resp_tupe = self.exec_rest_api(method, request_url, params)
+        if resp_tupe[0] is True:
+            if resp_tupe[1].status_code >= 200 and resp_tupe[1].status_code < 300:
+                if resp_tupe[1].status_code != 204 and ConstGen.CONTENT_TYPE_JSON in resp_tupe[1].headers.get(
+                        ConstGen.CONTENT_TYPE):
+                    resp_data = json.loads(resp_tupe[1].text)
+                    if K8SRestStr.STATUS in resp_data and resp_data[K8SRestStr.STATUS] == ResponseCode.Failure.value:
+                        return self.gen_inner_resp_data(ConstGen.FAIL_CODE, resp_data[K8SRestStr.MESSAGE])
+                    else:
+                        return self.gen_inner_resp_data(ConstGen.SUCCESS_CODE, ConstGen.SUCCESS_STR, resp_data)
+                else:
+                    return self.gen_inner_resp_data(ConstGen.SUCCESS_CODE, ConstGen.SUCCESS_STR, resp_tupe[1].text)
+            elif resp_tupe[1].status_code == 404:
+                print(resp_tupe[1].text + "请求资源未找到")
+                return self.gen_inner_resp_data(ConstGen.FAIL_CODE, "请求资源未找到")
+            elif resp_tupe[1].status_code == 409:
+                return self.gen_inner_resp_data(ConstGen.FAIL_CODE, "该资源已存在")
+            else:
+                return self.gen_inner_resp_data(ConstGen.FAIL_CODE, resp_tupe[1].text)
+        elif resp_tupe[0] is False and resp_tupe[1] is not None:
+            return self.gen_inner_resp_data(ConstGen.FAIL_CODE, resp_tupe[1])
+        else:
+            return self.gen_inner_resp_data(ConstGen.FAIL_CODE, "Kubernetes操作失败")
+
+    def get_json_from_jsonpath(self, jsonpath_list):
+        """
+        根据jsonpath生成json数据格式的封装服务
+        :param seletCondition:
+        :param table_name:
+        :return:
+        """
+        trans_data = {}
+        trans_data[ConstGen.TRANS_JSON_ARRAY_STR] = jsonpath_list
+        print(trans_data)
+        ret_data = self.request_trans_service(
+            ConstGen.JSON_PATH_TO_JSON_URL, trans_data)
+        print(ret_data)
+        if ret_data[ConstGen.RET_CODE] != '0':
+            if ConstGen.RET_VAL in ret_data:
+                data = ret_data[ConstGen.RET_VAL]
+                return data
+            else:
+                return None
+        else:
+            return None
+
+    def pop_json_key(self, json_data, keys: list):
+        if isinstance(json_data, dict):
+            for k in list(json_data.keys()):
+                if k in keys:
+                    json_data.pop(k)
+                elif isinstance(json_data[k], dict):
+                    self.pop_json_key(json_data[k], keys)
+            return True
+        else:
+            return False
+
+    def alter_json_value(self, json_data, json_key, value):
+        if isinstance(json_data, dict):
+            for k in list(json_data.keys()):
+                if k == json_key:
+                    json_data[json_key] = value
+                elif isinstance(json_data[k], dict):
+                    self.alter_json_value(json_data[k], json_key, value)
+            return True
+        else:
+            return False

cucc_common_pkg/util_pkg/const.py

+'''
+@Descripttion:
+@Author: guohb65
+@Email: guohb65@chinaunicom.cn
+@Date: 2019-12-09 18:19:17
+@LastEditors  : guohb65
+@LastEditTime : 2020-05-09 14:47:58
+'''
+import json
+import os
+from enum import Enum
+
+MYSQL_POOL_DOMAIN = "MYSQL_POOL_DOMAIN"
+WEB_UTILITY_DOMAIN = "WEB_UTILITY_DOMAIN"
+
+
+class Env(object):
+    def __init__(self):
+        env_dist = os.environ
+        if "COMMON_MOUNT_PATH" in env_dist:
+            common_mount_path = env_dist.get("COMMON_MOUNT_PATH")
+            common_conf_file = open(common_mount_path, 'r')
+            common_data_json = json.loads(common_conf_file.read())
+            common_conf_file.close()
+            self.mysql_pool_domain = common_data_json.get(MYSQL_POOL_DOMAIN)
+            self.web_utility_domain = common_data_json.get(WEB_UTILITY_DOMAIN)
+        else:
+            self.mysql_pool_domain = ""
+            self.web_utility_domain = ""
+
+    def get_mysql_pool_domain(self):
+        return self.mysql_pool_domain
+
+    def get_web_utility_domain(self):
+        return self.web_utility_domain
+
+
+class ConstGen(object):
+    """
+    # 普通常量类
+    """
+    REGIONS_ID = "region_id"
+    # 挂载路径环境变量
+    SELF_MOUNT_PATH = "SELF_MOUNT_PATH"
+    COMMON_MOUNT_PATH = "COMMON_MOUNT_PATH"
+    # 各域名KEY
+    TG_DOMAIN = "TG_DOMAIN"
+    CKE_DOMAIN = "CKE_DOMAIN"
+    CONFIG_CENTER_DOMAIN = "CONFIG_CENTER_DOMAIN"
+    IAM_DOMAIN = "IAM_DOMAIN"
+    # 返回字符串
+    CSM_BS_CODE = 'csm-bs-code'
+    CONTENT_TYPE = "Content-Type"
+    CONTENT_TYPE_JSON = "application/json"
+    CONTENT_TYPE_TEXT = "text/plain"
+    ACCESS_MSG = "accessMsg"
+    MESSAGE = "message"
+    CODE = "code"
+    CA_FLAG = "ca_flag"
+    HEADERS = "headers"
+    DATA_STR = "data"
+    TZ = "Asia/Shanghai"
+    RET_CODE = "RetCode"
+    RET_VAL = "RetVal"
+    SUCCESS_CODE = "1"
+    SUCCESS_STR = "success"
+    FAIL_CODE = "2"
+    ZERO_STR = "0"
+    # 接口常用字符串
+    DATA_ROWS_STR = "DataRows"
+    ROWCOUNT_STR = "RowCount"
+    PAGE_COUNT_STR = "PageCount"
+    UNIQUE_STR = 'unique'
+    OTHERS_STR = 'others'
+    CONDITION_STR = "condition"
+    EXACT_STR = "exact"
+    FUZZY_STR = "fuzzy"
+    PAGE_STR = "page"
+    PAGE_NUM_STR = "page_num"
+    PAGE_SIZE_STR = "page_size"
+    COOKIES_LOGIN_USER_STR = "loginname"
+    ACCOUNT_ID_STR = "accountID"
+    USER_ID_STR = "userID"
+    TABLE_NAME_STR = 'table_name'
+    SQL_STR = 'sql'
+    TRANS_SQL_STR = 'transsql'
+    TRANS_JSON_ARRAY_STR = 'transjsonarray'
+    # db 操作
+    OPT_INSERT = "insert"
+    OPT_UPDATE = "update"
+    OPT_DELETE = "delete"
+    ASC = "asc"
+    DESC = "desc"
+
+    # request key
+    PARAMS_STR = "params"
+    # 时间格式化
+    pre_fmt = "%Y-%m-%dT%H:%M:%SZ"
+    post_fmt = "%Y-%m-%d %H:%M:%S"
+    # 根路径
+    ROOT_URL = Env().get_mysql_pool_domain() + '/mysqlpool/'
+    HTTPS_STR = "https://"
+    BACKSLASH = '/'
+    # mysqlpool底层服务路径
+    STANDER_SQL = 'standardsql'
+    STANDARD_PROC = 'standardproc'
+    TRANS = 'trans'
+    # serviceMesh库访问路径
+    SERVICE_MESH_W_URL = '/w/servicemesh/service'
+    SERVICE_MESH_R_URL = '/r/servicemesh/service'
+    # sql写url
+    TRANS_SQL_URL = ROOT_URL + TRANS + SERVICE_MESH_W_URL
+    # sql读url
+    STANDER_SQL_URL = ROOT_URL + STANDER_SQL + SERVICE_MESH_R_URL
+    # 存储过程读url
+    STANDARD_PROC_R_URL = ROOT_URL + STANDARD_PROC + SERVICE_MESH_R_URL
+    # 存储过程写url
+    STANDARD_PROC_W_URL = ROOT_URL + STANDARD_PROC + SERVICE_MESH_W_URL
+    # jsonpath转json的服务
+    WEB_UTILITY_ROOT_URL = Env().get_web_utility_domain() + '/webutility/'
+    SVC_JSON_PATH_TO_JSON = 'getjsonpath/get'
+    JSON_PATH_TO_JSON_URL = WEB_UTILITY_ROOT_URL + SVC_JSON_PATH_TO_JSON
+
+
+class K8SRestUrl(object):
+    """
+    Kubernetes资源对象访问根路径
+    """
+    NAMESPACES_REST_URL = "/api/v1/"
+    DEPLOYMENT_REST_API = "/apis/apps/v1/"
+    SERVICE_REST_API = "/api/v1/"
+    POD_REST_API = "/api/v1/"
+    EVENT_REST_API = "/api/v1/"
+    NODE_REST_API = "/api/v1/"
+    ISTIO_REST_API = "/apis/networking.istio.io/v1alpha3/"
+
+
+class K8SObjStr(object):
+    """
+    Kubernetes资源对象中的字符串
+    """
+    API_VERSION_STR = "apiVersion"
+    # 命名空间变量KEY值
+    ITEM_KEY = "items"
+    METADATA_KEY = "metadata"
+    NAME_KEY = "name"
+    NAMESPACE_KEY = "namespace"
+    REPLICAS_KEY = "replicas"
+    AVAILABLE_REPLICAS_KEY = "availableReplicas"
+    SPEC_KEY = "spec"
+    CONTAINERS_KEY = "containers"
+    TEMPLATE_KEY = "template"
+    LABELS_KEY = "labels"
+    SELECTOR_KEY = "selector"
+    STATUS_KEY = "status"
+    STATE_KEY = "state"
+    PHASE_KEY = "phase"
+    POD_IP_KEY = "podIP"
+    NODE_IP_KEY = "hostIP"
+    NODE_NAME_KEY = "nodeName"
+    START_TIME_KEY = "startTime"
+    OWNERREFERENCES_KEY = "ownerReferences"
+    ADDRESSES_KEY = "addresses"
+    ADDRESS_KEY = "address"
+    CONDITIONS_KEY = "conditions"
+
+    CREATE_TIME_KEY = "creationTimestamp"
+    ANNOTATIONS_KEY = "annotations"
+    NS_DESC_KEY = "namespaceDesc"
+    MATCH_LABELS_KEY = "matchLabels"
+
+    CLUSTER_IP_KEY = "clusterIP"
+    TYPE_KEY = "type"
+    CONTAINER_STATUSES_KEY = "containerStatuses"
+    INIT_CONTAINER_STATUSES_KEY = "initContainerStatuses"
+
+
+class K8SRestStr(object):
+    """
+    Kubernetes中REST请求中的字符串
+    """
+    HEADERS = "headers"
+    AUTHORIZATION_STR = "authorization"
+    BEARER_STR = "Bearer "
+    CONTENT_TYPE = "Content-Type"
+    APPLICATION_JSON = "application/json"
+    PATCH_CONTENT_TYPE_STR = "application/json-patch+json"
+    MERGE_PATCH_JSON = "application/merge-patch+json"
+    STRATEGIC_MERGE_PATCH_JSON = "application/strategic-merge-patch+json"
+    NAMESPACES = "namespaces"
+    SERVICES = "services"
+    DEPLOYMENTS = "deployments"
+    REPLICASETS = "replicasets"
+    PODS = "pods"
+    NODES = "nodes"
+    SERVICEENTRIES = "serviceentries"
+    EVENTS = "events"
+
+    STATUS = "status"
+    MESSAGE = "message"
+
+
+class K8SOptJsonStr(object):
+    # json 数据KEY值
+    KUBE_INFO = "kube_info"
+    CA_INFO = "ca_info"
+    KUBE_CA_CRT = "kube_ca_crt"
+    KUBE_CLIENT_CRT = "kube_client_crt"
+    KUBE_CLIENT_KEY = "kube_client_key"
+    KUBECACRTPATH = "/root/ssl/ca.crt"
+    KUBECLIENTCRTPATH = "/root/ssl/istio.pem"
+    KUBECLIENTKEYPATH = "/root/ssl/istio-key.pem"
+    DEFAULTCONFIGPATH = "/root/.kube/config"
+
+    CA_CRT_FILE_PATH = "/tmp/pki/ca.crt"
+    CLIENT_CRT_FILE_PATH = "/tmp/pki/client.crt"
+    CLIENT_KEY_FILE_PATH = "/tmp/pki/client.key"
+
+    BEGIN_CERTIFICATE = "-----BEGIN CERTIFICATE-----"
+    END_CERTIFICATE = "-----END CERTIFICATE-----"
+    BEGIN_EC_PRIVATE_KEY = "-----BEGIN RSA PRIVATE KEY-----"
+    END_EC_PRIVATE_KEY = "-----END RSA PRIVATE KEY-----"
+    BEGIN_RSA_PRIVATE_KEY = "-----BEGIN RSA PRIVATE KEY-----"
+    END_RSA_PRIVATE_KEY = "-----END RSA PRIVATE KEY-----"
+
+
+class K8SResourceJsonStr(object):
+    """
+    # K8s资源对象中Json数据字符串KEY
+    """
+    K8S_POD_IP = "pod_ip"
+    K8S_POD_HOST_IP = "host_ip"
+    K8S_POD_START_TIME = "start_time"
+    K8S_POD_NODE_NAME = "node_name"
+    K8S_POD_NAME_KEY = "podName"
+    K8S_POD_STATUS_KEY = "status"
+    # POD状态
+    K8S_POD_NOT_READY = "NotReady"
+    K8S_POD_PENDING = "Pending"
+    K8S_POD_RUNNING = "Running"
+    K8S_POD_SUCCEEDED = "Succeeded"
+    K8S_POD_FAILED = "Failed"
+    K8S_POD_UNKNOWN = "Unknown"
+    K8S_POD_COMPLETED = "Completed"
+    K8S_POD_CRASHLOOPBACKOFF = "CrashLoopBackOff"
+
+
+class PodStatus(Enum):
+    """
+    # K8s Pod状态
+    """
+    Completed = 1
+    Succeeded = 2
+    Running = 3
+    Pending = 4
+    CrashLoopBackOff = 5
+    Failed = 6
+    Unknown = 7
+
+
+class RequestMethod(Enum):
+    GET = "get"
+    POST = "post"
+    DELETE = "delete"
+    PUT = "put"
+    PATCH = "patch"
+
+
+class NamespaceStatus(Enum):
+    Active = "可用"
+    Terminating = "停止中"
+
+
+class ResponseCode(Enum):
+    OK = "OK"
+    Failure = "Failure"
+    SysBusy = "SysBusy"
+    SysError = "SysError"
+    InvalidAction = "InvalidAction"
+    AuthFailure = "AuthFailure"
+    UnauthorizedOperation = "UnauthorizedOperation"
+    MissingParameter = "MissingParameter"
+
+
+class K8SResourceKindStr(Enum):
+    NAMESPACE = "Namespace"
+    SERVICE = "Service"
+    DEPLOYMENT = "Deployment"
+
+
+class ConstTableName(object):
+    """
+    # 业务数据表名
+    """
+    TB_KUBE_CLUSTER = "kube_cluster"
+
+
+class ConstClusterColumn(object):
+    CLUSTER_NAME = "cluster_name"
+    REGION_ID = "region_id"
+    CREATE_USER_ID = "create_userid"
+    CLUSTER_ID = "cluster_id"
+    CLUSTER_TYPE = "cluster_type"
+    CLIENT_KEY = "client_key"
+    CLIENT_CRT = "client_crt"
+    CA_CRT = "ca_crt"
+    CLUSTER_TOKEN = "cluster_token"
+    CLUSTER_PORT = "cluster_port"
+    CLUSTER_IP = "cluster_ip"
+
+
+class IAMAction(object):
+    CREATE_INSTANCE = "CreateInstance"
+    DESCRIBE_INSTANCE = "DescribeInstance"
+    DELETE_INSTANCE = "DeleteInstance"
+    LIST_INSTANCE = "ListInstance"
+    UPDATE_INSTANCE = "UpdateInstance"
+    LIST_K8S = "ListK8S"
+    DESCRIBE_K8S = "DescribeCluster"
+    DELETE_K8S = "DeleteK8S"
+    UPDATE_K8S = "UpdateK8S"

cucc_common_pkg/util_pkg/csk_cluster_info.py

+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+'''
+@Descripttion: CSK集群信息查询
+@Author: guohb65
+@Email: guohb65@chinaunicom.cn
+@Date: 22022/7/11 10:21
+@LastEditors: guohb65
+@LastEditTime: 2022/7/11 10:21
+'''
+import json
+import os
+
+import requests
+import urllib3
+
+from cucc_common_pkg.util_pkg.common_func import CommonFunc
+from cucc_common_pkg.util_pkg.const import RequestMethod, ConstGen, ResponseCode
+
+CSK_DOMAIN = "CSK_DOMAIN"
+CSK_SVC_TIMEOUT = "CSK_SVC_TIMEOUT"
+ACCESS_TOKEN = "accessToken"
+CSK_URL_REGIONS = "/regions/"
+CSK_URL_CLUSTER_URL = "/k8s/clusters"
+CSK_URL_VERSION = "/v1"
+CSK_URL_PREFIX = "/csk"
+CSK_URL_ADMIN_TOKEN = "adminToken"
+CSK_KEY_API_SERVER = "apiserver"
+CSK_KEY_VPC = "vpc"
+CSK_KEY_ADMIN_TOKEN = "AdminToken"
+
+
+class CskClusterInfo(object):
+
+    def __init__(self, login_cookie=None):
+        env_dist = os.environ
+        common_mount_path = env_dist.get(ConstGen.COMMON_MOUNT_PATH)
+        common_conf_file = open(common_mount_path, 'r')
+        common_data_json = json.loads(common_conf_file.read())
+        common_conf_file.close()
+        self.csk_domain = common_data_json.get(CSK_DOMAIN)
+        if CSK_SVC_TIMEOUT in common_data_json:
+            self.csk_svc_timeout = int(common_data_json.get(CSK_SVC_TIMEOUT))
+        else:
+            self.csk_svc_timeout = 3
+        self.login_cookie = login_cookie
+
+    def get_csk_list(self, regions):
+        request_url = self.csk_domain + CSK_URL_PREFIX + CSK_URL_REGIONS + regions + CSK_URL_CLUSTER_URL
+        urllib3.disable_warnings()
+        try:
+            resp = requests.request(RequestMethod.GET.value, request_url, cookies=self.login_cookie,
+                                    timeout=self.csk_svc_timeout, verify=False)
+        except Exception as e:
+            print("CSK请求异常：" + e.__str__())
+            ret_data = {ConstGen.CODE: ResponseCode.SysError.value, ConstGen.MESSAGE: "CSK访问异常"}
+            return False, json.dumps(ret_data, ensure_ascii=False)
+        resp_code = resp.status_code
+        if resp_code == 200:
+            if ConstGen.CONTENT_TYPE_JSON in resp.headers.get(ConstGen.CONTENT_TYPE) and resp.text is not None:
+                resp_json = json.loads(resp.text)
+                if resp_json[ConstGen.CODE] == ResponseCode.OK.value:
+                    cluster_list = resp_json["data"]
+                    cluster_data = []
+                    for cluster in cluster_list:
+                        post_handle_cluster = {"cluster_name": cluster.get("name"), "cluster_ip": "",
+                                               "cluster_port": "", "cluster_type": "CSK",
+                                               "cluster_apiserver": "", "cluster_apiservers": ""}
+                        cluster_data.append(post_handle_cluster)
+                    return True, cluster_data
+                else:
+                    return False, resp.text
+        else:
+            ret_data = {ConstGen.CODE: ResponseCode.SysError.value, ConstGen.MESSAGE: resp.text}
+            return False, json.dumps(ret_data, ensure_ascii=False)
+
+    def list_csk_cluster(self, regions):
+        ret_tuple = self.get_csk_list(regions)
+        if ret_tuple[0]:
+            return CommonFunc().fabricate_response_data(ConstGen.SUCCESS_CODE, ResponseCode.OK.value,
+                                                        ConstGen.SUCCESS_STR, None, ret_tuple[1])
+        else:
+            return CommonFunc().fabricate_response_data(ConstGen.FAIL_CODE, ResponseCode.Failure.value, ret_tuple[1])
+
+    def get_csk_info(self, region_id, cluster_name):
+        cluster_type = "CSK"
+        csk_info = self.get_csk_rest_info(region_id, cluster_name)
+        token = self.get_csk_token(region_id, cluster_name)
+        if csk_info is not None and token is not None:
+            api_servers = json.loads(csk_info).get(CSK_KEY_API_SERVER)
+            apiserver_list = api_servers.split(";")
+            api_server = apiserver_list[0]
+            vpc = json.loads(csk_info).get(CSK_KEY_VPC)
+            if type(api_server) is str and type(token) is str:
+                apiserver = api_server.split(":")
+                cluster_ip = apiserver[1][2:]
+                cluster_port = apiserver[2]
+                cluster_info = {"cluster_type": cluster_type, "cluster_ip": cluster_ip, "cluster_port": cluster_port,
+                                "cluster_token": token, "cluster_apiserver": api_server,
+                                "cluster_apiservers": apiserver_list}
+                if type(vpc) is str:
+                    cluster_info["cluster_vpc"] = vpc
+            else:
+                cluster_info = {}
+        else:
+            cluster_info = {}
+        print(cluster_info)
+        return cluster_info
+
+    def get_csk_apiserver(self, regions, cluster_name):
+        request_url = self.csk_domain + CSK_URL_PREFIX + CSK_URL_REGIONS + regions + CSK_URL_CLUSTER_URL + "/" + cluster_name
+        print(request_url)
+        urllib3.disable_warnings()
+        try:
+            resp = requests.request(RequestMethod.GET.value, request_url, cookies=self.login_cookie, verify=False)
+        except Exception as e:
+            print("csk请求异常：" + e.__str__())
+            return e.__str__()
+        resp_code = resp.status_code
+        if resp_code == 200:
+            if ConstGen.CONTENT_TYPE_JSON in resp.headers.get(ConstGen.CONTENT_TYPE) and resp.text is not None:
+                resp_json = json.loads(resp.text)
+                apiservers = resp_json.get(CSK_KEY_API_SERVER)
+                apiserver_list = apiservers.split(";")
+                return apiserver_list[0]
+            else:
+                return None
+        else:
+            return None
+
+    def get_csk_rest_info(self, regions, cluster_name):
+        if self.login_cookie is not None:
+            request_url = self.csk_domain + CSK_URL_PREFIX + CSK_URL_REGIONS + regions + CSK_URL_CLUSTER_URL + "/" + cluster_name
+            print(request_url)
+            urllib3.disable_warnings()
+            try:
+                resp = requests.request(RequestMethod.GET.value, request_url, cookies=self.login_cookie, verify=False)
+                print(resp.text)
+            except Exception as e:
+                print("csk请求异常：" + e.__str__())
+                return None
+            resp_code = resp.status_code
+            if resp_code == 200:
+                if ConstGen.CONTENT_TYPE_JSON in resp.headers.get(ConstGen.CONTENT_TYPE) and resp.text is not None:
+                    return resp.text
+                else:
+                    return None
+            else:
+                return None
+        else:
+            return None
+
+    def get_csk_token(self, regions, cluster_name):
+        if self.login_cookie is not None:
+            request_url = self.csk_domain + CSK_URL_PREFIX + CSK_URL_REGIONS + regions + CSK_URL_CLUSTER_URL + "/" + cluster_name \
+                          + "/" + CSK_URL_ADMIN_TOKEN
+            urllib3.disable_warnings()
+            try:
+                resp = requests.request(RequestMethod.GET.value, request_url, cookies=self.login_cookie, verify=False)
+
+            except Exception as e:
+                print("csk请求异常：" + e.__str__())
+                return None
+            resp_code = resp.status_code
+            if resp_code == 200:
+                if ConstGen.CONTENT_TYPE_JSON in resp.headers.get(ConstGen.CONTENT_TYPE) and resp.text is not None:
+                    resp_json = json.loads(resp.text)
+                    return resp_json.get(CSK_KEY_ADMIN_TOKEN)
+                else:
+                    return None
+            else:
+                return None
+        else:
+            return None

cucc_common_pkg/util_pkg/cuk_cluster_info.py

+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+'''
+@Descripttion: CUK集群信息查询
+@Author: guohb65
+@Email: guohb65@chinaunicom.cn
+@Date: 22022/7/11 10:21
+@LastEditors: guohb65
+@LastEditTime: 2022/7/11 10:21
+'''
+import json
+import os
+
+import requests
+import urllib3
+
+from cucc_common_pkg.util_pkg.common_func import CommonFunc
+from cucc_common_pkg.util_pkg.const import RequestMethod, ConstGen, ResponseCode
+
+CUK_DOMAIN = "CUK_DOMAIN"
+CUK_SVC_TIMEOUT = "CUK_SVC_TIMEOUT"
+ACCESS_TOKEN = "accessToken"
+CUK_URL_REGIONS = "/regions/"
+CUK_URL_CLUSTER_URL = "/k8s/clusters"
+CUK_URL_VERSION = "/v1"
+CUK_URL_PREFIX = "/cuk"
+CUK_URL_ADMIN_TOKEN = "adminToken"
+CUK_KEY_API_SERVER = "apiserver"
+CUK_KEY_NETWORK = "network"
+CUK_KEY_VPC = "vpc"
+CUK_KEY_ADMIN_TOKEN = "AdminToken"
+
+
+class CukClusterInfo(object):
+
+    def __init__(self, login_cookie=None):
+        env_dist = os.environ
+        common_mount_path = env_dist.get(ConstGen.COMMON_MOUNT_PATH)
+        common_conf_file = open(common_mount_path, 'r')
+        common_data_json = json.loads(common_conf_file.read())
+        common_conf_file.close()
+        self.cuk_domain = common_data_json.get(CUK_DOMAIN)
+        if CUK_SVC_TIMEOUT in common_data_json:
+            self.cuk_svc_timeout = int(common_data_json.get(CUK_SVC_TIMEOUT))
+        else:
+            self.cuk_svc_timeout = 3
+        self.login_cookie = login_cookie
+
+    def get_cuk_list(self, regions):
+        request_url = self.cuk_domain + CUK_URL_PREFIX + CUK_URL_REGIONS + regions + CUK_URL_CLUSTER_URL
+        urllib3.disable_warnings()
+        try:
+            resp = requests.request(RequestMethod.GET.value, request_url, cookies=self.login_cookie,
+                                    timeout=self.cuk_svc_timeout, verify=False)
+        except Exception as e:
+            print("CUK请求异常：" + e.__str__())
+            ret_data = {ConstGen.CODE: ResponseCode.SysError.value, ConstGen.MESSAGE: "CUK访问异常"}
+            return False, json.dumps(ret_data, ensure_ascii=False)
+        resp_code = resp.status_code
+        if resp_code == 200:
+            if ConstGen.CONTENT_TYPE_JSON in resp.headers.get(ConstGen.CONTENT_TYPE) and resp.text is not None:
+                resp_json = json.loads(resp.text)
+                if resp_json[ConstGen.CODE] == ResponseCode.OK.value:
+                    cluster_list = resp_json["data"]
+                    cluster_data = []
+                    for cluster in cluster_list:
+                        # apiservers = cluster.get(CUK_KEY_API_SERVER)
+                        # apiserver_list = apiservers.split(";")
+                        # apiserver = apiserver_list[0]
+                        # if apiserver is not "":
+                        #     apiserver_tuple = apiserver.split(":")
+                        #     cluster_ip = apiserver_tuple[1][2:]
+                        #     cluster_port = apiserver_tuple[2]
+                        post_handle_cluster = {"cluster_name": cluster.get("name"), "cluster_ip": "",
+                                               "cluster_port": "", "cluster_type": "CUK",
+                                               "cluster_apiserver": "", "cluster_apiservers": ""}
+                        cluster_data.append(post_handle_cluster)
+                    return True, cluster_data
+                else:
+                    return False, resp.text
+        else:
+            ret_data = {ConstGen.CODE: ResponseCode.SysError.value, ConstGen.MESSAGE: resp.text}
+            return False, json.dumps(ret_data, ensure_ascii=False)
+
+    def list_cuk_cluster(self, regions):
+        ret_tuple = self.get_cuk_list(regions)
+        if ret_tuple[0]:
+            return CommonFunc().fabricate_response_data(ConstGen.SUCCESS_CODE, ResponseCode.OK.value,
+                                                        ConstGen.SUCCESS_STR, None, ret_tuple[1])
+        else:
+            return CommonFunc().fabricate_response_data(ConstGen.FAIL_CODE, ResponseCode.Failure.value, ret_tuple[1])
+
+    def get_cuk_info(self, region_id, cluster_name):
+        cluster_type = "CUK"
+        cuk_info = self.get_cuk_rest_info(region_id, cluster_name)
+        token = self.get_cuk_token(region_id, cluster_name)
+        if cuk_info is not None and token is not None:
+            api_servers = json.loads(cuk_info).get(CUK_KEY_API_SERVER)
+            apiserver_list = api_servers.split(";")
+            api_server = apiserver_list[0]
+            network = json.loads(cuk_info).get(CUK_KEY_NETWORK)
+            vpc = json.loads(cuk_info).get(CUK_KEY_VPC)
+            if type(api_server) is str and type(token) is str:
+                apiserver = api_server.split(":")
+                cluster_ip = apiserver[1][2:]
+                cluster_port = apiserver[2]
+                cluster_info = {"cluster_type": cluster_type, "cluster_ip": cluster_ip, "cluster_port": cluster_port,
+                                "cluster_token": token, "cluster_apiserver": api_server,
+                                "cluster_apiservers": apiserver_list}
+                if type(network) is str:
+                    cluster_info["cluster_network"] = network
+                if type(vpc) is str:
+                    cluster_info["cluster_vpc"] = vpc
+            else:
+                cluster_info = {}
+        else:
+            cluster_info = {}
+        print(cluster_info)
+        return cluster_info
+
+    def get_cuk_apiserver(self, regions, cluster_name):
+        request_url = self.cuk_domain + CUK_URL_PREFIX + CUK_URL_REGIONS + regions + CUK_URL_CLUSTER_URL + "/" + cluster_name
+        print(request_url)
+        urllib3.disable_warnings()
+        try:
+            resp = requests.request(RequestMethod.GET.value, request_url, cookies=self.login_cookie, verify=False)
+        except Exception as e:
+            print("cuk请求异常：" + e.__str__())
+            return e.__str__()
+        resp_code = resp.status_code
+        if resp_code == 200:
+            if ConstGen.CONTENT_TYPE_JSON in resp.headers.get(ConstGen.CONTENT_TYPE) and resp.text is not None:
+                resp_json = json.loads(resp.text)
+                apiservers = resp_json.get(CUK_KEY_API_SERVER)
+                apiserver_list = apiservers.split(";")
+                return apiserver_list[0]
+            else:
+                return None
+        else:
+            return None
+
+    def get_cuk_rest_info(self, regions, cluster_name):
+        if self.login_cookie is not None:
+            request_url = self.cuk_domain + CUK_URL_PREFIX + CUK_URL_REGIONS + regions + CUK_URL_CLUSTER_URL + "/" + cluster_name
+            print(request_url)
+            urllib3.disable_warnings()
+            try:
+                resp = requests.request(RequestMethod.GET.value, request_url, cookies=self.login_cookie, verify=False)
+                print(resp.text)
+            except Exception as e:
+                print("cuk请求异常：" + e.__str__())
+                return None
+            resp_code = resp.status_code
+            if resp_code == 200:
+                if ConstGen.CONTENT_TYPE_JSON in resp.headers.get(ConstGen.CONTENT_TYPE) and resp.text is not None:
+                    return resp.text
+                else:
+                    return None
+            else:
+                return None
+        else:
+            return None
+
+    def get_cuk_token(self, regions, cluster_name):
+        if self.login_cookie is not None:
+            request_url = self.cuk_domain + CUK_URL_PREFIX + CUK_URL_REGIONS + regions + CUK_URL_CLUSTER_URL + "/" + cluster_name \
+                          + "/" + CUK_URL_ADMIN_TOKEN
+            urllib3.disable_warnings()
+            try:
+                resp = requests.request(RequestMethod.GET.value, request_url, cookies=self.login_cookie, verify=False)
+
+            except Exception as e:
+                print("cuk请求异常：" + e.__str__())
+                return None
+            resp_code = resp.status_code
+            if resp_code == 200:
+                if ConstGen.CONTENT_TYPE_JSON in resp.headers.get(ConstGen.CONTENT_TYPE) and resp.text is not None:
+                    resp_json = json.loads(resp.text)
+                    return resp_json.get(CUK_KEY_ADMIN_TOKEN)
+                else:
+                    return None
+            else:
+                return None
+        else:
+            return None

cucc_common_pkg/util_pkg/kube_cluster_info_get.py

+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+'''
+@Descripttion: 
+@Author: guohb65
+@Email: guohb65@chinaunicom.cn
+@Date: 2019/12/18 14:34
+@LastEditors  : guohb65
+@LastEditTime : 2019-12-20 14:53:48
+'''
+import json
+import os
+import requests
+import urllib3
+
+from cucc_common_pkg.util_pkg.cke_cluster_info import CkeClusterInfo
+from cucc_common_pkg.util_pkg.const import ResponseCode
+from .common_dao import CommonDAO
+from .common_func import CommonFunc
+from .const import ConstGen, ConstClusterColumn, ConstTableName, RequestMethod
+
+TG_DOMAIN = "TG_DOMAIN"
+SSO_URL = "/sso/v1/users/info"
+
+
+class KubeClusterInfoGet(object):
+
+    def __init__(self):
+        env_dist = os.environ
+        common_mount_path = env_dist.get(ConstGen.COMMON_MOUNT_PATH)
+        common_conf_file = open(common_mount_path, 'r')
+        common_data_json = json.loads(common_conf_file.read())
+        common_conf_file.close()
+        tg_domain = common_data_json.get(TG_DOMAIN)
+        self.sso_url = tg_domain + SSO_URL
+
+    def get_login_account(self, login_cookies):
+        urllib3.disable_warnings()
+        try:
+            resp = requests.request(RequestMethod.GET.value, self.sso_url, cookies=login_cookies, verify=False)
+        except Exception as e:
+            print("SSO请求异常：" + e.__str__())
+            return False, "SSO请求异常：" + e.__str__()
+        if ConstGen.CONTENT_TYPE_JSON in resp.headers.get(ConstGen.CONTENT_TYPE) and resp.text is not None:
+            ret_data = json.loads(resp.text)
+            if ResponseCode.OK.value == ret_data.get(ConstGen.CODE):
+                user_info = ret_data.get(ConstGen.DATA_STR)
+                return True, user_info.get(ConstGen.ACCOUNT_ID_STR)
+        return False, None
+
+    @staticmethod
+    def get_cluster_info_from_db(cluster_name, region_id, login_account):
+        if login_account is not None:
+            query_sql = "SELECT  if(kc.cluster_ip is null,temp.cke_apiserver," \
+                        + "CONCAT(kc.cluster_ip,\":\",kc.cluster_port)) as cluster_apiserver, " \
+                        + "ifnull(kc.cluster_token,temp.cke_token) as cluster_token ,temp.cluster_type" \
+                        + " FROM (select ci.cke_name,cke_apiserver,ci.cke_token,ci.cluster_type " \
+                        + "from csm.csm_instances ci where create_account_id='" \
+                        + CommonDAO.reverse_injection_conversion(
+                login_account) + "' and region_id='" + CommonDAO.reverse_injection_conversion(
+                region_id) + "' and cke_name='" + CommonDAO.reverse_injection_conversion(cluster_name) \
+                        + "' union select cic.cke_name,cic.cke_apiserver,cic.cke_token,cic.cluster_type " \
+                        + "from csm.csm_instance_clusters cic where create_account_id='" \
+                        + CommonDAO.reverse_injection_conversion(
+                login_account) + "' and region_id='" + CommonDAO.reverse_injection_conversion(
+                region_id) + "' and cke_name='" \
+                        + CommonDAO.reverse_injection_conversion(
+                cluster_name) + "') as temp left join kube_cluster kc on temp.cke_name=kc.cluster_name and kc.region_id='" \
+                        + CommonDAO.reverse_injection_conversion(region_id) + "'"
+            ret_dict = CommonDAO().exec_query_sql(query_sql)
+            print(ret_dict)
+            if ret_dict[ConstGen.RET_CODE] is ConstGen.SUCCESS_CODE and ret_dict[ConstGen.ROWCOUNT_STR] is not "0":
+                data_rows = ret_dict[ConstGen.DATA_ROWS_STR]
+                if len(data_rows) == 1:
+                    ret_data = data_rows[0]
+                    api_server = ret_data["cluster_apiserver"]
+                    apiserver = api_server.split(":")
+                    cluster_ip = apiserver[0]
+                    cluster_port = apiserver[1]
+                    ret_data["cluster_apiserver"] = "https://" + api_server
+                    ret_data["cluster_apiservers"] = [ret_data["cluster_apiserver"]]
+                    ret_data["cluster_ip"] = cluster_ip
+                    ret_data["cluster_port"] = cluster_port
+                    return True, data_rows[0]
+                else:
+                    print("数据不唯一")
+                    return False, None
+            else:
+                print(ret_dict)
+                return False, None
+        else:
+            print("用户信息不存在")
+            return False, None
+
+    @staticmethod
+    def get_self_cluster_info(cluster_name, region_id, login_account):
+        if login_account is not None:
+            exact_dict = {ConstClusterColumn.CLUSTER_NAME: cluster_name,
+                          ConstClusterColumn.CREATE_USER_ID: login_account}
+            if region_id is not None:
+                exact_dict[ConstClusterColumn.REGION_ID] = region_id
+            query_condition = {ConstGen.EXACT_STR: exact_dict}
+            query_key_list = [ConstClusterColumn.CLUSTER_TYPE, ConstClusterColumn.CLUSTER_IP,
+                              ConstClusterColumn.CLUSTER_PORT,
+                              ConstClusterColumn.CLUSTER_TOKEN, ConstClusterColumn.CA_CRT,
+                              ConstClusterColumn.CLIENT_CRT, ConstClusterColumn.CLIENT_KEY]
+            query_sql = CommonDAO().gen_query_sql(
+                query_condition, None, ConstTableName.TB_KUBE_CLUSTER, query_key_list)
+            ret_dict = CommonDAO().exec_query_sql(query_sql)
+            print(ret_dict)
+            if ret_dict[ConstGen.RET_CODE] is ConstGen.SUCCESS_CODE and ret_dict[ConstGen.ROWCOUNT_STR] is not "0":
+                data_rows = ret_dict[ConstGen.DATA_ROWS_STR]
+                if len(data_rows) == 1:
+                    ret_data = data_rows[0]
+                    ret_data["cluster_apiserver"] = "https://" + ret_data[ConstClusterColumn.CLUSTER_IP] + ":" + \
+                                                    ret_data[ConstClusterColumn.CLUSTER_PORT]
+                    ret_data["cluster_apiservers"] = [ret_data["cluster_apiserver"]]
+                    return True, data_rows[0]
+                else:
+                    print("数据不唯一")
+                    return False, None
+            else:
+                print(ret_dict)
+                return False, None
+        else:
+            print("用户信息不存在")
+            return False, None
+
+    def get_cluster_info(self, cluster_name, login_cookie, region_id=None):
+        """
+        获取集群server信息(内部使用)
+        :param region_id:
+        :param cluster_name:
+        :param login_cookie:
+        :return:
+        """
+        ret_tuple = self.get_login_account(login_cookie)
+        if cluster_name is None or cluster_name == "":
+            print("参数 cluster_name 不存在")
+            return {}
+        if ret_tuple[0] is True:
+            login_account = ret_tuple[1]
+            if login_account is not None:
+                # cke_cluster_info = CkeClusterInfo(login_cookie)
+                # cluster_info = cke_cluster_info.get_cke_info(region_id, cluster_name)
+                # if cluster_info is None or len(cluster_info) == 0:
+                #     cluster_info_tuple = self.get_cluster_info_from_db(cluster_name, region_id, login_account)
+                #     if cluster_info_tuple[0] is True:
+                #         cluster_info = cluster_info_tuple[1]
+                # return cluster_info
+                # cluster_info_tuple = self.get_self_cluster_info(cluster_name, region_id, login_account)
+                flag = False
+                cluster_info = {}
+                cluster_info_tuple = self.get_cluster_info_from_db(cluster_name, region_id, login_account)
+                if cluster_info_tuple[0] is True:
+                    cluster_info = cluster_info_tuple[1]
+                    if cluster_info["cluster_type"] == "CKE":
+                        flag = True
+                else:
+                    flag = True
+                if flag:
+                    cke_cluster_info = CkeClusterInfo(login_cookie)
+                    cluster_info = cke_cluster_info.get_cke_info(region_id, cluster_name)
+                return cluster_info
+
+        print("用户信息不存在")
+        return {}
+
+    @staticmethod
+    def get_instance_clusters(account_id, region_id, instance_name):
+        query_sql = "SELECT cke_name AS cluster_name " \
+                    + " FROM csm_instances " \
+                    + " WHERE instance_name = '" + CommonDAO.reverse_injection_conversion(instance_name) + "'" \
+                    + " AND region_id = '" + CommonDAO.reverse_injection_conversion(region_id) + "'" \
+                    + " AND create_account_id = '" + CommonDAO.reverse_injection_conversion(account_id) + "'" \
+                    + " UNION SELECT cke_name AS cluster_name" \
+                    + " FROM csm_instance_clusters " \
+                    + " WHERE instance_name='" + CommonDAO.reverse_injection_conversion(instance_name) + "'" \
+                    + " AND region_id = '" + CommonDAO.reverse_injection_conversion(region_id) + "'" \
+                    + " AND create_account_id = '" + CommonDAO.reverse_injection_conversion(account_id) + "'"
+        query_res = CommonDAO().exec_query_sql(query_sql)
+        print(query_res)
+        if query_res[ConstGen.RET_CODE] is ConstGen.SUCCESS_CODE:
+            return True, query_res[ConstGen.DATA_ROWS_STR]
+        else:
+            return False, None
+
+    @staticmethod
+    def cluster_info_pre_handle(cluster_info):
+        """
+        获取的集群信息预处理
+        :param cluster_info:
+        :return:
+        """
+        if cluster_info is None or len(cluster_info) == 0:
+            return False, CommonFunc().fabricate_response_data(ConstGen.FAIL_CODE, ResponseCode.Failure.value,
+                                                               "未查到集群相关信息")
+        else:
+            return True, None
+
+    @staticmethod
+    def get_cluster_token(cluster_info):
+        """
+        通过集群信息获取集群token
+        :param cluster_info:
+        :return:
+        """
+        return cluster_info[ConstClusterColumn.CLUSTER_TOKEN]
+
+    @staticmethod
+    def get_cluster_ip(cluster_info):
+        """
+        通过集群信息获取集群IP
+        :param cluster_info:
+        :return:
+        """
+        return cluster_info[ConstClusterColumn.CLUSTER_IP]
+
+    @staticmethod
+    def get_cluster_port(cluster_info):
+        """
+        通过集群信息获取集群IP
+        :param cluster_info:
+        :return:
+        """
+        return cluster_info[ConstClusterColumn.CLUSTER_PORT]
+
+    def get_cluster_api_server(self, cluster_info):
+        """
+        通过集群信息获取集群api访问地址
+        :param cluster_info:
+        :return:
+        """
+        cluster_ip = self.get_cluster_ip(cluster_info)
+        cluster_port = self.get_cluster_port(cluster_info)
+        return ConstGen.HTTPS_STR + cluster_ip + ":" + cluster_port
+
+    def gen_json_from_json_path(self, json_path_list):
+        '''
+        根据jsonpath生成json数据格式的封装服务
+        :param json_path_list:
+        :return:
+        '''
+        trans_data = {ConstGen.TRANS_JSON_ARRAY_STR: json_path_list}
+        json_data = CommonFunc().request_trans_service(ConstGen.JSON_PATH_TO_JSON_URL, trans_data)
+        if json_data[ConstGen.RET_CODE] != '0':
+            if ConstGen.RET_VAL in json_data:
+                data = json_data[ConstGen.RET_VAL]
+                return data
+            else:
+                return json_data
+        else:
+            return json_data

cucc_common_pkg/util_pkg/login_verify.py

+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+'''
+@Descripttion: 接入天宫校验
+@Author: guohb65
+@Email: guohb65@chinaunicom.cn
+@Date: 2020/4/30 9:57
+@LastEditors: guohb65
+@LastEditTime: 2020/4/30 9:57
+'''
+import datetime
+import json
+import os
+
+import requests
+import urllib3
+from flask import request, g
+
+from cucc_common_pkg.util_pkg.common_func import CommonFunc
+from cucc_common_pkg.util_pkg.const import RequestMethod, ConstGen, ResponseCode
+
+TG_DOMAIN = "TG_DOMAIN"
+CONFIG_CENTER_DOMAIN = "CONFIG_CENTER_DOMAIN"
+IAM_DOMAIN = "IAM_DOMAIN"
+ACCESS_TOKEN = "accessToken"
+SSO_URL = "/sso/v1/users/info"
+CSM_CONFIG_REGION_URL = "/configcenter/v1/product/csm/regions"
+CKE_CONFIG_REGION_URL = "/configcenter/v1/product/cke/regions"
+IAM_URL = "/iam/v1/checkuserhaspermission"
+IAM_OBJ_URL = "/iam/v2/checkuserhaspermissionwithinstanceattribution"
+IAM_LIST_URL = "/iam/v2/checkuserhaspermissionandgetinstancelist"
+REGION_CODE = "regionCode"
+IS_AUTHORIZED = "isAuthorized"
+PRODUCT_CODE = "productCode"
+ACTION_CODE = "actionCode"
+CRN = "crn"
+USER_HAS_PERMISSION = "userHasPermission"
+
+INSTANCE_LIST = "instanceList"
+
+
+class LoginVerify(object):
+
+    def __init__(self):
+        env_dist = os.environ
+        common_mount_path = env_dist.get(ConstGen.COMMON_MOUNT_PATH)
+        common_conf_file = open(common_mount_path, 'r')
+        common_data_json = json.loads(common_conf_file.read())
+        common_conf_file.close()
+        tg_domain = common_data_json.get(TG_DOMAIN)
+        self.config_center_domain = common_data_json.get(CONFIG_CENTER_DOMAIN)
+        self.iam_domain = common_data_json.get(IAM_DOMAIN)
+        self.sso_url = tg_domain + SSO_URL
+        self.cookies = request.cookies
+
+    def is_login(self):
+        urllib3.disable_warnings()
+        start_time = None
+        try:
+            print(f"请求SSO开始:GET {self.sso_url}")
+            start_time = datetime.datetime.now()
+            resp = requests.request(RequestMethod.GET.value, self.sso_url,
+                                    cookies=self.cookies, verify=False, timeout=5)
+            end_time = datetime.datetime.now()
+            consume_ms = (end_time - start_time).total_seconds() * 1000
+            print(f"请求SSO正常结束,耗时 {consume_ms} 豪秒:GET {self.sso_url}")
+        except Exception as e:
+            if start_time:
+                end_time = datetime.datetime.now()
+                consume_ms = (end_time - start_time).total_seconds() * 1000
+                print(f"请求SSO异常结束,耗时 {consume_ms} 豪秒:e={e},GET {self.sso_url}")
+            else:
+                print(f"请求SSO异常结束:e={e},GET {self.sso_url}")
+            return False, CommonFunc().fabricate_response_data(ConstGen.SUCCESS_CODE, ResponseCode.Failure.value,
+                                                               "SSO请求异常")
+
+        resp_code = resp.status_code
+        if resp_code == 200:
+            if ConstGen.CONTENT_TYPE_JSON in resp.headers.get(ConstGen.CONTENT_TYPE) and resp.text is not None:
+                ret_data = json.loads(resp.text)
+                if ResponseCode.OK.value == ret_data.get(ConstGen.CODE):
+                    g.user_info = ret_data.get(ConstGen.DATA_STR)
+                    g.cookies = self.cookies
+                    print("SSO返回用户信息：" + g.user_info.__str__())
+                    return True, None
+        return False, CommonFunc().user_info_error()
+
+    def config_center_verify(self, region_id):
+        config_center_url = self.config_center_domain + CSM_CONFIG_REGION_URL + "?" \
+                            + REGION_CODE + "=" + region_id + "&" + IS_AUTHORIZED + "=" + "true"
+        urllib3.disable_warnings()
+        try:
+            resp = requests.request(RequestMethod.GET.value, config_center_url,
+                                    cookies=self.cookies, verify=False)
+        except Exception as e:
+            print("配置中心请求异常：" + e.__str__())
+            return False, CommonFunc().fabricate_response_data(ConstGen.SUCCESS_CODE, ResponseCode.Failure.value,
+                                                               "配置中心请求异常")
+
+        resp_code = resp.status_code
+        if resp_code == 200:
+            if ConstGen.CONTENT_TYPE_JSON in resp.headers.get(ConstGen.CONTENT_TYPE) and resp.text is not None:
+                ret_data = json.loads(resp.text)
+                print(ret_data)
+                if ResponseCode.OK.value == ret_data.get(ConstGen.CODE):
+                    data = ret_data.get(ConstGen.DATA_STR)
+                    if len(data) == 0:
+                        return False
+                    else:
+                        return True
+        print("配置中心请求返回：" + resp.text)
+        return False
+
+    def config_center_region_list(self):
+        config_center_url = self.config_center_domain + CSM_CONFIG_REGION_URL + "?" + IS_AUTHORIZED + "=" + "true"
+        urllib3.disable_warnings()
+        try:
+            resp = requests.request(RequestMethod.GET.value, config_center_url,
+                                    cookies=self.cookies, verify=False)
+            print("配置中心请求返回：" + resp.text)
+        except Exception as e:
+            print("配置中心请求异常：" + e.__str__())
+            return False, CommonFunc().fabricate_response_data(ConstGen.SUCCESS_CODE, ResponseCode.Failure.value,
+                                                               "配置中心请求异常")
+        resp_code = resp.status_code
+        if resp_code == 200:
+            return resp.text
+        else:
+            return False, CommonFunc().fabricate_response_data(ConstGen.SUCCESS_CODE, ResponseCode.Failure.value,
+                                                               "配置中心请求异常")
+
+    def iam_verify(self, region_id, action_code, instance_name=None):
+        account_id = g.user_info.get(ConstGen.ACCOUNT_ID_STR)
+        crn_pattern = "crn:ucs:*:csm:" + region_id + ":" + account_id + ":"
+        if instance_name is None:
+            crn_pattern += "*"
+        else:
+            crn_pattern += instance_name
+        iam_request_url = self.iam_domain + IAM_OBJ_URL + "?" \
+                          + PRODUCT_CODE + "=csm&" + ACTION_CODE + "=" + action_code + "&" + CRN + "=" + crn_pattern
+        urllib3.disable_warnings()
+        try:
+            resp = requests.request(RequestMethod.GET.value, iam_request_url,
+                                    cookies=self.cookies, verify=False)
+        except Exception as e:
+            print("IAM请求异常：" + e.__str__())
+            return False
+        resp_code = resp.status_code
+        if resp_code == 200:
+            if ConstGen.CONTENT_TYPE_JSON in resp.headers.get(ConstGen.CONTENT_TYPE):
+                ret_data = json.loads(resp.text)
+                if ResponseCode.OK.value == ret_data.get(ConstGen.CODE):
+                    return ret_data[ConstGen.DATA_STR].get(USER_HAS_PERMISSION)
+        print("IAM请求返回：" + resp.text)
+        return False
+
+    def iam_filter(self, region_id, action_code, filter_key, instances: list):
+        account_id = g.user_info.get(ConstGen.ACCOUNT_ID_STR)
+        iam_request_url = self.iam_domain + IAM_LIST_URL
+        urllib3.disable_warnings()
+        body_data = {}
+        body_data[PRODUCT_CODE] = "csm"
+        body_data[ACTION_CODE] = action_code
+        data = {}
+        crn_list = []
+        for instance in instances:
+            crn_data = {}
+            crn_pattern = "crn:ucs:*:csm:" + region_id + ":" + account_id + ":" + instance[filter_key]
+            crn_data[CRN] = crn_pattern
+            if crn_pattern in data:
+                data[crn_pattern].append(instance)
+            else:
+                data[crn_pattern] = [instance]
+            crn_list.append(crn_data)
+        body_data[INSTANCE_LIST] = crn_list
+        try:
+            resp = requests.request(RequestMethod.POST.value, iam_request_url, json=body_data,
+                                    cookies=self.cookies, verify=False)
+        except Exception as e:
+            print("IAM请求异常：" + e.__str__())
+            return False, "IAM请求异常"
+        resp_code = resp.status_code
+        if resp_code == 200:
+            if ConstGen.CONTENT_TYPE_JSON in resp.headers.get(ConstGen.CONTENT_TYPE):
+                ret_data = json.loads(resp.text)
+                if ResponseCode.OK.value == ret_data.get(ConstGen.CODE) and ret_data[ConstGen.DATA_STR].get(
+                        USER_HAS_PERMISSION) is True:
+                    result_data = ret_data[ConstGen.DATA_STR].get("instanceList")
+                    last_list = []
+                    for data_i in result_data:
+                        if data_i[CRN] in data:
+                            last_list.extend(data[data_i[CRN]])
+                            data.pop(data_i[CRN])
+                    return True, last_list
+                else:
+                    return False, "无权限"
+        return True, []

cucc_common_pkg/util_pkg/login_verify_low_require.py

+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+'''
+@Descripttion: 接入天宫校验
+@Author: ludq1
+@Email: ludq1@chinaunicom.cn
+@Date: 2023/9/14 9:57
+@LastEditors: ludq1
+@LastEditTime: 2023/9/14 9:57
+'''
+import datetime
+import json
+
+import requests
+import urllib3
+from flask import request, g
+
+from cucc_common_pkg.util_pkg.common_func import CommonFunc
+from cucc_common_pkg.util_pkg.const import RequestMethod, ConstGen, ResponseCode
+
+
+class LoginVerifyLowRequire(object):
+    SSO_URL = "/sso/v1/users/info"
+
+    def is_login(self, sso_domain: str):
+        urllib3.disable_warnings()
+        start_time = None
+        sso_url = f"{sso_domain}{self.SSO_URL}"
+        try:
+            print(f"请求SSO开始:GET {sso_url}")
+            start_time = datetime.datetime.now()
+            resp = requests.request(RequestMethod.GET.value, sso_url, cookies=request.cookies, verify=False, timeout=5)
+            end_time = datetime.datetime.now()
+            consume_ms = (end_time - start_time).total_seconds() * 1000
+            print(f"请求SSO正常结束,耗时 {consume_ms} 豪秒:GET {sso_url}")
+        except Exception as e:
+            if start_time:
+                end_time = datetime.datetime.now()
+                consume_ms = (end_time - start_time).total_seconds() * 1000
+                print(f"请求SSO异常结束,耗时 {consume_ms} 豪秒:e={e},GET {sso_url}")
+            else:
+                print(f"请求SSO异常结束:e={e},GET {sso_url}")
+            return False, CommonFunc().fabricate_response_data(ConstGen.SUCCESS_CODE, ResponseCode.Failure.value,
+                                                               "SSO请求异常")
+
+        resp_code = resp.status_code
+        if resp_code == 200:
+            if ConstGen.CONTENT_TYPE_JSON in resp.headers.get(ConstGen.CONTENT_TYPE) and resp.text is not None:
+                ret_data = json.loads(resp.text)
+                if ResponseCode.OK.value == ret_data.get(ConstGen.CODE):
+                    g.user_info = ret_data.get(ConstGen.DATA_STR)
+                    g.cookies = request.cookies
+                    print("SSO返回用户信息：" + g.user_info.__str__())
+                    return True, None
+        return False, CommonFunc().user_info_error()

cucc_common_pkg/util_pkg/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

cucc_common_pkg/util_pkg/resource_obj_opt.py

+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+'''
+@Descripttion: 资源对象操作
+@Author: guohb65
+@Email: guohb65@chinaunicom.cn
+@Date: 2019/12/13 9:18
+@LastEditors  : guohb65
+@LastEditTime : 2019-12-20 14:51:26
+'''
+import json
+
+from cucc_common_pkg.util_pkg.common_func import CommonFunc
+from cucc_common_pkg.util_pkg.const import ConstGen, RequestMethod, K8SRestStr
+
+
+class ResourceObjOpt(object):
+
+    @staticmethod
+    def object_create(api_server, api_url, namespace, obj_type, body_data, token=None, ca_crt_data=None,
+                      client_crt_data=None, client_key_data=None):
+        """
+        对象创建
+        :param api_server:
+        :param api_url:
+        :param namespace:
+        :param obj_type:
+        :param body_data:
+        :param token:
+        :param ca_crt_data:
+        :param client_crt_data:
+        :param client_key_data:
+        :return:
+        """
+        request_url = api_server + api_url + K8SRestStr.NAMESPACES
+        if namespace is None and obj_type is K8SRestStr.NAMESPACES and body_data is not None:
+            pass
+        elif namespace is not None and obj_type is not None and body_data is not None:
+            request_url += ConstGen.BACKSLASH + namespace + ConstGen.BACKSLASH + obj_type
+        else:
+            return CommonFunc.gen_inner_resp_data(ConstGen.FAIL_CODE, "缺少参数")
+        headers = {K8SRestStr.CONTENT_TYPE: K8SRestStr.APPLICATION_JSON}
+        params = {ConstGen.DATA_STR: json.dumps(
+            body_data), K8SRestStr.HEADERS: headers}
+        return CommonFunc().pre_exec_rest_api(RequestMethod.POST.value, request_url, params, token,
+                                              ca_crt_data, client_crt_data, client_key_data)
+
+    @staticmethod
+    def object_create_dryrun(api_server, api_url, namespace, obj_type, body_data, token=None, ca_crt_data=None,
+                             client_crt_data=None, client_key_data=None):
+        """
+        对象创建
+        :param api_server:
+        :param api_url:
+        :param namespace:
+        :param obj_type:
+        :param body_data:
+        :param token:
+        :param ca_crt_data:
+        :param client_crt_data:
+        :param client_key_data:
+        :return:
+        """
+        request_url = api_server + api_url + K8SRestStr.NAMESPACES
+        if namespace is None and obj_type is K8SRestStr.NAMESPACES and body_data is not None:
+            pass
+        elif namespace is not None and obj_type is not None and body_data is not None:
+            request_url += ConstGen.BACKSLASH + namespace + ConstGen.BACKSLASH + obj_type
+        else:
+            return CommonFunc.gen_inner_resp_data(ConstGen.FAIL_CODE, "缺少参数")
+        headers = {K8SRestStr.CONTENT_TYPE: K8SRestStr.APPLICATION_JSON}
+        param_dict = {"dryRun": "All"}
+        params = {ConstGen.DATA_STR: json.dumps(body_data), K8SRestStr.HEADERS: headers,
+                  ConstGen.PARAMS_STR: param_dict}
+        return CommonFunc().pre_exec_rest_api(RequestMethod.POST.value, request_url, params, token,
+                                              ca_crt_data, client_crt_data, client_key_data)
+
+    @staticmethod
+    def object_patch_dryrun(api_server, api_url, namespace, obj_name, obj_type, body_data, token=None, ca_crt_data=None,
+                            client_crt_data=None, client_key_data=None):
+        """
+        对象创建
+        :param obj_name:
+        :param api_server:
+        :param api_url:
+        :param namespace:
+        :param obj_type:
+        :param body_data:
+        :param token:
+        :param ca_crt_data:
+        :param client_crt_data:
+        :param client_key_data:
+        :return:
+        """
+        request_url = api_server + api_url + K8SRestStr.NAMESPACES
+        if namespace is None and obj_type is K8SRestStr.NAMESPACES and body_data is not None:
+            pass
+        elif namespace is not None and obj_type is not None and body_data is not None:
+            request_url += ConstGen.BACKSLASH + namespace + ConstGen.BACKSLASH + obj_type + ConstGen.BACKSLASH + obj_name
+        else:
+            return CommonFunc.gen_inner_resp_data(ConstGen.FAIL_CODE, "缺少参数")
+        headers = {K8SRestStr.CONTENT_TYPE: K8SRestStr.MERGE_PATCH_JSON}
+        param_dict = {"dryRun": "All"}
+        params = {ConstGen.DATA_STR: json.dumps(body_data), K8SRestStr.HEADERS: headers,
+                  ConstGen.PARAMS_STR: param_dict}
+        return CommonFunc().pre_exec_rest_api(RequestMethod.PATCH.value, request_url, params, token,
+                                              ca_crt_data, client_crt_data, client_key_data)
+
+    @staticmethod
+    def object_alter(api_server, api_url, namespace, obj_type, obj_name, body_data, token=None, ca_crt_data=None,
+                     client_crt_data=None, client_key_data=None):
+        """
+        对象更新
+        :param api_server:
+        :param api_url:
+        :param namespace:
+        :param obj_type:
+        :param body_data:
+        :param token:
+        :param ca_crt_data:
+        :param client_crt_data:
+        :param client_key_data:
+        :return:
+        """
+        request_url = api_server + api_url + K8SRestStr.NAMESPACES
+        if namespace is None and obj_type is K8SRestStr.NAMESPACES and body_data is not None:
+            pass
+        elif namespace is not None and obj_type is not None and body_data is not None:
+            request_url += ConstGen.BACKSLASH + namespace + ConstGen.BACKSLASH + obj_type + ConstGen.BACKSLASH + obj_name
+        else:
+            return CommonFunc.gen_inner_resp_data(ConstGen.FAIL_CODE, "缺少参数")
+        if obj_type is K8SRestStr.DEPLOYMENTS:
+            headers = {K8SRestStr.CONTENT_TYPE: K8SRestStr.STRATEGIC_MERGE_PATCH_JSON}
+        else:
+            headers = {K8SRestStr.CONTENT_TYPE: K8SRestStr.MERGE_PATCH_JSON}
+        params = {ConstGen.DATA_STR: json.dumps(body_data), K8SRestStr.HEADERS: headers}
+        return CommonFunc().pre_exec_rest_api(RequestMethod.PATCH.value, request_url, params, token,
+                                              ca_crt_data, client_crt_data, client_key_data)
+
+    @staticmethod
+    def object_opt(api_server, api_url, opt_type, namespace, obj_type, obj_name, body_data, token=None,
+                   ca_crt_data=None, client_crt_data=None, client_key_data=None):
+        """
+        对象操作(包含查询、更新和删除)
+        :param api_server:
+        :param api_url:
+        :param opt_type:
+        :param namespace:
+        :param obj_type:
+        :param obj_name:
+        :param body_data:
+        :param token:
+        :param ca_crt_data:
+        :param client_crt_data:
+        :param client_key_data:
+        :return:
+        """
+        request_url = api_server + api_url
+        if opt_type is not None and obj_name is not None:
+            if opt_type is RequestMethod.PUT.value and body_data is not None:
+                params = {ConstGen.DATA_STR: json.dumps(body_data)}
+            elif opt_type is RequestMethod.PATCH.value and body_data is not None:
+                headers = {
+                    K8SRestStr.CONTENT_TYPE: K8SRestStr.PATCH_CONTENT_TYPE_STR}
+                params = {ConstGen.DATA_STR: json.dumps(
+                    body_data), K8SRestStr.HEADERS: headers}
+            elif opt_type is RequestMethod.DELETE.value or opt_type is RequestMethod.GET.value:
+                params = None
+            else:
+                return CommonFunc.gen_inner_resp_data(ConstGen.FAIL_CODE, "方法不支持")
+            if namespace is None:
+                request_url += obj_type + ConstGen.BACKSLASH + obj_name
+            elif namespace is not None and obj_type is not None:
+                request_url += K8SRestStr.NAMESPACES + ConstGen.BACKSLASH + namespace + ConstGen.BACKSLASH + obj_type \
+                               + ConstGen.BACKSLASH + obj_name
+            return CommonFunc().pre_exec_rest_api(opt_type, request_url, params, token,
+                                                  ca_crt_data, client_crt_data, client_key_data)
+        else:
+            return CommonFunc.gen_inner_resp_data(ConstGen.FAIL_CODE, "缺少参数")
+
+    @staticmethod
+    def object_merge_patch(api_server, api_url, namespace, obj_type, obj_name, body_data, token=None,
+                           ca_crt_data=None, client_crt_data=None, client_key_data=None):
+        """
+        对象操作(包含查询、更新和删除)
+        :param api_server:
+        :param api_url:
+        :param opt_type:
+        :param namespace:
+        :param obj_type:
+        :param obj_name:
+        :param body_data:
+        :param token:
+        :param ca_crt_data:
+        :param client_crt_data:
+        :param client_key_data:
+        :return:
+        """
+        request_url = api_server + api_url
+        if obj_name is not None:
+            headers = {K8SRestStr.CONTENT_TYPE: K8SRestStr.MERGE_PATCH_JSON}
+            params = {ConstGen.DATA_STR: json.dumps(body_data), K8SRestStr.HEADERS: headers}
+            if namespace is None:
+                request_url += obj_type + ConstGen.BACKSLASH + obj_name
+            elif namespace is not None and obj_type is not None:
+                request_url += K8SRestStr.NAMESPACES + ConstGen.BACKSLASH + namespace + ConstGen.BACKSLASH + obj_type \
+                               + ConstGen.BACKSLASH + obj_name
+            return CommonFunc().pre_exec_rest_api(RequestMethod.PATCH.value, request_url, params, token,
+                                                  ca_crt_data, client_crt_data, client_key_data)
+        else:
+            return CommonFunc.gen_inner_resp_data(ConstGen.FAIL_CODE, "缺少参数")
+
+    @staticmethod
+    def object_list(api_server, api_url, namespace, obj_type, token=None, params=None, ca_crt_data=None,
+                    client_crt_data=None, client_key_data=None):
+        request_url = api_server + api_url
+        if namespace is None and obj_type is not None:
+            request_url += obj_type
+        elif namespace is not None and obj_type is not None:
+            request_url += K8SRestStr.NAMESPACES + ConstGen.BACKSLASH + \
+                           namespace + ConstGen.BACKSLASH + obj_type
+        else:
+            return CommonFunc.gen_inner_resp_data(ConstGen.FAIL_CODE, "缺少参数")
+        return CommonFunc().pre_exec_rest_api(RequestMethod.GET.value, request_url, params, token,
+                                              ca_crt_data, client_crt_data, client_key_data)

requirements.txt

+bleach==3.3.0
+certifi==2020.12.5
+chardet==4.0.0
+click==7.1.2
+colorama==0.4.4
+crypto
+DBUtils==2.0
+docutils==0.16
+Flask==2.0.1
+gitdb==4.0.7
+GitPython==3.1.17
+idna==2.10
+importlib-metadata==3.7.3
+itsdangerous==2.0.1
+Jinja2==3.0.1
+keyring==23.0.1
+MarkupSafe==2.0.1
+packaging==20.9
+pkginfo==1.7.0
+pyasn1==0.4.8
+pycryptodome==3.9.9
+Pygments==2.8.1
+PyMySQL==0.10.1
+pyparsing==2.4.7
+pytz==2021.1
+pywin32-ctypes==0.2.0
+PyYAML==5.3.1
+rarfile==4.0
+readme-renderer==29.0
+redis==3.5.3
+requests==2.25.1
+requests-toolbelt==0.9.1
+rfc3986==1.4.0
+rsa==4.6
+simplejson==3.17.0
+six==1.15.0
+smmap==4.0.0
+tqdm==4.59.0
+twine==3.4.1
+urllib3==1.26.4
+webencodings==0.5.1
+Werkzeug==2.0.1
+zipp==3.4.1
+jsonpath-rw-ext==1.2.2
+jsonpath-rw==1.4.0
+
+setuptools~=54.2.0
\ No newline at end of file

setup.py

+#!/usr/bin/env python
+# -*- encoding: utf-8 -*-
+"""
+@Version: 1.0
+@Python Version:3.6.6
+@Author: ludq1
+@Email: ludq1@chinaunicom.cn
+@date: 2023/04/07 11:40:00
+@Description:
+"""
+
+import setuptools
+
+setuptools.setup(
+    name="cucc_common_pkg",  # 包名
+    version="2.2.6",  # 版本信息
+    author="wenhx8 ludq1 guohb65",
+    author_email="ludq1@chinaunicom.cn"
+    # , packages=setuptools.find_packages()  # 要打包的项目文件夹
+    ,
+    packages=[
+        "cucc_common_pkg",
+        "cucc_common_pkg.my_datahandle",
+        "cucc_common_pkg.util_pkg",
+        "cucc_common_pkg.ludq_utils",
+        "cucc_common_pkg.ludq_utils.utils_http",
+        "cucc_common_pkg.ludq_utils.utils_k8s",
+        "cucc_common_pkg.ludq_utils.utils_k8s_istio",
+        "cucc_common_pkg.ludq_utils.utils_k8s_knative",
+        "cucc_common_pkg.ludq_utils.utils_tg_billing",
+        "cucc_common_pkg.ludq_utils.utils_tg_configcenter",
+        "cucc_common_pkg.ludq_utils.utils_tg_iam",
+        "cucc_common_pkg.ludq_utils.utils_tg_sso",
+        "cucc_common_pkg.ludq_utils.utils_tg_vpc",
+        "cucc_common_pkg.ludq_utils.utils_promapi",
+        "cucc_common_pkg.ludq_utils.utils_get_cluster_info",
+        "cucc_common_pkg.ludq_utils.utils_webservice",
+        "cucc_common_pkg.ludq_utils.utils_mesh_mng",
+    ],
+    include_package_data=True,  # 自动打包文件夹内所有数据
+    zip_safe=True,  # 设定项目包为安全，不用每次都检测其安全性
+    install_requires=[  # 安装依赖的其他包（测试数据）
+        "bleach>=3.3.0",
+        "certifi>=2020.12.5",
+        "chardet>=4.0.0",
+        "click>=7.1.2",
+        "colorama>=0.4.4",
+        "crypto",
+        "DBUtils>=2.0",
+        "docutils>=0.16",
+        "Flask",
+        "gitdb>=4.0.7",
+        "GitPython>=3.1.17",
+        "idna>=2.10",
+        "importlib-metadata>=3.7.3",
+        "itsdangerous",
+        "Jinja2",
+        "keyring>=23.0.1",
+        "MarkupSafe>=2.0.1",
+        "packaging>=20.9",
+        "pkginfo>=1.7.0",
+        "pyasn1>=0.4.8",
+        "pycryptodome>=3.9.9",
+        "Pygments>=2.8.1",
+        "PyMySQL>=0.10.1",
+        "pyparsing>=2.4.7",
+        "pytz>=2021.1",
+        "pywin32-ctypes>=0.2.0",
+        "PyYAML>=5.3.1",
+        "rarfile>=4.0",
+        "readme-renderer>=29.0",
+        "redis>=3.5.3",
+        "requests>=2.25.1",
+        "requests-toolbelt>=0.9.1",
+        "rfc3986>=1.4.0",
+        "rsa>=4.6",
+        "simplejson>=3.17.0",
+        "six>=1.15.0",
+        "smmap>=4.0.0",
+        "tqdm>=4.59.0",
+        "twine>=3.4.1",
+        "urllib3>=1.26.4",
+        "webencodings>=0.5.1",
+        "Werkzeug",
+        "zipp>=3.4.1",
+    ],
+)

test/__init__.py

+#!/usr/bin/env python
+# -*- encoding: utf-8 -*-
+"""
+@Version: 1.0
+@Python Version:3.6.6
+@Author: ludq1
+@File: __init__.py
+@Time: 2019/1/8 008 16:49
+@Description: 初始化
+"""

test/test_flask_wrapper.py

+#!/usr/bin/env python
+# -*- encoding: utf-8 -*-
+"""
+@Version: 1.0
+@Python Version:3.6.6
+@Author: wenhx8
+@File: test_flask_wrapper
+@Time: 2019/1/7 007 22:01
+@Description: 测试代码
+"""
+from unittest import TestCase, main
+from cucc_common_pkg.cfginfohandle import CfgInfoHandle
+
+import os
+
+class TestUtility(TestCase):
+    r'''
+    TestUtility
+    '''
+
+    def test_func(self):
+        r'''
+
+        Returns:
+
+        '''
+        lk = CfgInfoHandle()
+        print(lk.get_redis_info())
+
+        self.assertTrue(1 == 1)
+
+
+if __name__ == '__main__':
+    main()

test/test_httptrans.py

+#!/usr/bin/env python
+# -*- encoding: utf-8 -*-
+"""
+@Version: 1.0
+@Python Version:3.6.6
+@Author: wenhx8
+@File: test_httpTrans
+@Time: 2019/1/8 008 9:35
+@Description:
+"""
+
+from unittest import TestCase
+
+from cucc_common_pkg.globalutility import Utility, GlobalConst
+from cucc_common_pkg.httptrans import HttpTrans
+from cucc_common_pkg.globalconst import HttpConst
+
+
+class TestHttpTrans(TestCase):
+    r'''
+    TestHttpTrans
+    '''
+
+    def test_generate_header(self):
+        r'''
+
+        Returns:
+
+        '''
+        http_trans = HttpTrans(None)
+        expect_header_dict = {
+            HttpConst.HEADER_KEY_CONTENT_TYPE: HttpConst.CONTENT_TYPE_URLENCODED}
+        gen_header_dict = http_trans.generate_header(
+            content_type=None,
+            dict_header=None
+        )
+        self.assertEqual(gen_header_dict, expect_header_dict)
+
+        header = {'x-request-id': 'xx', 'x-b3-traceid': 'yy'}
+        arg_extra_dict_header = {}
+        arg_extra_dict_header['token'] = '123456'
+        http_trans = HttpTrans(header)
+        gen_header_dict = http_trans.generate_header(
+            content_type=None,
+            dict_header=arg_extra_dict_header
+        )
+        expect_header_dict = dict(header.items(), **arg_extra_dict_header)
+        expect_header_dict.update({
+            HttpConst.HEADER_KEY_CONTENT_TYPE: HttpConst.CONTENT_TYPE_URLENCODED
+        })
+        self.assertEqual(gen_header_dict, expect_header_dict)
+
+    def test_post_encodedata(self):
+        r'''
+
+        Returns:
+
+        '''
+
+        http_trans = HttpTrans(None)
+        # url = 'http://10.0.209.147/auth/relogin/logincheck'
+        # url = 'http://www.baidu.com'
+        url = 'http://10.124.151.110:31380/csm-microsrv/webutility/getjsonpath/get'
+
+
+        list = []
+        dict__data = {
+            "jsonPath": "metadata.name"
+            , "value": 123}
+        list.append(dict__data)
+
+        dict_trans_data = {
+            'transjsonarray': list
+        }
+
+        ret_str = http_trans.post_encodedata(
+            urlstr=url,
+            trans_data=dict_trans_data,
+            dict_headers=None
+        )
+
+
+
+        ret_dict = Utility.jsonstr2dict(ret_str)
+        self.assertTrue(GlobalConst.RETKEY_RET_CODE in ret_dict.keys())
+        self.assertTrue(GlobalConst.RETKEY_RET_VAL in ret_dict.keys())
+
+    def test_post_encodeddata_standard(self):
+        r'''
+
+        Returns:
+
+        '''
+        http_trans = HttpTrans(None)
+        # url = 'http://10.0.209.147/auth/relogin/logincheck'
+        url = 'http://www.baidu.com'
+        dict_trans_data = None
+        resp = http_trans.post_encodeddata_standard(url, trans_data=dict_trans_data)
+        self.assertTrue(resp.ok)

test/test_k8s_op.py

+#!/usr/bin/env python
+# -*- encoding: utf-8 -*-
+"""
+@Version: 1.0
+@Python Version:3.6.6
+@Author: wenhx8
+@File: test_httpTrans
+@Time: 2019/1/8 008 9:35
+@Description:
+"""
+
+from unittest import TestCase
+
+from cucc_common_pkg.globalconst import GlobalConst
+from cucc_common_pkg.cucc_k8s import K8sOps
+import json
+from jsonpath_rw_ext import parser
+
+
+class TestK8sOps(TestCase):
+    r'''
+    TestHttpTrans
+    '''
+
+    def test_crd_ns_create_obj(self):
+        '''
+        测试创建crd对象
+        :return:
+        '''
+
+        k8s = K8sOps(None)
+
+        str_k8s_ip_port = "10.124.151.110:6443"
+        str_k8s_token = 'eyJhbGciOiJSUzI1NiIsImtpZCI6IiJ9.eyJpc3MiOiJrdWJlcm5ldGVzL3NlcnZpY2VhY2NvdW50Iiwia3ViZXJuZXRlcy5pby9zZXJ2aWNlYWNjb3VudC9uYW1lc3BhY2UiOiJjc20tbnMiLCJrdWJlcm5ldGVzLmlvL3NlcnZpY2VhY2NvdW50L3NlY3JldC5uYW1lIjoiY3NtLXNhLXRva2VuLWc3cHZwIiwia3ViZXJuZXRlcy5pby9zZXJ2aWNlYWNjb3VudC9zZXJ2aWNlLWFjY291bnQubmFtZSI6ImNzbS1zYSIsImt1YmVybmV0ZXMuaW8vc2VydmljZWFjY291bnQvc2VydmljZS1hY2NvdW50LnVpZCI6IjZjY2RkOWJiLTA1ZTktMTFlYS1hZmM4LTUyNTQwMDE3ZDk2MiIsInN1YiI6InN5c3RlbTpzZXJ2aWNlYWNjb3VudDpjc20tbnM6Y3NtLXNhIn0.ohnipl80g-ITUOK1T7dMMeaDYDiYiCrTZ9qJVeXCnFSZFLLic7GeUWn2zAaYUe57PHh0-VuT99cyx6uVb-GFDx9bkoLvgVK_nZBEHNVin6EyeP2jnvtQ6oZGBfDfRYLrSfkTauyqnnQ3hHSZbuAt55VrZFR2ragUx30gmmnaynjQb8QMduqmvzbzKUpHgbjWzb6V93j-sR-ulLVzkbW913ceU5od6daxWiVt-98P9QQoyZMG3JwxqEOCK_G1ZzNrKrUm-DgZzx9P2HdZKfcTDyiVNfyhaZ0eOmWqwh1Xtw-NUatrlHmQYqj0FoBP0Zl1cVajlHqHwyVaVfHLephC4g'
+        str_crd_group_version = "/networking.istio.io/v1alpha3"
+        str_crd_ns_name = "/istio-dd"
+        str_crd_obj = "/gateways"
+        dict_args = '{"apiVersion":"networking.istio.io/v1alpha3","kind":"Gateway","metadata":{"name":"wen-gateway","namespace":"istio-system"},"spec":{"selector":{"istio":"ingressgateway"},"servers":[{"port":{"number":80,"name":"http","protocol":"HTTP"},"hosts":["*"]}]}}'
+        dict_args = json.loads(dict_args)
+
+        ret_str = k8s.crd_ns_create_obj(
+            str_k8s_ip_port=str_k8s_ip_port,
+            str_k8s_token=str_k8s_token,
+            str_crd_ns_name=str_crd_ns_name,
+            str_crd_group_version=str_crd_group_version,
+            str_crd_obj=str_crd_obj,
+            dict_args=dict_args
+        )
+
+        print(ret_str)
+
+    def test_crd_ns_patch_obj(self):
+        '''
+        测试修改crd对象
+        :return:
+        '''
+
+        k8s = K8sOps(None)
+
+        str_k8s_ip_port = "10.124.151.110:6443"
+        str_k8s_token = 'eyJhbGciOiJSUzI1NiIsImtpZCI6IiJ9.eyJpc3MiOiJrdWJlcm5ldGVzL3NlcnZpY2VhY2NvdW50Iiwia3ViZXJuZXRlcy5pby9zZXJ2aWNlYWNjb3VudC9uYW1lc3BhY2UiOiJjc20tbnMiLCJrdWJlcm5ldGVzLmlvL3NlcnZpY2VhY2NvdW50L3NlY3JldC5uYW1lIjoiY3NtLXNhLXRva2VuLWc3cHZwIiwia3ViZXJuZXRlcy5pby9zZXJ2aWNlYWNjb3VudC9zZXJ2aWNlLWFjY291bnQubmFtZSI6ImNzbS1zYSIsImt1YmVybmV0ZXMuaW8vc2VydmljZWFjY291bnQvc2VydmljZS1hY2NvdW50LnVpZCI6IjZjY2RkOWJiLTA1ZTktMTFlYS1hZmM4LTUyNTQwMDE3ZDk2MiIsInN1YiI6InN5c3RlbTpzZXJ2aWNlYWNjb3VudDpjc20tbnM6Y3NtLXNhIn0.ohnipl80g-ITUOK1T7dMMeaDYDiYiCrTZ9qJVeXCnFSZFLLic7GeUWn2zAaYUe57PHh0-VuT99cyx6uVb-GFDx9bkoLvgVK_nZBEHNVin6EyeP2jnvtQ6oZGBfDfRYLrSfkTauyqnnQ3hHSZbuAt55VrZFR2ragUx30gmmnaynjQb8QMduqmvzbzKUpHgbjWzb6V93j-sR-ulLVzkbW913ceU5od6daxWiVt-98P9QQoyZMG3JwxqEOCK_G1ZzNrKrUm-DgZzx9P2HdZKfcTDyiVNfyhaZ0eOmWqwh1Xtw-NUatrlHmQYqj0FoBP0Zl1cVajlHqHwyVaVfHLephC4g'
+        str_crd_group_version = "/networking.istio.io/v1alpha3"
+        str_crd_ns_name = "/istio-system"
+        str_crd_obj = "/gateways"
+        str_crd_obj_name = '/wen-gateway'
+        #dict_args = '{"apiVersion":"networking.istio.io/v1alpha3","kind":"Gateway","metadata":{"name":"wen-gateway","namespace":"istio-system"},"spec":{"selector":{"istio":"ingressgateway"},"servers":[{"port":{"number":8880,"name":"http","protocol":"HTTP"},"hosts":["*"]}]}}'
+
+        dict_args ={}
+
+        json_mata = json.loads('{ "name": "wen-gateway","namespace": "istio-system"}')
+        dict_args["apiVersion"]="networking.istio.io/v1alpha3"
+        dict_args["kind"] = "Gateway"
+        dict_args["metadata"] = json_mata
+
+        json_arr = '{"servers":[{"port":{"number":8880,"name":"http","protocol":"HTTP"},"hosts":["*"]}]}'
+
+        dict_arry = json.loads(json_arr)
+        dict_arry["selector"] = json.loads('{"istio": "ingressgateway"}')
+        dict_args["spec"] = dict_arry
+        # dict_args = json.loads(dict_args)
+
+        print(json.dumps(dict_args))
+
+
+
+        ret_str = k8s.crd_ns_patch_obj(
+            str_k8s_ip_port=str_k8s_ip_port,
+            str_k8s_token=str_k8s_token,
+            str_crd_ns_name=str_crd_ns_name,
+            str_crd_group_version=str_crd_group_version,
+            str_crd_obj=str_crd_obj,
+            str_crd_obj_name=str_crd_obj_name,
+            dict_args=dict_args
+        )
+
+        print(ret_str)
+
+    def test_crd_ns_get_obj(self):
+        '''
+        测试修改crd对象
+        :return:
+        '''
+
+        k8s = K8sOps(None)
+
+        str_k8s_ip_port = "10.124.151.110:6443"
+        str_k8s_token = 'eyJhbGciOiJSUzI1NiIsImtpZCI6IiJ9.eyJpc3MiOiJrdWJlcm5ldGVzL3NlcnZpY2VhY2NvdW50Iiwia3ViZXJuZXRlcy5pby9zZXJ2aWNlYWNjb3VudC9uYW1lc3BhY2UiOiJjc20tbnMiLCJrdWJlcm5ldGVzLmlvL3NlcnZpY2VhY2NvdW50L3NlY3JldC5uYW1lIjoiY3NtLXNhLXRva2VuLWc3cHZwIiwia3ViZXJuZXRlcy5pby9zZXJ2aWNlYWNjb3VudC9zZXJ2aWNlLWFjY291bnQubmFtZSI6ImNzbS1zYSIsImt1YmVybmV0ZXMuaW8vc2VydmljZWFjY291bnQvc2VydmljZS1hY2NvdW50LnVpZCI6IjZjY2RkOWJiLTA1ZTktMTFlYS1hZmM4LTUyNTQwMDE3ZDk2MiIsInN1YiI6InN5c3RlbTpzZXJ2aWNlYWNjb3VudDpjc20tbnM6Y3NtLXNhIn0.ohnipl80g-ITUOK1T7dMMeaDYDiYiCrTZ9qJVeXCnFSZFLLic7GeUWn2zAaYUe57PHh0-VuT99cyx6uVb-GFDx9bkoLvgVK_nZBEHNVin6EyeP2jnvtQ6oZGBfDfRYLrSfkTauyqnnQ3hHSZbuAt55VrZFR2ragUx30gmmnaynjQb8QMduqmvzbzKUpHgbjWzb6V93j-sR-ulLVzkbW913ceU5od6daxWiVt-98P9QQoyZMG3JwxqEOCK_G1ZzNrKrUm-DgZzx9P2HdZKfcTDyiVNfyhaZ0eOmWqwh1Xtw-NUatrlHmQYqj0FoBP0Zl1cVajlHqHwyVaVfHLephC4g'
+        str_crd_group_version = "/networking.istio.io/v1alpha3"
+        str_crd_ns_name = "/istio-system"
+        str_crd_obj = "/gateways"
+        str_crd_obj_name = '/wen-gateway'
+        dict_args = '{"apiVersion":"networking.istio.io/v1alpha3","kind":"Gateway","metadata":{"name":"wen-gateway","namespace":"istio-system"},"spec":{"selector":{"istio":"ingressgateway"},"servers":[{"port":{"number":8880,"name":"http","protocol":"HTTP"},"hosts":["*"]}]}}'
+        dict_args = json.loads(dict_args)
+
+        ret_str = k8s.crd_ns_get_obj(
+            str_k8s_ip_port=str_k8s_ip_port,
+            str_k8s_token=str_k8s_token,
+            str_crd_ns_name=str_crd_ns_name,
+            str_crd_group_version=str_crd_group_version,
+            str_crd_obj=str_crd_obj,
+            str_crd_obj_name=str_crd_obj_name,
+            dict_args=dict_args
+        )
+
+        print(ret_str)
+
+    def test_crd_ns_list_obj(self):
+        '''
+        测试创建crd对象
+        :return:
+        '''
+
+        k8s = K8sOps(None)
+
+        str_k8s_ip_port = "10.124.151.110:6443"
+        str_k8s_token = 'eyJhbGciOiJSUzI1NiIsImtpZCI6IiJ9.eyJpc3MiOiJrdWJlcm5ldGVzL3NlcnZpY2VhY2NvdW50Iiwia3ViZXJuZXRlcy5pby9zZXJ2aWNlYWNjb3VudC9uYW1lc3BhY2UiOiJjc20tbnMiLCJrdWJlcm5ldGVzLmlvL3NlcnZpY2VhY2NvdW50L3NlY3JldC5uYW1lIjoiY3NtLXNhLXRva2VuLWc3cHZwIiwia3ViZXJuZXRlcy5pby9zZXJ2aWNlYWNjb3VudC9zZXJ2aWNlLWFjY291bnQubmFtZSI6ImNzbS1zYSIsImt1YmVybmV0ZXMuaW8vc2VydmljZWFjY291bnQvc2VydmljZS1hY2NvdW50LnVpZCI6IjZjY2RkOWJiLTA1ZTktMTFlYS1hZmM4LTUyNTQwMDE3ZDk2MiIsInN1YiI6InN5c3RlbTpzZXJ2aWNlYWNjb3VudDpjc20tbnM6Y3NtLXNhIn0.ohnipl80g-ITUOK1T7dMMeaDYDiYiCrTZ9qJVeXCnFSZFLLic7GeUWn2zAaYUe57PHh0-VuT99cyx6uVb-GFDx9bkoLvgVK_nZBEHNVin6EyeP2jnvtQ6oZGBfDfRYLrSfkTauyqnnQ3hHSZbuAt55VrZFR2ragUx30gmmnaynjQb8QMduqmvzbzKUpHgbjWzb6V93j-sR-ulLVzkbW913ceU5od6daxWiVt-98P9QQoyZMG3JwxqEOCK_G1ZzNrKrUm-DgZzx9P2HdZKfcTDyiVNfyhaZ0eOmWqwh1Xtw-NUatrlHmQYqj0FoBP0Zl1cVajlHqHwyVaVfHLephC4g'
+        # str_crd_group_version = "/networking.istio.io/v1alpha3"
+        # str_crd_ns_name = "/istio-system"
+        # str_crd_obj = "/virtualservices"
+        str_crd_group_version = "/v1"
+        str_crd_ns_name = "/istio-system"
+        str_prefix_url = "/api"
+        str_crd_obj = "/pods"
+
+        dict_args = {"labelSelector":"app=details"}
+
+        ret_str = k8s.crd_ns_list_obj(
+            str_k8s_ip_port=str_k8s_ip_port,
+            str_k8s_token=str_k8s_token,
+            str_crd_ns_name=str_crd_ns_name,
+            str_crd_group_version=str_crd_group_version,
+            str_crd_obj=str_crd_obj,
+            str_prefix_url=str_prefix_url,
+            dict_args=dict_args
+        )
+
+        print(json.dumps(ret_str))
+        match_result = parser.match('$.items[?(@.metadata.labels.app=="gitbook-csm-design-doc")]', ret_str)
+
+        print(json.dumps(match_result))
+
+    def test_crd_ns_delete_obj(self):
+        '''
+        测试创建crd对象
+        :return:
+        '''
+
+        k8s = K8sOps(None)
+
+        str_k8s_ip_port = "10.124.151.110:6443"
+        str_k8s_token = 'eyJhbGciOiJSUzI1NiIsImtpZCI6IiJ9.eyJpc3MiOiJrdWJlcm5ldGVzL3NlcnZpY2VhY2NvdW50Iiwia3ViZXJuZXRlcy5pby9zZXJ2aWNlYWNjb3VudC9uYW1lc3BhY2UiOiJjc20tbnMiLCJrdWJlcm5ldGVzLmlvL3NlcnZpY2VhY2NvdW50L3NlY3JldC5uYW1lIjoiY3NtLXNhLXRva2VuLWc3cHZwIiwia3ViZXJuZXRlcy5pby9zZXJ2aWNlYWNjb3VudC9zZXJ2aWNlLWFjY291bnQubmFtZSI6ImNzbS1zYSIsImt1YmVybmV0ZXMuaW8vc2VydmljZWFjY291bnQvc2VydmljZS1hY2NvdW50LnVpZCI6IjZjY2RkOWJiLTA1ZTktMTFlYS1hZmM4LTUyNTQwMDE3ZDk2MiIsInN1YiI6InN5c3RlbTpzZXJ2aWNlYWNjb3VudDpjc20tbnM6Y3NtLXNhIn0.ohnipl80g-ITUOK1T7dMMeaDYDiYiCrTZ9qJVeXCnFSZFLLic7GeUWn2zAaYUe57PHh0-VuT99cyx6uVb-GFDx9bkoLvgVK_nZBEHNVin6EyeP2jnvtQ6oZGBfDfRYLrSfkTauyqnnQ3hHSZbuAt55VrZFR2ragUx30gmmnaynjQb8QMduqmvzbzKUpHgbjWzb6V93j-sR-ulLVzkbW913ceU5od6daxWiVt-98P9QQoyZMG3JwxqEOCK_G1ZzNrKrUm-DgZzx9P2HdZKfcTDyiVNfyhaZ0eOmWqwh1Xtw-NUatrlHmQYqj0FoBP0Zl1cVajlHqHwyVaVfHLephC4g'
+        str_crd_group_version = "/networking.istio.io/v1alpha3"
+
+        str_crd_ns_name = "/istio-system"
+        str_crd_obj = "/gateways"
+        str_crd_obj_name = '/bookinfo-gateway'
+        dict_args = '{"apiVersion":"networking.istio.io/v1alpha3","kind":"Gateway","metadata":{"name":"wen-gateway","namespace":"zhangx511"},"spec":{"selector":{"istio":"ingressgateway"},"servers":[{"port":{"number":8880,"name":"http","protocol":"HTTP"},"hosts":["*"]}]}}'
+        dict_args = json.loads(dict_args)
+
+        ret_str = k8s.crd_ns_delete_obj(
+            str_k8s_ip_port=str_k8s_ip_port,
+            str_k8s_token=str_k8s_token,
+            str_crd_ns_name=str_crd_ns_name,
+            str_crd_group_version=str_crd_group_version,
+            str_crd_obj=str_crd_obj,
+            str_crd_obj_name=str_crd_obj_name,
+            dict_args=dict_args
+        )
+
+        print(ret_str)

test/test_ludq_k8s_utils.py

+#!/usr/bin/env python
+# -*- encoding: utf-8 -*-
+"""
+@Version: 1.0
+@Python Version:3.6.6
+@Author: ludq1
+@File: test_ludq_k8s_utils.py
+@Time: 2021/05/04 22:01
+@Description: 测试代码
+"""
+import os
+import unittest
+from typing import List
+from unittest import TestCase, main
+
+from cucc_common_pkg.ludq_utils.utils_k8s.k8s_api_objects import K8sApiObject
+from cucc_common_pkg.ludq_utils.utils_k8s.k8s_utils import K8sUtils, K8sConst
+from cucc_common_pkg.ludq_utils.utils_k8s_knative.knative_service_obj import KnativeServiceApiObject
+from cucc_common_pkg.ludq_utils.utils_k8s_knative.knative_utils import KnativeUtils
+from cucc_common_pkg.ludq_utils.utils_v2 import UtilityV2
+
+
+class TestUtility(TestCase):
+    r'''
+    TestUtility
+    '''
+
+    @unittest.skipIf(False, '需正确设置accessToken,vpc_name_full,account_id,region_code后测试')
+    def test_format_result(self):
+        r'''
+
+        Returns:
+
+        '''
+        k8s_api_object = K8sApiObject()
+        k8s_api_object.api_version = "v1"
+        k8s_api_object.kind = "Pod"
+        k8s_api_object.namespace = "default"
+        k8s_api_object.name = "testpod"
+        self.assertEqual("v1", k8s_api_object.api_version)
+        self.assertEqual("v1", k8s_api_object.obj_type.api_version)
+        self.assertEqual("Pod", k8s_api_object.kind)
+        self.assertEqual("Pod", k8s_api_object.obj_type.kind)
+        self.assertEqual("default", k8s_api_object.namespace)
+        self.assertEqual("default", k8s_api_object.metadata.namespace)
+        self.assertEqual("testpod", k8s_api_object.name)
+        self.assertEqual("testpod", k8s_api_object.metadata.name)
+        expect_dict_for_obj_type = {
+            "apiVersion": "v1",
+            "kind": "Pod",
+        }
+        self.assertEqual(expect_dict_for_obj_type, k8s_api_object.obj_type.to_dict())
+        expect_dict_for_metadata = {
+            "namespace": "default",
+            "name": "testpod",
+        }
+        self.assertEqual(expect_dict_for_metadata, k8s_api_object.metadata.to_dict())
+        expect_dict_for_obj = dict(**expect_dict_for_obj_type)
+        expect_dict_for_obj["metadata"] = expect_dict_for_metadata
+        self.assertEqual(expect_dict_for_obj, k8s_api_object.to_dict())
+
+    @unittest.skipIf(False, '需正确设置accessToken,vpc_name_full,account_id,region_code后测试')
+    def test_k8s_utils(self):
+        k8s_utils = K8sUtils(
+            api_server=os.getenv("api_server"),
+            token=os.getenv("token"),
+        )
+        app_response = k8s_utils.list_k8s_objects(
+            obj_type=K8sConst.OBJ_TYPE_KNATIVE_SVC,
+            namespace="default",
+        )
+        self.assertTrue(app_response.is_ok())
+        print(UtilityV2.dict2jsonstr(app_response.data))
+
+        if app_response.data.get("items"):
+            app_response = k8s_utils.delete_k8s_object(
+                obj_type=K8sConst.OBJ_TYPE_KNATIVE_SVC,
+                namespace="default",
+                obj_name="helloworld",
+            )
+            self.assertTrue(app_response.is_ok())
+            print(UtilityV2.dict2jsonstr(app_response.data))
+
+        app_response = k8s_utils.create_k8s_object(
+            obj_type=K8sConst.OBJ_TYPE_KNATIVE_SVC,
+            namespace="default",
+            object_yaml_content="""
+{
+  "apiVersion": "serving.knative.dev/v1",
+  "kind": "Service",
+  "metadata": {
+    "name": "helloworld",
+    "namespace": "default"
+  },
+  "spec": {
+    "template": {
+      "metadata": {
+        "annotations": {
+          "autoscaling.knative.dev/metric": "rps"
+        },
+        "creationTimestamp": null
+      },
+      "spec": {
+        "containerConcurrency": 0,
+        "containers": [
+          {
+            "env": [
+              {
+                "name": "TARGET",
+                "value": "Sample python v1"
+              }
+            ],
+            "image": "harbor.dcos.guangzhou.unicom.local/istio/knative-demo/helloworld-python:4.0-nodejs-framework",
+            "imagePullPolicy": "Always",
+            "name": "user-container",
+            "ports": [
+              {
+                "containerPort": 8080
+              }
+            ],
+            "readinessProbe": {
+              "successThreshold": 1,
+              "tcpSocket": {
+                "port": 0
+              }
+            },
+            "resources": {}
+          }
+        ],
+        "enableServiceLinks": false,
+        "timeoutSeconds": 300
+      }
+    },
+    "traffic": [
+      {
+        "latestRevision": true,
+        "percent": 100
+      }
+    ]
+  }
+}            
+            """
+        )
+
+        self.assertTrue(app_response.is_ok())
+        print(UtilityV2.dict2jsonstr(app_response.data))
+
+        app_response = k8s_utils.describe_k8s_object(
+            obj_type=K8sConst.OBJ_TYPE_KNATIVE_SVC,
+            namespace="default",
+            obj_name="helloworld",
+        )
+        self.assertTrue(app_response.is_ok())
+        print(UtilityV2.dict2jsonstr(app_response.data))
+
+        app_response = k8s_utils.patch_k8s_object_by_json_patch(
+            obj_type=K8sConst.OBJ_TYPE_KNATIVE_SVC,
+            namespace="default",
+            obj_name="helloworld",
+            patch_content=[
+                {
+                    "op": "replace",
+                    "path": "/spec/template/spec/containers/0/image",
+                    "value": "harbor.dcos.guangzhou.unicom.local/istio/knative-demo/helloworld-python:4.0-go-framework",
+                }
+            ]
+        )
+        self.assertTrue(app_response.is_ok())
+        print(UtilityV2.dict2jsonstr(app_response.data))
+
+        app_response = k8s_utils.patch_k8s_object_by_merge_patch(
+            obj_type=K8sConst.OBJ_TYPE_KNATIVE_SVC,
+            namespace="default",
+            obj_name="helloworld",
+            object_yaml_content="""
+{
+  "apiVersion": "serving.knative.dev/v1",
+  "kind": "Service",
+  "metadata": {
+    "name": "helloworld",
+    "namespace": "default"
+  },
+  "spec": {
+    "template": {
+      "metadata": {
+        "annotations": {
+          "autoscaling.knative.dev/metric": "rps"
+        },
+        "creationTimestamp": null
+      },
+      "spec": {
+        "containerConcurrency": 0,
+        "containers": [
+          {
+            "env": [
+              {
+                "name": "TARGET",
+                "value": "Sample python v1"
+              }
+            ],
+            "image": "harbor.dcos.guangzhou.unicom.local/istio/knative-demo/helloworld-python:4.0-java-framework",
+            "imagePullPolicy": "Always",
+            "name": "user-container",
+            "ports": [
+              {
+                "containerPort": 8080
+              }
+            ],
+            "readinessProbe": {
+              "successThreshold": 1,
+              "tcpSocket": {
+                "port": 0
+              }
+            },
+            "resources": {}
+          }
+        ],
+        "enableServiceLinks": false,
+        "timeoutSeconds": 300
+      }
+    },
+    "traffic": [
+      {
+        "latestRevision": true,
+        "percent": 100
+      }
+    ]
+  }
+}            
+            """
+        )
+        self.assertTrue(app_response.is_ok())
+        print(UtilityV2.dict2jsonstr(app_response.data))
+
+        def test_k8s_utils(self):
+            k8s_utils = K8sUtils(
+                api_server=os.getenv("api_server"),
+                token=os.getenv("token"),
+            )
+            app_response = k8s_utils.list_k8s_objects(
+                obj_type=K8sConst.OBJ_TYPE_KNATIVE_SVC,
+                namespace="default",
+            )
+            self.assertTrue(app_response.is_ok())
+            print(UtilityV2.dict2jsonstr(app_response.data))
+
+            if app_response.data.get("items"):
+                app_response = k8s_utils.delete_k8s_object(
+                    obj_type=K8sConst.OBJ_TYPE_KNATIVE_SVC,
+                    namespace="default",
+                    obj_name="helloworld",
+                )
+                self.assertTrue(app_response.is_ok())
+                print(UtilityV2.dict2jsonstr(app_response.data))
+
+            app_response = k8s_utils.create_k8s_object(
+                obj_type=K8sConst.OBJ_TYPE_KNATIVE_SVC,
+                namespace="default",
+                object_yaml_content="""
+    {
+      "apiVersion": "serving.knative.dev/v1",
+      "kind": "Service",
+      "metadata": {
+        "name": "helloworld",
+        "namespace": "default"
+      },
+      "spec": {
+        "template": {
+          "metadata": {
+            "annotations": {
+              "autoscaling.knative.dev/metric": "rps"
+            },
+            "creationTimestamp": null
+          },
+          "spec": {
+            "containerConcurrency": 0,
+            "containers": [
+              {
+                "env": [
+                  {
+                    "name": "TARGET",
+                    "value": "Sample python v1"
+                  }
+                ],
+                "image": "harbor.dcos.guangzhou.unicom.local/istio/knative-demo/helloworld-python:4.0-nodejs-framework",
+                "imagePullPolicy": "Always",
+                "name": "user-container",
+                "ports": [
+                  {
+                    "containerPort": 8080
+                  }
+                ],
+                "readinessProbe": {
+                  "successThreshold": 1,
+                  "tcpSocket": {
+                    "port": 0
+                  }
+                },
+                "resources": {}
+              }
+            ],
+            "enableServiceLinks": false,
+            "timeoutSeconds": 300
+          }
+        },
+        "traffic": [
+          {
+            "latestRevision": true,
+            "percent": 100
+          }
+        ]
+      }
+    }            
+                """
+            )
+
+            self.assertTrue(app_response.is_ok())
+            print(UtilityV2.dict2jsonstr(app_response.data))
+
+            app_response = k8s_utils.describe_k8s_object(
+                obj_type=K8sConst.OBJ_TYPE_KNATIVE_SVC,
+                namespace="default",
+                obj_name="helloworld",
+            )
+            self.assertTrue(app_response.is_ok())
+            print(UtilityV2.dict2jsonstr(app_response.data))
+
+            app_response = k8s_utils.patch_k8s_object_by_json_patch(
+                obj_type=K8sConst.OBJ_TYPE_KNATIVE_SVC,
+                namespace="default",
+                obj_name="helloworld",
+                patch_content=[
+                    {
+                        "op": "replace",
+                        "path": "/spec/template/spec/containers/0/image",
+                        "value": "harbor.dcos.guangzhou.unicom.local/istio/knative-demo/helloworld-python:4.0-go-framework",
+                    }
+                ]
+            )
+            self.assertTrue(app_response.is_ok())
+            print(UtilityV2.dict2jsonstr(app_response.data))
+
+            app_response = k8s_utils.patch_k8s_object_by_merge_patch(
+                obj_type=K8sConst.OBJ_TYPE_KNATIVE_SVC,
+                namespace="default",
+                obj_name="helloworld",
+                object_yaml_content="""
+    {
+      "apiVersion": "serving.knative.dev/v1",
+      "kind": "Service",
+      "metadata": {
+        "name": "helloworld",
+        "namespace": "default"
+      },
+      "spec": {
+        "template": {
+          "metadata": {
+            "annotations": {
+              "autoscaling.knative.dev/metric": "rps"
+            },
+            "creationTimestamp": null
+          },
+          "spec": {
+            "containerConcurrency": 0,
+            "containers": [
+              {
+                "env": [
+                  {
+                    "name": "TARGET",
+                    "value": "Sample python v1"
+                  }
+                ],
+                "image": "harbor.dcos.guangzhou.unicom.local/istio/knative-demo/helloworld-python:4.0-java-framework",
+                "imagePullPolicy": "Always",
+                "name": "user-container",
+                "ports": [
+                  {
+                    "containerPort": 8080
+                  }
+                ],
+                "readinessProbe": {
+                  "successThreshold": 1,
+                  "tcpSocket": {
+                    "port": 0
+                  }
+                },
+                "resources": {}
+              }
+            ],
+            "enableServiceLinks": false,
+            "timeoutSeconds": 300
+          }
+        },
+        "traffic": [
+          {
+            "latestRevision": true,
+            "percent": 100
+          }
+        ]
+      }
+    }            
+                """
+            )
+            self.assertTrue(app_response.is_ok())
+            print(UtilityV2.dict2jsonstr(app_response.data))
+
+    @unittest.skipIf(True, '需正确设置accessToken,vpc_name_full,account_id,region_code后测试')
+    def test_knative_utils(self):
+        knative_utils = KnativeUtils(
+            api_server=os.getenv("api_server"),
+            token=os.getenv("token"),
+        )
+        app_response = knative_utils.list_knative_svcs(
+            namespace="default",
+        )
+        self.assertTrue(app_response.is_ok())
+        svc_list: List[KnativeServiceApiObject] = app_response.data
+        for tmp_knative_svc in svc_list:
+            print(tmp_knative_svc.to_k8s_api_obj().to_dict())
+
+        if app_response.data:
+            app_response = knative_utils.delete_knative_svc(
+                namespace="default",
+                obj_name="helloworld",
+            )
+            self.assertTrue(app_response.is_ok())
+
+        knative_service_api_obj: KnativeServiceApiObject = KnativeServiceApiObject.from_dict(
+            UtilityV2.jsonstr2dict("""
+{
+  "apiVersion": "serving.knative.dev/v1",
+  "kind": "Service",
+  "metadata": {
+    "name": "helloworld",
+    "namespace": "default"
+  },
+  "spec": {
+    "template": {
+      "metadata": {
+        "annotations": {
+          "autoscaling.knative.dev/metric": "rps"
+        },
+        "creationTimestamp": null
+      },
+      "spec": {
+        "containerConcurrency": 0,
+        "containers": [
+          {
+            "env": [
+              {
+                "name": "TARGET",
+                "value": "Sample python v1"
+              }
+            ],
+            "image": "harbor.dcos.guangzhou.unicom.local/istio/knative-demo/helloworld-python:4.0-nodejs-framework",
+            "imagePullPolicy": "Always",
+            "name": "user-container",
+            "ports": [
+              {
+                "containerPort": 8080
+              }
+            ],
+            "readinessProbe": {
+              "successThreshold": 1,
+              "tcpSocket": {
+                "port": 0
+              }
+            },
+            "resources": {}
+          }
+        ],
+        "enableServiceLinks": false,
+        "timeoutSeconds": 300
+      }
+    },
+    "traffic": [
+      {
+        "latestRevision": true,
+        "percent": 100
+      }
+    ]
+  }
+}                      
+            """)
+        )
+        knative_service_api_obj.fill_attr_by_k8s_api_obj()
+
+        app_response = knative_utils.create_knative_svc(
+            knative_service_api_obj=knative_service_api_obj
+        )
+
+        self.assertTrue(app_response.is_ok())
+        knative_service_api_obj: KnativeServiceApiObject = app_response.data
+        print(UtilityV2.dict2jsonstr(knative_service_api_obj.to_k8s_api_obj().to_dict()))
+
+        app_response = knative_utils.describe_knative_svc(
+            namespace="default",
+            obj_name="helloworld",
+        )
+        self.assertTrue(app_response.is_ok())
+        knative_service_api_obj: KnativeServiceApiObject = app_response.data
+        print(UtilityV2.dict2jsonstr(knative_service_api_obj.to_k8s_api_obj().to_dict()))
+
+        knative_service_api_obj.template.revision_spec.pod_spec_dict["containers"][0][
+            "image"] = "harbor.dcos.guangzhou.unicom.local/istio/knative-demo/helloworld-python:4.0-java-framework"
+        app_response = knative_utils.patch_knative_service_api_obj_by_merge_patch(
+            knative_service_api_obj=knative_service_api_obj
+        )
+        self.assertTrue(app_response.is_ok())
+        knative_service_api_obj: KnativeServiceApiObject = app_response.data
+        print(UtilityV2.dict2jsonstr(knative_service_api_obj.to_k8s_api_obj().to_dict()))
+
+
+if __name__ == '__main__':
+    main()

test/test_ludq_utils_v2.py

+#!/usr/bin/env python
+# -*- encoding: utf-8 -*-
+"""
+@Version: 1.0
+@Python Version:3.6.6
+@Author: ludq1
+@File: test_ludq_utils_v2.py
+@Time: 2021/05/04 22:01
+@Description: 测试代码
+"""
+import unittest
+from unittest import TestCase, main
+
+from cucc_common_pkg.ludq_utils.utils_v2 import UtilityV2
+
+
+class TestUtility(TestCase):
+    r'''
+    TestUtility
+    '''
+
+    @unittest.skipIf(False, '需正确设置accessToken,vpc_name_full,account_id,region_code后测试')
+    def test_load_yaml(self):
+        r'''
+
+        Returns:
+
+        '''
+        yaml_str = """
+        a: 1
+        b:
+         c1: c1
+         c2: 中文
+        """
+        ret_obj = UtilityV2().yaml_load(yaml_str)
+        print(ret_obj)
+        self.assertEqual(ret_obj.get("a"), 1)
+        self.assertTrue(isinstance(ret_obj.get("b"), dict))
+        self.assertEqual(ret_obj.get("b").get("c1"), "c1")
+        self.assertEqual(ret_obj.get("b").get("c2"), "中文")
+
+
+if __name__ == '__main__':
+    main()

test/test_my_anykeyvalue_tils.py

+#!/usr/bin/env python3
+# -*- encoding: utf-8 -*-
+"""
+@Version: 1.0
+@Python Version:3.6.6
+@Author: ludq1
+@File: test_my_anykeyvalue_tils
+@Time: 2019/2/2 9:58
+@Description:
+"""
+
+import os
+from unittest import TestCase, main
+
+from cucc_common_pkg.globalconst import EnvNameConst
+from cucc_common_pkg.my_anykeyvalue_utils import AnyKeyValueUtils
+
+
+class TestUtility(TestCase):
+    r'''
+    TestUtility
+    '''
+
+    def test_query_any_key(self):
+        r'''
+
+        Returns:
+
+        '''
+        key_id = 'current_env'
+        key_type = 'current_env'
+
+        os.environ[EnvNameConst.ENV_LOCAL_RUN] = '1'
+        os.environ[EnvNameConst.ENV_MYSQLPOOL_SERVICE] = 'http://10.0.209.148:58006'
+        result = AnyKeyValueUtils.query_any_key(key_id, key_type=key_type)
+        expect_result = {key_id: 'dev'}
+        self.assertEqual(expect_result, result)
+
+
+if __name__ == '__main__':
+    main()