Synnefo » snf-ganeti

#

#

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

"""DRBD block device related functionality"""

import errno

import logging

import time

from ganeti import constants

from ganeti import utils

from ganeti import errors

from ganeti import netutils

from ganeti import objects

from ganeti.storage import base

from ganeti.storage.drbd_info import DRBD8Info

from ganeti.storage import drbd_info

from ganeti.storage import drbd_cmdgen

# Size of reads in _CanReadDevice

_DEVICE_READ_SIZE = 128 * 1024

class DRBD8(object):

  """Various methods to deals with the DRBD system as a whole.

  This class provides a set of methods to deal with the DRBD installation on

  the node or with uninitialized devices as opposed to a DRBD device.

  """

  _USERMODE_HELPER_FILE = "/sys/module/drbd/parameters/usermode_helper"

  _MAX_MINORS = 255

  @staticmethod

  def GetUsermodeHelper(filename=_USERMODE_HELPER_FILE):

    """Returns DRBD usermode_helper currently set.

    @type filename: string

    @param filename: the filename to read the usermode helper from

    @rtype: string

    @return: the currently configured DRBD usermode helper

    """

    try:

      helper = utils.ReadFile(filename).splitlines()[0]

    except EnvironmentError, err:

      if err.errno == errno.ENOENT:

        base.ThrowError("The file %s cannot be opened, check if the module"

                        " is loaded (%s)", filename, str(err))

      else:

        base.ThrowError("Can't read DRBD helper file %s: %s",

                        filename, str(err))

    if not helper:

      base.ThrowError("Can't read any data from %s", filename)

    return helper

  @staticmethod

  def GetProcInfo():

    """Reads and parses information from /proc/drbd.

    @rtype: DRBD8Info

    @return: a L{DRBD8Info} instance containing the current /proc/drbd info

    """

    return DRBD8Info.CreateFromFile()

  @staticmethod

  def GetUsedDevs():

    """Compute the list of used DRBD minors.

    @rtype: list of ints

    """

    info = DRBD8.GetProcInfo()

    return filter(lambda m: not info.GetMinorStatus(m).is_unconfigured,

                  info.GetMinors())

  @staticmethod

  def FindUnusedMinor():

    """Find an unused DRBD device.

    This is specific to 8.x as the minors are allocated dynamically,

    so non-existing numbers up to a max minor count are actually free.

    @rtype: int

    """

    highest = None

    info = DRBD8.GetProcInfo()

    for minor in info.GetMinors():

      status = info.GetMinorStatus(minor)

      if not status.is_in_use:

        return minor

      highest = max(highest, minor)

    if highest is None: # there are no minors in use at all

      return 0

    if highest >= DRBD8._MAX_MINORS:

      logging.error("Error: no free drbd minors!")

      raise errors.BlockDeviceError("Can't find a free DRBD minor")

    return highest + 1

  @staticmethod

  def GetCmdGenerator(info):

    """Creates a suitable L{BaseDRBDCmdGenerator} based on the given info.

    @type info: DRBD8Info

    @rtype: BaseDRBDCmdGenerator

    """

    version = info.GetVersion()

    if version["k_minor"] <= 3:

      return drbd_cmdgen.DRBD83CmdGenerator(version)

    else:

      return drbd_cmdgen.DRBD84CmdGenerator(version)

  @staticmethod

  def ShutdownAll(minor):

    """Deactivate the device.

    This will, of course, fail if the device is in use.

    @type minor: int

    @param minor: the minor to shut down

    """

    info = DRBD8.GetProcInfo()

    cmd_gen = DRBD8.GetCmdGenerator(info)

    cmd = cmd_gen.GenDownCmd(minor)

    result = utils.RunCmd(cmd)

    if result.failed:

      base.ThrowError("drbd%d: can't shutdown drbd device: %s",

                      minor, result.output)

class DRBD8Dev(base.BlockDev):

  """DRBD v8.x block device.

  This implements the local host part of the DRBD device, i.e. it

  doesn't do anything to the supposed peer. If you need a fully

  connected DRBD pair, you need to use this class on both hosts.

  The unique_id for the drbd device is a (pnode_uuid, snode_uuid,

  port, pnode_minor, lnode_minor, secret) tuple, and it must have

  two children: the data device and the meta_device. The meta

  device is checked for valid size and is zeroed on create.

  """

  _DRBD_MAJOR = 147

  # timeout constants

  _NET_RECONFIG_TIMEOUT = 60

  def __init__(self, unique_id, children, size, params, dyn_params, *args):

    if children and children.count(None) > 0:

      children = []

    if len(children) not in (0, 2):

      raise ValueError("Invalid configuration data %s" % str(children))

    if not isinstance(unique_id, (tuple, list)) or len(unique_id) != 6:

      raise ValueError("Invalid configuration data %s" % str(unique_id))

    if constants.DDP_LOCAL_IP not in dyn_params or \

       constants.DDP_REMOTE_IP not in dyn_params or \

       constants.DDP_LOCAL_MINOR not in dyn_params or \

       constants.DDP_REMOTE_MINOR not in dyn_params:

      raise ValueError("Invalid dynamic parameters %s" % str(dyn_params))

    self._lhost = dyn_params[constants.DDP_LOCAL_IP]

    self._lport = unique_id[2]

    self._rhost = dyn_params[constants.DDP_REMOTE_IP]

    self._rport = unique_id[2]

    self._aminor = dyn_params[constants.DDP_LOCAL_MINOR]

    self._secret = unique_id[5]

    if children:

      if not _CanReadDevice(children[1].dev_path):

        logging.info("drbd%s: Ignoring unreadable meta device", self._aminor)

        children = []

    super(DRBD8Dev, self).__init__(unique_id, children, size, params,

                                   dyn_params, *args)

    self.major = self._DRBD_MAJOR

    info = DRBD8.GetProcInfo()

    version = info.GetVersion()

    if version["k_major"] != 8:

      base.ThrowError("Mismatch in DRBD kernel version and requested ganeti"

                      " usage: kernel is %s.%s, ganeti wants 8.x",

                      version["k_major"], version["k_minor"])

    if version["k_minor"] <= 3:

      self._show_info_cls = drbd_info.DRBD83ShowInfo

    else:

      self._show_info_cls = drbd_info.DRBD84ShowInfo

    self._cmd_gen = DRBD8.GetCmdGenerator(info)

    if (self._lhost is not None and self._lhost == self._rhost and

            self._lport == self._rport):

      raise ValueError("Invalid configuration data, same local/remote %s, %s" %

                       (unique_id, dyn_params))

    self.Attach()

  @staticmethod

  def _DevPath(minor):

    """Return the path to a drbd device for a given minor.

    @type minor: int

    @rtype: string

    """

    return "/dev/drbd%d" % minor

  def _SetFromMinor(self, minor):

    """Set our parameters based on the given minor.

    This sets our minor variable and our dev_path.

    @type minor: int

    """

    if minor is None:

      self.minor = self.dev_path = None

      self.attached = False

    else:

      self.minor = minor

      self.dev_path = self._DevPath(minor)

      self.attached = True

  @staticmethod

  def _CheckMetaSize(meta_device):

    """Check if the given meta device looks like a valid one.

    This currently only checks the size, which must be around

    128MiB.

    @type meta_device: string

    @param meta_device: the path to the device to check

    """

    result = utils.RunCmd(["blockdev", "--getsize", meta_device])

    if result.failed:

      base.ThrowError("Failed to get device size: %s - %s",

                      result.fail_reason, result.output)

    try:

      sectors = int(result.stdout)

    except (TypeError, ValueError):

      base.ThrowError("Invalid output from blockdev: '%s'", result.stdout)

    num_bytes = sectors * 512

    if num_bytes < 128 * 1024 * 1024: # less than 128MiB

      base.ThrowError("Meta device too small (%.2fMib)",

                      (num_bytes / 1024 / 1024))

    # the maximum *valid* size of the meta device when living on top

    # of LVM is hard to compute: it depends on the number of stripes

    # and the PE size; e.g. a 2-stripe, 64MB PE will result in a 128MB

    # (normal size), but an eight-stripe 128MB PE will result in a 1GB

    # size meta device; as such, we restrict it to 1GB (a little bit

    # too generous, but making assumptions about PE size is hard)

    if num_bytes > 1024 * 1024 * 1024:

      base.ThrowError("Meta device too big (%.2fMiB)",

                      (num_bytes / 1024 / 1024))

  def _GetShowData(self, minor):

    """Return the `drbdsetup show` data.

    @type minor: int

    @param minor: the minor to collect show output for

    @rtype: string

    """

    result = utils.RunCmd(self._cmd_gen.GenShowCmd(minor))

    if result.failed:

      logging.error("Can't display the drbd config: %s - %s",

                    result.fail_reason, result.output)

      return None

    return result.stdout

  def _GetShowInfo(self, minor):

    """Return parsed information from `drbdsetup show`.

    @type minor: int

    @param minor: the minor to return information for

    @rtype: dict as described in L{drbd_info.BaseShowInfo.GetDevInfo}

    """

    return self._show_info_cls.GetDevInfo(self._GetShowData(minor))

  def _MatchesLocal(self, info):

    """Test if our local config matches with an existing device.

    The parameter should be as returned from `_GetShowInfo()`. This

    method tests if our local backing device is the same as the one in

    the info parameter, in effect testing if we look like the given

    device.

    @type info: dict as described in L{drbd_info.BaseShowInfo.GetDevInfo}

    @rtype: boolean

    """

    if self._children:

      backend, meta = self._children

    else:

      backend = meta = None

    if backend is not None:

      retval = ("local_dev" in info and info["local_dev"] == backend.dev_path)

    else:

      retval = ("local_dev" not in info)

    if meta is not None:

      retval = retval and ("meta_dev" in info and

                           info["meta_dev"] == meta.dev_path)

      if "meta_index" in info:

        retval = retval and info["meta_index"] == 0

    else:

      retval = retval and ("meta_dev" not in info and

                           "meta_index" not in info)

    return retval

  def _MatchesNet(self, info):

    """Test if our network config matches with an existing device.

    The parameter should be as returned from `_GetShowInfo()`. This

    method tests if our network configuration is the same as the one

    in the info parameter, in effect testing if we look like the given

    device.

    @type info: dict as described in L{drbd_info.BaseShowInfo.GetDevInfo}

    @rtype: boolean

    """

    if (((self._lhost is None and not ("local_addr" in info)) and

         (self._rhost is None and not ("remote_addr" in info)))):

      return True

    if self._lhost is None:

      return False

    if not ("local_addr" in info and

            "remote_addr" in info):

      return False

    retval = (info["local_addr"] == (self._lhost, self._lport))

    retval = (retval and

              info["remote_addr"] == (self._rhost, self._rport))

    return retval

  def _AssembleLocal(self, minor, backend, meta, size):

    """Configure the local part of a DRBD device.

    @type minor: int

    @param minor: the minor to assemble locally

    @type backend: string

    @param backend: path to the data device to use

    @type meta: string

    @param meta: path to the meta device to use

    @type size: int

    @param size: size in MiB

    """

    cmds = self._cmd_gen.GenLocalInitCmds(minor, backend, meta,

                                          size, self.params)

    for cmd in cmds:

      result = utils.RunCmd(cmd)

      if result.failed:

        base.ThrowError("drbd%d: can't attach local disk: %s",

                        minor, result.output)

  def _AssembleNet(self, minor, net_info, dual_pri=False, hmac=None,

                   secret=None):

    """Configure the network part of the device.

    @type minor: int

    @param minor: the minor to assemble the network for

    @type net_info: (string, int, string, int)

    @param net_info: tuple containing the local address, local port, remote

      address and remote port

    @type dual_pri: boolean

    @param dual_pri: whether two primaries should be allowed or not

    @type hmac: string

    @param hmac: the HMAC algorithm to use

    @type secret: string

    @param secret: the shared secret to use

    """

    lhost, lport, rhost, rport = net_info

    if None in net_info:

      # we don't want network connection and actually want to make

      # sure its shutdown

      self._ShutdownNet(minor)

      return

    if dual_pri:

      protocol = constants.DRBD_MIGRATION_NET_PROTOCOL

    else:

      protocol = self.params[constants.LDP_PROTOCOL]

    # Workaround for a race condition. When DRBD is doing its dance to

    # establish a connection with its peer, it also sends the

    # synchronization speed over the wire. In some cases setting the

    # sync speed only after setting up both sides can race with DRBD

    # connecting, hence we set it here before telling DRBD anything

    # about its peer.

    sync_errors = self._SetMinorSyncParams(minor, self.params)

    if sync_errors:

      base.ThrowError("drbd%d: can't set the synchronization parameters: %s" %

                      (minor, utils.CommaJoin(sync_errors)))

    family = self._GetNetFamily(minor, lhost, rhost)

    cmd = self._cmd_gen.GenNetInitCmd(minor, family, lhost, lport,

                                      rhost, rport, protocol,

                                      dual_pri, hmac, secret, self.params)

    result = utils.RunCmd(cmd)

    if result.failed:

      base.ThrowError("drbd%d: can't setup network: %s - %s",

                      minor, result.fail_reason, result.output)

    def _CheckNetworkConfig():

      info = self._GetShowInfo(minor)

      if not "local_addr" in info or not "remote_addr" in info:

        raise utils.RetryAgain()

      if (info["local_addr"] != (lhost, lport) or

          info["remote_addr"] != (rhost, rport)):

        raise utils.RetryAgain()

    try:

      utils.Retry(_CheckNetworkConfig, 1.0, 10.0)

    except utils.RetryTimeout:

      base.ThrowError("drbd%d: timeout while configuring network", minor)

    # Once the assembly is over, try to set the synchronization parameters

    try:

      # The minor may not have been set yet, requiring us to set it at least

      # temporarily

      old_minor = self.minor

      self._SetFromMinor(minor)

      sync_errors = self.SetSyncParams(self.params)

      if sync_errors:

        base.ThrowError("drbd%d: can't set the synchronization parameters: %s" %

                        (self.minor, utils.CommaJoin(sync_errors)))

    finally:

      # Undo the change, regardless of whether it will have to be done again

      # soon

      self._SetFromMinor(old_minor)

  @staticmethod

  def _GetNetFamily(minor, lhost, rhost):

    if netutils.IP6Address.IsValid(lhost):

      if not netutils.IP6Address.IsValid(rhost):

        base.ThrowError("drbd%d: can't connect ip %s to ip %s" %

                        (minor, lhost, rhost))

      return "ipv6"

    elif netutils.IP4Address.IsValid(lhost):

      if not netutils.IP4Address.IsValid(rhost):

        base.ThrowError("drbd%d: can't connect ip %s to ip %s" %

                        (minor, lhost, rhost))

      return "ipv4"

    else:

      base.ThrowError("drbd%d: Invalid ip %s" % (minor, lhost))

  def AddChildren(self, devices):

    """Add a disk to the DRBD device.

    @type devices: list of L{BlockDev}

    @param devices: a list of exactly two L{BlockDev} objects; the first

      denotes the data device, the second the meta device for this DRBD device

    """

    if self.minor is None:

      base.ThrowError("drbd%d: can't attach to dbrd8 during AddChildren",

                      self._aminor)

    if len(devices) != 2:

      base.ThrowError("drbd%d: need two devices for AddChildren", self.minor)

    info = self._GetShowInfo(self.minor)

    if "local_dev" in info:

      base.ThrowError("drbd%d: already attached to a local disk", self.minor)

    backend, meta = devices

    if backend.dev_path is None or meta.dev_path is None:

      base.ThrowError("drbd%d: children not ready during AddChildren",

                      self.minor)

    backend.Open()

    meta.Open()

    self._CheckMetaSize(meta.dev_path)

    self._InitMeta(DRBD8.FindUnusedMinor(), meta.dev_path)

    self._AssembleLocal(self.minor, backend.dev_path, meta.dev_path, self.size)

    self._children = devices

  def RemoveChildren(self, devices):

    """Detach the drbd device from local storage.

    @type devices: list of L{BlockDev}

    @param devices: a list of exactly two L{BlockDev} objects; the first

      denotes the data device, the second the meta device for this DRBD device

    """

    if self.minor is None:

      base.ThrowError("drbd%d: can't attach to drbd8 during RemoveChildren",

                      self._aminor)

    # early return if we don't actually have backing storage

    info = self._GetShowInfo(self.minor)

    if "local_dev" not in info:

      return

    if len(self._children) != 2:

      base.ThrowError("drbd%d: we don't have two children: %s", self.minor,

                      self._children)

    if self._children.count(None) == 2: # we don't actually have children :)

      logging.warning("drbd%d: requested detach while detached", self.minor)

      return

    if len(devices) != 2:

      base.ThrowError("drbd%d: we need two children in RemoveChildren",

                      self.minor)

    for child, dev in zip(self._children, devices):

      if dev != child.dev_path:

        base.ThrowError("drbd%d: mismatch in local storage (%s != %s) in"

                        " RemoveChildren", self.minor, dev, child.dev_path)

    self._ShutdownLocal(self.minor)

    self._children = []

  def _SetMinorSyncParams(self, minor, params):

    """Set the parameters of the DRBD syncer.

    This is the low-level implementation.

    @type minor: int

    @param minor: the drbd minor whose settings we change

    @type params: dict

    @param params: LD level disk parameters related to the synchronization

    @rtype: list

    @return: a list of error messages

    """

    cmd = self._cmd_gen.GenSyncParamsCmd(minor, params)

    result = utils.RunCmd(cmd)

    if result.failed:

      msg = ("Can't change syncer rate: %s - %s" %

             (result.fail_reason, result.output))

      logging.error(msg)

      return [msg]

    return []

  def SetSyncParams(self, params):

    """Set the synchronization parameters of the DRBD syncer.

    See L{BlockDev.SetSyncParams} for parameter description.

    """

    if self.minor is None:

      err = "Not attached during SetSyncParams"

      logging.info(err)

      return [err]

    children_result = super(DRBD8Dev, self).SetSyncParams(params)

    children_result.extend(self._SetMinorSyncParams(self.minor, params))

    return children_result

  def PauseResumeSync(self, pause):

    """Pauses or resumes the sync of a DRBD device.

    See L{BlockDev.PauseResumeSync} for parameter description.

    """

    if self.minor is None:

      logging.info("Not attached during PauseSync")

      return False

    children_result = super(DRBD8Dev, self).PauseResumeSync(pause)

    if pause:

      cmd = self._cmd_gen.GenPauseSyncCmd(self.minor)

    else:

      cmd = self._cmd_gen.GenResumeSyncCmd(self.minor)

    result = utils.RunCmd(cmd)

    if result.failed:

      logging.error("Can't %s: %s - %s", cmd,

                    result.fail_reason, result.output)

    return not result.failed and children_result

  def GetProcStatus(self):

    """Return the current status data from /proc/drbd for this device.

    @rtype: DRBD8Status

    """

    if self.minor is None:

      base.ThrowError("drbd%d: GetStats() called while not attached",

                      self._aminor)

    info = DRBD8.GetProcInfo()

    if not info.HasMinorStatus(self.minor):

      base.ThrowError("drbd%d: can't find myself in /proc", self.minor)

    return info.GetMinorStatus(self.minor)

  def GetSyncStatus(self):

    """Returns the sync status of the device.

    If sync_percent is None, it means all is ok

    If estimated_time is None, it means we can't estimate

    the time needed, otherwise it's the time left in seconds.

    We set the is_degraded parameter to True on two conditions:

    network not connected or local disk missing.

    We compute the ldisk parameter based on whether we have a local

    disk or not.

    @rtype: objects.BlockDevStatus

    """

    if self.minor is None and not self.Attach():

      base.ThrowError("drbd%d: can't Attach() in GetSyncStatus", self._aminor)

    stats = self.GetProcStatus()

    is_degraded = not stats.is_connected or not stats.is_disk_uptodate

    if stats.is_disk_uptodate:

      ldisk_status = constants.LDS_OKAY

    elif stats.is_diskless:

      ldisk_status = constants.LDS_FAULTY

    else:

      ldisk_status = constants.LDS_UNKNOWN

    return objects.BlockDevStatus(dev_path=self.dev_path,

                                  major=self.major,

                                  minor=self.minor,

                                  sync_percent=stats.sync_percent,

                                  estimated_time=stats.est_time,

                                  is_degraded=is_degraded,

                                  ldisk_status=ldisk_status)

  def Open(self, force=False):

    """Make the local state primary.

    If the 'force' parameter is given, DRBD is instructed to switch the device

    into primary mode. Since this is a potentially dangerous operation, the

    force flag should be only given after creation, when it actually is

    mandatory.

    """

    if self.minor is None and not self.Attach():

      logging.error("DRBD cannot attach to a device during open")

      return False

    cmd = self._cmd_gen.GenPrimaryCmd(self.minor, force)

    result = utils.RunCmd(cmd)

    if result.failed:

      base.ThrowError("drbd%d: can't make drbd device primary: %s", self.minor,

                      result.output)

  def Close(self):

    """Make the local state secondary.

    This will, of course, fail if the device is in use.

    """

    if self.minor is None and not self.Attach():

      base.ThrowError("drbd%d: can't Attach() in Close()", self._aminor)

    cmd = self._cmd_gen.GenSecondaryCmd(self.minor)

    result = utils.RunCmd(cmd)

    if result.failed:

      base.ThrowError("drbd%d: can't switch drbd device to secondary: %s",

                      self.minor, result.output)

  def DisconnectNet(self):

    """Removes network configuration.

    This method shutdowns the network side of the device.

    The method will wait up to a hardcoded timeout for the device to

    go into standalone after the 'disconnect' command before

    re-configuring it, as sometimes it takes a while for the

    disconnect to actually propagate and thus we might issue a 'net'

    command while the device is still connected. If the device will

    still be attached to the network and we time out, we raise an

    exception.

    """

    if self.minor is None:

      base.ThrowError("drbd%d: disk not attached in re-attach net",

                      self._aminor)

    if None in (self._lhost, self._lport, self._rhost, self._rport):

      base.ThrowError("drbd%d: DRBD disk missing network info in"

                      " DisconnectNet()", self.minor)

    class _DisconnectStatus:

      def __init__(self, ever_disconnected):

        self.ever_disconnected = ever_disconnected

    dstatus = _DisconnectStatus(base.IgnoreError(self._ShutdownNet, self.minor))

    def _WaitForDisconnect():

      if self.GetProcStatus().is_standalone:

        return

      # retry the disconnect, it seems possible that due to a well-time

      # disconnect on the peer, my disconnect command might be ignored and

      # forgotten

      dstatus.ever_disconnected = \

        base.IgnoreError(self._ShutdownNet, self.minor) or \

        dstatus.ever_disconnected

      raise utils.RetryAgain()

    # Keep start time

    start_time = time.time()

    try: