cabe94affb
Text mode provide very limited UI widget set and almost not existing error reporting, which can result in broken installation.
1241 lines
42 KiB
Python
Executable File
1241 lines
42 KiB
Python
Executable File
#!/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 fork_orphan():
|
|
"""Forks an orphan.
|
|
|
|
Returns 1 in the parent and 0 in the orphaned child.
|
|
"""
|
|
intermediate = os.fork()
|
|
if not intermediate:
|
|
if os.fork():
|
|
# the intermediate child dies
|
|
os._exit(0)
|
|
return 0;
|
|
# the original process waits for the intermediate child
|
|
os.waitpid(intermediate, 0)
|
|
return 1
|
|
|
|
def startSsh():
|
|
if not flags.sshd:
|
|
return
|
|
if iutil.isS390():
|
|
return
|
|
|
|
if not fork_orphan():
|
|
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):
|
|
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 protected(self):
|
|
import stat
|
|
|
|
if os.path.exists("/dev/live") and \
|
|
stat.S_ISBLK(os.stat("/dev/live")[stat.ST_MODE]):
|
|
return [os.readlink("/dev/live")]
|
|
elif self.methodstr and self.methodstr.startswith("hd:"):
|
|
method = self.methodstr[3:]
|
|
return [method.split(":", 3)[0]]
|
|
else:
|
|
return []
|
|
|
|
@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 initInterface(self):
|
|
if self._intf:
|
|
raise RuntimeError, "Second attempt to initialize the InstallInterface"
|
|
|
|
# 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 writeXdriver(self, root = None):
|
|
# this should go away at some point, but until it does, we
|
|
# need to keep it around.
|
|
if self.xdriver is None:
|
|
return
|
|
if root is None:
|
|
root = self.rootPath
|
|
if not os.path.isdir("%s/etc/X11" %(root,)):
|
|
os.makedirs("%s/etc/X11" %(root,), mode=0755)
|
|
f = open("%s/etc/X11/xorg.conf" %(root,), '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)
|
|
|
|
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)
|
|
|
|
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(root="/")
|
|
|
|
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)
|
|
log.info("Default encoding = %s " % sys.getdefaultencoding())
|
|
|
|
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:
|
|
# The following code depends on no SIGCHLD being delivered, possibly
|
|
# only except the one from a failing X.org. Thus make sure before
|
|
# entering this section that all the other children of anaconda have
|
|
# terminated or were forked into an orphan (which won't deliver a
|
|
# SIGCHLD to mess up the fragile signaling below).
|
|
|
|
# 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, aborting installation")
|
|
time.sleep(2)
|
|
sys.exit(1)
|
|
#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)
|
|
|
|
# with X running we can initialize the UI interface
|
|
anaconda.initInterface()
|
|
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
|