storage/formats/mdraid.py

# mdraid.py
# Device format classes for anaconda's storage configuration module.
#
# Copyright (C) 2009  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>
#

import os

from ..storage_log import log_method_call
from flags import flags
from parted import PARTITION_RAID
from ..errors import *
from ..devicelibs import mdraid
from . import DeviceFormat, register_device_format

import gettext
_ = lambda x: gettext.ldgettext("anaconda", x)

import logging
log = logging.getLogger("storage")


class MDRaidMember(DeviceFormat):
    """ An mdraid member disk. """
    _type = "mdmember"
    _name = "software RAID"
    _udevTypes = ["linux_raid_member"]
    partedFlag = PARTITION_RAID
    _formattable = True                 # can be formatted
    _supported = True                   # is supported
    _linuxNative = True                 # for clearpart
    _packages = ["mdadm"]               # required packages
    
    def __init__(self, *args, **kwargs):
        """ Create a MDRaidMember instance.

            Keyword Arguments:

                device -- path to underlying device
                uuid -- this member device's uuid
                mdUuid -- the uuid of the array this device belongs to
                exists -- indicates whether this is an existing format

        """
        log_method_call(self, *args, **kwargs)
        DeviceFormat.__init__(self, *args, **kwargs)
        self.mdUuid = kwargs.get("mdUuid")
        self.raidMinor = None

        #self.probe()
        self.biosraid = kwargs.get("biosraid")

    def __str__(self):
        s = DeviceFormat.__str__(self)
        s += ("  mdUUID = %(mdUUID)s  biosraid = %(biosraid)s" %
              {"mdUUID": self.mdUuid, "biosraid": self.biosraid})
        return s

    @property
    def dict(self):
        d = super(MDRaidMember, self).dict
        d.update({"mdUUID": self.mdUuid, "biosraid": self.biosraid})
        return d

    def probe(self):
        """ Probe for any missing information about this format. """
        log_method_call(self, device=self.device,
                        type=self.type, status=self.status)
        if not self.exists:
            raise MDMemberError("format does not exist")

        info = mdraid.mdexamine(self.device)
        if self.uuid is None:
            self.uuid = info['uuid']
        if self.raidMinor is None:
            self.raidMinor = info['mdMinor']

    def destroy(self, *args, **kwargs):
        if not self.exists:
            raise MDMemberError("format does not exist")

        if not os.access(self.device, os.W_OK):
            raise MDMemberError("device path does not exist")

        mdraid.mddestroy(self.device)
        self.exists = False

    @property
    def status(self):
        # XXX hack -- we don't have a nice way to see if the array is active
        return False

    @property
    def hidden(self):
        return (self._hidden or self.biosraid)

    def writeKS(self, f):
        f.write("raid.%s" % self.majorminor)

# nodmraid -> Wether to use BIOS RAID or not
# Note the anaconda cmdline has not been parsed yet when we're first imported,
# so we can not use flags.dmraid here
if not flags.cmdline.has_key("noiswmd") and \
   not flags.cmdline.has_key("nodmraid"):
    MDRaidMember._udevTypes.append("isw_raid_member")

register_device_format(MDRaidMember)

1	charliebrady	1.1	# mdraid.py
2			# Device format classes for anaconda's storage configuration module.
3			#
4			# Copyright (C) 2009 Red Hat, Inc.
5			#
6			# This copyrighted material is made available to anyone wishing to use,
7			# modify, copy, or redistribute it subject to the terms and conditions of
8			# the GNU General Public License v.2, or (at your option) any later version.
9			# This program is distributed in the hope that it will be useful, but WITHOUT
10			# ANY WARRANTY expressed or implied, including the implied warranties of
11			# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General
12			# Public License for more details. You should have received a copy of the
13			# GNU General Public License along with this program; if not, write to the
14			# Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
15			# 02110-1301, USA. Any Red Hat trademarks that are incorporated in the
16			# source code or documentation are not subject to the GNU General Public
17			# License and may only be used or replicated with the express permission of
18			# Red Hat, Inc.
19			#
20			# Red Hat Author(s): Dave Lehman <dlehman@redhat.com>
21			#
22
23			import os
24
25			from ..storage_log import log_method_call
26			from flags import flags
27			from parted import PARTITION_RAID
28			from ..errors import *
29			from ..devicelibs import mdraid
30			from . import DeviceFormat, register_device_format
31
32			import gettext
33			_ = lambda x: gettext.ldgettext("anaconda", x)
34
35			import logging
36			log = logging.getLogger("storage")
37
38
39			class MDRaidMember(DeviceFormat):
40			""" An mdraid member disk. """
41			_type = "mdmember"
42			_name = "software RAID"
43			_udevTypes = ["linux_raid_member"]
44			partedFlag = PARTITION_RAID
45			_formattable = True # can be formatted
46			_supported = True # is supported
47			_linuxNative = True # for clearpart
48			_packages = ["mdadm"] # required packages
49
50			def __init__(self, args, *kwargs):
51			""" Create a MDRaidMember instance.
52
53			Keyword Arguments:
54
55			device -- path to underlying device
56			uuid -- this member device's uuid
57			mdUuid -- the uuid of the array this device belongs to
58			exists -- indicates whether this is an existing format
59
60			"""
61			log_method_call(self, args, *kwargs)
62			DeviceFormat.__init__(self, args, *kwargs)
63			self.mdUuid = kwargs.get("mdUuid")
64			self.raidMinor = None
65
66			#self.probe()
67			self.biosraid = kwargs.get("biosraid")
68
69			def __str__(self):
70			s = DeviceFormat.__str__(self)
71			s += (" mdUUID = %(mdUUID)s biosraid = %(biosraid)s" %
72			{"mdUUID": self.mdUuid, "biosraid": self.biosraid})
73			return s
74
75			@property
76			def dict(self):
77			d = super(MDRaidMember, self).dict
78			d.update({"mdUUID": self.mdUuid, "biosraid": self.biosraid})
79			return d
80
81			def probe(self):
82			""" Probe for any missing information about this format. """
83			log_method_call(self, device=self.device,
84			type=self.type, status=self.status)
85			if not self.exists:
86			raise MDMemberError("format does not exist")
87
88			info = mdraid.mdexamine(self.device)
89			if self.uuid is None:
90			self.uuid = info['uuid']
91			if self.raidMinor is None:
92			self.raidMinor = info['mdMinor']
93
94			def destroy(self, args, *kwargs):
95			if not self.exists:
96			raise MDMemberError("format does not exist")
97
98			if not os.access(self.device, os.W_OK):
99			raise MDMemberError("device path does not exist")
100
101			mdraid.mddestroy(self.device)
102			self.exists = False
103
104			@property
105			def status(self):
106			# XXX hack -- we don't have a nice way to see if the array is active
107			return False
108
109			@property
110			def hidden(self):
111			return (self._hidden or self.biosraid)
112
113			def writeKS(self, f):
114			f.write("raid.%s" % self.majorminor)
115
116			# nodmraid -> Wether to use BIOS RAID or not
117			# Note the anaconda cmdline has not been parsed yet when we're first imported,
118			# so we can not use flags.dmraid here
119			if not flags.cmdline.has_key("noiswmd") and \
120			not flags.cmdline.has_key("nodmraid"):
121			MDRaidMember._udevTypes.append("isw_raid_member")
122
123			register_device_format(MDRaidMember)
124