def _build_filesystem_list(self): log.debug('FileSystemView: building part list') cols = [] longest_path = len("MOUNT POINT") for m in sorted(self.model._mounts, key=lambda m:m.path): path = m.path longest_path = max(longest_path, len(path)) for p, *_ in reversed(cols): if path.startswith(p): path = [('info_minor', p), path[len(p):]] break cols.append((m.path, path, humanize_size(m.device.volume.size), m.device.fstype, m.device.volume.desc())) for fs in self.model._filesystems: if fs.fstype == 'swap': cols.append((None, 'SWAP', humanize_size(fs.volume.size), fs.fstype, fs.volume.desc())) if len(cols) == 0: return Pile([Color.info_minor( Text("No disks or partitions mounted."))]) cols.insert(0, (None, "MOUNT POINT", "SIZE", "TYPE", "DEVICE TYPE")) pl = [] for _, a, b, c, d in cols: if b == "SIZE": b = Text(b, align='center') else: b = Text(b, align='right') pl.append(Columns([(longest_path, Text(a)), (9, b), (self.model.longest_fs_name, Text(c)), Text(d)], 4)) return Pile(pl)
def verify_size_ok(level, sizes): r = False try: devs = create_devices_for_sizes(sizes) raid = create_raid(level, devs) devs = [FakeDev(size) for size in sizes] calc_size = get_raid_size(level, devs) real_size = get_real_raid_size(raid) if len(set(sizes)) == 1: sz = '[{}]*{}'.format(humanize_size(sizes[0]), len(sizes)) else: sz = str([humanize_size(s) for s in sizes]) print("level {} sizes {} -> calc_size {} real_size {}".format( level, sz, calc_size, real_size), end=' ') if calc_size > real_size: print("BAAAAAAAAAAAD", real_size - calc_size) if os.environ.get('DEBUG'): print(raid) input('waiting: ') elif calc_size == real_size: print("exactly right!") r = True else: print("subiquity wasted space", real_size - calc_size) r = True finally: cleanup() return r
def lost_focus(self): val = self.value if not val: return suffixes = ''.join(HUMAN_UNITS) + ''.join(HUMAN_UNITS).lower() if val[-1] not in suffixes: unit = self.form.size_str[-1] val += unit self.value = val try: sz = self.form.size.value except ValueError: return if sz > self.form.max_size: self.value = self.form.size_str self.form.size.show_extra( ('info_minor', _("Capped partition size at {size}").format( size=self.form.size_str))) elif (align_up(sz) != sz and humanize_size(align_up(sz)) != self.form.size.value): sz_str = humanize_size(align_up(sz)) self.value = sz_str self.form.size.show_extra( ('info_minor', _("Rounded size up to {size}").format(size=sz_str)))
def summarize_device(device, part_filter=lambda p: True): """Return content for a table summarizing device. This (obj, cells) where obj is either device itself, a partition of device or None and cells is part of an argument to TableRow that will span 4 columns that describes device or a partition of device. This sounds a bit strange but hopefully you can figure it out by looking at the uses of this function. """ label = labels.label(device) anns = labels.annotations(device) if anns: label = "{} ({})".format(label, ", ".join(anns)) rows = [(device, [ (2, Text(label)), Text(labels.desc(device)), Text(humanize_size(device.size), align="right"), ])] partitions = device.partitions() if partitions: for part in device.partitions(): if not part_filter(part): continue details = ", ".join( labels.annotations(part) + labels.usage_labels(part)) rows.append((part, [ Text(labels.label(part, short=True)), (2, Text(details)), Text(humanize_size(part.size), align="right"), ])) else: rows.append((None, [ (4, Color.info_minor(Text(", ".join(labels.usage_labels(device))))) ])) return rows
def __init__(self, parent, snap, cur_channel): self.parent = parent self.snap = snap self.channels = [] self.needs_focus = True channel_width = (max(len(csi.channel_name) for csi in snap.channels) + StarRadioButton.reserve_columns + 1) max_version = max(len(csi.version) for csi in snap.channels) max_revision = max(len(str(csi.revision)) for csi in snap.channels) + 2 max_size = max(len(humanize_size(csi.size)) for csi in snap.channels) self.description = Text(snap.description.replace('\r', '').strip()) self.lb_description = ListBox([self.description]) radio_group = [] for csi in snap.channels: notes = '-' if csi.confinement != "strict": notes = csi.confinement btn = StarRadioButton(radio_group, "{}:".format(csi.channel_name), state=csi.channel_name == cur_channel, on_state_change=self.state_change, user_data=SnapSelection( channel=csi.channel_name, is_classic=csi.confinement == "classic")) self.channels.append( Color.menu_button( Columns([ (channel_width, btn), (max_version, Text(csi.version)), (max_revision, Text("({})".format(csi.revision))), (max_size, Text(humanize_size(csi.size))), ('pack', Text(notes)), ], dividechars=1))) self.lb_channels = NoTabCyclingListBox(self.channels) title = Columns([ Text(snap.name), ('pack', Text(_("Publisher: {}").format(snap.publisher), align='right')), ], dividechars=1) contents = [ ('pack', title), ('pack', Text("")), ('pack', Text(snap.summary)), ('pack', Text("")), self.lb_description, # overwritten in render() ('pack', Text("")), ('weight', 1, self.lb_channels), ] self.description_index = contents.index(self.lb_description) self.pile = Pile(contents) super().__init__(self.pile)
def __init__(self, model, controller, disk, partition=None): log.debug('PartitionView: selected_disk=[{}]'.format(disk.path)) self.model = model self.controller = controller self.disk = disk self.partition = partition max_size = disk.free if partition is None: initial = {'partnum': disk.next_partnum} label = _("Create") else: max_size += partition.size initial = { 'partnum': partition.number, 'size': humanize_size(partition.size), } label = _("Save") super().__init__(max_size, partition, initial, lambda: self.controller.partition_disk(disk)) self.form.buttons.base_widget[0].set_label(label) if partition is not None and partition.flag == "boot": opts = [Option(("fat32", True, self.model.fs_by_name["fat32"]))] self.form.fstype.widget._options = opts self.form.fstype.widget.index = 0 self.form.mount.enabled = False self.form.fstype.enabled = False
def __init__(self, model, max_size, initial, lvm_names, device): self.model = model self.device = device self.existing_fs_type = None if device: ofstype = device.original_fstype() if ofstype: self.existing_fs_type = ofstype initial_path = initial.get('mount') self.mountpoints = { m.path: m.device.volume for m in self.model.all_mounts() if m.path != initial_path } self.max_size = max_size if max_size is not None: self.size_str = humanize_size(max_size) self.size.caption = _("Size (max {size}):").format( size=self.size_str) self.lvm_names = lvm_names super().__init__(initial) if max_size is None: self.remove_field('size') connect_signal(self.fstype.widget, 'select', self.select_fstype) self.form_pile = None self.select_fstype(None, self.fstype.widget.value)
def _build_disk_selection(self): log.debug('lvm: _build_disk_selection') items = [Text("DISK SELECTION")] # lvm can use empty whole disks, or empty partitions avail_disks = self.model.get_empty_disk_names() avail_parts = self.model.get_empty_partition_names() avail_devs = sorted(avail_disks + avail_parts) if len(avail_devs) == 0: return items.append( [Color.info_minor(Text("No available disks."))]) for dname in avail_devs: device = self.model.get_disk(dname) if device.path != dname: # we've got a partition lvmdev = device.get_partition(dname) else: lvmdev = device disk_sz = humanize_size(lvmdev.size) disk_string = "{} {}, {}".format(dname, disk_sz, device.model) log.debug('lvm: disk_string={}'.format(disk_string)) self.selected_disks.append(CheckBox(disk_string)) items += self.selected_disks return Pile(items)
def __init__(self, model, controller): self.model = model self.controller = controller cancel = cancel_btn(_("Cancel"), on_press=self.cancel) disks = [] for disk in self.model.all_disks(): label = "%-42s %s" % (disk.label, humanize_size( disk.size).rjust(9)) if disk.size >= model.lower_size_limit: disk_btn = forward_btn(label, on_press=self.choose_disk, user_arg=disk) else: disk_btn = Color.info_minor(Text(" " + label)) disks.append(disk_btn) body = Pile([ ('pack', Text("")), ('pack', Padding.center_70(Text(_("Choose the disk to install to:")))), ('pack', Text("")), Padding.center_70(ListBox(disks)), ('pack', Text("")), ('pack', button_pile([cancel])), ('pack', Text("")), ]) super().__init__(body)
def __init__(self, model, controller, method): self.model = model self.controller = controller self.method = method cancel = cancel_btn(_("Cancel"), on_press=self.cancel) rows = [] for disk in self.model.all_disks(): if disk.size >= dehumanize_size("6G"): disk_btn = ClickableIcon(disk.label) connect_signal( disk_btn, 'click', self.choose_disk, disk) attr = Color.done_button else: disk_btn = Text(" "+disk.label) attr = Color.info_minor rows.append(attr(TableRow([ Text('['), disk_btn, Text(humanize_size(disk.size), align='right'), Text('\N{BLACK RIGHT-POINTING SMALL TRIANGLE}'), Text(']'), ]))) super().__init__(screen( TableListBox(rows, spacing=1, colspecs={ 1: ColSpec(can_shrink=True, min_width=20, rpad=2), 2: ColSpec(min_width=9), }), button_pile([cancel]), focus_buttons=False, excerpt=( excerpts[method] + "\n\n" + _("Choose the disk to install to:"))))
def _get_available_devs(self, section): devs = [] # bcache can use empty whole disks, or empty partitions avail_disks = self.model.get_empty_disk_names() avail_parts = self.model.get_empty_partition_names() input_disks = avail_disks + avail_parts if section == 'CACHE': input_disks += self.model.get_bcache_cachedevs() # filter out: # currently selected cache or backing disk # any bcache devices bcache_names = list(self.model.bcache_devices.keys()) selected_disks = [self.backing_disk, self.cache_disk] filter_disks = bcache_names + selected_disks avail_devs = sorted( [dev for dev in input_disks if dev not in filter_disks]) for dname in avail_devs: device = self.model.get_disk(dname) if device.path != dname: # we've got a partition bcachedev = device.get_partition(dname) else: bcachedev = device disk_sz = humanize_size(bcachedev.size) disk_string = "{} {}, {}".format(dname, disk_sz, device.model) log.debug('bcache: disk_string={}'.format(disk_string)) devs.append(disk_string) return devs
def set_bound_form_field(self, bff): super().set_bound_form_field(bff) self.all_rows = [] for kind, device in bff.form.all_devices: if kind == LABEL: self.all_rows.append(TableRow([ Text(" " + device.label), Text(humanize_size(device.size), align='right') ])) self.no_selector_rows.append(self.all_rows[-1]) self.all_rows.append(TableRow([ (2, Color.info_minor(Text(" " + device.desc()))) ])) self.no_selector_rows.append(self.all_rows[-1]) else: if kind == DEVICE: label = device.label prefix = " " elif kind == PART: label = _(" partition {}").format(device._number) prefix = " " else: raise Exception("unexpected kind {}".format(kind)) box = CheckBox( label, on_state_change=self._state_change_device, user_data=device) self.device_to_checkbox[device] = box size = Text(humanize_size(device.size), align='right') self.all_rows.append(Color.menu_button(TableRow([box, size]))) self.no_selector_rows.append(self.all_rows[-1]) selector = Selector(['active', 'spare']) connect_signal( selector, 'select', self._select_active_spare, device) selector = Toggleable( UrwidPadding( Color.menu_button(selector), left=len(prefix))) selector.disable() self.device_to_selector[device] = selector self.all_rows.append(TableRow([(2, selector)])) # Do not append that one to no_selector_rows! self.all_rows.append(self._summarize(prefix, device)) self.no_selector_rows.append(self.all_rows[-1]) self.table.set_contents(self.all_rows) log.debug("%s", self.table._w.focus_position)
def refresh_model_inputs(self): devices = [ d for d in self.parent.model.all_devices() if (d.available() == self.show_available or ( not self.show_available and d.has_unavailable_partition())) ] if len(devices) == 0: self._w = Padding.push_2(self._no_devices_content) self.table.table_rows = [] return self._w = self.table log.debug('FileSystemView: building device list') rows = [] rows.append( Color.info_minor( TableRow([ Text(""), (2, Text(_("DEVICE"))), Text(_("TYPE")), Text(_("SIZE"), align="center"), Text(""), Text(""), ]))) for device in devices: for obj, cells in summarize_device( device, lambda part: part.available() == self.show_available): if obj is not None: menu = self._action_menu_for_device(obj) else: menu = Text("") if obj is device: start, end = '[', ']' else: start, end = '', '' cells = [Text(start)] + cells + [menu, Text(end)] if obj is not None: rows.append(make_action_menu_row(cells, menu)) else: rows.append(TableRow(cells)) if (self.show_available and device.used > 0 and device.free_for_partitions > 0): free = humanize_size(device.free_for_partitions) rows.append( TableRow([ Text(""), (3, Color.info_minor(Text(_("free space")))), Text(free, align="right"), Text(""), Text(""), ])) rows.append(TableRow([Text("")])) self.table.set_contents(rows[:-1]) if self.table._w.focus_position >= len(rows): self.table._w.focus_position = len(rows) - 1 while not self.table._w.focus.selectable(): self.table._w.focus_position -= 1
def _build_model_inputs(self): partitioned_disks = [] def format_volume(label, part): size = humanize_size(part.size) if part.fs() is None: fstype = '-' mountpoint = '-' elif part.fs().mount() is None: fstype = part.fs().fstype mountpoint = '-' else: fstype = part.fs().fstype mountpoint = part.fs().mount().path if part.type == 'disk': part_btn = menu_btn(label, on_press=self._click_disk) else: part_btn = menu_btn(label, on_press=self._click_part, user_arg=part) return Columns([ (25, part_btn), (9, Text(size, align="right")), Text(fstype), Text(mountpoint), ], 2) if self.disk.fs() is not None: partitioned_disks.append(format_volume("entire disk", self.disk)) else: for part in self.disk.partitions(): partitioned_disks.append( format_volume("Partition {}".format(part.number), part)) if self.disk.free > 0: free_space = humanize_size(self.disk.free) if len(self.disk.partitions()) > 0: label = "Add another partition" else: label = "Add first partition" add_btn = menu_btn(label, on_press=self.add_partition) partitioned_disks.append( Columns([ (25, add_btn), (9, Text(free_space, align="right")), Text("free space"), ], 2)) if len(self.disk.partitions()) == 0 and \ self.disk.available: text = ("Format or create swap on entire " "device (unusual, advanced)") partitioned_disks.append(Text("")) partitioned_disks.append( menu_btn(label=text, on_press=self.format_entire)) return partitioned_disks
def __init__(self, mountpoint_to_devpath_mapping, max_size, initial={}): self.mountpoint_to_devpath_mapping = mountpoint_to_devpath_mapping self.max_size = max_size if max_size is not None: self.size_str = humanize_size(max_size) self.size.caption = _("Size (max {})").format(self.size_str) super().__init__(initial) if max_size is None: self.remove_field('size') connect_signal(self.fstype.widget, 'select', self.select_fstype) self.select_fstype(None, self.fstype.widget.value)
def summarize_device(disk): label = disk.label rows = [(disk, [ (2, Text(label)), Text(disk.type), Text(humanize_size(disk.size), align="right"), ])] if disk.partitions: for part in disk.partitions: details = ", ".join(part.annotations) rows.append((part, [ Text(_("partition {number}").format(number=part.number)), (2, Text(details)), Text(humanize_size(part.size), align="right"), ])) else: rows.append((None, [ (4, Color.info_minor(Text(", ".join(disk.usage_labels)))) ])) return rows
def _select_level(self, sender, new_level): active_device_count = len(self.form.devices.widget.active_devices) if active_device_count >= new_level.min_devices: self.form.size.value = humanize_size( get_raid_size(new_level.value, self.form.devices.value)) else: self.form.size.value = '-' self.form.devices.widget.set_supports_spares(new_level.supports_spares) self.form.level.value = new_level self.form.devices.showing_extra = False self.form.devices.validate()
def show_disk_information(self, disk): """ Show disk information, requires sudo/root """ bus = disk._info.raw.get('ID_BUS', None) major = disk._info.raw.get('MAJOR', None) if bus is None and major == '253': bus = 'virtio' devpath = disk._info.raw.get('DEVPATH', disk.path) rotational = '1' try: dev = os.path.basename(devpath) rfile = '/sys/class/block/{}/queue/rotational'.format(dev) rotational = open(rfile, 'r').read().strip() except (PermissionError, FileNotFoundError, IOError): log.exception('WARNING: Failed to read file {}'.format(rfile)) pass dinfo = { 'bus': bus, 'devname': disk.path, 'devpath': devpath, 'model': disk.model, 'serial': disk.serial, 'size': disk.size, 'humansize': humanize_size(disk.size), 'vendor': disk._info.vendor, 'rotational': 'true' if rotational == '1' else 'false', } if dinfo['serial'] is None: dinfo['serial'] = 'unknown' if dinfo['model'] is None: dinfo['model'] = 'unknown' if dinfo['vendor'] is None: dinfo['vendor'] = 'unknown' template = """\n {devname}:\n Vendor: {vendor} Model: {model} SerialNo: {serial} Size: {humansize} ({size}B) Bus: {bus} Rotational: {rotational} Path: {devpath} """ result = template.format(**dinfo) log.debug('calling DiskInfoView()') disk_info_view = DiskInfoView(self.model, self, disk, result) footer = _('Select next or previous disks with n and p') self.ui.set_footer(footer) self.ui.set_body(disk_info_view)
def __init__(self, mountpoints, max_size, initial, ok_for_slash_boot, lvm_names): self.mountpoints = mountpoints self.ok_for_slash_boot = ok_for_slash_boot self.max_size = max_size if max_size is not None: self.size_str = humanize_size(max_size) self.size.caption = _("Size (max {}):").format(self.size_str) self.lvm_names = lvm_names super().__init__(initial) if max_size is None: self.remove_field('size') connect_signal(self.fstype.widget, 'select', self.select_fstype) self.select_fstype(None, self.fstype.widget.value)
def __init__(self, model, controller, disk, partition=None): log.debug('PartitionView: selected_disk=[{}]'.format(disk.path)) self.model = model self.controller = controller self.disk = disk self.partition = partition self.title = _("Partition, format, and mount {}").format(disk.label) max_size = disk.free initial = {} if partition is None: label = _("Create") self.footer = _("Enter partition details, format and mount.") else: max_size += partition.size initial['size'] = humanize_size(partition.size) if partition.flag == "bios_grub": label = None initial['mount'] = None else: self.footer = _("Edit partition details, format and mount.") label = _("Save") super().__init__(max_size, partition, initial, lambda: self.controller.partition_disk(disk), focus_buttons=label is None) if label is not None: self.form.buttons.base_widget[0].set_label(label) else: del self.form.buttons.base_widget.contents[0] self.form.buttons.base_widget[0].set_label(_("OK")) if partition is not None: if partition.flag == "boot": opts = [ Option(("fat32", True, self.model.fs_by_name["fat32"])) ] self.form.fstype.widget._options = opts self.form.fstype.widget.index = 0 self.form.mount.enabled = False self.form.fstype.enabled = False elif partition.flag == "bios_grub": self.form.mount.enabled = False self.form.fstype.enabled = False self.form.size.enabled = False
def __init__(self, model, controller): self.model = model self.controller = controller cancel = cancel_btn("Cancel", on_press=self.cancel) disks = [] for disk in self.model.all_disks(): disk_btn = forward_btn( "%-40s %s" % (disk.serial, humanize_size(disk.size).rjust(9)), on_press=self.choose_disk, user_arg=disk) disks.append(disk_btn) lb = ListBox([ Padding.center_70(Text("")), Padding.center_70(Text(_("Choose the disk to install to:"))), Padding.center_70(Text("")), Padding.center_70(Pile(disks)), Padding.center_70(Text("")), button_pile([cancel]), ]) super().__init__(lb)
def format_volume(label, part): size = humanize_size(part.size) if part.fs() is None: fstype = '-' mountpoint = '-' elif part.fs().mount() is None: fstype = part.fs().fstype mountpoint = '-' else: fstype = part.fs().fstype mountpoint = part.fs().mount().path if part.type == 'disk': part_btn = menu_btn(label, on_press=self._click_disk) else: part_btn = menu_btn(label, on_press=self._click_part, user_arg=part) return Columns([ (label_width, part_btn), (9, Text(size, align="right")), Text(fstype), Text(mountpoint), ], 2)
def _change_devices(self, sender, new_devices): if len(sender.active_devices) >= self.form.level.value.min_devices: self.form.size.value = humanize_size( get_raid_size(self.form.level.value.value, new_devices)) else: self.form.size.value = '-'
def refresh_model_inputs(self): devices = [ d for d in self.parent.model.all_devices() if (d.available() == self.show_available or ( not self.show_available and d.has_unavailable_partition())) ] if len(devices) == 0: self._w = self._no_devices_content self.table.table_rows = [] return self._w = self.table log.debug('FileSystemView: building device list') rows = [] def _fmt_fs(label, fs): r = _("{} {}").format(label, fs.fstype) if not self.parent.model.fs_by_name[fs.fstype].is_mounted: return r m = fs.mount() if m: r += _(", {}").format(m.path) else: r += _(", not mounted") return r def _fmt_constructed(label, device): return _("{} part of {} ({})").format(label, device.label, device.desc()) rows.append( TableRow([ Text(_("DEVICE")), Text(_("SIZE"), align="center"), Text(_("TYPE")), ])) for device in devices: menu = self._action_menu_for_device(device) row = TableRow([ Text(device.label), Text("{:>9}".format(humanize_size(device.size))), Text(device.desc()), menu, ]) row = add_menu_row_focus_behaviour(menu, row, 'menu_button', 'menu_button focus') rows.append(row) entire_label = None if device.fs(): entire_label = _fmt_fs(_(" entire device formatted as"), device.fs()) elif device.constructed_device(): entire_label = _fmt_constructed(_(" entire device"), device.constructed_device()) if entire_label is not None: rows.append(TableRow([ Text(entire_label), ])) else: for part in device.partitions(): if part.available() != self.show_available: continue prefix = _(" partition {},").format(part._number) if part.flag == "bios_grub": label = prefix + " bios_grub" elif part.fs(): label = _fmt_fs(prefix, part.fs()) elif part.constructed_device(): label = _fmt_constructed(prefix, part.constructed_device()) else: label = _("{} not formatted").format(prefix) part_size = "{:>9} ({}%)".format( humanize_size(part.size), int(100 * part.size / device.size)) menu = self._action_menu_for_device(part) row = TableRow([ Text(label), (2, Text(part_size)), menu, ]) row = add_menu_row_focus_behaviour(menu, row, 'menu_button', 'menu_button focus', cursor_x=2) rows.append(row) if self.show_available and 0 < device.used < device.size: size = device.size free = device.free_for_partitions percent = str(int(100 * free / size)) if percent == "0": percent = "%.2f" % (100 * free / size, ) size_text = "{:>9} ({}%)".format(humanize_size(free), percent) rows.append( TableRow( [Text(_(" free space")), (2, Text(size_text))])) self.table.set_contents(rows) if self.table._w.focus_position >= len(rows): self.table._w.focus_position = len(rows) - 1 while not self.table._w.focus.selectable(): self.table._w.focus_position -= 1
def size(self): return humanize_size(self.mount.device.volume.size)
def _change_devices(self, sender, new_devices): if len(sender.active_devices) >= 1: self.form.size.value = humanize_size(get_lvm_size(new_devices)) else: self.form.size.value = '-'
def test_basics(self): for string, integer in self.basics: with self.subTest(input=string): self.assertEqual(string, humanize_size(integer))
def __init__(self, parent, disk, partition=None): self.disk = disk self.partition = partition self.model = parent.model self.controller = parent.controller self.parent = parent max_size = disk.free_for_partitions mountpoints = { m.path: m.device.volume for m in self.model.all_mounts()} initial = {} label = _("Create") if isinstance(disk, LVM_VolGroup): lvm_names = {p.name for p in disk.partitions()} else: lvm_names = set() if self.partition: if self.partition.flag == "bios_grub": label = None initial['mount'] = None else: label = _("Save") initial['size'] = humanize_size(self.partition.size) max_size += self.partition.size fs = self.partition.fs() if fs is not None: if partition.flag != "boot": initial['fstype'] = self.model.fs_by_name[fs.fstype] mount = fs.mount() if mount is not None: initial['mount'] = mount.path del mountpoints[mount.path] else: initial['fstype'] = self.model.fs_by_name[None] if isinstance(disk, LVM_VolGroup): initial['name'] = partition.name lvm_names.remove(partition.name) elif isinstance(disk, LVM_VolGroup): x = 0 while True: name = 'lv-{}'.format(x) if name not in lvm_names: break x += 1 initial['name'] = name self.form = PartitionForm( mountpoints, max_size, initial, isinstance(disk, Disk), lvm_names) if not isinstance(disk, LVM_VolGroup): self.form.remove_field('name') if label is not None: self.form.buttons.base_widget[0].set_label(label) else: del self.form.buttons.base_widget.contents[0] self.form.buttons.base_widget[0].set_label(_("OK")) if partition is not None: if partition.flag == "boot": opts = [ Option(("fat32", True, self.model.fs_by_name["fat32"])), ] self.form.fstype.widget.options = opts self.form.fstype.widget.index = 0 self.form.mount.enabled = False self.form.fstype.enabled = False elif partition.flag == "bios_grub": self.form.mount.enabled = False self.form.fstype.enabled = False self.form.size.enabled = False connect_signal(self.form, 'submit', self.done) connect_signal(self.form, 'cancel', self.cancel) rows = [] focus_index = 0 if partition is not None: if self.partition.flag == "boot": rows.extend([ Text(_(boot_partition_description)), Text(""), ]) elif self.partition.flag == "bios_grub": rows.extend([ Text(_(bios_grub_partition_description)), Text(""), ]) focus_index = 2 rows.extend(self.form.as_rows()) widgets = [ Pile(rows), Text(""), self.form.buttons, ] if partition is None: if isinstance(disk, LVM_VolGroup): add_name = _("logical volume") else: add_name = _("partition") title = _("Adding {} to {}").format(add_name, disk.label) else: if isinstance(disk, LVM_VolGroup): desc = _("logical volume {}").format(partition.name) else: desc = partition.short_label title = _("Editing {} of {}").format(desc, disk.label) super().__init__(title, widgets, 0, focus_index)
def refresh_model_inputs(self): devices = [ d for d in self.parent.model.all_devices() if (d.available() == self.show_available or (not self.show_available and d.has_unavailable_partition())) ] if len(devices) == 0: self._w = self._no_devices_content self.table.table_rows = [] return self._w = self.table log.debug('FileSystemView: building device list') rows = [] def _usage_label(obj): cd = obj.constructed_device() if cd is not None: return _("{component_name} of {name}").format( component_name=cd.component_name, name=cd.name) fs = obj.fs() if fs is not None: m = fs.mount() if m: return _( "formatted as {fstype}, mounted at {path}").format( fstype=fs.fstype, path=m.path) else: return _("formatted as {fstype}, not mounted").format( fstype=fs.fstype) else: return _("unused") rows.append(TableRow([Color.info_minor(heading) for heading in [ Text(" "), Text(_("DEVICE")), Text(_("SIZE"), align="center"), Text(_("TYPE")), Text(" "), Text(" "), ]])) for device in devices: menu = self._action_menu_for_device(device) cells = [ Text("["), Text(device.label), Text("{:>9}".format(humanize_size(device.size))), Text(device.desc()), menu, Text("]"), ] row = make_action_menu_row(cells, menu) rows.append(row) if not device.partitions(): rows.append(TableRow([ Text(""), (3, Text(" " + _usage_label(device))), Text(""), Text(""), ])) else: for part in device.partitions(): if part.available() != self.show_available: continue menu = self._action_menu_for_device(part) part_size = "{:>9} ({}%)".format( humanize_size(part.size), int(100 * part.size / device.size)) cells = [ Text("["), Text(" " + part.short_label), (2, Text(part_size)), menu, Text("]"), ] row = make_action_menu_row(cells, menu, cursor_x=4) rows.append(row) if part.flag == "bios_grub": label = "bios_grub" else: label = _usage_label(part) rows.append(TableRow([ Text(""), (3, Text(" " + label)), Text(""), Text(""), ])) if (self.show_available and device.used > 0 and device.free_for_partitions > 0): size = device.size free = device.free_for_partitions percent = str(int(100 * free / size)) if percent == "0": percent = "%.2f" % (100 * free / size,) size_text = "{:>9} ({}%)".format( humanize_size(free), percent) rows.append(TableRow([ Text(""), Text(" " + _("free space")), (2, Text(size_text)), Text(""), Text(""), ])) self.table.set_contents(rows) if self.table._w.focus_position >= len(rows): self.table._w.focus_position = len(rows) - 1 while not self.table._w.focus.selectable(): self.table._w.focus_position -= 1
def __init__(self, parent, disk, partition=None): self.disk = disk self.partition = partition self.model = parent.model self.controller = parent.controller self.parent = parent max_size = disk.free_for_partitions initial = {} label = _("Create") if isinstance(disk, LVM_VolGroup): lvm_names = {p.name for p in disk.partitions()} else: lvm_names = None if self.partition: if self.partition.flag in ["bios_grub", "prep"]: label = None initial['mount'] = None else: label = _("Save") initial['size'] = humanize_size(self.partition.size) max_size += self.partition.size if partition.flag != "boot": initial.update(initial_data_for_fs(self.partition.fs())) else: if partition.fs() and partition.fs().mount(): initial['mount'] = '/boot/efi' else: initial['mount'] = None if isinstance(disk, LVM_VolGroup): initial['name'] = partition.name lvm_names.remove(partition.name) else: initial['fstype'] = 'ext4' if isinstance(disk, LVM_VolGroup): x = 0 while True: name = 'lv-{}'.format(x) if name not in lvm_names: break x += 1 initial['name'] = name self.form = PartitionForm( self.model, max_size, initial, lvm_names, partition) if not isinstance(disk, LVM_VolGroup): self.form.remove_field('name') if label is not None: self.form.buttons.base_widget[0].set_label(label) else: del self.form.buttons.base_widget.contents[0] self.form.buttons.base_widget[0].set_label(_("OK")) if partition is not None: if partition.flag == "boot": if partition.original_fstype(): opts = [ Option(( _("Use existing fat32 filesystem"), True, None )), Option(("---", False)), Option(( _("Reformat as fresh fat32 filesystem"), True, "fat32" )), ] self.form.fstype.widget.options = opts if partition.fs().preserve: self.form.fstype.widget.index = 0 else: self.form.fstype.widget.index = 2 self.form.mount.enabled = False else: opts = [Option(("fat32", True))] self.form.fstype.widget.options = opts self.form.fstype.widget.index = 0 self.form.mount.enabled = False self.form.fstype.enabled = False elif partition.flag in ["bios_grub", "prep"]: self.form.mount.enabled = False self.form.fstype.enabled = False self.form.size.enabled = False if partition.preserve: self.form.name.enabled = False self.form.size.enabled = False connect_signal(self.form, 'submit', self.done) connect_signal(self.form, 'cancel', self.cancel) rows = [] focus_index = 0 if partition is not None: if self.partition.flag == "boot": desc = boot_partition_description if self.partition.preserve: desc += boot_partition_description_reformat else: desc += boot_partition_description_size rows.extend([ Text(_(desc)), Text(""), ]) elif self.partition.flag == "bios_grub": rows.extend([ Text(_(bios_grub_partition_description)), Text(""), ]) focus_index = 2 elif self.partition.flag == "prep": rows.extend([ Text(_(prep_partition_description)), Text(""), ]) focus_index = 2 rows.extend(self.form.as_rows()) self.form.form_pile = Pile(rows) widgets = [ self.form.form_pile, Text(""), self.form.buttons, ] if partition is None: if isinstance(disk, LVM_VolGroup): add_name = _("logical volume") else: add_name = _("partition") title = _("Adding {} to {}").format(add_name, disk.label) else: if isinstance(disk, LVM_VolGroup): desc = _("logical volume {}").format(partition.name) else: desc = partition.short_label title = _("Editing {} of {}").format(desc, disk.label) super().__init__(title, widgets, 0, focus_index)