Synnefo » snf-ganeti

#

#

# Copyright (C) 2006, 2007, 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.

"""Functions used by the node daemon

@var _ALLOWED_UPLOAD_FILES: denotes which files are accepted in

     the L{UploadFile} function

@var _ALLOWED_CLEAN_DIRS: denotes which directories are accepted

     in the L{_CleanDirectory} function

"""

# pylint: disable=E1103

# E1103: %s %r has no %r member (but some types could not be

# inferred), because the _TryOSFromDisk returns either (True, os_obj)

# or (False, "string") which confuses pylint

import os

import os.path

import shutil

import time

import stat

import errno

import re

import random

import logging

import tempfile

import zlib

import base64

import signal

from ganeti import errors

from ganeti import utils

from ganeti import ssh

from ganeti import hypervisor

from ganeti import constants

from ganeti import bdev

from ganeti import objects

from ganeti import ssconf

from ganeti import serializer

from ganeti import netutils

from ganeti import runtime

_BOOT_ID_PATH = "/proc/sys/kernel/random/boot_id"

_ALLOWED_CLEAN_DIRS = frozenset([

  constants.DATA_DIR,

  constants.JOB_QUEUE_ARCHIVE_DIR,

  constants.QUEUE_DIR,

  constants.CRYPTO_KEYS_DIR,

  ])

_MAX_SSL_CERT_VALIDITY = 7 * 24 * 60 * 60

_X509_KEY_FILE = "key"

_X509_CERT_FILE = "cert"

_IES_STATUS_FILE = "status"

_IES_PID_FILE = "pid"

_IES_CA_FILE = "ca"

#: Valid LVS output line regex

_LVSLINE_REGEX = re.compile("^ *([^|]+)\|([^|]+)\|([0-9.]+)\|([^|]{6})\|?$")

class RPCFail(Exception):

  """Class denoting RPC failure.

  Its argument is the error message.

  """

def _Fail(msg, *args, **kwargs):

  """Log an error and the raise an RPCFail exception.

  This exception is then handled specially in the ganeti daemon and

  turned into a 'failed' return type. As such, this function is a

  useful shortcut for logging the error and returning it to the master

  daemon.

  @type msg: string

  @param msg: the text of the exception

  @raise RPCFail

  """

  if args:

    msg = msg % args

  if "log" not in kwargs or kwargs["log"]: # if we should log this error

    if "exc" in kwargs and kwargs["exc"]:

      logging.exception(msg)

    else:

      logging.error(msg)

  raise RPCFail(msg)

def _GetConfig():

  """Simple wrapper to return a SimpleStore.

  @rtype: L{ssconf.SimpleStore}

  @return: a SimpleStore instance

  """

  return ssconf.SimpleStore()

def _GetSshRunner(cluster_name):

  """Simple wrapper to return an SshRunner.

  @type cluster_name: str

  @param cluster_name: the cluster name, which is needed

      by the SshRunner constructor

  @rtype: L{ssh.SshRunner}

  @return: an SshRunner instance

  """

  return ssh.SshRunner(cluster_name)

def _Decompress(data):

  """Unpacks data compressed by the RPC client.

  @type data: list or tuple

  @param data: Data sent by RPC client

  @rtype: str

  @return: Decompressed data

  """

  assert isinstance(data, (list, tuple))

  assert len(data) == 2

  (encoding, content) = data

  if encoding == constants.RPC_ENCODING_NONE:

    return content

  elif encoding == constants.RPC_ENCODING_ZLIB_BASE64:

    return zlib.decompress(base64.b64decode(content))

  else:

    raise AssertionError("Unknown data encoding")

def _CleanDirectory(path, exclude=None):

  """Removes all regular files in a directory.

  @type path: str

  @param path: the directory to clean

  @type exclude: list

  @param exclude: list of files to be excluded, defaults

      to the empty list

  """

  if path not in _ALLOWED_CLEAN_DIRS:

    _Fail("Path passed to _CleanDirectory not in allowed clean targets: '%s'",

          path)

  if not os.path.isdir(path):

    return

  if exclude is None:

    exclude = []

  else:

    # Normalize excluded paths

    exclude = [os.path.normpath(i) for i in exclude]

  for rel_name in utils.ListVisibleFiles(path):

    full_name = utils.PathJoin(path, rel_name)

    if full_name in exclude:

      continue

    if os.path.isfile(full_name) and not os.path.islink(full_name):

      utils.RemoveFile(full_name)

def _BuildUploadFileList():

  """Build the list of allowed upload files.

  This is abstracted so that it's built only once at module import time.

  """

  allowed_files = set([

    constants.CLUSTER_CONF_FILE,

    constants.ETC_HOSTS,

    constants.SSH_KNOWN_HOSTS_FILE,

    constants.VNC_PASSWORD_FILE,

    constants.RAPI_CERT_FILE,

    constants.RAPI_USERS_FILE,

    constants.CONFD_HMAC_KEY,

    constants.CLUSTER_DOMAIN_SECRET_FILE,

    ])

  for hv_name in constants.HYPER_TYPES:

    hv_class = hypervisor.GetHypervisorClass(hv_name)

    allowed_files.update(hv_class.GetAncillaryFiles()[0])

  return frozenset(allowed_files)

_ALLOWED_UPLOAD_FILES = _BuildUploadFileList()

def JobQueuePurge():

  """Removes job queue files and archived jobs.

  @rtype: tuple

  @return: True, None

  """

  _CleanDirectory(constants.QUEUE_DIR, exclude=[constants.JOB_QUEUE_LOCK_FILE])

  _CleanDirectory(constants.JOB_QUEUE_ARCHIVE_DIR)

def GetMasterInfo():

  """Returns master information.

  This is an utility function to compute master information, either

  for consumption here or from the node daemon.

  @rtype: tuple

  @return: master_netdev, master_ip, master_name, primary_ip_family

  @raise RPCFail: in case of errors

  """

  try:

    cfg = _GetConfig()

    master_netdev = cfg.GetMasterNetdev()

    master_ip = cfg.GetMasterIP()

    master_node = cfg.GetMasterNode()

    primary_ip_family = cfg.GetPrimaryIPFamily()

  except errors.ConfigurationError, err:

    _Fail("Cluster configuration incomplete: %s", err, exc=True)

  return (master_netdev, master_ip, master_node, primary_ip_family)

def ActivateMasterIp():

  """Activate the IP address of the master daemon.

  """

  # GetMasterInfo will raise an exception if not able to return data

  master_netdev, master_ip, _, family = GetMasterInfo()

  err_msg = None

  if netutils.TcpPing(master_ip, constants.DEFAULT_NODED_PORT):

    if netutils.IPAddress.Own(master_ip):

      # we already have the ip:

      logging.debug("Master IP already configured, doing nothing")

    else:

      err_msg = "Someone else has the master ip, not activating"

      logging.error(err_msg)

  else:

    ipcls = netutils.IP4Address

    if family == netutils.IP6Address.family:

      ipcls = netutils.IP6Address

    result = utils.RunCmd([constants.IP_COMMAND_PATH, "address", "add",

                           "%s/%d" % (master_ip, ipcls.iplen),

                           "dev", master_netdev, "label",

                           "%s:0" % master_netdev])

    if result.failed:

      err_msg = "Can't activate master IP: %s" % result.output

      logging.error(err_msg)

    # we ignore the exit code of the following cmds

    if ipcls == netutils.IP4Address:

      utils.RunCmd(["arping", "-q", "-U", "-c 3", "-I", master_netdev, "-s",

                    master_ip, master_ip])

    elif ipcls == netutils.IP6Address:

      try:

        utils.RunCmd(["ndisc6", "-q", "-r 3", master_ip, master_netdev])

      except errors.OpExecError:

        # TODO: Better error reporting

        logging.warning("Can't execute ndisc6, please install if missing")

  if err_msg:

    _Fail(err_msg)

def StartMasterDaemons(no_voting):

  """Activate local node as master node.

  The function will start the master daemons (ganeti-masterd and ganeti-rapi).

  @type no_voting: boolean

  @param no_voting: whether to start ganeti-masterd without a node vote

      but still non-interactively

  @rtype: None

  """

  if no_voting:

    masterd_args = "--no-voting --yes-do-it"

  else:

    masterd_args = ""

  env = {

    "EXTRA_MASTERD_ARGS": masterd_args,

    }

  result = utils.RunCmd([constants.DAEMON_UTIL, "start-master"], env=env)

  if result.failed:

    msg = "Can't start Ganeti master: %s" % result.output

    logging.error(msg)

    _Fail(msg)

def DeactivateMasterIp():

  """Deactivate the master IP on this node.

  """

  # TODO: log and report back to the caller the error failures; we

  # need to decide in which case we fail the RPC for this

  # GetMasterInfo will raise an exception if not able to return data

  master_netdev, master_ip, _, family = GetMasterInfo()

  ipcls = netutils.IP4Address

  if family == netutils.IP6Address.family:

    ipcls = netutils.IP6Address

  result = utils.RunCmd([constants.IP_COMMAND_PATH, "address", "del",

                         "%s/%d" % (master_ip, ipcls.iplen),

                         "dev", master_netdev])

  if result.failed:

    logging.error("Can't remove the master IP, error: %s", result.output)

    # but otherwise ignore the failure

def StopMasterDaemons():

  """Stop the master daemons on this node.

  Stop the master daemons (ganeti-masterd and ganeti-rapi) on this node.

  @rtype: None

  """

  # TODO: log and report back to the caller the error failures; we

  # need to decide in which case we fail the RPC for this

  result = utils.RunCmd([constants.DAEMON_UTIL, "stop-master"])

  if result.failed:

    logging.error("Could not stop Ganeti master, command %s had exitcode %s"

                  " and error %s",

                  result.cmd, result.exit_code, result.output)

def EtcHostsModify(mode, host, ip):

  """Modify a host entry in /etc/hosts.

  @param mode: The mode to operate. Either add or remove entry

  @param host: The host to operate on

  @param ip: The ip associated with the entry

  """

  if mode == constants.ETC_HOSTS_ADD:

    if not ip:

      RPCFail("Mode 'add' needs 'ip' parameter, but parameter not"

              " present")

    utils.AddHostToEtcHosts(host, ip)

  elif mode == constants.ETC_HOSTS_REMOVE:

    if ip:

      RPCFail("Mode 'remove' does not allow 'ip' parameter, but"

              " parameter is present")

    utils.RemoveHostFromEtcHosts(host)

  else:

    RPCFail("Mode not supported")

def LeaveCluster(modify_ssh_setup):

  """Cleans up and remove the current node.

  This function cleans up and prepares the current node to be removed

  from the cluster.

  If processing is successful, then it raises an

  L{errors.QuitGanetiException} which is used as a special case to

  shutdown the node daemon.

  @param modify_ssh_setup: boolean

  """

  _CleanDirectory(constants.DATA_DIR)

  _CleanDirectory(constants.CRYPTO_KEYS_DIR)

  JobQueuePurge()

  if modify_ssh_setup:

    try:

      priv_key, pub_key, auth_keys = ssh.GetUserFiles(constants.GANETI_RUNAS)

      utils.RemoveAuthorizedKey(auth_keys, utils.ReadFile(pub_key))

      utils.RemoveFile(priv_key)

      utils.RemoveFile(pub_key)

    except errors.OpExecError:

      logging.exception("Error while processing ssh files")

  try:

    utils.RemoveFile(constants.CONFD_HMAC_KEY)

    utils.RemoveFile(constants.RAPI_CERT_FILE)

    utils.RemoveFile(constants.NODED_CERT_FILE)

  except: # pylint: disable=W0702

    logging.exception("Error while removing cluster secrets")

  result = utils.RunCmd([constants.DAEMON_UTIL, "stop", constants.CONFD])

  if result.failed:

    logging.error("Command %s failed with exitcode %s and error %s",

                  result.cmd, result.exit_code, result.output)

  # Raise a custom exception (handled in ganeti-noded)

  raise errors.QuitGanetiException(True, "Shutdown scheduled")

def GetNodeInfo(vgname, hypervisor_type):

  """Gives back a hash with different information about the node.

  @type vgname: C{string}

  @param vgname: the name of the volume group to ask for disk space information

  @type hypervisor_type: C{str}

  @param hypervisor_type: the name of the hypervisor to ask for

      memory information

  @rtype: C{dict}

  @return: dictionary with the following keys:

      - vg_size is the size of the configured volume group in MiB

      - vg_free is the free size of the volume group in MiB

      - memory_dom0 is the memory allocated for domain0 in MiB

      - memory_free is the currently available (free) ram in MiB

      - memory_total is the total number of ram in MiB

      - hv_version: the hypervisor version, if available

  """

  outputarray = {}

  if vgname is not None:

    vginfo = bdev.LogicalVolume.GetVGInfo([vgname])

    vg_free = vg_size = None

    if vginfo:

      vg_free = int(round(vginfo[0][0], 0))

      vg_size = int(round(vginfo[0][1], 0))

    outputarray["vg_size"] = vg_size

    outputarray["vg_free"] = vg_free

  if hypervisor_type is not None:

    hyper = hypervisor.GetHypervisor(hypervisor_type)

    hyp_info = hyper.GetNodeInfo()

    if hyp_info is not None:

      outputarray.update(hyp_info)

  outputarray["bootid"] = utils.ReadFile(_BOOT_ID_PATH, size=128).rstrip("\n")

  return outputarray

def VerifyNode(what, cluster_name):

  """Verify the status of the local node.

  Based on the input L{what} parameter, various checks are done on the

  local node.

  If the I{filelist} key is present, this list of

  files is checksummed and the file/checksum pairs are returned.

  If the I{nodelist} key is present, we check that we have

  connectivity via ssh with the target nodes (and check the hostname

  report).

  If the I{node-net-test} key is present, we check that we have

  connectivity to the given nodes via both primary IP and, if

  applicable, secondary IPs.

  @type what: C{dict}

  @param what: a dictionary of things to check:

      - filelist: list of files for which to compute checksums

      - nodelist: list of nodes we should check ssh communication with

      - node-net-test: list of nodes we should check node daemon port

        connectivity with

      - hypervisor: list with hypervisors to run the verify for

  @rtype: dict

  @return: a dictionary with the same keys as the input dict, and

      values representing the result of the checks

  """

  result = {}

  my_name = netutils.Hostname.GetSysName()

  port = netutils.GetDaemonPort(constants.NODED)

  vm_capable = my_name not in what.get(constants.NV_VMNODES, [])

  if constants.NV_HYPERVISOR in what and vm_capable:

    result[constants.NV_HYPERVISOR] = tmp = {}

    for hv_name in what[constants.NV_HYPERVISOR]:

      try:

        val = hypervisor.GetHypervisor(hv_name).Verify()

      except errors.HypervisorError, err:

        val = "Error while checking hypervisor: %s" % str(err)

      tmp[hv_name] = val

  if constants.NV_HVPARAMS in what and vm_capable:

    result[constants.NV_HVPARAMS] = tmp = []

    for source, hv_name, hvparms in what[constants.NV_HVPARAMS]:

      try:

        logging.info("Validating hv %s, %s", hv_name, hvparms)

        hypervisor.GetHypervisor(hv_name).ValidateParameters(hvparms)

      except errors.HypervisorError, err:

        tmp.append((source, hv_name, str(err)))

  if constants.NV_FILELIST in what:

    result[constants.NV_FILELIST] = utils.FingerprintFiles(

      what[constants.NV_FILELIST])

  if constants.NV_NODELIST in what:

    (nodes, bynode) = what[constants.NV_NODELIST]

    # Add nodes from other groups (different for each node)

    try:

      nodes.extend(bynode[my_name])

    except KeyError:

      pass

    # Use a random order

    random.shuffle(nodes)

    # Try to contact all nodes

    val = {}

    for node in nodes:

      success, message = _GetSshRunner(cluster_name).VerifyNodeHostname(node)

      if not success:

        val[node] = message

    result[constants.NV_NODELIST] = val

  if constants.NV_NODENETTEST in what:

    result[constants.NV_NODENETTEST] = tmp = {}

    my_pip = my_sip = None

    for name, pip, sip in what[constants.NV_NODENETTEST]:

      if name == my_name:

        my_pip = pip

        my_sip = sip

        break

    if not my_pip:

      tmp[my_name] = ("Can't find my own primary/secondary IP"

                      " in the node list")

    else:

      for name, pip, sip in what[constants.NV_NODENETTEST]:

        fail = []

        if not netutils.TcpPing(pip, port, source=my_pip):

          fail.append("primary")

        if sip != pip:

          if not netutils.TcpPing(sip, port, source=my_sip):

            fail.append("secondary")

        if fail:

          tmp[name] = ("failure using the %s interface(s)" %

                       " and ".join(fail))

  if constants.NV_MASTERIP in what:

    # FIXME: add checks on incoming data structures (here and in the

    # rest of the function)

    master_name, master_ip = what[constants.NV_MASTERIP]

    if master_name == my_name:

      source = constants.IP4_ADDRESS_LOCALHOST

    else:

      source = None

    result[constants.NV_MASTERIP] = netutils.TcpPing(master_ip, port,

                                                  source=source)

  if constants.NV_OOB_PATHS in what:

    result[constants.NV_OOB_PATHS] = tmp = []

    for path in what[constants.NV_OOB_PATHS]:

      try:

        st = os.stat(path)

      except OSError, err:

        tmp.append("error stating out of band helper: %s" % err)

      else:

        if stat.S_ISREG(st.st_mode):

          if stat.S_IMODE(st.st_mode) & stat.S_IXUSR:

            tmp.append(None)

          else:

            tmp.append("out of band helper %s is not executable" % path)

        else:

          tmp.append("out of band helper %s is not a file" % path)

  if constants.NV_LVLIST in what and vm_capable:

    try:

      val = GetVolumeList(utils.ListVolumeGroups().keys())

    except RPCFail, err:

      val = str(err)

    result[constants.NV_LVLIST] = val

  if constants.NV_INSTANCELIST in what and vm_capable:

    # GetInstanceList can fail

    try:

      val = GetInstanceList(what[constants.NV_INSTANCELIST])

    except RPCFail, err:

      val = str(err)

    result[constants.NV_INSTANCELIST] = val

  if constants.NV_VGLIST in what and vm_capable:

    result[constants.NV_VGLIST] = utils.ListVolumeGroups()

  if constants.NV_PVLIST in what and vm_capable:

    result[constants.NV_PVLIST] = \

      bdev.LogicalVolume.GetPVInfo(what[constants.NV_PVLIST],

                                   filter_allocatable=False)

  if constants.NV_VERSION in what:

    result[constants.NV_VERSION] = (constants.PROTOCOL_VERSION,

                                    constants.RELEASE_VERSION)

  if constants.NV_HVINFO in what and vm_capable:

    hyper = hypervisor.GetHypervisor(what[constants.NV_HVINFO])

    result[constants.NV_HVINFO] = hyper.GetNodeInfo()

  if constants.NV_DRBDLIST in what and vm_capable:

    try:

      used_minors = bdev.DRBD8.GetUsedDevs().keys()

    except errors.BlockDeviceError, err:

      logging.warning("Can't get used minors list", exc_info=True)

      used_minors = str(err)

    result[constants.NV_DRBDLIST] = used_minors

  if constants.NV_DRBDHELPER in what and vm_capable:

    status = True

    try:

      payload = bdev.BaseDRBD.GetUsermodeHelper()

    except errors.BlockDeviceError, err:

      logging.error("Can't get DRBD usermode helper: %s", str(err))

      status = False

      payload = str(err)

    result[constants.NV_DRBDHELPER] = (status, payload)

  if constants.NV_NODESETUP in what:

    result[constants.NV_NODESETUP] = tmpr = []

    if not os.path.isdir("/sys/block") or not os.path.isdir("/sys/class/net"):

      tmpr.append("The sysfs filesytem doesn't seem to be mounted"

                  " under /sys, missing required directories /sys/block"

                  " and /sys/class/net")

    if (not os.path.isdir("/proc/sys") or

        not os.path.isfile("/proc/sysrq-trigger")):

      tmpr.append("The procfs filesystem doesn't seem to be mounted"

                  " under /proc, missing required directory /proc/sys and"

                  " the file /proc/sysrq-trigger")

  if constants.NV_TIME in what:

    result[constants.NV_TIME] = utils.SplitTime(time.time())

  if constants.NV_OSLIST in what and vm_capable:

    result[constants.NV_OSLIST] = DiagnoseOS()

  if constants.NV_BRIDGES in what and vm_capable:

    result[constants.NV_BRIDGES] = [bridge

                                    for bridge in what[constants.NV_BRIDGES]

                                    if not utils.BridgeExists(bridge)]

  return result

def GetBlockDevSizes(devices):

  """Return the size of the given block devices

  @type devices: list

  @param devices: list of block device nodes to query

  @rtype: dict

  @return:

    dictionary of all block devices under /dev (key). The value is their

    size in MiB.

    {'/dev/disk/by-uuid/123456-12321231-312312-312': 124}

  """

  DEV_PREFIX = "/dev/"

  blockdevs = {}

  for devpath in devices:

    if not utils.IsBelowDir(DEV_PREFIX, devpath):

      continue

    try:

      st = os.stat(devpath)

    except EnvironmentError, err:

      logging.warning("Error stat()'ing device %s: %s", devpath, str(err))

      continue

    if stat.S_ISBLK(st.st_mode):

      result = utils.RunCmd(["blockdev", "--getsize64", devpath])

      if result.failed:

        # We don't want to fail, just do not list this device as available

        logging.warning("Cannot get size for block device %s", devpath)

        continue

      size = int(result.stdout) / (1024 * 1024)

      blockdevs[devpath] = size

  return blockdevs

def GetVolumeList(vg_names):

  """Compute list of logical volumes and their size.

  @type vg_names: list

  @param vg_names: the volume groups whose LVs we should list, or

      empty for all volume groups

  @rtype: dict

  @return:

      dictionary of all partions (key) with value being a tuple of

      their size (in MiB), inactive and online status::

        {'xenvg/test1': ('20.06', True, True)}

      in case of errors, a string is returned with the error

      details.

  """

  lvs = {}

  sep = "|"

  if not vg_names:

    vg_names = []

  result = utils.RunCmd(["lvs", "--noheadings", "--units=m", "--nosuffix",

                         "--separator=%s" % sep,

                         "-ovg_name,lv_name,lv_size,lv_attr"] + vg_names)

  if result.failed:

    _Fail("Failed to list logical volumes, lvs output: %s", result.output)

  for line in result.stdout.splitlines():

    line = line.strip()

    match = _LVSLINE_REGEX.match(line)

    if not match:

      logging.error("Invalid line returned from lvs output: '%s'", line)

      continue

    vg_name, name, size, attr = match.groups()

    inactive = attr[4] == "-"

    online = attr[5] == "o"

    virtual = attr[0] == "v"

    if virtual:

      # we don't want to report such volumes as existing, since they

      # don't really hold data

      continue

    lvs[vg_name + "/" + name] = (size, inactive, online)

  return lvs

def ListVolumeGroups():

  """List the volume groups and their size.

  @rtype: dict

  @return: dictionary with keys volume name and values the

      size of the volume

  """

  return utils.ListVolumeGroups()

def NodeVolumes():

  """List all volumes on this node.

  @rtype: list

  @return:

    A list of dictionaries, each having four keys:

      - name: the logical volume name,

      - size: the size of the logical volume

      - dev: the physical device on which the LV lives

      - vg: the volume group to which it belongs

    In case of errors, we return an empty list and log the

    error.

    Note that since a logical volume can live on multiple physical

    volumes, the resulting list might include a logical volume

    multiple times.

  """

  result = utils.RunCmd(["lvs", "--noheadings", "--units=m", "--nosuffix",

                         "--separator=|",

                         "--options=lv_name,lv_size,devices,vg_name"])

  if result.failed:

    _Fail("Failed to list logical volumes, lvs output: %s",

          result.output)

  def parse_dev(dev):

    return dev.split("(")[0]

  def handle_dev(dev):

    return [parse_dev(x) for x in dev.split(",")]

  def map_line(line):

    line = [v.strip() for v in line]

    return [{"name": line[0], "size": line[1],

             "dev": dev, "vg": line[3]} for dev in handle_dev(line[2])]

  all_devs = []

  for line in result.stdout.splitlines():

    if line.count("|") >= 3:

      all_devs.extend(map_line(line.split("|")))

    else:

      logging.warning("Strange line in the output from lvs: '%s'", line)

  return all_devs

def BridgesExist(bridges_list):

  """Check if a list of bridges exist on the current node.

  @rtype: boolean

  @return: C{True} if all of them exist, C{False} otherwise

  """

  missing = []

  for bridge in bridges_list:

    if not utils.BridgeExists(bridge):

      missing.append(bridge)

  if missing:

    _Fail("Missing bridges %s", utils.CommaJoin(missing))

def GetInstanceList(hypervisor_list):

  """Provides a list of instances.

  @type hypervisor_list: list

  @param hypervisor_list: the list of hypervisors to query information

  @rtype: list

  @return: a list of all running instances on the current node

    - instance1.example.com

    - instance2.example.com

  """

  results = []

  for hname in hypervisor_list:

    try:

      names = hypervisor.GetHypervisor(hname).ListInstances()

      results.extend(names)

    except errors.HypervisorError, err:

      _Fail("Error enumerating instances (hypervisor %s): %s",

            hname, err, exc=True)

  return results

def GetInstanceInfo(instance, hname):

  """Gives back the information about an instance as a dictionary.

  @type instance: string

  @param instance: the instance name

  @type hname: string

  @param hname: the hypervisor type of the instance

  @rtype: dict

  @return: dictionary with the following keys:

      - memory: memory size of instance (int)

      - state: xen state of instance (string)

      - time: cpu time of instance (float)

  """

  output = {}

  iinfo = hypervisor.GetHypervisor(hname).GetInstanceInfo(instance)

  if iinfo is not None:

    output["memory"] = iinfo[2]

    output["state"] = iinfo[4]

    output["time"] = iinfo[5]

  return output

def GetInstanceMigratable(instance):

  """Gives whether an instance can be migrated.

  @type instance: L{objects.Instance}

  @param instance: object representing the instance to be checked.

  @rtype: tuple

  @return: tuple of (result, description) where:

      - result: whether the instance can be migrated or not

      - description: a description of the issue, if relevant

  """

  hyper = hypervisor.GetHypervisor(instance.hypervisor)

  iname = instance.name

  if iname not in hyper.ListInstances():

    _Fail("Instance %s is not running", iname)

  for idx in range(len(instance.disks)):

    link_name = _GetBlockDevSymlinkPath(iname, idx)

    if not os.path.islink(link_name):

      logging.warning("Instance %s is missing symlink %s for disk %d",

                      iname, link_name, idx)

def GetAllInstancesInfo(hypervisor_list):

  """Gather data about all instances.

  This is the equivalent of L{GetInstanceInfo}, except that it

  computes data for all instances at once, thus being faster if one

  needs data about more than one instance.

  @type hypervisor_list: list

  @param hypervisor_list: list of hypervisors to query for instance data

  @rtype: dict

  @return: dictionary of instance: data, with data having the following keys:

      - memory: memory size of instance (int)

      - state: xen state of instance (string)

      - time: cpu time of instance (float)

      - vcpus: the number of vcpus

  """

  output = {}

  for hname in hypervisor_list:

    iinfo = hypervisor.GetHypervisor(hname).GetAllInstancesInfo()

    if iinfo:

      for name, _, memory, vcpus, state, times in iinfo:

        value = {

          "memory": memory,

          "vcpus": vcpus,

          "state": state,

          "time": times,

          }

        if name in output:

          # we only check static parameters, like memory and vcpus,

          # and not state and time which can change between the

          # invocations of the different hypervisors

          for key in "memory", "vcpus":

            if value[key] != output[name][key]:

              _Fail("Instance %s is running twice"

                    " with different parameters", name)

        output[name] = value

  return output

def _InstanceLogName(kind, os_name, instance, component):

  """Compute the OS log filename for a given instance and operation.

  The instance name and os name are passed in as strings since not all

  operations have these as part of an instance object.

  @type kind: string

  @param kind: the operation type (e.g. add, import, etc.)

  @type os_name: string

  @param os_name: the os name

  @type instance: string

  @param instance: the name of the instance being imported/added/etc.

  @type component: string or None

  @param component: the name of the component of the instance being

      transferred

  """

  # TODO: Use tempfile.mkstemp to create unique filename

  if component:

    assert "/" not in component

    c_msg = "-%s" % component

  else:

    c_msg = ""

  base = ("%s-%s-%s%s-%s.log" %

          (kind, os_name, instance, c_msg, utils.TimestampForFilename()))

  return utils.PathJoin(constants.LOG_OS_DIR, base)

def InstanceOsAdd(instance, reinstall, debug):

  """Add an OS to an instance.

  @type instance: L{objects.Instance}

  @param instance: Instance whose OS is to be installed

  @type reinstall: boolean

  @param reinstall: whether this is an instance reinstall

  @type debug: integer

  @param debug: debug level, passed to the OS scripts

  @rtype: None

  """

  inst_os = OSFromDisk(instance.os)

  create_env = OSEnvironment(instance, inst_os, debug)

  if reinstall:

    create_env["INSTANCE_REINSTALL"] = "1"

  logfile = _InstanceLogName("add", instance.os, instance.name, None)

  result = utils.RunCmd([inst_os.create_script], env=create_env,

                        cwd=inst_os.path, output=logfile, reset_env=True)

  if result.failed:

    logging.error("os create command '%s' returned error: %s, logfile: %s,"

                  " output: %s", result.cmd, result.fail_reason, logfile,

                  result.output)

    lines = [utils.SafeEncode(val)

             for val in utils.TailFile(logfile, lines=20)]

    _Fail("OS create script failed (%s), last lines in the"

          " log file:\n%s", result.fail_reason, "\n".join(lines), log=False)

def RunRenameInstance(instance, old_name, debug):

  """Run the OS rename script for an instance.

  @type instance: L{objects.Instance}

  @param instance: Instance whose OS is to be installed

  @type old_name: string

  @param old_name: previous instance name

  @type debug: integer

  @param debug: debug level, passed to the OS scripts

  @rtype: boolean

  @return: the success of the operation

  """

  inst_os = OSFromDisk(instance.os)

  rename_env = OSEnvironment(instance, inst_os, debug)

  rename_env["OLD_INSTANCE_NAME"] = old_name

  logfile = _InstanceLogName("rename", instance.os,

                             "%s-%s" % (old_name, instance.name), None)

  result = utils.RunCmd([inst_os.rename_script], env=rename_env,

                        cwd=inst_os.path, output=logfile, reset_env=True)

  if result.failed:

    logging.error("os create command '%s' returned error: %s output: %s",

                  result.cmd, result.fail_reason, result.output)

    lines = [utils.SafeEncode(val)

             for val in utils.TailFile(logfile, lines=20)]

    _Fail("OS rename script failed (%s), last lines in the"

          " log file:\n%s", result.fail_reason, "\n".join(lines), log=False)

def _GetBlockDevSymlinkPath(instance_name, idx):

  return utils.PathJoin(constants.DISK_LINKS_DIR, "%s%s%d" %

                        (instance_name, constants.DISK_SEPARATOR, idx))

def _SymlinkBlockDev(instance_name, device_path, idx):

  """Set up symlinks to a instance's block device.

  This is an auxiliary function run when an instance is start (on the primary

  node) or when an instance is migrated (on the target node).

  @param instance_name: the name of the target instance

  @param device_path: path of the physical block device, on the node

  @param idx: the disk index

  @return: absolute path to the disk's symlink

  """

  link_name = _GetBlockDevSymlinkPath(instance_name, idx)

  try:

    os.symlink(device_path, link_name)

  except OSError, err:

    if err.errno == errno.EEXIST:

      if (not os.path.islink(link_name) or

          os.readlink(link_name) != device_path):

        os.remove(link_name)

        os.symlink(device_path, link_name)

    else:

      raise