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",
                 "betanag",
                 "installtype",
                 "partitionobjinit",
                 "autopartitionexecute",
                 "partition",
                 "partitiondone",
                 "bootloadersetup",                 
                 "languagesupport",
                 "timezone",
                 "readcomps",
                 "selectlangpackages",
                 "checkdeps",
                 "dependencies",
                 "install",
                 "enablefilesystems",
                 "migratefilesystems",
                 "setuptime",
                 "preinstallconfig",
                 "installpackages",
                 "postinstallconfig",
                 "writeconfig",
                 "instbootloader",
                 "dopostaction",
                 "writeksconfig",
                 "methodcomplete",
                 "copylogs",
                 "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 >= 1:
            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 useable >= 3 and "nospare" not in cmdline:
                    useable = useable - 1
                    spares = 1

                if "raid1" in cmdline and useable >= 1:
                    useable = 1
                    raidLevel = "RAID1"
                else:
                    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 >= 2:
                            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:
            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	slords	1.28	"language",
72			"keyboard",
73	slords	1.1	"findrootparts",
74	slords	1.28	"betanag",
75			"installtype",
76	slords	1.1	"partitionobjinit",
77			"autopartitionexecute",
78	slords	1.2	"partition",
79	slords	1.28	"partitiondone",
80			"bootloadersetup",
81			"languagesupport",
82			"timezone",
83			"readcomps",
84	slords	1.1	"selectlangpackages",
85	slords	1.28	"checkdeps",
86			"dependencies",
87			"install",
88			"enablefilesystems",
89	slords	1.1	"migratefilesystems",
90			"setuptime",
91			"preinstallconfig",
92	slords	1.28	"installpackages",
93	slords	1.1	"postinstallconfig",
94	slords	1.28	"writeconfig",
95			"instbootloader",
96	slords	1.1	"dopostaction",
97	slords	1.28	"writeksconfig",
98	slords	1.1	"methodcomplete",
99			"copylogs",
100			"setfilecon",
101	slords	1.28	"complete"
102	slords	1.1	)
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	slords	1.25	if useable >= 1:
127	slords	1.18	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	slords	1.25	if useable >= 3 and "nospare" not in cmdline:
162			useable = useable - 1
163			spares = 1
164
165			if "raid1" in cmdline and useable >= 1:
166	slords	1.18	useable = 1
167			raidLevel = "RAID1"
168			else:
169	slords	1.24	if useable >= 6:
170	slords	1.18	useable = useable - 2
171			raidLevel = "RAID6"
172	slords	1.24	elif useable >= 2:
173	slords	1.18	useable = useable - 1
174	slords	1.24	if useable >= 2:
175	slords	1.18	raidLevel = "RAID5"
176			else:
177			raidLevel = "RAID1"
178	slords	1.19	else:
179			raidLevel = "RAID1"
180	slords	1.16
181	slords	1.18	for drive in drives:
182			if not isys.driveIsRemovable(drive):
183	slords	1.16	filesystem = fileSystemTypeGet("software RAID")
184	slords	1.18	request = partRequests.PartitionSpec(filesystem, drive=[drive], size=100, primary=1, format=1)
185			request.uniqueID = uniqueID
186			raid1.append(uniqueID)
187			partitions.autoPartitionRequests.append(request)
188	slords	1.22	usedDrives.append(drive);
189	slords	1.18
190			if "nolvm" in cmdline:
191			filesystem = fileSystemTypeGet("software RAID")
192	slords	1.20	request = partRequests.PartitionSpec(filesystem, drive=[drive], size=swapMin/useable+10,
193			maxSizeMB=swapMax/useable, grow=1, primary=1, format=1)
194	slords	1.18	request.uniqueID = uniqueID + 30
195	slords	1.21	raid2.append(uniqueID + 30)
196			partitions.autoPartitionRequests.append(request)
197	slords	1.20
198	slords	1.18	filesystem = fileSystemTypeGet("software RAID")
199	slords	1.20	request = partRequests.PartitionSpec(filesystem, drive=[drive], size=1500/useable,
200			grow=1, primary=1, format=1)
201	slords	1.18	request.uniqueID = uniqueID + 60
202	slords	1.21	raid3.append(uniqueID + 60)
203	slords	1.18	partitions.autoPartitionRequests.append(request)
204
205			else:
206			filesystem = fileSystemTypeGet("software RAID")
207	slords	1.23	if "multipart" in cmdline:
208			request = partRequests.PartitionSpec(filesystem, drive=[drive], size=(swapMin+3000)/useable,
209			grow=1, format=1)
210			else:
211			request = partRequests.PartitionSpec(filesystem, drive=[drive], size=(swapMin+1500)/useable,
212			grow=1, format=1)
213	slords	1.18	request.uniqueID = uniqueID + 50
214			raid2.append(uniqueID + 50)
215			partitions.autoPartitionRequests.append(request)
216	slords	1.16
217	slords	1.18	uniqueID = uniqueID + 1
218	slords	1.16
219	slords	1.25	if "raid1" in cmdline and len(raid1)-spares >= 2:
220	slords	1.18	break
221	slords	1.16
222			filesystem = fileSystemTypeGet("ext3")
223	slords	1.18	request = partRequests.RaidRequestSpec(filesystem, mountpoint="/boot", raidminor=1,
224			raidmembers=raid1, raidlevel="RAID1", format=1, raidspares=spares)
225	slords	1.16	partitions.autoPartitionRequests.append(request)
226
227	slords	1.18	if "nolvm" in cmdline:
228	slords	1.20	filesystem = fileSystemTypeGet("swap")
229			request = partRequests.RaidRequestSpec(filesystem, raidmembers=raid2, raidminor=2,
230	slords	1.18	raidlevel=raidLevel, format=1, raidspares=spares)
231			partitions.autoPartitionRequests.append(request)
232
233	slords	1.20	filesystem = fileSystemTypeGet("ext3")
234			request = partRequests.RaidRequestSpec(filesystem, mountpoint="/", raidmembers=raid3, raidminor=3,
235	slords	1.18	raidlevel=raidLevel, format=1, raidspares=spares)
236			partitions.autoPartitionRequests.append(request)
237	slords	1.16
238	slords	1.18	else:
239			filesystem = fileSystemTypeGet("physical volume (LVM)")
240			request = partRequests.RaidRequestSpec(filesystem, raidmembers=raid2, raidminor=2,
241			raidlevel=raidLevel, format=1, raidspares=spares)
242			request.uniqueID = 200
243			partitions.autoPartitionRequests.append(request)
244	slords	1.16
245			if not "nolvm" in cmdline:
246			request = partRequests.VolumeGroupRequestSpec(vgname="main", physvols=[200],
247			pesize=32768, format=1)
248			request.uniqueID = 201
249			partitions.autoPartitionRequests.append(request)
250
251	slords	1.23	if "multipart" in cmdline:
252			filesystem = fileSystemTypeGet("ext3")
253			request = partRequests.LogicalVolumeRequestSpec(filesystem, mountpoint="/", size=2048,
254			maxSizeMB=4096, volgroup=201, lvname="root", grow=1, format=1)
255			partitions.autoPartitionRequests.append(request)
256
257			filesystem = fileSystemTypeGet("ext3")
258			request = partRequests.LogicalVolumeRequestSpec(filesystem, mountpoint="/var", size=1024,
259			maxSizeMB=4096, volgroup=201, lvname="var", grow=1, format=1)
260			partitions.autoPartitionRequests.append(request)
261
262			filesystem = fileSystemTypeGet("ext3")
263			request = partRequests.LogicalVolumeRequestSpec(filesystem, mountpoint="/home/e-smith/files", size=1024,
264			maxSizeMB=8192, volgroup=201, lvname="files", grow=1, format=1)
265			partitions.autoPartitionRequests.append(request)
266
267			filesystem = fileSystemTypeGet("ext3")
268			request = partRequests.LogicalVolumeRequestSpec(filesystem, mountpoint="/tmp", size=512,
269			maxSizeMB=4096, volgroup=201, lvname="tmp", grow=1, format=1)
270			partitions.autoPartitionRequests.append(request)
271
272			filesystem = fileSystemTypeGet("swap")
273			request = partRequests.LogicalVolumeRequestSpec(filesystem, size=swapMin, maxSizeMB=swapMax,
274			volgroup=201, lvname="swap", grow=1, format=1)
275			partitions.autoPartitionRequests.append(request)
276			else:
277			filesystem = fileSystemTypeGet("ext3")
278			request = partRequests.LogicalVolumeRequestSpec(filesystem, mountpoint="/", size=1300,
279			volgroup=201, lvname="root", grow=1, format=1)
280			partitions.autoPartitionRequests.append(request)
281	slords	1.16
282	slords	1.23	filesystem = fileSystemTypeGet("swap")
283			request = partRequests.LogicalVolumeRequestSpec(filesystem, size=swapMin, maxSizeMB=swapMax,
284			volgroup=201, lvname="swap", grow=1, format=1)
285			partitions.autoPartitionRequests.append(request)
286	slords	1.22
287			partitions.autoClearPartDrives = usedDrives
288	slords	1.16	else:
289			BaseInstallClass.setDefaultPartitioning(self, partitions, clear, doClear)
290
291	slords	1.14	def setAsHeadless(self, dispatch, isHeadless = 0):
292			if isHeadless == 0:
293			pass
294			else:
295			dispatch.skipStep("handleX11pkgs", permanent = 1)
296			dispatch.skipStep("videocard", permanent = 1)
297			dispatch.skipStep("monitor", permanent = 1)
298			dispatch.skipStep("xcustom", permanent = 1)
299			dispatch.skipStep("writexconfig", permanent = 1)
300
301	slords	1.1	def setGroupSelection(self, grpset, intf):
302			grpset.unselectAll()
303			grpset.selectGroup("Base")
304
305	gordonr	1.10	def postAction(self, rootPath, serial, intf):
306			win = intf.waitWindow(_("Post Install Script"),
307			_("The post installation script is running..."))
308
309	slords	1.3	script = ( "/sbin/syslogd &\n"
310			"sleep 2\n"
311			"/sbin/e-smith/signal-event post-install\n" )
312	slords	1.2	s = Script(script, interp="/bin/sh", inChroot=1)
313			log("%s", s)
314			s.run(rootPath, serial)
315	gordonr	1.10	win.pop()
316	slords	1.1
317			def setInstallData(self, id, intf = None):
318			BaseInstallClass.setInstallData(self, id)
319			self.setAuthentication(id, useShadow=1, useMd5=1)
320			self.setRootPassword(id, pw="ThisIsGoingToBeDisabledAnyway", isCrypted=0)
321			self.setZeroMbr(id, zeroMbr=1)
322			self.setClearParts(id, clear=CLEARPART_TYPE_ALL, initAll=1)
323			self.setDefaultPartitioning(id.partitions, doClear=0)
324			self.setBootloader(id, useLilo=0, location="mbr", linear=1)
325
326			def __init__(self, expert):
327	slords	1.12	BaseInstallClass.__init__(self, expert)