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-msg=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())

  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 StartMaster(start_daemons, no_voting):

  """Activate local node as master node.

  The function will either try activate the IP address of the master

  (unless someone else has it) or also start the master daemons, based

  on the start_daemons parameter.

  @type start_daemons: boolean

  @param start_daemons: whether to start the master daemons

      (ganeti-masterd and ganeti-rapi), or (if false) activate the

      master ip

  @type no_voting: boolean

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

      (if start_daemons is True), but still non-interactively

  @rtype: None

  """

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

  master_netdev, master_ip, _, family = GetMasterInfo()

  err_msgs = []

  # either start the master and rapi daemons

  if start_daemons:

    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)

      err_msgs.append(msg)

  # or activate the IP

  else:

    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:

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

        logging.error(msg)

        err_msgs.append(msg)

    else:

      ipcls = netutils.IP4Address

      if family == netutils.IP6Address.family:

        ipcls = netutils.IP6Address

      result = utils.RunCmd(["ip", "address", "add",

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

                             "dev", master_netdev, "label",

                             "%s:0" % master_netdev])

      if result.failed:

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

        logging.error(msg)

        err_msgs.append(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_msgs:

    _Fail("; ".join(err_msgs))

def StopMaster(stop_daemons):

  """Deactivate this node as master.

  The function will always try to deactivate the IP address of the

  master. It will also stop the master daemons depending on the

  stop_daemons parameter.

  @type stop_daemons: boolean

  @param stop_daemons: whether to also stop the master daemons

      (ganeti-masterd and ganeti-rapi)

  @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

  # 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(["ip", "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

  if stop_daemons:

    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-msg=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

  """

  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:

    result[constants.NV_NODELIST] = tmp = {}

    random.shuffle(what[constants.NV_NODELIST])

    for node in what[constants.NV_NODELIST]:

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

      if not success:

        tmp[node] = message

  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 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)