Synnefo » snf-ganeti

def _WipeDisks(lu, instance, disks=None):

  if disks is None:

    disks = [(idx, disk, 0)

             for (idx, disk) in enumerate(instance.disks)]

  for (_, device, _) in disks:

                                                  (map(compat.snd, disks),

                                                   instance),

    for (idx, device, offset) in disks:

      if offset == 0:

        info_text = ""

      else:

        info_text = (" (from %s to %s)" %

                     (utils.FormatUnit(offset, "h"),

                      utils.FormatUnit(size, "h")))

      lu.LogInfo("* Wiping disk %s%s", idx, info_text)

      logging.info("Wiping disk %d for instance %s on node %s using"

                   " chunk size %s", idx, instance.name, node, wipe_chunk_size)

                                                    (map(compat.snd, disks),

                                                     instance),

def _DiskSizeInBytesToMebibytes(lu, size):

  """Converts a disk size in bytes to mebibytes.

  Warns and rounds up if the size isn't an even multiple of 1 MiB.

  """

  (mib, remainder) = divmod(size, 1024 * 1024)

  if remainder != 0:

    lu.LogWarning("Disk size is not an even multiple of 1 MiB; rounding up"

                  " to not overwrite existing data (%s bytes will not be"

                  " wiped)", (1024 * 1024) - remainder)

    mib += 1

  return mib

    wipe_disks = self.cfg.GetClusterInfo().prealloc_wipe_disks

      result.Raise("Dry-run grow request failed to node %s" % node)

    if wipe_disks:

      # Get disk size from primary node for wiping

      result = self.rpc.call_blockdev_getsize(instance.primary_node, [disk])

      result.Raise("Failed to retrieve disk size from node '%s'" %

                   instance.primary_node)

      (disk_size_in_bytes, ) = result.payload

      if disk_size_in_bytes is None:

        raise errors.OpExecError("Failed to retrieve disk size from primary"

                                 " node '%s'" % instance.primary_node)

      old_disk_size = _DiskSizeInBytesToMebibytes(self, disk_size_in_bytes)

      assert old_disk_size >= disk.size, \

        ("Retrieved disk size too small (got %s, should be at least %s)" %

         (old_disk_size, disk.size))

    else:

      old_disk_size = None

    assert wipe_disks ^ (old_disk_size is None)

    if wipe_disks:

      assert instance.disks[self.op.disk] == disk

      # Wipe newly added disk space

      _WipeDisks(self, instance,

                 disks=[(self.op.disk, disk, old_disk_size)])

The ``--prealloc-wipe-disks`` sets a cluster wide configuration value

for wiping disks prior to allocation and size changes (``gnt-instance

grow-disk``). This increases security on instance level as the instance

can't access untouched data from its underlying storage.

    assert not (set(disks) - set(instance.disks))

    for start_offset in [0, 280, 8895, 1563204]:

      pt = _DiskPauseTracker()

      progress = {}

      def _WipeCb((disk, _), offset, size):

        assert isinstance(offset, (long, int))

        assert isinstance(size, (long, int))

        max_chunk_size = (disk.size / 100.0 * constants.MIN_WIPE_CHUNK_PERCENT)

        self.assertTrue(offset >= start_offset)

        self.assertTrue((offset + size) <= disk.size)

        self.assertTrue(size > 0)

        self.assertTrue(size <= constants.MAX_WIPE_CHUNK)

        self.assertTrue(size <= max_chunk_size)

        self.assertTrue(offset == start_offset or disk.logical_id in progress)

        # Keep track of progress

        cur_progress = progress.setdefault(disk.logical_id, start_offset)

        self.assertEqual(cur_progress, offset)

        progress[disk.logical_id] += size

        return (True, None)

      lu = _FakeLU(rpc=_RpcForDiskWipe(pt, _WipeCb),

                   cfg=_ConfigForDiskWipe())

      if start_offset > 0:

        disks = [

          objects.Disk(dev_type=constants.LD_LV, logical_id="disk0",

                       size=128),

          objects.Disk(dev_type=constants.LD_LV, logical_id="disk1",

                       size=start_offset + (100 * 1024)),

          ]

      else:

        disks = [

          objects.Disk(dev_type=constants.LD_LV, logical_id="disk0", size=1024),

          objects.Disk(dev_type=constants.LD_LV, logical_id="disk1",

                       size=500 * 1024),

          objects.Disk(dev_type=constants.LD_LV, logical_id="disk2", size=128),

          objects.Disk(dev_type=constants.LD_LV, logical_id="disk3",

                       size=constants.MAX_WIPE_CHUNK),

          ]

      instance = objects.Instance(name="inst3560",

                                  primary_node="node1.example.com",

                                  disk_template=constants.DT_PLAIN,

                                  disks=disks)

      if start_offset > 0:

        # Test start offset with only one disk

        cmdlib._WipeDisks(lu, instance,

                          disks=[(1, disks[1], start_offset)])

        self.assertEqual(pt.history, [

          ("disk1", start_offset + (100 * 1024), True),

          ("disk1", start_offset + (100 * 1024), False),

          ])

        self.assertEqual(progress, {

          "disk1": disks[1].size,

          })

      else:

        cmdlib._WipeDisks(lu, instance)

        self.assertEqual(pt.history, [

          ("disk0", 1024, True),

          ("disk1", 500 * 1024, True),

          ("disk2", 128, True),

          ("disk3", constants.MAX_WIPE_CHUNK, True),

          ("disk0", 1024, False),

          ("disk1", 500 * 1024, False),

          ("disk2", 128, False),

          ("disk3", constants.MAX_WIPE_CHUNK, False),

          ])

        # Ensure the complete disk has been wiped

        self.assertEqual(progress, dict((i.logical_id, i.size) for i in disks))

class TestDiskSizeInBytesToMebibytes(unittest.TestCase):

  def testLessThanOneMebibyte(self):

    for i in [1, 2, 7, 512, 1000, 1023]:

      lu = _FakeLU()

      result = cmdlib._DiskSizeInBytesToMebibytes(lu, i)

      self.assertEqual(result, 1)

      self.assertEqual(len(lu.warning_log), 1)

      self.assertEqual(len(lu.warning_log[0]), 2)

      (_, (warnsize, )) = lu.warning_log[0]

      self.assertEqual(warnsize, (1024 * 1024) - i)

  def testEven(self):

    for i in [1, 2, 7, 512, 1000, 1023]:

      lu = _FakeLU()

      result = cmdlib._DiskSizeInBytesToMebibytes(lu, i * 1024 * 1024)

      self.assertEqual(result, i)

      self.assertFalse(lu.warning_log)

  def testLargeNumber(self):

    for i in [1, 2, 7, 512, 1000, 1023, 2724, 12420]:

      for j in [1, 2, 486, 326, 986, 1023]:

        lu = _FakeLU()

        size = (1024 * 1024 * i) + j

        result = cmdlib._DiskSizeInBytesToMebibytes(lu, size)

        self.assertEqual(result, i + 1, msg="Amount was not rounded up")

        self.assertEqual(len(lu.warning_log), 1)

        self.assertEqual(len(lu.warning_log[0]), 2)

        (_, (warnsize, )) = lu.warning_log[0]

        self.assertEqual(warnsize, (1024 * 1024) - j)