product/installclasses/smeinstallclass.py

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

from autopart import getAutopartitionBoot, autoCreatePartitionRequests, autoCreateLVMPartitionRequests
from rhpl.log import log
import string
import partRequests
import partedUtils

class Script:
    def __repr__(self):
        str = ("(s: '%s' i: %s c: %d)") % \
            (self.script, self.interp, self.inChroot)
        return string.replace(str, "\n", "|")

    def __init__(self, script, interp, inChroot, logfile = None):
        self.script = script
        self.interp = interp
        self.inChroot = inChroot
        self.logfile = logfile

    def run(self, chroot, serial):
        scriptRoot = "/"
        if self.inChroot:
            scriptRoot = chroot

        path = scriptRoot + "/tmp/sme-script"

        f = open(path, "w")
        f.write(self.script)
        f.close()
        os.chmod(path, 0700)

        if self.logfile is not None:
            messages = self.logfile
        elif serial:
            messages = "/tmp/sme-script.log"
        else:
            messages = "/dev/tty3"

        rc = iutil.execWithRedirect(self.interp,
                                    [self.interp,"/tmp/sme-script"],
                                    stdout = messages, stderr = messages,
                                    root = scriptRoot)

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

        os.unlink(path)

class InstallClass(BaseInstallClass):
    id = "smeserver"
    name = N_("New _SME Server Install")
    pixmap = "smeserver.png"
    description = N_("This option performs a new install of "
                     "SME Server.  All attached hard drives "
                     "will be repartitioned and formated.")

    sortPriority = 1
    doPartition = False
    cmdline = {}

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

    def requiredDisplayMode(self):
        return 't'

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

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

            cmdlineDict[key] = val

        return cmdlineDict

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

    def setSteps(self, dispatch):
        dispatch.setStepList(
                 "language",
                 "keyboard",
                 "findrootparts",
                 "betanag",
                 "installtype",
                 "partitionobjinit",
                 "autopartitionexecute",
                 "partition",
                 "partitiondone",
                 "bootloadersetup",
                 "languagesupport",
                 "timezone",
                 "readcomps",
                 "selectlangpackages",
                 "checkdeps",
                 "dependencies",
                 "install",
                 "enablefilesystems",
                 "migratefilesystems",
                 "setuptime",
                 "preinstallconfig",
                 "installpackages",
                 "postinstallconfig",
                 "writeconfig",
                 "instbootloader",
                 "dopostaction",
                 "writeksconfig",
                 "methodcomplete",
                 "copylogs",
                 "setfilecon",
                 "complete"
                )

        # 'partition' can be used on the command line to force
        # verification of partitions.  useful in some cases...
        if self.doPartition or self.cmdline.has_key("partition"):
            dispatch.skipStep("partition", skip = 0)
        else:
            dispatch.skipStep("partition", skip = 1)

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

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

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

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

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

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

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

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

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

                    uniqueID = uniqueID + 1

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

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

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

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

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

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

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

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

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

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

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

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

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

            partitions.autoClearPartType = CLEARPART_TYPE_ALL
            partitions.autoClearPartDrives = drives
            self.doPartition = False
        else:
            log("Not useable drives found.  Enabling manual partitioning.")
            self.doPartition = True
            BaseInstallClass.setDefaultPartitioning(self, partitions, clear, doClear)

    def setAsHeadless(self, dispatch, isHeadless = 0):
        if isHeadless == 0:
            pass
        else:
            dispatch.skipStep("handleX11pkgs", permanent = 1)
            dispatch.skipStep("videocard", permanent = 1)
            dispatch.skipStep("monitor", permanent = 1)
            dispatch.skipStep("xcustom", permanent = 1)
            dispatch.skipStep("writexconfig", permanent = 1)

    def setGroupSelection(self, grpset, intf):
        grpset.unselectAll()
        grpset.selectGroup("Base")

    def postAction(self, rootPath, serial, intf):
        win = intf.waitWindow(_("Post Install Script"),
           _("The post installation script is running..."))

        script = ( "/sbin/syslogd &\n"
                   "sleep 2\n"
                   "/sbin/e-smith/signal-event post-install\n" )
        s = Script(script, interp="/bin/sh", inChroot=1)
        log("%s", s)
        s.run(rootPath, serial)
        win.pop()

    def setInstallData(self, id, intf = None):
        BaseInstallClass.setInstallData(self, id)
        self.setAuthentication(id, useShadow=1, salt="md5")
        self.setRootPassword(id, pw="ThisIsGoingToBeDisabledAnyway", isCrypted=0)
        self.setZeroMbr(id, zeroMbr=1)
        self.setClearParts(id, clear=CLEARPART_TYPE_ALL, initAll=1)
        self.setDefaultPartitioning(id.partitions, doClear=0)
        self.setBootloader(id, useLilo=0, location="mbr", linear=1)

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