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()

        if self.cmdline.has_key("exclude"):
            alldrives = filter(lambda x:not x in self.cmdline["exclude"].split(","), diskset.driveList())
        else:
            alldrives = diskset.driveList()

        if self.cmdline.has_key("drives"):
            if self.cmdline["drives"] == "all":
                drives = filter(lambda x:self.mediaPresent(x), alldrives)
            else:
                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"):
            if self.cmdline["spares"] == "none":
                spares = 0
            else:
                try:
                    spares = max(0,min(int(self.cmdline["spares"]),len(drives)-2))
                except:
                    spares = (len(drives)+4)/7
        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:
            excluded = filter(lambda x:x not in drives, diskset.driveList())
            log("Using the following drives: %s" % drives)
            log("Excluding the following drives: %s" % excluded)
            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	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	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	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
63	sortPriority = 1
64	doPartition = False
65	cmdline = {}
66
67	parentClass = ( _("Install SME Server"), "smeserver.png" )
68
69	def requiredDisplayMode(self):
70	return 't'
71
72	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	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	"bootloadersetup",
112	"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	# 'partition' can be used on the command line to force
136	# verification of partitions. useful in some cases...
137	if self.doPartition or self.cmdline.has_key("partition"):
138	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	self.cmdline = self.createCmdlineDict()
144	diskset = partedUtils.DiskSet()
145
146	if self.cmdline.has_key("exclude"):
147	alldrives = filter(lambda x:not x in self.cmdline["exclude"].split(","), diskset.driveList())
148	else:
149	alldrives = diskset.driveList()
150
151	if self.cmdline.has_key("drives"):
152	if self.cmdline["drives"] == "all":
153	drives = filter(lambda x:self.mediaPresent(x), alldrives)
154	else:
155	drives = filter(lambda x:self.mediaPresent(x) and
156	x in self.cmdline["drives"].split(","), alldrives)
157	else:
158	drives = filter(lambda x:not isys.driveIsRemovable(x) and
159	self.mediaPresent(x) and
160	not isys.driveUsesModule(x, ["usb-storage", "ub", "sbp2"]), alldrives)
161
162	if self.cmdline.has_key("spares"):
163	if self.cmdline["spares"] == "none":
164	spares = 0
165	else:
166	try:
167	spares = max(0,min(int(self.cmdline["spares"]),len(drives)-2))
168	except:
169	spares = (len(drives)+4)/7
170	else:
171	spares = (len(drives)+4)/7
172
173	if self.cmdline.has_key("raid") and self.cmdline["raid"] in ["none","0","1","5","6"]:
174	if self.cmdline["raid"] == "none":
175	level = 0
176	else:
177	level = int(self.cmdline["raid"])
178	if level == 0:
179	del drives[1:]
180	spares = 0
181	if level == 6 and len(drives)-spares < 4:
182	level = 5
183	if level == 5 and len(drives)-spares < 3:
184	level = 1
185	if level == 1:
186	if spares > 1 and not self.cmdline.has_key("spares"):
187	spares = 1
188	del drives[2+spares:]
189	else:
190	if len(drives) - spares >= 6:
191	level = 6
192	elif len(drives) - spares >= 3:
193	level = 5
194	else:
195	level = 1
196
197	if len(drives) >= 1:
198	excluded = filter(lambda x:x not in drives, diskset.driveList())
199	log("Using the following drives: %s" % drives)
200	log("Excluding the following drives: %s" % excluded)
201	if level >= 1:
202	log("Installing using RAID%s" % level)
203	log("Using %s spare drives" % spares)
204	else:
205	log("Installing without using RAID")
206
207	(swapMin, swapMax) = iutil.swapSuggestion()
208	if level >= 1:
209	raid1 = []
210	raid2 = []
211	raid3 = []
212	uniqueID = 100
213
214	for drive in drives:
215	request = partRequests.PartitionSpec(fileSystemTypeGet("software RAID"),
216	drive=[drive], size=100, primary=1, format=1)
217	request.uniqueID = uniqueID
218	raid1.append(uniqueID)
219	partitions.autoPartitionRequests.append(request)
220
221	if not self.cmdline.has_key("nolvm"):
222	request = partRequests.PartitionSpec(fileSystemTypeGet("software RAID"),
223	size=(swapMin+4096)/(len(drives)-spares-max(0,level-4)),
224	drive=[drive], primary=1, grow=1, format=1)
225	request.uniqueID = uniqueID + 50
226	raid2.append(uniqueID + 50)
227	partitions.autoPartitionRequests.append(request)
228	else:
229	request = partRequests.PartitionSpec(fileSystemTypeGet("software RAID"),
230	drive=[drive], size=swapMin/(len(drives)-spares-max(0,level-4))+10, grow=1,
231	maxSizeMB=swapMax/(len(drives)-spares-max(0,level-4)), format=1, primary=1)
232	request.uniqueID = uniqueID + 30
233	raid2.append(uniqueID + 30)
234	partitions.autoPartitionRequests.append(request)
235
236	request = partRequests.PartitionSpec(fileSystemTypeGet("software RAID"),
237	size=1500/(len(drives)-spares-max(0,level-4)),
238	drive=[drive], grow=1, primary=1, format=1)
239	request.uniqueID = uniqueID + 60
240	raid3.append(uniqueID + 60)
241	partitions.autoPartitionRequests.append(request)
242
243	uniqueID = uniqueID + 1
244
245	partitions.autoPartitionRequests.append(partRequests.RaidRequestSpec(fileSystemTypeGet("ext3"),
246	mountpoint="/boot", raidmembers=raid1, raidlevel="RAID1", raidminor=1, format=1,
247	raidspares=0))
248
249	if not self.cmdline.has_key("nolvm"):
250	request = partRequests.RaidRequestSpec(fileSystemTypeGet("physical volume (LVM)"),
251	raidmembers=raid2, raidlevel="RAID"+str(level), raidminor=2, format=1,
252	raidspares=spares)
253	request.uniqueID = 200
254	partitions.autoPartitionRequests.append(request)
255	else:
256	partitions.autoPartitionRequests.append(partRequests.RaidRequestSpec(fileSystemTypeGet("swap"),
257	raidmembers=raid2, raidlevel="RAID"+str(level), raidminor=2, format=1, raidspares=spares))
258
259	partitions.autoPartitionRequests.append(partRequests.RaidRequestSpec(fileSystemTypeGet("ext3"),
260	mountpoint="/", raidmembers=raid3, raidlevel="RAID"+str(level), raidminor=3, format=1,
261	raidspares=spares))
262
263	else:
264	for drive in drives:
265	partitions.autoPartitionRequests.append(partRequests.PartitionSpec(fileSystemTypeGet("ext3"),
266	mountpoint="/boot", drive=[drive], size=100, primary=1, format=1))
267
268	if not self.cmdline.has_key("nolvm"):
269	request = partRequests.PartitionSpec(fileSystemTypeGet("physical volume (LVM)"),
270	drive=[drive], size=swapMin+4096, grow=1, primary=1, format=1)
271	request.uniqueID = 200
272	partitions.autoPartitionRequests.append(request)
273	else:
274	partitions.autoPartitionRequests.append(partRequests.PartitionSpec(fileSystemTypeGet("ext3"),
275	mountpoint="/", drive=[drive], size=4096, grow=1, primary=1, format=1))
276
277	partitions.autoPartitionRequests.append(partRequests.PartitionSpec(fileSystemTypeGet("swap"),
278	drive=[drive], size=swapMin, maxSizeMB=swapMax, grow=1, primary=1, format=1))
279
280	if not self.cmdline.has_key("nolvm"):
281	request = partRequests.VolumeGroupRequestSpec(vgname="main", physvols=[200], pesize=32768, format=1)
282	request.uniqueID = 201
283	partitions.autoPartitionRequests.append(request)
284
285	if not self.cmdline.has_key("multipart"):
286	partitions.autoPartitionRequests.append(partRequests.LogicalVolumeRequestSpec(fileSystemTypeGet("ext3"),
287	mountpoint="/", size=1300, volgroup=201, lvname="root", grow=1, format=1))
288
289	partitions.autoPartitionRequests.append(partRequests.LogicalVolumeRequestSpec(fileSystemTypeGet("swap"),
290	size=swapMin, maxSizeMB=swapMax, volgroup=201, lvname="swap", grow=1, format=1))
291	else:
292	partitions.autoPartitionRequests.append(partRequests.LogicalVolumeRequestSpec(fileSystemTypeGet("ext3"),
293	mountpoint="/", size=2048, maxSizeMB=4096, volgroup=201, lvname="root", grow=1, format=1))
294
295	partitions.autoPartitionRequests.append(partRequests.LogicalVolumeRequestSpec(fileSystemTypeGet("ext3"),
296	mountpoint="/var", size=1024, maxSizeMB=4096, volgroup=201, lvname="var", grow=1, format=1))
297
298	partitions.autoPartitionRequests.append(partRequests.LogicalVolumeRequestSpec(fileSystemTypeGet("ext3"),
299	mountpoint="/home/e-smith/files", size=1024, maxSizeMB=8192, volgroup=201, lvname="files", grow=1, format=1))
300
301	partitions.autoPartitionRequests.append(partRequests.LogicalVolumeRequestSpec(fileSystemTypeGet("ext3"),
302	mountpoint="/tmp", size=512, maxSizeMB=4096, volgroup=201, lvname="tmp", grow=1, format=1))
303
304	partitions.autoPartitionRequests.append(partRequests.LogicalVolumeRequestSpec(fileSystemTypeGet("swap"),
305	size=swapMin, maxSizeMB=swapMax, volgroup=201, lvname="swap", grow=1, format=1))
306
307	partitions.autoClearPartType = CLEARPART_TYPE_ALL
308	partitions.autoClearPartDrives = drives
309	self.doPartition = False
310	else:
311	log("Not useable drives found. Enabling manual partitioning.")
312	self.doPartition = True
313	BaseInstallClass.setDefaultPartitioning(self, partitions, clear, doClear)
314
315	def setAsHeadless(self, dispatch, isHeadless = 0):
316	if isHeadless == 0:
317	pass
318	else:
319	dispatch.skipStep("handleX11pkgs", permanent = 1)
320	dispatch.skipStep("videocard", permanent = 1)
321	dispatch.skipStep("monitor", permanent = 1)
322	dispatch.skipStep("xcustom", permanent = 1)
323	dispatch.skipStep("writexconfig", permanent = 1)
324
325	def setGroupSelection(self, grpset, intf):
326	grpset.unselectAll()
327	grpset.selectGroup("Base")
328
329	def postAction(self, rootPath, serial, intf):
330	win = intf.waitWindow(_("Post Install Script"),
331	_("The post installation script is running..."))
332
333	script = ( "/sbin/syslogd &\n"
334	"sleep 2\n"
335	"/sbin/e-smith/signal-event post-install\n" )
336	s = Script(script, interp="/bin/sh", inChroot=1)
337	log("%s", s)
338	s.run(rootPath, serial)
339	win.pop()
340
341	def setInstallData(self, id, intf = None):
342	BaseInstallClass.setInstallData(self, id)
343	self.setAuthentication(id, useShadow=1, salt="md5")
344	self.setRootPassword(id, pw="ThisIsGoingToBeDisabledAnyway", isCrypted=0)
345	self.setZeroMbr(id, zeroMbr=1)
346	self.setClearParts(id, clear=CLEARPART_TYPE_ALL, initAll=1)
347	self.setDefaultPartitioning(id.partitions, doClear=0)
348	self.setBootloader(id, useLilo=0, location="mbr", linear=1)
349
350	def __init__(self, expert):
351	BaseInstallClass.__init__(self, expert)