openstack nova 源码分析5-2 -nova/virt/libvirt目录下的connection.py

   由于该文件大于8万字符 所以我分4次挂载(2)

   该文件位于nova/virt/libvirt目录下的connection.py！我只是浅浅的分析了一下类中函数的方法 细节并没有多看，肯定有很多地方是错的 或者不好！希望大家能够帮忙指出错误！

    接下来 看源代码如下：中文部分是我加的注释 ！或许大家会问 为什么要看这个connection.py呢 因为我发现该文件外部virt目录下有个connection.py 其中引用了 这个文件 所以觉得这个应该很重要 而且发现 好多方法都是重写的底层的driver的方法

 

def rescue(self, context, instance, callback, network_info):
       #使用恢复镜像 加载一个vM
       """Loads a VM using rescue images.

       A rescue is normally performed when something goes wrong with the
       primary images and data needs to be corrected/recovered. Rescuing
       should not edit or over-ride the original image, only allow for
       data recovery.

       """

       virt_dom = self._conn.lookupByName(instance['name'])
       unrescue_xml = virt_dom.XMLDesc(0)
       unrescue_xml_path = os.path.join(FLAGS.instances_path,
                                        instance['name'],
                                        'unrescue.xml')
       f = open(unrescue_xml_path, 'w')
       f.write(unrescue_xml)
       f.close()

       xml = self.to_xml(instance, network_info, rescue=True)
       rescue_images = {
           'image_id': FLAGS.rescue_image_id or instance['image_ref'],
           'kernel_id': FLAGS.rescue_kernel_id or instance['kernel_id'],
           'ramdisk_id': FLAGS.rescue_ramdisk_id or instance['ramdisk_id'],
       }
       self._create_image(context, instance, xml, '.rescue', rescue_images,
                          network_info=network_info)
       self.reboot(instance, network_info, xml=xml)

   @exception.wrap_exception()
   def unrescue(self, instance, callback, network_info):
       """Reboot the VM which is being rescued back into primary images.

       Because reboot destroys and re-creates instances, unresue should
       simply call reboot.

       """
       unrescue_xml_path = os.path.join(FLAGS.instances_path,
                                        instance['name'],
                                        'unrescue.xml')
       f = open(unrescue_xml_path)
       unrescue_xml = f.read()
       f.close()
       os.remove(unrescue_xml_path)
       self.reboot(instance, network_info, xml=unrescue_xml)

   @exception.wrap_exception()
   def poll_rescued_instances(self, timeout):
       #轮询已经恢复的实例
       pass

   # NOTE(ilyaalekseyev): Implementation like in multinics
   # for xenapi(tr3buchet)
   @exception.wrap_exception()
   def spawn(self, context, instance, network_info,
             block_device_info=None):
       #感觉像是防火墙的过滤
       xml = self.to_xml(instance, network_info, False,
                         block_device_info=block_device_info)
       self.firewall_driver.setup_basic_filtering(instance, network_info)
       self.firewall_driver.prepare_instance_filter(instance, network_info)
       self._create_image(context, instance, xml, network_info=network_info,
                          block_device_info=block_device_info)

       domain = self._create_new_domain(xml)
       LOG.debug(_("instance %s: is running"), instance['name'])
       self.firewall_driver.apply_instance_filter(instance, network_info)

       def _wait_for_boot():
           """Called at an interval until the VM is running."""
           instance_name = instance['name']

           try:
               state = self.get_info(instance_name)['state']
           except exception.NotFound:
               msg = _("During reboot, %s disappeared.") % instance_name
               LOG.error(msg)
               raise utils.LoopingCallDone

           if state == power_state.RUNNING:
               msg = _("Instance %s spawned successfully.") % instance_name
               LOG.info(msg)
               raise utils.LoopingCallDone

       timer = utils.LoopingCall(_wait_for_boot)
       return timer.start(interval=0.5, now=True)

   def _flush_xen_console(self, virsh_output):
       #清除？？
       LOG.info(_('virsh said: %r'), virsh_output)
       virsh_output = virsh_output[0].strip()

       if virsh_output.startswith('/dev/'):
           LOG.info(_("cool, it's a device"))
           out, err = utils.execute('dd',
                                    "if=%s" % virsh_output,
                                    'iflag=nonblock',
                                    run_as_root=True,
                                    check_exit_code=False)
           return out
       else:
           return ''

   def _append_to_file(self, data, fpath):
       #写入fp中 返回fpath
       LOG.info(_('data: %(data)r, fpath: %(fpath)r') % locals())
       fp = open(fpath, 'a+')
       fp.write(data)
       return fpath

   def _dump_file(self, fpath):
       #返回读出来的contents
       fp = open(fpath, 'r+')
       contents = fp.read()
       LOG.info(_('Contents of file %(fpath)s: %(contents)r') % locals())
       return contents

   @exception.wrap_exception()
   def get_console_output(self, instance):
       #得到控制台的outPut 最后返回的是fpath里面的contents
       console_log = os.path.join(FLAGS.instances_path, instance['name'],
                                  'console.log')

       utils.execute('chown', os.getuid(), console_log, run_as_root=True)

       if FLAGS.libvirt_type == 'xen':
           # Xen is special
           virsh_output = utils.execute('virsh', 'ttyconsole',
                                        instance['name'])
           data = self._flush_xen_console(virsh_output)
           fpath = self._append_to_file(data, console_log)
       elif FLAGS.libvirt_type == 'lxc':
           # LXC is also special
           LOG.info(_("Unable to read LXC console"))
       else:
           fpath = console_log

       return self._dump_file(fpath)

   @exception.wrap_exception()
   def get_ajax_console(self, instance):
       def get_open_port():
           start_port, end_port = FLAGS.ajaxterm_portrange.split("-")
           for i in xrange(0, 100):  # don't loop forever
               port = random.randint(int(start_port), int(end_port))
               # netcat will exit with 0 only if the port is in use,
               # so a nonzero return value implies it is unused
               cmd = 'netcat', '0.0.0.0', port, '-w', '1'
               try:
                   stdout, stderr = utils.execute(*cmd, process_input='')
               except exception.ProcessExecutionError:
                   return port
           raise Exception(_('Unable to find an open port'))

       def get_pty_for_instance(instance_name):
           virt_dom = self._lookup_by_name(instance_name)
           xml = virt_dom.XMLDesc(0)
           dom = minidom.parseString(xml)

           for serial in dom.getElementsByTagName('serial'):
               if serial.getAttribute('type') == 'pty':
                   source = serial.getElementsByTagName('source')[0]
                   return source.getAttribute('path')

       port = get_open_port()
       token = str(uuid.uuid4())
       host = instance['host']

       ajaxterm_cmd = 'sudo socat - %s' \
                      % get_pty_for_instance(instance['name'])

       cmd = ['%s/tools/ajaxterm/ajaxterm.py' % utils.novadir(),
              '--command', ajaxterm_cmd, '-t', token, '-p', port]

       utils.execute(cmd)
       return {'token': token, 'host': host, 'port': port}

   def get_host_ip_addr(self):
       # Retrieves the IP address of the dom0得到主机ip地址
       return FLAGS.my_ip

   @exception.wrap_exception()
   def get_vnc_console(self, instance):
       #取得虚拟网络计算机的控制 最后返回 token，host，port
       def get_vnc_port_for_instance(instance_name):
           virt_dom = self._lookup_by_name(instance_name)
           xml = virt_dom.XMLDesc(0)
           # TODO: use etree instead of minidom
           dom = minidom.parseString(xml)

           for graphic in dom.getElementsByTagName('graphics'):
               if graphic.getAttribute('type') == 'vnc':
                   return graphic.getAttribute('port')

       port = get_vnc_port_for_instance(instance['name'])
       token = str(uuid.uuid4())
       host = instance['host']

       return {'token': token, 'host': host, 'port': port}

   @staticmethod
   def _cache_image(fn, target, fname, cow=False, *args, **kwargs):
       #封装一个方法是他能够创建一个可以缓存镜像的镜像
       """Wrapper for a method that creates an image that caches the image.

       This wrapper will save the image into a common store and create a
       copy for use by the hypervisor.

       The underlying method should specify a kwarg of target representing
       where the image will be saved.

       fname is used as the filename of the base image.  The filename needs
       to be unique to a given image.

       If cow is True, it will make a CoW image instead of a copy.
       """

       if not os.path.exists(target):
           base_dir = os.path.join(FLAGS.instances_path, '_base')
           if not os.path.exists(base_dir):
               os.mkdir(base_dir)
           base = os.path.join(base_dir, fname)

           @utils.synchronized(fname)
           def call_if_not_exists(base, fn, *args, **kwargs):
               if not os.path.exists(base):
                   fn(target=base, *args, **kwargs)

           call_if_not_exists(base, fn, *args, **kwargs)

           if cow:
               utils.execute('qemu-img', 'create', '-f', 'qcow2', '-o',
                             'cluster_size=2M,backing_file=%s' % base,
                             target)
           else:
               utils.execute('cp', base, target)

   def _fetch_image(self, context, target, image_id, user_id, project_id,
                    size=None):
       """Grab image and optionally attempt to resize it"""
       #GRAB 镜像和可选地试图调整他
       images.fetch_to_raw(context, image_id, target, user_id, project_id)
       if size:
           disk.extend(target, size)

   def _create_local(self, target, local_size, unit='G', fs_format=None):
       """Create a blank image of specified size"""
       #创建一个空的指定size的镜像

       if not fs_format:
           fs_format = FLAGS.default_local_format

       utils.execute('truncate', target, '-s', "%d%c" % (local_size, unit))
       if fs_format:
           utils.execute('mkfs', '-t', fs_format, target)

   def _create_ephemeral(self, target, local_size, fs_label, os_type):
       self._create_local(target, local_size)
       disk.mkfs(os_type, fs_label, target)

   def _create_swap(self, target, swap_mb):
       """Create a swap file of specified size"""
       #创建一个指定size的swap file
       self._create_local(target, swap_mb, unit='M')
       utils.execute('mkswap', target)

   def _create_image(self, context, inst, libvirt_xml, suffix='',
                     disk_images=None, network_info=None,
                     block_device_info=None):
       if not suffix:
           suffix = ''

       # syntactic nicety
       def basepath(fname='', suffix=suffix):
           return os.path.join(FLAGS.instances_path,
                               inst['name'],
                               fname + suffix)

       # ensure directories exist and are writable
       utils.execute('mkdir', '-p', basepath(suffix=''))

       LOG.info(_('instance %s: Creating image'), inst['name'])
       f = open(basepath('libvirt.xml'), 'w')
       f.write(libvirt_xml)
       f.close()

       if FLAGS.libvirt_type == 'lxc':
           container_dir = '%s/rootfs' % basepath(suffix='')
           utils.execute('mkdir', '-p', container_dir)

       # NOTE(vish): No need add the suffix to console.log
       console_log = basepath('console.log', '')
       if os.path.exists(console_log):
           utils.execute('chown', os.getuid(), console_log, run_as_root=True)
       os.close(os.open(console_log, os.O_CREAT | os.O_WRONLY, 0660))

       if not disk_images:
           disk_images = {'image_id': inst['image_ref'],
                          'kernel_id': inst['kernel_id'],
                          'ramdisk_id': inst['ramdisk_id']}

       if disk_images['kernel_id']:
           fname = '%08x' % int(disk_images['kernel_id'])
           self._cache_image(fn=self._fetch_image,
                             context=context,
                             target=basepath('kernel'),
                             fname=fname,
                             image_id=disk_images['kernel_id'],
                             user_id=inst['user_id'],
                             project_id=inst['project_id'])
           if disk_images['ramdisk_id']:
               fname = '%08x' % int(disk_images['ramdisk_id'])
               self._cache_image(fn=self._fetch_image,
                                 context=context,
                                 target=basepath('ramdisk'),
                                 fname=fname,
                                 image_id=disk_images['ramdisk_id'],
                                 user_id=inst['user_id'],
                                 project_id=inst['project_id'])

       root_fname = hashlib.sha1(disk_images['image_id']).hexdigest()
       size = FLAGS.minimum_root_size

       inst_type_id = inst['instance_type_id']
       inst_type = instance_types.get_instance_type(inst_type_id)
       if inst_type['name'] == 'm1.tiny' or suffix == '.rescue':
           size = None
           root_fname += "_sm"

       if not self._volume_in_mapping(self.default_root_device,
                                      block_device_info):
           self._cache_image(fn=self._fetch_image,
                             context=context,
                             target=basepath('disk'),
                             fname=root_fname,
                             cow=FLAGS.use_cow_images,
                             image_id=disk_images['image_id'],
                             user_id=inst['user_id'],
                             project_id=inst['project_id'],
                             size=size)

       local_gb = inst['local_gb']
       if local_gb and not self._volume_in_mapping(
           self.default_local_device, block_device_info):
           fn = functools.partial(self._create_ephemeral,
                                  fs_label='ephemeral0',
                                  os_type=inst.os_type)
           self._cache_image(fn=fn,
                             target=basepath('disk.local'),
                             fname="ephemeral_%s_%s_%s" %
                             ("0", local_gb, inst.os_type),
                             cow=FLAGS.use_cow_images,
                             local_size=local_gb)

       for eph in driver.block_device_info_get_ephemerals(block_device_info):
           fn = functools.partial(self._create_ephemeral,
                                  fs_label='ephemeral%d' % eph['num'],
                                  os_type=inst.os_type)
           self._cache_image(fn=fn,
                             target=basepath(_get_eph_disk(eph)),
                             fname="ephemeral_%s_%s_%s" %
                             (eph['num'], eph['size'], inst.os_type),
                             cow=FLAGS.use_cow_images,
                             local_size=eph['size'])

       swap_mb = 0

       swap = driver.block_device_info_get_swap(block_device_info)
       if driver.swap_is_usable(swap):
           swap_mb = swap['swap_size']
       elif (inst_type['swap'] > 0 and
             not self._volume_in_mapping(self.default_swap_device,
                                         block_device_info)):
           swap_mb = inst_type['swap']

       if swap_mb > 0:
           self._cache_image(fn=self._create_swap,
                             target=basepath('disk.swap'),
                             fname="swap_%s" % swap_mb,
                             cow=FLAGS.use_cow_images,
                             swap_mb=swap_mb)

       # For now, we assume that if we're not using a kernel, we're using a
       # partitioned disk image where the target partition is the first
       # partition
       target_partition = None
       if not inst['kernel_id']:
           target_partition = "1"

       config_drive_id = inst.get('config_drive_id')
       config_drive = inst.get('config_drive')

       if any((FLAGS.libvirt_type == 'lxc', config_drive, config_drive_id)):
           target_partition = None

       if config_drive_id:
           fname = '%08x' % int(config_drive_id)
           self._cache_image(fn=self._fetch_image,
                             target=basepath('disk.config'),
                             fname=fname,
                             image_id=config_drive_id,
                             user_id=inst['user_id'],
                             project_id=inst['project_id'],)
       elif config_drive:
           self._create_local(basepath('disk.config'), 64, unit='M',
                              fs_format='msdos')  # 64MB

       if inst['key_data']:
           key = str(inst['key_data'])
       else:
           key = None
       net = None

       nets = []
       ifc_template = open(FLAGS.injected_network_template).read()
       ifc_num = -1
       have_injected_networks = False
       admin_context = nova_context.get_admin_context()
       for (network_ref, mapping) in network_info:
           ifc_num += 1

           if not network_ref['injected']:
               continue

           have_injected_networks = True
           address = mapping['ips'][0]['ip']
           netmask = mapping['ips'][0]['netmask']
           address_v6 = None
           gateway_v6 = None
           netmask_v6 = None
           if FLAGS.use_ipv6:
               address_v6 = mapping['ip6s'][0]['ip']
               netmask_v6 = mapping['ip6s'][0]['netmask']
               gateway_v6 = mapping['gateway6']
           net_info = {'name': 'eth%d' % ifc_num,
                  'address': address,
                  'netmask': netmask,
                  'gateway': mapping['gateway'],
                  'broadcast': mapping['broadcast'],
                  'dns': ' '.join(mapping['dns']),
                  'address_v6': address_v6,
                  'gateway6': gateway_v6,
                  'netmask_v6': netmask_v6}
           nets.append(net_info)

       if have_injected_networks:
           net = str(Template(ifc_template,
                              searchList=[{'interfaces': nets,
                                           'use_ipv6': FLAGS.use_ipv6}]))

       metadata = inst.get('metadata')
       if any((key, net, metadata)):
           inst_name = inst['name']

           if config_drive:  # Should be True or None by now.
               injection_path = basepath('disk.config')
               img_id = 'config-drive'
               tune2fs = False
           else:
               injection_path = basepath('disk')
               img_id = inst.image_ref
               tune2fs = True

           for injection in ('metadata', 'key', 'net'):
               if locals()[injection]:
                   LOG.info(_('instance %(inst_name)s: injecting '
                              '%(injection)s into image %(img_id)s'
                              % locals()))
           try:
               disk.inject_data(injection_path, key, net, metadata,
                                partition=target_partition,
                                nbd=FLAGS.use_cow_images,
                                tune2fs=tune2fs)

           except Exception as e:
               # This could be a windows image, or a vmdk format disk
               LOG.warn(_('instance %(inst_name)s: ignoring error injecting'
                       ' data into image %(img_id)s (%(e)s)') % locals())

       if FLAGS.libvirt_type == 'lxc':
           disk.setup_container(basepath('disk'),
                               container_dir=container_dir,
                               nbd=FLAGS.use_cow_images)

       if FLAGS.libvirt_type == 'uml':
           utils.execute('chown', 'root', basepath('disk'), run_as_root=True)