Try to prevent instance memory changes N+1 failures

[ganeti-local] / lib / config.py

diff --git a/lib/config.py b/lib/config.py
index 51e9d1a..fe580ef 100644 (file)
--- a/lib/config.py
+++ b/lib/config.py
@@ -367,6 +367,7 @@ class ConfigWriter:
         configuration errors
 
     """
+    # pylint: disable-msg=R0914
     result = []
     seen_macs = []
     ports = {}
@@ -392,6 +393,27 @@ class ConfigWriter:
       result.append("cluster has invalid primary node '%s'" %
                     cluster.master_node)
 
+    def _helper(owner, attr, value, template):
+      try:
+        utils.ForceDictType(value, template)
+      except errors.GenericError, err:
+        result.append("%s has invalid %s: %s" % (owner, attr, err))
+
+    def _helper_nic(owner, params):
+      try:
+        objects.NIC.CheckParameterSyntax(params)
+      except errors.ConfigurationError, err:
+        result.append("%s has invalid nicparams: %s" % (owner, err))
+
+    # check cluster parameters
+    _helper("cluster", "beparams", cluster.SimpleFillBE({}),
+            constants.BES_PARAMETER_TYPES)
+    _helper("cluster", "nicparams", cluster.SimpleFillNIC({}),
+            constants.NICS_PARAMETER_TYPES)
+    _helper_nic("cluster", cluster.SimpleFillNIC({}))
+    _helper("cluster", "ndparams", cluster.SimpleFillND({}),
+            constants.NDS_PARAMETER_TYPES)
+
     # per-instance checks
     for instance_name in data.instances:
       instance = data.instances[instance_name]
@@ -411,6 +433,17 @@ class ConfigWriter:
                         (instance_name, idx, nic.mac))
         else:
           seen_macs.append(nic.mac)
+        if nic.nicparams:
+          filled = cluster.SimpleFillNIC(nic.nicparams)
+          owner = "instance %s nic %d" % (instance.name, idx)
+          _helper(owner, "nicparams",
+                  filled, constants.NICS_PARAMETER_TYPES)
+          _helper_nic(owner, filled)
+
+      # parameter checks
+      if instance.beparams:
+        _helper("instance %s" % instance.name, "beparams",
+                cluster.FillBE(instance), constants.BES_PARAMETER_TYPES)
 
       # gather the drbd ports for duplicate checks
       for dsk in instance.disks:
@@ -472,6 +505,13 @@ class ConfigWriter:
                       " drain=%s, offline=%s" %
                       (node.name, node.master_candidate, node.drained,
                        node.offline))
+      if node.group not in data.nodegroups:
+        result.append("Node '%s' has invalid group '%s'" %
+                      (node.name, node.group))
+      else:
+        _helper("node %s" % node.name, "ndparams",
+                cluster.FillND(node, data.nodegroups[node.group]),
+                constants.NDS_PARAMETER_TYPES)
 
     # nodegroups checks
     nodegroups_names = set()
@@ -487,6 +527,11 @@ class ConfigWriter:
         result.append("duplicate node group name '%s'" % nodegroup.name)
       else:
         nodegroups_names.add(nodegroup.name)
+      if nodegroup.ndparams:
+        _helper("group %s" % nodegroup.name, "ndparams",
+                cluster.SimpleFillND(nodegroup.ndparams),
+                constants.NDS_PARAMETER_TYPES)
+
 
     # drbd minors check
     _, duplicates = self._UnlockedComputeDRBDMap()
@@ -897,6 +942,16 @@ class ConfigWriter:
     if check_uuid:
       self._EnsureUUID(group, ec_id)
 
+    try:
+      existing_uuid = self._UnlockedLookupNodeGroup(group.name)
+    except errors.OpPrereqError:
+      pass
+    else:
+      raise errors.OpPrereqError("Desired group name '%s' already exists as a"
+                                 " node group (UUID: %s)" %
+                                 (group.name, existing_uuid),
+                                 errors.ECODE_EXISTS)
+
     group.serial_no = 1
     group.ctime = group.mtime = time.time()
     group.UpgradeConfig()
@@ -924,8 +979,7 @@ class ConfigWriter:
     self._config_data.cluster.serial_no += 1
     self._WriteConfig()
 
-  @locking.ssynchronized(_config_lock, shared=1)
-  def LookupNodeGroup(self, target):
+  def _UnlockedLookupNodeGroup(self, target):
     """Lookup a node group's UUID.
 
     @type target: string or None
@@ -949,6 +1003,20 @@ class ConfigWriter:
     raise errors.OpPrereqError("Node group '%s' not found" % target,
                                errors.ECODE_NOENT)
 
+  @locking.ssynchronized(_config_lock, shared=1)
+  def LookupNodeGroup(self, target):
+    """Lookup a node group's UUID.
+
+    This function is just a wrapper over L{_UnlockedLookupNodeGroup}.
+
+    @type target: string or None
+    @param target: group name or UUID or None to look for the default
+    @rtype: string
+    @return: nodegroup UUID
+
+    """
+    return self._UnlockedLookupNodeGroup(target)
+
   def _UnlockedGetNodeGroup(self, uuid):
     """Lookup a node group.
 
@@ -1332,6 +1400,17 @@ class ConfigWriter:
                     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.