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	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.4	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	slords	1.2	if self.cmdline.has_key("drives"):
152	slords	1.4	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	slords	1.2	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	slords	1.1
162	slords	1.2	if self.cmdline.has_key("spares"):
163	slords	1.4	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	slords	1.2	else:
171			spares = (len(drives)+4)/7
172	slords	1.1
173	slords	1.2	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	slords	1.1
197	slords	1.2	if len(drives) >= 1:
198	slords	1.4	excluded = filter(lambda x:x not in drives, diskset.driveList())
199	slords	1.2	log("Using the following drives: %s" % drives)
200	slords	1.4	log("Excluding the following drives: %s" % excluded)
201	slords	1.2	if level >= 1:
202			log("Installing using RAID%s" % level)
203			log("Using %s spare drives" % spares)
204	slords	1.1	else:
205	slords	1.2	log("Installing without using RAID")
206
207			(swapMin, swapMax) = iutil.swapSuggestion()
208			if level >= 1:
209	slords	1.1	raid1 = []
210			raid2 = []
211			raid3 = []
212	slords	1.2	uniqueID = 100
213	slords	1.1
214	slords	1.2	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	slords	1.1
221	slords	1.2	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	slords	1.1	else:
229	slords	1.2	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	slords	1.1
236	slords	1.2	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	slords	1.1	partitions.autoPartitionRequests.append(request)
242
243	slords	1.2	uniqueID = uniqueID + 1
244	slords	1.1
245	slords	1.2	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	slords	1.1	partitions.autoPartitionRequests.append(request)
255	slords	1.2	else:
256			partitions.autoPartitionRequests.append(partRequests.RaidRequestSpec(fileSystemTypeGet("swap"),
257			raidmembers=raid2, raidlevel="RAID"+str(level), raidminor=2, format=1, raidspares=spares))
258	slords	1.1
259	slords	1.2	partitions.autoPartitionRequests.append(partRequests.RaidRequestSpec(fileSystemTypeGet("ext3"),
260	slords	1.3	mountpoint="/", raidmembers=raid3, raidlevel="RAID"+str(level), raidminor=3, format=1,
261	slords	1.2	raidspares=spares))
262
263			else:
264			for drive in drives:
265			partitions.autoPartitionRequests.append(partRequests.PartitionSpec(fileSystemTypeGet("ext3"),
266	slords	1.3	mountpoint="/boot", drive=[drive], size=100, primary=1, format=1))
267	slords	1.2
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	slords	1.1
277	slords	1.2	partitions.autoPartitionRequests.append(partRequests.PartitionSpec(fileSystemTypeGet("swap"),
278			drive=[drive], size=swapMin, maxSizeMB=swapMax, grow=1, primary=1, format=1))
279	slords	1.1
280	slords	1.2	if not self.cmdline.has_key("nolvm"):
281			request = partRequests.VolumeGroupRequestSpec(vgname="main", physvols=[200], pesize=32768, format=1)
282	slords	1.1	request.uniqueID = 201
283			partitions.autoPartitionRequests.append(request)
284
285	slords	1.2	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	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			else:
292			partitions.autoPartitionRequests.append(partRequests.LogicalVolumeRequestSpec(fileSystemTypeGet("ext3"),
293			mountpoint="/", size=2048, maxSizeMB=4096, volgroup=201, lvname="root", grow=1, format=1))
294	slords	1.1
295	slords	1.2	partitions.autoPartitionRequests.append(partRequests.LogicalVolumeRequestSpec(fileSystemTypeGet("ext3"),
296			mountpoint="/var", size=1024, maxSizeMB=4096, volgroup=201, lvname="var", grow=1, format=1))
297	slords	1.1
298	slords	1.2	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	slords	1.1
301	slords	1.2	partitions.autoPartitionRequests.append(partRequests.LogicalVolumeRequestSpec(fileSystemTypeGet("ext3"),
302			mountpoint="/tmp", size=512, maxSizeMB=4096, volgroup=201, lvname="tmp", grow=1, format=1))
303	slords	1.1
304	slords	1.2	partitions.autoPartitionRequests.append(partRequests.LogicalVolumeRequestSpec(fileSystemTypeGet("swap"),
305			size=swapMin, maxSizeMB=swapMax, volgroup=201, lvname="swap", grow=1, format=1))
306	slords	1.1
307	slords	1.2	partitions.autoClearPartType = CLEARPART_TYPE_ALL
308			partitions.autoClearPartDrives = drives
309			self.doPartition = False
310	slords	1.1	else:
311	slords	1.2	log("Not useable drives found. Enabling manual partitioning.")
312			self.doPartition = True
313	slords	1.1	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)