Synnefo » snf-ganeti

import errno

import pyparsing as pyp

import os

from ganeti import utils

from ganeti import errors

from ganeti import constants

               "--separator=:"]

    result = utils.RunCmd(command)

    if result.failed:

      return None

    data = []

    for line in result.stdout.splitlines():

      fields = line.strip().split(':')

      if len(fields) != 4:

        return None

      # skip over pvs from another vg or ones which are not allocatable

      if fields[1] != vg_name or fields[3][0] != 'a':

    result = utils.RunCmd(["lvremove", "-f", "%s/%s" %

                           (self._vg_name, self._lv_name)])

    if result.failed:

    return not result.failed

                           "-olv_attr,lv_kernel_major,lv_kernel_minor",

                           self.dev_path])

    if result.failed:

      return False

    out = result.stdout.strip().rstrip(',')

    out = out.split(",")

    if len(out) != 3:

      return False

    status, major, minor = out[:3]

    if len(status) != 6:

      return False

    try:

      major = int(major)

      minor = int(minor)

    except ValueError, err:

    self.major = major

    self.minor = minor

    """

    result = utils.RunCmd(["lvchange", "-ay", self.dev_path])

    if result.failed:

    return not result.failed

  def Shutdown(self):

    """

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

    if result.failed:

      return False

    try:

      sectors = int(result.stdout)

    except ValueError:

      return False

    bytes = sectors * 512

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

      return False

    if bytes > (128 + 32) * 1024 * 1024: # account for an extra (big) PE on LVM

      return False

    return True

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

      return 0

    if highest >= cls._MAX_MINORS:

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

    return highest + 1

                           "v08", meta_device, "0",

                           "dstate"])

    if result.failed:

      return False

    return True

    """

    result = utils.RunCmd(["drbdsetup", cls._DevPath(minor), "show"])

    if result.failed:

      return None

    return result.stdout

            backend, meta, "0", "-e", "detach", "--create-device"]

    result = utils.RunCmd(args)

    if result.failed:

    return not result.failed

  @classmethod

      args.extend(["-a", hmac, "-x", secret])

    result = utils.RunCmd(args)

    if result.failed:

      return False

    timeout = time.time() + 10

      ok = True

      break

    if not ok:

      return False

    return True

      raise errors.BlockDeviceError("We don't have two children: %s" %

                                    self._children)

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

      return

    if len(devices) != 2:

      raise errors.BlockDeviceError("We need two children in RemoveChildren")

    """

    children_result = super(DRBD8, self).SetSyncSpeed(kbytes)

    if self.minor is None:

      return False

    result = utils.RunCmd(["drbdsetup", self.dev_path, "syncer", "-r", "%d" %

                           kbytes])

    if result.failed:

    return not result.failed and children_result

  def GetProcStatus(self):

    """

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

      return False

    cmd = ["drbdsetup", self.dev_path, "primary"]

    if force:

    result = utils.RunCmd(cmd)

    if result.failed:

      msg = ("Can't make drbd device primary: %s" % result.output)

      raise errors.BlockDeviceError(msg)

  def Close(self):

    """

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

      raise errors.BlockDeviceError("Can't find device")

    result = utils.RunCmd(["drbdsetup", self.dev_path, "secondary"])

    if result.failed:

      msg = ("Can't switch drbd device to"

             " secondary: %s" % result.output)

      raise errors.BlockDeviceError(msg)

  def Attach(self):

    """

    self.Attach()

    if self.minor is not None:

      return True

    result = super(DRBD8, self).Assemble()

      if not result:

        if need_localdev_teardown:

          # we will ignore failures from this

          self._ShutdownAll(minor)

        return False

    self._SetFromMinor(minor)

    """

    result = utils.RunCmd(["drbdsetup", cls._DevPath(minor), "detach"])

    if result.failed:

    return not result.failed

  @classmethod

    """

    result = utils.RunCmd(["drbdsetup", cls._DevPath(minor), "disconnect"])

    if result.failed:

    return not result.failed

  @classmethod

    """

    result = utils.RunCmd(["drbdsetup", cls._DevPath(minor), "down"])

    if result.failed:

    return not result.failed

  def Shutdown(self):

    """

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

      return True

    if not self._ShutdownAll(self.minor):

      return False

      os.remove(self.dev_path)

      return True

    except OSError, err:

      return False

  def Attach(self):