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
        raid1 = []
        raid2 = []
        (swapMin, swapMax) = iutil.swapSuggestion()

        diskset = partedUtils.DiskSet()
        drives = diskset.driveList()

        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)

                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

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