Synnefo » snf-ganeti

#

#

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

"""Ganeti utility module.

This module holds functions that can be used in both daemons (all) and

the command line scripts.

"""

import sys

import os

import time

import subprocess

import re

import socket

import tempfile

import shutil

import errno

import pwd

import itertools

import select

import fcntl

import resource

import logging

import signal

from cStringIO import StringIO

try:

  from hashlib import sha1

except ImportError:

  import sha

  sha1 = sha.new

from ganeti import errors

from ganeti import constants

_locksheld = []

_re_shell_unquoted = re.compile('^[-.,=:/_+@A-Za-z0-9]+$')

debug = False

debug_locks = False

#: when set to True, L{RunCmd} is disabled

no_fork = False

class RunResult(object):

  """Holds the result of running external programs.

  @type exit_code: int

  @ivar exit_code: the exit code of the program, or None (if the program

      didn't exit())

  @type signal: int or None

  @ivar signal: the signal that caused the program to finish, or None

      (if the program wasn't terminated by a signal)

  @type stdout: str

  @ivar stdout: the standard output of the program

  @type stderr: str

  @ivar stderr: the standard error of the program

  @type failed: boolean

  @ivar failed: True in case the program was

      terminated by a signal or exited with a non-zero exit code

  @ivar fail_reason: a string detailing the termination reason

  """

  __slots__ = ["exit_code", "signal", "stdout", "stderr",

               "failed", "fail_reason", "cmd"]

  def __init__(self, exit_code, signal_, stdout, stderr, cmd):

    self.cmd = cmd

    self.exit_code = exit_code

    self.signal = signal_

    self.stdout = stdout

    self.stderr = stderr

    self.failed = (signal_ is not None or exit_code != 0)

    if self.signal is not None:

      self.fail_reason = "terminated by signal %s" % self.signal

    elif self.exit_code is not None:

      self.fail_reason = "exited with exit code %s" % self.exit_code

    else:

      self.fail_reason = "unable to determine termination reason"

    if self.failed:

      logging.debug("Command '%s' failed (%s); output: %s",

                    self.cmd, self.fail_reason, self.output)

  def _GetOutput(self):

    """Returns the combined stdout and stderr for easier usage.

    """

    return self.stdout + self.stderr

  output = property(_GetOutput, None, None, "Return full output")

def RunCmd(cmd, env=None, output=None, cwd='/'):

  """Execute a (shell) command.

  The command should not read from its standard input, as it will be

  closed.

  @type  cmd: string or list

  @param cmd: Command to run

  @type env: dict

  @param env: Additional environment

  @type output: str

  @param output: if desired, the output of the command can be

      saved in a file instead of the RunResult instance; this

      parameter denotes the file name (if not None)

  @type cwd: string

  @param cwd: if specified, will be used as the working

      directory for the command; the default will be /

  @rtype: L{RunResult}

  @return: RunResult instance

  @raise erors.ProgrammerError: if we call this when forks are disabled

  """

  if no_fork:

    raise errors.ProgrammerError("utils.RunCmd() called with fork() disabled")

  if isinstance(cmd, list):

    cmd = [str(val) for val in cmd]

    strcmd = " ".join(cmd)

    shell = False

  else:

    strcmd = cmd

    shell = True

  logging.debug("RunCmd '%s'", strcmd)

  cmd_env = os.environ.copy()

  cmd_env["LC_ALL"] = "C"

  if env is not None:

    cmd_env.update(env)

  try:

    if output is None:

      out, err, status = _RunCmdPipe(cmd, cmd_env, shell, cwd)

    else:

      status = _RunCmdFile(cmd, cmd_env, shell, output, cwd)

      out = err = ""

  except OSError, err:

    if err.errno == errno.ENOENT:

      raise errors.OpExecError("Can't execute '%s': not found (%s)" %

                               (strcmd, err))

    else:

      raise

  if status >= 0:

    exitcode = status

    signal_ = None

  else:

    exitcode = None

    signal_ = -status

  return RunResult(exitcode, signal_, out, err, strcmd)

def _RunCmdPipe(cmd, env, via_shell, cwd):

  """Run a command and return its output.

  @type  cmd: string or list

  @param cmd: Command to run

  @type env: dict

  @param env: The environment to use

  @type via_shell: bool

  @param via_shell: if we should run via the shell

  @type cwd: string

  @param cwd: the working directory for the program

  @rtype: tuple

  @return: (out, err, status)

  """

  poller = select.poll()

  child = subprocess.Popen(cmd, shell=via_shell,

                           stderr=subprocess.PIPE,

                           stdout=subprocess.PIPE,

                           stdin=subprocess.PIPE,

                           close_fds=True, env=env,

                           cwd=cwd)

  child.stdin.close()

  poller.register(child.stdout, select.POLLIN)

  poller.register(child.stderr, select.POLLIN)

  out = StringIO()

  err = StringIO()

  fdmap = {

    child.stdout.fileno(): (out, child.stdout),

    child.stderr.fileno(): (err, child.stderr),

    }

  for fd in fdmap:

    status = fcntl.fcntl(fd, fcntl.F_GETFL)

    fcntl.fcntl(fd, fcntl.F_SETFL, status | os.O_NONBLOCK)

  while fdmap:

    try:

      pollresult = poller.poll()

    except EnvironmentError, eerr:

      if eerr.errno == errno.EINTR:

        continue

      raise

    except select.error, serr:

      if serr[0] == errno.EINTR:

        continue

      raise

    for fd, event in pollresult:

      if event & select.POLLIN or event & select.POLLPRI:

        data = fdmap[fd][1].read()

        # no data from read signifies EOF (the same as POLLHUP)

        if not data:

          poller.unregister(fd)

          del fdmap[fd]

          continue

        fdmap[fd][0].write(data)

      if (event & select.POLLNVAL or event & select.POLLHUP or

          event & select.POLLERR):

        poller.unregister(fd)

        del fdmap[fd]

  out = out.getvalue()

  err = err.getvalue()

  status = child.wait()

  return out, err, status

def _RunCmdFile(cmd, env, via_shell, output, cwd):

  """Run a command and save its output to a file.

  @type  cmd: string or list

  @param cmd: Command to run

  @type env: dict

  @param env: The environment to use

  @type via_shell: bool

  @param via_shell: if we should run via the shell

  @type output: str

  @param output: the filename in which to save the output

  @type cwd: string

  @param cwd: the working directory for the program

  @rtype: int

  @return: the exit status

  """

  fh = open(output, "a")

  try:

    child = subprocess.Popen(cmd, shell=via_shell,

                             stderr=subprocess.STDOUT,

                             stdout=fh,

                             stdin=subprocess.PIPE,

                             close_fds=True, env=env,

                             cwd=cwd)

    child.stdin.close()

    status = child.wait()

  finally:

    fh.close()

  return status

def RemoveFile(filename):

  """Remove a file ignoring some errors.

  Remove a file, ignoring non-existing ones or directories. Other

  errors are passed.

  @type filename: str

  @param filename: the file to be removed

  """

  try:

    os.unlink(filename)

  except OSError, err:

    if err.errno not in (errno.ENOENT, errno.EISDIR):

      raise

def RenameFile(old, new, mkdir=False, mkdir_mode=0750):

  """Renames a file.

  @type old: string

  @param old: Original path

  @type new: string

  @param new: New path

  @type mkdir: bool

  @param mkdir: Whether to create target directory if it doesn't exist

  @type mkdir_mode: int

  @param mkdir_mode: Mode for newly created directories

  """

  try:

    return os.rename(old, new)

  except OSError, err:

    # In at least one use case of this function, the job queue, directory

    # creation is very rare. Checking for the directory before renaming is not

    # as efficient.

    if mkdir and err.errno == errno.ENOENT:

      # Create directory and try again

      os.makedirs(os.path.dirname(new), mkdir_mode)

      return os.rename(old, new)

    raise

def _FingerprintFile(filename):

  """Compute the fingerprint of a file.

  If the file does not exist, a None will be returned

  instead.

  @type filename: str

  @param filename: the filename to checksum

  @rtype: str

  @return: the hex digest of the sha checksum of the contents

      of the file

  """

  if not (os.path.exists(filename) and os.path.isfile(filename)):

    return None

  f = open(filename)

  fp = sha1()

  while True:

    data = f.read(4096)

    if not data:

      break

    fp.update(data)

  return fp.hexdigest()

def FingerprintFiles(files):

  """Compute fingerprints for a list of files.

  @type files: list

  @param files: the list of filename to fingerprint

  @rtype: dict

  @return: a dictionary filename: fingerprint, holding only

      existing files

  """

  ret = {}

  for filename in files:

    cksum = _FingerprintFile(filename)

    if cksum:

      ret[filename] = cksum

  return ret

def ForceDictType(target, key_types, allowed_values=None):

  """Force the values of a dict to have certain types.

  @type target: dict

  @param target: the dict to update

  @type key_types: dict

  @param key_types: dict mapping target dict keys to types

                    in constants.ENFORCEABLE_TYPES

  @type allowed_values: list

  @keyword allowed_values: list of specially allowed values

  """

  if allowed_values is None:

    allowed_values = []

  for key in target:

    if key not in key_types:

      msg = "Unknown key '%s'" % key

      raise errors.TypeEnforcementError(msg)

    if target[key] in allowed_values:

      continue

    type = key_types[key]

    if type not in constants.ENFORCEABLE_TYPES:

      msg = "'%s' has non-enforceable type %s" % (key, type)

      raise errors.ProgrammerError(msg)

    if type == constants.VTYPE_STRING:

      if not isinstance(target[key], basestring):

        if isinstance(target[key], bool) and not target[key]:

          target[key] = ''

        else:

          msg = "'%s' (value %s) is not a valid string" % (key, target[key])

          raise errors.TypeEnforcementError(msg)

    elif type == constants.VTYPE_BOOL:

      if isinstance(target[key], basestring) and target[key]:

        if target[key].lower() == constants.VALUE_FALSE:

          target[key] = False

        elif target[key].lower() == constants.VALUE_TRUE:

          target[key] = True

        else:

          msg = "'%s' (value %s) is not a valid boolean" % (key, target[key])

          raise errors.TypeEnforcementError(msg)

      elif target[key]:

        target[key] = True

      else:

        target[key] = False

    elif type == constants.VTYPE_SIZE:

      try:

        target[key] = ParseUnit(target[key])

      except errors.UnitParseError, err:

        msg = "'%s' (value %s) is not a valid size. error: %s" % \

              (key, target[key], err)

        raise errors.TypeEnforcementError(msg)

    elif type == constants.VTYPE_INT:

      try:

        target[key] = int(target[key])

      except (ValueError, TypeError):

        msg = "'%s' (value %s) is not a valid integer" % (key, target[key])

        raise errors.TypeEnforcementError(msg)

def IsProcessAlive(pid):

  """Check if a given pid exists on the system.

  @note: zombie status is not handled, so zombie processes

      will be returned as alive

  @type pid: int

  @param pid: the process ID to check

  @rtype: boolean

  @return: True if the process exists

  """

  if pid <= 0:

    return False

  try:

    os.stat("/proc/%d/status" % pid)

    return True

  except EnvironmentError, err:

    if err.errno in (errno.ENOENT, errno.ENOTDIR):

      return False

    raise

def ReadPidFile(pidfile):

  """Read a pid from a file.

  @type  pidfile: string

  @param pidfile: path to the file containing the pid

  @rtype: int

  @return: The process id, if the file exists and contains a valid PID,

           otherwise 0

  """

  try:

    pf = open(pidfile, 'r')

  except EnvironmentError, err:

    if err.errno != errno.ENOENT:

      logging.exception("Can't read pid file?!")

    return 0

  try:

    pid = int(pf.read())

  except ValueError, err:

    logging.info("Can't parse pid file contents", exc_info=True)

    return 0

  return pid

def MatchNameComponent(key, name_list):

  """Try to match a name against a list.

  This function will try to match a name like test1 against a list

  like C{['test1.example.com', 'test2.example.com', ...]}. Against

  this list, I{'test1'} as well as I{'test1.example'} will match, but

  not I{'test1.ex'}. A multiple match will be considered as no match

  at all (e.g. I{'test1'} against C{['test1.example.com',

  'test1.example.org']}).

  @type key: str

  @param key: the name to be searched

  @type name_list: list

  @param name_list: the list of strings against which to search the key

  @rtype: None or str

  @return: None if there is no match I{or} if there are multiple matches,

      otherwise the element from the list which matches

  """

  mo = re.compile("^%s(\..*)?$" % re.escape(key))

  names_filtered = [name for name in name_list if mo.match(name) is not None]

  if len(names_filtered) != 1:

    return None

  return names_filtered[0]

class HostInfo:

  """Class implementing resolver and hostname functionality

  """

  def __init__(self, name=None):

    """Initialize the host name object.

    If the name argument is not passed, it will use this system's

    name.

    """

    if name is None:

      name = self.SysName()

    self.query = name

    self.name, self.aliases, self.ipaddrs = self.LookupHostname(name)

    self.ip = self.ipaddrs[0]

  def ShortName(self):

    """Returns the hostname without domain.

    """

    return self.name.split('.')[0]

  @staticmethod

  def SysName():

    """Return the current system's name.

    This is simply a wrapper over C{socket.gethostname()}.

    """

    return socket.gethostname()

  @staticmethod

  def LookupHostname(hostname):

    """Look up hostname

    @type hostname: str

    @param hostname: hostname to look up

    @rtype: tuple

    @return: a tuple (name, aliases, ipaddrs) as returned by

        C{socket.gethostbyname_ex}

    @raise errors.ResolverError: in case of errors in resolving

    """

    try:

      result = socket.gethostbyname_ex(hostname)

    except socket.gaierror, err:

      # hostname not found in DNS

      raise errors.ResolverError(hostname, err.args[0], err.args[1])

    return result

def ListVolumeGroups():

  """List volume groups and their size

  @rtype: dict

  @return:

       Dictionary with keys volume name and values

       the size of the volume

  """

  command = "vgs --noheadings --units m --nosuffix -o name,size"

  result = RunCmd(command)

  retval = {}

  if result.failed:

    return retval

  for line in result.stdout.splitlines():

    try:

      name, size = line.split()

      size = int(float(size))

    except (IndexError, ValueError), err:

      logging.error("Invalid output from vgs (%s): %s", err, line)

      continue

    retval[name] = size

  return retval

def BridgeExists(bridge):

  """Check whether the given bridge exists in the system

  @type bridge: str

  @param bridge: the bridge name to check

  @rtype: boolean

  @return: True if it does

  """

  return os.path.isdir("/sys/class/net/%s/bridge" % bridge)

def NiceSort(name_list):

  """Sort a list of strings based on digit and non-digit groupings.

  Given a list of names C{['a1', 'a10', 'a11', 'a2']} this function

  will sort the list in the logical order C{['a1', 'a2', 'a10',

  'a11']}.

  The sort algorithm breaks each name in groups of either only-digits

  or no-digits. Only the first eight such groups are considered, and

  after that we just use what's left of the string.

  @type name_list: list

  @param name_list: the names to be sorted

  @rtype: list

  @return: a copy of the name list sorted with our algorithm

  """

  _SORTER_BASE = "(\D+|\d+)"

  _SORTER_FULL = "^%s%s?%s?%s?%s?%s?%s?%s?.*$" % (_SORTER_BASE, _SORTER_BASE,

                                                  _SORTER_BASE, _SORTER_BASE,

                                                  _SORTER_BASE, _SORTER_BASE,

                                                  _SORTER_BASE, _SORTER_BASE)

  _SORTER_RE = re.compile(_SORTER_FULL)

  _SORTER_NODIGIT = re.compile("^\D*$")

  def _TryInt(val):

    """Attempts to convert a variable to integer."""

    if val is None or _SORTER_NODIGIT.match(val):

      return val

    rval = int(val)

    return rval

  to_sort = [([_TryInt(grp) for grp in _SORTER_RE.match(name).groups()], name)

             for name in name_list]

  to_sort.sort()

  return [tup[1] for tup in to_sort]

def TryConvert(fn, val):

  """Try to convert a value ignoring errors.

  This function tries to apply function I{fn} to I{val}. If no

  C{ValueError} or C{TypeError} exceptions are raised, it will return

  the result, else it will return the original value. Any other

  exceptions are propagated to the caller.

  @type fn: callable

  @param fn: function to apply to the value

  @param val: the value to be converted

  @return: The converted value if the conversion was successful,

      otherwise the original value.

  """

  try:

    nv = fn(val)

  except (ValueError, TypeError), err:

    nv = val

  return nv

def IsValidIP(ip):

  """Verifies the syntax of an IPv4 address.

  This function checks if the IPv4 address passes is valid or not based

  on syntax (not IP range, class calculations, etc.).

  @type ip: str

  @param ip: the address to be checked

  @rtype: a regular expression match object

  @return: a regular epression match object, or None if the

      address is not valid

  """

  unit = "(0|[1-9]\d{0,2})"

  #TODO: convert and return only boolean

  return re.match("^%s\.%s\.%s\.%s$" % (unit, unit, unit, unit), ip)

def IsValidShellParam(word):

  """Verifies is the given word is safe from the shell's p.o.v.

  This means that we can pass this to a command via the shell and be

  sure that it doesn't alter the command line and is passed as such to

  the actual command.

  Note that we are overly restrictive here, in order to be on the safe

  side.

  @type word: str

  @param word: the word to check

  @rtype: boolean

  @return: True if the word is 'safe'

  """

  return bool(re.match("^[-a-zA-Z0-9._+/:%@]+$", word))

def BuildShellCmd(template, *args):

  """Build a safe shell command line from the given arguments.

  This function will check all arguments in the args list so that they

  are valid shell parameters (i.e. they don't contain shell

  metacharaters). If everything is ok, it will return the result of

  template % args.

  @type template: str

  @param template: the string holding the template for the

      string formatting

  @rtype: str

  @return: the expanded command line

  """

  for word in args:

    if not IsValidShellParam(word):

      raise errors.ProgrammerError("Shell argument '%s' contains"

                                   " invalid characters" % word)

  return template % args

def FormatUnit(value, units):

  """Formats an incoming number of MiB with the appropriate unit.

  @type value: int

  @param value: integer representing the value in MiB (1048576)

  @type units: char

  @param units: the type of formatting we should do:

      - 'h' for automatic scaling

      - 'm' for MiBs

      - 'g' for GiBs

      - 't' for TiBs

  @rtype: str

  @return: the formatted value (with suffix)