Synnefo » snf-ganeti » ganeti-local

    instance_names = self._GetNames(lu, all_info.keys(), locking.LEVEL_INSTANCE)

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

    wrongnode_inst = set()

    # Gather data as requested

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

      live_data = {}

                                                 cluster.hvparams)

        if result.offline:

          # offline nodes will be in both lists

          assert result.fail_msg

        if result.fail_msg:

        elif result.payload:

          for inst in result.payload:

            if inst in all_info:

                live_data.update(result.payload)

              else:

                wrongnode_inst.add(inst)

              # 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 = {}

      for inst in instance_list:

        if inst.name in live_data:

          # Instance is running

        else:

          consinfo[inst.name] = None

      assert set(consinfo.keys()) == set(instance_names)

      consinfo = None

    if query.IQ_NODES in self.requested_data:

      groups = dict((uuid, lu.cfg.GetNodeGroup(uuid))

                    for uuid in set(map(operator.attrgetter("group"),

                                        nodes.values())))

      networks = None

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

class LUInstanceQuery(NoHooksLU):

    """

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

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

    owned_networks = frozenset(self.owned_locks(locking.LEVEL_NETWORK))

    if self.wanted_names is None:

    instances = dict(self.cfg.GetMultiInstanceInfo(self.wanted_names))

    if self.op.use_locking:

    else:

      assert not (owned_instances or owned_groups or

    self.wanted_instances = instances.values()

    """Returns the status of a block device

    """

      return None

    if result.offline:

      return None

            status.sync_percent, status.estimated_time,

            status.is_degraded, status.ldisk_status)

    """Compute block device status.

    """

    (anno_dev,) = AnnotateDiskParams(instance, [dev], self.cfg)

    """Compute block device status.

    @attention: The device has to be annotated already.

    """

    if dev.dev_type in constants.LDS_DRBD:

      # we change the snode then (otherwise we use the one passed in)

      if dev.logical_id[0] == instance.primary_node:

      else:

    dev_pstatus = self._ComputeBlockdevStatus(instance.primary_node,

                                              instance, dev)

    if dev.children:

      dev_children = map(compat.partial(self._ComputeDiskStatusInner,

                         dev.children)

    else:

      dev_children = []

      "iv_name": dev.iv_name,

      "dev_type": dev.dev_type,

      "logical_id": dev.logical_id,

      "physical_id": dev.physical_id,

      "pstatus": dev_pstatus,

      "sstatus": dev_sstatus,

    cluster = self.cfg.GetClusterInfo()

    groups = dict(self.cfg.GetMultiNodeGroupInfo(node.group

                                                 for node in nodes.values()))

    for instance in self.wanted_instances:

      pnode = nodes[instance.primary_node]

        remote_info = self.rpc.call_instance_info(

            instance.primary_node, instance.name, instance.hypervisor,

            cluster.hvparams[instance.hypervisor])

        remote_info = remote_info.payload

        if remote_info and "state" in remote_info:

          remote_state = "up"

          else:

            remote_state = instance.admin_state

                  instance.disks)

      result[instance.name] = {

        "name": instance.name,

        "config_state": instance.admin_state,

        "run_state": remote_state,

        "pnode_group_uuid": pnode.group,

        "pnode_group_name": group2name_fn(pnode.group),

        "snodes_group_uuids": snodes_group_uuids,

        "snodes_group_names": map(group2name_fn, snodes_group_uuids),

        "os": instance.os,