Synnefo » snf-ganeti

  return not cumul_degraded

  """Check that mirrors are not degraded.

  The ldisk parameter, if True, will change the test from the

  if dev.children:

    for child in dev.children:

  return result

        node_disk = node_disk.Copy()

        node_disk.UnsetSize()

      lu.cfg.SetDiskID(node_disk, node)

      msg = result.fail_msg

      if msg:

        lu.proc.LogWarning("Could not prepare block device %s on node %s"

        node_disk = node_disk.Copy()

        node_disk.UnsetSize()

      lu.cfg.SetDiskID(node_disk, node)

      msg = result.fail_msg

      if msg:

        lu.proc.LogWarning("Could not prepare block device %s on node %s"

    # activate, get path, copy the data over

    for idx, disk in enumerate(instance.disks):

      self.LogInfo("Copying data for disk %d", idx)

                                               instance.name, True, idx)

      if result.fail_msg:

        self.LogWarning("Can't assemble newly created disk %d: %s",

        errs.append(result.fail_msg)

        break

      dev_path = result.payload

                                             target_node, dev_path,

                                             cluster_name)

      if result.fail_msg:

      all_done = True

      result = self.rpc.call_drbd_wait_sync(self.all_nodes,

                                            self.nodes_ip,

      min_percent = 100

      for node, nres in result.items():

        nres.Raise("Cannot resync disks on node %s" % node)

      msg = "single-master"

    self.feedback_fn("* changing disks into %s mode" % msg)

    result = self.rpc.call_drbd_attach_net(self.all_nodes, self.nodes_ip,

                                           self.instance.name, multimaster)

    for node, nres in result.items():

      nres.Raise("Cannot change disks config on node %s" % node)

    self.feedback_fn("* checking disk consistency between source and target")

    for (idx, dev) in enumerate(instance.disks):

        raise errors.OpExecError("Disk %s is degraded or not fully"

                                 " synchronized on target node,"

                                 " aborting migration" % idx)

      self.feedback_fn("* checking disk consistency between source and target")

      for (idx, dev) in enumerate(instance.disks):

        # for drbd, these are drbd over lvm

          if primary_node.offline:

            self.feedback_fn("Node %s is offline, ignoring degraded disk %s on"

                             " target node %s" %

    lu.cfg.SetDiskID(device, node)

  logging.info("Pause sync of instance %s disks", instance.name)

  for idx, success in enumerate(result.payload):

    if not success:

        wipe_size = min(wipe_chunk_size, size - offset)

        logging.debug("Wiping disk %d, offset %s, chunk %s",

                      idx, offset, wipe_size)

        result.Raise("Could not wipe disk %d at offset %d for size %d" %

                     (idx, offset, wipe_size))

        now = time.time()

  finally:

    logging.info("Resume sync of instance %s disks", instance.name)

    for idx, success in enumerate(result.payload):

      if not success:

          if pause_sync:

            feedback_fn("* pausing disk sync to install instance OS")

            result = self.rpc.call_blockdev_pause_resume_sync(pnode_name,

            for idx, success in enumerate(result.payload):

              if not success:

                logging.warn("pause-sync of instance %s for disk %d failed",

          if pause_sync:

            feedback_fn("* resuming disk sync")

            result = self.rpc.call_blockdev_pause_resume_sync(pnode_name,

            for idx, success in enumerate(result.payload):

              if not success:

                logging.warn("resume-sync of instance %s for disk %d failed",

      self.lu.LogInfo("Checking disk/%d consistency on node %s" %

                      (idx, node_name))

        raise errors.OpExecError("Node %s has degraded storage, unsafe to"

                                 " replace disks for instance %s" %

                                 (node_name, self.instance.name))

      # Now that the new lvs have the old name, we can add them to the device

      self.lu.LogInfo("Adding new mirror component on %s" % self.target_node)

      msg = result.fail_msg

      if msg:

        for new_lv in new_lvs:

    result = self.rpc.call_drbd_attach_net([self.instance.primary_node,

                                            self.new_node],

                                           self.node_secondary_ip,

                                           self.instance.name,

                                           False)

    for to_node, to_result in result.items():

    # First run all grow ops in dry-run mode

    for node in instance.all_nodes:

      self.cfg.SetDiskID(disk, node)

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

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

    # nodes will succeed, time to run it for real

    for node in instance.all_nodes:

      self.cfg.SetDiskID(disk, node)

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

      # TODO: Rewrite code to work properly

    self.wanted_instances = instances.values()

    """Returns the status of a block device

    """

    if result.offline:

      return None

    status = result.payload

    if status is None:

        snode = dev.logical_id[0]

    dev_pstatus = self._ComputeBlockdevStatus(instance.primary_node,

    if dev.children:

      dev_children = map(compat.partial(self._ComputeDiskStatus,

      # result.payload will be a snapshot of an lvm leaf of the one we

      # passed

      new_dev = False

      msg = result.fail_msg

      if msg: