def format_response(self, item):
d = item.as_dict()
d = {
'id': d.get('id'),
'resource_group': self.parse_resource_to_dict(d.get('id')).get('resource_group'),
'name': d.get('name', None),
'location': d.get('location', '').replace(' ', '').lower(),
'kind': _camel_to_snake(d.get('kind', None)),
'consistency_policy': {'default_consistency_level': _camel_to_snake(d['consistency_policy']['default_consistency_level']),
'max_interval_in_seconds': d['consistency_policy']['max_interval_in_seconds'],
'max_staleness_prefix': d['consistency_policy']['max_staleness_prefix']},
'failover_policies': [{'name': fp['location_name'].replace(' ', '').lower(),
'failover_priority': fp['failover_priority'],
'id': fp['id']} for fp in d['failover_policies']],
'read_locations': [{'name': rl['location_name'].replace(' ', '').lower(),
'failover_priority': rl['failover_priority'],
'id': rl['id'],
'document_endpoint': rl['document_endpoint'],
'provisioning_state': rl['provisioning_state']} for rl in d['read_locations']],
'write_locations': [{'name': wl['location_name'].replace(' ', '').lower(),
'failover_priority': wl['failover_priority'],
'id': wl['id'],
'document_endpoint': wl['document_endpoint'],
'provisioning_state': wl['provisioning_state']} for wl in d['write_locations']],
'database_account_offer_type': d.get('database_account_offer_type'),
'ip_range_filter': d['ip_range_filter'],
'is_virtual_network_filter_enabled': d.get('is_virtual_network_filter_enabled'),
'enable_automatic_failover': d.get('enable_automatic_failover'),
'enable_cassandra': 'EnableCassandra' in d.get('capabilities', []),
'enable_table': 'EnableTable' in d.get('capabilities', []),
'enable_gremlin': 'EnableGremlin' in d.get('capabilities', []),
'virtual_network_rules': d.get('virtual_network_rules'),
'enable_multiple_write_locations': d.get('enable_multiple_write_locations'),
'document_endpoint': d.get('document_endpoint'),
'provisioning_state': d.get('provisioning_state'),
'tags': d.get('tags', None)
}
if self.retrieve_keys == 'all':
keys = self.mgmt_client.database_accounts.list_keys(resource_group_name=self.resource_group,
account_name=self.name)
d['primary_master_key'] = keys.primary_master_key
d['secondary_master_key'] = keys.secondary_master_key
d['primary_readonly_master_key'] = keys.primary_readonly_master_key
d['secondary_readonly_master_key'] = keys.secondary_readonly_master_key
elif self.retrieve_keys == 'readonly':
keys = self.mgmt_client.database_accounts.get_read_only_keys(resource_group_name=self.resource_group,
account_name=self.name)
d['primary_readonly_master_key'] = keys.primary_readonly_master_key
d['secondary_readonly_master_key'] = keys.secondary_readonly_master_key
if self.retrieve_connection_strings:
connection_strings = self.mgmt_client.database_accounts.list_connection_strings(resource_group_name=self.resource_group,
account_name=self.name)
d['connection_strings'] = connection_strings.as_dict()
return d
def instance_to_dict(self, instance):
result = dict()
instance_type = getattr(self.servicebus_models,
'SB{0}'.format(str.capitalize(self.type)))
attribute_map = instance_type._attribute_map
for attribute in attribute_map.keys():
value = getattr(instance, attribute)
if attribute_map[attribute]['type'] == 'duration':
if is_valid_timedelta(value):
key = duration_spec_map.get(attribute) or attribute
result[key] = int(value.total_seconds())
elif attribute == 'status':
result['status'] = _camel_to_snake(value)
elif isinstance(value, self.servicebus_models.MessageCountDetails):
result[attribute] = value.as_dict()
elif isinstance(value, self.servicebus_models.SBSku):
result[attribute] = value.name.lower()
elif isinstance(value, datetime):
result[attribute] = str(value)
elif isinstance(value, str):
result[attribute] = to_native(value)
elif attribute == 'max_size_in_megabytes':
result['max_size_in_mb'] = value
else:
result[attribute] = value
if self.show_sas_policies and self.type != 'subscription':
policies = self.get_auth_rules()
for name in policies.keys():
policies[name]['keys'] = self.get_sas_key(name)
result['sas_policies'] = policies
if self.namespace:
result['namespace'] = self.namespace
if self.topic:
result['topic'] = self.topic
return result
def to_dict(self, instance):
result = dict()
attribute_map = self.servicebus_models.SBTopic._attribute_map
for attribute in attribute_map.keys():
value = getattr(instance, attribute)
if not value:
continue
if attribute_map[attribute]['type'] == 'duration':
if is_valid_timedelta(value):
key = duration_spec_map.get(attribute) or attribute
result[key] = int(value.total_seconds())
elif attribute == 'status':
result['status'] = _camel_to_snake(value)
elif isinstance(value, self.servicebus_models.MessageCountDetails):
result[attribute] = value.as_dict()
elif isinstance(value, self.servicebus_models.SBSku):
result[attribute] = value.name.lower()
elif isinstance(value, datetime):
result[attribute] = str(value)
elif isinstance(value, str):
result[attribute] = to_native(value)
elif attribute == 'max_size_in_megabytes':
result['max_size_in_mb'] = value
else:
result[attribute] = value
return result
def route_to_dict(self, route):
return dict(
name=route.name,
source=_camel_to_snake(route.source),
endpoint_name=route.endpoint_names[0],
enabled=route.is_enabled,
condition=route.condition
)
def route_to_dict(route):
id_dict = azure_id_to_dict(route.id)
return dict(id=route.id,
name=route.name,
resource_group=id_dict.get('resourceGroups'),
route_table_name=id_dict.get('routeTables'),
address_prefix=route.address_prefix,
next_hop_type=_camel_to_snake(route.next_hop_type),
next_hop_ip_address=route.next_hop_ip_address)
def format_response(self, item):
d = item.as_dict()
d = {
'resource_group': self.resource_group,
'lab_name': self.lab_name,
'name': _camel_to_snake(d.get('name')),
'id': d.get('id', None),
'tags': d.get('tags', None),
'time': d.get('daily_recurrence', {}).get('time'),
'time_zone_id': d.get('time_zone_id')
}
return d
def to_dict(self, workspace):
result = workspace.as_dict()
result['sku'] = _camel_to_snake(workspace.sku.name)
if self.show_intelligence_packs:
result['intelligence_packs'] = self.list_intelligence_packs()
if self.show_management_groups:
result['management_groups'] = self.list_management_groups()
if self.show_shared_keys:
result['shared_keys'] = self.get_shared_keys()
if self.show_usages:
result['usages'] = self.list_usages()
return result
def to_dict(self, lock):
resp = dict(
id=lock['id'],
name=lock['name'],
level=_camel_to_snake(lock['properties']['level']),
managed_resource_id=re.sub('/providers/Microsoft.Authorization/locks/.+', '', lock['id'])
)
if lock['properties'].get('notes'):
resp['notes'] = lock['properties']['notes']
if lock['properties'].get('owners'):
resp['owners'] = [x['application_id'] for x in lock['properties']['owners']]
return resp
def format_item(self, item):
d = item.as_dict()
containers = d['containers']
ports = d['ip_address']['ports'] if 'ip_address' in d else []
resource_group = d['id'].split('resourceGroups/')[1].split('/')[0]
for port_index in range(len(ports)):
ports[port_index] = ports[port_index]['port']
for container_index in range(len(containers)):
old_container = containers[container_index]
new_container = {
'name': old_container['name'],
'image': old_container['image'],
'memory':
old_container['resources']['requests']['memory_in_gb'],
'cpu': old_container['resources']['requests']['cpu'],
'ports': [],
'commands': old_container.get('command'),
'environment_variables':
old_container.get('environment_variables')
}
for port_index in range(len(old_container['ports'])):
new_container['ports'].append(
old_container['ports'][port_index]['port'])
containers[container_index] = new_container
d = {
'id':
d['id'],
'resource_group':
resource_group,
'name':
d['name'],
'os_type':
d['os_type'],
'dns_name_label':
d['ip_address'].get('dns_name_label'),
'ip_address':
d['ip_address']['ip'] if 'ip_address' in d else '',
'ports':
ports,
'location':
d['location'],
'containers':
containers,
'restart_policy':
_camel_to_snake(d.get('restart_policy'))
if d.get('restart_policy') else None,
'tags':
d.get('tags', None)
}
return d
def lookup_route(self, target, routes):
if not routes or len(routes) == 0:
return False
for item in routes:
if item.name == target['name']:
if target['source'] != _camel_to_snake(item.source):
return False
if target['enabled'] != item.is_enabled:
return False
if target['endpoint_name'] != item.endpoint_names[0]:
return False
if target.get('condition') and target['condition'] != item.condition:
return False
return True
return False
def serialize_endpoint(endpoint):
result = dict(
id=endpoint.id,
name=endpoint.name,
target_resource_id=endpoint.target_resource_id,
target=endpoint.target,
status=endpoint.endpoint_status,
weight=endpoint.weight,
priority=endpoint.priority,
location=endpoint.endpoint_location,
min_child_endpoints=endpoint.min_child_endpoints,
geo_mapping=endpoint.geo_mapping,
)
if endpoint.type:
result['type'] = _camel_to_snake(endpoint.type.split("/")[-1])
return result
def serialize_endpoint(endpoint, resource_group):
result = dict(id=endpoint.id,
name=endpoint.name,
target_resource_id=endpoint.target_resource_id,
target=endpoint.target,
enabled=True,
weight=endpoint.weight,
priority=endpoint.priority,
location=endpoint.endpoint_location,
min_child_endpoints=endpoint.min_child_endpoints,
geo_mapping=endpoint.geo_mapping,
monitor_status=endpoint.endpoint_monitor_status,
resource_group=resource_group)
if endpoint.endpoint_status and endpoint.endpoint_status == 'Disabled':
result['enabled'] = False
if endpoint.type:
result['type'] = _camel_to_snake(endpoint.type.split("/")[-1])
return result
def test_reversible_camel_to_snake(self):
for (k, v) in EXPECTED_REVERSIBLE.items():
self.assertEqual(_camel_to_snake(k, reversible=True), v)
def test_camel_to_snake(self):
for (k, v) in EXPECTED_SNAKIFICATION.items():
assert _camel_to_snake(k) == v
def to_dict(self, workspace):
result = workspace.as_dict()
result['sku'] = _camel_to_snake(workspace.sku.name)
return result
def test_camel_to_snake_and_back(self):
for (k, v) in EXPECTED_REVERSIBLE.items():
self.assertEqual(_snake_to_camel(_camel_to_snake(k, reversible=True), capitalize_first=True), k)
def test_camel_to_snake(self):
for (k, v) in EXPECTED_SNAKIFICATION.items():
self.assertEqual(_camel_to_snake(k), v)
