Synnefo » snf-ganeti » ganeti-local

#

#

# Copyright (C) 2008, 2009, 2010, 2011 Google Inc.

#

# This program is free software; you can redistribute it and/or modify

# it under the terms of the GNU General Public License as published by

# the Free Software Foundation; either version 2 of the License, or

# (at your option) any later version.

#

# This program is distributed in the hope that it will be useful, but

# WITHOUT ANY WARRANTY; without even the implied warranty of

# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU

# General Public License for more details.

#

# You should have received a copy of the GNU General Public License

# along with this program; if not, write to the Free Software

# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA

# 02110-1301, USA.

"""KVM hypervisor

"""

import errno

import os

import os.path

import re

import tempfile

import time

import logging

import pwd

import struct

import fcntl

import shutil

import socket

import StringIO

from ganeti import utils

from ganeti import constants

from ganeti import errors

from ganeti import serializer

from ganeti import objects

from ganeti import uidpool

from ganeti import ssconf

from ganeti.hypervisor import hv_base

from ganeti import netutils

from ganeti.utils import wrapper as utils_wrapper

_KVM_NETWORK_SCRIPT = constants.SYSCONFDIR + "/ganeti/kvm-vif-bridge"

# TUN/TAP driver constants, taken from <linux/if_tun.h>

# They are architecture-independent and already hardcoded in qemu-kvm source,

# so we can safely include them here.

TUNSETIFF = 0x400454ca

TUNGETIFF = 0x800454d2

TUNGETFEATURES = 0x800454cf

IFF_TAP = 0x0002

IFF_NO_PI = 0x1000

IFF_VNET_HDR = 0x4000

def _ProbeTapVnetHdr(fd):

  """Check whether to enable the IFF_VNET_HDR flag.

  To do this, _all_ of the following conditions must be met:

   1. TUNGETFEATURES ioctl() *must* be implemented

   2. TUNGETFEATURES ioctl() result *must* contain the IFF_VNET_HDR flag

   3. TUNGETIFF ioctl() *must* be implemented; reading the kernel code in

      drivers/net/tun.c there is no way to test this until after the tap device

      has been created using TUNSETIFF, and there is no way to change the

      IFF_VNET_HDR flag after creating the interface, catch-22! However both

      TUNGETIFF and TUNGETFEATURES were introduced in kernel version 2.6.27,

      thus we can expect TUNGETIFF to be present if TUNGETFEATURES is.

   @type fd: int

   @param fd: the file descriptor of /dev/net/tun

  """

  req = struct.pack("I", 0)

  try:

    res = fcntl.ioctl(fd, TUNGETFEATURES, req)

  except EnvironmentError:

    logging.warning("TUNGETFEATURES ioctl() not implemented")

    return False

  tunflags = struct.unpack("I", res)[0]

  if tunflags & IFF_VNET_HDR:

    return True

  else:

    logging.warning("Host does not support IFF_VNET_HDR, not enabling")

    return False

def _OpenTap(vnet_hdr=True):

  """Open a new tap device and return its file descriptor.

  This is intended to be used by a qemu-type hypervisor together with the -net

  tap,fd=<fd> command line parameter.

  @type vnet_hdr: boolean

  @param vnet_hdr: Enable the VNET Header

  @return: (ifname, tapfd)

  @rtype: tuple

  """

  try:

    tapfd = os.open("/dev/net/tun", os.O_RDWR)

  except EnvironmentError:

    raise errors.HypervisorError("Failed to open /dev/net/tun")

  flags = IFF_TAP | IFF_NO_PI

  if vnet_hdr and _ProbeTapVnetHdr(tapfd):

    flags |= IFF_VNET_HDR

  # The struct ifreq ioctl request (see netdevice(7))

  ifr = struct.pack("16sh", "", flags)

  try:

    res = fcntl.ioctl(tapfd, TUNSETIFF, ifr)

  except EnvironmentError:

    raise errors.HypervisorError("Failed to allocate a new TAP device")

  # Get the interface name from the ioctl

  ifname = struct.unpack("16sh", res)[0].strip("\x00")

  return (ifname, tapfd)

class QmpMessage:

  """QEMU Messaging Protocol (QMP) message.

  """

  def __init__(self, data):

    """Creates a new QMP message based on the passed data.

    """

    if not isinstance(data, dict):

      raise TypeError("QmpMessage must be initialized with a dict")

    self.data = data

  def __getitem__(self, field_name):

    """Get the value of the required field if present, or None.

    Overrides the [] operator to provide access to the message data,

    returning None if the required item is not in the message

    @return: the value of the field_name field, or None if field_name

             is not contained in the message

    """

    if field_name in self.data:

      return self.data[field_name]

    return None

  def __setitem__(self, field_name, field_value):

    """Set the value of the required field_name to field_value.

    """

    self.data[field_name] = field_value

  @staticmethod

  def BuildFromJsonString(json_string):

    """Build a QmpMessage from a JSON encoded string.

    @type json_string: str

    @param json_string: JSON string representing the message

    @rtype: L{QmpMessage}

    @return: a L{QmpMessage} built from json_string

    """

    # Parse the string

    data = serializer.LoadJson(json_string)

    return QmpMessage(data)

  def __str__(self):

    # The protocol expects the JSON object to be sent as a single

    # line, hence the need for indent=False.

    return serializer.DumpJson(self.data, indent=False)

  def __eq__(self, other):

    # When comparing two QmpMessages, we are interested in comparing

    # their internal representation of the message data

    return self.data == other.data

class QmpConnection:

  """Connection to the QEMU Monitor using the QEMU Monitor Protocol (QMP).

  """

  _FIRST_MESSAGE_KEY = "QMP"

  _EVENT_KEY = "event"

  _ERROR_KEY = "error"

  _ERROR_CLASS_KEY = "class"

  _ERROR_DATA_KEY = "data"

  _ERROR_DESC_KEY = "desc"

  _EXECUTE_KEY = "execute"

  _ARGUMENTS_KEY = "arguments"

  _CAPABILITIES_COMMAND = "qmp_capabilities"

  _MESSAGE_END_TOKEN = "\r\n"

  _SOCKET_TIMEOUT = 5

  def __init__(self, monitor_filename):

    """Instantiates the QmpConnection object.

    @type monitor_filename: string

    @param monitor_filename: the filename of the UNIX raw socket on which the

                             QMP monitor is listening

    """

    self.monitor_filename = monitor_filename

    self.sock = socket.socket(socket.AF_UNIX, socket.SOCK_STREAM)

    # We want to fail if the server doesn't send a complete message

    # in a reasonable amount of time

    self.sock.settimeout(self._SOCKET_TIMEOUT)

    self._connected = False

    self._buf = ""

  def _check_connection(self):

    """Make sure that the connection is established.

    """

    if not self._connected:

      raise errors.ProgrammerError("To use a QmpConnection you need to first"

                                   " invoke connect() on it")

  def connect(self):

    """Connects to the QMP monitor.

    Connects to the UNIX socket and makes sure that we can actually send and

    receive data to the kvm instance via QMP.

    @raise errors.HypervisorError: when there are communication errors

    @raise errors.ProgrammerError: when there are data serialization errors

    """

    self.sock.connect(self.monitor_filename)

    self._connected = True

    # Check if we receive a correct greeting message from the server

    # (As per the QEMU Protocol Specification 0.1 - section 2.2)

    greeting = self._Recv()

    if not greeting[self._FIRST_MESSAGE_KEY]:

      self._connected = False

      raise errors.HypervisorError("kvm: qmp communication error (wrong"

                                   " server greeting")

    # Let's put the monitor in command mode using the qmp_capabilities

    # command, or else no command will be executable.

    # (As per the QEMU Protocol Specification 0.1 - section 4)

    self.Execute(self._CAPABILITIES_COMMAND)

  def _ParseMessage(self, buf):

    """Extract and parse a QMP message from the given buffer.

    Seeks for a QMP message in the given buf. If found, it parses it and

    returns it together with the rest of the characters in the buf.

    If no message is found, returns None and the whole buffer.

    @raise errors.ProgrammerError: when there are data serialization errors

    """

    message = None

    # Check if we got the message end token (CRLF, as per the QEMU Protocol

    # Specification 0.1 - Section 2.1.1)

    pos = buf.find(self._MESSAGE_END_TOKEN)

    if pos >= 0:

      try:

        message = QmpMessage.BuildFromJsonString(buf[:pos + 1])

      except Exception, err:

        raise errors.ProgrammerError("QMP data serialization error: %s" % err)

      buf = buf[pos + 1:]

    return (message, buf)

  def _Recv(self):

    """Receives a message from QMP and decodes the received JSON object.

    @rtype: QmpMessage

    @return: the received message

    @raise errors.HypervisorError: when there are communication errors

    @raise errors.ProgrammerError: when there are data serialization errors

    """

    self._check_connection()

    # Check if there is already a message in the buffer

    (message, self._buf) = self._ParseMessage(self._buf)

    if message:

      return message

    recv_buffer = StringIO.StringIO(self._buf)

    recv_buffer.seek(len(self._buf))

    try:

      while True:

        data = self.sock.recv(4096)

        if not data:

          break

        recv_buffer.write(data)

        (message, self._buf) = self._ParseMessage(recv_buffer.getvalue())

        if message:

          return message

    except socket.timeout, err:

      raise errors.HypervisorError("Timeout while receiving a QMP message: "

                                   "%s" % (err))

    except socket.error, err:

      raise errors.HypervisorError("Unable to receive data from KVM using the"

                                   " QMP protocol: %s" % err)

  def _Send(self, message):

    """Encodes and sends a message to KVM using QMP.

    @type message: QmpMessage

    @param message: message to send to KVM

    @raise errors.HypervisorError: when there are communication errors

    @raise errors.ProgrammerError: when there are data serialization errors

    """

    self._check_connection()

    try:

      message_str = str(message)

    except Exception, err:

      raise errors.ProgrammerError("QMP data deserialization error: %s" % err)

    try:

      self.sock.sendall(message_str)

    except socket.timeout, err:

      raise errors.HypervisorError("Timeout while sending a QMP message: "

                                   "%s (%s)" % (err.string, err.errno))

    except socket.error, err:

      raise errors.HypervisorError("Unable to send data from KVM using the"

                                   " QMP protocol: %s" % err)

  def Execute(self, command, arguments=None):

    """Executes a QMP command and returns the response of the server.

    @type command: str

    @param command: the command to execute

    @type arguments: dict

    @param arguments: dictionary of arguments to be passed to the command

    @rtype: dict

    @return: dictionary representing the received JSON object

    @raise errors.HypervisorError: when there are communication errors

    @raise errors.ProgrammerError: when there are data serialization errors

    """

    self._check_connection()

    message = QmpMessage({self._EXECUTE_KEY: command})

    if arguments:

      message[self._ARGUMENTS_KEY] = arguments

    self._Send(message)

    # Events can occur between the sending of the command and the reception

    # of the response, so we need to filter out messages with the event key.

    while True:

      response = self._Recv()

      err = response[self._ERROR_KEY]

      if err:

        raise errors.HypervisorError("kvm: error executing the %s"

                                     " command: %s (%s, %s):" %

                                     (command,

                                      err[self._ERROR_DESC_KEY],

                                      err[self._ERROR_CLASS_KEY],

                                      err[self._ERROR_DATA_KEY]))

      elif not response[self._EVENT_KEY]:

        return response

class KVMHypervisor(hv_base.BaseHypervisor):

  """KVM hypervisor interface"""

  CAN_MIGRATE = True

  _ROOT_DIR = constants.RUN_GANETI_DIR + "/kvm-hypervisor"

  _PIDS_DIR = _ROOT_DIR + "/pid" # contains live instances pids

  _UIDS_DIR = _ROOT_DIR + "/uid" # contains instances reserved uids

  _CTRL_DIR = _ROOT_DIR + "/ctrl" # contains instances control sockets

  _CONF_DIR = _ROOT_DIR + "/conf" # contains instances startup data

  _NICS_DIR = _ROOT_DIR + "/nic" # contains instances nic <-> tap associations

  _KEYMAP_DIR = _ROOT_DIR + "/keymap" # contains instances keymaps

  # KVM instances with chroot enabled are started in empty chroot directories.

  _CHROOT_DIR = _ROOT_DIR + "/chroot" # for empty chroot directories

  # After an instance is stopped, its chroot directory is removed.

  # If the chroot directory is not empty, it can't be removed.

  # A non-empty chroot directory indicates a possible security incident.

  # To support forensics, the non-empty chroot directory is quarantined in

  # a separate directory, called 'chroot-quarantine'.

  _CHROOT_QUARANTINE_DIR = _ROOT_DIR + "/chroot-quarantine"

  _DIRS = [_ROOT_DIR, _PIDS_DIR, _UIDS_DIR, _CTRL_DIR, _CONF_DIR, _NICS_DIR,

           _CHROOT_DIR, _CHROOT_QUARANTINE_DIR]

  PARAMETERS = {

    constants.HV_KERNEL_PATH: hv_base.OPT_FILE_CHECK,

    constants.HV_INITRD_PATH: hv_base.OPT_FILE_CHECK,

    constants.HV_ROOT_PATH: hv_base.NO_CHECK,

    constants.HV_KERNEL_ARGS: hv_base.NO_CHECK,

    constants.HV_ACPI: hv_base.NO_CHECK,

    constants.HV_SERIAL_CONSOLE: hv_base.NO_CHECK,

    constants.HV_VNC_BIND_ADDRESS:

      (False, lambda x: (netutils.IP4Address.IsValid(x) or

                         utils.IsNormAbsPath(x)),

       "the VNC bind address must be either a valid IP address or an absolute"

       " pathname", None, None),

    constants.HV_VNC_TLS: hv_base.NO_CHECK,

    constants.HV_VNC_X509: hv_base.OPT_DIR_CHECK,

    constants.HV_VNC_X509_VERIFY: hv_base.NO_CHECK,

    constants.HV_VNC_PASSWORD_FILE: hv_base.OPT_FILE_CHECK,

    constants.HV_KVM_SPICE_BIND: hv_base.NO_CHECK, # will be checked later

    constants.HV_KVM_SPICE_IP_VERSION:

      (False, lambda x: (x == constants.IFACE_NO_IP_VERSION_SPECIFIED or

                         x in constants.VALID_IP_VERSIONS),

       "the SPICE IP version should be 4 or 6",

       None, None),

    constants.HV_KVM_SPICE_PASSWORD_FILE: hv_base.OPT_FILE_CHECK,

    constants.HV_KVM_SPICE_LOSSLESS_IMG_COMPR:

      hv_base.ParamInSet(False,

        constants.HT_KVM_SPICE_VALID_LOSSLESS_IMG_COMPR_OPTIONS),

    constants.HV_KVM_SPICE_JPEG_IMG_COMPR:

      hv_base.ParamInSet(False,

        constants.HT_KVM_SPICE_VALID_LOSSY_IMG_COMPR_OPTIONS),

    constants.HV_KVM_SPICE_ZLIB_GLZ_IMG_COMPR:

      hv_base.ParamInSet(False,

        constants.HT_KVM_SPICE_VALID_LOSSY_IMG_COMPR_OPTIONS),

    constants.HV_KVM_SPICE_STREAMING_VIDEO_DETECTION:

      hv_base.ParamInSet(False,

        constants.HT_KVM_SPICE_VALID_VIDEO_STREAM_DETECTION_OPTIONS),

    constants.HV_KVM_SPICE_AUDIO_COMPR: hv_base.NO_CHECK,

    constants.HV_KVM_FLOPPY_IMAGE_PATH: hv_base.OPT_FILE_CHECK,

    constants.HV_CDROM_IMAGE_PATH: hv_base.OPT_FILE_CHECK,

    constants.HV_KVM_CDROM2_IMAGE_PATH: hv_base.OPT_FILE_CHECK,

    constants.HV_BOOT_ORDER:

      hv_base.ParamInSet(True, constants.HT_KVM_VALID_BO_TYPES),

    constants.HV_NIC_TYPE:

      hv_base.ParamInSet(True, constants.HT_KVM_VALID_NIC_TYPES),

    constants.HV_DISK_TYPE:

      hv_base.ParamInSet(True, constants.HT_KVM_VALID_DISK_TYPES),

    constants.HV_KVM_CDROM_DISK_TYPE:

      hv_base.ParamInSet(False, constants.HT_KVM_VALID_DISK_TYPES),

    constants.HV_USB_MOUSE:

      hv_base.ParamInSet(False, constants.HT_KVM_VALID_MOUSE_TYPES),

    constants.HV_KEYMAP: hv_base.NO_CHECK,

    constants.HV_MIGRATION_PORT: hv_base.REQ_NET_PORT_CHECK,

    constants.HV_MIGRATION_BANDWIDTH: hv_base.NO_CHECK,

    constants.HV_MIGRATION_DOWNTIME: hv_base.NO_CHECK,

    constants.HV_MIGRATION_MODE: hv_base.MIGRATION_MODE_CHECK,

    constants.HV_USE_LOCALTIME: hv_base.NO_CHECK,

    constants.HV_DISK_CACHE:

      hv_base.ParamInSet(True, constants.HT_VALID_CACHE_TYPES),

    constants.HV_SECURITY_MODEL:

      hv_base.ParamInSet(True, constants.HT_KVM_VALID_SM_TYPES),

    constants.HV_SECURITY_DOMAIN: hv_base.NO_CHECK,

    constants.HV_KVM_FLAG:

      hv_base.ParamInSet(False, constants.HT_KVM_FLAG_VALUES),

    constants.HV_VHOST_NET: hv_base.NO_CHECK,

    constants.HV_KVM_USE_CHROOT: hv_base.NO_CHECK,

    constants.HV_MEM_PATH: hv_base.OPT_DIR_CHECK,

    constants.HV_REBOOT_BEHAVIOR:

      hv_base.ParamInSet(True, constants.REBOOT_BEHAVIORS)

    }

  _MIGRATION_STATUS_RE = re.compile("Migration\s+status:\s+(\w+)",

                                    re.M | re.I)

  _MIGRATION_INFO_MAX_BAD_ANSWERS = 5

  _MIGRATION_INFO_RETRY_DELAY = 2

  _VERSION_RE = re.compile(r"\b(\d+)\.(\d+)\.(\d+)\b")

  ANCILLARY_FILES = [

    _KVM_NETWORK_SCRIPT,

    ]

  ANCILLARY_FILES_OPT = [

    _KVM_NETWORK_SCRIPT,

    ]

  def __init__(self):

    hv_base.BaseHypervisor.__init__(self)

    # Let's make sure the directories we need exist, even if the RUN_DIR lives

    # in a tmpfs filesystem or has been otherwise wiped out.

    dirs = [(dname, constants.RUN_DIRS_MODE) for dname in self._DIRS]

    utils.EnsureDirs(dirs)

  @classmethod

  def _InstancePidFile(cls, instance_name):

    """Returns the instance pidfile.

    """

    return utils.PathJoin(cls._PIDS_DIR, instance_name)

  @classmethod

  def _InstanceUidFile(cls, instance_name):

    """Returns the instance uidfile.

    """

    return utils.PathJoin(cls._UIDS_DIR, instance_name)

  @classmethod

  def _InstancePidInfo(cls, pid):

    """Check pid file for instance information.

    Check that a pid file is associated with an instance, and retrieve

    information from its command line.

    @type pid: string or int

    @param pid: process id of the instance to check

    @rtype: tuple

    @return: (instance_name, memory, vcpus)

    @raise errors.HypervisorError: when an instance cannot be found

    """

    alive = utils.IsProcessAlive(pid)

    if not alive:

      raise errors.HypervisorError("Cannot get info for pid %s" % pid)

    cmdline_file = utils.PathJoin("/proc", str(pid), "cmdline")

    try:

      cmdline = utils.ReadFile(cmdline_file)

    except EnvironmentError, err:

      raise errors.HypervisorError("Can't open cmdline file for pid %s: %s" %

                                   (pid, err))

    instance = None

    memory = 0

    vcpus = 0

    arg_list = cmdline.split("\x00")

    while arg_list:

      arg = arg_list.pop(0)

      if arg == "-name":

        instance = arg_list.pop(0)

      elif arg == "-m":

        memory = int(arg_list.pop(0))

      elif arg == "-smp":

        vcpus = int(arg_list.pop(0))

    if instance is None:

      raise errors.HypervisorError("Pid %s doesn't contain a ganeti kvm"

                                   " instance" % pid)

    return (instance, memory, vcpus)

  def _InstancePidAlive(self, instance_name):

    """Returns the instance pidfile, pid, and liveness.

    @type instance_name: string

    @param instance_name: instance name

    @rtype: tuple

    @return: (pid file name, pid, liveness)

    """

    pidfile = self._InstancePidFile(instance_name)

    pid = utils.ReadPidFile(pidfile)

    alive = False

    try:

      cmd_instance = self._InstancePidInfo(pid)[0]

      alive = (cmd_instance == instance_name)

    except errors.HypervisorError:

      pass

    return (pidfile, pid, alive)

  def _CheckDown(self, instance_name):

    """Raises an error unless the given instance is down.

    """

    alive = self._InstancePidAlive(instance_name)[2]

    if alive:

      raise errors.HypervisorError("Failed to start instance %s: %s" %

                                   (instance_name, "already running"))

  @classmethod

  def _InstanceMonitor(cls, instance_name):

    """Returns the instance monitor socket name

    """

    return utils.PathJoin(cls._CTRL_DIR, "%s.monitor" % instance_name)

  @classmethod

  def _InstanceSerial(cls, instance_name):

    """Returns the instance serial socket name

    """

    return utils.PathJoin(cls._CTRL_DIR, "%s.serial" % instance_name)

  @classmethod

  def _InstanceQmpMonitor(cls, instance_name):

    """Returns the instance serial QMP socket name

    """

    return utils.PathJoin(cls._CTRL_DIR, "%s.qmp" % instance_name)

  @staticmethod

  def _SocatUnixConsoleParams():

    """Returns the correct parameters for socat

    If we have a new-enough socat we can use raw mode with an escape character.

    """

    if constants.SOCAT_USE_ESCAPE:

      return "raw,echo=0,escape=%s" % constants.SOCAT_ESCAPE_CODE

    else:

      return "echo=0,icanon=0"

  @classmethod

  def _InstanceKVMRuntime(cls, instance_name):

    """Returns the instance KVM runtime filename

    """

    return utils.PathJoin(cls._CONF_DIR, "%s.runtime" % instance_name)

  @classmethod

  def _InstanceChrootDir(cls, instance_name):

    """Returns the name of the KVM chroot dir of the instance

    """

    return utils.PathJoin(cls._CHROOT_DIR, instance_name)

  @classmethod

  def _InstanceNICDir(cls, instance_name):

    """Returns the name of the directory holding the tap device files for a

    given instance.

    """

    return utils.PathJoin(cls._NICS_DIR, instance_name)

  @classmethod

  def _InstanceNICFile(cls, instance_name, seq):

    """Returns the name of the file containing the tap device for a given NIC

    """

    return utils.PathJoin(cls._InstanceNICDir(instance_name), str(seq))

  @classmethod

  def _InstanceKeymapFile(cls, instance_name):

    """Returns the name of the file containing the keymap for a given instance

    """

    return utils.PathJoin(cls._KEYMAP_DIR, instance_name)

  @classmethod

  def _TryReadUidFile(cls, uid_file):

    """Try to read a uid file

    """

    if os.path.exists(uid_file):

      try:

        uid = int(utils.ReadOneLineFile(uid_file))

        return uid

      except EnvironmentError:

        logging.warning("Can't read uid file", exc_info=True)

      except (TypeError, ValueError):

        logging.warning("Can't parse uid file contents", exc_info=True)

    return None

  @classmethod

  def _RemoveInstanceRuntimeFiles(cls, pidfile, instance_name):

    """Removes an instance's rutime sockets/files/dirs.

    """

    utils.RemoveFile(pidfile)

    utils.RemoveFile(cls._InstanceMonitor(instance_name))

    utils.RemoveFile(cls._InstanceSerial(instance_name))

    utils.RemoveFile(cls._InstanceQmpMonitor(instance_name))

    utils.RemoveFile(cls._InstanceKVMRuntime(instance_name))

    utils.RemoveFile(cls._InstanceKeymapFile(instance_name))

    uid_file = cls._InstanceUidFile(instance_name)

    uid = cls._TryReadUidFile(uid_file)

    utils.RemoveFile(uid_file)

    if uid is not None:

      uidpool.ReleaseUid(uid)

    try:

      shutil.rmtree(cls._InstanceNICDir(instance_name))

    except OSError, err:

      if err.errno != errno.ENOENT:

        raise

    try:

      chroot_dir = cls._InstanceChrootDir(instance_name)

      utils.RemoveDir(chroot_dir)

    except OSError, err:

      if err.errno == errno.ENOTEMPTY:

        # The chroot directory is expected to be empty, but it isn't.

        new_chroot_dir = tempfile.mkdtemp(dir=cls._CHROOT_QUARANTINE_DIR,

                                          prefix="%s-%s-" %

                                          (instance_name,

                                           utils.TimestampForFilename()))

        logging.warning("The chroot directory of instance %s can not be"

                        " removed as it is not empty. Moving it to the"

                        " quarantine instead. Please investigate the"

                        " contents (%s) and clean up manually",

                        instance_name, new_chroot_dir)

        utils.RenameFile(chroot_dir, new_chroot_dir)

      else:

        raise

  @staticmethod

  def _ConfigureNIC(instance, seq, nic, tap):

    """Run the network configuration script for a specified NIC

    @param instance: instance we're acting on

    @type instance: instance object

    @param seq: nic sequence number

    @type seq: int

    @param nic: nic we're acting on

    @type nic: nic object

    @param tap: the host's tap interface this NIC corresponds to

    @type tap: str

    """

    if instance.tags:

      tags = " ".join(instance.tags)

    else:

      tags = ""

    env = {

      "PATH": "%s:/sbin:/usr/sbin" % os.environ["PATH"],

      "INSTANCE": instance.name,

      "MAC": nic.mac,

      "MODE": nic.nicparams[constants.NIC_MODE],

      "INTERFACE": tap,

      "INTERFACE_INDEX": str(seq),

      "TAGS": tags,

    }

    if nic.ip:

      env["IP"] = nic.ip

    if nic.nicparams[constants.NIC_LINK]:

      env["LINK"] = nic.nicparams[constants.NIC_LINK]

    if nic.nicparams[constants.NIC_MODE] == constants.NIC_MODE_BRIDGED:

      env["BRIDGE"] = nic.nicparams[constants.NIC_LINK]

    result = utils.RunCmd([constants.KVM_IFUP, tap], env=env)

    if result.failed:

      raise errors.HypervisorError("Failed to configure interface %s: %s."

                                   " Network configuration script output: %s" %

                                   (tap, result.fail_reason, result.output))

  def ListInstances(self):

    """Get the list of running instances.

    We can do this by listing our live instances directory and

    checking whether the associated kvm process is still alive.

    """

    result = []

    for name in os.listdir(self._PIDS_DIR):

      if self._InstancePidAlive(name)[2]:

        result.append(name)

    return result

  def GetInstanceInfo(self, instance_name):

    """Get instance properties.

    @type instance_name: string

    @param instance_name: the instance name