def test_snake_to_camel_reversed(self): for (k, v) in EXPECTED_REVERSIBLE.items(): self.assertEqual(_snake_to_camel(v, capitalize_first=True), k)
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 exec_module(self, **kwargs): for key in list(self.module_arg_spec.keys()): setattr(self, key, kwargs[key]) changed = False original = self.get() if self.state == 'present': # Create the resource instance params = dict( dead_lettering_on_filter_evaluation_exceptions=self.dead_lettering_on_filter_evaluation_exceptions, dead_lettering_on_message_expiration=self.dead_lettering_on_message_expiration, enable_batched_operations=self.enable_batched_operations, forward_dead_lettered_messages_to=self.forward_dead_lettered_messages_to, forward_to=self.forward_to, max_delivery_count=self.max_delivery_count, requires_session=self.requires_session ) if self.status: params['status'] = self.servicebus_models.EntityStatus(str.capitalize(_snake_to_camel(self.status))) for k, v in duration_spec_map.items(): seconds = getattr(self, v) if seconds: params[k] = timedelta(seconds=seconds) instance = self.servicebus_models.SBSubscription(**params) result = original if not original: changed = True result = instance else: result = original attribute_map_keys = set(self.servicebus_models.SBSubscription._attribute_map.keys()) validation_keys = set(self.servicebus_models.SBSubscription._validation.keys()) attribute_map = attribute_map_keys - validation_keys for attribute in attribute_map: value = getattr(instance, attribute) if value and value != getattr(original, attribute): changed = True if changed and not self.check_mode: result = self.create_or_update(instance) self.results = self.to_dict(result) elif original: changed = True if not self.check_mode: self.delete() self.results['deleted'] = True self.results['changed'] = changed 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: self.batch_account[key] = kwargs[key] resource_group = self.get_resource_group(self.resource_group) if self.batch_account.get('location') is None: self.batch_account['location'] = resource_group.location if self.batch_account.get('auto_storage_account') is not None: self.batch_account['auto_storage'] = { 'storage_account_id': self.normalize_resource_id( self.batch_account.pop('auto_storage_account'), '/subscriptions/{subscription_id}/resourceGroups/{resource_group}/providers/Microsoft.Storage/storageAccounts/{name}' ) } if self.batch_account.get('key_vault') is not None: id = self.normalize_resource_id( self.batch_account.pop('key_vault'), '/subscriptions/{subscription_id}/resourceGroups/{resource_group}/providers/Microsoft.KeyVault/vaults/{name}' ) url = 'https://' + id.split('/').pop() + '.vault.azure.net/' self.batch_account['key_vault_reference'] = {'id': id, 'url': url} self.batch_account['pool_allocation_mode'] = _snake_to_camel( self.batch_account['pool_allocation_mode'], True) response = None self.mgmt_client = self.get_mgmt_svc_client( BatchManagementClient, base_url=self._cloud_environment.endpoints.resource_manager) old_response = self.get_batchaccount() if not old_response: self.log("Batch Account instance doesn't exist") if self.state == 'absent': self.log("Old instance didn't exist") else: self.to_do = Actions.Create else: self.log("Batch Account instance already exists") if self.state == 'absent': self.to_do = Actions.Delete elif self.state == 'present': self.results['old'] = old_response self.results['new'] = self.batch_account if not self.idempotency_check(old_response, self.batch_account): self.to_do = Actions.Update if (self.to_do == Actions.Create) or (self.to_do == Actions.Update): self.log("Need to Create / Update the Batch Account instance") self.results['changed'] = True if self.check_mode: return self.results response = self.create_update_batchaccount() self.log("Creation / Update done") elif self.to_do == Actions.Delete: self.log("Batch Account instance deleted") self.results['changed'] = True if self.check_mode: return self.results self.delete_batchaccount() else: self.log("Batch Account instance unchanged") self.results['changed'] = False response = old_response if self.state == 'present': self.results.update({ 'id': response.get('id', None), 'account_endpoint': response.get('account_endpoint', None) }) 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 == "id": self.parameters["id"] = kwargs[key] elif key == "location": self.parameters["location"] = kwargs[key] elif key == "sku": ev = kwargs[key] if 'name' in ev: if ev['name'] == 'standard_small': ev['name'] = 'Standard_Small' elif ev['name'] == 'standard_medium': ev['name'] = 'Standard_Medium' elif ev['name'] == 'standard_large': ev['name'] = 'Standard_Large' elif ev['name'] == 'waf_medium': ev['name'] = 'WAF_Medium' elif ev['name'] == 'waf_large': ev['name'] = 'WAF_Large' if 'tier' in ev: if ev['tier'] == 'standard': ev['tier'] = 'Standard' elif ev['tier'] == 'waf': ev['tier'] = 'WAF' self.parameters["sku"] = ev elif key == "ssl_policy": ev = kwargs[key] if 'policy_type' in ev: ev['policy_type'] = _snake_to_camel( ev['policy_type'], True) if 'policy_name' in ev: if ev['policy_name'] == 'ssl_policy20150501': ev['policy_name'] = 'AppGwSslPolicy20150501' elif ev['policy_name'] == 'ssl_policy20170401': ev['policy_name'] = 'AppGwSslPolicy20170401' elif ev['policy_name'] == 'ssl_policy20170401_s': ev['policy_name'] = 'AppGwSslPolicy20170401S' if 'min_protocol_version' in ev: if ev['min_protocol_version'] == 'tls_v1_0': ev['min_protocol_version'] = 'TLSv1_0' elif ev['min_protocol_version'] == 'tls_v1_1': ev['min_protocol_version'] = 'TLSv1_1' elif ev['min_protocol_version'] == 'tls_v1_2': ev['min_protocol_version'] = 'TLSv1_2' if 'disabled_ssl_protocols' in ev: protocols = ev['disabled_ssl_protocols'] if protocols is not None: for i in range(len(protocols)): if protocols[i] == 'tls_v1_0': protocols[i] = 'TLSv1_0' elif protocols[i] == 'tls_v1_1': protocols[i] = 'TLSv1_1' elif protocols[i] == 'tls_v1_2': protocols[i] = 'TLSv1_2' if 'cipher_suites' in ev: suites = ev['cipher_suites'] if suites is not None: for i in range(len(suites)): suites[i] = suites[i].upper() elif key == "gateway_ip_configurations": self.parameters["gateway_ip_configurations"] = kwargs[key] elif key == "authentication_certificates": self.parameters["authentication_certificates"] = kwargs[ key] elif key == "ssl_certificates": self.parameters["ssl_certificates"] = kwargs[key] elif key == "redirect_configurations": ev = kwargs[key] for i in range(len(ev)): item = ev[i] if 'redirect_type' in item: item['redirect_type'] = _snake_to_camel( item['redirect_type'], True) if 'target_listener' in item: id = http_listener_id(self.subscription_id, kwargs['resource_group'], kwargs['name'], item['target_listener']) item['target_listener'] = {'id': id} self.parameters["redirect_configurations"] = ev elif key == "frontend_ip_configurations": ev = kwargs[key] for i in range(len(ev)): item = ev[i] if 'private_ip_allocation_method' in item: item[ 'private_ip_allocation_method'] = _snake_to_camel( item['private_ip_allocation_method'], True) if 'public_ip_address' in item: id = public_ip_id(self.subscription_id, kwargs['resource_group'], item['public_ip_address']) item['public_ip_address'] = {'id': id} self.parameters["frontend_ip_configurations"] = ev elif key == "frontend_ports": self.parameters["frontend_ports"] = kwargs[key] elif key == "backend_address_pools": self.parameters["backend_address_pools"] = kwargs[key] elif key == "probes": ev = kwargs[key] for i in range(len(ev)): item = ev[i] if 'protocol' in item: item['protocol'] = _snake_to_camel( item['protocol'], True) self.parameters["probes"] = ev elif key == "backend_http_settings_collection": ev = kwargs[key] for i in range(len(ev)): item = ev[i] if 'protocol' in item: item['protocol'] = _snake_to_camel( item['protocol'], True) if 'cookie_based_affinity' in item: item['cookie_based_affinity'] = _snake_to_camel( item['cookie_based_affinity'], True) if 'probe' in item: id = probe_id(self.subscription_id, kwargs['resource_group'], kwargs['name'], item['probe']) item['probe'] = {'id': id} self.parameters["backend_http_settings_collection"] = ev elif key == "http_listeners": ev = kwargs[key] for i in range(len(ev)): item = ev[i] if 'frontend_ip_configuration' in item: id = frontend_ip_configuration_id( self.subscription_id, kwargs['resource_group'], kwargs['name'], item['frontend_ip_configuration']) item['frontend_ip_configuration'] = {'id': id} if 'frontend_port' in item: id = frontend_port_id(self.subscription_id, kwargs['resource_group'], kwargs['name'], item['frontend_port']) item['frontend_port'] = {'id': id} if 'ssl_certificate' in item: id = ssl_certificate_id(self.subscription_id, kwargs['resource_group'], kwargs['name'], item['ssl_certificate']) item['ssl_certificate'] = {'id': id} if 'protocol' in item: item['protocol'] = _snake_to_camel( item['protocol'], True) ev[i] = item self.parameters["http_listeners"] = ev elif key == "request_routing_rules": ev = kwargs[key] for i in range(len(ev)): item = ev[i] if 'backend_address_pool' in item: id = backend_address_pool_id( self.subscription_id, kwargs['resource_group'], kwargs['name'], item['backend_address_pool']) item['backend_address_pool'] = {'id': id} if 'backend_http_settings' in item: id = backend_http_settings_id( self.subscription_id, kwargs['resource_group'], kwargs['name'], item['backend_http_settings']) item['backend_http_settings'] = {'id': id} if 'http_listener' in item: id = http_listener_id(self.subscription_id, kwargs['resource_group'], kwargs['name'], item['http_listener']) item['http_listener'] = {'id': id} if 'protocol' in item: item['protocol'] = _snake_to_camel( item['protocol'], True) if 'rule_type' in ev: item['rule_type'] = _snake_to_camel( item['rule_type'], True) if 'redirect_configuration' in item: id = redirect_configuration_id( self.subscription_id, kwargs['resource_group'], kwargs['name'], item['redirect_configuration']) item['redirect_configuration'] = {'id': id} ev[i] = item self.parameters["request_routing_rules"] = ev elif key == "etag": self.parameters["etag"] = kwargs[key] old_response = None response = None self.mgmt_client = self.get_mgmt_svc_client( NetworkManagementClient, base_url=self._cloud_environment.endpoints.resource_manager) resource_group = self.get_resource_group(self.resource_group) if "location" not in self.parameters: self.parameters["location"] = resource_group.location old_response = self.get_applicationgateway() if not old_response: self.log("Application Gateway instance doesn't exist") if self.state == 'absent': self.log("Old instance didn't exist") else: self.to_do = Actions.Create else: self.log("Application Gateway instance already exists") if self.state == 'absent': self.to_do = Actions.Delete elif self.state == 'present': self.log( "Need to check if Application Gateway instance has to be deleted or may be updated" ) self.to_do = Actions.Update if (self.to_do == Actions.Update): if (self.parameters['location'] != old_response['location'] or self.parameters['sku']['name'] != old_response['sku']['name'] or self.parameters['sku']['tier'] != old_response['sku']['tier'] or self.parameters['sku']['capacity'] != old_response['sku']['capacity'] or not compare_arrays(old_response, self.parameters, 'authentication_certificates') or not compare_arrays(old_response, self.parameters, 'gateway_ip_configurations') or not compare_arrays(old_response, self.parameters, 'redirect_configurations') or not compare_arrays(old_response, self.parameters, 'frontend_ip_configurations') or not compare_arrays(old_response, self.parameters, 'frontend_ports') or not compare_arrays(old_response, self.parameters, 'backend_address_pools') or not compare_arrays(old_response, self.parameters, 'probes') or not compare_arrays(old_response, self.parameters, 'backend_http_settings_collection') or not compare_arrays(old_response, self.parameters, 'request_routing_rules') or not compare_arrays(old_response, self.parameters, 'http_listeners')): self.to_do = Actions.Update else: self.to_do = Actions.NoAction if (self.to_do == Actions.Create) or (self.to_do == Actions.Update): self.log( "Need to Create / Update the Application Gateway instance") if self.check_mode: self.results['changed'] = True self.results["parameters"] = self.parameters return self.results response = self.create_update_applicationgateway() if not old_response: self.results['changed'] = True else: self.results['changed'] = old_response.__ne__(response) self.log("Creation / Update done") elif self.to_do == Actions.Delete: self.log("Application Gateway instance deleted") self.results['changed'] = True if self.check_mode: return self.results self.delete_applicationgateway() # make sure instance is actually deleted, for some Azure resources, instance is hanging around # for some time after deletion -- this should be really fixed in Azure while self.get_applicationgateway(): time.sleep(20) else: self.log("Application Gateway instance unchanged") self.results['changed'] = False response = old_response if response: self.results["id"] = response["id"] 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: self.lab_virtual_machine[key] = kwargs[key] self.lab_virtual_machine[ 'gallery_image_reference'] = self.lab_virtual_machine.pop( 'image', None) if self.lab_virtual_machine.get('artifacts') is not None: for artifact in self.lab_virtual_machine.get('artifacts'): source_name = artifact.pop('source_name') source_path = artifact.pop('source_path') template = "/subscriptions/{0}/resourceGroups/{1}/providers/Microsoft.DevTestLab/labs/{2}/artifactsources/{3}{4}" artifact['artifact_id'] = template.format( self.subscription_id, self.resource_group, self.lab_name, source_name, source_path) self.lab_virtual_machine['size'] = self.lab_virtual_machine.pop( 'vm_size') self.lab_virtual_machine['os_type'] = _snake_to_camel( self.lab_virtual_machine['os_type'], True) if self.lab_virtual_machine.get('storage_type'): self.lab_virtual_machine['storage_type'] = _snake_to_camel( self.lab_virtual_machine['storage_type'], True) lab_subnet = self.lab_virtual_machine.pop('lab_subnet') if isinstance(lab_subnet, str): vn_and_subnet = lab_subnet.split('/subnets/') if (len(vn_and_subnet) == 2): self.lab_virtual_machine[ 'lab_virtual_network_id'] = vn_and_subnet[0] self.lab_virtual_machine['lab_subnet_name'] = vn_and_subnet[1] else: self.fail("Invalid 'lab_subnet' resource id format") else: template = "/subscriptions/{0}/resourceGroups/{1}/providers/Microsoft.DevTestLab/labs/{2}/virtualnetworks/{3}" self.lab_virtual_machine[ 'lab_virtual_network_id'] = template.format( self.subscription_id, self.resource_group, self.lab_name, lab_subnet.get('virtual_network_name')) self.lab_virtual_machine['lab_subnet_name'] = lab_subnet.get( 'name') response = None self.mgmt_client = self.get_mgmt_svc_client( DevTestLabsClient, base_url=self._cloud_environment.endpoints.resource_manager) old_response = self.get_virtualmachine() if not old_response: self.log("Virtual Machine instance doesn't exist") if self.state == 'absent': self.log("Old instance didn't exist") else: self.to_do = Actions.Create # get location from the lab as it has to be the same and has to be specified (why??) lab = self.get_devtestlab() self.lab_virtual_machine['location'] = lab['location'] else: self.log("Virtual Machine instance already exists") if self.state == 'absent': self.to_do = Actions.Delete elif self.state == 'present': self.lab_virtual_machine['location'] = old_response['location'] if old_response['size'].lower( ) != self.lab_virtual_machine.get('size').lower(): self.lab_virtual_machine['size'] = old_response['size'] self.module.warn("Property 'size' cannot be changed") if self.lab_virtual_machine.get('storage_type') is not None and \ old_response['storage_type'].lower() != self.lab_virtual_machine.get('storage_type').lower(): self.lab_virtual_machine['storage_type'] = old_response[ 'storage_type'] self.module.warn( "Property 'storage_type' cannot be changed") if old_response.get('gallery_image_reference', {}) != self.lab_virtual_machine.get( 'gallery_image_reference', {}): self.lab_virtual_machine[ 'gallery_image_reference'] = old_response[ 'gallery_image_reference'] self.module.warn("Property 'image' cannot be changed") # currently artifacts can be only specified when vm is created # and in addition we don't have detailed information, just a number of "total artifacts" if len(self.lab_virtual_machine.get( 'artifacts', [])) != old_response[ 'artifact_deployment_status']['total_artifacts']: self.module.warn("Property 'artifacts' cannot be changed") if self.lab_virtual_machine.get( 'disallow_public_ip_address') is not None: if old_response[ 'disallow_public_ip_address'] != self.lab_virtual_machine.get( 'disallow_public_ip_address'): self.module.warn( "Property 'disallow_public_ip_address' cannot be changed" ) self.lab_virtual_machine[ 'disallow_public_ip_address'] = old_response[ 'disallow_public_ip_address'] if self.lab_virtual_machine.get('allow_claim') is not None: if old_response[ 'allow_claim'] != self.lab_virtual_machine.get( 'allow_claim'): self.module.warn( "Property 'allow_claim' cannot be changed") self.lab_virtual_machine['allow_claim'] = old_response[ 'allow_claim'] if self.lab_virtual_machine.get('notes') is not None: if old_response['notes'] != self.lab_virtual_machine.get( 'notes'): self.to_do = Actions.Update else: self.lab_virtual_machine['notes'] = old_response['notes'] if (self.to_do == Actions.Create) or (self.to_do == Actions.Update): self.log("Need to Create / Update the Virtual Machine instance") self.results['changed'] = True if self.check_mode: return self.results response = self.create_update_virtualmachine() self.log("Creation / Update done") elif self.to_do == Actions.Delete: self.log("Virtual Machine instance deleted") self.results['changed'] = True if self.check_mode: return self.results self.delete_virtualmachine() else: self.log("Virtual Machine instance unchanged") self.results['changed'] = False response = old_response if self.state == 'present': self.results.update({ 'id': response.get('id', None), 'compute_id': response.get('compute_id', None), 'fqdn': response.get('fqdn', None) }) return self.results
def exec_module(self, **kwargs): for key in list(self.module_arg_spec.keys()) + ['tags']: setattr(self, key, kwargs[key]) self.results = dict() changed = False if not self.location: resource_group = self.get_resource_group(self.resource_group) self.location = resource_group.location if self.sku == 'per_gb2018': self.sku = 'PerGB2018' else: self.sku = _snake_to_camel(self.sku) workspace = self.get_workspace() if not workspace and self.state == 'present': changed = True workspace = self.log_analytics_models.Workspace( sku=self.log_analytics_models.WorkspaceSku(name=self.sku), retention_in_days=self.retention_in_days, location=self.location, tags=self.tags) if not self.check_mode: workspace = self.create_workspace(workspace) elif workspace and self.state == 'present': if workspace.retention_in_days != self.retention_in_days: changed = True results = dict() update_tags, results['tags'] = self.update_tags(workspace.tags) if update_tags: changed = True if not self.check_mode and changed: workspace = self.log_analytics_models.Workspace( sku=self.log_analytics_models.WorkspaceSku(name=self.sku), retention_in_days=self.retention_in_days, location=self.location, tags=results['tags']) workspace = self.create_workspace(workspace) elif workspace and self.state == 'absent': changed = True workspace = None if not self.check_mode: self.delete_workspace() if workspace and workspace.id: self.results = self.to_dict(workspace) self.results['intelligence_packs'] = self.list_intelligence_packs() self.results['management_groups'] = self.list_management_groups() self.results['usages'] = self.list_usages() self.results['shared_keys'] = self.get_shared_keys() # handle the intelligence pack if workspace and workspace.id and self.intelligence_packs: intelligence_packs = self.results['intelligence_packs'] for key in self.intelligence_packs.keys(): enabled = self.intelligence_packs[key] for x in intelligence_packs: if x['name'].lower() == key.lower(): if x['enabled'] != enabled: changed = True if not self.check_mode: self.change_intelligence(x['name'], enabled) x['enabled'] = enabled break self.results['changed'] = changed 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: self.custom_image[key] = kwargs[key] if self.state == 'present': windows_os_state = self.custom_image.pop('windows_os_state', False) linux_os_state = self.custom_image.pop('linux_os_state', False) source_vm_name = self.custom_image.pop('source_vm') temp = "/subscriptions/{0}/resourcegroups/{1}/providers/microsoft.devtestlab/labs/{2}/virtualmachines/{3}" self.custom_image['vm'] = {} self.custom_image['vm']['source_vm_id'] = temp.format( self.subscription_id, self.resource_group, self.lab_name, source_vm_name) if windows_os_state: self.custom_image['vm']['windows_os_info'] = { 'windows_os_state': _snake_to_camel(windows_os_state, True) } elif linux_os_state: self.custom_image['vm']['linux_os_info'] = { 'linux_os_state': _snake_to_camel(linux_os_state, True) } else: self.fail( "Either 'linux_os_state' or 'linux_os_state' must be specified" ) response = None self.mgmt_client = self.get_mgmt_svc_client( DevTestLabsClient, base_url=self._cloud_environment.endpoints.resource_manager) old_response = self.get_customimage() if not old_response: self.log("Custom Image instance doesn't exist") if self.state == 'absent': self.log("Old instance didn't exist") else: self.to_do = Actions.Create else: self.log("Custom Image instance already exists") if self.state == 'absent': self.to_do = Actions.Delete elif self.state == 'present': if (not default_compare(self.custom_image, old_response, '', self.results)): self.to_do = Actions.Update if (self.to_do == Actions.Create) or (self.to_do == Actions.Update): self.log("Need to Create / Update the Custom Image instance") if self.check_mode: self.results['changed'] = True return self.results response = self.create_update_customimage() self.results['changed'] = True self.log("Creation / Update done") elif self.to_do == Actions.Delete: self.log("Custom Image instance deleted") self.results['changed'] = True if self.check_mode: return self.results self.delete_customimage() # This currently doesnt' work as there is a bug in SDK / Service if isinstance(response, LROPoller) or isinstance( response, AzureOperationPoller): response = self.get_poller_result(response) else: self.log("Custom Image instance unchanged") self.results['changed'] = False response = old_response if self.state == 'present': self.results.update({'id': response.get('id', None)}) return self.results
def exec_module(self, **kwargs): for key in self.module_arg_spec.keys(): setattr(self, key, kwargs[key]) self._base_url = '{0}.azure-devices.net'.format(self.hub) config = { 'base_url': self._base_url, 'key': self.hub_policy_key, 'policy': self.hub_policy_name } self._mgmt_client = self.get_data_svc_client(**config) changed = False device = self.get_device() if self.state == 'present': if not device: changed = True auth = {'type': _snake_to_camel(self.auth_method)} if self.auth_method == 'self_signed': auth['x509Thumbprint'] = { 'primaryThumbprint': self.primary_key, 'secondaryThumbprint': self.secondary_key } elif self.auth_method == 'sas': auth['symmetricKey'] = { 'primaryKey': self.primary_key, 'secondaryKey': self.secondary_key } device = { 'deviceId': self.name, 'capabilities': { 'iotEdge': self.edge_enabled or False }, 'authentication': auth } if self.status is not None and not self.status: device['status'] = 'disabled' else: if self.edge_enabled is not None and self.edge_enabled != device[ 'capabilities']['iotEdge']: changed = True device['capabilities']['iotEdge'] = self.edge_enabled if self.status is not None: status = 'enabled' if self.status else 'disabled' if status != device['status']: changed = True device['status'] = status if changed and not self.check_mode: device = self.create_or_update_device(device) twin = self.get_twin() if twin: if not twin.get('tags'): twin['tags'] = dict() twin_change = False if self.twin_tags and not self.is_equal( self.twin_tags, twin['tags']): twin_change = True if self.desired and not self.is_equal( self.desired, twin['properties']['desired']): twin_change = True if twin_change and not self.check_mode: self.update_twin(twin) changed = changed or twin_change device['tags'] = twin.get('tags') or dict() device['properties'] = twin['properties'] device['modules'] = self.list_device_modules() elif self.twin_tags or self.desired: self.fail( "Device twin is not supported in IoT Hub with basic tier.") elif device: if not self.check_mode: self.delete_device(device['etag']) changed = True device = None self.results = device or dict() self.results['changed'] = changed return self.results
def exec_module(self, **kwargs): """Main module execution method""" for key in list(self.module_arg_spec.keys()) + ['tags']: setattr(self, key, kwargs[key]) self.cdn_client = self.get_cdn_client() to_be_updated = False resource_group = self.get_resource_group(self.resource_group) if not self.location: self.location = resource_group.location if self.query_string_caching_behavior: self.query_string_caching_behavior = _snake_to_camel( self.query_string_caching_behavior) response = self.get_cdnendpoint() if self.state == 'present': if not response: if self.started is None: # If endpoint dosen't exist and no start/stop operation specified, create endpoint. if self.origins is None: self.fail( "Origins is not provided when trying to create endpoint" ) self.log("Need to create the Azure CDN endpoint") if not self.check_mode: result = self.create_cdnendpoint() self.results['id'] = result['id'] self.results['host_name'] = result['host_name'] self.log("Creation done") self.results['changed'] = True return self.results else: # Fail the module when user try to start/stop a non-existed endpoint self.log("Can't stop/stop a non-existed endpoint") self.fail( "This endpoint is not found, stop/start is forbidden") else: self.log('Results : {0}'.format(response)) self.results['id'] = response['id'] self.results['host_name'] = response['host_name'] update_tags, response['tags'] = self.update_tags( response['tags']) if update_tags: to_be_updated = True if response['provisioning_state'] == "Succeeded": if self.started is False and response[ 'resource_state'] == 'Running': self.log("Need to stop the Azure CDN endpoint") if not self.check_mode: result = self.stop_cdnendpoint() self.log("Endpoint stopped") self.results['changed'] = True elif self.started and response[ 'resource_state'] == 'Stopped': self.log("Need to start the Azure CDN endpoint") if not self.check_mode: result = self.start_cdnendpoint() self.log("Endpoint started") self.results['changed'] = True elif self.started is not None: self.module.warn( "Start/Stop not performed due to current resource state {0}" .format(response['resource_state'])) self.results['changed'] = False if self.purge: self.log("Need to purge endpoint") if not self.check_mode: result = self.purge_cdnendpoint() self.log("Endpoint purged") self.results['changed'] = True to_be_updated = to_be_updated or self.check_update( response) if to_be_updated: self.log("Need to update the Azure CDN endpoint") self.results['changed'] = True if not self.check_mode: result = self.update_cdnendpoint() self.results['host_name'] = result['host_name'] self.log("Update done") elif self.started is not None: self.module.warn( "Start/Stop not performed due to current provisioning state {0}" .format(response['provisioning_state'])) self.results['changed'] = False elif self.state == 'absent' and response: self.log("Need to delete the Azure CDN endpoint") self.results['changed'] = True if not self.check_mode: self.delete_cdnendpoint() self.log("Azure CDN endpoint deleted") 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: self.lab[key] = kwargs[key] if self.lab.get('storage_type'): self.lab['lab_storage_type'] = _snake_to_camel(self.lab['storage_type'], True) self.lab.pop('storage_type', None) if self.lab.get('premium_data_disks') is not None: self.lab['premium_data_disks'] = 'Enabled' if self.lab['premium_data_disks'] else 'Disabled' response = None self.mgmt_client = self.get_mgmt_svc_client(DevTestLabsClient, base_url=self._cloud_environment.endpoints.resource_manager, api_version='2018-10-15') resource_group = self.get_resource_group(self.resource_group) if self.lab.get('location') is None: self.lab['location'] = resource_group.location old_response = self.get_devtestlab() if not old_response: self.log("DevTest Lab instance doesn't exist") if self.state == 'absent': self.log("Old instance didn't exist") else: self.to_do = Actions.Create else: self.log("DevTest Lab instance already exists") if self.state == 'absent': self.to_do = Actions.Delete elif self.state == 'present': if self.lab.get('lab_storage_type') is not None and \ self.lab.get('lab_storage_type').lower() != old_response.get('lab_storage_type', '').lower(): self.to_do = Actions.Update if (self.lab.get('premium_data_disks') is not None and self.lab.get('premium_data_disks').lower() != old_response.get('premium_data_disks').lower()): self.to_do = Actions.Update if (self.to_do == Actions.Create) or (self.to_do == Actions.Update): self.log("Need to Create / Update the DevTest Lab instance") self.results['changed'] = True if self.check_mode: return self.results response = self.create_update_devtestlab() self.log("Creation / Update done") elif self.to_do == Actions.Delete: self.log("DevTest Lab instance deleted") self.results['changed'] = True if self.check_mode: return self.results self.delete_devtestlab() # This currently doesnt' work as there is a bug in SDK / Service if isinstance(response, LROPoller) or isinstance(response, AzureOperationPoller): response = self.get_poller_result(response) else: self.log("DevTest Lab instance unchanged") self.results['changed'] = False response = old_response if self.state == 'present': self.results.update({ 'id': response.get('id', None) }) return self.results
def exec_module(self, **kwargs): for key in self.module_arg_spec.keys(): setattr(self, key, kwargs[key]) self._base_url = '{0}.azure-devices.net'.format(self.hub) config = { 'base_url': self._base_url, 'key': self.hub_policy_key, 'policy': self.hub_policy_name } self._mgmt_client = self.get_data_svc_client(**config) changed = False module = self.get_module() if self.state == 'present': if not module: changed = True auth = {'type': _snake_to_camel(self.auth_method)} if self.auth_method == 'self_signed': auth['x509Thumbprint'] = { 'primaryThumbprint': self.primary_key, 'secondaryThumbprint': self.secondary_key } elif self.auth_method == 'sas': auth['symmetricKey'] = { 'primaryKey': self.primary_key, 'secondaryKey': self.secondary_key } module = { 'deviceId': self.device, 'moduleId': self.name, 'authentication': auth } if changed and not self.check_mode: module = self.create_or_update_module(module) twin = self.get_twin() if not twin.get('tags'): twin['tags'] = dict() twin_change = False if self.twin_tags and not self.is_equal(self.twin_tags, twin['tags']): twin_change = True if self.desired and not self.is_equal( self.desired, twin['properties']['desired']): self.module.warn('desired') twin_change = True if twin_change and not self.check_mode: twin = self.update_twin(twin) changed = changed or twin_change module['tags'] = twin.get('tags') or dict() module['properties'] = twin['properties'] elif module: if not self.check_mode: self.delete_module(module['etag']) changed = True module = None self.results = module or dict() self.results['changed'] = changed return self.results
def exec_module(self, **kwargs): for key in list(self.module_arg_spec.keys()): setattr(self, key, kwargs[key]) changed = False original = self.get() if self.state == 'present': # Create the resource instance params = dict( enable_batched_operations=self.enable_batched_operations, enable_express=self.enable_express, enable_partitioning=self.enable_partitioning, max_size_in_megabytes=self.max_size_in_mb, support_ordering=self.support_ordering ) if self.status: params['status'] = self.servicebus_models.EntityStatus(str.capitalize(_snake_to_camel(self.status))) for k, v in duration_spec_map.items(): seconds = getattr(self, v) if seconds: params[k] = timedelta(seconds=seconds) instance = self.servicebus_models.SBTopic(**params) result = original if not original: changed = True result = instance else: result = original attribute_map = set(self.servicebus_models.SBTopic._attribute_map.keys()) - set(self.servicebus_models.SBTopic._validation.keys()) for attribute in attribute_map: value = getattr(instance, attribute) if value and value != getattr(original, attribute): changed = True if changed and not self.check_mode: result = self.create_or_update(instance) self.results = self.to_dict(result) elif original: changed = True if not self.check_mode: self.delete() self.results['deleted'] = True self.results['changed'] = changed return self.results
def exec_module(self, **kwargs): for key in list(self.module_arg_spec.keys()) + ['tags']: setattr(self, key, kwargs[key]) changed = False results = dict() vgw = None resource_group = self.get_resource_group(self.resource_group) if not self.location: self.location = resource_group.location self.virtual_network = self.parse_resource_to_dict(self.virtual_network) resource_group = self.get_resource_group(self.resource_group) try: vgw = self.network_client.virtual_network_gateways.get(self.resource_group, self.name) if self.state == 'absent': self.log("CHANGED: vnet exists but requested state is 'absent'") changed = True except CloudError: if self.state == 'present': self.log("CHANGED: VPN Gateway {0} does not exist but requested state is 'present'".format(self.name)) changed = True if vgw: results = vgw_to_dict(vgw) if self.state == 'present': update_tags, results['tags'] = self.update_tags(results['tags']) if update_tags: changed = True sku = dict(name=self.sku, tier=self.sku) if sku != results['sku']: changed = True if self.enable_bgp != results['enable_bgp']: changed = True if self.bgp_settings and self.bgp_settings['asn'] != results['bgp_settings']['asn']: changed = True self.results['changed'] = changed self.results['id'] = results.get('id') if self.check_mode: return self.results if changed: if self.state == 'present': if not self.sku: self.fail('Parameter error: sku is required when creating a vpn gateway') if not self.ip_configurations: self.fail('Parameter error: ip_configurations required when creating a vpn gateway') subnet = self.network_models.SubResource( id='/subscriptions/{0}/resourceGroups/{1}/providers/Microsoft.Network/virtualNetworks/{2}/subnets/GatewaySubnet'.format( self.virtual_network['subscription_id'], self.virtual_network['resource_group'], self.virtual_network['name'])) public_ip_address = self.network_models.SubResource( id='/subscriptions/{0}/resourceGroups/{1}/providers/Microsoft.Network/publicIPAddresses/{2}'.format( self.virtual_network['subscription_id'], self.virtual_network['resource_group'], self.ip_configurations[0]['public_ip_address_name'])) vgw_ip_configurations = [ self.network_models.VirtualNetworkGatewayIPConfiguration( private_ip_allocation_method=ip_config.get('private_ip_allocation_method'), subnet=subnet, public_ip_address=public_ip_address, name='default' ) for ip_config in self.ip_configurations ] vgw_sku = self.network_models.VirtualNetworkGatewaySku( name=self.sku, tier=self.sku ) vgw_bgp_settings = self.network_models.BgpSettings( asn=self.bgp_settings.get('asn'), ) if self.bgp_settings else None vgw = self.network_models.VirtualNetworkGateway( location=self.location, ip_configurations=vgw_ip_configurations, gateway_type=_snake_to_camel(self.gateway_type, True), vpn_type=_snake_to_camel(self.vpn_type, True), enable_bgp=self.enable_bgp, sku=vgw_sku, bgp_settings=vgw_bgp_settings ) if self.tags: vgw.tags = self.tags results = self.create_or_update_vgw(vgw) else: results = self.delete_vgw() if self.state == 'present': self.results['id'] = results.get('id') return self.results
def create_update_containerinstance(self): ''' Creates or updates a container service with the specified configuration of orchestrator, masters, and agents. :return: deserialized container instance state dictionary ''' self.log("Creating / Updating the container instance {0}".format( self.name)) registry_credentials = None if self.registry_login_server is not None: registry_credentials = [ self.cgmodels.ImageRegistryCredential( server=self.registry_login_server, username=self.registry_username, password=self.registry_password) ] ip_address = None containers = [] all_ports = set([]) for container_def in self.containers: name = container_def.get("name") image = container_def.get("image") memory = container_def.get("memory") cpu = container_def.get("cpu") commands = container_def.get("commands") ports = [] variables = [] port_list = container_def.get("ports") if port_list: for port in port_list: all_ports.add(port) ports.append(self.cgmodels.ContainerPort(port=port)) variable_list = container_def.get("environment_variables") if variable_list: for variable in variable_list: variables.append( self.cgmodels.EnvironmentVariable( name=variable.get('name'), value=variable.get('value') if not variable.get('is_secure') else None, secure_value=variable.get('value') if variable.get('is_secure') else None)) containers.append( self.cgmodels.Container( name=name, image=image, resources=self.cgmodels.ResourceRequirements( requests=self.cgmodels.ResourceRequests( memory_in_gb=memory, cpu=cpu)), ports=ports, command=commands, environment_variables=variables)) if self.ip_address == 'public': # get list of ports if len(all_ports) > 0: ports = [] for port in all_ports: ports.append(self.cgmodels.Port(port=port, protocol="TCP")) ip_address = self.cgmodels.IpAddress( ports=ports, dns_name_label=self.dns_name_label, type='public') parameters = self.cgmodels.ContainerGroup( location=self.location, containers=containers, image_registry_credentials=registry_credentials, restart_policy=_snake_to_camel(self.restart_policy, True) if self.restart_policy else None, ip_address=ip_address, os_type=self.os_type, volumes=None, tags=self.tags) try: response = self.containerinstance_client.container_groups.create_or_update( resource_group_name=self.resource_group, container_group_name=self.name, container_group=parameters) if isinstance(response, LROPoller): response = self.get_poller_result(response) except CloudError as exc: self.fail("Error when creating ACI {0}: {1}".format( self.name, exc.message or str(exc))) return response.as_dict()