def ok_handler(self):
# mythtv passwords
passwords = self.frontend.get_mythtv_passwords()
for this_password in passwords:
self.preseed("mythtv/" + this_password, passwords[this_password])
FilteredCommand.ok_handler(self)
def ok_handler(self):
if self.frontend.get_secure_mysql():
mysql_root = self.frontend.get_mysql_root_password()
else:
mysql_root = ""
self.preseed('mythtv/mysql_admin_password',mysql_root)
if not self.frontend.get_uselivemysqlinfo():
mysqluser = self.frontend.get_mysqluser()
else:
mysqluser = self.db.get('mythtv/mysql_mythtv_user')
self.preseed('mythtv/mysql_mythtv_user', mysqluser)
if not self.frontend.get_uselivemysqlinfo():
mysqlpass = self.frontend.get_mysqlpass()
else:
mysqlpass = self.db.get('mythtv/mysql_mythtv_password')
self.preseed('mythtv/mysql_mythtv_password', mysqlpass)
if not self.frontend.get_uselivemysqlinfo():
mysqldatabase = self.frontend.get_mysqldatabase()
else:
mysqldatabase = self.db.get('mythtv/mysql_mythtv_dbname')
self.preseed('mythtv/mysql_mythtv_dbname', mysqldatabase)
if not self.frontend.get_uselivemysqlinfo():
mysqlserver = self.frontend.get_mysqlserver()
else:
mysqlserver = self.db.get('mythtv/mysql_host')
self.preseed('mythtv/mysql_host', mysqlserver)
auth = self.frontend.get_secure_mythweb()
self.preseed_bool('mythweb/enable', auth)
user = self.frontend.get_mythweb_username()
self.preseed('mythweb/username', user)
passw = self.frontend.get_mythweb_password()
self.preseed('mythweb/password', passw)
FilteredCommand.ok_handler(self)
def ok_handler(self):
mytharchive = self.frontend.get_mytharchive()
self.preseed_bool('mythbuntu/mytharchive', mytharchive)
mythbrowser = self.frontend.get_mythbrowser()
self.preseed_bool('mythbuntu/mythbrowser', mythbrowser)
mythcontrols = self.frontend.get_mythcontrols()
self.preseed_bool('mythbuntu/mythcontrols', mythcontrols)
mythflix = self.frontend.get_mythflix()
self.preseed_bool('mythbuntu/mythflix', mythflix)
mythgallery = self.frontend.get_mythgallery()
self.preseed_bool('mythbuntu/mythgallery', mythgallery)
mythgame = self.frontend.get_mythgame()
self.preseed_bool('mythbuntu/mythgame', mythgame)
mythmovies = self.frontend.get_mythmovies()
self.preseed_bool('mythbuntu/mythmovies', mythmovies)
mythmusic = self.frontend.get_mythmusic()
self.preseed_bool('mythbuntu/mythmusic', mythmusic)
mythnews = self.frontend.get_mythnews()
self.preseed_bool('mythbuntu/mythnews', mythnews)
mythphone = self.frontend.get_mythphone()
self.preseed_bool('mythbuntu/mythphone', mythphone)
mythstream = self.frontend.get_mythstream()
self.preseed_bool('mythbuntu/mythstream', mythstream)
mythvideo = self.frontend.get_mythvideo()
self.preseed_bool('mythbuntu/mythvideo', mythvideo)
mythweather = self.frontend.get_mythweather()
self.preseed_bool('mythbuntu/mythweather', mythweather)
mythweb = self.frontend.get_mythweb()
self.preseed_bool('mythbuntu/mythweb', mythweb)
FilteredCommand.ok_handler(self)
def ok_handler(self):
fullname = self.frontend.get_fullname()
username = self.frontend.get_username()
password = self.frontend.get_password()
password_confirm = self.frontend.get_verified_password()
auto_login = self.frontend.get_auto_login()
encrypt_home = self.frontend.get_encrypt_home()
self.preseed('passwd/user-fullname', fullname)
self.preseed('passwd/username', username)
# TODO: maybe encrypt these first
self.preseed('passwd/user-password', password)
self.preseed('passwd/user-password-again', password_confirm)
if self.frontend.oem_config:
self.preseed('passwd/user-uid', '29999')
else:
self.preseed('passwd/user-uid', '')
self.preseed_bool('passwd/auto-login', auto_login)
self.preseed_bool('user-setup/encrypt-home', encrypt_home)
hostname = self.frontend.get_hostname()
if hostname is not None and hostname != '':
hd = hostname.split('.', 1)
self.preseed('netcfg/get_hostname', hd[0])
if len(hd) > 1:
self.preseed('netcfg/get_domain', hd[1])
else:
self.preseed('netcfg/get_domain', '')
FilteredCommand.ok_handler(self)
def ok_handler(self):
drivers = self.frontend.get_drivers()
for this_driver in drivers:
if drivers[this_driver] is True or drivers[this_driver] is False:
self.preseed_bool("mythbuntu/" + this_driver, drivers[this_driver])
else:
self.preseed("mythbuntu/" + this_driver, drivers[this_driver])
FilteredCommand.ok_handler(self)
def ok_handler(self):
services = self.frontend.get_services()
for this_service in services:
answer = services[this_service]
if answer is True or answer is False:
self.preseed_bool("mythbuntu/" + this_service, answer)
else:
self.preseed("mythbuntu/" + this_service, answer)
FilteredCommand.ok_handler(self)
def run(self, priority, question):
if self.done:
return self.succeeded
if question.startswith('partman/confirm'):
if question == 'partman/confirm':
self.db.set('ubiquity/partman-made-changes', 'true')
else:
self.db.set('ubiquity/partman-made-changes', 'false')
self.preseed(question, 'true')
return True
elif question == 'partman/exception_handler':
if priority == 'critical' or priority == 'high':
response = self.frontend.question_dialog(
self.description(question),
self.extended_description(question),
self.choices(question), use_templates=False)
self.preseed(question, response, seen=False)
else:
self.preseed(question, 'unhandled', seen=False)
return True
elif question == 'partman/exception_handler_note':
if priority == 'critical' or priority == 'high':
self.frontend.error_dialog(self.description(question),
self.extended_description(question))
return FilteredCommand.error(self, priority, question)
else:
return True
elif self.question_type(question) == 'boolean':
response = self.frontend.question_dialog(
self.description(question),
self.extended_description(question),
('ubiquity/text/go_back', 'ubiquity/text/continue'))
answer_reversed = False
if (question == 'partman-jfs/jfs_boot' or
question == 'partman-jfs/jfs_root'):
answer_reversed = True
if response is None or response == 'ubiquity/text/continue':
answer = answer_reversed
else:
answer = not answer_reversed
self.succeeded = False
self.done = True
self.frontend.return_to_partitioning()
if answer:
self.preseed(question, 'true')
else:
self.preseed(question, 'false')
return True
else:
return FilteredCommand.run(self, priority, question)
def ok_handler(self):
video_driver = self.frontend.get_video()
self.preseed('mythbuntu/video_driver', video_driver)
tvout = self.frontend.get_tvout()
self.preseed('mythbuntu/tvout', tvout)
tvstandard = self.frontend.get_tvstandard()
self.preseed('mythbuntu/tvstandard', tvstandard)
hdhomerun = self.frontend.get_hdhomerun()
self.preseed_bool('mythbuntu/hdhomerun',hdhomerun)
FilteredCommand.ok_handler(self)
def ok_handler(self):
zone = self.frontend.get_timezone()
if zone is None:
zone = self.db.get('time/zone')
else:
self.preseed('time/zone', zone)
for location in self.tzdb.locations:
if location.zone == zone:
self.preseed('debian-installer/country', location.country)
break
FilteredCommand.ok_handler(self)
def run(self, priority, question):
if self.done:
return self.succeeded
if question.startswith('partman/confirm'):
self.db.set('ubiquity/partman-confirm', question[8:])
self.preseed(question, 'true')
return True
elif question == 'partman/exception_handler':
if priority == 'critical' or priority == 'high':
response = self.frontend.question_dialog(
self.description(question),
self.extended_description(question),
self.choices(question),
use_templates=False)
self.preseed(question, response, seen=False)
else:
self.preseed(question, 'unhandled', seen=False)
return True
elif question == 'partman/exception_handler_note':
if priority == 'critical' or priority == 'high':
self.frontend.error_dialog(self.description(question),
self.extended_description(question))
return FilteredCommand.error(self, priority, question)
else:
return True
elif self.question_type(question) == 'boolean':
response = self.frontend.question_dialog(
self.description(question),
self.extended_description(question),
('ubiquity/text/go_back', 'ubiquity/text/continue'))
answer_reversed = False
if (question == 'partman-jfs/jfs_boot'
or question == 'partman-jfs/jfs_root'):
answer_reversed = True
if response is None or response == 'ubiquity/text/continue':
answer = answer_reversed
else:
answer = not answer_reversed
self.succeeded = False
self.done = True
self.frontend.return_to_partitioning()
if answer:
self.preseed(question, 'true')
else:
self.preseed(question, 'false')
return True
else:
return FilteredCommand.run(self, priority, question)
def ok_handler(self):
device = self.frontend.get_lirc("remote")
self.preseed('lirc/remote_modules',device["modules"])
self.preseed('lirc/remote_lircd_conf',device["lircd_conf"])
self.preseed('lirc/remote_driver',device["driver"])
self.preseed('lirc/remote_device',device["device"])
self.preseed('lirc/remote',device["remote"])
device = self.frontend.get_lirc("transmitter")
self.preseed('lirc/transmitter_modules',device["modules"])
self.preseed('lirc/transmitter_lircd_conf',device["lircd_conf"])
self.preseed('lirc/transmitter_driver',device["driver"])
self.preseed('lirc/transmitter_device',device["device"])
self.preseed('lirc/transmitter',device["transmitter"])
FilteredCommand.ok_handler(self)
def ok_handler(self):
official = self.frontend.get_officialthemes()
official_string=""
for theme in official:
if not official[theme].get_active():
official_string+=theme + " "
self.preseed('mythbuntu/officialthemes', official_string)
community = self.frontend.get_communitythemes()
community_string=""
for theme in community:
if not community[theme].get_active():
community_string+=theme + " "
self.preseed('mythbuntu/communitythemes', community_string)
FilteredCommand.ok_handler(self)
def run(self, priority, question):
if self.done:
return self.succeeded
if question == 'console-setup/layout':
# Reset this in case we just backed up from the variant
# question.
self.succeeded = True
# TODO cjwatson 2006-09-07: no console-setup support for layout
# choice translation yet
self.frontend.set_keyboard_choices(
self.choices_untranslated(question))
self.frontend.set_keyboard(self.db.get(question))
return True
elif question == 'console-setup/variant':
# TODO cjwatson 2006-10-02: no console-setup support for variant
# choice translation yet
self.frontend.set_keyboard_variant_choices(
self.choices_untranslated(question))
self.frontend.set_keyboard_variant(self.db.get(question))
# console-setup preseeding is special, and needs to be checked
# by hand. The seen flag on console-setup/layout is used
# internally by console-setup, so we can't just force it to
# true.
if ('UBIQUITY_AUTOMATIC' in os.environ and
self.db.fget('console-setup/layoutcode', 'seen') == 'true'):
return True
else:
return FilteredCommand.run(self, priority, question)
else:
return True
def run(self,priority,question):
if question.startswith('lirc/remote'):
device=self.frontend.get_lirc("remote")
if question.startswith('lirc/remote_modules'):
self.preseed('lirc/remote_modules',device["modules"])
elif question.startswith('lirc/remote_lircd_conf'):
self.preseed('lirc/remote_lircd_conf',device["lircd_conf"])
elif question.startswith('lirc/remote_driver'):
self.preseed('lirc/remote_driver',device["driver"])
elif question.startswith('lirc/remote_device'):
self.preseed('lirc/remote_device',device["device"])
elif question.startswith('lirc/remote'):
self.preseed('lirc/remote',device["remote"])
elif question.startswith('lirc/transmitter'):
device=self.frontend.get_lirc("transmitter")
if question.startswith('lirc/transmitter_modules'):
self.preseed('lirc/transmitter_modules',device["modules"])
elif question.startswith('lirc/transmitter_lircd_conf'):
self.preseed('lirc/transmitter_lircd_conf',device["lircd_conf"])
elif question.startswith('lirc/transmitter_driver'):
self.preseed('lirc/transmitter_driver',device["driver"])
elif question.startswith('lirc/transmitter_device'):
self.preseed('lirc/transmitter_device',device["device"])
elif question.startswith('lirc/transmitter'):
self.preseed('lirc/transmitter',device["transmitter"])
return FilteredCommand.run(self, priority, question)
def run(self, priority, question):
if question == 'grub-installer/bootdev':
# Force to (hd0) in the case of an unsupported OS.
if self.db.get(question) == '':
self.preseed(question, '(hd0)')
return FilteredCommand.run(self, priority, question)
def progress_info(self, progress_title, progress_info):
# "Loading module ..." messages are boring. Hide them.
if progress_info == 'hw-detect/load_progress_step':
return True
return FilteredCommand.progress_info(self,
progress_title, progress_info)
def run(self, priority, question):
if question.endswith('/apt-install-failed'):
return self.error(priority, question)
elif question == 'migration-assistant/failed-unmount':
response = self.frontend.question_dialog(
self.description(question),
self.extended_description(question),
('ubiquity/text/go_back', 'ubiquity/text/continue'))
if response is None or response == 'ubiquity/text/continue':
self.preseed(question, 'true')
else:
self.preseed(question, 'false')
return True
elif question == 'ubiquity/install/copying_error/md5':
response = self.frontend.question_dialog(
self.description(question),
# TODO evand 2008-02-14: i18n.
self.extended_description(question),
('Abort', 'Retry', 'Skip'),
use_templates=False)
if response is None or response == 'Abort':
self.preseed(question, 'abort')
elif response == 'Retry':
self.preseed(question, 'retry')
elif response == 'Skip':
self.preseed(question, 'skip')
return True
return FilteredCommand.run(self, priority, question)
def run(self, priority, question):
if question == 'grub-installer/bootdev':
# Force to the default in the case of an unsupported OS.
if self.db.get(question) == '':
self.preseed(question, misc.grub_default())
return FilteredCommand.run(self, priority, question)
def run(self, priority, question):
if question == 'grub-installer/bootdev':
# Force to the default in the case of an unsupported OS.
if self.db.get(question) == '':
self.preseed(question, misc.grub_default())
return FilteredCommand.run(self, priority, question)
def run(self, priority, question):
if question.endswith('/apt-install-failed'):
return self.error(priority, question)
elif question == 'migration-assistant/failed-unmount':
response = self.frontend.question_dialog(
self.description(question),
self.extended_description(question),
('ubiquity/text/go_back', 'ubiquity/text/continue'))
if response is None or response == 'ubiquity/text/continue':
self.preseed(question, 'true')
else:
self.preseed(question, 'false')
return True
elif question == 'ubiquity/install/copying_error/md5':
response = self.frontend.question_dialog(
self.description(question),
# TODO evand 2008-02-14: i18n.
self.extended_description(question),
('Abort', 'Retry', 'Skip'),
use_templates=False)
if response is None or response == 'Abort':
self.preseed(question, 'abort')
elif response == 'Retry':
self.preseed(question, 'retry')
elif response == 'Skip':
self.preseed(question, 'skip')
return True
elif question == 'ubiquity/install/new-bootdev':
current_device = self.db.get(question)
response = self.frontend.bootloader_dialog(current_device)
self.preseed(question, response)
return True
return FilteredCommand.run(self, priority, question)
def progress_info(self, progress_title, progress_info):
# "Loading module ..." messages are boring. Hide them.
if progress_info == 'hw-detect/load_progress_step':
return True
return FilteredCommand.progress_info(self, progress_title,
progress_info)
def error(self, priority, question):
if question == 'partman-partitioning/impossible_resize':
# Back up silently.
return False
elif question == 'partman-partitioning/bad_new_partition_size':
if self.creating_partition:
# Break out of creating the partition.
self.creating_partition['bad_size'] = True
elif question in ('partman-partitioning/bad_new_size',
'partman-partitioning/big_new_size',
'partman-partitioning/small_new_size',
'partman-partitioning/new_size_commit_failed'):
if self.editing_partition:
# Break out of resizing the partition.
self.editing_partition['bad_size'] = True
else:
# Break out of resizing the partition in cases where partman
# fed us bad boundary values. These are bugs in partman, but
# we should handle the result as gracefully as possible.
self.bad_auto_size = True
elif question == 'partman-basicfilesystems/bad_mountpoint':
# Break out of creating or editing the partition.
if self.creating_partition:
self.creating_partition['bad_mountpoint'] = True
elif self.editing_partition:
self.editing_partition['bad_mountpoint'] = True
self.frontend.error_dialog(self.description(question),
self.extended_description(question))
return FilteredCommand.error(self, priority, question)
def run(self, priority, question):
if question.endswith('/summary'):
text = ''
wrapper = textwrap.TextWrapper(width=76)
for line in self.extended_description(question).split("\n"):
text += wrapper.fill(line) + "\n"
self.frontend.set_summary_text(text)
if os.access('/usr/share/grub-installer/grub-installer', os.X_OK):
# TODO cjwatson 2006-09-04: a bit inelegant, and possibly
# Ubuntu-specific?
self.frontend.set_summary_device('(hd0)')
else:
self.frontend.set_summary_device(None)
self.frontend.set_grub_combo(grub_options())
if will_be_installed('popularity-contest'):
try:
participate = self.db.get('popularity-contest/participate')
self.frontend.set_popcon(participate == 'true')
except debconf.DebconfError:
self.frontend.set_popcon(None)
else:
self.frontend.set_popcon(None)
# This component exists only to gather some information and then
# get out of the way.
#return True
return FilteredCommand.run(self, priority, question)
def run(self, priority, question):
syslog.syslog("-------> run guadaPrePartition")
if question.startswith('guada-ubiquity/prepartition'):
#advanced = self.frontend.get_advanced()
#self.preseed_bool('mythbuntu/advanced_install', advanced)
print "question"
return FilteredCommand.run(self, priority, question)
def run(self, priority, question):
syslog.syslog("-------> run guadaPrePartition")
if question.startswith('guada-ubiquity/prepartition'):
#advanced = self.frontend.get_advanced()
#self.preseed_bool('mythbuntu/advanced_install', advanced)
print "question"
return FilteredCommand.run(self, priority, question)
def ok_handler(self):
vnc = self.frontend.get_vnc()
self.preseed_bool('mythbuntu/vncservice', vnc)
if not self.frontend.get_vnc():
vnc_pass = "******"
else:
vnc_pass = self.frontend.get_vnc_password()
self.preseed('mythbuntu/vnc_password', vnc_pass)
ssh = self.frontend.get_ssh()
self.preseed_bool('mythbuntu/sshservice', ssh)
samba = self.frontend.get_samba()
self.preseed_bool('mythbuntu/sambaservice', samba)
nfs = self.frontend.get_nfs()
self.preseed_bool('mythbuntu/nfsservice', nfs)
mysql_secure = self.frontend.get_mysql_port()
self.preseed_bool('mythbuntu/mysqlservice', mysql_secure)
FilteredCommand.ok_handler(self)
def ok_handler(self):
fullname = self.frontend.get_fullname()
username = self.frontend.get_username()
password = self.frontend.get_password()
password_confirm = self.frontend.get_verified_password()
self.preseed('passwd/user-fullname', fullname)
self.preseed('passwd/username', username)
# TODO: maybe encrypt these first
self.preseed('passwd/user-password', password)
self.preseed('passwd/user-password-again', password_confirm)
if self.frontend.oem_config:
self.preseed('passwd/user-uid', '29999')
else:
self.preseed('passwd/user-uid', '')
FilteredCommand.ok_handler(self)
def error(self, priority, question):
if question.startswith('passwd/username-'):
self.frontend.username_error(self.extended_description(question))
elif question.startswith('user-setup/password-'):
self.frontend.password_error(self.extended_description(question))
else:
self.frontend.error_dialog(self.description(question),
self.extended_description(question))
return FilteredCommand.error(self, priority, question)
def run(self, priority, question):
if question.endswith('/apt-install-failed'):
return self.error(priority, question)
elif question == 'ubiquity/install/new-bootdev':
current_device = self.db.get(question)
response = self.frontend.bootloader_dialog(current_device)
self.preseed(question, response)
return True
return FilteredCommand.run(self, priority, question)
def run(self, priority, question):
if question.endswith('/apt-install-failed'):
return self.error(priority, question)
elif question == 'ubiquity/install/new-bootdev':
current_device = self.db.get(question)
response = self.frontend.bootloader_dialog(current_device)
self.preseed(question, response)
return True
return FilteredCommand.run(self, priority, question)
def run(self, priority, question):
if question.endswith('/summary'):
text = ''
wrapper = textwrap.TextWrapper(width=76)
for line in self.extended_description(question).split("\n"):
text += wrapper.fill(line) + "\n"
self.frontend.set_summary_text(text)
useRaid = self.db.get('ubiquity/use_raid')
if useRaid != "true":
self.frontend.set_summary_text(text)
try:
install_bootloader = self.db.get(
'ubiquity/install_bootloader')
self.frontend.set_grub(install_bootloader == 'true')
except debconf.DebconfError:
self.frontend.set_grub(None)
if os.access('/usr/share/grub-installer/grub-installer',
os.X_OK):
# TODO cjwatson 2006-09-04: a bit inelegant, and possibly
# Ubuntu-specific?
if installing_from_disk():
self.frontend.set_summary_device(find_grub_target())
else:
self.frontend.set_summary_device('(hd0)')
else:
self.frontend.set_summary_device(None)
self.frontend.set_grub_combo(grub_options())
if will_be_installed('popularity-contest'):
try:
participate = self.db.get(
'popularity-contest/participate')
self.frontend.set_popcon(participate == 'true')
except debconf.DebconfError:
self.frontend.set_popcon(None)
else:
self.frontend.set_popcon(None)
else:
raidDiskStrs = re.split("\\\\[\t ]+",
self.db.get('ubiquity/raid_disks'))
text = text + "\n"
text = text + "These disks will be formatted into a RAID array:\n" + '\n'.join(
raidDiskStrs) + "\n\n"
self.frontend.set_summary_text(text)
# This component exists only to gather some information and then
# get out of the way.
#return True
return FilteredCommand.run(self, priority, question)
def error(self, priority, question):
if question == "hw-detect/modprobe_error":
# don't need to display this, and it's non-fatal
return True
elif question == "apt-setup/security-updates-failed":
fatal = False
else:
fatal = True
self.frontend.error_dialog(self.description(question), self.extended_description(question), fatal)
if fatal:
return FilteredCommand.error(self, priority, question)
else:
return True
def error(self, priority, question):
if question == 'hw-detect/modprobe_error':
# don't need to display this, and it's non-fatal
return True
elif question == 'apt-setup/security-updates-failed':
fatal = False
else:
fatal = True
self.frontend.error_dialog(self.description(question),
self.extended_description(question), fatal)
if fatal:
return FilteredCommand.error(self, priority, question)
else:
return True
def ok_handler(self):
choices = self.frontend.ma_get_choices()
username = self.db.get('passwd/username')
users = {}
for c in choices:
if c['selected']:
question = 'migration-assistant/%s/%s/' % \
(c['part'],c['user'].replace(' ','+'))
self.db.register('migration-assistant/items', question + 'items')
self.preseed(question + 'items', ', '.join(c['items']))
self.db.register('migration-assistant/user', question + 'user')
self.preseed(question + 'user', username)
try:
users[c['part']].append(c['user'])
except KeyError:
users[c['part']] = [c['user']]
for p in users.iterkeys():
question = 'migration-assistant/%s/users' % p
self.db.register('migration-assistant/users', question)
self.preseed(question, ', '.join(users[p]))
FilteredCommand.ok_handler(self)
def run(self, priority, question):
if question.endswith("/summary"):
text = ""
wrapper = textwrap.TextWrapper(width=76)
for line in self.extended_description(question).split("\n"):
text += wrapper.fill(line) + "\n"
self.frontend.set_summary_text(text)
useRaid = self.db.get("ubiquity/use_raid")
if useRaid != "true":
self.frontend.set_summary_text(text)
try:
install_bootloader = self.db.get("ubiquity/install_bootloader")
self.frontend.set_grub(install_bootloader == "true")
except debconf.DebconfError:
self.frontend.set_grub(None)
if os.access("/usr/share/grub-installer/grub-installer", os.X_OK):
# TODO cjwatson 2006-09-04: a bit inelegant, and possibly
# Ubuntu-specific?
if installing_from_disk():
self.frontend.set_summary_device(find_grub_target())
else:
self.frontend.set_summary_device("(hd0)")
else:
self.frontend.set_summary_device(None)
self.frontend.set_grub_combo(grub_options())
if will_be_installed("popularity-contest"):
try:
participate = self.db.get("popularity-contest/participate")
self.frontend.set_popcon(participate == "true")
except debconf.DebconfError:
self.frontend.set_popcon(None)
else:
self.frontend.set_popcon(None)
else:
raidDiskStrs = re.split("\\\\[\t ]+", self.db.get("ubiquity/raid_disks"))
text = text + "\n"
text = text + "These disks will be formatted into a RAID array:\n" + "\n".join(raidDiskStrs) + "\n\n"
self.frontend.set_summary_text(text)
# This component exists only to gather some information and then
# get out of the way.
# return True
return FilteredCommand.run(self, priority, question)
def error(self, priority, question):
if question == 'hw-detect/modprobe_error':
# don't need to display this, and it's non-fatal
return True
elif question == 'apt-setup/security-updates-failed':
fatal = False
elif (question == 'ubiquity/install/broken_active_directory'
or question == 'ubiquity/install/broken_luks_add_key'):
fatal = False
else:
fatal = True
self.frontend.error_dialog(self.description(question),
self.extended_description(question), fatal)
if fatal:
return FilteredCommand.error(self, priority, question)
else:
return True
def run(self, priority, question):
if question == 'ubiquity/install/copying_error/md5':
response = self.frontend.question_dialog(
self.description(question),
# TODO evand 2008-02-14: i18n.
self.extended_description(question),
('Abort', 'Retry', 'Skip'),
use_templates=False)
if response is None or response == 'Abort':
self.preseed(question, 'abort')
elif response == 'Retry':
self.preseed(question, 'retry')
elif response == 'Skip':
self.preseed(question, 'skip')
return True
return FilteredCommand.run(self, priority, question)
def run(self, priority, question):
if question == 'ubiquity/install/copying_error/md5':
response = self.frontend.question_dialog(
self.description(question),
# TODO evand 2008-02-14: i18n.
self.extended_description(question),
('Abort', 'Retry', 'Skip'),
use_templates=False)
if response is None or response == 'Abort':
self.preseed(question, 'abort')
elif response == 'Retry':
self.preseed(question, 'retry')
elif response == 'Skip':
self.preseed(question, 'skip')
return True
return FilteredCommand.run(self, priority, question)
def run(self, priority, question):
if question == 'time/zone':
zone = self.db.get(question)
# Some countries don't have a default zone, so just pick the
# first choice in the list.
if not zone:
choices_c = self.choices_untranslated(question)
if choices_c:
zone = choices_c[0]
# special cases where default is not in zone.tab
if zone == 'Canada/Eastern':
zone = 'America/Toronto'
elif zone == 'US/Eastern':
zone = 'America/New_York'
self.frontend.set_timezone(zone)
return FilteredCommand.run(self, priority, question)
def run(self,priority,question):
if question.startswith('mythbuntu/officialthemes'):
official = self.frontend.get_officialthemes()
official_string=""
for theme in official:
if not official[theme].get_active():
official_string+=theme + " "
self.preseed('mythbuntu/officialthemes', official_string)
elif question.startswith('mythbuntu/communitythemes'):
community = self.frontend.get_communitythemes()
community_string=""
for theme in community:
if not community[theme].get_active():
community_string+=theme + " "
self.preseed('mythbuntu/communitythemes', community_string)
return FilteredCommand.run(self, priority, question)
def __init__(self, frontend=None, db=None):
FilteredCommand.__init__(self, frontend, db)
def error(self, priority, question):
self.frontend.error_dialog(self.description(question),
self.extended_description(question))
return FilteredCommand.error(self, priority, question)
def ok_handler(self):
syslog.syslog("------->ok handler guadaPrePartition")
return FilteredCommand.ok_handler(self)