def test_bootloader_in_kickstart(self): ''' test that a bootloader such as prepboot/biosboot shows up in the kickstart data ''' # prepboot test case with patch( 'pyanaconda.storage.osinstall.InstallerStorage.bootloader_device', new_callable=PropertyMock) as mock_bootloader_device: with patch( 'pyanaconda.storage.osinstall.InstallerStorage.mountpoints', new_callable=PropertyMock) as mock_mountpoints: # set up prepboot partition bootloader_device_obj = PartitionDevice( "test_partition_device") bootloader_device_obj.size = Size('5 MiB') bootloader_device_obj.format = formats.get_format("prepboot") prepboot_blivet_obj = InstallerStorage() # mountpoints must exist for update_ksdata to run mock_bootloader_device.return_value = bootloader_device_obj mock_mountpoints.values.return_value = [] # initialize ksdata prepboot_ksdata = returnClassForVersion()() prepboot_blivet_obj.ksdata = prepboot_ksdata prepboot_blivet_obj.update_ksdata() self.assertIn("part prepboot", str(prepboot_blivet_obj.ksdata)) # biosboot test case with patch('pyanaconda.storage.osinstall.InstallerStorage.devices', new_callable=PropertyMock) as mock_devices: with patch( 'pyanaconda.storage.osinstall.InstallerStorage.mountpoints', new_callable=PropertyMock) as mock_mountpoints: # set up biosboot partition biosboot_device_obj = PartitionDevice( "biosboot_partition_device") biosboot_device_obj.size = Size('1MiB') biosboot_device_obj.format = formats.get_format("biosboot") biosboot_blivet_obj = InstallerStorage() # mountpoints must exist for updateKSData to run mock_devices.return_value = [biosboot_device_obj] mock_mountpoints.values.return_value = [] # initialize ksdata biosboot_ksdata = returnClassForVersion()() biosboot_blivet_obj.ksdata = biosboot_ksdata biosboot_blivet_obj.update_ksdata() self.assertIn("part biosboot", str(biosboot_blivet_obj.ksdata))
def setupDisks(self, ksdata): self._storage = InstallerStorage() for component in self._reusedComponents: self._disks.update(component._disks) for (name, image) in self._disks.items(): self._storage.disk_images[name] = image self._storage.reset()
def setupDisks(self, ksdata): """Create all disk images given by self.disksToCreate and initialize the storage module. Subclasses may override this method, but they should be sure to call the base method as well. """ self._storage = InstallerStorage() for (name, size) in self.disksToCreate: self._disks[name] = blivet.util.create_sparse_tempfile(name, size) self._storage.disk_images[name] = self._disks[name] self._storage.reset()
def storage(self): if not self._storage: from pyanaconda.storage.osinstall import InstallerStorage import blivet.arch self._storage = InstallerStorage(ksdata=self.ksdata) self._set_storage_defaults(self._storage) if blivet.arch.is_s390(): self._load_plugin_s390() return self._storage
def setupDisks(self, ksdata): self._storage = InstallerStorage(ksdata=ksdata) # See comment in super class's method. from pyanaconda.bootloader import get_bootloader self._storage._bootloader = get_bootloader() for component in self._reusedComponents: self._disks.update(component._disks) for (name, image) in self._disks.items(): self._storage.disk_images[name] = image self._storage.reset()
def create_storage(): """Create the storage object. :return: an instance of the Blivet's storage object """ storage = InstallerStorage() # Set the default filesystem type. storage.set_default_fstype(conf.storage.file_system_type or storage.default_fstype) # Set the default LUKS version. storage.set_default_luks_version(conf.storage.luks_version or storage.default_luks_version) return storage
def setUp(self): self.storage = InstallerStorage() # anaconda first configures disk images for (name, size) in iter(self.disks.items()): path = util.create_sparse_tempfile(name, size) self.storage.disk_images[name] = path # at this point the DMLinearDevice has correct size self.storage.setup_disk_images() # anaconda calls initialize_storage regardless of whether or not # this is an image install. Somewhere along the line this will # execute setup_disk_images() once more and the DMLinearDevice created # in this second execution has size 0 with patch('blivet.flags'): reset_storage(self.storage)
def test_biosboot_bootloader_in_kickstart(self, mock_mountpoints, mock_devices, dbus): """Test that a biosboot bootloader shows up in the ks data.""" # set up biosboot partition biosboot_device_obj = PartitionDevice("biosboot_partition_device") biosboot_device_obj.size = Size('1MiB') biosboot_device_obj.format = formats.get_format("biosboot") # mountpoints must exist for updateKSData to run mock_devices.return_value = [biosboot_device_obj] mock_mountpoints.values.return_value = [] # initialize ksdata ksdata = makeVersion() biosboot_blivet_obj = InstallerStorage() update_storage_ksdata(biosboot_blivet_obj, ksdata) self.assertIn("part biosboot", str(ksdata))
def test_prepboot_bootloader_in_kickstart(self, mock_mountpoints, mock_bootloader_device, dbus): """Test that a prepboot bootloader shows up in the ks data.""" # set up prepboot partition bootloader_device_obj = PartitionDevice("test_partition_device") bootloader_device_obj.size = Size('5 MiB') bootloader_device_obj.format = formats.get_format("prepboot") # mountpoints must exist for update_ksdata to run mock_bootloader_device.return_value = bootloader_device_obj mock_mountpoints.values.return_value = [] # initialize ksdata prepboot_blivet_obj = InstallerStorage(makeVersion()) prepboot_blivet_obj.update_ksdata() self.assertIn("part prepboot", str(prepboot_blivet_obj.ksdata))
def setupDisks(self, ksdata): """Create all disk images given by self.disksToCreate and initialize the storage module. Subclasses may override this method, but they should be sure to call the base method as well. """ self._storage = InstallerStorage(ksdata=ksdata) # blivet only sets up the bootloader in installer_mode. We don't # want installer_mode, though, because that involves running lots # of programs on the host and setting up all sorts of other things. # Thus, we set it up manually. from pyanaconda.bootloader import get_bootloader self._storage._bootloader = get_bootloader() for (name, size) in self.disksToCreate: self._disks[name] = blivet.util.create_sparse_tempfile(name, size) self._storage.disk_images[name] = self._disks[name] self._storage.reset()
def setUp(self): self.storage = InstallerStorage() # anaconda first configures disk images for (name, size) in iter(self.disks.items()): path = util.create_sparse_tempfile(name, size) self.storage.disk_images[name] = path # at this point the DMLinearDevice has correct size self.storage.setup_disk_images() # emulates setting the anaconda flags which later update flags.image_install = True # no kickstart available ksdata = kickstart.AnacondaKSHandler([]) # anaconda calls storage_initialize regardless of whether or not # this is an image install. Somewhere along the line this will # execute setup_disk_images() once more and the DMLinearDevice created # in this second execution has size 0 with patch('blivet.flags'): storage_initialize(self.storage, ksdata, [])
def test_prepboot_bootloader_in_kickstart(self, mock_mountpoints, dbus): """Test that a prepboot bootloader shows up in the ks data.""" # disable other partitioning modules dbus.return_value.Enabled = False # set up prepboot partition bootloader_device_obj = PartitionDevice("test_partition_device") bootloader_device_obj.size = Size('5 MiB') bootloader_device_obj.format = formats.get_format("prepboot") # mountpoints must exist for update_ksdata to run mock_mountpoints.values.return_value = [] # set up the storage prepboot_blivet_obj = InstallerStorage() prepboot_blivet_obj.bootloader.stage1_device = bootloader_device_obj # initialize ksdata ksdata = makeVersion() update_storage_ksdata(prepboot_blivet_obj, ksdata) self.assertIn("part prepboot", str(ksdata))
def setUp(self): flags.testing = True self._storage = InstallerStorage() self._config = DiskInitializationConfig()
def test_should_clear(self): """ Test the Blivet.should_clear method. """ b = InstallerStorage() DiskDevice = blivet.devices.DiskDevice PartitionDevice = blivet.devices.PartitionDevice # sda is a disk with an existing disklabel containing two partitions sda = DiskDevice("sda", size=100000, exists=True) sda.format = blivet.formats.get_format("disklabel", device=sda.path, exists=True) sda.format._parted_disk = mock.Mock() sda.format._parted_device = mock.Mock() sda.format._parted_disk.configure_mock(partitions=[]) b.devicetree._add_device(sda) # sda1 is a partition containing an existing ext4 filesystem sda1 = PartitionDevice("sda1", size=500, exists=True, parents=[sda]) sda1._parted_partition = mock.Mock( **{ 'type': PARTITION_NORMAL, 'getLength.return_value': int(sda1.size), 'getFlag.return_value': 0 }) sda1.format = blivet.formats.get_format("ext4", mountpoint="/boot", device=sda1.path, exists=True) b.devicetree._add_device(sda1) # sda2 is a partition containing an existing vfat filesystem sda2 = PartitionDevice("sda2", size=10000, exists=True, parents=[sda]) sda2._parted_partition = mock.Mock( **{ 'type': PARTITION_NORMAL, 'getLength.return_value': int(sda2.size), 'getFlag.return_value': 0 }) sda2.format = blivet.formats.get_format("vfat", mountpoint="/foo", device=sda2.path, exists=True) b.devicetree._add_device(sda2) # sdb is an unpartitioned disk containing an xfs filesystem sdb = DiskDevice("sdb", size=100000, exists=True) sdb.format = blivet.formats.get_format("xfs", device=sdb.path, exists=True) b.devicetree._add_device(sdb) # sdc is an unformatted/uninitialized/empty disk sdc = DiskDevice("sdc", size=100000, exists=True) b.devicetree._add_device(sdc) # sdd is a disk containing an existing disklabel with no partitions sdd = DiskDevice("sdd", size=100000, exists=True) sdd.format = blivet.formats.get_format("disklabel", device=sdd.path, exists=True) b.devicetree._add_device(sdd) # # clearpart type none # b.config.clear_part_type = CLEARPART_TYPE_NONE self.assertFalse(b.should_clear(sda1), msg="type none should not clear any partitions") self.assertFalse(b.should_clear(sda2), msg="type none should not clear any partitions") b.config.initialize_disks = False self.assertFalse(b.should_clear(sda), msg="type none should not clear non-empty disks") self.assertFalse(b.should_clear(sdb), msg="type none should not clear formatting from " "unpartitioned disks") self.assertFalse(b.should_clear(sdc), msg="type none should not clear empty disk without " "initlabel") self.assertFalse( b.should_clear(sdd), msg="type none should not clear empty partition table " "without initlabel") b.config.initialize_disks = True self.assertFalse(b.should_clear(sda), msg="type none should not clear non-empty disks even " "with initlabel") self.assertFalse(b.should_clear(sdb), msg="type non should not clear formatting from " "unpartitioned disks even with initlabel") self.assertTrue( b.should_clear(sdc), msg="type none should clear empty disks when initlabel " "is set") self.assertTrue( b.should_clear(sdd), msg="type none should clear empty partition table when " "initlabel is set") # # clearpart type linux # b.config.clear_part_type = CLEARPART_TYPE_LINUX self.assertTrue(b.should_clear(sda1), msg="type linux should clear partitions containing " "ext4 filesystems") self.assertFalse(b.should_clear(sda2), msg="type linux should not clear partitions " "containing vfat filesystems") b.config.initialize_disks = False self.assertFalse( b.should_clear(sda), msg="type linux should not clear non-empty disklabels") self.assertTrue(b.should_clear(sdb), msg="type linux should clear linux-native whole-disk " "formatting regardless of initlabel setting") self.assertFalse(b.should_clear(sdc), msg="type linux should not clear unformatted disks " "unless initlabel is set") self.assertFalse(b.should_clear(sdd), msg="type linux should not clear disks with empty " "partition tables unless initlabel is set") b.config.initialize_disks = True self.assertFalse( b.should_clear(sda), msg="type linux should not clear non-empty disklabels") self.assertTrue(b.should_clear(sdb), msg="type linux should clear linux-native whole-disk " "formatting regardless of initlabel setting") self.assertTrue(b.should_clear(sdc), msg="type linux should clear unformatted disks when " "initlabel is set") self.assertTrue(b.should_clear(sdd), msg="type linux should clear disks with empty " "partition tables when initlabel is set") sda1.protected = True self.assertFalse(b.should_clear(sda1), msg="protected devices should never be cleared") self.assertFalse(b.should_clear(sda), msg="disks containing protected devices should never " "be cleared") sda1.protected = False # # clearpart type all # b.config.clear_part_type = CLEARPART_TYPE_ALL self.assertTrue(b.should_clear(sda1), msg="type all should clear all partitions") self.assertTrue(b.should_clear(sda2), msg="type all should clear all partitions") b.config.initialize_disks = False self.assertTrue(b.should_clear(sda), msg="type all should initialize all disks") self.assertTrue(b.should_clear(sdb), msg="type all should initialize all disks") self.assertTrue(b.should_clear(sdc), msg="type all should initialize all disks") self.assertTrue(b.should_clear(sdd), msg="type all should initialize all disks") b.config.initialize_disks = True self.assertTrue(b.should_clear(sda), msg="type all should initialize all disks") self.assertTrue(b.should_clear(sdb), msg="type all should initialize all disks") self.assertTrue(b.should_clear(sdc), msg="type all should initialize all disks") self.assertTrue(b.should_clear(sdd), msg="type all should initialize all disks") sda1.protected = True self.assertFalse(b.should_clear(sda1), msg="protected devices should never be cleared") self.assertFalse(b.should_clear(sda), msg="disks containing protected devices should never " "be cleared") sda1.protected = False