def process(self): """ reformats raw disk image and its format to a new disk geometry using the qemu tool chain """ self.manual = Help() if self.command_args.get('help') is True: return self.manual.show('kiwi::image::resize') abs_target_dir_path = os.path.abspath( self.command_args['--target-dir']) if self.command_args['--root']: image_root = os.path.abspath( os.path.normpath(self.command_args['--root'])) else: image_root = os.sep.join( [abs_target_dir_path, 'build', 'image-root']) self.load_xml_description(image_root) disk_format = self.xml_state.build_type.get_format() image_format = DiskFormat(disk_format or 'raw', self.xml_state, image_root, abs_target_dir_path) if not image_format.has_raw_disk(): raise KiwiImageResizeError( 'no raw disk image {0} found in build results'.format( image_format.diskname)) new_disk_size = StringToSize.to_bytes(self.command_args['--size']) # resize raw disk log.info('Resizing raw disk to {0} bytes'.format(new_disk_size)) resize_result = image_format.resize_raw_disk(new_disk_size) # resize raw disk partition table firmware = FirmWare(self.xml_state) loop_provider = LoopDevice(image_format.diskname) loop_provider.create(overwrite=False) partitioner = Partitioner(firmware.get_partition_table_type(), loop_provider) partitioner.resize_table() del loop_provider # resize disk format from resized raw disk if disk_format and resize_result is True: log.info('Creating {0} disk format from resized raw disk'.format( disk_format)) image_format.create_image_format() elif resize_result is False: log.info('Raw disk is already at {0} bytes'.format(new_disk_size))
def __init__(self, table_type, storage_provider): # bind the underlaying block device providing class instance # to this object (e.g loop) if present. This is done to guarantee # the correct destructor order when the device should be released. self.storage_provider = storage_provider self.partition_map = {} self.public_partition_id_map = {} self.partition_id_map = {} self.is_mapped = False self.partitioner = Partitioner(table_type, storage_provider) self.table_type = table_type
def __init__(self, table_type: str, storage_provider: DeviceProvider, start_sector: int = None): # bind the underlaying block device providing class instance # to this object (e.g loop) if present. This is done to guarantee # the correct destructor order when the device should be released. self.storage_provider = storage_provider # list of protected map ids. If used in a custom partitions # setup this will lead to a raise conditition in order to # avoid conflicts with the existing partition layout and its # customizaton capabilities self.protected_map_ids = [ 'root', 'readonly', 'boot', 'prep', 'spare', 'swap', 'efi_csm', 'efi' ] self.partition_map: Dict[str, str] = {} self.public_partition_id_map: Dict[str, str] = {} self.partition_id_map: Dict[str, str] = {} self.is_mapped = False self.partitioner = Partitioner.new(table_type, storage_provider, start_sector) self.table_type = table_type
def append_unpartitioned_space(self): """ Extends the raw disk if an unpartitioned area is specified """ if self.unpartitioned_bytes: log.info('Expanding disk with %d bytes of unpartitioned space', self.unpartitioned_bytes) disk_format = DiskFormat('raw', self.xml_state, self.root_dir, self.target_dir) disk_format.resize_raw_disk(self.unpartitioned_bytes, append=True) firmware = FirmWare(self.xml_state) loop_provider = LoopDevice(disk_format.diskname) loop_provider.create(overwrite=False) partitioner = Partitioner(firmware.get_partition_table_type(), loop_provider) partitioner.resize_table()
def test_partitioner_s390_dasd_with_custom_start_sector( self, mock_machine, mock_dasd): mock_machine.return_value = 's390' storage_provider = Mock() with self._caplog.at_level(logging.WARNING): Partitioner('dasd', storage_provider, 4096) mock_dasd.assert_called_once_with(storage_provider)
def test_partitioner_s390_dasd_with_custom_start_sector( self, mock_machine, mock_dasd, mock_warning): mock_machine.return_value = 's390' storage_provider = Mock() Partitioner('dasd', storage_provider, 4096) mock_dasd.assert_called_once_with(storage_provider) assert mock_warning.called
def append_unpartitioned_space(self): """ Extends the raw disk if an unpartitioned area is specified """ if self.unpartitioned_bytes: log.info( 'Expanding disk with %d bytes of unpartitioned space', self.unpartitioned_bytes ) disk_format = DiskFormat( 'raw', self.xml_state, self.root_dir, self.target_dir ) disk_format.resize_raw_disk(self.unpartitioned_bytes, append=True) firmware = FirmWare(self.xml_state) loop_provider = LoopDevice(disk_format.diskname) loop_provider.create(overwrite=False) partitioner = Partitioner( firmware.get_partition_table_type(), loop_provider ) partitioner.resize_table()
def __init__( self, table_type: str, storage_provider: DeviceProvider, start_sector: int = None, extended_layout: bool = False ): """ Construct a new Disk layout object :param string table_type: Partition table type name :param object storage_provider: Instance of class based on DeviceProvider :param int start_sector: sector number :param bool extended_layout: If set to true and on msdos table type when creating more than 4 partitions, this will cause the fourth partition to be an extended partition and all following partitions will be placed as logical partitions inside of that extended partition """ # bind the underlaying block device providing class instance # to this object (e.g loop) if present. This is done to guarantee # the correct destructor order when the device should be released. self.storage_provider = storage_provider # list of protected map ids. If used in a custom partitions # setup this will lead to a raise conditition in order to # avoid conflicts with the existing partition layout and its # customizaton capabilities self.protected_map_ids = [ 'root', 'readonly', 'boot', 'prep', 'spare', 'swap', 'efi_csm', 'efi' ] self.partition_map: Dict[str, str] = {} self.public_partition_id_map: Dict[str, str] = {} self.partition_id_map: Dict[str, str] = {} self.is_mapped = False self.partitioner = Partitioner.new( table_type, storage_provider, start_sector, extended_layout ) self.table_type = table_type
def __init__(self, table_type, storage_provider): # bind the underlaying block device providing class instance # to this object (e.g loop) if present. This is done to guarantee # the correct destructor order when the device should be released. self.storage_provider = storage_provider self.partition_map = {} self.public_partition_id_map = {} self.partition_id_map = {} self.is_mapped = False self.partitioner = Partitioner( table_type, storage_provider ) self.table_type = table_type
def test_partitioner_not_implemented(self, mock_machine): mock_machine.return_value = 'x86_64' Partitioner('foo', mock.Mock())
def test_partitioner_ppc_gpt(self, mock_machine, mock_gpt): mock_machine.return_value = 'ppc64' storage_provider = Mock() Partitioner('gpt', storage_provider) mock_gpt.assert_called_once_with(storage_provider, None)
def test_partitioner_s390_msdos(self, mock_machine, mock_dos): mock_machine.return_value = 's390' storage_provider = Mock() Partitioner('msdos', storage_provider) mock_dos.assert_called_once_with(storage_provider, None)
def process(self): """ reformats raw disk image and its format to a new disk geometry using the qemu tool chain """ self.manual = Help() if self.command_args.get('help') is True: return self.manual.show('kiwi::image::resize') abs_target_dir_path = os.path.abspath( self.command_args['--target-dir'] ) if self.command_args['--root']: image_root = os.path.abspath( os.path.normpath(self.command_args['--root']) ) else: image_root = os.sep.join( [abs_target_dir_path, 'build', 'image-root'] ) self.load_xml_description( image_root ) disk_format = self.xml_state.build_type.get_format() image_format = DiskFormat( disk_format or 'raw', self.xml_state, image_root, abs_target_dir_path ) if not image_format.has_raw_disk(): raise KiwiImageResizeError( 'no raw disk image {0} found in build results'.format( image_format.diskname ) ) new_disk_size = StringToSize.to_bytes(self.command_args['--size']) # resize raw disk log.info( 'Resizing raw disk to {0} bytes'.format(new_disk_size) ) resize_result = image_format.resize_raw_disk(new_disk_size) # resize raw disk partition table firmware = FirmWare(self.xml_state) loop_provider = LoopDevice(image_format.diskname) loop_provider.create(overwrite=False) partitioner = Partitioner( firmware.get_partition_table_type(), loop_provider ) partitioner.resize_table() del loop_provider # resize disk format from resized raw disk if disk_format and resize_result is True: log.info( 'Creating {0} disk format from resized raw disk'.format( disk_format ) ) image_format.create_image_format() elif resize_result is False: log.info( 'Raw disk is already at {0} bytes'.format(new_disk_size) )
def test_partitioner_msdos(self, mock_dos): storage_provider = Mock() Partitioner.new('msdos', storage_provider) mock_dos.assert_called_once_with(storage_provider, None, False)
def test_partitioner_arm_gpt(self, mock_machine, mock_gpt): mock_machine.return_value = 'aarch64' storage_provider = mock.Mock() Partitioner('gpt', storage_provider) mock_gpt.assert_called_once_with(storage_provider)
class Disk(DeviceProvider): """ Implements storage disk and partition table setup Attributes * :attr:`storage_provider` Instance of class based on DeviceProvider * :attr:`partition_map` Dict of internal partition names to device node name * :attr:`public_partition_id_map` Dict of public partition names to partition number * :attr:`partition_id_map` Dict of internal partition names to partition number * :attr:`is_mapped` Indicate if partitions are kpartx mapped * :attr:`partitioner` Instance of Partitioner * :attr:`table_type` Partition table type """ def __init__(self, table_type, storage_provider): # bind the underlaying block device providing class instance # to this object (e.g loop) if present. This is done to guarantee # the correct destructor order when the device should be released. self.storage_provider = storage_provider self.partition_map = {} self.public_partition_id_map = {} self.partition_id_map = {} self.is_mapped = False self.partitioner = Partitioner( table_type, storage_provider ) self.table_type = table_type def get_device(self): """ Names of partition devices Note that the mapping requires an explicit map() call :return: instances of MappedDevice :rtype: dict """ device_map = {} for partition_name, device_node in list(self.partition_map.items()): device_map[partition_name] = MappedDevice( device=device_node, device_provider=self ) return device_map def is_loop(self): """ Check if storage provider is loop based The information is taken from the storage provider. If the storage provider is loop based the disk is it too """ return self.storage_provider.is_loop() def create_root_partition(self, mbsize): """ Create root partition Populates kiwi_RootPart(id) and kiwi_BootPart(id) if no extra boot partition is requested :param int mbsize: partition size """ self.partitioner.create('p.lxroot', mbsize, 't.linux') self._add_to_map('root') self._add_to_public_id_map('kiwi_RootPart') if 'kiwi_ROPart' in self.public_partition_id_map: self._add_to_public_id_map('kiwi_RWPart') if 'kiwi_BootPart' not in self.public_partition_id_map: self._add_to_public_id_map('kiwi_BootPart') def create_root_lvm_partition(self, mbsize): """ Create root partition for use with LVM Populates kiwi_RootPart(id) and kiwi_RootPartVol(LVRoot) :param int mbsize: partition size """ self.partitioner.create('p.lxlvm', mbsize, 't.lvm') self._add_to_map('root') self._add_to_public_id_map('kiwi_RootPart') self._add_to_public_id_map('kiwi_RootPartVol', 'LVRoot') def create_root_raid_partition(self, mbsize): """ Create root partition for use with MD Raid Populates kiwi_RootPart(id) and kiwi_RaidPart(id) as well as the default raid device node at boot time which is configured to be kiwi_RaidDev(/dev/mdX) :param int mbsize: partition size """ self.partitioner.create('p.lxraid', mbsize, 't.raid') self._add_to_map('root') self._add_to_public_id_map('kiwi_RootPart') self._add_to_public_id_map('kiwi_RaidPart') def create_root_readonly_partition(self, mbsize): """ Create root readonly partition for use with overlayfs Populates kiwi_ReadOnlyPart(id), the partition is meant to contain a squashfs readonly filesystem. The partition size should be the size of the squashfs filesystem in order to avoid wasting disk space :param int mbsize: partition size """ self.partitioner.create('p.lxreadonly', mbsize, 't.linux') self._add_to_map('readonly') self._add_to_public_id_map('kiwi_ROPart') def create_boot_partition(self, mbsize): """ Create boot partition Populates kiwi_BootPart(id) :param int mbsize: partition size """ self.partitioner.create('p.lxboot', mbsize, 't.linux') self._add_to_map('boot') self._add_to_public_id_map('kiwi_BootPart') def create_prep_partition(self, mbsize): """ Create prep partition Populates kiwi_PrepPart(id) :param int mbsize: partition size """ self.partitioner.create('p.prep', mbsize, 't.prep') self._add_to_map('prep') self._add_to_public_id_map('kiwi_PrepPart') def create_spare_partition(self, mbsize): """ Create spare partition for custom use Populates kiwi_SparePart(id) :param int mbsize: partition size """ self.partitioner.create('p.spare', mbsize, 't.linux') self._add_to_map('spare') self._add_to_public_id_map('kiwi_SparePart') def create_efi_csm_partition(self, mbsize): """ Create EFI bios grub partition Populates kiwi_BiosGrub(id) :param int mbsize: partition size """ self.partitioner.create('p.legacy', mbsize, 't.csm') self._add_to_map('efi_csm') self._add_to_public_id_map('kiwi_BiosGrub') def create_efi_partition(self, mbsize): """ Create EFI partition Populates kiwi_EfiPart(id) :param int mbsize: partition size """ self.partitioner.create('p.UEFI', mbsize, 't.efi') self._add_to_map('efi') self._add_to_public_id_map('kiwi_EfiPart') def activate_boot_partition(self): """ Activate boot partition Note: not all Partitioner instances supports this """ partition_id = None if 'prep' in self.partition_id_map: partition_id = self.partition_id_map['prep'] elif 'boot' in self.partition_id_map: partition_id = self.partition_id_map['boot'] elif 'root' in self.partition_id_map: partition_id = self.partition_id_map['root'] if partition_id: self.partitioner.set_flag(partition_id, 'f.active') def create_hybrid_mbr(self): """ Turn partition table into a hybrid GPT/MBR table Note: only GPT tables supports this """ self.partitioner.set_hybrid_mbr() def create_mbr(self): """ Turn partition table into MBR (msdos table) Note: only GPT tables supports this """ self.partitioner.set_mbr() def wipe(self): """ Zap (destroy) any GPT and MBR data structures if present For DASD disks create a new VTOC table """ if 'dasd' in self.table_type: log.debug('Initialize DASD disk with new VTOC table') fdasd_input = NamedTemporaryFile() with open(fdasd_input.name, 'w') as vtoc: vtoc.write('y\n\nw\nq\n') bash_command = ' '.join( [ 'cat', fdasd_input.name, '|', 'fdasd', '-f', self.storage_provider.get_device() ] ) try: Command.run( ['bash', '-c', bash_command] ) except Exception: # unfortunately fdasd reports that it can't read in the # partition table which I consider a bug in fdasd. However # the table was correctly created and therefore we continue. # Problem is that we are not able to detect real errors # with the fdasd operation at that point. log.debug('potential fdasd errors were ignored') else: log.debug('Initialize %s disk', self.table_type) Command.run( [ 'sgdisk', '--zap-all', self.storage_provider.get_device() ] ) def map_partitions(self): """ Map/Activate partitions In order to access the partitions through a device node it is required to map them if the storage provider is loop based """ if self.storage_provider.is_loop(): Command.run( ['kpartx', '-s', '-a', self.storage_provider.get_device()] ) self.is_mapped = True else: Command.run( ['partprobe', self.storage_provider.get_device()] ) def get_public_partition_id_map(self): """ Populated partition name to number map """ return OrderedDict( sorted(self.public_partition_id_map.items()) ) def _add_to_public_id_map(self, name, value=None): if not value: value = self.partitioner.get_id() self.public_partition_id_map[name] = value def _add_to_map(self, name): device_node = None partition_number = format(self.partitioner.get_id()) if self.storage_provider.is_loop(): device_base = os.path.basename(self.storage_provider.get_device()) device_node = ''.join( ['/dev/mapper/', device_base, 'p', partition_number] ) else: device = self.storage_provider.get_device() if device[-1].isdigit(): device_node = ''.join( [device, 'p', partition_number] ) else: device_node = ''.join( [device, partition_number] ) if device_node: self.partition_map[name] = device_node self.partition_id_map[name] = partition_number def __del__(self): if self.storage_provider.is_loop() and self.is_mapped: log.info('Cleaning up %s instance', type(self).__name__) try: for device_node in self.partition_map.values(): Command.run(['dmsetup', 'remove', device_node]) except Exception: log.warning( 'cleanup of partition device maps failed, %s still busy', self.storage_provider.get_device() )
def test_partitioner_dasd(self, mock_dasd): storage_provider = Mock() Partitioner.new('dasd', storage_provider) mock_dasd.assert_called_once_with(storage_provider, None, False)
def test_partitioner_for_arch_not_implemented(self, mock_machine): mock_machine.return_value = 'some-arch' Partitioner('foo', mock.Mock())
def test_partitioner_gpt(self, mock_gpt): storage_provider = Mock() Partitioner.new('gpt', storage_provider) mock_gpt.assert_called_once_with(storage_provider, None, False)
def test_partitioner_s390_dasd(self, mock_machine, mock_dasd): mock_machine.return_value = 's390' storage_provider = mock.Mock() Partitioner('dasd', storage_provider) mock_dasd.assert_called_once_with(storage_provider)
class Disk(DeviceProvider): """ **Implements storage disk and partition table setup** :param string table_type: Partition table type name :param object storage_provider: Instance of class based on DeviceProvider :param int start_sector: sector number """ def __init__(self, table_type, storage_provider, start_sector=None): # bind the underlaying block device providing class instance # to this object (e.g loop) if present. This is done to guarantee # the correct destructor order when the device should be released. self.storage_provider = storage_provider self.partition_map = {} self.public_partition_id_map = {} self.partition_id_map = {} self.is_mapped = False self.partitioner = Partitioner(table_type, storage_provider, start_sector) self.table_type = table_type def get_device(self): """ Names of partition devices Note that the mapping requires an explicit map() call :return: instances of MappedDevice :rtype: dict """ device_map = {} for partition_name, device_node in list(self.partition_map.items()): device_map[partition_name] = MappedDevice(device=device_node, device_provider=self) return device_map def is_loop(self): """ Check if storage provider is loop based The information is taken from the storage provider. If the storage provider is loop based the disk is it too :return: True or False :rtype: bool """ return self.storage_provider.is_loop() def create_root_partition(self, mbsize): """ Create root partition Populates kiwi_RootPart(id) and kiwi_BootPart(id) if no extra boot partition is requested :param int mbsize: partition size """ self.partitioner.create('p.lxroot', mbsize, 't.linux') self._add_to_map('root') self._add_to_public_id_map('kiwi_RootPart') if 'kiwi_ROPart' in self.public_partition_id_map: self._add_to_public_id_map('kiwi_RWPart') if 'kiwi_BootPart' not in self.public_partition_id_map: self._add_to_public_id_map('kiwi_BootPart') def create_root_lvm_partition(self, mbsize): """ Create root partition for use with LVM Populates kiwi_RootPart(id) and kiwi_RootPartVol(LVRoot) :param int mbsize: partition size """ self.partitioner.create('p.lxlvm', mbsize, 't.lvm') self._add_to_map('root') self._add_to_public_id_map('kiwi_RootPart') self._add_to_public_id_map('kiwi_RootPartVol', 'LVRoot') def create_root_raid_partition(self, mbsize): """ Create root partition for use with MD Raid Populates kiwi_RootPart(id) and kiwi_RaidPart(id) as well as the default raid device node at boot time which is configured to be kiwi_RaidDev(/dev/mdX) :param int mbsize: partition size """ self.partitioner.create('p.lxraid', mbsize, 't.raid') self._add_to_map('root') self._add_to_public_id_map('kiwi_RootPart') self._add_to_public_id_map('kiwi_RaidPart') def create_root_readonly_partition(self, mbsize): """ Create root readonly partition for use with overlayfs Populates kiwi_ReadOnlyPart(id), the partition is meant to contain a squashfs readonly filesystem. The partition size should be the size of the squashfs filesystem in order to avoid wasting disk space :param int mbsize: partition size """ self.partitioner.create('p.lxreadonly', mbsize, 't.linux') self._add_to_map('readonly') self._add_to_public_id_map('kiwi_ROPart') def create_boot_partition(self, mbsize): """ Create boot partition Populates kiwi_BootPart(id) :param int mbsize: partition size """ self.partitioner.create('p.lxboot', mbsize, 't.linux') self._add_to_map('boot') self._add_to_public_id_map('kiwi_BootPart') def create_prep_partition(self, mbsize): """ Create prep partition Populates kiwi_PrepPart(id) :param int mbsize: partition size """ self.partitioner.create('p.prep', mbsize, 't.prep') self._add_to_map('prep') self._add_to_public_id_map('kiwi_PrepPart') def create_spare_partition(self, mbsize): """ Create spare partition for custom use Populates kiwi_SparePart(id) :param int mbsize: partition size """ self.partitioner.create('p.spare', mbsize, 't.linux') self._add_to_map('spare') self._add_to_public_id_map('kiwi_SparePart') def create_swap_partition(self, mbsize): """ Create swap partition Populates kiwi_SwapPart(id) :param int mbsize: partition size """ self.partitioner.create('p.swap', mbsize, 't.swap') self._add_to_map('swap') self._add_to_public_id_map('kiwi_SwapPart') def create_efi_csm_partition(self, mbsize): """ Create EFI bios grub partition Populates kiwi_BiosGrub(id) :param int mbsize: partition size """ self.partitioner.create('p.legacy', mbsize, 't.csm') self._add_to_map('efi_csm') self._add_to_public_id_map('kiwi_BiosGrub') def create_efi_partition(self, mbsize): """ Create EFI partition Populates kiwi_EfiPart(id) :param int mbsize: partition size """ self.partitioner.create('p.UEFI', mbsize, 't.efi') self._add_to_map('efi') self._add_to_public_id_map('kiwi_EfiPart') def activate_boot_partition(self): """ Activate boot partition Note: not all Partitioner instances supports this """ partition_id = None if 'prep' in self.partition_id_map: partition_id = self.partition_id_map['prep'] elif 'boot' in self.partition_id_map: partition_id = self.partition_id_map['boot'] elif 'root' in self.partition_id_map: partition_id = self.partition_id_map['root'] if partition_id: self.partitioner.set_flag(partition_id, 'f.active') def create_hybrid_mbr(self): """ Turn partition table into a hybrid GPT/MBR table Note: only GPT tables supports this """ self.partitioner.set_hybrid_mbr() def create_mbr(self): """ Turn partition table into MBR (msdos table) Note: only GPT tables supports this """ self.partitioner.set_mbr() def wipe(self): """ Zap (destroy) any GPT and MBR data structures if present For DASD disks create a new VTOC table """ if 'dasd' in self.table_type: log.debug('Initialize DASD disk with new VTOC table') fdasd_input = NamedTemporaryFile() with open(fdasd_input.name, 'w') as vtoc: vtoc.write('y\n\nw\nq\n') bash_command = ' '.join([ 'cat', fdasd_input.name, '|', 'fdasd', '-f', self.storage_provider.get_device() ]) try: Command.run(['bash', '-c', bash_command]) except Exception: # unfortunately fdasd reports that it can't read in the # partition table which I consider a bug in fdasd. However # the table was correctly created and therefore we continue. # Problem is that we are not able to detect real errors # with the fdasd operation at that point. log.debug('potential fdasd errors were ignored') else: log.debug('Initialize %s disk', self.table_type) Command.run( ['sgdisk', '--zap-all', self.storage_provider.get_device()]) def map_partitions(self): """ Map/Activate partitions In order to access the partitions through a device node it is required to map them if the storage provider is loop based """ if self.storage_provider.is_loop(): Command.run( ['kpartx', '-s', '-a', self.storage_provider.get_device()]) self.is_mapped = True else: Command.run(['partprobe', self.storage_provider.get_device()]) def get_public_partition_id_map(self): """ Populated partition name to number map """ return OrderedDict(sorted(self.public_partition_id_map.items())) def _add_to_public_id_map(self, name, value=None): if not value: value = self.partitioner.get_id() self.public_partition_id_map[name] = value def _add_to_map(self, name): device_node = None partition_number = format(self.partitioner.get_id()) if self.storage_provider.is_loop(): device_base = os.path.basename(self.storage_provider.get_device()) device_node = ''.join( ['/dev/mapper/', device_base, 'p', partition_number]) else: device = self.storage_provider.get_device() if device[-1].isdigit(): device_node = ''.join([device, 'p', partition_number]) else: device_node = ''.join([device, partition_number]) if device_node: self.partition_map[name] = device_node self.partition_id_map[name] = partition_number def __del__(self): if self.storage_provider.is_loop() and self.is_mapped: log.info('Cleaning up %s instance', type(self).__name__) try: for device_node in self.partition_map.values(): Command.run(['dmsetup', 'remove', device_node]) except Exception: log.warning( 'cleanup of partition device maps failed, %s still busy', self.storage_provider.get_device())
def test_partitioner_arm_msdos(self, mock_machine, mock_dos): mock_machine.return_value = 'armv7l' storage_provider = mock.Mock() Partitioner('msdos', storage_provider) mock_dos.assert_called_once_with(storage_provider)
def test_partitioner_for_arch_not_implemented(self, mock_machine): mock_machine.return_value = 'some-arch' with raises(KiwiPartitionerSetupError): Partitioner('foo', Mock())
def test_partitioner_for_arch_not_implemented(self): with raises(KiwiPartitionerSetupError): Partitioner.new('foo', Mock())
def test_partitioner_dasd_with_custom_start_sector(self, mock_dasd): storage_provider = Mock() with self._caplog.at_level(logging.WARNING): Partitioner.new('dasd', storage_provider, 4096) mock_dasd.assert_called_once_with(storage_provider, None, False)