Synnefo » snf-ganeti » ganeti-local

  def ExpandNames(self):

    # These raise errors.OpPrereqError on their own:

    self.group_uuid = self.cfg.LookupNodeGroup(self.op.group_name)

    # We want to lock all the affected nodes and groups. We have readily

    # available the list of nodes, and the *destination* group. To gather the

    # list of "source" groups, we need to fetch node information later on.

    self.needed_locks = {

      locking.LEVEL_NODEGROUP: set([self.group_uuid]),

      }

  def DeclareLocks(self, level):

      # Try to get all affected nodes' groups without having the group or node

      # lock yet. Needs verification later in the code flow.

      self.needed_locks[locking.LEVEL_NODEGROUP].update(groups)

    """

    assert self.needed_locks[locking.LEVEL_NODEGROUP]

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

    expected_locks = (set([self.group_uuid]) |

    actual_locks = self.owned_locks(locking.LEVEL_NODEGROUP)

    if actual_locks != expected_locks:

      raise errors.OpExecError("Nodes changed groups since locks were acquired,"

                               (self.op.group_name, self.group_uuid))

    (new_splits, previous_splits) = \

                                            self.node_data, instance_data)

    if new_splits:

    """Assign nodes to a new group.

    """

    self.cfg.AssignGroupNodes(mods)

    Only instances whose disk template is listed in constants.DTS_INT_MIRROR are

    considered.

    @param changes: list of node assignments to consider.

    @param node_data: a dict with data for all nodes

    @param instance_data: a dict with all instances to consider

      split and this change does not fix.

    """

    all_split_instances = set()

    previously_split_instances = set()

    for inst in instance_data.values():

      if inst.disk_template not in constants.DTS_INT_MIRROR:

        continue

        previously_split_instances.add(inst.name)

        all_split_instances.add(inst.name)

    return (list(all_split_instances - previously_split_instances),

      for node in all_nodes.values():

        if node.group in group_to_nodes:

      if do_instances:

        all_instances = lu.cfg.GetAllInstancesInfo()

    """

    # Verify that the group is empty.

                   for node in self.cfg.GetAllNodesInfo().values()

                   if node.group == self.group_uuid]

    all_nodes.pop(mn, None)

    run_nodes = [mn]

                     if node.group == self.group_uuid)

    return (run_nodes, run_nodes)

      # Lock all nodes in group to be evacuated and target groups

      owned_groups = frozenset(self.owned_locks(locking.LEVEL_NODEGROUP))

      assert self.group_uuid in owned_groups

  def CheckPrereq(self):

    owned_instances = frozenset(self.owned_locks(locking.LEVEL_INSTANCE))

    owned_groups = frozenset(self.owned_locks(locking.LEVEL_NODEGROUP))

    assert owned_groups.issuperset(self.req_target_uuids)

    assert self.group_uuid in owned_groups

    # Check if node groups for locked instances are still correct

    CheckInstancesNodeGroups(self.cfg, self.instances,

    if self.req_target_uuids:

      # User requested specific target groups

      # Lock all nodes in group to be verified

      assert self.group_uuid in self.owned_locks(locking.LEVEL_NODEGROUP)

  def CheckPrereq(self):

    owned_instances = frozenset(self.owned_locks(locking.LEVEL_INSTANCE))

    owned_groups = frozenset(self.owned_locks(locking.LEVEL_NODEGROUP))

    assert self.group_uuid in owned_groups

    # Check if node groups for locked instances are still correct

    CheckInstancesNodeGroups(self.cfg, self.instances,

  def Exec(self, feedback_fn):

    """Verify integrity of cluster disks.

      [inst for inst in self.instances.values() if inst.disks_active])

    if nv_dict:

        if node_res.offline:

          continue

        msg = node_res.fail_msg

        if msg:

          continue

        for lv_name, (_, _, lv_online) in node_res.payload.items():

          if not (lv_online or inst is None):

            res_instances.add(inst)