"""
-# pylint: disable-msg=R0904
+# pylint: disable=R0904
# R0904: Too many public methods
import os
def GetNdParams(self, node):
"""Get the node params populated with cluster defaults.
- @type node: L{object.Node}
+ @type node: L{objects.Node}
@param node: The node we want to know the params for
@return: A dict with the filled in node params
if mac in all_macs:
raise errors.ReservationError("mac already in use")
else:
- self._temporary_macs.Reserve(mac, ec_id)
+ self._temporary_macs.Reserve(ec_id, mac)
@locking.ssynchronized(_config_lock, shared=1)
def ReserveLV(self, lv_name, ec_id):
if lv_name in all_lvs:
raise errors.ReservationError("LV already in use")
else:
- self._temporary_lvs.Reserve(lv_name, ec_id)
+ self._temporary_lvs.Reserve(ec_id, lv_name)
@locking.ssynchronized(_config_lock, shared=1)
def GenerateDRBDSecret(self, ec_id):
configuration errors
"""
- # pylint: disable-msg=R0914
+ # pylint: disable=R0914
result = []
seen_macs = []
ports = {}
cluster.SimpleFillND(nodegroup.ndparams),
constants.NDS_PARAMETER_TYPES)
-
# drbd minors check
_, duplicates = self._UnlockedComputeDRBDMap()
for node, minor, instance_a, instance_b in duplicates:
"""
return self._config_data.nodegroups.keys()
+ @locking.ssynchronized(_config_lock, shared=1)
+ def GetNodeGroupMembersByNodes(self, nodes):
+ """Get nodes which are member in the same nodegroups as the given nodes.
+
+ """
+ ngfn = lambda node_name: self._UnlockedGetNodeInfo(node_name).group
+ return frozenset(member_name
+ for node_name in nodes
+ for member_name in
+ self._UnlockedGetNodeGroup(ngfn(node_name)).members)
+
@locking.ssynchronized(_config_lock)
def AddInstance(self, instance, ec_id):
"""Add an instance to the config.
return self._UnlockedGetInstanceInfo(instance_name)
@locking.ssynchronized(_config_lock, shared=1)
+ def GetInstanceNodeGroups(self, instance_name, primary_only=False):
+ """Returns set of node group UUIDs for instance's nodes.
+
+ @rtype: frozenset
+
+ """
+ instance = self._UnlockedGetInstanceInfo(instance_name)
+ if not instance:
+ raise errors.ConfigurationError("Unknown instance '%s'" % instance_name)
+
+ if primary_only:
+ nodes = [instance.primary_node]
+ else:
+ nodes = instance.all_nodes
+
+ return frozenset(self._UnlockedGetNodeInfo(node_name).group
+ for node_name in nodes)
+
+ @locking.ssynchronized(_config_lock, shared=1)
+ def GetMultiInstanceInfo(self, instances):
+ """Get the configuration of multiple instances.
+
+ @param instances: list of instance names
+ @rtype: list
+ @return: list of tuples (instance, instance_info), where
+ instance_info is what would GetInstanceInfo return for the
+ node, while keeping the original order
+
+ """
+ return [(name, self._UnlockedGetInstanceInfo(name)) for name in instances]
+
+ @locking.ssynchronized(_config_lock, shared=1)
def GetAllInstancesInfo(self):
"""Get the configuration of all instances.
sec.append(inst.name)
return (pri, sec)
+ @locking.ssynchronized(_config_lock, shared=1)
+ def GetNodeGroupInstances(self, uuid, primary_only=False):
+ """Get the instances of a node group.
+
+ @param uuid: Node group UUID
+ @param primary_only: Whether to only consider primary nodes
+ @rtype: frozenset
+ @return: List of instance names in node group
+
+ """
+ if primary_only:
+ nodes_fn = lambda inst: [inst.primary_node]
+ else:
+ nodes_fn = lambda inst: inst.all_nodes
+
+ return frozenset(inst.name
+ for inst in self._config_data.instances.values()
+ for node_name in nodes_fn(inst)
+ if self._UnlockedGetNodeInfo(node_name).group == uuid)
+
def _UnlockedGetNodeList(self):
"""Return the list of nodes which are in the configuration.
return [node.name for node in all_nodes if not node.vm_capable]
@locking.ssynchronized(_config_lock, shared=1)
+ def GetMultiNodeInfo(self, nodes):
+ """Get the configuration of multiple nodes.
+
+ @param nodes: list of node names
+ @rtype: list
+ @return: list of tuples of (node, node_info), where node_info is
+ what would GetNodeInfo return for the node, in the original
+ order
+
+ """
+ return [(name, self._UnlockedGetNodeInfo(name)) for name in nodes]
+
+ @locking.ssynchronized(_config_lock, shared=1)
def GetAllNodesInfo(self):
"""Get the configuration of all nodes.
for node in self._UnlockedGetNodeList()])
return my_dict
+ @locking.ssynchronized(_config_lock, shared=1)
+ def GetNodeGroupsFromNodes(self, nodes):
+ """Returns groups for a list of nodes.
+
+ @type nodes: list of string
+ @param nodes: List of node names
+ @rtype: frozenset
+
+ """
+ return frozenset(self._UnlockedGetNodeInfo(name).group for name in nodes)
+
def _UnlockedGetMasterCandidateStats(self, exceptions=None):
"""Get the number of current and maximum desired and possible candidates.