Synnefo » snf-ganeti

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

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

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

    self.Attach()

  @classmethod

import tempfile

import re

import platform

from ganeti import rpc

from ganeti import ssh

  return results

  """Generate a drbd8 device complete with its children.

  """

  dev_meta = objects.Disk(dev_type=constants.LD_LV, size=128,

                          logical_id=(vgname, names[1]))

  drbd_dev = objects.Disk(dev_type=constants.LD_DRBD8, size=size,

                          iv_name=iv_name)

  return drbd_dev

    if len(secondary_nodes) != 1:

      raise errors.ProgrammerError("Wrong template configuration")

    remote_node = secondary_nodes[0]

    names = _GenerateUniqueNames(cfg, [".sda_data", ".sda_meta",

                                       ".sdb_data", ".sdb_meta"])

    drbd_sda_dev = _GenerateDRBD8Branch(cfg, primary_node, remote_node,

    drbd_sdb_dev = _GenerateDRBD8Branch(cfg, primary_node, remote_node,

    disks = [drbd_sda_dev, drbd_sdb_dev]

  elif template_name == constants.DT_FILE:

    if len(secondary_nodes) != 0:

                                 pri_node)

    # Step: create new storage

    self.proc.LogStep(3, steps_total, "allocate new storage")

      size = dev.size

      info("adding new local storage on %s for %s" % (new_node, dev.iv_name))

      # since we *always* want to create this LV, we use the

                                   " node '%s'" %

                                   (new_lv.logical_id[1], new_node))

    self.proc.LogStep(4, steps_total, "changing drbd configuration")

    for dev in instance.disks:

      size = dev.size

      info("activating a new drbd on %s for %s" % (new_node, dev.iv_name))

      # create new devices on new_node

      new_drbd = objects.Disk(dev_type=constants.LD_DRBD8,

                              children=dev.children)

      if not _CreateBlockDevOnSecondary(cfg, new_node, instance,

                                        new_drbd, False,

      cfg.SetDiskID(dev, pri_node)

      # set the physical (unique in bdev terms) id to None, meaning

      # detach from network

      # and 'find' the device, which will 'fix' it to match the

      # standalone state

      if rpc.call_blockdev_find(pri_node, dev):

      # it will automatically activate the network, if the physical_id

      # is correct

      cfg.SetDiskID(dev, pri_node)

      if not rpc.call_blockdev_find(pri_node, dev):

        warning("can't attach drbd %s to new secondary!" % dev.iv_name,

                "please do a gnt-instance info to see the status of disks")

    _WaitForSync(cfg, instance, self.proc, unlock=True)

    # so check manually all the devices

      cfg.SetDiskID(dev, pri_node)

      is_degr = rpc.call_blockdev_find(pri_node, dev)[5]

      if is_degr:

        raise errors.OpExecError("DRBD device %s is degraded!" % name)

    self.proc.LogStep(6, steps_total, "removing old storage")

      info("remove logical volumes for %s" % name)

      for lv in old_lvs:

        cfg.SetDiskID(lv, old_node)

    if disk.logical_id is None and disk.physical_id is not None:

      return

      if node_name not in (pnode, snode):

        raise errors.ConfigurationError("DRBD device not knowing node %s" %

                                        node_name)

      if pnode_info is None or snode_info is None:

        raise errors.ConfigurationError("Can't find primary or secondary node"

                                        " for %s" % str(disk))

      if pnode == node_name:

      else: # it must be secondary, we tested above

    else:

      disk.physical_id = disk.logical_id

    return

    if self.logical_id is None and self.physical_id is not None:

      return

    if self.dev_type in constants.LDS_DRBD:

      if target_node not in (pnode, snode):

        raise errors.ConfigurationError("DRBD device not knowing node %s" %

                                        target_node)

      if pnode_ip is None or snode_ip is None:

        raise errors.ConfigurationError("Can't find primary or secondary node"

                                        " for %s" % str(self))

      if pnode == target_node:

      else: # it must be secondary, we tested above

    else:

      self.physical_id = self.logical_id

    return

      obj.logical_id = tuple(obj.logical_id)

    if obj.physical_id and isinstance(obj.physical_id, list):

      obj.physical_id = tuple(obj.physical_id)

    return obj

  def __str__(self):

    def _Helper(primary, sec_nodes, device):

      """Recursively computes secondary nodes given a top device."""

      if device.dev_type in constants.LDS_DRBD:

        if nodea == primary:

          candidate = nodeb

        else: