[PATCH 1/4] Do not add a list of PVs or RAID members when writing out --useexisting (#1021274).
by Chris Lumens
---
pykickstart/commands/raid.py | 11 ++++++++---
pykickstart/commands/volgroup.py | 16 ++++++++++------
2 files changed, 18 insertions(+), 9 deletions(-)
diff --git a/pykickstart/commands/raid.py b/pykickstart/commands/raid.py
index 0c49214..818c9bd 100644
--- a/pykickstart/commands/raid.py
+++ b/pykickstart/commands/raid.py
@@ -69,9 +69,14 @@ class FC3_RaidData(BaseData):
def __str__(self):
retval = BaseData.__str__(self)
- retval += "raid %s%s %s\n" % (self.mountpoint, self._getArgsAsStr(),
- " ".join(self.members))
- return retval
+ retval += "raid %s%s" % (self.mountpoint, self._getArgsAsStr())
+
+ # Do not output the members list if --preexist was passed in.
+ # This would be invalid input according to the parse method.
+ if not self.preexist:
+ retval += " " + " ".join(self.members)
+
+ return retval.strip() + "\n"
class FC4_RaidData(FC3_RaidData):
removedKeywords = FC3_RaidData.removedKeywords
diff --git a/pykickstart/commands/volgroup.py b/pykickstart/commands/volgroup.py
index eb9dbd9..03569ff 100644
--- a/pykickstart/commands/volgroup.py
+++ b/pykickstart/commands/volgroup.py
@@ -1,7 +1,7 @@
#
# Chris Lumens <clumens(a)redhat.com>
#
-# Copyright 2005, 2006, 2007, 2012 Red Hat, Inc.
+# Copyright 2005, 2006, 2007, 2012, 2013 Red Hat, Inc.
#
# This copyrighted material is made available to anyone wishing to use, modify,
# copy, or redistribute it subject to the terms and conditions of the GNU
@@ -61,7 +61,11 @@ class FC3_VolGroupData(BaseData):
retval = BaseData.__str__(self)
retval += "volgroup %s" % self.vgname
retval += self._getArgsAsStr()
- retval += " " + " ".join(self.physvols)
+
+ # Do not output the physical volumes list if --preexist was passed in.
+ # This would be invalid input according to the parse method.
+ if not self.preexist:
+ retval += " " + " ".join(self.physvols)
return retval.strip() + "\n"
@@ -161,28 +165,28 @@ class FC16_VolGroup(FC3_VolGroup):
dest="reserved_percent", type="int", nargs=1, default=0)
return op
-
class RHEL6_VolGroup(FC3_VolGroup):
-
def parse(self, args):
# first call the overriden method
retval = FC3_VolGroup.parse(self, args)
+
# the volgroup command can't be used together with the autopart command
# due to the hard to debug behavior their combination introduces
if self.handler.autopart.seen:
errorMsg = _("The volgroup and autopart commands can't be used at the same time")
raise KickstartParseError(formatErrorMsg(self.lineno, msg=errorMsg))
- return retval
+ return retval
class F20_VolGroup(FC16_VolGroup):
-
def parse(self, args):
# first call the overriden method
retval = FC16_VolGroup.parse(self, args)
+
# the volgroup command can't be used together with the autopart command
# due to the hard to debug behavior their combination introduces
if self.handler.autopart.seen:
errorMsg = _("The volgroup and autopart commands can't be used at the same time")
raise KickstartParseError(formatErrorMsg(self.lineno, msg=errorMsg))
+
return retval
--
1.8.3.1
10 years, 6 months
[PATCH] If spokes are not complete in command line mode, let the user know which.
by Chris Lumens
---
pyanaconda/ui/tui/hubs/summary.py | 11 ++++++++---
1 file changed, 8 insertions(+), 3 deletions(-)
diff --git a/pyanaconda/ui/tui/hubs/summary.py b/pyanaconda/ui/tui/hubs/summary.py
index 2d9ff29..7b332a3 100644
--- a/pyanaconda/ui/tui/hubs/summary.py
+++ b/pyanaconda/ui/tui/hubs/summary.py
@@ -55,11 +55,16 @@ class SummaryHub(TUIHub):
# override the prompt so that we can skip user input on kickstarts
# where all the data is in hand. If not in hand, do the actual prompt.
def prompt(self, args=None):
- if flags.automatedInstall and \
- all(spoke.completed for spoke in self._keys.values() if spoke.mandatory):
+ incompleteSpokes = [spoke for spoke in self._keys.values()
+ if spoke.mandatory and not spoke.completed]
+
+ if flags.automatedInstall and not incompleteSpokes:
self.close()
return None
+
if not flags.ksprompt:
- errtxt = _("Can't have a question in command line mode!")
+ errtxt = _("In command line mode, the following mandatory spokes are not completed:") + \
+ "\n" + " ".join(spoke.title for spoke in incompleteSpokes)
raise RuntimeError(errtxt)
+
return TUIHub.prompt(self, args)
--
1.8.3.1
10 years, 6 months
[master/f20] tui: show Processing while source is busy
by Brian C. Lane
From: "Brian C. Lane" <bcl(a)redhat.com>
---
pyanaconda/ui/tui/spokes/source.py | 2 +-
1 file changed, 1 insertion(+), 1 deletion(-)
diff --git a/pyanaconda/ui/tui/spokes/source.py b/pyanaconda/ui/tui/spokes/source.py
index e48b9b9..750d3e3 100644
--- a/pyanaconda/ui/tui/spokes/source.py
+++ b/pyanaconda/ui/tui/spokes/source.py
@@ -202,7 +202,7 @@ class SourceSpoke(SourceSwitchHandler, EditTUISpoke):
def status(self):
if self.errors:
return _("Error setting up software source")
- elif not self._ready:
+ elif not self.ready:
return _("Processing...")
else:
return self._repo_status()
--
1.8.3.1
10 years, 6 months
[master/f20] tui: wait for threads before entering source and software (#1032823)
by Brian C. Lane
From: "Brian C. Lane" <bcl(a)redhat.com>
When first run THREAD_PAYLOAD is running. You shouldn't change the
source while this is happening.
Software shouldn't be changed in the middle of THREAD_CHECK_SOFTWARE
---
pyanaconda/ui/tui/spokes/software.py | 2 ++
pyanaconda/ui/tui/spokes/source.py | 1 +
2 files changed, 3 insertions(+)
diff --git a/pyanaconda/ui/tui/spokes/software.py b/pyanaconda/ui/tui/spokes/software.py
index 87eaefc..d7f6bbb 100644
--- a/pyanaconda/ui/tui/spokes/software.py
+++ b/pyanaconda/ui/tui/spokes/software.py
@@ -126,6 +126,8 @@ class SoftwareSpoke(NormalTUISpoke):
self._window.append(TextWidget(""))
return True
+ threadMgr.wait(THREAD_CHECK_SOFTWARE)
+
# put a title above the list and some space below it
self._window.append(TextWidget(_("Base environment")))
self._window.append(TextWidget(""))
diff --git a/pyanaconda/ui/tui/spokes/source.py b/pyanaconda/ui/tui/spokes/source.py
index 79ac1e0..e48b9b9 100644
--- a/pyanaconda/ui/tui/spokes/source.py
+++ b/pyanaconda/ui/tui/spokes/source.py
@@ -226,6 +226,7 @@ class SourceSpoke(SourceSwitchHandler, EditTUISpoke):
def refresh(self, args=None):
EditTUISpoke.refresh(self, args)
+ threadMgr.wait(THREAD_PAYLOAD)
threadMgr.wait(THREAD_PAYLOAD_MD)
_methods = [_("CD/DVD"), _("Local ISO file"), _("Network")]
--
1.8.3.1
10 years, 6 months
[PATCH] Fix parallel pylint in distcheck.
by David Shea
Fail in runpylint.sh if xargs exits unsuccessfully. Add pylint-one.sh to
dist.
---
tests/Makefile.am | 1 +
tests/pylint/runpylint.sh | 2 +-
2 files changed, 2 insertions(+), 1 deletion(-)
diff --git a/tests/Makefile.am b/tests/Makefile.am
index dc59daf..693f0f3 100644
--- a/tests/Makefile.am
+++ b/tests/Makefile.am
@@ -41,6 +41,7 @@ dist_check_SCRIPTS = accelerators/check_accelerators.py \
nosetests.sh \
pylint/intl.py \
pylint/runpylint.sh \
+ pylint/pylint-one.sh \
testenv.sh \
gettext/gettext_warnings.sh \
storage/run_storage_tests.py \
diff --git a/tests/pylint/runpylint.sh b/tests/pylint/runpylint.sh
index e3c8a67..df8f243 100755
--- a/tests/pylint/runpylint.sh
+++ b/tests/pylint/runpylint.sh
@@ -91,7 +91,7 @@ fi
num_cpus=$(getconf _NPROCESSORS_ONLN)
# run pylint in paralel
-echo $FILES | xargs --max-procs=$num_cpus -n 1 "$srcdir"/pylint-one.sh
+echo $FILES | xargs --max-procs=$num_cpus -n 1 "$srcdir"/pylint-one.sh || exit 1
for file in $(find -name 'pylint-out*'); do
cat "$file" >> pylint-log
--
1.8.4.2
10 years, 6 months
[blivet] Add some basic unit tests for MDRaidArrayDevice.
by Anne Mulhern
Add some basic tests to check the state of an MDRaidArrayDevice
after initialization and to check the behavior of some methods.
The changes to the tested code are:
* Correct an exception initialization in get_raid_min_members() so
an exception won't be thrown when the exception message is initialized.
* Check whether a smallestMember actually exists and set
smallestMemberSize to 0 if one does not exist or if there are no devices.
Still go through the checks for level even if smallestMemberSize is 0
in order to catch invalid raid level.
* In rawArraySize for RAID10, divide by 2 instead of 2.0. I believe that
if there are three disks available then we get only one disk's worth of data.
Do the same in size.
* A semantics preserving change to initializer.
This change preserves the semantics of the if statement completely.
The advantage is that self.level is no longer
set to any arbitrary value which allows error checking in self.level
setter itself.
* Make level setter error checking.
Previously, the level could be set to anything in the initializer.
Now that this is not true, it is possible to check for invalid values in
the level setter. Valid values are an integer RAID level, "container", or
None.
* smallestMember is altered in a semantically equivalent way, except that
if not self.devices evaluates to True an exception will not be thrown.
Previously, it would have been thrown if self.devices was not a list.
It uses min instead of smallest, since we only need the minimum element
in self.devices.
* totalDevices is also semantically equivalent, but the len of self.parents
is only calculated if needed.
* description is extended so that it makes a somewhat sensible string if
self.level is None.
* In initializer,
use memberDevices setter rather than assigning to _memberDevices
directly in order to get the error checking in the setter.
---
blivet/devicelibs/mdraid.py | 2 +-
blivet/devices.py | 44 ++++--
tests/devices_test.py | 378 ++++++++++++++++++++++++++++++++++++++++++++
3 files changed, 408 insertions(+), 16 deletions(-)
create mode 100644 tests/devices_test.py
diff --git a/blivet/devicelibs/mdraid.py b/blivet/devicelibs/mdraid.py
index 9c827e1..17f3ee4 100644
--- a/blivet/devicelibs/mdraid.py
+++ b/blivet/devicelibs/mdraid.py
@@ -85,7 +85,7 @@ def get_raid_min_members(raidlevel):
if isRaid(raid, raidlevel):
return min_members
- raise MDRaidError("invalid raid level %d" % raidlevel)
+ raise MDRaidError("invalid raid level %s" % str(raidlevel))
def get_raid_max_spares(raidlevel, nummembers):
"""Return the maximum number of raid spares for raidlevel."""
diff --git a/blivet/devices.py b/blivet/devices.py
index 8426339..c649659 100644
--- a/blivet/devices.py
+++ b/blivet/devices.py
@@ -2978,11 +2978,13 @@ class MDRaidArrayDevice(StorageDevice):
major=major, minor=minor, size=size,
parents=parents, sysfsPath=sysfsPath)
- self.level = level
if level == "container":
self._type = "mdcontainer"
+ self.level = "container"
elif level is not None:
self.level = mdraid.raidLevel(level)
+ else:
+ self.level = None
# For new arrays check if we have enough members
if (not exists and parents and
@@ -2996,7 +2998,7 @@ class MDRaidArrayDevice(StorageDevice):
self.uuid = uuid
self._totalDevices = util.numeric_type(totalDevices)
- self._memberDevices = util.numeric_type(memberDevices)
+ self.memberDevices = util.numeric_type(memberDevices)
self.chunkSize = 512.0 / 1024.0 # chunk size in MB
@@ -3028,7 +3030,7 @@ class MDRaidArrayDevice(StorageDevice):
""" Return the raid level
:returns: raid level value
- :rtype: int
+ :rtype: an int representing a raid level, "container", or None
"""
return self._level
@@ -3037,11 +3039,15 @@ class MDRaidArrayDevice(StorageDevice):
""" Set the RAID level and enforce restrictions based on it.
:param value: new raid level
- :param type: int
+ :param type: a valid raid level int, "container", or None
:returns: None
Sets createBitmap True unless level is 0
"""
+ if not value in mdraid.raid_levels and \
+ value != "container" and value is not None:
+ raise mdraid.MDRaidError("invalid raid level %s" % str(value))
+
self._level = value
# bitmaps are not meaningful on raid0 according to mdadm-3.0.3
@@ -3057,7 +3063,13 @@ class MDRaidArrayDevice(StorageDevice):
Returns the raw size in MB
"""
- smallestMemberSize = self.smallestMember.size
+ smallestMember = self.smallestMember
+ if smallestMember is None:
+ log.debug("device has no members, size is 0")
+ smallestMemberSize = 0
+ else:
+ smallestMemberSize = smallestMember.size
+
if self.level == mdraid.RAID0:
size = self.memberDevices * smallestMemberSize
elif self.level == mdraid.RAID1:
@@ -3069,10 +3081,11 @@ class MDRaidArrayDevice(StorageDevice):
elif self.level == mdraid.RAID6:
size = (self.memberDevices - 2) * smallestMemberSize
elif self.level == mdraid.RAID10:
- size = (self.memberDevices / 2.0) * smallestMemberSize
+ size = (self.memberDevices / 2) * smallestMemberSize
else:
size = smallestMemberSize
log.error("unknown RAID level %s" % (self.level))
+
log.debug("raw RAID %s size == %s" % (self.level, size))
return size
@@ -3083,11 +3096,10 @@ class MDRaidArrayDevice(StorageDevice):
@property
def smallestMember(self):
- try:
- smallest = sorted(self.devices, key=lambda d: d.size)[0]
- except IndexError:
- smallest = None
- return smallest
+ if not self.devices:
+ return None
+ else:
+ return min(self.devices, key=lambda d: d.size)
@property
def size(self):
@@ -3117,7 +3129,7 @@ class MDRaidArrayDevice(StorageDevice):
size = (self.memberDevices - 2) * smallestMemberSize
size -= size % self.chunkSize
elif self.level == mdraid.RAID10:
- size = (self.memberDevices / 2.0) * smallestMemberSize
+ size = (self.memberDevices / 2) * smallestMemberSize
size -= size % self.chunkSize
log.debug("non-existent RAID %s size == %s" % (self.level, size))
else:
@@ -3132,6 +3144,8 @@ class MDRaidArrayDevice(StorageDevice):
levelstr = "stripe"
elif self.level == mdraid.RAID1:
levelstr = "mirror"
+ elif self.level is None:
+ levelstr = "unknown level"
else:
levelstr = "raid%s" % self.level
@@ -3180,10 +3194,10 @@ class MDRaidArrayDevice(StorageDevice):
@property
def totalDevices(self):
""" Total number of devices in the array, including spares. """
- count = len(self.parents)
if not self.exists:
- count = self._totalDevices
- return count
+ return self._totalDevices
+ else:
+ return len(self.parents)
def _getMemberDevices(self):
return self._memberDevices
diff --git a/tests/devices_test.py b/tests/devices_test.py
new file mode 100644
index 0000000..8057e37
--- /dev/null
+++ b/tests/devices_test.py
@@ -0,0 +1,378 @@
+#!/usr/bin/python
+
+import unittest
+
+from mock import Mock
+
+import blivet
+
+from blivet.errors import DeviceError
+
+from blivet.devices import Device
+from blivet.devices import MDRaidArrayDevice
+from blivet.devices import mdraid
+
+class MDRaidArrayDeviceTestCase(unittest.TestCase):
+
+ def stateCheck(self, device, **kwargs):
+ """Checks the current state of an mdraid device by means of its
+ fields or properties.
+
+ Every kwarg should be a key which is a field or property
+ of an MDRaidArrayDevice and a value which is a function of
+ two parameters and should call the appropriate assert* functions.
+ These values override those in the state_functions dict.
+
+ If the value is None, then the test starts the debugger instead.
+ """
+ self.longMessage = True
+ state_functions = {
+ "createBitmap" : lambda x,m: self.assertTrue(x, m),
+ "currentSize" : lambda x, m: self.assertEqual(x, 0, m),
+ "description" : lambda x, m: self.assertEqual(x, "MDRAID set (unknown level)", m),
+ "devices" : lambda x, m: self.assertEqual(x, [], m),
+ "exists" : self.assertFalse,
+ "format" : self.assertIsNotNone,
+ "formatClass" : self.assertIsNotNone,
+ "isDisk" : self.assertFalse,
+ "level" : self.assertIsNone,
+ "major" : lambda x, m: self.assertEqual(x, 0, m),
+ "mediaPresent" : self.assertFalse,
+ "metadataVersion" : lambda x, m: self.assertEqual(x, "default", m),
+ "minor" : lambda x, m: self.assertEqual(x, 0, m),
+ "parents" : lambda x, m: self.assertEqual(x, [], m),
+ "partitionable" : self.assertFalse,
+ "rawArraySize" : lambda x, m: self.assertEqual(x, 0, m),
+ "size" : lambda x, m: self.assertEqual(x, 0, m),
+ "smallestMember" : lambda x, m: self.assertIsNone(x, m),
+ "spares" : lambda x, m: self.assertEqual(x, 0, m),
+ "superBlockSize" : lambda x, m: self.assertEqual(x, 0, m),
+ "sysfsPath" : lambda x, m: self.assertEqual(x, "", m),
+ "uuid" : self.assertIsNone,
+ "memberDevices" : lambda x, m: self.assertEqual(x, 0, m),
+ "totalDevices" : lambda x, m: self.assertEqual(x, 0, m),
+ "type" : lambda x, m: self.assertEqual(x, "mdarray", m) }
+ for k,v in state_functions.items():
+ if kwargs.has_key(k):
+ key = kwargs[k]
+ if key is None:
+ import pdb
+ pdb.set_trace()
+ getattr(device, k)
+ else:
+ kwargs[k](getattr(device, k), k)
+ else:
+ v(getattr(device, k), k)
+
+ def setUp(self):
+ self.dev0 = MDRaidArrayDevice("dev0")
+
+ self.dev1 = MDRaidArrayDevice("dev1", level="container")
+ self.dev2 = MDRaidArrayDevice("dev2", level="raid0")
+ self.dev3 = MDRaidArrayDevice("dev3", level="raid1")
+ self.dev4 = MDRaidArrayDevice("dev4", level="raid4")
+ self.dev5 = MDRaidArrayDevice("dev5", level="raid5")
+ self.dev6 = MDRaidArrayDevice("dev6", level="raid6")
+ self.dev7 = MDRaidArrayDevice("dev7", level="raid10")
+
+ self.dev8 = MDRaidArrayDevice("dev8", exists=True)
+ self.dev9 = MDRaidArrayDevice(
+ "dev9",
+ level="raid0",
+ parents=[
+ MDRaidArrayDevice("parent", level="container"),
+ MDRaidArrayDevice("other")])
+
+ self.dev10 = MDRaidArrayDevice(
+ "dev10",
+ level="raid0",
+ size=32)
+
+ self.dev11 = MDRaidArrayDevice(
+ "dev11",
+ level=1,
+ parents=[
+ MDRaidArrayDevice("parent", level="container"),
+ MDRaidArrayDevice("other")],
+ size=32)
+
+ self.dev12 = MDRaidArrayDevice(
+ "dev12",
+ level=1,
+ memberDevices=2,
+ parents=[
+ Mock(**{"type": "mdcontainer",
+ "size": 4}),
+ Mock(**{"size": 2})],
+ size=32,
+ totalDevices=2)
+
+ self.dev13 = MDRaidArrayDevice(
+ "dev13",
+ level=0,
+ memberDevices=3,
+ parents=[
+ Mock(**{"size": 4}),
+ Mock(**{"size": 2})],
+ size=32,
+ totalDevices=3)
+
+ self.dev14 = MDRaidArrayDevice(
+ "dev14",
+ level=4,
+ memberDevices=3,
+ parents=[
+ Mock(**{"size": 4}),
+ Mock(**{"size": 2}),
+ Mock(**{"size": 2})],
+ totalDevices=3)
+
+ self.dev15 = MDRaidArrayDevice(
+ "dev15",
+ level=5,
+ memberDevices=3,
+ parents=[
+ Mock(**{"size": 4}),
+ Mock(**{"size": 2}),
+ Mock(**{"size": 2})],
+ totalDevices=3)
+
+ self.dev16 = MDRaidArrayDevice(
+ "dev16",
+ level=6,
+ memberDevices=4,
+ parents=[
+ Mock(**{"size": 4}),
+ Mock(**{"size": 4}),
+ Mock(**{"size": 2}),
+ Mock(**{"size": 2})],
+ totalDevices=4)
+
+ self.dev17 = MDRaidArrayDevice(
+ "dev17",
+ level=10,
+ memberDevices=4,
+ parents=[
+ Mock(**{"size": 4}),
+ Mock(**{"size": 4}),
+ Mock(**{"size": 2}),
+ Mock(**{"size": 2})],
+ totalDevices=4)
+
+ self.dev18 = MDRaidArrayDevice(
+ "dev18",
+ level=10,
+ memberDevices=4,
+ parents=[
+ Mock(**{"size": 4}),
+ Mock(**{"size": 4}),
+ Mock(**{"size": 2}),
+ Mock(**{"size": 2})],
+ totalDevices=5)
+
+
+ def testMDRaidArrayDeviceInit(self, *args, **kwargs):
+ """
+ """
+ self.stateCheck(self.dev0)
+
+
+ ##
+ ## level tests
+ ##
+ self.stateCheck(self.dev1,
+ description=lambda x, m: self.assertEqual(x, "BIOS RAID container", m),
+ level=lambda x, m: self.assertEqual(x, "container", m),
+ type=lambda x, m: self.assertEqual(x, "mdcontainer", m))
+ self.stateCheck(self.dev2,
+ description=lambda x, m: self.assertEqual(x, "MDRAID set (stripe)", m),
+ createBitmap=self.assertFalse,
+ level=lambda x, m: self.assertEqual(x, 0, m))
+ self.stateCheck(self.dev3,
+ description=lambda x, m: self.assertEqual(x, "MDRAID set (mirror)", m),
+ level=lambda x, m: self.assertEqual(x, 1, m))
+ self.stateCheck(self.dev4,
+ description=lambda x, m: self.assertEqual(x, "MDRAID set (raid4)", m),
+ level=lambda x, m: self.assertEqual(x, 4, m))
+ self.stateCheck(self.dev5,
+ description=lambda x, m: self.assertEqual(x, "MDRAID set (raid5)", m),
+ level=lambda x, m: self.assertEqual(x, 5, m))
+ self.stateCheck(self.dev6,
+ description=lambda x, m: self.assertEqual(x, "MDRAID set (raid6)", m),
+ level=lambda x, m: self.assertEqual(x, 6, m))
+ self.stateCheck(self.dev7,
+ description=lambda x, m: self.assertEqual(x, "MDRAID set (raid10)", m),
+ level=lambda x, m: self.assertEqual(x, 10, m))
+
+ ##
+ ## existing device tests
+ ##
+ self.stateCheck(self.dev8,
+ exists=self.assertTrue,
+ metadataVersion=self.assertIsNone)
+
+
+ ##
+ ## mdbiosraidarray tests
+ ##
+ self.stateCheck(self.dev9,
+ createBitmap=self.assertFalse,
+ description=lambda x, m: self.assertEqual(x, "BIOS RAID set (stripe)", m),
+ devices=lambda x, m: self.assertEqual(len(x), 2, m),
+ isDisk=self.assertTrue,
+ level=lambda x, m: self.assertEqual(x, 0, m),
+ mediaPresent=self.assertTrue,
+ parents=lambda x, m: self.assertNotEqual(x, [], m),
+ partitionable=self.assertTrue,
+ smallestMember=self.assertIsNotNone,
+ type = lambda x, m: self.assertEqual(x, "mdbiosraidarray", m))
+
+ ##
+ ## size tests
+ ##
+ self.stateCheck(self.dev10,
+ createBitmap=self.assertFalse,
+ description=lambda x, m: self.assertEqual(x, "MDRAID set (stripe)", m),
+ level=lambda x, m: self.assertEqual(x, 0, m))
+
+ self.stateCheck(self.dev11,
+ description=lambda x, m: self.assertEqual(x, "BIOS RAID set (mirror)", m),
+ devices=lambda x, m: self.assertEqual(len(x), 2, m),
+ isDisk=self.assertTrue,
+ level=lambda x, m: self.assertEqual(x, 1, m),
+ mediaPresent=self.assertTrue,
+ parents=lambda x, m: self.assertNotEqual(x, [], m),
+ partitionable=self.assertTrue,
+ smallestMember=self.assertIsNotNone,
+ type=lambda x, m: self.assertEqual(x, "mdbiosraidarray", m))
+
+ ##
+ ## rawArraySize tests
+ ##
+ self.stateCheck(self.dev12,
+ description=lambda x, m: self.assertEqual(x, "BIOS RAID set (mirror)", m),
+ devices=lambda x, m: self.assertEqual(len(x), 2, m),
+ isDisk=self.assertTrue,
+ level=lambda x, m: self.assertEqual(x, 1, m),
+ mediaPresent=self.assertTrue,
+ memberDevices=lambda x, m: self.assertEqual(x, 2, m),
+ parents=lambda x, m: self.assertNotEqual(x, [], m),
+ partitionable=self.assertTrue,
+ rawArraySize=lambda x, m: self.assertEqual(x, 2, m),
+ smallestMember=self.assertIsNotNone,
+ totalDevices=lambda x, m: self.assertEqual(x, 2, m),
+ type = lambda x, m: self.assertEqual(x, "mdbiosraidarray", m))
+
+ self.stateCheck(self.dev13,
+ createBitmap=self.assertFalse,
+ description=lambda x, m: self.assertEqual(x, "MDRAID set (stripe)", m),
+ devices=lambda x, m: self.assertEqual(len(x), 2, m),
+ level=lambda x, m: self.assertEqual(x, 0, m),
+ memberDevices=lambda x, m: self.assertEqual(x, 3, m),
+ parents=lambda x, m: self.assertNotEqual(x, [], m),
+ rawArraySize=lambda x, m: self.assertEqual(x, 6, m),
+ size=lambda x, m: self.assertEqual(x, 6, m),
+ smallestMember=self.assertIsNotNone,
+ totalDevices=lambda x, m: self.assertEqual(x, 3, m))
+
+ self.stateCheck(self.dev14,
+ description=lambda x, m: self.assertEqual(x, "MDRAID set (raid4)", m),
+ devices=lambda x, m: self.assertEqual(len(x), 3, m),
+ level=lambda x, m: self.assertEqual(x, 4, m),
+ memberDevices=lambda x, m: self.assertEqual(x, 3, m),
+ parents=lambda x, m: self.assertNotEqual(x, [], m),
+ rawArraySize=lambda x, m: self.assertEqual(x, 4, m),
+ size=lambda x, m: self.assertEqual(x, 4, m),
+ smallestMember=self.assertIsNotNone,
+ totalDevices=lambda x, m: self.assertEqual(x, 3, m))
+
+ self.stateCheck(self.dev15,
+ description=lambda x, m: self.assertEqual(x, "MDRAID set (raid5)", m),
+ devices=lambda x, m: self.assertEqual(len(x), 3, m),
+ level=lambda x, m: self.assertEqual(x, 5, m),
+ memberDevices=lambda x, m: self.assertEqual(x, 3, m),
+ parents=lambda x, m: self.assertNotEqual(x, [], m),
+ rawArraySize=lambda x, m: self.assertEqual(x, 4, m),
+ size=lambda x, m: self.assertEqual(x, 4, m),
+ smallestMember=self.assertIsNotNone,
+ totalDevices=lambda x, m: self.assertEqual(x, 3, m))
+
+ self.stateCheck(self.dev16,
+ description=lambda x, m: self.assertEqual(x, "MDRAID set (raid6)", m),
+ devices=lambda x, m: self.assertEqual(len(x), 4, m),
+ level=lambda x, m: self.assertEqual(x, 6, m),
+ memberDevices=lambda x, m: self.assertEqual(x, 4, m),
+ parents=lambda x, m: self.assertNotEqual(x, [], m),
+ rawArraySize=lambda x, m: self.assertEqual(x, 4, m),
+ size=lambda x, m: self.assertEqual(x, 4, m),
+ smallestMember=self.assertIsNotNone,
+ totalDevices=lambda x, m: self.assertEqual(x, 4, m))
+
+ self.stateCheck(self.dev17,
+ description=lambda x, m: self.assertEqual(x, "MDRAID set (raid10)", m),
+ devices=lambda x, m: self.assertEqual(len(x), 4, m),
+ level=lambda x, m: self.assertEqual(x, 10, m),
+ memberDevices=lambda x, m: self.assertEqual(x, 4, m),
+ parents=lambda x, m: self.assertNotEqual(x, [], m),
+ rawArraySize=lambda x, m: self.assertEqual(x, 4, m),
+ size=lambda x, m: self.assertEqual(x, 4, m),
+ smallestMember=self.assertIsNotNone,
+ totalDevices=lambda x, m: self.assertEqual(x, 4, m))
+
+ self.stateCheck(self.dev18,
+ description=lambda x, m: self.assertEqual(x, "MDRAID set (raid10)", m),
+ devices=lambda x, m: self.assertEqual(len(x), 4, m),
+ level=lambda x, m: self.assertEqual(x, 10, m),
+ memberDevices=lambda x, m: self.assertEqual(x, 4, m),
+ parents=lambda x, m: self.assertNotEqual(x, [], m),
+ rawArraySize=lambda x, m: self.assertEqual(x, 4, m),
+ size=lambda x, m: self.assertEqual(x, 4, m),
+ smallestMember=self.assertIsNotNone,
+ spares=lambda x, m: self.assertEqual(x, 1, m),
+ totalDevices=lambda x, m: self.assertEqual(x, 5, m))
+
+ self.assertRaisesRegexp(mdraid.MDRaidError,
+ "invalid raid level",
+ MDRaidArrayDevice,
+ "dev",
+ level="raid2")
+
+ self.assertRaisesRegexp(mdraid.MDRaidError,
+ "invalid raid level",
+ MDRaidArrayDevice,
+ "dev",
+ parents=[Device("parent")])
+
+ self.assertRaisesRegexp(DeviceError,
+ "A RAID0 set requires at least 2 members",
+ MDRaidArrayDevice,
+ "dev",
+ level="raid0",
+ parents=[Device("parent")])
+
+ self.assertRaisesRegexp(mdraid.MDRaidError,
+ "invalid raid level descriptor junk",
+ MDRaidArrayDevice,
+ "dev",
+ level="junk")
+
+ self.assertRaisesRegexp(ValueError,
+ "memberDevices cannot be greater than totalDevices",
+ MDRaidArrayDevice,
+ "dev",
+ memberDevices=2)
+
+
+ def testMDRaidArrayDeviceMethods(self, *args, **kwargs):
+
+ with self.assertRaisesRegexp(mdraid.MDRaidError, "invalid raid level junk" ):
+ self.dev7.level = "junk"
+
+
+def suite():
+ return unittest.TestLoader().loadTestsFromTestCase(MDRaidArrayDeviceTestCase)
+
+
+if __name__ == "__main__":
+ unittest.main()
+
--
1.8.3.1
10 years, 6 months
[master/f20-branch][PATCH] Fix geolocation on live installs
by Martin Kolman
Ignore LANG if it is the same as our default language,
otherwise geolocation will never bee used.
If LANG is set to a different value than our
default language, it will take precedence and
geolocation will not be used.
Signed-off-by: Martin Kolman <mkolman(a)redhat.com>
---
anaconda | 16 +++++++++++++++-
data/liveinst/liveinst | 4 ----
2 files changed, 15 insertions(+), 5 deletions(-)
diff --git a/anaconda b/anaconda
index fcaeb1c..5e10315 100755
--- a/anaconda
+++ b/anaconda
@@ -980,7 +980,21 @@ if __name__ == "__main__":
from pyanaconda import localization
# Set the language before loading an interface, when it may be too late.
- requested_lang = opts.lang or ksdata.lang.lang
+
+ # check if the LANG environmental variable is set
+ env_lang = os.environ.get("LANG")
+ if env_lang is not None:
+ # parse it using langtable
+ env_langs = localization.get_language_locales(env_lang)
+ # if parsed LANG is the same as our default language - ignore it;
+ # otherwise use it as valid language candidate
+ if env_langs and env_langs[0] != constants.DEFAULT_LANG:
+ env_lang = env_langs[0] # the first language is the best match
+ else:
+ env_lang = None
+
+ requested_lang = opts.lang or ksdata.lang.lang or env_lang
+
if requested_lang:
locales = localization.get_language_locales(requested_lang)
if locales:
diff --git a/data/liveinst/liveinst b/data/liveinst/liveinst
index dce02e5..a2cd773 100755
--- a/data/liveinst/liveinst
+++ b/data/liveinst/liveinst
@@ -18,10 +18,6 @@
# along with this program. If not, see <http://www.gnu.org/licenses/>.
#
-if [ -n "$DISPLAY" -a -n "$LANG" ]; then
- INSTLANG="--lang $LANG"
-fi
-
LIVE_INSTALL=0
IMAGE_INSTALL=0
RESCUE=0
--
1.8.4.2
10 years, 6 months
[master][v2] Split the UI code out into separate packages
by Vratislav Podzimek
These patches fix some issues we had in our spec file and split the UI code out
into separate packages. Results of my testing are as follows:
1) Installing anconda-gui with all its dependencies on top of already installed
anaconda-tui with all its dependencies results in almost 180 MB of disk space
taken. That may come handy on minimal installations requiring Initial Setup and
we could create minimal composes with much smaller squashfs images (don't know
what compression does with that number, but it will probably be a noticeable
difference).
2) Using updates.img with all python modules from pyanaconda/ui/gui replaced
with stubs raising errors results in automatic falling back to text mode and
successfull installation without any traceback.
Vratislav Podzimek (5):
Split out anaconda's user interfaces into separate packages
No longer need the Gconf2 package
Don't rely on having zenity and require it only for GUI
Get rid of unused isys.isCapsLockEnabled function
Fall back to text mode if GUI is not available
anaconda | 9 ++++++
anaconda.spec.in | 74 +++++++++++++++++++++++++++++++++++----------
data/liveinst/liveinst | 18 +++++++++--
pyanaconda/isys/Makefile.am | 2 +-
pyanaconda/isys/isys.c | 26 ----------------
5 files changed, 84 insertions(+), 45 deletions(-)
--
1.8.4.2
10 years, 6 months
[initial-setup] Split the GUI code out in a separate package
by Vratislav Podzimek
This is needed for some minimal installations that require Initial Setup, but
don't have the GUI stack.
Vratislav Podzimek (3):
Get rid of the useless modules directory
Split GUI code into a separate package (#999464)
Fallback to text UI if GUI is not available
MANIFEST.in | 3 +--
initial-setup.spec | 40 ++++++++++++++++++++++++++++++++--------
initial_setup/__main__.py | 10 ++++++++--
modules/README.txt | 0
setup.py | 3 +--
5 files changed, 42 insertions(+), 14 deletions(-)
delete mode 100644 modules/README.txt
--
1.8.4.2
10 years, 6 months
[python-meh] Splitting out GUI into a separate package
by Vratislav Podzimek
PATCH 1/2 is just a minor tweak fixing and issue I found during testing. PATCH
2/2 modifies the spec file to split the GUI parts out into a separate package
allowing e.g. the anaconda installer to pull in just TUI if needed.
Vratislav Podzimek (2):
Create archives in one Makefile target and reuse it
Split out GUI to a separate package
Makefile | 15 +++------------
python-meh.spec | 17 +++++++++++++++--
2 files changed, 18 insertions(+), 14 deletions(-)
--
1.8.4.2
10 years, 6 months