updates/installclasses/smeinstallclass.py

from installclass import BaseInstallClass
from rhpl.translate import N_, _
from constants import *
import os
import iutil
from fsset import *
from flags import flags

from autopart import getAutopartitionBoot, autoCreatePartitionRequests, autoCreateLVMPartitionRequests

import logging
log = logging.getLogger("anaconda")

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):
        import tempfile
        import os.path

        if self.inChroot:
            scriptRoot = chroot
        else:
            scriptRoot = "/"

        (fd, path) = tempfile.mkstemp("", "sme-script-", scriptRoot + "/tmp")

        os.write(fd, self.script)
        os.close(fd)
        os.chmod(path, 0700)

        if self.logfile is not None:
            messages = self.logfile
        elif serial:
            messages = "%s.log" % path
        else:
            messages = "/dev/tty3"

        rc = iutil.execWithRedirect(self.interp, ["/tmp/%s" % os.path.basename(path)],
                                    stdin = messages, stdout = messages, stderr = messages,
                                    root = scriptRoot)

        if rc != 0:
            log.error("WARNING - Error code %s encountered running a sme script", rc)

        os.unlink(path)
        if serial or self.logfile is not None:
            os.chmod("%s" % messages, 0600)

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

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

    def requiredDisplayMode(self):
        return 't'

    def driveIsRemovable(self, device):
        try:
            removable = bool(int(open("/sys/block/%s/removable" % device).read()))
        except:
            removable = False
            
        return removable

    def setSteps(self, dispatch):
        dispatch.setStepList(
                 "language",
                 "keyboard",
                 "findrootparts",
                 "betanag",
                 "installtype",
                 "partitionobjinit",
                 "autopartitionexecute",
                 "parttype",
                 "partition",
                 "partitiondone",
                 "bootloadersetup",
                 "timezone",
                 "reposetup",
                 "basepkgsel",
                 "postselection",
                 "confirminstall",
                 "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 flags.cmdline.has_key("partition"):
            if not self.doPartition:
                dispatch.skipStep("parttype", skip = 1)
            dispatch.skipStep("partition", skip = 0)
        else:
            dispatch.skipStep("parttype", skip = 1)
            dispatch.skipStep("partition", skip = 1)

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

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

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

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

        if flags.cmdline.has_key("raid") and flags.cmdline["raid"] in ["none","0","1","5","6"]:
            if flags.cmdline["raid"] == "none":
                level = 0
            else:
                level = int(flags.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 flags.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.info("Using the following drives: %s" % drives)
            log.info("Excluding the following drives: %s" % excluded)
            if level >= 1:
                log.info("Installing using RAID%s" % level)
                log.info("Using %s spare drives" % spares)
            else:
                log.warning("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 flags.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 flags.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 flags.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 flags.cmdline.has_key("nolvm"):
                request = partRequests.VolumeGroupRequestSpec(vgname="main", physvols=[200], pesize=32768, format=1)
                request.uniqueID = 201
                partitions.autoPartitionRequests.append(request)

                if not flags.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.warning("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 postAction(self, anaconda, serial):
        win = anaconda.intf.waitWindow(_("Post Install Script"),
           _("The post installation script is running..."))

        script = ( "#!/bin/sh\nmkdir -p /var/lib/dhcp; /sbin/syslogd ; sleep 2; /sbin/e-smith/signal-event post-install\n" )
        s = Script(script, interp="/bin/sh", inChroot=1)
        log.info("%s", s)
        s.run(anaconda.rootPath, serial)
        win.pop()

    def setInstallData(self, anaconda):
        BaseInstallClass.setInstallData(self, anaconda)
        self.setDefaultPartitioning(anaconda.id.partitions, CLEARPART_TYPE_ALL)
        self.setSELinux(anaconda.id, SELINUX_DISABLED)

    def setGroupSelection(self, anaconda):
        BaseInstallClass.__init__(self, anaconda.backend)
        anaconda.backend.selectGroup("Base")
        anaconda.backend.selectGroup("Core")
        anaconda.backend.selectGroup("Extras")
        anaconda.backend.selectGroup("SME Server")

    def __init__(self, expert):
        BaseInstallClass.__init__(self, expert)
        self.repopaths = { "base": "%s" %(productPath,) }
        self.forceTextMode = 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	from flags import flags
8
9	from autopart import getAutopartitionBoot, autoCreatePartitionRequests, autoCreateLVMPartitionRequests
10
11	import logging
12	log = logging.getLogger("anaconda")
13
14	import string
15	import partRequests
16	import partedUtils
17
18	class Script:
19	def __repr__(self):
20	str = ("(s: '%s' i: %s c: %d)") % \
21	(self.script, self.interp, self.inChroot)
22	return string.replace(str, "\n", "\|")
23
24	def __init__(self, script, interp, inChroot, logfile = None):
25	self.script = script
26	self.interp = interp
27	self.inChroot = inChroot
28	self.logfile = logfile
29
30	def run(self, chroot, serial):
31	import tempfile
32	import os.path
33
34	if self.inChroot:
35	scriptRoot = chroot
36	else:
37	scriptRoot = "/"
38
39	(fd, path) = tempfile.mkstemp("", "sme-script-", scriptRoot + "/tmp")
40
41	os.write(fd, self.script)
42	os.close(fd)
43	os.chmod(path, 0700)
44
45	if self.logfile is not None:
46	messages = self.logfile
47	elif serial:
48	messages = "%s.log" % path
49	else:
50	messages = "/dev/tty3"
51
52	rc = iutil.execWithRedirect(self.interp, ["/tmp/%s" % os.path.basename(path)],
53	stdin = messages, stdout = messages, stderr = messages,
54	root = scriptRoot)
55
56	if rc != 0:
57	log.error("WARNING - Error code %s encountered running a sme script", rc)
58
59	os.unlink(path)
60	if serial or self.logfile is not None:
61	os.chmod("%s" % messages, 0600)
62
63	class InstallClass(BaseInstallClass):
64	id = "smeserver"
65	name = N_("New _SME Server Install")
66	pixmap = "smeserver.png"
67	description = N_("This option performs a new install of "
68	"SME Server. All attached hard drives "
69	"will be repartitioned and formated.")
70
71	sortPriority = 1
72	doPartition = False
73
74	parentClass = ( _("Install SME Server"), "smeserver.png" )
75
76	def requiredDisplayMode(self):
77	return 't'
78
79	def driveIsRemovable(self, device):
80	try:
81	removable = bool(int(open("/sys/block/%s/removable" % device).read()))
82	except:
83	removable = False
84
85	return removable
86
87	def setSteps(self, dispatch):
88	dispatch.setStepList(
89	"language",
90	"keyboard",
91	"findrootparts",
92	"betanag",
93	"installtype",
94	"partitionobjinit",
95	"autopartitionexecute",
96	"parttype",
97	"partition",
98	"partitiondone",
99	"bootloadersetup",
100	"timezone",
101	"reposetup",
102	"basepkgsel",
103	"postselection",
104	"confirminstall",
105	"install",
106	"enablefilesystems",
107	"migratefilesystems",
108	"setuptime",
109	"preinstallconfig",
110	"installpackages",
111	"postinstallconfig",
112	"writeconfig",
113	"instbootloader",
114	"dopostaction",
115	"writeksconfig",
116	"methodcomplete",
117	"copylogs",
118	"setfilecon",
119	"complete"
120	)
121
122	# 'partition' can be used on the command line to force
123	# verification of partitions. useful in some cases...
124	if self.doPartition or flags.cmdline.has_key("partition"):
125	if not self.doPartition:
126	dispatch.skipStep("parttype", skip = 1)
127	dispatch.skipStep("partition", skip = 0)
128	else:
129	dispatch.skipStep("parttype", skip = 1)
130	dispatch.skipStep("partition", skip = 1)
131
132	def setDefaultPartitioning(self, partitions, clear = CLEARPART_TYPE_LINUX, doClear = 1):
133	diskset = partedUtils.DiskSet()
134
135	if flags.cmdline.has_key("exclude"):
136	alldrives = filter(lambda x:not x in flags.cmdline["exclude"].split(","), diskset.driveList())
137	else:
138	alldrives = diskset.driveList()
139
140	if flags.cmdline.has_key("drives"):
141	if flags.cmdline["drives"] == "all":
142	drives = filter(lambda x:isys.mediaPresent(x), alldrives)
143	else:
144	drives = filter(lambda x:isys.mediaPresent(x) and
145	x in flags.cmdline["drives"].split(","), alldrives)
146	else:
147	drives = filter(lambda x:not self.driveIsRemovable(x) and
148	isys.mediaPresent(x) and
149	not isys.driveUsesModule(x, ["usb-storage", "ub", "sbp2"]), alldrives)
150
151	if flags.cmdline.has_key("spares"):
152	if flags.cmdline["spares"] == "none":
153	spares = 0
154	else:
155	try:
156	spares = max(0,min(int(flags.cmdline["spares"]),len(drives)-2))
157	except:
158	spares = (len(drives)+4)/7
159	else:
160	spares = (len(drives)+4)/7
161
162	if flags.cmdline.has_key("raid") and flags.cmdline["raid"] in ["none","0","1","5","6"]:
163	if flags.cmdline["raid"] == "none":
164	level = 0
165	else:
166	level = int(flags.cmdline["raid"])
167	if level == 0:
168	del drives[1:]
169	spares = 0
170	if level == 6 and len(drives)-spares < 4:
171	level = 5
172	if level == 5 and len(drives)-spares < 3:
173	level = 1
174	if level == 1:
175	if spares > 1 and not flags.cmdline.has_key("spares"):
176	spares = 1
177	del drives[2+spares:]
178	else:
179	if len(drives) - spares >= 6:
180	level = 6
181	elif len(drives) - spares >= 3:
182	level = 5
183	else:
184	level = 1
185
186	if len(drives) >= 1:
187	excluded = filter(lambda x:x not in drives, diskset.driveList())
188	log.info("Using the following drives: %s" % drives)
189	log.info("Excluding the following drives: %s" % excluded)
190	if level >= 1:
191	log.info("Installing using RAID%s" % level)
192	log.info("Using %s spare drives" % spares)
193	else:
194	log.warning("Installing without using RAID")
195
196	(swapMin, swapMax) = iutil.swapSuggestion()
197	if level >= 1:
198	raid1 = []
199	raid2 = []
200	raid3 = []
201	uniqueID = 100
202
203	for drive in drives:
204	request = partRequests.PartitionSpec(fileSystemTypeGet("software RAID"),
205	drive=[drive], size=100, primary=1, format=1)
206	request.uniqueID = uniqueID
207	raid1.append(uniqueID)
208	partitions.autoPartitionRequests.append(request)
209
210	if not flags.cmdline.has_key("nolvm"):
211	request = partRequests.PartitionSpec(fileSystemTypeGet("software RAID"),
212	size=(swapMin+4096)/(len(drives)-spares-max(0,level-4)),
213	drive=[drive], primary=1, grow=1, format=1)
214	request.uniqueID = uniqueID + 50
215	raid2.append(uniqueID + 50)
216	partitions.autoPartitionRequests.append(request)
217	else:
218	request = partRequests.PartitionSpec(fileSystemTypeGet("software RAID"),
219	drive=[drive], size=swapMin/(len(drives)-spares-max(0,level-4))+10, grow=1,
220	maxSizeMB=swapMax/(len(drives)-spares-max(0,level-4)), format=1, primary=1)
221	request.uniqueID = uniqueID + 30
222	raid2.append(uniqueID + 30)
223	partitions.autoPartitionRequests.append(request)
224
225	request = partRequests.PartitionSpec(fileSystemTypeGet("software RAID"),
226	size=1500/(len(drives)-spares-max(0,level-4)),
227	drive=[drive], grow=1, primary=1, format=1)
228	request.uniqueID = uniqueID + 60
229	raid3.append(uniqueID + 60)
230	partitions.autoPartitionRequests.append(request)
231
232	uniqueID = uniqueID + 1
233
234	partitions.autoPartitionRequests.append(partRequests.RaidRequestSpec(fileSystemTypeGet("ext3"),
235	mountpoint="/boot", raidmembers=raid1, raidlevel="RAID1", raidminor=1, format=1,
236	raidspares=0))
237
238	if not flags.cmdline.has_key("nolvm"):
239	request = partRequests.RaidRequestSpec(fileSystemTypeGet("physical volume (LVM)"),
240	raidmembers=raid2, raidlevel="RAID"+str(level), raidminor=2, format=1,
241	raidspares=spares)
242	request.uniqueID = 200
243	partitions.autoPartitionRequests.append(request)
244	else:
245	partitions.autoPartitionRequests.append(partRequests.RaidRequestSpec(fileSystemTypeGet("swap"),
246	raidmembers=raid2, raidlevel="RAID"+str(level), raidminor=2, format=1, raidspares=spares))
247
248	partitions.autoPartitionRequests.append(partRequests.RaidRequestSpec(fileSystemTypeGet("ext3"),
249	mountpoint="/", raidmembers=raid3, raidlevel="RAID"+str(level), raidminor=3, format=1,
250	raidspares=spares))
251
252	else:
253	for drive in drives:
254	partitions.autoPartitionRequests.append(partRequests.PartitionSpec(fileSystemTypeGet("ext3"),
255	mountpoint="/boot", drive=[drive], size=100, primary=1, format=1))
256
257	if not flags.cmdline.has_key("nolvm"):
258	request = partRequests.PartitionSpec(fileSystemTypeGet("physical volume (LVM)"),
259	drive=[drive], size=swapMin+4096, grow=1, primary=1, format=1)
260	request.uniqueID = 200
261	partitions.autoPartitionRequests.append(request)
262	else:
263	partitions.autoPartitionRequests.append(partRequests.PartitionSpec(fileSystemTypeGet("ext3"),
264	mountpoint="/", drive=[drive], size=4096, grow=1, primary=1, format=1))
265
266	partitions.autoPartitionRequests.append(partRequests.PartitionSpec(fileSystemTypeGet("swap"),
267	drive=[drive], size=swapMin, maxSizeMB=swapMax, grow=1, primary=1, format=1))
268
269	if not flags.cmdline.has_key("nolvm"):
270	request = partRequests.VolumeGroupRequestSpec(vgname="main", physvols=[200], pesize=32768, format=1)
271	request.uniqueID = 201
272	partitions.autoPartitionRequests.append(request)
273
274	if not flags.cmdline.has_key("multipart"):
275	partitions.autoPartitionRequests.append(partRequests.LogicalVolumeRequestSpec(fileSystemTypeGet("ext3"),
276	mountpoint="/", size=1300, volgroup=201, lvname="root", grow=1, format=1))
277
278	partitions.autoPartitionRequests.append(partRequests.LogicalVolumeRequestSpec(fileSystemTypeGet("swap"),
279	size=swapMin, maxSizeMB=swapMax, volgroup=201, lvname="swap", grow=1, format=1))
280	else:
281	partitions.autoPartitionRequests.append(partRequests.LogicalVolumeRequestSpec(fileSystemTypeGet("ext3"),
282	mountpoint="/", size=2048, maxSizeMB=4096, volgroup=201, lvname="root", grow=1, format=1))
283
284	partitions.autoPartitionRequests.append(partRequests.LogicalVolumeRequestSpec(fileSystemTypeGet("ext3"),
285	mountpoint="/var", size=1024, maxSizeMB=4096, volgroup=201, lvname="var", grow=1, format=1))
286
287	partitions.autoPartitionRequests.append(partRequests.LogicalVolumeRequestSpec(fileSystemTypeGet("ext3"),
288	mountpoint="/home/e-smith/files", size=1024, maxSizeMB=8192, volgroup=201, lvname="files", grow=1, format=1))
289
290	partitions.autoPartitionRequests.append(partRequests.LogicalVolumeRequestSpec(fileSystemTypeGet("ext3"),
291	mountpoint="/tmp", size=512, maxSizeMB=4096, volgroup=201, lvname="tmp", grow=1, format=1))
292
293	partitions.autoPartitionRequests.append(partRequests.LogicalVolumeRequestSpec(fileSystemTypeGet("swap"),
294	size=swapMin, maxSizeMB=swapMax, volgroup=201, lvname="swap", grow=1, format=1))
295
296	partitions.autoClearPartType = CLEARPART_TYPE_ALL
297	partitions.autoClearPartDrives = drives
298	self.doPartition = False
299	else:
300	log.warning("Not useable drives found. Enabling manual partitioning.")
301	self.doPartition = True
302	BaseInstallClass.setDefaultPartitioning(self, partitions, clear, doClear)
303
304	def setAsHeadless(self, dispatch, isHeadless = 0):
305	if isHeadless == 0:
306	pass
307	else:
308	dispatch.skipStep("handleX11pkgs", permanent = 1)
309	dispatch.skipStep("videocard", permanent = 1)
310	dispatch.skipStep("monitor", permanent = 1)
311	dispatch.skipStep("xcustom", permanent = 1)
312	dispatch.skipStep("writexconfig", permanent = 1)
313
314	def postAction(self, anaconda, serial):
315	win = anaconda.intf.waitWindow(_("Post Install Script"),
316	_("The post installation script is running..."))
317
318	script = ( "#!/bin/sh\nmkdir -p /var/lib/dhcp; /sbin/syslogd ; sleep 2; /sbin/e-smith/signal-event post-install\n" )
319	s = Script(script, interp="/bin/sh", inChroot=1)
320	log.info("%s", s)
321	s.run(anaconda.rootPath, serial)
322	win.pop()
323
324	def setInstallData(self, anaconda):
325	BaseInstallClass.setInstallData(self, anaconda)
326	self.setDefaultPartitioning(anaconda.id.partitions, CLEARPART_TYPE_ALL)
327	self.setSELinux(anaconda.id, SELINUX_DISABLED)
328
329	def setGroupSelection(self, anaconda):
330	BaseInstallClass.__init__(self, anaconda.backend)
331	anaconda.backend.selectGroup("Base")
332	anaconda.backend.selectGroup("Core")
333	anaconda.backend.selectGroup("Extras")
334	anaconda.backend.selectGroup("SME Server")
335
336	def __init__(self, expert):
337	BaseInstallClass.__init__(self, expert)
338	self.repopaths = { "base": "%s" %(productPath,) }
339	self.forceTextMode = 1