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)