def resolve_storage_source(self, source): blob_uri = None disk = None snapshot = None # blob URI can only be given by str if isinstance(source, str) and source.lower().endswith('.vhd'): blob_uri = source return (blob_uri, disk, snapshot) tokenize = dict() if isinstance(source, dict): tokenize = source elif isinstance(source, str): tokenize = parse_resource_id(source) else: self.fail( "source parameter should be in type string or dictionary") if tokenize.get('type') == 'disks': disk = format_resource_id( tokenize['name'], tokenize.get('subscription_id') or self.subscription_id, 'Microsoft.Compute', 'disks', tokenize.get('resource_group') or self.resource_group) return (blob_uri, disk, snapshot) if tokenize.get('type') == 'snapshots': snapshot = format_resource_id( tokenize['name'], tokenize.get('subscription_id') or self.subscription_id, 'Microsoft.Compute', 'snapshots', tokenize.get('resource_group') or self.resource_group) return (blob_uri, disk, snapshot) # not a disk or snapshots if 'type' in tokenize: return (blob_uri, disk, snapshot) # source can be name of snapshot or disk snapshot_instance = self.get_snapshot( tokenize.get('resource_group') or self.resource_group, tokenize['name']) if snapshot_instance: snapshot = snapshot_instance.id return (blob_uri, disk, snapshot) disk_instance = self.get_disk( tokenize.get('resource_group') or self.resource_group, tokenize['name']) if disk_instance: disk = disk_instance.id return (blob_uri, disk, snapshot)
def create_or_update_vnet_peering(self): ''' Creates or Update Azure Virtual Network Peering. :return: deserialized Azure Virtual Network Peering instance state dictionary ''' self.log("Creating or Updating the Azure Virtual Network Peering {0}". format(self.name)) vnet_id = format_resource_id(self.virtual_network['name'], self.subscription_id, 'Microsoft.Network', 'virtualNetworks', self.virtual_network['resource_group']) peering = self.network_models.VirtualNetworkPeering( id=vnet_id, name=self.name, remote_virtual_network=self.network_models.SubResource( id=self.remote_virtual_network), allow_virtual_network_access=self.allow_virtual_network_access, allow_gateway_transit=self.allow_gateway_transit, allow_forwarded_traffic=self.allow_forwarded_traffic, use_remote_gateways=self.use_remote_gateways) try: response = self.network_client.virtual_network_peerings.create_or_update( self.resource_group, self.virtual_network['name'], self.name, peering) if isinstance(response, LROPoller): response = self.get_poller_result(response) return vnetpeering_to_dict(response) except CloudError as exc: self.fail( "Error creating Azure Virtual Network Peering: {0}.".format( exc.message))
def format_elastic_pool_id(self): parrent_id = format_resource_id(val=self.server_name, subscription_id=self.subscription_id, namespace="Microsoft.Sql", types="servers", resource_group=self.resource_group) self.parameters[ 'elastic_pool_id'] = parrent_id + "/elasticPools/" + self.parameters[ 'elastic_pool_id']
def parse_vn_id(self, vn): vn_dict = self.parse_resource_to_dict(vn) if not isinstance( vn, dict) else vn return format_resource_id(val=vn_dict['name'], subscription_id=vn_dict.get('subscription') or self.subscription_id, namespace='Microsoft.Network', types='virtualNetworks', resource_group=vn_dict.get('resource_group') or self.resource_group)
def parse_nsg(self): nsg = self.security_group resource_group = self.resource_group if isinstance(self.security_group, dict): nsg = self.security_group.get('name') resource_group = self.security_group.get('resource_group', self.resource_group) id = format_resource_id(val=nsg, subscription_id=self.subscription_id, namespace='Microsoft.Network', types='networkSecurityGroups', resource_group=resource_group) name = azure_id_to_dict(id).get('name') return dict(id=id, name=name)
def format_vnet_id(self, vnet): if not vnet: return vnet if isinstance( vnet, dict) and vnet.get('name') and vnet.get('resource_group'): remote_vnet_id = format_resource_id(vnet['name'], self.subscription_id, 'Microsoft.Network', 'virtualNetworks', vnet['resource_group']) elif isinstance(vnet, str): if is_valid_resource_id(vnet): remote_vnet_id = vnet else: remote_vnet_id = format_resource_id(vnet, self.subscription_id, 'Microsoft.Network', 'virtualNetworks', self.resource_group) else: self.fail( "remote_virtual_network could be a valid resource id, dict of name and resource_group, name of virtual network in same resource group." ) return remote_vnet_id
def get_source_vm(self): # self.resource can be a vm (id/name/dict), or not a vm. return the vm iff it is an existing vm. resource = dict() if isinstance(self.source, dict): if self.source.get('type') != 'virtual_machines': return None resource = dict(type='virtualMachines', name=self.source['name'], resource_group=self.source.get('resource_group') or self.resource_group) elif isinstance(self.source, str): vm_resource_id = format_resource_id(self.source, self.subscription_id, 'Microsoft.Compute', 'virtualMachines', self.resource_group) resource = parse_resource_id(vm_resource_id) else: self.fail( "Unsupported type of source parameter, please give string or dictionary" ) return self.get_vm(resource['resource_group'], resource['name'] ) if resource['type'] == 'virtualMachines' else None
def get_public_ip_address_instance(self, id): """Get a reference to the public ip address resource""" self.log('Fetching public ip address {0}'.format(id)) resource_id = format_resource_id(id, self.subscription_id, 'Microsoft.Network', 'publicIPAddresses', self.resource_group) return self.network_models.PublicIPAddress(id=resource_id)
def exec_module(self, **kwargs): nsg = None subnet = None for key in self.module_arg_spec: setattr(self, key, kwargs[key]) if self.address_prefix_cidr and not CIDR_PATTERN.match( self.address_prefix_cidr): self.fail("Invalid address_prefix_cidr value {0}".format( self.address_prefix_cidr)) nsg = dict() if self.security_group: nsg = self.parse_nsg() route_table = dict() if self.route_table: route_table = self.parse_resource_to_dict(self.route_table) self.route_table = format_resource_id( val=route_table['name'], subscription_id=route_table['subscription_id'], namespace='Microsoft.Network', types='routeTables', resource_group=route_table['resource_group']) results = dict() changed = False try: self.log('Fetching subnet {0}'.format(self.name)) subnet = self.network_client.subnets.get(self.resource_group, self.virtual_network_name, self.name) self.check_provisioning_state(subnet, self.state) results = subnet_to_dict(subnet) if self.state == 'present': if self.address_prefix_cidr and results[ 'address_prefix'] != self.address_prefix_cidr: self.log("CHANGED: subnet {0} address_prefix_cidr".format( self.name)) changed = True results['address_prefix'] = self.address_prefix_cidr if self.security_group is not None and results[ 'network_security_group'].get('id') != nsg.get('id'): self.log( "CHANGED: subnet {0} network security group".format( self.name)) changed = True results['network_security_group']['id'] = nsg.get('id') results['network_security_group']['name'] = nsg.get('name') if self.route_table is not None and self.route_table != results[ 'route_table'].get('id'): changed = True results['route_table']['id'] = self.route_table self.log("CHANGED: subnet {0} route_table to {1}".format( self.name, route_table.get('name'))) if self.service_endpoints: oldd = {} for item in self.service_endpoints: name = item['service'] locations = item.get('locations') or [] oldd[name] = { 'service': name, 'locations': locations.sort() } newd = {} if 'service_endpoints' in results: for item in results['service_endpoints']: name = item['service'] locations = item.get('locations') or [] newd[name] = { 'service': name, 'locations': locations.sort() } if newd != oldd: changed = True results['service_endpoints'] = self.service_endpoints elif self.state == 'absent': changed = True except CloudError: # the subnet does not exist if self.state == 'present': changed = True self.results['changed'] = changed self.results['state'] = results if not self.check_mode: if self.state == 'present' and changed: if not subnet: # create new subnet if not self.address_prefix_cidr: self.fail('address_prefix_cidr is not set') self.log('Creating subnet {0}'.format(self.name)) subnet = self.network_models.Subnet( address_prefix=self.address_prefix_cidr) if nsg: subnet.network_security_group = self.network_models.NetworkSecurityGroup( id=nsg.get('id')) if self.route_table: subnet.route_table = self.network_models.RouteTable( id=self.route_table) if self.service_endpoints: subnet.service_endpoints = self.service_endpoints else: # update subnet self.log('Updating subnet {0}'.format(self.name)) subnet = self.network_models.Subnet( address_prefix=results['address_prefix']) if results['network_security_group'].get('id') is not None: subnet.network_security_group = self.network_models.NetworkSecurityGroup( id=results['network_security_group'].get('id')) if results['route_table'].get('id') is not None: subnet.route_table = self.network_models.RouteTable( id=results['route_table'].get('id')) if results.get('service_endpoints') is not None: subnet.service_endpoints = results['service_endpoints'] self.results['state'] = self.create_or_update_subnet(subnet) elif self.state == 'absent' and changed: # delete subnet self.delete_subnet() # the delete does not actually return anything. if no exception, then we'll assume # it worked. self.results['state']['status'] = 'Deleted' return self.results
def exec_module(self, **kwargs): for key in list(self.module_arg_spec.keys()) + ['tags']: setattr(self, key, kwargs[key]) results = None changed = False self.log('Fetching auto scale settings {0}'.format(self.name)) results = self.get_auto_scale() if results and self.state == 'absent': # delete changed = True if not self.check_mode: self.delete_auto_scale() elif self.state == 'present': if not self.location: # Set default location resource_group = self.get_resource_group(self.resource_group) self.location = resource_group.location resource_id = self.target if isinstance(self.target, dict): resource_id = format_resource_id( val=self.target['name'], subscription_id=self.target.get('subscription_id') or self.subscription_id, namespace=self.target['namespace'], types=self.target['types'], resource_group=self.target.get('resource_group') or self.resource_group) self.target = resource_id resource_name = self.name def create_rule_instance(params): rule = params.copy() rule['metric_resource_uri'] = rule.get('metric_resource_uri', self.target) rule['time_grain'] = timedelta( minutes=rule.get('time_grain', 0)) rule['time_window'] = timedelta( minutes=rule.get('time_window', 0)) rule['cooldown'] = timedelta(minutes=rule.get('cooldown', 0)) return ScaleRule(metric_trigger=MetricTrigger(**rule), scale_action=ScaleAction(**rule)) profiles = [ AutoscaleProfile( name=p.get('name'), capacity=ScaleCapacity(minimum=p.get('min_count'), maximum=p.get('max_count'), default=p.get('count')), rules=[ create_rule_instance(r) for r in p.get('rules') or [] ], fixed_date=TimeWindow( time_zone=p.get('fixed_date_timezone'), start=p.get('fixed_date_start'), end=p.get('fixed_date_end')) if p.get('fixed_date_timezone') else None, recurrence=Recurrence( frequency=p.get('recurrence_frequency'), schedule=(RecurrentSchedule( time_zone=p.get('recurrence_timezone'), days=p.get('recurrence_days'), hours=p.get('recurrence_hours'), minutes=p.get('recurrence_mins')))) if p.get('recurrence_frequency') and p['recurrence_frequency'] != 'None' else None) for p in self.profiles or [] ] notifications = [ AutoscaleNotification(email=EmailNotification(**n), webhooks=[ WebhookNotification(service_uri=w) for w in n.get('webhooks') or [] ]) for n in self.notifications or [] ] if not results: # create new changed = True else: # check changed resource_name = results.autoscale_setting_resource_name or self.name update_tags, tags = self.update_tags(results.tags) if update_tags: changed = True self.tags = tags if self.target != results.target_resource_uri: changed = True if self.enabled != results.enabled: changed = True profile_result_set = set( [str(profile_to_dict(p)) for p in results.profiles or []]) if profile_result_set != set( [str(profile_to_dict(p)) for p in profiles]): changed = True notification_result_set = set([ str(notification_to_dict(n)) for n in results.notifications or [] ]) if notification_result_set != set( [str(notification_to_dict(n)) for n in notifications]): changed = True if changed: # construct the instance will be send to create_or_update api results = AutoscaleSettingResource( location=self.location, tags=self.tags, profiles=profiles, notifications=notifications, enabled=self.enabled, autoscale_setting_resource_name=resource_name, target_resource_uri=self.target) if not self.check_mode: results = self.create_or_update_auto_scale(results) # results should be the dict of the instance self.results = auto_scale_to_dict(results) self.results['changed'] = changed return self.results