import datetime
import json
import logging
import logging.config
import math
import sys
from functools import wraps
from logging.handlers import RotatingFileHandler
import flask
import kubernetes
from aliyunsdkcore.client import AcsClient
from flask import current_app, g, got_request_exception
from flask_restful import reqparse, Resource, Api, http_status_message
from itsdangerous import TimedJSONWebSignatureSerializer as Serializer, SignatureExpired, BadSignature
from kubernetes.client import AppsV1Api, ExtensionsV1beta1Api
from kubernetes.client import V1Pod
from kubernetes.client.rest import ApiException
from sqlalchemy import text
from werkzeug.datastructures import Headers
from werkzeug.exceptions import BadRequest, HTTPException
from utils.email_tool import send_email
from utils.exceptions import ParameterError
from utils.response import unauthorized_response
from utils.short_message_tool import send_sms
def generate_auth_token(data, expiration=3600 * 24 * 15):
s = Serializer(current_app.config['SECRET_KEY'], expires_in=expiration)
return s.dumps(data).decode('utf-8')
def authorization(operation_set: set = None, role_set: set = None, menu_set: set = None,
certification_type: str = "competence", without_env: bool = True):
"""
权限检测
:param operation_set: 该接口所需要的操作权限集合，多个操作之间是 且
:param role_set: 该接口所需要的角色要求，多个角色之间是 或
:param menu_set: 该接口所需要的菜单权限集合
:param certification_type: 验证类型 competence：操作权限控制 role基于角色控制
:param without_env: 是否需要与环境关联, 默认不关联，个别操作需要判断环境
:return:
"""
def login_required(function):
@wraps(function)
def wrap(self, *args, **kwargs):
if 'X-Token' not in flask.request.headers:
return unauthorized_response()
else:
# token验证
token = flask.request.headers.get('X-Token')
s = Serializer(current_app.config['SECRET_KEY'])
try:
data = s.loads(token.encode("utf-8"))
except SignatureExpired:
return unauthorized_response(message="认证过期")
except BadSignature:
return unauthorized_response(message="认证失败")
except Exception as e:
current_app.logger.error(str(e))
return unauthorized_response(message="认证异常")
results = self.get_query_results(
"select user_name, status from user where user_id=:user_id limit 1;",
user_id=data["user_id"],
fetch_result=True
)
if not results:
return unauthorized_response(message="用户不存在")
if not results[0][1]:
return unauthorized_response(message="用户已被禁用")
g.user_id = data["user_id"]
g.user_name = results[0][0]
if not check_competence(
self, operation_set=operation_set, role_set=role_set, menu_set=menu_set,
certification_type=certification_type, without_env=without_env
):
raise ParameterError("权限不足")
return function(self, *args, **kwargs)
return wrap
return login_required
def check_competence(
current_handler, operation_set: set = None, role_set: set = None, menu_set: set = None,
certification_type: str = "competence", without_env: bool = True
):
"""
权限检测
:param current_handler: 当前请求视图实例
:param operation_set: 该接口所需要的操作权限集合
:param menu_set: 该接口所需要的菜单权限集合
:param role_set: 该接口所需要的角色要求
:param certification_type: 验证类型 competence：操作权限控制 role基于角色控制, menu 菜单控制
:param without_env: 是否需要与环境关联, 默认不关联，个别操作需要判断环境
:return:
"""
# 菜单权限由前端实现，后端无从校验。后端主要做操作权限校验
if certification_type == "competence":
if not operation_set:
return True
request_env = None
if not without_env:
request_env = current_handler.args["env"]
role_ids = get_user_role_ids(g.user_id)
operation_keys = get_user_operation_keys(role_ids, request_env)
return not bool(operation_set.difference(operation_keys))
# 基于角色的权限控制
elif certification_type == "role":
if not role_set:
return True
role_keys = get_user_role_keys(g.user_id)
return bool(role_keys & role_set)
elif certification_type == "menu":
if not menu_set:
return True
role_ids = get_user_role_ids(g.user_id)
menu_keys = get_user_menu_keys(role_ids)
return not bool(menu_set.difference(menu_keys))
else:
raise ValueError("暂不支持该类型权限认证")
def get_user_role_ids(user_id):
query = f"select role_id from role_user where user_id=:user_id;"
return [_id[0] for _id in TransactionResource.get_query_results(query, user_id=user_id)]
def get_user_role_keys(user_id):
role_ids = get_user_role_ids(user_id)
if not role_ids:
return set()
sql = """
select role_key from role where role_id in :role_ids;
"""
results = TransactionResource.get_query_results(sql, role_ids=role_ids)
return set(r[0] for r in results)
def get_user_operation_keys(role_ids, env=None):
"""获取用户的可操作列表"""
if not role_ids:
return set()
sql = f"""
select gb_operation.operation_key from role_operation
inner join gb_operation on role_operation.operation_id = gb_operation.operation_id
where role_operation.role_id in :role_ids
"""
if env:
sql += " and gb_operation.env = :env;"
results = TransactionResource.get_query_results(sql, role_ids=role_ids, env=env)
operation_keys = {r[0] for r in results}
return operation_keys
def get_user_menu_keys(role_ids):
if not role_ids:
return set()
sql = f"""
select gb_menu.menu_key from role_menu
inner join gb_menu on role_menu.menu_id = gb_menu.menu_id
where role_menu.role_id in :role_ids
"""
results = TransactionResource.get_query_results(sql, role_ids=role_ids)
menu_keys = {r[0] for r in results}
return menu_keys
def transaction(sql, bindparams=None, commit=True, fetch_result=False, **kwargs):
"""
@param sql: sql text
@param bindparams: List 对kwargs中的key进行类型绑定及限制等 like :
[bindparam('alarm_time_param', type_=DateTime, required=True)])
@param fetch_result: 是否直接返回结果，如果返回，为列表，否则是一个result对象
@param kwargs: sql中绑定的参数
@return:
"""
session = current_app.db.session
try:
results = session.execute(text(sql, bindparams), kwargs)
if commit:
session.commit()
except Exception as e:
current_app.logger.error(str(e))
session.rollback() # 出现异常则 rollback
raise e
if fetch_result:
if results.rowcount:
return [r for r in results]
else:
return None
else:
return results
def with_transaction(function):
@wraps(function)
def wrap(self, *args, **kwargs):
with current_app.db.engine.connect() as conn:
trans = conn.begin() # 开启一个 transaction
g.trans = trans
g.conn = conn
self.trans = trans
self.conn = conn
try:
resp = function(self, *args, **kwargs)
trans.commit()
return resp
except Exception as e:
current_app.logger.error(str(e))
trans.rollback() # 出现异常则 rollback
raise e
return wrap
def do_nothing(value):
return value
def check_args(**kwargs):
def my_decorator(func):
@wraps(func)
def wrapper(self, *_args, **_kwargs):
parser = reqparse.RequestParser()
# 添加请求体或查询参数
for key, value in kwargs.items():
if key not in _kwargs:
required = False if value.startswith("?") else True
ignore = ~required
# assert ":" in value, "若字符串以?开始，代表非必须; ':'前为字段类型，后为缺失时的错误提示"
# 问号开头代表非必须，第零项为变量名
items = value.lstrip("?").split(":")
items_count = len(items)
_type_str = items[0]
# 第一项为错误提示语
if items_count >= 2 and items[1]:
_help = items[1]
else:
_help = f"{key}为必须参数"
# 第二项为参数所在位置
if items_count >= 3 and items[2]:
location = tuple(items[2].split(","))
else:
location = ('json', 'values',)
# 第三项为参数实际名称（请求参数的名称）
if items_count >= 4 and items[3]:
name = items[3]
dest = key
else:
name = key
dest = None
if _type_str == "list":
_type = do_nothing
action = "append"
default = lambda: []
else:
_type = eval(_type_str)
action = "store"
default = None
parser.add_argument(
name, dest=dest, type=_type, help=_help, required=required, action=action, default=default,
ignore=ignore, location=location
)
try:
args = parser.parse_args()
except BadRequest as e:
if hasattr(e, "data"):
values = e.data.get("message", {}).values()
msg = ",".join(values)
if not msg:
keys = e.data.get("message", {}).keys()
msg = ",".join(keys)
raise ParameterError(msg)
else:
raise e
# 添加url解析出来的参数
args.update(_kwargs)
self.args = args
current_app.logger.debug('请求参数：{}'.format(json.dumps(args, ensure_ascii=False, indent=4)))
result = func(self, *_args, **_kwargs)
current_app.logger.debug(
'响应参数：{}'.format(json.dumps(result, ensure_ascii=False, indent=4)))
return result
return wrapper
return my_decorator
class QueryMixin:
select_fields = None
table = None
@classmethod
def get_query_results(cls, sql, bindparams=None, fetch_result=False, **kwargs):
results = current_app.db.session.execute(text(sql, bindparams), kwargs)
current_app.logger.debug(results.cursor._executed.decode())
if fetch_result:
if results.rowcount:
return [r for r in results]
else:
return []
return results
@classmethod
def get_single_field_query_result(cls, sql, bindparams=None, **kwargs):
results = current_app.db.session.execute(text(sql, bindparams), kwargs)
current_app.logger.debug(results.cursor._executed.decode())
result = None
for r in results:
result = r[0]
break
return result
@classmethod
def get_single_field_query_results(cls, sql, bindparams=None, **kwargs):
results = current_app.db.session.execute(text(sql, bindparams), kwargs)
current_app.logger.debug(results.cursor._executed.decode())
return [r[0] for r in results]
@classmethod
def update_or_insert(cls, sql, bindparams=None, **kwargs):
results = current_app.db.session.execute(text(sql, bindparams), kwargs)
cursor = results._saved_cursor or results.cursor
if cursor:
current_app.logger.debug(results._saved_cursor._executed.decode())
return results
@classmethod
def serialize_results(cls, results, select_fields=None, is_multi=False, rename_map=None):
if is_multi:
return cls.serialize_multi_results(results, select_fields=select_fields, rename_map=rename_map)
else:
return cls.serialize_single_results(results, select_fields=select_fields, rename_map=rename_map)
@classmethod
def serialize_single_results(cls, results, select_fields=None, rename_map=None):
select_fields = select_fields or cls.select_fields
assert select_fields, "请检查需要序列化的字段"
data = dict()
if not rename_map:
rename_map = dict()
for result in results:
for index, field in enumerate(select_fields):
if a := rename_map.get(field):
field = a
else:
field = field.split(".")[-1]
temp_result = result[index]
if isinstance(temp_result, datetime.datetime):
data[field] = result[index].strftime('%Y-%m-%d %H:%M:%S')
elif isinstance(temp_result, datetime.date):
data[field] = result[index].strftime('%Y-%m-%d')
else:
data[field] = result[index]
return data
@classmethod
def serialize_multi_results(cls, results, select_fields=None, rename_map=None):
select_fields = select_fields or cls.select_fields
data_list = list()
if not rename_map:
rename_map = dict()
for result in results:
data = dict()
for index, field in enumerate(select_fields):
if a := rename_map.get(field):
field = a
else:
field = field.split(".")[-1]
temp_result = result[index]
if isinstance(temp_result, datetime.datetime):
data[field] = result[index].strftime('%Y-%m-%d %H:%M:%S')
elif isinstance(temp_result, datetime.date):
data[field] = result[index].strftime('%Y-%m-%d')
else:
data[field] = result[index]
data_list.append(data)
return data_list
@classmethod
def get_query_single_result(
cls, sql, bindparams=None, fetch_result=False, select_fields=None, serialize=True, rename_map=None, **kwargs
):
if serialize:
fetch_result = False
results = cls.get_query_results(sql=sql, bindparams=bindparams, fetch_result=fetch_result, **kwargs)
if serialize:
return cls.serialize_single_results(results, select_fields=select_fields, rename_map=rename_map)
else:
return results
@classmethod
def get_last_insert_id(cls):
results = cls.get_query_results("SELECT LAST_INSERT_ID();", fetch_result=True)
if results:
return results[0][0]
else:
return None
@classmethod
def group_data_list(cls, data_list: list, key) -> list:
value_set = {d[key] for d in data_list}
value_list = sorted(value_set)
index_map = dict()
results = list()
for index, v in enumerate(value_list):
results.append({key: v, "values": list()})
index_map[v] = index
for data in data_list:
results[index_map[data[key]]]["values"].append(data)
return results
@classmethod
def get_limit_sql_suffix(cls, page_size, current_page):
return f" limit {(current_page - 1) * page_size}, {page_size};"
@classmethod
def build_query_sql(cls, sql_template: str, select_fields: list = None, page_size: int = 0, current_page=None):
if current_page is None:
current_page = 1
select_fields = select_fields or cls.select_fields
sql = sql_template.format(fields=",".join(select_fields))
count_sql = sql_template.format(fields="count(1)") + ";"
if page_size:
sql += cls.get_limit_sql_suffix(page_size, current_page)
else:
sql += ";"
return sql, count_sql
@classmethod
def get_page_info(cls, page_size, current_page, total_count):
if current_page is None:
current_page = 1
if page_size:
pages = math.ceil(total_count / page_size)
return {
"total": total_count,
"size": page_size,
"pages": pages,
"current": current_page
}
else:
return {
"total": total_count,
"size": total_count,
"pages": 1,
"current": 1
}
@classmethod
def get_config_value_by_key(cls, config_key):
sql = "select config_value from gb_config where config_key=:config_key;"
config_value = cls.get_single_field_query_result(sql, config_key=config_key)
return config_value
@staticmethod
def paginate(collections, page=None, per_page=None) -> tuple:
"""返回第page页的per_page个结果
返回(items, total)
"""
if page is None:
page = 1
else:
page = int(page)
if per_page is None:
per_page = 20
else:
per_page = int(per_page)
if (total := len(collections)) < (end := page * per_page):
items = collections[(page - 1) * per_page:]
else:
items = collections[(page - 1) * per_page: end]
return items, total
class TransactionResource(Resource, QueryMixin):
def dispatch_request(self, *args, **kwargs):
try:
return super(TransactionResource, self).dispatch_request(*args, **kwargs)
except Exception as e:
current_app.db.session.rollback()
current_app.logger.error(str(e))
raise e
# 重写API类，目的是做到正确返回错误码，否则默认是500
class CustomizeApi(Api):
def handle_error(self, e):
"""Error handler for the API transforms a raised exception into a Flask
response, with the appropriate HTTP status code and body.
:param e: the raised Exception object
:type e: Exception
"""
got_request_exception.send(current_app._get_current_object(), exception=e)
if not isinstance(e, HTTPException) and current_app.propagate_exceptions:
exc_type, exc_value, tb = sys.exc_info()
if exc_value is e:
raise
else:
raise e
headers = Headers()
if isinstance(e, HTTPException):
code = e.code
default_data = {
'message': getattr(e, 'description', http_status_message(code))
}
headers = e.get_response().headers
else:
code = 500
default_data = {
'message': http_status_message(code),
}
# Werkzeug exceptions generate a content-length header which is added
# to the response in addition to the actual content-length header
# https://github.com/flask-restful/flask-restful/issues/534
remove_headers = ('Content-Length',)
for header in remove_headers:
headers.pop(header, None)
data = getattr(e, 'data', default_data)
if code and code >= 500:
exc_info = sys.exc_info()
if exc_info[1] is None:
exc_info = None
current_app.log_exception(exc_info)
error_cls_name = type(e).__name__
if error_cls_name in self.errors:
custom_data = self.errors.get(error_cls_name, {})
code = custom_data.get('status', code)
if e.description:
custom_data["message"] = e.description
data.update(custom_data)
if code == 406 and self.default_mediatype is None:
# if we are handling NotAcceptable (406), make sure that
# make_response uses a representation we support as the
# default mediatype (so that make_response doesn't throw
# another NotAcceptable error).
supported_mediatypes = list(self.representations.keys())
fallback_mediatype = supported_mediatypes[0] if supported_mediatypes else "text/plain"
resp = self.make_response(
data,
code,
headers,
fallback_mediatype=fallback_mediatype
)
else:
resp = self.make_response(data, code, headers)
if code == 401:
resp = self.unauthorized(resp)
return resp
class K8SBase:
def __init__(self, app_name, group_name, k8s_url, k8s_token, namespace, zone_code):
self.k8s_url = k8s_url
self.k8s_token = k8s_token
self.config = self.get_config()
self.core_v1 = self.get_core_v1()
self.apps_v1 = self.get_apps_v1()
self.extensions_v1 = self.get_extensions_v1_beta1()
self.namespace = namespace
self.zone_code = zone_code
self.app_name = app_name
self.group_name = group_name
def get_config(self):
try:
configuration = kubernetes.client.Configuration()
configuration.host = self.k8s_url
configuration.verify_ssl = False
configuration.api_key = {"authorization": "Bearer " + self.k8s_token} # 获取异常并提示用户
client_config = kubernetes.client.api_client.ApiClient(configuration=configuration)
return client_config
except TypeError as e:
current_app.logger.error(str(e))
return
def get_core_v1(self):
core_v1 = kubernetes.client.apis.core_v1_api.CoreV1Api(self.config)
return core_v1
def get_extensions_v1_beta1(self):
extensions_v1 = ExtensionsV1beta1Api(self.config)
return extensions_v1
def get_apps_v1(self):
apps_v1 = AppsV1Api(self.config)
return apps_v1
class K8SPodInfoTool(K8SBase):
@classmethod
def get_pod_restart_count(cls, pod: V1Pod):
if pod.status.container_statuses:
for item in pod.status.container_statuses:
return item.restart_count
return 0
@classmethod
def get_image_version(cls, pod: V1Pod):
if pod.status.container_statuses:
for item in pod.status.container_statuses:
return item.image.split(":")[1] if item.image and ":" in item.image else None
return ""
@classmethod
def get_pod_info(cls, pod):
conditions = pod.status.conditions
return {
"pod_name": pod.metadata.name,
"pod_ip": pod.status.pod_ip,
"app_version": cls.get_image_version(pod),
"phase": pod.status.phase,
"conditions": ";".join(map(lambda x: f"{x.type}: {x.status}", conditions)) if conditions else "",
"restart_count": cls.get_pod_restart_count(pod)
}
def sync_deployment_pods_info(self, match_labels):
"""
同步正在发布中的 pod 的信息
:return:
"""
items = []
for key, value in match_labels.items():
items.append(f"{key}={value}")
labels = ",".join(items)
results = self.core_v1.list_namespaced_pod(namespace=self.namespace, label_selector=labels, watch=False)
pod_list = list()
for pod in results.items:
pod_info = self.get_pod_info(pod)
pod_list.append(pod_info)
return pod_list
class K8SCDTool(K8SBase):
def get_deploy_info(self, deploy_name):
try:
result = self.apps_v1.read_namespaced_deployment(deploy_name, self.namespace)
except ApiException as e:
current_app.logger.error('获取deployment信息失败:{}'.format(e))
error = json.loads(e.body)
message = error.get("message", e)
return False, message
else:
return True, result
def get_deploy_info_status(self, deploy_name):
try:
result = self.apps_v1.read_namespaced_deployment_status(deploy_name, self.namespace)
except ApiException as e:
current_app.logger.error('获取deployment信息失败:{}'.format(e))
error = json.loads(e.body)
message = error.get("message", e)
return False, message
else:
return True, result
def get_pod_status(self, k8s_pod_tool, match_label):
try:
pod_list = k8s_pod_tool.sync_deployment_pods_info(match_label)
pods_status = {}
for pod_info in pod_list:
pod_name = pod_info.get('pod_name')
result = self.core_v1.read_namespaced_pod_status(pod_name, self.namespace)
pods_status[pod_name] = result
except ApiException as e:
current_app.logger.error('获取Pod信息失败:{}'.format(e))
error = json.loads(e.body)
message = error.get("message", e)
return False, message
else:
return True, pods_status
def get_namespace_pod(self, deploy_name):
try:
result = self.core_v1.read_namespaced_pod(deploy_name, self.namespace)
except ApiException as e:
current_app.logger.error('获取deployment信息失败:{}'.format(e))
error = json.loads(e.body)
message = error.get("message", e)
return False, message
else:
return True, result
def update_deploy(self, name, body):
try:
result = self.apps_v1.replace_namespaced_deployment(name, self.namespace, body)
return 3, result # 3 为发布中
except ApiException as e:
current_app.logger.error('更新Deployment失败:{}'.format(e))
error = json.loads(e.body)
message = error.get("message", "")
if e.status == 422:
if "MatchLabels" in message and "field is immutable" in message:
return 2, "检测到应用名称发生改变，需删除Deployment后重新发布"
else:
return 2, message
else:
return 2, e # 2 为发布失败
def patch_deploy(self, name, patch_body):
try:
result = self.apps_v1.patch_namespaced_deployment(name, self.namespace, patch_body)
return 3, result # 3 为发布中
except ApiException as e:
current_app.logger.error('更新Deployment失败:{}'.format(e))
error = json.loads(e.body)
message = error.get("message", e)
return 2, message # 2 为发布失败
def delete_deploy(self, name):
try:
result = self.apps_v1.delete_namespaced_deployment(name, self.namespace)
return 3, result # 3 为发布中
except ApiException as e:
current_app.logger.error('更新Deployment失败:{}'.format(e))
error = json.loads(e.body)
message = error.get("message", e)
return 2, message # 2 为发布失败
def create_deploy(self, body):
"""创建deploy"""
try:
result = self.apps_v1.create_namespaced_deployment(self.namespace, body)
return 3, result # 3 为发布中
except ApiException as e:
current_app.logger.error('发布失败:{}'.format(e))
error = json.loads(e.body)
message = error.get("message", e)
return 2, message # 2 为发布失败
def add_pod_label(self, label, pod_name_list):
"""为pod添加标签"""
try:
result = self.core_v1.list_pod_for_all_namespaces(label_selector=label)
index = 0
for pod_info in result.items:
pod_name = pod_info.metadata.name
pod_res = self.core_v1.read_namespaced_pod(pod_name, self.namespace)
pod_res.metadata.labels['name'] = pod_name_list[index][0]
self.core_v1.patch_namespaced_pod(pod_name, self.namespace, pod_res)
index += 1
except ApiException as e:
current_app.logger.error('添加名称标签异常：{}'.format(e))
def get_service_info(self, service_name):
try:
result = self.core_v1.read_namespaced_service(service_name, self.namespace)
except ApiException as e:
return 2, e
else:
return 1, result
def create_service(self, body):
"""创建 service"""
try:
result = self.core_v1.create_namespaced_service(self.namespace, body)
return 1, result
except Exception as e:
current_app.logger.error('创建 service 失败:{}'.format(e))
return 2, e
def update_service(self, service_name, body):
""" 更新 service, patch为补丁方式更新，默认为merge，需要指定replace， 参照：http://jsonpatch.com/ """
try:
result = self.core_v1.patch_namespaced_service(service_name, self.namespace, body)
return 1, result
except Exception as e:
current_app.logger.error('更新 service 失败:{}'.format(e))
return 2, e
def delete_service(self, service_name):
""" 删除 service """
try:
result = self.core_v1.delete_namespaced_service(service_name, self.namespace)
return 1, result
except Exception as e:
current_app.logger.error('删除 service 失败:{}'.format(e))
return 2, e
def create_ingress(self, body):
""" 创建 ingress 规则"""
try:
result = self.extensions_v1.create_namespaced_ingress(self.namespace, body)
return 1, result
except Exception as e:
current_app.logger.error('创建 service 失败:{}'.format(e))
return 2, e
def update_ingress(self, ingress_name, body):
""" 更新 ingress 规则"""
try:
result = self.extensions_v1.patch_namespaced_ingress(ingress_name, self.namespace, body)
return 1, result
except Exception as e:
current_app.logger.error('更新 ingress 失败:{}'.format(e))
return 2, e
def delete_ingress(self, ingress_name):
""" 删除 ingress 规则"""
try:
result = self.extensions_v1.delete_namespaced_ingress(ingress_name, self.namespace)
return 1, result
except Exception as e:
current_app.logger.error('删除 ingress 失败:{}'.format(e))
return 2, e
def check_service_exists(self, service_name):
try:
result = self.core_v1.read_namespaced_service(service_name, self.namespace)
except ApiException as e:
if e.status == 404:
return False
else:
return result
def check_deployment_exists(self, deployment_name):
try:
self.apps_v1.read_namespaced_deployment(deployment_name, self.namespace)
except ApiException as e:
if e.status == 404:
return False
else:
return True
def check_ingress_exists(self, ingress_name):
try:
self.extensions_v1.read_namespaced_ingress(ingress_name, self.namespace)
except ApiException as e:
if e.status == 404:
return False
else:
return True
def list_namespaced_persistent_volume_claim(self):
try:
result = self.core_v1.list_namespaced_persistent_volume_claim(self.namespace)
return True, result
except ApiException as e:
error = json.loads(e.body)
message = error.get("message", e)
current_app.logger.error('获取存储声明失败：{}'.format(message))
return False, message
def list_namespaced_config_map(self):
try:
result = self.core_v1.list_namespaced_config_map(self.namespace)
return True, result
except ApiException as e:
error = json.loads(e.body)
message = error.get("message", e)
current_app.logger.error('获取 config map 失败：{}'.format(message))
return False, message
def list_namespaced_secret_map(self):
try:
result = self.core_v1.list_namespaced_secret(self.namespace)
return True, result
except ApiException as e:
error = json.loads(e.body)
message = error.get("message", e)
current_app.logger.error('获取 config map 失败：{}'.format(message))
return False, message
def get_k8s_cd_tool(app_name, group_name, system_code, env, namespace, zone_code) -> K8SCDTool:
return get_k8s_tool(app_name, group_name, system_code, env, namespace, zone_code, K8SCDTool)
def get_k8s_info_tool(app_name, group_name, system_code, env, namespace, zone_code) -> K8SPodInfoTool:
return get_k8s_tool(app_name, group_name, system_code, env, namespace, zone_code, K8SPodInfoTool)
def get_k8s_tool(app_name, group_name, system_code, env, namespace, zone_code, k8s_class):
url_key = f"K8S_{system_code}_{env}_{zone_code}_URL"
try:
k8s_url = TransactionResource.get_config_value_by_key(url_key)
if not k8s_url:
raise ValueError(f'{url_key} 未配置')
token_key = f"K8S_{system_code}_{env}_{zone_code}_TOKEN"
k8s_token = TransactionResource.get_config_value_by_key(token_key)
cd_obj = k8s_class(app_name, group_name, k8s_url, k8s_token, namespace, zone_code)
return cd_obj
except ApiException as e:
current_app.logger.error(str(e))
raise ParameterError(f'{url_key} 未配置')
def setup_log(config_obj, app):
# 设置日志的记录等级
logging.basicConfig(level=config_obj.LOG_LEVEL)
# 创建日志记录器，指明日志保存的路径、每个日志文件的最大大小、保存的日志文件个数上限
file_log_handler = RotatingFileHandler(config_obj.LOG_FILE, maxBytes=1024 * 1024 * 100, backupCount=10)
# 创建日志记录的格式 日志等级 输入日志信息的文件名 行数 日志信息
formatter = logging.Formatter(
"[%(asctime)s][%(pathname)s][%(filename)s][%(lineno)d][%(levelname)s][%(thread)d][%(module)s][%(funcName)s][%(message)s]")
# 为刚创建的日志记录器设置日志记录格式
file_log_handler.setFormatter(formatter)
# 为全局的日志工具对象（flask app使用的）添加日志记录器
logging.getLogger().addHandler(file_log_handler)
# 设置flask自带的app.logger级别
app.logger.setLevel(config_obj.LOG_LEVEL)
# 用户操作日志
class OperationLog(object):
def __init__(self, user_id, operation_key, page, result, env, created_time, content
):
self.operation_key = operation_key
self.created_time = created_time
self.user_id = user_id
self.page = page
self.result = result
self.env = env
self.content = content
def set_log(self, bindparams=None):
params = {
"operation_key": self.operation_key,
"created_time": self.created_time,
"user_id": self.user_id,
"page": self.page,
"result": self.result,
'env': self.env,
'content': self.content,
}
values_str = ','.join(map(lambda x: f':{x}', params.keys()))
sql = f"insert into gb_operation_log ({','.join(params.keys())}) values ({values_str});"
results = current_app.db.session.execute(text(sql, bindparams), params)
return results
class OperationNotify(object):
def __init__(self, operation_key, content, template_code=None, params=None):
self.operation_key = operation_key
self.text = content
self.template_code = template_code
self.params = params
def get_notify_user_list(self):
sql = f'select user_id from gb_notify where operation_key=:operation_key'
results = QueryMixin.get_single_field_query_results(sql, operation_key=self.operation_key)
return results
def get_recipients_email(self):
user_list = self.get_notify_user_list()
query_email_sql = "select email from user where user_id in :user_list; "
results_email = QueryMixin.get_single_field_query_results(query_email_sql, user_list=user_list,
fetch_result=True)
return results_email
def get_recipients_phone(self):
user_list = self.get_notify_user_list()
query_sms_sql = "select phone from user where user_id in :user_list; "
results_sms = QueryMixin.get_single_field_query_results(query_sms_sql, user_list=user_list, fetch_result=True)
return results_sms
def send_email(self):
sql = f'select distinct is_notify_email from `gb_notify` where operation_key=:operation_key'
is_notify = QueryMixin.get_single_field_query_result(sql, operation_key=self.operation_key)
if not is_notify:
return
mail_body = self.text
recipients = self.get_recipients_email()
send_email("Genbu通知", recipients, mail_body)
def send_sms(self):
sql = f'select distinct is_notify_sms from `gb_notify` where operation_key=:operation_key'
is_notify = QueryMixin.get_single_field_query_result(sql, operation_key=self.operation_key)
if not is_notify:
return
if not self.template_code or not self.params:
return
recipients = self.get_recipients_phone()
acs_client = AcsClient(current_app.config["ACCESS_KEY_ID"], current_app.config["ACCESS_KEY_SECRET"])
for phone in recipients:
result = send_sms(acs_client, phone, self.template_code, template_param=self.params)
result_obj = json.loads(result)
if result_obj['Code'] != 'OK':
current_app.logger.error(result.decode('utf8'))
raise ParameterError("短信发送失败")
current_app.logger.info(result.decode('utf8'))
