Synnefo » snf-ganeti » ganeti-local

from ganeti.cmdlib.common import _AnnotateDiskParams

def _StartInstanceDisks(lu, instance, force):

  """Start the disks of an instance.

  """

  disks_ok, _ = _AssembleInstanceDisks(lu, instance,

                                           ignore_secondaries=force)

  if not disks_ok:

    _ShutdownInstanceDisks(lu, instance)

    if force is not None and not force:

      lu.LogWarning("",

                    hint=("If the message above refers to a secondary node,"

                          " you can retry the operation using '--force'"))

    raise errors.OpExecError("Disk consistency error")

def _ShutdownInstanceDisks(lu, instance, disks=None, ignore_primary=False):

  """Shutdown block devices of an instance.

  This does the shutdown on all nodes of the instance.

  If the ignore_primary is false, errors on the primary node are

  ignored.

  all_result = True

  disks = _ExpandCheckDisks(instance, disks)

  for disk in disks:

    for node, top_disk in disk.ComputeNodeTree(instance.primary_node):

      lu.cfg.SetDiskID(top_disk, node)

      result = lu.rpc.call_blockdev_shutdown(node, (top_disk, instance))

      msg = result.fail_msg

      if msg:

        lu.LogWarning("Could not shutdown block device %s on node %s: %s",

                      disk.iv_name, node, msg)

        if ((node == instance.primary_node and not ignore_primary) or

            (node != instance.primary_node and not result.offline)):

          all_result = False

  return all_result

def _AssembleInstanceDisks(lu, instance, disks=None, ignore_secondaries=False,

                           ignore_size=False):

  """Prepare the block devices for an instance.

  This sets up the block devices on all nodes.

  @type lu: L{LogicalUnit}

  @param lu: the logical unit on whose behalf we execute

  @type instance: L{objects.Instance}

  @param instance: the instance for whose disks we assemble

  @type disks: list of L{objects.Disk} or None

  @param disks: which disks to assemble (or all, if None)

  @type ignore_secondaries: boolean

  @param ignore_secondaries: if true, errors on secondary nodes

      won't result in an error return from the function

  @type ignore_size: boolean

  @param ignore_size: if true, the current known size of the disk

      will not be used during the disk activation, useful for cases

      when the size is wrong

  @return: False if the operation failed, otherwise a list of

      (host, instance_visible_name, node_visible_name)

      with the mapping from node devices to instance devices

  """

  device_info = []

  disks_ok = True

  iname = instance.name

  disks = _ExpandCheckDisks(instance, disks)

  # With the two passes mechanism we try to reduce the window of

  # opportunity for the race condition of switching DRBD to primary

  # before handshaking occured, but we do not eliminate it

  # The proper fix would be to wait (with some limits) until the

  # connection has been made and drbd transitions from WFConnection

  # into any other network-connected state (Connected, SyncTarget,

  # SyncSource, etc.)

  # 1st pass, assemble on all nodes in secondary mode

  for idx, inst_disk in enumerate(disks):

    for node, node_disk in inst_disk.ComputeNodeTree(instance.primary_node):

      if ignore_size:

        node_disk = node_disk.Copy()

        node_disk.UnsetSize()

      lu.cfg.SetDiskID(node_disk, node)

      result = lu.rpc.call_blockdev_assemble(node, (node_disk, instance), iname,

                                             False, idx)

      msg = result.fail_msg

      if msg:

        is_offline_secondary = (node in instance.secondary_nodes and

                                result.offline)

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

                      " (is_primary=False, pass=1): %s",

                      inst_disk.iv_name, node, msg)

        if not (ignore_secondaries or is_offline_secondary):

          disks_ok = False

  # FIXME: race condition on drbd migration to primary

  # 2nd pass, do only the primary node

  for idx, inst_disk in enumerate(disks):

    dev_path = None

    for node, node_disk in inst_disk.ComputeNodeTree(instance.primary_node):

      if node != instance.primary_node:

        continue

      if ignore_size:

        node_disk = node_disk.Copy()

        node_disk.UnsetSize()

      lu.cfg.SetDiskID(node_disk, node)

      result = lu.rpc.call_blockdev_assemble(node, (node_disk, instance), iname,

                                             True, idx)

      msg = result.fail_msg

      if msg:

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

                      " (is_primary=True, pass=2): %s",

                      inst_disk.iv_name, node, msg)

        disks_ok = False

      else:

        dev_path = result.payload

    device_info.append((instance.primary_node, inst_disk.iv_name, dev_path))

  # leave the disks configured for the primary node

  # this is a workaround that would be fixed better by

  # improving the logical/physical id handling

  for disk in disks:

    lu.cfg.SetDiskID(disk, instance.primary_node)

  return disks_ok, device_info

def _ExpandCheckDisks(instance, disks):

  """Return the instance disks selected by the disks list

  @type disks: list of L{objects.Disk} or None

  @param disks: selected disks

  @rtype: list of L{objects.Disk}

  @return: selected instance disks to act on

  """

  if disks is None:

    return instance.disks

  else:

    if not set(disks).issubset(instance.disks):

      raise errors.ProgrammerError("Can only act on disks belonging to the"

                                   " target instance")

    return disks