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 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.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 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):
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 == '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 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):
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 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 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 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 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 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 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.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 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 != 'ubiquity/run-ma-again') and \
(question != 'migration-assistant/partitions'):
self.got_a_question = True
if 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
# We cannot currently import from partitions that are scheduled for
# deletion, so we filter them out of the list.
if question == 'migration-assistant/partitions':
self.filter_parts()
elif question == 'ubiquity/run-ma-again':
self.db.set('ubiquity/run-ma-again', 'false')
self.set_choices()
# If we didn't ask any questions, they're all preseeded and we don't
# need to show the page, so we'll continue along. If we got at
# least one question, show the page.
if not self.got_a_question:
return self.succeeded
else:
return FilteredCommand.run(self, priority, question)
elif question.endswith('user'):
username = self.db.get('passwd/username')
self.preseed(question, username)
elif question.endswith('password'):
# Just in case for now. It should never get here as there's a check
# in ma-ask that skips asking the user details if the username is
# already preseeded in passwd.
password = self.db.get('passwd/user-password')
self.preseed(question, password)
self.preseed(question + '-again', password)
else:
self.preseed(question, ", ".join(self.choices(question)))
return True
def run(self,priority,question):
if question.startswith('mythbuntu/mytharchive'):
mytharchive = self.frontend.get_mytharchive()
self.preseed_bool('mythbuntu/mytharchive', mytharchive)
elif question.startswith('mythbuntu/mythbrowser'):
mythbrowser = self.frontend.get_mythbrowser()
self.preseed_bool('mythbuntu/mythbrowser', mythbrowser)
elif question.startswith('mythbuntu/mythcontrols'):
mythcontrols = self.frontend.get_mythcontrols()
self.preseed_bool('mythbuntu/mythcontrols', mythcontrols)
elif question.startswith('mythbuntu/mythflix'):
mythflix = self.frontend.get_mythflix()
self.preseed_bool('mythbuntu/mythflix', mythflix)
elif question.startswith('mythbuntu/mythgallery'):
mythgallery = self.frontend.get_mythgallery()
self.preseed_bool('mythbuntu/mythgallery', mythgallery)
elif question.startswith('mythbuntu/mythgame'):
mythgame = self.frontend.get_mythgame()
self.preseed_bool('mythbuntu/mythgame', mythgame)
elif question.startswith('mythbuntu/mythmovies'):
mythmovies = self.frontend.get_mythmovies()
self.preseed_bool('mythbuntu/mythmovies', mythmovies)
elif question.startswith('mythbuntu/mythmusic'):
mythmusic = self.frontend.get_mythmusic()
self.preseed_bool('mythbuntu/mythmusic', mythmusic)
elif question.startswith('mythbuntu/mythnews'):
mythnews = self.frontend.get_mythnews()
self.preseed_bool('mythbuntu/mythnews', mythnews)
elif question.startswith('mythbuntu/mythphone'):
mythphone = self.frontend.get_mythphone()
self.preseed_bool('mythbuntu/mythphone', mythphone)
elif question.startswith('mythbuntu/mythphone'):
mythstream = self.frontend.get_mythstream()
self.preseed_bool('mythbuntu/mythstream', mythstream)
elif question.startswith('mythbuntu/mythvideo'):
mythvideo = self.frontend.get_mythvideo()
self.preseed_bool('mythbuntu/mythvideo', mythvideo)
elif question.startswith('mythbuntu/mythweather'):
mythweather = self.frontend.get_mythweather()
self.preseed_bool('mythbuntu/mythweather', mythweather)
elif question.startswith('mythbuntu/mythweb'):
mythweb = self.frontend.get_mythweb()
self.preseed_bool('mythbuntu/mythweb', mythweb)
return FilteredCommand.run(self, priority, question)
def run(self,priority,question):
if question.startswith('mythbuntu/video_driver'):
video_driver = self.frontend.get_video()
self.preseed('mythbuntu/video_driver', video_driver)
elif question.startswith('mythbuntu/tvout'):
tvout = self.frontend.get_tvout()
self.preseed('mythbuntu/tvout', tvout)
elif question.startswith('mythbuntu/tvstandard'):
tvstandard = self.frontend.get_tvstandard()
self.preseed('mythbuntu/tvstandard', tvstandard)
elif question.startswith('mythbuntu/hdhomerun'):
hdhomerun = self.frontend.get_hdhomerun()
self.preseed_bool('mythbuntu/hdhomerun',hdhomerun)
elif question.startswith('mythbuntu/xmltv'):
xmltv = self.frontend.get_xmltv()
self.preseed_bool('mythbuntu/xmltv',xmltv)
elif question.startswith('mythbuntu/dvbutils'):
dvbutils = self.frontend.get_dvbutils()
self.preseed_bool('mythbuntu/dvbutils',dvbutils)
return FilteredCommand.run(self, priority, question)
def run(self,priority,question):
if question.startswith('mythtv/mysql_admin_password'):
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)
elif question.startswith('mythtv/mysql_mythtv_user'):
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)
elif question.startswith('mythtv/mysql_mythtv_password'):
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)
elif question.startswith('mythtv/mysql_mythtv_dbname'):
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)
elif question.startswith('mythtv/mysql_host'):
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)
elif question.startswith('mythweb/enable'):
auth = self.frontend.get_secure_mythweb()
self.preseed_bool('mythweb/enable', auth)
elif question.startswith('mythweb/username'):
user = self.frontend.get_mythweb_username()
self.preseed('mythweb/username', user)
elif question.startswith('mythweb/password'):
passw = self.frontend.get_mythweb_password()
self.preseed('mythweb/password', passw)
return FilteredCommand.run(self, priority, question)
def run(self, priority, question):
if question.startswith('user-setup/password-weak'):
# A dialog is a bit clunky, but workable for now. Perhaps it
# would be better to display some text in the style of
# password_error, and then let the user carry on anyway by
# clicking next again?
response = self.frontend.question_dialog(
self.description(question),
self.extended_description(question),
('ubiquity/text/choose_another_password',
'ubiquity/text/continue'))
if response is None or response == 'ubiquity/text/continue':
self.preseed(question, 'true')
else:
self.preseed(question, 'false')
self.succeeded = False
self.done = False
self.frontend.select_password()
return True
return FilteredCommand.run(self, priority, question)
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))
return FilteredCommand.run(self, priority, question)
else:
return True
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/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 == 'time/zone':
if self.multiple:
# Work around a debconf bug: REGISTER does not appear to
# give a newly-registered question the same default as the
# question associated with its template, unless we also
# RESET it.
self.db.reset(question)
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 == 'localechooser/languagelist':
self.language_question = question
current_language_index = self.value_index(question)
current_language = "English"
import gzip
languagelist = gzip.open('/usr/lib/ubiquity/localechooser/languagelist.data.gz')
language_display_map = {}
i = 0
for line in languagelist:
line = unicode(line, 'utf-8')
if line == '' or line == '\n':
continue
code, name, trans = line.strip(u'\n').split(u':')[1:]
if code in ('dz', 'km'):
i += 1
continue
language_display_map[trans] = (name, code)
if i == current_language_index:
current_language = trans
i += 1
languagelist.close()
def compare_choice(x, y):
result = cmp(language_display_map[x][1],
language_display_map[y][1])
if result != 0:
return result
return cmp(x, y)
sorted_choices = sorted(language_display_map, compare_choice)
self.frontend.set_language_choices(sorted_choices,
language_display_map)
self.frontend.set_language(current_language)
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 run(self,priority,question):
if question.startswith('mythbuntu/vncservice'):
vnc = self.frontend.get_vnc()
self.preseed_bool('mythbuntu/vncservice', vnc)
elif question.startswith('mythbuntu/vnc_password'):
if not self.frontend.get_vnc():
vnc_pass = "******"
else:
vnc_pass = self.frontend.get_vnc_password()
self.preseed('mythbuntu/vnc_password', vnc_pass)
elif question.startswith('mythbuntu/sshservice'):
ssh = self.frontend.get_ssh()
self.preseed_bool('mythbuntu/sshservice', ssh)
elif question.startswith('mythbuntu/sambaservice'):
samba = self.frontend.get_samba()
self.preseed_bool('mythbuntu/sambaservice', samba)
elif question.startswith('mythbuntu/nfsservice'):
nfs = self.frontend.get_nfs()
self.preseed_bool('mythbuntu/nfsservice', nfs)
elif question.startswith('mythbuntu/mysqlservice'):
mysql_secure = self.frontend.get_mysql_port()
self.preseed_bool('mythbuntu/mysqlservice', mysql_secure)
return FilteredCommand.run(self, priority, question)
def run(self, priority, question):
if question.startswith('languagechooser/language-name'):
self.language_question = question
# Get index of untranslated value; we'll map this to the
# translated value later.
current_language_index = self.value_index(question)
current_language = "English"
language_choices = self.split_choices(
unicode(self.db.metaget(question, 'choices-en.utf-8'),
'utf-8', 'replace'))
language_choices_c = self.choices_untranslated(question)
language_codes = {}
languagelist = open('/usr/lib/ubiquity/localechooser/languagelist')
for line in languagelist:
if line.startswith('#'):
continue
bits = line.split(';')
if len(bits) >= 3:
if bits[2] in ('dz', 'km'):
# Exclude these languages for now, as we don't ship
# fonts for them and we don't have sufficient
# translations anyway.
continue
elif bits[2] in ('pt', 'zh'):
# Special handling for subdivided languages.
code = '%s_%s' % (bits[2], bits[3])
else:
code = bits[2]
language_codes[bits[0]] = code
languagelist.close()
language_display_map = {}
for i in range(len(language_choices)):
choice = re.sub(r'.*? *- (.*)', r'\1', language_choices[i])
choice_c = language_choices_c[i]
if choice_c not in language_codes:
continue
language_display_map[choice] = (choice_c,
language_codes[choice_c])
if i == current_language_index:
current_language = choice
def compare_choice(x, y):
result = cmp(language_display_map[x][1],
language_display_map[y][1])
if result != 0:
return result
return cmp(x, y)
sorted_choices = sorted(language_display_map, compare_choice)
self.frontend.set_language_choices(sorted_choices,
language_display_map)
self.frontend.set_language(current_language)
elif question.startswith('countrychooser/'):
if 'DEBCONF_USE_CDEBCONF' not in os.environ:
# Normally this default is handled by Default-$LL, but since
# we can't change debconf's language on the fly (unlike
# cdebconf), we have to fake it.
country = self.db.get('debian-installer/country')
if question.endswith('shortlist'):
self.db.set(question, country)
elif question.endswith('country-name') and country:
fp = open('/usr/share/iso-codes/iso_3166.tab')
try:
for line in fp:
if line.startswith(country):
line = line.rstrip('\n')
self.db.set(question, line.split('\t')[1])
break
finally:
fp.close()
return True
return FilteredCommand.run(self, priority, question)
def run(self, priority, question):
if self.done:
# user answered confirmation question or backed up
return self.succeeded
self.current_question = question
options = self.snoop()
menu_options = self.snoop_menu(options)
self.debug('Partman: state = %s', self.__state)
if question.endswith('automatically_partition'):
self.autopartition_question = question
choices = self.choices(question)
if self.auto_state is None:
self.some_device_desc = \
self.description('partman-auto/text/use_device')
self.resize_desc = \
self.description('partman-auto/text/resize_use_free')
self.manual_desc = \
self.description('partman-auto/text/custom_partitioning')
self.extra_options = {}
if choices:
self.auto_state = [0, None]
else:
self.auto_state[0] += 1
while self.auto_state[0] < len(choices):
self.auto_state[1] = choices[self.auto_state[0]]
if (self.auto_state[1] == self.some_device_desc or
self.auto_state[1] == self.resize_desc):
break
else:
self.auto_state[0] += 1
if self.auto_state[0] < len(choices):
# Don't preseed_as_c, because Perl debconf is buggy in that
# it doesn't expand variables in the result of METAGET
# choices-c. All locales have the same variables anyway so
# it doesn't matter.
self.preseed(question, self.auto_state[1])
self.succeeded = True
return True
else:
self.auto_state = None
if self.resize_desc not in self.extra_options:
try:
del choices[choices.index(self.resize_desc)]
except ValueError:
pass
self.frontend.set_autopartition_choices(
choices, self.extra_options,
self.resize_desc, self.manual_desc)
elif question == 'partman-auto/select_disk':
if self.auto_state is not None:
self.extra_options[self.auto_state[1]] = self.choices(question)
# Back up to autopartitioning question.
self.succeeded = False
return False
else:
assert self.extra_choice is not None
self.preseed(question, self.extra_choice)
self.succeeded = True
return True
elif question == 'partman/choose_partition':
self.autopartition_question = None # not autopartitioning any more
if not self.building_cache and self.update_partitions:
# Rebuild our cache of just these partitions.
self.__state = [['', None, None]]
self.building_cache = True
if 'ALL' in self.update_partitions:
self.update_partitions = None
if self.building_cache:
state = self.__state[-1]
if state[0] == question:
# advance to next partition
self.frontend.debconf_progress_step(1)
self.frontend.refresh()
self.debug('Partman: update_partitions = %s',
self.update_partitions)
state[1] = None
while self.update_partitions:
state[1] = self.update_partitions[0]
del self.update_partitions[0]
if state[1] not in self.partition_cache:
self.debug('Partman: %s not found in cache',
partition)
state[1] = None
self.frontend.debconf_progress_step(1)
self.frontend.refresh()
else:
break
if state[1] is not None:
# Move on to the next partition.
partition = self.partition_cache[state[1]]
self.debug('Partman: Building cache (%s)',
partition['parted']['path'])
self.preseed(question, partition['display'])
return True
else:
# Finished building the cache.
self.debug('Partman: Finished building cache')
self.__state.pop()
self.update_partitions = None
self.building_cache = False
self.frontend.debconf_progress_stop()
self.frontend.refresh()
self.frontend.update_partman(
self.disk_cache, self.partition_cache,
self.cache_order)
else:
self.debug('Partman: Building cache')
os.seteuid(0)
parted = parted_server.PartedServer()
matches = self.find_script(menu_options, 'partition_tree')
# If we're only updating our cache for certain
# partitions, then self.update_partitions will be a list
# of the partitions to update; otherwise, we build the
# cache from scratch.
rebuild_all = self.update_partitions is None
if rebuild_all:
self.disk_cache = {}
self.partition_cache = {}
self.cache_order = []
# Clear out the partitions we're updating to make sure
# stale keys are removed.
if self.update_partitions is not None:
for devpart in self.update_partitions:
if devpart in self.partition_cache:
del self.partition_cache[devpart]
# Initialise any items we haven't heard of yet.
for script, arg, option in matches:
dev, part_id = self.split_devpart(arg)
if not dev:
continue
parted.select_disk(dev)
self.cache_order.append(arg)
if part_id:
if rebuild_all or arg not in self.partition_cache:
self.partition_cache[arg] = {
'dev': dev,
'id': part_id
}
else:
if rebuild_all or arg not in self.disk_cache:
device = parted.readline_device_entry('device')
self.disk_cache[arg] = {
'dev': dev,
'device': device
}
if self.update_partitions is None:
self.update_partitions = self.partition_cache.keys()
else:
self.update_partitions = [devpart
for devpart in self.update_partitions
if devpart in self.partition_cache]
# Update the display names of all disks and partitions.
for script, arg, option in matches:
dev, part_id = self.split_devpart(arg)
if not dev:
continue
parted.select_disk(dev)
if part_id:
self.partition_cache[arg]['display'] = option
else:
self.disk_cache[arg]['display'] = option
# Get basic information from parted_server for each
# partition being updated.
for devpart in self.update_partitions:
dev, part_id = self.split_devpart(devpart)
if not dev:
continue
parted.select_disk(dev)
info = parted.partition_info(part_id)
self.partition_cache[devpart]['parted'] = {
'num': info[0],
'id': info[1],
'size': info[2],
'type': info[3],
'fs': info[4],
'path': info[5],
'name': info[6]
}
drop_privileges()
self.frontend.debconf_progress_start(
0, len(self.update_partitions),
self.description('partman/progress/init/parted'))
self.frontend.refresh()
self.debug('Partman: update_partitions = %s',
self.update_partitions)
# Selecting a disk will ask to create a new disklabel,
# so don't bother with that.
devpart = None
if self.partition_cache:
while self.update_partitions:
devpart = self.update_partitions[0]
del self.update_partitions[0]
if devpart not in self.partition_cache:
self.debug('Partman: %s not found in cache',
partition)
devpart = None
self.frontend.debconf_progress_step(1)
self.frontend.refresh()
else:
break
if devpart is not None:
partition = self.partition_cache[devpart]
self.debug('Partman: Building cache (%s)',
partition['parted']['path'])
self.__state.append([question, devpart, None])
self.preseed(question, partition['display'])
return True
else:
self.debug('Partman: Finished building cache '
'(no partitions to update)')
self.update_partitions = None
self.building_cache = False
self.frontend.debconf_progress_stop()
self.frontend.refresh()
self.frontend.update_partman(
self.disk_cache, self.partition_cache,
self.cache_order)
elif self.creating_partition:
devpart = self.creating_partition['devpart']
if devpart in self.partition_cache:
self.frontend.update_partman(
self.disk_cache, self.partition_cache,
self.cache_order)
elif self.editing_partition:
devpart = self.editing_partition['devpart']
if devpart in self.partition_cache:
self.frontend.update_partman(
self.disk_cache, self.partition_cache,
self.cache_order)
elif self.deleting_partition:
raise AssertionError, "Deleting partition didn't rebuild cache?"
if self.debug_enabled():
import pprint
self.debug('disk_cache:')
printer = pprint.PrettyPrinter()
for line in printer.pformat(self.disk_cache).split('\n'):
self.debug('%s', line)
self.debug('disk_cache end')
self.debug('partition_cache:')
printer = pprint.PrettyPrinter()
for line in printer.pformat(self.partition_cache).split('\n'):
self.debug('%s', line)
self.debug('partition_cache end')
self.__state = [['', None, None]]
self.creating_label = None
self.creating_partition = None
self.editing_partition = None
self.deleting_partition = None
self.undoing = False
self.finish_partitioning = False
FilteredCommand.run(self, priority, question)
if self.finish_partitioning or self.done:
if self.succeeded:
self.preseed_script(question, menu_options, 'finish')
return self.succeeded
elif self.creating_label:
devpart = self.creating_label['devpart']
if devpart in self.disk_cache:
disk = self.disk_cache[devpart]
# No need to use self.__state to keep track of this.
self.preseed(question, disk['display'])
return True
elif self.creating_partition:
devpart = self.creating_partition['devpart']
if devpart in self.partition_cache:
partition = self.partition_cache[devpart]
self.__state.append([question, devpart, None])
self.preseed(question, partition['display'])
return True
elif self.editing_partition:
devpart = self.editing_partition['devpart']
if devpart in self.partition_cache:
partition = self.partition_cache[devpart]
self.__state.append([question, devpart, None])
self.preseed(question, partition['display'])
return True
elif self.deleting_partition:
devpart = self.deleting_partition['devpart']
if devpart in self.partition_cache:
partition = self.partition_cache[devpart]
# No need to use self.__state to keep track of this.
self.preseed(question, partition['display'])
return True
elif self.undoing:
self.preseed_script(question, menu_options, 'undo')
return True
else:
raise AssertionError, ("Returned to %s with nothing to do" %
question)
elif question == 'partman-partitioning/confirm_new_label':
if self.creating_label:
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
else:
raise AssertionError, "Arrived at %s unexpectedly" % question
elif question == 'partman/free_space':
if self.building_cache:
state = self.__state[-1]
assert state[0] == 'partman/choose_partition'
partition = self.partition_cache[state[1]]
can_new = False
if self.find_script(menu_options, 'new'):
can_new = True
partition['can_new'] = can_new
# Back up to the previous menu.
return False
elif self.creating_partition:
self.preseed_script(question, menu_options, 'new')
return True
else:
raise AssertionError, "Arrived at %s unexpectedly" % question
elif question == 'partman-partitioning/new_partition_size':
if self.creating_partition:
if 'bad_size' in self.creating_partition:
return False
size = self.creating_partition['size']
if re.search(r'^[0-9.]+$', size):
# ensure megabytes just in case partman's semantics change
size += 'M'
self.preseed(question, size)
return True
else:
raise AssertionError, "Arrived at %s unexpectedly" % question
elif question == 'partman-partitioning/new_partition_type':
if self.creating_partition:
if self.creating_partition['type'] == PARTITION_TYPE_PRIMARY:
self.preseed(question, 'Primary')
else:
self.preseed(question, 'Logical')
return True
else:
raise AssertionError, "Arrived at %s unexpectedly" % question
elif question == 'partman-partitioning/new_partition_place':
if self.creating_partition:
if (self.creating_partition['place'] ==
PARTITION_PLACE_BEGINNING):
self.preseed(question, 'Beginning')
else:
self.preseed(question, 'End')
return True
else:
raise AssertionError, "Arrived at %s unexpectedly" % question
elif question == 'partman/active_partition':
if self.building_cache:
state = self.__state[-1]
partition = self.partition_cache[state[1]]
if state[0] == question:
state[2] += 1
if state[2] < len(partition['active_partition_build']):
# Move on to the next item.
visit = partition['active_partition_build']
self.preseed(question, visit[state[2]][2])
return True
else:
# Finished building the cache for this submenu; go
# back to the previous one.
try:
del partition['active_partition_build']
except KeyError:
pass
self.__state.pop()
return False
assert state[0] == 'partman/choose_partition'
os.seteuid(0)
parted = parted_server.PartedServer()
parted.select_disk(partition['dev'])
for entry in ('method',
'filesystem', 'detected_filesystem',
'acting_filesystem',
'existing', 'formatable',
'mountpoint'):
if parted.has_part_entry(partition['id'], entry):
partition[entry] = \
parted.readline_part_entry(partition['id'], entry)
drop_privileges()
visit = []
for (script, arg, option) in menu_options:
if arg in ('method', 'mountpoint'):
visit.append((script, arg, option))
elif arg == 'format':
partition['can_activate_format'] = True
elif arg == 'resize':
visit.append((script, arg, option))
partition['can_resize'] = True
if visit:
partition['active_partition_build'] = visit
self.__state.append([question, state[1], 0])
self.preseed(question, visit[0][2])
return True
else:
# Back up to the previous menu.
return False
elif self.creating_partition or self.editing_partition:
if self.creating_partition:
request = self.creating_partition
else:
request = self.editing_partition
state = self.__state[-1]
partition = self.partition_cache[state[1]]
if state[0] != question:
# Set up our intentions for this menu.
visit = []
for item in ('method', 'mountpoint', 'format'):
if item in request and request[item] is not None:
visit.append(item)
if (self.editing_partition and
'size' in request and request['size'] is not None):
visit.append('resize')
partition['active_partition_edit'] = visit
self.__state.append([question, state[1], -1])
state = self.__state[-1]
state[2] += 1
while state[2] < len(partition['active_partition_edit']):
# Move on to the next item.
visit = partition['active_partition_edit']
item = visit[state[2]]
scripts = self.find_script(menu_options, None, item)
if scripts:
self.preseed(question, scripts[0][2])
return True
state[2] += 1
# If we didn't find anything to do, finish editing this
# partition.
try:
del partition['active_partition_edit']
except KeyError:
pass
self.__state.pop()
self.preseed_script(question, menu_options, 'finish')
return True
elif self.deleting_partition:
self.preseed_script(question, menu_options, 'delete')
self.deleting_partition = None
return True
else:
raise AssertionError, "Arrived at %s unexpectedly" % question
elif question == 'partman-partitioning/confirm_resize':
if self.autopartition_question is not None:
if self.auto_state is not None:
# Proceed through confirmation question; we'll back up
# later.
self.preseed(question, 'true')
return True
else:
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 self.building_cache:
state = self.__state[-1]
assert state[0] == 'partman/active_partition'
# Proceed through to asking for the size; don't worry, we'll
# back up from there.
self.preseed(question, 'true')
return True
elif self.editing_partition:
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
else:
raise AssertionError, "Arrived at %s unexpectedly" % question
elif question == 'partman-partitioning/new_size':
if self.autopartition_question is not None:
if self.auto_state is not None:
self.extra_options[self.auto_state[1]] = \
(self.resize_min_size, self.resize_max_size,
self.resize_orig_size, self.resize_path)
# Back up to autopartitioning question.
self.succeeded = False
return False
else:
assert self.extra_choice is not None
if self.bad_auto_size:
self.bad_auto_size = False
return False
self.preseed(question, '%d%%' % self.extra_choice)
self.succeeded = True
return True
elif self.building_cache:
# subst() should have gathered the necessary information.
# Back up.
return False
elif self.editing_partition:
if 'bad_size' in self.editing_partition:
return False
size = self.editing_partition['size']
if re.search(r'^[0-9.]+$', size):
# ensure megabytes just in case partman's semantics change
size += 'M'
self.preseed(question, size)
return True
else:
raise AssertionError, "Arrived at %s unexpectedly" % question
elif question == 'partman-target/choose_method':
if self.building_cache:
state = self.__state[-1]
assert state[0] == 'partman/active_partition'
partition = self.partition_cache[state[1]]
partition['method_choices'] = []
for (script, arg, option) in menu_options:
partition['method_choices'].append((script, arg, option))
# Back up to the previous menu.
return False
elif self.creating_partition or self.editing_partition:
if self.creating_partition:
request = self.creating_partition
else:
request = self.editing_partition
self.preseed_script(question, menu_options,
None, request['method'])
return True
else:
raise AssertionError, "Arrived at %s unexpectedly" % question
elif question in ('partman-basicfilesystems/mountpoint',
'partman-basicfilesystems/fat_mountpoint'):
if self.building_cache:
state = self.__state[-1]
assert state[0] == 'partman/active_partition'
partition = self.partition_cache[state[1]]
partition['mountpoint_choices'] = []
choices_c = self.choices_untranslated(question)
choices = self.choices(question)
assert len(choices_c) == len(choices)
for i in range(len(choices_c)):
if choices_c[i].startswith('/'):
partition['mountpoint_choices'].append((
choices_c[i].split(' ')[0],
choices_c[i], choices[i]))
# Back up to the previous menu.
return False
elif self.creating_partition or self.editing_partition:
if self.creating_partition:
request = self.creating_partition
else:
request = self.editing_partition
if 'bad_mountpoint' in request:
return False
mountpoint = request['mountpoint']
if mountpoint == '' or mountpoint is None:
self.preseed(question, 'Do not mount it')
else:
self.preseed(question, 'Enter manually')
return True
else:
raise AssertionError, "Arrived at %s unexpectedly" % question
elif question == 'partman-basicfilesystems/mountpoint_manual':
if self.creating_partition or self.editing_partition:
if self.creating_partition:
request = self.creating_partition
else:
request = self.editing_partition
if 'bad_mountpoint' in request:
return False
self.preseed(question, request['mountpoint'])
return True
else:
raise AssertionError, "Arrived at %s unexpectedly" % question
elif 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')
self.succeeded = True
self.done = 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)
else:
self.preseed(question, 'unhandled')
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 in ('partman-jfs/jfs_boot', 'partman-jfs/jfs_root',
'grub-installer/install_to_xfs'):
answer_reversed = True
if response is None or response == 'ubiquity/text/continue':
answer = answer_reversed
else:
answer = not answer_reversed
if answer:
self.preseed(question, 'true')
else:
self.preseed(question, 'false')
return True
return FilteredCommand.run(self, priority, question)
def run(self,priority,question):
if question.startswith('mythbuntu/advanced_install'):
advanced = self.frontend.get_advanced()
self.preseed_bool('mythbuntu/advanced_install', advanced)
return FilteredCommand.run(self, priority, question)
def run(self,priority,question):
if question.startswith('mythbuntu/install_type'):
installtype = self.frontend.get_installtype()
self.preseed('mythbuntu/install_type', installtype)
return FilteredCommand.run(self, priority, question)
def run(self, priority, question):
if self.done:
# user answered confirmation question or backed up
return self.succeeded
self.current_question = question
options = self.snoop()
menu_options = self.snoop_menu(options)
self.debug("Partman: state = %s", self.__state)
self.debug("Partman: auto_state = %s", self.auto_state)
if question.endswith("automatically_partition"):
self.autopartition_question = question
choices = self.choices(question)
if self.auto_state is None:
self.some_device_desc = self.description("partman-auto/text/use_device")
self.resize_desc = self.description("partman-auto/text/resize_use_free")
self.manual_desc = self.description("partman-auto/text/custom_partitioning")
self.biggest_free_desc = self.description("partman-auto/text/use_biggest_free")
self.extra_options = {}
if choices:
self.auto_state = [0, None]
else:
self.auto_state[0] += 1
while self.auto_state[0] < len(choices):
self.auto_state[1] = choices[self.auto_state[0]]
if self.auto_state[1] == self.some_device_desc or self.auto_state[1] == self.resize_desc:
break
else:
self.auto_state[0] += 1
if self.auto_state[0] < len(choices):
self.preseed_as_c(question, self.auto_state[1], seen=False)
self.succeeded = True
return True
else:
self.auto_state = None
if self.resize_desc not in self.extra_options:
try:
del choices[choices.index(self.resize_desc)]
except ValueError:
pass
regain_privileges()
# {'/dev/sda' : ('/dev/sda1', 24973242, '32256-2352430079'), ...
# TODO evand 2009-04-16: We should really use named tuples here.
parted = parted_server.PartedServer()
layout = {}
for disk in parted.disks():
parted.select_disk(disk)
ret = []
total = 0
for partition in parted.partitions():
size = int(partition[2])
if partition[4] == "free":
dev = "free"
else:
dev = partition[5]
ret.append((dev, size, partition[1]))
layout[disk] = ret
self.frontend.set_disk_layout(layout)
drop_privileges()
# Set up translation mappings to avoid debian-installer
# specific text ('Guided -').
self.translation_mappings = {}
def map_trans(di_string, ubiquity_string):
ubiquity_string = self.description(ubiquity_string)
self.translation_mappings[ubiquity_string] = di_string
try:
choices[choices.index(di_string)] = ubiquity_string
except ValueError:
pass
if di_string in self.extra_options:
t = self.extra_options[di_string]
del self.extra_options[di_string]
self.extra_options[ubiquity_string] = t
return ubiquity_string
self.some_device_desc = map_trans(self.some_device_desc, "ubiquity/text/use_device")
self.biggest_free_desc = map_trans(self.biggest_free_desc, "ubiquity/text/biggest_free")
self.resize_desc = map_trans(self.resize_desc, "ubiquity/text/resize_use_free")
self.manual_desc = map_trans(self.manual_desc, "ubiquity/text/custom_partitioning")
biggest_free = self.find_script(menu_options, "biggest_free")
if biggest_free:
biggest_free = biggest_free[0][1]
biggest_free = self.split_devpart(biggest_free)[1]
self.extra_options[self.biggest_free_desc] = biggest_free
self.frontend.set_autopartition_choices(
choices, self.extra_options, self.resize_desc, self.manual_desc, self.biggest_free_desc
)
elif question == "partman-auto/select_disk":
if self.auto_state is not None:
self.extra_options[self.auto_state[1]] = self.choices(question)
# Back up to autopartitioning question.
self.succeeded = False
return False
else:
assert self.extra_choice is not None
self.preseed_as_c(question, self.extra_choice, seen=False)
self.succeeded = True
return True
elif question == "partman/choose_partition":
self.autopartition_question = None # not autopartitioning any more
if not self.building_cache and self.update_partitions:
# Rebuild our cache of just these partitions.
self.__state = [["", None, None]]
self.building_cache = True
if "ALL" in self.update_partitions:
self.update_partitions = None
if self.building_cache:
state = self.__state[-1]
if state[0] == question:
# advance to next partition
self.frontend.debconf_progress_step(1)
self.frontend.refresh()
self.debug("Partman: update_partitions = %s", self.update_partitions)
state[1] = None
while self.update_partitions:
state[1] = self.update_partitions[0]
del self.update_partitions[0]
if state[1] not in self.partition_cache:
self.debug("Partman: %s not found in cache", partition)
state[1] = None
self.frontend.debconf_progress_step(1)
self.frontend.refresh()
else:
break
if state[1] is not None:
# Move on to the next partition.
partition = self.partition_cache[state[1]]
self.debug("Partman: Building cache (%s)", partition["parted"]["path"])
self.preseed(question, partition["display"], seen=False)
return True
else:
# Finished building the cache.
self.debug("Partman: Finished building cache")
self.__state.pop()
self.update_partitions = None
self.building_cache = False
self.frontend.debconf_progress_stop()
self.frontend.refresh()
self.frontend.update_partman(self.disk_cache, self.partition_cache, self.cache_order)
else:
self.debug("Partman: Building cache")
regain_privileges()
parted = parted_server.PartedServer()
matches = self.find_script(menu_options, "partition_tree")
# If we're only updating our cache for certain
# partitions, then self.update_partitions will be a list
# of the partitions to update; otherwise, we build the
# cache from scratch.
rebuild_all = self.update_partitions is None
if rebuild_all:
self.disk_cache = {}
self.partition_cache = {}
self.cache_order = []
# Clear out the partitions we're updating to make sure
# stale keys are removed.
if self.update_partitions is not None:
for devpart in self.update_partitions:
if devpart in self.partition_cache:
del self.partition_cache[devpart]
# Initialise any items we haven't heard of yet.
for script, arg, option in matches:
dev, part_id = self.split_devpart(arg)
if not dev:
continue
parted.select_disk(dev)
self.cache_order.append(arg)
if part_id:
if rebuild_all or arg not in self.partition_cache:
self.partition_cache[arg] = {"dev": dev, "id": part_id, "parent": dev.replace("=", "/")}
else:
if rebuild_all or arg not in self.disk_cache:
device = parted.readline_device_entry("device")
self.disk_cache[arg] = {"dev": dev, "device": device}
if self.update_partitions is None:
self.update_partitions = self.partition_cache.keys()
else:
self.update_partitions = [
devpart for devpart in self.update_partitions if devpart in self.partition_cache
]
# Update the display names of all disks and partitions.
for script, arg, option in matches:
dev, part_id = self.split_devpart(arg)
if not dev:
continue
parted.select_disk(dev)
if part_id:
self.partition_cache[arg]["display"] = "%s__________%s" % (script, arg)
else:
self.disk_cache[arg]["display"] = "%s__________%s" % (script, arg)
# Get basic information from parted_server for each
# partition being updated.
for devpart in self.update_partitions:
dev, part_id = self.split_devpart(devpart)
if not dev:
continue
parted.select_disk(dev)
info = parted.partition_info(part_id)
self.partition_cache[devpart]["parted"] = {
"num": info[0],
"id": info[1],
"size": info[2],
"type": info[3],
"fs": info[4],
"path": info[5],
"name": info[6],
}
drop_privileges()
self.frontend.debconf_progress_start(
0, len(self.update_partitions), self.description("partman/progress/init/parted")
)
self.frontend.refresh()
self.debug("Partman: update_partitions = %s", self.update_partitions)
# Selecting a disk will ask to create a new disklabel,
# so don't bother with that.
devpart = None
if self.partition_cache:
while self.update_partitions:
devpart = self.update_partitions[0]
del self.update_partitions[0]
if devpart not in self.partition_cache:
self.debug("Partman: %s not found in cache", partition)
devpart = None
self.frontend.debconf_progress_step(1)
self.frontend.refresh()
else:
break
if devpart is not None:
partition = self.partition_cache[devpart]
self.debug("Partman: Building cache (%s)", partition["parted"]["path"])
self.__state.append([question, devpart, None])
self.preseed(question, partition["display"], seen=False)
return True
else:
self.debug("Partman: Finished building cache " "(no partitions to update)")
self.update_partitions = None
self.building_cache = False
self.frontend.debconf_progress_stop()
self.frontend.refresh()
self.frontend.update_partman(self.disk_cache, self.partition_cache, self.cache_order)
elif self.creating_partition:
devpart = self.creating_partition["devpart"]
if devpart in self.partition_cache:
self.frontend.update_partman(self.disk_cache, self.partition_cache, self.cache_order)
elif self.editing_partition:
devpart = self.editing_partition["devpart"]
if devpart in self.partition_cache:
self.frontend.update_partman(self.disk_cache, self.partition_cache, self.cache_order)
elif self.deleting_partition:
raise AssertionError, "Deleting partition didn't rebuild cache?"
if self.debug_enabled():
import pprint
self.debug("disk_cache:")
printer = pprint.PrettyPrinter()
for line in printer.pformat(self.disk_cache).split("\n"):
self.debug("%s", line)
self.debug("disk_cache end")
self.debug("partition_cache:")
printer = pprint.PrettyPrinter()
for line in printer.pformat(self.partition_cache).split("\n"):
self.debug("%s", line)
self.debug("partition_cache end")
self.__state = [["", None, None]]
self.creating_label = None
self.creating_partition = None
self.editing_partition = None
self.deleting_partition = None
self.undoing = False
self.finish_partitioning = False
FilteredCommand.run(self, priority, question)
if self.finish_partitioning or self.done:
if self.succeeded:
self.preseed_script(question, menu_options, "finish")
return self.succeeded
elif self.creating_label:
devpart = self.creating_label["devpart"]
if devpart in self.disk_cache:
disk = self.disk_cache[devpart]
# No need to use self.__state to keep track of this.
self.preseed(question, disk["display"], seen=False)
return True
elif self.creating_partition:
devpart = self.creating_partition["devpart"]
if devpart in self.partition_cache:
partition = self.partition_cache[devpart]
self.__state.append([question, devpart, None])
self.preseed(question, partition["display"], seen=False)
return True
elif self.editing_partition:
devpart = self.editing_partition["devpart"]
if devpart in self.partition_cache:
partition = self.partition_cache[devpart]
self.__state.append([question, devpart, None])
self.preseed(question, partition["display"], seen=False)
return True
elif self.deleting_partition:
devpart = self.deleting_partition["devpart"]
if devpart in self.partition_cache:
partition = self.partition_cache[devpart]
# No need to use self.__state to keep track of this.
self.preseed(question, partition["display"], seen=False)
return True
elif self.undoing:
self.preseed_script(question, menu_options, "undo")
return True
else:
raise AssertionError, ("Returned to %s with nothing to do" % question)
elif question == "partman-partitioning/confirm_new_label":
if self.creating_label:
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", seen=False)
else:
self.preseed(question, "false", seen=False)
return True
else:
raise AssertionError, "Arrived at %s unexpectedly" % question
elif question == "partman/free_space":
if self.building_cache:
state = self.__state[-1]
assert state[0] == "partman/choose_partition"
partition = self.partition_cache[state[1]]
can_new = False
if self.find_script(menu_options, "new"):
can_new = True
partition["can_new"] = can_new
# Back up to the previous menu.
return False
elif self.creating_partition:
self.preseed_script(question, menu_options, "new")
return True
else:
raise AssertionError, "Arrived at %s unexpectedly" % question
elif question == "partman-partitioning/new_partition_size":
if self.creating_partition:
if "bad_size" in self.creating_partition:
return False
size = self.creating_partition["size"]
if re.search(r"^[0-9.]+$", size):
# ensure megabytes just in case partman's semantics change
size += "M"
self.preseed(question, size, seen=False)
return True
else:
raise AssertionError, "Arrived at %s unexpectedly" % question
elif question == "partman-partitioning/new_partition_type":
if self.creating_partition:
if self.creating_partition["type"] == PARTITION_TYPE_PRIMARY:
self.preseed(question, "Primary", seen=False)
else:
self.preseed(question, "Logical", seen=False)
return True
else:
raise AssertionError, "Arrived at %s unexpectedly" % question
elif question == "partman-partitioning/new_partition_place":
if self.creating_partition:
if self.creating_partition["place"] == PARTITION_PLACE_BEGINNING:
self.preseed(question, "Beginning", seen=False)
else:
self.preseed(question, "End", seen=False)
return True
else:
raise AssertionError, "Arrived at %s unexpectedly" % question
elif question == "partman/active_partition":
if self.building_cache:
state = self.__state[-1]
partition = self.partition_cache[state[1]]
if state[0] == question:
state[2] += 1
if state[2] < len(partition["active_partition_build"]):
# Move on to the next item.
visit = partition["active_partition_build"]
self.preseed_as_c(question, visit[state[2]][2], seen=False)
return True
else:
# Finished building the cache for this submenu; go
# back to the previous one.
try:
del partition["active_partition_build"]
except KeyError:
pass
self.__state.pop()
return False
assert state[0] == "partman/choose_partition"
regain_privileges()
parted = parted_server.PartedServer()
parted.select_disk(partition["dev"])
for entry in (
"method",
"filesystem",
"detected_filesystem",
"acting_filesystem",
"existing",
"formatable",
"mountpoint",
):
if parted.has_part_entry(partition["id"], entry):
partition[entry] = parted.readline_part_entry(partition["id"], entry)
drop_privileges()
visit = []
for (script, arg, option) in menu_options:
if arg in ("method", "mountpoint"):
visit.append((script, arg, option))
elif arg == "format":
partition["can_activate_format"] = True
elif arg == "resize":
visit.append((script, arg, option))
partition["can_resize"] = True
if visit:
partition["active_partition_build"] = visit
self.__state.append([question, state[1], 0])
self.preseed_as_c(question, visit[0][2], seen=False)
return True
else:
# Back up to the previous menu.
return False
elif self.creating_partition or self.editing_partition:
if self.creating_partition:
request = self.creating_partition
else:
request = self.editing_partition
state = self.__state[-1]
partition = self.partition_cache[state[1]]
if state[0] != question:
# Set up our intentions for this menu.
visit = []
for item in ("method", "mountpoint", "format"):
if item in request and request[item] is not None:
visit.append(item)
if self.editing_partition and "size" in request and request["size"] is not None:
visit.append("resize")
partition["active_partition_edit"] = visit
self.__state.append([question, state[1], -1])
state = self.__state[-1]
state[2] += 1
while state[2] < len(partition["active_partition_edit"]):
# Move on to the next item.
visit = partition["active_partition_edit"]
item = visit[state[2]]
scripts = self.find_script(menu_options, None, item)
if scripts:
self.preseed_as_c(question, scripts[0][2], seen=False)
return True
state[2] += 1
# If we didn't find anything to do, finish editing this
# partition.
try:
del partition["active_partition_edit"]
except KeyError:
pass
self.__state.pop()
self.preseed_script(question, menu_options, "finish")
return True
elif self.deleting_partition:
self.preseed_script(question, menu_options, "delete")
self.deleting_partition = None
return True
else:
raise AssertionError, "Arrived at %s unexpectedly" % question
elif question == "partman-partitioning/confirm_resize":
if self.autopartition_question is not None:
if self.auto_state is not None:
# Proceed through confirmation question; we'll back up
# later.
self.preseed(question, "true", seen=False)
return True
else:
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", seen=False)
else:
self.preseed(question, "false", seen=False)
return True
elif self.building_cache:
state = self.__state[-1]
assert state[0] == "partman/active_partition"
# Proceed through to asking for the size; don't worry, we'll
# back up from there.
self.preseed(question, "true", seen=False)
return True
elif self.editing_partition:
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", seen=False)
else:
self.preseed(question, "false", seen=False)
return True
else:
raise AssertionError, "Arrived at %s unexpectedly" % question
elif question == "partman-partitioning/new_size":
if self.autopartition_question is not None:
if self.auto_state is not None:
self.extra_options[self.auto_state[1]] = (
self.resize_min_size,
self.resize_max_size,
self.resize_orig_size,
self.resize_path,
)
# Back up to autopartitioning question.
self.succeeded = False
return False
else:
assert self.extra_choice is not None
if self.bad_auto_size:
self.bad_auto_size = False
return False
self.preseed(question, self.extra_choice, seen=False)
self.succeeded = True
return True
elif self.building_cache:
# subst() should have gathered the necessary information.
# Back up.
return False
elif self.editing_partition:
if "bad_size" in self.editing_partition:
return False
size = self.editing_partition["size"]
if re.search(r"^[0-9.]+$", size):
# ensure megabytes just in case partman's semantics change
size += "M"
self.preseed(question, size, seen=False)
return True
else:
raise AssertionError, "Arrived at %s unexpectedly" % question
elif question == "partman-target/choose_method":
if self.building_cache:
state = self.__state[-1]
assert state[0] == "partman/active_partition"
partition = self.partition_cache[state[1]]
partition["method_choices"] = []
for (script, arg, option) in menu_options:
partition["method_choices"].append((script, arg, option))
# Back up to the previous menu.
return False
elif self.creating_partition or self.editing_partition:
if self.creating_partition:
request = self.creating_partition
else:
request = self.editing_partition
self.preseed_script(question, menu_options, None, request["method"])
return True
else:
raise AssertionError, "Arrived at %s unexpectedly" % question
elif question in ("partman-basicfilesystems/mountpoint", "partman-basicfilesystems/fat_mountpoint"):
if self.building_cache:
state = self.__state[-1]
assert state[0] == "partman/active_partition"
partition = self.partition_cache[state[1]]
partition["mountpoint_choices"] = []
choices_c = self.choices_untranslated(question)
choices = self.choices(question)
assert len(choices_c) == len(choices)
for i in range(len(choices_c)):
if choices_c[i].startswith("/"):
partition["mountpoint_choices"].append((choices_c[i].split(" ")[0], choices_c[i], choices[i]))
# Back up to the previous menu.
return False
elif self.creating_partition or self.editing_partition:
if self.creating_partition:
request = self.creating_partition
else:
request = self.editing_partition
if "bad_mountpoint" in request:
return False
mountpoint = request["mountpoint"]
if mountpoint == "" or mountpoint is None:
self.preseed(question, "Do not mount it", seen=False)
else:
self.preseed(question, "Enter manually", seen=False)
return True
else:
raise AssertionError, "Arrived at %s unexpectedly" % question
elif question == "partman-basicfilesystems/mountpoint_manual":
if self.creating_partition or self.editing_partition:
if self.creating_partition:
request = self.creating_partition
else:
request = self.editing_partition
if "bad_mountpoint" in request:
return False
self.preseed(question, request["mountpoint"], seen=False)
return True
else:
raise AssertionError, "Arrived at %s unexpectedly" % question
elif 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", seen=False)
self.succeeded = True
self.done = 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 question == "partman/installation_medium_mounted":
self.frontend.installation_medium_mounted(self.extended_description(question))
return True
elif self.question_type(question) == "boolean":
if question == "partman/unmount_active":
yes = "ubiquity/imported/yes"
no = "ubiquity/imported/no"
else:
yes = "ubiquity/text/continue"
no = "ubiquity/text/go_back"
response = self.frontend.question_dialog(
self.description(question), self.extended_description(question), (no, yes)
)
answer_reversed = False
if question in ("partman-jfs/jfs_boot", "partman-jfs/jfs_root", "partman/unmount_active"):
answer_reversed = True
if response is None or response == yes:
answer = answer_reversed
else:
answer = not answer_reversed
if answer:
self.preseed(question, "true", seen=False)
else:
self.preseed(question, "false", seen=False)
return True
return FilteredCommand.run(self, priority, question)
