product/installclasses/smeinstallclass.py

from installclass import BaseInstallClass
from rhpl.translate import N_, _
from constants import *
import os
import iutil
from fsset import *

from autopart import getAutopartitionBoot, autoCreatePartitionRequests, autoCreateLVMPartitionRequests
from rhpl.log import log
import string
import partRequests
import partedUtils

class Script:
    def __repr__(self):
        str = ("(s: '%s' i: %s c: %d)") %  \
            (self.script, self.interp, self.inChroot)
        return string.replace(str, "\n", "|")

    def __init__(self, script, interp, inChroot, logfile = None):
        self.script = script
        self.interp = interp
        self.inChroot = inChroot
        self.logfile = logfile

    def run(self, chroot, serial):
        scriptRoot = "/"
        if self.inChroot:
            scriptRoot = chroot

        path = scriptRoot + "/tmp/sme-script"

        f = open(path, "w")
        f.write(self.script)
        f.close()
        os.chmod(path, 0700)

        if self.logfile is not None:
            messages = self.logfile
        elif serial:
            messages = "/tmp/sme-script.log"
        else:
            messages = "/dev/tty3"

        rc = iutil.execWithRedirect(self.interp,
                                    [self.interp,"/tmp/sme-script"],
                                    stdout = messages, stderr = messages,
                                    root = scriptRoot)

        if rc != 0:
            log("WARNING - Error code %s encountered running a sme script", rc)

        os.unlink(path)

class InstallClass(BaseInstallClass):
    id = "smeserver"
    name = N_("New _SME Server Install")
    pixmap = "smeserver.png"
    description = N_("This option performs a new install of "
                     "SME Server.  All attached hard drives "
                     "will be repartitioned and formated.")
    sortPriority = 1

    parentClass = ( _("Install SME Server"), "smeserver.png" )

    def requiredDisplayMode(self):
        return 't'

    def setSteps(self, dispatch):
        dispatch.setStepList(
                 "language",
                 "keyboard",
                 "findrootparts",
                 "findinstall",
                 "installtype",
                 "partitionobjinit",
                 "autopartitionexecute",
                 "partition",
                 "partitiondone",
                 "bootloadersetup",
                 "languagesupport",
                 "timezone",
                 "readcomps",
                 "selectlangpackages",
                 "checkdeps",
                 "dependencies",
                 "install",
                 "enablefilesystems",
                 "migratefilesystems",
                 "setuptime",
                 "preinstallconfig",
                 "installpackages",
                 "postinstallconfig",
                 "writeconfig",
                 "instbootloader",
                 "dopostaction",
                 "methodcomplete",
                 "copylogs",
                 "writeksconfig",
                 "setfilecon",
                 "complete"
                )

        # 'partition' can be used on the command line to force 
        # verification of partitions.  useful in some cases...
        cmdline = open("/proc/cmdline", "r").read()
        cmdline = cmdline.split()
        if "partition" in cmdline:
            dispatch.skipStep("partition", skip = 0)
        else:
            dispatch.skipStep("partition", skip = 1)

    def setDefaultPartitioning(self, partitions, clear = CLEARPART_TYPE_LINUX, doClear = 1):
        uniqueID = 100
        (swapMin, swapMax) = iutil.swapSuggestion()
        diskset = partedUtils.DiskSet()
        drives = diskset.driveList()

        spares = 0
        useable = 0
        for drive in drives:
            if not isys.driveIsRemovable(drive):
                useable = useable + 1

        if useable > 0:
            if "noraid" in cmdline:
                for drive in drives:
                    if not isys.driveIsRemovable(drive):
                        filesystem = fileSystemTypeGet("ext3")
                        request = partRequests.PartitionSpec(filesystem, mountpoint="/boot", drive=[drive],
                                size=100, primary=1, format=1)
                        partitions.autoPartitionRequests.append(request)

                        if "nolvm" in cmdline:
                            filesystem = fileSystemTypeGet("ext3")
                            request = partRequests.PartitionSpec(filesystem, mountpoint="/", drive=[drive],
                                    size=1300, grow=1, primary=1, format=1)
                            partitions.autoPartitionRequests.append(request)

                            filesystem = fileSystemTypeGet("swap")
                            request = partRequests.PartitionSpec(filesystem, drive=[drive], size=swapMin, 
                                    maxSizeMB=swapMax, grow=1, primary=1, format=1)
                            partitions.autoPartitionRequests.append(request)

                        else:
                            filesystem = fileSystemTypeGet("physical volume (LVM)")
                            request = partRequests.PartitionSpec(filesystem, drive=[drive], size=swapMin+1500,
                                    grow=1, primary=1, format=1)
                            request.uniqueID = 200
                            partitions.autoPartitionRequests.append(request)

                        break

            else:
                raid1 = []
                raid2 = []
                raid3 = []

                if "raid1" in cmdline and useable > 0:
                    if useable > 2 and "spare" in cmdline:
                        spares = 1
                    useable = 1
                    raidLevel = "RAID1"

                else:
                    if useable > 2 and "spare" in cmdline:
                        useable = useable - 1
                        spares = 1

                    if useable > 5:
                        useable = useable - 2
                        raidLevel = "RAID6"
                    elif useable > 1:
                        useable = useable - 1
                        if useable > 2:
                            raidLevel = "RAID5"
                        else:
                            raidLevel = "RAID1"

                for drive in drives:
                    if not isys.driveIsRemovable(drive):
                        filesystem = fileSystemTypeGet("software RAID")
                        request = partRequests.PartitionSpec(filesystem, drive=[drive], size=100, primary=1, format=1)
                        request.uniqueID = uniqueID
                        raid1.append(uniqueID)
                        partitions.autoPartitionRequests.append(request)

                        if "nolvm" in cmdline:
                            filesystem = fileSystemTypeGet("software RAID")
                            request = partRequests.PartitionSpec(filesystem, drive=[drive], size=1500/useable,
                                    grow=1, primary=1, format=1)
                            request.uniqueID = uniqueID + 30
                            raid2.append(uniqueID + 30)
                            partitions.autoPartitionRequests.append(request)

                            filesystem = fileSystemTypeGet("software RAID")
                            request = partRequests.PartitionSpec(filesystem, drive=[drive], size=swapMin/useable+10,
                                    maxSizeMB=swapMax/useable, grow=1, primary=1, format=1)
                            request.uniqueID = uniqueID + 60
                            raid3.append(uniqueID + 60)
                            partitions.autoPartitionRequests.append(request)

                        else:
                            filesystem = fileSystemTypeGet("software RAID")
                            request = partRequests.PartitionSpec(filesystem, drive=[drive], size=(swapMin+1500)/useable,
                                    grow=1, format=1)
                            request.uniqueID = uniqueID + 50
                            raid2.append(uniqueID + 50)
                            partitions.autoPartitionRequests.append(request)

                        uniqueID = uniqueID + 1

                        if "raid1" in cmdline and len(raid1)-spares > 1:
                            break

                filesystem = fileSystemTypeGet("ext3")
                request = partRequests.RaidRequestSpec(filesystem, mountpoint="/boot", raidminor=1,
                        raidmembers=raid1, raidlevel="RAID1", format=1, raidspares=spares)
                partitions.autoPartitionRequests.append(request)

                if "nolvm" in cmdline:
                    filesystem = fileSystemTypeGet("ext3")
                    request = partRequests.RaidRequestSpec(filesystem, mountpoint="/", raidmembers=raid2,  raidminor=2,
                            raidlevel=raidLevel, format=1, raidspares=spares)
                    partitions.autoPartitionRequests.append(request)

                    filesystem = fileSystemTypeGet("swap")
                    request = partRequests.RaidRequestSpec(filesystem, raidmembers=raid3,  raidminor=3,
                            raidlevel=raidLevel, format=1, raidspares=spares)
                    partitions.autoPartitionRequests.append(request)

                else:
                    filesystem = fileSystemTypeGet("physical volume (LVM)")
                    request = partRequests.RaidRequestSpec(filesystem, raidmembers=raid2,  raidminor=2,
                            raidlevel=raidLevel, format=1, raidspares=spares)
                    request.uniqueID = 200
                    partitions.autoPartitionRequests.append(request)

            if not "nolvm" in cmdline:
                request = partRequests.VolumeGroupRequestSpec(vgname="main", physvols=[200], 
                        pesize=32768, format=1)
                request.uniqueID = 201
                partitions.autoPartitionRequests.append(request)

                filesystem = fileSystemTypeGet("ext3")
                request = partRequests.LogicalVolumeRequestSpec(filesystem, mountpoint="/", size=1300, 
                        volgroup=201, lvname="root", grow=1, format=1)
                partitions.autoPartitionRequests.append(request)

                filesystem = fileSystemTypeGet("swap")
                request = partRequests.LogicalVolumeRequestSpec(filesystem, size=swapMin, maxSizeMB=swapMax, 
                        volgroup=201, lvname="swap", grow=1, format=1)
                partitions.autoPartitionRequests.append(request)
        else:
            dispatch.skipStep("partition", skip = 0)
            BaseInstallClass.setDefaultPartitioning(self, partitions, clear, doClear)

    def setAsHeadless(self, dispatch, isHeadless = 0):
        if isHeadless == 0:
            pass
        else:
#           dispatch.skipStep("keyboard", permanent = 1)
#           dispatch.skipStep("mouse", permanent = 1)
            dispatch.skipStep("handleX11pkgs", permanent = 1)
            dispatch.skipStep("videocard", permanent = 1)
            dispatch.skipStep("monitor", permanent = 1)
            dispatch.skipStep("xcustom", permanent = 1)
            dispatch.skipStep("writexconfig", permanent = 1)

    def setGroupSelection(self, grpset, intf):
        grpset.unselectAll()
        grpset.selectGroup("Base")

    def postAction(self, rootPath, serial, intf):
        win = intf.waitWindow(_("Post Install Script"),
           _("The post installation script is running..."))

        script = ( "/sbin/syslogd &\n"
                   "sleep 2\n"
                   "/sbin/e-smith/signal-event post-install\n" )
        s = Script(script, interp="/bin/sh", inChroot=1)
        log("%s", s)
        s.run(rootPath, serial)
        win.pop()

    def setInstallData(self, id, intf = None):
        BaseInstallClass.setInstallData(self, id)
        self.setAuthentication(id, useShadow=1, useMd5=1)
        self.setRootPassword(id, pw="ThisIsGoingToBeDisabledAnyway", isCrypted=0)
        self.setZeroMbr(id, zeroMbr=1)
        self.setClearParts(id, clear=CLEARPART_TYPE_ALL, initAll=1)
        self.setDefaultPartitioning(id.partitions, doClear=0)
        self.setBootloader(id, useLilo=0, location="mbr", linear=1)

    def __init__(self, expert):
        BaseInstallClass.__init__(self, expert)
1	slords	1.1	from installclass import BaseInstallClass
2	slords	1.13	from rhpl.translate import N_, _
3	slords	1.12	from constants import *
4			import os
5			import iutil
6	slords	1.13	from fsset import *
7	slords	1.12
8	slords	1.1	from autopart import getAutopartitionBoot, autoCreatePartitionRequests, autoCreateLVMPartitionRequests
9			from rhpl.log import log
10	slords	1.2	import string
11	slords	1.1	import partRequests
12			import partedUtils
13
14	slords	1.2	class Script:
15			def __repr__(self):
16			str = ("(s: '%s' i: %s c: %d)") % \
17			(self.script, self.interp, self.inChroot)
18			return string.replace(str, "\n", "\|")
19
20			def __init__(self, script, interp, inChroot, logfile = None):
21			self.script = script
22			self.interp = interp
23			self.inChroot = inChroot
24			self.logfile = logfile
25
26			def run(self, chroot, serial):
27			scriptRoot = "/"
28			if self.inChroot:
29			scriptRoot = chroot
30
31			path = scriptRoot + "/tmp/sme-script"
32
33			f = open(path, "w")
34			f.write(self.script)
35			f.close()
36			os.chmod(path, 0700)
37
38			if self.logfile is not None:
39			messages = self.logfile
40			elif serial:
41			messages = "/tmp/sme-script.log"
42			else:
43			messages = "/dev/tty3"
44
45			rc = iutil.execWithRedirect(self.interp,
46			[self.interp,"/tmp/sme-script"],
47			stdout = messages, stderr = messages,
48			root = scriptRoot)
49
50			if rc != 0:
51			log("WARNING - Error code %s encountered running a sme script", rc)
52
53			os.unlink(path)
54
55	slords	1.1	class InstallClass(BaseInstallClass):
56	slords	1.2	id = "smeserver"
57			name = N_("New _SME Server Install")
58			pixmap = "smeserver.png"
59	slords	1.3	description = N_("This option performs a new install of "
60			"SME Server. All attached hard drives "
61			"will be repartitioned and formated.")
62	slords	1.1	sortPriority = 1
63
64	slords	1.2	parentClass = ( _("Install SME Server"), "smeserver.png" )
65	slords	1.1
66			def requiredDisplayMode(self):
67			return 't'
68
69			def setSteps(self, dispatch):
70			dispatch.setStepList(
71			"language",
72			"keyboard",
73			"findrootparts",
74	slords	1.4	"findinstall",
75			"installtype",
76	slords	1.1	"partitionobjinit",
77			"autopartitionexecute",
78	slords	1.2	"partition",
79	slords	1.1	"partitiondone",
80			"bootloadersetup",
81	slords	1.7	"languagesupport",
82	slords	1.1	"timezone",
83			"readcomps",
84			"selectlangpackages",
85			"checkdeps",
86			"dependencies",
87			"install",
88			"enablefilesystems",
89			"migratefilesystems",
90			"setuptime",
91			"preinstallconfig",
92			"installpackages",
93			"postinstallconfig",
94			"writeconfig",
95			"instbootloader",
96			"dopostaction",
97			"methodcomplete",
98			"copylogs",
99	slords	1.11	"writeksconfig",
100	slords	1.1	"setfilecon",
101			"complete"
102			)
103
104	slords	1.2	# 'partition' can be used on the command line to force
105			# verification of partitions. useful in some cases...
106			cmdline = open("/proc/cmdline", "r").read()
107			cmdline = cmdline.split()
108			if "partition" in cmdline:
109			dispatch.skipStep("partition", skip = 0)
110			else:
111			dispatch.skipStep("partition", skip = 1)
112
113	slords	1.1	def setDefaultPartitioning(self, partitions, clear = CLEARPART_TYPE_LINUX, doClear = 1):
114	slords	1.15	uniqueID = 100
115	slords	1.16	(swapMin, swapMax) = iutil.swapSuggestion()
116			diskset = partedUtils.DiskSet()
117			drives = diskset.driveList()
118
119	slords	1.18	spares = 0
120			useable = 0
121			for drive in drives:
122			if not isys.driveIsRemovable(drive):
123			useable = useable + 1
124
125			if useable > 0:
126			if "noraid" in cmdline:
127			for drive in drives:
128			if not isys.driveIsRemovable(drive):
129	slords	1.16	filesystem = fileSystemTypeGet("ext3")
130	slords	1.18	request = partRequests.PartitionSpec(filesystem, mountpoint="/boot", drive=[drive],
131			size=100, primary=1, format=1)
132	slords	1.16	partitions.autoPartitionRequests.append(request)
133
134	slords	1.18	if "nolvm" in cmdline:
135			filesystem = fileSystemTypeGet("ext3")
136			request = partRequests.PartitionSpec(filesystem, mountpoint="/", drive=[drive],
137			size=1300, grow=1, primary=1, format=1)
138			partitions.autoPartitionRequests.append(request)
139
140			filesystem = fileSystemTypeGet("swap")
141			request = partRequests.PartitionSpec(filesystem, drive=[drive], size=swapMin,
142			maxSizeMB=swapMax, grow=1, primary=1, format=1)
143			partitions.autoPartitionRequests.append(request)
144
145			else:
146			filesystem = fileSystemTypeGet("physical volume (LVM)")
147			request = partRequests.PartitionSpec(filesystem, drive=[drive], size=swapMin+1500,
148			grow=1, primary=1, format=1)
149			request.uniqueID = 200
150			partitions.autoPartitionRequests.append(request)
151	slords	1.16
152	slords	1.18	break
153	slords	1.16
154	slords	1.18	else:
155			raid1 = []
156			raid2 = []
157			raid3 = []
158
159			if "raid1" in cmdline and useable > 0:
160			if useable > 2 and "spare" in cmdline:
161			spares = 1
162			useable = 1
163			raidLevel = "RAID1"
164
165			else:
166			if useable > 2 and "spare" in cmdline:
167			useable = useable - 1
168			spares = 1
169
170			if useable > 5:
171			useable = useable - 2
172			raidLevel = "RAID6"
173			elif useable > 1:
174			useable = useable - 1
175			if useable > 2:
176			raidLevel = "RAID5"
177			else:
178			raidLevel = "RAID1"
179	slords	1.16
180	slords	1.18	for drive in drives:
181			if not isys.driveIsRemovable(drive):
182	slords	1.16	filesystem = fileSystemTypeGet("software RAID")
183	slords	1.18	request = partRequests.PartitionSpec(filesystem, drive=[drive], size=100, primary=1, format=1)
184			request.uniqueID = uniqueID
185			raid1.append(uniqueID)
186			partitions.autoPartitionRequests.append(request)
187
188			if "nolvm" in cmdline:
189			filesystem = fileSystemTypeGet("software RAID")
190			request = partRequests.PartitionSpec(filesystem, drive=[drive], size=1500/useable,
191			grow=1, primary=1, format=1)
192			request.uniqueID = uniqueID + 30
193			raid2.append(uniqueID + 30)
194			partitions.autoPartitionRequests.append(request)
195
196			filesystem = fileSystemTypeGet("software RAID")
197			request = partRequests.PartitionSpec(filesystem, drive=[drive], size=swapMin/useable+10,
198			maxSizeMB=swapMax/useable, grow=1, primary=1, format=1)
199			request.uniqueID = uniqueID + 60
200			raid3.append(uniqueID + 60)
201			partitions.autoPartitionRequests.append(request)
202
203			else:
204			filesystem = fileSystemTypeGet("software RAID")
205			request = partRequests.PartitionSpec(filesystem, drive=[drive], size=(swapMin+1500)/useable,
206			grow=1, format=1)
207			request.uniqueID = uniqueID + 50
208			raid2.append(uniqueID + 50)
209			partitions.autoPartitionRequests.append(request)
210	slords	1.16
211	slords	1.18	uniqueID = uniqueID + 1
212	slords	1.16
213	slords	1.18	if "raid1" in cmdline and len(raid1)-spares > 1:
214			break
215	slords	1.16
216			filesystem = fileSystemTypeGet("ext3")
217	slords	1.18	request = partRequests.RaidRequestSpec(filesystem, mountpoint="/boot", raidminor=1,
218			raidmembers=raid1, raidlevel="RAID1", format=1, raidspares=spares)
219	slords	1.16	partitions.autoPartitionRequests.append(request)
220
221	slords	1.18	if "nolvm" in cmdline:
222			filesystem = fileSystemTypeGet("ext3")
223			request = partRequests.RaidRequestSpec(filesystem, mountpoint="/", raidmembers=raid2, raidminor=2,
224			raidlevel=raidLevel, format=1, raidspares=spares)
225			partitions.autoPartitionRequests.append(request)
226
227			filesystem = fileSystemTypeGet("swap")
228			request = partRequests.RaidRequestSpec(filesystem, raidmembers=raid3, raidminor=3,
229			raidlevel=raidLevel, format=1, raidspares=spares)
230			partitions.autoPartitionRequests.append(request)
231	slords	1.16
232	slords	1.18	else:
233			filesystem = fileSystemTypeGet("physical volume (LVM)")
234			request = partRequests.RaidRequestSpec(filesystem, raidmembers=raid2, raidminor=2,
235			raidlevel=raidLevel, format=1, raidspares=spares)
236			request.uniqueID = 200
237			partitions.autoPartitionRequests.append(request)
238	slords	1.16
239			if not "nolvm" in cmdline:
240			request = partRequests.VolumeGroupRequestSpec(vgname="main", physvols=[200],
241			pesize=32768, format=1)
242			request.uniqueID = 201
243			partitions.autoPartitionRequests.append(request)
244
245			filesystem = fileSystemTypeGet("ext3")
246			request = partRequests.LogicalVolumeRequestSpec(filesystem, mountpoint="/", size=1300,
247			volgroup=201, lvname="root", grow=1, format=1)
248			partitions.autoPartitionRequests.append(request)
249
250			filesystem = fileSystemTypeGet("swap")
251			request = partRequests.LogicalVolumeRequestSpec(filesystem, size=swapMin, maxSizeMB=swapMax,
252			volgroup=201, lvname="swap", grow=1, format=1)
253			partitions.autoPartitionRequests.append(request)
254			else:
255			dispatch.skipStep("partition", skip = 0)
256			BaseInstallClass.setDefaultPartitioning(self, partitions, clear, doClear)
257
258	slords	1.14	def setAsHeadless(self, dispatch, isHeadless = 0):
259			if isHeadless == 0:
260			pass
261			else:
262			# dispatch.skipStep("keyboard", permanent = 1)
263			# dispatch.skipStep("mouse", permanent = 1)
264			dispatch.skipStep("handleX11pkgs", permanent = 1)
265			dispatch.skipStep("videocard", permanent = 1)
266			dispatch.skipStep("monitor", permanent = 1)
267			dispatch.skipStep("xcustom", permanent = 1)
268			dispatch.skipStep("writexconfig", permanent = 1)
269
270	slords	1.1	def setGroupSelection(self, grpset, intf):
271			grpset.unselectAll()
272			grpset.selectGroup("Base")
273
274	gordonr	1.10	def postAction(self, rootPath, serial, intf):
275			win = intf.waitWindow(_("Post Install Script"),
276			_("The post installation script is running..."))
277
278	slords	1.3	script = ( "/sbin/syslogd &\n"
279			"sleep 2\n"
280			"/sbin/e-smith/signal-event post-install\n" )
281	slords	1.2	s = Script(script, interp="/bin/sh", inChroot=1)
282			log("%s", s)
283			s.run(rootPath, serial)
284	gordonr	1.10	win.pop()
285	slords	1.1
286			def setInstallData(self, id, intf = None):
287			BaseInstallClass.setInstallData(self, id)
288			self.setAuthentication(id, useShadow=1, useMd5=1)
289			self.setRootPassword(id, pw="ThisIsGoingToBeDisabledAnyway", isCrypted=0)
290			self.setZeroMbr(id, zeroMbr=1)
291			self.setClearParts(id, clear=CLEARPART_TYPE_ALL, initAll=1)
292			self.setDefaultPartitioning(id.partitions, doClear=0)
293			self.setBootloader(id, useLilo=0, location="mbr", linear=1)
294
295			def __init__(self, expert):
296	slords	1.12	BaseInstallClass.__init__(self, expert)