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

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

        if flags.cmdline.has_key("spares"):
            spares = max(0,min(int(flags.cmdline["spares"]),len(drives)-2))
        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

        log.info("Using the following drives: %s" % drives)
        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 len(drives) >= 1:
            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 = clear
            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	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			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			sortPriority = 1
71			doPartition = False
72
73			parentClass = ( _("Install SME Server"), "smeserver.png" )
74
75			def requiredDisplayMode(self):
76			return 't'
77
78			def setSteps(self, dispatch):
79			dispatch.setStepList(
80			"language",
81			"keyboard",
82			"findrootparts",
83			"betanag",
84			"installtype",
85			"partitionobjinit",
86			"autopartitionexecute",
87			"parttype",
88			"partition",
89			"partitiondone",
90			"bootloadersetup",
91			"timezone",
92			"reposetup",
93			"basepkgsel",
94			"postselection",
95			"confirminstall",
96			"install",
97			"enablefilesystems",
98			"migratefilesystems",
99			"setuptime",
100			"preinstallconfig",
101			"installpackages",
102			"postinstallconfig",
103			"writeconfig",
104			"instbootloader",
105			"dopostaction",
106			"writeksconfig",
107			"methodcomplete",
108			"copylogs",
109			"setfilecon",
110			"complete"
111			)
112
113			# 'partition' can be used on the command line to force
114			# verification of partitions. useful in some cases...
115			if self.doPartition or flags.cmdline.has_key("partition"):
116			if not self.doPartition:
117			dispatch.skipStep("parttype", skip = 1)
118			dispatch.skipStep("partition", skip = 0)
119			else:
120			dispatch.skipStep("parttype", skip = 1)
121			dispatch.skipStep("partition", skip = 1)
122
123			def setDefaultPartitioning(self, partitions, clear = CLEARPART_TYPE_LINUX, doClear = 1):
124			diskset = partedUtils.DiskSet()
125
126			alldrives = diskset.driveList()
127			if flags.cmdline.has_key("drives"):
128			drives = filter(lambda x:isys.mediaPresent(x) and x in flags.cmdline["drives"].split(","), alldrives)
129			else:
130			drives = filter(lambda x:isys.mediaPresent(x) and not isys.driveUsesModule(x, ["usb-storage", "sbp2"]), alldrives)
131
132			if flags.cmdline.has_key("spares"):
133			spares = max(0,min(int(flags.cmdline["spares"]),len(drives)-2))
134			else:
135			spares = (len(drives)+4)/7
136
137			if flags.cmdline.has_key("raid") and flags.cmdline["raid"] in ["none","0","1","5","6"]:
138			if flags.cmdline["raid"] == "none":
139			level = 0
140			else:
141			level = int(flags.cmdline["raid"])
142			if level == 0:
143			del drives[1:]
144			spares = 0
145			if level == 6 and len(drives)-spares < 4:
146			level = 5
147			if level == 5 and len(drives)-spares < 3:
148			level = 1
149			if level == 1:
150			if spares > 1 and not flags.cmdline.has_key("spares"):
151			spares = 1
152			del drives[2+spares:]
153			else:
154			if len(drives) - spares >= 6:
155			level = 6
156			elif len(drives) - spares >= 3:
157			level = 5
158			else:
159			level = 1
160
161			log.info("Using the following drives: %s" % drives)
162			if level >= 1:
163			log.info("Installing using RAID%s" % level)
164			log.info("Using %s spare drives" % spares)
165			else:
166			log.warning("Installing without using RAID")
167
168			(swapMin, swapMax) = iutil.swapSuggestion()
169			if len(drives) >= 1:
170			if level >= 1:
171			raid1 = []
172			raid2 = []
173			raid3 = []
174			uniqueID = 100
175
176			for drive in drives:
177			request = partRequests.PartitionSpec(fileSystemTypeGet("software RAID"),
178			drive=[drive], size=100, primary=1, format=1)
179			request.uniqueID = uniqueID
180			raid1.append(uniqueID)
181			partitions.autoPartitionRequests.append(request)
182
183			if not flags.cmdline.has_key("nolvm"):
184			request = partRequests.PartitionSpec(fileSystemTypeGet("software RAID"),
185			size=(swapMin+4096)/(len(drives)-spares-max(0,level-4)),
186			drive=[drive], primary=1, grow=1, format=1)
187			request.uniqueID = uniqueID + 50
188			raid2.append(uniqueID + 50)
189			partitions.autoPartitionRequests.append(request)
190			else:
191			request = partRequests.PartitionSpec(fileSystemTypeGet("software RAID"),
192			drive=[drive], size=swapMin/(len(drives)-spares-max(0,level-4))+10, grow=1,
193			maxSizeMB=swapMax/(len(drives)-spares-max(0,level-4)), format=1, primary=1)
194			request.uniqueID = uniqueID + 30
195			raid2.append(uniqueID + 30)
196			partitions.autoPartitionRequests.append(request)
197
198			request = partRequests.PartitionSpec(fileSystemTypeGet("software RAID"),
199			size=1500/(len(drives)-spares-max(0,level-4)),
200			drive=[drive], grow=1, primary=1, format=1)
201			request.uniqueID = uniqueID + 60
202			raid3.append(uniqueID + 60)
203			partitions.autoPartitionRequests.append(request)
204
205			uniqueID = uniqueID + 1
206
207			partitions.autoPartitionRequests.append(partRequests.RaidRequestSpec(fileSystemTypeGet("ext3"),
208			mountpoint="/boot", raidmembers=raid1, raidlevel="RAID1", raidminor=1, format=1,
209			raidspares=0))
210
211			if not flags.cmdline.has_key("nolvm"):
212			request = partRequests.RaidRequestSpec(fileSystemTypeGet("physical volume (LVM)"),
213			raidmembers=raid2, raidlevel="RAID"+str(level), raidminor=2, format=1,
214			raidspares=spares)
215			request.uniqueID = 200
216			partitions.autoPartitionRequests.append(request)
217			else:
218			partitions.autoPartitionRequests.append(partRequests.RaidRequestSpec(fileSystemTypeGet("swap"),
219			raidmembers=raid2, raidlevel="RAID"+str(level), raidminor=2, format=1, raidspares=spares))
220
221			partitions.autoPartitionRequests.append(partRequests.RaidRequestSpec(fileSystemTypeGet("ext3"),
222			mountpoint="/", raidmembers=raid3, raidlevel="RAID"+str(level), raidminor=3, format=1,
223			raidspares=spares))
224
225			else:
226			for drive in drives:
227			partitions.autoPartitionRequests.append(partRequests.PartitionSpec(fileSystemTypeGet("ext3"),
228			mountpoint="/boot", drive=[drive], size=100, primary=1, format=1))
229
230			if not flags.cmdline.has_key("nolvm"):
231			request = partRequests.PartitionSpec(fileSystemTypeGet("physical volume (LVM)"),
232			drive=[drive], size=swapMin+4096, grow=1, primary=1, format=1)
233			request.uniqueID = 200
234			partitions.autoPartitionRequests.append(request)
235			else:
236			partitions.autoPartitionRequests.append(partRequests.PartitionSpec(fileSystemTypeGet("ext3"),
237			mountpoint="/", drive=[drive], size=4096, grow=1, primary=1, format=1))
238
239			partitions.autoPartitionRequests.append(partRequests.PartitionSpec(fileSystemTypeGet("swap"),
240			drive=[drive], size=swapMin, maxSizeMB=swapMax, grow=1, primary=1, format=1))
241
242			if not flags.cmdline.has_key("nolvm"):
243			request = partRequests.VolumeGroupRequestSpec(vgname="main", physvols=[200], pesize=32768, format=1)
244			request.uniqueID = 201
245			partitions.autoPartitionRequests.append(request)
246
247			if not flags.cmdline.has_key("multipart"):
248			partitions.autoPartitionRequests.append(partRequests.LogicalVolumeRequestSpec(fileSystemTypeGet("ext3"),
249			mountpoint="/", size=1300, volgroup=201, lvname="root", grow=1, format=1))
250
251			partitions.autoPartitionRequests.append(partRequests.LogicalVolumeRequestSpec(fileSystemTypeGet("swap"),
252			size=swapMin, maxSizeMB=swapMax, volgroup=201, lvname="swap", grow=1, format=1))
253			else:
254			partitions.autoPartitionRequests.append(partRequests.LogicalVolumeRequestSpec(fileSystemTypeGet("ext3"),
255			mountpoint="/", size=2048, maxSizeMB=4096, volgroup=201, lvname="root", grow=1, format=1))
256
257			partitions.autoPartitionRequests.append(partRequests.LogicalVolumeRequestSpec(fileSystemTypeGet("ext3"),
258			mountpoint="/var", size=1024, maxSizeMB=4096, volgroup=201, lvname="var", grow=1, format=1))
259
260			partitions.autoPartitionRequests.append(partRequests.LogicalVolumeRequestSpec(fileSystemTypeGet("ext3"),
261			mountpoint="/home/e-smith/files", size=1024, maxSizeMB=8192, volgroup=201, lvname="files", grow=1, format=1))
262
263			partitions.autoPartitionRequests.append(partRequests.LogicalVolumeRequestSpec(fileSystemTypeGet("ext3"),
264			mountpoint="/tmp", size=512, maxSizeMB=4096, volgroup=201, lvname="tmp", grow=1, format=1))
265
266			partitions.autoPartitionRequests.append(partRequests.LogicalVolumeRequestSpec(fileSystemTypeGet("swap"),
267			size=swapMin, maxSizeMB=swapMax, volgroup=201, lvname="swap", grow=1, format=1))
268
269			partitions.autoClearPartType = clear
270			partitions.autoClearPartDrives = drives
271			self.doPartition = False
272			else:
273			log.warning("Not useable drives found. Enabling manual partitioning.")
274			self.doPartition = True
275			BaseInstallClass.setDefaultPartitioning(self, partitions, clear, doClear)
276
277			def setAsHeadless(self, dispatch, isHeadless = 0):
278			if isHeadless == 0:
279			pass
280			else:
281			dispatch.skipStep("handleX11pkgs", permanent = 1)
282			dispatch.skipStep("videocard", permanent = 1)
283			dispatch.skipStep("monitor", permanent = 1)
284			dispatch.skipStep("xcustom", permanent = 1)
285			dispatch.skipStep("writexconfig", permanent = 1)
286
287			def postAction(self, anaconda, serial):
288			win = anaconda.intf.waitWindow(_("Post Install Script"),
289			_("The post installation script is running..."))
290
291			script = ( "#!/bin/sh\nmkdir -p /var/lib/dhcp; /sbin/syslogd ; sleep 2; /sbin/e-smith/signal-event post-install\n" )
292			s = Script(script, interp="/bin/sh", inChroot=1)
293			log.info("%s", s)
294			s.run(anaconda.rootPath, serial)
295			win.pop()
296
297			def setInstallData(self, anaconda):
298			BaseInstallClass.setInstallData(self, anaconda)
299			self.setDefaultPartitioning(anaconda.id.partitions, CLEARPART_TYPE_ALL)
300			self.setSELinux(anaconda.id, SELINUX_DISABLED)
301
302			def setGroupSelection(self, anaconda):
303			BaseInstallClass.__init__(self, anaconda.backend)
304			anaconda.backend.selectGroup("Base")
305			anaconda.backend.selectGroup("Core")
306			anaconda.backend.selectGroup("Extras")
307			anaconda.backend.selectGroup("SME Server")
308
309			def __init__(self, expert):
310			BaseInstallClass.__init__(self, expert)
311			self.repopaths = { "base": "%s" %(productPath,) }
312			self.forceTextMode = 1