def _init_regional_endpoint_data(self, obj):
if "regional_endpoints" not in obj:
return
self._regional_endpoint_data = obj["regional_endpoints"]
for code, product_data in iteritems(obj["regional_endpoints"]):
for region_id, endpoint in iteritems(product_data):
self.put_endpoint_entry(
self._make_endpoint_entry_key(code, region_id), endpoint)
def _build_canonical_headers(headers, header_begin):
"""
alibabacloud headers
:param headers:
:param header_begin:
:return:
"""
result = ""
unsort_map = dict()
for (key, value) in iteritems(headers):
if key.lower().find(header_begin) >= 0:
unsort_map[key.lower()] = value
sort_map = sorted(iteritems(unsort_map), key=lambda d: d[0])
for (key, value) in sort_map:
result += key + ":" + value
result += "\n"
return result
def _handle_param_aliases(params, aliases):
for key, value in iteritems(aliases):
if key in params:
if value in params:
raise ClientException(
msg="Param {0} is already set.".format(value))
params[value] = params[key]
del params[key]
def _init_global_endpoint_data(self, obj):
if "global_endpoints" not in obj:
return
global_endpoints = obj["global_endpoints"]
for location_service_code, endpoint in iteritems(global_endpoints):
self.put_endpoint_entry(
self._make_endpoint_entry_key(location_service_code), endpoint)
def _replace_occupied_parameters(self):
uri_pattern = copy.deepcopy(self.request.uri_pattern)
paths = self.request.path_params
result = uri_pattern
if paths:
for (key, value) in iteritems(paths):
target = "[" + key + "]"
result = result.replace(target, value)
return result
def status_verify(self, instance):
client = alibabacloud.get_client(service_name='ecs', access_key_id=self.access_key_id,
access_key_secret=self.access_key_secret,
region_id=self.region_id)
response = client.describe_instances(instance_ids=json.dumps([instance.instance_id]))
obj = response['Instances']['Instance'][0]
for key, value in iteritems(obj):
attr_name = self._convert_camel_to_snake(key)
self.assertTrue(hasattr(instance, attr_name), "instance has no " + attr_name)
self.assertEqual(obj[key], getattr(instance, attr_name))
def request_helper(client, request, **params):
for key, value in iteritems(params):
set_name = 'set_' + key
if hasattr(request, set_name):
func = getattr(request, set_name)
func(value)
else:
raise Exception("{0} has no parameter named {1}.".format(
request.__class__.__name__, key))
response = client.do_action_with_exception(request)
return json.loads(response.decode('utf-8'))
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(
msg="Param {0} is already set.".format(value))
params[value] = json.dumps(to_add)
def _build_canonical_resource(uri, queries):
"""
resource and params
:param uri:
:param queries:
:return:
"""
uri_parts = uri.rsplit("?", 1)
if len(uri_parts) > 1 and uri_parts[1] is not None:
queries[uri_parts[1]] = None
query_builder = uri_parts[0]
sorted_map = sorted(iteritems(queries), key=lambda queries: queries[0])
if len(sorted_map) > 0:
query_builder += "?"
for (k, v) in sorted_map:
query_builder += k
if v is not None:
query_builder += "="
query_builder += str(v)
query_builder += "&"
if query_builder.endswith("&"):
query_builder = query_builder[0:(len(query_builder) - 1)]
return query_builder
def _calc_signature(self, method, params):
sorted_parameters = sorted(iteritems(params), key=lambda queries: queries[0])
sorted_query_string = self._pop_standard_urlencode(urlencode(sorted_parameters))
canonicalized_query_string = self._pop_standard_urlencode(pathname2url(sorted_query_string))
string_to_sign = method + "&%2F&" + canonicalized_query_string
return string_to_sign
def _assign_attributes(self, attrs):
for key, value in iteritems(attrs):
setattr(self, _convert_name_from_camel_case_to_snake_case(key),
value)
