Merge branch 'stable-2.12' into stable-2.13

* stable-2.12 Check disk size ipolicy during "gnt-instance grow-disk" Test function ComputeIPolicyDiskSizesViolation Add a helper function for checking the disk size ipolicy Add "ignore-ipolicy" option to gnt-instance grow-disk Fix the installation instructions for the DRBD module Update install docs - DRBD module parameters * stable-2.11 (no changes) * stable-2.10 Fix hlint warnings found by hlint 1.9.11 Only check header for non-generated files Signed-off-by: Klaus Aehlig <[email protected]> Reviewed-by: Petr Pudlak <[email protected]>
nh2 · Dec 2, 2014 · 51620a2 · 51620a2
2 parents 1e25ff0 + f1e2d4f
commit 51620a2
Show file tree

Hide file tree

Showing 9 changed files with 142 additions and 7 deletions.
diff --git a/Makefile.am b/Makefile.am
@@ -2402,7 +2402,8 @@ check-news:
 .PHONY: check-local
 check-local: check-dirs check-news $(GENERATED_FILES)
 	$(CHECK_PYTHON_CODE) $(check_python_code)
-	PYTHONPATH=. $(CHECK_HEADER) $(check_python_code)
+	PYTHONPATH=. $(CHECK_HEADER) \
+	    $(filter-out $(GENERATED_FILES),$(check_python_code))
 	$(CHECK_VERSION) $(VERSION) $(top_srcdir)/NEWS
 	PYTHONPATH=. $(RUN_IN_TEMPDIR) $(CURDIR)/$(CHECK_IMPORTS) . $(standalone_python_modules)
 	error= ; \

diff --git a/doc/install.rst b/doc/install.rst
@@ -286,9 +286,11 @@ instances on a node.
 
    Then to configure it for Ganeti::
 
-     $ echo drbd minor_count=128 usermode_helper=/bin/true >> /etc/modules
+     $ echo "options drbd minor_count=128 usermode_helper=/bin/true" \
+        > /etc/modprobe.d/drbd.conf
+     $ echo "drbd" >> /etc/modules
      $ depmod -a
-     $ modprobe drbd minor_count=128 usermode_helper=/bin/true
+     $ modprobe drbd
 
    It is also recommended that you comment out the default resources (if any)
    in the ``/etc/drbd.conf`` file, so that the init script doesn't try to

diff --git a/lib/client/gnt_instance.py b/lib/client/gnt_instance.py
@@ -608,7 +608,9 @@ def GrowDisk(opts, args):
   op = opcodes.OpInstanceGrowDisk(instance_name=instance,
                                   disk=disk, amount=amount,
                                   wait_for_sync=opts.wait_for_sync,
-                                  absolute=opts.absolute)
+                                  absolute=opts.absolute,
+                                  ignore_ipolicy=opts.ignore_ipolicy
+                                  )
   SubmitOrSend(op, opts)
   return 0
 
@@ -1688,7 +1690,8 @@ def ChangeGroup(opts, args):
     GrowDisk,
     [ArgInstance(min=1, max=1), ArgUnknown(min=1, max=1),
      ArgUnknown(min=1, max=1)],
-    SUBMIT_OPTS + [NWSYNC_OPT, DRY_RUN_OPT, PRIORITY_OPT, ABSOLUTE_OPT],
+    SUBMIT_OPTS +
+    [NWSYNC_OPT, DRY_RUN_OPT, PRIORITY_OPT, ABSOLUTE_OPT, IGNORE_IPOLICY_OPT],
     "<instance> <disk> <size>", "Grow an instance's disk"),
   "change-group": (
     ChangeGroup, ARGS_ONE_INSTANCE,

diff --git a/lib/cmdlib/common.py b/lib/cmdlib/common.py
@@ -602,6 +602,33 @@ def ComputeIPolicySpecViolation(ipolicy, mem_size, cpu_count, disk_count,
   return ret + min_errs
 
 
+def ComputeIPolicyDiskSizesViolation(ipolicy, disk_sizes,
+                                     disk_template,
+                                     _compute_fn=_ComputeMinMaxSpec):
+  """Verifies ipolicy against provided disk sizes.
+
+  No other specs except the disk sizes, the number of disks and the disk
+  template are checked.
+
+  @type ipolicy: dict
+  @param ipolicy: The ipolicy
+  @type disk_sizes: list of ints
+  @param disk_sizes: Disk sizes of used disk (len must match C{disk_count})
+  @type disk_template: string
+  @param disk_template: The disk template of the instance
+  @param _compute_fn: The compute function (unittest only)
+  @return: A list of violations, or an empty list of no violations are found
+
+  """
+  return ComputeIPolicySpecViolation(ipolicy,
+                                     # mem_size, cpu_count, disk_count
+                                     None, None, len(disk_sizes),
+                                     None, disk_sizes, # nic_count, disk_sizes
+                                     None, # spindle_use
+                                     disk_template,
+                                     _compute_fn=_compute_fn)
+
+
 def ComputeIPolicyInstanceViolation(ipolicy, instance, cfg,
                                     _compute_fn=ComputeIPolicySpecViolation):
   """Compute if instance meets the specs of ipolicy.

diff --git a/lib/cmdlib/instance_storage.py b/lib/cmdlib/instance_storage.py
@@ -47,6 +47,7 @@
 from ganeti.cmdlib.base import LogicalUnit, NoHooksLU, Tasklet
 from ganeti.cmdlib.common import INSTANCE_DOWN, INSTANCE_NOT_RUNNING, \
   AnnotateDiskParams, CheckIAllocatorOrNode, ExpandNodeUuidAndName, \
+  ComputeIPolicyDiskSizesViolation, \
   CheckNodeOnline, CheckInstanceNodeGroups, CheckInstanceState, \
   IsExclusiveStorageEnabledNode, FindFaultyInstanceDisks, GetWantedNodes, \
   CheckDiskTemplateEnabled
@@ -1706,6 +1707,8 @@ def CheckPrereq(self):
 
     self._CheckDiskSpace(node_uuids, self.disk.ComputeGrowth(self.delta))
 
+    self._CheckIPolicy(self.target)
+
   def _CheckDiskSpace(self, node_uuids, req_vgspace):
     template = self.instance.disk_template
     if (template not in (constants.DTS_NO_FREE_SPACE_CHECK) and
@@ -1717,6 +1720,29 @@ def _CheckDiskSpace(self, node_uuids, req_vgspace):
       # the dry run performed in Exec() instead.
       CheckNodesFreeDiskPerVG(self, node_uuids, req_vgspace)
 
+  def _CheckIPolicy(self, target_size):
+    cluster = self.cfg.GetClusterInfo()
+    group_uuid = list(self.cfg.GetInstanceNodeGroups(self.op.instance_uuid,
+                                                     primary_only=True))[0]
+    group_info = self.cfg.GetNodeGroup(group_uuid)
+    ipolicy = ganeti.masterd.instance.CalculateGroupIPolicy(cluster,
+                                                            group_info)
+
+    disk_sizes = [disk.size if disk.uuid != self.disk.uuid else target_size
+                  for disk in self.cfg.GetInstanceDisks(self.op.instance_uuid)]
+
+    # The ipolicy checker below ignores None, so we only give it the disk size
+    res = ComputeIPolicyDiskSizesViolation(ipolicy, disk_sizes,
+                                           self.instance.disk_template)
+    if res:
+      msg = ("Growing disk %s violates policy: %s" %
+             (self.op.disk,
+              utils.CommaJoin(res)))
+      if self.op.ignore_ipolicy:
+        self.LogWarning(msg)
+      else:
+        raise errors.OpPrereqError(msg, errors.ECODE_INVAL)
+
   def Exec(self, feedback_fn):
     """Execute disk grow.
 

diff --git a/lib/tools/burnin.py b/lib/tools/burnin.py
@@ -667,7 +667,8 @@ def BurnGrowDisks(self):
       for idx, growth in enumerate(self.disk_growth):
         if growth > 0:
           op = opcodes.OpInstanceGrowDisk(instance_name=instance, disk=idx,
-                                          amount=growth, wait_for_sync=True)
+                                          amount=growth, wait_for_sync=True,
+                                          ignore_ipolicy=True)
           Log("increase disk/%s by %s MB", idx, growth, indent=2)
           self.ExecOrQueue(instance, [op])
 

diff --git a/src/Ganeti/OpCodes.hs b/src/Ganeti/OpCodes.hs
@@ -702,6 +702,7 @@ $(genOpCode "OpCode"
      , pDiskIndex
      , pDiskChgAmount
      , pDiskChgAbsolute
+     , pIgnoreIpolicy
      ],
      "instance_name")
   , ("OpInstanceChangeGroup",

diff --git a/test/hs/Test/Ganeti/OpCodes.hs b/test/hs/Test/Ganeti/OpCodes.hs
@@ -421,7 +421,7 @@ instance Arbitrary OpCodes.OpCode where
           <*> arbitrary                       -- instance_communication
       "OP_INSTANCE_GROW_DISK" ->
         OpCodes.OpInstanceGrowDisk <$> genFQDN <*> return Nothing <*>
-          arbitrary <*> arbitrary <*> arbitrary <*> arbitrary
+          arbitrary <*> arbitrary <*> arbitrary <*> arbitrary <*> arbitrary
       "OP_INSTANCE_CHANGE_GROUP" ->
         OpCodes.OpInstanceChangeGroup <$> genFQDN <*> return Nothing <*>
           arbitrary <*> genMaybe genNameNE <*>

diff --git a/test/py/cmdlib/cmdlib_unittest.py b/test/py/cmdlib/cmdlib_unittest.py
@@ -557,6 +557,80 @@ def AssertComputeViolation(ipolicy, violations):
     AssertComputeViolation(ipolicy1, 1)
 
 
+class TestComputeIPolicyDiskSizesViolation(unittest.TestCase):
+  # Minimal policy accepted by _ComputeIPolicyDiskSizesViolation()
+  _MICRO_IPOL = {
+    constants.IPOLICY_DTS: [constants.DT_PLAIN, constants.DT_DISKLESS],
+    constants.ISPECS_MINMAX: [NotImplemented],
+    }
+
+  def test(self):
+    compute_fn = _ValidateComputeMinMaxSpec
+    ret = common.ComputeIPolicyDiskSizesViolation(self._MICRO_IPOL, [1024],
+                                                  constants.DT_PLAIN,
+                                                  _compute_fn=compute_fn)
+    self.assertEqual(ret, [])
+
+  def testDiskFull(self):
+    compute_fn = _NoDiskComputeMinMaxSpec
+    ret = common.ComputeIPolicyDiskSizesViolation(self._MICRO_IPOL, [1024],
+                                                  constants.DT_PLAIN,
+                                                  _compute_fn=compute_fn)
+    self.assertEqual(ret, [constants.ISPEC_DISK_COUNT])
+
+  def testDiskLess(self):
+    compute_fn = _NoDiskComputeMinMaxSpec
+    ret = common.ComputeIPolicyDiskSizesViolation(self._MICRO_IPOL, [1024],
+                                                  constants.DT_DISKLESS,
+                                                  _compute_fn=compute_fn)
+    self.assertEqual(ret, [])
+
+  def testWrongTemplates(self):
+    compute_fn = _ValidateComputeMinMaxSpec
+    ret = common.ComputeIPolicyDiskSizesViolation(self._MICRO_IPOL, [1024],
+                                                  constants.DT_DRBD8,
+                                                  _compute_fn=compute_fn)
+    self.assertEqual(len(ret), 1)
+    self.assertTrue("Disk template" in ret[0])
+
+  def _AssertComputeViolation(self, ipolicy, disk_sizes, disk_template,
+                              violations):
+    ret = common.ComputeIPolicyDiskSizesViolation(ipolicy, disk_sizes,
+                                                  disk_template)
+    self.assertEqual(len(ret), violations)
+
+  def testWithIPolicy(self):
+    mem_size = 2048
+    cpu_count = 2
+    disk_count = 1
+    disk_sizes = [512]
+    nic_count = 1
+    spindle_use = 4
+    disk_template = "mytemplate"
+    ispec = {
+      constants.ISPEC_MEM_SIZE: mem_size,
+      constants.ISPEC_CPU_COUNT: cpu_count,
+      constants.ISPEC_DISK_COUNT: disk_count,
+      constants.ISPEC_DISK_SIZE: disk_sizes[0],
+      constants.ISPEC_NIC_COUNT: nic_count,
+      constants.ISPEC_SPINDLE_USE: spindle_use,
+      }
+
+    ipolicy = {
+      constants.ISPECS_MINMAX: [{
+        constants.ISPECS_MIN: ispec,
+        constants.ISPECS_MAX: ispec,
+        }],
+      constants.IPOLICY_DTS: [disk_template],
+      }
+
+    self._AssertComputeViolation(ipolicy, [512], disk_template, 0)
+    self._AssertComputeViolation(ipolicy, [], disk_template, 1)
+    self._AssertComputeViolation(ipolicy, [512, 512], disk_template, 1)
+    self._AssertComputeViolation(ipolicy, [511], disk_template, 1)
+    self._AssertComputeViolation(ipolicy, [513], disk_template, 1)
+
+
 class _StubComputeIPolicySpecViolation:
   def __init__(self, mem_size, cpu_count, disk_count, nic_count, disk_sizes,
                spindle_use, disk_template):