def setUp(self):
super(VirtDiskVFSLocalFSTest, self).setUp()
self.qcowfile = imgmodel.LocalFileImage("/dummy.qcow2",
imgmodel.FORMAT_QCOW2)
self.rawfile = imgmodel.LocalFileImage("/dummy.img",
imgmodel.FORMAT_RAW)
def setUp(self):
super(VirtDiskVFSGuestFSTest, self).setUp()
self.useFixture(
fixtures.MonkeyPatch('nova.virt.disk.vfs.guestfs.guestfs',
fakeguestfs))
self.qcowfile = imgmodel.LocalFileImage("/dummy.qcow2",
imgmodel.FORMAT_QCOW2)
self.rawfile = imgmodel.LocalFileImage("/dummy.img",
imgmodel.FORMAT_RAW)
self.lvmfile = imgmodel.LocalBlockImage("/dev/volgroup/myvol")
self.rbdfile = imgmodel.RBDImage("myvol", "mypool", "cthulu",
"arrrrrgh",
["server1:123", "server2:123"])
def test_equality(self):
img1 = imgmodel.LocalFileImage("/var/lib/libvirt/images/demo.qcow2",
imgmodel.FORMAT_QCOW2)
img2 = imgmodel.LocalFileImage("/var/lib/libvirt/images/demo.qcow2",
imgmodel.FORMAT_QCOW2)
img3 = imgmodel.LocalFileImage("/var/lib/libvirt/images/demo.qcow2",
imgmodel.FORMAT_RAW)
img4 = imgmodel.LocalImage("/dev/mapper/vol", imgmodel.FORMAT_RAW)
img5 = imgmodel.LocalBlockImage("/dev/mapper/vol")
self.assertEqual(img1, img1)
self.assertEqual(img1, img2)
self.assertEqual(img1.__hash__(), img2.__hash__())
self.assertNotEqual(img1, img3)
self.assertNotEqual(img4, img5)
def test_extend_qcow_success(self, mock_exec, mock_inst, mock_resize,
mock_extendable, mock_can_resize):
imgfile = tempfile.NamedTemporaryFile()
self.addCleanup(imgfile.close)
imgsize = 10
device = "/dev/sdh"
image = imgmodel.LocalFileImage(imgfile, imgmodel.FORMAT_QCOW2)
self.flags(resize_fs_using_block_device=True)
mounter = FakeMount.instance_for_format(image, None, None)
mounter.device = device
mock_inst.return_value = mounter
with test.nested(
mock.patch.object(mounter,
'get_dev',
autospec=True,
return_value=True),
mock.patch.object(mounter, 'unget_dev', autospec=True),
) as (mock_get_dev, mock_unget_dev):
api.extend(image, imgsize)
mock_can_resize.assert_called_once_with(imgfile, imgsize)
mock_exec.assert_called_once_with('qemu-img', 'resize', imgfile,
imgsize)
mock_extendable.assert_called_once_with(image)
mock_inst.assert_called_once_with(image, None, None)
mock_resize.assert_called_once_with(mounter.device,
run_as_root=True,
check_exit_code=[0])
mock_get_dev.assert_called_once_with()
mock_unget_dev.assert_called_once_with()
def test_instance_for_format_qcow2(self):
image = imgmodel.LocalFileImage("/some/file.qcows",
imgmodel.FORMAT_QCOW2)
mount_dir = '/mount/dir'
partition = -1
inst = api.Mount.instance_for_format(image, mount_dir, partition)
self.assertIsInstance(inst, nbd.NbdMount)
def test_local_file_image(self):
img = imgmodel.LocalFileImage("/var/lib/libvirt/images/demo.qcow2",
imgmodel.FORMAT_QCOW2)
self.assertIsInstance(img, imgmodel.Image)
self.assertEqual("/var/lib/libvirt/images/demo.qcow2", img.path)
self.assertEqual(imgmodel.FORMAT_QCOW2, img.format)
def copy_raw_image(base, target, size):
libvirt_utils.copy_image(base, target)
if size:
# class Raw is misnamed, format may not be 'raw' in all cases
image = imgmodel.LocalFileImage(target,
self.driver_format)
disk.extend(image, size)
def test_extend_qcow_success(self):
imgfile = tempfile.NamedTemporaryFile()
self.addCleanup(imgfile.close)
imgsize = 10
device = "/dev/sdh"
image = imgmodel.LocalFileImage(imgfile, imgmodel.FORMAT_QCOW2)
self.flags(resize_fs_using_block_device=True)
mounter = FakeMount.instance_for_format(image, None, None)
mounter.device = device
self.mox.StubOutWithMock(api, 'can_resize_image')
self.mox.StubOutWithMock(utils, 'execute')
self.mox.StubOutWithMock(api, 'is_image_extendable')
self.mox.StubOutWithMock(mounter, 'get_dev')
self.mox.StubOutWithMock(mounter, 'unget_dev')
self.mox.StubOutWithMock(api, 'resize2fs')
self.mox.StubOutWithMock(mount.Mount,
'instance_for_format',
use_mock_anything=True)
api.can_resize_image(imgfile, imgsize).AndReturn(True)
utils.execute('qemu-img', 'resize', imgfile, imgsize)
api.is_image_extendable(image).AndReturn(True)
mount.Mount.instance_for_format(image, None, None).AndReturn(mounter)
mounter.get_dev().AndReturn(True)
api.resize2fs(mounter.device, run_as_root=True, check_exit_code=[0])
mounter.unget_dev()
self.mox.ReplayAll()
api.extend(image, imgsize)
def setUp(self):
super(VirtDiskTest, self).setUp()
self.useFixture(
fixtures.MonkeyPatch('nova.virt.disk.vfs.guestfs.guestfs',
fakeguestfs))
self.file = imgmodel.LocalFileImage("/some/file",
imgmodel.FORMAT_QCOW2)
def setUp(self):
super(NbdTestCase, self).setUp()
self.stub_out('nova.virt.disk.mount.nbd.NbdMount._detect_nbd_devices',
_fake_detect_nbd_devices)
self.useFixture(
fixtures.MonkeyPatch('os.listdir', _fake_listdir_nbd_devices))
self.file = imgmodel.LocalFileImage("/some/file.qcow2",
imgmodel.FORMAT_QCOW2)
def copy_qcow2_image(base, target, size):
# TODO(pbrady): Consider copying the cow image here
# with preallocation=metadata set for performance reasons.
# This would be keyed on a 'preallocate_images' setting.
libvirt_utils.create_cow_image(base, target)
if size:
image = imgmodel.LocalFileImage(target, imgmodel.FORMAT_QCOW2)
disk.extend(image, size)
def test_extend_ploop(self, mock_ploop_resize, mock_can_resize_image):
imgfile = tempfile.NamedTemporaryFile()
self.addCleanup(imgfile.close)
imgsize = 10 * units.Gi
image = imgmodel.LocalFileImage(imgfile, imgmodel.FORMAT_PLOOP)
api.extend(image, imgsize)
mock_can_resize_image.assert_called_once_with(image.path, imgsize)
mock_ploop_resize.assert_called_once_with(imgfile, imgsize)
def create_image(self, prepare_template, base, size, *args, **kwargs):
filename = self._get_lock_name(base)
@utils.synchronized(filename, external=True, lock_path=self.lock_path)
def copy_qcow2_image(base, target, size):
# TODO(pbrady): Consider copying the cow image here
# with preallocation=metadata set for performance reasons.
# This would be keyed on a 'preallocate_images' setting.
#libvirt_utils.create_cow_image(base, target)
disk_format = kwargs.get('disk_format', '')
if disk_format == 'iso':
libvirt_utils.create_image('qcow2', target, size)
else:
libvirt_utils.create_cow_image(base, target)
if size:
image = imgmodel.LocalFileImage(target, imgmodel.FORMAT_QCOW2)
disk.extend(image, size)
# Download the unmodified base image unless we already have a copy.
if not os.path.exists(base):
prepare_template(target=base, *args, **kwargs)
# NOTE(ankit): Update the mtime of the base file so the image
# cache manager knows it is in use.
libvirt_utils.update_mtime(base)
self.verify_base_size(base, size)
legacy_backing_size = None
legacy_base = base
# Determine whether an existing qcow2 disk uses a legacy backing by
# actually looking at the image itself and parsing the output of the
# backing file it expects to be using.
if os.path.exists(self.path):
backing_path = libvirt_utils.get_disk_backing_file(self.path)
if backing_path is not None:
backing_file = os.path.basename(backing_path)
backing_parts = backing_file.rpartition('_')
if backing_file != backing_parts[-1] and \
backing_parts[-1].isdigit():
legacy_backing_size = int(backing_parts[-1])
legacy_base += '_%d' % legacy_backing_size
legacy_backing_size *= units.Gi
# Create the legacy backing file if necessary.
if legacy_backing_size:
if not os.path.exists(legacy_base):
with fileutils.remove_path_on_error(legacy_base):
libvirt_utils.copy_image(base, legacy_base)
image = imgmodel.LocalFileImage(legacy_base,
imgmodel.FORMAT_QCOW2)
disk.extend(image, legacy_backing_size)
if not os.path.exists(self.path):
with fileutils.remove_path_on_error(self.path):
copy_qcow2_image(base, self.path, size)
def test_is_image_extendable_raw(self):
imgfile = tempfile.NamedTemporaryFile()
self.mox.StubOutWithMock(utils, 'execute')
utils.execute('e2label', imgfile)
self.mox.ReplayAll()
image = imgmodel.LocalFileImage(imgfile, imgmodel.FORMAT_RAW)
self.addCleanup(imgfile.close)
self.assertTrue(api.is_image_extendable(image))
def setUp(self):
super(VirtDiskVFSLocalFSTestPaths, self).setUp()
real_execute = processutils.execute
def nonroot_execute(*cmd_parts, **kwargs):
kwargs.pop('run_as_root', None)
return real_execute(*cmd_parts, **kwargs)
self.stubs.Set(processutils, 'execute', nonroot_execute)
self.rawfile = imgmodel.LocalFileImage("/dummy.img",
imgmodel.FORMAT_RAW)
def test_inject_data(self):
self.assertTrue(diskapi.inject_data(
imgmodel.LocalFileImage("/some/file", imgmodel.FORMAT_QCOW2)))
self.assertTrue(diskapi.inject_data(
imgmodel.LocalFileImage("/some/file", imgmodel.FORMAT_RAW),
mandatory=('files',)))
self.assertTrue(diskapi.inject_data(
imgmodel.LocalFileImage("/some/file", imgmodel.FORMAT_RAW),
key="mysshkey",
mandatory=('key',)))
os_name = os.name
os.name = 'nt' # Cause password injection to fail
self.assertRaises(exception.NovaException,
diskapi.inject_data,
imgmodel.LocalFileImage("/some/file",
imgmodel.FORMAT_RAW),
admin_password="******",
mandatory=('admin_password',))
self.assertFalse(diskapi.inject_data(
imgmodel.LocalFileImage("/some/file", imgmodel.FORMAT_RAW),
admin_password="******"))
os.name = os_name
self.assertFalse(diskapi.inject_data(
imgmodel.LocalFileImage("/some/fail/file", imgmodel.FORMAT_RAW),
key="mysshkey"))
def test_extend_qcow_no_resize(self, mock_execute, mock_extendable,
mock_can_resize_image):
imgfile = tempfile.NamedTemporaryFile()
imgsize = 10
image = imgmodel.LocalFileImage(imgfile, imgmodel.FORMAT_QCOW2)
self.flags(resize_fs_using_block_device=False)
api.extend(image, imgsize)
mock_can_resize_image.assert_called_once_with(imgfile, imgsize)
mock_execute.assert_called_once_with('qemu-img', 'resize', imgfile,
imgsize)
self.assertFalse(mock_extendable.called)
def test_extend_ploop(self, mock_execute, mock_can_resize_image):
imgfile = tempfile.NamedTemporaryFile()
self.addCleanup(imgfile.close)
imgsize = 10 * units.Gi
imgsize_mb = str(imgsize // units.Mi) + 'M'
image = imgmodel.LocalFileImage(imgfile, imgmodel.FORMAT_PLOOP)
api.extend(image, imgsize)
mock_can_resize_image.assert_called_once_with(image.path,
imgsize)
mock_execute.assert_called_once_with('prl_disk_tool', 'resize',
'--size', imgsize_mb,
'--resize_partition',
'--hdd', imgfile,
run_as_root=True)
def test_extend_raw_success(self, mock_exec, mock_resize, mock_can_resize):
imgfile = tempfile.NamedTemporaryFile()
self.addCleanup(imgfile.close)
imgsize = 10
image = imgmodel.LocalFileImage(imgfile, imgmodel.FORMAT_RAW)
api.extend(image, imgsize)
mock_exec.assert_has_calls([
mock.call('qemu-img', 'resize', imgfile, imgsize),
mock.call('e2label', image.path)
])
mock_resize.assert_called_once_with(imgfile,
run_as_root=False,
check_exit_code=[0])
mock_can_resize.assert_called_once_with(imgfile, imgsize)
def test_extend_raw_success(self):
imgfile = tempfile.NamedTemporaryFile()
self.addCleanup(imgfile.close)
imgsize = 10
image = imgmodel.LocalFileImage(imgfile, imgmodel.FORMAT_RAW)
self.mox.StubOutWithMock(api, 'can_resize_image')
self.mox.StubOutWithMock(utils, 'execute')
self.mox.StubOutWithMock(api, 'resize2fs')
api.can_resize_image(imgfile, imgsize).AndReturn(True)
utils.execute('qemu-img', 'resize', imgfile, imgsize)
utils.execute('e2label', image.path)
api.resize2fs(imgfile, run_as_root=False, check_exit_code=[0])
self.mox.ReplayAll()
api.extend(image, imgsize)
def test_can_resize_need_fs_type_specified(self):
# NOTE(mikal): Bug 1094373 saw a regression where we failed to
# treat a failure to mount as a failure to be able to resize the
# filesystem
def _fake_get_disk_size(path):
return 10
self.useFixture(
fixtures.MonkeyPatch('nova.virt.disk.api.get_disk_size',
_fake_get_disk_size))
def fake_trycmd(*args, **kwargs):
return '', 'broken'
self.useFixture(fixtures.MonkeyPatch('nova.utils.trycmd', fake_trycmd))
def fake_returns_true(*args, **kwargs):
return True
def fake_returns_nothing(*args, **kwargs):
return ''
self.useFixture(
fixtures.MonkeyPatch('nova.virt.disk.mount.nbd.NbdMount.get_dev',
fake_returns_true))
self.useFixture(
fixtures.MonkeyPatch('nova.virt.disk.mount.nbd.NbdMount.map_dev',
fake_returns_true))
self.useFixture(
fixtures.MonkeyPatch(
'nova.virt.disk.vfs.localfs.VFSLocalFS.get_image_fs',
fake_returns_nothing))
# Force the use of localfs, which is what was used during the failure
# reported in the bug
def fake_import_fails(*args, **kwargs):
raise Exception('Failed')
self.useFixture(
fixtures.MonkeyPatch('oslo_utils.import_module',
fake_import_fails))
imgfile = tempfile.NamedTemporaryFile()
self.addCleanup(imgfile.close)
image = imgmodel.LocalFileImage(imgfile.name, imgmodel.FORMAT_QCOW2)
self.assertFalse(api.is_image_extendable(image))
def get_model(self, connection):
return imgmodel.LocalFileImage(self.path, imgmodel.FORMAT_QCOW2)
def resize_image(self, size):
image = imgmodel.LocalFileImage(self.path, imgmodel.FORMAT_QCOW2)
disk.extend(image, size)
def test_can_resize_need_fs_type_specified(self, mock_image_fs):
imgfile = tempfile.NamedTemporaryFile()
self.addCleanup(imgfile.close)
image = imgmodel.LocalFileImage(imgfile.name, imgmodel.FORMAT_QCOW2)
self.assertFalse(api.is_image_extendable(image))
self.assertTrue(mock_image_fs.called)
def copy_raw_image(base, target, size):
libvirt_utils.copy_image(base, target)
if size:
image = imgmodel.LocalFileImage(target, self.driver_format)
disk.extend(image, size)
def test_is_image_extendable_raw(self, mock_exec):
imgfile = tempfile.NamedTemporaryFile()
image = imgmodel.LocalFileImage(imgfile, imgmodel.FORMAT_RAW)
self.addCleanup(imgfile.close)
self.assertTrue(api.is_image_extendable(image))
mock_exec.assert_called_once_with('e2label', imgfile)
def setUp(self):
super(LoopTestCase, self).setUp()
self.file = imgmodel.LocalFileImage("/some/file.qcow2",
imgmodel.FORMAT_QCOW2)
def test_instance_for_format_raw(self):
image = imgmodel.LocalFileImage("/some/file.raw", imgmodel.FORMAT_RAW)
mount_dir = '/mount/dir'
partition = -1
inst = api.Mount.instance_for_format(image, mount_dir, partition)
self.assertIsInstance(inst, loop.LoopMount)
def resize_image(self, size):
image = imgmodel.LocalFileImage(self.path, self.driver_format)
disk.extend(image, size)
def setUp(self):
super(VirtDiskVFSLocalFSTestPaths, self).setUp()
self.rawfile = imgmodel.LocalFileImage('/dummy.img',
imgmodel.FORMAT_RAW)
