X-Git-Url: https://code.grnet.gr/git/ganeti-local/blobdiff_plain/89ce4acc135357b803dfb64a93ae256a2f1e3d64..a6682fdcc173998be87b77043bfa56c0d12b1ca4:/lib/query.py?ds=sidebyside diff --git a/lib/query.py b/lib/query.py index 9d64694..86940f3 100644 --- a/lib/query.py +++ b/lib/query.py @@ -19,7 +19,36 @@ # 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 @@ -33,10 +62,27 @@ from ganeti import objects 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/._]+$") @@ -200,7 +246,7 @@ def _PrepareFieldList(fields): @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} @@ -231,6 +277,38 @@ def _PrepareFieldList(fields): 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. @@ -273,12 +351,47 @@ def _GetItemAttr(attr): 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. """ @@ -288,6 +401,8 @@ class NodeQueryData: 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 @@ -309,11 +424,9 @@ class NodeQueryData: #: 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), @@ -336,30 +449,83 @@ _NODE_LIVE_FIELDS = { } -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) @@ -398,9 +564,16 @@ def _BuildNodeFields(): (_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): @@ -435,8 +608,643 @@ def _BuildNodeFields(): 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]