Synnefo » snf-ganeti

    lu.share_locks = ShareAll()

    if self.names:

    else:

      self.wanted = locking.ALL_SET

        lu.needed_locks[locking.LEVEL_NODEGROUP] = \

          set(group_uuid

              for instance_name in lu.owned_locks(locking.LEVEL_INSTANCE)

      elif level == locking.LEVEL_NODE:

        lu._LockInstancesNodes() # pylint: disable=W0212

        lu.needed_locks[locking.LEVEL_NETWORK] = \

          frozenset(net_uuid

                    for instance_name in lu.owned_locks(locking.LEVEL_INSTANCE)

  @staticmethod

  def _CheckGroupLocks(lu):

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

    # Check if node groups for locked instances are still correct

  def _GetQueryData(self, lu):

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

      self._CheckGroupLocks(lu)

    cluster = lu.cfg.GetClusterInfo()

    node_uuids = frozenset(itertools.chain(*(inst.all_nodes

                                             for inst in instance_list)))

    hv_list = list(set([inst.hypervisor for inst in instance_list]))

    bad_node_uuids = []

    offline_node_uuids = []

    # Gather data as requested

    if self.requested_data & set([query.IQ_LIVE, query.IQ_CONSOLE]):

        if result.fail_msg:

          bad_node_uuids.append(node_uuid)

        elif result.payload:

              else:

            else:

              # orphan instance; we don't list it here as we don't

              # handle this case yet in the output of instance listing

              logging.warning("Orphan instance '%s' found on node %s",

              # else no instance is alive

    else:

      live_data = {}

    if query.IQ_DISKUSAGE in self.requested_data:

      gmi = ganeti.masterd.instance

                         gmi.ComputeDiskSize(inst.disk_template,

                                             [{constants.IDISK_SIZE: disk.size}

                                              for disk in inst.disks]))

    if query.IQ_CONSOLE in self.requested_data:

      consinfo = {}

      for inst in instance_list:

          # Instance is running

            GetInstanceConsole(cluster, inst,

                               lu.cfg.GetNodeInfo(inst.primary_node))

        else:

    else:

      consinfo = None

      groups = None

    if query.IQ_NETWORKS in self.requested_data:

                                    for i in instance_list))

      networks = dict((uuid, lu.cfg.GetNetwork(uuid)) for uuid in net_uuids)

    else:

    return query.InstanceQueryData(instance_list, lu.cfg.GetClusterInfo(),

                                   disk_usage, offline_node_uuids,

class LUInstanceQuery(NoHooksLU):

    if self.op.instances or not self.op.use_locking:

      # Expand instance names right here

    else:

      # Will use acquired locks

      self.wanted_names = None

  def DeclareLocks(self, level):

    if self.op.use_locking:

      if level == locking.LEVEL_NODEGROUP:

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

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

        self.needed_locks[locking.LEVEL_NODEGROUP] = \

          frozenset(group_uuid

                    for group_uuid in

      elif level == locking.LEVEL_NODE:

        self._LockInstancesNodes()

      elif level == locking.LEVEL_NETWORK:

        self.needed_locks[locking.LEVEL_NETWORK] = \

          frozenset(net_uuid

                    for net_uuid in

  def CheckPrereq(self):

    """Check prerequisites.

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

      self.wanted_names = owned_instances

    if self.op.use_locking:

      CheckInstancesNodeGroups(self.cfg, instances, owned_groups,