FAQ Search Today's Posts Mark Forums Read
» Video Reviews

» Linux Archive

Linux-archive is a website aiming to archive linux email lists and to make them easily accessible for linux users/developers.


» Sponsor

» Partners

» Sponsor

Go Back   Linux Archive > CentOS > CentOS

 
 
LinkBack Thread Tools
 
Old 04-19-2011, 04:34 PM
David Lehman
 
Default Consistently refer to stage1 and stage2 device as such.

---
pyanaconda/bootloader.py | 232 +++++++++++++++++++++++-----------------------
pyanaconda/platform.py | 20 ++--
2 files changed, 126 insertions(+), 126 deletions(-)

diff --git a/pyanaconda/bootloader.py b/pyanaconda/bootloader.py
index 9d9d794..dcb022b 100644
--- a/pyanaconda/bootloader.py
+++ b/pyanaconda/bootloader.py
@@ -195,9 +195,9 @@ class BootLoader(object):
- consider re-implementing ArgumentList as something else, like
perhaps collections.OrderedDict
- resolve overlap between Platform checkFoo methods and
- _is_valid_target_device and _is_valid_boot_device
- - split certain parts of _is_valid_target_device and
- _is_valid_boot_device into specific bootloader classes
+ _is_valid_stage1_device and _is_valid_stage2_device
+ - split certain parts of _is_valid_stage1_device and
+ _is_valid_stage2_device into specific bootloader classes
"""
name = "Generic Bootloader"
packages = []
@@ -207,26 +207,26 @@ class BootLoader(object):
can_update = False
image_label_attr = "label"

- # requirements for bootloader target devices
- target_device_types = []
- target_device_raid_levels = []
- target_device_format_types = []
- target_device_disklabel_types = []
- target_device_mountpoints = []
- target_device_min_size = None
- target_device_max_size = None
+ # requirements for bootloader stage1 devices
+ stage1_device_types = []
+ stage1_device_raid_levels = []
+ stage1_device_format_types = []
+ stage1_device_disklabel_types = []
+ stage1_device_mountpoints = []
+ stage1_device_min_size = None
+ stage1_device_max_size = None

# for UI use, eg: "mdarray": N_("RAID Device")
target_descriptions = {}

- # requirements for boot devices
- boot_device_types = []
- boot_device_raid_levels = []
- boot_device_format_types = ["ext4", "ext3", "ext2"]
- boot_device_mountpoints = ["/boot", "/"]
- boot_device_min_size = 50
- boot_device_max_size = None
- non_linux_boot_device_format_types = []
+ # requirements for stage2 devices
+ stage2_device_types = []
+ stage2_device_raid_levels = []
+ stage2_device_format_types = ["ext4", "ext3", "ext2"]
+ stage2_device_mountpoints = ["/boot", "/"]
+ stage2_device_min_size = 50
+ stage2_device_max_size = None
+ non_linux_format_types = []

# this is so stupid...
global_preserve_args = ["speakup_synth", "apic", "noapic", "apm", "ide",
@@ -261,28 +261,28 @@ class BootLoader(object):
self._default_image = None

# the device the bootloader will be installed on
- self._target_device = None
+ self._stage1_device = None

self._update_only = False

#
- # target device access
+ # stage1 device access
#
@property
def stage1_device(self):
""" Stage1 target device. """
- if not self._target_device:
- self.stage1_device = self.target_devices[0]
+ if not self._stage1_device:
+ self.stage1_device = self.stage1_devices[0]

- return self._target_device
+ return self._stage1_device

@stage1_device.setter
def stage1_device(self, device):
- if not self._is_valid_target_device(device):
- raise ValueError("%s is not a valid target device" % device.name)
+ if not self._is_valid_stage1_device(device):
+ raise ValueError("%s is not a valid stage1 device" % device.name)

log.debug("new bootloader stage1 device: %s" % device.name)
- self._target_device = device
+ self._stage1_device = device

@property
def stage2_device(self):
@@ -417,11 +417,11 @@ class BootLoader(object):
return self._device_type_index(device, types) is not None

def device_description(self, device):
- idx = self._device_type_index(device, self.target_device_types)
+ idx = self._device_type_index(device, self.stage1_device_types)
if idx is None:
raise ValueError("'%s' not a valid stage1 type" % device.type)

- return self.target_descriptions[self.target_device_types[idx]]
+ return self.target_descriptions[self.stage1_device_types[idx]]

def set_preferred_stage2_type(self, preferred):
""" Set a preferred type of stage1 device.
@@ -431,13 +431,13 @@ class BootLoader(object):
preferred = "disk"

try:
- index = self.target_device_types.index(preferred)
+ index = self.stage1_device_types.index(preferred)
except ValueError:
raise ValueError("'%s' not a valid stage1 device type" % preferred)

- self.target_device_types.insert(0, self.target_device_types.pop(index))
+ self.stage1_device_types.insert(0, self.stage1_device_types.pop(index))

- def _is_valid_target_device(self, device):
+ def _is_valid_stage1_device(self, device):
""" Return True if the device is a valid stage1 target device.

The criteria for being a valid stage1 target device vary from
@@ -446,15 +446,15 @@ class BootLoader(object):
a special device. Some examples of these special devices are EFI
system partitions on EFI machines, PReP boot partitions on
iSeries, and Apple bootstrap partitions on Mac. """
- if not self._device_type_match(device, self.target_device_types):
+ if not self._device_type_match(device, self.stage1_device_types):
return False

- if (self.target_device_min_size is not None and
- device.size < self.target_device_min_size):
+ if (self.stage1_device_min_size is not None and
+ device.size < self.stage1_device_min_size):
return False

- if (self.target_device_max_size is not None and
- device.size > self.target_device_max_size):
+ if (self.stage1_device_max_size is not None and
+ device.size > self.stage1_device_max_size):
return False

if not getattr(device, "bootable", True) or
@@ -465,38 +465,38 @@ class BootLoader(object):
if getattr(device.format, "label", None) == "ANACONDA":
return False

- if self.target_device_format_types and
- device.format.type not in self.target_device_format_types:
+ if self.stage1_device_format_types and
+ device.format.type not in self.stage1_device_format_types:
return False

- if self.target_device_disklabel_types:
+ if self.stage1_device_disklabel_types:
for disk in device.disks:
label_type = disk.format.labelType
- if label_type not in self.target_device_disklabel_types:
+ if label_type not in self.stage1_device_disklabel_types:
return False

- if self.target_device_mountpoints and
+ if self.stage1_device_mountpoints and
hasattr(device.format, "mountpoint") and
- device.format.mountpoint not in self.target_device_mountpoints:
+ device.format.mountpoint not in self.stage1_device_mountpoints:
return False

return True

@property
- def target_devices(self):
+ def stage1_devices(self):
""" A list of valid stage1 target devices.

- The list self.target_device_types is ordered, so we return a list
+ The list self.stage1_device_types is ordered, so we return a list
of all valid target devices, sorted by device type, then sorted
according to our drive ordering.
"""
- slots = [[] for t in self.target_device_types]
+ slots = [[] for t in self.stage1_device_types]
for device in self.storage.devices:
- idx = self._device_type_index(device, self.target_device_types)
+ idx = self._device_type_index(device, self.stage1_device_types)
if idx is None:
continue

- if self._is_valid_target_device(device):
+ if self._is_valid_stage1_device(device):
slots[idx].append(device)

devices = []
@@ -509,17 +509,17 @@ class BootLoader(object):
# boot/stage2 device access
#

- def _is_valid_boot_device(self, device, linux=True, non_linux=False):
+ def _is_valid_stage2_device(self, device, linux=True, non_linux=False):
""" Return True if the specified device might contain an OS image. """
- if not self._device_type_match(device, self.boot_device_types):
+ if not self._device_type_match(device, self.stage2_device_types):
return False

if device.type == "mdarray" and
- device.level not in self.boot_device_raid_levels:
+ device.level not in self.stage2_device_raid_levels:
# TODO: also check metadata version, as ridiculous as that is
return False

- if not self.target_devices:
+ if not self.stage1_devices:
# XXX is this really a dealbreaker?
return False

@@ -531,14 +531,14 @@ class BootLoader(object):

format_types = []
if linux:
- format_types = self.boot_device_format_types
+ format_types = self.stage2_device_format_types
mountpoint = getattr(device.format, "mountpoint", None)
- if self.boot_device_mountpoints and
- mountpoint not in self.boot_device_mountpoints:
+ if self.stage2_device_mountpoints and
+ mountpoint not in self.stage2_device_mountpoints:
return False

if non_linux:
- format_types.extend(self.non_linux_boot_device_for mat_types)
+ format_types.extend(self.non_linux_format_types)

return device.format.type in format_types

@@ -546,13 +546,13 @@ class BootLoader(object):
def bootable_chain_devices(self):
""" Potential boot devices containing non-linux operating systems. """
return [d for d in self.storage.devices
- if self._is_valid_boot_device(d, linux=False, non_linux=True)]
+ if self._is_valid_stage2_device(d, linux=False, non_linux=True)]

@property
def bootable_devices(self):
""" Potential boot devices containing linux operating systems. """
return [d for d in self.storage.devices
- if self._is_valid_boot_device(d)]
+ if self._is_valid_stage2_device(d)]

#
# miscellaneous
@@ -802,11 +802,11 @@ class GRUB(BootLoader):
can_update = True

# list of strings representing options for bootloader target device types
- target_device_types = ["disk", "partition", "mdarray"]
- target_device_raid_levels = [mdraid.RAID1]
- target_device_format_types = []
- target_device_format_mountpoints = ["/boot", "/"]
- target_device_disklabel_types = ["msdos", "gpt"] # gpt?
+ stage1_device_types = ["disk", "partition", "mdarray"]
+ stage1_device_raid_levels = [mdraid.RAID1]
+ stage1_device_format_types = []
+ stage1_device_format_mountpoints = ["/boot", "/"]
+ stage1_device_disklabel_types = ["msdos", "gpt"] # gpt?

# XXX account for disklabel type since mbr means nothing on gpt
target_descriptions = {"disk": N_("Master Boot Record"),
@@ -814,11 +814,11 @@ class GRUB(BootLoader):
"mdarray": N_("RAID Device")}

# list of strings representing options for boot device types
- boot_device_types = ["partition", "mdarray"]
- boot_device_raid_levels = [mdraid.RAID1]
+ stage2_device_types = ["partition", "mdarray"]
+ stage2_device_raid_levels = [mdraid.RAID1]

# XXX hpfs, if reported by blkid/udev, will end up with a type of None
- non_linux_device_format_types = ["vfat", "ntfs", "hpfs"]
+ non_linux_format_types = ["vfat", "ntfs", "hpfs"]

packages = ["grub"]

@@ -1134,19 +1134,19 @@ class EFIGRUB(GRUB):
can_dual_boot = False
_config_dir = "efi/EFI/redhat"

- # bootloader target device types
- target_device_types = ["partition", "mdarray"]
- target_device_raid_levels = [mdraid.RAID1]
- target_device_format_types = ["efi"]
- target_device_mountpoints = ["/boot/efi"]
- target_device_disklabel_types = ["gpt"]
- target_device_min_size = 50
- target_device_max_size = 256
+ # stage1 device types
+ stage1_device_types = ["partition", "mdarray"]
+ stage1_device_raid_levels = [mdraid.RAID1]
+ stage1_device_format_types = ["efi"]
+ stage1_device_mountpoints = ["/boot/efi"]
+ stage1_device_disklabel_types = ["gpt"]
+ stage1_device_min_size = 50
+ stage1_device_max_size = 256

target_descriptions = {"partition": N_("EFI System Partition"),
"mdarray": N_("RAID Device")}

- non_linux_boot_device_format_types = []
+ non_linux_format_types = []

def efibootmgr(self, *args, **kwargs):
if kwargs.pop("capture", False):
@@ -1261,12 +1261,12 @@ class GRUB2(GRUB):
can_dual_boot = True
can_update = True

- # requirements for bootloader target devices
- target_device_types = ["disk", "partition", "mdarray"]
- target_device_raid_levels = [mdraid.RAID1]
- target_device_format_types = []
- target_device_disklabel_types = ["msdos", "gpt"]
- target_device_mountpoints = ["/boot", "/"]
+ # requirements for bootloader stage1 devices
+ stage1_device_types = ["disk", "partition", "mdarray"]
+ stage1_device_raid_levels = [mdraid.RAID1]
+ stage1_device_format_types = []
+ stage1_device_disklabel_types = ["msdos", "gpt"]
+ stage1_device_mountpoints = ["/boot", "/"]

# for UI use, eg: "mdarray": N_("RAID Device")
target_descriptions = {"msdos": N_("Master Boot Record"),
@@ -1278,14 +1278,14 @@ class GRUB2(GRUB):
"gpt": N_("BIOS boot partition")}

# requirements for boot devices
- boot_device_types = ["partition", "mdarray", "lvmlv"]
- boot_device_raid_levels = [mdraid.RAID4, mdraid.RAID1, mdraid.RAID4,
+ stage2_device_types = ["partition", "mdarray", "lvmlv"]
+ stage2_device_raid_levels = [mdraid.RAID4, mdraid.RAID1, mdraid.RAID4,
mdraid.RAID5, mdraid.RAID6, mdraid.RAID10]
- boot_device_format_types = ["ext4", "ext3", "ext2"]
- boot_device_mountpoints = ["/boot", "/"]
- boot_device_min_size = 50
- boot_device_max_size = None
- non_linux_boot_device_format_types = []
+ stage2_device_format_types = ["ext4", "ext3", "ext2"]
+ stage2_device_mountpoints = ["/boot", "/"]
+ stage2_device_min_size = 50
+ stage2_device_max_size = None
+ non_linux_format_types = []

#
# grub-related conveniences
@@ -1313,7 +1313,7 @@ class GRUB2(GRUB):
return name

def device_description(self, device):
- idx = self._device_type_index(device, self.target_device_types)
+ idx = self._device_type_index(device, self.stage1_device_types)
if idx is None:
raise ValueError("'%s' not a valid stage1 type" % device.type)

@@ -1431,15 +1431,15 @@ class Yaboot(YabootSILOBase):
image_label_attr = "short_label"
packages = ["yaboot"]

- # list of strings representing options for bootloader target device types
- target_device_types = ["partition", "mdarray"]
- target_device_raid_levels = [mdraid.RAID1]
- target_device_format_types = ["appleboot", "prepboot"]
+ # requirements for bootloader stage1 devices
+ stage1_device_types = ["partition", "mdarray"]
+ stage1_device_raid_levels = [mdraid.RAID1]
+ stage1_device_format_types = ["appleboot", "prepboot"]

- # boot device requirements
- boot_device_types = ["partition", "mdarray"]
- boot_device_raid_levels = [mdraid.RAID1]
- non_linux_boot_device_format_types = ["hfs", "hfs+"]
+ # stage2 device requirements
+ stage2_device_types = ["partition", "mdarray"]
+ stage2_device_raid_levels = [mdraid.RAID1]
+ non_linux_format_types = ["hfs", "hfs+"]

def __init__(self, storage):
BootLoader.__init__(self, storage)
@@ -1524,10 +1524,10 @@ class Yaboot(YabootSILOBase):
class IPSeriesYaboot(Yaboot):
prog = "mkofboot"

- target_device_format_types = ["prepboot"]
- target_device_disklabel_types = ["msdos"]
- target_device_min_size = 4
- target_device_max_size = 10
+ stage1_device_format_types = ["prepboot"]
+ stage1_device_disklabel_types = ["msdos"]
+ stage1_device_min_size = 4
+ stage1_device_max_size = 10

target_descriptions = {"partition": N_("PReP Boot Partition"),
"mdarray": N_("RAID Device")}
@@ -1545,10 +1545,10 @@ class MacYaboot(Yaboot):
prog = "mkofboot"

can_dual_boot = True
- target_device_format_types = ["appleboot"]
- target_device_disklabel_types = ["mac"]
- target_device_min_size = 800.00 / 1024.00
- target_device_max_size = 1
+ stage1_device_format_types = ["appleboot"]
+ stage1_device_disklabel_types = ["mac"]
+ stage1_device_min_size = 800.00 / 1024.00
+ stage1_device_max_size = 1

target_descriptions = {"partition": N_("Apple Bootstrap Partition"),
"mdarray": N_("RAID Device")}
@@ -1573,13 +1573,13 @@ class ZIPL(BootLoader):
config_file = "/etc/zipl.conf"
packages = ["zipl"]

- # list of strings representing options for bootloader target device types
- target_device_types = ["disk", "partition"]
- target_device_disklabel_types = ["msdos", "dasd"]
+ # stage1 device requirements
+ stage1_device_types = ["disk", "partition"]
+ stage1_device_disklabel_types = ["msdos", "dasd"]

- # list of strings representing options for boot device types
- boot_device_types = ["partition", "mdarray", "lvmlv"]
- boot_device_raid_levels = [mdraid.RAID1]
+ # stage2 device requirements
+ stage2_device_types = ["partition", "mdarray", "lvmlv"]
+ stage2_device_raid_levels = [mdraid.RAID1]

packages = ["s390utils"] # is this bootloader or platform?
image_label_attr = "short_label"
@@ -1650,12 +1650,12 @@ class SILO(YabootSILOBase):
_config_file = "silo.conf"
message_file = "/etc/silo.message"

- # list of strings representing options for bootloader target device types
- target_device_types = ["partition"]
- target_device_disklabel_types = ["sun"]
+ # stage1 device requirements
+ stage1_device_types = ["partition"]
+ stage1_device_disklabel_types = ["sun"]

- # list of strings representing options for boot device types
- boot_device_types = ["partition"]
+ # stage2 device requirements
+ stage2_device_types = ["partition"]

packages = ["silo"]

diff --git a/pyanaconda/platform.py b/pyanaconda/platform.py
index 1105b05..0419592 100644
--- a/pyanaconda/platform.py
+++ b/pyanaconda/platform.py
@@ -62,7 +62,7 @@ class Platform(object):
@property
def bootFSTypes(self):
"""A list of all valid filesystem types for the boot partition."""
- return self.bootloader.boot_device_format_types
+ return self.bootloader.stage2_device_format_types

@property
def defaultBootFSType(self):
@@ -72,7 +72,7 @@ class Platform(object):
@property
def diskLabelTypes(self):
"""A list of valid disklabel types for this architecture."""
- return self.bootloader.target_device_disklabel_types
+ return self.bootloader.stage1_device_disklabel_types

@property
def defaultDiskLabelType(self):
@@ -88,12 +88,12 @@ class Platform(object):

Return a list of error strings if incorrect disklabels are found."""
errors = []
- if not self.bootloader.target_device_disklabel_types:
+ if not self.bootloader.stage1_device_disklabel_types:
return errors

for disk in req.disks:
labelType = disk.format.labelType
- labelTypes = self.bootloader.target_device_disklabel_types
+ labelTypes = self.bootloader.stage1_device_disklabel_types
if labelType not in labelTypes:
errors.append(_("%s must have a %s disk label.")
% (disk.name,
@@ -114,11 +114,11 @@ class Platform(object):
# such that it returns a list of error strings instead of
# True/False

- if req.type not in self.bootloader.boot_device_types:
+ if req.type not in self.bootloader.stage2_device_types:
errors.append(_("The /boot filesystem cannot be on devices of "
"type %s") % req.type)
elif req.type == "mdarray":
- raid_levels = self.bootloader.boot_device_raid_levels
+ raid_levels = self.bootloader.stage2_device_raid_levels
if req.level not in raid_levels:
levels = ",".join(["RAID%d" % l for l in raid_levels])
errors.append(_("RAID sets containing the /boot filesystem "
@@ -175,11 +175,11 @@ class Platform(object):
if not isinstance(size, int) and not isinstance(size, float):
return False

- return ((self.bootloader.target_device_min_size is None or
- size >= self.bootloader.target_device_min_size)
+ return ((self.bootloader.stage1_device_min_size is None or
+ size >= self.bootloader.stage1_device_min_size)
and
- (self.bootloader.target_device_max_size is None or
- size <= self.bootloader.target_device_max_size))
+ (self.bootloader.stage1_device_max_size is None or
+ size <= self.bootloader.stage1_device_max_size))

def weight(self, fstype=None, mountpoint=None):
""" Given an fstype (as a string) or a mountpoint, return an integer
--
1.7.3.4

_______________________________________________
Anaconda-devel-list mailing list
Anaconda-devel-list@redhat.com
https://www.redhat.com/mailman/listinfo/anaconda-devel-list
 

Thread Tools




All times are GMT. The time now is 07:21 AM.

VBulletin, Copyright ©2000 - 2014, Jelsoft Enterprises Ltd.
Content Relevant URLs by vBSEO ©2007, Crawlability, Inc.
Copyright 2007 - 2008, www.linux-archive.org