def validate(self, value, context): nova_client = clients.Clients(context).nova() try: nova_utils.get_flavor_id(nova_client, value) except exception.FlavorMissing: return False else: return True
def test_get_flavor_id(self): """Tests the get_flavor_id function.""" flav_id = str(uuid.uuid4()) flav_name = "X-Large" my_flavor = self.m.CreateMockAnything() my_flavor.name = flav_name my_flavor.id = flav_id self.nova_client.flavors = self.m.CreateMockAnything() self.nova_client.flavors.list().MultipleTimes().AndReturn([my_flavor]) self.m.ReplayAll() self.assertEqual(flav_id, nova_utils.get_flavor_id(self.nova_client, flav_name)) self.assertEqual(flav_id, nova_utils.get_flavor_id(self.nova_client, flav_id)) self.assertRaises(exception.FlavorMissing, nova_utils.get_flavor_id, self.nova_client, "noflavor") self.m.VerifyAll()
def handle_create(self): ''' Create cloud database instance. ''' self.dbinstancename = self.physical_resource_name() self.flavor = nova_utils.get_flavor_id(self.trove(), self.properties['flavor']) self.volume = {'size': self.properties['size']} self.databases = self.properties.get('databases', []) self.users = self.properties.get('users', []) restore_point = self.properties.get('restore_point', None) zone = self.properties.get('availability_zone', None) # convert user databases to format required for troveclient. # that is, list of database dictionaries for user in self.users: user['databases'] = [{'name': db} for db in user.get('databases', [])] # create db instance instance = self.trove().instances.create( self.dbinstancename, self.flavor, volume=self.volume, databases=self.databases, users=self.users, restorePoint=restore_point, availability_zone=zone) self.resource_id_set(instance.id) return instance
def handle_update(self, json_snippet, tmpl_diff, prop_diff): """Try to update a Cloud Server's parameters. If the Cloud Server's Metadata or flavor changed, update the Cloud Server. If any other parameters changed, re-create the Cloud Server with the new parameters. """ if 'Metadata' in tmpl_diff: self.metadata = json_snippet['Metadata'] metadata_string = json.dumps(self.metadata) files = [{ 'path': "/var/cache/heat-cfntools/last_metadata", 'data': metadata_string }] self._sftp_files(files) command = "bash -x /var/lib/cloud/data/cfn-userdata > " + \ "/root/cfn-userdata.log 2>&1" exit_code = self._run_ssh_command(command) if exit_code != 0: raise exception.Error(self.script_error_msg % { 'path': "cfn-userdata", 'log': "/root/cfn-userdata.log" }) if 'flavor' in prop_diff: flav = json_snippet['Properties']['flavor'] new_flavor = nova_utils.get_flavor_id(self.nova(), flav) self.server.resize(new_flavor) resize = scheduler.TaskRunner(nova_utils.check_resize, self.server, flav) resize.start() return resize
def handle_update(self, json_snippet, tmpl_diff, prop_diff): """Try to update a Cloud Server's parameters. If the Cloud Server's Metadata or flavor changed, update the Cloud Server. If any other parameters changed, re-create the Cloud Server with the new parameters. """ if "Metadata" in tmpl_diff: self.metadata = json_snippet["Metadata"] metadata_string = json.dumps(self.metadata) files = [{"path": "/var/cache/heat-cfntools/last_metadata", "data": metadata_string}] self._sftp_files(files) command = "bash -x /var/lib/cloud/data/cfn-userdata > " + "/root/cfn-userdata.log 2>&1" exit_code = self._run_ssh_command(command) if exit_code != 0: raise exception.Error(self.script_error_msg % {"path": "cfn-userdata", "log": "/root/cfn-userdata.log"}) if "flavor" in prop_diff: flav = json_snippet["Properties"]["flavor"] new_flavor = nova_utils.get_flavor_id(self.nova(), flav) self.server.resize(new_flavor) resize = scheduler.TaskRunner(nova_utils.check_resize, self.server, flav) resize.start() return resize
def handle_create(self): security_groups = self.properties.get(self.SECURITY_GROUPS) user_data_format = self.properties.get(self.USER_DATA_FORMAT) userdata = nova_utils.build_userdata( self, self.properties.get(self.USER_DATA), instance_user=self.properties[self.ADMIN_USER], user_data_format=user_data_format) flavor = self.properties[self.FLAVOR] availability_zone = self.properties[self.AVAILABILITY_ZONE] key_name = self.properties[self.KEY_NAME] if key_name: # confirm keypair exists nova_utils.get_keypair(self.nova(), key_name) image = self.properties.get(self.IMAGE) if image: image = nova_utils.get_image_id(self.nova(), image) flavor_id = nova_utils.get_flavor_id(self.nova(), flavor) instance_meta = self.properties.get(self.METADATA) if instance_meta is not None: instance_meta = nova_utils.meta_serialize(instance_meta) scheduler_hints = self.properties.get(self.SCHEDULER_HINTS) nics = self._build_nics(self.properties.get(self.NETWORKS)) block_device_mapping = self._build_block_device_mapping( self.properties.get(self.BLOCK_DEVICE_MAPPING)) reservation_id = self.properties.get(self.RESERVATION_ID) config_drive = self.properties.get(self.CONFIG_DRIVE) disk_config = self.properties.get(self.DISK_CONFIG) server = None try: server = self.nova().servers.create( name=self.physical_resource_name(), image=image, flavor=flavor_id, key_name=key_name, security_groups=security_groups, userdata=userdata, meta=instance_meta, scheduler_hints=scheduler_hints, nics=nics, availability_zone=availability_zone, block_device_mapping=block_device_mapping, reservation_id=reservation_id, config_drive=config_drive, disk_config=disk_config) finally: # Avoid a race condition where the thread could be cancelled # before the ID is stored if server is not None: self.resource_id_set(server.id) return server
def handle_create(self): ''' Create cloud database instance. ''' self.dbinstancename = self.physical_resource_name() self.flavor = nova_utils.get_flavor_id(self.trove(), self.properties[self.FLAVOR]) self.volume = {'size': self.properties[self.SIZE]} self.databases = self.properties.get(self.DATABASES) self.users = self.properties.get(self.USERS) restore_point = self.properties.get(self.RESTORE_POINT) zone = self.properties.get(self.AVAILABILITY_ZONE) # convert user databases to format required for troveclient. # that is, list of database dictionaries for user in self.users: dbs = [{'name': db} for db in user.get(self.USER_DATABASES, [])] user[self.USER_DATABASES] = dbs # create db instance instance = self.trove().instances.create( self.dbinstancename, self.flavor, volume=self.volume, databases=self.databases, users=self.users, restorePoint=restore_point, availability_zone=zone) self.resource_id_set(instance.id) return instance
def handle_create(self): ''' Create cloud database instance. ''' self.dbinstancename = self.physical_resource_name() self.flavor = nova_utils.get_flavor_id(self.trove(), self.properties['flavor']) self.volume = {'size': self.properties['size']} self.databases = self.properties.get('databases', []) self.users = self.properties.get('users', []) restore_point = self.properties.get('restore_point', None) zone = self.properties.get('availability_zone', None) # convert user databases to format required for troveclient. # that is, list of database dictionaries for user in self.users: user['databases'] = [{ 'name': db } for db in user.get('databases', [])] # create db instance instance = self.trove().instances.create(self.dbinstancename, self.flavor, volume=self.volume, databases=self.databases, users=self.users, restorePoint=restore_point, availability_zone=zone) self.resource_id_set(instance.id) return instance
def handle_create(self): ''' Create cloud database instance. ''' self.flavor = nova_utils.get_flavor_id(self.trove(), self.properties[self.FLAVOR]) self.volume = {'size': self.properties[self.SIZE]} self.databases = self.properties.get(self.DATABASES) self.users = self.properties.get(self.USERS) restore_point = self.properties.get(self.RESTORE_POINT) zone = self.properties.get(self.AVAILABILITY_ZONE) self.datastore_type = self.properties.get(self.DATASTORE_TYPE) self.datastore_version = self.properties.get(self.DATASTORE_VERSION) # convert user databases to format required for troveclient. # that is, list of database dictionaries for user in self.users: dbs = [{'name': db} for db in user.get(self.USER_DATABASES, [])] user[self.USER_DATABASES] = dbs # create db instance instance = self.trove().instances.create( self._dbinstance_name(), self.flavor, volume=self.volume, databases=self.databases, users=self.users, restorePoint=restore_point, availability_zone=zone, datastore=self.datastore_type, datastore_version=self.datastore_version) self.resource_id_set(instance.id) return instance
def test_get_flavor_id(self): """Tests the get_flavor_id function.""" flav_id = str(uuid.uuid4()) flav_name = 'X-Large' my_flavor = self.m.CreateMockAnything() my_flavor.name = flav_name my_flavor.id = flav_id self.nova_client.flavors = self.m.CreateMockAnything() self.nova_client.flavors.list().MultipleTimes().AndReturn([my_flavor]) self.m.ReplayAll() self.assertEqual(flav_id, nova_utils.get_flavor_id(self.nova_client, flav_name)) self.assertEqual(flav_id, nova_utils.get_flavor_id(self.nova_client, flav_id)) self.assertRaises(exception.FlavorMissing, nova_utils.get_flavor_id, self.nova_client, 'noflavor') self.m.VerifyAll()
def handle_update(self, json_snippet, tmpl_diff, prop_diff): if 'Metadata' in tmpl_diff: self.metadata = tmpl_diff['Metadata'] checkers = [] server = None if self.METADATA in prop_diff: server = self.nova().servers.get(self.resource_id) nova_utils.meta_update(self.nova(), server, prop_diff[self.METADATA]) if self.FLAVOR in prop_diff: flavor_update_policy = (prop_diff.get(self.FLAVOR_UPDATE_POLICY) or self.properties.get( self.FLAVOR_UPDATE_POLICY)) if flavor_update_policy == 'REPLACE': raise resource.UpdateReplace(self.name) flavor = prop_diff[self.FLAVOR] flavor_id = nova_utils.get_flavor_id(self.nova(), flavor) if not server: server = self.nova().servers.get(self.resource_id) checker = scheduler.TaskRunner(nova_utils.resize, server, flavor, flavor_id) checkers.append(checker) if self.IMAGE in prop_diff: image_update_policy = (prop_diff.get(self.IMAGE_UPDATE_POLICY) or self.properties.get( self.IMAGE_UPDATE_POLICY)) if image_update_policy == 'REPLACE': raise resource.UpdateReplace(self.name) image = prop_diff[self.IMAGE] image_id = nova_utils.get_image_id(self.nova(), image) if not server: server = self.nova().servers.get(self.resource_id) preserve_ephemeral = ( image_update_policy == 'REBUILD_PRESERVE_EPHEMERAL') checker = scheduler.TaskRunner( nova_utils.rebuild, server, image_id, preserve_ephemeral=preserve_ephemeral) checkers.append(checker) if self.NAME in prop_diff: if not server: server = self.nova().servers.get(self.resource_id) nova_utils.rename(server, prop_diff[self.NAME]) # Optimization: make sure the first task is started before # check_update_complete. if checkers: checkers[0].start() return checkers
def handle_update(self, json_snippet, tmpl_diff, prop_diff): if 'Metadata' in tmpl_diff: self.metadata = tmpl_diff['Metadata'] checkers = [] server = None if self.METADATA in prop_diff: server = self.nova().servers.get(self.resource_id) nova_utils.meta_update(self.nova(), server, prop_diff[self.METADATA]) if self.FLAVOR in prop_diff: flavor_update_policy = ( prop_diff.get(self.FLAVOR_UPDATE_POLICY) or self.properties.get(self.FLAVOR_UPDATE_POLICY)) if flavor_update_policy == 'REPLACE': raise resource.UpdateReplace(self.name) flavor = prop_diff[self.FLAVOR] flavor_id = nova_utils.get_flavor_id(self.nova(), flavor) if not server: server = self.nova().servers.get(self.resource_id) checker = scheduler.TaskRunner(nova_utils.resize, server, flavor, flavor_id) checkers.append(checker) if self.IMAGE in prop_diff: image_update_policy = ( prop_diff.get(self.IMAGE_UPDATE_POLICY) or self.properties.get(self.IMAGE_UPDATE_POLICY)) if image_update_policy == 'REPLACE': raise resource.UpdateReplace(self.name) image = prop_diff[self.IMAGE] image_id = nova_utils.get_image_id(self.nova(), image) if not server: server = self.nova().servers.get(self.resource_id) preserve_ephemeral = ( image_update_policy == 'REBUILD_PRESERVE_EPHEMERAL') checker = scheduler.TaskRunner( nova_utils.rebuild, server, image_id, preserve_ephemeral=preserve_ephemeral) checkers.append(checker) if self.NAME in prop_diff: if not server: server = self.nova().servers.get(self.resource_id) nova_utils.rename(server, prop_diff[self.NAME]) # Optimization: make sure the first task is started before # check_update_complete. if checkers: checkers[0].start() return checkers
def handle_update(self, json_snippet, tmpl_diff, prop_diff): if 'Metadata' in tmpl_diff: self.metadata = tmpl_diff['Metadata'] if 'InstanceType' in prop_diff: flavor = prop_diff['InstanceType'] flavor_id = nova_utils.get_flavor_id(self.nova(), flavor) server = self.nova().servers.get(self.resource_id) server.resize(flavor_id) scheduler.TaskRunner(nova_utils.check_resize, server, flavor)()
def handle_create(self): security_groups = self._get_security_groups() userdata = self.properties['UserData'] or '' flavor = self.properties['InstanceType'] availability_zone = self.properties['AvailabilityZone'] key_name = self.properties['KeyName'] if key_name: # confirm keypair exists nova_utils.get_keypair(self.nova(), key_name) image_name = self.properties['ImageId'] image_id = nova_utils.get_image_id(self.nova(), image_name) flavor_id = nova_utils.get_flavor_id(self.nova(), flavor) tags = {} if self.properties['Tags']: for tm in self.properties['Tags']: tags[tm['Key']] = tm['Value'] else: tags = None scheduler_hints = {} if self.properties['NovaSchedulerHints']: for tm in self.properties['NovaSchedulerHints']: scheduler_hints[tm['Key']] = tm['Value'] else: scheduler_hints = None nics = self._build_nics(self.properties['NetworkInterfaces'], security_groups=security_groups, subnet_id=self.properties['SubnetId']) server = None try: server = self.nova().servers.create( name=self.physical_resource_name(), image=image_id, flavor=flavor_id, key_name=key_name, security_groups=security_groups, userdata=self.get_mime_string(userdata), meta=tags, scheduler_hints=scheduler_hints, nics=nics, availability_zone=availability_zone) finally: # Avoid a race condition where the thread could be cancelled # before the ID is stored if server is not None: self.resource_id_set(server.id) return server, scheduler.TaskRunner(self._attach_volumes_task())
def handle_create(self): security_groups = self.properties.get('security_groups', []) user_data_format = self.properties.get('user_data_format') userdata = nova_utils.build_userdata( self, self.properties.get('user_data', ''), instance_user=self.properties['admin_user'], user_data_format=user_data_format) flavor = self.properties['flavor'] availability_zone = self.properties['availability_zone'] key_name = self.properties['key_name'] if key_name: # confirm keypair exists nova_utils.get_keypair(self.nova(), key_name) image = self.properties.get('image') if image: image = nova_utils.get_image_id(self.nova(), image) flavor_id = nova_utils.get_flavor_id(self.nova(), flavor) instance_meta = self.properties.get('metadata') scheduler_hints = self.properties.get('scheduler_hints') nics = self._build_nics(self.properties.get('networks')) block_device_mapping = self._build_block_device_mapping( self.properties.get('block_device_mapping')) reservation_id = self.properties.get('reservation_id') config_drive = self.properties.get('config_drive') disk_config = self.properties.get('diskConfig') server = None try: server = self.nova().servers.create( name=self.physical_resource_name(), image=image, flavor=flavor_id, key_name=key_name, security_groups=security_groups, userdata=userdata, meta=instance_meta, scheduler_hints=scheduler_hints, nics=nics, availability_zone=availability_zone, block_device_mapping=block_device_mapping, reservation_id=reservation_id, config_drive=config_drive, disk_config=disk_config) finally: # Avoid a race condition where the thread could be cancelled # before the ID is stored if server is not None: self.resource_id_set(server.id) return server
def handle_create(self): security_groups = self.properties.get('security_groups', []) user_data_format = self.properties.get('user_data_format') if user_data_format == 'HEAT_CFNTOOLS': userdata = self.get_mime_string( self.properties.get('user_data', '')) else: userdata = self.properties.get('user_data', '') flavor = self.properties['flavor'] availability_zone = self.properties['availability_zone'] key_name = self.properties['key_name'] if key_name: # confirm keypair exists nova_utils.get_keypair(self.nova(), key_name) image = self.properties.get('image') if image: image = nova_utils.get_image_id(self.nova(), image) flavor_id = nova_utils.get_flavor_id(self.nova(), flavor) instance_meta = self.properties.get('metadata') scheduler_hints = self.properties.get('scheduler_hints') nics = self._build_nics(self.properties.get('networks')) block_device_mapping = self._build_block_device_mapping( self.properties.get('block_device_mapping')) reservation_id = self.properties.get('reservation_id') config_drive = self.properties.get('config_drive') disk_config = self.properties.get('diskConfig') server = None try: server = self.nova().servers.create( name=self.physical_resource_name(), image=image, flavor=flavor_id, key_name=key_name, security_groups=security_groups, userdata=userdata, meta=instance_meta, scheduler_hints=scheduler_hints, nics=nics, availability_zone=availability_zone, block_device_mapping=block_device_mapping, reservation_id=reservation_id, config_drive=config_drive, disk_config=disk_config) finally: # Avoid a race condition where the thread could be cancelled # before the ID is stored if server is not None: self.resource_id_set(server.id) return server
def handle_update(self, json_snippet, tmpl_diff, prop_diff): if "Metadata" in tmpl_diff: self.metadata = tmpl_diff["Metadata"] if "InstanceType" in prop_diff: flavor = prop_diff["InstanceType"] flavor_id = nova_utils.get_flavor_id(self.nova(), flavor) server = self.nova().servers.get(self.resource_id) server.resize(flavor_id) checker = scheduler.TaskRunner(nova_utils.check_resize, server, flavor) checker.start() return checker
def handle_create(self): security_groups = self._get_security_groups() userdata = self.properties['UserData'] or '' flavor = self.properties['InstanceType'] availability_zone = self.properties['AvailabilityZone'] key_name = self.properties['KeyName'] if key_name: # confirm keypair exists nova_utils.get_keypair(self.nova(), key_name) image_name = self.properties['ImageId'] image_id = nova_utils.get_image_id(self.nova(), image_name) flavor_id = nova_utils.get_flavor_id(self.nova(), flavor) tags = {} if self.properties['Tags']: for tm in self.properties['Tags']: tags[tm['Key']] = tm['Value'] else: tags = None scheduler_hints = {} if self.properties['NovaSchedulerHints']: for tm in self.properties['NovaSchedulerHints']: scheduler_hints[tm['Key']] = tm['Value'] else: scheduler_hints = None nics = self._build_nics(self.properties['NetworkInterfaces'], subnet_id=self.properties['SubnetId']) server = None try: server = self.nova().servers.create( name=self.physical_resource_name(), image=image_id, flavor=flavor_id, key_name=key_name, security_groups=security_groups, userdata=self.get_mime_string(userdata), meta=tags, scheduler_hints=scheduler_hints, nics=nics, availability_zone=availability_zone) finally: # Avoid a race condition where the thread could be cancelled # before the ID is stored if server is not None: self.resource_id_set(server.id) return server, scheduler.TaskRunner(self._attach_volumes_task())
def handle_create(self): security_groups = self._get_security_groups() userdata = self.properties[self.USER_DATA] or '' flavor = self.properties[self.INSTANCE_TYPE] availability_zone = self.properties[self.AVAILABILITY_ZONE] image_name = self.properties[self.IMAGE_ID] image_id = nova_utils.get_image_id(self.nova(), image_name) flavor_id = nova_utils.get_flavor_id(self.nova(), flavor) scheduler_hints = {} if self.properties[self.NOVA_SCHEDULER_HINTS]: for tm in self.properties[self.NOVA_SCHEDULER_HINTS]: scheduler_hints[tm[self.TAG_KEY]] = tm[self.TAG_VALUE] else: scheduler_hints = None nics = self._build_nics(self.properties[self.NETWORK_INTERFACES], security_groups=security_groups, subnet_id=self.properties[self.SUBNET_ID]) server = None # FIXME(shadower): the instance_user config option is deprecated. Once # it's gone, we should always use ec2-user for compatibility with # CloudFormation. if cfg.CONF.instance_user: instance_user = cfg.CONF.instance_user else: instance_user = '******' try: server = self.nova().servers.create( name=self.physical_resource_name(), image=image_id, flavor=flavor_id, key_name=self.properties[self.KEY_NAME], security_groups=security_groups, userdata=nova_utils.build_userdata(self, userdata, instance_user), meta=self._get_nova_metadata(self.properties), scheduler_hints=scheduler_hints, nics=nics, availability_zone=availability_zone) finally: # Avoid a race condition where the thread could be cancelled # before the ID is stored if server is not None: self.resource_id_set(server.id) return server, scheduler.TaskRunner(self._attach_volumes_task())
def handle_update(self, json_snippet, tmpl_diff, prop_diff): if 'Metadata' in tmpl_diff: self.metadata = tmpl_diff['Metadata'] checkers = [] server = None if 'metadata' in prop_diff: server = self.nova().servers.get(self.resource_id) nova_utils.meta_update(self.nova(), server, prop_diff['metadata']) if 'flavor' in prop_diff: flavor_update_policy = ( prop_diff.get('flavor_update_policy') or self.properties.get('flavor_update_policy')) if flavor_update_policy == 'REPLACE': raise resource.UpdateReplace(self.name) flavor = prop_diff['flavor'] flavor_id = nova_utils.get_flavor_id(self.nova(), flavor) if not server: server = self.nova().servers.get(self.resource_id) checker = scheduler.TaskRunner(nova_utils.resize, server, flavor, flavor_id) checkers.append(checker) if 'image' in prop_diff: image_update_policy = ( prop_diff.get('image_update_policy') or self.properties.get('image_update_policy')) if image_update_policy == 'REPLACE': raise resource.UpdateReplace(self.name) image = prop_diff['image'] image_id = nova_utils.get_image_id(self.nova(), image) if not server: server = self.nova().servers.get(self.resource_id) checker = scheduler.TaskRunner(nova_utils.rebuild, server, image_id) checkers.append(checker) # Optimization: make sure the first task is started before # check_update_complete. if checkers: checkers[0].start() return checkers
def handle_create(self): security_groups = self._get_security_groups() userdata = self.properties[self.USER_DATA] or '' flavor = self.properties[self.INSTANCE_TYPE] availability_zone = self.properties[self.AVAILABILITY_ZONE] key_name = self.properties[self.KEY_NAME] if key_name: # confirm keypair exists nova_utils.get_keypair(self.nova(), key_name) image_name = self.properties[self.IMAGE_ID] image_id = nova_utils.get_image_id(self.nova(), image_name) flavor_id = nova_utils.get_flavor_id(self.nova(), flavor) scheduler_hints = {} if self.properties[self.NOVA_SCHEDULER_HINTS]: for tm in self.properties[self.NOVA_SCHEDULER_HINTS]: scheduler_hints[tm[self.TAG_KEY]] = tm[self.TAG_VALUE] else: scheduler_hints = None nics = self._build_nics(self.properties[self.NETWORK_INTERFACES], security_groups=security_groups, subnet_id=self.properties[self.SUBNET_ID]) server = None try: server = self.nova().servers.create( name=self.physical_resource_name(), image=image_id, flavor=flavor_id, key_name=key_name, security_groups=security_groups, userdata=nova_utils.build_userdata(self, userdata), meta=self._get_nova_metadata(self.properties), scheduler_hints=scheduler_hints, nics=nics, availability_zone=availability_zone) finally: # Avoid a race condition where the thread could be cancelled # before the ID is stored if server is not None: self.resource_id_set(server.id) return server, scheduler.TaskRunner(self._attach_volumes_task())
def handle_update(self, json_snippet, tmpl_diff, prop_diff): if 'Metadata' in tmpl_diff: self.metadata = tmpl_diff['Metadata'] checkers = [] server = None if 'metadata' in prop_diff: server = self.nova().servers.get(self.resource_id) nova_utils.meta_update(self.nova(), server, prop_diff['metadata']) if 'flavor' in prop_diff: flavor_update_policy = ( prop_diff.get('flavor_update_policy') or self.properties.get('flavor_update_policy')) if flavor_update_policy == 'REPLACE': raise resource.UpdateReplace(self.name) flavor = prop_diff['flavor'] flavor_id = nova_utils.get_flavor_id(self.nova(), flavor) if not server: server = self.nova().servers.get(self.resource_id) checker = scheduler.TaskRunner(nova_utils.resize, server, flavor, flavor_id) checkers.append(checker) if 'image' in prop_diff: image_update_policy = (prop_diff.get('image_update_policy') or self.properties.get('image_update_policy')) if image_update_policy == 'REPLACE': raise resource.UpdateReplace(self.name) image = prop_diff['image'] image_id = nova_utils.get_image_id(self.nova(), image) if not server: server = self.nova().servers.get(self.resource_id) checker = scheduler.TaskRunner(nova_utils.rebuild, server, image_id) checkers.append(checker) # Optimization: make sure the first task is started before # check_update_complete. if checkers: checkers[0].start() return checkers
def handle_update(self, json_snippet, tmpl_diff, prop_diff): if 'Metadata' in tmpl_diff: self.metadata = tmpl_diff['Metadata'] if 'flavor' in prop_diff: flavor_update_policy = ( prop_diff.get('flavor_update_policy') or self.properties.get('flavor_update_policy')) if flavor_update_policy == 'REPLACE': raise resource.UpdateReplace(self.name) flavor = prop_diff['flavor'] flavor_id = nova_utils.get_flavor_id(self.nova(), flavor) server = self.nova().servers.get(self.resource_id) server.resize(flavor_id) scheduler.TaskRunner(nova_utils.check_resize, server, flavor)()
def handle_update(self, json_snippet, tmpl_diff, prop_diff): if 'Metadata' in tmpl_diff: self.metadata = tmpl_diff['Metadata'] server = None if self.TAGS in prop_diff: server = self.nova().servers.get(self.resource_id) nova_utils.meta_update(self.nova(), server, self._get_nova_metadata(prop_diff)) if self.INSTANCE_TYPE in prop_diff: flavor = prop_diff[self.INSTANCE_TYPE] flavor_id = nova_utils.get_flavor_id(self.nova(), flavor) if not server: server = self.nova().servers.get(self.resource_id) checker = scheduler.TaskRunner(nova_utils.resize, server, flavor, flavor_id) checker.start() return checker
def handle_update(self, json_snippet, tmpl_diff, prop_diff): if 'Metadata' in tmpl_diff: self.metadata_set(tmpl_diff['Metadata']) checkers = [] server = None if self.METADATA in prop_diff: server = self.nova().servers.get(self.resource_id) nova_utils.meta_update(self.nova(), server, prop_diff[self.METADATA]) if self.FLAVOR in prop_diff: flavor_update_policy = ( prop_diff.get(self.FLAVOR_UPDATE_POLICY) or self.properties.get(self.FLAVOR_UPDATE_POLICY)) if flavor_update_policy == 'REPLACE': raise resource.UpdateReplace(self.name) flavor = prop_diff[self.FLAVOR] flavor_id = nova_utils.get_flavor_id(self.nova(), flavor) if not server: server = self.nova().servers.get(self.resource_id) checker = scheduler.TaskRunner(nova_utils.resize, server, flavor, flavor_id) checkers.append(checker) if self.IMAGE in prop_diff: image_update_policy = ( prop_diff.get(self.IMAGE_UPDATE_POLICY) or self.properties.get(self.IMAGE_UPDATE_POLICY)) if image_update_policy == 'REPLACE': raise resource.UpdateReplace(self.name) image = prop_diff[self.IMAGE] image_id = self.client_plugin('glance').get_image_id(image) if not server: server = self.nova().servers.get(self.resource_id) preserve_ephemeral = ( image_update_policy == 'REBUILD_PRESERVE_EPHEMERAL') checker = scheduler.TaskRunner( nova_utils.rebuild, server, image_id, preserve_ephemeral=preserve_ephemeral) checkers.append(checker) if self.NAME in prop_diff: if not server: server = self.nova().servers.get(self.resource_id) nova_utils.rename(server, prop_diff[self.NAME]) if self.NETWORKS in prop_diff: new_networks = prop_diff.get(self.NETWORKS) attach_first_free_port = False if not new_networks: new_networks = [] attach_first_free_port = True old_networks = self.properties.get(self.NETWORKS) if not server: server = self.nova().servers.get(self.resource_id) interfaces = server.interface_list() # if old networks is None, it means that the server got first # free port. so we should detach this interface. if old_networks is None: for iface in interfaces: checker = scheduler.TaskRunner(server.interface_detach, iface.port_id) checkers.append(checker) # if we have any information in networks field, we should: # 1. find similar networks, if they exist # 2. remove these networks from new_networks and old_networks # lists # 3. detach unmatched networks, which were present in old_networks # 4. attach unmatched networks, which were present in new_networks else: # remove not updated networks from old and new networks lists, # also get list these networks not_updated_networks = \ self._get_network_matches(old_networks, new_networks) self.update_networks_matching_iface_port( old_networks + not_updated_networks, interfaces) # according to nova interface-detach command detached port # will be deleted for net in old_networks: checker = scheduler.TaskRunner(server.interface_detach, net.get('port')) checkers.append(checker) # attach section similar for both variants that # were mentioned above for net in new_networks: if net.get('port'): checker = scheduler.TaskRunner(server.interface_attach, net['port'], None, None) checkers.append(checker) elif net.get('network'): checker = scheduler.TaskRunner(server.interface_attach, None, net['network'], net.get('fixed_ip')) checkers.append(checker) # if new_networks is None, we should attach first free port, # according to similar behavior during instance creation if attach_first_free_port: checker = scheduler.TaskRunner(server.interface_attach, None, None, None) checkers.append(checker) # Optimization: make sure the first task is started before # check_update_complete. if checkers: checkers[0].start() return checkers
def handle_create(self): security_groups = self.properties.get(self.SECURITY_GROUPS) user_data_format = self.properties.get(self.USER_DATA_FORMAT) ud_content = self.properties.get(self.USER_DATA) if self.user_data_software_config() or self.user_data_raw(): if uuidutils.is_uuid_like(ud_content): # attempt to load the userdata from software config try: ud_content = sc.SoftwareConfig.get_software_config( self.heat(), ud_content) except exception.SoftwareConfigMissing: # no config was found, so do not modify the user_data pass if self.user_data_software_config(): self._create_transport_credentials() self._populate_deployments_metadata() if self.properties[self.ADMIN_USER]: instance_user = self.properties[self.ADMIN_USER] elif cfg.CONF.instance_user: instance_user = cfg.CONF.instance_user else: instance_user = None userdata = nova_utils.build_userdata( self, ud_content, instance_user=instance_user, user_data_format=user_data_format) flavor = self.properties[self.FLAVOR] availability_zone = self.properties[self.AVAILABILITY_ZONE] image = self.properties.get(self.IMAGE) if image: image = self.client_plugin('glance').get_image_id(image) flavor_id = nova_utils.get_flavor_id(self.nova(), flavor) instance_meta = self.properties.get(self.METADATA) if instance_meta is not None: instance_meta = nova_utils.meta_serialize(instance_meta) scheduler_hints = self.properties.get(self.SCHEDULER_HINTS) nics = self._build_nics(self.properties.get(self.NETWORKS)) block_device_mapping = self._build_block_device_mapping( self.properties.get(self.BLOCK_DEVICE_MAPPING)) reservation_id = self.properties.get(self.RESERVATION_ID) disk_config = self.properties.get(self.DISK_CONFIG) admin_pass = self.properties.get(self.ADMIN_PASS) or None personality_files = self.properties.get(self.PERSONALITY) key_name = self.properties.get(self.KEY_NAME) server = None try: server = self.nova().servers.create( name=self._server_name(), image=image, flavor=flavor_id, key_name=key_name, security_groups=security_groups, userdata=userdata, meta=instance_meta, scheduler_hints=scheduler_hints, nics=nics, availability_zone=availability_zone, block_device_mapping=block_device_mapping, reservation_id=reservation_id, config_drive=self._config_drive(), disk_config=disk_config, files=personality_files, admin_pass=admin_pass) finally: # Avoid a race condition where the thread could be cancelled # before the ID is stored if server is not None: self.resource_id_set(server.id) return server
def validate_with_client(self, client, value): nova_client = client.client('nova') nova_utils.get_flavor_id(nova_client, value)
def handle_create(self): security_groups = self._get_security_groups() userdata = self.properties['UserData'] or '' flavor = self.properties['InstanceType'] availability_zone = self.properties['AvailabilityZone'] key_name = self.properties['KeyName'] if key_name: # confirm keypair exists nova_utils.get_keypair(self.nova(), key_name) image_name = self.properties['ImageId'] image_id = nova_utils.get_image_id(self.nova(), image_name) flavor_id = nova_utils.get_flavor_id(self.nova(), flavor) tags = {} if self.properties['Tags']: for tm in self.properties['Tags']: tags[tm['Key']] = tm['Value'] else: tags = None scheduler_hints = {} if self.properties['NovaSchedulerHints']: for tm in self.properties['NovaSchedulerHints']: scheduler_hints[tm['Key']] = tm['Value'] else: scheduler_hints = None nics = self._build_nics(self.properties['NetworkInterfaces'], security_groups=security_groups, subnet_id=self.properties['SubnetId']) server = None # TODO(sdake/shardy) ensure physical_resource_name() never returns a # string longer than 63 characters, as this is pretty inconvenient # behavior for autoscaling groups and nested stacks where instance # names can easily become quite long even with terse names. physical_resource_name_len = len(self.physical_resource_name()) if physical_resource_name_len > 63: raise exception.Error( _('Server %(server)s length %(length)d > 63' ' characters, please reduce the length of' ' stack or resource names') % dict(server=self.physical_resource_name(), length=physical_resource_name_len)) try: server = self.nova().servers.create( name=self.physical_resource_name(), image=image_id, flavor=flavor_id, key_name=key_name, security_groups=security_groups, userdata=self.get_mime_string(userdata), meta=tags, scheduler_hints=scheduler_hints, nics=nics, availability_zone=availability_zone) finally: # Avoid a race condition where the thread could be cancelled # before the ID is stored if server is not None: self.resource_id_set(server.id) return server, scheduler.TaskRunner(self._attach_volumes_task())
def handle_update(self, json_snippet, tmpl_diff, prop_diff): if 'Metadata' in tmpl_diff: self.metadata_set(tmpl_diff['Metadata']) checkers = [] server = None if self.TAGS in prop_diff: server = self.nova().servers.get(self.resource_id) nova_utils.meta_update(self.nova(), server, self._get_nova_metadata(prop_diff)) if self.INSTANCE_TYPE in prop_diff: flavor = prop_diff[self.INSTANCE_TYPE] flavor_id = nova_utils.get_flavor_id(self.nova(), flavor) if not server: server = self.nova().servers.get(self.resource_id) checker = scheduler.TaskRunner(nova_utils.resize, server, flavor, flavor_id) checkers.append(checker) if self.NETWORK_INTERFACES in prop_diff: new_network_ifaces = prop_diff.get(self.NETWORK_INTERFACES) old_network_ifaces = self.properties.get(self.NETWORK_INTERFACES) subnet_id = (prop_diff.get(self.SUBNET_ID) or self.properties.get(self.SUBNET_ID)) security_groups = self._get_security_groups() if not server: server = self.nova().servers.get(self.resource_id) # if there is entrys in old_network_ifaces and new_network_ifaces, # remove the same entrys from old and new ifaces if old_network_ifaces and new_network_ifaces: # there are four situations: # 1.old includes new, such as: old = 2,3, new = 2 # 2.new includes old, such as: old = 2,3, new = 1,2,3 # 3.has overlaps, such as: old = 2,3, new = 1,2 # 4.different, such as: old = 2,3, new = 1,4 # detach unmatched ones in old, attach unmatched ones in new self._remove_matched_ifaces(old_network_ifaces, new_network_ifaces) if old_network_ifaces: old_nics = self._build_nics(old_network_ifaces) for nic in old_nics: checker = scheduler.TaskRunner(server.interface_detach, nic['port-id']) checkers.append(checker) if new_network_ifaces: new_nics = self._build_nics(new_network_ifaces) for nic in new_nics: checker = scheduler.TaskRunner(server.interface_attach, nic['port-id'], None, None) checkers.append(checker) # if the interfaces not come from property 'NetworkInterfaces', # the situation is somewhat complex, so to detach the old ifaces, # and then attach the new ones. else: interfaces = server.interface_list() for iface in interfaces: checker = scheduler.TaskRunner(server.interface_detach, iface.port_id) checkers.append(checker) nics = self._build_nics(new_network_ifaces, security_groups=security_groups, subnet_id=subnet_id) # 'SubnetId' property is empty(or None) and # 'NetworkInterfaces' property is empty(or None), # _build_nics() will return nics = None,we should attach # first free port, according to similar behavior during # instance creation if not nics: checker = scheduler.TaskRunner(server.interface_attach, None, None, None) checkers.append(checker) else: for nic in nics: checker = scheduler.TaskRunner(server.interface_attach, nic['port-id'], None, None) checkers.append(checker) if checkers: checkers[0].start() return checkers
def handle_create(self): security_groups = self._get_security_groups() userdata = self.properties['UserData'] or '' flavor = self.properties['InstanceType'] availability_zone = self.properties['AvailabilityZone'] key_name = self.properties['KeyName'] if key_name: # confirm keypair exists nova_utils.get_keypair(self.nova(), key_name) image_name = self.properties['ImageId'] image_id = nova_utils.get_image_id(self.nova(), image_name) flavor_id = nova_utils.get_flavor_id(self.nova(), flavor) tags = {} if self.properties['Tags']: for tm in self.properties['Tags']: tags[tm['Key']] = tm['Value'] else: tags = None scheduler_hints = {} if self.properties['NovaSchedulerHints']: for tm in self.properties['NovaSchedulerHints']: scheduler_hints[tm['Key']] = tm['Value'] else: scheduler_hints = None nics = self._build_nics(self.properties['NetworkInterfaces'], security_groups=security_groups, subnet_id=self.properties['SubnetId']) server = None # TODO(sdake/shardy) ensure physical_resource_name() never returns a # string longer than 63 characters, as this is pretty inconvenient # behavior for autoscaling groups and nested stacks where instance # names can easily become quite long even with terse names. physical_resource_name_len = len(self.physical_resource_name()) if physical_resource_name_len > 63: raise exception.Error(_('Server %(server)s length %(length)d > 63' ' characters, please reduce the length of' ' stack or resource names') % dict(server=self.physical_resource_name(), length=physical_resource_name_len)) try: server = self.nova().servers.create( name=self.physical_resource_name(), image=image_id, flavor=flavor_id, key_name=key_name, security_groups=security_groups, userdata=self.get_mime_string(userdata), meta=tags, scheduler_hints=scheduler_hints, nics=nics, availability_zone=availability_zone) finally: # Avoid a race condition where the thread could be cancelled # before the ID is stored if server is not None: self.resource_id_set(server.id) return server, scheduler.TaskRunner(self._attach_volumes_task())
def flavor(self): """Get the flavors from the API.""" if not self._flavor: self._flavor = nova_utils.get_flavor_id(self.nova(), self.properties["flavor"]) return self._flavor
def handle_create(self): security_groups = self.properties.get('security_groups', []) user_data_format = self.properties.get('user_data_format') if user_data_format == 'HEAT_CFNTOOLS': userdata = self.get_mime_string( self.properties.get('user_data', '')) else: userdata = self.properties.get('user_data', '') flavor = self.properties['flavor'] availability_zone = self.properties['availability_zone'] key_name = self.properties['key_name'] if key_name: # confirm keypair exists nova_utils.get_keypair(self.nova(), key_name) image = self.properties.get('image') if image: image = nova_utils.get_image_id(self.nova(), image) flavor_id = nova_utils.get_flavor_id(self.nova(), flavor) instance_meta = self.properties.get('metadata') scheduler_hints = self.properties.get('scheduler_hints') nics = self._build_nics(self.properties.get('networks')) block_device_mapping = self._build_block_device_mapping( self.properties.get('block_device_mapping')) reservation_id = self.properties.get('reservation_id') config_drive = self.properties.get('config_drive') disk_config = self.properties.get('diskConfig') # TODO(sdake/shardy) ensure physical_resource_name() never returns a # string longer than 63 characters, as this is pretty inconvenient # behavior for autoscaling groups and nested stacks where instance # names can easily become quite long even with terse names. physical_resource_name_len = len(self.physical_resource_name()) if physical_resource_name_len > 63: raise exception.Error( _('Server %(server)s length %(length)d > 63' ' characters, please reduce the length of' ' stack or resource names') % dict(server=self.physical_resource_name(), length=physical_resource_name_len)) server = None try: server = self.nova().servers.create( name=self.physical_resource_name(), image=image, flavor=flavor_id, key_name=key_name, security_groups=security_groups, userdata=userdata, meta=instance_meta, scheduler_hints=scheduler_hints, nics=nics, availability_zone=availability_zone, block_device_mapping=block_device_mapping, reservation_id=reservation_id, config_drive=config_drive, disk_config=disk_config) finally: # Avoid a race condition where the thread could be cancelled # before the ID is stored if server is not None: self.resource_id_set(server.id) return server
def flavor(self): """Get the flavors from the API.""" if not self._flavor: flavor = self.properties[self.FLAVOR] self._flavor = nova_utils.get_flavor_id(self.nova(), flavor) return self._flavor
def handle_create(self): security_groups = self.properties.get(self.SECURITY_GROUPS) user_data_format = self.properties.get(self.USER_DATA_FORMAT) ud_content = self.properties.get(self.USER_DATA) if self.user_data_software_config() or self.user_data_raw(): if uuidutils.is_uuid_like(ud_content): # attempt to load the userdata from software config try: ud_content = sc.SoftwareConfig.get_software_config( self.heat(), ud_content) except exception.SoftwareConfigMissing: # no config was found, so do not modify the user_data pass if self.user_data_software_config(): self._create_transport_credentials() if self.properties[self.ADMIN_USER]: instance_user = self.properties[self.ADMIN_USER] elif cfg.CONF.instance_user: instance_user = cfg.CONF.instance_user else: instance_user = None userdata = nova_utils.build_userdata(self, ud_content, instance_user=instance_user, user_data_format=user_data_format) flavor = self.properties[self.FLAVOR] availability_zone = self.properties[self.AVAILABILITY_ZONE] image = self.properties.get(self.IMAGE) if image: image = nova_utils.get_image_id(self.nova(), image) flavor_id = nova_utils.get_flavor_id(self.nova(), flavor) instance_meta = self.properties.get(self.METADATA) if instance_meta is not None: instance_meta = nova_utils.meta_serialize(instance_meta) scheduler_hints = self.properties.get(self.SCHEDULER_HINTS) nics = self._build_nics(self.properties.get(self.NETWORKS)) block_device_mapping = self._build_block_device_mapping( self.properties.get(self.BLOCK_DEVICE_MAPPING)) reservation_id = self.properties.get(self.RESERVATION_ID) config_drive = self.properties.get(self.CONFIG_DRIVE) disk_config = self.properties.get(self.DISK_CONFIG) admin_pass = self.properties.get(self.ADMIN_PASS) or None server = None try: server = self.nova().servers.create( name=self.physical_resource_name(), image=image, flavor=flavor_id, key_name=self._key_name(), security_groups=security_groups, userdata=userdata, meta=instance_meta, scheduler_hints=scheduler_hints, nics=nics, availability_zone=availability_zone, block_device_mapping=block_device_mapping, reservation_id=reservation_id, config_drive=config_drive, disk_config=disk_config, files=self._personality(), admin_pass=admin_pass) finally: # Avoid a race condition where the thread could be cancelled # before the ID is stored if server is not None: self.resource_id_set(server.id) return server
def handle_update(self, json_snippet, tmpl_diff, prop_diff): if 'Metadata' in tmpl_diff: self.metadata_set(tmpl_diff['Metadata']) checkers = [] server = None if self.TAGS in prop_diff: server = self.nova().servers.get(self.resource_id) nova_utils.meta_update(self.nova(), server, self._get_nova_metadata(prop_diff)) if self.INSTANCE_TYPE in prop_diff: flavor = prop_diff[self.INSTANCE_TYPE] flavor_id = nova_utils.get_flavor_id(self.nova(), flavor) if not server: server = self.nova().servers.get(self.resource_id) checker = scheduler.TaskRunner(nova_utils.resize, server, flavor, flavor_id) checkers.append(checker) if self.NETWORK_INTERFACES in prop_diff: new_network_ifaces = prop_diff.get(self.NETWORK_INTERFACES) old_network_ifaces = self.properties.get(self.NETWORK_INTERFACES) subnet_id = ( prop_diff.get(self.SUBNET_ID) or self.properties.get(self.SUBNET_ID)) security_groups = self._get_security_groups() if not server: server = self.nova().servers.get(self.resource_id) # if there is entrys in old_network_ifaces and new_network_ifaces, # remove the same entrys from old and new ifaces if old_network_ifaces and new_network_ifaces: # there are four situations: # 1.old includes new, such as: old = 2,3, new = 2 # 2.new includes old, such as: old = 2,3, new = 1,2,3 # 3.has overlaps, such as: old = 2,3, new = 1,2 # 4.different, such as: old = 2,3, new = 1,4 # detach unmatched ones in old, attach unmatched ones in new self._remove_matched_ifaces(old_network_ifaces, new_network_ifaces) if old_network_ifaces: old_nics = self._build_nics(old_network_ifaces) for nic in old_nics: checker = scheduler.TaskRunner( server.interface_detach, nic['port-id']) checkers.append(checker) if new_network_ifaces: new_nics = self._build_nics(new_network_ifaces) for nic in new_nics: checker = scheduler.TaskRunner( server.interface_attach, nic['port-id'], None, None) checkers.append(checker) # if the interfaces not come from property 'NetworkInterfaces', # the situation is somewhat complex, so to detach the old ifaces, # and then attach the new ones. else: interfaces = server.interface_list() for iface in interfaces: checker = scheduler.TaskRunner(server.interface_detach, iface.port_id) checkers.append(checker) nics = self._build_nics(new_network_ifaces, security_groups=security_groups, subnet_id=subnet_id) # 'SubnetId' property is empty(or None) and # 'NetworkInterfaces' property is empty(or None), # _build_nics() will return nics = None,we should attach # first free port, according to similar behavior during # instance creation if not nics: checker = scheduler.TaskRunner(server.interface_attach, None, None, None) checkers.append(checker) else: for nic in nics: checker = scheduler.TaskRunner( server.interface_attach, nic['port-id'], None, None) checkers.append(checker) if checkers: checkers[0].start() return checkers
def handle_create(self): security_groups = self.properties.get('security_groups', []) userdata = self.properties.get('user_data', '') flavor = self.properties['flavor'] availability_zone = self.properties['availability_zone'] key_name = self.properties['key_name'] if key_name: # confirm keypair exists nova_utils.get_keypair(self.nova(), key_name) image = self.properties.get('image') if image: image = nova_utils.get_image_id(self.nova(), image) flavor_id = nova_utils.get_flavor_id(self.nova(), flavor) instance_meta = self.properties.get('metadata') scheduler_hints = self.properties.get('scheduler_hints') nics = self._build_nics(self.properties.get('networks')) block_device_mapping = self._build_block_device_mapping( self.properties.get('block_device_mapping')) reservation_id = self.properties.get('reservation_id') config_drive = self.properties.get('config_drive') disk_config = self.properties.get('diskConfig') # TODO(sdake/shardy) ensure physical_resource_name() never returns a # string longer than 63 characters, as this is pretty inconvenient # behavior for autoscaling groups and nested stacks where instance # names can easily become quite long even with terse names. physical_resource_name_len = len(self.physical_resource_name()) if physical_resource_name_len > 63: raise exception.Error(_('Server %(server)s length %(length)d > 63' ' characters, please reduce the length of' ' stack or resource names') % dict(server=self.physical_resource_name(), length=physical_resource_name_len)) server = None try: server = self.nova().servers.create( name=self.physical_resource_name(), image=image, flavor=flavor_id, key_name=key_name, security_groups=security_groups, userdata=self.get_mime_string(userdata), meta=instance_meta, scheduler_hints=scheduler_hints, nics=nics, availability_zone=availability_zone, block_device_mapping=block_device_mapping, reservation_id=reservation_id, config_drive=config_drive, disk_config=disk_config) finally: # Avoid a race condition where the thread could be cancelled # before the ID is stored if server is not None: self.resource_id_set(server.id) return server
def flavor(self): """Get the flavors from the API.""" if not self._flavor: self._flavor = nova_utils.get_flavor_id(self.nova(), self.properties['flavor']) return self._flavor
def handle_update(self, json_snippet, tmpl_diff, prop_diff): if 'Metadata' in tmpl_diff: self.metadata = tmpl_diff['Metadata'] checkers = [] server = None if self.METADATA in prop_diff: server = self.nova().servers.get(self.resource_id) nova_utils.meta_update(self.nova(), server, prop_diff[self.METADATA]) if self.FLAVOR in prop_diff: flavor_update_policy = (prop_diff.get(self.FLAVOR_UPDATE_POLICY) or self.properties.get( self.FLAVOR_UPDATE_POLICY)) if flavor_update_policy == 'REPLACE': raise resource.UpdateReplace(self.name) flavor = prop_diff[self.FLAVOR] flavor_id = nova_utils.get_flavor_id(self.nova(), flavor) if not server: server = self.nova().servers.get(self.resource_id) checker = scheduler.TaskRunner(nova_utils.resize, server, flavor, flavor_id) checkers.append(checker) if self.IMAGE in prop_diff: image_update_policy = (prop_diff.get(self.IMAGE_UPDATE_POLICY) or self.properties.get( self.IMAGE_UPDATE_POLICY)) if image_update_policy == 'REPLACE': raise resource.UpdateReplace(self.name) image = prop_diff[self.IMAGE] image_id = nova_utils.get_image_id(self.nova(), image) if not server: server = self.nova().servers.get(self.resource_id) preserve_ephemeral = ( image_update_policy == 'REBUILD_PRESERVE_EPHEMERAL') checker = scheduler.TaskRunner( nova_utils.rebuild, server, image_id, preserve_ephemeral=preserve_ephemeral) checkers.append(checker) if self.NAME in prop_diff: if not server: server = self.nova().servers.get(self.resource_id) nova_utils.rename(server, prop_diff[self.NAME]) if self.NETWORKS in prop_diff: new_networks = prop_diff.get(self.NETWORKS) attach_first_free_port = False if not new_networks: new_networks = [] attach_first_free_port = True old_networks = self.properties.get(self.NETWORKS) if not server: server = self.nova().servers.get(self.resource_id) interfaces = server.interface_list() # if old networks is None, it means that the server got first # free port. so we should detach this interface. if old_networks is None: for iface in interfaces: checker = scheduler.TaskRunner(server.interface_detach, iface.port_id) checkers.append(checker) # if we have any information in networks field, we should: # 1. find similar networks, if they exist # 2. remove these networks from new_networks and old_networks # lists # 3. detach unmatched networks, which were present in old_networks # 4. attach unmatched networks, which were present in new_networks else: # remove not updated networks from old and new networks lists, # also get list these networks not_updated_networks = \ self._get_network_matches(old_networks, new_networks) self.update_networks_matching_iface_port( old_networks + not_updated_networks, interfaces) # according to nova interface-detach command detached port # will be deleted for net in old_networks: checker = scheduler.TaskRunner(server.interface_detach, net.get('port')) checkers.append(checker) # attach section similar for both variants that # were mentioned above for net in new_networks: if net.get('port'): checker = scheduler.TaskRunner(server.interface_attach, net['port'], None, None) checkers.append(checker) elif net.get('network'): checker = scheduler.TaskRunner(server.interface_attach, None, net['network'], net.get('fixed_ip')) checkers.append(checker) # if new_networks is None, we should attach first free port, # according to similar behavior during instance creation if attach_first_free_port: checker = scheduler.TaskRunner(server.interface_attach, None, None, None) checkers.append(checker) # Optimization: make sure the first task is started before # check_update_complete. if checkers: checkers[0].start() return checkers
def validate_with_client(self, client, value): nova_client = client.nova() nova_utils.get_flavor_id(nova_client, value)