Пример #1
0
    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)
Пример #2
0
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)
Пример #3
0
 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)
Пример #4
0
    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)
Пример #5
0
    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)
Пример #6
0
 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)
Пример #7
0
    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)
Пример #8
0
 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)
Пример #9
0
 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)
Пример #11
0
 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)
Пример #12
0
 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
Пример #14
0
 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)
Пример #15
0
    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)
Пример #16
0
    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)
Пример #17
0
    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)
Пример #18
0
    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)
Пример #19
0
    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)
Пример #20
0
    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)
Пример #21
0
    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)
Пример #22
0
 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)
Пример #23
0
    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)
Пример #24
0
    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)
Пример #26
0
 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)
Пример #27
0
    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)
Пример #28
0
 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)
Пример #29
0
    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)
Пример #30
0
    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)
Пример #31
0
    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)
Пример #32
0
 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
Пример #33
0
 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
Пример #34
0
    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)
Пример #35
0
    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)
Пример #36
0
 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
Пример #37
0
    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)
Пример #38
0
    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)
Пример #39
0
    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)
Пример #40
0
    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)
Пример #43
0
 def ok_handler(self):
     syslog.syslog("------->ok handler guadaPrePartition")
     return FilteredCommand.ok_handler(self)