• OpenStack之虚机热迁移代码解析


    OpenStack之虚机热迁移代码解析

      话说虚机迁移分为冷迁移以及热迁移,所谓热迁移用度娘的话说即是:热迁移(Live Migration,又叫动态迁移、实时迁移),即虚机保存/恢复(Save/Restore):将整个虚拟机的运行状态完整保存下来,同时可以快速的恢复到原有硬件平台甚至是不同硬件平台上。恢复以后,虚机仍旧平滑运行,用户不会察觉到任何差异。OpenStack的虚机迁移是基于Libvirt实现的,下面来看看Openstack虚机热迁移的具体代码实现。

      首先,由API入口进入到nova/api/openstack/compute/contrib/admin_actions.py

     1  @wsgi.action('os-migrateLive')
     2     def _migrate_live(self, req, id, body):
     3         """Permit admins to (live) migrate a server to a new host."""
     4         context = req.environ["nova.context"]
     5         authorize(context, 'migrateLive')
     6 
     7         try:
     8             block_migration = body["os-migrateLive"]["block_migration"]
     9             disk_over_commit = body["os-migrateLive"]["disk_over_commit"]
    10             host = body["os-migrateLive"]["host"]
    11         except (TypeError, KeyError):
    12             msg = _("host, block_migration and disk_over_commit must "
    13                     "be specified for live migration.")
    14             raise exc.HTTPBadRequest(explanation=msg)
    15 
    16         try:
    17             block_migration = strutils.bool_from_string(block_migration,
    18                                                         strict=True)
    19             disk_over_commit = strutils.bool_from_string(disk_over_commit,
    20                                                          strict=True)
    21         except ValueError as err:
    22             raise exc.HTTPBadRequest(explanation=str(err))
    23 
    24         try:
    25             instance = self.compute_api.get(context, id, want_objects=True)
    26             self.compute_api.live_migrate(context, instance, block_migration,
    27                                           disk_over_commit, host)
    28         except (exception.ComputeServiceUnavailable,
    29                 exception.InvalidHypervisorType,
    30                 exception.UnableToMigrateToSelf,
    31                 exception.DestinationHypervisorTooOld,
    32                 exception.NoValidHost,
    33                 exception.InvalidLocalStorage,
    34                 exception.InvalidSharedStorage,
    35                 exception.MigrationPreCheckError) as ex:
    36             raise exc.HTTPBadRequest(explanation=ex.format_message())
    37         except exception.InstanceNotFound as e:
    38             raise exc.HTTPNotFound(explanation=e.format_message())
    39         except exception.InstanceInvalidState as state_error:
    40             common.raise_http_conflict_for_instance_invalid_state(state_error,
    41                     'os-migrateLive')
    42         except Exception:
    43             if host is None:
    44                 msg = _("Live migration of instance %s to another host "
    45                         "failed") % id
    46             else:
    47                 msg = _("Live migration of instance %(id)s to host %(host)s "
    48                         "failed") % {'id': id, 'host': host}
    49             LOG.exception(msg)
    50             # Return messages from scheduler
    51             raise exc.HTTPBadRequest(explanation=msg)
    52 
    53         return webob.Response(status_int=202)

        这里第一行可以看到是与API文档的第二行照应的:

    1 {
    2     "os-migrateLive": {
    3         "host": "0443e9a1254044d8b99f35eace132080",
    4         "block_migration": false,
    5         "disk_over_commit": false
    6     }
    7 }

      好了,源码中其实执行迁移工作的就是第26、27行的一条语句:

    1 self.compute_api.live_migrate(context, instance, block_migration,
    2                                           disk_over_commit, host)

      由这句进入到nova/compute/api.py中,源码如下:

     1     @check_instance_cell
     2     @check_instance_state(vm_state=[vm_states.ACTIVE])
     3     def live_migrate(self, context, instance, block_migration,
     4                      disk_over_commit, host_name):
     5         """Migrate a server lively to a new host."""
     6         LOG.debug(_("Going to try to live migrate instance to %s"),
     7                   host_name or "another host", instance=instance)
     8 
     9         instance.task_state = task_states.MIGRATING
    10         instance.save(expected_task_state=[None])
    11 
    12         self.compute_task_api.live_migrate_instance(context, instance,
    13                 host_name, block_migration=block_migration,
    14                 disk_over_commit=disk_over_commit)

      第2行是一个装饰器,用于在进入API方法之前,检测虚拟机和/或任务的状态, 如果实例处于错误的状态,将会引发异常;接下来实时迁移虚机到新的主机,并将虚机状态置于“migrating”,然后由12行进入nova/conductor/api.py

    1 def live_migrate_instance(self, context, instance, host_name,
    2                               block_migration, disk_over_commit):
    3         scheduler_hint = {'host': host_name}
    4         self._manager.migrate_server(
    5             context, instance, scheduler_hint, True, False, None,
    6             block_migration, disk_over_commit, None)

      将主机名存入字典scheduler_hint中,然后调用nova/conductor/manager.py方法migrate_server,

     1 def migrate_server(self, context, instance, scheduler_hint, live, rebuild,
     2             flavor, block_migration, disk_over_commit, reservations=None):
     3         if instance and not isinstance(instance, instance_obj.Instance):
     4             # NOTE(danms): Until v2 of the RPC API, we need to tolerate
     5             # old-world instance objects here
     6             attrs = ['metadata', 'system_metadata', 'info_cache',
     7                      'security_groups']
     8             instance = instance_obj.Instance._from_db_object(
     9                 context, instance_obj.Instance(), instance,
    10                 expected_attrs=attrs)
    11         if live and not rebuild and not flavor:
    12             self._live_migrate(context, instance, scheduler_hint,
    13                                block_migration, disk_over_commit)
    14         elif not live and not rebuild and flavor:
    15             instance_uuid = instance['uuid']
    16             with compute_utils.EventReporter(context, self.db,
    17                                          'cold_migrate', instance_uuid):
    18                 self._cold_migrate(context, instance, flavor,
    19                                    scheduler_hint['filter_properties'],
    20                                    reservations)
    21         else:
    22             raise NotImplementedError()

      由于在nova/conductor/api.py中传过来的参数是

    1 self._manager.migrate_server(
    2             context, instance, scheduler_hint, True, False, None,
    3             block_migration, disk_over_commit, None)

      因此live是True,rebuild是Flase,flavor是None,执行第12、13行代码:

    1 if live and not rebuild and not flavor:
    2             self._live_migrate(context, instance, scheduler_hint,
    3                                block_migration, disk_over_commit) 

      _live_migrate代码如下:

     1  def _live_migrate(self, context, instance, scheduler_hint,
     2                       block_migration, disk_over_commit):
     3         destination = scheduler_hint.get("host")
     4         try:
     5             live_migrate.execute(context, instance, destination,
     6                              block_migration, disk_over_commit)
     7         except (exception.NoValidHost,
     8                 exception.ComputeServiceUnavailable,
     9                 exception.InvalidHypervisorType,
    10                 exception.InvalidCPUInfo,
    11                 exception.UnableToMigrateToSelf,
    12                 exception.DestinationHypervisorTooOld,
    13                 exception.InvalidLocalStorage,
    14                 exception.InvalidSharedStorage,
    15                 exception.HypervisorUnavailable,
    16                 exception.MigrationPreCheckError) as ex:
    17             with excutils.save_and_reraise_exception():
    18                 #TODO(johngarbutt) - eventually need instance actions here
    19                 request_spec = {'instance_properties': {
    20                     'uuid': instance['uuid'], },
    21                 }
    22                 scheduler_utils.set_vm_state_and_notify(context,
    23                         'compute_task', 'migrate_server',
    24                         dict(vm_state=instance['vm_state'],
    25                              task_state=None,
    26                              expected_task_state=task_states.MIGRATING,),
    27                         ex, request_spec, self.db)
    28         except Exception as ex:
    29             LOG.error(_('Migration of instance %(instance_id)s to host'
    30                        ' %(dest)s unexpectedly failed.'),
    31                        {'instance_id': instance['uuid'], 'dest': destination},
    32                        exc_info=True)
    33             raise exception.MigrationError(reason=ex)

      首先,第三行中将主机名赋给destination,然后执行迁移,后面的都是异常的捕捉,执行迁移的代码分为两部分,先看第一部分,在nova/conductor/tasks/live_migrate.py的184行左右:

    1 def execute(context, instance, destination,
    2             block_migration, disk_over_commit):
    3     task = LiveMigrationTask(context, instance,
    4                              destination,
    5                              block_migration,
    6                              disk_over_commit)
    7     #TODO(johngarbutt) create a superclass that contains a safe_execute call
    8     return task.execute()

      先创建包含安全执行回调的超类,然后返回如下函数也即执行迁移的第二部分代码,在54行左右:

     1 def execute(self):
     2         self._check_instance_is_running()
     3         self._check_host_is_up(self.source)
     4 
     5         if not self.destination:
     6             self.destination = self._find_destination()
     7         else:
     8             self._check_requested_destination()
     9 
    10         #TODO(johngarbutt) need to move complexity out of compute manager
    11         return self.compute_rpcapi.live_migration(self.context,
    12                 host=self.source,
    13                 instance=self.instance,
    14                 dest=self.destination,
    15                 block_migration=self.block_migration,
    16                 migrate_data=self.migrate_data)
    17                 #TODO(johngarbutt) disk_over_commit?

      这里有三部分内容:

    1. 如果目前主机不存在,则由调度算法选取一个目标主机,并且进行相关的检测,确保能够进行实时迁移操作;
    2. 如果目标主机存在,则直接进行相关的检测操作,确保能够进行实时迁移操作;
    3. 执行迁移操作。

      前两部分不再赘述,直接看第三部分代码,在nova/compute/rpcapi.py中:

    1 def live_migration(self, ctxt, instance, dest, block_migration, host,
    2                        migrate_data=None):
    3         # NOTE(russellb) Havana compat
    4         version = self._get_compat_version('3.0', '2.0')
    5         instance_p = jsonutils.to_primitive(instance)
    6         cctxt = self.client.prepare(server=host, version=version)
    7         cctxt.cast(ctxt, 'live_migration', instance=instance_p,
    8                    dest=dest, block_migration=block_migration,
    9                    migrate_data=migrate_data)

      热迁移开始执行:

     1  def live_migration(self, context, instance, dest,
     2                        post_method, recover_method, block_migration=False,
     3                        migrate_data=None):
     4         """Spawning live_migration operation for distributing high-load.
     5 
     6         :param context: security context
     7         :param instance:
     8             nova.db.sqlalchemy.models.Instance object
     9             instance object that is migrated.
    10         :param dest: destination host
    11         :param post_method:
    12             post operation method.
    13             expected nova.compute.manager.post_live_migration.
    14         :param recover_method:
    15             recovery method when any exception occurs.
    16             expected nova.compute.manager.recover_live_migration.
    17         :param block_migration: if true, do block migration.
    18         :param migrate_data: implementation specific params
    19 
    20         """
    21 
    22         greenthread.spawn(self._live_migration, context, instance, dest,
    23                           post_method, recover_method, block_migration,
    24                           migrate_data)

      这个方法中建立一个绿色线程来运行方法_live_migration,来执行实时迁移; 主要是调用libvirt python接口方法virDomainMigrateToURI,来实现从当前主机迁移domain对象到给定的目标主机;

      spawn:建立一个绿色线程来运行方法“func(*args, **kwargs)”,这里就是来运行方法_live_migration;

       _live_migration:执行实时迁移; 主要是调用libvirt python接口方法virDomainMigrateToURI,来实现从当前主机迁移domain对象到给定的目标主机; 

       接着在绿色线程中调用_live_migration方法:

     1 def _live_migration(self, context, instance, dest, post_method,
     2                         recover_method, block_migration=False,
     3                         migrate_data=None):
     4         """Do live migration.
     5 
     6         :param context: security context
     7         :param instance:
     8             nova.db.sqlalchemy.models.Instance object
     9             instance object that is migrated.
    10         :param dest: destination host
    11         :param post_method:
    12             post operation method.
    13             expected nova.compute.manager.post_live_migration.
    14         :param recover_method:
    15             recovery method when any exception occurs.
    16             expected nova.compute.manager.recover_live_migration.
    17         :param block_migration: if true, do block migration.
    18         :param migrate_data: implementation specific params
    19         """
    20 
    21         # Do live migration.
    22         try:
    23             if block_migration:
    24                 flaglist = CONF.libvirt.block_migration_flag.split(',')
    25             else:
    26                 flaglist = CONF.libvirt.live_migration_flag.split(',')
    27             flagvals = [getattr(libvirt, x.strip()) for x in flaglist]
    28             logical_sum = reduce(lambda x, y: x | y, flagvals)
    29 
    30             dom = self._lookup_by_name(instance["name"])
    31             dom.migrateToURI(CONF.libvirt.live_migration_uri % dest,
    32                              logical_sum,
    33                              None,
    34                              CONF.libvirt.live_migration_bandwidth)
    35 
    36         except Exception as e:
    37             with excutils.save_and_reraise_exception():
    38                 LOG.error(_("Live Migration failure: %s"), e,
    39                           instance=instance)
    40                 recover_method(context, instance, dest, block_migration)
    41 
    42         # Waiting for completion of live_migration.
    43         timer = loopingcall.FixedIntervalLoopingCall(f=None)
    1 if block_migration:
    2                 flaglist = CONF.libvirt.block_migration_flag.split(',')

      这个获取块迁移标志列表,block_migration_flag:这个参数定义了为块迁移设置迁移标志。

    1  else:
    2                 flaglist = CONF.libvirt.live_migration_flag.split(',')
    3             flagvals = [getattr(libvirt, x.strip()) for x in flaglist]
    4             logical_sum = reduce(lambda x, y: x | y, flagvals)

      这部分获取实时迁移标志列表,live_migration_flag这个参数定义了实时迁移的迁移标志。

    1 dom = self._lookup_by_name(instance["name"])

      根据给定的实例名称检索libvirt域对象。

    1 timer = loopingcall.FixedIntervalLoopingCall(f=None)

      获取等待完成实时迁移的时间。

      热迁移代码部分至此结束。

    PS:本博客欢迎转发,但请注明博客地址及作者~

      博客地址:http://www.cnblogs.com/voidy/

      <。)#)))≦

    评论
  • 相关阅读:
    微软SmartClient高级开发
    JavaScript教程大全目录( 最后更新:2007/2/27 不断更新中...)
    智能客户端的定义
    JavaScript浏览器输出
    事半功倍系列之javascript
    智能客户端SmartClient (三)
    智能客户端SmartClient (一)
    日文假名输入与键盘对应
    连体词、接续词、接续助词相关
    JavaScript表单
  • 原文地址:https://www.cnblogs.com/voidy/p/4056329.html
Copyright © 2020-2023  润新知