bkflow-sdk 0.0.42__py2.py3-none-any.whl

bkflow/client/core.py

@@ -0,0 +1,289 @@
+"""
+Tencent is pleased to support the open source community by making 蓝鲸智云 - PaaS平台 (BlueKing - PaaS System) available.
+Copyright (C) 2022 THL A29 Limited, a Tencent company. All rights reserved.
+Licensed under the MIT License (the "License"); you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+http://opensource.org/licenses/MIT
+Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on
+an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the
+specific language governing permissions and limitations under the License.
+"""
+
+import json
+import logging
+
+import requests
+from django.conf import settings
+
+from bkflow.client.apis.bkflow import CollectionsBKFlow
+from bkflow.common.exceptions import APIException
+from bkflow.common.loader import call_config_function
+
+logger = logging.getLogger(__name__)
+
+__all__ = [
+    "get_client_by_request",
+    "get_client_by_user",
+]
+
+HEADER_BK_AUTHORIZATION = "X-Bkapi-Authorization"
+DEFAULT_STAGE = getattr(settings, "BK_APIGW_STAGE_NAME", "prod")
+AVAILABLE_COLLECTIONS = {
+    "bkflow": CollectionsBKFlow,
+}
+
+
+class BaseAPIClient:
+    """Base client class for api"""
+
+    def __init__(
+        self,
+        app_code=None,
+        app_secret=None,
+        headers=None,
+        common_args=None,
+        stage="prod",
+        timeout=None,
+        bk_apigw_ver="v3",
+    ):
+        """
+        :param str app_code: App code to use
+        :param str app_secret: App secret to use
+        :param dict headers: headers be sent to api
+        :param dict common_args: Args that will apply to every request
+        :param str stage: Stage for api gateway
+        :param int timeout: timeout for request
+        """
+
+        self.app_code = app_code or settings.APP_CODE
+        self.app_secret = app_secret or settings.SECRET_KEY
+        self.headers = headers or {}
+        self.common_args = common_args or {}
+        self.stage = stage
+        self.bk_apigw_ver = bk_apigw_ver
+        self.timeout = timeout
+        self._cached_collections = {}
+        self._log_warning()
+        self.available_collections = AVAILABLE_COLLECTIONS
+
+    def _log_warning(self):
+        _, _, api_name = __package__.partition(".")
+        logger.warning(
+            "%s is no longer maintained, recommend to use bkapi.%s as a replacement",
+            __package__,
+            api_name,
+        )
+
+    def merge_params_data_with_common_args(self, method, params, data):
+        """Add common args to params every request"""
+        common_args = dict(app_code=self.app_code, **self.common_args)
+        if method in ["GET", "HEAD"]:
+            _params = common_args.copy()
+            _params.update(params or {})
+            params = _params
+        elif method in ["POST", "PUT", "PATCH", "DELETE"]:
+            _data = common_args.copy()
+            _data.update(data or {})
+            data = json.dumps(_data)
+        return params, data
+
+    def __getattr__(self, key):
+        if key not in self.available_collections:
+            return getattr(super(), key)
+
+        if key not in self._cached_collections:
+            collection = self.available_collections[key]
+            self._cached_collections[key] = collection(self)
+        return self._cached_collections[key]
+
+    def request(self, method, url, params=None, data=None, path_params=None, **kwargs):
+        # Merge custom headers with instance headers
+        headers = self.headers.copy()
+        if "headers" in kwargs:
+            headers.update(kwargs.pop("headers"))
+        return requests.request(method, url, headers=headers, params=params, json=data, timeout=self.timeout, **kwargs)
+
+
+class RedirectAPIClient(BaseAPIClient):
+    """用于根据View的request配置重定向请求."""
+
+    def redirect(self, request):
+        pass
+
+
+class RequestAPIClient(BaseAPIClient):
+    def request(self, *args, **kwargs):
+        # update headers
+        headers = kwargs.pop("headers", {})
+        headers.update(self.headers)
+        method = kwargs.get("method", "GET")
+        if method.upper() in ["POST", "PUT", "PATCH", "DELETE"]:
+            headers["Content-Type"] = "application/json"
+        return self._request(headers=headers, *args, **kwargs)
+
+    def _request(self, method, url, params=None, data=None, **kwargs):
+        """Send request direct"""
+        params, data = self.merge_params_data_with_common_args(method, params, data)
+        logger.info("Calling %s %s with params=%s, data=%s", method, url, params, data)
+        return requests.request(method, url, params=params, json=data, timeout=self.timeout, **kwargs)
+
+
+def get_client_by_request(request, stage=DEFAULT_STAGE, common_args=None, headers=None):
+    """
+    根据当前请求返回一个client
+    :param request: 一个django request实例
+    :param stage: 请求环境，默认为prod
+    :param common_args: 公共请求参数
+    :param headers: 头部信息
+    :returns: 一个初始化好的APIClint对象
+    """
+    headers = headers or {}
+
+    is_authenticated = request.user.is_authenticated
+    if callable(is_authenticated):
+        is_authenticated = is_authenticated()
+    if is_authenticated:
+        headers.update(
+            {
+                HEADER_BK_AUTHORIZATION: json.dumps(
+                    {
+                        "bk_ticket": request.COOKIES.get("bk_ticket", ""),
+                        "bk_app_code": settings.APP_CODE,
+                        "bk_app_secret": settings.SECRET_KEY,
+                    }
+                )
+            }
+        )
+    else:
+        raise APIException("用户未通过验证")
+
+    return RedirectAPIClient(
+        app_code=settings.APP_CODE,
+        app_secret=settings.SECRET_KEY,
+        headers=headers,
+        common_args=common_args,
+        stage=stage,
+    )
+
+
+def get_client_by_user(user, stage=DEFAULT_STAGE, common_args=None, headers=None):
+    """
+    根据user实例返回一个client
+    :param user: 用户
+    :param stage: 请求环境，默认为prod
+    :param common_args: 公共请求参数
+    :param common_args: 公共请求参数
+    :param headers: 头部信息
+    :returns: 一个初始化好的APIClint对象
+    """
+    headers = headers or {}
+    common_args = common_args or {}
+    if hasattr(user, "username"):
+        user = user.username
+    try:
+        from bkoauth import get_access_token_by_user
+
+        access_token = get_access_token_by_user(user)
+        headers.update(
+            {
+                HEADER_BK_AUTHORIZATION: json.dumps({"access_token": access_token.access_token}),
+            }
+        )
+    except Exception as e:
+        logger.warning("get_access_token_by_user error %s, using header authorization", str(e))
+        headers.update(
+            {
+                HEADER_BK_AUTHORIZATION: json.dumps(
+                    {"bk_username": user, "bk_app_code": settings.APP_CODE, "bk_app_secret": settings.SECRET_KEY}
+                )
+            }
+        )
+
+    return RedirectAPIClient(
+        app_code=settings.APP_CODE,
+        app_secret=settings.SECRET_KEY,
+        headers=headers,
+        common_args=common_args,
+        stage=stage,
+    )
+
+
+def get_headers_by_generator(request):
+    """
+    通过配置的 generator 函数获取 headers
+
+    优先级：
+    1. 如果配置了 BKFLOW_SDK_APIGW_HEADERS_GENERATOR，则调用该函数获取
+    2. 否则返回 None，使用默认的 headers 生成逻辑
+
+    :param request: 一个django request实例
+    :return: headers 字典，如果 generator 未配置或返回 None，则返回 None
+    """
+    generator_path = getattr(settings, "BKFLOW_SDK_APIGW_HEADERS_GENERATOR", None)
+
+    if generator_path:
+        headers = call_config_function(
+            generator_path,
+            "BKFLOW_SDK_APIGW_HEADERS_GENERATOR",
+            error_message_prefix="调用 BKFLOW_SDK_APIGW_HEADERS_GENERATOR",
+            request=request,
+        )
+        # 验证返回值为字典类型
+        if headers is not None and isinstance(headers, dict):
+            return headers
+
+    return None
+
+
+def get_redirect_client_with_auth(request, **kwargs):
+    """
+    根据当前请求返回一个带有认证信息的client
+    :param request: 一个django request实例
+    :returns: 一个初始化好的APIClint对象
+    """
+    # 尝试通过 generator 函数获取 headers
+    generator_headers = get_headers_by_generator(request)
+
+    if generator_headers is not None:
+        # 如果 generator 返回了 headers，直接使用
+        headers = generator_headers
+    else:
+        # 否则使用默认的 headers 生成逻辑
+        bk_ticket = request.COOKIES.get("bk_ticket", None)
+        bk_token = request.COOKIES.get("bk_token", None)
+        if not bk_ticket and not bk_token:
+            raise APIException("用户未通过验证")
+        headers = {
+            HEADER_BK_AUTHORIZATION: json.dumps(
+                {
+                    "bk_app_code": settings.APP_CODE,
+                    "bk_app_secret": settings.SECRET_KEY,
+                    "bk_ticket": bk_ticket,
+                    "bk_token": bk_token,
+                }
+            )
+        }
+
+    return RedirectAPIClient(
+        app_code=settings.APP_CODE, app_secret=settings.SECRET_KEY, headers=headers, common_args={}, stage=DEFAULT_STAGE
+    )
+
+
+def get_redirect_client(request):
+    """
+    根据当前请求返回一个client
+    :param request: 一个django request实例
+    :returns: 一个初始化好的APIClint对象
+    """
+    headers = {
+        HEADER_BK_AUTHORIZATION: json.dumps(
+            {
+                "bk_app_code": settings.APP_CODE,
+                "bk_app_secret": settings.SECRET_KEY,
+            }
+        )
+    }
+
+    return RedirectAPIClient(
+        app_code=settings.APP_CODE, app_secret=settings.SECRET_KEY, headers=headers, common_args={}, stage=DEFAULT_STAGE
+    )

bkflow/common/__init__.py

@@ -0,0 +1,10 @@
+"""
+Tencent is pleased to support the open source community by making 蓝鲸智云 - PaaS平台 (BlueKing - PaaS System) available.
+Copyright (C) 2022 THL A29 Limited, a Tencent company. All rights reserved.
+Licensed under the MIT License (the "License"); you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+http://opensource.org/licenses/MIT
+Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on
+an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the
+specific language governing permissions and limitations under the License.
+"""

bkflow/common/decorators.py

@@ -0,0 +1,107 @@
+"""
+Tencent is pleased to support the open source community by making 蓝鲸智云 - PaaS平台 (BlueKing - PaaS System) available.
+Copyright (C) 2022 THL A29 Limited, a Tencent company. All rights reserved.
+Licensed under the MIT License (the "License"); you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+http://opensource.org/licenses/MIT
+Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on
+an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the
+specific language governing permissions and limitations under the License.
+"""
+from functools import wraps
+
+from django.core.handlers.wsgi import WSGIRequest
+from django.utils.translation import gettext_lazy as _
+from rest_framework import serializers
+from rest_framework.request import Request
+
+from bkflow.common.exceptions import ValidationError
+from bkflow.common.validator import custom_params_valid
+from bkflow.config.default import REQUEST_TOKEN_HEADER_KEY
+
+
+def token_inject(view_func):
+    """
+    token注入
+    :param view_func: 被装饰的view函数
+    """
+
+    def wrapper(*args, **kwargs):
+        request = args[1]
+        if not hasattr(request, "token"):
+            token = request.META.get(REQUEST_TOKEN_HEADER_KEY, "")
+
+            if not token:
+                raise ValidationError(
+                    _("当前接口需要token，请在请求头中添加${REQUEST_TOKEN_HEADER_KEY}").format(
+                        REQUEST_TOKEN_HEADER_KEY=REQUEST_TOKEN_HEADER_KEY
+                    )
+                )
+
+            setattr(request, "token", token)
+
+        return view_func(*args, **kwargs)
+
+    return wraps(view_func)(wrapper)
+
+
+def params_valid(serializer: serializers.Serializer, add_params: bool = True):
+    """参数校验装饰器
+
+    :param serializer: serializer类
+    :param add_params: 是否将校验后的参数添加到request.cleaned_params中
+    :return: 参数校验装饰器
+    """
+
+    def decorator(view_func):
+        @wraps(view_func)
+        def wrapper(*args, **kwargs):
+            # 获得Django的request对象
+            _request = kwargs.get("request")
+
+            if not _request:
+                for arg in args:
+                    if isinstance(arg, (Request, WSGIRequest)):
+                        _request = arg
+                        break
+
+            if not _request:
+                raise ValidationError(_("该装饰器只允许用于Django的View函数(包括普通View函数和Class-base的View函数)"))
+
+            # 校验request中的参数
+            params = {}
+            if _request.method in ["GET"]:
+                if isinstance(_request, Request):
+                    params = _request.query_params
+                else:
+                    params = _request.GET
+            elif _request.META.get("HTTP_X_REQUESTED_WITH") == "XMLHttpRequest":
+                if isinstance(_request, Request):
+                    params = _request.data
+                else:
+                    params = _request.json()
+            else:
+                if isinstance(_request, Request):
+                    params = _request.data
+                else:
+                    params = _request.POST
+
+            cleaned_params = custom_params_valid(serializer=serializer, params=params)
+            _request.cleaned_params = cleaned_params
+
+            # 执行实际的View逻辑
+            params_add = False
+            try:
+                # 语法糖，使用这个decorator的话可直接从view中获得参数的字典
+                if "params" not in kwargs and add_params:
+                    kwargs["params"] = cleaned_params
+                    params_add = True
+            except TypeError:
+                if params_add:
+                    del kwargs["params"]
+            resp = view_func(*args, **kwargs)
+            return resp
+
+        return wrapper
+
+    return decorator

bkflow/common/exceptions.py

@@ -0,0 +1,46 @@
+"""
+Tencent is pleased to support the open source community by making 蓝鲸智云 - PaaS平台 (BlueKing - PaaS System) available.
+Copyright (C) 2022 THL A29 Limited, a Tencent company. All rights reserved.
+Licensed under the MIT License (the "License"); you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+http://opensource.org/licenses/MIT
+Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on
+an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the
+specific language governing permissions and limitations under the License.
+"""
+
+
+class BkflowSDKException(Exception):
+    CODE = None
+    MESSAGE = None
+    STATUS_CODE = 500
+
+    def __init__(self, message="", errors=""):
+        if message:
+            self.MESSAGE = message
+        if self.MESSAGE and errors:
+            self.message = f"{self.MESSAGE}: {errors}"
+        elif self.MESSAGE:
+            self.message = self.MESSAGE
+        else:
+            self.message = f"{errors}"
+
+    def __str__(self):
+        return self.message
+
+
+class APIException(BkflowSDKException):
+    """Exception for API"""
+
+    def __init__(self, errors, resp=None, url=""):
+        self.url = url
+        self.error_message = errors
+        self.resp = resp
+
+        if self.resp is not None:
+            errors = "%s, resp=%s" % (errors, self.resp.text)
+        super(APIException, self).__init__(errors)
+
+
+class ValidationError(BkflowSDKException):
+    pass

bkflow/common/loader.py

@@ -0,0 +1,98 @@
+"""
+Tencent is pleased to support the open source community by making 蓝鲸智云 - PaaS平台 (BlueKing - PaaS System) available.
+Copyright (C) 2022 THL A29 Limited, a Tencent company. All rights reserved.
+Licensed under the MIT License (the "License"); you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+http://opensource.org/licenses/MIT
+Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on
+an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the
+specific language governing permissions and limitations under the License.
+"""
+import importlib
+import logging
+
+logger = logging.getLogger(__name__)
+
+
+def load_function_from_path(function_path, setting_name):
+    """
+    从配置的函数路径动态加载函数
+
+    :param function_path: 函数路径，格式：module.path.function_name 或 module.path.ClassName.method_name
+    :param setting_name: 配置项名称，用于错误消息
+    :return: 加载的函数对象，如果无法加载则返回 None
+    :raises ValueError: 当函数路径格式错误或无法解析时
+    """
+    if not function_path:
+        return None
+
+    # 解析函数路径，格式：module.path.function_name 或 module.path.ClassName.method_name
+    # 从右到左尝试解析，找到最长的可导入模块路径
+    parts = function_path.split(".")
+    if len(parts) < 2:
+        raise ValueError(f"{setting_name} 格式错误，应为 'module.path.function_name'" " 或 'module.path.ClassName.method_name'")
+
+    # 尝试导入模块，从最长的路径开始
+    func = None
+    last_exception = None
+    for i in range(len(parts) - 1, 0, -1):
+        try:
+            module_path = ".".join(parts[:i])
+            attr_path = parts[i:]
+            module = importlib.import_module(module_path)
+            # 递归获取属性（支持类方法）
+            func = module
+            for attr_name in attr_path:
+                func = getattr(func, attr_name)
+            break
+        except ImportError:
+            # ImportError 表示模块不存在，继续尝试下一个路径
+            continue
+        except AttributeError as e:
+            # AttributeError 表示模块存在但属性不存在
+            # 如果这是第一个成功的模块导入，说明路径格式正确但属性不存在，应该抛出异常
+            # 否则继续尝试其他路径
+            last_exception = e
+            # 如果已经成功导入了模块，说明路径是正确的，只是属性不存在，应该立即抛出异常
+            if module is not None:
+                raise ValueError(
+                    f"无法解析 {setting_name}: {function_path}，" f"模块 '{module_path}' 存在但属性 '{'.'.join(attr_path)}' 不存在"
+                )
+            continue
+
+    if func is None:
+        # 如果所有尝试都失败，抛出异常
+        if last_exception:
+            raise ValueError(f"无法解析 {setting_name}: {function_path}，原因：{str(last_exception)}")
+        else:
+            raise ValueError(f"无法解析 {setting_name}: {function_path}")
+
+    return func
+
+
+def call_config_function(function_path, setting_name, error_message_prefix=None, **kwargs):
+    """
+    调用配置的函数并返回结果
+
+    :param function_path: 函数路径，格式：module.path.function_name 或 module.path.ClassName.method_name
+    :param setting_name: 配置项名称，用于错误消息
+    :param error_message_prefix: 错误消息前缀，用于日志记录
+    :param kwargs: 传递给函数的参数
+    :return: 函数返回值，如果函数未配置或调用失败则返回 None
+    """
+    if not function_path:
+        return None
+
+    try:
+        func = load_function_from_path(function_path, setting_name)
+        if func is None:
+            return None
+
+        # 调用函数
+        result = func(**kwargs)
+        return result
+    except Exception as e:
+        # 如果函数调用失败，记录错误
+        error_prefix = error_message_prefix or f"调用 {setting_name}"
+        logger.warning(f"{error_prefix} 失败: {e}，将使用默认逻辑")
+        return None

bkflow/common/validator.py

@@ -0,0 +1,96 @@
+"""
+Tencent is pleased to support the open source community by making 蓝鲸智云 - PaaS平台 (BlueKing - PaaS System) available.
+Copyright (C) 2022 THL A29 Limited, a Tencent company. All rights reserved.
+Licensed under the MIT License (the "License"); you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+http://opensource.org/licenses/MIT
+Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on
+an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the
+specific language governing permissions and limitations under the License.
+"""
+import json
+
+from django.utils.translation import gettext_lazy as _
+from rest_framework import serializers
+
+from bkflow.common.exceptions import ValidationError
+
+
+def format_serializer_errors(errors: dict, fields: dict, params: dict, prefix: str = "  "):
+    """格式化序列化器错误信息
+
+    :param errors: 错误信息
+    :param fields: 序列化器字段
+    :param params: 参数
+    :return: 格式化后的错误信息
+    """
+    message = _("参数校验失败:{wrap}").format(wrap="\n") if prefix == "  " else "\n"
+    for key, field_errors in list(errors.items()):
+        sub_message = ""
+        label = key
+        if key not in fields:
+            sub_message = json.dumps(field_errors, ensure_ascii=False)
+        else:
+            field = fields[key]
+            label = field.label or field.field_name
+            if (
+                hasattr(field, "child")
+                and isinstance(field_errors, list)
+                and len(field_errors) > 0
+                and not isinstance(field_errors[0], str)
+            ):
+                for index, sub_errors in enumerate(field_errors):
+                    if sub_errors:
+                        sub_format = format_serializer_errors(
+                            sub_errors, field.child.fields, params, prefix=prefix + "    "
+                        )
+                        # return sub_format
+                        sub_message += _("{wrap}{prefix}第{index}项:").format(
+                            wrap="\n",
+                            prefix=prefix + "  ",
+                            index=index + 1,
+                        )
+                        sub_message += sub_format
+            else:
+                if isinstance(field_errors, dict):
+                    if hasattr(field, "child"):
+                        sub_foramt = format_serializer_errors(
+                            field_errors, field.child.fields, params, prefix=prefix + "  "
+                        )
+                    else:
+                        sub_foramt = format_serializer_errors(field_errors, field.fields, params, prefix=prefix + "  ")
+                    sub_message += sub_foramt
+                elif isinstance(field_errors, list):
+                    for index in range(len(field_errors)):
+                        field_errors[index] = field_errors[index].format(**{key: params.get(key, "")})
+                        sub_message += "{index}.{error}".format(index=index + 1, error=field_errors[index])
+                    sub_message += "\n"
+        # 对使用 Validate() 时 label == "non_field_errors" 的特殊情况做处理
+        if label == "non_field_errors":
+            message += f"{prefix} {sub_message}"
+        else:
+            message += f"{prefix}{label}: {sub_message}"
+    return message
+
+
+def custom_params_valid(serializer: serializers.Serializer, params: dict, many: bool = False):
+    """校验参数
+
+    :param serializer: 校验器
+    :param params: 原始参数
+    :param many: 是否为多个参数
+    :return: 校验通过的参数
+    """
+    _serializer = serializer(data=params, many=many)
+    try:
+        _serializer.is_valid(raise_exception=True)
+    except serializers.ValidationError as e:  # pylint: disable=broad-except # noqa
+        try:
+            message = format_serializer_errors(_serializer.errors, _serializer.fields, params)
+        except Exception as e:  # pylint: disable=broad-except
+            if isinstance(e.message, str):
+                message = e.message
+            else:
+                message = _("参数校验失败，详情请查看返回的errors")
+        raise ValidationError(message=message, errors=_serializer.errors)
+    return list(_serializer.validated_data) if many else dict(_serializer.validated_data)