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)