async def _create_credential_async(self, url=None):
tea_request = TeaRequest()
tea_request.headers[
'host'] = url if url else self.__metadata_service_host
if not url:
tea_request.pathname = self.__url_in_ecs_metadata + self.role_name
# request
response = await TeaCore.async_do_action(tea_request)
if response.status_code != 200:
raise CredentialException(self.__ecs_metadata_fetch_error_msg +
" HttpCode=" + str(response.status_code))
dic = json.loads(response.body.decode('utf-8'))
content_code = dic.get('Code')
content_access_key_id = dic.get('AccessKeyId')
content_access_key_secret = dic.get('AccessKeySecret')
content_security_token = dic.get('SecurityToken')
content_expiration = dic.get('Expiration')
if content_code != "Success":
raise CredentialException(self.__ecs_metadata_fetch_error_msg)
# 先转换为时间数组
time_array = time.strptime(content_expiration, "%Y-%m-%dT%H:%M:%SZ")
# 转换为时间戳
time_stamp = calendar.timegm(time_array)
return credentials.EcsRamRoleCredential(content_access_key_id,
content_access_key_secret,
content_security_token,
time_stamp, self)
def test_do_action(self):
request = TeaRequest()
request.headers['host'] = "www.alibabacloud.com"
request.pathname = "/s/zh"
request.query["k"] = "ecs"
option = {
"readTimeout": 20000,
"connectTimeout": 10000,
"httpProxy": None,
"httpsProxy": None,
"noProxy": None,
"maxIdleConns": None,
"retry": {
"retryable": None,
"maxAttempts": None
},
"backoff": {
"policy": None,
"period": None
},
'debug': 'sdk',
"ignoreSSL": None
}
resp = TeaCore.do_action(request, option)
self.assertTrue(resp.headers.get('server'))
self.assertIsNotNone(bytes.decode(resp.body))
option['httpProxy'] = '127.0.0.1'
option['httpsProxy'] = '127.0.0.1'
option['noProxy'] = '127.0.0.1'
try:
TeaCore.do_action(request, option)
assert False
except Exception as e:
self.assertIsInstance(e, RetryError)
def test_get_signature(self):
request = TeaRequest()
request.pathname = '/test/a/b'
request.query = {
'key': 'test'
}
request.headers = {
'content-md5': '098f6bcd4621d373cade4e832627b4f6'
}
result = OpensearchUtil.get_signature(request, 'AccessKeyId', 'AccessKeySecret')
self.assertEqual('OPENSEARCH AccessKeyId:Puo3jkoIu0S1F8x3jHDxSpNhnQU=', result)
async def _get_role_name_async(self, url=None):
tea_request = TeaRequest()
tea_request.headers[
'host'] = url if url else self.__metadata_service_host
if not url:
tea_request.pathname = self.__url_in_ecs_metadata
response = await TeaCore.async_do_action(tea_request)
if response.status_code != 200:
raise CredentialException(self.__ecs_metadata_fetch_error_msg +
" HttpCode=" + str(response.status_code))
self.role_name = response.body.decode('utf-8')
def test_init(self):
request = TeaRequest()
self.assertEqual({}, request.query)
self.assertEqual({}, request.headers)
self.assertEqual('http', request.protocol)
self.assertEqual(80, request.port)
self.assertEqual('GET', request.method)
self.assertEqual("", request.pathname)
self.assertEqual(None, request.body)
request.query = None
self.assertEqual({}, request.query)
def test_get_signature_v2(self):
request = TeaRequest()
signature = Client.get_signature(request, "bucket", "accessKeyId",
"accessKeySecret", "v2", None)
self.assertEqual(
"OSS2 AccessKeyId:accessKeyId,Signature:61mT0P8eZxBI5cfj7YfqctSz4Zwtp0sltgTS5JZZc1M=",
signature)
request = TeaRequest()
request.pathname = 'test?aa'
request.headers = {
'x-oss-test': 'test',
'content-type': 'type',
'content-md5': 'md5',
}
request.query = {
'testQuery': 'testQuery',
'queryKey': 'queryValue',
"x-oss-test": "test"
}
res = Client.get_signature(request, 'test', 'ak', 'sk', 'v2',
['headers', 'sign2'])
self.assertEqual(
'OSS2 AccessKeyId:ak,AdditionalHeaders:headers;'
'sign2,Signature:l8RDYSFtqTP0NhyoTyrRqAtrnUO6lCjrOF/MK2zV0nU=',
res)
request.pathname = 'test?zz'
res = Client.get_signature(request, 'test', 'ak', 'sk', 'v2',
['headers'])
self.assertEqual(
'OSS2 AccessKeyId:ak,AdditionalHeaders:headers,Signature:kbg4BGoZbDGm2OBRt1kOTh9z6dToFSg1L55PXTmGdQw=',
res)
def test_get_authorization(self):
# request method is 'GET'
request = TeaRequest()
request.query = {'test': 'ok', 'empty': ''}
request.headers = {'x-acs-test': 'http', 'x-acs-TEST': 'https'}
res = Client.get_authorization(
request, 'ACS3-HMAC-SHA256',
'55e12e91650d2fec56ec74e1d3e4ddbfce2ef3a65890c2a19ecf88a307e76a23',
'acesskey', 'secret')
self.assertEqual(
'ACS3-HMAC-SHA256 Credential=acesskey,SignedHea'
'ders=x-acs-test,Signature=d16b30a7699ae9e43875b13195b2f81bcc3ed10c14a9b5eb780e51619aa50be1',
res)
def test_get_authorization(self):
# request method is 'GET'
request = TeaRequest()
request.query = {'test': 'ok', 'empty': ''}
request.headers = {'x-acs-test': 'http', 'x-acs-TEST': 'https'}
res = Client.get_authorization(
request, 'ACS3-HMAC-SHA256',
'55e12e91650d2fec56ec74e1d3e4ddbfce2ef3a65890c2a19ecf88a307e76a23',
'acesskey', 'secret')
self.assertEqual(
'ACS3-HMAC-SHA256 Credential=acesskey,SignedHea'
'ders=x-acs-test,Signature=910e59dd385879346de704a06c96613f8157aa7124e6d1c4f2bdffa1e5588187',
res)
def test_get_signature_v1(self):
request = TeaRequest()
request.headers = {
'x-oss-test': 'test',
'content-type': 'type',
'content-md5': 'md5'
}
request.query = {
'testQuery': 'testQuery',
'queryKey': 'queryValue',
'x-oss-process': 'value',
'location': 'test'
}
res = Client.get_signature(request, 'test', "ak", "sk", "v1", None)
self.assertEqual('OSS ak:EutyeRVaRDNJSPiaBHmN/Cip8lw=', res)
res = Client.get_signature(request, 'test', "ak", "sk", None, None)
self.assertEqual('OSS ak:EutyeRVaRDNJSPiaBHmN/Cip8lw=', res)
def test_get_signature(self):
request = TeaRequest()
request.pathname = "/test"
request.method = "GET"
signedStr = Client.get_signature("accessKeyId", "accessKeySecret",
request, "/version")
self.assertEqual(
"FC accessKeyId:tvvm2KiUDmXlQiuwz21CtN59JcKTT5QzIcrc122DKVo=",
signedStr)
header = {}
header["x-fc-test"] = "test"
request.headers = header
signedStr = Client.get_signature("accessKeyId", "accessKeySecret",
request, "/version")
self.assertEqual(
"FC accessKeyId:lP6dXPCXlQNI7VY+f0brnZ4bwluNvGqcwdDf5GoM9ag=",
signedStr)
query = {}
query["testQuery"] = "test"
request.query = query
request.pathname = "/version/proxy/"
signedStr = Client.get_signature("accessKeyId", "accessKeySecret",
request, "/version")
self.assertEqual(
"FC accessKeyId:aCD88kzuMQYKQGo7kq7DeqhT72nVrNSEqAJtiHNj9L0=",
signedStr)
def test_unretryable_exception(self):
request = TeaRequest()
ex = Exception()
ex.message = "test exception"
try:
raise UnretryableException(request, ex)
except UnretryableException as e:
self.assertIsNotNone(e)
self.assertIsNotNone(e.last_request)
self.assertEqual("Retry failed:test exception", e.message)
def _create_credential(self, turl=None):
tea_request = TeaRequest()
tea_request.query = {
'Action': 'GenerateSessionAccessKey',
'Format': 'JSON',
'Version': '2015-04-01',
'DurationSeconds': str(self.duration_seconds),
'AccessKeyId': self.access_key_id,
'RegionId': self.region_id,
}
str_to_sign = ph.compose_string_to_sign('GET', tea_request.query)
signature = ph.sign_string(str_to_sign, self.access_key_id + '&')
tea_request.query['Signature'] = signature
tea_request.protocol = 'https'
tea_request.headers['host'] = turl if turl else 'sts.aliyuncs.com'
# request
response = TeaCore.do_action(tea_request)
if response.status_code == 200:
dic = json.loads(response.body.decode('utf-8'))
if "SessionAccessKey" in dic:
cre = dic.get("SessionAccessKey")
time_array = time.strptime(cre.get("Expiration"),
"%Y-%m-%dT%H:%M:%SZ")
expiration = calendar.timegm(time_array)
return credentials.RsaKeyPairCredential(
cre.get("SessionAccessKeyId"),
cre.get("SessionAccessKeySecret"), expiration, self)
raise CredentialException(response.body.decode('utf-8'))
def __refresh_access_token(self):
tea_request = TeaRequest()
tea_request.method = "POST"
tea_request.pathname = "/v2/oauth/token"
headers = {
"host": self.__get_host(self.__endpoint, self.__domain_id + ".api.alicloudccp.com"),
"content-type": "application/x-www-form-urlencoded; charset=utf-8",
"date": datetime.utcnow().strftime('%a, %d %b %Y %H:%M:%S GMT'),
"accept": "application/json",
"x-acs-signature-method": "HMAC-SHA1",
"x-acs-signature-version": "1.0"
}
tea_request.headers = headers
body_str = "grant_type=refresh_token&refresh_token={0}&client_id={1}&client_secret={2}".format(
self.__refresh_token, self.__client_id, self.__client_secret)
tea_request.body = bytes(body_str, encoding="utf-8")
response = TeaCore.do_action(tea_request)
dic = json.loads(str(response.body, encoding="utf-8"))
if 400 <= response.status_code < 600:
raise TeaException({
"code": str(dic.get('code')) + "Error",
"message": "code: " + str(response.status_code) + ", " + str(dic.get('message')) +
" requestid: " + str(dic.get('requestId')),
"data": dic
})
else:
self.__expire_time = dic.get("expire_time")
self.__access_token = dic.get("access_token")
self.__refresh_token = dic.get("refresh_token")
def refresh_access_token(self):
tea_request = TeaRequest()
tea_request.method = "POST"
tea_request.pathname = "/v2/oauth/token"
headers = {
"host":
self._endpoint if self._endpoint else self._domain_id +
".api.aliyunpds.com",
"content-type":
"application/x-www-form-urlencoded; charset=utf-8",
"date":
datetime.datetime.utcnow().strftime('%a, %d %b %Y %H:%M:%S GMT'),
"accept":
"application/json",
"x-acs-signature-method":
"HMAC-SHA1",
"x-acs-signature-version":
"1.0"
}
tea_request.headers = headers
body_str = "grant_type=refresh_token&refresh_token={0}&client_id={1}&client_secret={2}".format(
self._refresh_token, self._client_id, self._client_secret)
tea_request.body = bytes(body_str, encoding="utf-8")
response = TeaCore.do_action(tea_request)
dic = json.loads(str(response.body, encoding="utf-8"))
if response.status_code == 200:
self._expire_time = dic.get("expire_time")
self._access_token = dic.get("access_token")
self._refresh_token = dic.get("refresh_token")
else:
raise TeaException(dic)
def test_do_action(self):
request = TeaRequest()
request.headers['host'] = "www.alibabacloud.com"
request.pathname = "/s/zh"
request.query["k"] = "ecs"
option = {
"readTimeout": 0,
"connectTimeout": 0,
"httpProxy": None,
"httpsProxy": None,
"noProxy": None,
"maxIdleConns": None,
"retry": {
"retryable": None,
"maxAttempts": None
},
"backoff": {
"policy": None,
"period": None
},
"ignoreSSL": None
}
resp = TeaCore.do_action(request, option)
self.assertIsNotNone(bytes.decode(resp.body))
def test_async_stream_upload(self):
request = TeaRequest()
request.method = 'POST'
request.protocol = 'http'
request.headers['host'] = "127.0.0.1:8888"
loop = asyncio.get_event_loop()
task = asyncio.ensure_future(TeaCore.async_do_action(request))
f = TeaStream()
request.body = f
loop.run_until_complete(task)
self.assertEqual(b'{"result": "tea test"}', task.result().body)
def test_unretryable_exception(self):
request = TeaRequest()
ex = RetryError("test exception")
try:
raise UnretryableException(request, ex)
except UnretryableException as e:
self.assertIsNotNone(e)
self.assertIsNotNone(e.last_request)
self.assertEqual("test exception", str(e.inner_exception))
e = TeaException({
'code': 'error code',
'message': 'error message',
'data': 'data',
})
try:
raise UnretryableException(request, e)
except UnretryableException as e:
self.assertEqual('Error: error code error message Response: data', str(e))
self.assertEqual('error code', e.inner_exception.code)
self.assertEqual('error message', e.inner_exception.message)
self.assertEqual('data', e.inner_exception.data)
def test_async_do_action(self):
request = TeaRequest()
request.headers['host'] = "www.alibabacloud.com"
request.protocol = 'https'
request.pathname = "/s/zh"
request.query["k"] = "ecs"
option = {
"readTimeout": 20000,
"connectTimeout": 10000,
"httpProxy": None,
"httpsProxy": None,
"noProxy": None,
"maxIdleConns": None,
"retry": {
"retryable": None,
"maxAttempts": None
},
"backoff": {
"policy": None,
"period": None
},
"ignoreSSL": None
}
loop = asyncio.get_event_loop()
task = asyncio.ensure_future(TeaCore.async_do_action(request, option))
loop.run_until_complete(task)
response = task.result()
self.assertTrue(response.headers.get('server'))
self.assertIsNotNone(bytes.decode(response.body))
request.protocol = 'http'
option['httpProxy'] = 'http://127.0.0.1'
try:
loop.run_until_complete(TeaCore.async_do_action(request, option))
assert False
except Exception as e:
self.assertIsInstance(e, RetryError)
async def _create_credentials_async(self, turl=None):
# 获取credential 先实现签名用工具类
tea_request = TeaRequest()
tea_request.query = {
'Action': 'AssumeRole',
'Format': 'JSON',
'Version': '2015-04-01',
'DurationSeconds': str(self.duration_seconds),
'RoleArn': self.role_arn,
'AccessKeyId': self.access_key_id,
'RegionId': self.region_id,
'RoleSessionName': self.role_session_name
}
if self.policy is not None:
tea_request.query["Policy"] = self.policy
string_to_sign = ph.compose_string_to_sign("GET", tea_request.query)
signature = ph.sign_string(string_to_sign,
self.access_key_secret + "&")
tea_request.query["Signature"] = signature
tea_request.protocol = 'https'
tea_request.headers['host'] = turl if turl else 'sts.aliyuncs.com'
# request
response = await TeaCore.async_do_action(tea_request)
if response.status_code == 200:
dic = json.loads(response.body.decode('utf-8'))
if "Credentials" in dic:
cre = dic.get("Credentials")
# 先转换为时间数组
time_array = time.strptime(cre.get("Expiration"),
"%Y-%m-%dT%H:%M:%SZ")
# 转换为时间戳
expiration = calendar.timegm(time_array)
return credentials.RamRoleArnCredential(
cre.get("AccessKeyId"), cre.get("AccessKeySecret"),
cre.get("SecurityToken"), expiration, self)
raise CredentialException(response.body.decode('utf-8'))
def execute(self, params, request, runtime):
"""
Encapsulate the request and invoke the network
@param action: api name
@param version: product version
@param protocol: http or https
@param method: e.g. GET
@param auth_type: authorization type e.g. AK
@param body_type: response body type e.g. String
@param request: object of OpenApiRequest
@param runtime: which controls some details of call api, such as retry times
@rtype: dict
@return: the response
"""
params.validate()
request.validate()
runtime.validate()
_runtime = {
'timeouted': 'retry',
'readTimeout': UtilClient.default_number(runtime.read_timeout, self._read_timeout),
'connectTimeout': UtilClient.default_number(runtime.connect_timeout, self._connect_timeout),
'httpProxy': UtilClient.default_string(runtime.http_proxy, self._http_proxy),
'httpsProxy': UtilClient.default_string(runtime.https_proxy, self._https_proxy),
'noProxy': UtilClient.default_string(runtime.no_proxy, self._no_proxy),
'socks5Proxy': UtilClient.default_string(runtime.socks_5proxy, self._socks_5proxy),
'socks5NetWork': UtilClient.default_string(runtime.socks_5net_work, self._socks_5net_work),
'maxIdleConns': UtilClient.default_number(runtime.max_idle_conns, self._max_idle_conns),
'retry': {
'retryable': runtime.autoretry,
'maxAttempts': UtilClient.default_number(runtime.max_attempts, 3)
},
'backoff': {
'policy': UtilClient.default_string(runtime.backoff_policy, 'no'),
'period': UtilClient.default_number(runtime.backoff_period, 1)
},
'ignoreSSL': runtime.ignore_ssl
}
_last_request = None
_last_exception = None
_now = time.time()
_retry_times = 0
while TeaCore.allow_retry(_runtime.get('retry'), _retry_times, _now):
if _retry_times > 0:
_backoff_time = TeaCore.get_backoff_time(_runtime.get('backoff'), _retry_times)
if _backoff_time > 0:
TeaCore.sleep(_backoff_time)
_retry_times = _retry_times + 1
try:
_request = TeaRequest()
# spi = new Gateway();//Gateway implements SPI，这一步在产品 SDK 中实例化
headers = self.get_rpc_headers()
request_context = spi_models.InterceptorContextRequest(
headers=TeaCore.merge(request.headers,
headers),
query=request.query,
body=request.body,
stream=request.stream,
host_map=request.host_map,
pathname=params.pathname,
product_id=self._product_id,
action=params.action,
version=params.version,
protocol=UtilClient.default_string(self._protocol, params.protocol),
method=UtilClient.default_string(self._method, params.method),
auth_type=params.auth_type,
body_type=params.body_type,
req_body_type=params.req_body_type,
style=params.style,
credential=self._credential,
signature_version=self._signature_version,
signature_algorithm=self._signature_algorithm,
user_agent=self.get_user_agent()
)
configuration_context = spi_models.InterceptorContextConfiguration(
region_id=self._region_id,
endpoint=UtilClient.default_string(request.endpoint_override, self._endpoint),
endpoint_rule=self._endpoint_rule,
endpoint_map=self._endpoint_map,
endpoint_type=self._endpoint_type,
network=self._network,
suffix=self._suffix
)
interceptor_context = spi_models.InterceptorContext(
request=request_context,
configuration=configuration_context
)
attribute_map = spi_models.AttributeMap()
# 1. spi.modifyConfiguration(context: SPI.InterceptorContext, attributeMap: SPI.AttributeMap);
self._spi.modify_configuration(interceptor_context, attribute_map)
# 2. spi.modifyRequest(context: SPI.InterceptorContext, attributeMap: SPI.AttributeMap);
self._spi.modify_request(interceptor_context, attribute_map)
_request.protocol = interceptor_context.request.protocol
_request.method = interceptor_context.request.method
_request.pathname = interceptor_context.request.pathname
_request.query = interceptor_context.request.query
_request.body = interceptor_context.request.stream
_request.headers = interceptor_context.request.headers
_last_request = _request
_response = TeaCore.do_action(_request, _runtime)
response_context = spi_models.InterceptorContextResponse(
status_code=_response.status_code,
headers=_response.headers,
body=_response.body
)
interceptor_context.response = response_context
# 3. spi.modifyResponse(context: SPI.InterceptorContext, attributeMap: SPI.AttributeMap);
self._spi.modify_response(interceptor_context, attribute_map)
return {
'headers': interceptor_context.response.headers,
'statusCode': interceptor_context.response.status_code,
'body': interceptor_context.response.deserialized_body
}
except Exception as e:
if TeaCore.is_retryable(e):
_last_exception = e
continue
raise e
raise UnretryableException(_last_request, _last_exception)
def test_get_roa_signature(self):
request = TeaRequest()
str_to_sign = Client.get_string_to_sign(request)
signature = Client.get_roasignature(str_to_sign, 'secret')
self.assertEqual('GET\n\n\n\n\n', str_to_sign)
self.assertEqual('XGXDWA78AEvx/wmfxKoVCq/afWw=', signature)
def test_get_string_to_sign(self):
request = TeaRequest()
str_to_sign = Client.get_string_to_sign(request)
self.assertEqual('GET\n\n\n\n\n', str_to_sign)
request = TeaRequest()
request.method = "POST"
request.query = {'test': 'tests'}
str_to_sign = Client.get_string_to_sign(request)
self.assertEqual('POST\n\n\n\n\n?test=tests', str_to_sign)
request = TeaRequest()
request.headers = {
'content-md5': 'md5',
}
str_to_sign = Client.get_string_to_sign(request)
self.assertEqual('GET\n\nmd5\n\n\n', str_to_sign)
request = TeaRequest()
request.pathname = "Pathname"
request.query = {
'ccp': 'ok',
'test': 'tests',
'test1': '',
'test2': '中文'
}
request.headers = {
'x-acs-meta': 'user',
"accept": "application/json",
'content-md5': 'md5',
'content-type': 'application/json',
'date': 'date'
}
str_to_sign = Client.get_string_to_sign(request)
s = u'GET\napplication/json\nmd5\napplication/json\ndate\nx-acs-meta:user\nPathname?ccp=ok&test=tests&test1&test2=中文'
self.assertEqual(s, str_to_sign)
def do_request(
self,
version: str,
action: str,
protocol: str,
method: str,
pathname: str,
request: dict,
headers: Dict[str, str],
runtime: util_models.RuntimeOptions,
) -> dict:
"""
Encapsulate the request and invoke the network
@param action: api name
@param protocol: http or https
@param method: e.g. GET
@param pathname: pathname of every api
@param request: which contains request params
@param runtime: which controls some details of call api, such as retry times
@return: the response
"""
runtime.validate()
_runtime = {
'timeouted':
'retry',
'readTimeout':
UtilClient.default_number(runtime.read_timeout,
self._read_timeout),
'connectTimeout':
UtilClient.default_number(runtime.connect_timeout,
self._connect_timeout),
'httpProxy':
UtilClient.default_string(runtime.http_proxy, self._http_proxy),
'httpsProxy':
UtilClient.default_string(runtime.https_proxy, self._https_proxy),
'noProxy':
UtilClient.default_string(runtime.no_proxy, self._no_proxy),
'maxIdleConns':
UtilClient.default_number(runtime.max_idle_conns,
self._max_idle_conns),
'maxIdleTimeMillis':
self._max_idle_time_millis,
'keepAliveDurationMillis':
self._keep_alive_duration_millis,
'maxRequests':
self._max_requests,
'maxRequestsPerHost':
self._max_requests_per_host,
'retry': {
'retryable': runtime.autoretry,
'maxAttempts':
UtilClient.default_number(runtime.max_attempts, 3)
},
'backoff': {
'policy': UtilClient.default_string(runtime.backoff_policy,
'no'),
'period': UtilClient.default_number(runtime.backoff_period, 1)
},
'ignoreSSL':
runtime.ignore_ssl
}
_last_request = None
_last_exception = None
_now = time.time()
_retry_times = 0
while TeaCore.allow_retry(_runtime.get('retry'), _retry_times, _now):
if _retry_times > 0:
_backoff_time = TeaCore.get_backoff_time(
_runtime.get('backoff'), _retry_times)
if _backoff_time > 0:
TeaCore.sleep(_backoff_time)
_retry_times = _retry_times + 1
try:
_request = TeaRequest()
_request.protocol = UtilClient.default_string(
self._protocol, protocol)
_request.method = method
_request.pathname = pathname
_request.query = {
'method': action,
'version': version,
'sign_type': 'HmacSHA1',
'req_time': AntchainUtils.get_timestamp(),
'req_msg_id': AntchainUtils.get_nonce(),
'access_key': self._access_key_id,
'base_sdk_version': 'TeaSDK-2.0',
'sdk_version': '1.1.8'
}
if not UtilClient.empty(self._security_token):
_request.query['security_token'] = self._security_token
_request.headers = TeaCore.merge(
{
'host':
UtilClient.default_string(
self._endpoint, 'openapi.antchain.antgroup.com'),
'user-agent':
UtilClient.get_user_agent(self._user_agent)
}, headers)
tmp = UtilClient.anyify_map_value(RPCUtilClient.query(request))
_request.body = UtilClient.to_form_string(tmp)
_request.headers[
'content-type'] = 'application/x-www-form-urlencoded'
signed_param = TeaCore.merge(_request.query,
RPCUtilClient.query(request))
_request.query['sign'] = AntchainUtils.get_signature(
signed_param, self._access_key_secret)
_last_request = _request
_response = TeaCore.do_action(_request, _runtime)
raw = UtilClient.read_as_string(_response.body)
obj = UtilClient.parse_json(raw)
res = UtilClient.assert_as_map(obj)
resp = UtilClient.assert_as_map(res.get('response'))
if AntchainUtils.has_error(raw, self._access_key_secret):
raise TeaException({
'message': resp.get('result_msg'),
'data': resp,
'code': resp.get('result_code')
})
return resp
except Exception as e:
if TeaCore.is_retryable(e):
_last_exception = e
continue
raise e
raise UnretryableException(_last_request, _last_exception)
def do_request(self, version, action, protocol, method, pathname, request, runtime):
"""
Encapsulate the request and invoke the network
:type action: str
:param action: api name
:type protocol: str
:param protocol: http or https
:type method: str
:param method: e.g. GET
:type pathname: str
:param pathname: pathname of every api
:type request: dict
:param request: which contains request params
:param runtime: which controls some details of call api, such as retry times
:return: the response
"""
runtime.validate()
_runtime = {
"timeouted": "retry",
"readTimeout": UtilClient.default_number(runtime.read_timeout, self._read_timeout),
"connectTimeout": UtilClient.default_number(runtime.connect_timeout, self._connect_timeout),
"httpProxy": UtilClient.default_string(runtime.http_proxy, self._http_proxy),
"httpsProxy": UtilClient.default_string(runtime.https_proxy, self._https_proxy),
"noProxy": UtilClient.default_string(runtime.no_proxy, self._no_proxy),
"maxIdleConns": UtilClient.default_number(runtime.max_idle_conns, self._max_idle_conns),
"retry": {
"retryable": runtime.autoretry,
"maxAttempts": UtilClient.default_number(runtime.max_attempts, 3)
},
"backoff": {
"policy": UtilClient.default_string(runtime.backoff_policy, "no"),
"period": UtilClient.default_number(runtime.backoff_period, 1)
},
"ignoreSSL": runtime.ignore_ssl
}
_last_request = None
_last_exception = None
_now = time.time()
_retry_times = 0
while TeaCore.allow_retry(_runtime.get('retry'), _retry_times, _now):
if _retry_times > 0:
_backoff_time = TeaCore.get_backoff_time(_runtime.get('backoff'), _retry_times)
if _backoff_time > 0:
TeaCore.sleep(_backoff_time)
_retry_times = _retry_times + 1
try:
_request = TeaRequest()
_request.protocol = UtilClient.default_string(self._protocol, protocol)
_request.method = method
_request.pathname = pathname
_request.query = {
"method": action,
"version": version,
"sign_type": "HmacSHA1",
"req_time": AlipayUtilClient.get_timestamp(),
"req_msg_id": UtilClient.get_nonce(),
"access_key": self._access_key_id,
"charset": "UTF-8",
"baseSdkVersion": "Tea-SDK",
"sdkVersion": "Tea-SDK-20200804"
}
if not UtilClient.empty(self._security_token):
_request.query["security_token"] = self._security_token
_request.headers = {
"host": self._endpoint,
"user-agent": self.get_user_agent()
}
tmp = UtilClient.anyify_map_value(RPCUtilClient.query(request))
_request.body = UtilClient.to_form_string(tmp)
_request.headers["content-type"] = "application/x-www-form-urlencoded"
signed_param = TeaCore.merge(_request.query,
RPCUtilClient.query(request))
_request.query["sign"] = AlipayUtilClient.get_signature(signed_param, self._access_key_secret)
_last_request = _request
_response = TeaCore.do_action(_request, _runtime)
obj = UtilClient.read_as_json(_response.body)
res = UtilClient.assert_as_map(obj)
resp = UtilClient.assert_as_map(res.get('response'))
if AlipayUtilClient.has_error(res):
raise TeaException({
"message": resp.get('result_msg'),
"data": resp,
"code": resp.get('result_code')
})
return resp
except Exception as e:
if TeaCore.is_retryable(e):
_last_exception = e
continue
raise e
raise UnretryableException(_last_request, _last_exception)
def test_get_signature(self):
request = TeaRequest()
request.method = 'test'
request.headers['accept'] = 'json'
request.headers['date'] = 'now'
request.pathname = 'test'
self.assertEqual('lzttujz/sOhS2QSBBSZBq58ZNSxvSDdkWWlknQxnrt0=',
Client.get_signature(request, 'sk'))
request.headers['content-md5'] = 'md5'
request.headers['content-type'] = 'type'
self.assertEqual('HcjhFWjGB9Xyitos6CHnJvwQoPQzdPUBgv5oUd0tdoA=',
Client.get_signature(request, 'sk'))
request = TeaRequest()
request.headers['testKey'] = 'value'
request.headers['testNull'] = None
self.assertEqual('6iwWMKFM5HOmBuRm8Xb4i/bv3Zrd8eP0qSoO3iZiSG4=',
Client.get_signature(request, 'sk'))
request = TeaRequest()
request.pathname = 'test'
request.query['testKey'] = 'value'
self.assertEqual('A9g2VbnkB+GS+nyiKTIqSruJvxrgZ9rgot6wVPFbewk=',
Client.get_signature(request, 'sk'))
def test_get_signature(self):
request = TeaRequest()
str_to_sign = Client.get_string_to_sign(request)
signature = Client.get_signature(str_to_sign, 'secret')
self.assertEqual('GET\n\n\n\n', str_to_sign)
self.assertEqual('Mzu+31oD5IDdv3WFBNIi4Y7JZto=', signature)
def do_rpcrequest(self, action, version, protocol, method, auth_type, body_type, request, runtime):
"""
Encapsulate the request and invoke the network
@type action: str
@param action: api name
@type version: str
@param version: product version
@type protocol: str
@param protocol: http or https
@type method: str
@param method: e.g. GET
@type auth_type: str
@param auth_type: authorization type e.g. AK
@type body_type: str
@param body_type: response body type e.g. String
@param request: object of OpenApiRequest
@param runtime: which controls some details of call api, such as retry times
@rtype: dict
@return: the response
"""
request.validate()
runtime.validate()
_runtime = {
'timeouted': 'retry',
'readTimeout': UtilClient.default_number(runtime.read_timeout, self._read_timeout),
'connectTimeout': UtilClient.default_number(runtime.connect_timeout, self._connect_timeout),
'httpProxy': UtilClient.default_string(runtime.http_proxy, self._http_proxy),
'httpsProxy': UtilClient.default_string(runtime.https_proxy, self._https_proxy),
'noProxy': UtilClient.default_string(runtime.no_proxy, self._no_proxy),
'socks5Proxy': UtilClient.default_string(runtime.socks_5proxy, self._socks_5proxy),
'socks5NetWork': UtilClient.default_string(runtime.socks_5net_work, self._socks_5net_work),
'maxIdleConns': UtilClient.default_number(runtime.max_idle_conns, self._max_idle_conns),
'retry': {
'retryable': runtime.autoretry,
'maxAttempts': UtilClient.default_number(runtime.max_attempts, 3)
},
'backoff': {
'policy': UtilClient.default_string(runtime.backoff_policy, 'no'),
'period': UtilClient.default_number(runtime.backoff_period, 1)
},
'ignoreSSL': runtime.ignore_ssl
}
_last_request = None
_last_exception = None
_now = time.time()
_retry_times = 0
while TeaCore.allow_retry(_runtime.get('retry'), _retry_times, _now):
if _retry_times > 0:
_backoff_time = TeaCore.get_backoff_time(_runtime.get('backoff'), _retry_times)
if _backoff_time > 0:
TeaCore.sleep(_backoff_time)
_retry_times = _retry_times + 1
try:
_request = TeaRequest()
_request.protocol = UtilClient.default_string(self._protocol, protocol)
_request.method = method
_request.pathname = '/'
_request.query = TeaCore.merge({
'Action': action,
'Format': 'json',
'Version': version,
'Timestamp': OpenApiUtilClient.get_timestamp(),
'SignatureNonce': UtilClient.get_nonce()
}, request.query)
headers = self.get_rpc_headers()
if UtilClient.is_unset(headers):
# endpoint is setted in product client
_request.headers = {
'host': self._endpoint,
'x-acs-version': version,
'x-acs-action': action,
'user-agent': self.get_user_agent()
}
else:
_request.headers = TeaCore.merge({
'host': self._endpoint,
'x-acs-version': version,
'x-acs-action': action,
'user-agent': self.get_user_agent()
}, headers)
if not UtilClient.is_unset(request.body):
m = UtilClient.assert_as_map(request.body)
tmp = UtilClient.anyify_map_value(OpenApiUtilClient.query(m))
_request.body = UtilClient.to_form_string(tmp)
_request.headers['content-type'] = 'application/x-www-form-urlencoded'
if not UtilClient.equal_string(auth_type, 'Anonymous'):
access_key_id = self.get_access_key_id()
access_key_secret = self.get_access_key_secret()
security_token = self.get_security_token()
if not UtilClient.empty(security_token):
_request.query['SecurityToken'] = security_token
_request.query['SignatureMethod'] = 'HMAC-SHA1'
_request.query['SignatureVersion'] = '1.0'
_request.query['AccessKeyId'] = access_key_id
t = None
if not UtilClient.is_unset(request.body):
t = UtilClient.assert_as_map(request.body)
signed_param = TeaCore.merge(_request.query,
OpenApiUtilClient.query(t))
_request.query['Signature'] = OpenApiUtilClient.get_rpcsignature(signed_param, _request.method, access_key_secret)
_last_request = _request
_response = TeaCore.do_action(_request, _runtime)
if UtilClient.is_4xx(_response.status_code) or UtilClient.is_5xx(_response.status_code):
_res = UtilClient.read_as_json(_response.body)
err = UtilClient.assert_as_map(_res)
request_id = self.default_any(err.get('RequestId'), err.get('requestId'))
raise TeaException({
'code': '%s' % TeaConverter.to_unicode(self.default_any(err.get('Code'), err.get('code'))),
'message': 'code: %s, %s request id: %s' % (TeaConverter.to_unicode(_response.status_code), TeaConverter.to_unicode(self.default_any(err.get('Message'), err.get('message'))), TeaConverter.to_unicode(request_id)),
'data': err
})
if UtilClient.equal_string(body_type, 'binary'):
resp = {
'body': _response.body,
'headers': _response.headers
}
return resp
elif UtilClient.equal_string(body_type, 'byte'):
byt = UtilClient.read_as_bytes(_response.body)
return {
'body': byt,
'headers': _response.headers
}
elif UtilClient.equal_string(body_type, 'string'):
str = UtilClient.read_as_string(_response.body)
return {
'body': str,
'headers': _response.headers
}
elif UtilClient.equal_string(body_type, 'json'):
obj = UtilClient.read_as_json(_response.body)
res = UtilClient.assert_as_map(obj)
return {
'body': res,
'headers': _response.headers
}
elif UtilClient.equal_string(body_type, 'array'):
arr = UtilClient.read_as_json(_response.body)
return {
'body': arr,
'headers': _response.headers
}
else:
return {
'headers': _response.headers
}
except Exception as e:
if TeaCore.is_retryable(e):
_last_exception = e
continue
raise e
raise UnretryableException(_last_request, _last_exception)
def test_compose_url(self):
request = TeaRequest()
try:
TeaCore.compose_url(request)
except Exception as e:
self.assertEqual('"endpoint" is required.', str(e))
request.headers['host'] = "fake.domain.com"
self.assertEqual("http://fake.domain.com",
TeaCore.compose_url(request))
request.headers['host'] = "http://fake.domain.com"
self.assertEqual("http://fake.domain.com",
TeaCore.compose_url(request))
request.port = 8080
self.assertEqual("http://fake.domain.com:8080",
TeaCore.compose_url(request))
request.pathname = "/index.html"
self.assertEqual("http://fake.domain.com:8080/index.html",
TeaCore.compose_url(request))
request.query["foo"] = ""
self.assertEqual("http://fake.domain.com:8080/index.html?foo=",
TeaCore.compose_url(request))
request.query["foo"] = "bar"
self.assertEqual("http://fake.domain.com:8080/index.html?foo=bar",
TeaCore.compose_url(request))
request.pathname = "/index.html?a=b"
self.assertEqual("http://fake.domain.com:8080/index.html?a=b&foo=bar",
TeaCore.compose_url(request))
request.pathname = "/index.html?a=b&"
self.assertEqual("http://fake.domain.com:8080/index.html?a=b&foo=bar",
TeaCore.compose_url(request))
request.query["fake"] = None
self.assertEqual("http://fake.domain.com:8080/index.html?a=b&foo=bar",
TeaCore.compose_url(request))
def test_get_signature(self):
request = TeaRequest()
signature = Client.get_signature(request, "bucket", "accessKeyId",
"accessKeySecret", "v2", None)
self.assertEqual(
"OSS2 AccessKeyId:accessKeyId,Signature:61mT0P8eZxBI5cfj7YfqctSz4Zwtp0sltgTS5JZZc1M=",
signature)
request = TeaRequest()
request.pathname = 'test?aa'
request.headers = {
'x-oss-test': 'test',
'content-type': 'type',
'content-md5': 'md5',
}
request.query = {
'testQuery': 'testQuery',
'queryKey': 'queryValue',
"x-oss-test": "test"
}
res = Client.get_signature(request, 'test', 'ak', 'sk', 'v2', None)
self.assertEqual(
'OSS2 AccessKeyId:ak,Signature:QNGIXVU4Qg0dxuBmVaN8q//ceXf15fmdTEaIK7R3od4=',
res)
request = TeaRequest()
request.headers = {
'x-oss-test': 'test',
'content-type': 'type',
'content-md5': 'md5'
}
request.query = {
'testQuery': 'testQuery',
'queryKey': 'queryValue',
'x-oss-process': 'value'
}
res = Client.get_signature(request, 'test', "ak", "sk", "v1", None)
self.assertEqual('OSS ak:q9lSDGVH1VmpjMTGSwUZn3tg3J4=', res)
def do_request(self, params, request, runtime):
"""
Encapsulate the request and invoke the network
@param action: api name
@param version: product version
@param protocol: http or https
@param method: e.g. GET
@param auth_type: authorization type e.g. AK
@param body_type: response body type e.g. String
@param request: object of OpenApiRequest
@param runtime: which controls some details of call api, such as retry times
@rtype: dict
@return: the response
"""
params.validate()
request.validate()
runtime.validate()
_runtime = {
'timeouted': 'retry',
'readTimeout': UtilClient.default_number(runtime.read_timeout, self._read_timeout),
'connectTimeout': UtilClient.default_number(runtime.connect_timeout, self._connect_timeout),
'httpProxy': UtilClient.default_string(runtime.http_proxy, self._http_proxy),
'httpsProxy': UtilClient.default_string(runtime.https_proxy, self._https_proxy),
'noProxy': UtilClient.default_string(runtime.no_proxy, self._no_proxy),
'socks5Proxy': UtilClient.default_string(runtime.socks_5proxy, self._socks_5proxy),
'socks5NetWork': UtilClient.default_string(runtime.socks_5net_work, self._socks_5net_work),
'maxIdleConns': UtilClient.default_number(runtime.max_idle_conns, self._max_idle_conns),
'retry': {
'retryable': runtime.autoretry,
'maxAttempts': UtilClient.default_number(runtime.max_attempts, 3)
},
'backoff': {
'policy': UtilClient.default_string(runtime.backoff_policy, 'no'),
'period': UtilClient.default_number(runtime.backoff_period, 1)
},
'ignoreSSL': runtime.ignore_ssl
}
_last_request = None
_last_exception = None
_now = time.time()
_retry_times = 0
while TeaCore.allow_retry(_runtime.get('retry'), _retry_times, _now):
if _retry_times > 0:
_backoff_time = TeaCore.get_backoff_time(_runtime.get('backoff'), _retry_times)
if _backoff_time > 0:
TeaCore.sleep(_backoff_time)
_retry_times = _retry_times + 1
try:
_request = TeaRequest()
_request.protocol = UtilClient.default_string(self._protocol, params.protocol)
_request.method = params.method
_request.pathname = params.pathname
_request.query = request.query
# endpoint is setted in product client
_request.headers = TeaCore.merge({
'host': self._endpoint,
'x-acs-version': params.version,
'x-acs-action': params.action,
'user-agent': self.get_user_agent(),
'x-acs-date': OpenApiUtilClient.get_timestamp(),
'x-acs-signature-nonce': UtilClient.get_nonce(),
'accept': 'application/json'
}, request.headers)
if UtilClient.equal_string(params.style, 'RPC'):
headers = self.get_rpc_headers()
if not UtilClient.is_unset(headers):
_request.headers = TeaCore.merge(_request.headers,
headers)
signature_algorithm = UtilClient.default_string(self._signature_algorithm, 'ACS3-HMAC-SHA256')
hashed_request_payload = OpenApiUtilClient.hex_encode(OpenApiUtilClient.hash(UtilClient.to_bytes(''), signature_algorithm))
if not UtilClient.is_unset(request.stream):
tmp = UtilClient.read_as_bytes(request.stream)
hashed_request_payload = OpenApiUtilClient.hex_encode(OpenApiUtilClient.hash(tmp, signature_algorithm))
_request.body = tmp
_request.headers['content-type'] = 'application/octet-stream'
else:
if not UtilClient.is_unset(request.body):
if UtilClient.equal_string(params.req_body_type, 'json'):
json_obj = UtilClient.to_jsonstring(request.body)
hashed_request_payload = OpenApiUtilClient.hex_encode(OpenApiUtilClient.hash(UtilClient.to_bytes(json_obj), signature_algorithm))
_request.body = json_obj
_request.headers['content-type'] = 'application/json; charset=utf-8'
else:
m = UtilClient.assert_as_map(request.body)
form_obj = OpenApiUtilClient.to_form(m)
hashed_request_payload = OpenApiUtilClient.hex_encode(OpenApiUtilClient.hash(UtilClient.to_bytes(form_obj), signature_algorithm))
_request.body = form_obj
_request.headers['content-type'] = 'application/x-www-form-urlencoded'
_request.headers['x-acs-content-sha256'] = hashed_request_payload
if not UtilClient.equal_string(params.auth_type, 'Anonymous'):
auth_type = self.get_type()
if UtilClient.equal_string(auth_type, 'bearer'):
bearer_token = self.get_bearer_token()
_request.headers['x-acs-bearer-token'] = bearer_token
else:
access_key_id = self.get_access_key_id()
access_key_secret = self.get_access_key_secret()
security_token = self.get_security_token()
if not UtilClient.empty(security_token):
_request.headers['x-acs-accesskey-id'] = access_key_id
_request.headers['x-acs-security-token'] = security_token
_request.headers['Authorization'] = OpenApiUtilClient.get_authorization(_request, signature_algorithm, hashed_request_payload, access_key_id, access_key_secret)
_last_request = _request
_response = TeaCore.do_action(_request, _runtime)
if UtilClient.is_4xx(_response.status_code) or UtilClient.is_5xx(_response.status_code):
err = {}
if not UtilClient.is_unset(_response.headers.get('content-type')) and UtilClient.equal_string(_response.headers.get('content-type'), 'text/xml;charset=utf-8'):
_str = UtilClient.read_as_string(_response.body)
resp_map = XMLClient.parse_xml(_str, None)
err = UtilClient.assert_as_map(resp_map.get('Error'))
else:
_res = UtilClient.read_as_json(_response.body)
err = UtilClient.assert_as_map(_res)
err['statusCode'] = _response.status_code
raise TeaException({
'code': '%s' % TeaConverter.to_unicode(self.default_any(err.get('Code'), err.get('code'))),
'message': 'code: %s, %s request id: %s' % (TeaConverter.to_unicode(_response.status_code), TeaConverter.to_unicode(self.default_any(err.get('Message'), err.get('message'))), TeaConverter.to_unicode(self.default_any(err.get('RequestId'), err.get('requestId')))),
'data': err
})
if UtilClient.equal_string(params.body_type, 'binary'):
resp = {
'body': _response.body,
'headers': _response.headers,
'statusCode': _response.status_code
}
return resp
elif UtilClient.equal_string(params.body_type, 'byte'):
byt = UtilClient.read_as_bytes(_response.body)
return {
'body': byt,
'headers': _response.headers,
'statusCode': _response.status_code
}
elif UtilClient.equal_string(params.body_type, 'string'):
str = UtilClient.read_as_string(_response.body)
return {
'body': str,
'headers': _response.headers,
'statusCode': _response.status_code
}
elif UtilClient.equal_string(params.body_type, 'json'):
obj = UtilClient.read_as_json(_response.body)
res = UtilClient.assert_as_map(obj)
return {
'body': res,
'headers': _response.headers,
'statusCode': _response.status_code
}
elif UtilClient.equal_string(params.body_type, 'array'):
arr = UtilClient.read_as_json(_response.body)
return {
'body': arr,
'headers': _response.headers,
'statusCode': _response.status_code
}
else:
return {
'headers': _response.headers,
'statusCode': _response.status_code
}
except Exception as e:
if TeaCore.is_retryable(e):
_last_exception = e
continue
raise e
raise UnretryableException(_last_request, _last_exception)
