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()
        usedDrives = []

        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)
                        usedDrives.append(drive);

                        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 >= 3 and "spare" in cmdline:
                        spares = 1
                    useable = 1
                    raidLevel = "RAID1"

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

                    if useable >= 6:
                        useable = useable - 2
                        raidLevel = "RAID6"
                    elif useable >= 2:
                        useable = useable - 1
                        if useable >= 2:
                            raidLevel = "RAID5"
                        else:
                            raidLevel = "RAID1"
                    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)
                        usedDrives.append(drive);

                        if "nolvm" in cmdline:
                            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 + 30
                            raid2.append(uniqueID + 30)
                            partitions.autoPartitionRequests.append(request)

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

                        else:
                            filesystem = fileSystemTypeGet("software RAID")
                            if "multipart" in cmdline:
                                request = partRequests.PartitionSpec(filesystem, drive=[drive], size=(swapMin+3000)/useable,
                                        grow=1, format=1)
                            else:
                                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("swap")
                    request = partRequests.RaidRequestSpec(filesystem, raidmembers=raid2,  raidminor=2,
                            raidlevel=raidLevel, format=1, raidspares=spares)
                    partitions.autoPartitionRequests.append(request)

                    filesystem = fileSystemTypeGet("ext3")
                    request = partRequests.RaidRequestSpec(filesystem, mountpoint="/", 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)

                if "multipart" in cmdline:
                    filesystem = fileSystemTypeGet("ext3")
                    request = partRequests.LogicalVolumeRequestSpec(filesystem, mountpoint="/", size=2048, 
                            maxSizeMB=4096, volgroup=201, lvname="root", grow=1, format=1)
                    partitions.autoPartitionRequests.append(request)

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

                    filesystem = fileSystemTypeGet("ext3")
                    request = partRequests.LogicalVolumeRequestSpec(filesystem, mountpoint="/home/e-smith/files", size=1024, 
                            maxSizeMB=8192, volgroup=201, lvname="files", grow=1, format=1)
                    partitions.autoPartitionRequests.append(request)

                    filesystem = fileSystemTypeGet("ext3")
                    request = partRequests.LogicalVolumeRequestSpec(filesystem, mountpoint="/tmp", size=512, 
                            maxSizeMB=4096, volgroup=201, lvname="tmp", 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:
                    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)

            partitions.autoClearPartDrives = usedDrives
        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("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	slords	1.22	usedDrives = []
119	slords	1.16
120	slords	1.18	spares = 0
121			useable = 0
122			for drive in drives:
123			if not isys.driveIsRemovable(drive):
124			useable = useable + 1
125
126			if useable > 0:
127			if "noraid" in cmdline:
128			for drive in drives:
129			if not isys.driveIsRemovable(drive):
130	slords	1.16	filesystem = fileSystemTypeGet("ext3")
131	slords	1.18	request = partRequests.PartitionSpec(filesystem, mountpoint="/boot", drive=[drive],
132			size=100, primary=1, format=1)
133	slords	1.16	partitions.autoPartitionRequests.append(request)
134	slords	1.22	usedDrives.append(drive);
135	slords	1.16
136	slords	1.18	if "nolvm" in cmdline:
137			filesystem = fileSystemTypeGet("ext3")
138			request = partRequests.PartitionSpec(filesystem, mountpoint="/", drive=[drive],
139			size=1300, grow=1, primary=1, format=1)
140			partitions.autoPartitionRequests.append(request)
141
142			filesystem = fileSystemTypeGet("swap")
143			request = partRequests.PartitionSpec(filesystem, drive=[drive], size=swapMin,
144			maxSizeMB=swapMax, grow=1, primary=1, format=1)
145			partitions.autoPartitionRequests.append(request)
146
147			else:
148			filesystem = fileSystemTypeGet("physical volume (LVM)")
149			request = partRequests.PartitionSpec(filesystem, drive=[drive], size=swapMin+1500,
150			grow=1, primary=1, format=1)
151			request.uniqueID = 200
152			partitions.autoPartitionRequests.append(request)
153	slords	1.16
154	slords	1.18	break
155	slords	1.16
156	slords	1.18	else:
157			raid1 = []
158			raid2 = []
159			raid3 = []
160
161			if "raid1" in cmdline and useable > 0:
162	slords	1.24	if useable >= 3 and "spare" in cmdline:
163	slords	1.18	spares = 1
164			useable = 1
165			raidLevel = "RAID1"
166
167			else:
168	slords	1.24	if useable >= 3 and "spare" in cmdline:
169	slords	1.18	useable = useable - 1
170			spares = 1
171
172	slords	1.24	if useable >= 6:
173	slords	1.18	useable = useable - 2
174			raidLevel = "RAID6"
175	slords	1.24	elif useable >= 2:
176	slords	1.18	useable = useable - 1
177	slords	1.24	if useable >= 2:
178	slords	1.18	raidLevel = "RAID5"
179			else:
180			raidLevel = "RAID1"
181	slords	1.19	else:
182			raidLevel = "RAID1"
183	slords	1.16
184	slords	1.18	for drive in drives:
185			if not isys.driveIsRemovable(drive):
186	slords	1.16	filesystem = fileSystemTypeGet("software RAID")
187	slords	1.18	request = partRequests.PartitionSpec(filesystem, drive=[drive], size=100, primary=1, format=1)
188			request.uniqueID = uniqueID
189			raid1.append(uniqueID)
190			partitions.autoPartitionRequests.append(request)
191	slords	1.22	usedDrives.append(drive);
192	slords	1.18
193			if "nolvm" in cmdline:
194			filesystem = fileSystemTypeGet("software RAID")
195	slords	1.20	request = partRequests.PartitionSpec(filesystem, drive=[drive], size=swapMin/useable+10,
196			maxSizeMB=swapMax/useable, grow=1, primary=1, format=1)
197	slords	1.18	request.uniqueID = uniqueID + 30
198	slords	1.21	raid2.append(uniqueID + 30)
199			partitions.autoPartitionRequests.append(request)
200	slords	1.20
201	slords	1.18	filesystem = fileSystemTypeGet("software RAID")
202	slords	1.20	request = partRequests.PartitionSpec(filesystem, drive=[drive], size=1500/useable,
203			grow=1, primary=1, format=1)
204	slords	1.18	request.uniqueID = uniqueID + 60
205	slords	1.21	raid3.append(uniqueID + 60)
206	slords	1.18	partitions.autoPartitionRequests.append(request)
207
208			else:
209			filesystem = fileSystemTypeGet("software RAID")
210	slords	1.23	if "multipart" in cmdline:
211			request = partRequests.PartitionSpec(filesystem, drive=[drive], size=(swapMin+3000)/useable,
212			grow=1, format=1)
213			else:
214			request = partRequests.PartitionSpec(filesystem, drive=[drive], size=(swapMin+1500)/useable,
215			grow=1, format=1)
216	slords	1.18	request.uniqueID = uniqueID + 50
217			raid2.append(uniqueID + 50)
218			partitions.autoPartitionRequests.append(request)
219	slords	1.16
220	slords	1.18	uniqueID = uniqueID + 1
221	slords	1.16
222	slords	1.18	if "raid1" in cmdline and len(raid1)-spares > 1:
223			break
224	slords	1.16
225			filesystem = fileSystemTypeGet("ext3")
226	slords	1.18	request = partRequests.RaidRequestSpec(filesystem, mountpoint="/boot", raidminor=1,
227			raidmembers=raid1, raidlevel="RAID1", format=1, raidspares=spares)
228	slords	1.16	partitions.autoPartitionRequests.append(request)
229
230	slords	1.18	if "nolvm" in cmdline:
231	slords	1.20	filesystem = fileSystemTypeGet("swap")
232			request = partRequests.RaidRequestSpec(filesystem, raidmembers=raid2, raidminor=2,
233	slords	1.18	raidlevel=raidLevel, format=1, raidspares=spares)
234			partitions.autoPartitionRequests.append(request)
235
236	slords	1.20	filesystem = fileSystemTypeGet("ext3")
237			request = partRequests.RaidRequestSpec(filesystem, mountpoint="/", raidmembers=raid3, raidminor=3,
238	slords	1.18	raidlevel=raidLevel, format=1, raidspares=spares)
239			partitions.autoPartitionRequests.append(request)
240	slords	1.16
241	slords	1.18	else:
242			filesystem = fileSystemTypeGet("physical volume (LVM)")
243			request = partRequests.RaidRequestSpec(filesystem, raidmembers=raid2, raidminor=2,
244			raidlevel=raidLevel, format=1, raidspares=spares)
245			request.uniqueID = 200
246			partitions.autoPartitionRequests.append(request)
247	slords	1.16
248			if not "nolvm" in cmdline:
249			request = partRequests.VolumeGroupRequestSpec(vgname="main", physvols=[200],
250			pesize=32768, format=1)
251			request.uniqueID = 201
252			partitions.autoPartitionRequests.append(request)
253
254	slords	1.23	if "multipart" in cmdline:
255			filesystem = fileSystemTypeGet("ext3")
256			request = partRequests.LogicalVolumeRequestSpec(filesystem, mountpoint="/", size=2048,
257			maxSizeMB=4096, volgroup=201, lvname="root", grow=1, format=1)
258			partitions.autoPartitionRequests.append(request)
259
260			filesystem = fileSystemTypeGet("ext3")
261			request = partRequests.LogicalVolumeRequestSpec(filesystem, mountpoint="/var", size=1024,
262			maxSizeMB=4096, volgroup=201, lvname="var", grow=1, format=1)
263			partitions.autoPartitionRequests.append(request)
264
265			filesystem = fileSystemTypeGet("ext3")
266			request = partRequests.LogicalVolumeRequestSpec(filesystem, mountpoint="/home/e-smith/files", size=1024,
267			maxSizeMB=8192, volgroup=201, lvname="files", grow=1, format=1)
268			partitions.autoPartitionRequests.append(request)
269
270			filesystem = fileSystemTypeGet("ext3")
271			request = partRequests.LogicalVolumeRequestSpec(filesystem, mountpoint="/tmp", size=512,
272			maxSizeMB=4096, volgroup=201, lvname="tmp", grow=1, format=1)
273			partitions.autoPartitionRequests.append(request)
274
275			filesystem = fileSystemTypeGet("swap")
276			request = partRequests.LogicalVolumeRequestSpec(filesystem, size=swapMin, maxSizeMB=swapMax,
277			volgroup=201, lvname="swap", grow=1, format=1)
278			partitions.autoPartitionRequests.append(request)
279			else:
280			filesystem = fileSystemTypeGet("ext3")
281			request = partRequests.LogicalVolumeRequestSpec(filesystem, mountpoint="/", size=1300,
282			volgroup=201, lvname="root", grow=1, format=1)
283			partitions.autoPartitionRequests.append(request)
284	slords	1.16
285	slords	1.23	filesystem = fileSystemTypeGet("swap")
286			request = partRequests.LogicalVolumeRequestSpec(filesystem, size=swapMin, maxSizeMB=swapMax,
287			volgroup=201, lvname="swap", grow=1, format=1)
288			partitions.autoPartitionRequests.append(request)
289	slords	1.22
290			partitions.autoClearPartDrives = usedDrives
291	slords	1.16	else:
292			dispatch.skipStep("partition", skip = 0)
293			BaseInstallClass.setDefaultPartitioning(self, partitions, clear, doClear)
294
295	slords	1.14	def setAsHeadless(self, dispatch, isHeadless = 0):
296			if isHeadless == 0:
297			pass
298			else:
299			dispatch.skipStep("handleX11pkgs", permanent = 1)
300			dispatch.skipStep("videocard", permanent = 1)
301			dispatch.skipStep("monitor", permanent = 1)
302			dispatch.skipStep("xcustom", permanent = 1)
303			dispatch.skipStep("writexconfig", permanent = 1)
304
305	slords	1.1	def setGroupSelection(self, grpset, intf):
306			grpset.unselectAll()
307			grpset.selectGroup("Base")
308
309	gordonr	1.10	def postAction(self, rootPath, serial, intf):
310			win = intf.waitWindow(_("Post Install Script"),
311			_("The post installation script is running..."))
312
313	slords	1.3	script = ( "/sbin/syslogd &\n"
314			"sleep 2\n"
315			"/sbin/e-smith/signal-event post-install\n" )
316	slords	1.2	s = Script(script, interp="/bin/sh", inChroot=1)
317			log("%s", s)
318			s.run(rootPath, serial)
319	gordonr	1.10	win.pop()
320	slords	1.1
321			def setInstallData(self, id, intf = None):
322			BaseInstallClass.setInstallData(self, id)
323			self.setAuthentication(id, useShadow=1, useMd5=1)
324			self.setRootPassword(id, pw="ThisIsGoingToBeDisabledAnyway", isCrypted=0)
325			self.setZeroMbr(id, zeroMbr=1)
326			self.setClearParts(id, clear=CLEARPART_TYPE_ALL, initAll=1)
327			self.setDefaultPartitioning(id.partitions, doClear=0)
328			self.setBootloader(id, useLilo=0, location="mbr", linear=1)
329
330			def __init__(self, expert):
331	slords	1.12	BaseInstallClass.__init__(self, expert)