upstream/oracle/pkg-gate: comparison src/packagemanager.py

equal deleted inserted replaced

-:7c34ba6e5e4f
+:15707d6de40b
 #
 # Copyright 2009 Sun Microsystems, Inc.  All rights reserved.
 # Use is subject to license terms.
 #
-# Progress:
-# Startup Progress has two phases:
-# - Start phase:
-#   The start phase should be fairly constant at around a few seconds and so is given 5%
-#   of the total progress bar.
-# - Package entry loading phase:
-#   The package entry loading phase is given the remaining 95% of the bar for progress.
-INITIAL_PROGRESS_TIME_INTERVAL = 0.5      # Time to update progress during start phase
-INITIAL_PROGRESS_TIME_PERCENTAGE = 0.005  # Amount to update progress during start phase
-INITIAL_PROGRESS_TOTAL_PERCENTAGE = 0.05  # Total progress for start phase
-PACKAGE_PROGRESS_TOTAL_INCREMENTS = 95    # Total increments for loading phase
-PACKAGE_PROGRESS_PERCENT_INCREMENT = 0.01 # Amount to update progress during loading phase
-PACKAGE_PROGRESS_PERCENT_TOTAL = 1.0      # Total progress for loading phase
 MAX_DESC_LEN = 60                         # Max length of the description
 MAX_INFO_CACHE_LIMIT = 100                # Max number of package descriptions to cache
 NOTEBOOK_PACKAGE_LIST_PAGE = 0            # Main Package List page index
 NOTEBOOK_START_PAGE = 1                   # Main View Start page index
 INFO_NOTEBOOK_LICENSE_PAGE = 3            # License Tab index
 self.application_dir,
 "usr/share/locale"))
 module.textdomain("pkg")
 gui_misc.init_for_help(self.application_dir)
 self.main_window_title = _('Package Manager')
+self.gdk_window = None
 self.user_rights = portable.is_admin()
 self.cancelled = False                    # For background processes
 self.image_directory = None
 self.description_thread_running = False   # For background processes
 gtk.rc_parse('~/.gtkrc-1.2-gnome2')       # Load gtk theme
-self.progress_stop_timer_thread = False
+self.progress_stop_thread = True
-self.progress_fraction_time_count = 0
-self.progress_canceled = False
 self.catalog_loaded = False
 self.image_dir_arg = None
 self.update_all_proceed = False
 self.ua_be_name = None
 self.application_path = None
 # Create Widgets and show gui
 self.gladefile = os.path.join(self.application_dir,
 "usr/share/package-manager/packagemanager.glade")
 w_tree_main = gtk.glade.XML(self.gladefile, "mainwindow")
-w_tree_progress = gtk.glade.XML(self.gladefile, "progressdialog")
 w_tree_preferences = gtk.glade.XML(self.gladefile, "preferencesdialog")
 w_tree_api_search_error = gtk.glade.XML(self.gladefile,
 "api_search_error")
 self.w_preferencesdialog = \
 w_tree_preferences.get_widget("preferencesdialog")
 w_tree_main.get_widget("startpage_eventbox")
 self.w_startpage_eventbox.modify_bg(gtk.STATE_NORMAL,
 gtk.gdk.color_parse("white"))
 self.w_main_statusbar = w_tree_main.get_widget("statusbar")
+self.w_statusbar_hbox = w_tree_main.get_widget("statusbar_hbox")
 self.w_infosearch_frame = w_tree_main.get_widget("infosearch_frame")
 self.w_infosearch_button = w_tree_main.get_widget("infosearch_button")
+self.w_progress_frame = w_tree_main.get_widget("progress_frame")
+self.w_status_progressbar = w_tree_main.get_widget("status_progressbar")
+self.w_status_progressbar.set_pulse_step(0.1)
+self.w_progress_frame.hide()
 self.w_main_view_notebook = \
 w_tree_main.get_widget("main_view_notebook")
 self.w_searchentry = w_tree_main.get_widget("searchentry")
 self.entry_embedded_icons_supported = True
 self.w_selectupdates_menuitem = \
 w_tree_main.get_widget("edit_select_updates")
 self.w_deselect_menuitem = w_tree_main.get_widget("edit_deselect")
 self.w_clear_search_menuitem = w_tree_main.get_widget("clear")
 self.w_main_clipboard =  gtk.clipboard_get(gtk.gdk.SELECTION_CLIPBOARD)
-self.w_progress_dialog = w_tree_progress.get_widget("progressdialog")
-self.w_progress_dialog.connect('delete-event', lambda stub1, stub2: True)
-self.w_progress_dialog.set_title(_("Update All"))
-self.w_progressinfo_label = w_tree_progress.get_widget("progressinfo")
-self.w_progressinfo_label.set_text(_(
-"Checking SUNWipkg and SUNWipkg-gui versions\n\nPlease wait ..."))
-self.w_progressbar = w_tree_progress.get_widget("progressbar")
-self.w_progressbar.set_pulse_step(0.1)
-self.w_progress_cancel = w_tree_progress.get_widget("progresscancel")
-self.progress_canceled = False
 self.saved_filter_combobox_active = self.initial_show_filter
 self.search_image = w_tree_main.get_widget("search_image")
 self.search_button = w_tree_main.get_widget("do_search")
+self.progress_cancel = w_tree_main.get_widget("progress_cancel")
 self.is_all_publishers = False
 self.search_image.set_from_pixbuf(gui_misc.get_icon(self.icon_theme,
 'search', 20))
 self.saved_repository_combobox_active = 0
 self.saved_sections_combobox_active = 0
 try:
 dic_mainwindow = \
 {
 "on_mainwindow_delete_event": \
 self.__on_mainwindow_delete_event,
+"on_mainwindow_check_resize": \
+self.__on_mainwindow_check_resize,
 "on_mainwindow_key_press_event": \
 self.__on_mainwindow_key_press_event,
 "on_searchentry_changed":self.__on_searchentry_changed,
 "on_searchentry_focus_in_event": \
 self.__on_searchentry_focus_in,
 "on_edit_search_activate":self.__on_edit_search_clicked,
 "on_clear_search_activate":self.__on_clear_search,
 "on_clear_search_clicked":self.__on_clear_search,
 "on_do_search_clicked":self.__do_search,
 "on_do_search_button_press_event":self.__do_search,
+"on_progress_cancel_clicked": \
+self.__on_progress_cancel_clicked,
 "on_edit_select_all_activate":self.__on_select_all,
 "on_edit_select_updates_activate": \
 self.__on_select_updates,
 "on_edit_deselect_activate":self.__on_deselect,
 "on_edit_preferences_activate":self.__on_preferences,
 "on_help_start_page_activate":self.__on_startpage,
 "on_details_notebook_switch_page": \
 self.__on_notebook_change,
 "on_infosearch_button_clicked": \
 self.__on_infosearch_button_clicked,
-}
-dic_progress = \
-{
-"on_cancel_progressdialog_clicked": \
-self.__on_cancel_progressdialog_clicked,
 }
 dic_preferences = \
 {
 "on_startpage_checkbutton_toggled": \
 self.__on_startpage_checkbutton_toggled,
 }
 w_xmltree_ua_completed.signal_autoconnect(dic_completed)
 w_tree_main.signal_autoconnect(dic_mainwindow)
-w_tree_progress.signal_autoconnect(dic_progress)
 w_tree_preferences.signal_autoconnect(dic_preferences)
 w_tree_api_search_error.signal_autoconnect(
 dic_api_search_error)
 except AttributeError, error:
 print _(
 self.w_main_window.show_all()
 gdk_win = self.w_main_window.get_window()
 self.gdk_window = gtk.gdk.Window(gdk_win, gtk.gdk.screen_width(),
 gtk.gdk.screen_height(), gtk.gdk.WINDOW_CHILD, 0, gtk.gdk.INPUT_ONLY)
 gdk_cursor = gtk.gdk.Cursor(gtk.gdk.WATCH)
 self.gdk_window.set_cursor(gdk_cursor)
 # Until package icons become available hide Package Icon Panel
 w_package_hbox.hide()
 if self.show_startpage:
 self.w_main_view_notebook.set_current_page(NOTEBOOK_START_PAGE)
 if link == None or link == "":
 self.update_statusbar()
 else:
 display_link = self.__handle_link(None, link, DISPLAY_LINK)
 if display_link != None:
-self.w_main_statusbar.push(0, display_link)
+self.__update_statusbar_message(display_link)
 else:
 self.update_statusbar()
 @staticmethod
 def __is_relative_to_server(url):
 # Stub handler required by GtkHtml widget or widget will assert
 def __stream_cancel(self, *vargs):
 pass
 def __load_uri(self, document, link):
-self.w_main_statusbar.push(0, _("Loading... " + link))
+self.__update_statusbar_message(_("Loading... " + link))
 try:
 f = self.__open_url(link)
 except  (IOError, OSError), err:
 if debug:
 print "err: %s" % (err)
-self.w_main_statusbar.push(0, _("Stopped"))
+self.__update_statusbar_message(_("Stopped"))
 return False
 self.current_url = self.__resolve_uri(link)
 self.document.clear()
 headers = f.info()
 else:
 self.document.open_stream('text/plain')
 self.document.write_stream(f.read())
 self.document.close_stream()
-self.w_main_statusbar.push(0, _("Done"))
+self.__update_statusbar_message(_("Done"))
 return True
 def __link_load_error(self, link):
 self.document.clear()
 self.document.open_stream('text/html')
 pkg_descriptions_for_update, orig_model)
 def __update_description_from_iter(self, pkg_descriptions_for_update, orig_model):
 sort_filt_model = \
 self.w_application_treeview.get_model() #gtk.TreeModelSort
+if not sort_filt_model:
+return
 filt_model = sort_filt_model.get_model() #gtk.TreeModelFilter
 model = filt_model.get_model() #gtk.ListStore
 #If model has changed abandon description updates
 if orig_model != model:
 if current_length > length_to_check:
 return current_length
 else:
 return length_to_check
-def __on_cancel_progressdialog_clicked(self, widget):
-self.progress_canceled = True
-self.progress_stop_timer_thread = True
 def __on_mainwindow_key_press_event(self, widget, event):
 if self.is_busy_cursor_set():
 return True
 else:
 return False
 # XXX if some changes were applied:
 self.__main_application_quit()
 return True
 else:
 self.__main_application_quit()
+def __on_mainwindow_check_resize(self, widget):
+if widget and self.gdk_window:
+status_height = self.w_statusbar_hbox.get_allocation().height
+self.gdk_window.move_resize(0, 0, widget.get_size()[0],
+widget.get_size()[1]-status_height)
 def __on_api_search_error_delete_event(self, widget, event):
 self.__on_api_search_button_clicked(None)
 def __on_api_search_button_clicked(self, widget):
 def __restore_setup_for_browse(self):
 self.in_search_mode = False
 self.is_all_publishers = False
 self.w_infosearch_frame.hide()
 self.set_busy_cursor()
 self.w_repository_combobox.set_active(
 self.saved_repository_combobox_active)
 self.set_section = self.saved_sections_combobox_active
 if self.saved_category_list == self.category_list:
 sort_col = enumerations.NAME_COLUMN
 try:
 for query_num, pub, (v, return_type, tmp) in \
 itertools.chain(*searches):
 if v < 1 or return_type != api.Query.RETURN_PACKAGES:
-gobject.idle_add(self.w_progress_dialog.hide)
 self.__process_after_search_failure()
 return
 active_pub = None
 if pub is not None \
 sort_col)
 last_name = name
 self.pylintstub = query_num
 except api_errors.ProblematicSearchServers, ex:
 self.__process_api_search_error(ex)
-gobject.idle_add(self.w_progress_dialog.hide)
 gobject.idle_add(self.__handle_api_search_error)
 if len(result) == 0:
 self.__process_after_search_with_zero_results()
 return
+except api_errors.CanceledException:
+# TBD. Currently search is not cancelable
+# so this should not happen, but the logic is in place
+# to support cancelable search.
+self.unset_busy_cursor()
+return
 except Exception, ex:
 # We are not interested in this error
-gobject.idle_add(self.w_progress_dialog.hide)
 self.__process_after_search_failure()
 return
 if debug:
 print "Number of search results:", len(result)
 if len(result) == 0:
 except api_errors.InventoryException:
 # This can happen if load_catalogs has not been run
 err = _("Unable to get status for search results.\n"
 "The catalogs have not been loaded.\n"
 "Please try after few seconds.\n")
-gobject.idle_add(self.w_progress_dialog.hide)
 gobject.idle_add(self.error_occurred, err)
 return
 return self.__add_pkgs_to_lists(pkgs_known, application_list,
 None, None)
 # Only clear out search results
 if self.in_search_mode or self.is_all_publishers:
 self.__clear_before_search()
 self.__update_statusbar_message(_("Search cleared"))
 return
+def __on_progress_cancel_clicked(self, widget):
+Thread(target = self.api_o.cancel, args = ()).start()
 def __on_startpage(self, widget):
 self.__load_startpage()
 self.w_main_view_notebook.set_current_page(NOTEBOOK_START_PAGE)
 def __get_application_categories_lists(self, publishers):
 application_list = self.__get_new_application_liststore()
 category_list = self.__get_new_category_liststore()
 section_list = self.__get_new_section_liststore()
-first_loop = True
 for pub in publishers:
 uptodate = False
 try:
 uptodate = self.__check_if_cache_uptodate(pub)
 if uptodate:
 #from api.
 application_list = self.__get_new_application_liststore()
 category_list = self.__get_new_category_liststore()
 uptodate = False
 if not uptodate:
-if first_loop == True:
+status_str = _("Refreshing package catalog information")
-first_loop = False
+gobject.idle_add(self.__update_statusbar_message,
-gobject.idle_add(self.setup_progressdialog_show)
+status_str)
 self.api_o.refresh(pubs=[pub])
 self.__add_pkgs_to_lists_from_api(pub,
 application_list, category_list, section_list)
 category_list.prepend([0, _('All'), None, None, False,
 True, None])
 if self.application_list and self.category_list and \
 not self.last_visible_publisher_uptodate:
+status_str = _("Loading package list")
+gobject.idle_add(self.__update_statusbar_message,
+status_str)
 if self.last_visible_publisher:
 dump_list = self.application_list
 if self.saved_application_list != None:
 dump_list = \
 self.saved_application_list
 self.last_visible_publisher_uptodate = uptodate
 return application_list, category_list, section_list
 def __check_if_cache_uptodate(self, pub):
 if self.cache_o:
-return self.cache_o.check_if_cache_uptodate(pub)
+uptodate = self.cache_o.check_if_cache_uptodate(pub)
+# We need to reset the state of the api, otherwise
+# method api.can_be_canceled() will return True
+self.api_o.reset()
+return uptodate
 return False
 def __dump_datamodels(self, pub, application_list, category_list,
 section_list):
 #Consistency check - only dump models if publisher passed in matches
 installupdate.InstallUpdate(remove_list, self,
 self.api_o, ips_update = False,
 action = enumerations.REMOVE)
 def __on_reload(self, widget):
+self.w_searchentry.grab_focus()
 if self.description_thread_running:
 self.cancelled = True
 if self.in_search_mode or self.is_all_publishers:
 self.__unset_search(False)
 self.__set_empty_details_panel()
 self.in_setup = True
 self.last_visible_publisher = None
 if widget != None:
 self.__remove_cache()
-self.w_progress_dialog.set_title(_("Refreshing catalogs"))
+self.set_busy_cursor()
-self.w_progressinfo_label.set_text(_("Refreshing catalogs..."))
+status_str = _("Refreshing package catalog information")
-self.progress_stop_timer_thread = False
+self.__update_statusbar_message(status_str)
-Thread(target = self.__progressdialog_progress_pulse).start()
-self.w_progress_dialog.show()
-self.w_progress_cancel.hide()
 self.__disconnect_models()
 self.in_reload = True
 Thread(target = self.__catalog_refresh).start()
 def __catalog_refresh_done(self):
-self.progress_stop_timer_thread = True
-#Let the progress_pulse finish. This should be done other way, but at
-#The moment this works fine
-time.sleep(0.2)
-gobject.idle_add(self.w_progress_cancel.show)
 gobject.idle_add(self.process_package_list_start,
 self.image_directory)
 def __main_application_quit(self, be_name = None):
 '''quits the main gtk loop'''
 True, True)
 except api_errors.InventoryException:
 # This can happen if the repository does not
 # contain any packages
 err = _("Selected repository does not contain any packages.")
-gobject.idle_add(self.w_progress_dialog.hide)
 gobject.idle_add(self.error_occurred, err, None,
 gtk.MESSAGE_INFO)
 self.unset_busy_cursor()
 pkgs_known = []
 section = sectioninfo.read(self.application_dir +
 share_path + "opensolaris.org.sections")
 sections[pub] = section
 pkg_count = 0
 pkg_add = 0
-progress_percent = INITIAL_PROGRESS_TOTAL_PERCENTAGE
 total_pkg_count = len(pkgs_known)
-progress_increment = \
+status_str = _("Loading package list")
-total_pkg_count / PACKAGE_PROGRESS_TOTAL_INCREMENTS
+gobject.idle_add(self.__update_statusbar_message, status_str)
-self.progress_stop_timer_thread = True
-while gtk.events_pending():
-gtk.main_iteration(False)
 prev_stem = ""
 prev_pfmri_str = ""
 next_app = None
 pkg_name = None
 pkg_publisher = None
 pkg_add += 1
 prev_stem = pkg.get_pkg_stem()
 prev_pfmri_str = pkg.get_short_fmri()
 prev_state = state
-if progress_increment > 0 and pkg_count % progress_increment == 0:
+gobject.idle_add(self.__progress_set_fraction,
-progress_percent += PACKAGE_PROGRESS_PERCENT_INCREMENT
+pkg_count, total_pkg_count)
-if progress_percent <= PACKAGE_PROGRESS_PERCENT_TOTAL:
-self.__progressdialog_progress_percent(
-progress_percent, pkg_count, total_pkg_count)
-while gtk.events_pending():
-gtk.main_iteration(False)
 status_icon = None
 category_icon = None
 pkg_name = pkg.get_name()
 pkg_name = gui_misc.get_pkg_name(pkg_name)
 pkg_stem = pkg.get_pkg_stem()
 category_list, pkg_publisher)
 pkg_add += 1
 if category_list != None:
 self.__add_categories_to_sections(sections,
 category_list, section_list)
-self.__progressdialog_progress_percent(PACKAGE_PROGRESS_PERCENT_TOTAL,
+gobject.idle_add(self.__progress_set_fraction,
-total_pkg_count, total_pkg_count)
+pkg_count, total_pkg_count)
 return
 def __add_categories_to_sections(self, sections, category_list, section_list):
 for pub in sections:
 for section in sections[pub]:
 if not section_name in \
 section_lst:
 section_lst.append(
 section_id)
-def __progressdialog_progress_pulse(self):
-while not self.progress_stop_timer_thread:
+def __progress_set_fraction(self, count, total):
-gobject.idle_add(self.w_progressbar.pulse)
+self.__progress_pulse_stop()
+if count == total:
+self.w_progress_frame.hide()
+return False
+if self.api_o.can_be_canceled():
+self.progress_cancel.show()
+else:
+self.progress_cancel.hide()
+self.w_progress_frame.show()
+result = (count + 0.0)/total
+if result > 1.0:
+result = 1.0
+elif result < 0.0:
+result = 0.0
+self.w_status_progressbar.set_fraction(result)
+def __progress_pulse_start(self):
+if self.progress_stop_thread == True:
+self.progress_stop_thread = False
+Thread(target = self.__progress_pulse).start()
+def __progress_pulse_stop(self):
+self.progress_stop_thread = True
+def __progress_pulse(self):
+gobject.idle_add(self.w_progress_frame.show)
+while not self.progress_stop_thread:
+if self.api_o.can_be_canceled():
+gobject.idle_add(self.progress_cancel.show)
+else:
+gobject.idle_add(self.progress_cancel.hide)
+gobject.idle_add(self.w_status_progressbar.pulse)
 time.sleep(0.1)
-gobject.idle_add(self.w_progress_dialog.hide)
+gobject.idle_add(self.w_progress_frame.hide)
-self.progress_stop_timer_thread = False
+self.progress_stop_thread = True
-# For initial setup before loading package entries allow 5% of progress bar
-# update it on a time base as we have no other way to judge progress at this point
-def __progressdialog_progress_time(self):
-while not self.progress_stop_timer_thread and \
-self.progress_fraction_time_count <= \
-INITIAL_PROGRESS_TOTAL_PERCENTAGE:
-gobject.idle_add(self.w_progressbar.set_fraction,
-self.progress_fraction_time_count)
-self.progress_fraction_time_count += \
-INITIAL_PROGRESS_TIME_PERCENTAGE
-time.sleep(INITIAL_PROGRESS_TIME_INTERVAL)
-self.progress_stop_timer_thread = False
-self.progress_fraction_time_count = 0
-def __progressdialog_progress_percent(self, fraction, count, total):
-gobject.idle_add(self.w_progressinfo_label.set_text, _(
-"Processing package entries: %d of %d") % (count, total)  )
-gobject.idle_add(self.w_progressbar.set_fraction, fraction)
 def error_occurred(self, error_msg, msg_title=None, msg_type=gtk.MESSAGE_ERROR):
 if msg_title:
 title = msg_title
 else:
 return version
 #-----------------------------------------------------------------------------#
 # Public Methods
 #-----------------------------------------------------------------------------#
-def setup_progressdialog_show(self):
-self.w_progress_dialog.set_title(_("Loading Repository Information"))
-self.w_progressinfo_label.set_text(
-_( "Fetching package entries ..."))
-self.w_progress_cancel.hide()
-self.w_progress_dialog.show()
-Thread(target = self.__progressdialog_progress_time).start()
-def setup_progressdialog_hide(self):
-self.progress_stop_timer_thread = True
-self.w_progress_dialog.hide()
 def init_show_filter(self):
 """ Sets up the Filter Combobox and returns the maximum length of text
 labels it is displaying."""
 return self.__init_show_filter()                #Initiates filter
 def is_busy_cursor_set(self):
 return self.gdk_window.is_visible()
 def set_busy_cursor(self):
+self.__progress_pulse_start()
 self.gdk_window.show()
 def unset_busy_cursor(self):
+self.__progress_pulse_stop()
 self.gdk_window.hide()
 def process_package_list_start(self, image_directory):
 self.image_directory = image_directory
 if not self.api_o:
 if self.update_all_proceed:
 # TODO: Handle situation where only SUNWipkg/SUNWipg-gui have been updated
 # in update all: bug 6357
 self.__on_update_all(None)
 self.update_all_proceed = False
-self.setup_progressdialog_hide()
 self.__enable_disable_install_remove()
 self.update_statusbar()
 self.in_setup = False
 self.cancelled = False
 if self.set_section != 0 or \
 listed_str = _('%d listed') % len(self.application_list)
 sel_str = _('%d selected') % sel
 inst_str = _('%d installed') % installed
 status_str = _("%s: %s , %s, %s.") % (visible_publisher,
 listed_str, inst_str, sel_str)
-self.w_main_statusbar.push(0, status_str)
+self.__update_statusbar_message(status_str)
 return
 # In Search Mode
 active = ""
 if self.is_all_publishers:
 elif self.search_time_sec > 1:
 time_str = _("in %d seconds") % self.search_time_sec
 status_str = fmt_str % {"option_str" : opt_str, "number" :
 len(self.application_list), "time" : time_str}
-self.w_main_statusbar.push(0, status_str)
+self.__update_statusbar_message(status_str)
 def update_package_list(self, update_list):
 if update_list == None and self.img_timestamp:
 return
 visible_publisher = self.__get_selected_publisher()

changeset 1236	15707d6de40b
parent 1233	32a432cffc1e
child 1243	d1f303f7dd86