# 02110-1301, USA.
-"""Module for query operations"""
+"""Module for query operations
+
+How it works:
+
+ - Add field definitions
+ - See how L{NODE_FIELDS} is built
+ - Each field gets:
+ - Query field definition (L{objects.QueryFieldDefinition}, use
+ L{_MakeField} for creating), containing:
+ - Name, must be lowercase and match L{FIELD_NAME_RE}
+ - Title for tables, must not contain whitespace and match
+ L{TITLE_RE}
+ - Value data type, e.g. L{constants.QFT_NUMBER}
+ - Data request type, see e.g. C{NQ_*}
+ - A retrieval function, see L{Query.__init__} for description
+ - Pass list of fields through L{_PrepareFieldList} for preparation and
+ checks
+ - Instantiate L{Query} with prepared field list definition and selected fields
+ - Call L{Query.RequestedData} to determine what data to collect/compute
+ - Call L{Query.Query} or L{Query.OldStyleQuery} with collected data and use
+ result
+ - Data container must support iteration using C{__iter__}
+ - Items are passed to retrieval functions and can have any format
+ - Call L{Query.GetFields} to get list of definitions for selected fields
+
+@attention: Retrieval functions must be idempotent. They can be called multiple
+ times, in any order and any number of times. This is important to keep in
+ mind for implementing filters in the future.
+
+"""
import logging
import operator
from ganeti import ht
+# Constants for requesting data from the caller/data provider. Each property
+# collected/computed separately by the data provider should have its own to
+# only collect the requested data and not more.
+
(NQ_CONFIG,
NQ_INST,
NQ_LIVE,
- NQ_GROUP) = range(1, 5)
+ NQ_GROUP,
+ NQ_OOB) = range(1, 6)
+
+(IQ_CONFIG,
+ IQ_LIVE,
+ IQ_DISKUSAGE) = range(100, 103)
+
+(LQ_MODE,
+ LQ_OWNER,
+ LQ_PENDING) = range(10, 13)
+
+(GQ_CONFIG,
+ GQ_NODE,
+ GQ_INST) = range(200, 203)
FIELD_NAME_RE = re.compile(r"^[a-z0-9/._]+$")
for (idx, row) in enumerate(result):
assert _VerifyResultRow(self._fields, row), \
("Inconsistent result for fields %s in row %s: %r" %
- (self._fields, idx, row))
+ (GetAllFields(self._fields), idx, row))
return result
@type fields: list of tuples; (L{objects.QueryFieldDefinition}, data kind,
retrieval function)
- @param fields: List of fields
+ @param fields: List of fields, see L{Query.__init__} for a better description
@rtype: dict
@return: Field dictionary for L{Query}
"""
- assert len(set(fdef.title.lower()
- for (fdef, _, _) in fields)) == len(fields), \
- "Duplicate title found"
+ if __debug__:
+ duplicates = utils.FindDuplicates(fdef.title.lower()
+ for (fdef, _, _) in fields)
+ assert not duplicates, "Duplicate title(s) found: %r" % duplicates
result = {}
assert FIELD_NAME_RE.match(fdef.name)
assert TITLE_RE.match(fdef.title)
assert callable(fn)
- assert fdef.name not in result, "Duplicate field name found"
+ assert fdef.name not in result, \
+ "Duplicate field name '%s' found" % fdef.name
result[fdef.name] = field
return result
+def GetQueryResponse(query, ctx):
+ """Prepares the response for a query.
+
+ @type query: L{Query}
+ @param ctx: Data container, see L{Query.Query}
+
+ """
+ return objects.QueryResponse(data=query.Query(ctx),
+ fields=query.GetFields()).ToDict()
+
+
+def QueryFields(fielddefs, selected):
+ """Returns list of available fields.
+
+ @type fielddefs: dict
+ @param fielddefs: Field definitions
+ @type selected: list of strings
+ @param selected: List of selected fields
+ @return: List of L{objects.QueryFieldDefinition}
+
+ """
+ if selected is None:
+ # Client requests all fields, sort by name
+ fdefs = utils.NiceSort(GetAllFields(fielddefs.values()),
+ key=operator.attrgetter("name"))
+ else:
+ # Keep order as requested by client
+ fdefs = Query(fielddefs, selected).GetFields()
+
+ return objects.QueryFieldsResponse(fields=fdefs).ToDict()
+
+
def _MakeField(name, title, kind):
"""Wrapper for creating L{objects.QueryFieldDefinition} instances.
return lambda _, item: (constants.QRFS_NORMAL, getter(item))
+def _GetItemTimestamp(getter):
+ """Returns function for getting timestamp of item.
+
+ @type getter: callable
+ @param getter: Function to retrieve timestamp attribute
+
+ """
+ def fn(_, item):
+ """Returns a timestamp of item.
+
+ """
+ timestamp = getter(item)
+ if timestamp is None:
+ # Old configs might not have all timestamps
+ return (constants.QRFS_UNAVAIL, None)
+ else:
+ return (constants.QRFS_NORMAL, timestamp)
+
+ return fn
+
+
+def _GetItemTimestampFields(datatype):
+ """Returns common timestamp fields.
+
+ @param datatype: Field data type for use by L{Query.RequestedData}
+
+ """
+ return [
+ (_MakeField("ctime", "CTime", constants.QFT_TIMESTAMP), datatype,
+ _GetItemTimestamp(operator.attrgetter("ctime"))),
+ (_MakeField("mtime", "MTime", constants.QFT_TIMESTAMP), datatype,
+ _GetItemTimestamp(operator.attrgetter("mtime"))),
+ ]
+
+
class NodeQueryData:
"""Data container for node data queries.
"""
def __init__(self, nodes, live_data, master_name, node_to_primary,
- node_to_secondary, groups):
+ node_to_secondary, groups, oob_support, cluster):
"""Initializes this class.
"""
self.node_to_primary = node_to_primary
self.node_to_secondary = node_to_secondary
self.groups = groups
+ self.oob_support = oob_support
+ self.cluster = cluster
# Used for individual rows
self.curlive_data = None
#: Fields that are direct attributes of an L{objects.Node} object
_NODE_SIMPLE_FIELDS = {
- "ctime": ("CTime", constants.QFT_TIMESTAMP),
"drained": ("Drained", constants.QFT_BOOL),
"master_candidate": ("MasterC", constants.QFT_BOOL),
"master_capable": ("MasterCapable", constants.QFT_BOOL),
- "mtime": ("MTime", constants.QFT_TIMESTAMP),
"name": ("Node", constants.QFT_TEXT),
"offline": ("Offline", constants.QFT_BOOL),
"serial_no": ("SerialNo", constants.QFT_NUMBER),
}
-def _GetNodeGroup(ctx, node):
+def _GetGroup(cb):
+ """Build function for calling another function with an node group.
+
+ @param cb: The callback to be called with the nodegroup
+
+ """
+ def fn(ctx, node):
+ """Get group data for a node.
+
+ @type ctx: L{NodeQueryData}
+ @type inst: L{objects.Node}
+ @param inst: Node object
+
+ """
+ ng = ctx.groups.get(node.group, None)
+ if ng is None:
+ # Nodes always have a group, or the configuration is corrupt
+ return (constants.QRFS_UNAVAIL, None)
+
+ return cb(ctx, node, ng)
+
+ return fn
+
+
+def _GetNodeGroup(ctx, node, ng): # pylint: disable-msg=W0613
"""Returns the name of a node's group.
@type ctx: L{NodeQueryData}
@type node: L{objects.Node}
@param node: Node object
+ @type ng: L{objects.NodeGroup}
+ @param ng: The node group this node belongs to
"""
- ng = ctx.groups.get(node.group, None)
- if ng is None:
- # Nodes always have a group, or the configuration is corrupt
- return (constants.QRFS_UNAVAIL, None)
-
return (constants.QRFS_NORMAL, ng.name)
-def _GetLiveNodeField(field, kind, ctx, _):
+def _GetNodePower(ctx, node):
+ """Returns the node powered state
+
+ @type ctx: L{NodeQueryData}
+ @type node: L{objects.Node}
+ @param node: Node object
+
+ """
+ if ctx.oob_support[node.name]:
+ return (constants.QRFS_NORMAL, node.powered)
+
+ return (constants.QRFS_UNAVAIL, None)
+
+
+def _GetNdParams(ctx, node, ng):
+ """Returns the ndparams for this node.
+
+ @type ctx: L{NodeQueryData}
+ @type node: L{objects.Node}
+ @param node: Node object
+ @type ng: L{objects.NodeGroup}
+ @param ng: The node group this node belongs to
+
+ """
+ return (constants.QRFS_NORMAL, ctx.cluster.SimpleFillND(ng.FillND(node)))
+
+
+def _GetLiveNodeField(field, kind, ctx, node):
"""Gets the value of a "live" field from L{NodeQueryData}.
@param field: Live field name
@param kind: Data kind, one of L{constants.QFT_ALL}
@type ctx: L{NodeQueryData}
+ @type node: L{objects.Node}
+ @param node: Node object
"""
+ if node.offline:
+ return (constants.QRFS_OFFLINE, None)
+
if not ctx.curlive_data:
return (constants.QRFS_NODATA, None)
(_MakeField("role", "Role", constants.QFT_TEXT), NQ_CONFIG,
lambda ctx, node: (constants.QRFS_NORMAL,
_GetNodeRole(node, ctx.master_name))),
- (_MakeField("group", "Group", constants.QFT_TEXT), NQ_GROUP, _GetNodeGroup),
+ (_MakeField("group", "Group", constants.QFT_TEXT), NQ_GROUP,
+ _GetGroup(_GetNodeGroup)),
(_MakeField("group.uuid", "GroupUUID", constants.QFT_TEXT),
NQ_CONFIG, lambda ctx, node: (constants.QRFS_NORMAL, node.group)),
+ (_MakeField("powered", "Powered", constants.QFT_BOOL), NQ_OOB,
+ _GetNodePower),
+ (_MakeField("ndparams", "NodeParameters", constants.QFT_OTHER), NQ_GROUP,
+ _GetGroup(_GetNdParams)),
+ (_MakeField("custom_ndparams", "CustomNodeParameters", constants.QFT_OTHER),
+ NQ_GROUP, lambda ctx, node: (constants.QRFS_NORMAL, node.ndparams)),
]
def _GetLength(getter):
for (name, (title, kind, nfield)) in _NODE_LIVE_FIELDS.items()
])
+ # 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 (constants.QRFS_NODATA, None)
+ else:
+ return (constants.QRFS_NORMAL, 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 (constants.QRFS_NODATA, None)
+
+ if inst.name in ctx.live_data:
+ data = ctx.live_data[inst.name]
+ if name in data:
+ return (constants.QRFS_NORMAL, data[name])
+
+ return (constants.QRFS_UNAVAIL, None)
+
+ 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 (constants.QRFS_NORMAL, "ERROR_nodeoffline")
+
+ if inst.primary_node in ctx.bad_nodes:
+ return (constants.QRFS_NORMAL, "ERROR_nodedown")
+
+ if bool(ctx.live_data.get(inst.name)):
+ if inst.admin_up:
+ return (constants.QRFS_NORMAL, "running")
+ else:
+ return (constants.QRFS_NORMAL, "ERROR_up")
+
+ if inst.admin_up:
+ return (constants.QRFS_NORMAL, "ERROR_down")
+
+ return (constants.QRFS_NORMAL, "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 (constants.QRFS_NORMAL, inst.disks[index].size)
+ except IndexError:
+ return (constants.QRFS_UNAVAIL, None)
+
+ 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 (constants.QRFS_UNAVAIL, None)
+
+ 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 (constants.QRFS_UNAVAIL, None)
+ else:
+ return (constants.QRFS_NORMAL, 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 (constants.QRFS_NORMAL, nicparams[constants.NIC_LINK])
+ else:
+ return (constants.QRFS_UNAVAIL, None)
+
+
+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 (constants.QRFS_NORMAL, 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 (constants.QRFS_NORMAL, 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: (constants.QRFS_NORMAL, nic.mac)
+ nic_mode_fn = _GetInstNicParam(constants.NIC_MODE)
+ nic_link_fn = _GetInstNicParam(constants.NIC_LINK)
+
+ fields = [
+ # First NIC (legacy)
+ (_MakeField("ip", "IP_address", constants.QFT_TEXT), IQ_CONFIG,
+ _GetInstNic(0, _GetInstNicIp)),
+ (_MakeField("mac", "MAC_address", constants.QFT_TEXT), IQ_CONFIG,
+ _GetInstNic(0, nic_mac_fn)),
+ (_MakeField("bridge", "Bridge", constants.QFT_TEXT), IQ_CONFIG,
+ _GetInstNic(0, _GetInstNicBridge)),
+ (_MakeField("nic_mode", "NIC_Mode", constants.QFT_TEXT), IQ_CONFIG,
+ _GetInstNic(0, nic_mode_fn)),
+ (_MakeField("nic_link", "NIC_Link", constants.QFT_TEXT), IQ_CONFIG,
+ _GetInstNic(0, nic_link_fn)),
+
+ # All NICs
+ (_MakeField("nic.count", "NICs", constants.QFT_NUMBER), IQ_CONFIG,
+ lambda ctx, inst: (constants.QRFS_NORMAL, len(inst.nics))),
+ (_MakeField("nic.macs", "NIC_MACs", constants.QFT_OTHER), IQ_CONFIG,
+ lambda ctx, inst: (constants.QRFS_NORMAL, [nic.mac for nic in inst.nics])),
+ (_MakeField("nic.ips", "NIC_IPs", constants.QFT_OTHER), IQ_CONFIG,
+ lambda ctx, inst: (constants.QRFS_NORMAL, [nic.ip for nic in inst.nics])),
+ (_MakeField("nic.modes", "NIC_modes", constants.QFT_OTHER), IQ_CONFIG,
+ lambda ctx, inst: (constants.QRFS_NORMAL,
+ [nicp[constants.NIC_MODE]
+ for nicp in ctx.inst_nicparams])),
+ (_MakeField("nic.links", "NIC_links", constants.QFT_OTHER), IQ_CONFIG,
+ lambda ctx, inst: (constants.QRFS_NORMAL,
+ [nicp[constants.NIC_LINK]
+ for nicp in ctx.inst_nicparams])),
+ (_MakeField("nic.bridges", "NIC_bridges", constants.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, constants.QFT_TEXT),
+ IQ_CONFIG, _GetInstNic(i, _GetInstNicIp)),
+ (_MakeField("nic.mac/%s" % i, "NicMAC/%s" % i, constants.QFT_TEXT),
+ IQ_CONFIG, _GetInstNic(i, nic_mac_fn)),
+ (_MakeField("nic.mode/%s" % i, "NicMode/%s" % i, constants.QFT_TEXT),
+ IQ_CONFIG, _GetInstNic(i, nic_mode_fn)),
+ (_MakeField("nic.link/%s" % i, "NicLink/%s" % i, constants.QFT_TEXT),
+ IQ_CONFIG, _GetInstNic(i, nic_link_fn)),
+ (_MakeField("nic.bridge/%s" % i, "NicBridge/%s" % i, constants.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 (constants.QRFS_NORMAL, usage)
+
+
+def _GetInstanceDiskFields():
+ """Get instance fields involving disks.
+
+ @return: List of field definitions used as input for L{_PrepareFieldList}
+
+ """
+ fields = [
+ (_MakeField("disk_usage", "DiskUsage", constants.QFT_UNIT), IQ_DISKUSAGE,
+ _GetInstDiskUsage),
+ (_MakeField("sda_size", "LegacyDisk/0", constants.QFT_UNIT), IQ_CONFIG,
+ _GetInstDiskSize(0)),
+ (_MakeField("sdb_size", "LegacyDisk/1", constants.QFT_UNIT), IQ_CONFIG,
+ _GetInstDiskSize(1)),
+ (_MakeField("disk.count", "Disks", constants.QFT_NUMBER), IQ_CONFIG,
+ lambda ctx, inst: (constants.QRFS_NORMAL, len(inst.disks))),
+ (_MakeField("disk.sizes", "Disk_sizes", constants.QFT_OTHER), IQ_CONFIG,
+ lambda ctx, inst: (constants.QRFS_NORMAL,
+ [disk.size for disk in inst.disks])),
+ ]
+
+ # Disks by number
+ fields.extend([
+ (_MakeField("disk.size/%s" % i, "Disk/%s" % i, constants.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: "Configured_memory",
+ constants.BE_VCPUS: "VCPUs",
+ }
+
+ 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", constants.QFT_OTHER),
+ IQ_CONFIG, lambda ctx, _: (constants.QRFS_NORMAL, ctx.inst_hvparams)),
+ (_MakeField("beparams", "BackendParameters", constants.QFT_OTHER),
+ IQ_CONFIG, lambda ctx, _: (constants.QRFS_NORMAL, ctx.inst_beparams)),
+ (_MakeField("vcpus", "LegacyVCPUs", constants.QFT_NUMBER), IQ_CONFIG,
+ lambda ctx, _: (constants.QRFS_NORMAL,
+ ctx.inst_beparams[constants.BE_VCPUS])),
+
+ # Unfilled parameters
+ (_MakeField("custom_hvparams", "CustomHypervisorParameters",
+ constants.QFT_OTHER),
+ IQ_CONFIG, lambda ctx, inst: (constants.QRFS_NORMAL, inst.hvparams)),
+ (_MakeField("custom_beparams", "CustomBackendParameters",
+ constants.QFT_OTHER),
+ IQ_CONFIG, lambda ctx, inst: (constants.QRFS_NORMAL, inst.beparams)),
+ (_MakeField("custom_nicparams", "CustomNicParameters",
+ constants.QFT_OTHER),
+ IQ_CONFIG, lambda ctx, inst: (constants.QRFS_NORMAL,
+ [nic.nicparams for nic in inst.nics])),
+ ]
+
+ # HV params
+ def _GetInstHvParam(name):
+ return lambda ctx, _: (constants.QRFS_NORMAL,
+ 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),
+ constants.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, _: (constants.QRFS_NORMAL,
+ 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),
+ constants.QFT_OTHER),
+ IQ_CONFIG, _GetInstBeParam(name))
+ for name in constants.BES_PARAMETERS
+ ])
+
+ return fields
+
+
+_INST_SIMPLE_FIELDS = {
+ "disk_template": ("Disk_template", constants.QFT_TEXT),
+ "hypervisor": ("Hypervisor", constants.QFT_TEXT),
+ "name": ("Node", constants.QFT_TEXT),
+ # Depending on the hypervisor, the port can be None
+ "network_port": ("Network_port", constants.QFT_OTHER),
+ "os": ("OS", constants.QFT_TEXT),
+ "serial_no": ("SerialNo", constants.QFT_NUMBER),
+ "uuid": ("UUID", constants.QFT_TEXT),
+ }
+
+
+def _BuildInstanceFields():
+ """Builds list of fields for instance queries.
+
+ """
+ fields = [
+ (_MakeField("pnode", "Primary_node", constants.QFT_TEXT), IQ_CONFIG,
+ lambda ctx, inst: (constants.QRFS_NORMAL, inst.primary_node)),
+ (_MakeField("snodes", "Secondary_Nodes", constants.QFT_OTHER), IQ_CONFIG,
+ lambda ctx, inst: (constants.QRFS_NORMAL, list(inst.secondary_nodes))),
+ (_MakeField("admin_state", "Autostart", constants.QFT_BOOL), IQ_CONFIG,
+ lambda ctx, inst: (constants.QRFS_NORMAL, inst.admin_up)),
+ (_MakeField("tags", "Tags", constants.QFT_OTHER), IQ_CONFIG,
+ lambda ctx, inst: (constants.QRFS_NORMAL, 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", constants.QFT_BOOL), IQ_LIVE,
+ _GetInstOperState),
+ (_MakeField("oper_ram", "RuntimeMemory", constants.QFT_UNIT), IQ_LIVE,
+ _GetInstLiveData("memory")),
+ (_MakeField("oper_vcpus", "RuntimeVCPUs", constants.QFT_NUMBER), IQ_LIVE,
+ _GetInstLiveData("vcpus")),
+ (_MakeField("status", "Status", constants.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 (constants.QRFS_NORMAL, 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 (constants.QRFS_NORMAL, pending)
+
+
+def _BuildLockFields():
+ """Builds list of fields for lock queries.
+
+ """
+ return _PrepareFieldList([
+ (_MakeField("name", "Name", constants.QFT_TEXT), None,
+ lambda ctx, (name, mode, owners, pending): (constants.QRFS_NORMAL, name)),
+ (_MakeField("mode", "Mode", constants.QFT_OTHER), LQ_MODE,
+ lambda ctx, (name, mode, owners, pending): (constants.QRFS_NORMAL, mode)),
+ (_MakeField("owner", "Owner", constants.QFT_OTHER), LQ_OWNER,
+ _GetLockOwners),
+ (_MakeField("pending", "Pending", constants.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", constants.QFT_TEXT),
+ "name": ("Group", constants.QFT_TEXT),
+ "serial_no": ("SerialNo", constants.QFT_NUMBER),
+ "uuid": ("UUID", constants.QFT_TEXT),
+ "ndparams": ("NDParams", constants.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: (constants.QRFS_NORMAL,
+ len(getter(ctx)[group.uuid]))
+
+ def _GetSortedList(getter):
+ return lambda ctx, group: (constants.QRFS_NORMAL,
+ 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", constants.QFT_NUMBER),
+ GQ_NODE, _GetLength(group_to_nodes)),
+ (_MakeField("node_list", "NodeList", constants.QFT_OTHER),
+ GQ_NODE, _GetSortedList(group_to_nodes)),
+ ])
+
+ # Add fields for instances
+ fields.extend([
+ (_MakeField("pinst_cnt", "Instances", constants.QFT_NUMBER),
+ GQ_INST, _GetLength(group_to_instances)),
+ (_MakeField("pinst_list", "InstanceList", constants.QFT_OTHER),
+ GQ_INST, _GetSortedList(group_to_instances)),
+ ])
+
+ fields.extend(_GetItemTimestampFields(GQ_CONFIG))
+
return _PrepareFieldList(fields)
#: Fields available for node queries
NODE_FIELDS = _BuildNodeFields()
+
+#: Fields available for instance queries
+INSTANCE_FIELDS = _BuildInstanceFields()
+
+#: Fields available for lock queries
+LOCK_FIELDS = _BuildLockFields()
+
+#: Fields available for node group queries
+GROUP_FIELDS = _BuildGroupFields()
+
+#: All available field lists
+ALL_FIELD_LISTS = [NODE_FIELDS, INSTANCE_FIELDS, LOCK_FIELDS, GROUP_FIELDS]
projects / ganeti-local / blobdiff