Synnefo » snf-ganeti

def GenerateDiskTemplate(

  disk_info, file_storage_dir, file_driver, base_index,

  feedback_fn, full_disk_params, _req_file_storage=opcodes.RequireFileStorage,

  _req_shr_file_storage=opcodes.RequireSharedFileStorage):

      raise errors.ProgrammerError("Wrong template configuration")

    remote_node_uuid = secondary_node_uuids[0]

    minors = lu.cfg.AllocateDRBDMinor(

    (drbd_params, _, _) = objects.Disk.ComputeLDParams(template_name,

                                                       full_disk_params)

      # requires going via the node before it's locked, requiring

      # verification later on

      self.needed_locks[locking.LEVEL_NODEGROUP] = \

    elif level == locking.LEVEL_NODE:

      # If an allocator is used, then we lock all the nodes in the current

    This checks that the instance is in the cluster and is not running.

    """

    assert instance is not None, \

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

    if self.op.node_uuids:

    if owned_groups:

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

      # when the allocator is used)

                              primary_only=True)

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

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

  ignored.

  """

  all_result = True

  disks = ExpandCheckDisks(instance, disks)

  """

  device_info = []

  disks_ok = True

  disks = ExpandCheckDisks(instance, disks)

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

  # mark instance disks as active before doing actual work, so watcher does

  # not try to shut them down erroneously

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

  for idx, inst_disk in enumerate(disks):

        node_disk.UnsetSize()

      lu.cfg.SetDiskID(node_disk, node_uuid)

      result = lu.rpc.call_blockdev_assemble(node_uuid, (node_disk, instance),

      msg = result.fail_msg

      if msg:

        is_offline_secondary = (node_uuid in instance.secondary_nodes and

        node_disk.UnsetSize()

      lu.cfg.SetDiskID(node_disk, node_uuid)

      result = lu.rpc.call_blockdev_assemble(node_uuid, (node_disk, instance),

      msg = result.fail_msg

      if msg:

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

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

  if not disks_ok:

  return disks_ok, device_info

    This checks that the instance is in the cluster.

    """

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

    for node_uuid in node_uuids:

      CheckNodeOnline(self, node_uuid)

      raise errors.OpPrereqError("Instance's disk layout does not support"

                                 " growing", errors.ECODE_INVAL)

    if self.op.absolute:

      self.target = self.op.amount

    self.needed_locks[locking.LEVEL_NODE_RES] = []

                                   self.op.iallocator, self.op.remote_node_uuid,

                                   self.op.disks, self.op.early_release,

                                   self.op.ignore_ipolicy)

      # Lock all groups used by instance optimistically; this requires going

      # via the node before it's locked, requiring verification later on

      self.needed_locks[locking.LEVEL_NODEGROUP] = \

    elif level == locking.LEVEL_NODE:

      if self.op.iallocator is not None:

    # Verify if node group locks are still correct

    owned_groups = self.owned_locks(locking.LEVEL_NODEGROUP)

    if owned_groups:

    return LogicalUnit.CheckPrereq(self)

    This checks that the instance is in the cluster.

    """

    assert self.instance is not None, \

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

    CheckNodeOnline(self, self.instance.primary_node)

    if self.op.wait_for_sync:

      if not WaitForSync(self, self.instance):

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

    return disks_info

    This checks that the instance is in the cluster.

    """

    assert self.instance is not None, \

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

  Note: Locking is not within the scope of this class.

  """

    """Initializes this class.

    """

    Tasklet.__init__(self, lu)

    # Parameters

    self.instance_name = instance_name

    self.mode = mode

    self.iallocator_name = iallocator_name

    self.node_secondary_ip = None

  @staticmethod

                    relocate_from_node_uuids):

    """Compute a new secondary node using an IAllocator.

    """

    req = iallocator.IAReqRelocate(

          relocate_from_node_uuids=list(relocate_from_node_uuids))

    ial = iallocator.IAllocator(lu.cfg, lu.rpc, req)

                                 remote_node_name, errors.ECODE_NOENT)

    lu.LogInfo("Selected new secondary for instance '%s': %s",

    return remote_node.uuid

    This checks that the instance is in the cluster.

    """

    assert self.instance is not None, \

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

      remote_node_uuid = self.remote_node_uuid

    else:

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

                                            self.instance.secondary_nodes)

    if remote_node_uuid is None:

    self.lu.LogStep(4, steps_total, "Changing drbd configuration")

    minors = self.cfg.AllocateDRBDMinor([self.new_node_uuid

                                         for _ in self.instance.disks],

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

    iv_names = {}

                             GetInstanceInfoText(self.instance), False,

                             excl_stor)

      except errors.GenericError:

        raise

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

    msg = result.fail_msg

    if msg:

      # detaches didn't succeed (unlikely)

      raise errors.OpExecError("Can't detach the disks from the network on"

                               " old node: %s" % (msg,))