openstack-nova源码分析(十）resize

梦里梦外; 2021-11-16 10:44 430阅读 0赞

OpenStack resize 调整虚拟机配置

resize调整配置的步骤与冷迁移的步骤大致一致，只是在api以及conductor处理上由一些不同

该部分源码分析， 分析不同的部分的关键代码， 相同部分的源码可以参考冷迁移的源码分析

##### 一.API入口 #####

api 入口定义在nova/api/openstack/compute/servers.py

@wsgi.action('resize')
       // 校验 resize输入参数合法性
        @validation.schema(schema_server_resize)
        def _action_resize(self, req, id, body):
            """Resizes a given instance to the flavor size requested."""
            resize_dict = body['resize']
            
            // 获取调整的flavor配置
            flavor_ref = str(resize_dict["flavorRef"])
    
            kwargs = {}
            helpers.translate_attributes(helpers.RESIZE, resize_dict, kwargs)
    
    		
            self._resize(req, id, flavor_ref, **kwargs)

附 resize的参数校验配置

base_resize = {
        'type': 'object',
        'properties': {
            'resize': {
                'type': 'object',
                'properties': {
                    'flavorRef': parameter_types.flavor_ref,
                    'OS-DCF:diskConfig': parameter_types.disk_config,
                },
                'required': ['flavorRef'],
                'additionalProperties': False,
            },
        },
        'required': ['resize'],
        'additionalProperties': False,
    }

api resize 实际使用`_resize` 进行处理

\_resize 定义如下：

def _resize(self, req, instance_id, flavor_id, **kwargs):
        """Begin the resize process with given instance/flavor."""
        context = req.environ["nova.context"]
        
        // 获取instance信息
        instance = self._get_server(context, req, instance_id)
        context.can(server_policies.SERVERS % 'resize',
                    target={'user_id': instance.user_id,
                            'project_id': instance.project_id})
    
        try:
        // compute 调用， 调整配置
            self.compute_api.resize(context, instance, flavor_id, **kwargs)
        except exception.InstanceUnknownCell as e:
        	.....

--------------------

##### compute resize #####

compute\_api.resize 定义在nova/compute/api.py

可以看到 resize与migrate 冷迁移，合并使用的该函数，但resize与migate处理参数稍微不一样， 这里也做分析

// 校验虚拟机状态为active或者stopped状态时运行resize
    
    @check_instance_state(vm_state=[vm_states.ACTIVE, vm_states.STOPPED])
    def resize(self, context, instance, flavor_id=None, clean_shutdown=True,
               **extra_instance_updates):
        """Resize (ie, migrate) a running instance.
    
        If flavor_id is None, the process is considered a migration, keeping
        the original flavor_id. If flavor_id is not None, the instance should
        be migrated to a new host and resized to the new flavor_id.
        """
        self._check_auto_disk_config(instance, **extra_instance_updates)
    
    
    	//  获取当前flavor
        current_instance_type = instance.get_flavor()
    
        # If flavor_id is not provided, only migrate the instance.
        if not flavor_id:
    		...
        else:
        
        // 获取并校验新flavor的信息
        // 限制磁盘调整为0的设置
        
            new_instance_type = flavors.get_flavor_by_flavor_id(
                    flavor_id, read_deleted="no")
            if (new_instance_type.get('root_gb') == 0 and
                current_instance_type.get('root_gb') != 0 and
                not compute_utils.is_volume_backed_instance(context,
                    instance)):
                reason = _('Resize to zero disk flavor is not allowed.')
                raise exception.CannotResizeDisk(reason=reason)
    
    	// 没有flavor抛出异常
        if not new_instance_type:
            raise exception.FlavorNotFound(flavor_id=flavor_id)
    
        current_instance_type_name = current_instance_type['name']
        new_instance_type_name = new_instance_type['name']
        LOG.debug("Old instance type %(current_instance_type_name)s, "
                  "new instance type %(new_instance_type_name)s",
                  {'current_instance_type_name': current_instance_type_name,
                   'new_instance_type_name': new_instance_type_name},
                  instance=instance)
    
        same_instance_type = (current_instance_type['id'] ==
                              new_instance_type['id'])
    
    
        if not same_instance_type and new_instance_type.get('disabled'):
            raise exception.FlavorNotFound(flavor_id=flavor_id)
    
    	//  校验flavor是否相同， 相同则抛出异常
        if same_instance_type and flavor_id and self.cell_type != 'compute':
            raise exception.CannotResizeToSameFlavor()
    
        # ensure there is sufficient headroom for upsizes
        if flavor_id:
        //  校验配额
            deltas = compute_utils.upsize_quota_delta(context,
                                                      new_instance_type,
                                                      current_instance_type)
            try:
                quotas = compute_utils.reserve_quota_delta(context, deltas,
                                                           instance)
            except exception.OverQuota as exc:
                quotas = exc.kwargs['quotas']
                overs = exc.kwargs['overs']
                usages = exc.kwargs['usages']
                headroom = self._get_headroom(quotas, usages, deltas)
                (overs, reqs, total_alloweds,
                 useds) = self._get_over_quota_detail(headroom, overs, quotas,
                                                      deltas)
                LOG.warning(_LW("%(overs)s quota exceeded for %(pid)s,"
                                " tried to resize instance."),
                            {'overs': overs, 'pid': context.project_id})
                raise exception.TooManyInstances(overs=overs,
                                                 req=reqs,
                                                 used=useds,
                                                 allowed=total_alloweds)
        else:
            quotas = objects.Quotas(context=context)
    
    	//  标识迁移状态
        instance.task_state = task_states.RESIZE_PREP
        instance.progress = 0
        instance.update(extra_instance_updates)
        instance.save(expected_task_state=[None])
    
        filter_properties = {'ignore_hosts': []}
    
        if not CONF.allow_resize_to_same_host:
            filter_properties['ignore_hosts'].append(instance.host)
    
        if self.cell_type == 'api':
            # Commit reservations early and create migration record.
            self._resize_cells_support(context, quotas, instance,
                                       current_instance_type,
                                       new_instance_type)
    
        if not flavor_id:
    		....
        else:
        	//  发送迁移状态
            self._record_action_start(context, instance,
                                      instance_actions.RESIZE)
    
    	获取request_spec 调度参数
        try:
            request_spec = objects.RequestSpec.get_by_instance_uuid(
                context, instance.uuid)
            request_spec.ignore_hosts = filter_properties['ignore_hosts']
        except exception.RequestSpecNotFound:
            # Some old instances can still have no RequestSpec object attached
            # to them, we need to support the old way
            request_spec = None
    
        scheduler_hint = {'filter_properties': filter_properties}
        
        // 调用resize_instance
        self.compute_task_api.resize_instance(context, instance,
                extra_instance_updates, scheduler_hint=scheduler_hint,
                flavor=new_instance_type,
                reservations=quotas.reservations or [],
                clean_shutdown=clean_shutdown,
                request_spec=request_spec)

compute\_task\_api.resize\_instance 实际会调用conductor的 migrate\_server

该过程与冷迁移一致， 这里不重复分析， 具体可以参考[冷迁移分析][Link 1]

[Link 1]: https://blog.csdn.net/comprel/article/details/97616533