Synnefo » snf-ganeti

    """Recreate the disks.

    """

    assert (self.owned_locks(locking.LEVEL_NODE) ==

            self.owned_locks(locking.LEVEL_NODE_RES))

    to_skip = []

    mods = [] # keeps track of needed changes

      try:

        changes = self.disks[idx]

      except KeyError:

                                         # have changed

        (_, _, old_port, _, _, old_secret) = disk.logical_id

        new_minors = self.cfg.AllocateDRBDMinor(self.op.node_uuids,

        new_id = (self.op.node_uuids[0], self.op.node_uuids[1], old_port,

                  new_minors[0], new_minors[1], old_secret)

        assert len(disk.logical_id) == len(new_id)

    # now that we have passed all asserts above, we can apply the mods

    # in a single run (to avoid partial changes)

    for idx, new_id, changes in mods:

      if new_id is not None:

        assert disk.dev_type == constants.LD_DRBD8

        disk.logical_id = new_id

    # change primary node, if needed

    if self.op.node_uuids:

      self.LogWarning("Changing the instance's nodes, you will have to"

                      " remove any disks left on the older nodes manually")

    if self.op.node_uuids:

    # All touched nodes must be locked

    mylocks = self.owned_locks(locking.LEVEL_NODE)

    # TODO: Release node locks before wiping, or explain why it's not possible

    if self.cfg.GetClusterInfo().prealloc_wipe_disks:

      wipedisks = [(idx, disk, 0)

                   if idx not in to_skip]

def _CheckNodesFreeDiskOnVG(lu, node_uuids, vg, requested):

    """Execute disk grow.

    """

    assert (self.owned_locks(locking.LEVEL_NODE) ==

            self.owned_locks(locking.LEVEL_NODE_RES))

    wipe_disks = self.cfg.GetClusterInfo().prealloc_wipe_disks

    if not disks_ok:

      raise errors.OpExecError("Cannot activate block device to grow")

    feedback_fn("Growing disk %s of instance '%s' by %s to %s" %

                 utils.FormatUnit(self.delta, "h"),

                 utils.FormatUnit(self.target, "h")))

    # First run all grow ops in dry-run mode

                                           self.delta, True, True)

      result.Raise("Dry-run grow request failed to node %s" %

                   self.cfg.GetNodeName(node_uuid))

    if wipe_disks:

      # Get disk size from primary node for wiping

      result.Raise("Failed to retrieve disk size from node '%s'" %

      (disk_dimensions, ) = result.payload

      if disk_dimensions is None:

        raise errors.OpExecError("Failed to retrieve disk size from primary"

      (disk_size_in_bytes, _) = disk_dimensions

      old_disk_size = _DiskSizeInBytesToMebibytes(self, disk_size_in_bytes)

        ("Retrieved disk size too small (got %s, should be at least %s)" %

    else:

      old_disk_size = None

    # We know that (as far as we can test) operations across different

    # nodes will succeed, time to run it for real on the backing storage

                                           self.delta, False, True)

      result.Raise("Grow request failed to node %s" %

                   self.cfg.GetNodeName(node_uuid))

    # And now execute it for logical storage, on the primary node

                                         self.delta, False, False)

    result.Raise("Grow request failed to node %s" %

                 self.cfg.GetNodeName(node_uuid))

    # Changes have been recorded, release node lock

    ReleaseLocks(self, locking.LEVEL_NODE)

    assert wipe_disks ^ (old_disk_size is None)

    if wipe_disks:

      # Wipe newly added disk space

    if self.op.wait_for_sync:

      if disk_abort:

        self.LogWarning("Disk syncing has not returned a good status; check"

                        " the instance")

      self.LogWarning("Not shutting down the disk even if the instance is"

                      " not supposed to be running because no wait for"

                      " sync mode was requested")

    assert self.owned_locks(locking.LEVEL_NODE_RES)

class LUInstanceReplaceDisks(LogicalUnit):

    """Check arguments.

    """

    if self.op.mode == constants.REPLACE_DISK_CHG:

        raise errors.OpPrereqError("When changing the secondary either an"

                                   " iallocator script must be used or the"

                                   " new node given", errors.ECODE_INVAL)

      else:

        CheckIAllocatorOrNode(self, "iallocator", "remote_node")

      # Not replacing the secondary

      raise errors.OpPrereqError("The iallocator and new node options can"

                                 " only be used when changing the"

    """Deactivate the disks

    """

    if self.op.force:

    else:

def _CheckDiskConsistencyInner(lu, instance, dev, node_uuid, on_primary,

    This checks that the instance is in the cluster.

    """

      "Cannot retrieve locked instance %s" % self.instance_name

      raise errors.OpPrereqError("Can only run replace disks for DRBD8-based"

                                 " instances", errors.ECODE_INVAL)

      raise errors.OpPrereqError("The instance has a strange layout,"

                                 " expected one secondary but found %d" %

                                 errors.ECODE_FAULT)

    if self.iallocator_name is None:

      remote_node_uuid = self.remote_node_uuid

    else:

      remote_node_uuid = self._RunAllocator(self.lu, self.iallocator_name,

    if remote_node_uuid is None:

      self.remote_node_info = None

                                 errors.ECODE_INVAL)

    if self.mode == constants.REPLACE_DISK_AUTO:

        raise errors.OpPrereqError("Please run activate-disks on instance %s"

                                   " first" % self.instance_name,

                                   errors.ECODE_STATE)

      faulty_secondary = self._FindFaultyDisks(secondary_node_uuid)

      if faulty_primary and faulty_secondary:

      if faulty_primary:

        self.disks = faulty_primary

        self.other_node_uuid = secondary_node_uuid

        check_nodes = [self.target_node_uuid, self.other_node_uuid]

      elif faulty_secondary:

        self.disks = faulty_secondary

        self.target_node_uuid = secondary_node_uuid

        check_nodes = [self.target_node_uuid, self.other_node_uuid]

      else:

        self.disks = []

    else:

      # Non-automatic modes

      if self.mode == constants.REPLACE_DISK_PRI:

        self.other_node_uuid = secondary_node_uuid

        check_nodes = [self.target_node_uuid, self.other_node_uuid]

      elif self.mode == constants.REPLACE_DISK_SEC:

        self.target_node_uuid = secondary_node_uuid

        check_nodes = [self.target_node_uuid, self.other_node_uuid]

      elif self.mode == constants.REPLACE_DISK_CHG:

        self.new_node_uuid = remote_node_uuid

        self.target_node_uuid = secondary_node_uuid

        check_nodes = [self.new_node_uuid, self.other_node_uuid]

      cluster = self.cfg.GetClusterInfo()

      ipolicy = ganeti.masterd.instance.CalculateGroupIPolicy(cluster,

                                                              new_group_info)

    for node_uuid in check_nodes:

      CheckNodeOnline(self.lu, node_uuid)

    # Check whether disks are valid

    for disk_idx in self.disks:

    # Get secondary node IP addresses

    self.node_secondary_ip = dict((uuid, node.secondary_ip) for (uuid, node)