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 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 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 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 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 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)
def _request(
self,
method: str,
pathname: str,
query: Dict[str, Any],
headers: Dict[str, str],
body: Any,
runtime: util_models.RuntimeOptions,
) -> Dict[str, Any]:
runtime.validate()
_runtime = {
'timeouted': 'retry',
'readTimeout': runtime.read_timeout,
'connectTimeout': runtime.connect_timeout,
'httpProxy': runtime.http_proxy,
'httpsProxy': runtime.https_proxy,
'noProxy': runtime.no_proxy,
'maxIdleConns': runtime.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()
accesskey_id = self.get_access_key_id()
access_key_secret = self.get_access_key_secret()
_request.protocol = UtilClient.default_string(
self._protocol, 'HTTP')
_request.method = method
_request.pathname = pathname
_request.headers = TeaCore.merge(
{
'user-agent':
self.get_user_agent(),
'Date':
OpensearchUtil.get_date(),
'host':
UtilClient.default_string(
self._endpoint,
f'opensearch-cn-hangzhou.aliyuncs.com'),
'X-Opensearch-Nonce':
UtilClient.get_nonce()
}, headers)
if not UtilClient.is_unset(query):
_request.query = UtilClient.stringify_map_value(query)
if not UtilClient.is_unset(body):
req_body = UtilClient.to_jsonstring(body)
_request.headers[
'Content-MD5'] = OpensearchUtil.get_content_md5(
req_body)
_request.headers['Content-Type'] = 'application/json'
_request.body = req_body
_request.headers[
'Authorization'] = OpensearchUtil.get_signature(
_request, accesskey_id, access_key_secret)
_last_request = _request
_response = TeaCore.do_action(_request, _runtime)
obj_str = UtilClient.read_as_string(_response.body)
if UtilClient.is_4xx(
_response.status_code) or UtilClient.is_5xx(
_response.status_code):
raise TeaException({
'message': _response.status_message,
'data': obj_str,
'code': _response.status_code
})
obj = UtilClient.parse_json(obj_str)
res = UtilClient.assert_as_map(obj)
return {'body': res, '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 do_request(
self,
version: str,
protocol: str,
method: str,
auth_type: str,
pathname: str,
query: Dict[str, str],
headers: Dict[str, str],
body: Any,
runtime: util_models.RuntimeOptions,
) -> dict:
"""
Encapsulate the request and invoke the network
@param version: product version
@param protocol: http or https
@param method: e.g. GET
@param auth_type: when authType is Anonymous, the signature will not be calculate
@param pathname: pathname of every api
@param query: which contains request params
@param headers: request headers
@param body: content of request
@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.headers = TeaCore.merge(
{
'date': UtilClient.get_date_utcstring(),
'host': self._endpoint_host,
'accept': 'application/json',
'x-acs-signature-nonce': UtilClient.get_nonce(),
'x-acs-signature-method': 'HMAC-SHA1',
'x-acs-signature-version': '1.0',
'x-acs-version': version,
'user-agent': UtilClient.get_user_agent(
self._user_agent),
# x-sdk-client': helper.DEFAULT_CLIENT
},
headers)
if not UtilClient.is_unset(body):
_request.body = UtilClient.to_jsonstring(body)
_request.headers[
'content-type'] = 'application/json; charset=utf-8'
if not UtilClient.is_unset(query):
_request.query = query
if not UtilClient.equal_string(auth_type, 'Anonymous'):
access_key_id = self._credential.get_access_key_id()
access_key_secret = self._credential.get_access_key_secret(
)
security_token = self._credential.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
string_to_sign = ROAUtilClient.get_string_to_sign(_request)
_request.headers['authorization'] = 'acs %s:%s' % (
access_key_id,
ROAUtilClient.get_signature(string_to_sign,
access_key_secret))
_last_request = _request
_response = TeaCore.do_action(_request, _runtime)
if UtilClient.equal_number(_response.status_code, 204):
return {'headers': _response.headers}
result = UtilClient.read_as_json(_response.body)
if UtilClient.is_4xx(
_response.status_code) or UtilClient.is_5xx(
_response.status_code):
err = UtilClient.assert_as_map(result)
raise TeaException({
'code':
'%s' %
self.default_any(err.get('Code'), err.get('code')),
'message':
'code: %s, %s request id: %s' %
(_response.status_code,
self.default_any(err.get('Message'),
err.get('message')),
self.default_any(err.get('RequestId'),
err.get('requestId'))),
'data':
err
})
return {'headers': _response.headers, 'body': result}
except Exception as e:
if TeaCore.is_retryable(e):
_last_exception = e
continue
raise e
raise UnretryableException(_last_request, _last_exception)
def do_roarequest_with_form(self, action, version, protocol, method,
auth_type, pathname, body_type, request,
runtime):
"""
Encapsulate the request and invoke the network with form body
: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 pathname: str
:param pathname: pathname of every api
: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
: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),
"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.headers = TeaCore.merge(
{
"date": UtilClient.get_date_utcstring(),
"host": self._endpoint,
"accept": "application/json",
"x-acs-signature-nonce": UtilClient.get_nonce(),
"x-acs-signature-method": "HMAC-SHA1",
"x-acs-signature-version": "1.0",
"x-acs-version": version,
"x-acs-action": action,
"user-agent": UtilClient.get_user_agent(
self._user_agent)
}, request.headers)
if not UtilClient.is_unset(request.body):
_request.body = OpenApiUtilClient.to_form(request.body)
_request.headers[
"content-type"] = "application/x-www-form-urlencoded"
if not UtilClient.is_unset(request.query):
_request.query = request.query
if not UtilClient.equal_string(auth_type, "Anonymous"):
access_key_id = self._credential.get_access_key_id()
access_key_secret = self._credential.get_access_key_secret(
)
security_token = self._credential.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
string_to_sign = OpenApiUtilClient.get_string_to_sign(
_request)
_request.headers["authorization"] = "acs " + str(
access_key_id) + ":" + str(
OpenApiUtilClient.get_roasignature(
string_to_sign, access_key_secret)) + ""
_last_request = _request
_response = TeaCore.do_action(_request, _runtime)
if UtilClient.equal_number(_response.status_code, 204):
return {"headers": _response.headers}
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)
raise TeaException({
"message": err.get('Message'),
"data": err,
"code": err.get('Code')
})
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}
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 do_request(self, action, protocol, method, version, auth_type, query, body, runtime):
"""
Encapsulate the request and invoke the network
@type action: unicode
@param action: api name
@type protocol: unicode
@param protocol: http or https
@type method: unicode
@param method: e.g. GET
@type version: unicode
@param version: product version
@type auth_type: unicode
@param auth_type: when authType is Anonymous, the signature will not be calculate
@param pathname: pathname of every api
@type query: dict
@param query: which contains request params
@type body: dict
@param body: content of request
@param runtime: which controls some details of call api, such as retry times
@rtype: dict
@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 = '/'
_request.query = RPCUtilClient.query(TeaCore.merge({
'Action': action,
'Format': 'json',
'Timestamp': RPCUtilClient.get_timestamp(),
'Version': version,
'SignatureNonce': UtilClient.get_nonce()
}, query))
# endpoint is setted in product client
_request.headers = {
'x-acs-version': version,
'x-acs-action': action,
'host': self._endpoint,
'user-agent': self.get_user_agent()
}
if not UtilClient.is_unset(body):
tmp = UtilClient.anyify_map_value(RPCUtilClient.query(body))
_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
signed_param = TeaCore.merge(_request.query,
RPCUtilClient.query(body))
_request.query['Signature'] = RPCUtilClient.get_signature_v1(signed_param, _request.method, 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)
if UtilClient.is_4xx(_response.status_code) or UtilClient.is_5xx(_response.status_code):
raise TeaException({
'code': '%s' % TeaConverter.to_unicode(self.default_any(res.get('Code'), res.get('code'))),
'message': 'code: %s, %s request id: %s' % (TeaConverter.to_unicode(_response.status_code), TeaConverter.to_unicode(self.default_any(res.get('Message'), res.get('message'))), TeaConverter.to_unicode(self.default_any(res.get('RequestId'), res.get('requestId')))),
'data': res
})
return res
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, pathname, protocol, method, header, body, runtime):
"""
Send request
@type pathname: str
@param pathname: the url path
@type protocol: str
@param protocol: http or https
@type method: str
@param method: example GET
@type header: Dict[str, str]
@param header: request header
@type body: iot_api_gateway_models.IoTApiRequest
@param body: the object of IoTApiRequest
@type runtime: util_models.RuntimeOptions
@param runtime: which controls some details of call api, such as retry times
@rtype: TeaResponse
@return: the response
"""
body.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),
'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 = UtilClient.default_string(method, 'POST')
_request.pathname = pathname
_request.headers = TeaCore.merge(
{
'host': self._domain,
'date': UtilClient.get_date_utcstring(),
'x-ca-nonce': UtilClient.get_nonce(),
'x-ca-key': self._app_key,
'x-ca-signaturemethod': 'HmacSHA256',
'accept': 'application/json',
'user-agent': self.get_user_agent()
}, header)
if UtilClient.empty(body.id):
body.id = UtilClient.get_nonce()
if not UtilClient.is_unset(body):
_request.headers[
'content-type'] = 'application/octet-stream'
_request.headers[
'content-md5'] = APIGatewayUtilClient.get_content_md5(
UtilClient.to_jsonstring(TeaCore.to_map(body)))
_request.body = UtilClient.to_jsonstring(
TeaCore.to_map(body))
_request.headers[
'x-ca-signature'] = APIGatewayUtilClient.get_signature(
_request, self._app_secret)
_last_request = _request
_response = TeaCore.do_action(_request, _runtime)
return _response
except Exception as e:
if TeaCore.is_retryable(e):
_last_exception = e
continue
raise e
raise UnretryableException(_last_request, _last_exception)