From: mulhern amulhern@redhat.com

Related: #12

After a few more patches they will be required to access instance variables.

Does not affect downstream, which always uses instance when invoking, anyway.

Signed-off-by: mulhern amulhern@redhat.com --- blivet/formats/__init__.py | 8 +++---- blivet/formats/fs.py | 15 +++++------- blivet/formats/swap.py | 6 ++--- tests/formats_test/labeling_test.py | 46 ++++++++++++++++++------------------- 4 files changed, 34 insertions(+), 41 deletions(-)

diff --git a/blivet/formats/__init__.py b/blivet/formats/__init__.py index d881a7c..ba15c62 100644 --- a/blivet/formats/__init__.py +++ b/blivet/formats/__init__.py @@ -222,13 +222,11 @@ def dict(self): "resizable": self.resizable} return d

- @classmethod - def labeling(cls): + def labeling(self): """Returns False by default since most formats are non-labeling.""" return False

- @classmethod - def labelFormatOK(cls, label): + def labelFormatOK(self, label): """Checks whether the format of the label is OK for whatever application is used by blivet to write a label for this format. If there is no application that blivet uses to write a label, @@ -240,7 +238,7 @@ def labelFormatOK(cls, label): :return: True if the format of the label is OK, otherwise False """ # pylint: disable=unused-argument - return cls.labeling() + return self.labeling()

def _setLabel(self, label): """Sets the label for this format. diff --git a/blivet/formats/fs.py b/blivet/formats/fs.py index ad48d6e..9e91083 100644 --- a/blivet/formats/fs.py +++ b/blivet/formats/fs.py @@ -151,25 +151,22 @@ def dict(self): "mountable": self.mountable}) return d

- @classmethod - def labeling(cls): + def labeling(self): """Returns True if this filesystem uses labels, otherwise False.

:rtype: bool """ - return cls._labelfs is not None + return self._labelfs is not None

- @classmethod - def relabels(cls): + def relabels(self): """Returns True if it is possible to relabel this filesystem after creation, otherwise False.

:rtype: bool """ - return cls._labelfs is not None and cls._labelfs.label_app is not None + return self._labelfs is not None and self._labelfs.label_app is not None

- @classmethod - def labelFormatOK(cls, label): + def labelFormatOK(self, label): """Return True if the label has an acceptable format for this filesystem. None, which represents accepting the default for this device, is always acceptable. @@ -177,7 +174,7 @@ def labelFormatOK(cls, label): :param label: A possible label :type label: str or None """ - return label is None or (cls._labelfs is not None and cls._labelfs.labelFormatOK(label)) + return label is None or (self._labelfs is not None and self._labelfs.labelFormatOK(label))

label = property(lambda s: s._getLabel(), lambda s,l: s._setLabel(l), doc="this filesystem's label") diff --git a/blivet/formats/swap.py b/blivet/formats/swap.py index 2e2e910..4eab044 100644 --- a/blivet/formats/swap.py +++ b/blivet/formats/swap.py @@ -80,13 +80,11 @@ def dict(self): d.update({"priority": self.priority, "label": self.label}) return d

- @classmethod - def labeling(cls): + def labeling(self): """Returns True as mkswap can write a label to the swap space.""" return True

- @classmethod - def labelFormatOK(cls, label): + def labelFormatOK(self, label): """Returns True since no known restrictions on the label.""" return True

diff --git a/tests/formats_test/labeling_test.py b/tests/formats_test/labeling_test.py index 82a61b7..dfa6e79 100755 --- a/tests/formats_test/labeling_test.py +++ b/tests/formats_test/labeling_test.py @@ -15,41 +15,41 @@ def testLabels(self): """Initialize some filesystems with valid and invalid labels."""

# Ext2FS has a maximum length of 16 - self.assertFalse(fs.Ext2FS.labelFormatOK("root___filesystem")) - self.assertTrue(fs.Ext2FS.labelFormatOK("root__filesystem")) + self.assertFalse(fs.Ext2FS().labelFormatOK("root___filesystem")) + self.assertTrue(fs.Ext2FS().labelFormatOK("root__filesystem"))

# FATFS has a maximum length of 11 - self.assertFalse(fs.FATFS.labelFormatOK("rtfilesystem")) - self.assertTrue(fs.FATFS.labelFormatOK("rfilesystem")) + self.assertFalse(fs.FATFS().labelFormatOK("rtfilesystem")) + self.assertTrue(fs.FATFS().labelFormatOK("rfilesystem"))

# JFS has a maximum length of 16 - self.assertFalse(fs.JFS.labelFormatOK("root___filesystem")) - self.assertTrue(fs.JFS.labelFormatOK("root__filesystem")) + self.assertFalse(fs.JFS().labelFormatOK("root___filesystem")) + self.assertTrue(fs.JFS().labelFormatOK("root__filesystem"))

# ReiserFS has a maximum length of 16 - self.assertFalse(fs.ReiserFS.labelFormatOK("root___filesystem")) - self.assertTrue(fs.ReiserFS.labelFormatOK("root__filesystem")) + self.assertFalse(fs.ReiserFS().labelFormatOK("root___filesystem")) + self.assertTrue(fs.ReiserFS().labelFormatOK("root__filesystem"))

#XFS has a maximum length 12 and does not allow spaces - self.assertFalse(fs.XFS.labelFormatOK("root_filesyst")) - self.assertFalse(fs.XFS.labelFormatOK("root file")) - self.assertTrue(fs.XFS.labelFormatOK("root_filesys")) + self.assertFalse(fs.XFS().labelFormatOK("root_filesyst")) + self.assertFalse(fs.XFS().labelFormatOK("root file")) + self.assertTrue(fs.XFS().labelFormatOK("root_filesys"))

#HFS has a maximum length of 27, minimum length of 1, and does not allow colons - self.assertFalse(fs.HFS.labelFormatOK("n" * 28)) - self.assertFalse(fs.HFS.labelFormatOK("root:file")) - self.assertFalse(fs.HFS.labelFormatOK("")) - self.assertTrue(fs.HFS.labelFormatOK("n" * 27)) + self.assertFalse(fs.HFS().labelFormatOK("n" * 28)) + self.assertFalse(fs.HFS().labelFormatOK("root:file")) + self.assertFalse(fs.HFS().labelFormatOK("")) + self.assertTrue(fs.HFS().labelFormatOK("n" * 27))

#HFSPlus has a maximum length of 128, minimum length of 1, and does not allow colons - self.assertFalse(fs.HFSPlus.labelFormatOK("n" * 129)) - self.assertFalse(fs.HFSPlus.labelFormatOK("root:file")) - self.assertFalse(fs.HFSPlus.labelFormatOK("")) - self.assertTrue(fs.HFSPlus.labelFormatOK("n" * 128)) + self.assertFalse(fs.HFSPlus().labelFormatOK("n" * 129)) + self.assertFalse(fs.HFSPlus().labelFormatOK("root:file")) + self.assertFalse(fs.HFSPlus().labelFormatOK("")) + self.assertTrue(fs.HFSPlus().labelFormatOK("n" * 128))

# NTFS has a maximum length of 128 - self.assertFalse(fs.NTFS.labelFormatOK("n" * 129)) - self.assertTrue(fs.NTFS.labelFormatOK("n" * 128)) + self.assertFalse(fs.NTFS().labelFormatOK("n" * 129)) + self.assertTrue(fs.NTFS().labelFormatOK("n" * 128))

# all devices are permitted to be passed a label argument of None # some will ignore it completely @@ -62,7 +62,7 @@ class MethodsTestCase(unittest.TestCase): def setUp(self): self.fs = {} for k, v in device_formats.items(): - if issubclass(v, fs.FS) and v.labeling(): + if issubclass(v, fs.FS) and v().labeling(): self.fs[k] = v(device="/dev", label="myfs")

@@ -87,7 +87,7 @@ def testGetLabelArgs(self): # all of the remaining are non-labeling so will accept any label label = "Houston, we have a problem!" for name, klass in device_formats.items(): - if issubclass(klass, fs.FS) and not klass.labeling() and not issubclass(klass, fs.NFS): + if issubclass(klass, fs.FS) and not klass().labeling() and not issubclass(klass, fs.NFS): self.assertEqual(klass(device="/dev", label=label).label, label, msg=name)

class XFSTestCase(fslabeling.CompleteLabelingAsRoot):

From: mulhern amulhern@redhat.com

Related: #12

This way, tasks can know what the kernel filesystems are if they need to. Avoids circular imports of filesystems, task, then filesystem again.

Signed-off-by: mulhern amulhern@redhat.com --- blivet/devicetree.py | 2 +- blivet/formats/fs.py | 14 ++------------ blivet/formats/fslib.py | 34 ++++++++++++++++++++++++++++++++++ 3 files changed, 37 insertions(+), 13 deletions(-) create mode 100644 blivet/formats/fslib.py

diff --git a/blivet/devicetree.py b/blivet/devicetree.py index 765e4ce..e86c8c3 100644 --- a/blivet/devicetree.py +++ b/blivet/devicetree.py @@ -1013,7 +1013,7 @@ def handleNodevFilesystems(self): except ValueError: log.error("failed to parse /proc/mounts line: %s", line) continue - if fstype in formats.fs.nodev_filesystems: + if fstype in formats.fslib.nodev_filesystems: if not flags.include_nodev: continue

diff --git a/blivet/formats/fs.py b/blivet/formats/fs.py index 9e91083..3bb0ebe 100644 --- a/blivet/formats/fs.py +++ b/blivet/formats/fs.py @@ -41,21 +41,11 @@ from .. import udev from ..mounts import mountsCache

+from .fslib import kernel_filesystems, update_kernel_filesystems + import logging log = logging.getLogger("blivet")

-kernel_filesystems = [] -nodev_filesystems = [] - -def update_kernel_filesystems(): - for line in open("/proc/filesystems").readlines(): - fields = line.split() - kernel_filesystems.append(fields[-1]) - if fields[0] == "nodev": - nodev_filesystems.append(fields[-1]) - -update_kernel_filesystems() - class FS(DeviceFormat): """ Filesystem base class. """ _type = "Abstract Filesystem Class" # fs type name diff --git a/blivet/formats/fslib.py b/blivet/formats/fslib.py new file mode 100644 index 0000000..092439d --- /dev/null +++ b/blivet/formats/fslib.py @@ -0,0 +1,34 @@ +# fslib.py +# Library to support filesystem classes. +# +# Copyright (C) 2015 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 General Public License v.2, or (at your option) any later version. +# This program is distributed in the hope that it will be useful, but WITHOUT +# ANY WARRANTY expressed or implied, including the implied warranties of +# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General +# Public License for more details. You should have received a copy of the +# GNU General Public License along with this program; if not, write to the +# Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA +# 02110-1301, USA. Any Red Hat trademarks that are incorporated in the +# source code or documentation are not subject to the GNU General Public +# License and may only be used or replicated with the express permission of +# Red Hat, Inc. +# +# Red Hat Author(s): Dave Lehman dlehman@redhat.com +# David Cantrell dcantrell@redhat.com +# Anne Mulhern amulhern@redhat.com + +kernel_filesystems = [] +nodev_filesystems = [] + +def update_kernel_filesystems(): + for line in open("/proc/filesystems").readlines(): + fields = line.split() + kernel_filesystems.append(fields[-1]) + if fields[0] == "nodev": + nodev_filesystems.append(fields[-1]) + +update_kernel_filesystems()

From: mulhern amulhern@redhat.com

Related: #12

Signed-off-by: mulhern amulhern@redhat.com --- blivet/tasks/__init__.py | 0 blivet/tasks/availability.py | 192 +++++++++++++++++++++++++++++++++++++++++++ blivet/tasks/task.py | 86 +++++++++++++++++++ python-blivet.spec | 1 + setup.py | 2 +- 5 files changed, 280 insertions(+), 1 deletion(-) create mode 100644 blivet/tasks/__init__.py create mode 100644 blivet/tasks/availability.py create mode 100644 blivet/tasks/task.py

diff --git a/blivet/tasks/__init__.py b/blivet/tasks/__init__.py new file mode 100644 index 0000000..e69de29 diff --git a/blivet/tasks/availability.py b/blivet/tasks/availability.py new file mode 100644 index 0000000..b868e39 --- /dev/null +++ b/blivet/tasks/availability.py @@ -0,0 +1,192 @@ +# availability.py +# Class for tracking availability of an application. +# +# Copyright (C) 2014-2015 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 General Public License v.2, or (at your option) any later version. +# This program is distributed in the hope that it will be useful, but WITHOUT +# ANY WARRANTY expressed or implied, including the implied warranties of +# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General +# Public License for more details. You should have received a copy of the +# GNU General Public License along with this program; if not, write to the +# Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA +# 02110-1301, USA. Any Red Hat trademarks that are incorporated in the +# source code or documentation are not subject to the GNU General Public +# License and may only be used or replicated with the express permission of +# Red Hat, Inc. +# +# Red Hat Author(s): Anne Mulhern amulhern@redhat.com + +import abc +from distutils.version import LooseVersion + +from six import add_metaclass + +from gi.repository import BlockDev as blockdev + +from .. import util +from ..errors import AvailabilityError + +class ExternalResource(object): + """ An application. """ + + def __init__(self, method, name): + """ Initializes an instance of an application. + + :param method: A method object + :type method: :class:`Method` + :param str name: the name of the application + """ + self._method = method + self.name = name + + def __str__(self): + return self.name + + # Results of these methods may change at runtime, depending on system + # state. + + @property + def available(self): + """ Whether the resource is available. + + :returns: True if the resource is available, otherwise False + :rtype: bool + """ + return self._method.available(self) + +@add_metaclass(abc.ABCMeta) +class Method(object): + """ A collection of methods for a particular application task. """ + + @abc.abstractmethod + def available(self, resource): + """ Returns True if the resource is available. + + :param resource: any external resource + :type resource: :class:`ExternalResource` + + :returns: True if the application is available + :rtype: bool + """ + raise NotImplementedError() + +class Path(Method): + """ Methods for when application is found in PATH. """ + + def available(self, resource): + """ Returns True if the name of the application is in the path. + + :param resource: any application + :type resource: :class:`ExternalResource` + + :returns: True if the name of the application is in the path + :rtype: bool + """ + return bool(util.find_program_in_path(resource.name)) + +Path = Path() + +class PackageInfo(object): + + def __init__(self, package_name, required_version=None): + """ Initializer. + + :param str package_name: the name of the package + :param required_version: the required version for this package + :type required_version: :class:`distutils.LooseVersion` or NoneType + """ + self.package_name = package_name + self.required_version = required_version + + def __str__(self): + return "%s-%s" % (self.package_name, self.required_version) + +class PackageMethod(Method): + """ Methods for checking the package version of the external resource. """ + + def __init__(self, package=None): + """ Initializer. + + :param :class:`PackageInfo` package: + """ + self.package = package + + @property + def packageVersion(self): + args = ["rpm", "-q", "--queryformat", "%{VERSION}", self.package.package_name] + try: + (rc, out) = util.run_program_and_capture_output(args) + if rc != 0: + raise AvailabilityError("Could not determine package version for %s" % self.package.package_name) + except OSError as e: + raise AvailabilityError("Could not determine package version for %s: %s" % (self.package.package_name, e)) + + return LooseVersion(out) + + def available(self, resource): + return Path.available(resource) and \ + self.package.required_version is None or self.packageVersion >= self.package.required_version + +class BlockDevMethod(Method): + """ Methods for when application is actually a libblockdev plugin. """ + + def available(self, resource): + """ Returns True if the plugin is loaded. + + :param resource: a libblockdev plugin + :type resource: :class:`ExternalResource` + + :returns: True if the name of the plugin is loaded + :rtype: bool + """ + return resource.name in blockdev.get_available_plugin_names() + +BlockDevMethod = BlockDevMethod() + +def application(name): + """ Construct an external resource that is an application. + + This application will be available if its name can be found in $PATH. + """ + return ExternalResource(Path, name) + +def application_by_package(name, package_method): + """ Construct an external resource that is an application. + + This application will be available if its name can be found in $PATH + AND its package version is at least the required version. + + :param :class:`PackageMethod` package_method: the package method + """ + return ExternalResource(package_method, name) + +def blockdev_plugin(name): + """ Construct an external resource that is a libblockdev plugin. """ + return ExternalResource(BlockDevMethod, name) + +# blockdev plugins +BLOCKDEV_BTRFS_PLUGIN = blockdev_plugin("btrfs") +BLOCKDEV_CRYPTO_PLUGIN = blockdev_plugin("crypto") +BLOCKDEV_DM_PLUGIN = blockdev_plugin("dm") +BLOCKDEV_LOOP_PLUGIN = blockdev_plugin("loop") +BLOCKDEV_LVM_PLUGIN = blockdev_plugin("lvm") +BLOCKDEV_MDRAID_PLUGIN = blockdev_plugin("mdraid") +BLOCKDEV_MPATH_PLUGIN = blockdev_plugin("mpath") +BLOCKDEV_SWAP_PLUGIN = blockdev_plugin("swap") + +# packages +E2FSPROGS_PACKAGE = PackageMethod(PackageInfo("e2fsprogs", LooseVersion("1.41.0"))) + +# applications +DOSFSLABEL_APP = application("dosfslabel") +E2LABEL_APP = application_by_package("e2label", E2FSPROGS_PACKAGE) +JFSTUNE_APP = application("jfs_tune") +NTFSLABEL_APP = application("ntfslabel") +NTFSRESIZE_APP = application("ntfsresize") +RESIZE2FS_APP = application_by_package("resize2fs", E2FSPROGS_PACKAGE) +XFSADMIN_APP = application("xfs_admin") + +MOUNT_APP = application("mount") diff --git a/blivet/tasks/task.py b/blivet/tasks/task.py new file mode 100644 index 0000000..9a519ff --- /dev/null +++ b/blivet/tasks/task.py @@ -0,0 +1,86 @@ +# task.py +# Abstract class for tasks. +# +# Copyright (C) 2015 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 General Public License v.2, or (at your option) any later version. +# This program is distributed in the hope that it will be useful, but WITHOUT +# ANY WARRANTY expressed or implied, including the implied warranties of +# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General +# Public License for more details. You should have received a copy of the +# GNU General Public License along with this program; if not, write to the +# Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA +# 02110-1301, USA. Any Red Hat trademarks that are incorporated in the +# source code or documentation are not subject to the GNU General Public +# License and may only be used or replicated with the express permission of +# Red Hat, Inc. +# +# Red Hat Author(s): Anne Mulhern amulhern@redhat.com + +import abc + +from six import add_metaclass + +@add_metaclass(abc.ABCMeta) +class Task(object): + """ An abstract class that represents some task. """ + + # Whether or not the functionality is implemented in the task class. + # It is True by default. Only NotImplementedClass and its descendants + # should have a False value. + implemented = True + + description = abc.abstractproperty(doc="Brief description for this task.") + + @property + def availabilityErrors(self): + """ Reasons if this task or the tasks it depends on are unavailable. """ + return self._availabilityErrors + \ + [e for t in self.dependsOn for e in t.availabilityErrors] + + _availabilityErrors = abc.abstractproperty( + doc="Reasons if the necessary external tools are unavailable.") + + dependsOn = abc.abstractproperty(doc="tasks that this task depends on") + + @abc.abstractmethod + def doTask(self, *args, **kwargs): + """ Do the task for this class. """ + raise NotImplementedError() + +class UnimplementedTask(Task): + """ A null Task, which returns a negative or empty for all properties.""" + + description = "an unimplemented task" + implemented = False + + @property + def _availabilityErrors(self): + return ["Not implemented task can not succeed."] + + dependsOn = [] + + def doTask(self, *args, **kwargs): + raise NotImplementedError() + +@add_metaclass(abc.ABCMeta) +class BasicApplication(Task): + """ A task representing an application. """ + + ext = abc.abstractproperty(doc="The object representing the external resource.") + + # TASK methods + + @property + def _availabilityErrors(self): + errors = [] + if not self.ext.available: + errors.append("application %s is not available" % self.ext) + + return errors + + @property + def dependsOn(self): + return [] diff --git a/python-blivet.spec b/python-blivet.spec index c01f462..73d981b 100644 --- a/python-blivet.spec +++ b/python-blivet.spec @@ -41,6 +41,7 @@ Requires: libselinux-python Requires: libblockdev >= %{libblockdevver} Requires: libblockdev-plugins-all >= %{libblockdevver} Requires: libselinux-python +Requires: rpm

%description The python-blivet package is a python module for examining and modifying diff --git a/setup.py b/setup.py index 83a23ff..e7ac91c 100644 --- a/setup.py +++ b/setup.py @@ -36,4 +36,4 @@ def add_member_order_option(files): author='David Lehman', author_email='dlehman@redhat.com', url='http://fedoraproject.org/wiki/blivet', data_files=data_files, - packages=['blivet', 'blivet.devices', 'blivet.devicelibs', 'blivet.formats']) + packages=['blivet', 'blivet.devices', 'blivet.devicelibs', 'blivet.formats', 'blivet.tasks'])

From: mulhern amulhern@redhat.com

Related: #12

Signed-off-by: mulhern amulhern@redhat.com --- blivet/tasks/fsck.py | 157 ++++++++++++++++++++++++ blivet/tasks/fsinfo.py | 106 +++++++++++++++++ blivet/tasks/fslabeling.py | 98 +++++++++++++++ blivet/tasks/fsminsize.py | 187 +++++++++++++++++++++++++++++ blivet/tasks/fsmkfs.py | 231 ++++++++++++++++++++++++++++++++++++ blivet/tasks/fsmount.py | 195 ++++++++++++++++++++++++++++++ blivet/tasks/fsreadlabel.py | 133 +++++++++++++++++++++ blivet/tasks/fsresize.py | 148 +++++++++++++++++++++++ blivet/tasks/fssize.py | 166 ++++++++++++++++++++++++++ blivet/tasks/fssync.py | 89 ++++++++++++++ blivet/tasks/fswritelabel.py | 116 ++++++++++++++++++ tests/pylint/pylint-false-positives | 3 + 12 files changed, 1629 insertions(+) create mode 100644 blivet/tasks/fsck.py create mode 100644 blivet/tasks/fsinfo.py create mode 100644 blivet/tasks/fslabeling.py create mode 100644 blivet/tasks/fsminsize.py create mode 100644 blivet/tasks/fsmkfs.py create mode 100644 blivet/tasks/fsmount.py create mode 100644 blivet/tasks/fsreadlabel.py create mode 100644 blivet/tasks/fsresize.py create mode 100644 blivet/tasks/fssize.py create mode 100644 blivet/tasks/fssync.py create mode 100644 blivet/tasks/fswritelabel.py

diff --git a/blivet/tasks/fsck.py b/blivet/tasks/fsck.py new file mode 100644 index 0000000..a70e45e --- /dev/null +++ b/blivet/tasks/fsck.py @@ -0,0 +1,157 @@ +# fsck.py +# Filesystem check functionality. +# +# Copyright (C) 2015 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 General Public License v.2, or (at your option) any later version. +# This program is distributed in the hope that it will be useful, but WITHOUT +# ANY WARRANTY expressed or implied, including the implied warranties of +# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General +# Public License for more details. You should have received a copy of the +# GNU General Public License along with this program; if not, write to the +# Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA +# 02110-1301, USA. Any Red Hat trademarks that are incorporated in the +# source code or documentation are not subject to the GNU General Public +# License and may only be used or replicated with the express permission of +# Red Hat, Inc. +# +# Red Hat Author(s): Anne Mulhern amulhern@redhat.com + +import abc + +from six import add_metaclass + +from ..errors import FSError +from .. import util + +from . import availability +from . import task + +_UNKNOWN_RC_MSG = "Unknown return code: %d" + +@add_metaclass(abc.ABCMeta) +class FSCK(task.BasicApplication): + """An abstract class that represents actions associated with + checking consistency of a filesystem. + """ + description = "fsck" + + options = abc.abstractproperty( + doc="Options for invoking the application.") + + def __init__(self, an_fs): + """ Initializer. + + :param FS an_fs: a filesystem object + """ + self.fs = an_fs + + # IMPLEMENTATION methods + + @abc.abstractmethod + def _errorMessage(self, rc): + """ Error message corresponding to rc. + + :param int rc: the fsck program return code + :returns: an error message corresponding to the code, or None + :rtype: str or NoneType + + A return value of None indicates no error. + """ + raise NotImplementedError() + + @property + def _fsckCommand(self): + """The command to check the filesystem. + + :return: the command + :rtype: list of str + """ + return [str(self.ext)] + self.options + [self.fs.device] + + def doTask(self): + """ Check the filesystem. + + :raises FSError: on failure + """ + error_msgs = self.availabilityErrors + if error_msgs: + raise FSError("\n".join(error_msgs)) + + try: + rc = util.run_program(self._fsckCommand) + except OSError as e: + raise FSError("filesystem check failed: %s" % e) + + error_msg = self._errorMessage(rc) + if error_msg is not None: + hdr = "%(type)s filesystem check failure on %(device)s: " % \ + {"type": self.fs.type, "device": self.fs.device} + + raise FSError(hdr + error_msg) + + +class DosFSCK(FSCK): + _fsckErrors = {1: "Recoverable errors have been detected or dosfsck has " + "discovered an internal inconsistency.", + 2: "Usage error."} + + ext = availability.application("dosfsck") + options = ["-n"] + + def _errorMessage(self, rc): + if rc < 1: + return None + try: + return self._fsckErrors[rc] + except KeyError: + return _UNKNOWN_RC_MSG % rc + + +class Ext2FSCK(FSCK): + _fsckErrors = {4: "File system errors left uncorrected.", + 8: "Operational error.", + 16: "Usage or syntax error.", + 32: "e2fsck cancelled by user request.", + 128: "Shared library error."} + + ext = availability.application_by_package("e2fsck", availability.E2FSPROGS_PACKAGE) + options = ["-f", "-p", "-C", "0"] + + def _errorMessage(self, rc): + msgs = (self._fsckErrors[c] for c in self._fsckErrors.keys() if rc & c) + return "\n".join(msgs) or None + +class HFSPlusFSCK(FSCK): + _fsckErrors = {3: "Quick check found a dirty filesystem; no repairs done.", + 4: "Root filesystem was dirty. System should be rebooted.", + 8: "Corrupt filesystem, repairs did not succeed.", + 47: "Major error found; no repairs attempted."} + ext = availability.application("fsck.hfsplus") + options = [] + + def _errorMessage(self, rc): + if rc < 1: + return None + try: + return self._fsckErrors[rc] + except KeyError: + return _UNKNOWN_RC_MSG % rc + +class NTFSFSCK(FSCK): + ext = availability.NTFSRESIZE_APP + options = ["-c"] + + def _errorMessage(self, rc): + return _UNKNOWN_RC_MSG % (rc,) if rc != 0 else None + +class UnimplementedFSCK(task.UnimplementedTask): + + def __init__(self, an_fs): + """ Initializer. + + :param FS an_fs: a filesystem object + """ + self.fs = an_fs diff --git a/blivet/tasks/fsinfo.py b/blivet/tasks/fsinfo.py new file mode 100644 index 0000000..18eeb79 --- /dev/null +++ b/blivet/tasks/fsinfo.py @@ -0,0 +1,106 @@ +# fsinfo.py +# Filesystem information gathering classes. +# +# Copyright (C) 2015 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 General Public License v.2, or (at your option) any later version. +# This program is distributed in the hope that it will be useful, but WITHOUT +# ANY WARRANTY expressed or implied, including the implied warranties of +# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General +# Public License for more details. You should have received a copy of the +# GNU General Public License along with this program; if not, write to the +# Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA +# 02110-1301, USA. Any Red Hat trademarks that are incorporated in the +# source code or documentation are not subject to the GNU General Public +# License and may only be used or replicated with the express permission of +# Red Hat, Inc. +# +# Red Hat Author(s): Anne Mulhern amulhern@redhat.com + +import abc + +from six import add_metaclass + +from ..errors import FSError +from .. import util + +from . import availability +from . import task + +@add_metaclass(abc.ABCMeta) +class FSInfo(task.BasicApplication): + """ An abstract class that represents an information gathering app. """ + + description = "filesystem info" + + options = abc.abstractproperty( + doc="Options for invoking the application.") + + def __init__(self, an_fs): + """ Initializer. + + :param FS an_fs: a filesystem object + """ + self.fs = an_fs + + @property + def _infoCommand(self): + """ Returns the command for reading filesystem information. + + :returns: a list of appropriate options + :rtype: list of str + """ + return [str(self.ext)] + self.options + [self.fs.device] + + def doTask(self): + """ Returns information from the command. + + :returns: a string representing the output of the command + :rtype: str + :raises FSError: if info cannot be obtained + """ + error_msgs = self.availabilityErrors + if error_msgs: + raise FSError("\n".join(error_msgs)) + + error_msg = None + try: + (rc, out) = util.run_program_and_capture_output(self._infoCommand) + if rc: + error_msg = "failed to gather fs info: %s" % rc + except OSError as e: + error_msg = "failed to gather fs info: %s" % e + if error_msg: + raise FSError(error_msg) + return out + +class Ext2FSInfo(FSInfo): + ext = availability.application_by_package("dumpe2fs", availability.E2FSPROGS_PACKAGE) + options = ["-h"] + +class JFSInfo(FSInfo): + ext = availability.JFSTUNE_APP + options = ["-l"] + +class NTFSInfo(FSInfo): + ext = availability.application("ntfsinfo") + options = ["-m"] + +class ReiserFSInfo(FSInfo): + ext = availability.application("debugreiserfs") + options = [] + +class XFSInfo(FSInfo): + ext = availability.application("xfs_db") + options = ["-c", "sb 0", "-c", "p dblocks", "-c", "p blocksize"] + +class UnimplementedFSInfo(task.UnimplementedTask): + + def __init__(self, an_fs): + """ Initializer. + + :param FS an_fs: a filesystem object + """ + self.fs = an_fs diff --git a/blivet/tasks/fslabeling.py b/blivet/tasks/fslabeling.py new file mode 100644 index 0000000..b0a4c7e --- /dev/null +++ b/blivet/tasks/fslabeling.py @@ -0,0 +1,98 @@ +# fslabeling.py +# Filesystem labeling classes for anaconda's storage configuration module. +# +# Copyright (C) 2014 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 General Public License v.2, or (at your option) any later version. +# This program is distributed in the hope that it will be useful, but WITHOUT +# ANY WARRANTY expressed or implied, including the implied warranties of +# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General +# Public License for more details. You should have received a copy of the +# GNU General Public License along with this program; if not, write to the +# Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA +# 02110-1301, USA. Any Red Hat trademarks that are incorporated in the +# source code or documentation are not subject to the GNU General Public +# License and may only be used or replicated with the express permission of +# Red Hat, Inc. +# +# Red Hat Author(s): Anne Mulhern amulhern@redhat.com + +import abc + +from six import add_metaclass + +@add_metaclass(abc.ABCMeta) +class FSLabeling(object): + """An abstract class that represents filesystem labeling actions. + """ + + default_label = abc.abstractproperty( + doc="Default label set on this filesystem at creation.") + + @abc.abstractmethod + def labelFormatOK(self, label): + """Returns True if this label is correctly formatted for this + filesystem, otherwise False. + + :param str label: the label for this filesystem + :rtype: bool + """ + raise NotImplementedError + +class Ext2FSLabeling(FSLabeling): + + default_label = "" + + def labelFormatOK(self, label): + return len(label) < 17 + +class FATFSLabeling(FSLabeling): + + default_label = "NO NAME" + + def labelFormatOK(self, label): + return len(label) < 12 + +class JFSLabeling(FSLabeling): + + default_label = "" + + def labelFormatOK(self, label): + return len(label) < 17 + +class ReiserFSLabeling(FSLabeling): + + default_label = "" + + def labelFormatOK(self, label): + return len(label) < 17 + +class XFSLabeling(FSLabeling): + + default_label = "" + + def labelFormatOK(self, label): + return ' ' not in label and len(label) < 13 + +class HFSLabeling(FSLabeling): + + default_label = "Untitled" + + def labelFormatOK(self, label): + return ':' not in label and len(label) < 28 and len(label) > 0 + +class HFSPlusLabeling(FSLabeling): + + default_label = "Untitled" + + def labelFormatOK(self, label): + return ':' not in label and 0 < len(label) < 129 + +class NTFSLabeling(FSLabeling): + + default_label = "" + + def labelFormatOK(self, label): + return len(label) < 129 diff --git a/blivet/tasks/fsminsize.py b/blivet/tasks/fsminsize.py new file mode 100644 index 0000000..5044190 --- /dev/null +++ b/blivet/tasks/fsminsize.py @@ -0,0 +1,187 @@ +# fsminsize.py +# Filesystem size gathering classes. +# +# Copyright (C) 2015 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 General Public License v.2, or (at your option) any later version. +# This program is distributed in the hope that it will be useful, but WITHOUT +# ANY WARRANTY expressed or implied, including the implied warranties of +# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General +# Public License for more details. You should have received a copy of the +# GNU General Public License along with this program; if not, write to the +# Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA +# 02110-1301, USA. Any Red Hat trademarks that are incorporated in the +# source code or documentation are not subject to the GNU General Public +# License and may only be used or replicated with the express permission of +# Red Hat, Inc. +# +# Red Hat Author(s): Anne Mulhern amulhern@redhat.com + +import abc + +from six import add_metaclass + +from ..errors import FSError +from .. import util +from ..size import Size + +from . import availability +from . import task + +@add_metaclass(abc.ABCMeta) +class FSMinSize(task.BasicApplication): + """ An abstract class that represents min size information extraction. """ + + description = "minimum filesystem size" + + options = abc.abstractproperty(doc="Options for use with app.") + + def __init__(self, an_fs): + """ Initializer. + + :param FS an_fs: a filesystem object + """ + self.fs = an_fs + + def _resizeCommand(self): + return [str(self.ext)] + self.options + [self.fs.device] + + def _getResizeInfo(self): + """ Get info from fsresize program. + + :rtype: str + :returns: output returned by fsresize program + """ + error_msg = None + try: + (rc, out) = util.run_program_and_capture_output(self._resizeCommand()) + except OSError as e: + error_msg = "failed to gather info from resize program: %s" % e + if rc: + error_msg = "failed to gather info from resize program: %s" % e + + if error_msg: + raise FSError(error_msg) + return out + + @abc.abstractmethod + def doTask(self): + """ Returns the minimum size for this filesystem object. + + :rtype: :class:`~.size.Size` + :returns: the minimum size + :raises FSError: if filesystem can not be obtained + """ + raise NotImplementedError() + +class Ext2FSMinSize(FSMinSize): + + ext = availability.RESIZE2FS_APP + options = ["-P"] + + @property + def dependsOn(self): + return [self.fs._info] + + def _extractBlockSize(self): + """ Extract block size from filesystem info. + + :returns: block size of fileystem or None + :rtype: :class:`~.size.Size` or NoneType + """ + if self.fs._current_info is None: + return None + + blockSize = None + for line in (l.strip() for l in self.fs._current_info.splitlines() if l.startswith("Block size:")): + try: + blockSize = int(line.split(" ")[-1]) + break + except ValueError: + continue + + return Size(blockSize) if blockSize else None + + def _extractNumBlocks(self, info): + """ Extract the number of blocks from the resizefs info. + + :returns: the number of blocks or None + :rtype: int or NoneType + """ + numBlocks = None + for line in info.splitlines(): + (text, _sep, value) = line.partition(":") + if "minimum size of the filesystem" not in text: + continue + + try: + numBlocks = int(value.strip()) + break + except ValueError: + break + + return numBlocks + + def doTask(self): + error_msgs = self.availabilityErrors + if error_msgs: + raise FSError("\n".join(error_msgs)) + + blockSize = self._extractBlockSize() + if blockSize is None: + raise FSError("failed to get block size for %s filesystem on %s" % (self.fs.mountType, self.fs.device.name)) + + resize_info = self._getResizeInfo() + numBlocks = self._extractNumBlocks(resize_info) + if numBlocks is None: + raise FSError("failed to get minimum block number for %s filesystem on %s" % (self.fs.mountType, self.fs.device.name)) + + return blockSize * numBlocks + +class NTFSMinSize(FSMinSize): + + ext = availability.NTFSRESIZE_APP + options = ["-m"] + + def _extractMinSize(self, info): + """ Extract the minimum size from the resizefs info. + + :param str info: info obtained from resizefs prog + :rtype: :class:`~.size.Size` or NoneType + :returns: the minimum size, or None + """ + minSize = None + for line in info.splitlines(): + (text, _sep, value) = line.partition(":") + if "Minsize" not in text: + continue + + try: + minSize = Size("%d MB" % int(value.strip())) + except ValueError: + break + + return minSize + + + def doTask(self): + error_msgs = self.availabilityErrors + if error_msgs: + raise FSError("\n".join(error_msgs)) + + resize_info = self._getResizeInfo() + minSize = self._extractMinSize(resize_info) + if minSize is None: + raise FSError("Unable to discover minimum size of filesystem on %s" % self.fs.device) + return minSize + +class UnimplementedFSMinSize(task.UnimplementedTask): + + def __init__(self, an_fs): + """ Initializer. + + :param FS an_fs: a filesystem object + """ + self.fs = an_fs diff --git a/blivet/tasks/fsmkfs.py b/blivet/tasks/fsmkfs.py new file mode 100644 index 0000000..33cd50f --- /dev/null +++ b/blivet/tasks/fsmkfs.py @@ -0,0 +1,231 @@ +# fsmkfs.py +# Filesystem formatting classes. +# +# Copyright (C) 2015 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 General Public License v.2, or (at your option) any later version. +# This program is distributed in the hope that it will be useful, but WITHOUT +# ANY WARRANTY expressed or implied, including the implied warranties of +# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General +# Public License for more details. You should have received a copy of the +# GNU General Public License along with this program; if not, write to the +# Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA +# 02110-1301, USA. Any Red Hat trademarks that are incorporated in the +# source code or documentation are not subject to the GNU General Public +# License and may only be used or replicated with the express permission of +# Red Hat, Inc. +# +# Red Hat Author(s): Anne Mulhern amulhern@redhat.com + +import abc + +from six import add_metaclass + +from ..errors import FSError, FSWriteLabelError +from .. import util + +from . import availability +from . import task + +@add_metaclass(abc.ABCMeta) +class FSMkfsTask(task.Task): + + can_label = abc.abstractproperty(doc="whether this task labels") + +@add_metaclass(abc.ABCMeta) +class FSMkfs(task.BasicApplication, FSMkfsTask): + """An abstract class that represents filesystem creation actions. """ + description = "mkfs" + + label_option = abc.abstractproperty( + doc="Option for setting a filesystem label.") + + args = abc.abstractproperty(doc="options for creating filesystem") + + def __init__(self, an_fs): + """ Initializer. + + :param FS an_fs: a filesystem object + """ + self.fs = an_fs + + # IMPLEMENTATION methods + + @property + def can_label(self): + """ Whether this task can label the filesystem. + + :returns: True if this task can label the filesystem + :rtype: bool + """ + return self.label_option is not None + + @property + def _labelOptions(self): + """ Any labeling options that a particular filesystem may use. + + :returns: labeling options + :rtype: list of str + """ + # Do not know how to set label while formatting. + if self.label_option is None: + return [] + + # No label to set + if self.fs.label is None: + return [] + + if self.fs.labelFormatOK(self.fs.label): + return [self.label_option, self.fs.label] + else: + raise FSWriteLabelError("Choosing not to apply label (%s) during creation of filesystem %s. Label format is unacceptable for this filesystem." % (self.fs.label, self.fs.type)) + + def _formatOptions(self, options=None, label=False): + """Get a list of format options to be used when creating the + filesystem. + + :param options: any special options + :type options: list of str or None + :param bool label: if True, label if possible, default is False + """ + options = options or [] + + if not isinstance(options, list): + raise FSError("options parameter must be a list.") + + label_options = self._labelOptions if label else [] + return options + self.args + label_options + [self.fs.device] + + def _mkfsCommand(self, options, label): + """Return the command to make the filesystem. + + :param options: any special options + :type options: list of str or None + :returns: the mkfs command + :rtype: list of str + """ + return [str(self.ext)] + self._formatOptions(options, label) + + def doTask(self, options=None, label=False): + """Create the format on the device and label if possible and desired. + + :param options: any special options, may be None + :type options: list of str or NoneType + :param bool label: whether to label while creating, default is False + """ + # pylint: disable=arguments-differ + error_msgs = self.availabilityErrors + if error_msgs: + raise FSError("\n".join(error_msgs)) + + options = options or [] + try: + ret = util.run_program(self._mkfsCommand(options, label)) + except OSError as e: + raise FSError(e) + + if ret: + raise FSError("format failed: %s" % ret) + +class BTRFSMkfs(FSMkfs): + ext = availability.application("mkfs.btrfs") + label_option = None + + @property + def args(self): + return [] + +class Ext2FSMkfs(FSMkfs): + ext = availability.application_by_package("mke2fs", availability.E2FSPROGS_PACKAGE) + label_option = "-L" + + _opts = [] + + @property + def args(self): + return self._opts + (["-T", self.fs.fsprofile] if self.fs.fsprofile else []) + +class Ext3FSMkfs(Ext2FSMkfs): + _opts = ["-t", "ext3"] + +class Ext4FSMkfs(Ext3FSMkfs): + _opts = ["-t", "ext4"] + +class FATFSMkfs(FSMkfs): + ext = availability.application("mkdosfs") + label_option = "-n" + + @property + def args(self): + return [] + +class GFS2Mkfs(FSMkfs): + ext = availability.application("mkfs.gfs2") + label_option = None + + @property + def args(self): + return ["-j", "1", "-p", "lock_nolock", "-O"] + +class HFSMkfs(FSMkfs): + ext = availability.application("hformat") + label_option = "-l" + + @property + def args(self): + return [] + +class HFSPlusMkfs(FSMkfs): + ext = availability.application("mkfs.hfsplus") + label_option = "-v" + + @property + def args(self): + return [] + +class JFSMkfs(FSMkfs): + ext = availability.application("mkfs.jfs") + label_option = "-L" + + @property + def args(self): + return ["-q"] + +class NTFSMkfs(FSMkfs): + ext = availability.application("mkntfs") + label_option = "-L" + + @property + def args(self): + return [] + +class ReiserFSMkfs(FSMkfs): + ext = availability.application("mkreiserfs") + label_option = "-l" + + @property + def args(self): + return ["-f", "-f"] + +class XFSMkfs(FSMkfs): + ext = availability.application("mkfs.xfs") + label_option = "-L" + + @property + def args(self): + return ["-f"] + +class UnimplementedFSMkfs(task.UnimplementedTask, FSMkfsTask): + + def __init__(self, an_fs): + """ Initializer. + + :param FS an_fs: a filesystem object + """ + self.fs = an_fs + + @property + def can_label(self): + return False diff --git a/blivet/tasks/fsmount.py b/blivet/tasks/fsmount.py new file mode 100644 index 0000000..39a11b7 --- /dev/null +++ b/blivet/tasks/fsmount.py @@ -0,0 +1,195 @@ +# fsmount.py +# Filesystem mounting classes. +# +# Copyright (C) 2015 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 General Public License v.2, or (at your option) any later version. +# This program is distributed in the hope that it will be useful, but WITHOUT +# ANY WARRANTY expressed or implied, including the implied warranties of +# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General +# Public License for more details. You should have received a copy of the +# GNU General Public License along with this program; if not, write to the +# Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA +# 02110-1301, USA. Any Red Hat trademarks that are incorporated in the +# source code or documentation are not subject to the GNU General Public +# License and may only be used or replicated with the express permission of +# Red Hat, Inc. +# +# Red Hat Author(s): Anne Mulhern amulhern@redhat.com + +import os + +from ..errors import FSError +from ..flags import flags +from .. import util +from ..formats import fslib + +from . import availability +from . import task + +class FSMount(task.BasicApplication): + """An abstract class that represents filesystem mounting actions. """ + description = "mount a filesystem" + + options = ["defaults"] + # type argument to pass to mount, if different from filesystem type + fstype = None + + ext = availability.MOUNT_APP + + def __init__(self, an_fs): + self.fs = an_fs + + # TASK methods + + @property + def _availabilityErrors(self): + errors = super(FSMount, self)._availabilityErrors + + canmount = (self.mountType in fslib.kernel_filesystems) or \ + (os.access("/sbin/mount.%s" % (self.mountType,), os.X_OK)) + + # Still consider the filesystem type mountable if there exists + # an appropriate filesystem driver in the kernel modules directory. + if not canmount: + modpath = os.path.realpath(os.path.join("/lib/modules", os.uname()[2])) + if os.path.isdir(modpath): + modname = "%s.ko" % self.mountType + for _root, _dirs, files in os.walk(modpath): + if any(x.startswith(modname) for x in files): + canmount = True + break + + if not canmount: + errors.append("mounting filesystem %s is not supported" % self.mountType) + return errors + + # IMPLEMENTATION methods + + @property + def mountType(self): + """ Mount type string to pass to mount command. + + :returns: mount type string + :rtype: str + """ + return self.fstype or self.fs._type + + def _modifyOptions(self, options): + """ Any mandatory options can be added in this method. + + :param str options: an option string + :returns: a modified option string + :rtype: str + """ + return options + + def mountOptions(self, options): + """ The options used for mounting. + + :param options: mount options + :type options: str or None + :returns: the options used by the task + :rtype: str + """ + if not options or not isinstance(options, str): + options = self.fs.mountopts or ",".join(self.options) + + return self._modifyOptions(options) + + def doTask(self, mountpoint, options=None): + """Create the format on the device and label if possible and desired. + + :param str mountpoint: mountpoint that overrides self.mountpoint + :param options: mount options + :type options: str or None + """ + # pylint: disable=arguments-differ + error_msgs = self.availabilityErrors + if error_msgs: + raise FSError("\n".join(error_msgs)) + + try: + rc = util.mount(self.fs.device, mountpoint, + fstype=self.mountType, + options=self.mountOptions(options)) + except OSError as e: + raise FSError("mount failed: %s" % e) + + if rc: + raise FSError("mount failed: %s" % rc) + +class AppleBootstrapFSMount(FSMount): + fstype = "hfs" + +class BindFSMount(FSMount): + + @property + def _availabilityErrors(self): + errors = [] + if not self.ext.available: + errors.append("application %s is not available" % self.ext) + + return errors + + def _modifyOptions(self, options): + return ",".join(["bind", options]) + +class DevPtsFSMount(FSMount): + options = ["gid=5", "mode=620"] + +class FATFSMount(FSMount): + options = ["umask=0077", "shortname=winnt"] + +class EFIFSMount(FATFSMount): + fstype = "vfat" + +class HFSPlusMount(FSMount): + fstype = "hfsplus" + +class Iso9660FSMount(FSMount): + options = ["ro"] + +class NoDevFSMount(FSMount): + + @property + def mountType(self): + return self.fs.device + +class NFSMount(FSMount): + + def _availabilityErrors(self): + return ["nfs filesystem can't be mounted"] + +class NTFSMount(FSMount): + options = ["default", "ro"] + +class SELinuxFSMount(NoDevFSMount): + + @property + def _availabilityErrors(self): + errors = super(SELinuxFSMount, self)._availabilityErrors + if not flags.selinux: + errors.append("selinux not enabled") + return errors + +class TmpFSMount(NoDevFSMount): + + def _modifyOptions(self, options): + # This duplicates some code in fs.TmpFS._getOptions. + # There seems to be no way around that. + if self.fs._accept_default_size: + size_opt = None + else: + size_opt = self.fs._sizeOption(self.fs._size) + return ",".join(o for o in (options, size_opt) if o) + + @property + def _availabilityErrors(self): + errors = [] + if not self.ext.available: + errors.append("application %s is not available" % self.ext) + + return errors diff --git a/blivet/tasks/fsreadlabel.py b/blivet/tasks/fsreadlabel.py new file mode 100644 index 0000000..8b61b02 --- /dev/null +++ b/blivet/tasks/fsreadlabel.py @@ -0,0 +1,133 @@ +# fsreadlabel.py +# Filesystem label reading classes. +# +# Copyright (C) 2015 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 General Public License v.2, or (at your option) any later version. +# This program is distributed in the hope that it will be useful, but WITHOUT +# ANY WARRANTY expressed or implied, including the implied warranties of +# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General +# Public License for more details. You should have received a copy of the +# GNU General Public License along with this program; if not, write to the +# Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA +# 02110-1301, USA. Any Red Hat trademarks that are incorporated in the +# source code or documentation are not subject to the GNU General Public +# License and may only be used or replicated with the express permission of +# Red Hat, Inc. +# +# Red Hat Author(s): Anne Mulhern amulhern@redhat.com + +import abc +import re + +from six import add_metaclass + +from ..errors import FSReadLabelError +from .. import util + +from . import availability +from . import task + +@add_metaclass(abc.ABCMeta) +class FSReadLabel(task.BasicApplication): + """ An abstract class that represents reading a filesystem's label. """ + description = "read filesystem label" + + label_regex = abc.abstractproperty( + doc="Matches the string output by the reading application.") + + args = abc.abstractproperty(doc="arguments for reading a label.") + + def __init__(self, an_fs): + """ Initializer. + + :param FS an_fs: a filesystem object + """ + self.fs = an_fs + + # IMPLEMENTATION methods + + @property + def _readCommand(self): + """Get the command to read the filesystem label. + + :return: the command + :rtype: list of str + """ + return [str(self.ext)] + self.args + + def _extractLabel(self, labelstr): + """Extract the label from an output string. + + :param str labelstr: the string containing the label information + + :return: the label + :rtype: str + + Raises an FSReadLabelError if the label can not be extracted. + """ + match = re.match(self.label_regex, labelstr) + if match is None: + raise FSReadLabelError("Unknown format for application %s" % self._app()) + return match.group('label') + + def doTask(self): + """ Get the label. + + :returns: the filesystem label + :rtype: str + """ + error_msgs = self.availabilityErrors + if error_msgs: + raise FSReadLabelError("\n".join(error_msgs)) + + (rc, out) = util.run_program_and_capture_output(self._readCommand) + if rc != 0: + raise FSReadLabelError("read label failed") + + label = out.strip() + + return label if label == "" else self._extractLabel(label) + +class DosFSReadLabel(FSReadLabel): + ext = availability.DOSFSLABEL_APP + label_regex = r'(?P<label>.*)' + + @property + def args(self): + return [self.fs.device] + +class Ext2FSReadLabel(FSReadLabel): + ext = availability.E2LABEL_APP + label_regex = r'(?P<label>.*)' + + @property + def args(self): + return [self.fs.device] + +class NTFSReadLabel(FSReadLabel): + ext = availability.NTFSLABEL_APP + label_regex = r'(?P<label>.*)' + + @property + def args(self): + return [self.fs.device] + +class XFSReadLabel(FSReadLabel): + ext = availability.XFSADMIN_APP + label_regex = r'label = "(?P<label>.*)"' + + @property + def args(self): + return ["-l", self.fs.device] + +class UnimplementedFSReadLabel(task.UnimplementedTask): + + def __init__(self, an_fs): + """ Initializer. + + :param FS an_fs: a filesystem object + """ + self.fs = an_fs diff --git a/blivet/tasks/fsresize.py b/blivet/tasks/fsresize.py new file mode 100644 index 0000000..46023d1 --- /dev/null +++ b/blivet/tasks/fsresize.py @@ -0,0 +1,148 @@ +# fsresize.py +# Filesystem resizing classes. +# +# Copyright (C) 2015 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 General Public License v.2, or (at your option) any later version. +# This program is distributed in the hope that it will be useful, but WITHOUT +# ANY WARRANTY expressed or implied, including the implied warranties of +# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General +# Public License for more details. You should have received a copy of the +# GNU General Public License along with this program; if not, write to the +# Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA +# 02110-1301, USA. Any Red Hat trademarks that are incorporated in the +# source code or documentation are not subject to the GNU General Public +# License and may only be used or replicated with the express permission of +# Red Hat, Inc. +# +# Red Hat Author(s): Anne Mulhern amulhern@redhat.com + +import abc + +from six import add_metaclass + +from ..errors import FSError +from ..size import B, KiB, MiB, GiB, KB, MB, GB +from ..import util + +from . import availability +from . import task + +@add_metaclass(abc.ABCMeta) +class FSResizeTask(task.Task): + """ The abstract properties that any resize task must have. """ + + unit = abc.abstractproperty(doc="Resize unit.") + size_fmt = abc.abstractproperty(doc="Size format string.") + + +@add_metaclass(abc.ABCMeta) +class FSResize(task.BasicApplication, FSResizeTask): + """ An abstract class for resizing a filesystem. """ + + description = "resize filesystem" + + args = abc.abstractproperty(doc="Resize arguments.") + + def __init__(self, an_fs): + """ Initializer. + + :param FS an_fs: a filesystem object + """ + self.fs = an_fs + + # IMPLEMENTATION methods + + @abc.abstractmethod + def sizeSpec(self): + """ Returns a string specification for the target size of the command. + :returns: size specification + :rtype: str + """ + raise NotImplementedError() + + def _resizeCommand(self): + return [str(self.ext)] + self.args + + def doTask(self): + """ Resize the device. + + :raises FSError: on failure + """ + error_msgs = self.availabilityErrors + if error_msgs: + raise FSError("\n".join(error_msgs)) + + try: + ret = util.run_program(self._resizeCommand()) + except OSError as e: + raise FSError(e) + + if ret: + raise FSError("resize failed: %s" % ret) + +class Ext2FSResize(FSResize): + ext = availability.RESIZE2FS_APP + unit = MiB + # No unit specifier is interpreted not as bytes, but block size + size_fmt = {KiB: "%dK", MiB: "%dM", GiB: "%dG"}[unit] + + def sizeSpec(self): + return self.size_fmt % self.fs.targetSize.convertTo(self.unit) + + @property + def args(self): + return ["-p", self.fs.device, self.sizeSpec()] + +class NTFSResize(FSResize): + ext = availability.NTFSRESIZE_APP + unit = B + size_fmt = {B: "%d", KB: "%dK", MB: "%dM", GB: "%dG"}[unit] + + def sizeSpec(self): + return self.size_fmt % self.fs.targetSize.convertTo(self.unit) + + @property + def args(self): + return [ + "-ff", # need at least two 'f's to fully supress interaction + "-s", self.sizeSpec(), + self.fs.device + ] + +class TmpFSResize(FSResize): + + ext = availability.MOUNT_APP + unit = MiB + size_fmt = {KiB: "%dk", MiB: "%dm", GiB: "%dg"}[unit] + + def sizeSpec(self): + return "size=%s" % (self.size_fmt % self.fs.targetSize.convertTo(self.unit)) + + @property + def args(self): + # This is too closely mixed in w/ TmpFS object, due to the + # fact that resizing is done by mounting and that the options are + # therefore mount options. The situation is hard to avoid, though. + opts = self.fs.mountopts or ",".join(self.fs._mount.options) + options = ("remount", opts, self.sizeSpec()) + return ['-o', ",".join(options), self.fs._type, self.fs.systemMountpoint] + +class UnimplementedFSResize(task.UnimplementedTask, FSResizeTask): + + def __init__(self, an_fs): + """ Initializer. + + :param FS an_fs: a filesystem object + """ + self.fs = an_fs + + @property + def unit(self): + raise NotImplementedError() + + @property + def size_fmt(self): + raise NotImplementedError() diff --git a/blivet/tasks/fssize.py b/blivet/tasks/fssize.py new file mode 100644 index 0000000..e4a7507 --- /dev/null +++ b/blivet/tasks/fssize.py @@ -0,0 +1,166 @@ +# fssize.py +# Filesystem size gathering classes. +# +# Copyright (C) 2015 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 General Public License v.2, or (at your option) any later version. +# This program is distributed in the hope that it will be useful, but WITHOUT +# ANY WARRANTY expressed or implied, including the implied warranties of +# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General +# Public License for more details. You should have received a copy of the +# GNU General Public License along with this program; if not, write to the +# Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA +# 02110-1301, USA. Any Red Hat trademarks that are incorporated in the +# source code or documentation are not subject to the GNU General Public +# License and may only be used or replicated with the express permission of +# Red Hat, Inc. +# +# Red Hat Author(s): Anne Mulhern amulhern@redhat.com + +import abc +from collections import namedtuple + +from six import add_metaclass + +from ..errors import FSError +from ..size import Size +from .. import util + +from . import availability +from . import task + +_tags = ("count", "size") +_Tags = namedtuple("_Tags", _tags) + +@add_metaclass(abc.ABCMeta) +class FSSize(task.Task): + """ An abstract class that represents size information extraction. """ + description = "current filesystem size" + + tags = abc.abstractproperty( + doc="Strings used for extracting components of size.") + + def __init__(self, an_fs): + """ Initializer. + + :param FS an_fs: a filesystem object + """ + self.fs = an_fs + + # TASK methods + + @property + def _availabilityErrors(self): + return [] + + @property + def dependsOn(self): + return [self.fs._info] + + # IMPLEMENTATION methods + + def doTask(self): + """ Returns the size of the filesystem. + + :returns: the size of the filesystem or None + :rtype: :class:`~.size.Size` or NoneType + :raises FSError: on failure + """ + error_msgs = self.availabilityErrors + if error_msgs: + raise FSError("\n".join(error_msgs)) + + if self.fs._current_info is None: + raise FSError("No info available for size computation.") + + # Setup initial values + values = {} + for k in _tags: + values[k] = None + + # Attempt to set values from info + for line in (l.strip() for l in self.fs._current_info.splitlines()): + key = next((k for k in _tags if line.startswith(getattr(self.tags, k))), None) + if not key: + continue + + if values[key] is not None: + raise FSError("found two matches for key %s" % key) + + # Look for last numeric value in matching line + fields = line.split() + fields.reverse() + for field in fields: + try: + values[key] = int(field) + break + except ValueError: + continue + + # Raise an error if a value is missing + missing = next((k for k in _tags if values[k] is None), None) + if missing is not None: + raise FSError("Failed to parse info for %s." % missing) + + return values["count"] * Size(values["size"]) + +class Ext2FSSize(FSSize): + tags = _Tags(size="Block size:", count="Block count:") + +class JFSSize(FSSize): + tags = _Tags(size="Physical block size:", count="Aggregate size:") + +class NTFSSize(FSSize): + tags = _Tags(size="Cluster Size:", count="Volume Size in Clusters:") + +class ReiserFSSize(FSSize): + tags = _Tags(size="Blocksize:", count="Count of blocks on the device:") + +class XFSSize(FSSize): + tags = _Tags(size="blocksize =", count="dblocks =") + +class TmpFSSize(task.BasicApplication): + description = "current filesystem size" + + ext = availability.application("df") + + def __init__(self, an_fs): + """ Initializer. + + :param FS an_fs: a filesystem object + """ + self.fs = an_fs + + @property + def _sizeCommand(self): + return [str(self.ext), self.fs.systemMountpoint, "--output=size"] + + def doTask(self): + error_msgs = self.availabilityErrors + if error_msgs: + raise FSError("\n".join(error_msgs)) + + try: + (ret, out) = util.run_program_and_capture_output(self._sizeCommand) + if ret: + raise FSError("Failed to execute command %s." % self._sizeCommand) + except OSError: + raise FSError("Failed to execute command %s." % self._sizeCommand) + + lines = out.splitlines() + if len(lines) != 2 or lines[0].strip() != "1K-blocks": + raise FSError("Failed to parse output of command %s." % self._sizeCommand) + + return Size("%s KiB" % lines[1]) + + +class UnimplementedFSSize(task.UnimplementedTask): + + def __init__(self, an_fs): + """ Initializer. + + :param FS an_fs: a filesystem object + """ + self.fs = an_fs diff --git a/blivet/tasks/fssync.py b/blivet/tasks/fssync.py new file mode 100644 index 0000000..5cf82b6 --- /dev/null +++ b/blivet/tasks/fssync.py @@ -0,0 +1,89 @@ +# fssync.py +# Filesystem syncing classes. +# +# Copyright (C) 2014 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 General Public License v.2, or (at your option) any later version. +# This program is distributed in the hope that it will be useful, but WITHOUT +# ANY WARRANTY expressed or implied, including the implied warranties of +# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General +# Public License for more details. You should have received a copy of the +# GNU General Public License along with this program; if not, write to the +# Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA +# 02110-1301, USA. Any Red Hat trademarks that are incorporated in the +# source code or documentation are not subject to the GNU General Public +# License and may only be used or replicated with the express permission of +# Red Hat, Inc. +# +# Red Hat Author(s): Anne Mulhern amulhern@redhat.com + +import abc + +from six import add_metaclass + +from ..errors import FSError +from .. import util + +from . import availability +from . import task + +@add_metaclass(abc.ABCMeta) +class FSSync(task.BasicApplication): + """ An abstract class that represents syncing a filesystem. """ + + description = "filesystem syncing" + + def __init__(self, an_fs): + """ Initializer. + + :param FS an_fs: a filesystem object + """ + self.fs = an_fs + + @abc.abstractmethod + def doTask(self): + raise NotImplementedError() + +class XFSSync(FSSync): + """ Info application for XFS. """ + + ext = availability.application("xfs_freeze") + + def _freezeCommand(self): + return [str(self.ext), "-f", self.fs.systemMountpoint] + + def _unfreezeCommand(self): + return [str(self.ext), "-u", self.fs.systemMountpoint] + + def doTask(self, root="/"): + # pylint: disable=arguments-differ + error_msgs = self.availabilityErrors + if error_msgs: + raise FSError("\n".join(error_msgs)) + + error_msg = None + try: + rc = util.run_program(self._freezeCommand(), root=root) + except OSError as e: + error_msg = "failed to sync filesytem: %s" % e + error_msg = error_msg or rc + + try: + rc = util.run_program(self._unfreezeCommand(), root=root) + except OSError as e: + error_msg = error_msg or "failed to sync filesystem: %s" % e + error_msg = error_msg or rc + + if error_msg: + raise FSError(error_msg) + +class UnimplementedFSSync(task.UnimplementedTask): + + def __init__(self, an_fs): + """ Initializer. + + :param FS an_fs: a filesystem object + """ + self.fs = an_fs diff --git a/blivet/tasks/fswritelabel.py b/blivet/tasks/fswritelabel.py new file mode 100644 index 0000000..bcdff7c --- /dev/null +++ b/blivet/tasks/fswritelabel.py @@ -0,0 +1,116 @@ +# fswritelabel.py +# Filesystem label writing classes. +# +# Copyright (C) 2015 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 General Public License v.2, or (at your option) any later version. +# This program is distributed in the hope that it will be useful, but WITHOUT +# ANY WARRANTY expressed or implied, including the implied warranties of +# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General +# Public License for more details. You should have received a copy of the +# GNU General Public License along with this program; if not, write to the +# Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA +# 02110-1301, USA. Any Red Hat trademarks that are incorporated in the +# source code or documentation are not subject to the GNU General Public +# License and may only be used or replicated with the express permission of +# Red Hat, Inc. +# +# Red Hat Author(s): Anne Mulhern amulhern@redhat.com + +import abc + +from six import add_metaclass + +from .. import util +from ..errors import FSWriteLabelError + +from . import availability +from . import task + +@add_metaclass(abc.ABCMeta) +class FSWriteLabel(task.BasicApplication): + """ An abstract class that represents writing a label for a filesystem. """ + + description = "write filesystem label" + + args = abc.abstractproperty(doc="arguments for writing a label") + + def __init__(self, an_fs): + """ Initializer. + + :param FS an_fs: a filesystem object + """ + self.fs = an_fs + + # IMPLEMENTATION methods + + @property + def _setCommand(self): + """Get the command to label the filesystem. + + :return: the command + :rtype: list of str + """ + return [str(self.ext)] + self.args + + def doTask(self): + error_msgs = self.availabilityErrors + if error_msgs: + raise FSWriteLabelError("\n".join(error_msgs)) + + rc = util.run_program(self._setCommand) + if rc: + raise FSWriteLabelError("label failed") + +class DosFSWriteLabel(FSWriteLabel): + ext = availability.DOSFSLABEL_APP + + @property + def args(self): + return [self.fs.device, self.fs.label] + +class Ext2FSWriteLabel(FSWriteLabel): + ext = availability.E2LABEL_APP + + @property + def args(self): + return [self.fs.device, self.fs.label] + +class JFSWriteLabel(FSWriteLabel): + ext = availability.JFSTUNE_APP + + @property + def args(self): + return ["-L", self.fs.label, self.fs.device] + +class NTFSWriteLabel(FSWriteLabel): + ext = availability.NTFSLABEL_APP + + @property + def args(self): + return [self.fs.device, self.fs.label] + +class ReiserFSWriteLabel(FSWriteLabel): + ext = availability.application("reiserfstune") + + @property + def args(self): + return ["-l", self.fs.label, self.fs.device] + +class XFSWriteLabel(FSWriteLabel): + ext = availability.XFSADMIN_APP + + @property + def args(self): + return ["-L", self.fs.label if self.fs.label != "" else "--", self.fs.device] + +class UnimplementedFSWriteLabel(task.UnimplementedTask): + + def __init__(self, an_fs): + """ Initializer. + + :param FS an_fs: a filesystem object + """ + self.fs = an_fs diff --git a/tests/pylint/pylint-false-positives b/tests/pylint/pylint-false-positives index d33c566..c02fff7 100644 --- a/tests/pylint/pylint-false-positives +++ b/tests/pylint/pylint-false-positives @@ -20,6 +20,9 @@ ^blivet/blivet.py:[[:digit:]]+: [E1101(no-member), Blivet.savePassphrase] Instance of 'DeviceTree' has no '_DeviceTree__luksDevs' member$ ^blivet/blivet.py:[[:digit:]]+: [E1101(no-member), Blivet.savePassphrase] Instance of 'DeviceTree' has no '_DeviceTree__passphrases' member$ ^blivet/formats/__init__.py:[[:digit:]]+: [W0201(attribute-defined-outside-init), DeviceFormat._setDevice] Attribute '_device' defined outside __init__$ +^blivet/tasks/.*py:[[:digit:]]+: [W0223(abstract-method), .*] Method 'available' is abstract in class 'Task' but is not overridden$ +^blivet/tasks/.*py:[[:digit:]]+: [W0223(abstract-method), .*] Method 'doTask' is abstract in class 'Task' but is not overridden$ +^blivet/tasks/.*py:[[:digit:]]+: [W0223(abstract-method), .*] Method 'doTask' is abstract in class 'UnimplementedTask' but is not overridden$ ^dm.c: [[:digit:]]+: not running as root returning empty list$ ^tests/devicelibs_test/mdraid_test.py:[[:digit:]]+: [E1003(bad-super-call), ([[:alnum:].]+).__init__] Bad first argument YES given to super()$ ^tests/devicelibs_test/raid_test.py:[[:digit:]]+: [E1120(no-value-for-parameter), [[:alnum:].]+] No value [[:alnum:] ]+ 'member_count' in [[:alnum:] ]+ call$

From: mulhern amulhern@redhat.com

Related: #12

Make use of the availability information in method formattable, controllable, supported, destroyable.

Signed-off-by: mulhern amulhern@redhat.com --- blivet/formats/__init__.py | 16 ++++++++++++++++ blivet/formats/luks.py | 18 ++++++++++++++++++ blivet/formats/lvmpv.py | 14 ++++++++++++++ blivet/formats/mdraid.py | 14 ++++++++++++++ blivet/formats/swap.py | 14 ++++++++++++++ 5 files changed, 76 insertions(+)

diff --git a/blivet/formats/__init__.py b/blivet/formats/__init__.py index ba15c62..4ec93c4 100644 --- a/blivet/formats/__init__.py +++ b/blivet/formats/__init__.py @@ -438,6 +438,12 @@ def _postDestroy(self, **kwargs): self.exists = False self.notifyKernel()

+ @property + def destroyable(self): + """ Do we have the facilities to destroy a format of this type. """ + # assumes wipefs is always available + return True + def setup(self, **kwargs): """ Activate the formatting.

@@ -459,6 +465,16 @@ def setup(self, **kwargs): self._setup(**kwargs) self._postSetup(**kwargs)

+ @property + def controllable(self): + """ Are external utilities available to allow this format to be both + setup and teared down. + + :returns: True if this format can be set up, otherwise False + :rtype: bool + """ + return True + def _preSetup(self, **kwargs): """ Return True if setup should proceed. """ if not self.exists: diff --git a/blivet/formats/luks.py b/blivet/formats/luks.py index 2d1353f..5fd116c 100644 --- a/blivet/formats/luks.py +++ b/blivet/formats/luks.py @@ -29,6 +29,7 @@ from . import DeviceFormat, register_device_format from ..flags import flags from ..i18n import _, N_ +from ..tasks import availability

import logging log = logging.getLogger("blivet") @@ -44,6 +45,7 @@ class LUKS(DeviceFormat): _linuxNative = True # for clearpart _packages = ["cryptsetup"] # required packages _minSize = crypto.LUKS_METADATA_SIZE + _plugin = availability.BLOCKDEV_CRYPTO_PLUGIN

def __init__(self, **kwargs): """ @@ -150,6 +152,18 @@ def hasKey(self): (self._key_file and os.access(self._key_file, os.R_OK)))

@property + def formattable(self): + return super(LUKS, self).formattable and self._plugin.available + + @property + def supported(self): + return super(LUKS, self).supported and self._plugin.available + + @property + def controllable(self): + return super(LUKS, self).controllable and self._plugin.available + + @property def configured(self): """ To be ready we need a key or passphrase and a map name. """ return self.hasKey and self.mapName @@ -203,6 +217,10 @@ def _postCreate(self, **kwargs): self.mapName = "luks-%s" % self.uuid

@property + def destroyable(self): + return self._plugin.available + + @property def keyFile(self): """ Path to key file to be used in /etc/crypttab """ return self._key_file diff --git a/blivet/formats/lvmpv.py b/blivet/formats/lvmpv.py index 3c9e5c0..c834d03 100644 --- a/blivet/formats/lvmpv.py +++ b/blivet/formats/lvmpv.py @@ -27,6 +27,7 @@ from ..storage_log import log_method_call from parted import PARTITION_LVM from ..devicelibs import lvm +from ..tasks import availability from ..i18n import N_ from ..size import Size from . import DeviceFormat, register_device_format @@ -47,6 +48,7 @@ class LVMPhysicalVolume(DeviceFormat): _minSize = lvm.LVM_PE_SIZE * 2 # one for metadata and one for data _packages = ["lvm2"] # required packages _ksMountpoint = "pv." + _plugin = availability.BLOCKDEV_LVM_PLUGIN

def __init__(self, **kwargs): """ @@ -95,6 +97,14 @@ def dict(self): "peStart": self.peStart, "dataAlignment": self.dataAlignment}) return d

+ @property + def formattable(self): + return super(LVMPhysicalVolume, self).formattable and self._plugin.available + + @property + def supported(self): + return super(LVMPhysicalVolume, self).supported and self._plugin.available + def _create(self, **kwargs): log_method_call(self, device=self.device, type=self.type, status=self.status) @@ -122,6 +132,10 @@ def _destroy(self, **kwargs): blockdev.lvm_pvscan(self.device)

@property + def destroyable(self): + return self._plugin.available + + @property def status(self): # XXX hack return (self.exists and self.vgName and diff --git a/blivet/formats/mdraid.py b/blivet/formats/mdraid.py index 1c7a02a..4590393 100644 --- a/blivet/formats/mdraid.py +++ b/blivet/formats/mdraid.py @@ -27,6 +27,7 @@ from . import DeviceFormat, register_device_format from ..flags import flags from ..i18n import N_ +from ..tasks import availability

import logging log = logging.getLogger("blivet") @@ -43,6 +44,7 @@ class MDRaidMember(DeviceFormat): _linuxNative = True # for clearpart _packages = ["mdadm"] # required packages _ksMountpoint = "raid." + _plugin = availability.BLOCKDEV_MDRAID_PLUGIN

def __init__(self, **kwargs): """ @@ -74,10 +76,22 @@ def dict(self): d.update({"mdUUID": self.mdUuid, "biosraid": self.biosraid}) return d

+ @property + def formattable(self): + return super(MDRaidMember, self).formattable and self._plugin.available + + @property + def supported(self): + return super(MDRaidMember, self).supported and self._plugin.available + def _destroy(self, **kwargs): blockdev.md_destroy(self.device)

@property + def destroyable(self): + return self._plugin.available + + @property def status(self): # XXX hack -- we don't have a nice way to see if the array is active return False diff --git a/blivet/formats/swap.py b/blivet/formats/swap.py index 4eab044..4983073 100644 --- a/blivet/formats/swap.py +++ b/blivet/formats/swap.py @@ -22,6 +22,7 @@

from parted import PARTITION_SWAP, fileSystemType from ..storage_log import log_method_call +from ..tasks import availability from . import DeviceFormat, register_device_format from ..size import Size from gi.repository import BlockDev as blockdev @@ -40,6 +41,7 @@ class SwapSpace(DeviceFormat): _formattable = True # can be formatted _supported = True # is supported _linuxNative = True # for clearpart + _plugin = availability.BLOCKDEV_SWAP_PLUGIN

#see rhbz#744129 for details _maxSize = Size("128 GiB") @@ -80,6 +82,18 @@ def dict(self): d.update({"priority": self.priority, "label": self.label}) return d

+ @property + def formattable(self): + return super(SwapSpace, self).formattable and self._plugin.available + + @property + def supported(self): + return super(SwapSpace, self).supported and self._plugin.available + + @property + def controllable(self): + return super(SwapSpace, self).controllable and self._plugin.available + def labeling(self): """Returns True as mkswap can write a label to the swap space.""" return True

From: mulhern amulhern@redhat.com

Related: #12

Signed-off-by: mulhern amulhern@redhat.com --- blivet/deviceaction.py | 11 +++++ tests/devices_test/dependencies_test.py | 86 +++++++++++++++++++++++++++++++++ 2 files changed, 97 insertions(+) create mode 100644 tests/devices_test/dependencies_test.py

diff --git a/blivet/deviceaction.py b/blivet/deviceaction.py index 4d10765..212dee3 100644 --- a/blivet/deviceaction.py +++ b/blivet/deviceaction.py @@ -148,6 +148,11 @@ def __init__(self, device): util.ObjectID.__init__(self) if not isinstance(device, StorageDevice): raise ValueError("arg 1 must be a StorageDevice instance") + + unavailable_dependencies = device.unavailableDependencies + if unavailable_dependencies: + raise ValueError("device type %s requires unavailable_dependencies: %s" % (device.type, ", ".join(str(d) for d in unavailable_dependencies))) + self.device = device self.container = getattr(self.device, "container", None) self._applied = False @@ -516,6 +521,9 @@ def __init__(self, device, fmt=None): if self._format.exists: raise ValueError("specified format already exists")

+ if not fmt.formattable: + raise ValueError("resource to create this format %s is unavailable" % fmt) + def apply(self): """ apply changes related to the action to the device(s) """ if self._applied: @@ -638,6 +646,9 @@ def __init__(self, device): DeviceAction.__init__(self, device) self.origFormat = self.device.format

+ if not device.format.destroyable: + raise ValueError("resource to destroy this format type %s is unavailable" % device.format.type) + def apply(self): if self._applied: return diff --git a/tests/devices_test/dependencies_test.py b/tests/devices_test/dependencies_test.py new file mode 100644 index 0000000..2077216 --- /dev/null +++ b/tests/devices_test/dependencies_test.py @@ -0,0 +1,86 @@ +#!/usr/bin/python +# vim:set fileencoding=utf-8 + +import unittest + +from blivet.deviceaction import ActionCreateDevice +from blivet.deviceaction import ActionDestroyDevice + +from blivet.deviceaction import ActionCreateFormat +from blivet.deviceaction import ActionDestroyFormat + +from blivet.devices import DiskDevice +from blivet.devices import LUKSDevice +from blivet.devices import MDRaidArrayDevice +from blivet.devices import PartitionDevice + +from blivet.formats import getFormat + +from blivet.tasks import availability + +class FalseMethod(availability.Method): + def available(self, resource): + return False + +class TrueMethod(availability.Method): + def available(self, resource): + return True + +class DeviceDependenciesTestCase(unittest.TestCase): + """Test external device dependencies. """ + + def testDependencies(self): + dev1 = DiskDevice("name", fmt=getFormat("mdmember")) + dev2 = DiskDevice("other", fmt=getFormat("mdmember")) + dev = MDRaidArrayDevice("dev", level="raid1", parents=[dev1,dev2]) + luks = LUKSDevice("luks", parents=[dev]) + + # a parent's dependencies are a subset of its child's. + for d in dev.externalDependencies: + self.assertIn(d, luks.externalDependencies) + + # make sure that there's at least something in these dependencies + self.assertTrue(len(luks.externalDependencies) > 0) + +class MockingDeviceDependenciesTestCase(unittest.TestCase): + """Test availability of external device dependencies. """ + + def setUp(self): + dev1 = DiskDevice("name", fmt=getFormat("mdmember")) + dev2 = DiskDevice("other") + self.part = PartitionDevice("part", fmt=getFormat("mdmember"), parents=[dev2]) + self.dev = MDRaidArrayDevice("dev", level="raid1", parents=[dev1, self.part], fmt=getFormat("luks")) + self.luks = LUKSDevice("luks", parents=[self.dev], fmt=getFormat("ext4")) + + self.mdraid_method = availability.BLOCKDEV_MDRAID_PLUGIN._method + + def testAvailabilityMDRAIDplugin(self): + + # if the plugin is not in, there's nothing to test + self.assertIn(availability.BLOCKDEV_MDRAID_PLUGIN, self.luks.externalDependencies) + + # dev is not among its unavailable dependencies + availability.BLOCKDEV_MDRAID_PLUGIN._method = TrueMethod() + self.assertNotIn(availability.BLOCKDEV_MDRAID_PLUGIN, self.luks.unavailableDependencies) + self.assertIsNotNone(ActionCreateDevice(self.luks)) + self.assertIsNotNone(ActionDestroyDevice(self.luks)) + self.assertIsNotNone(ActionCreateFormat(self.luks, fmt=getFormat("macefi"))) + self.assertIsNotNone(ActionDestroyFormat(self.luks)) + + # dev is among the unavailable dependencies + availability.BLOCKDEV_MDRAID_PLUGIN._method = FalseMethod() + self.assertIn(availability.BLOCKDEV_MDRAID_PLUGIN, self.luks.unavailableDependencies) + with self.assertRaises(ValueError): + ActionCreateDevice(self.luks) + with self.assertRaises(ValueError): + ActionDestroyDevice(self.dev) + with self.assertRaises(ValueError): + ActionCreateFormat(self.dev) + with self.assertRaises(ValueError): + ActionDestroyFormat(self.dev) + + def tearDown(self): + availability.BLOCKDEV_MDRAID_PLUGIN._method = self.mdraid_method + +if __name__ == "__main__": + unittest.main()

From: mulhern amulhern@redhat.com

Related: #12

All plugin are no longer required, but libblockdev is, to run the plugins. dosfstools is no longer required. e2fsprogs remains because it is blivet's default filesystem type.

Signed-off-by: mulhern amulhern@redhat.com --- python-blivet.spec | 4 ---- 1 file changed, 4 deletions(-)

diff --git a/python-blivet.spec b/python-blivet.spec index 73d981b..605bae0 100644 --- a/python-blivet.spec +++ b/python-blivet.spec @@ -34,12 +34,10 @@ Requires: util-linux >= %{utillinuxver} Requires: python-pyudev Requires: parted >= %{partedver} Requires: pyparted >= %{pypartedver} -Requires: dosfstools Requires: e2fsprogs >= %{e2fsver} Requires: lsof Requires: libselinux-python Requires: libblockdev >= %{libblockdevver} -Requires: libblockdev-plugins-all >= %{libblockdevver} Requires: libselinux-python Requires: rpm

@@ -58,9 +56,7 @@ Requires: parted >= %{partedver} Requires: python3-pyparted >= %{pypartedver} Requires: libselinux-python3 Requires: libblockdev >= %{libblockdevver} -Requires: libblockdev-plugins-all >= %{libblockdevver} Requires: util-linux >= %{utillinuxver} -Requires: dosfstools Requires: e2fsprogs >= %{e2fsver} Requires: lsof

From: mulhern amulhern@redhat.com

Related: #12

Check if the filesystem has resizing abilities instead.

Signed-off-by: mulhern amulhern@redhat.com --- tests/formats_test/fs_test.py | 14 ------------ tests/formats_test/fstesting.py | 49 +++++++++++++++++++++-------------------- 2 files changed, 25 insertions(+), 38 deletions(-)

diff --git a/tests/formats_test/fs_test.py b/tests/formats_test/fs_test.py index 2b22de3..71fa524 100755 --- a/tests/formats_test/fs_test.py +++ b/tests/formats_test/fs_test.py @@ -12,7 +12,6 @@

class Ext2FSTestCase(fstesting.FSAsRoot): _fs_class = fs.Ext2FS - _resizable = True

class Ext3FSTestCase(Ext2FSTestCase): _fs_class = fs.Ext3FS @@ -22,42 +21,34 @@ class Ext4FSTestCase(Ext3FSTestCase):

class FATFSTestCase(fstesting.FSAsRoot): _fs_class = fs.FATFS - _resizable = False

class EFIFSTestCase(FATFSTestCase): _fs_class = fs.EFIFS

class BTRFSTestCase(fstesting.FSAsRoot): _fs_class = fs.BTRFS - _resizable = False

@unittest.skip("Unable to create GFS2 filesystem.") class GFS2TestCase(fstesting.FSAsRoot): _fs_class = fs.GFS2 - _resizable = False

class JFSTestCase(fstesting.FSAsRoot): _fs_class = fs.JFS - _resizable = False

class ReiserFSTestCase(fstesting.FSAsRoot): _fs_class = fs.ReiserFS - _resizable = False

class XFSTestCase(fstesting.FSAsRoot): _fs_class = fs.XFS - _resizable = False

class HFSTestCase(fstesting.FSAsRoot): _fs_class = fs.HFS - _resizable = False

class AppleBootstrapFSTestCase(HFSTestCase): _fs_class = fs.AppleBootstrapFS

class HFSPlusTestCase(fstesting.FSAsRoot): _fs_class = fs.HFSPlus - _resizable = False

class MacEFIFSTestCase(HFSPlusTestCase): _fs_class = fs.MacEFIFS @@ -65,24 +56,20 @@ class MacEFIFSTestCase(HFSPlusTestCase): @unittest.skip("Unable to create because NTFS._formattable is False.") class NTFSTestCase(fstesting.FSAsRoot): _fs_class = fs.NTFS - _resizable = True

@unittest.skip("Unable to create because device fails deviceCheck().") class NFSTestCase(fstesting.FSAsRoot): _fs_class = fs.NFS - _resizable = False

class NFSv4TestCase(NFSTestCase): _fs_class = fs.NFSv4

class Iso9660FS(fstesting.FSAsRoot): _fs_class = fs.Iso9660FS - _resizable = False

@unittest.skip("Too strange to test using this framework.") class NoDevFSTestCase(fstesting.FSAsRoot): _fs_class = fs.NoDevFS - _resizable = False

class DevPtsFSTestCase(NoDevFSTestCase): _fs_class = fs.DevPtsFS @@ -104,7 +91,6 @@ class USBFSTestCase(NoDevFSTestCase):

class BindFSTestCase(fstesting.FSAsRoot): _fs_class = fs.BindFS - _resizable = False

class SimpleTmpFSTestCase(loopbackedtestcase.LoopBackedTestCase):

diff --git a/tests/formats_test/fstesting.py b/tests/formats_test/fstesting.py index 25646da..eb527f5 100644 --- a/tests/formats_test/fstesting.py +++ b/tests/formats_test/fstesting.py @@ -11,15 +11,21 @@ from blivet.size import Size, ROUND_DOWN from blivet.formats import fs

+def can_resize(an_fs): + """ Returns True if this filesystem has all necessary resizing tools + available. + + :param an_fs: a filesystem object + """ + resize_tasks = (an_fs._resize, an_fs._sizeinfo, an_fs._minsize) + return all(not t.availabilityErrors for t in resize_tasks) + @add_metaclass(abc.ABCMeta) class FSAsRoot(loopbackedtestcase.LoopBackedTestCase):

_fs_class = abc.abstractproperty( doc="The class of the filesystem being tested on.")

- _resizable = abc.abstractproperty( - doc="Should we expect to be able to resize this filesystem.") - _DEVICE_SIZE = Size("100 MiB")

def __init__(self, methodName='runTest'): @@ -83,7 +89,7 @@ def testInstantiation(self): self.assertEqual(an_fs.resizable, False)

# sizes - expected_min_size = Size(0) if self._resizable else an_fs._minSize + expected_min_size = Size(0) if can_resize(an_fs) else an_fs._minSize self.assertEqual(an_fs.minSize, expected_min_size)

self.assertEqual(an_fs.maxSize, an_fs._maxSize) @@ -97,7 +103,7 @@ def testInstantiation(self): an_fs = self._fs_class(size=NEW_SIZE)

# sizes - expected_min_size = Size(0) if self._resizable else an_fs._minSize + expected_min_size = Size(0) if can_resize(an_fs) else an_fs._minSize self.assertEqual(an_fs.minSize, expected_min_size)

self.assertEqual(an_fs.maxSize, an_fs._maxSize) @@ -116,7 +122,7 @@ def testCreation(self): self.assertTrue(an_fs.exists) self.assertIsNone(an_fs.doCheck())

- expected_min_size = Size(0) if self._resizable else an_fs._minSize + expected_min_size = Size(0) if can_resize(an_fs) else an_fs._minSize self.assertEqual(an_fs.minSize, expected_min_size)

self.assertEqual(an_fs.maxSize, an_fs._maxSize) @@ -192,7 +198,7 @@ def testResize(self): # CHECKME: target size is still 0 after updatedSizeInfo is called. self.assertEqual(an_fs.size, Size(0) if an_fs.resizable else an_fs._size)

- if not self._resizable: + if not can_resize(an_fs): self.assertFalse(an_fs.resizable) # Not resizable, so can not do resizing actions. with self.assertRaises(FSError): @@ -221,10 +227,10 @@ def testNoExplicitTargetSize(self): # _size if it is not set when size is calculated. Note that _targetSize # gets value of _size in constructor, so if _size is set to not-zero # in constructor call behavior would be different. - if not self._resizable: - self.skipTest("Not checking resize for this test category.")

an_fs = self._fs_class() + if not can_resize(an_fs): + self.skipTest("Not checking resize for this test category.") if not an_fs.formattable: self.skipTest("can not create filesystem %s" % an_fs.name)

@@ -244,11 +250,10 @@ def testNoExplicitTargetSize2(self): """ Because _targetSize has been set to size in constructor the resize action resizes filesystem to that size. """ - if not self._resizable: - self.skipTest("Not checking resize for this test category.") - SIZE = Size("64 MiB") an_fs = self._fs_class(size=SIZE) + if not can_resize(an_fs): + self.skipTest("Not checking resize for this test category.") if not an_fs.formattable: self.skipTest("can not create filesystem %s" % an_fs.name)

@@ -266,10 +271,9 @@ def testNoExplicitTargetSize2(self): self._test_sizes(an_fs)

def testShrink(self): - if not self._resizable: - self.skipTest("Not checking resize for this test category.") - an_fs = self._fs_class() + if not can_resize(an_fs): + self.skipTest("Not checking resize for this test category.") if not an_fs.formattable: self.skipTest("can not create filesystem %s" % an_fs.name)

@@ -299,10 +303,9 @@ def testShrink(self): self._test_sizes(an_fs)

def testTooSmall(self): - if not self._resizable: - self.skipTest("Not checking resize for this test category.") - an_fs = self._fs_class() + if not can_resize(an_fs): + self.skipTest("Not checking resize for this test category.") if not an_fs.formattable: self.skipTest("can not create or resize filesystem %s" % an_fs.name)

@@ -319,10 +322,9 @@ def testTooSmall(self): self._test_sizes(an_fs)

def testTooBig(self): - if not self._resizable: - self.skipTest("Not checking resize for this test category.") - an_fs = self._fs_class() + if not can_resize(an_fs): + self.skipTest("Not checking resize for this test category.") if not an_fs.formattable: self.skipTest("can not create filesystem %s" % an_fs.name)

@@ -339,10 +341,9 @@ def testTooBig(self): self._test_sizes(an_fs)

def testTooBig2(self): - if not self._resizable: - self.skipTest("Not checking resize for this test category.") - an_fs = self._fs_class() + if not can_resize(an_fs): + self.skipTest("Not checking resize for this test category.") if not an_fs.formattable: self.skipTest("can not create filesystem %s" % an_fs.name)

From: mulhern amulhern@redhat.com

Related: #12

Signed-off-by: mulhern amulhern@redhat.com --- tests/formats_test/selinux_test.py | 8 ++++++++ 1 file changed, 8 insertions(+)

diff --git a/tests/formats_test/selinux_test.py b/tests/formats_test/selinux_test.py index 516e07f..b5c62eb 100755 --- a/tests/formats_test/selinux_test.py +++ b/tests/formats_test/selinux_test.py @@ -28,6 +28,10 @@ def testMountingExt2FS(self): """ LOST_AND_FOUND_CONTEXT = 'system_u:object_r:lost_found_t:s0' an_fs = fs.Ext2FS(device=self.loopDevices[0], label="test") + + if not an_fs.formattable or not an_fs.mountable: + self.skipTest("can not create or mount filesystem %s" % an_fs.name) + self.assertIsNone(an_fs.create())

blivet.flags.installer_mode = False @@ -61,6 +65,10 @@ def testMountingExt2FS(self): def testMountingXFS(self): """ XFS does not have a lost+found directory. """ an_fs = fs.XFS(device=self.loopDevices[0], label="test") + + if not an_fs.formattable or not an_fs.mountable: + self.skipTest("can not create or mount filesystem %s" % an_fs.name) + self.assertIsNone(an_fs.create())

blivet.flags.installer_mode = False