Synnefo » snf-ganeti » ganeti-local

    self.op = op

    self.cfg = context.cfg

    self.glm = context.glm

    self.context = context

    self.rpc = rpc

    # Dicts used to declare locking needs to mcpu

    # future we might want to have different behaviors depending on the value

    # of self.recalculate_locks[locking.LEVEL_NODE]

    wanted_nodes = []

    for _, instance in self.cfg.GetMultiInstanceInfo(locked_i):

      wanted_nodes.append(instance.primary_node)

      if not primary_only:

    """

    if self.do_locking:

    else:

      names = all_names

    release = []

    # Determine which locks to release

      if should_release(name):

        release.append(name)

      else:

        retain.append(name)

    # Release just some locks

    lu.glm.release(level, names=release)

  else:

    # Release everything

    lu.glm.release(level)

      # volumes for these instances are healthy, we will need to do an

      # extra call to their secondaries. We ensure here those nodes will

      # be locked.

        # Important: access only the instances whose lock is owned

        if all_inst_info[inst].disk_template in constants.DTS_INT_MIRROR:

          nodes.update(all_inst_info[inst].secondary_nodes)

    group_instances = self.cfg.GetNodeGroupInstances(self.group_uuid)

    unlocked_nodes = \

    unlocked_instances = \

    if unlocked_nodes:

      raise errors.OpPrereqError("Missing lock for nodes: %s" %

            extra_lv_nodes.add(nname)

    unlocked_lv_nodes = \

    if unlocked_lv_nodes:

      raise errors.OpPrereqError("these nodes could be locked: %s" %

      }

  def Exec(self, feedback_fn):

    # Submit one instance of L{opcodes.OpGroupVerifyDisks} per node group

    return ResultWithJobs([[opcodes.OpGroupVerifyDisks(group_name=group)]

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

            # later on

            [group_uuid

    elif level == locking.LEVEL_NODE:

      # This will only lock the nodes in the group to be verified which contain

      self._LockInstancesNodes()

      # Lock all nodes in group to be verified

      member_nodes = self.cfg.GetNodeGroup(self.group_uuid).members

      self.needed_locks[locking.LEVEL_NODE].extend(member_nodes)

  def CheckPrereq(self):

    assert self.group_uuid in owned_groups

                                        if inst.admin_up])

    if nv_dict:

                             set(self.cfg.GetVmCapableNodeList()))

      node_lvs = self.rpc.call_lv_list(nodes, [])

    """

    if self.wanted_names is None:

    self.wanted_instances = \

        map(compat.snd, self.cfg.GetMultiInstanceInfo(self.wanted_names))

                                   " drbd-based instances exist",

                                   errors.ECODE_INVAL)

    # if vg_name not None, checks given volume group on all nodes

    if self.op.vg_name:

    """Computes the list of nodes and their attributes.

    """

    volumes = self.rpc.call_node_volumes(nodenames)

    ilist = self.cfg.GetAllInstancesInfo()

    """Computes the list of nodes and their attributes.

    """

    # Always get name to sort by

    if constants.SF_NAME in self.op.output_fields:

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

        lu.needed_locks[locking.LEVEL_NODEGROUP] = \

          set(group_uuid

      elif level == locking.LEVEL_NODE:

        lu._LockInstancesNodes() # pylint: disable-msg=W0212

  @staticmethod

  def _CheckGroupLocks(lu):

    # Check if node groups for locked instances are still correct

    for instance_name in owned_instances:

        instances_keep = []

        # Build list of instances to release

        for instance_name, instance in self.cfg.GetMultiInstanceInfo(locked_i):

          if (instance.disk_template in constants.DTS_INT_MIRROR and

              self.op.node_name in instance.all_nodes):

        _ReleaseLocks(self, locking.LEVEL_INSTANCE, keep=instances_keep)

                set(instances_keep))

  def BuildHooksEnv(self):

    # running the iallocator and the actual migration, a good consistency model

    # will have to be found.

            frozenset([self.op.node_name]))

    return ResultWithJobs(jobs)

    src_path = self.op.src_path

    if src_node is None:

      exp_list = self.rpc.call_export_list(locked_nodes)

      found = False

      for node in exp_list:

        # Lock member nodes of all locked groups

        self.needed_locks[locking.LEVEL_NODE] = [node_name

          for node_name in self.cfg.GetNodeGroup(group_uuid).members]

      else:

        self._LockInstancesNodes()

    assert (self.glm.is_owned(locking.LEVEL_NODEGROUP) or

            self.op.iallocator is None)

    if owned_groups:

      _CheckInstanceNodeGroups(self.cfg, self.op.instance_name, owned_groups)

    if remote_node is None:

      self.remote_node_info = None

    else:

             "Remote node '%s' is not locked" % remote_node

      self.remote_node_info = self.cfg.GetNodeInfo(remote_node)

    if __debug__:

      # Verify owned locks before starting operation

          ("Incorrect node locks, owning %s, expected %s" %

          "Instance '%s' not locked" % self.instance_name

      assert not self.lu.glm.is_owned(locking.LEVEL_NODEGROUP), \

    if __debug__:

      # Verify owned locks

      nodes = frozenset(self.node_secondary_ip)

        ("Not owning the correct locks, early_release=%s, owned=%r,"

    return result

  def CheckPrereq(self):

    # Verify locks

    assert owned_nodes == self.lock_nodes

    """

    if self.wanted_names is None:

      assert self.op.use_locking, "Locking was not used"

    self.wanted_instances = \

        map(compat.snd, self.cfg.GetMultiInstanceInfo(self.wanted_names))

        self._LockInstancesNodes()

        # Lock all nodes in all potential target groups

                       self.cfg.GetInstanceNodeGroups(self.op.instance_name))

        member_nodes = [node_name

                        for group in lock_groups

        self.needed_locks[locking.LEVEL_NODE] = locking.ALL_SET

  def CheckPrereq(self):

    assert (self.req_target_uuids is None or

            owned_groups.issuperset(self.req_target_uuids))

    return ([mn], [mn])

  def Exec(self, feedback_fn):

    assert instances == [self.op.instance_name], "Instance not locked"

        that node.

    """

    rpcresult = self.rpc.call_export_list(self.nodes)

    result = {}

    for node in rpcresult:

      fqdn_warn = True

      instance_name = self.op.instance_name

    exportlist = self.rpc.call_export_list(locked_nodes)

    found = False

    for node in exportlist:

    """

    assert self.needed_locks[locking.LEVEL_NODEGROUP]

            frozenset(self.op.nodes))

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

                      self.cfg.GetNodeGroupsFromNodes(self.op.nodes))

    if actual_locks != expected_locks:

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

                               " current groups are '%s', used to be '%s'" %

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

        lock_groups.update(group_uuid

                           for instance_name in

                           for group_uuid in

                             self.cfg.GetInstanceNodeGroups(instance_name))

      else:

      self._LockInstancesNodes()

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

      assert self.group_uuid in owned_groups

      member_nodes = [node_name

                      for group in owned_groups

      self.needed_locks[locking.LEVEL_NODE].extend(member_nodes)

  def CheckPrereq(self):

    assert owned_groups.issuperset(self.req_target_uuids)

    assert self.group_uuid in owned_groups

    """

    mn = self.cfg.GetMasterNode()

    run_nodes = [mn] + self.cfg.GetNodeGroup(self.group_uuid).members

    return (run_nodes, run_nodes)

  def Exec(self, feedback_fn):

    assert self.group_uuid not in self.target_uuids