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')
