# 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/._]+$")
TITLE_RE = re.compile(r"^[^\s]+$")
@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}
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.
"""
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
}
-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):
@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:
"""
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:
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