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