huaweicloud-encryption-sdk-python 1.2.1__py3-none-any.whl

huaweicloud_encryptionsdk/_apig_sdk/sm3_hash.py

@@ -0,0 +1,141 @@
+#
+# Copyright (c) Huawei Technologies Co., Ltd. 2025. All rights reserved.
+#
+# coding=utf-8
+
+import hashlib
+from sys import version_info
+
+if version_info.major == 3:
+    if version_info.minor < 7:
+        _IV = [0x7380166f, 0x4914b2b9, 0x172442d7, 0xda8a0600, 0xa96f30bc, 0x163138aa, 0xe38dee4d, 0xb0fb0e4e]
+        _T_J = [0x79cc4519 if j < 16 else 0x7a879d8a for j in range(64)]
+        _0X8F = 0xffffffff
+
+        _OUT_OF_RANGE_ERROR = ValueError("j out of range [0, 64)")
+
+
+        def _left_rotate(n, k):
+            # type: (int, int) -> int
+            """
+            Shift the binary representation of n to the left by k bits,
+            and then shift the k bits of the highest bits to the lowest bits to form a new 32-bit unsigned integer.
+            """
+            return ((n << k) & _0X8F) | ((n >> (32 - k)) & _0X8F)
+
+
+        def _ff_j(x, y, z, j):
+            # type: (int, int, int, int) -> int
+            """Boolean function, take different expressions as j changes. Based on GB/T 32905-2016."""
+            if 0 <= j < 16:
+                return x ^ y ^ z
+            elif 16 <= j < 64:
+                return (x & y) | (x & z) | (y & z)
+            else:
+                raise _OUT_OF_RANGE_ERROR
+
+
+        def _gg_j(x, y, z, j):
+            # type: (int, int, int, int) -> int
+            """Boolean function, take different expressions as j changes, based on GB/T 32905-2016."""
+            if 0 <= j < 16:
+                return x ^ y ^ z
+            elif 16 <= j < 64:
+                return (x & y) ^ (~x & z)
+            else:
+                raise _OUT_OF_RANGE_ERROR
+
+
+        def _p_0(x):
+            # type: (int) -> int
+            """permutation function in compression function, based on GB/T 32905-2016."""
+            return x ^ _left_rotate(x, 9) ^ _left_rotate(x, 17)
+
+
+        def _p_1(x):
+            # type: (int) -> int
+            """permutation function in compression function, based on GB/T 32905-2016."""
+            return x ^ _left_rotate(x, 15) ^ _left_rotate(x, 23)
+
+
+        def _cf(v_i, b_i):
+            # type: (list[int], list[int]) -> list[int]
+            """Compression function, based on GB/T 32905-2016."""
+            w = [0] * 68
+            for i in range(16):
+                data = b_i[i * 4: (i + 1) * 4]
+                w[i] = int.from_bytes(data, byteorder='big')
+
+            for i in range(16, 68):
+                w[i] = _p_1(w[i - 16] ^ w[i - 9] ^ (_left_rotate(w[i - 3], 15))) ^ (_left_rotate(w[i - 13], 7)) ^ w[
+                    i - 6]
+
+            w_1 = [w[i] ^ w[i + 4] for i in range(64)]
+
+            a, b, c, d, e, f, g, h = v_i
+
+            for i in range(64):
+                ss_1 = _left_rotate((_left_rotate(a, 12) + e + _left_rotate(_T_J[i], i % 32)) & _0X8F, 7)
+                ss_2 = ss_1 ^ _left_rotate(a, 12)
+                tt_1 = (_ff_j(a, b, c, i) + d + ss_2 + w_1[i]) & _0X8F
+                tt_2 = (_gg_j(e, f, g, i) + h + ss_1 + w[i]) & _0X8F
+                d, c, b, a, h, g, f, e = c, _left_rotate(b, 9), a, tt_1, g, _left_rotate(f, 19), e, _p_0(tt_2)
+                a, b, c, d, e, f, g, h = map(lambda x: x & _0X8F, (a, b, c, d, e, f, g, h))
+
+            v_j = (a, b, c, d, e, f, g, h)
+            return [v_j[i] ^ v_i[i] for i in range(8)]
+
+
+        def _hash(data):
+            # type: (bytes) -> bytes
+            """Hash function, based on GB/T 32905-2016."""
+            data_list = [i for i in data]
+            length = len(data_list)
+            bit_length = length * 8
+            k = (56 - length - 1) % 64
+            data_list.append(0x80)
+            data_list.extend([0x00] * k)
+            data_list.extend([i for i in bit_length.to_bytes(8, 'big')])
+
+            iter_count = int(len(data_list) / 64)
+            b = [data_list[i * 64:(i + 1) * 64] for i in range(iter_count)]
+
+            v = [_IV]
+
+            i = 0
+            for i in range(iter_count):
+                v.append(_cf(v[i], b[i]))
+
+            return b''.join(map(lambda n: n.to_bytes(4, 'big'), v[i + 1]))
+
+
+        class _SM3Hash:
+            name = 'sm3'
+            digest_size = 32
+            block_size = 64
+
+            def __init__(self, data=b''):
+                self._bytearray = bytearray(data)
+
+            def update(self, data):
+                # type: (bytes) -> None
+                self._bytearray.extend(data)
+
+            def digest(self):
+                # type: () -> bytes
+                return _hash(bytes(self._bytearray))
+
+            def hexdigest(self):
+                # type: () -> str
+                return self.digest().hex()
+
+            def copy(self):
+                # type: () -> _SM3Hash
+                return self.__class__(bytes(self._bytearray))
+
+
+        new_sm3_hash = lambda data=b'': _SM3Hash(data)
+    else:
+        new_sm3_hash = lambda data=b'': hashlib.new('sm3', data)
+else:
+    new_sm3_hash = None

huaweicloud_encryptionsdk/_lts_sdk/auth/signer.py

@@ -0,0 +1,174 @@
+import datetime
+import hashlib
+import hmac
+from typing import List
+from urllib.parse import unquote, quote
+
+import requests
+from huaweicloud_encryptionsdk._lts_sdk.producer.lts_http.simple_request import LtsRequest
+
+
+class Constants:
+    HEADER_X_DATA = "X-Sdk-Date"
+    BASIC_DATE_FORMAT = "%Y%m%dT%H%M%SZ"
+    DERIVED_DATE_FORMAT = "%Y%m%d"
+    HEADER_CONTENT_SHA256 = "X-Sdk-Content-Sha256"
+    AUTH_SERVICE_NAME = "lts"
+    ALGORITHM = "V11-HMAC-SHA256"
+    HEADER_AUTHORIZATION = "Authorization"
+
+
+class Signer(object):
+
+    def __init__(self):
+        self._hash_func = hashlib.sha256
+
+    def _derive_key(self, ak, sk, info):
+        salt = bytearray(ak, 'utf-8')
+        ikm = bytearray(sk, 'utf-8')
+        info_bytes = bytearray(info, 'utf-8')
+        prk = hmac.new(salt, ikm, self._hash_func).digest()
+        okm = b""
+        t = b""
+        for i in range(1, (32 + 32) // 32 + 1):
+            t = hmac.new(prk, t + info_bytes + bytes([i]), self._hash_func).digest()
+            okm += t
+        return okm[:32].hex()
+
+    def sign(self, lts_request: LtsRequest) -> requests.Request:
+        try:
+            if lts_request.method not in {"POST", "PATCH", "PUT"}:
+                lts_request.body = ""
+
+            if lts_request.security_token:
+                lts_request.headers["X-Security-Token"] = lts_request.security_token
+
+            date_time = datetime.datetime.now(datetime.timezone.utc)
+            if Constants.HEADER_X_DATA not in lts_request.headers:
+                lts_request.headers[Constants.HEADER_X_DATA] = date_time.strftime(Constants.BASIC_DATE_FORMAT)
+            else:
+                time = lts_request.headers[Constants.HEADER_X_DATA]
+                date_time = datetime.datetime.strptime(time, Constants.BASIC_DATE_FORMAT)
+
+            signed_headers = self._signed_headers(lts_request)
+            canonical_request = self._canonical_request(lts_request, signed_headers)
+            date_str = datetime.datetime.strftime(date_time, Constants.DERIVED_DATE_FORMAT)
+            info_str = "%s/%s/%s" % (date_str, lts_request.region, Constants.AUTH_SERVICE_NAME)
+            string_to_sign = self._string_to_sign_derived(canonical_request, date_time, info_str)
+            derivation_key = self._derive_key(lts_request.ak, lts_request.sk, info_str)
+            signature = self._sign_string_to_sign(string_to_sign, derivation_key)
+            auth_value = self._derivation_auth_header_value(signature, lts_request.ak, signed_headers, info_str)
+            lts_request.headers[Constants.HEADER_AUTHORIZATION] = auth_value
+
+            url = lts_request.host + lts_request.interface
+            req = requests.Request(method=lts_request.method, headers=lts_request.headers, data=lts_request.body,
+                                   url=url, params=lts_request.query)
+            return req
+        except Exception as e:
+            pass
+
+    def _hash_hex_string(self, data):
+        # type: (bytes) -> str
+        _hash = self._hash_func(data)
+        return _hash.hexdigest()
+
+    @classmethod
+    def _signed_headers(cls, lts_request: LtsRequest):
+        key_list = []
+        for key, value in lts_request.headers.items():
+            key_list.append(key.lower())
+        key_list.sort()
+        return key_list
+
+    @classmethod
+    def _canonical_headers(cls, request: LtsRequest, signed_headers: List[str]):
+        canonical_headers = []
+        __headers = {}
+        for key in request.headers:
+            key_encoded = key.lower()
+            value = request.headers[key]
+            value_encoded = str(value).strip()
+            __headers[key_encoded] = value_encoded
+
+        for key in signed_headers:
+            canonical_headers.append(key + ":" + __headers.get(key))
+
+        return '\n'.join(canonical_headers) + "\n"
+
+    @classmethod
+    def _canonical_uri(cls, lts_request: LtsRequest):
+        pattens = unquote(lts_request.interface).split("/")
+        uri = []
+        for v in pattens:
+            uri.append(cls._url_encode(v))
+        url_path = "/".join(uri)
+
+        if url_path[-1] != '/':
+            url_path = url_path + "/"
+
+        return url_path
+
+    @classmethod
+    def _url_encode(cls, s):
+        return quote(s, safe='~')
+
+    @classmethod
+    def _canonical_query_string(cls, lts_request: LtsRequest):
+        query_keys = []
+        for key, value in lts_request.query.items():
+            query_keys.append(key)
+        query_keys.sort()
+        canonical_query_param = []
+
+        for query_key in query_keys:
+            encode_query_key = cls._url_encode(query_key)
+            query_value = lts_request.query[query_key]
+            if isinstance(query_value, str):
+                kv = "%s=%s" % (encode_query_key, cls._url_encode(query_value))
+                canonical_query_param.append(kv)
+            elif isinstance(query_value, bool):
+                kv = "%s=%s" % (encode_query_key, cls._url_encode(str(query_value).lower()))
+                canonical_query_param.append(kv)
+            elif isinstance(query_value, int):
+                kv = "%s=%s" % (encode_query_key, cls._url_encode(str(query_value)))
+                canonical_query_param.append(kv)
+        return '&'.join(canonical_query_param)
+
+    def _canonical_request(self, lts_request: LtsRequest, signed_headers: List[str]):
+        hex_encode = ""
+        if Constants.HEADER_CONTENT_SHA256 in signed_headers:
+            hex_encode = lts_request.headers[Constants.HEADER_CONTENT_SHA256]
+        else:
+            hex_encode = self._hash_hex_string(lts_request.body.encode('utf-8'))
+
+        canonical_uri = self._canonical_uri(lts_request)
+        canonical_query_string = self._canonical_query_string(lts_request)
+        canonical_headers = self._canonical_headers(lts_request, signed_headers)
+
+        return "{0}\n{1}\n{2}\n{3}\n{4}\n{5}".format(lts_request.method.upper(), canonical_uri, canonical_query_string,
+                                                     canonical_headers,
+                                                     ";".join(signed_headers), hex_encode)
+
+    def _string_to_sign_derived(self, canonical_request, time, info=None):
+        # type: (str, datetime, str) -> str
+        return "%s\n%s\n%s\n%s" % (
+            Constants.ALGORITHM,
+            datetime.datetime.strftime(time, Constants.DERIVED_DATE_FORMAT),
+            info,
+            self._hash_hex_string(canonical_request.encode('utf-8')))
+
+    def _sign_string_to_sign(self, string_to_sign, key):
+        # type: (str, str) -> str
+        return self._hex(self._hmac(key.encode('utf-8'), string_to_sign.encode('utf-8')))
+
+    def _derivation_auth_header_value(self, signature, app_key, signed_headers, info=None):
+        # type: (str, str, list, str) -> str
+        return "%s Credential=%s/%s, SignedHeaders=%s, Signature=%s" % (
+            Constants.ALGORITHM, app_key, info, ";".join(signed_headers), signature)
+
+    def _hex(self, data):
+        return data.hex()
+
+    def _hmac(self, key, data):
+        # type: (bytes, bytes) -> bytes
+        return hmac.new(key, data, digestmod=self._hash_func).digest()

huaweicloud_encryptionsdk/_lts_sdk/consumer/client/consumer_client_adapter.py

@@ -0,0 +1,59 @@
+from consumer.client.http_client import HttpClient
+from consumer.model.consumer_config import ConsumerConfig
+from huaweicloud_encryptionsdk._lts_sdk.utils import lts_threading
+
+
+class LogConsumerClientAdapter(object):
+    def __init__(self, config: ConsumerConfig):
+        self._project_id = config.project_id
+        self._log_group_id = config.log_group_id
+        self._log_stream_id = config.log_stream_id
+        self._region_name = config.region_name
+        self._consumer_group_name = config.consumer_group_name
+        self._consumer = config.consumer
+        self._is_shutdown = False
+        self._client = HttpClient(config)
+        self._lock = lts_threading.ReadWriteLock()
+
+    def shutdown(self):
+        self._is_shutdown = True
+
+    def hear_beat(self, all_shards):
+        self._lock.acquire_read()
+        try:
+            return self._client.heart_beat(self._project_id, self._log_group_id, self._log_stream_id,
+                                           self._consumer_group_name, self._consumer, all_shards)
+        finally:
+            self._lock.release_read()
+
+    def fetch_consumer_group(self, shard_id):
+        self._lock.acquire_read()
+        try:
+            return self._client.fetch_consumer_group(self._project_id, self._log_group_id, self._log_stream_id,
+                                                     self._consumer_group_name, shard_id)
+        finally:
+            self._lock.release_read()
+
+    def update_check_point(self, shard_id, consumer, check_point):
+        self._lock.acquire_read()
+        try:
+            return self._client.update_check_point(self._project_id, self._log_group_id, self._log_stream_id,
+                                                   self._consumer_group_name, shard_id, consumer, check_point)
+        finally:
+            self._lock.release_read()
+
+    def batch_get_logs(self, shard_id, batch_size, start_time, end_time):
+        self._lock.acquire_read()
+        try:
+            return self._client.batch_get_log(self._project_id, self._log_group_id, self._log_stream_id, shard_id,
+                                              batch_size, start_time, end_time)
+        finally:
+            self._lock.release_read()
+
+    def get_cursor_by_time(self, shard_id, time):
+        self._lock.acquire_read()
+        try:
+            return self._client.get_cursor_by_time(self._project_id, self._log_group_id, self._log_stream_id, shard_id,
+                                                   time)
+        finally:
+            self._lock.release_read()

huaweicloud_encryptionsdk/_lts_sdk/consumer/client/http_client.py

@@ -0,0 +1,211 @@
+import json
+from json import JSONDecodeError
+
+import requests
+import urllib3
+from loguru import logger
+from requests.adapters import HTTPAdapter
+from urllib3.exceptions import InsecureRequestWarning
+from urllib3.util.retry import Retry
+
+from huaweicloud_encryptionsdk._lts_sdk.auth.signer import Signer
+from consumer.model.check_point import ShardCheckPoint, Cursor
+from consumer.model.consumer_config import ConsumerConfig
+from consumer.model.log_data import BatchGetLog
+from huaweicloud_encryptionsdk._lts_sdk.producer.lts_http.simple_request import LtsRequest
+from huaweicloud_encryptionsdk._lts_sdk.producer.model import error
+from huaweicloud_encryptionsdk._lts_sdk.utils import common
+
+
+class HttpClient(object):
+    def __init__(self, config: ConsumerConfig):
+        self._session = requests.Session()
+        self._signer = Signer()
+        self._config = config
+
+        retry_strategy = Retry(
+            total=2,
+            status_forcelist=[429, 500, 502, 503, 504],
+            backoff_factor=1
+        )
+        adapter = HTTPAdapter(max_retries=retry_strategy, pool_connections=100, pool_maxsize=100)
+        self._session.mount("https://", adapter)
+        self._session.mount("http://", adapter)
+        urllib3.disable_warnings(InsecureRequestWarning)
+
+    @staticmethod
+    def connect_query_string(query_map, url):
+        if query_map is None or len(query_map) == 0:
+            return url
+        query_list = []
+        for key, value in query_map.items():
+            query_list.append(key + "=" + value)
+
+        query_url = "&".join(query_list)
+        return url + "?" + query_url
+
+    def heart_beat(self, project_id, log_group_id, log_stream_id, consumer_group_name, consumer, all_shards):
+        interface = f"/v2/{project_id}/groups/{log_group_id}/streams/{log_stream_id}/consumer-groups/{consumer_group_name}/heartbeat"
+        query_map = {"consumer_name": consumer}
+        body = common.convert_obj2_json_str(all_shards)
+        r = self.generate_request("POST", interface, query_map, body, self._config)
+        try:
+            begin_time = common.current_time_ms()
+            response = self._session.send(r, verify=False)
+            response.encoding = "utf-8"
+            end_time = common.current_time_ms()
+            logger.debug("httpclient url is {}, code is {}, body is {}, result is {}, cost [{}]ms", r.url,
+                         response.status_code,
+                         body,
+                         response.content.decode("utf-8"),
+                         end_time - begin_time)
+            if response.status_code == 200:
+                result_str = response.content.decode("utf-8")
+                try:
+                    result = json.loads(result_str)
+                except JSONDecodeError as e:
+                    logger.info("heart beat result is not json: {}", result_str)
+                    return error.Error(error_code=error.RESULT_JSON_FORMAT_ERROR_CODE,
+                                       error_msg=result_str,
+                                       http_code=response.status_code), None
+                return None, result
+            else:
+                return error.Error(error_code=error.HTTP_QUEST_ERROR_CODE, error_msg=response.content.decode("utf-8"),
+                                   http_code=response.status_code), None
+        except Exception as e:
+            logger.error("httpclient url is {}, exception is {}", r.url, str(e))
+            return error.Error(error_code=error.HTTP_QUEST_ERROR_CODE, error_msg=str(e), http_code=0), None
+
+    def fetch_consumer_group(self, project_id, log_group_id, log_stream_id, consumer_group_name, shard_id):
+        interface = f"/v2/{project_id}/groups/{log_group_id}/streams/{log_stream_id}/consumer-groups/{consumer_group_name}"
+        query_map = None
+        if len(shard_id) > 0:
+            query_map = {"shard_id": shard_id}
+        r = self.generate_request("GET", interface, query_map, "", self._config)
+        try:
+            begin_time = common.current_time_ms()
+            response = self._session.send(r, verify=False)
+            end_time = common.current_time_ms()
+            response.encoding = "utf-8"
+            logger.debug("httpclient url is {}, code is {}, result is {}, cost [{}]ms", r.url, response.status_code,
+                         response.content.decode("utf-8"), end_time - begin_time)
+            if response.status_code == 200:
+                result_str = response.content.decode("utf-8")
+                try:
+                    result = common.convert_json_str2_list_obj(result_str, ShardCheckPoint)
+                except JSONDecodeError as e:
+                    logger.error("fetch_consumer_group result is not json: {}", result_str)
+                    return error.Error(error_code=error.RESULT_JSON_FORMAT_ERROR_CODE,
+                                       error_msg=result_str,
+                                       http_code=response.status_code), None
+                return None, result
+            else:
+                return error.Error(error_code=error.HTTP_QUEST_ERROR_CODE, error_msg=response.content.decode("utf-8"),
+                                   http_code=response.status_code), None
+        except Exception as e:
+            logger.error("httpclient url is {}, exception is {}", r.url, str(e))
+            return error.Error(error_code=error.HTTP_QUEST_ERROR_CODE, error_msg=str(e), http_code=0), None
+
+    def get_cursor_by_time(self, project_id, log_group_id, log_stream_id, shard_id, time):
+        interface = f"/v2/{project_id}/groups/{log_group_id}/streams/{log_stream_id}/shards/{shard_id}/cursor"
+        query_map = {"from": time}
+        r = self.generate_request("GET", interface, query_map, "", self._config)
+        try:
+            begin_time = common.current_time_ms()
+            response = self._session.send(r, verify=False)
+            end_time = common.current_time_ms()
+            response.encoding = "utf-8"
+            logger.info("httpclient url is {}, code is {}, result is {}, cost [{}]ms", r.url, response.status_code,
+                        response.content.decode("utf-8"), end_time - begin_time)
+            if response.status_code == 200:
+                result_str = response.content.decode("utf-8")
+                try:
+                    result = common.convert_json_str2_obj(result_str, Cursor)
+                except JSONDecodeError as e:
+                    logger.error("get_cursor_by_time result is not json: {}", result_str)
+                    return error.Error(error_code=error.RESULT_JSON_FORMAT_ERROR_CODE,
+                                       error_msg=result_str,
+                                       http_code=response.status_code), None
+                return None, result
+            else:
+                return error.Error(error_code=error.HTTP_QUEST_ERROR_CODE, error_msg=response.content.decode("utf-8"),
+                                   http_code=response.status_code), None
+        except Exception as e:
+            logger.error("httpclient url is {}, exception is {}", r.url, str(e))
+            return error.Error(error_code=error.HTTP_QUEST_ERROR_CODE, error_msg=str(e), http_code=0), None
+
+    def update_check_point(self, project_id, log_group_id, log_stream_id, consumer_group_name, shard_id, consumer,
+                           check_point):
+        interface = f"/v2/{project_id}/groups/{log_group_id}/streams/{log_stream_id}/consumer-groups/{consumer_group_name}"
+        query_map = {"consumer_name": consumer}
+        request_body = []
+        param = {"shard_id": shard_id, "checkpoint": check_point}
+        request_body.append(param)
+        logger.debug("update check point, shard_id {}, checkpoint {} request_body is {}", shard_id, check_point,
+                     request_body)
+        body = common.convert_obj2_json_str(request_body)
+        r = self.generate_request("POST", interface, query_map, body, self._config)
+        try:
+            begin_time = common.current_time_ms()
+            response = self._session.send(r, verify=False)
+            end_time = common.current_time_ms()
+            response.encoding = "utf-8"
+            logger.debug("httpclient url is {}, code is {}, body is {}, result is {}, cost [{}]ms", r.url,
+                         response.status_code,
+                         body,
+                         response.content.decode("utf-8"), end_time - begin_time)
+            if response.status_code == 200:
+                return None
+            else:
+                return error.Error(error_code=error.HTTP_QUEST_ERROR_CODE, error_msg=response.content.decode("utf-8"),
+                                   http_code=response.status_code)
+        except Exception as e:
+            logger.error("httpclient url is {}, exception is {}", r.url, str(e))
+            return error.Error(error_code=error.HTTP_QUEST_ERROR_CODE, error_msg=str(e), http_code=0)
+
+    def batch_get_log(self, project_id, log_group_id, log_stream_id, shard_id, batch_size, start_time, end_time):
+        interface = f"/v2/{project_id}/groups/{log_group_id}/streams/{log_stream_id}/shards/{shard_id}"
+        query_map = {"limit": batch_size, "start": start_time}
+        if len(end_time) > 0:
+            query_map["end"] = end_time
+        r = self.generate_request("GET", interface, query_map, "", self._config)
+        try:
+            begin_time = common.current_time_ms()
+            response = self._session.send(r, verify=False)
+            end_time = common.current_time_ms()
+            response.encoding = "utf-8"
+            logger.debug("httpclient url is {} query map is {}, code is {}, result is {}, cost [{}]ms", r.url,
+                         query_map,
+                         response.status_code,
+                         response.content.decode("utf-8"), end_time - begin_time)
+            if response.status_code == 200:
+                result_str = response.content.decode("utf-8")
+                try:
+                    result = common.convert_json_str2_obj(result_str, BatchGetLog)
+                except JSONDecodeError as e:
+                    logger.error("batch_get_log result is not json: {}", result_str)
+                    return error.Error(error_code=error.RESULT_JSON_FORMAT_ERROR_CODE,
+                                       error_msg=result_str,
+                                       http_code=response.status_code), None
+                return None, result
+            else:
+                return error.Error(error_code=error.HTTP_QUEST_ERROR_CODE, error_msg=response.content.decode("utf-8"),
+                                   http_code=response.status_code), None
+        except Exception as e:
+            logger.error("httpclient url is {}, exception is {}", r.url, str(e))
+            return error.Error(error_code=error.HTTP_QUEST_ERROR_CODE, error_msg=str(e), http_code=0), None
+
+    def generate_request(self, method, interface, query_map, body, config):
+        header = {"content-type": "application/json"}
+        if query_map is None:
+            req = LtsRequest(method=method, host=config.endpoint, headers=header, body=body, region=config.region_name,
+                             interface=interface, ak=config.access_key, sk=config.access_secret)
+            request = self._signer.sign(req)
+            r = request.prepare()
+            return r
+        else:
+            req = LtsRequest(method=method, host=config.endpoint, headers=header, body=body, region=config.region_name,
+                             interface=interface, ak=config.access_key, sk=config.access_secret, **query_map)
+            request = self._signer.sign(req)
+            r = request.prepare()
+            return r