def deploy_webapp(self, app_name, group_name, service_plan, storage_account_name):
self.log.info("Deploying Function App %s (%s) in group %s" %
(app_name, service_plan.location, group_name))
site_config = SiteConfig(app_settings=[])
functionapp_def = Site(location=service_plan.location, site_config=site_config)
functionapp_def.kind = 'functionapp,linux'
functionapp_def.server_farm_id = service_plan.id
site_config.linux_fx_version = CONST_DOCKER_VERSION
site_config.always_on = True
app_insights_key = self.get_application_insights_key(group_name,
service_plan.app_service_plan_name)
if app_insights_key:
site_config.app_settings.append(
NameValuePair('APPINSIGHTS_INSTRUMENTATIONKEY', app_insights_key))
con_string = self.get_storage_connection_string(group_name, storage_account_name)
site_config.app_settings.append(NameValuePair('AzureWebJobsStorage', con_string))
site_config.app_settings.append(NameValuePair('AzureWebJobsDashboard', con_string))
site_config.app_settings.append(NameValuePair('FUNCTIONS_EXTENSION_VERSION',
CONST_FUNCTIONS_EXT_VERSION))
site_config.app_settings.append(NameValuePair('FUNCTIONS_WORKER_RUNTIME', 'python'))
#: :type: azure.mgmt.web.WebSiteManagementClient
web_client = self.local_session.client('azure.mgmt.web.WebSiteManagementClient')
web_client.web_apps.create_or_update(group_name, app_name, functionapp_def).wait()
def necessary_functionapp_settings(self):
"""Construct the necessary app settings required for an Azure Function App"""
function_app_settings = []
if self.container_settings is None:
for key in [
'AzureWebJobsStorage',
'WEBSITE_CONTENTAZUREFILECONNECTIONSTRING',
'AzureWebJobsDashboard'
]:
function_app_settings.append(
NameValuePair(name=key,
value=self.storage_connection_string))
function_app_settings.append(
NameValuePair(name='FUNCTIONS_EXTENSION_VERSION', value='~1'))
function_app_settings.append(
NameValuePair(name='WEBSITE_NODE_DEFAULT_VERSION',
value='6.5.0'))
function_app_settings.append(
NameValuePair(name='WEBSITE_CONTENTSHARE', value=self.name))
else:
function_app_settings.append(
NameValuePair(name='FUNCTIONS_EXTENSION_VERSION', value='~2'))
return function_app_settings
def aggregated_app_settings(self):
"""Combine both system and user app settings"""
function_app_settings = self.necessary_functionapp_settings()
for app_setting_key in self.app_settings:
function_app_settings.append(
NameValuePair(name=app_setting_key,
value=self.app_settings[app_setting_key]))
return function_app_settings
async def main():
log.info("Loading secrets")
secrets = load_secrets()
web_client, cosmosdb_client = setup_azure(secrets)
db, keys, connection_string = setup_cosmosdb(cosmosdb_client,
Azure.cosmosdb_name)
configure_collections(Mongo.database_name, Mongo.collections,
keys.primary_master_key, db.document_endpoint)
app_env = deepcopy(secrets["appEnvironment"])
app_env["MajavashakkiMongoConnectionString"] = connection_string
app_env["MajavaMongoPassword"] = keys.primary_master_key
log.info("Creating App Service Plan")
plan = web_client.app_service_plans.create_or_update(
Azure.resource_group,
Azure.plan_name,
app_service_plan=AppServicePlan(Azure.location,
Azure.plan_name,
sku=SKU_B1_BASIC)).result()
log.info("Creating Web App")
env_pairs = [NameValuePair(k, v) for k, v in app_env.items()]
site = web_client.web_apps.create_or_update(
Azure.resource_group, Azure.site_name,
Site(location=Azure.location,
site_config=SiteConfig(
app_settings=env_pairs,
scm_type=ScmType.local_git,
web_sockets_enabled=True,
always_on=True,
))).result()
log.info("Pushing code to App Service")
pub_cred = web_client.web_apps.list_publishing_credentials(
Azure.resource_group, Azure.site_name).result()
git_url = mk_git_url(Azure.site_name, pub_cred)
if "CI" in os.environ:
await shell("git", "-c", "user.name='Majavashakki Deployer'", "-c",
"user.email='*****@*****.**'",
"commit", "--allow-empty", "-m",
"Empty commit to force app service to redeploy")
await shell("git", "push", "--force", git_url, "HEAD:master")
log.info("Done")
def aggregated_app_settings(self):
"""Combine both system and user app settings"""
function_app_settings = self.necessary_functionapp_settings()
for app_setting_key in self.app_settings:
found_setting = None
for s in function_app_settings:
if s.name == app_setting_key:
found_setting = s
break
if found_setting:
found_setting.value = self.app_settings[app_setting_key]
else:
function_app_settings.append(
NameValuePair(name=app_setting_key,
value=self.app_settings[app_setting_key]))
return function_app_settings
def exec_module(self, **kwargs):
"""Main module execution method"""
for key in list(self.module_arg_spec.keys()) + ['tags']:
if hasattr(self, key):
setattr(self, key, kwargs[key])
elif kwargs[key] is not None:
if key == "scm_type":
self.site_config[key] = kwargs[key]
old_response = None
response = None
to_be_updated = False
# set location
resource_group = self.get_resource_group(self.resource_group)
if not self.location:
self.location = resource_group.location
# get existing web app
old_response = self.get_webapp()
if old_response:
self.results['id'] = old_response['id']
if self.state == 'present':
if not self.plan and not old_response:
self.fail("Please specify plan for newly created web app.")
if not self.plan:
self.plan = old_response['server_farm_id']
self.plan = self.parse_resource_to_dict(self.plan)
# get app service plan
is_linux = False
old_plan = self.get_app_service_plan()
if old_plan:
is_linux = old_plan['reserved']
else:
is_linux = self.plan[
'is_linux'] if 'is_linux' in self.plan else False
if self.frameworks:
# java is mutually exclusive with other frameworks
if len(self.frameworks) > 1 and any(f['name'] == 'java'
for f in self.frameworks):
self.fail(
'Java is mutually exclusive with other frameworks.')
if is_linux:
if len(self.frameworks) != 1:
self.fail(
'Can specify one framework only for Linux web app.'
)
if self.frameworks[0][
'name'] not in self.supported_linux_frameworks:
self.fail(
'Unsupported framework {0} for Linux web app.'.
format(self.frameworks[0]['name']))
self.site_config['linux_fx_version'] = (
self.frameworks[0]['name'] + '|' +
self.frameworks[0]['version']).upper()
else:
for fx in self.frameworks:
if fx.get('name'
) not in self.supported_windows_frameworks:
self.fail(
'Unsupported framework {0} for Windows web app.'
.format(fx.get('name')))
else:
self.site_config[fx.get('name') +
'_version'] = fx.get('version')
for fx in self.frameworks:
if 'settings' in fx and fx['settings'] is not None:
for key, value in fx['settings'].items():
self.site_config[key] = value
if not self.app_settings:
self.app_settings = dict()
if self.container_settings:
linux_fx_version = 'DOCKER|'
if self.container_settings.get('registry_server_url'):
self.app_settings[
'DOCKER_REGISTRY_SERVER_URL'] = 'https://' + self.container_settings[
'registry_server_url']
linux_fx_version += self.container_settings[
'registry_server_url'] + '/'
linux_fx_version += self.container_settings['name']
self.site_config['linux_fx_version'] = linux_fx_version
if self.container_settings.get('registry_server_user'):
self.app_settings[
'DOCKER_REGISTRY_SERVER_USERNAME'] = self.container_settings[
'registry_server_user']
if self.container_settings.get('registry_server_password'):
self.app_settings[
'DOCKER_REGISTRY_SERVER_PASSWORD'] = self.container_settings[
'registry_server_password']
# init site
self.site = Site(location=self.location,
site_config=self.site_config)
if self.https_only is not None:
self.site.https_only = self.https_only
if self.client_affinity_enabled:
self.site.client_affinity_enabled = self.client_affinity_enabled
# check if the web app already present in the resource group
if not old_response:
self.log("Web App instance doesn't exist")
to_be_updated = True
self.to_do = Actions.CreateOrUpdate
# service plan is required for creation
if not self.plan:
self.fail(
"Please specify app service plan in plan parameter.")
if not old_plan:
# no existing service plan, create one
if (not self.plan.get('name') or not self.plan.get('sku')):
self.fail('Please specify name, is_linux, sku in plan')
if 'location' not in self.plan:
plan_resource_group = self.get_resource_group(
self.plan['resource_group'])
self.plan['location'] = plan_resource_group.location
old_plan = self.create_app_service_plan()
self.site.server_farm_id = old_plan['id']
# if linux, setup startup_file
if old_plan.get('is_linux'):
if self.startup_file:
self.site_config[
'app_command_line'] = self.startup_file
# set app setting
if self.app_settings:
app_settings = []
for key in self.app_settings.keys():
app_settings.append(
NameValuePair(key, self.app_settings[key]))
self.site_config['app_settings'] = app_settings
else:
# existing web app, do update
self.log("Web App instance already exists")
self.log('Result: {0}'.format(old_response))
update_tags, old_response['tags'] = self.update_tags(
old_response.get('tags', dict()))
if update_tags:
to_be_updated = True
# check if root level property changed
if self.is_updatable_property_changed(old_response):
to_be_updated = True
self.to_do = Actions.CreateOrUpdate
# check if site_config changed
old_config = self.get_webapp_configuration()
if self.is_site_config_changed(old_config):
to_be_updated = True
self.to_do = Actions.CreateOrUpdate
# check if linux_fx_version changed
if old_config.linux_fx_version != self.site_config.get(
'linux_fx_version', ''):
to_be_updated = True
self.to_do = Actions.CreateOrUpdate
self.app_settings_strDic = self.list_app_settings()
# purge existing app_settings:
if self.purge_app_settings:
to_be_updated = True
self.app_settings_strDic.properties = dict()
# check if app settings changed
if self.purge_app_settings or self.is_app_settings_changed():
to_be_updated = True
self.to_do = Actions.CreateOrUpdate
if self.app_settings:
for key in self.app_settings.keys():
self.app_settings_strDic.properties[
key] = self.app_settings[key]
elif self.state == 'absent':
if old_response:
self.log("Delete Web App instance")
self.results['changed'] = True
if self.check_mode:
return self.results
self.delete_webapp()
self.log('Web App instance deleted')
else:
self.fail("Web app {0} not exists.".format(self.name))
if to_be_updated:
self.log('Need to Create/Update web app')
self.results['changed'] = True
if self.check_mode:
return self.results
if self.to_do == Actions.CreateOrUpdate:
response = self.create_update_webapp()
self.results['id'] = response['id']
return self.results
def azure_name_value_pair(name, value):
return NameValuePair(**{'name': name, 'value': value})
def exec_module(self, **kwargs):
"""Main module execution method"""
for key in list(self.module_arg_spec.keys()) + ['tags']:
if hasattr(self, key):
setattr(self, key, kwargs[key])
elif kwargs[key] is not None:
if key == "scm_type":
self.site_config[key] = kwargs[key]
old_response = None
response = None
to_be_updated = False
# set location
resource_group = self.get_resource_group(self.resource_group)
if not self.location:
self.location = resource_group.location
# get web app
webapp_response = self.get_webapp()
if not webapp_response:
self.fail("Web app {0} does not exist in resource group {1}.".format(self.webapp_name, self.resource_group))
# get slot
old_response = self.get_slot()
# set is_linux
is_linux = True if webapp_response['reserved'] else False
if self.state == 'present':
if self.frameworks:
# java is mutually exclusive with other frameworks
if len(self.frameworks) > 1 and any(f['name'] == 'java' for f in self.frameworks):
self.fail('Java is mutually exclusive with other frameworks.')
if is_linux:
if len(self.frameworks) != 1:
self.fail('Can specify one framework only for Linux web app.')
if self.frameworks[0]['name'] not in self.supported_linux_frameworks:
self.fail('Unsupported framework {0} for Linux web app.'.format(self.frameworks[0]['name']))
self.site_config['linux_fx_version'] = (self.frameworks[0]['name'] + '|' + self.frameworks[0]['version']).upper()
if self.frameworks[0]['name'] == 'java':
if self.frameworks[0]['version'] != '8':
self.fail("Linux web app only supports java 8.")
if self.frameworks[0].get('settings', {}) and self.frameworks[0]['settings'].get('java_container', None) and \
self.frameworks[0]['settings']['java_container'].lower() != 'tomcat':
self.fail("Linux web app only supports tomcat container.")
if self.frameworks[0].get('settings', {}) and self.frameworks[0]['settings'].get('java_container', None) and \
self.frameworks[0]['settings']['java_container'].lower() == 'tomcat':
self.site_config['linux_fx_version'] = 'TOMCAT|' + self.frameworks[0]['settings']['java_container_version'] + '-jre8'
else:
self.site_config['linux_fx_version'] = 'JAVA|8-jre8'
else:
for fx in self.frameworks:
if fx.get('name') not in self.supported_windows_frameworks:
self.fail('Unsupported framework {0} for Windows web app.'.format(fx.get('name')))
else:
self.site_config[fx.get('name') + '_version'] = fx.get('version')
if 'settings' in fx and fx['settings'] is not None:
for key, value in fx['settings'].items():
self.site_config[key] = value
if not self.app_settings:
self.app_settings = dict()
if self.container_settings:
linux_fx_version = 'DOCKER|'
if self.container_settings.get('registry_server_url'):
self.app_settings['DOCKER_REGISTRY_SERVER_URL'] = 'https://' + self.container_settings['registry_server_url']
linux_fx_version += self.container_settings['registry_server_url'] + '/'
linux_fx_version += self.container_settings['name']
self.site_config['linux_fx_version'] = linux_fx_version
if self.container_settings.get('registry_server_user'):
self.app_settings['DOCKER_REGISTRY_SERVER_USERNAME'] = self.container_settings['registry_server_user']
if self.container_settings.get('registry_server_password'):
self.app_settings['DOCKER_REGISTRY_SERVER_PASSWORD'] = self.container_settings['registry_server_password']
# set auto_swap_slot_name
if self.auto_swap_slot_name and isinstance(self.auto_swap_slot_name, str):
self.site_config['auto_swap_slot_name'] = self.auto_swap_slot_name
if self.auto_swap_slot_name is False:
self.site_config['auto_swap_slot_name'] = None
# init site
self.site = Site(location=self.location, site_config=self.site_config)
# check if the slot already present in the webapp
if not old_response:
self.log("Web App slot doesn't exist")
to_be_updated = True
self.to_do = Actions.CreateOrUpdate
self.site.tags = self.tags
# if linux, setup startup_file
if self.startup_file:
self.site_config['app_command_line'] = self.startup_file
# set app setting
if self.app_settings:
app_settings = []
for key in self.app_settings.keys():
app_settings.append(NameValuePair(name=key, value=self.app_settings[key]))
self.site_config['app_settings'] = app_settings
# clone slot
if self.configuration_source:
self.clone = True
else:
# existing slot, do update
self.log("Web App slot already exists")
self.log('Result: {0}'.format(old_response))
update_tags, self.site.tags = self.update_tags(old_response.get('tags', None))
if update_tags:
to_be_updated = True
# check if site_config changed
old_config = self.get_configuration_slot(self.name)
if self.is_site_config_changed(old_config):
to_be_updated = True
self.to_do = Actions.CreateOrUpdate
self.app_settings_strDic = self.list_app_settings_slot(self.name)
# purge existing app_settings:
if self.purge_app_settings:
to_be_updated = True
self.to_do = Actions.UpdateAppSettings
self.app_settings_strDic = dict()
# check if app settings changed
if self.purge_app_settings or self.is_app_settings_changed():
to_be_updated = True
self.to_do = Actions.UpdateAppSettings
if self.app_settings:
for key in self.app_settings.keys():
self.app_settings_strDic[key] = self.app_settings[key]
elif self.state == 'absent':
if old_response:
self.log("Delete Web App slot")
self.results['changed'] = True
if self.check_mode:
return self.results
self.delete_slot()
self.log('Web App slot deleted')
else:
self.log("Web app slot {0} not exists.".format(self.name))
if to_be_updated:
self.log('Need to Create/Update web app')
self.results['changed'] = True
if self.check_mode:
return self.results
if self.to_do == Actions.CreateOrUpdate:
response = self.create_update_slot()
self.results['id'] = response['id']
if self.clone:
self.clone_slot()
if self.to_do == Actions.UpdateAppSettings:
self.update_app_settings_slot()
slot = None
if response:
slot = response
if old_response:
slot = old_response
if slot:
if (slot['state'] != 'Stopped' and self.app_state == 'stopped') or \
(slot['state'] != 'Running' and self.app_state == 'started') or \
self.app_state == 'restarted':
self.results['changed'] = True
if self.check_mode:
return self.results
self.set_state_slot(self.app_state)
if self.swap:
self.results['changed'] = True
if self.check_mode:
return self.results
self.swap_slot()
return self.results
def exec_module(self, **kwargs):
"""Main module execution method"""
for key in list(self.module_arg_spec.keys()) + ['tags']:
if hasattr(self, key):
setattr(self, key, kwargs[key])
elif kwargs[key] is not None:
if key == "scm_type":
self.site_config[key] = kwargs[key]
# azure sdk linux_fx_version:
# for docker web app, value is like DOCKER|imagename:tag
# for linux web app, value is like NODE|6.6
if key == "linux_framework":
self.site_config['linux_fx_version'] = (kwargs[key]['name'] + '|' + kwargs[key]['version']).upper()
if key == "java_container_settings":
if 'name' in kwargs['java_container_settings']:
self.site_config['java_container'] = kwargs['java_container_settings']['name']
if 'version' in kwargs['java_container_settings']:
self.site_config['java_container_version'] = kwargs['java_container_settings']['version']
old_response = None
response = None
to_be_updated = False
if self.windows_framework is not None:
if self.windows_framework.get('java_version', None) is not None and len(self.windows_framework) > 1:
self.fail('java_version is mutually exclusive with other framework version in windows_framework.')
for key in list(self.windows_framework.keys()):
self.site_config[key] = self.windows_framework[key]
if self.app_settings is None:
self.app_settings = dict()
if self.plan:
self.plan = self.parse_resource_to_dict(self.plan)
if self.container_settings is not None:
if hasattr(self.site_config, 'linux_fx_version'):
self.fail("Cannot set linux_framework with container_settings at same time.")
linux_fx_version = 'DOCKER|'
if self.container_settings.get('registry_server_url', None) is not None:
self.app_settings['DOCKER_REGISTRY_SERVER_URL'] = 'https://' + self.container_settings['registry_server_url']
linux_fx_version += self.container_settings['registry_server_url'] + '/'
linux_fx_version += self.container_settings['name']
self.site_config['linux_fx_version'] = linux_fx_version
if self.container_settings.get('registry_server_user', None) is not None:
self.app_settings['DOCKER_REGISTRY_SERVER_USERNAME'] = self.container_settings['registry_server_user']
if self.container_settings.get('registry_server_password', None) is not None:
self.app_settings['DOCKER_REGISTRY_SERVER_PASSWORD'] = self.container_settings['registry_server_password']
# set location
resource_group = self.get_resource_group(self.resource_group)
if not self.location:
self.location = resource_group.location
# init site
self.site = Site(location=self.location, site_config=self.site_config)
if self.https_only is not None:
self.site.https_only = self.https_only
if self.client_affinity_enabled:
self.site.client_affinity_enabled = self.client_affinity_enabled
# get existing web app
old_response = self.get_webapp()
# check if the web app already present in the resource group
if not old_response:
self.log("Web App instance doesn't exist")
if self.state == "present":
to_be_updated = True
self.to_do = Actions.CreateOrUpdate
# service plan is required for creation
if not self.plan:
self.fail("Please specify app service plan in plan parameter.")
# get app service plan
old_plan = self.get_app_service_plan()
if not old_plan:
# no existing service plan, create one
if (self.plan['name'] is None or self.plan['sku'] is None):
self.fail('Please specify name, is_linux, sku in plan')
if 'location' not in self.plan:
plan_resource_group = self.get_resource_group(self.plan['resource_group'])
self.plan['location'] = plan_resource_group.location
old_plan = self.create_app_service_plan()
self.site.server_farm_id = old_plan['id']
# if linux, setup startup_file
if hasattr(old_plan, 'is_linux'):
if hasattr(self, 'startup_file'):
self.site_config['app_command_line'] = self.startup_file
# set app setting
if self.app_settings is not None:
app_settings = []
for key in self.app_settings.keys():
app_settings.append(NameValuePair(key, self.app_settings[key]))
self.site_config['app_settings'] = app_settings
else:
# existing web app, do update
self.log("Web App instance already exists")
if self.state == 'present':
self.log('Result: {0}'.format(old_response))
update_tags, old_response['tags'] = self.update_tags(
old_response.get('tags', dict()))
if update_tags:
to_be_updated = True
# check if root level property changed
if self.is_updatable_property_changed(old_response):
to_be_updated = True
self.to_do = Actions.CreateOrUpdate
# check if site_config changed
old_config = self.get_webapp_configuration()
if self.is_site_config_changed(old_config):
to_be_updated = True
self.to_do = Actions.CreateOrUpdate
# check if linux_fx_version changed
if old_config.linux_fx_version != self.site_config.get('linux_fx_version', None):
to_be_updated = True
self.to_do = Actions.CreateOrUpdate
self.app_settings_strDic = self.list_app_settings()
# purge existing app_settings:
if self.purge_app_settings:
self.app_settings_strDic.properties = dict()
# check if app settings changed
if self.purge_app_settings or self.is_app_settings_changed():
to_be_updated = True
self.to_do = Actions.UpdateAppSettings
if self.app_settings is not None:
for key in self.app_settings.keys():
self.app_settings_strDic.properties[key] = self.app_settings[key]
if old_response:
self.results['ansible_facts']['azure_webapp'] = old_response
if to_be_updated:
self.log('Need to Create/Update web app')
self.results['changed'] = True
if self.check_mode:
return self.results
if self.to_do == Actions.CreateOrUpdate:
response = self.create_update_webapp()
self.results['ansible_facts']['azure_webapp'] = response
if self.to_do == Actions.UpdateAppSettings:
response = self.update_app_settings()
self.results['ansible_facts']['azure_webapp']['app_settings'] = response
if self.state == 'absent' and old_response:
self.log("Delete Web App instance")
self.results['changed'] = True
if self.check_mode:
return self.results
self.delete_webapp()
self.log('Web App instance deleted')
return self.results