def search_button_clicked(self, widget=None):
        """
        Reload the subscriptions from the server when the Search button
        is clicked.
        """
        if not self.date_picker.date_entry_validate():
            return
        try:
            pb_title = _("Searching")
            pb_label = _("Searching for subscriptions. Please wait.")
            if self.pb:
                self.pb.set_title(pb_title)
                self.pb.set_label(pb_label)
            else:
                # show pulsating progress bar while we wait for results
                self.pb = progress.Progress(pb_title, pb_label)
                self.timer = ga_GObject.timeout_add(100, self.pb.pulse)
                self.pb.set_transient_for(self.parent_win)

            # fire off async refresh
            async_stash = async_utils.AsyncPool(self.pool_stash)
            async_stash.refresh(self.date_picker.date, self._update_display)
        except Exception as e:
            handle_gui_exception(e, _("Error fetching subscriptions from server:  %s"),
                    self.parent_win)

    def _on_get_owner_list_cb(self, owners, error=None):
        if error != None:
            handle_gui_exception(error, REGISTER_ERROR,
                    self.registerWin)
            self._finish_registration(failed=True)
            return

        owners = [(owner['key'], owner['displayName']) for owner in owners]

        if len(owners) == 0:
            handle_gui_exception(None,
                    _("<b>User %s is not able to register with any orgs.</b>") \
                            % (self.uname.get_text().strip()),
                    self.registerWin)
            self._finish_registration(failed=True)
            return

        if len(owners) == 1:
            self.owner_key = owners[0][0]
            self.async.get_environment_list(self.owner_key, self._on_get_environment_list_cb)

        else:
            owner_model = gtk.ListStore(str, str)
            for owner in owners:
                owner_model.append(owner)

            self.owner_treeview.set_model(owner_model)

            self.owner_treeview.get_selection().select_iter(
                    owner_model.get_iter_first())

            self.cancel_button.set_sensitive(True)
            self.register_button.set_sensitive(True)
            self.register_notebook.set_page(OWNER_SELECT_PAGE)

    def _init_sla(self):
        if self.skip_auto_subscribe():
            return self._move_to_manual_install(_("You have opted to skip auto-subscribe."))

        # sla autosubscribe time. load up the possible slas, to decide if
        # we need to display the selection screen, or go to the confirm
        # screen.
        # XXX this should really be done async.

        controller = autobind.init_controller(self.backend, self.consumer,
                Facts())

        # XXX see autobind.AutobindWizard load() and _show_initial_screen
        # for matching error handling.
        try:
            controller.load()
        except autobind.ServiceLevelNotSupportedException:
            message = _("Unable to auto-subscribe, server does not support service levels. Please run 'Subscription Manager' to manually subscribe.")
            return self._move_to_manual_install(message)

        except autobind.NoProductsException:
            message = _("No installed products on system. No need to update certificates at this time.")
            return self._move_to_manual_install(message)

        except autobind.AllProductsCoveredException:
            message = _("All installed products are covered by valid entitlements. Please run 'Subscription Manager' to subscribe to additional products.")
            return self._move_to_manual_install(message)

        except socket.error, e:
            handle_gui_exception(e, None, self.registerWin)
            return

    def _on_get_environment_list_cb(self, result_tuple, error=None):
        environments = result_tuple
        if error != None:
            handle_gui_exception(error, REGISTER_ERROR, self.registerWin)
            self._finish_registration(failed=True)
            return

        if not environments:
            self._run_register_step(self.owner_key, None)
            return

        envs = [(env['id'], env['name']) for env in environments]
        if len(envs) == 1:
            self._run_register_step(self.owner_key, envs[0][0])
        else:
            environment_model = gtk.ListStore(str, str)
            for env in envs:
                environment_model.append(env)

            self.environment_treeview.set_model(environment_model)

            self.environment_treeview.get_selection().select_iter(
                    environment_model.get_iter_first())

            self.cancel_button.set_sensitive(True)
            self.register_button.set_sensitive(True)
            self.register_notebook.set_page(ENVIRONMENT_SELECT_PAGE)

    def _on_get_owner_list_cb(self, owners, error=None):
        if error is not None:
            handle_gui_exception(error, REGISTER_ERROR,
                    self._parent.window)
            self._parent.pre_done(CREDENTIALS_PAGE)
            return

        owners = [(owner['key'], owner['displayName']) for owner in owners]
        # Sort by display name so the list doesn't randomly change.
        owners = sorted(owners, key=lambda item: item[1])

        if len(owners) == 0:
            handle_gui_exception(None,
                                 _("<b>User %s is not able to register with any orgs.</b>") %
                                   (self._parent.username),
                    self._parent.parent)
            self._parent.finish_registration(failed=True)
            return

        if len(owners) == 1:
            self._owner_key = owners[0][0]
            self._parent.pre_done(ENVIRONMENT_SELECT_PAGE)
        else:
            self.set_model(owners)
            self._parent.pre_done(DONT_CHANGE)

    def apply(self, interface, testing=False):
        """
        'Next' button has been clicked - try to register with the
        provided user credentials and return the appropriate result
        value.
        """

        # on el5 we can't just move to another page, we have to set the next
        # page then do an apply. since we've already done our work async, skip
        # this time through
        if self._skip_apply_for_page_jump:
            self._skip_apply_for_page_jump = False
            return self._RESULT_SUCCESS

        self.interface = interface

        self._read_rhn_proxy_settings()

        credentials = self._get_credentials_hash()

        # bad proxy settings can cause socket.error or friends here
        # see bz #810363
        try:
            valid_registration = self.register(testing=testing)
        except socket.error, e:
            handle_gui_exception(e, e, self.registerWin)
            return self._RESULT_FAILURE

 def _repos_item_clicked(self, widget):
     try:
         self.repos_dialog.show()
     except Exception as e:
         handle_gui_exception(e, _("Error in repos dialog. "
                                   "Please see /var/log/rhsm/rhsm.log for more information."),
                              self._get_window())

    def _on_refresh_cb(self, error=None):
        if error is not None:
            handle_gui_exception(error, _("Error subscribing: %s"), self._parent.parent)
            self._parent.finish_registration(failed=True)
            return

        self._parent.pre_done(FINISH)

    def _on_registration_finished_cb(self, new_account, error=None):
        if error is not None:
            handle_gui_exception(error, registergui.REGISTER_ERROR,
                    self._parent.window)
            self._parent.finish_registration(failed=True)
            return

        try:
            managerlib.persist_consumer_cert(new_account)
            self._parent.backend.cs.force_cert_check()  # Ensure there isn't much wait time

            if self._parent.activation_keys:
                self._parent.pre_done(registergui.REFRESH_SUBSCRIPTIONS_PAGE)
            elif self._parent.skip_auto_bind:
                message = _("You have opted to skip auto-attach.")
                self._parent.manual_message = message
                self._parent.pre_done(MANUALLY_SUBSCRIBE_PAGE)
            else:
                self._parent.pre_done(registergui.SELECT_SLA_PAGE)

        # If we get errors related to consumer name on register,
        # go back to the credentials screen where we set the
        # consumer name. See bz#865954
        except RestlibException, e:
            handle_gui_exception(e, registergui.REGISTER_ERROR,
                self._parent.window)
            if e.code == 404 and self._parent.activation_keys:
                self._parent.pre_done(registergui.ACTIVATION_KEY_PAGE)
            if e.code == 400:
                self._parent.pre_done(registergui.CREDENTIALS_PAGE)

    def apply(self, interface, testing=False):
        """
        'Next' button has been clicked - try to register with the
        provided user credentials and return the appropriate result
        value.
        """

        # on el5 we can't just move to another page, we have to set the next
        # page then do an apply. since we've already done our work async, skip
        # this time through
        if self._skip_apply_for_page_jump:
            self._skip_apply_for_page_jump = False
            # Reset back to first screen in our module in case the user hits back.
            # The firstboot register screen subclass will handle unregistering
            # if necessary when it runs again.
            self.show()
            return self._RESULT_SUCCESS

        self.interface = interface

        self._read_rhn_proxy_settings()

        # bad proxy settings can cause socket.error or friends here
        # see bz #810363
        try:
            valid_registration = self.register()
        except socket.error, e:
            handle_gui_exception(e, e, self.window)
            return self._RESULT_FAILURE

    def _on_subscribing_finished_cb(self, unused, error=None):
        if error is not None:
            handle_gui_exception(error, _("Error subscribing: %s"), self._parent.parent)
            self._parent.finish_registration(failed=True)
            return

        self._parent.pre_done(FINISH)
        self._parent.backend.cs.force_cert_check()

 def _update_certificates_button_clicked(self, widget):
     # Catch exceptions in the autobind wizard initialization (only)
     try:
         autobind_wizard = AutobindWizard(self.backend, self.consumer, self.facts,
                 self._get_window())
         autobind_wizard.show()
     except Exception, e:
         handle_gui_exception(e, _("Error in autobind wizard"), self._get_window())

    def _update_display(self, data, error):
        self._clear_progress_bar()

        if error:
            handle_gui_exception(error, _("Unable to search for subscriptions:  %s"),
                    self.parent_win)
        else:
            self.display_pools()

 def update(self, widget_update, backend_method, args=[], kwargs={}, exception_msg=None, callback=None):
     try:
         result = backend_method(*args, **kwargs)
         if callback:
             callback(result)
     except Exception, e:
         message = exception_msg or str(e)
         handle_gui_exception(e, message, self.parent_window)

 def _preferences_item_clicked(self, widget):
     try:
         self.preferences_dialog.show()
     except Exception, e:
         handle_gui_exception(
             e,
             _("Error in preferences dialog." "Please see /var/log/rhsm/rhsm.log for more information."),
             self._get_window(),
         )

 def _handle_unbind_exception(self, e, selection):
     self._clear_progress_bar()
     handle_gui_exception(
         e,
         _("There was an error removing %s with serial number %s")
         % (selection["subscription"], selection["serial"]),
         self.parent_win,
         format_msg=False,
     )

    def update_facts(self):
        """Sends the current system facts to the UEP server."""
        consumer_uuid = self.consumer.uuid

        try:
            self.facts.update_check(self.backend.uep, consumer_uuid, force=True)
        except Exception, e:
            log.error("Could not update system facts \nError: %s" % e)
            handle_gui_exception(e, linkify(str(e)), self.system_facts_dialog)

    def _on_subscribing_finished_cb(self, unused, error=None):
        try:
            if error != None:
                raise error
            self._parent.pre_done(FINISH)

        except Exception, e:
            handle_gui_exception(e, _("Error subscribing: %s"),
                                 self._parent.window)
            self._parent.finish_registration(failed=True)

    def update_facts(self):
        """Sends the current system facts to the UEP server."""

        identity = inj.require(inj.IDENTITY)

        try:
            self.facts.update_check(self.cp_provider.get_consumer_auth_cp(), identity.uuid, force=True)
        except Exception, e:
            log.error("Could not update system facts \nError: %s" % e)
            handle_gui_exception(e, linkify(str(e)), self.system_facts_dialog)

 def _perform_unregister(self):
     try:
         managerlib.unregister(self.backend.cp_provider.get_consumer_auth_cp(), self.identity.uuid)
     except Exception, e:
         log.error("Error unregistering system with entitlement platform.")
         handle_gui_exception(e, _("<b>Errors were encountered during unregister.</b>") +
                                   "\n%s\n" +
                                   _("Please see /var/log/rhsm/rhsm.log for more information."),
                             self.main_window,
                             log_msg="Consumer may need to be manually cleaned up: %s" %
                             self.identity.uuid)