def get_raw_resp(request):
"""
Get RAW response of aliyunsdk
:param client: aliyunsdk client
:param request: request to send
:return: None
"""
client = connect.client
endpoint = client._resolve_endpoint(request)
http_response = client._make_http_response(endpoint, request)
if client._url_test_flag:
raise ClientException("URLTestFlagIsSet", http_response.get_url())
# Do the actual network thing
try:
status, headers, body = http_response.get_response_object()
return status, headers, body
except IOError as e:
raise ClientException(
error_code.SDK_SERVER_UNREACHABLE,
error_msg.get_msg('SDK_SERVER_UNREACHABLE') + ': ' + str(e))
except AttributeError:
raise ClientException(error_code.SDK_INVALID_REQUEST,
error_msg.get_msg('SDK_INVALID_REQUEST'))
def implementation_of_do_action(self, request, signer=None):
if not isinstance(request, AcsRequest):
raise ClientException(error_code.SDK_INVALID_REQUEST,
error_msg.get_msg('SDK_INVALID_REQUEST'))
# add core version
core_version = __import__('aliyunsdkcore').__version__
request.add_header('x-sdk-core-version', core_version)
if isinstance(request, CommonRequest):
request.trans_to_acs_request()
if request.endpoint:
endpoint = request.endpoint
else:
endpoint = self._resolve_endpoint(request)
http_response = self._make_http_response(endpoint, request, signer)
# Do the actual network thing
try:
status, headers, body = http_response.get_response_object()
return status, headers, body
except IOError as e:
error_message = str(e)
error_message += "\nEndpoint: " + endpoint
error_message += "\nProduct: " + str(request.get_product())
error_message += "\nSdkCoreVersion: " + aliyunsdkcore.__version__
error_message += "\nHttpUrl: " + str(http_response.get_url())
error_message += "\nHttpHeaders: " + \
str(http_response.get_headers())
raise ClientException(error_code.SDK_HTTP_ERROR, error_message)
def implementation_of_do_action(self, request, signer=None):
if not isinstance(request, AcsRequest):
raise ClientException(error_code.SDK_INVALID_REQUEST,
error_msg.get_msg('SDK_INVALID_REQUEST'))
# add core version
core_version = __import__('aliyunsdkcore').__version__
request.add_header('x-sdk-core-version', core_version)
if isinstance(request, CommonRequest):
request.trans_to_acs_request()
endpoint = self._resolve_endpoint(request)
http_response = self._make_http_response(endpoint, request, signer)
if self._url_test_flag:
raise ClientException("URLTestFlagIsSet", http_response.get_url())
# Do the actual network thing
try:
status, headers, body = http_response.get_response_object()
return status, headers, body
except IOError as e:
raise ClientException(
error_code.SDK_SERVER_UNREACHABLE,
error_msg.get_msg('SDK_SERVER_UNREACHABLE') + ': ' + str(e))
def send_sms(self, business_id, phone_numbers, sign_name, template_code, template_param=None):
smsRequest = SendSmsRequest.SendSmsRequest()
# 申请的短信模板编码,必填
smsRequest.set_TemplateCode(template_code)
# 短信模板变量参数
if template_param is not None:
smsRequest.set_TemplateParam(template_param)
# 设置业务请求流水号，必填。
smsRequest.set_OutId(business_id)
# 短信签名
smsRequest.set_SignName(sign_name);
# 短信发送的号码列表，必填。
smsRequest.set_PhoneNumbers(phone_numbers)
# 调用短信发送接口，返回json
smsRequest.set_accept_format('JSON')
http_response = self.acs_client._make_http_response('dysmsapi.aliyuncs.com', smsRequest)
try:
status, headers, body = http_response.get_response_object()
except IOError as e:
raise ClientException(
error_code.SDK_SERVER_UNREACHABLE,
error_msg.get_msg('SDK_SERVER_UNREACHABLE') + ': ' + str(e))
except AttributeError:
raise ClientException(
error_code.SDK_INVALID_REQUEST,
error_msg.get_msg('SDK_INVALID_REQUEST'))
return body
def _handle_single_request(self, endpoint, request, read_timeout,
connect_timeout, signer):
http_response = self._make_http_response(endpoint, request,
read_timeout, connect_timeout,
signer)
params = copy.deepcopy(request.get_query_params())
params.pop('AccessKeyId', None)
logger.debug('Request received. Product:%s Endpoint:%s Params: %s',
request.get_product(), endpoint, params)
# Do the actual network thing
try:
status, headers, body = http_response.get_response_object()
except IOError as e:
exception = ClientException(error_code.SDK_HTTP_ERROR,
compat.ensure_string('%s' % e))
msg = "HttpError occurred. Host:%s SDK-Version:%s ClientException:%s" % (
endpoint, aliyunsdkcore.__version__, exception)
logger.error(compat.ensure_string(msg))
return None, None, None, exception
exception = self._get_server_exception(status, body, endpoint,
request.string_to_sign)
return status, headers, body, exception
def test_add_endpoint_static(self):
from aliyunsdkcore.profile.region_provider import add_endpoint, modify_point
my_client = self.init_client("cn-ningbo")
add_endpoint(
"Ecs", # which does not exist at all
"cn-ningbo",
"abc.cn-ningbo.endpoint-test.exception.com")
with patch.object(
my_client._endpoint_resolver,
'resolve',
wraps=my_client._endpoint_resolver.resolve) as monkey:
monkey.side_effect = ClientException(
error_code.SDK_HTTP_ERROR,
"abc.cn-ningbo.endpoint-test.exception.com")
request2 = DescribeRegionsRequest()
try:
response2 = my_client.do_action_with_exception(request2)
assert False
except ClientException as e:
self.assertEqual(error_code.SDK_HTTP_ERROR, e.get_error_code())
self.assertEqual("abc.cn-ningbo.endpoint-test.exception.com",
e.get_error_msg())
DefaultEndpointResolver.predefined_endpoint_resolver.reset()
def test_add_new_endpoint_manually(self):
my_client = self.init_client("cn-ningbo")
request = DescribeRegionsRequest()
try:
response = my_client.do_action_with_exception(request)
assert False
except ClientException as e:
self.assertEqual(error_code.SDK_ENDPOINT_RESOLVING_ERROR, e.get_error_code())
self.assertEqual(
"No such region 'cn-ningbo'. Please check your region ID.",
e.get_error_msg()
)
my_client.add_endpoint(
"cn-ningbo", # which does not exist at all
"Ecs",
"abc.cn-ningbo.endpoint-test.exception.com"
)
with patch.object(
my_client._endpoint_resolver,
'resolve',
wraps=my_client._endpoint_resolver.resolve
) as monkey:
monkey.side_effect = ClientException(
error_code.SDK_HTTP_ERROR,
"abc.cn-ningbo.endpoint-test.exception.com")
request2 = DescribeRegionsRequest()
try:
response2 = my_client.do_action_with_exception(request2)
assert False
except ClientException as e:
self.assertEqual(error_code.SDK_HTTP_ERROR, e.get_error_code())
self.assertEqual("abc.cn-ningbo.endpoint-test.exception.com", e.get_error_msg())
def get_resource(*args,
access_key_id=None,
access_key_secret=None,
region_id=None,
resource_id=None):
resource_name = _get_param_from_args(args, 0, "resource_name")
if resource_name.lower() == "ecs":
client = AcsClient(access_key_id, access_key_secret, region_id)
return ECSResource(_client=client)
elif resource_name.lower() == "ecs.instance":
instance_id = _get_param_from_args(args, 1, "instance_id")
client = AcsClient(access_key_id, access_key_secret, region_id)
return ECSInstanceResource(instance_id, _client=client)
elif resource_name.lower() == "ecs.system_event":
event_id = _get_param_from_args(args, 1, "event_id")
client = AcsClient(access_key_id, access_key_secret, region_id)
return ECSSystemEventResource(event_id, _client=client)
else:
raise ClientException(
alibabacloud.errors.ERROR_CODE_SERVICE_NOT_SUPPORTED,
"Resource '{0}' is not currently supported.".format(resource_name))
def _do_request(client, request, params):
for key, value in params.items():
if hasattr(request, 'set_' + key):
func = getattr(request, 'set_' + key)
func(value)
elif key == "RegionId":
request.add_query_param(key, value)
else:
raise ClientException(
errors.ERROR_INVALID_PARAMETER,
"{0} has no parameter named {1}.".format(
request.__class__.__name__,
key,
))
if _test_flag:
import time
print(time.time(), request.__class__.__name__,
request.get_query_params())
response = client.do_action_with_exception(request)
if _test_flag:
print(response.decode('utf-8'))
return json.loads(response.decode('utf-8'), object_hook=_SearchableDict)
def _handle_param_aliases(params, aliases):
for key, value in iteritems(aliases):
if key in params:
if value in params:
raise ClientException(ERROR_INVALID_PARAMETER,
"Param {0} is already set.".format(value))
params[value] = params[key]
del params[key]
def _check_region_id(self, request):
for resolver in self.endpoint_resolvers:
if resolver.is_region_id_valid(request):
return
raise ClientException(
error_code.SDK_ENDPOINT_RESOLVING_ERROR,
error_msg.INVALID_REGION_ID.format(region_id=request.region_id))
def _assert_is_list_but_not_string(item, name):
if not isinstance(item, str) and (isinstance(item, list)
or isinstance(item, tuple)):
pass
else:
message = "{0} should be a list or a tuple, {1} found.".format(
name, item.__class__.__name__)
raise ClientException(errors.ERROR_INVALID_PARAMETER, message)
def _check_product_code(self, request):
for resolver in self.endpoint_resolvers:
if resolver.is_product_code_valid(request):
return
raise ClientException(
error_code.SDK_ENDPOINT_RESOLVING_ERROR,
error_msg.ENDPOINT_NO_PRODUCT.format(
product_code=request.product_code))
def refresh(self):
request = DescribeInstancesRequest()
request.set_InstanceIds(json.dumps([self.instance_id]))
items = _get_response(self._client, request, {}, 'Instances.Instance')
if not items:
raise ClientException(errors.ERROR_INVALID_SERVER_RESPONSE,
"Failed to find instance data from DescribeInstances response. "
"InstanceId = {0}".format(self.instance_id))
self._assign_attributes(items[0])
def get_secret_value(self, get_secret_value_req):
futures = []
finished = []
if self.signer is not None and isinstance(self.signer,
ClientKeySigner):
get_secret_value_req._signer = sha_hmac256
for i in range(len(self.region_info_list)):
if i == 0:
try:
return self.__get_secret_value(
self.region_info_list[i], get_secret_value_req)
except ClientException as e:
get_logger().error("action:__get_secret_value",
exc_info=True)
if not judge_need_recovery_exception(e):
raise e
get_secret_request = RpcRequest(
get_secret_value_req._product,
get_secret_value_req._version,
get_secret_value_req._action_name,
get_secret_value_req._location_service_code,
signer=get_secret_value_req._signer)
get_secret_request._protocol_type = get_secret_value_req._protocol_type
get_secret_request.add_query_param(
'SecretName',
get_secret_value_req.get_query_params().get('SecretName'))
get_secret_request.add_query_param(
'VersionStage',
get_secret_value_req.get_query_params().get(
'VersionStage'))
get_secret_request.add_query_param(
'FetchExtendedConfig',
get_secret_value_req.get_query_params().get(
'FetchExtendedConfig'))
future = self.pool.submit(self.__retry_get_secret_value,
get_secret_request,
self.region_info_list[i], finished)
futures.append(future)
try:
if wait(futures,
self.request_waiting_time,
return_when=FIRST_COMPLETED):
for future in futures:
if not future.done():
future.cancel()
else:
return future.result()
except Exception as e:
get_logger().error("action:__retry_get_secret_value_task",
exc_info=True)
raise e
finally:
finished.append(True)
raise ClientException(error_code.SDK_HTTP_ERROR,
"refreshSecretTask fail")
def refresh(self):
request = DescribeImagesRequest()
request.set_ImageId(self.image_id)
items = _get_response(self._client, request, {}, 'Images.Image')
if not items:
raise ClientException(
errors.ERROR_INVALID_SERVER_RESPONSE,
"Failed to find image data from DescribeImages "
"response. "
"ImageId = {0}".format(self.image_id))
self._assign_attributes(items[0])
def _handle_single_request(endpoint, request, request_timeout, signer=None):
global _test_retry_times
assert "ABCDEFGHIJKLMN" == request.get_ClientToken()
_test_retry_times += 0
return (
None,
None,
None,
ClientException(error_code.SDK_HTTP_ERROR, "some error"),
)
def refresh(self):
request = DescribeDisksRequest()
request.set_DiskIds(json.dumps([self.disk_id]))
items = _get_response(self._client, request, {}, 'Disks.Disk')
if not items:
raise ClientException(
errors.ERROR_INVALID_SERVER_RESPONSE,
"Failed to find disk data from DescribeDiks "
"response. "
"DiskId = {0}".format(self.disk_id))
self._assign_attributes(items[0])
def refresh(self):
request = DescribeInstanceHistoryEventsRequest()
request.set_EventIds([self.event_id])
items = _get_response(self._client, request, {},
'InstanceSystemEventSet.InstanceSystemEventType')
if not items:
raise ClientException(errors.ERROR_INVALID_SERVER_RESPONSE,
"Failed to find event data from "
"DescribeInstanceHistoryEventsRequest response. "
"EventId = {0}".format(self.event_id))
self._assign_attributes(items[0])
def refresh(self):
request = DescribeEipAddressesRequest()
request.set_AllocationId(self.allocation_id)
items = _get_response(self._client, request, {},
'EipAddresses.EipAddress')
if not items:
raise ClientException(
errors.ERROR_INVALID_SERVER_RESPONSE,
"Failed to find EIP Address data from DescribeEipAddresses "
"response. "
"AllocationId = {0}".format(self.allocation_id))
self._assign_attributes(items[0])
def refresh(self):
request = DescribeLoadBalancersRequest()
request.set_LoadBalancerId(self.load_balancer_id)
items = _get_response(self._client, request, {},
'LoadBalancers.LoadBalancer')
if not items:
raise ClientException(
errors.ERROR_INVALID_SERVER_RESPONSE,
"Failed to find load balancer data from DescribeLoadBalancers "
"response. "
"LoadBalancerId = {0}".format(self.load_balancer_id))
self._assign_attributes(items[0])
def _handle_single_request(*args, **kwargs):
global _test_retry_times
if _test_retry_times < 3:
_test_retry_times += 1
return (
None,
None,
None,
ClientException(error_code.SDK_HTTP_ERROR, "some error"),
)
else:
return orginal_func(*args, **kwargs)
def _resolve_endpoint(self, request):
if isinstance(request, CommonRequest) and request.get_domain():
return request.get_domain()
endpoint = None
if request.get_location_service_code() is not None:
endpoint = self._location_service.find_product_domain(
self.get_region_id(), request.get_location_service_code(),
request.get_product(), request.get_location_endpoint_type())
if endpoint is None:
endpoint = region_provider.find_product_domain(
self.get_region_id(), request.get_product())
if endpoint is None:
raise ClientException(
error_code.SDK_INVALID_REGION_ID,
error_msg.get_msg('SDK_INVALID_REGION_ID'))
if not isinstance(request, AcsRequest):
raise ClientException(error_code.SDK_INVALID_REQUEST,
error_msg.get_msg('SDK_INVALID_REQUEST'))
return endpoint
def do_action_with_exception(self, request: RpcRequest):
request.set_accept_format('JSON')
path = request.path_pattern if hasattr(
request, 'path_pattern') else '/api/acs/openapi'
if self._endpoint:
endpoint = self._endpoint
elif request.endpoint:
endpoint = request.endpoint
else:
endpoint = self._resolve_endpoint(request)
request.add_query_param('Product', request.get_product())
request.add_query_param('RegionId', self.get_region_id())
request.add_query_param('Action', request.get_action_name())
request.add_query_param('Version', request.get_version())
request._params.update(self.query_params)
sign_params = dict(request._params)
query, sign_str = get_signed_url(sign_params, self.get_access_key(),
self.get_access_secret(),
request.get_accept_format(),
request.get_method(),
request.get_body_params(),
self.query_params)
request.string_to_sign = sign_str
endpoint += path
response = HttpResponse(
endpoint, query, request.get_method(),
request.get_signed_header(self.get_region_id(),
self.get_access_key(),
self.get_access_secret()),
request.get_protocol_type(), request.get_content(), self._port)
if self._read_timeout:
response._timeout = response.__read_timeout = self._read_timeout
if self._connect_timeout:
response.__connect_timeout = self._connect_timeout
try:
status, headers, body = response.get_response_object()
except IOError as e:
exception = ClientException(error_code.SDK_HTTP_ERROR,
compat.ensure_string('%s' % e))
return None, None, None, exception
exception = self.get_server_exception(status, body)
if exception:
raise exception
return body
def _resolve_endpoint(self, request):
resolve_request = ResolveEndpointRequest(
self.__region_id,
request.get_product(),
request.get_location_service_code(),
request.get_location_endpoint_type(),
)
endpoint = self._endpoint_resolver.resolve(resolve_request)
if endpoint.endswith("endpoint-test.exception.com"):
# For endpoint testability, if the endpoint is xxxx.endpoint-test.special.com
# throw a client exception with this endpoint
raise ClientException(error_code.SDK_ENDPOINT_TESTABILITY, endpoint)
return endpoint
def _implementation_of_do_action(self, request, signer=None):
if not isinstance(request, AcsRequest):
raise ClientException(error_code.SDK_INVALID_REQUEST,
error_msg.get_msg('SDK_INVALID_REQUEST'))
# modify Accept-Encoding
request.add_header('Accept-Encoding', 'identity')
if request.endpoint:
endpoint = request.endpoint
else:
endpoint = self._resolve_endpoint(request)
return self._handle_retry_and_timeout(endpoint, request, signer)
def _handle_single_request(endpoint, request, request_timeout, signer=None):
global _test_client_token
global _test_retry_times
if _test_retry_times > 0:
assert _test_client_token == request.get_ClientToken()
_test_retry_times += 0
_test_client_token = request.get_ClientToken()
return (
None,
None,
None,
ClientException(error_code.SDK_HTTP_ERROR, "some error"),
)
def resolve(self, request):
for resolver in self.endpoint_resolvers:
endpoint = resolver.resolve(request)
if endpoint is not None:
return endpoint
self._check_product_code(request)
self._check_region_id(request)
raise ClientException(
error_code.SDK_ENDPOINT_RESOLVING_ERROR,
error_msg.ENDPOINT_NO_REGION.format(
region_id=request.region_id,
product_code=request.product_code,
more=self._get_available_regions_hint(request.product_code)))
def _param_expand_to_json(params, rules, singular=True):
for key, value in iteritems(rules):
# key is like: instance_id or instance_ids
# value is like: InstanceIds
if key in params:
if singular:
to_add = [params[key]]
else:
to_add = params[key]
_assert_is_list_but_not_string(to_add, key)
del params[key]
if value in params:
raise ClientException(ERROR_INVALID_PARAMETER,
"Param {0} is already set.".format(value))
params[value] = json.dumps(to_add)
def _implementation_of_do_action(self, request, signer=None):
if not isinstance(request, AcsRequest):
raise ClientException(error_code.SDK_INVALID_REQUEST,
error_msg.get_msg('SDK_INVALID_REQUEST'))
# add core version
core_version = __import__('aliyunsdkcore').__version__
request.add_header('x-sdk-core-version', core_version)
if isinstance(request, CommonRequest):
request.trans_to_acs_request()
if request.endpoint:
endpoint = request.endpoint
else:
endpoint = self._resolve_endpoint(request)
return self._handle_retry_and_timeout(endpoint, request, signer)