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
    doPartition = False
    cmdline = {}

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

    def requiredDisplayMode(self):
        return 't'

    def createCmdlineDict(self):
        cmdlineDict = {}
        cmdline = open("/proc/cmdline", "r").read().strip()

        for i in cmdline.split():
            try:
                (key, val) = i.split("=", 1)
            except:
                key = i
                val = True

            cmdlineDict[key] = val

        return cmdlineDict

    def mediaPresent(self, device):
        try:
            fd = os.open("/dev/%s" % device, os.O_RDONLY)
        except OSError, (errno, strerror):
            # error 123 = No medium found
            if errno == 123:
                return False
            else:
                return True
        else:
            os.close(fd)
            return True

    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...
        if self.doPartition or self.cmdline.has_key("partition"):
            dispatch.skipStep("partition", skip = 0)
        else:
            dispatch.skipStep("partition", skip = 1)

    def setDefaultPartitioning(self, partitions, clear = CLEARPART_TYPE_LINUX, doClear = 1):
        self.cmdline = self.createCmdlineDict()
        diskset = partedUtils.DiskSet()

        alldrives = diskset.driveList()
        if self.cmdline.has_key("drives"):
            drives = filter(lambda x:self.mediaPresent(x) and 
                                     x in self.cmdline["drives"].split(","), alldrives)
        else:
            drives = filter(lambda x:not isys.driveIsRemovable(x) and
                                     self.mediaPresent(x) and
                                     not isys.driveUsesModule(x, ["usb-storage", "ub", "sbp2"]), alldrives)

        if self.cmdline.has_key("spares"):
            spares = max(0,min(int(self.cmdline["spares"]),len(drives)-2))
        else:
            spares = (len(drives)+4)/7

        if self.cmdline.has_key("raid") and self.cmdline["raid"] in ["none","0","1","5","6"]:
            if self.cmdline["raid"] == "none":
                level = 0
            else:
                level = int(self.cmdline["raid"])
            if level == 0:
                del drives[1:]
                spares = 0
            if level == 6 and len(drives)-spares < 4:
                level = 5
            if level == 5 and len(drives)-spares < 3:
                level = 1
            if level == 1:
                if spares > 1 and not self.cmdline.has_key("spares"):
                    spares = 1
                del drives[2+spares:]
        else:
            if len(drives) - spares >= 6:
                level = 6
            elif len(drives) - spares >= 3:
                level = 5
            else:
                level = 1

        if len(drives) >= 1:
            log("Using the following drives: %s" % drives)
            if level >= 1:
                log("Installing using RAID%s" % level)
                log("Using %s spare drives" % spares)
            else:
                log("Installing without using RAID")

            (swapMin, swapMax) = iutil.swapSuggestion()
            if level >= 1:
                raid1 = []
                raid2 = []
                raid3 = []
                uniqueID = 100

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

                    if not self.cmdline.has_key("nolvm"):
                        request = partRequests.PartitionSpec(fileSystemTypeGet("software RAID"),
                                size=(swapMin+4096)/(len(drives)-spares-max(0,level-4)),
                                drive=[drive], primary=1, grow=1, format=1)
                        request.uniqueID = uniqueID + 50
                        raid2.append(uniqueID + 50)
                        partitions.autoPartitionRequests.append(request)
                    else:
                        request = partRequests.PartitionSpec(fileSystemTypeGet("software RAID"),
                                drive=[drive], size=swapMin/(len(drives)-spares-max(0,level-4))+10, grow=1,
                                maxSizeMB=swapMax/(len(drives)-spares-max(0,level-4)), format=1, primary=1)
                        request.uniqueID = uniqueID + 30
                        raid2.append(uniqueID + 30)
                        partitions.autoPartitionRequests.append(request)

                        request = partRequests.PartitionSpec(fileSystemTypeGet("software RAID"),
                                size=1500/(len(drives)-spares-max(0,level-4)),
                                drive=[drive], grow=1, primary=1, format=1)
                        request.uniqueID = uniqueID + 60
                        raid3.append(uniqueID + 60)
                        partitions.autoPartitionRequests.append(request)

                    uniqueID = uniqueID + 1

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

                if not self.cmdline.has_key("nolvm"):
                    request = partRequests.RaidRequestSpec(fileSystemTypeGet("physical volume (LVM)"),
                            raidmembers=raid2, raidlevel="RAID"+str(level), raidminor=2, format=1,
                            raidspares=spares)
                    request.uniqueID = 200
                    partitions.autoPartitionRequests.append(request)
                else:
                    partitions.autoPartitionRequests.append(partRequests.RaidRequestSpec(fileSystemTypeGet("swap"),
                            raidmembers=raid2, raidlevel="RAID"+str(level), raidminor=2, format=1, raidspares=spares))

                    partitions.autoPartitionRequests.append(partRequests.RaidRequestSpec(fileSystemTypeGet("ext3"),
                            mountpoint="/", raidmembers=raid3, raidlevel="RAID"+str(level), raidminor=3, format=1,
                            raidspares=spares))

            else:
                for drive in drives:
                    partitions.autoPartitionRequests.append(partRequests.PartitionSpec(fileSystemTypeGet("ext3"),
                            mountpoint="/boot", drive=[drive], size=100, primary=1, format=1))

                    if not self.cmdline.has_key("nolvm"):
                        request = partRequests.PartitionSpec(fileSystemTypeGet("physical volume (LVM)"),
                                drive=[drive], size=swapMin+4096, grow=1, primary=1, format=1)
                        request.uniqueID = 200
                        partitions.autoPartitionRequests.append(request)
                    else:
                        partitions.autoPartitionRequests.append(partRequests.PartitionSpec(fileSystemTypeGet("ext3"),
                                mountpoint="/", drive=[drive], size=4096, grow=1, primary=1, format=1))

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

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

                if not self.cmdline.has_key("multipart"):
                    partitions.autoPartitionRequests.append(partRequests.LogicalVolumeRequestSpec(fileSystemTypeGet("ext3"),
                            mountpoint="/", size=1300, volgroup=201, lvname="root", grow=1, format=1))

                    partitions.autoPartitionRequests.append(partRequests.LogicalVolumeRequestSpec(fileSystemTypeGet("swap"),
                            size=swapMin, maxSizeMB=swapMax, volgroup=201, lvname="swap", grow=1, format=1))
                else:
                    partitions.autoPartitionRequests.append(partRequests.LogicalVolumeRequestSpec(fileSystemTypeGet("ext3"),
                            mountpoint="/", size=2048, maxSizeMB=4096, volgroup=201, lvname="root", grow=1, format=1))

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

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

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

                    partitions.autoPartitionRequests.append(partRequests.LogicalVolumeRequestSpec(fileSystemTypeGet("swap"),
                            size=swapMin, maxSizeMB=swapMax, volgroup=201, lvname="swap", grow=1, format=1))

            partitions.autoClearPartType = CLEARPART_TYPE_ALL
            partitions.autoClearPartDrives = drives
            self.doPartition = False
        else:
            log("Not useable drives found.  Enabling manual partitioning.")
            self.doPartition = True
            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, salt="md5")
        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			from rhpl.translate import N_, _
3			from constants import *
4			import os
5			import iutil
6			from fsset import *
7
8			from autopart import getAutopartitionBoot, autoCreatePartitionRequests, autoCreateLVMPartitionRequests
9			from rhpl.log import log
10			import string
11			import partRequests
12			import partedUtils
13
14			class Script:
15			def __repr__(self):
16	slords	1.3	str = ("(s: '%s' i: %s c: %d)") % \
17	slords	1.1	(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			class InstallClass(BaseInstallClass):
56			id = "smeserver"
57			name = N_("New _SME Server Install")
58			pixmap = "smeserver.png"
59			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.2
63	slords	1.1	sortPriority = 1
64	slords	1.3	doPartition = False
65	slords	1.2	cmdline = {}
66	slords	1.1
67			parentClass = ( _("Install SME Server"), "smeserver.png" )
68
69			def requiredDisplayMode(self):
70			return 't'
71
72	slords	1.2	def createCmdlineDict(self):
73			cmdlineDict = {}
74			cmdline = open("/proc/cmdline", "r").read().strip()
75
76			for i in cmdline.split():
77			try:
78			(key, val) = i.split("=", 1)
79			except:
80			key = i
81			val = True
82
83			cmdlineDict[key] = val
84
85			return cmdlineDict
86
87			def mediaPresent(self, device):
88			try:
89			fd = os.open("/dev/%s" % device, os.O_RDONLY)
90			except OSError, (errno, strerror):
91			# error 123 = No medium found
92			if errno == 123:
93			return False
94			else:
95			return True
96			else:
97			os.close(fd)
98			return True
99
100	slords	1.1	def setSteps(self, dispatch):
101			dispatch.setStepList(
102			"language",
103			"keyboard",
104			"findrootparts",
105			"betanag",
106			"installtype",
107			"partitionobjinit",
108			"autopartitionexecute",
109			"partition",
110			"partitiondone",
111	slords	1.2	"bootloadersetup",
112	slords	1.1	"languagesupport",
113			"timezone",
114			"readcomps",
115			"selectlangpackages",
116			"checkdeps",
117			"dependencies",
118			"install",
119			"enablefilesystems",
120			"migratefilesystems",
121			"setuptime",
122			"preinstallconfig",
123			"installpackages",
124			"postinstallconfig",
125			"writeconfig",
126			"instbootloader",
127			"dopostaction",
128			"writeksconfig",
129			"methodcomplete",
130			"copylogs",
131			"setfilecon",
132			"complete"
133			)
134
135	slords	1.2	# 'partition' can be used on the command line to force
136	slords	1.1	# verification of partitions. useful in some cases...
137	slords	1.2	if self.doPartition or self.cmdline.has_key("partition"):
138	slords	1.1	dispatch.skipStep("partition", skip = 0)
139			else:
140			dispatch.skipStep("partition", skip = 1)
141
142			def setDefaultPartitioning(self, partitions, clear = CLEARPART_TYPE_LINUX, doClear = 1):
143	slords	1.2	self.cmdline = self.createCmdlineDict()
144	slords	1.1	diskset = partedUtils.DiskSet()
145
146	slords	1.2	alldrives = diskset.driveList()
147			if self.cmdline.has_key("drives"):
148			drives = filter(lambda x:self.mediaPresent(x) and
149			x in self.cmdline["drives"].split(","), alldrives)
150			else:
151			drives = filter(lambda x:not isys.driveIsRemovable(x) and
152			self.mediaPresent(x) and
153			not isys.driveUsesModule(x, ["usb-storage", "ub", "sbp2"]), alldrives)
154	slords	1.1
155	slords	1.2	if self.cmdline.has_key("spares"):
156			spares = max(0,min(int(self.cmdline["spares"]),len(drives)-2))
157			else:
158			spares = (len(drives)+4)/7
159	slords	1.1
160	slords	1.2	if self.cmdline.has_key("raid") and self.cmdline["raid"] in ["none","0","1","5","6"]:
161			if self.cmdline["raid"] == "none":
162			level = 0
163			else:
164			level = int(self.cmdline["raid"])
165			if level == 0:
166			del drives[1:]
167			spares = 0
168			if level == 6 and len(drives)-spares < 4:
169			level = 5
170			if level == 5 and len(drives)-spares < 3:
171			level = 1
172			if level == 1:
173			if spares > 1 and not self.cmdline.has_key("spares"):
174			spares = 1
175			del drives[2+spares:]
176			else:
177			if len(drives) - spares >= 6:
178			level = 6
179			elif len(drives) - spares >= 3:
180			level = 5
181			else:
182			level = 1
183	slords	1.1
184	slords	1.2	if len(drives) >= 1:
185			log("Using the following drives: %s" % drives)
186			if level >= 1:
187			log("Installing using RAID%s" % level)
188			log("Using %s spare drives" % spares)
189	slords	1.1	else:
190	slords	1.2	log("Installing without using RAID")
191
192			(swapMin, swapMax) = iutil.swapSuggestion()
193			if level >= 1:
194	slords	1.1	raid1 = []
195			raid2 = []
196			raid3 = []
197	slords	1.2	uniqueID = 100
198	slords	1.1
199	slords	1.2	for drive in drives:
200			request = partRequests.PartitionSpec(fileSystemTypeGet("software RAID"),
201			drive=[drive], size=100, primary=1, format=1)
202			request.uniqueID = uniqueID
203			raid1.append(uniqueID)
204			partitions.autoPartitionRequests.append(request)
205	slords	1.1
206	slords	1.2	if not self.cmdline.has_key("nolvm"):
207			request = partRequests.PartitionSpec(fileSystemTypeGet("software RAID"),
208			size=(swapMin+4096)/(len(drives)-spares-max(0,level-4)),
209			drive=[drive], primary=1, grow=1, format=1)
210			request.uniqueID = uniqueID + 50
211			raid2.append(uniqueID + 50)
212			partitions.autoPartitionRequests.append(request)
213	slords	1.1	else:
214	slords	1.2	request = partRequests.PartitionSpec(fileSystemTypeGet("software RAID"),
215			drive=[drive], size=swapMin/(len(drives)-spares-max(0,level-4))+10, grow=1,
216			maxSizeMB=swapMax/(len(drives)-spares-max(0,level-4)), format=1, primary=1)
217			request.uniqueID = uniqueID + 30
218			raid2.append(uniqueID + 30)
219			partitions.autoPartitionRequests.append(request)
220	slords	1.1
221	slords	1.2	request = partRequests.PartitionSpec(fileSystemTypeGet("software RAID"),
222			size=1500/(len(drives)-spares-max(0,level-4)),
223			drive=[drive], grow=1, primary=1, format=1)
224			request.uniqueID = uniqueID + 60
225			raid3.append(uniqueID + 60)
226	slords	1.1	partitions.autoPartitionRequests.append(request)
227
228	slords	1.2	uniqueID = uniqueID + 1
229	slords	1.1
230	slords	1.2	partitions.autoPartitionRequests.append(partRequests.RaidRequestSpec(fileSystemTypeGet("ext3"),
231			mountpoint="/boot", raidmembers=raid1, raidlevel="RAID1", raidminor=1, format=1,
232			raidspares=0))
233
234			if not self.cmdline.has_key("nolvm"):
235			request = partRequests.RaidRequestSpec(fileSystemTypeGet("physical volume (LVM)"),
236			raidmembers=raid2, raidlevel="RAID"+str(level), raidminor=2, format=1,
237			raidspares=spares)
238			request.uniqueID = 200
239	slords	1.1	partitions.autoPartitionRequests.append(request)
240	slords	1.2	else:
241			partitions.autoPartitionRequests.append(partRequests.RaidRequestSpec(fileSystemTypeGet("swap"),
242			raidmembers=raid2, raidlevel="RAID"+str(level), raidminor=2, format=1, raidspares=spares))
243	slords	1.1
244	slords	1.2	partitions.autoPartitionRequests.append(partRequests.RaidRequestSpec(fileSystemTypeGet("ext3"),
245	slords	1.3	mountpoint="/", raidmembers=raid3, raidlevel="RAID"+str(level), raidminor=3, format=1,
246	slords	1.2	raidspares=spares))
247
248			else:
249			for drive in drives:
250			partitions.autoPartitionRequests.append(partRequests.PartitionSpec(fileSystemTypeGet("ext3"),
251	slords	1.3	mountpoint="/boot", drive=[drive], size=100, primary=1, format=1))
252	slords	1.2
253			if not self.cmdline.has_key("nolvm"):
254			request = partRequests.PartitionSpec(fileSystemTypeGet("physical volume (LVM)"),
255			drive=[drive], size=swapMin+4096, grow=1, primary=1, format=1)
256			request.uniqueID = 200
257			partitions.autoPartitionRequests.append(request)
258			else:
259			partitions.autoPartitionRequests.append(partRequests.PartitionSpec(fileSystemTypeGet("ext3"),
260			mountpoint="/", drive=[drive], size=4096, grow=1, primary=1, format=1))
261	slords	1.1
262	slords	1.2	partitions.autoPartitionRequests.append(partRequests.PartitionSpec(fileSystemTypeGet("swap"),
263			drive=[drive], size=swapMin, maxSizeMB=swapMax, grow=1, primary=1, format=1))
264	slords	1.1
265	slords	1.2	if not self.cmdline.has_key("nolvm"):
266			request = partRequests.VolumeGroupRequestSpec(vgname="main", physvols=[200], pesize=32768, format=1)
267	slords	1.1	request.uniqueID = 201
268			partitions.autoPartitionRequests.append(request)
269
270	slords	1.2	if not self.cmdline.has_key("multipart"):
271			partitions.autoPartitionRequests.append(partRequests.LogicalVolumeRequestSpec(fileSystemTypeGet("ext3"),
272			mountpoint="/", size=1300, volgroup=201, lvname="root", grow=1, format=1))
273	slords	1.1
274	slords	1.2	partitions.autoPartitionRequests.append(partRequests.LogicalVolumeRequestSpec(fileSystemTypeGet("swap"),
275			size=swapMin, maxSizeMB=swapMax, volgroup=201, lvname="swap", grow=1, format=1))
276			else:
277			partitions.autoPartitionRequests.append(partRequests.LogicalVolumeRequestSpec(fileSystemTypeGet("ext3"),
278			mountpoint="/", size=2048, maxSizeMB=4096, volgroup=201, lvname="root", grow=1, format=1))
279	slords	1.1
280	slords	1.2	partitions.autoPartitionRequests.append(partRequests.LogicalVolumeRequestSpec(fileSystemTypeGet("ext3"),
281			mountpoint="/var", size=1024, maxSizeMB=4096, volgroup=201, lvname="var", grow=1, format=1))
282	slords	1.1
283	slords	1.2	partitions.autoPartitionRequests.append(partRequests.LogicalVolumeRequestSpec(fileSystemTypeGet("ext3"),
284			mountpoint="/home/e-smith/files", size=1024, maxSizeMB=8192, volgroup=201, lvname="files", grow=1, format=1))
285	slords	1.1
286	slords	1.2	partitions.autoPartitionRequests.append(partRequests.LogicalVolumeRequestSpec(fileSystemTypeGet("ext3"),
287			mountpoint="/tmp", size=512, maxSizeMB=4096, volgroup=201, lvname="tmp", grow=1, format=1))
288	slords	1.1
289	slords	1.2	partitions.autoPartitionRequests.append(partRequests.LogicalVolumeRequestSpec(fileSystemTypeGet("swap"),
290			size=swapMin, maxSizeMB=swapMax, volgroup=201, lvname="swap", grow=1, format=1))
291	slords	1.1
292	slords	1.2	partitions.autoClearPartType = CLEARPART_TYPE_ALL
293			partitions.autoClearPartDrives = drives
294			self.doPartition = False
295	slords	1.1	else:
296	slords	1.2	log("Not useable drives found. Enabling manual partitioning.")
297			self.doPartition = True
298	slords	1.1	BaseInstallClass.setDefaultPartitioning(self, partitions, clear, doClear)
299
300			def setAsHeadless(self, dispatch, isHeadless = 0):
301			if isHeadless == 0:
302			pass
303			else:
304			dispatch.skipStep("handleX11pkgs", permanent = 1)
305			dispatch.skipStep("videocard", permanent = 1)
306			dispatch.skipStep("monitor", permanent = 1)
307			dispatch.skipStep("xcustom", permanent = 1)
308			dispatch.skipStep("writexconfig", permanent = 1)
309
310			def setGroupSelection(self, grpset, intf):
311			grpset.unselectAll()
312			grpset.selectGroup("Base")
313
314			def postAction(self, rootPath, serial, intf):
315			win = intf.waitWindow(_("Post Install Script"),
316			_("The post installation script is running..."))
317
318			script = ( "/sbin/syslogd &\n"
319			"sleep 2\n"
320			"/sbin/e-smith/signal-event post-install\n" )
321			s = Script(script, interp="/bin/sh", inChroot=1)
322			log("%s", s)
323			s.run(rootPath, serial)
324			win.pop()
325
326			def setInstallData(self, id, intf = None):
327			BaseInstallClass.setInstallData(self, id)
328			self.setAuthentication(id, useShadow=1, salt="md5")
329			self.setRootPassword(id, pw="ThisIsGoingToBeDisabledAnyway", isCrypted=0)
330			self.setZeroMbr(id, zeroMbr=1)
331			self.setClearParts(id, clear=CLEARPART_TYPE_ALL, initAll=1)
332			self.setDefaultPartitioning(id.partitions, doClear=0)
333			self.setBootloader(id, useLilo=0, location="mbr", linear=1)
334
335			def __init__(self, expert):
336			BaseInstallClass.__init__(self, expert)