path: root/anaconda

#!/usr/bin/python
#
# anaconda: The Red Hat Linux Installation program
#
# Copyright (C) 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007
# Red Hat, Inc.  All rights reserved.
#
# This program is free software; you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
# the Free Software Foundation; either version 2 of the License, or
# (at your option) any later version.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program.  If not, see <http://www.gnu.org/licenses/>.
#
# Author(s): Brent Fox <bfox@redhat.com>
#            Mike Fulbright <msf@redhat.com>
#            Jakub Jelinek <jakub@redhat.com>
#            Jeremy Katz <katzj@redhat.com>
#            Chris Lumens <clumens@redhat.com>
#            Paul Nasrat <pnasrat@redhat.com>
#            Erik Troan <ewt@rpath.com>
#            Matt Wilson <msw@rpath.com>
#

# This toplevel file is a little messy at the moment...

import sys, os, re, time, subprocess
from optparse import OptionParser
from tempfile import mkstemp

# keep up with process ID of miniwm if we start it

miniwm_pid = None

# Make sure messages sent through python's warnings module get logged.
def AnacondaShowWarning(message, category, filename, lineno, file=sys.stderr, line=None):
    log.warning("%s" % warnings.formatwarning(message, category, filename, lineno, line))

# start miniWM
def startMiniWM(root='/'):
    (rd, wr) = os.pipe()
    childpid = os.fork()
    if not childpid:
        if os.access("./mini-wm", os.X_OK):
            cmd = "./mini-wm"
        elif os.access(root + "/usr/bin/mini-wm", os.X_OK):
            cmd = root + "/usr/bin/mini-wm"
        else:
            return None
        
        os.dup2(wr, 1)
        os.close(wr)
        args = [cmd, '--display', ':1']
        os.execv(args[0], args)
        sys.exit (1)
    else:
        # We need to make sure that mini-wm is the first client to
        # connect to the X server (see bug #108777).  Wait for mini-wm
        # to write back an acknowledge token.
        os.read(rd, 1)

    return childpid

# function to handle X startup special issues for anaconda
def doStartupX11Actions(runres="800x600"):
    global miniwm_pid

    setupGraphicalLinks()

    # now start up mini-wm
    try:
        miniwm_pid = startMiniWM()
        log.info("Started mini-wm")

    except:
        miniwm_pid = None
        log.error("Unable to start mini-wm")

    if miniwm_pid is not None:
        import xutils
        import gtk

        try:
            i = gtk.Invisible()
            i.selection_owner_set("_ANACONDA_MINI_WM_RUNNING")

            xutils.setRootResource('Xcursor.size', '24')
            xutils.setRootResource('Xcursor.theme', 'Bluecurve')
            xutils.setRootResource('Xcursor.theme_core', 'true')

            xutils.setRootResource('Xft.antialias', '1')
            xutils.setRootResource('Xft.hinting', '1')
            xutils.setRootResource('Xft.hintstyle', 'hintslight')
            xutils.setRootResource('Xft.rgba', 'none')
        except:
            sys.stderr.write("X SERVER STARTED, THEN FAILED");
            raise RuntimeError, "X server failed to start"

def doShutdownX11Actions():
    global miniwm_pid
    
    if miniwm_pid is not None:
        try:
            os.kill(miniwm_pid, 15)
            os.waitpid(miniwm_pid, 0)
        except:
            pass

def setupPythonUpdates():
    from distutils.sysconfig import get_python_lib

    if not os.path.exists("/tmp/updates"):
        return

    for pkg in os.listdir("/tmp/updates"):
        d = "/tmp/updates/%s" % pkg

        if not os.path.isdir(d):
            continue

        # See if the package exists in /usr/lib{64,}/python/?.?/site-packages.
        # If it does, we can set it up as an update.  If not, the pkg is
        # likely a completely new directory and should not be looked at.
        dest = "%s/%s" % (get_python_lib(), pkg)
        if not os.access(dest, os.R_OK):
            dest = "%s/%s" % (get_python_lib(1), pkg)
            if not os.access(dest, os.R_OK):
                continue

        contents = os.listdir(d)

        # Symlink over everything that's in the python libdir but not in
        # the updates directory.
        for f in filter(lambda fn: fn not in contents, os.listdir(dest)):
            if f.endswith(".pyc") or f.endswith(".pyo"):
                continue

            os.symlink("%s/%s" % (dest, f), "/tmp/updates/%s/%s" % (pkg, f))

    if os.access("/tmp/updates/70-anaconda.rules", os.R_OK):
        import shutil
        shutil.copyfile("/tmp/updates/70-anaconda.rules",
                        "/etc/udev/rules.d/70-anaconda.rules")

def parseOptions():
    def resolution_cb (option, opt_str, value, parser):
        parser.values.runres = value

    op = OptionParser()
    # Interface
    op.add_option("-C", "--cmdline", dest="display_mode", action="store_const", const="c",
                  default="g")
    op.add_option("-G", "--graphical", dest="display_mode", action="store_const", const="g")
    op.add_option("-T", "--text", dest="display_mode", action="store_const", const="t")

    # Network
    op.add_option("--noipv4", action="store_true", default=False)
    op.add_option("--noipv6", action="store_true", default=False)
    op.add_option("--proxy")
    op.add_option("--proxyAuth")

    # Method of operation
    op.add_option("--autostep", action="store_true", default=False)
    op.add_option("-d", "--debug", dest="debug", action="store_true", default=False)
    op.add_option("--kickstart", dest="ksfile")
    op.add_option("--rescue", dest="rescue", action="store_true", default=False)
    op.add_option("--targetarch", dest="targetArch", nargs=1, type="string")

    op.add_option("-m", "--method", dest="method", default=None)
    op.add_option("--repo", dest="method", default=None)
    op.add_option("--stage2", dest="stage2", default=None)

    op.add_option("--liveinst", action="store_true", default=False)

    # Display
    op.add_option("--headless", dest="isHeadless", action="store_true", default=False)
    op.add_option("--nofb")
    op.add_option("--resolution", action="callback", callback=resolution_cb, dest="runres",
                  default="800x600", nargs=1, type="string")
    op.add_option("--serial", action="store_true", default=False)
    op.add_option("--usefbx", dest="xdriver", action="store_const", const="fbdev")
    op.add_option("--virtpconsole")
    op.add_option("--vnc", action="store_true", default=False)
    op.add_option("--vncconnect")
    op.add_option("--xdriver", dest="xdriver", action="store", type="string", default=None)

    # Language
    op.add_option("--keymap")
    op.add_option("--kbdtype")
    op.add_option("--lang")

    # Obvious
    op.add_option("--loglevel")
    op.add_option("--syslog")

    op.add_option("--noselinux", dest="selinux", action="store_false", default=True)
    op.add_option("--selinux", action="store_true")

    op.add_option("--nompath", dest="mpath", action="store_false", default=True)
    op.add_option("--mpath", action="store_true")

    op.add_option("--nodmraid", dest="dmraid", action="store_false", default=True)
    op.add_option("--dmraid", action="store_true")

    op.add_option("--noibft", dest="ibft", action="store_false", default=True)
    op.add_option("--ibft", action="store_true")
    op.add_option("--noiscsi", dest="iscsi", action="store_false", default=False)
    op.add_option("--iscsi", action="store_true")

    # Miscellaneous
    op.add_option("--module", action="append", default=[])
    op.add_option("--nomount", dest="rescue_nomount", action="store_true", default=False)
    op.add_option("--updates", dest="updateSrc", action="store", type="string")
    op.add_option("--dogtail", dest="dogtail",   action="store", type="string")
    op.add_option("--dlabel", action="store_true", default=False)

    # Deprecated, unloved, unused
    op.add_option("-r", "--rootPath", dest="unsupportedMode",
                  action="store_const", const="root path")
    op.add_option("-t", "--test", dest="unsupportedMode",
                  action="store_const", const="test")

    return op.parse_args()

def setupPythonPath():
    haveUpdates = False
    for ndx in range(len(sys.path)-1, -1, -1):
        if sys.path[ndx].endswith('updates'):
            haveUpdates = True
            break

    if haveUpdates:
        sys.path.insert(ndx+1, '/usr/lib/anaconda')
        sys.path.insert(ndx+2, '/usr/lib/anaconda/textw')
        sys.path.insert(ndx+3, '/usr/lib/anaconda/iw')
    else:
        sys.path.insert(0, '/usr/lib/anaconda')
        sys.path.insert(1, '/usr/lib/anaconda/textw')
        sys.path.insert(2, '/usr/lib/anaconda/iw')

    sys.path.append('/usr/share/system-config-date')

def addPoPath(dir):
    """ Looks to see what translations are under a given path and tells
    the gettext module to use that path as the base dir """
    for d in os.listdir(dir):
        if not os.path.isdir("%s/%s" %(dir,d)):
            continue
        if not os.path.exists("%s/%s/LC_MESSAGES" %(dir,d)):
            continue
        for basename in os.listdir("%s/%s/LC_MESSAGES" %(dir,d)):
            if not basename.endswith(".mo"):
                continue
            log.info("setting %s as translation source for %s" %(dir, basename[:-3]))
            gettext.bindtextdomain(basename[:-3], dir)

def setupTranslations():
    if os.path.isdir("/tmp/updates/po"):
        addPoPath("/tmp/updates/po")
    gettext.textdomain("anaconda")

def setupEnvironment():
    # Silly GNOME stuff
    if os.environ.has_key('HOME') and not os.environ.has_key("XAUTHORITY"):
        os.environ['XAUTHORITY'] = os.environ['HOME'] + '/.Xauthority'
    os.environ['HOME'] = '/tmp'
    os.environ['LC_NUMERIC'] = 'C'
    os.environ["GCONF_GLOBAL_LOCKS"] = "1"

    # In theory, this gets rid of our LVM file descriptor warnings
    os.environ["LVM_SUPPRESS_FD_WARNINGS"] = "1"

    # make sure we have /sbin and /usr/sbin in our path
    os.environ["PATH"] += ":/sbin:/usr/sbin"

    # we can't let the LD_PRELOAD hang around because it will leak into
    # rpm %post and the like.  ick :/
    if os.environ.has_key("LD_PRELOAD"):
        del os.environ["LD_PRELOAD"]

    os.environ["GLADEPATH"] = "/tmp/updates/:/tmp/updates/ui/:ui/:/usr/share/anaconda/ui/:/usr/share/python-meh/"
    os.environ["PIXMAPPATH"] = "/tmp/updates/pixmaps/:/tmp/updates/:/tmp/product/pixmaps/:/tmp/product/:pixmaps/:/usr/share/anaconda/pixmaps/:/usr/share/pixmaps/:/usr/share/anaconda/:/usr/share/python-meh/"

def setupLoggingFromOpts(opts):
    if opts.loglevel and anaconda_log.logLevelMap.has_key(opts.loglevel):
        level = anaconda_log.logLevelMap[opts.loglevel]
        anaconda_log.logger.tty_loglevel = level
        anaconda_log.setHandlersLevel(log, level)
        anaconda_log.setHandlersLevel(storage.storage_log.logger, level)

    if opts.syslog:
        anaconda_log.logger.remote_syslog = opts.syslog
        if opts.syslog.find(":") != -1:
            (host, port) = opts.syslog.split(":")
            anaconda_log.logger.addSysLogHandler(log, host, port=int(port))
        else:
            anaconda_log.logger.addSysLogHandler(log, opts.syslog)

# ftp installs pass the password via a file in /tmp so
# ps doesn't show it
def expandFTPMethod(str):
    ret = None

    try:
        filename = str[1:]
        ret = open(filename, "r").readline()
        ret = ret[:len(ret) - 1]
        os.unlink(filename)
        return ret
    except:
        return None

def runVNC():
    global vncS
    vncS.startServer()

    child = os.fork()
    if child == 0:
        for p in ('/tmp/updates/pyrc.py', \
                '/usr/lib/anaconda-runtime/pyrc.py'):
            if os.access(p, os.R_OK|os.X_OK):
                os.environ['PYTHONSTARTUP'] = p
                break

        while True:
            # s390/s390x are the only places we /really/ need a shell on tty1,
            # and everywhere else this just gets in the way of pdb.  But we
            # don't want to return, because that'll return try to start X
            # a second time.
            if iutil.isConsoleOnVirtualTerminal():
                    time.sleep(10000)
            else:
                    print _("Press <enter> for a shell")
                    sys.stdin.readline()
                    iutil.execConsole()

def checkMemory(anaconda):
    if iutil.memInstalled() < isys.MIN_RAM:
        from snack import SnackScreen, ButtonChoiceWindow

        screen = SnackScreen()
        ButtonChoiceWindow(screen, _('Fatal Error'),
                            _('You do not have enough RAM to install %s '
                              'on this machine.\n'
                              '\n'
                              'Press <return> to reboot your system.\n')
                           %(product.productName,),
                           buttons = (_("OK"),))
        screen.finish()
        sys.exit(0)

    # override display mode if machine cannot nicely run X
    if not flags.usevnc:
        if anaconda.displayMode not in ('t', 'c') and iutil.memInstalled() < isys.MIN_GUI_RAM:
            stdoutLog.warning(_("You do not have enough RAM to use the graphical "
                                "installer.  Starting text mode."))
            anaconda.displayMode = 't'
            time.sleep(2)

def setupGraphicalLinks():
    for i in ( "imrc", "im_palette.pal", "gtk-2.0", "pango", "fonts",
               "fb.modes"):
        try:
            if os.path.exists("/mnt/runtime/etc/%s" %(i,)):
                os.symlink ("../mnt/runtime/etc/" + i, "/etc/" + i)
        except:
            pass

def handleSshPw(anaconda):
    import users
    u = users.Users(anaconda)

    userdata = anaconda.ksdata.sshpw.dataList()
    for ud in userdata:
        if u.checkUserExists(ud.username, root="/"):
            u.setUserPassword(username=ud.username, password=ud.password,
                              isCrypted=ud.isCrypted, lock=ud.lock)
        else:
            u.createUser(name=ud.username, password=ud.password,
                         isCrypted=ud.isCrypted, lock=ud.lock,
                         root="/")

    del u

def createSshKey(algorithm, keyfile):
    path = '/etc/ssh/%s' % (keyfile,)
    argv = ['-q','-t',algorithm,'-f',path,'-C','','-N','']
    log.info("running \"%s\"" % (" ".join(['ssh-keygen']+argv),))

    so = "/tmp/ssh-keygen-%s-stdout.log" % (algorithm,)
    se = "/tmp/ssh-keygen-%s-stderr.log" % (algorithm,)
    iutil.execWithRedirect('ssh-keygen', argv, stdout=so, stderr=se)

def startSsh():
    if not flags.sshd:
        return   
    if iutil.isS390():
        return

    childpid = os.fork()
    if not childpid:
        os.mkdir("/var/log", 0755)
        os.open("/var/log/lastlog", os.O_RDWR | os.O_CREAT, 0644)
        ssh_keys = {
            'rsa1':'ssh_host_key',
            'rsa':'ssh_host_rsa_key',
            'dsa':'ssh_host_dsa_key',
            }
        for (algorithm, keyfile) in ssh_keys.items():
            createSshKey(algorithm, keyfile)
        args = ["/sbin/sshd", "-f", "/etc/ssh/sshd_config.anaconda"]
        os.execv("/sbin/sshd", args)
        sys.exit(1)

def startDebugger(signum, frame):
    import epdb
    epdb.serve(skip=1)

class Anaconda(object):
    def __init__(self):
        import desktop, dispatch, firewall, security
        import system_config_keyboard.keyboard as keyboard
        from flags import flags

        self._backend = None
        self._bootloader = None
        self.canReIPL = False
        self.desktop = desktop.Desktop()
        self.dir = None
        self.dispatch = dispatch.Dispatcher(self)
        self.displayMode = None
        self.extraModules = []
        self.firewall = firewall.Firewall()
        self.id = None
        self._instClass = None
        self._instLanguage = None
        self._intf = None
        self.isHeadless = False
        self.keyboard = keyboard.Keyboard()
        self.ksdata = None
        self.mediaDevice = None
        self.methodstr = None
        self._network = None
        self._platform = None
        self.proxy = None
        self.proxyUsername = None
        self.proxyPassword = None
        self.reIPLMessage = None
        self.rescue = False
        self.rescue_mount = True
        self.rootParts = None
        self.rootPath = "/mnt/sysimage"
        self.security = security.Security()
        self.simpleFilter = True
        self.stage2 = None
        self._storage = None
        self._timezone = None
        self.updateSrc = None
        self.upgrade = flags.cmdline.has_key("preupgrade")
        self.upgradeRoot = None
        self.upgradeSwapInfo = None
        self._users = None

        # *sigh* we still need to be able to write this out
        self.xdriver = None

    @property
    def backend(self):
        if not self._backend:
            b = self.instClass.getBackend()
            self._backend = apply(b, (self, ))

        return self._backend

    @property
    def bootloader(self):
        if not self._bootloader:
            import booty
            self._bootloader = booty.getBootloader(self)

        return self._bootloader

    @property
    def firstboot(self):
        from pykickstart.constants import FIRSTBOOT_SKIP, FIRSTBOOT_DEFAULT

        if self.ksdata:
            return self.ksdata.firstboot.firstboot
        elif iutil.isS390():
            return FIRSTBOOT_SKIP
        else:
            return FIRSTBOOT_DEFAULT

    @property
    def instClass(self):
        if not self._instClass:
            from installclass import DefaultInstall
            self._instClass = DefaultInstall()

        return self._instClass

    @property
    def instLanguage(self):
        if not self._instLanguage:
            import language
            self._instLanguage = language.Language(self.displayMode)

        return self._instLanguage

    def _getInterface(self):
        if self._intf:
            return self._intf

        # setup links required by graphical mode if installing and verify display mode
        if self.displayMode == 'g':
            stdoutLog.info (_("Starting graphical installation."))

            try:
                from gui import InstallInterface
            except Exception, e:
                stdoutLog.error("Exception starting GUI installer: %s" %(e,))
                # if we're not going to really go into GUI mode, we need to get
                # back to vc1 where the text install is going to pop up.
                if not flags.livecdInstall:
                    isys.vtActivate (1)
                stdoutLog.warning("GUI installer startup failed, falling back to text mode.")
                self.displayMode = 't'
                if 'DISPLAY' in os.environ.keys():
                    del os.environ['DISPLAY']
                time.sleep(2)

        if self.displayMode == 't':
            from text import InstallInterface
            if not os.environ.has_key("LANG"):
                os.environ["LANG"] = "en_US.UTF-8"

        if self.displayMode == 'c':
            from cmdline import InstallInterface

        self._intf = InstallInterface()
        return self._intf

    def _setInterface(self, v):
        # "lambda cannot contain assignment"
        self._intf = v

    def _delInterface(self):
        del self._intf

    intf = property(_getInterface, _setInterface, _delInterface)

    @property
    def network(self):
        if not self._network:
            import network
            self._network = network.Network()

        return self._network

    @property
    def platform(self):
        if not self._platform:
            import platform
            self._platform = platform.getPlatform(self)

        return self._platform

    @property
    def users(self):
        if not self._users:
            import users
            self._users = users.Users(self)

        return self._users

    @property
    def storage(self):
        if not self._storage:
            import storage
            self._storage = storage.Storage(self)

        return self._storage

    @property
    def timezone(self):
        if not self._timezone:
            import timezone
            self._timezone = timezone.Timezone()
            self._timezone.setTimezoneInfo(self.instLanguage.getDefaultTimeZone(self.rootPath))

        return self._timezone

    def dumpState(self):
        from meh.dump import ReverseExceptionDump
        from inspect import stack as _stack

        # Skip the frames for dumpState and the signal handler.
        stack = _stack()[2:]
        stack.reverse()
        exn = ReverseExceptionDump((None, None, stack), self.mehConfig)

        (fd, filename) = mkstemp("", "anaconda-tb-", "/tmp")
        fo = os.fdopen(fd, "w")

        exn.write(self, fo)

    def writeXdriver(self):
        # this should go away at some point, but until it does, we
        # need to keep it around.
        if self.xdriver is None:
            return
        if not os.path.isdir("%s/etc/X11" %(self.rootPath,)):
            os.makedirs("%s/etc/X11" %(self.rootPath,), mode=0755)
        f = open("%s/etc/X11/xorg.conf" %(self.rootPath,), 'w')
        f.write('Section "Device"\n\tIdentifier "Videocard0"\n\tDriver "%s"\nEndSection\n' % self.xdriver)
        f.close()

    def setMethodstr(self, methodstr):
        if methodstr.startswith("cdrom://"):
            (device, tree) = string.split(methodstr[8:], ":", 1)

            if not tree.startswith("/"):
                tree = "/%s" %(tree,)

            if device.startswith("/dev/"):
                device = device[5:]

            self.mediaDevice = device
            self.methodstr = "cdrom://%s" % tree
        else:
            self.methodstr = methodstr

    def requiresNetworkInstall(self):
        fail = False
        numNetDevs = isys.getNetworkDeviceCount()

        if self.methodstr is not None:
            if (self.methodstr.startswith("http") or \
                self.methodstr.startswith("ftp://") or \
                self.methodstr.startswith("nfs:")) and \
               numNetDevs == 0:
                fail = True
        elif self.stage2 is not None:
            if self.stage2.startswith("cdrom://") and \
               not os.path.isdir("/mnt/stage2/Packages") and \
               numNetDevs == 0:
                fail = True

        if fail:
            log.error("network install required, but no network devices available")

        return fail

    def write(self):
        self.writeXdriver()
        self.instLanguage.write(self.rootPath)

        if not self.isHeadless:
            self.keyboard.write(self.rootPath)

        self.timezone.write(self.rootPath)
        self.network.write(instPath=self.rootPath, anaconda=self)
        self.desktop.write(self.rootPath)
        self.users.write(self.rootPath)
        self.security.write(self.rootPath)
        self.firewall.write(self.rootPath)

        if self.ksdata:
            for svc in self.ksdata.services.disabled:
                iutil.execWithRedirect("/sbin/chkconfig",
                                       [svc, "off"],
                                       stdout="/dev/tty5", stderr="/dev/tty5",
                                       root=self.rootPath)

            for svc in self.ksdata.services.enabled:
                iutil.execWithRedirect("/sbin/chkconfig",
                                       [svc, "on"],
                                       stdout="/dev/tty5", stderr="/dev/tty5",
                                       root=self.rootPath)
        if not self.isHeadless:
            self.keyboard.write(self.rootPath)

        self.network.write(instPath=self.rootPath, anaconda=self)
        self.users.write(self.rootPath)
        self.security.write(self.rootPath)

    def writeKS(self, filename):
        import urllib
        from pykickstart.version import versionToString, DEVEL

        f = open(filename, "w")

        f.write("# Kickstart file automatically generated by anaconda.\n\n")
        f.write("#version=%s\n" % versionToString(DEVEL))

        if self.upgrade:
            f.write("upgrade\n");
        else:
            f.write("install\n");

        m = None

        if self.methodstr:
            m = self.methodstr
        elif self.stage2:
            m = self.stage2

        if m:
            if m.startswith("cdrom:"):
                f.write("cdrom\n")
            elif m.startswith("hd:"):
                if m.count(":") == 3:
                    (part, fs, dir) = string.split(m[3:], ":")
                else:
                    (part, dir) = string.split(m[3:], ":")

                f.write("harddrive --partition=%s --dir=%s\n" % (part, dir))
            elif m.startswith("nfs:"):
                if m.count(":") == 3:
                    (server, opts, dir) = string.split(m[4:], ":")
                    f.write("nfs --server=%s --opts=%s --dir=%s" % (server, opts, dir))
                else:
                    (server, dir) = string.split(m[4:], ":")
                    f.write("nfs --server=%s --dir=%s\n" % (server, dir))
            elif m.startswith("ftp://") or m.startswith("http"):
                f.write("url --url=%s\n" % urllib.unquote(m))

        # Some kickstart commands do not correspond to any anaconda UI
        # component.  If this is a kickstart install, we need to make sure
        # the information from the input file ends up in the output file.
        if self.ksdata:
            f.write(self.ksdata.user.__str__())
            f.write(self.ksdata.services.__str__())
            f.write(self.ksdata.reboot.__str__())

        self.instLanguage.writeKS(f)

        if not self.isHeadless:
            self.keyboard.writeKS(f)
            self.network.writeKS(f)

        self.timezone.writeKS(f)
        self.users.writeKS(f)
        self.security.writeKS(f)
        self.firewall.writeKS(f)

        self.storage.writeKS(f)
        self.bootloader.writeKS(f)

        if self.backend:
            self.backend.writeKS(f)
            self.backend.writePackagesKS(f, self)

        # Also write out any scripts from the input ksfile.
        if self.ksdata:
            for s in self.ksdata.scripts:
                f.write(s.__str__())

        # make it so only root can read, could have password
        os.chmod(filename, 0600)

if __name__ == "__main__":
    setupPythonPath()

    # Allow a file to be loaded as early as possible
    try:
        import updates_disk_hook
    except ImportError:
        pass

    # Set up logging as early as possible.
    import logging
    import anaconda_log

    log = logging.getLogger("anaconda")
    stdoutLog = logging.getLogger("anaconda.stdout")

    # pull this in to get product name and versioning
    import product

    # this handles setting up updates for pypackages to minimize the set needed
    setupPythonUpdates()

    import signal, string, isys, iutil, time
    import warnings
    import vnc
    import users
    import kickstart
    import storage.storage_log

    from flags import flags

    # the following makes me very sad. -- katzj
    # we have a slightly different set of udev rules in the second 
    # stage than the first stage.  why this doesn't get picked up
    # automatically, I don't know.  but we need to trigger so that we
    # have all the information about netdevs that we care about for 
    # NetworkManager in the udev database
    from baseudev import udev_trigger, udev_settle
    udev_trigger("net")
    udev_settle()
    # and for added fun, once doesn't seem to be enough?  so we 
    # do it twice, it works and we scream at the world "OH WHY?"
    udev_trigger("net")
    udev_settle()

    import gettext
    _ = lambda x: gettext.ldgettext("anaconda", x)

    anaconda = Anaconda()
    warnings.showwarning = AnacondaShowWarning
    setupTranslations()

    # reset python's default SIGINT handler
    signal.signal(signal.SIGINT, signal.SIG_DFL)
    signal.signal(signal.SIGSEGV, isys.handleSegv)

    setupEnvironment()

    pidfile = open("/var/run/anaconda.pid", "w")
    pidfile.write("%s\n" % (os.getpid(),))
    del pidfile
    # add our own additional signal handlers
    signal.signal(signal.SIGHUP, startDebugger)

    # we need to do this really early so we make sure its done before rpm
    # is imported
    iutil.writeRpmPlatform()

    graphical_failed = 0
    vncS = vnc.VncServer()          # The vnc Server object.
    vncS.anaconda = anaconda
    xserver_pid = None

    (opts, args) = parseOptions()

    if opts.unsupportedMode:
        stdoutLog.error("Running anaconda in %s mode is no longer supported." % opts.unsupportedMode)
        sys.exit(0)

    # Now that we've got arguments, do some extra processing.
    setupLoggingFromOpts(opts)

    # Default is to prompt to mount the installed system.
    anaconda.rescue_mount = not opts.rescue_nomount

    if opts.dlabel: #autodetected driverdisc in use
        flags.dlabel = True

    anaconda.displayMode = opts.display_mode
    anaconda.isHeadless = opts.isHeadless

    if opts.noipv4:
        flags.useIPv4 = False

    if opts.noipv6:
        flags.useIPv6 = False

    if opts.proxy:
        anaconda.proxy = opts.proxy

        if opts.proxyAuth:
            filename = opts.proxyAuth
            ret = open(filename, "r").readlines()
            os.unlink(filename)

            anaconda.proxyUsername = ret[0].rstrip()
            if len(ret) == 2:
                anaconda.proxyPassword = ret[1].rstrip()

    if opts.updateSrc:
        anaconda.updateSrc = opts.updateSrc

    if opts.method:
        if opts.method[0] == '@':
            opts.method = expandFTPMethod(opts.method)

        anaconda.setMethodstr(opts.method)
    else:
        anaconda.methodstr = None

    if opts.stage2:
        if opts.stage2[0] == '@':
            opts.stage2 = expandFTPMethod(opts.stage2)

        anaconda.stage2 = opts.stage2

    if opts.liveinst:
        flags.livecdInstall = True

    if opts.module:
        for mod in opts.module:
            (path, name) = string.split(mod, ":")
            anaconda.extraModules.append((path, name))

    if opts.vnc:
        flags.usevnc = 1
        anaconda.displayMode = 'g'
        vncS.recoverVNCPassword()

        # Only consider vncconnect when vnc is a param
        if opts.vncconnect:
            cargs = string.split(opts.vncconnect, ":")
            vncS.vncconnecthost = cargs[0]
            if len(cargs) > 1 and len(cargs[1]) > 0:
                if len(cargs[1]) > 0:
                    vncS.vncconnectport = cargs[1]

    if opts.ibft:
        flags.ibft = 1

    if opts.iscsi:
        flags.iscsi = 1

    if opts.targetArch:
        flags.targetarch = opts.targetArch

    # set flags 
    flags.dmraid = opts.dmraid
    flags.mpath = opts.mpath
    flags.selinux = opts.selinux

    if opts.serial:
        flags.serial = True
    if opts.virtpconsole:
        flags.virtpconsole = opts.virtpconsole

    if opts.xdriver:
        anaconda.xdriver = opts.xdriver
        anaconda.writeXdriver()

    if not flags.livecdInstall:
        isys.auditDaemon()

    # setup links required for all install types
    for i in ( "services", "protocols", "nsswitch.conf", "joe", "selinux",
               "mke2fs.conf" ):
        try:
            if os.path.exists("/mnt/runtime/etc/" + i):
                os.symlink ("../mnt/runtime/etc/" + i, "/etc/" + i)
        except:
            pass

    # This is the one place we do all kickstart file parsing.
    if opts.ksfile:
        kickstart.preScriptPass(anaconda, opts.ksfile)
        anaconda.ksdata = kickstart.parseKickstart(anaconda, opts.ksfile)
        opts.rescue = anaconda.ksdata.rescue.rescue

        # we need to have a libuser.conf that points to the installer root for
        # sshpw, but after that we start sshd, we need one that points to the
        # install target.
        luserConf = users.createLuserConf(instPath="")
        handleSshPw(anaconda)
        startSsh()
        del(os.environ["LIBUSER_CONF"])

    users.createLuserConf(anaconda.rootPath)

    if opts.rescue:
        anaconda.rescue = True

        import rescue

        if anaconda.ksdata:
            anaconda.instClass.configure(anaconda)

            # We need an interface before running kickstart execute methods for
            # storage.
            from snack import *
            screen = SnackScreen()
            anaconda.intf = rescue.RescueInterface(screen)

            anaconda.ksdata.execute()

            anaconda.intf = None
            screen.finish()

            # command line 'nomount' overrides kickstart /same for vnc/
            anaconda.rescue_mount = not (opts.rescue_nomount or anaconda.ksdata.rescue.nomount)

        rescue.runRescue(anaconda)

        # shouldn't get back here
        sys.exit(1)

    if anaconda.ksdata:
        if anaconda.ksdata.vnc.enabled:
            flags.usevnc = 1
            anaconda.displayMode = 'g'

            if vncS.password == "":
                vncS.password = anaconda.ksdata.vnc.password

            if vncS.vncconnecthost == "":
                vncS.vncconnecthost = anaconda.ksdata.vnc.host

            if vncS.vncconnectport == "":
                vncS.vncconnectport = anaconda.ksdata.vnc.port

        flags.vncquestion = False

    # disable VNC over text question when not enough memory is available
    if iutil.memInstalled() < isys.MIN_GUI_RAM:
        flags.vncquestion = False


    if anaconda.displayMode == 't' and flags.vncquestion: #we prefer vnc over text mode, so ask about that
        title = _("Would you like to use VNC?")
        message = _("Text mode provides a limited set of installation options.  "
                    "It does not allow you to specify your own partitioning "
                    "layout or package selections.  Would you like to use VNC "
                    "mode instead?")

        ret = vnc.askVncWindow(title, message)
        if ret != -1:
            anaconda.displayMode = 'g'
            flags.usevnc = 1
            if ret is not None:
                vncS.password = ret

    if opts.debug:
        flags.debug = True

    log.info("anaconda called with cmdline = %s" %(sys.argv,))
    log.info("Display mode = %s" % anaconda.displayMode)

    checkMemory(anaconda)

    #
    # now determine if we're going to run in GUI or TUI mode
    #
    # if no X server, we have to use text mode
    if not flags.livecdInstall and not iutil.isS390() and not os.access("/usr/bin/Xorg", os.X_OK):
         stdoutLog.warning(_("Graphical installation is not available. "
                             "Starting text mode."))
         time.sleep(2)
         anaconda.displayMode = 't'

    # s390/iSeries checks
    if anaconda.isHeadless and anaconda.displayMode == "g" and not \
       (os.environ.has_key("DISPLAY") or flags.usevnc):
        stdoutLog.warning(_("DISPLAY variable not set. Starting text mode."))
        anaconda.displayMode = 't'
        graphical_failed = 1
        time.sleep(2)

    # if DISPLAY not set either vnc server failed to start or we're not
    # running on a redirected X display, so start local X server
    if anaconda.displayMode == 'g' and not os.environ.has_key('DISPLAY') and not flags.usevnc:
        try:
            # start X with its USR1 handler set to ignore.  this will make it send
            # us SIGUSR1 if it succeeds.  if it fails, catch SIGCHLD and bomb out.

            def sigchld_handler(num, frame):
                raise OSError

            def sigusr1_handler(num, frame):
                pass

            def preexec_fn():
                signal.signal(signal.SIGUSR1, signal.SIG_IGN)

            old_sigusr1 = signal.signal(signal.SIGUSR1, sigusr1_handler)
            old_sigchld = signal.signal(signal.SIGCHLD, sigchld_handler)
            xout = open("/dev/tty5", "w")

            proc = subprocess.Popen(["Xorg", "-br", "-logfile", "/tmp/X.log",
                                     ":1", "vt6", "-s", "1440", "-ac",
                                     "-nolisten", "tcp", "-dpi", "96"],
                                     close_fds=True, stdout=xout, stderr=xout,
                                     preexec_fn=preexec_fn)

            signal.pause()

            os.environ["DISPLAY"] = ":1"
            doStartupX11Actions(opts.runres)
            xserver_pid = proc.pid
        except (OSError, RuntimeError):
            stdoutLog.warning(" X startup failed, falling back to text mode")
            anaconda.displayMode = 't'
            graphical_failed = 1
            time.sleep(2)
        finally:
            signal.signal(signal.SIGUSR1, old_sigusr1)
            signal.signal(signal.SIGCHLD, old_sigchld)

    if anaconda.displayMode == 't' and graphical_failed and not anaconda.ksdata:
        ret = vnc.askVncWindow()
        if ret != -1:
            anaconda.displayMode = 'g'
            flags.usevnc = 1
            if ret is not None:
                vncS.password = ret

    # if they want us to use VNC do that now
    if anaconda.displayMode == 'g' and flags.usevnc:
        runVNC()
        doStartupX11Actions(opts.runres)

    anaconda.instClass.configure(anaconda)

    # comment out the next line to make exceptions non-fatal
    from exception import initExceptionHandling
    anaconda.mehConfig = initExceptionHandling(anaconda)

    # add our own additional signal handlers
    signal.signal(signal.SIGUSR2, lambda signum, frame: anaconda.dumpState())

    # download and run Dogtail script
    if opts.dogtail:
       try:
           import urlgrabber

           try:
               fr = urlgrabber.urlopen(opts.dogtail)
           except urlgrabber.grabber.URLGrabError, e:
               log.error("Could not retrieve Dogtail script from %s.\nError was\n%s" % (opts.dogtail, e))
               fr = None
                           
           if fr:
               (fw, testcase) = mkstemp(prefix='testcase.py.', dir='/tmp')
               os.write(fw, fr.read())
               fr.close()
               os.close(fw)
               
               # download completed, run the test
               if not os.fork():
                   # we are in the child
                   os.chmod(testcase, 0755)
                   os.execv(testcase, [testcase])
                   sys.exit(0)
               else:
                   # we are in the parent, sleep to give time for the testcase to initialize
                   # todo: is this needed, how to avoid possible race conditions
                   time.sleep(1)
       except Exception, e:
           log.error("Exception %s while running Dogtail testcase" % e)

    if opts.lang:
        # this is lame, but make things match what we expect (#443408)
        opts.lang = opts.lang.replace(".utf8", ".UTF-8")
        anaconda.dispatch.skipStep("language", permanent = 1)
        anaconda.instLanguage.instLang = opts.lang
        anaconda.instLanguage.systemLang = opts.lang
        anaconda.timezone.setTimezoneInfo(anaconda.instLanguage.getDefaultTimeZone(anaconda.rootPath))

    if opts.keymap:
        anaconda.dispatch.skipStep("keyboard", permanent = 1)
        anaconda.keyboard.set(opts.keymap)
        anaconda.keyboard.activate()

    if anaconda.ksdata:
        import storage

        # Before we set up the storage system, we need to know which disks to
        # ignore, etc.  Luckily that's all in the kickstart data.
        anaconda.storage.zeroMbr = anaconda.ksdata.zerombr.zerombr
        anaconda.storage.ignoredDisks = anaconda.ksdata.ignoredisk.ignoredisk
        anaconda.storage.exclusiveDisks = anaconda.ksdata.ignoredisk.onlyuse

        if anaconda.ksdata.clearpart.type is not None:
            anaconda.storage.clearPartType = anaconda.ksdata.clearpart.type
            anaconda.storage.clearPartDisks = anaconda.ksdata.clearpart.drives
            if anaconda.ksdata.clearpart.initAll:
                anaconda.storage.reinitializeDisks = anaconda.ksdata.clearpart.initAll

        storage.storageInitialize(anaconda)

        # Now having initialized storage, we can apply all the other kickstart
        # commands.  This gives us the ability to check that storage commands
        # are correctly formed and refer to actual devices.
        anaconda.ksdata.execute()

    # set up the headless case
    if anaconda.isHeadless:
        anaconda.dispatch.skipStep("keyboard", permanent = 1)

    if not anaconda.ksdata:
        anaconda.instClass.setSteps(anaconda)
    else:
        kickstart.setSteps(anaconda)

    try:
        anaconda.intf.run(anaconda)
    except SystemExit, code:
        anaconda.intf.shutdown()

    if anaconda.ksdata and anaconda.ksdata.reboot.eject:
        for drive in anaconda.storage.devicetree.devices:
            if drive.type != "cdrom":
                continue

            log.info("attempting to eject %s" % drive.path)
            drive.eject()

    del anaconda.intf

# vim:tw=78:ts=4:et:sw=4