Synnefo » snf-ganeti

import stat

class PersistentBlockDevice(BlockDev):

  """A block device with persistent node

  May be either directly attached, or exposed through DM (e.g. dm-multipath).

  udev helpers are probably required to give persistent, human-friendly

  names.

  For the time being, pathnames are required to lie under /dev.

  """

  def __init__(self, unique_id, children, size):

    """Attaches to a static block device.

    The unique_id is a path under /dev.

    """

    super(PersistentBlockDevice, self).__init__(unique_id, children, size)

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

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

    self.dev_path = unique_id[1]

    if not os.path.realpath(self.dev_path).startswith('/dev/'):

      raise ValueError("Full path '%s' lies outside /dev" %

                              os.path.realpath(self.dev_path))

    # TODO: this is just a safety guard checking that we only deal with devices

    # we know how to handle. In the future this will be integrated with

    # external storage backends and possible values will probably be collected

    # from the cluster configuration.

    if unique_id[0] != constants.BLOCKDEV_DRIVER_MANUAL:

      raise ValueError("Got persistent block device of invalid type: %s" %

                       unique_id[0])

    self.major = self.minor = None

    self.Attach()

  @classmethod

  def Create(cls, unique_id, children, size):

    """Create a new device

    This is a noop, we only return a PersistentBlockDevice instance

    """

    return PersistentBlockDevice(unique_id, children, 0)

  def Remove(self):

    """Remove a device

    This is a noop

    """

    pass

  def Rename(self, new_id):

    """Rename this device.

    """

    _ThrowError("Rename is not supported for PersistentBlockDev storage")

  def Attach(self):

    """Attach to an existing block device.

    """

    self.attached = False

    try:

      st = os.stat(self.dev_path)

    except OSError, err:

      logging.error("Error stat()'ing %s: %s", self.dev_path, str(err))

      return False

    if not stat.S_ISBLK(st.st_mode):

      logging.error("%s is not a block device", self.dev_path)

      return False

    self.major = os.major(st.st_rdev)

    self.minor = os.minor(st.st_rdev)

    self.attached = True

    return True

  def Assemble(self):

    """Assemble the device.

    """

    pass

  def Shutdown(self):

    """Shutdown the device.

    """

    pass

  def Open(self, force=False):

    """Make the device ready for I/O.

    """

    pass

  def Close(self):

    """Notifies that the device will no longer be used for I/O.

    """

    pass

  def Grow(self, amount):

    """Grow the logical volume.

    """

    _ThrowError("Grow is not supported for PersistentBlockDev storage")

  constants.LD_BLOCKDEV: PersistentBlockDevice,

  elif template_name == constants.DT_BLOCK:

    if len(secondary_nodes) != 0:

      raise errors.ProgrammerError("Wrong template configuration")

    for idx, disk in enumerate(disk_info):

      disk_index = idx + base_index

      disk_dev = objects.Disk(dev_type=constants.LD_BLOCKDEV, size=disk["size"],

                              logical_id=(constants.BLOCKDEV_DRIVER_MANUAL,

                                          disk["adopt"]),

                              iv_name="disk/%d" % disk_index,

                              mode=disk["mode"])

      disks.append(disk_dev)

    constants.DT_BLOCK: 0,

    else:

      if self.op.disk_template in constants.DTS_MUST_ADOPT:

        raise errors.OpPrereqError("Disk template %s requires disk adoption,"

                                   " but no 'adopt' parameter given" %

                                   self.op.disk_template,

                                   errors.ECODE_INVAL)

    elif self.op.disk_template == constants.DT_PLAIN: # Check the adoption data

    elif self.op.disk_template == constants.DT_BLOCK:

      # Normalize and de-duplicate device paths

      all_disks = set([os.path.abspath(i["adopt"]) for i in self.disks])

      if len(all_disks) != len(self.disks):

        raise errors.OpPrereqError("Duplicate disk names given for adoption",

                                   errors.ECODE_INVAL)

      baddisks = [d for d in all_disks

                  if not d.startswith(constants.ADOPTABLE_BLOCKDEV_ROOT)]

      if baddisks:

        raise errors.OpPrereqError("Device node(s) %s lie outside %s and"

                                   " cannot be adopted" %

                                   (", ".join(baddisks),

                                    constants.ADOPTABLE_BLOCKDEV_ROOT),

                                   errors.ECODE_INVAL)

      node_disks = self.rpc.call_bdev_sizes([pnode.name],

                                            list(all_disks))[pnode.name]

      node_disks.Raise("Cannot get block device information from node %s" %

                       pnode.name)

      node_disks = node_disks.payload

      delta = all_disks.difference(node_disks.keys())

      if delta:

        raise errors.OpPrereqError("Missing block device(s): %s" %

                                   utils.CommaJoin(delta),

                                   errors.ECODE_INVAL)

      for dsk in self.disks:

        dsk["size"] = int(float(node_disks[dsk["adopt"]]))

      if self.op.disk_template == constants.DT_PLAIN:

        # rename LVs to the newly-generated names; we need to construct

        # 'fake' LV disks with the old data, plus the new unique_id

        tmp_disks = [objects.Disk.FromDict(v.ToDict()) for v in disks]

        rename_to = []

        for t_dsk, a_dsk in zip (tmp_disks, self.disks):

          rename_to.append(t_dsk.logical_id)

          t_dsk.logical_id = (t_dsk.logical_id[0], a_dsk["adopt"])

          self.cfg.SetDiskID(t_dsk, pnode_name)

        result = self.rpc.call_blockdev_rename(pnode_name,

                                               zip(tmp_disks, rename_to))

        result.Raise("Failed to rename adoped LVs")

ADOPTABLE_BLOCKDEV_ROOT = "/dev/disk/"

DT_BLOCK = "blockdev"

# the set of externally-mirrored disk templates (e.g. SAN, NAS)

DTS_EXT_MIRROR = frozenset([DT_SHARED_FILE, DT_BLOCK])

DTS_NOT_LVM = frozenset([DT_DISKLESS, DT_FILE, DT_SHARED_FILE, DT_BLOCK])

DTS_MAY_ADOPT = frozenset([DT_PLAIN, DT_BLOCK])

# the set of disk templates that *must* use adoption

DTS_MUST_ADOPT = frozenset([DT_BLOCK])

LD_BLOCKDEV = "blockdev"

LDS_BLOCK = frozenset([LD_LV, LD_DRBD8, LD_BLOCKDEV])

                            DT_FILE, DT_SHARED_FILE, DT_BLOCK])

# Temporary external/shared storage parameters

BLOCKDEV_DRIVER_MANUAL = "manual"

    elif self.dev_type == constants.LD_BLOCKDEV:

      return self.logical_id[1]

    if self.dev_type in [constants.LD_LV, constants.LD_FILE,

                         constants.LD_BLOCKDEV]: