+ # Add timestamps
+ fields.extend(_GetItemTimestampFields(NQ_CONFIG))
+
+ return _PrepareFieldList(fields)
+
+
+class InstanceQueryData:
+ """Data container for instance data queries.
+
+ """
+ def __init__(self, instances, cluster, disk_usage, offline_nodes, bad_nodes,
+ live_data):
+ """Initializes this class.
+
+ @param instances: List of instance objects
+ @param cluster: Cluster object
+ @type disk_usage: dict; instance name as key
+ @param disk_usage: Per-instance disk usage
+ @type offline_nodes: list of strings
+ @param offline_nodes: List of offline nodes
+ @type bad_nodes: list of strings
+ @param bad_nodes: List of faulty nodes
+ @type live_data: dict; instance name as key
+ @param live_data: Per-instance live data
+
+ """
+ assert len(set(bad_nodes) & set(offline_nodes)) == len(offline_nodes), \
+ "Offline nodes not included in bad nodes"
+ assert not (set(live_data.keys()) & set(bad_nodes)), \
+ "Found live data for bad or offline nodes"
+
+ self.instances = instances
+ self.cluster = cluster
+ self.disk_usage = disk_usage
+ self.offline_nodes = offline_nodes
+ self.bad_nodes = bad_nodes
+ self.live_data = live_data
+
+ # Used for individual rows
+ self.inst_hvparams = None
+ self.inst_beparams = None
+ self.inst_nicparams = None
+
+ def __iter__(self):
+ """Iterate over all instances.
+
+ This function has side-effects and only one instance of the resulting
+ generator should be used at a time.
+
+ """
+ for inst in self.instances:
+ self.inst_hvparams = self.cluster.FillHV(inst, skip_globals=True)
+ self.inst_beparams = self.cluster.FillBE(inst)
+ self.inst_nicparams = [self.cluster.SimpleFillNIC(nic.nicparams)
+ for nic in inst.nics]
+
+ yield inst
+
+
+def _GetInstOperState(ctx, inst):
+ """Get instance's operational status.
+
+ @type ctx: L{InstanceQueryData}
+ @type inst: L{objects.Instance}
+ @param inst: Instance object
+
+ """
+ # Can't use QRFS_OFFLINE here as it would describe the instance to
+ # be offline when we actually don't know due to missing data
+ if inst.primary_node in ctx.bad_nodes:
+ return _FS_NODATA
+ else:
+ return bool(ctx.live_data.get(inst.name))
+
+
+def _GetInstLiveData(name):
+ """Build function for retrieving live data.
+
+ @type name: string
+ @param name: Live data field name
+
+ """
+ def fn(ctx, inst):
+ """Get live data for an instance.
+
+ @type ctx: L{InstanceQueryData}
+ @type inst: L{objects.Instance}
+ @param inst: Instance object
+
+ """
+ if (inst.primary_node in ctx.bad_nodes or
+ inst.primary_node in ctx.offline_nodes):
+ # Can't use QRFS_OFFLINE here as it would describe the instance to be
+ # offline when we actually don't know due to missing data
+ return _FS_NODATA
+
+ if inst.name in ctx.live_data:
+ data = ctx.live_data[inst.name]
+ if name in data:
+ return data[name]
+
+ return _FS_UNAVAIL
+
+ return fn
+
+
+def _GetInstStatus(ctx, inst):
+ """Get instance status.
+
+ @type ctx: L{InstanceQueryData}
+ @type inst: L{objects.Instance}
+ @param inst: Instance object
+
+ """
+ if inst.primary_node in ctx.offline_nodes:
+ return "ERROR_nodeoffline"
+
+ if inst.primary_node in ctx.bad_nodes:
+ return "ERROR_nodedown"
+
+ if bool(ctx.live_data.get(inst.name)):
+ if inst.admin_up:
+ return "running"
+ else:
+ return "ERROR_up"
+
+ if inst.admin_up:
+ return "ERROR_down"
+
+ return "ADMIN_down"
+
+
+def _GetInstDiskSize(index):
+ """Build function for retrieving disk size.
+
+ @type index: int
+ @param index: Disk index
+
+ """
+ def fn(_, inst):
+ """Get size of a disk.
+
+ @type inst: L{objects.Instance}
+ @param inst: Instance object
+
+ """
+ try:
+ return inst.disks[index].size
+ except IndexError:
+ return _FS_UNAVAIL
+
+ return fn
+
+
+def _GetInstNic(index, cb):
+ """Build function for calling another function with an instance NIC.
+
+ @type index: int
+ @param index: NIC index
+ @type cb: callable
+ @param cb: Callback
+
+ """
+ def fn(ctx, inst):
+ """Call helper function with instance NIC.
+
+ @type ctx: L{InstanceQueryData}
+ @type inst: L{objects.Instance}
+ @param inst: Instance object
+
+ """
+ try:
+ nic = inst.nics[index]
+ except IndexError:
+ return _FS_UNAVAIL
+
+ return cb(ctx, index, nic)
+
+ return fn
+
+
+def _GetInstNicIp(ctx, _, nic): # pylint: disable-msg=W0613
+ """Get a NIC's IP address.
+
+ @type ctx: L{InstanceQueryData}
+ @type nic: L{objects.NIC}
+ @param nic: NIC object
+
+ """
+ if nic.ip is None:
+ return _FS_UNAVAIL
+ else:
+ return nic.ip
+
+
+def _GetInstNicBridge(ctx, index, _):
+ """Get a NIC's bridge.
+
+ @type ctx: L{InstanceQueryData}
+ @type index: int
+ @param index: NIC index
+
+ """
+ assert len(ctx.inst_nicparams) >= index
+
+ nicparams = ctx.inst_nicparams[index]
+
+ if nicparams[constants.NIC_MODE] == constants.NIC_MODE_BRIDGED:
+ return nicparams[constants.NIC_LINK]
+ else:
+ return _FS_UNAVAIL
+
+
+def _GetInstAllNicBridges(ctx, inst):
+ """Get all network bridges for an instance.
+
+ @type ctx: L{InstanceQueryData}
+ @type inst: L{objects.Instance}
+ @param inst: Instance object
+
+ """
+ assert len(ctx.inst_nicparams) == len(inst.nics)
+
+ result = []
+
+ for nicp in ctx.inst_nicparams:
+ if nicp[constants.NIC_MODE] == constants.NIC_MODE_BRIDGED:
+ result.append(nicp[constants.NIC_LINK])
+ else:
+ result.append(None)
+
+ assert len(result) == len(inst.nics)
+
+ return result
+
+
+def _GetInstNicParam(name):
+ """Build function for retrieving a NIC parameter.
+
+ @type name: string
+ @param name: Parameter name
+
+ """
+ def fn(ctx, index, _):
+ """Get a NIC's bridge.
+
+ @type ctx: L{InstanceQueryData}
+ @type inst: L{objects.Instance}
+ @param inst: Instance object
+ @type nic: L{objects.NIC}
+ @param nic: NIC object
+
+ """
+ assert len(ctx.inst_nicparams) >= index
+ return ctx.inst_nicparams[index][name]
+
+ return fn
+
+
+def _GetInstanceNetworkFields():
+ """Get instance fields involving network interfaces.
+
+ @return: List of field definitions used as input for L{_PrepareFieldList}
+
+ """
+ nic_mac_fn = lambda ctx, _, nic: nic.mac
+ nic_mode_fn = _GetInstNicParam(constants.NIC_MODE)
+ nic_link_fn = _GetInstNicParam(constants.NIC_LINK)
+
+ fields = [
+ # First NIC (legacy)
+ (_MakeField("ip", "IP_address", QFT_TEXT), IQ_CONFIG,
+ _GetInstNic(0, _GetInstNicIp)),
+ (_MakeField("mac", "MAC_address", QFT_TEXT), IQ_CONFIG,
+ _GetInstNic(0, nic_mac_fn)),
+ (_MakeField("bridge", "Bridge", QFT_TEXT), IQ_CONFIG,
+ _GetInstNic(0, _GetInstNicBridge)),
+ (_MakeField("nic_mode", "NIC_Mode", QFT_TEXT), IQ_CONFIG,
+ _GetInstNic(0, nic_mode_fn)),
+ (_MakeField("nic_link", "NIC_Link", QFT_TEXT), IQ_CONFIG,
+ _GetInstNic(0, nic_link_fn)),
+
+ # All NICs
+ (_MakeField("nic.count", "NICs", QFT_NUMBER), IQ_CONFIG,
+ lambda ctx, inst: len(inst.nics)),
+ (_MakeField("nic.macs", "NIC_MACs", QFT_OTHER), IQ_CONFIG,
+ lambda ctx, inst: [nic.mac for nic in inst.nics]),
+ (_MakeField("nic.ips", "NIC_IPs", QFT_OTHER), IQ_CONFIG,
+ lambda ctx, inst: [nic.ip for nic in inst.nics]),
+ (_MakeField("nic.modes", "NIC_modes", QFT_OTHER), IQ_CONFIG,
+ lambda ctx, inst: [nicp[constants.NIC_MODE]
+ for nicp in ctx.inst_nicparams]),
+ (_MakeField("nic.links", "NIC_links", QFT_OTHER), IQ_CONFIG,
+ lambda ctx, inst: [nicp[constants.NIC_LINK]
+ for nicp in ctx.inst_nicparams]),
+ (_MakeField("nic.bridges", "NIC_bridges", QFT_OTHER), IQ_CONFIG,
+ _GetInstAllNicBridges),
+ ]
+
+ # NICs by number
+ for i in range(constants.MAX_NICS):
+ fields.extend([
+ (_MakeField("nic.ip/%s" % i, "NicIP/%s" % i, QFT_TEXT),
+ IQ_CONFIG, _GetInstNic(i, _GetInstNicIp)),
+ (_MakeField("nic.mac/%s" % i, "NicMAC/%s" % i, QFT_TEXT),
+ IQ_CONFIG, _GetInstNic(i, nic_mac_fn)),
+ (_MakeField("nic.mode/%s" % i, "NicMode/%s" % i, QFT_TEXT),
+ IQ_CONFIG, _GetInstNic(i, nic_mode_fn)),
+ (_MakeField("nic.link/%s" % i, "NicLink/%s" % i, QFT_TEXT),
+ IQ_CONFIG, _GetInstNic(i, nic_link_fn)),
+ (_MakeField("nic.bridge/%s" % i, "NicBridge/%s" % i, QFT_TEXT),
+ IQ_CONFIG, _GetInstNic(i, _GetInstNicBridge)),
+ ])
+
+ return fields
+
+
+def _GetInstDiskUsage(ctx, inst):
+ """Get disk usage for an instance.
+
+ @type ctx: L{InstanceQueryData}
+ @type inst: L{objects.Instance}
+ @param inst: Instance object
+
+ """
+ usage = ctx.disk_usage[inst.name]
+
+ if usage is None:
+ usage = 0
+
+ return usage
+
+
+def _GetInstanceDiskFields():
+ """Get instance fields involving disks.
+
+ @return: List of field definitions used as input for L{_PrepareFieldList}
+
+ """
+ fields = [
+ (_MakeField("disk_usage", "DiskUsage", QFT_UNIT), IQ_DISKUSAGE,
+ _GetInstDiskUsage),
+ (_MakeField("sda_size", "LegacyDisk/0", QFT_UNIT), IQ_CONFIG,
+ _GetInstDiskSize(0)),
+ (_MakeField("sdb_size", "LegacyDisk/1", QFT_UNIT), IQ_CONFIG,
+ _GetInstDiskSize(1)),
+ (_MakeField("disk.count", "Disks", QFT_NUMBER), IQ_CONFIG,
+ lambda ctx, inst: len(inst.disks)),
+ (_MakeField("disk.sizes", "Disk_sizes", QFT_OTHER), IQ_CONFIG,
+ lambda ctx, inst: [disk.size for disk in inst.disks]),
+ ]
+
+ # Disks by number
+ fields.extend([
+ (_MakeField("disk.size/%s" % i, "Disk/%s" % i, QFT_UNIT),
+ IQ_CONFIG, _GetInstDiskSize(i))
+ for i in range(constants.MAX_DISKS)
+ ])
+
+ return fields
+
+
+def _GetInstanceParameterFields():
+ """Get instance fields involving parameters.
+
+ @return: List of field definitions used as input for L{_PrepareFieldList}
+
+ """
+ # TODO: Consider moving titles closer to constants
+ be_title = {
+ constants.BE_AUTO_BALANCE: "Auto_balance",
+ constants.BE_MEMORY: "ConfigMemory",
+ constants.BE_VCPUS: "ConfigVCPUs",
+ }
+
+ hv_title = {
+ constants.HV_ACPI: "ACPI",
+ constants.HV_BOOT_ORDER: "Boot_order",
+ constants.HV_CDROM_IMAGE_PATH: "CDROM_image_path",
+ constants.HV_DISK_TYPE: "Disk_type",
+ constants.HV_INITRD_PATH: "Initrd_path",
+ constants.HV_KERNEL_PATH: "Kernel_path",
+ constants.HV_NIC_TYPE: "NIC_type",
+ constants.HV_PAE: "PAE",
+ constants.HV_VNC_BIND_ADDRESS: "VNC_bind_address",
+ }
+
+ fields = [
+ # Filled parameters
+ (_MakeField("hvparams", "HypervisorParameters", QFT_OTHER),
+ IQ_CONFIG, lambda ctx, _: ctx.inst_hvparams),
+ (_MakeField("beparams", "BackendParameters", QFT_OTHER),
+ IQ_CONFIG, lambda ctx, _: ctx.inst_beparams),
+ (_MakeField("vcpus", "LegacyVCPUs", QFT_NUMBER), IQ_CONFIG,
+ lambda ctx, _: ctx.inst_beparams[constants.BE_VCPUS]),
+
+ # Unfilled parameters
+ (_MakeField("custom_hvparams", "CustomHypervisorParameters", QFT_OTHER),
+ IQ_CONFIG, _GetItemAttr("hvparams")),
+ (_MakeField("custom_beparams", "CustomBackendParameters", QFT_OTHER),
+ IQ_CONFIG, _GetItemAttr("beparams")),
+ (_MakeField("custom_nicparams", "CustomNicParameters", QFT_OTHER),
+ IQ_CONFIG, lambda ctx, inst: [nic.nicparams for nic in inst.nics]),
+ ]
+
+ # HV params
+ def _GetInstHvParam(name):
+ return lambda ctx, _: ctx.inst_hvparams.get(name, None)
+
+ fields.extend([
+ # For now all hypervisor parameters are exported as QFT_OTHER
+ (_MakeField("hv/%s" % name, hv_title.get(name, "hv/%s" % name), QFT_OTHER),
+ IQ_CONFIG, _GetInstHvParam(name))
+ for name in constants.HVS_PARAMETERS
+ if name not in constants.HVC_GLOBALS
+ ])
+
+ # BE params
+ def _GetInstBeParam(name):
+ return lambda ctx, _: ctx.inst_beparams.get(name, None)
+
+ fields.extend([
+ # For now all backend parameters are exported as QFT_OTHER
+ (_MakeField("be/%s" % name, be_title.get(name, "be/%s" % name), QFT_OTHER),
+ IQ_CONFIG, _GetInstBeParam(name))
+ for name in constants.BES_PARAMETERS
+ ])
+
+ return fields
+
+
+_INST_SIMPLE_FIELDS = {
+ "disk_template": ("Disk_template", QFT_TEXT),
+ "hypervisor": ("Hypervisor", QFT_TEXT),
+ "name": ("Node", QFT_TEXT),
+ # Depending on the hypervisor, the port can be None
+ "network_port": ("Network_port", QFT_OTHER),
+ "os": ("OS", QFT_TEXT),
+ "serial_no": ("SerialNo", QFT_NUMBER),
+ "uuid": ("UUID", QFT_TEXT),
+ }
+
+
+def _BuildInstanceFields():
+ """Builds list of fields for instance queries.
+
+ """
+ fields = [
+ (_MakeField("pnode", "Primary_node", QFT_TEXT), IQ_CONFIG,
+ _GetItemAttr("primary_node")),
+ (_MakeField("snodes", "Secondary_Nodes", QFT_OTHER), IQ_CONFIG,
+ lambda ctx, inst: list(inst.secondary_nodes)),
+ (_MakeField("admin_state", "Autostart", QFT_BOOL), IQ_CONFIG,
+ _GetItemAttr("admin_up")),
+ (_MakeField("tags", "Tags", QFT_OTHER), IQ_CONFIG,
+ lambda ctx, inst: list(inst.GetTags())),
+ ]
+
+ # Add simple fields
+ fields.extend([(_MakeField(name, title, kind), IQ_CONFIG, _GetItemAttr(name))
+ for (name, (title, kind)) in _INST_SIMPLE_FIELDS.items()])
+
+ # Fields requiring talking to the node
+ fields.extend([
+ (_MakeField("oper_state", "Running", QFT_BOOL), IQ_LIVE,
+ _GetInstOperState),
+ (_MakeField("oper_ram", "Memory", QFT_UNIT), IQ_LIVE,
+ _GetInstLiveData("memory")),
+ (_MakeField("oper_vcpus", "VCPUs", QFT_NUMBER), IQ_LIVE,
+ _GetInstLiveData("vcpus")),
+ (_MakeField("status", "Status", QFT_TEXT), IQ_LIVE, _GetInstStatus),
+ ])
+
+ fields.extend(_GetInstanceParameterFields())
+ fields.extend(_GetInstanceDiskFields())
+ fields.extend(_GetInstanceNetworkFields())
+ fields.extend(_GetItemTimestampFields(IQ_CONFIG))
+
+ return _PrepareFieldList(fields)
+
+
+class LockQueryData:
+ """Data container for lock data queries.
+
+ """
+ def __init__(self, lockdata):
+ """Initializes this class.
+
+ """
+ self.lockdata = lockdata
+
+ def __iter__(self):
+ """Iterate over all locks.
+
+ """
+ return iter(self.lockdata)
+
+
+def _GetLockOwners(_, data):
+ """Returns a sorted list of a lock's current owners.
+
+ """
+ (_, _, owners, _) = data
+
+ if owners:
+ owners = utils.NiceSort(owners)
+
+ return owners
+
+
+def _GetLockPending(_, data):
+ """Returns a sorted list of a lock's pending acquires.
+
+ """
+ (_, _, _, pending) = data
+
+ if pending:
+ pending = [(mode, utils.NiceSort(names))
+ for (mode, names) in pending]
+
+ return pending
+
+
+def _BuildLockFields():
+ """Builds list of fields for lock queries.
+
+ """
+ return _PrepareFieldList([
+ (_MakeField("name", "Name", QFT_TEXT), None,
+ lambda ctx, (name, mode, owners, pending): name),
+ (_MakeField("mode", "Mode", QFT_OTHER), LQ_MODE,
+ lambda ctx, (name, mode, owners, pending): mode),
+ (_MakeField("owner", "Owner", QFT_OTHER), LQ_OWNER, _GetLockOwners),
+ (_MakeField("pending", "Pending", QFT_OTHER), LQ_PENDING, _GetLockPending),
+ ])
+
+
+class GroupQueryData:
+ """Data container for node group data queries.
+
+ """
+ def __init__(self, groups, group_to_nodes, group_to_instances):
+ """Initializes this class.
+
+ @param groups: List of node group objects
+ @type group_to_nodes: dict; group UUID as key
+ @param group_to_nodes: Per-group list of nodes
+ @type group_to_instances: dict; group UUID as key
+ @param group_to_instances: Per-group list of (primary) instances
+
+ """
+ self.groups = groups
+ self.group_to_nodes = group_to_nodes
+ self.group_to_instances = group_to_instances
+
+ def __iter__(self):
+ """Iterate over all node groups.
+
+ """
+ return iter(self.groups)
+
+
+_GROUP_SIMPLE_FIELDS = {
+ "alloc_policy": ("AllocPolicy", QFT_TEXT),
+ "name": ("Group", QFT_TEXT),
+ "serial_no": ("SerialNo", QFT_NUMBER),
+ "uuid": ("UUID", QFT_TEXT),
+ "ndparams": ("NDParams", QFT_OTHER),
+ }
+
+
+def _BuildGroupFields():
+ """Builds list of fields for node group queries.
+
+ """
+ # Add simple fields
+ fields = [(_MakeField(name, title, kind), GQ_CONFIG, _GetItemAttr(name))
+ for (name, (title, kind)) in _GROUP_SIMPLE_FIELDS.items()]
+
+ def _GetLength(getter):
+ return lambda ctx, group: len(getter(ctx)[group.uuid])
+
+ def _GetSortedList(getter):
+ return lambda ctx, group: utils.NiceSort(getter(ctx)[group.uuid])
+
+ group_to_nodes = operator.attrgetter("group_to_nodes")
+ group_to_instances = operator.attrgetter("group_to_instances")
+
+ # Add fields for nodes
+ fields.extend([
+ (_MakeField("node_cnt", "Nodes", QFT_NUMBER),
+ GQ_NODE, _GetLength(group_to_nodes)),
+ (_MakeField("node_list", "NodeList", QFT_OTHER),
+ GQ_NODE, _GetSortedList(group_to_nodes)),
+ ])
+
+ # Add fields for instances
+ fields.extend([
+ (_MakeField("pinst_cnt", "Instances", QFT_NUMBER),
+ GQ_INST, _GetLength(group_to_instances)),
+ (_MakeField("pinst_list", "InstanceList", QFT_OTHER),
+ GQ_INST, _GetSortedList(group_to_instances)),
+ ])
+
+ fields.extend(_GetItemTimestampFields(GQ_CONFIG))
+