124 lines
3.9 KiB
Python
124 lines
3.9 KiB
Python
# Copyright (c) 2014 Baidu.com, Inc. All Rights Reserved
|
|
#
|
|
# Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file
|
|
# except in compliance with the License. You may obtain a copy of the License at
|
|
#
|
|
# http://www.apache.org/licenses/LICENSE-2.0
|
|
#
|
|
# 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.
|
|
|
|
"""
|
|
This module provides a client class for CDN.
|
|
"""
|
|
|
|
import copy
|
|
import logging
|
|
import uuid
|
|
|
|
from baidubce import bce_base_client
|
|
from baidubce.auth import bce_v1_signer
|
|
from baidubce.http import bce_http_client
|
|
from baidubce.http import handler
|
|
from baidubce.http import http_methods
|
|
from baidubce.utils import required
|
|
|
|
_logger = logging.getLogger(__name__)
|
|
|
|
|
|
class DumapClient(bce_base_client.BceBaseClient):
|
|
"""
|
|
DumapClient
|
|
"""
|
|
|
|
def __init__(self, config=None):
|
|
bce_base_client.BceBaseClient.__init__(self, config)
|
|
|
|
@required(app_id=(bytes, str), uri=(bytes, str), params=dict)
|
|
def call_open_api(self, app_id=None, uri=None, params=None, body=None, method=b'GET', config=None):
|
|
"""
|
|
call open_api
|
|
:param app_id: app_id
|
|
:type app_id: string
|
|
:param uri: open api uri
|
|
:type uri: string
|
|
:param params: dict
|
|
:type params:request params
|
|
:param body: request body (default: None)
|
|
:type body: string
|
|
:param method: http method (default GET)
|
|
:type method: http_methods
|
|
:param config: None
|
|
:type config: baidubce.BceClientConfiguration
|
|
|
|
:return:
|
|
:rtype: baidubce.bce_response.BceResponse
|
|
"""
|
|
response = self._send_request(
|
|
http_method=method,
|
|
path=uri,
|
|
params=params,
|
|
body=body,
|
|
headers={b'x-app-id': app_id},
|
|
config=config
|
|
)
|
|
|
|
if response.body:
|
|
return response.body.decode("utf-8")
|
|
else:
|
|
return response
|
|
|
|
@staticmethod
|
|
def _merge_config(self, config):
|
|
if config is None:
|
|
return self.config
|
|
else:
|
|
new_config = copy.copy(self.config)
|
|
new_config.merge_non_none_values(config)
|
|
return new_config
|
|
|
|
def _send_request(
|
|
self, http_method, path,
|
|
body=None, headers=None, params=None,
|
|
config=None):
|
|
config = self._merge_config(self, config)
|
|
headers[b'x-bce-request-id'] = uuid.uuid4()
|
|
headers[b'Content-Type'] = b'application/json;charset=utf-8'
|
|
|
|
return bce_http_client.send_request(
|
|
config, sign_wrapper([b'host', b'x-bce-date', b'x-bce-request-id', b'x-app-id']),
|
|
[handler.parse_error, parse_none],
|
|
http_method, path, body, headers, params)
|
|
|
|
|
|
def sign_wrapper(headers_to_sign):
|
|
"""wrapper the bce_v1_signer.sign()."""
|
|
|
|
def _wrapper(credentials, http_method, path, headers, params):
|
|
return bce_v1_signer.sign(credentials, http_method, path, headers, params,
|
|
headers_to_sign=headers_to_sign)
|
|
|
|
return _wrapper
|
|
|
|
|
|
def parse_none(http_response, response):
|
|
"""If the body is not empty, convert it to a python object and set as the value of
|
|
response.body. http_response is always closed if no error occurs.
|
|
|
|
:param http_response: the http_response object returned by HTTPConnection.getresponse()
|
|
:type http_response: httplib.HTTPResponse
|
|
|
|
:param response: general response object which will be returned to the caller
|
|
:type response: baidubce.BceResponse
|
|
|
|
:return: always true
|
|
:rtype bool
|
|
"""
|
|
body = http_response.read()
|
|
if body:
|
|
response.body = body
|
|
http_response.close()
|
|
return True
|