Synnefo » snf-ganeti » ganeti-local

from ganeti import rpc

from ganeti.cmdlib.base import LogicalUnit, NoHooksLU, Tasklet

from ganeti.cmdlib.common import INSTANCE_DOWN, INSTANCE_NOT_RUNNING, \

import ganeti.masterd.instance

  }

  """Create a single block device on a given node.

  This will not recurse over children of the device, so they must be

    if not force_create:

      return created_devices

    # The device has been completely created, so there is no point in keeping

    # its subdevices in the list. We just add the device itself instead.

    created_devices = [(node, device)]

    raise errors.DeviceCreationError(str(e), created_devices)

  """Whether exclusive_storage is in effect for the given node.

  @type cfg: L{config.ConfigWriter}

  if ni is None:

    raise errors.OpPrereqError("Invalid node name %s" % nodename,

                               errors.ECODE_NOENT)

                    force_open):

  """Wrapper around L{_CreateBlockDevInner}.

  This method annotates the root device first.

  """

  return _CreateBlockDevInner(lu, node, instance, disk, force_create, info,

                              force_open, excl_stor)

  """Create all disks for an instance.

  This abstracts away some work from AddInstance.

  @return: the success of the creation

  """

  if target_node is None:

    pnode = instance.primary_node

    all_nodes = instance.all_nodes

    for node in all_nodes:

      f_create = node == pnode

      try:

        disks_created.append((node, device))

      except errors.OpExecError:

        logging.warning("Creating disk %s for instance '%s' failed",

        raise errors.OpExecError(e.message)

  """Compute disk size requirements in the volume group

  """

  return req_size_dict[disk_template]

  """Computes the instance disks.

  @param op: The instance opcode

  return disks

  """Compute disk size requirements inside the RADOS cluster.

  """

  return drbd_dev

  lu, template_name, instance_name, primary_node, secondary_nodes,

  disk_info, file_storage_dir, file_driver, base_index,

  feedback_fn, full_disk_params, _req_file_storage=opcodes.RequireFileStorage,

    # We don't want _CheckIAllocatorOrNode selecting the default iallocator

    # when neither iallocator nor nodes are specified

    if self.op.iallocator or self.op.nodes:

    for (idx, params) in self.op.disks:

      utils.ForceDictType(params, constants.IDISK_PARAMS_TYPES)

    self.recalculate_locks[locking.LEVEL_NODE] = constants.LOCKS_APPEND

    if self.op.nodes:

      self.needed_locks[locking.LEVEL_NODE] = list(self.op.nodes)

    else:

      self.needed_locks[locking.LEVEL_NODE] = []

    elif level == locking.LEVEL_NODE_RES:

      # Copy node locks

      self.needed_locks[locking.LEVEL_NODE_RES] = \

  def BuildHooksEnv(self):

    """Build hooks env.

    This runs on master, primary and secondary nodes of the instance.

    """

  def BuildHooksNodes(self):

    """Build hooks nodes.

    else:

      primary_node = instance.primary_node

    if not self.op.iallocator:

    if instance.disk_template == constants.DT_DISKLESS:

      raise errors.OpPrereqError("Instance '%s' has no disks" %

    if owned_groups:

      # Node group locks are acquired only for the primary node (and only

      # when the allocator is used)

    # if we replace nodes *and* the old primary is offline, we don't

    # check the instance state

    old_pnode = self.cfg.GetNodeInfo(instance.primary_node)

    if not ((self.op.iallocator or self.op.nodes) and old_pnode.offline):

    if self.op.disks:

      self.disks = dict(self.op.disks)

    if self.op.iallocator:

      self._RunAllocator()

      # Release unneeded node and node resource locks

    assert not self.glm.is_owned(locking.LEVEL_NODE_ALLOC)

    # All touched nodes must be locked

    mylocks = self.owned_locks(locking.LEVEL_NODE)

    assert mylocks.issuperset(frozenset(instance.all_nodes))

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

                                 errors.ECODE_NORES)

  """Checks if nodes have enough free disk space in all the VGs.

  This function checks if all given nodes have the needed amount of

  return (total_size - written) * avg_time

  """Wipes instance disks.

  @type lu: L{LogicalUnit}

                        " failed", idx, instance.name)

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

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

    return disks

  """Sleep and poll for an instance's disk to sync.

  """

  if not instance.disks or disks is not None and not disks:

    return True

  if not oneshot:

    lu.LogInfo("Waiting for instance %s to sync disks", instance.name)

  return not cumul_degraded

  """Shutdown block devices of an instance.

  This does the shutdown on all nodes of the instance.

  """

  all_result = True

  for disk in disks:

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

  _ShutdownInstanceDisks.

  """

                           ignore_size=False):

  """Prepare the block devices for an instance.

  device_info = []

  disks_ok = True

  iname = instance.name

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

  # opportunity for the race condition of switching DRBD to primary

  return disks_ok, device_info

  """Start the disks of an instance.

  """

  if not disks_ok:

    if force is not None and not force:

      lu.LogWarning("",

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

    elif level == locking.LEVEL_NODE_RES:

      # Copy node locks

      self.needed_locks[locking.LEVEL_NODE_RES] = \

  def BuildHooksEnv(self):

    """Build hooks env.

      "AMOUNT": self.op.amount,

      "ABSOLUTE": self.op.absolute,

      }

    return env

  def BuildHooksNodes(self):

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

    nodenames = list(instance.all_nodes)

    for node in nodenames:

    self.instance = instance

      # TODO: check the free disk space for file, when that feature will be

      # supported

      nodes = map(self.cfg.GetNodeInfo, nodenames)

                        nodes)

      if es_nodes:

        # With exclusive storage we need to something smarter than just looking

        # at free space; for now, let's simply abort the operation.

        raise errors.OpPrereqError("Cannot grow disks when exclusive_storage"

                                   " is enabled", errors.ECODE_STATE)

  def Exec(self, feedback_fn):

    """Execute disk grow.

    wipe_disks = self.cfg.GetClusterInfo().prealloc_wipe_disks

    if not disks_ok:

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

    self.cfg.Update(instance, feedback_fn)

    # Changes have been recorded, release node lock

    # Downgrade lock while waiting for sync

    self.glm.downgrade(locking.LEVEL_INSTANCE)

      assert instance.disks[self.op.disk] == disk

      # 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")

                                   " iallocator script must be used or the"

                                   " new node given", errors.ECODE_INVAL)

      else:

    elif remote_node is not None or ialloc is not None:

      # Not replacing the secondary

      "Conflicting options"

    if self.op.remote_node is not None:

      # Warning: do not remove the locking of the new secondary here

      # unless DRBD8.AddChildren is changed to work in parallel;

      "NEW_SECONDARY": self.op.remote_node,

      "OLD_SECONDARY": instance.secondary_nodes[0],

      }

    return env

  def BuildHooksNodes(self):

    # Verify if node group locks are still correct

    owned_groups = self.owned_locks(locking.LEVEL_NODEGROUP)

    if owned_groups:

    return LogicalUnit.CheckPrereq(self)

    self.instance = self.cfg.GetInstanceInfo(self.op.instance_name)

    assert self.instance is not None, \

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

  def Exec(self, feedback_fn):

    """Activate the disks.

    """

    disks_ok, disks_info = \

    if not disks_ok:

      raise errors.OpExecError("Cannot activate block devices")

    if self.op.wait_for_sync:

        raise errors.OpExecError("Some disks of the instance are degraded!")

    return disks_info

    """

    instance = self.instance

    if self.op.force:

    else:

      _SafeShutdownInstanceDisks(self, instance)

  return result

  """Wrapper around L{_CheckDiskConsistencyInner}.

  """

  return _CheckDiskConsistencyInner(lu, instance, disk, node, on_primary,

                                    ldisk=ldisk)

  @returns The result of the rpc call

  """

  return lu.rpc.call_blockdev_find(node, disk)

    return remote_node_name

  def _FindFaultyDisks(self, node_name):

    """

  def _CheckDisksActivated(self, instance):

    """Checks if the instance disks are activated.

        self.target_node = secondary_node

        check_nodes = [self.new_node, self.other_node]

        old_node_info = self.cfg.GetNodeInfo(secondary_node)

        assert old_node_info is not None

      cluster = self.cfg.GetClusterInfo()

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

                                                              new_group_info)

    for node in check_nodes:

    touched_nodes = frozenset(node_name for node_name in [self.new_node,

                                                          self.other_node,

                              if node_name is not None)

    # Release unneeded node and node resource locks

    # Release any owned node group

    # Check whether disks are valid

    for disk_idx in self.disks:

    # Activate the instance disks if we're replacing them on a down instance

    if activate_disks:

    try:

      # Should we replace the secondary node?

      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))

    """

    iv_names = {}

    for idx, dev in enumerate(disks):

      if idx not in self.disks:

        continue

      new_lvs = [lv_data, lv_meta]

      old_lvs = [child.Copy() for child in dev.children]

      iv_names[dev.iv_name] = (dev, old_lvs, new_lvs)

      # we pass force_create=True to force the LVM creation

      for new_lv in new_lvs:

        _CreateBlockDevInner(self.lu, node_name, self.instance, new_lv, True,

                             excl_stor)

    return iv_names

      self.lu.LogStep(cstep.next(), steps_total, "Removing old storage")

      self._RemoveOldStorage(self.target_node, iv_names)

      # TODO: Check if releasing locks early still makes sense

    else:

      # Release all resource locks except those used by the instance

    # Release all node locks while waiting for sync

    # TODO: Can the instance lock be downgraded here? Take the optional disk

    # shutdown in the caller into consideration.

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

    # does a combined result over all disks, so we don't check its return value

    self.lu.LogStep(cstep.next(), steps_total, "Sync devices")

    # Check all devices manually

    self._CheckDevices(self.instance.primary_node, iv_names)

    # Step: create new storage

    self.lu.LogStep(3, steps_total, "Allocate new storage")

    for idx, dev in enumerate(disks):

      self.lu.LogInfo("Adding new local storage on %s for disk/%d" %

                      (self.new_node, idx))

      # we pass force_create=True to force LVM creation

      for new_lv in dev.children:

        _CreateBlockDevInner(self.lu, self.new_node, self.instance, new_lv,

                             excl_stor)

    # Step 4: dbrd minors and drbd setups changes

                              children=dev.children,

                              size=dev.size,

                              params={})

      try:

      except errors.GenericError:

        self.cfg.ReleaseDRBDMinors(self.instance.name)

        raise

    self.cfg.Update(self.instance, feedback_fn)

    # Release all node locks (the configuration has been updated)

    # and now perform the drbd attach

    self.lu.LogInfo("Attaching primary drbds to new secondary"

      self.lu.LogStep(cstep.next(), steps_total, "Removing old storage")

      self._RemoveOldStorage(self.target_node, iv_names)

      # TODO: Check if releasing locks early still makes sense

    else:

      # Release all resource locks except those used by the instance

    # TODO: Can the instance lock be downgraded here? Take the optional disk

    # shutdown in the caller into consideration.

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

    # does a combined result over all disks, so we don't check its return value

    self.lu.LogStep(cstep.next(), steps_total, "Sync devices")

    # Check all devices manually

    self._CheckDevices(self.instance.primary_node, iv_names)