async def _parse_instance(self, raw_instance):
instance_dict = {}
instance_dict['id'] = get_non_provider_id(raw_instance.id.lower())
instance_dict['name'] = raw_instance.name
instance_dict['vm_id'] = raw_instance.vm_id
instance_dict['zones'] = raw_instance.zones
instance_dict['instance_view'] = raw_instance.instance_view
instance_dict['availability_set'] = raw_instance.availability_set
instance_dict[
'proximity_placement_group'] = raw_instance.proximity_placement_group
instance_dict['additional_properties'] = list(
raw_instance.additional_properties)
instance_dict['location'] = raw_instance.location
instance_dict['type'] = raw_instance.type
instance_dict['resources'] = raw_instance.resources
if raw_instance.tags is not None:
instance_dict['tags'] = [
"{}:{}".format(key, value)
for key, value in raw_instance.tags.items()
]
else:
instance_dict['tags'] = []
instance_dict['resource_group_name'] = get_resource_group_name(
raw_instance.id)
instance_dict['provisioning_state'] = raw_instance.provisioning_state
instance_dict['plan'] = raw_instance.plan
instance_dict['identity'] = raw_instance.identity
instance_dict[
'additional_capabilities'] = raw_instance.additional_capabilities
instance_dict['license_type'] = raw_instance.license_type
# TODO process and display the below
instance_dict['hardware_profile'] = raw_instance.hardware_profile
instance_dict['diagnostics_profile'] = raw_instance.diagnostics_profile
instance_dict['os_profile'] = raw_instance.os_profile
instance_dict['storage_profile'] = raw_instance.storage_profile
instance_dict['network_profile'] = raw_instance.network_profile
# instance_dict['network_profile'] = raw_instance.network_profile
instance_dict['network_interfaces'] = []
for interface in raw_instance.network_profile.network_interfaces:
instance_dict['network_interfaces'].append(
get_non_provider_id(interface.id))
instance_dict[
'extensions'] = await self.facade.virtualmachines.get_instance_extensions(
subscription_id=self.subscription_id,
instance_name=instance_dict['name'],
resource_group=get_resource_group_name(raw_instance.id))
return instance_dict['id'], instance_dict
def _parse_application_security_group(self,
raw_application_security_group):
application_security_group_dict = {}
application_security_group_dict['id'] = get_non_provider_id(
raw_application_security_group.id)
application_security_group_dict[
'name'] = raw_application_security_group.name
application_security_group_dict[
'type'] = raw_application_security_group.type
application_security_group_dict[
'location'] = raw_application_security_group.location
if raw_application_security_group.tags is not None:
application_security_group_dict['tags'] = [
"{}:{}".format(key, value)
for key, value in raw_application_security_group.tags.items()
]
else:
application_security_group_dict['tags'] = []
application_security_group_dict[
'resource_group_name'] = get_resource_group_name(
raw_application_security_group.id)
application_security_group_dict[
'resource_guid'] = raw_application_security_group.resource_guid
application_security_group_dict[
'provisioning_state'] = raw_application_security_group.provisioning_state
application_security_group_dict[
'etag'] = raw_application_security_group.etag
application_security_group_dict['network_interfaces'] = [
] # this is filled in the base class
return application_security_group_dict[
'id'], application_security_group_dict
async def fetch_all(self):
for db in await self.facade.sqldatabase.get_databases(
self.resource_group_name, self.server_name,
self.subscription_id):
# We do not want to scan 'master' database which is auto-generated by Azure and read-only:
if db.name == 'master':
continue
self[db.name] = {
'id':
db.name,
'name':
db.name,
'tags':
["{}:{}".format(key, value) for key, value in db.tags.items()]
if db.tags is not None else [],
'resource_group_name':
get_resource_group_name(db.id)
}
await self._fetch_children_of_all_resources(
resources=self,
scopes={
db_id: {
'resource_group_name': self.resource_group_name,
'server_name': self.server_name,
'database_name': db['name'],
'subscription_id': self.subscription_id
}
for (db_id, db) in self.items()
})
async def _get_and_set_web_app_configuration(self, web_app, api_client):
resource_group_name = get_resource_group_name(web_app.id)
try:
web_app_config = await run_concurrently(
lambda: api_client.web_apps.get_configuration(resource_group_name, web_app.name)
)
except Exception as e:
print_exception(f'Failed to retrieve web app configuration: {e}')
setattr(web_app, 'config', None)
else:
setattr(web_app, 'config', web_app_config)
async def _get_and_set_web_app_auth_settings(self, web_app, api_client):
resource_group_name = get_resource_group_name(web_app.id)
try:
web_app_auth_settings = await run_concurrently(
lambda: api_client.web_apps.get_auth_settings(resource_group_name=resource_group_name,
name=web_app.name)
)
except Exception as e:
print_exception(f'Failed to retrieve web app auth settings: {e}')
setattr(web_app, 'auth_settings', None)
else:
setattr(web_app, 'auth_settings', web_app_auth_settings)
def _get_servers(self, api_client, method, list_params):
servers = []
servers_raw = method(**list_params)
for server in servers_raw:
resource_group_name = get_resource_group_name(server.id)
setattr(server, "azure_ad_admin_settings",
self._get_azure_ad_admin_settings(api_client, resource_group_name, server.name))
setattr(server, "databases",
self._get_databases(api_client, resource_group_name, server.name))
servers.append(server)
return servers
def _parse_virtual_network(self, raw_virtual_network):
virtual_network_dict = {}
virtual_network_dict['id'] = get_non_provider_id(raw_virtual_network.id)
virtual_network_dict['name'] = raw_virtual_network.name
virtual_network_dict['enable_vm_protection'] = raw_virtual_network.enable_vm_protection
virtual_network_dict['etag'] = str(raw_virtual_network.etag)
if raw_virtual_network.tags is not None:
virtual_network_dict['tags'] = ["{}:{}".format(key, value) for key, value in raw_virtual_network.tags.items()]
else:
virtual_network_dict['tags'] = []
virtual_network_dict['resource_group_name'] = get_resource_group_name(raw_virtual_network.id)
virtual_network_dict['virtual_network_peerings'] = raw_virtual_network.virtual_network_peerings
virtual_network_dict['enable_ddos_protection'] = raw_virtual_network.enable_ddos_protection
virtual_network_dict['resource_guid'] = raw_virtual_network.resource_guid
virtual_network_dict['provisioning_state'] = raw_virtual_network.provisioning_state
virtual_network_dict['address_space'] = raw_virtual_network.address_space
virtual_network_dict['ddos_protection_plan'] = raw_virtual_network.ddos_protection_plan
virtual_network_dict['additional_properties'] = list(raw_virtual_network.additional_properties)
virtual_network_dict['location'] = raw_virtual_network.location
virtual_network_dict['type'] = raw_virtual_network.type
virtual_network_dict['dhcp_options'] = raw_virtual_network.dhcp_options
virtual_network_dict['subnets'] = {}
virtual_network_dict['subnets_count'] = 0
for raw_subnet in raw_virtual_network.subnets:
subnet_dict = {}
subnet_dict['id'] = get_non_provider_id(raw_subnet.id)
subnet_dict['name'] = raw_subnet.name
subnet_dict['service_association_links'] = raw_subnet.service_association_links
subnet_dict['resource_navigation_links'] = raw_subnet.resource_navigation_links
subnet_dict['service_endpoint_policies'] = raw_subnet.service_endpoint_policies
subnet_dict['interface_endpoints'] = raw_subnet.interface_endpoints if \
hasattr(raw_subnet, 'interface_endpoints') else None
subnet_dict['purpose'] = raw_subnet.purpose
subnet_dict['address_prefix'] = raw_subnet.address_prefix
subnet_dict['provisioning_state'] = raw_subnet.provisioning_state
subnet_dict['etag'] = str(raw_subnet.etag)
subnet_dict['additional_properties'] = raw_subnet.additional_properties
subnet_dict['route_table'] = raw_subnet.route_table
subnet_dict['delegations'] = raw_subnet.delegations
subnet_dict['service_endpoints'] = raw_subnet.service_endpoints
subnet_dict['ip_configuration_profiles'] = raw_subnet.ip_configuration_profiles
subnet_dict['ip_configurations'] = raw_subnet.ip_configurations
subnet_dict['address_prefixes'] = raw_subnet.address_prefixes
if raw_subnet.network_security_group:
subnet_dict['network_security_group'] = get_non_provider_id(raw_subnet.network_security_group.id)
else:
subnet_dict['network_security_group'] = None
virtual_network_dict['subnets_count'] += 1
virtual_network_dict['subnets'][subnet_dict['id']] = subnet_dict
return virtual_network_dict['id'], virtual_network_dict
def _parse_server(self, raw_server):
server = {}
server['id'] = get_non_provider_id(raw_server.id)
server['name'] = raw_server.name
server['resource_group_name'] = get_resource_group_name(raw_server.id)
if raw_server.tags is not None:
server['tags'] = [
"{}:{}".format(key, value)
for key, value in raw_server.tags.items()
]
else:
server['tags'] = []
return server['id'], server
def _parse_storage_account(self, raw_storage_account):
storage_account = {}
raw_id = raw_storage_account.id
storage_account['id'] = get_non_provider_id(raw_id.lower())
storage_account['resource_group_name'] = get_resource_group_name(raw_id)
storage_account['name'] = raw_storage_account.name
storage_account['https_traffic_enabled'] = raw_storage_account.enable_https_traffic_only
storage_account['public_traffic_allowed'] = self._is_public_traffic_allowed(raw_storage_account)
storage_account['trusted_microsoft_services_enabled'] = \
self._is_trusted_microsoft_services_enabled(raw_storage_account)
storage_account['bypass'] = raw_storage_account.network_rule_set.bypass
storage_account['access_keys_last_rotation_date'] = \
self._parse_access_keys_last_rotation_date(raw_storage_account.activity_logs)
return storage_account['id'], storage_account
def _parse_network_watcher(self, raw_watcher):
watcher_dict = {}
watcher_dict['id'] = get_non_provider_id(raw_watcher.id)
watcher_dict['name'] = raw_watcher.name
watcher_dict['type'] = raw_watcher.type
watcher_dict['location'] = raw_watcher.location
if raw_watcher.tags is not None:
watcher_dict['tags'] = ["{}:{}".format(key, value) for key, value in raw_watcher.tags.items()]
else:
watcher_dict['tags'] = []
watcher_dict['resource_group_name'] = get_resource_group_name(raw_watcher.id)
watcher_dict['etag'] = raw_watcher.etag
watcher_dict['additional_properties'] = raw_watcher.additional_properties
watcher_dict['provisioning_state'] = raw_watcher.provisioning_state
return watcher_dict['id'], watcher_dict
async def fetch_all(self):
for server in await self.facade.sqldatabase.get_servers(self.subscription_id):
id = get_non_provider_id(server.id)
resource_group_name = get_resource_group_name(server.id)
self[id] = {
'id': id,
'name': server.name,
'resource_group_name': resource_group_name
}
await self._fetch_children_of_all_resources(
resources=self,
scopes={server_id: {'resource_group_name': server['resource_group_name'],
'server_name': server['name'],
'subscription_id': self.subscription_id}
for (server_id, server) in self.items()}
)
def _parse_key_vault(self, raw_vault):
vault = {}
vault['id'] = get_non_provider_id(raw_vault.id)
vault['name'] = raw_vault.name
vault['type'] = raw_vault.type
vault['location'] = raw_vault.location
vault['additional_properties'] = raw_vault.additional_properties
if raw_vault.tags is not None:
vault['tags'] = [
"{}:{}".format(key, value)
for key, value in raw_vault.tags.items()
]
else:
vault['tags'] = []
vault['resource_group_name'] = get_resource_group_name(raw_vault.id)
vault['properties'] = raw_vault.properties
vault['public_access_allowed'] = self._is_public_access_allowed(
raw_vault)
return vault['id'], vault
async def fetch_all(self):
self['servers'] = {}
for server in await self.facade.sqldatabase.get_servers():
id = get_non_provider_id(server.id)
resource_group_name = get_resource_group_name(server.id)
self['servers'][id] = {
'id': id,
'name': server.name,
'resource_group_name': resource_group_name
}
self['servers_count'] = len(self['servers'])
await self._fetch_children_of_all_resources(
resources=self['servers'],
scopes={
server_id: {
'resource_group_name': server['resource_group_name'],
'server_name': server['name']
}
for (server_id, server) in self['servers'].items()
})
def _parse_server(self, raw_server):
server = {}
server['id'] = get_non_provider_id(raw_server.id)
server['name'] = raw_server.name
server['resource_group_name'] = get_resource_group_name(raw_server.id)
return server['id'], server
def _parse_network_interface(self, raw_network_interface):
network_interface_dict = {}
network_interface_dict['id'] = get_non_provider_id(
raw_network_interface.id)
network_interface_dict[
'enable_accelerated_networking'] = raw_network_interface.enable_accelerated_networking
network_interface_dict['virtual_machine'] = \
get_non_provider_id(raw_network_interface.virtual_machine.id.lower()) if \
raw_network_interface.virtual_machine else None
network_interface_dict['name'] = raw_network_interface.name
if raw_network_interface.tags is not None:
network_interface_dict['tags'] = [
"{}:{}".format(key, value)
for key, value in raw_network_interface.tags.items()
]
else:
network_interface_dict['tags'] = []
network_interface_dict[
'resource_group_name'] = get_resource_group_name(
raw_network_interface.id)
network_interface_dict['interface_endpoint'] = raw_network_interface.interface_endpoint if \
hasattr(raw_network_interface, 'interface_endpoint') else None
network_interface_dict['primary'] = raw_network_interface.primary
network_interface_dict['etag'] = raw_network_interface.etag
network_interface_dict[
'additional_properties'] = raw_network_interface.additional_properties
network_interface_dict['location'] = raw_network_interface.location
network_interface_dict[
'mac_address'] = raw_network_interface.mac_address
network_interface_dict[
'provisioning_state'] = raw_network_interface.provisioning_state
network_interface_dict[
'resource_guid'] = raw_network_interface.resource_guid
network_interface_dict[
'enable_ip_forwarding'] = raw_network_interface.enable_ip_forwarding
network_interface_dict['type'] = raw_network_interface.type
network_interface_dict['network_security_group'] = \
get_non_provider_id(raw_network_interface.network_security_group.id) if \
raw_network_interface.network_security_group else None
# TODO process and display the below
network_interface_dict[
'hosted_workloads'] = raw_network_interface.hosted_workloads
network_interface_dict[
'tap_configurations'] = raw_network_interface.tap_configurations
network_interface_dict[
'dns_settings'] = raw_network_interface.dns_settings
ip_configuration = raw_network_interface.ip_configurations[
0] # TODO is this always an array of 1?
network_interface_dict['ip_configuration'] = {}
network_interface_dict['ip_configuration']['id'] = ip_configuration.id
network_interface_dict['ip_configuration'][
'additional_properties'] = ip_configuration.additional_properties
network_interface_dict['ip_configuration'][
'virtual_network_taps'] = ip_configuration.virtual_network_taps
network_interface_dict['ip_configuration'][
'application_gateway_backend_address_pools'] = ip_configuration.application_gateway_backend_address_pools
network_interface_dict['ip_configuration'][
'load_balancer_backend_address_pools'] = ip_configuration.load_balancer_backend_address_pools
network_interface_dict['ip_configuration'][
'load_balancer_inbound_nat_rules'] = ip_configuration.load_balancer_inbound_nat_rules
network_interface_dict['ip_configuration'][
'private_ip_address'] = ip_configuration.private_ip_address
network_interface_dict['ip_configuration'][
'private_ip_allocation_method'] = ip_configuration.private_ip_allocation_method
network_interface_dict['ip_configuration'][
'private_ip_address_version'] = ip_configuration.private_ip_address_version
network_interface_dict['ip_configuration']['subnet'] = {
'id': get_non_provider_id(ip_configuration.subnet.id)
}
network_interface_dict['ip_configuration'][
'primary'] = ip_configuration.primary
network_interface_dict['ip_configuration'][
'public_ip_address'] = ip_configuration.public_ip_address
network_interface_dict['ip_configuration'][
'provisioning_state'] = ip_configuration.provisioning_state
network_interface_dict['ip_configuration'][
'name'] = ip_configuration.name
network_interface_dict['ip_configuration'][
'etag'] = ip_configuration.etag
network_interface_dict['ip_configuration'][
'application_security_groups'] = []
if ip_configuration.application_security_groups:
for asg in ip_configuration.application_security_groups:
network_interface_dict['ip_configuration'][
'application_security_groups'].append(
get_non_provider_id(asg.id))
# FIXME this is currently always None, might change in the future?
# network_interface_dict['ip_configuration']['subnet_security_group'] = ip_configuration.subnet.network_security_group
return network_interface_dict['id'], network_interface_dict
async def _parse_instance(self, raw_instance):
instance_dict = {}
instance_dict['id'] = get_non_provider_id(raw_instance.id.lower())
instance_dict['name'] = raw_instance.name
instance_dict['vm_id'] = raw_instance.vm_id
instance_dict['zones'] = raw_instance.zones
if raw_instance.availability_set is not None:
#Get the resource group and availability set if set
try:
instance_dict[
'availability_set'] = raw_instance.availability_set.id.split(
'/')[4] + ':' + raw_instance.availability_set.id.split(
'/')[8]
except Exception as e:
instance_dict[
'availability_set'] = raw_instance.availability_set.id
else:
instance_dict['availability_set'] = None
if raw_instance.proximity_placement_group is not None:
#Get the resource group and proximity placement group if set
try:
instance_dict[
'proximity_placement_group'] = raw_instance.proximity_placement_group.id.split(
'/'
)[4] + ':' + raw_instance.proximity_placement_group.id.split(
'/')[8]
except Exception as e:
instance_dict[
'proximity_placement_group'] = raw_instance.proximity_placement_group.id
else:
instance_dict['proximity_placement_group'] = None
instance_dict['additional_properties'] = list(
raw_instance.additional_properties)
instance_dict['location'] = raw_instance.location
instance_dict['type'] = raw_instance.type
instance_dict['resources'] = raw_instance.resources
if raw_instance.tags is not None:
instance_dict['tags'] = [
"{}:{}".format(key, value)
for key, value in raw_instance.tags.items()
]
else:
instance_dict['tags'] = []
instance_dict['resource_group_name'] = get_resource_group_name(
raw_instance.id)
instance_dict['provisioning_state'] = raw_instance.provisioning_state
if raw_instance.plan is not None:
instance_dict['plan'] = raw_instance.plan.name
else:
instance_dict['plan'] = None
instance_dict['identity'] = raw_instance.identity
if raw_instance.additional_capabilities is not None:
#Get all the enabled additional capabilities ignoring not set or empty values
instance_dict['additional_capabilities'] = [
additional_capability for additional_capability, value in
raw_instance.additional_capabilities.__dict__.items()
if (value and value is not None)
]
else:
instance_dict['additional_capabilities'] = None
instance_dict['license_type'] = raw_instance.license_type
# TODO process and display the below
instance_dict[
'hardware_profile'] = raw_instance.hardware_profile.vm_size
instance_dict['diagnostics_profile'] = {
'Boot Diagnostics':
True if raw_instance.diagnostics_profile.boot_diagnostics.enabled
else None
}
instance_dict['os_profile'] = {}
if raw_instance.os_profile is not None:
instance_dict['os_profile'][
'Administrator Username'] = raw_instance.os_profile.admin_username
instance_dict['os_profile'][
'Allow Extension Operations'] = raw_instance.os_profile.allow_extension_operations
instance_dict['os_profile'][
'Computer Name'] = raw_instance.os_profile.computer_name
instance_dict['os_profile'][
'Custom Data'] = raw_instance.os_profile.custom_data
instance_dict['os_profile']['Secrets'] = ''.join(
raw_instance.os_profile.secrets)
if raw_instance.os_profile.windows_configuration:
instance_dict['os_profile'][
'Unnatended Content'] = raw_instance.os_profile.windows_configuration.additional_unattend_content
instance_dict['os_profile'][
'Automatic Updates'] = raw_instance.os_profile.windows_configuration.enable_automatic_updates
instance_dict['os_profile'][
'VM Agent Provision'] = raw_instance.os_profile.windows_configuration.provision_vm_agent
instance_dict['os_profile'][
'Windows Remote Management'] = raw_instance.os_profile.windows_configuration.win_rm
elif raw_instance.os_profile.linux_configuration:
instance_dict['os_profile'][
'Disable Password Authentication'] = raw_instance.os_profile.linux_configuration.disable_password_authentication
instance_dict['os_profile'][
'VM Agent Provision'] = raw_instance.os_profile.linux_configuration.provision_vm_agent
if raw_instance.storage_profile is not None:
instance_dict['storage_profile'] = {}
instance_dict['storage_profile'][
'Publisher'] = raw_instance.storage_profile.image_reference.publisher
instance_dict['storage_profile'][
'Release'] = raw_instance.storage_profile.image_reference.version
instance_dict['storage_profile'][
'SKU'] = raw_instance.storage_profile.image_reference.sku
instance_dict['storage_profile'][
'Offer'] = raw_instance.storage_profile.image_reference.offer
instance_dict['storage_profile'][
'Exact Version'] = raw_instance.storage_profile.image_reference.exact_version
instance_dict['storage_profile'][
'OS Disk Size (GB)'] = raw_instance.storage_profile.os_disk.disk_size_gb
instance_dict['storage_profile'][
'OS Disk Name'] = raw_instance.storage_profile.os_disk.name
instance_dict['storage_profile'][
'OS Disk VHD'] = raw_instance.storage_profile.os_disk.vhd
instance_dict['storage_profile'][
'OS Managed Disk ID'] = raw_instance.storage_profile.os_disk.managed_disk.id.split(
'/')[-1]
instance_dict['storage_profile'][
'OS Managed Disk Storage Account Type'] = raw_instance.storage_profile.os_disk.managed_disk.storage_account_type
if raw_instance.storage_profile.data_disks is not None and raw_instance.storage_profile.data_disks:
instance_dict['storage_profile']['Data Disks'] = [
"{} ({}GB)".format(disk.name, disk.disk_size_gb)
for disk in raw_instance.storage_profile.data_disks
]
else:
instance_dict['storage_profile'] = None
instance_dict['network_interfaces'] = []
for interface in raw_instance.network_profile.network_interfaces:
instance_dict['network_interfaces'].append(
get_non_provider_id(interface.id))
instance_dict[
'extensions'] = await self.facade.virtualmachines.get_instance_extensions(
subscription_id=self.subscription_id,
instance_name=instance_dict['name'],
resource_group=get_resource_group_name(raw_instance.id))
return instance_dict['id'], instance_dict
def _parse_web_app(self, raw_web_app):
web_app_dict = {}
web_app_dict['id'] = get_non_provider_id(raw_web_app.id)
web_app_dict['name'] = raw_web_app.name
web_app_dict['kind'] = raw_web_app.kind
web_app_dict['location'] = raw_web_app.location
web_app_dict['type'] = raw_web_app.type
if raw_web_app.tags is not None:
web_app_dict['tags'] = [
"{}:{}".format(key, value)
for key, value in raw_web_app.tags.items()
]
else:
web_app_dict['tags'] = []
web_app_dict['resource_group_name'] = get_resource_group_name(
raw_web_app.id)
web_app_dict['state'] = raw_web_app.state
web_app_dict['host_names'] = raw_web_app.host_names
web_app_dict['repository_site_name'] = raw_web_app.repository_site_name
web_app_dict['usage_state'] = raw_web_app.usage_state
web_app_dict['enabled'] = raw_web_app.enabled
web_app_dict['https_only'] = raw_web_app.https_only
web_app_dict['enabled_host_names'] = raw_web_app.enabled_host_names
web_app_dict['availability_state'] = raw_web_app.availability_state
web_app_dict['host_name_ssl_states'] = raw_web_app.host_name_ssl_states
web_app_dict['server_farm_id'] = raw_web_app.server_farm_id
web_app_dict['reserved'] = raw_web_app.reserved
web_app_dict['is_xenon'] = raw_web_app.is_xenon
web_app_dict['hyper_v'] = raw_web_app.hyper_v
web_app_dict[
'last_modified_time_utc'] = raw_web_app.last_modified_time_utc
web_app_dict['site_config'] = raw_web_app.site_config
web_app_dict[
'traffic_manager_host_names'] = raw_web_app.traffic_manager_host_names
web_app_dict[
'scm_site_also_stopped'] = raw_web_app.scm_site_also_stopped
web_app_dict['target_swap_slot'] = raw_web_app.target_swap_slot
web_app_dict[
'hosting_environment_profile'] = raw_web_app.hosting_environment_profile
web_app_dict[
'client_affinity_enabled'] = raw_web_app.client_affinity_enabled
web_app_dict['client_cert_enabled'] = raw_web_app.client_cert_enabled
web_app_dict[
'client_cert_exclusion_paths'] = raw_web_app.client_cert_exclusion_paths
web_app_dict['host_names_disabled'] = raw_web_app.host_names_disabled
web_app_dict['container_size'] = raw_web_app.container_size
web_app_dict[
'daily_memory_time_quota'] = raw_web_app.daily_memory_time_quota
web_app_dict['suspended_till'] = raw_web_app.suspended_till
web_app_dict[
'max_number_of_workers'] = raw_web_app.max_number_of_workers
web_app_dict['cloning_info'] = raw_web_app.cloning_info
web_app_dict['resource_group'] = raw_web_app.resource_group
web_app_dict['is_default_container'] = raw_web_app.is_default_container
web_app_dict['default_host_name'] = raw_web_app.default_host_name
web_app_dict['slot_swap_status'] = raw_web_app.slot_swap_status
web_app_dict['redundancy_mode'] = raw_web_app.redundancy_mode
web_app_dict[
'in_progress_operation_id'] = raw_web_app.in_progress_operation_id
web_app_dict['identity'] = raw_web_app.identity
web_app_dict[
'additional_properties'] = raw_web_app.additional_properties
web_app_dict[
'outbound_ip_addresses'] = raw_web_app.outbound_ip_addresses.split(
',')
web_app_dict[
'possible_outbound_ip_addresses'] = raw_web_app.possible_outbound_ip_addresses.split(
',')
if raw_web_app.config is not None:
web_app_dict[
'minimum_tls_version_supported'] = raw_web_app.config.min_tls_version
web_app_dict['http_2_enabled'] = raw_web_app.config.http20_enabled
web_app_dict[
'http_logging_enabled'] = raw_web_app.config.http_logging_enabled
if raw_web_app.config.linux_fx_version:
web_app_dict[
'programming_language'] = raw_web_app.config.linux_fx_version.split(
'|')[0].lower()
web_app_dict[
'programming_language_version'] = raw_web_app.config.linux_fx_version.split(
'|')[1]
elif raw_web_app.config.windows_fx_version:
web_app_dict[
'programming_language'] = raw_web_app.config.windows_fx_version.split(
'|')[0].lower()
web_app_dict[
'programming_language_version'] = raw_web_app.config.windows_fx_version.split(
'|')[1]
elif raw_web_app.config.net_framework_version:
web_app_dict['programming_language'] = 'dotnet'
web_app_dict[
'programming_language_version'] = raw_web_app.config.net_framework_version
elif raw_web_app.config.php_version:
web_app_dict['programming_language'] = 'php'
web_app_dict[
'programming_language_version'] = raw_web_app.config.php_version
elif raw_web_app.config.python_version:
web_app_dict['programming_language'] = 'python'
web_app_dict[
'programming_language_version'] = raw_web_app.config.python_version
elif raw_web_app.config.node_version:
web_app_dict['programming_language'] = 'node'
web_app_dict[
'programming_language_version'] = raw_web_app.config.node_version
elif raw_web_app.config.java_version:
web_app_dict['programming_language'] = 'java'
web_app_dict[
'programming_language_version'] = raw_web_app.config.java_version
else:
web_app_dict['programming_language'] = None
web_app_dict['programming_language_version'] = None
else:
web_app_dict['minimum_tls_version_supported'] = None
web_app_dict['http_2_enabled'] = None
web_app_dict['http_logging_enabled'] = False
web_app_dict['programming_language'] = None
web_app_dict['programming_language_version'] = None
if raw_web_app.auth_settings is not None:
web_app_dict[
'authentication_enabled'] = raw_web_app.auth_settings.enabled
else:
web_app_dict['authentication_enabled'] = None
return web_app_dict['id'], web_app_dict
