/sample/drb/

• ../
• README.rd
• README.rd.ja
• darray.rb
• darrayc.rb
• dbiff.rb
• dcdbiff.rb
• dchatc.rb
• dchats.rb
• dhasen.rb
• dhasenc.rb
• dlogc.rb
• dlogd.rb
• dqin.rb
• dqlib.rb
• dqout.rb
• dqueue.rb
• drbc.rb
• drbch.rb
• drbm.rb
• drbmc.rb
• drbs-acl.rb
• drbs.rb
• drbssl_c.rb
• drbssl_s.rb
• extserv_test.rb
• gw_ct.rb
• gw_cu.rb
• gw_s.rb
• holderc.rb
• holders.rb
• http0.rb
• http0serv.rb
• name.rb
• namec.rb
• old_tuplespace.rb
• rinda_ts.rb
• rindac.rb
• rindas.rb
• ring_echo.rb
• ring_inspect.rb
• ring_place.rb
• simpletuple.rb
• speedc.rb
• speeds.rb

#
# kickstart.py: kickstart install support
#
# Copyright 1999-2006 Red Hat, Inc.
#
# This software may be freely redistributed under the terms of the GNU
# general public license.
#
# You should have received a copy of the GNU General Public License
# along with this program; if not, write to the Free Software
# Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
#

import iutil
import isys
import os
from installclass import BaseInstallClass, availableClasses, getBaseInstallClass
from partitioning import *
from autopart import *
from fsset import *
from flags import flags
from constants import *
import sys
import raid
import string
import partRequests
import urlgrabber.grabber as grabber
import lvm
import warnings
from pykickstart.constants import *
from pykickstart.parser import *
from pykickstart.data import *
from rhpl.translate import _

import logging
log = logging.getLogger("anaconda")
from anaconda_log import logger, logLevelMap

class AnacondaKSScript(Script):
    def run(self, chroot, serial, intf = None):
        import tempfile
        import os.path

        if self.inChroot:
            scriptRoot = chroot
        else:
            scriptRoot = "/"

        (fd, path) = tempfile.mkstemp("", "ks-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)

        # Always log an error.  Only fail if we have a handle on the
        # windowing system and the kickstart file included --erroronfail.
        if rc != 0:
            log.error("Error code %s encountered running a kickstart %%pre/%%post script", rc)

            if self.errorOnFail:
                if intf != None:
                    intf.messageWindow(_("Scriptlet Failure"),
                                       _("There was an error running the "
                                         "scriptlet.  You may examine the "
                                         "output in %s.  This is a fatal error "
                                         "and your install will be aborted.\n\n"
                                         "Press the OK button to reboot your "
                                         "system.") % (messages,))
                sys.exit(0)

        os.unlink(path)

        if serial or self.logfile is not None:
            os.chmod("%s" % messages, 0600)

class AnacondaKSHandlers(KickstartHandlers):
    def __init__ (self, ksdata, anaconda):
        KickstartHandlers.__init__(self, ksdata)
        self.permanentSkipSteps = []
        self.skipSteps = []
        self.showSteps = []
        self.ksRaidMapping = {}
        self.ksUsedMembers = []
        self.ksPVMapping = {}
        self.ksVGMapping = {}
        # XXX hack to give us a starting point for RAID, LVM, etc unique IDs.
        self.ksID = 100000

        self.id = anaconda.id

        self.lineno = 0
        self.currentCmd = ""

    def doAuthconfig(self, args):
        KickstartHandlers.doAuthconfig(self, args)
        self.id.auth = self.ksdata.authconfig

    def doAutoPart(self, args):
        KickstartHandlers.doAutoPart(self, args)

        # sets up default autopartitioning.  use clearpart separately
        # if you want it
        self.id.instClass.setDefaultPartitioning(self.id, doClear = 0)

        self.skipSteps.extend(["partition", "zfcpconfig", "parttype"])

    def doAutoStep(self, args):
        KickstartHandlers.doAutoStep(self, args)
        flags.autostep = 1
        flags.autoscreenshot = self.ksdata.autostep["autoscreenshot"]

    def doBootloader (self, args):
        KickstartHandlers.doBootloader(self, args)
        dict = self.ksdata.bootloader

        if dict["location"] == "none":
            location = None
        elif dict["location"] == "partition":
            location = "boot"
        else:
            location = dict["location"]

        if dict["upgrade"] and not self.id.getUpgrade():
            raise KickstartValueError, formatErrorMsg(self.lineno, msg="Selected upgrade mode for bootloader but not doing an upgrade")

        if dict["upgrade"]:
            self.id.bootloader.kickstart = 1
            self.id.bootloader.doUpgradeOnly = 1

        if location is None:
            self.permanentSkipSteps.extend(["bootloadersetup", "instbootloader"])
        else:
            self.showSteps.append("bootloader")
            self.id.instClass.setBootloader(self.id, location, dict["forceLBA"],
                                            dict["password"], dict["md5pass"],
                                            dict["appendLine"], dict["driveorder"])

        self.permanentSkipSteps.extend(["upgbootloader", "bootloader",
                                        "bootloaderadvanced"])

    def doClearPart(self, args):
        KickstartHandlers.doClearPart(self, args)
        dict = self.ksdata.clearpart

        hds = isys.hardDriveDict().keys()
        for disk in dict["drives"]:
            if disk not in hds:
                raise KickstartValueError, formatErrorMsg(self.lineno, msg="Specified nonexistent disk %s in clearpart command" % disk)

        self.id.instClass.setClearParts(self.id, dict["type"], drives=dict["drives"],
                                        initAll=dict["initAll"])

    def doFirewall(self, args):
        KickstartHandlers.doFirewall(self, args)
        dict = self.ksdata.firewall
	self.id.instClass.setFirewall(self.id, dict["enabled"], dict["trusts"],
                                      dict["ports"])

    def doFirstboot(self, args):
        KickstartHandlers.doFirstboot(self, args)
        self.id.firstboot = self.ksdata.firstboot

    def doIgnoreDisk(self, args):
	KickstartHandlers.doIgnoreDisk(self, args)
        self.id.instClass.setIgnoredDisks(self.id, self.ksdata.ignoredisk)

    def doIscsi(self, args):
        KickstartHandlers.doIscsi(self, args)

        for target in self.ksdata.iscsi:
            if self.id.iscsi.addTarget(target.ipaddr, target.port, target.user, target.password):
                log.info("added iscsi target: %s" %(target.ipaddr,))

        # FIXME: flush the drive dict so we figure drives out again
        isys.flushDriveDict()

    def doIscsiName(self, args):
        KickstartHandlers.doIscsiName(self, args)
        self.id.iscsi.initiator = self.ksdata.iscsiname

        self.id.iscsi.startup()
        # FIXME: flush the drive dict so we figure drives out again        
        isys.flushDriveDict()

    def doKeyboard(self, args):
        KickstartHandlers.doKeyboard(self, args)
        self.id.instClass.setKeyboard(self.id, self.ksdata.keyboard)
        self.id.keyboard.beenset = 1
	self.skipSteps.append("keyboard")

    def doLang(self, args):
        KickstartHandlers.doLang(self, args)
        self.id.instClass.setLanguage(self.id, self.ksdata.lang)
	self.skipSteps.append("language")

    def doLogicalVolume(self, args):
        KickstartHandlers.doLogicalVolume(self, args)
        lvd = self.ksdata.lvList[-1]

        if lvd.mountpoint == "swap":
            filesystem = fileSystemTypeGet("swap")
            lvd.mountpoint = ""

            if lvd.recommended:
                (lvd.size, lvd.maxSizeMB) = iutil.swapSuggestion()
                lvd.grow = True
        else:
            if lvd.fstype != "":
                filesystem = fileSystemTypeGet(lvd.fstype)
            else:
                filesystem = fileSystemTypeGetDefault()

	# sanity check mountpoint
	if lvd.mountpoint != "" and lvd.mountpoint[0] != '/':
	    raise KickstartValueError, formatErrorMsg(self.lineno, msg="The mount point \"%s\" is not valid." % (lvd.mountpoint,))

        try:
            vgid = self.ksVGMapping[lvd.vgname]
        except KeyError:
            raise KickstartValueError, formatErrorMsg(self.lineno, msg="No volume group exists with the name '%s'.  Specify volume groups before logical volumes." % lvd.vgname)

	for areq in self.id.partitions.autoPartitionRequests:
	    if areq.type == REQUEST_LV:
		if areq.volumeGroup == vgid and areq.logicalVolumeName == lvd.name:
		    raise KickstartValueError, formatErrorMsg(self.lineno, msg="Logical volume name already used in volume group %s" % lvd.vgname)
            elif areq.type == REQUEST_VG and areq.uniqueID == vgid:
                # Store a reference to the VG so we can do the PE size check.
                vg = areq

        if not self.ksVGMapping.has_key(lvd.vgname):
            raise KickstartValueError, formatErrorMsg(self.lineno, msg="Logical volume specifies a non-existent volume group" % lvd.name)

        if lvd.percent == 0 and not lvd.preexist:
            if lvd.size == 0:
                raise KickstartValueError, formatErrorMsg(self.lineno, msg="Size required")
            elif not lvd.grow and lvd.size*1024 < vg.pesize:
                raise KickstartValueError, formatErrorMsg(self.lineno, msg="Logical volume size must be larger than the volume group physical extent size.")
        elif (lvd.percent <= 0 or lvd.percent > 100) and not lvd.preexist:
            raise KickstartValueError, formatErrorMsg(self.lineno, msg="Percentage must be between 0 and 100")

        request = partRequests.LogicalVolumeRequestSpec(filesystem,
                                      format = lvd.format,
                                      mountpoint = lvd.mountpoint,
                                      size = lvd.size,
                                      percent = lvd.percent,
                                      volgroup = vgid,
                                      lvname = lvd.name,
				      grow = lvd.grow,
				      maxSizeMB = lvd.maxSizeMB,
                                      preexist = lvd.preexist,
                                      bytesPerInode = lvd.bytesPerInode)

	if lvd.fsopts != "":
            request.fsopts = lvd.fsopts

        self.id.instClass.addPartRequest(self.id.partitions, request)
        self.skipSteps.extend(["partition", "zfcpconfig", "parttype"])

    def doLogging(self, args):
        KickstartHandlers.doLogging(self, args)
        log.setHandlersLevel(logLevelMap[self.ksdata.logging["level"]])

        if self.ksdata.logging["host"] != "" and self.ksdata.logging["port"] != "":
            logger.addSysLogHandler(log, self.ksdata.logging["host"],
                                    port=int(self.ksdata.logging["port"]))
        elif self.ksdata.logging["host"] != "":
            logger.addSysLogHandler(log, self.ksdata.logging["host"])

    def doMonitor(self, args):
        KickstartHandlers.doMonitor(self, args)
        dict = self.ksdata.monitor
        self.skipSteps.extend(["monitor", "checkmonitorok"])
        self.id.instClass.setMonitor(self.id, dict["hsync"], dict["vsync"],
                                     dict["monitor"])

    def doNetwork(self, args):
        KickstartHandlers.doNetwork(self, args)
        nd = self.ksdata.network[-1]

        try:
            self.id.instClass.setNetwork(self.id, nd.bootProto, nd.ip, nd.netmask,
                                         nd.ethtool, nd.device, nd.onboot,
                                         nd.dhcpclass, nd.essid, nd.wepkey)
        except KeyError:
            raise KickstartValueError, formatErrorMsg(self.lineno, msg="The provided network interface %s does not exist" % nd.device)

        if nd.hostname != "":
            self.id.instClass.setHostname(self.id, nd.hostname, override=1)

        if nd.nameserver != "":
            self.id.instClass.setNameserver(self.id, nd.nameserver)

        if nd.gateway != "":
            self.id.instClass.setGateway(self.id, nd.gateway)

    def doMultiPath(self, args):
        KickstartHandlers.doMultiPath(self, args)

        from partedUtils import DiskSet
        ds = DiskSet()
        ds.startMPath()

        mpath = self.ksdata.mpaths[-1]
        log.debug("Searching for mpath '%s'" % (mpath.name,))
        for mp in DiskSet.mpList or []:
            it = True
            for dev in mpath.devices:
                dev = dev.split('/')[-1]
                log.debug("mpath '%s' has members %s" % (mp.name, list(mp.members)))
                if not dev in mp.members:
                    log.debug("mpath '%s' does not have device %s, skipping" \
                        % (mp.name, dev))
                    it = False
            if it:
                log.debug("found mpath '%s', changing name to %s" \
                    % (mp.name, mpath.name))
                newname = mpath.name
                ds.renameMPath(mp, newname)
                return
        ds.startMPath()

    def doDmRaid(self, args):
        KickstartHandlers.doDmRaid(self, args)

        from partedUtils import DiskSet
        ds = DiskSet()
        ds.startDmRaid()

        raid = self.ksdata.dmraids[-1]
        log.debug("Searching for dmraid '%s'" % (raid.name,))
        for rs in DiskSet.dmList or []:
            it = True
            for dev in raid.devices:
                dev = dev.split('/')[-1]
                log.debug("dmraid '%s' has members %s" % (rs.name, list(rs.members)))
                if not dev in rs.members:
                    log.debug("dmraid '%s' does not have device %s, skipping" \
                        % (rs.name, dev))
                    it = False
            if it:
                log.debug("found dmraid '%s', changing name to %s" \
                    % (rs.name, raid.name))
                # why doesn't rs.name go through the setter here?
                newname = raid.name
                ds.renameDmRaid(rs, newname)
                return
        ds.startDmRaid()

    def doPartition(self, args):
        KickstartHandlers.doPartition(self, args)
        pd = self.ksdata.partitions[-1]
        uniqueID = None

        if pd.onbiosdisk != "":
            pd.disk = isys.doGetBiosDisk(pd.onbiosdisk)

            if pd.disk == "":
                raise KickstartValueError, formatErrorMsg(self.lineno, msg="Specified BIOS disk %s cannot be determined" % pd.onbiosdisk)

        if pd.mountpoint == "swap":
            filesystem = fileSystemTypeGet('swap')
            pd.mountpoint = ""
            if pd.recommended:
                (pd.size, pd.maxSizeMB) = iutil.swapSuggestion()
                pd.grow = True
        # if people want to specify no mountpoint for some reason, let them
        # this is really needed for pSeries boot partitions :(
        elif pd.mountpoint == "None":
            pd.mountpoint = ""
            if pd.fstype:
                filesystem = fileSystemTypeGet(pd.fstype)
            else:
                filesystem = fileSystemTypeGetDefault()
        elif pd.mountpoint == 'appleboot':
            filesystem = fileSystemTypeGet("Apple Bootstrap")
            pd.mountpoint = ""
        elif pd.mountpoint == 'prepboot':
            filesystem = fileSystemTypeGet("PPC PReP Boot")
            pd.mountpoint = ""
        elif pd.mountpoint.startswith("raid."):
            filesystem = fileSystemTypeGet("software RAID")
            
            if self.ksRaidMapping.has_key(pd.mountpoint):
                raise KickstartValueError, formatErrorMsg(self.lineno, msg="Defined RAID partition multiple times")
            
            # get a sort of hackish id
            uniqueID = self.ksID
            self.ksRaidMapping[pd.mountpoint] = uniqueID
            self.ksID += 1
            pd.mountpoint = ""
        elif pd.mountpoint.startswith("pv."):
            filesystem = fileSystemTypeGet("physical volume (LVM)")

            if self.ksPVMapping.has_key(pd.mountpoint):
                raise KickstartValueError, formatErrorMsg(self.lineno, msg="Defined PV partition multiple times")

            # get a sort of hackish id
            uniqueID = self.ksID
            self.ksPVMapping[pd.mountpoint] = uniqueID
            self.ksID += 1
            pd.mountpoint = ""
        # XXX should we let people not do this for some reason?
        elif pd.mountpoint == "/boot/efi":
            filesystem = fileSystemTypeGet("vfat")
        else:
            if pd.fstype != "":
                filesystem = fileSystemTypeGet(pd.fstype)
            else:
                filesystem = fileSystemTypeGetDefault()

        if pd.size is None and (pd.start == 0 and pd.end == 0) and pd.onPart == "":
            raise KickstartValueError, formatErrorMsg(self.lineno, msg="Partition requires a size specification")
        if pd.start != 0 and pd.disk == "":
            raise KickstartValueError, formatErrorMsg(self.lineno, msg="Partition command with start cylinder requires a drive specification")
        hds = isys.hardDriveDict()
        if not hds.has_key(pd.disk) and hds.has_key('mapper/'+pd.disk):
            pd.disk = 'mapper/' + pd.disk
        if pd.disk != "" and pd.disk not in hds.keys():
            raise KickstartValueError, formatErrorMsg(self.lineno, msg="Specified nonexistent disk %s in partition command" % pd.disk)

        request = partRequests.PartitionSpec(filesystem,
                                             mountpoint = pd.mountpoint,
                                             format = pd.format,
                                             fslabel = pd.label,
                                             bytesPerInode = pd.bytesPerInode)
        
        if pd.size is not None:
            request.size = pd.size
        if pd.start != 0:
            request.start = pd.start
        if pd.end != 0:
            request.end = pd.end
        if pd.grow:
            request.grow = pd.grow
        if pd.maxSizeMB != 0:
            request.maxSizeMB = pd.maxSizeMB
        if pd.disk != "":
            request.drive = [ pd.disk ]
        if pd.primOnly:
            request.primary = pd.primOnly
        if uniqueID:
            request.uniqueID = uniqueID
        if pd.onPart != "":
            request.device = pd.onPart
            for areq in self.id.partitions.autoPartitionRequests:
                if areq.device is not None and areq.device == pd.onPart:
		    raise KickstartValueError, formatErrorMsg(self.lineno, "Partition already used")

        if pd.fsopts != "":
            request.fsopts = pd.fsopts

        self.id.instClass.addPartRequest(self.id.partitions, request)
        self.skipSteps.extend(["partition", "zfcpconfig", "parttype"])

    def doReboot(self, args):
        KickstartHandlers.doReboot(self, args)
        self.skipSteps.append("complete")

    def doRaid(self, args):
        KickstartHandlers.doRaid(self, args)
        rd = self.ksdata.raidList[-1]

	uniqueID = None

        if rd.mountpoint == "swap":
            filesystem = fileSystemTypeGet('swap')
            rd.mountpoint = ""
        elif rd.mountpoint.startswith("pv."):
            filesystem = fileSystemTypeGet("physical volume (LVM)")

            if self.ksPVMapping.has_key(rd.mountpoint):
                raise KickstartValueError, formatErrorMsg(self.lineno, msg="Defined PV partition multiple times")

            # get a sort of hackish id
            uniqueID = self.ksID
            self.ksPVMapping[rd.mountpoint] = uniqueID
            self.ksID += 1
            rd.mountpoint = ""
        else:
            if rd.fstype != "":
                filesystem = fileSystemTypeGet(rd.fstype)
            else:
                filesystem = fileSystemTypeGetDefault()

	# sanity check mountpoint
	if rd.mountpoint != "" and rd.mountpoint[0] != '/':
	    raise KickstartValueError, formatErrorMsg(self.lineno, msg="The mount point is not valid.")

        raidmems = []

        # get the unique ids of each of the raid members
        for member in rd.members:
            if member not in self.ksRaidMapping.keys():
                raise KickstartValueError, formatErrorMsg(self.lineno, msg="Tried to use undefined partition %s in RAID specification" % member)
	    if member in self.ksUsedMembers:
                raise KickstartValueError, formatErrorMsg(self.lineno, msg="Tried to use RAID member %s in two or more RAID specifications" % member)
		
            raidmems.append(self.ksRaidMapping[member])
	    self.ksUsedMembers.append(member)

        if rd.level == "" and not rd.preexist:
            raise KickstartValueError, formatErrorMsg(self.lineno, msg="RAID Partition defined without RAID level")
        if len(raidmems) == 0 and not rd.preexist:
            raise KickstartValueError, formatErrorMsg(self.lineno, msg="RAID Partition defined without any RAID members")

        request = partRequests.RaidRequestSpec(filesystem,
                                               mountpoint = rd.mountpoint,
                                               raidmembers = raidmems,
                                               raidlevel = rd.level,
                                               raidspares = rd.spares,
                                               format = rd.format,
                                               raidminor = rd.device,
                                               preexist = rd.preexist)

        if uniqueID is not None:
            request.uniqueID = uniqueID
        if rd.preexist and rd.device != "":
            request.device = "md%s" % rd.device
        if rd.fsopts != "":
            request.fsopts = rd.fsopts

        self.id.instClass.addPartRequest(self.id.partitions, request)
        self.skipSteps.extend(["partition", "zfcpconfig", "parttype"])

    def doRootPw(self, args):
        KickstartHandlers.doRootPw(self, args)
        dict = self.ksdata.rootpw

        self.id.rootPassword["password"] = dict["password"]
        self.id.rootPassword["isCrypted"] = dict["isCrypted"]
	self.skipSteps.append("accounts")

    def doSELinux(self, args):
        KickstartHandlers.doSELinux(self, args)
        self.id.instClass.setSELinux(self.id, self.ksdata.selinux)

    def doSkipX(self, args):
        KickstartHandlers.doSkipX(self, args)
        self.skipSteps.extend(["checkmonitorok", "setsanex", "videocard",
                               "monitor", "xcustom", "writexconfig"])

        if self.id.xsetup is not None: