Synnefo » snf-ganeti

    self.rpc = rpc

    # Dicts used to declare locking needs to mcpu

    self.needed_locks = None

    self.share_locks = dict.fromkeys(locking.LEVELS, 0)

    self.add_locks = {}

    self.remove_locks = {}

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

    # of self.recalculate_locks[locking.LEVEL_NODE]

    wanted_nodes = []

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

      wanted_nodes.append(instance.primary_node)

      if not primary_only:

    """

    if self.do_locking:

    else:

      names = all_names

    # caller specified names and we must keep the same order

    assert self.names

    missing = set(self.wanted).difference(names)

    if missing:

    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)

    assert frozenset(lu.glm.list_owned(level)) == frozenset(retain)

  else:

    # Release everything

    lu.glm.release(level)

def _RunPostHook(lu, node_name):

    """

    if self.wanted_names is None:

    self.wanted_instances = [self.cfg.GetInstanceInfo(name) for name

                             in 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:

    """

    # Locking is not used

    valid_nodes = [node.name

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

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

    """

    volumes = self.rpc.call_node_volumes(nodenames)

    ilist = [self.cfg.GetInstanceInfo(iname) for iname

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

    """

    # Always get name to sort by

    if constants.SF_NAME in self.op.output_fields:

        instances_keep = []

        # Build list of instances to release

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

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

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

    """Check prerequisites.

    """

            self.op.iallocator is None)

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

        raise errors.OpExecError("Node groups used by instance '%s' changed"

                                 " since lock was acquired, current list is %r,"

                                 " used to be '%s'" %

                                 (self.op.instance_name,

                                  utils.CommaJoin(groups),

    return LogicalUnit.CheckPrereq(self)

    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 self.wanted_names is None:

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

    self.wanted_instances = [self.cfg.GetInstanceInfo(name)

                             for name in self.wanted_names]

        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: