| 1 |
# |
| 2 |
# text.py - text mode frontend to anaconda |
| 3 |
# |
| 4 |
# Erik Troan <ewt@redhat.com> |
| 5 |
# Matt Wilson <msw@redhat.com> |
| 6 |
# |
| 7 |
# Copyright 1999-2004 Red Hat, Inc. |
| 8 |
# |
| 9 |
# This software may be freely redistributed under the terms of the GNU |
| 10 |
# library public license. |
| 11 |
# |
| 12 |
# You should have received a copy of the GNU Library Public License |
| 13 |
# along with this program; if not, write to the Free Software |
| 14 |
# Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. |
| 15 |
# |
| 16 |
|
| 17 |
from snack import * |
| 18 |
import sys |
| 19 |
import os |
| 20 |
import isys |
| 21 |
import iutil |
| 22 |
import time |
| 23 |
import signal |
| 24 |
import parted |
| 25 |
import string |
| 26 |
import kudzu |
| 27 |
from language import expandLangs |
| 28 |
from flags import flags |
| 29 |
from constants_text import * |
| 30 |
from constants import * |
| 31 |
|
| 32 |
from rhpl.log import log |
| 33 |
from rhpl.translate import _, cat, N_ |
| 34 |
|
| 35 |
stepToClasses = { |
| 36 |
"language" : ("language_text", "LanguageWindow"), |
| 37 |
"keyboard" : ("keyboard_text", "KeyboardWindow"), |
| 38 |
"mouse" : ("mouse_text", ("MouseWindow", "MouseDeviceWindow")), |
| 39 |
"welcome" : ("welcome_text", "WelcomeWindow"), |
| 40 |
"installtype" : ("installpath_text", "InstallPathWindow"), |
| 41 |
"autopartition" : ("partition_text", "AutoPartitionWindow"), |
| 42 |
"custom-upgrade" : ("upgrade_text", "UpgradeExamineWindow"), |
| 43 |
"addswap" : ("upgrade_text", "UpgradeSwapWindow"), |
| 44 |
"upgrademigratefs" : ("upgrade_text", "UpgradeMigrateFSWindow"), |
| 45 |
"fdisk" : ("fdisk_text", "fdiskPartitionWindow"), |
| 46 |
"partitionmethod" : ("partmethod_text", ("PartitionMethod")), |
| 47 |
"partition": ("partition_text", ("PartitionWindow")), |
| 48 |
"zfcpconfig": ("zfcp_text", ("ZFCPWindow")), |
| 49 |
"findinstall" : ("upgrade_text", ("UpgradeExamineWindow")), |
| 50 |
# replace with below if you want customize screen |
| 51 |
# "findinstall" : ("upgrade_text", ("UpgradeExamineWindow", |
| 52 |
# "CustomizeUpgradeWindow")), |
| 53 |
"addswap" : ("upgrade_text", "UpgradeSwapWindow"), |
| 54 |
"upgbootloader": ("upgrade_bootloader_text", "UpgradeBootloaderWindow"), |
| 55 |
"bootloader" : ("bootloader_text", ("BootloaderChoiceWindow", |
| 56 |
"BootloaderAppendWindow", |
| 57 |
"BootloaderPasswordWindow")), |
| 58 |
"bootloaderadvanced" : ("bootloader_text", ("BootloaderImagesWindow", |
| 59 |
"BootloaderLocationWindow")), |
| 60 |
"network" : ("network_text", ("NetworkDeviceWindow", "NetworkGlobalWindow", |
| 61 |
"HostnameWindow")), |
| 62 |
"firewall" : ("firewall_text", ("FirewallWindow", |
| 63 |
"SELinuxWindow")), |
| 64 |
"languagesupport" : ("language_text", ("LanguageSupportWindow", |
| 65 |
"LanguageDefaultWindow")), |
| 66 |
"timezone" : ("timezone_text", "TimezoneWindow"), |
| 67 |
"accounts" : ("userauth_text", "RootPasswordWindow"), |
| 68 |
"authentication" : ("userauth_text", ("AuthConfigWindow")), |
| 69 |
"desktopchoice": ("desktop_choice_text", "DesktopChoiceWindow"), |
| 70 |
"package-selection" : ("packages_text", "PackageGroupWindow"), |
| 71 |
"indivpackage" : ("packages_text", ("IndividualPackageWindow")), |
| 72 |
"dependencies" : ("packages_text", "PackageDepWindow"), |
| 73 |
"videocard" : ("xconfig_text", "XConfigWindowCard"), |
| 74 |
"monitor" : ("xconfig_text", "MonitorWindow"), |
| 75 |
"xcustom" : ("xconfig_text", "XCustomWindow"), |
| 76 |
"confirminstall" : ("confirm_text", "BeginInstallWindow"), |
| 77 |
"confirmupgrade" : ("confirm_text", "BeginUpgradeWindow"), |
| 78 |
"install" : ("progress_text", "setupForInstall"), |
| 79 |
"bootdisk" : ("bootdisk_text", ("BootDiskWindow")), |
| 80 |
"complete" : ("complete_text", "FinishedWindow"), |
| 81 |
} |
| 82 |
|
| 83 |
if iutil.getArch() == 'sparc': |
| 84 |
stepToClasses["bootloader"] = ("silo_text", ("SiloAppendWindow", |
| 85 |
"SiloWindow" |
| 86 |
"SiloImagesWindow")) |
| 87 |
if iutil.getArch() == 's390': |
| 88 |
stepToClasses["bootloader"] = ("zipl_text", ( "ZiplWindow")) |
| 89 |
|
| 90 |
class InstallWindow: |
| 91 |
def __call__ (self, screen): |
| 92 |
raise RuntimeError, "Unimplemented screen" |
| 93 |
|
| 94 |
class WaitWindow: |
| 95 |
def pop(self): |
| 96 |
self.screen.popWindow() |
| 97 |
self.screen.refresh() |
| 98 |
|
| 99 |
def __init__(self, screen, title, text): |
| 100 |
self.screen = screen |
| 101 |
width = 40 |
| 102 |
if (len(text) < width): width = len(text) |
| 103 |
|
| 104 |
t = TextboxReflowed(width, text) |
| 105 |
|
| 106 |
g = GridForm(self.screen, title, 1, 1) |
| 107 |
g.add(t, 0, 0) |
| 108 |
g.draw() |
| 109 |
self.screen.refresh() |
| 110 |
|
| 111 |
class OkCancelWindow: |
| 112 |
def getrc(self): |
| 113 |
return self.rc |
| 114 |
|
| 115 |
def __init__(self, screen, title, text): |
| 116 |
rc = ButtonChoiceWindow(screen, title, text, |
| 117 |
buttons=[TEXT_OK_BUTTON, _("Cancel")]) |
| 118 |
if rc == string.lower(_("Cancel")): |
| 119 |
self.rc = 1 |
| 120 |
else: |
| 121 |
self.rc = 0 |
| 122 |
|
| 123 |
class ProgressWindow: |
| 124 |
def pop(self): |
| 125 |
self.screen.popWindow() |
| 126 |
self.screen.refresh() |
| 127 |
del self.scale |
| 128 |
self.scale = None |
| 129 |
|
| 130 |
def set(self, amount): |
| 131 |
self.scale.set(amount) |
| 132 |
self.screen.refresh() |
| 133 |
|
| 134 |
def __init__(self, screen, title, text, total): |
| 135 |
self.screen = screen |
| 136 |
width = 55 |
| 137 |
if (len(text) > width): width = len(text) |
| 138 |
|
| 139 |
t = TextboxReflowed(width, text) |
| 140 |
|
| 141 |
g = GridForm(self.screen, title, 1, 2) |
| 142 |
g.add(t, 0, 0, (0, 0, 0, 1), anchorLeft=1) |
| 143 |
|
| 144 |
self.scale = Scale(width, total) |
| 145 |
g.add(self.scale, 0, 1) |
| 146 |
|
| 147 |
g.draw() |
| 148 |
self.screen.refresh() |
| 149 |
|
| 150 |
class InstallInterface: |
| 151 |
def helpWindow(self, screen, key): |
| 152 |
lang = self.instLanguage.getCurrent() |
| 153 |
lang = self.instLanguage.getLangNick(lang) |
| 154 |
self.langSearchPath = expandLangs(lang) + ['C'] |
| 155 |
|
| 156 |
if key == "helponhelp": |
| 157 |
if self.showingHelpOnHelp: |
| 158 |
return None |
| 159 |
else: |
| 160 |
self.showingHelpOnHelp = 1 |
| 161 |
try: |
| 162 |
f = None |
| 163 |
|
| 164 |
if self.configFileData.has_key("helptag"): |
| 165 |
helpTag = "-%s" % (self.configFileData["helptag"],) |
| 166 |
else: |
| 167 |
helpTag = "" |
| 168 |
arch = "-%s" % (iutil.getArch(),) |
| 169 |
tags = [ "%s%s" % (helpTag, arch), "%s" % (helpTag,), |
| 170 |
"%s" % (arch,), "" ] |
| 171 |
|
| 172 |
# XXX |
| 173 |
# |
| 174 |
# HelpWindow can't get to the langauge |
| 175 |
|
| 176 |
found = 0 |
| 177 |
for path in ("./text-", "/mnt/source/RHupdates/", |
| 178 |
"/usr/share/anaconda/"): |
| 179 |
if found: |
| 180 |
break |
| 181 |
for lang in self.langSearchPath: |
| 182 |
for tag in tags: |
| 183 |
fn = "%shelp/%s/s1-help-screens-%s%s.txt" \ |
| 184 |
% (path, lang, key, tag) |
| 185 |
|
| 186 |
try: |
| 187 |
f = open(fn) |
| 188 |
except IOError, msg: |
| 189 |
continue |
| 190 |
found = 1 |
| 191 |
break |
| 192 |
|
| 193 |
if not f: |
| 194 |
ButtonChoiceWindow(screen, _("Help not available"), |
| 195 |
_("No help is available for this " |
| 196 |
"step of the install."), |
| 197 |
buttons=[TEXT_OK_BUTTON]) |
| 198 |
return None |
| 199 |
|
| 200 |
lines = f.readlines() |
| 201 |
for l in lines: |
| 202 |
l = l.replace("@RHL@", productName) |
| 203 |
l = l.replace("@RHLVER@", productVersion) |
| 204 |
while not string.strip(l[0]): |
| 205 |
l = l[1:] |
| 206 |
title = string.strip(l[0]) |
| 207 |
l = l[1:] |
| 208 |
while not string.strip(l[0]): |
| 209 |
l = l[1:] |
| 210 |
f.close() |
| 211 |
|
| 212 |
height = 10 |
| 213 |
scroll = 1 |
| 214 |
if len(l) < height: |
| 215 |
height = len(l) |
| 216 |
scroll = 0 |
| 217 |
|
| 218 |
width = len(title) + 6 |
| 219 |
stream = "" |
| 220 |
for line in l: |
| 221 |
line = string.strip(line) |
| 222 |
stream = stream + line + "\n" |
| 223 |
if len(line) > width: |
| 224 |
width = len(line) |
| 225 |
|
| 226 |
bb = ButtonBar(screen, [TEXT_OK_BUTTON]) |
| 227 |
t = Textbox(width, height, stream, scroll=scroll) |
| 228 |
|
| 229 |
g = GridFormHelp(screen, title, "helponhelp", 1, 2) |
| 230 |
g.add(t, 0, 0, padding=(0, 0, 0, 1)) |
| 231 |
g.add(bb, 0, 1, growx=1) |
| 232 |
|
| 233 |
g.runOnce() |
| 234 |
self.showingHelpOnHelp = 0 |
| 235 |
except: |
| 236 |
import traceback |
| 237 |
(type, value, tb) = sys.exc_info() |
| 238 |
from string import joinfields |
| 239 |
list = traceback.format_exception(type, value, tb) |
| 240 |
text = joinfields(list, "") |
| 241 |
rc = self.exceptionWindow(_("Exception Occurred"), text) |
| 242 |
if rc: |
| 243 |
import pdb |
| 244 |
pdb.post_mortem(tb) |
| 245 |
os._exit(1) |
| 246 |
|
| 247 |
def progressWindow(self, title, text, total): |
| 248 |
return ProgressWindow(self.screen, title, text, total) |
| 249 |
|
| 250 |
def messageWindow(self, title, text, type="ok", default = None, |
| 251 |
custom_icon=None, custom_buttons=[]): |
| 252 |
if type == "ok": |
| 253 |
ButtonChoiceWindow(self.screen, title, text, |
| 254 |
buttons=[TEXT_OK_BUTTON]) |
| 255 |
elif type == "yesno": |
| 256 |
if default and default == "no": |
| 257 |
btnlist = [TEXT_NO_BUTTON, TEXT_YES_BUTTON] |
| 258 |
else: |
| 259 |
btnlist = [TEXT_YES_BUTTON, TEXT_NO_BUTTON] |
| 260 |
rc = ButtonChoiceWindow(self.screen, title, text, |
| 261 |
buttons=btnlist) |
| 262 |
if rc == "yes": |
| 263 |
return 1 |
| 264 |
else: |
| 265 |
return 0 |
| 266 |
elif type == "custom": |
| 267 |
tmpbut = [] |
| 268 |
for but in custom_buttons: |
| 269 |
tmpbut.append(string.replace(but,"_","")) |
| 270 |
|
| 271 |
rc = ButtonChoiceWindow(self.screen, title, text, width=60, |
| 272 |
buttons=tmpbut) |
| 273 |
|
| 274 |
idx = 0 |
| 275 |
for b in tmpbut: |
| 276 |
if string.lower(b) == rc: |
| 277 |
return idx != 0 |
| 278 |
idx = idx + 1 |
| 279 |
return 0 |
| 280 |
else: |
| 281 |
return OkCancelWindow(self.screen, title, text) |
| 282 |
|
| 283 |
def kickstartErrorWindow(self, text): |
| 284 |
s = _("The following error was found while parsing your " |
| 285 |
"kickstart configuration:\n\n%s") %(text,) |
| 286 |
self.messageWindow(_("Error Parsing Kickstart Config"), |
| 287 |
s, |
| 288 |
type = "custom", |
| 289 |
custom_buttons = [("_Reboot")], |
| 290 |
custom_icon="error") |
| 291 |
|
| 292 |
|
| 293 |
|
| 294 |
def dumpWindow(self): |
| 295 |
rc = ButtonChoiceWindow(self.screen, _("Save Crash Dump"), |
| 296 |
_("Please insert a floppy now. All contents of the disk " |
| 297 |
"will be erased, so please choose your diskette carefully."), |
| 298 |
[TEXT_OK_BUTTON, _("Cancel")]) |
| 299 |
|
| 300 |
if rc == string.lower(_("Cancel")): |
| 301 |
return 1 |
| 302 |
|
| 303 |
return 0 |
| 304 |
|
| 305 |
def exceptionWindow(self, title, text): |
| 306 |
try: |
| 307 |
floppyDevices = 0 |
| 308 |
for dev in kudzu.probe(kudzu.CLASS_FLOPPY, kudzu.BUS_UNSPEC, |
| 309 |
kudzu.PROBE_ALL): |
| 310 |
if not dev.detached: |
| 311 |
floppyDevices = floppyDevices + 1 |
| 312 |
except: |
| 313 |
floppyDevices = 0 |
| 314 |
if floppyDevices > 0 or DEBUG: |
| 315 |
ugh = "%s\n\n" % (exceptionText,) |
| 316 |
buttons=[TEXT_OK_BUTTON, _("Save"), _("Debug")] |
| 317 |
else: |
| 318 |
ugh = "%s\n\n" % (exceptionTextNoFloppy,) |
| 319 |
buttons=[TEXT_OK_BUTTON, _("Debug")] |
| 320 |
|
| 321 |
rc = ButtonChoiceWindow(self.screen, title, ugh + text, buttons) |
| 322 |
if rc == string.lower(_("Debug")): |
| 323 |
return 1 |
| 324 |
elif rc == string.lower(_("Save")): |
| 325 |
return 2 |
| 326 |
return None |
| 327 |
|
| 328 |
def partedExceptionWindow(self, exc): |
| 329 |
# if our only option is to cancel, let us handle the exception |
| 330 |
# in our code and avoid popping up the exception window here. |
| 331 |
if exc.options == parted.EXCEPTION_CANCEL: |
| 332 |
return parted.EXCEPTION_UNHANDLED |
| 333 |
log("parted exception: %s: %s" %(exc.type_string,exc.message)) |
| 334 |
buttons = [] |
| 335 |
buttonToAction = {} |
| 336 |
flags = ((parted.EXCEPTION_FIX, N_("Fix")), |
| 337 |
(parted.EXCEPTION_YES, N_("Yes")), |
| 338 |
(parted.EXCEPTION_NO, N_("No")), |
| 339 |
(parted.EXCEPTION_OK, N_("OK")), |
| 340 |
(parted.EXCEPTION_RETRY, N_("Retry")), |
| 341 |
(parted.EXCEPTION_IGNORE, N_("Ignore")), |
| 342 |
(parted.EXCEPTION_CANCEL, N_("Cancel"))) |
| 343 |
for flag, errorstring in flags: |
| 344 |
if exc.options & flag: |
| 345 |
buttons.append(_(errorstring)) |
| 346 |
buttonToAction[string.lower(_(errorstring))] = flag |
| 347 |
|
| 348 |
rc = None |
| 349 |
while not buttonToAction.has_key(rc): |
| 350 |
rc = ButtonChoiceWindow(self.screen, exc.type_string, exc.message, |
| 351 |
buttons=buttons) |
| 352 |
|
| 353 |
return buttonToAction[rc] |
| 354 |
|
| 355 |
|
| 356 |
def waitWindow(self, title, text): |
| 357 |
return WaitWindow(self.screen, title, text) |
| 358 |
|
| 359 |
def drawFrame(self): |
| 360 |
self.welcomeText = _("%s Released via the GPL") % (productName,) |
| 361 |
self.screen.drawRootText (0, 0, self.welcomeText) |
| 362 |
self.screen.drawRootText (len(_(self.welcomeText)), 0, |
| 363 |
(self.screen.width - |
| 364 |
len(_(self.welcomeText))) * " ") |
| 365 |
|
| 366 |
if (os.access("/usr/share/anaconda/help/C/s1-help-screens-lang.txt", os.R_OK)): |
| 367 |
self.screen.pushHelpLine(_(" <F1> for help | <Tab> between elements | <Space> selects | <F12> next screen")) |
| 368 |
else: |
| 369 |
self.screen.pushHelpLine(_(" <Tab>/<Alt-Tab> between elements | <Space> selects | <F12> next screen")) |
| 370 |
|
| 371 |
def setScreen(self, screen): |
| 372 |
self.screen = screen |
| 373 |
|
| 374 |
def shutdown(self): |
| 375 |
self.screen.finish() |
| 376 |
self.screen = None |
| 377 |
|
| 378 |
def __init__(self): |
| 379 |
signal.signal(signal.SIGINT, signal.SIG_IGN) |
| 380 |
signal.signal(signal.SIGTSTP, signal.SIG_IGN) |
| 381 |
self.screen = None |
| 382 |
self.showingHelpOnHelp = 0 |
| 383 |
|
| 384 |
def __del__(self): |
| 385 |
if self.screen: |
| 386 |
self.screen.finish() |
| 387 |
|
| 388 |
def run(self, id, dispatch, configFileData): |
| 389 |
# set up for CJK text mode if needed |
| 390 |
oldlang = None |
| 391 |
if (flags.setupFilesystems and |
| 392 |
(id.instLanguage.getFontFile(id.instLanguage.getCurrent()) == "bterm") |
| 393 |
and not flags.serial and not flags.virtpconsole |
| 394 |
and not isys.isPsudoTTY(0) and not isys.isVioConsole()): |
| 395 |
log("starting bterm") |
| 396 |
rc = 1 |
| 397 |
try: |
| 398 |
rc = isys.startBterm() |
| 399 |
time.sleep(1) |
| 400 |
except Exception, e: |
| 401 |
log("got an exception starting bterm: %s" %(e,)) |
| 402 |
|
| 403 |
if rc == 1: |
| 404 |
log("unable to start bterm, falling back to english") |
| 405 |
oldlang = id.instLanguage.getCurrent() |
| 406 |
log("old language was %s" %(oldlang,)) |
| 407 |
id.instLanguage.setRuntimeLanguage("English") |
| 408 |
id.instLanguage.setRuntimeDefaults(oldlang) |
| 409 |
|
| 410 |
if id.instLanguage.getFontFile(id.instLanguage.getCurrent()) == "none": |
| 411 |
oldlang = id.instLanguage.getCurrent() |
| 412 |
id.instLanguage.setRuntimeLanguage("English") |
| 413 |
id.instLanguage.setRuntimeDefaults(oldlang) |
| 414 |
|
| 415 |
self.screen = SnackScreen() |
| 416 |
self.configFileData = configFileData |
| 417 |
self.screen.helpCallback(self.helpWindow) |
| 418 |
|
| 419 |
# uncomment this line to make the installer quit on <Ctrl+Z> |
| 420 |
# handy for quick debugging. |
| 421 |
# self.screen.suspendCallback(killSelf, self.screen) |
| 422 |
# uncomment this line to drop into the python debugger on <Ctrl+Z> |
| 423 |
# --VERY handy-- |
| 424 |
if DEBUG or flags.test: |
| 425 |
self.screen.suspendCallback(debugSelf, self.screen) |
| 426 |
|
| 427 |
if flags.serial or flags.virtpconsole or isys.isPsudoTTY(0) or isys.isVioConsole(): |
| 428 |
self.screen.suspendCallback(spawnShell, self.screen) |
| 429 |
|
| 430 |
# clear out the old root text by writing spaces in the blank |
| 431 |
# area on the right side of the screen |
| 432 |
#self.screen.drawRootText (len(_(self.welcomeText)), 0, |
| 433 |
#(self.screen.width - len(_(self.welcomeText))) * " ") |
| 434 |
#self.screen.drawRootText (0 - len(_(step[0])), 0, _(step[0])) |
| 435 |
langname = id.instLanguage.getCurrent() |
| 436 |
lang = id.instLanguage.getLangNick(langname) |
| 437 |
|
| 438 |
self.langSearchPath = expandLangs(lang) + ['C'] |
| 439 |
self.instLanguage = id.instLanguage |
| 440 |
|
| 441 |
# draw the frame after setting up the fallback |
| 442 |
self.drawFrame() |
| 443 |
|
| 444 |
# draw the frame after setting up the fallback |
| 445 |
self.drawFrame() |
| 446 |
|
| 447 |
if oldlang is not None: |
| 448 |
ButtonChoiceWindow(self.screen, "Language Unavailable", |
| 449 |
"%s display is unavailable in text mode. " |
| 450 |
"The installation will continue in " |
| 451 |
"English." % (oldlang,), |
| 452 |
buttons=[TEXT_OK_BUTTON]) |
| 453 |
|
| 454 |
|
| 455 |
id.fsset.registerMessageWindow(self.messageWindow) |
| 456 |
id.fsset.registerProgressWindow(self.progressWindow) |
| 457 |
id.fsset.registerWaitWindow(self.waitWindow) |
| 458 |
parted.exception_set_handler(self.partedExceptionWindow) |
| 459 |
|
| 460 |
lastrc = INSTALL_OK |
| 461 |
(step, args) = dispatch.currentStep() |
| 462 |
while step: |
| 463 |
(file, classNames) = stepToClasses[step] |
| 464 |
|
| 465 |
if type(classNames) != type(()): |
| 466 |
classNames = (classNames,) |
| 467 |
|
| 468 |
if lastrc == INSTALL_OK: |
| 469 |
step = 0 |
| 470 |
else: |
| 471 |
step = len(classNames) - 1 |
| 472 |
|
| 473 |
while step >= 0 and step < len(classNames): |
| 474 |
# reget the args. they could change (especially direction) |
| 475 |
(foo, args) = dispatch.currentStep() |
| 476 |
|
| 477 |
nextWindow = None |
| 478 |
s = "from %s import %s; nextWindow = %s" % \ |
| 479 |
(file, classNames[step], classNames[step]) |
| 480 |
exec s |
| 481 |
|
| 482 |
win = nextWindow() |
| 483 |
|
| 484 |
#log("TUI running step %s (class %s, file %s)" % |
| 485 |
#(step, file, classNames)) |
| 486 |
|
| 487 |
rc = apply(win, (self.screen, ) + args) |
| 488 |
|
| 489 |
if rc == INSTALL_NOOP: |
| 490 |
rc = lastrc |
| 491 |
|
| 492 |
if rc == INSTALL_BACK: |
| 493 |
step = step - 1 |
| 494 |
dispatch.dir = DISPATCH_BACK |
| 495 |
elif rc == INSTALL_OK: |
| 496 |
step = step + 1 |
| 497 |
dispatch.dir = DISPATCH_FORWARD |
| 498 |
|
| 499 |
lastrc = rc |
| 500 |
|
| 501 |
if step == -1: |
| 502 |
if not dispatch.canGoBack(): |
| 503 |
ButtonChoiceWindow(self.screen, _("Cancelled"), |
| 504 |
_("I can't go to the previous step " |
| 505 |
"from here. You will have to try " |
| 506 |
"again."), |
| 507 |
buttons=[_("OK")]) |
| 508 |
else: |
| 509 |
dispatch.gotoPrev() |
| 510 |
else: |
| 511 |
dispatch.gotoNext() |
| 512 |
|
| 513 |
(step, args) = dispatch.currentStep() |
| 514 |
|
| 515 |
self.screen.finish() |
| 516 |
|
| 517 |
def killSelf(screen): |
| 518 |
screen.finish() |
| 519 |
os._exit(0) |
| 520 |
|
| 521 |
def debugSelf(screen): |
| 522 |
screen.suspend() |
| 523 |
import pdb |
| 524 |
try: |
| 525 |
pdb.set_trace() |
| 526 |
except: |
| 527 |
sys.exit(-1) |
| 528 |
screen.resume() |
| 529 |
|
| 530 |
def spawnShell(screen): |
| 531 |
screen.suspend() |
| 532 |
print "\n\nType <exit> to return to the install program.\n" |
| 533 |
if os.path.exists("/bin/sh"): |
| 534 |
iutil.execWithRedirect("/bin/sh", ["-/bin/sh"]) |
| 535 |
else: |
| 536 |
print "Unable to find /bin/sh to execute! Not starting shell" |
| 537 |
time.sleep(5) |
| 538 |
screen.resume() |
Parent Directory
| 
Revision Log
| 
Revision Graph
