Synnefo » snf-ganeti

    for disk_idx in self.op.disks:

      if disk_idx < 0 or disk_idx >= len(instance.disks):

        raise errors.OpPrereqError("Disk '%s' not found for instance '%s'" %

  def _ExecD8DiskOnly(self, feedback_fn):

    """Replace a disk on the primary or secondary for dbrd8.

      if not res or my_vg not in res:

        raise errors.OpExecError("Volume group '%s' not found on %s" %

                                 (my_vg, node))

        continue

      cfg.SetDiskID(dev, pri_node)

      if not self.rpc.call_blockdev_find(pri_node, dev):

    # Step: check other node consistency

    self.proc.LogStep(2, steps_total, "check peer consistency")

        continue

      if not _CheckDiskConsistency(self, dev, pri_node, True, ldisk=True):

        raise errors.OpExecError("Primary node (%s) has degraded storage,"

                                 " unsafe to replace the secondary" %

    # Step: create new storage

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

      size = dev.size

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

      # _Create...OnPrimary (which forces the creation), even if we

      # are talking about the secondary node

                                   " node '%s'" %

                                   (new_lv.logical_id[1], new_node))

    # Step 4: dbrd minors and drbd setups changes

    # after this, we must manually remove the drbd minors on both the

    # error and the success paths

                                   instance.name)

    logging.debug("Allocated minors %s" % (minors,))

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

      size = dev.size

      # create new devices on new_node

      if pri_node == dev.logical_id[0]:

        new_logical_id = (pri_node, new_node,

        new_logical_id = (new_node, pri_node,

                          dev.logical_id[2], new_minor, dev.logical_id[4],

                          dev.logical_id[5])

      logging.debug("Allocated new_minor: %s, new_logical_id: %s", new_minor,

                    new_logical_id)

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

        raise errors.OpExecError("Failed to create new DRBD on"

                                 " node '%s'" % new_node)

      # we have new devices, shutdown the drbd on the old secondary

      cfg.SetDiskID(dev, old_node)

      if not self.rpc.call_blockdev_shutdown(old_node, dev):

                hint="Please cleanup this device manually as soon as possible")

    info("detaching primary drbds from the network (=> standalone)")

    done = 0

      cfg.SetDiskID(dev, pri_node)

      # set the network part of the physical (unique in bdev terms) id

      # to None, meaning detach from network

      if self.rpc.call_blockdev_find(pri_node, dev):

        done += 1

      else:

    if not done:

      # no detaches succeeded (very unlikely)

    # and now perform the drbd attach

    info("attaching primary drbds to new secondary (standalone => connected)")

    failures = []

      # since the attach is smart, it's enough to 'find' the device,

      # it will automatically activate the network, if the physical_id

      # is correct

      cfg.SetDiskID(dev, pri_node)

      logging.debug("Disk to attach: %s", dev)

      if not self.rpc.call_blockdev_find(pri_node, dev):

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

    # this can fail as the old devices are degraded and _WaitForSync

    _WaitForSync(self, instance, unlock=True)

    # so check manually all the devices

      cfg.SetDiskID(dev, pri_node)

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

      if is_degr:

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

      for lv in old_lvs:

        cfg.SetDiskID(lv, old_node)

        if not self.rpc.call_blockdev_remove(old_node, lv):