_SERIAL_NO_DOC = "%s object serial number, incremented on each modification"
-def _GetUnknownField(ctx, item): # pylint: disable-msg=W0613
+def _GetUnknownField(ctx, item): # pylint: disable=W0613
"""Gets the contents of an unknown field.
"""
if op != qlang.OP_OR:
self._NeedAllNames()
- def NoteUnaryOp(self, op): # pylint: disable-msg=W0613
+ def NoteUnaryOp(self, op): # pylint: disable=W0613
"""Called when handling an unary operation.
@type op: string
"""Converts a query filter to a callable usable for filtering.
"""
- # String statement has no effect, pylint: disable-msg=W0105
+ # String statement has no effect, pylint: disable=W0105
#: How deep filters can be nested
_LEVELS_MAX = 10
self._hints = None
self._op_handler = None
- def __call__(self, hints, filter_):
+ def __call__(self, hints, qfilter):
"""Converts a query filter into a callable function.
@type hints: L{_FilterHints} or None
@param hints: Callbacks doing analysis on filter
- @type filter_: list
- @param filter_: Filter structure
+ @type qfilter: list
+ @param qfilter: Filter structure
@rtype: callable
@return: Function receiving context and item as parameters, returning
boolean as to whether item matches filter
}
try:
- filter_fn = self._Compile(filter_, 0)
+ filter_fn = self._Compile(qfilter, 0)
finally:
self._op_handler = None
return filter_fn
- def _Compile(self, filter_, level):
+ def _Compile(self, qfilter, level):
"""Inner function for converting filters.
Calls the correct handler functions for the top-level operator. This
function is called recursively (e.g. for logic operators).
"""
- if not (isinstance(filter_, (list, tuple)) and filter_):
+ if not (isinstance(qfilter, (list, tuple)) and qfilter):
raise errors.ParameterError("Invalid filter on level %s" % level)
# Limit recursion
" nested too deep)" % self._LEVELS_MAX)
# Create copy to be modified
- operands = filter_[:]
+ operands = qfilter[:]
op = operands.pop(0)
try:
@param operands: List of operands
"""
- # Unused arguments, pylint: disable-msg=W0613
+ # Unused arguments, pylint: disable=W0613
try:
(name, value) = operands
except (ValueError, TypeError):
" (op '%s', flags %s)" % (op, field_flags))
-def _CompileFilter(fields, hints, filter_):
+def _CompileFilter(fields, hints, qfilter):
"""Converts a query filter into a callable function.
See L{_FilterCompilerHelper} for details.
@rtype: callable
"""
- return _FilterCompilerHelper(fields)(hints, filter_)
+ return _FilterCompilerHelper(fields)(hints, qfilter)
class Query:
- def __init__(self, fieldlist, selected, filter_=None, namefield=None):
+ def __init__(self, fieldlist, selected, qfilter=None, namefield=None):
"""Initializes this class.
The field definition is a dictionary with the field's name as a key and a
self._requested_names = None
self._filter_datakinds = frozenset()
- if filter_ is not None:
+ if qfilter is not None:
# Collect requested names if wanted
if namefield:
hints = _FilterHints(namefield)
hints = None
# Build filter function
- self._filter_fn = _CompileFilter(fieldlist, hints, filter_)
+ self._filter_fn = _CompileFilter(fieldlist, hints, qfilter)
if hints:
self._requested_names = hints.RequestedNames()
self._filter_datakinds = hints.ReferencedData()
elif value is not None:
errs.append("abnormal field %s has a non-None value" % fdef.name)
assert not errs, ("Failed validation: %s in row %s" %
- (utils.CommaJoin(errors), row))
+ (utils.CommaJoin(errs), row))
+
+
+def _FieldDictKey((fdef, _, flags, fn)):
+ """Generates key for field dictionary.
+
+ """
+ assert fdef.name and fdef.title, "Name and title are required"
+ assert FIELD_NAME_RE.match(fdef.name)
+ assert TITLE_RE.match(fdef.title)
+ assert (DOC_RE.match(fdef.doc) and len(fdef.doc.splitlines()) == 1 and
+ fdef.doc.strip() == fdef.doc), \
+ "Invalid description for field '%s'" % fdef.name
+ assert callable(fn)
+ assert (flags & ~QFF_ALL) == 0, "Unknown flags for field '%s'" % fdef.name
+
+ return fdef.name
def _PrepareFieldList(fields, aliases):
for (fdef, _, _, _) in fields)
assert not duplicates, "Duplicate title(s) found: %r" % duplicates
- result = {}
-
- for field in fields:
- (fdef, _, flags, fn) = field
-
- assert fdef.name and fdef.title, "Name and title are required"
- assert FIELD_NAME_RE.match(fdef.name)
- assert TITLE_RE.match(fdef.title)
- assert (DOC_RE.match(fdef.doc) and len(fdef.doc.splitlines()) == 1 and
- fdef.doc.strip() == fdef.doc), \
- "Invalid description for field '%s'" % fdef.name
- assert callable(fn)
- assert fdef.name not in result, \
- "Duplicate field name '%s' found" % fdef.name
- assert (flags & ~QFF_ALL) == 0, "Unknown flags for field '%s'" % fdef.name
-
- result[fdef.name] = field
+ result = utils.SequenceToDict(fields, key=_FieldDictKey)
for alias, target in aliases:
assert alias not in result, "Alias %s overrides an existing field" % alias
return fn
-def _GetNodeGroup(ctx, node, ng): # pylint: disable-msg=W0613
+def _GetNodeGroup(ctx, node, ng): # pylint: disable=W0613
"""Returns the name of a node's group.
@type ctx: L{NodeQueryData}
return _FS_UNAVAIL
+def _GetNodeHvState(_, node):
+ """Converts node's hypervisor state for query result.
+
+ """
+ hv_state = node.hv_state
+
+ if hv_state is None:
+ return _FS_UNAVAIL
+
+ return dict((name, value.ToDict()) for (name, value) in hv_state.items())
+
+
+def _GetNodeDiskState(_, node):
+ """Converts node's disk state for query result.
+
+ """
+ disk_state = node.disk_state
+
+ if disk_state is None:
+ return _FS_UNAVAIL
+
+ return dict((disk_kind, dict((name, value.ToDict())
+ for (name, value) in kind_state.items()))
+ for (disk_kind, kind_state) in disk_state.items())
+
+
def _BuildNodeFields():
"""Builds list of fields for node queries.
(_MakeField("custom_ndparams", "CustomNodeParameters", QFT_OTHER,
"Custom node parameters"),
NQ_GROUP, 0, _GetItemAttr("ndparams")),
+ (_MakeField("hv_state", "HypervisorState", QFT_OTHER, "Hypervisor state"),
+ NQ_CONFIG, 0, _GetNodeHvState),
+ (_MakeField("disk_state", "DiskState", QFT_OTHER, "Disk state"),
+ NQ_CONFIG, 0, _GetNodeDiskState),
]
# Node role
if bool(ctx.live_data.get(inst.name)):
if inst.name in ctx.wrongnode_inst:
return constants.INSTST_WRONGNODE
- elif inst.admin_up:
+ elif inst.admin_state == constants.ADMINST_UP:
return constants.INSTST_RUNNING
else:
return constants.INSTST_ERRORUP
- if inst.admin_up:
+ if inst.admin_state == constants.ADMINST_UP:
return constants.INSTST_ERRORDOWN
+ elif inst.admin_state == constants.ADMINST_DOWN:
+ return constants.INSTST_ADMINDOWN
- return constants.INSTST_ADMINDOWN
+ return constants.INSTST_ADMINOFFLINE
def _GetInstDiskSize(index):
return fn
-def _GetInstNicIp(ctx, _, nic): # pylint: disable-msg=W0613
+def _GetInstNicIp(ctx, _, nic): # pylint: disable=W0613
"""Get a NIC's IP address.
@type ctx: L{InstanceQueryData}
# TODO: Consider moving titles closer to constants
be_title = {
constants.BE_AUTO_BALANCE: "Auto_balance",
- constants.BE_MEMORY: "ConfigMemory",
+ constants.BE_MAXMEM: "ConfigMaxMem",
+ constants.BE_MINMEM: "ConfigMinMem",
constants.BE_VCPUS: "ConfigVCPUs",
}
IQ_NODES, 0,
lambda ctx, inst: map(compat.partial(_GetInstNodeGroup, ctx, None),
inst.secondary_nodes)),
- (_MakeField("admin_state", "Autostart", QFT_BOOL,
- "Desired state of instance (if set, the instance should be"
- " up)"),
- IQ_CONFIG, 0, _GetItemAttr("admin_up")),
+ (_MakeField("admin_state", "InstanceState", QFT_TEXT,
+ "Desired state of instance"),
+ IQ_CONFIG, 0, _GetItemAttr("admin_state")),
+ (_MakeField("admin_up", "Autostart", QFT_BOOL,
+ "Desired state of instance"),
+ IQ_CONFIG, 0, lambda ctx, inst: inst.admin_state == constants.ADMINST_UP),
(_MakeField("tags", "Tags", QFT_OTHER, "Tags"), IQ_CONFIG, 0,
lambda ctx, inst: list(inst.GetTags())),
(_MakeField("console", "Console", QFT_OTHER,
status_values = (constants.INSTST_RUNNING, constants.INSTST_ADMINDOWN,
constants.INSTST_WRONGNODE, constants.INSTST_ERRORUP,
constants.INSTST_ERRORDOWN, constants.INSTST_NODEDOWN,
- constants.INSTST_NODEOFFLINE)
+ constants.INSTST_NODEOFFLINE, constants.INSTST_ADMINOFFLINE)
status_doc = ("Instance status; \"%s\" if instance is set to be running"
" and actually is, \"%s\" if instance is stopped and"
" is not running, \"%s\" if instance running, but not on its"
" designated primary node, \"%s\" if instance should be"
" stopped, but is actually running, \"%s\" if instance should"
" run, but doesn't, \"%s\" if instance's primary node is down,"
- " \"%s\" if instance's primary node is marked offline" %
- status_values)
+ " \"%s\" if instance's primary node is marked offline,"
+ " \"%s\" if instance is offline and does not use dynamic"
+ " resources" % status_values)
fields.append((_MakeField("status", "Status", QFT_TEXT, status_doc),
IQ_LIVE, 0, _GetInstStatus))
assert set(status_values) == constants.INSTST_ALL, \
aliases = [
("vcpus", "be/vcpus"),
+ ("be/memory", "be/maxmem"),
("sda_size", "disk.size/0"),
("sdb_size", "disk.size/1"),
] + network_aliases
"""Data container for node group data queries.
"""
- def __init__(self, groups, group_to_nodes, group_to_instances):
+ def __init__(self, cluster, groups, group_to_nodes, group_to_instances):
"""Initializes this class.
+ @param cluster: Cluster object
@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
self.groups = groups
self.group_to_nodes = group_to_nodes
self.group_to_instances = group_to_instances
+ self.cluster = cluster
+
+ # Used for individual rows
+ self.group_ipolicy = None
def __iter__(self):
"""Iterate over all node groups.
+ This function has side-effects and only one instance of the resulting
+ generator should be used at a time.
+
"""
- return iter(self.groups)
+ for group in self.groups:
+ self.group_ipolicy = self.cluster.SimpleFillIPolicy(group.ipolicy)
+ yield group
_GROUP_SIMPLE_FIELDS = {
fields.extend([
(_MakeField("tags", "Tags", QFT_OTHER, "Tags"), GQ_CONFIG, 0,
lambda ctx, group: list(group.GetTags())),
+ (_MakeField("ipolicy", "InstancePolicy", QFT_OTHER,
+ "Instance policy limitations (merged)"),
+ GQ_CONFIG, 0, lambda ctx, _: ctx.group_ipolicy),
+ (_MakeField("custom_ipolicy", "CustomInstancePolicy", QFT_OTHER,
+ "Custom instance policy limitations"),
+ GQ_CONFIG, 0, _GetItemAttr("ipolicy")),
])
fields.extend(_GetItemTimestampFields(GQ_CONFIG))