product/installclasses/smeinstallclass.py

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

from autopart import getAutopartitionBoot, autoCreatePartitionRequests, autoCreateLVMPartitionRequests
from fsset import *
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):
        diskset = partedUtils.DiskSet()
        drives = diskset.driveList()
        if len(drives) > 0:
            uniqueID = 100
            raid1 = []
            raid2 = []
            (swapMin, swapMax) = iutil.swapSuggestion()

            for drive in drives:
                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)

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

                uniqueID = uniqueID + 1

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

            if len(drives) > 5:
                raidLevel = "RAID6"
            elif len(drives) > 2:
                raidLevel = "RAID5"
            else:
                raidLevel = "RAID1"

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

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

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

            filesystem = fileSystemTypeGet("ext3")
            (size, maxSizeMB) = iutil.swapSuggestion()
            request = partRequests.LogicalVolumeRequestSpec(filesystem, format=1, grow=1,
                    mountpoint="/", size=1300, volgroup=201, lvname="root")
            partitions.autoPartitionRequests.append(request)
        else:
            BaseInstallClass.setDefaultPartitioning(self, partitions, clear, doClear)
            
    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.12	from rhpl.translate import N_
3			from constants import *
4			import os
5			import iutil
6
7	slords	1.1	from autopart import getAutopartitionBoot, autoCreatePartitionRequests, autoCreateLVMPartitionRequests
8			from fsset import *
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			diskset = partedUtils.DiskSet()
115			drives = diskset.driveList()
116			if len(drives) > 0:
117			uniqueID = 100
118			raid1 = []
119			raid2 = []
120			(swapMin, swapMax) = iutil.swapSuggestion()
121
122			for drive in drives:
123			filesystem = fileSystemTypeGet("software RAID")
124			request = partRequests.PartitionSpec(filesystem, drive=[drive], size=100, primary=1, format=1)
125			request.uniqueID = uniqueID
126			raid1.append(uniqueID)
127			partitions.autoPartitionRequests.append(request)
128
129			filesystem = fileSystemTypeGet("software RAID")
130			request = partRequests.PartitionSpec(filesystem, drive=[drive], size=swapMin+1500,
131			grow=1, format=1);
132			request.uniqueID = uniqueID + 10
133			raid2.append(uniqueID + 10)
134			partitions.autoPartitionRequests.append(request)
135
136			uniqueID = uniqueID + 1
137
138			filesystem = fileSystemTypeGet("ext3")
139			request = partRequests.RaidRequestSpec(filesystem, mountpoint="/boot", raidminor=1,
140			raidmembers=raid1, raidlevel="RAID1", format=1, raidspares=0)
141			partitions.autoPartitionRequests.append(request)
142
143			if len(drives) > 5:
144			raidLevel = "RAID6"
145			elif len(drives) > 2:
146			raidLevel = "RAID5"
147			else:
148			raidLevel = "RAID1"
149
150			filesystem = fileSystemTypeGet("physical volume (LVM)")
151			request = partRequests.RaidRequestSpec(filesystem, raidmembers=raid2, raidminor=2,
152			raidlevel=raidLevel, format=1, raidspares=0)
153			request.uniqueID = 200
154			partitions.autoPartitionRequests.append(request)
155
156	slords	1.11	request = partRequests.VolumeGroupRequestSpec(vgname="main", physvols=[200],
157	slords	1.2	pesize=32768, format=1)
158	slords	1.1	request.uniqueID = 201
159			partitions.autoPartitionRequests.append(request)
160
161			filesystem = fileSystemTypeGet("swap")
162			request = partRequests.LogicalVolumeRequestSpec(filesystem, format=1, grow=1,
163	slords	1.11	size=swapMin, maxSizeMB=swapMax, volgroup=201, lvname="swap")
164	slords	1.1	partitions.autoPartitionRequests.append(request)
165
166			filesystem = fileSystemTypeGet("ext3")
167			(size, maxSizeMB) = iutil.swapSuggestion()
168			request = partRequests.LogicalVolumeRequestSpec(filesystem, format=1, grow=1,
169	slords	1.11	mountpoint="/", size=1300, volgroup=201, lvname="root")
170	slords	1.1	partitions.autoPartitionRequests.append(request)
171			else:
172			BaseInstallClass.setDefaultPartitioning(self, partitions, clear, doClear)
173
174			def setGroupSelection(self, grpset, intf):
175			grpset.unselectAll()
176			grpset.selectGroup("Base")
177
178	gordonr	1.10	def postAction(self, rootPath, serial, intf):
179			win = intf.waitWindow(_("Post Install Script"),
180			_("The post installation script is running..."))
181
182	slords	1.3	script = ( "/sbin/syslogd &\n"
183			"sleep 2\n"
184			"/sbin/e-smith/signal-event post-install\n" )
185	slords	1.2	s = Script(script, interp="/bin/sh", inChroot=1)
186			log("%s", s)
187			s.run(rootPath, serial)
188	gordonr	1.10	win.pop()
189	slords	1.1
190			def setInstallData(self, id, intf = None):
191			BaseInstallClass.setInstallData(self, id)
192			self.setAuthentication(id, useShadow=1, useMd5=1)
193			self.setRootPassword(id, pw="ThisIsGoingToBeDisabledAnyway", isCrypted=0)
194			self.setZeroMbr(id, zeroMbr=1)
195			self.setClearParts(id, clear=CLEARPART_TYPE_ALL, initAll=1)
196			self.setDefaultPartitioning(id.partitions, doClear=0)
197			self.setBootloader(id, useLilo=0, location="mbr", linear=1)
198
199			def __init__(self, expert):
200	slords	1.12	BaseInstallClass.__init__(self, expert)