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

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

    def requiredDisplayMode(self):
        return 't'

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

        # 'partition' can be used on the command line to force 
        # verification of partitions.  useful in some cases...
        cmdline = open("/proc/cmdline", "r").read()
        cmdline = cmdline.split()
        if "partition" in cmdline:
            dispatch.skipStep("partition", skip = 0)
        else:
            dispatch.skipStep("partition", skip = 1)

    def setDefaultPartitioning(self, partitions, clear = CLEARPART_TYPE_LINUX, doClear = 1):
        uniqueID = 100
        (swapMin, swapMax) = iutil.swapSuggestion()
        diskset = partedUtils.DiskSet()
        drives = diskset.driveList()

        spares = 0
        useable = 0
        for drive in drives:
            if not isys.driveIsRemovable(drive):
                useable = useable + 1

        if useable > 0:
            if "noraid" in cmdline:
                for drive in drives:
                    if not isys.driveIsRemovable(drive):
                        filesystem = fileSystemTypeGet("ext3")
                        request = partRequests.PartitionSpec(filesystem, mountpoint="/boot", drive=[drive],
                                size=100, primary=1, format=1)
                        partitions.autoPartitionRequests.append(request)

                        if "nolvm" in cmdline:
                            filesystem = fileSystemTypeGet("ext3")
                            request = partRequests.PartitionSpec(filesystem, mountpoint="/", drive=[drive],
                                    size=1300, grow=1, primary=1, format=1)
                            partitions.autoPartitionRequests.append(request)

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

                        else:
                            filesystem = fileSystemTypeGet("physical volume (LVM)")
                            request = partRequests.PartitionSpec(filesystem, drive=[drive], size=swapMin+1500,
                                    grow=1, primary=1, format=1)
                            request.uniqueID = 200
                            partitions.autoPartitionRequests.append(request)

                        break

            else:
                raid1 = []
                raid2 = []
                raid3 = []

                if "raid1" in cmdline and useable > 0:
                    if useable > 2 and "spare" in cmdline:
                        spares = 1
                    useable = 1
                    raidLevel = "RAID1"

                else:
                    if useable > 2 and "spare" in cmdline:
                        useable = useable - 1
                        spares = 1

                    if useable > 5:
                        useable = useable - 2
                        raidLevel = "RAID6"
                    elif useable > 1:
                        useable = useable - 1
                        if useable > 2:
                            raidLevel = "RAID5"
                        else:
                            raidLevel = "RAID1"
                    else:
                        raidLevel = "RAID1"

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

                        if "nolvm" in cmdline:
                            filesystem = fileSystemTypeGet("software RAID")
                            request = partRequests.PartitionSpec(filesystem, drive=[drive], size=swapMin/useable+10,
                                    maxSizeMB=swapMax/useable, grow=1, primary=1, format=1)
                            request.uniqueID = uniqueID + 30
                            raid2.append(uniqueID + 30)
                            partitions.autoPartitionRequests.append(request)

                            filesystem = fileSystemTypeGet("software RAID")
                            request = partRequests.PartitionSpec(filesystem, drive=[drive], size=1500/useable,
                                    grow=1, primary=1, format=1)
                            request.uniqueID = uniqueID + 60
                            raid3.append(uniqueID + 60)
                            partitions.autoPartitionRequests.append(request)

                        else:
                            filesystem = fileSystemTypeGet("software RAID")
                            request = partRequests.PartitionSpec(filesystem, drive=[drive], size=(swapMin+1500)/useable,
                                    grow=1, format=1)
                            request.uniqueID = uniqueID + 50
                            raid2.append(uniqueID + 50)
                            partitions.autoPartitionRequests.append(request)

                        uniqueID = uniqueID + 1

                        if "raid1" in cmdline and len(raid1)-spares > 1:
                            break

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

                if "nolvm" in cmdline:
                    filesystem = fileSystemTypeGet("swap")
                    request = partRequests.RaidRequestSpec(filesystem, raidmembers=raid2,  raidminor=2,
                            raidlevel=raidLevel, format=1, raidspares=spares)
                    partitions.autoPartitionRequests.append(request)

                    filesystem = fileSystemTypeGet("ext3")
                    request = partRequests.RaidRequestSpec(filesystem, mountpoint="/", raidmembers=raid3,  raidminor=3,
                            raidlevel=raidLevel, format=1, raidspares=spares)
                    partitions.autoPartitionRequests.append(request)

                else:
                    filesystem = fileSystemTypeGet("physical volume (LVM)")
                    request = partRequests.RaidRequestSpec(filesystem, raidmembers=raid2,  raidminor=2,
                            raidlevel=raidLevel, format=1, raidspares=spares)
                    request.uniqueID = 200
                    partitions.autoPartitionRequests.append(request)

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

                filesystem = fileSystemTypeGet("ext3")
                request = partRequests.LogicalVolumeRequestSpec(filesystem, mountpoint="/", size=1300, 
                        volgroup=201, lvname="root", grow=1, format=1)
                partitions.autoPartitionRequests.append(request)

                filesystem = fileSystemTypeGet("swap")
                request = partRequests.LogicalVolumeRequestSpec(filesystem, size=swapMin, maxSizeMB=swapMax, 
                        volgroup=201, lvname="swap", grow=1, format=1)
                partitions.autoPartitionRequests.append(request)
        else:
            dispatch.skipStep("partition", skip = 0)
            BaseInstallClass.setDefaultPartitioning(self, partitions, clear, doClear)

    def setAsHeadless(self, dispatch, isHeadless = 0):
        if isHeadless == 0:
            pass
        else:
#           dispatch.skipStep("keyboard", permanent = 1)
#           dispatch.skipStep("mouse", permanent = 1)
            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, useMd5=1)
        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	slords	1.13	from rhpl.translate import N_, _
3	slords	1.12	from constants import *
4			import os
5			import iutil
6	slords	1.13	from fsset import *
7	slords	1.12
8	slords	1.1	from autopart import getAutopartitionBoot, autoCreatePartitionRequests, autoCreateLVMPartitionRequests
9			from rhpl.log import log
10	slords	1.2	import string
11	slords	1.1	import partRequests
12			import partedUtils
13
14	slords	1.2	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	slords	1.1	class InstallClass(BaseInstallClass):
56	slords	1.2	id = "smeserver"
57			name = N_("New _SME Server Install")
58			pixmap = "smeserver.png"
59	slords	1.3	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.1	sortPriority = 1
63
64	slords	1.2	parentClass = ( _("Install SME Server"), "smeserver.png" )
65	slords	1.1
66			def requiredDisplayMode(self):
67			return 't'
68
69			def setSteps(self, dispatch):
70			dispatch.setStepList(
71			"language",
72			"keyboard",
73			"findrootparts",
74	slords	1.4	"findinstall",
75			"installtype",
76	slords	1.1	"partitionobjinit",
77			"autopartitionexecute",
78	slords	1.2	"partition",
79	slords	1.1	"partitiondone",
80			"bootloadersetup",
81	slords	1.7	"languagesupport",
82	slords	1.1	"timezone",
83			"readcomps",
84			"selectlangpackages",
85			"checkdeps",
86			"dependencies",
87			"install",
88			"enablefilesystems",
89			"migratefilesystems",
90			"setuptime",
91			"preinstallconfig",
92			"installpackages",
93			"postinstallconfig",
94			"writeconfig",
95			"instbootloader",
96			"dopostaction",
97			"methodcomplete",
98			"copylogs",
99	slords	1.11	"writeksconfig",
100	slords	1.1	"setfilecon",
101			"complete"
102			)
103
104	slords	1.2	# 'partition' can be used on the command line to force
105			# verification of partitions. useful in some cases...
106			cmdline = open("/proc/cmdline", "r").read()
107			cmdline = cmdline.split()
108			if "partition" in cmdline:
109			dispatch.skipStep("partition", skip = 0)
110			else:
111			dispatch.skipStep("partition", skip = 1)
112
113	slords	1.1	def setDefaultPartitioning(self, partitions, clear = CLEARPART_TYPE_LINUX, doClear = 1):
114	slords	1.15	uniqueID = 100
115	slords	1.16	(swapMin, swapMax) = iutil.swapSuggestion()
116			diskset = partedUtils.DiskSet()
117			drives = diskset.driveList()
118
119	slords	1.18	spares = 0
120			useable = 0
121			for drive in drives:
122			if not isys.driveIsRemovable(drive):
123			useable = useable + 1
124
125			if useable > 0:
126			if "noraid" in cmdline:
127			for drive in drives:
128			if not isys.driveIsRemovable(drive):
129	slords	1.16	filesystem = fileSystemTypeGet("ext3")
130	slords	1.18	request = partRequests.PartitionSpec(filesystem, mountpoint="/boot", drive=[drive],
131			size=100, primary=1, format=1)
132	slords	1.16	partitions.autoPartitionRequests.append(request)
133
134	slords	1.18	if "nolvm" in cmdline:
135			filesystem = fileSystemTypeGet("ext3")
136			request = partRequests.PartitionSpec(filesystem, mountpoint="/", drive=[drive],
137			size=1300, grow=1, primary=1, format=1)
138			partitions.autoPartitionRequests.append(request)
139
140			filesystem = fileSystemTypeGet("swap")
141			request = partRequests.PartitionSpec(filesystem, drive=[drive], size=swapMin,
142			maxSizeMB=swapMax, grow=1, primary=1, format=1)
143			partitions.autoPartitionRequests.append(request)
144
145			else:
146			filesystem = fileSystemTypeGet("physical volume (LVM)")
147			request = partRequests.PartitionSpec(filesystem, drive=[drive], size=swapMin+1500,
148			grow=1, primary=1, format=1)
149			request.uniqueID = 200
150			partitions.autoPartitionRequests.append(request)
151	slords	1.16
152	slords	1.18	break
153	slords	1.16
154	slords	1.18	else:
155			raid1 = []
156			raid2 = []
157			raid3 = []
158
159			if "raid1" in cmdline and useable > 0:
160			if useable > 2 and "spare" in cmdline:
161			spares = 1
162			useable = 1
163			raidLevel = "RAID1"
164
165			else:
166			if useable > 2 and "spare" in cmdline:
167			useable = useable - 1
168			spares = 1
169
170			if useable > 5:
171			useable = useable - 2
172			raidLevel = "RAID6"
173			elif useable > 1:
174			useable = useable - 1
175			if useable > 2:
176			raidLevel = "RAID5"
177			else:
178			raidLevel = "RAID1"
179	slords	1.19	else:
180			raidLevel = "RAID1"
181	slords	1.16
182	slords	1.18	for drive in drives:
183			if not isys.driveIsRemovable(drive):
184	slords	1.16	filesystem = fileSystemTypeGet("software RAID")
185	slords	1.18	request = partRequests.PartitionSpec(filesystem, drive=[drive], size=100, primary=1, format=1)
186			request.uniqueID = uniqueID
187			raid1.append(uniqueID)
188			partitions.autoPartitionRequests.append(request)
189
190			if "nolvm" in cmdline:
191			filesystem = fileSystemTypeGet("software RAID")
192	slords	1.20	request = partRequests.PartitionSpec(filesystem, drive=[drive], size=swapMin/useable+10,
193			maxSizeMB=swapMax/useable, grow=1, primary=1, format=1)
194	slords	1.18	request.uniqueID = uniqueID + 30
195	slords	1.21	raid2.append(uniqueID + 30)
196			partitions.autoPartitionRequests.append(request)
197	slords	1.20
198	slords	1.18	filesystem = fileSystemTypeGet("software RAID")
199	slords	1.20	request = partRequests.PartitionSpec(filesystem, drive=[drive], size=1500/useable,
200			grow=1, primary=1, format=1)
201	slords	1.18	request.uniqueID = uniqueID + 60
202	slords	1.21	raid3.append(uniqueID + 60)
203	slords	1.18	partitions.autoPartitionRequests.append(request)
204
205			else:
206			filesystem = fileSystemTypeGet("software RAID")
207			request = partRequests.PartitionSpec(filesystem, drive=[drive], size=(swapMin+1500)/useable,
208			grow=1, format=1)
209			request.uniqueID = uniqueID + 50
210			raid2.append(uniqueID + 50)
211			partitions.autoPartitionRequests.append(request)
212	slords	1.16
213	slords	1.18	uniqueID = uniqueID + 1
214	slords	1.16
215	slords	1.18	if "raid1" in cmdline and len(raid1)-spares > 1:
216			break
217	slords	1.16
218			filesystem = fileSystemTypeGet("ext3")
219	slords	1.18	request = partRequests.RaidRequestSpec(filesystem, mountpoint="/boot", raidminor=1,
220			raidmembers=raid1, raidlevel="RAID1", format=1, raidspares=spares)
221	slords	1.16	partitions.autoPartitionRequests.append(request)
222
223	slords	1.18	if "nolvm" in cmdline:
224	slords	1.20	filesystem = fileSystemTypeGet("swap")
225			request = partRequests.RaidRequestSpec(filesystem, raidmembers=raid2, raidminor=2,
226	slords	1.18	raidlevel=raidLevel, format=1, raidspares=spares)
227			partitions.autoPartitionRequests.append(request)
228
229	slords	1.20	filesystem = fileSystemTypeGet("ext3")
230			request = partRequests.RaidRequestSpec(filesystem, mountpoint="/", raidmembers=raid3, raidminor=3,
231	slords	1.18	raidlevel=raidLevel, format=1, raidspares=spares)
232			partitions.autoPartitionRequests.append(request)
233	slords	1.16
234	slords	1.18	else:
235			filesystem = fileSystemTypeGet("physical volume (LVM)")
236			request = partRequests.RaidRequestSpec(filesystem, raidmembers=raid2, raidminor=2,
237			raidlevel=raidLevel, format=1, raidspares=spares)
238			request.uniqueID = 200
239			partitions.autoPartitionRequests.append(request)
240	slords	1.16
241			if not "nolvm" in cmdline:
242			request = partRequests.VolumeGroupRequestSpec(vgname="main", physvols=[200],
243			pesize=32768, format=1)
244			request.uniqueID = 201
245			partitions.autoPartitionRequests.append(request)
246
247			filesystem = fileSystemTypeGet("ext3")
248			request = partRequests.LogicalVolumeRequestSpec(filesystem, mountpoint="/", size=1300,
249			volgroup=201, lvname="root", grow=1, format=1)
250			partitions.autoPartitionRequests.append(request)
251
252			filesystem = fileSystemTypeGet("swap")
253			request = partRequests.LogicalVolumeRequestSpec(filesystem, size=swapMin, maxSizeMB=swapMax,
254			volgroup=201, lvname="swap", grow=1, format=1)
255			partitions.autoPartitionRequests.append(request)
256			else:
257			dispatch.skipStep("partition", skip = 0)
258			BaseInstallClass.setDefaultPartitioning(self, partitions, clear, doClear)
259
260	slords	1.14	def setAsHeadless(self, dispatch, isHeadless = 0):
261			if isHeadless == 0:
262			pass
263			else:
264			# dispatch.skipStep("keyboard", permanent = 1)
265			# dispatch.skipStep("mouse", permanent = 1)
266			dispatch.skipStep("handleX11pkgs", permanent = 1)
267			dispatch.skipStep("videocard", permanent = 1)
268			dispatch.skipStep("monitor", permanent = 1)
269			dispatch.skipStep("xcustom", permanent = 1)
270			dispatch.skipStep("writexconfig", permanent = 1)
271
272	slords	1.1	def setGroupSelection(self, grpset, intf):
273			grpset.unselectAll()
274			grpset.selectGroup("Base")
275
276	gordonr	1.10	def postAction(self, rootPath, serial, intf):
277			win = intf.waitWindow(_("Post Install Script"),
278			_("The post installation script is running..."))
279
280	slords	1.3	script = ( "/sbin/syslogd &\n"
281			"sleep 2\n"
282			"/sbin/e-smith/signal-event post-install\n" )
283	slords	1.2	s = Script(script, interp="/bin/sh", inChroot=1)
284			log("%s", s)
285			s.run(rootPath, serial)
286	gordonr	1.10	win.pop()
287	slords	1.1
288			def setInstallData(self, id, intf = None):
289			BaseInstallClass.setInstallData(self, id)
290			self.setAuthentication(id, useShadow=1, useMd5=1)
291			self.setRootPassword(id, pw="ThisIsGoingToBeDisabledAnyway", isCrypted=0)
292			self.setZeroMbr(id, zeroMbr=1)
293			self.setClearParts(id, clear=CLEARPART_TYPE_ALL, initAll=1)
294			self.setDefaultPartitioning(id.partitions, doClear=0)
295			self.setBootloader(id, useLilo=0, location="mbr", linear=1)
296
297			def __init__(self, expert):
298	slords	1.12	BaseInstallClass.__init__(self, expert)