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 SyncRegion():
client = AcsClient(accesskeyId, accessSecret, 'cn-hangzhou')
request = DescribeRegionsRequest()
request.set_accept_format('json')
response = json.loads(client.do_action_with_exception(request),
encoding='utf-8')
return response
def list_regions(self, **params):
regions = []
request = DescribeRegionsRequest()
request._params = params
response = self._send_request(request)
if response :
regions.extend(response.get("Regions", []).get("Region", []))
return regions
def getRegionIds():
client = AcsClient(ak, sk, 'cn-hangzhou')
request = DescribeRegionsRequest()
request.set_accept_format('json')
response = json.loads(client.do_action_with_exception(request))
regions = response['Regions']['Region']
regionIds = []
for i in regions:
regionIds.append(i['RegionId'])
return regionIds
def test_bug_with_17602976(self):
from aliyunsdkecs.request.v20140526.DescribeRegionsRequest import DescribeRegionsRequest
request = DescribeRegionsRequest()
request.set_accept_format('JSON')
status, headers, body = self.client.implementation_of_do_action(request)
try:
body_obj = ["ecs", "rdm", "roa"]
request_id = body_obj.get("RequestId")
assert False
except (ValueError, TypeError, AttributeError) as e:
self.assertEqual("'list' object has no attribute 'get'", e.args[0])
def get_regions(self):
request = DescribeRegionsRequest()
request.set_accept_format('json')
data = self._request(request)
data = data.get('Regions')
data_list = data.get('Region')
data = {
'total': len(data_list),
'data_list': data_list,
}
return data
def getAliCloundRegionsList(self):
client=AcsClient(self.secreyKey,self.accesssecret)
req=DescribeRegionsRequest()
# req.set_AcceptLanguage(language)
req.set_accept_format('json')
try:
data=client.do_action_with_exception(req)
if data:
return data
else:
return False
except Exception as e:
logger.error(e)
return False
def get_regions():
""" 获取区域列表
:return: 返回区域列表数组,格式
[{
"RegionId": "cn-shenzhen",
"RegionEndpoint": "ecs.aliyuncs.com",
"LocalName": "华南 1"
},...]
"""
client = AcsClient(accessKeyId, accessSecret, 'cn-shenzhen')
request = DescribeRegionsRequest()
request.set_accept_format('json')
response = client.do_action_with_exception(request)
return json.loads(str(response, encoding='utf-8'))['Regions']['Region']
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_ecs_ram_role(self):
# push ecs
from aliyunsdkcore.auth.credentials import EcsRamRoleCredential
ecs_ram_role_credential = EcsRamRoleCredential("TestRole")
acs_client = AcsClient(region_id="cn-hangzhou", credential=ecs_ram_role_credential)
request = DescribeRegionsRequest()
response = acs_client.do_action_with_exception(request)
def list_region():
request = DescribeRegionsRequest()
response = _send_request(request)
if response is not None:
region_list = response.get('Regions').get('Region')
result = map(_print_region_id, region_list)
return result
def test_call_rpc_request_with_sts_token(self):
# create AssumeRole request ,Acquire a temporary ak
request = AssumeRoleRequest()
# the role must exist
# FIXME : the RoleArn must according to user's setting
request.set_RoleArn("acs:ram::1988236124481530:role/testrole")
request.set_RoleSessionName("alice_test")
client = self.init_sub_client()
response = client.do_action_with_exception(request)
response = self.get_dict_response(response)
credentials = response.get("Credentials")
# Using temporary AK + STS for authentication
sts_token_credential = StsTokenCredential(
credentials.get("AccessKeyId"), credentials.get("AccessKeySecret"),
credentials.get("SecurityToken"))
acs_client = AcsClient(region_id="me-east-1",
credential=sts_token_credential)
request = DescribeRegionsRequest()
url = self.get_http_request(acs_client, request)
self.assertTrue(url.find("AccessKeyId=STS."))
response = acs_client.do_action_with_exception(request)
ret = self.get_dict_response(response)
self.assertTrue(ret.get("Regions"))
self.assertTrue(ret.get("RequestId"))
def test_call_rpc_request_with_sts_token(self):
client = self.init_sub_client()
self._create_default_ram_role()
request = AssumeRoleRequest()
request.set_RoleArn(self.ram_role_arn)
request.set_RoleSessionName(self.default_role_session_name)
response = client.do_action_with_exception(request)
response = self.get_dict_response(response)
credentials = response.get("Credentials")
# Using temporary AK + STS for authentication
sts_token_credential = StsTokenCredential(
credentials.get("AccessKeyId"), credentials.get("AccessKeySecret"),
credentials.get("SecurityToken"))
acs_client = AcsClient(region_id=self.region_id,
credential=sts_token_credential)
request = DescribeRegionsRequest()
url = self.get_http_request(acs_client, request)
self.assertTrue(url.find("AccessKeyId=STS."))
response = acs_client.do_action_with_exception(request)
ret = self.get_dict_response(response)
self._delete_default_ram_role()
self._delete_access_key()
self.assertTrue(ret.get("Regions"))
self.assertTrue(ret.get("RequestId"))
def test_file_logger(self):
tempdir = tempfile.mkdtemp()
temp_file = os.path.join(tempdir, 'file_logger')
self.client.set_file_logger(log_level=logging.DEBUG, path=temp_file)
from aliyunsdkecs.request.v20140526.DescribeRegionsRequest import DescribeRegionsRequest
request = DescribeRegionsRequest()
self.client.do_action_with_exception(request)
self.assertTrue(os.path.isfile(temp_file))
with open(temp_file) as logfile:
s = logfile.read()
self.assertTrue('aliyunsdkcore.client DEBUG Request received.' in s)
def test_add_existing_endpoint_manually(self):
my_client = self.init_client("cn-hangzhou")
request = DescribeRegionsRequest()
response = my_client.do_action_with_exception(request)
my_client.add_endpoint("cn-hangzhou", "Ecs",
"abc.cn-hangzhou.endpoint-test.exception.com")
with patch.object(my_client._endpoint_resolver, 'resolve') as monkey:
monkey.side_effect = ClientException(
error_code.SDK_HTTP_ERROR,
"abc.cn-hangzhou.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-hangzhou.endpoint-test.exception.com",
e.get_error_msg())
def Aliyun_City_Scan(ALIYUN_ACCESSKEYID, ALIYUN_ACCESSKEYSECRET):
Aliyun_City = {}
client = AcsClient(ALIYUN_ACCESSKEYID, ALIYUN_ACCESSKEYSECRET)
request = DescribeRegionsRequest()
request.set_accept_format('json')
response = client.do_action_with_exception(request)
response = str(response, encoding='utf-8')
for i in range(0, 30):
try:
City_Host = json.loads(
response)['Regions']['Region'][i]['RegionId']
City_Name = json.loads(
response)['Regions']['Region'][i]['LocalName']
Aliyun_City[City_Name] = City_Host
except:
print('\033[1;34m ------ 搜索到有{}个可使用阿里云地域 ------\033[0m'.format(i))
break
return Aliyun_City
def get_region(self):
'''
获取账户支持的所有区域id
:return:
'''
self.__get_client()
request = DescribeRegionsRequest()
response = self.__do_action(request)
region_list = response.get('Regions').get('Region')
assert response is not None
assert region_list is not None
self.regionList = list(map(print_dict_key, region_list, ['RegionId'] * len(region_list)))
return self.regionList
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 endpoint in the region 'cn-ningbo' for product 'Ecs'.\n"
"You can set an endpoint for your request explicitly.\n"
"Or you can use the other available regions: ap-northeast-1 "
"ap-south-1 ap-southeast-2 ap-southeast-3 ap-southeast-5 cn-huhehaote "
"cn-zhangjiakou eu-central-1 me-east-1\n"
"See https://www.alibabacloud.com/help/doc-detail/92074.htm\n",
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 test_call_roa_request_with_sts_token(self):
from aliyunsdkcore.auth.credentials import RamRoleArnCredential
# FIXME : the RoleArn must according to user's setting
ram_role_arn_credential = RamRoleArnCredential(
self.sub_access_key_id, self.sub_access_key_secret,
"acs:ram::1988236124481530:role/testrole", "alice_test")
acs_client = AcsClient(region_id="cn-hangzhou",
credential=ram_role_arn_credential)
request = DescribeRegionsRequest()
url = self.get_http_request(acs_client, request)
self.assertTrue(url.find("AccessKeyId=STS."))
response = acs_client.do_action_with_exception(request)
ret = self.get_dict_response(response)
self.assertTrue(ret.get("Regions"))
self.assertTrue(ret.get("RequestId"))
def _get_region_info(self):
c = client.AcsClient(self._AK, self._AKS)
req = DescribeRegionsRequest()
req.set_AcceptLanguage('zh-CN')
req.set_accept_format('json')
try:
response = c.do_action(req)
result = json.loads(response)
for region_info in result['Regions']['Region']:
self._region.append(region_info['RegionId'])
except Exception as e:
print e
def test_call_roa_request_with_sts_token(self):
from aliyunsdkcore.auth.credentials import RamRoleArnCredential
self._create_default_ram_user()
self._attach_default_policy()
self._create_access_key()
self._create_default_ram_role()
ram_role_arn_credential = RamRoleArnCredential(
self.ram_user_access_key_id, self.ram_user_access_key_secret,
self.ram_role_arn, "alice_test")
acs_client = AcsClient(region_id="cn-hangzhou",
credential=ram_role_arn_credential)
request = DescribeRegionsRequest()
url = self.get_http_request(acs_client, request)
self.assertTrue(url.find("AccessKeyId=STS."))
response = acs_client.do_action_with_exception(request)
ret = self.get_dict_response(response)
self.assertTrue(ret.get("Regions"))
self.assertTrue(ret.get("RequestId"))
def get_regionid():
client = AcsClient(accessKeyId, accessSecret, 'cn-hangzhou')
request = DescribeRegionsRequest()
request.set_accept_format('json')
response = client.do_action_with_exception(request)
return json.loads(str(response, encoding='utf-8'))["Regions"]["Region"]
def test_products_with_location_service(self):
request = DescribeRegionsRequest()
response = self.client.do_action_with_exception(request)
def test_call_rpc_request_with_client(self):
request = DescribeRegionsRequest()
response = self.client.do_action_with_exception(request)
def verify(self, secret_data, region_name):
self.set_client(secret_data, region_name)
request = DescribeRegionsRequest()
response = self._send_request(request)
return "ACTIVE" if response is not None else "UNKNOWN"
from aliyunsdkcore.acs_exception.exceptions import ServerException
from aliyunsdkecs.request.v20140526.DescribeRegionsRequest import DescribeRegionsRequest
parser = argparse.ArgumentParser()
parser.add_argument('-k',
'--alicloud_access_key',
help='Alicloud Key',
required=True)
parser.add_argument('-s',
'--alicloud_secret_key',
help='Alicloud Secret',
required=True)
args = parser.parse_args()
access_key = args.alicloud_access_key
secret_key = args.alicloud_secret_key
client = AcsClient(access_key, secret_key, 'ap-southeast-1')
request = DescribeRegionsRequest()
request.set_accept_format('json')
response = client.do_action_with_exception(request)
parsed = json.loads(str(response, encoding='utf-8'))
data = parsed['Regions']['Region']
for x in range(len(data)):
print(str(x + 1) + ' :' + '\t' + data[x]["RegionId"])
def show_regions(self):
request = DescribeRegionsRequest()
result = self.send_aliyun_request(request)
regions = result.getex('Regions.Region', [])
print(regions)
return regions
def DescRegionsRequest():
request = DescribeRegionsRequest()
request.set_accept_format('json')
return request
