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 > Redhat > Fedora SELinux Support

 
 
LinkBack Thread Tools
 
Old 02-09-2012, 03:15 PM
David Lehman
 
Default Remove the anaconda attribute from Storage and add a bootloader attr.

---
pyanaconda/rescue.py | 5 +-
pyanaconda/storage/__init__.py | 363 +++++++++---------------------------
pyanaconda/storage/errors.py | 6 +
pyanaconda/storage/partitioning.py | 226 +++++++++--------------
pyanaconda/upgrade.py | 2 +-
5 files changed, 185 insertions(+), 417 deletions(-)

diff --git a/pyanaconda/rescue.py b/pyanaconda/rescue.py
index 6fab62d..0698357 100644
--- a/pyanaconda/rescue.py
+++ b/pyanaconda/rescue.py
@@ -339,8 +339,9 @@ def doRescue(anaconda):

if root:
try:
- rc = mountExistingSystem(anaconda, root,
- allowDirty = 1, warnDirty = 1,
+ # TODO: add a callback to warn about dirty filesystems
+ rc = mountExistingSystem(anaconda.storage.fsset, root,
+ allowDirty = 1,
readOnly = readOnly)

if not flags.imageInstall:
diff --git a/pyanaconda/storage/__init__.py b/pyanaconda/storage/__init__.py
index ae6e26f..e4f0b17 100644
--- a/pyanaconda/storage/__init__.py
+++ b/pyanaconda/storage/__init__.py
@@ -304,25 +304,18 @@ class StorageDiscoveryConfig(object):


class Storage(object):
- def __init__(self, anaconda=None, intf=None, platform=None):
+ def __init__(self, data=None, platform=None):
""" Create a Storage instance.

Keyword Arguments:

- anaconda - an Anaconda instance
- intf - an InstallInterface instance
+ data - a pykickstart Handler instance
platform - a Platform instance

- All arguments are optional. An Anaconda instance will contain
- an InstallInterface and a Platform instance, so it makes sense
- to pass in either an Anaconda instance or as many of the other
- two as is desired. Explicitly passed intf or platform will take
- precedence over those in the Anaconda instance.
-
"""
- self.anaconda = anaconda
- self._intf = intf
- self._platform = platform
+ self.data = data
+ self.platform = platform
+ self._bootloader = None

self.config = StorageDiscoveryConfig()

@@ -365,8 +358,8 @@ class Storage(object):
self.doEncryptionPassphraseRetrofits()

# now set the boot partition's flag
- if self.anaconda:
- if self.anaconda.bootloader.stage2_bootable:
+ if self.bootloader:
+ if self.bootloader.stage2_bootable:
boot = self.bootDevice
else:
boot = self.bootLoaderDevice
@@ -437,7 +430,7 @@ class Storage(object):
self.config.exclusiveDisks,
self.config.zeroMbr)
clearPartType = self.config.clearPartType # save this before overriding it
- if getattr(self.anaconda, "upgrade", False):
+ if self.data and self.data.upgrade.upgrade:
self.config.clearPartType = CLEARPART_TYPE_NONE

self.devicetree.reset(conf=self.config,
@@ -449,16 +442,12 @@ class Storage(object):
self.config.clearPartType = clearPartType # set it back
self.fsset = FSSet(self.devicetree)
self.eddDict = get_edd_dict(self.partitioned)
- if hasattr(self.anaconda, "rootParts") and
- hasattr(self.anaconda, "upgradeRoot"):
- self.anaconda.rootParts = None
- self.anaconda.upgradeRoot = None
- if self.anaconda:
+ if self.bootloader:
# clear out bootloader attributes that refer to devices that are
# no longer in the tree
- self.anaconda.bootloader.clear_drive_list()
- self.anaconda.bootloader.stage1_drive = None
- self.anaconda.bootloader.stage1_device = None
+ self.bootloader.clear_drive_list()
+ self.bootloader.stage1_drive = None
+ self.bootloader.stage1_device = None

self.dumpState("initial")

@@ -657,24 +646,7 @@ class Storage(object):
@property
def liveImage(self):
""" The OS image used by live installs. """
- _image = None
- if flags.livecdInstall and hasattr(self.anaconda, "methodstr"):
- _image = self.devicetree.getDeviceByPath(self.anaconda.meth odstr[9:])
- return _image
-
- @property
- def intf(self):
- _intf = self._intf
- if not _intf:
- _intf = getattr(self.anaconda, "intf", None)
- return _intf
-
- @property
- def platform(self):
- _platform = self._platform
- if not _platform:
- _platform = getattr(self.anaconda, "platform", None)
- return _platform
+ raise NotImplementedError()

def exceptionDisks(self):
""" Return a list of removable devices to save exceptions to.
@@ -839,8 +811,8 @@ class Storage(object):
name = kwargs.pop("name")
else:
hostname = ""
- if hasattr(self.anaconda, "network"):
- hostname = self.anaconda.network.hostname
+ if self.data:
+ hostname = self.data.network.hostname
name = self.createSuggestedVGName(hostname=hostname)

if name in [d.name for d in self.devices]:
@@ -1056,7 +1028,6 @@ class Storage(object):
try:
boot = self.bootDevice
except (DeviceError, AttributeError):
- # AttributeError means we have no anaconda or platform. it's ok.
boot = None

if not root:
@@ -1069,19 +1040,7 @@ class Storage(object):
"megabytes which is usually too small to "
"install %s.") % (productName,))

- if (root and
- hasattr(self.anaconda, "backend") and
- root.size < self.anaconda.backend.getMinimumSizeMB("/")):
- if flags.livecdInstall:
- live = " Live"
- else:
- live = ""
- errors.append(_("Your / partition is less than %(min)s "
- "MB which is lower than recommended "
- "for a normal %(productName)s%(live)s install.")
- % {'min': self.anaconda.backend.getMinimumSizeMB("/"),
- 'productName': productName,
- 'live': live})
+ # FIXME: put a check here for enough space on the filesystems. maybe?

# livecds have to have the rootfs type match up
if (root and
@@ -1142,23 +1101,23 @@ class Storage(object):
warnings.append(_("Installing on a FireWire device. This may "
"or may not produce a working system."))

- if self.anaconda and self.anaconda.dispatch.step_enabled('instbootloade r'):
- stage1 = self.anaconda.bootloader.stage1_device
+ if self.data and self.data.bootloader.location is not None:
+ stage1 = self.bootloader.stage1_device
if not stage1:
errors.append(_("you have not created a bootloader stage1 "
"target device"))
else:
- self.anaconda.bootloader.is_valid_stage1_device(st age1)
- errors.extend(self.anaconda.bootloader.errors)
- warnings.extend(self.anaconda.bootloader.warnings)
+ self.bootloader.is_valid_stage1_device(stage1)
+ errors.extend(self.bootloader.errors)
+ warnings.extend(self.bootloader.warnings)

- stage2 = self.anaconda.bootloader.stage2_device
+ stage2 = self.bootloader.stage2_device
if not stage2:
errors.append(_("You have not created a bootable partition."))
else:
- self.anaconda.bootloader.is_valid_stage2_device(st age2)
- errors.extend(self.anaconda.bootloader.errors)
- warnings.extend(self.anaconda.bootloader.warnings)
+ self.bootloader.is_valid_stage2_device(stage2)
+ errors.extend(self.bootloader.errors)
+ warnings.extend(self.bootloader.warnings)

if not swaps:
from pyanaconda.storage.size import Size
@@ -1203,14 +1162,8 @@ class Storage(object):

def checkNoDisks(self):
"""Check that there are valid disk devices."""
- if not self.disks and self.intf:
- self.intf.messageWindow(_("No Drives Found"),
- _("An error has occurred - no valid devices were "
- "found on which to create new file systems. "
- "Please check your hardware for the cause "
- "of this problem."))
- return True
- return False
+ if not self.disks:
+ raise NoDisksError()

def dumpState(self, suffix):
""" Dump the current device list to the storage shelf. """
@@ -1290,21 +1243,19 @@ class Storage(object):
f.write("
")

def turnOnSwap(self, upgrading=None):
- self.fsset.turnOnSwap(intf=self.intf,
- rootPath=ROOT_PATH,
+ self.fsset.turnOnSwap(rootPath=ROOT_PATH,
upgrading=upgrading)

def mountFilesystems(self, raiseErrors=None, readOnly=None, skipRoot=False):
- self.fsset.mountFilesystems(intf=self.intf,
- rootPath=ROOT_PATH,
+ self.fsset.mountFilesystems(rootPath=ROOT_PATH,
raiseErrors=raiseErrors,
readOnly=readOnly, skipRoot=skipRoot)

def umountFilesystems(self, ignoreErrors=True, swapoff=True):
self.fsset.umountFilesystems(ignoreErrors=ignoreEr rors, swapoff=swapoff)

- def parseFSTab(self, anaconda=None, chroot=None):
- self.fsset.parseFSTab(anaconda=anaconda, chroot=chroot)
+ def parseFSTab(self, chroot=None):
+ self.fsset.parseFSTab(chroot=chroot)

def mkDevRoot(self):
self.fsset.mkDevRoot()
@@ -1313,32 +1264,39 @@ class Storage(object):
self.fsset.createSwapFile(device, size)

@property
- def bootDevice(self):
- dev = None
- if self.anaconda:
- dev = self.anaconda.bootloader.stage2_device
- return dev
+ def bootloader(self):
+ if self._bootloader is None and self.platform is not None:
+ self._bootloader = self.platform.bootloaderClass(self.platform)
+ return self._bootloader
+
+ @property
+ def bootDisk(self):
+ disk = None
+ if self.data:
+ spec = self.data.bootloader.bootDrive
+ disk = self.devicetree.resolveDevice(spec)
+ return disk

@property
- def bootLoaderDevice(self):
+ def bootDevice(self):
dev = None
- if self.anaconda:
- dev = self.anaconda.bootloader.stage1_device
+ if self.fsset:
+ dev = self.mountpoints.get("/boot", self.rootDevice)
return dev

@property
def bootFSTypes(self):
"""A list of all valid filesystem types for the boot partition."""
fstypes = []
- if self.anaconda:
- fstypes = self.anaconda.bootloader.stage2_format_types
+ if self.bootloader:
+ fstypes = self.bootloader.stage2_format_types
return fstypes

@property
def defaultBootFSType(self):
"""The default filesystem type for the boot partition."""
fstype = None
- if self.anaconda:
+ if self.bootloader:
fstype = self.bootFSTypes[0]
return fstype

@@ -1516,13 +1474,15 @@ def findExistingRootDevices(anaconda, upgradeany=False):

return (rootDevs, notUpgradable)

-def mountExistingSystem(anaconda, rootEnt,
- allowDirty=None, warnDirty=None,
+def mountExistingSystem(fsset, rootEnt,
+ allowDirty=None, dirtyCB=None,
readOnly=None):
""" Mount filesystems specified in rootDevice's /etc/fstab file. """
rootDevice = rootEnt[0]
rootPath = ROOT_PATH
- fsset = anaconda.storage.fsset
+ if dirtyCB is None:
+ dirtyCB = lambda l: False
+
if readOnly:
readOnly = "ro"
else:
@@ -1539,7 +1499,7 @@ def mountExistingSystem(anaconda, rootEnt,
mountpoint="/",
options=readOnly)

- fsset.parseFSTab(anaconda=anaconda)
+ fsset.parseFSTab()

# check for dirty filesystems
dirtyDevs = []
@@ -1558,28 +1518,10 @@ def mountExistingSystem(anaconda, rootEnt,
device.format.type))
dirtyDevs.append(device.path)

- messageWindow = anaconda.intf.messageWindow
- if not allowDirty and dirtyDevs:
- messageWindow(_("Dirty File Systems"),
- _("The following file systems for your Linux system "
- "were not unmounted cleanly. Please boot your "
- "Linux installation, let the file systems be "
- "checked and shut down cleanly to upgrade.
"
- "%s") % "
".join(dirtyDevs))
- anaconda.storage.devicetree.teardownAll()
- sys.exit(0)
- elif warnDirty and dirtyDevs:
- rc = messageWindow(_("Dirty File Systems"),
- _("The following file systems for your Linux "
- "system were not unmounted cleanly. Would "
- "you like to mount them anyway?
"
- "%s") % "
".join(dirtyDevs),
- type = "yesno")
- if rc == 0:
- return -1
+ if dirtyDevs and (not allowDirty or dirtyCB(dirtyDevs)):
+ raise DirtyFSError("
".join(dirtyDevs))

- fsset.mountFilesystems(intf=anaconda.intf, rootPath=ROOT_PATH,
- readOnly=readOnly, skipRoot=True)
+ fsset.mountFilesystems(rootPath=ROOT_PATH, readOnly=readOnly, skipRoot=True)


class BlkidTab(object):
@@ -1908,7 +1850,7 @@ class FSSet(object):

return device

- def parseFSTab(self, anaconda=None, chroot=None):
+ def parseFSTab(self, chroot=None):
""" parse /etc/fstab

preconditions:
@@ -1977,16 +1919,6 @@ class FSSet(object):
# just write the line back out as-is after upgrade
self.preserveLines.append(line)
continue
- except FSTabTypeMismatchError as e:
- if anaconda and hasattr(anaconda.intf, "messageWindow"):
- err = _("There is an entry in your /etc/fstab file "
- "that contains an invalid or incorrect "
- "filesystem type:

")
- err += str(e)
- anaconda.intf.messageWindow(_("Error"), err)
- sys.exit(0)
-
- raise Exception("fstab entry %s is malformed: %s" % (devspec, e))

if not device:
continue
@@ -1998,25 +1930,14 @@ class FSSet(object):
# just write duplicates back out post-install
self.preserveLines.append(line)

- def turnOnSwap(self, intf=None, rootPath="", upgrading=None):
- def swapErrorDialog(msg, device):
- if not intf:
- # can't show a dialog? ignore this busted device.
- ret = 0
- else:
- buttons = [_("Skip"), _("Format"), _("_Exit")]
- ret = intf.messageWindow(_("Error"), msg, type="custom",
- custom_buttons=buttons,
- custom_icon="warning")
+ def turnOnSwap(self, rootPath="", upgrading=None, errorcb=None):
+ """ Activate the system's swap space.

- if ret == 0:
- self.devicetree._removeDevice(device)
- return False
- elif ret == 1:
- device.format.create(force=True)
- return True
- else:
- sys.exit(0)
+ errorcb should accept an Exception instance and a Device instance
+ return True if the exception should be fatal, which is the default.
+ """
+ if errorcb is None:
+ errorcb = lambda e,d: True

for device in self.swapDevices:
if isinstance(device, FileDevice):
@@ -2036,69 +1957,23 @@ class FSSet(object):
try:
device.setup()
device.format.setup()
- except OldSwapError:
- msg = _("The swap device:

%s

"
- "is an old-style Linux swap partition. If "
- "you want to use this device for swap space, "
- "you must reformat as a new-style Linux swap "
- "partition.")
- % device.path
-
- if swapErrorDialog(msg, device):
- continue
- except SuspendError:
- if upgrading:
- msg = _("The swap device:

%s

"
- "in your /etc/fstab file is currently in "
- "use as a software suspend device, "
- "which means your system is hibernating. "
- "To perform an upgrade, please shut down "
- "your system rather than hibernating it.")
- % device.path
- else:
- msg = _("The swap device:

%s

"
- "in your /etc/fstab file is currently in "
- "use as a software suspend device, "
- "which means your system is hibernating. "
- "If you are performing a new install, "
- "make sure the installer is set "
- "to format all swap devices.")
- % device.path
-
- if swapErrorDialog(msg, device):
- continue
- except UnknownSwapError:
- msg = _("The swap device:

%s

"
- "does not contain a supported swap volume. In "
- "order to continue installation, you will need "
- "to format the device or skip it.")
- % device.path
-
- if swapErrorDialog(msg, device):
- continue
- except DeviceError as (msg, name):
- if intf:
- if upgrading:
- err = _("Error enabling swap device %(name)s: "
- "%(msg)s

"
- "The /etc/fstab on your upgrade partition "
- "does not reference a valid swap "
- "device.

Press OK to exit the "
- "installer") % {'name': name, 'msg': msg}
- else:
- err = _("Error enabling swap device %(name)s: "
- "%(msg)s

"
- "This most likely means this swap "
- "device has not been initialized.

"
- "Press OK to exit the installer.") %
- {'name': name, 'msg': msg}
- intf.messageWindow(_("Error"), err)
- sys.exit(0)
-
- break
+ except StorageError as e:
+ if errorcb(e, device):
+ raise
+ else:
+ break

- def mountFilesystems(self, intf=None, rootPath="", readOnly=None,
+ def mountFilesystems(self, rootPath="", readOnly=None, errorcb=None,
skipRoot=False, raiseErrors=None):
+ """ Mount the system's filesystems.
+
+ errorcb should accept an Exception instance and a Device instance
+ and return True if the exception should be fatal, which is the
+ default.
+ """
+ if errorcb is None:
+ errorcb = lambda e,d: True
+
devices = self.mountpoints.values() + self.swapDevices
devices.extend([self.dev, self.devshm, self.devpts, self.sysfs,
self.proc, self.selinux, self.usb])
@@ -2135,8 +2010,10 @@ class FSSet(object):
try:
device.setup()
except Exception as msg:
- # FIXME: need an error popup
- continue
+ if errorcb(e, device):
+ raise
+ else:
+ continue

if readOnly:
options = "%s,%s" % (options, readOnly)
@@ -2144,73 +2021,11 @@ class FSSet(object):
try:
device.format.setup(options=options,
chroot=rootPath)
- except OSError as e:
- log.error("OSError: (%d) %s" % (e.errno, e.strerror))
-
- if intf:
- if e.errno == errno.EEXIST:
- intf.messageWindow(_("Invalid mount point"),
- _("An error occurred when trying "
- "to create %s. Some element of "
- "this path is not a directory. "
- "This is a fatal error and the "
- "install cannot continue.

"
- "Press <Enter> to exit the "
- "installer.")
- % (device.format.mountpoint,))
- else:
- na = {'mountpoint': device.format.mountpoint,
- 'msg': e.strerror}
- intf.messageWindow(_("Invalid mount point"),
- _("An error occurred when trying "
- "to create %(mountpoint)s: "
- "%(msg)s. This is "
- "a fatal error and the install "
- "cannot continue.

"
- "Press <Enter> to exit the "
- "installer.") % na)
- sys.exit(0)
- except SystemError as (num, msg):
- log.error("SystemError: (%d) %s" % (num, msg) )
-
- if raiseErrors:
+ except Exception as e:
+ log.error("error mounting %s on %s: %s"
+ % (device.path, device.format.mountpoint, e))
+ if errorcb(e, device):
raise
- if intf and not device.format.linuxNative:
- na = {'path': device.path,
- 'mountpoint': device.format.mountpoint}
- ret = intf.messageWindow(_("Unable to mount filesystem"),
- _("An error occurred mounting "
- "device %(path)s as "
- "%(mountpoint)s. You may "
- "continue installation, but "
- "there may be problems.") % na,
- type="custom",
- custom_icon="warning",
- custom_buttons=[_("_Exit installer"),
- _("_Continue")])
-
- if ret == 0:
- sys.exit(0)
- else:
- continue
-
- sys.exit(0)
- except FSError as msg:
- log.error("FSError: %s" % msg)
-
- if intf:
- na = {'path': device.path,
- 'mountpoint': device.format.mountpoint,
- 'msg': msg}
- intf.messageWindow(_("Unable to mount filesystem"),
- _("An error occurred mounting "
- "device %(path)s as %(mountpoint)s: "
- "%(msg)s. This is "
- "a fatal error and the install "
- "cannot continue.

"
- "Press <Enter> to exit the "
- "installer.") % na)
- sys.exit(0)

self.active = True

diff --git a/pyanaconda/storage/errors.py b/pyanaconda/storage/errors.py
index 2217873..6b7e5fc 100644
--- a/pyanaconda/storage/errors.py
+++ b/pyanaconda/storage/errors.py
@@ -25,6 +25,9 @@ class StorageError(Exception):
self.hardware_fault = kwargs.pop("hardware_fault", False)
super(StorageError, self).__init__(*args, **kwargs)

+class NoDisksError(StorageError):
+ pass
+
# Device
class DeviceError(StorageError):
pass
@@ -78,6 +81,9 @@ class FSResizeError(FSError):
class FSMigrateError(FSError):
pass

+class DirtyFSError(FSError):
+ pass
+
class LUKSError(DeviceFormatError):
pass

diff --git a/pyanaconda/storage/partitioning.py b/pyanaconda/storage/partitioning.py
index 7dba783..cbcb43a 100644
--- a/pyanaconda/storage/partitioning.py
+++ b/pyanaconda/storage/partitioning.py
@@ -104,6 +104,17 @@ def _schedulePartitions(storage, disks):
if len(all_free) > 1:
free += all_free[1].getSize()

+ # The boot disk must be set at this point. See if any platform-specific
+ # stage1 device we might allocate already exists on the boot disk.
+ stage1_device = None
+ for device in storage.devices:
+ if storage.bootloader.stage1_drive not in device.disks:
+ continue
+
+ if storage.bootloader._is_valid_stage1_device(device) :
+ stage1_device = device
+ break
+
#
# First pass is for partitions only. We'll do LVs later.
#
@@ -120,27 +131,17 @@ def _schedulePartitions(storage, disks):
else:
request.fstype = storage.defaultFSType

- elif request.fstype == "prepboot" and storage.bootLoaderDevice:
- # there should never be a need for more than one of these
- # partitions, so skip them.
- log.info("skipping unneeded stage1 prepboot request")
- log.debug(request)
- log.debug(storage.bootLoaderDevice)
- continue
- elif request.fstype == "efi" and storage.bootLoaderDevice:
- # there should never be a need for more than one of these
- # partitions, so skip them.
- log.info("skipping unneeded stage1 efi request")
- log.debug(request)
- # Set the mountpoint for the existing EFI boot partition
- storage.bootLoaderDevice.format.mountpoint = "/boot/efi"
- log.debug(storage.bootLoaderDevice)
- continue
- elif request.fstype == "biosboot" and storage.bootLoaderDevice:
- log.info("skipping unneeded stage1 biosboot request")
- log.debug(request)
- log.debug(storage.bootLoaderDevice)
- continue
+ elif request.fstype in ("prepboot", "efi", "biosboot") and stage1_device:
+ # there should never be a need for more than one of these
+ # partitions, so skip them.
+ log.info("skipping unneeded stage1 %s request" % request.fstype)
+ log.debug(request)
+
+ if request.fstype == "efi":
+ # Set the mountpoint for the existing EFI boot partition
+ stage1_device.format.mountpoint = "/boot/efi"
+
+ log.debug(stage1_device)

# This is a little unfortunate but let the backend dictate the rootfstype
# so that things like live installs can do the right thing
@@ -244,121 +245,75 @@ def scheduleShrinkActions(storage):
if device.targetSize != size:
device.format.targetSize = device.targetSize

-def doAutoPartition(anaconda):
- log.debug("doAutoPartition(%s)" % anaconda)
- log.debug("doAutoPart: %s" % anaconda.storage.doAutoPart)
- log.debug("encryptedAutoPart: %s" % anaconda.storage.encryptedAutoPart)
- log.debug("lvmAutoPart: %s" % anaconda.storage.lvmAutoPart)
- log.debug("clearPartType: %s" % anaconda.storage.config.clearPartType)
- log.debug("clearPartDisks: %s" % anaconda.storage.config.clearPartDisks)
- log.debug("autoPartitionRequests:
%s" % "".join([str(p) for p in anaconda.storage.autoPartitionRequests]))
- log.debug("storage.disks: %s" % [d.name for d in anaconda.storage.disks])
- log.debug("storage.partitioned: %s" % [d.name for d in anaconda.storage.partitioned])
- log.debug("all names: %s" % [d.name for d in anaconda.storage.devices])
- if anaconda.dir == DISPATCH_BACK:
- return
+def doAutoPartition(storage, data, errorcb=None, warningcb=None):
+ log.debug("doAutoPart: %s" % storage.doAutoPart)
+ log.debug("encryptedAutoPart: %s" % storage.encryptedAutoPart)
+ log.debug("lvmAutoPart: %s" % storage.lvmAutoPart)
+ log.debug("clearPartType: %s" % storage.config.clearPartType)
+ log.debug("clearPartDisks: %s" % storage.config.clearPartDisks)
+ log.debug("autoPartitionRequests:
%s" % "".join([str(p) for p in storage.autoPartitionRequests]))
+ log.debug("storage.disks: %s" % [d.name for d in storage.disks])
+ log.debug("storage.partitioned: %s" % [d.name for d in storage.partitioned])
+ log.debug("all names: %s" % [d.name for d in storage.devices])
+ log.debug("boot disk: %s" % getattr(storage.bootDisk, "name", None))

disks = []
devs = []

- if anaconda.storage.doAutoPart:
- scheduleShrinkActions(anaconda.storage)
- clearPartitions(anaconda.storage, bootloader=anaconda.bootloader)
+ if errorcb is None:
+ errorcb = lambda e: True
+ if warningcb is None:
+ warningcb = lambda e: True
+
+ if storage.doAutoPart:
+ scheduleShrinkActions(storage)
+ clearPartitions(storage)
# update the bootloader's drive list to add disks which have their
# whole disk format replaced by a disklabel. Make sure to keep any
# previous boot order selection from clearpart_gui or kickstart
anaconda.bootloader.clear_drive_list()

- disks = _getCandidateDisks(anaconda.storage)
- devs = _schedulePVs(anaconda.storage, disks)
+ disks = _getCandidateDisks(storage)
+ devs = _schedulePVs(storage, disks)
log.debug("candidate disks: %s" % disks)
log.debug("devs: %s" % devs)

if disks == []:
- if anaconda.ksdata:
- msg = _("Could not find enough free space for automatic "
- "partitioning. Press 'OK' to exit the installer.")
- else:
- msg = _("Could not find enough free space for automatic "
- "partitioning, please use another partitioning method.")
-
- anaconda.intf.messageWindow(_("Error Partitioning"), msg,
- custom_icon='error')
-
- if anaconda.ksdata:
- sys.exit(0)
+ raise PartitioningError("not enough free space")

- anaconda.storage.reset()
- return DISPATCH_BACK
-
- _schedulePartitions(anaconda.storage, disks)
+ _schedulePartitions(storage, disks)

# run the autopart function to allocate and grow partitions
try:
- doPartitioning(anaconda.storage, bootloader=anaconda.bootloader)
+ doPartitioning(storage)

- if anaconda.storage.doAutoPart:
- _scheduleLVs(anaconda.storage, devs)
+ if storage.doAutoPart:
+ _scheduleLVs(storage, devs)

# grow LVs
- growLVM(anaconda.storage)
- except PartitioningWarning as msg:
- if not anaconda.ksdata:
- anaconda.intf.messageWindow(_("Warnings During Automatic "
- "Partitioning"),
- _("Following warnings occurred during automatic "
- "partitioning:

%s") % (msg,),
- custom_icon='warning')
- else:
- log.warning(msg)
- except PartitioningError as msg:
- # restore drives to original state
- anaconda.storage.reset()
-
- extra = ""
- if anaconda.ksdata:
- extra = _("

Press 'OK' to exit the installer.")
- else:
- anaconda.dispatch.request_steps_gently("partition" )
- anaconda.intf.messageWindow(_("Error Partitioning"),
- _("Could not allocate requested partitions:

"
- "%(msg)s.%(extra)s") % {'msg': msg, 'extra': extra},
- custom_icon='error')
-
- if anaconda.ksdata:
- sys.exit(0)
- else:
- return DISPATCH_BACK
+ growLVM(storage)
+ except PartitioningWarning as e:
+ log.warning(str(e))
+ warningcb(e)
+ except PartitioningError as e:
+ log.error(str(e))
+ errorcb(e)
+ storage.reset()
+ raise
+
+ storage.setUpBootLoader()

# now do a full check of the requests
- (errors, warnings) = anaconda.storage.sanityCheck()
- if warnings:
- for warning in warnings:
- log.warning(warning)
+ (errors, warnings) = storage.sanityCheck()
+ for error in errors:
+ log.error(error)
+ for warning in warnings:
+ log.warning(warning)
if errors:
- errortxt = "
".join(errors)
- if anaconda.ksdata:
- extra = _("

Press 'OK' to exit the installer.")
- else:
- extra = _("

Press 'OK' to choose a different partitioning option.")
-
- anaconda.intf.messageWindow(_("Automatic Partitioning Errors"),
- _("The following errors occurred with your "
- "partitioning:

%(errortxt)s

"
- "This can happen if there is not enough "
- "space on your hard drive(s) for the "
- "installation. %(extra)s")
- % {'errortxt': errortxt, 'extra': extra},
- custom_icon='error')
- #
- # XXX if in kickstart we reboot
- #
- if anaconda.ksdata:
- anaconda.intf.messageWindow(_("Unrecoverable Error"),
- _("The system will now reboot."))
- sys.exit(0)
- anaconda.storage.reset()
- return DISPATCH_BACK
+ exn = PartitioningError("
".join(errors))
+ errorcb(exn)
+ storage.reset()
+ raise exn

def shouldClear(device, clearPartType, clearPartDisks=None):
if clearPartType not in [CLEARPART_TYPE_LINUX, CLEARPART_TYPE_ALL]:
@@ -409,7 +364,7 @@ def shouldClear(device, clearPartType, clearPartDisks=None):

return True

-def clearPartitions(storage, bootloader=None):
+def clearPartitions(storage):
""" Clear partitions and dependent devices from disks.

Arguments:
@@ -418,7 +373,7 @@ def clearPartitions(storage, bootloader=None):

Keyword arguments:

- bootloader -- a BootLoader instance
+ None

NOTES:

@@ -486,11 +441,12 @@ def clearPartitions(storage, bootloader=None):

# make sure that the the boot device has the correct disklabel type if
# we're going to completely clear it.
+ boot_disk = storage.bootDisk
for disk in storage.partitioned:
- if not bootloader or not bootloader.stage1_drive:
+ if not boot_disk:
break

- if disk != bootloader.stage1_drive:
+ if disk != boot_disk:
continue

if storage.config.clearPartType != CLEARPART_TYPE_ALL or
@@ -926,7 +882,7 @@ def updateExtendedPartitions(storage, disks):
# moment to simplify things
storage.devicetree._addDevice(device)

-def doPartitioning(storage, bootloader=None):
+def doPartitioning(storage):
""" Allocate and grow partitions.

When this function returns without error, all PartitionDevice
@@ -941,7 +897,7 @@ def doPartitioning(storage, bootloader=None):

Keyword/Optional Arguments:

- bootloader - BootLoader instance
+ None

"""
if not hasattr(storage.platform, "diskLabelTypes"):
@@ -973,14 +929,6 @@ def doPartitioning(storage, bootloader=None):
# start over with flexible-size requests
part.req_size = part.req_base_size

- try:
- storage.bootDevice.req_bootable = True
- except AttributeError:
- # there's no stage2 device. hopefully it's temporary.
- pass
-
- removeNewPartitions(disks, partitions)
-
if storage.platform.weight(fstype="biosboot") > 0:
# add a request for a bios boot partition on every disk that contains a
# gpt disklabel if we're on a bios platform.
@@ -1017,10 +965,16 @@ def doPartitioning(storage, bootloader=None):
storage.createDevice(part)
partitions.append(part)

+ try:
+ storage.bootDevice.req_bootable = True
+ except AttributeError:
+ # there's no stage2 device. hopefully it's temporary.
+ pass
+
+ removeNewPartitions(disks, partitions)
free = getFreeRegions(disks)
try:
- allocatePartitions(storage, disks, partitions, free,
- bootloader=bootloader)
+ allocatePartitions(storage, disks, partitions, free)
growPartitions(disks, partitions, free)
finally:
# The number and thus the name of partitions may have changed now,
@@ -1034,11 +988,7 @@ def doPartitioning(storage, bootloader=None):

updateExtendedPartitions(storage, disks)

- # make sure the stage1_device gets updated
- if storage.anaconda:
- storage.anaconda.bootloader.stage1_device = None
-
-def allocatePartitions(storage, disks, partitions, freespace, bootloader=None):
+def allocatePartitions(storage, disks, partitions, freespace):
""" Allocate partitions based on requested features.

Non-existing partitions are sorted according to their requested
@@ -1088,14 +1038,10 @@ def allocatePartitions(storage, disks, partitions, freespace, bootloader=None):

# sort the disks, making sure the boot disk is first
req_disks.sort(key=lambda d: d.name, cmp=storage.compareDisks)
- boot_index = None
for disk in req_disks:
- if bootloader and disk == bootloader.stage1_drive:
+ if storage.bootDisk and disk == storage.bootDisk:
boot_index = req_disks.index(disk)
-
- if boot_index is not None and len(req_disks) > 1:
- boot_disk = req_disks.pop(boot_index)
- req_disks.insert(0, boot_disk)
+ req_disks.insert(0, req_disks.pop(boot_index))

boot = _part.req_base_weight > 1000

diff --git a/pyanaconda/upgrade.py b/pyanaconda/upgrade.py
index 5d9fe4f..d5dd7a4 100644
--- a/pyanaconda/upgrade.py
+++ b/pyanaconda/upgrade.py
@@ -168,7 +168,7 @@ def upgradeMountFilesystems(anaconda):
# mount everything and turn on swap

try:
- mountExistingSystem(anaconda, anaconda.upgradeRoot[0], allowDirty = 0)
+ mountExistingSystem(anaconda.storage.fsset, anaconda.upgradeRoot[0], allowDirty = 0)
except ValueError as e:
log.error("Error mounting filesystem: %s" % e)
anaconda.intf.messageWindow(_("Mount failed"),
--
1.7.8.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:15 AM.

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