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 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() 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 _parse_error_info_from_response_body(response_body): try: body_obj = json.loads(response_body) if 'Code' in body_obj and 'Message' in body_obj: return body_obj['Code'], body_obj['Message'] else: return (error_code.SDK_UNKNOWN_SERVER_ERROR, error_msg.get_msg('SDK_UNKNOWN_SERVER_ERROR')) except ValueError: # failed to parse body as json format return (error_code.SDK_UNKNOWN_SERVER_ERROR, error_msg.get_msg('SDK_UNKNOWN_SERVER_ERROR'))
def __init__(self, public_key_id, private_key, session_period, region_id, debug=False): if not debug and session_period < self._MIN_SESSION_PERIOD or session_period > self._MAX_SESSION_PERIOD: raise exceptions.ClientException( error_code.SDK_INVALID_SESSION_EXPIRATION, error_msg.get_msg('SDK_INVALID_SESSION_EXPIRATION').format( self._MIN_SESSION_PERIOD, self._MAX_SESSION_PERIOD)) self._public_key_id = public_key_id self._private_key = private_key self._session_period = session_period self._schedule_interval = session_period if debug else max( session_period * 0.8, 5) from aliyunsdkcore.client import AcsClient self._sts_client = AcsClient(self._public_key_id, self._private_key, region_id) self._session_credential = None self._get_session_ak_and_sk() self._scheduler = sched.scheduler(time.time, time.sleep) self._daemon_thread = threading.Thread( target=self._refresh_session_ak_and_sk, args=[True, 0]) self._daemon_thread.setDaemon(True) self._daemon_thread.start()
def get_signer(cred, region_id, do_action_api, debug=False): if cred['ak'] is not None and cred['secret'] is not None: access_key_credential = credentials.AccessKeyCredential( cred['ak'], cred['secret']) return access_key_signer.AccessKeySigner(access_key_credential) elif cred['credential'] is not None: credential = cred['credential'] if isinstance(credential, credentials.AccessKeyCredential): return access_key_signer.AccessKeySigner(credential) elif isinstance(credential, credentials.StsTokenCredential): return sts_token_signer.StsTokenSigner(credential) elif isinstance(credential, credentials.RamRoleArnCredential): return ram_role_arn_signer.RamRoleArnSigner( credential, do_action_api) elif isinstance(credential, credentials.EcsRamRoleCredential): return ecs_ram_role_singer.EcsRamRoleSigner(credential) elif isinstance(credential, credentials.RsaKeyPairCredential): return rsa_key_pair_signer.RsaKeyPairSigner( credential, region_id, debug) elif cred['public_key_id'] is not None and cred[ 'private_key'] is not None: logging.info( "'AcsClient(regionId, pub_key_id, pri_key)' is deprecated") rsa_key_pair_credential = credentials.RsaKeyPairCredential( cred['public_key_id'], cred['private_key'], cred['session_period'], region_id, debug) return rsa_key_pair_signer.RsaKeyPairSigner( rsa_key_pair_credential) else: raise exceptions.ClientException( error_code.SDK_INVALID_CREDENTIAL, error_msg.get_msg('SDK_INVALID_CREDENTIAL'))
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 get_signer(credential, debug=False): if credential['ak'] is not None and credential['secret'] is not None: return SignerV1(credential['ak'], credential['secret']) elif credential['public_key_id'] is not None and credential['private_key'] is not None: return SignerV2(credential['public_key_id'], credential['private_key'], credential['session_period'], credential['region_id'], debug) else: raise exceptions.ClientException(error_code.SDK_INVALID_CREDENTIAL, error_msg.get_msg('SDK_INVALID_CREDENTIAL'))
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 _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 __init__(self, credential, region_id, debug=False): if credential.session_period < self._MIN_SESSION_PERIOD or \ credential.session_period > self._MAX_SESSION_PERIOD: raise exceptions.ClientException( error_code.SDK_INVALID_SESSION_EXPIRATION, error_msg.get_msg('SDK_INVALID_SESSION_EXPIRATION').format( self._MIN_SESSION_PERIOD, self._MAX_SESSION_PERIOD)) credential.region_id = region_id self._public_key_id = credential.public_key_id self._private_key = credential.private_key self._session_period = credential.session_period self._last_update_time = 0 # self._schedule_interval = credential.session_period if debug \ # else max(credential.session_period * 0.8, 5) from aliyunsdkcore.client import AcsClient self._sts_client = AcsClient(self._public_key_id, self._private_key, credential.region_id) self._session_credential = None
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)
def _get_session_ak_and_sk(self): request = GetSessionAkRequest() request.set_method("GET") request.set_duration_seconds(self._session_period) try: response_str = self._sts_client.do_action_with_exception(request) response = json.loads(response_str.decode('utf-8')) session_ak = str(response.get("SessionAccessKey").get("SessionAccessKeyId")) session_sk = str(response.get("SessionAccessKey").get("SessionAccessKeySecret")) self._session_credential = session_ak, session_sk except exceptions.ServerException as srv_ex: if srv_ex.error_code == 'InvalidAccessKeyId.NotFound' or srv_ex.error_code == 'SignatureDoesNotMatch': raise exceptions.ClientException(error_code.SDK_INVALID_CREDENTIAL, error_msg.get_msg('SDK_INVALID_CREDENTIAL')) else: raise
def test_get_msg(self): self.assertEqual(get_msg("SDK_INVALID_REGION_ID"), "Can not find endpoint to access.")
for region in regions: region_list.append(region.childNodes[0].nodeValue) for product in products: name_node = product.getElementsByTagName('ProductName')[0] name = name_node.childNodes[0].nodeValue domain_node = product.getElementsByTagName('DomainName')[0] domain = domain_node.childNodes[0].nodeValue product_list.append({name: domain}) __endpoints[endpoint.getAttribute('name')] = dict( regions=region_list, products=product_list) except Exception as ex: raise ClientException( error_code.SDK_MISSING_ENDPOINTS_FILER, error_msg.get_msg('SDK_MISSING_ENDPOINTS_FILER')) def find_product_domain(regionid, prod_name): """ Fetch endpoint url with given region id, product name and endpoint list :param regionid: region id :param product: product name :param endpoints: product list :return: endpoint url """ if regionid is not None and product is not None: for point in __endpoints: point_info = __endpoints.get(point) if regionid in point_info.get('regions'): prod_info = point_info.get('products')