← Back to branch summary

~mvo/software-center/startup-speed

« back to all changes in this revision

Viewing changes to softwarecenter/ui/gtk3/app.py

  • Committer: Gary Lasker
  • Date: 2011-12-15 02:27:13 UTC
  • mfrom: (2599.1.2 performance-probes)
  • Revision ID: gary.lasker@canonical.com-20111215022713-24ei35n31czl8q5x
merge lp:~mvo/software-center/performance-probes

Show diffs side-by-side

added added

removed removed

Lines of Context:
softwarecenter/ui/gtk3/app.py
62
62
from softwarecenter.utils import (clear_token_from_ubuntu_sso,
63
63
                                  get_http_proxy_string_from_gsettings,
64
64
                                  wait_for_apt_cache_ready,
 
65
                                  ExecutionTime,
65
66
                                  is_unity_running)
66
67
from softwarecenter.ui.gtk3.utils import (get_sc_icon_theme,
67
68
                                          init_sc_css_provider)
209
210
            sources = self.builder.get_object("menuitem_software_sources")
210
211
            sources.set_sensitive(False)
211
212
 
212
 
        # a main iteration friendly apt cache
213
 
        self.cache = get_pkg_info()
214
 
        self.cache.open()
215
 
        self.cache.connect("cache-broken", self._on_apt_cache_broken)
 
213
        with ExecutionTime("opening the pkginfo"):
 
214
            # a main iteration friendly apt cache
 
215
            self.cache = get_pkg_info()
 
216
            self.cache.open()
 
217
            self.cache.connect("cache-broken", self._on_apt_cache_broken)
216
218
 
217
 
        # xapian
218
 
        pathname = os.path.join(xapian_base_path, "xapian")
219
 
        self._use_axi = not options.disable_apt_xapian_index
220
 
        try:
221
 
            self.db = StoreDatabase(pathname, self.cache)
222
 
            self.db.open(use_axi = self._use_axi)
223
 
            if self.db.schema_version() != DB_SCHEMA_VERSION:
224
 
                LOG.warn("database format '%s' expected, but got '%s'" % (
225
 
                         DB_SCHEMA_VERSION, self.db.schema_version()))
226
 
                if os.access(pathname, os.W_OK):
 
219
        with ExecutionTime("opening the xapiandb"):
 
220
            pathname = os.path.join(xapian_base_path, "xapian")
 
221
            self._use_axi = not options.disable_apt_xapian_index
 
222
            try:
 
223
                self.db = StoreDatabase(pathname, self.cache)
 
224
                self.db.open(use_axi = self._use_axi)
 
225
                if self.db.schema_version() != DB_SCHEMA_VERSION:
 
226
                    LOG.warn("database format '%s' expected, but got '%s'" % (
 
227
                            DB_SCHEMA_VERSION, self.db.schema_version()))
 
228
                    if os.access(pathname, os.W_OK):
 
229
                        self._rebuild_and_reopen_local_db(pathname)
 
230
            except xapian.DatabaseOpeningError:
 
231
                # Couldn't use that folder as a database
 
232
                # This may be because we are in a bzr checkout and that
 
233
                #   folder is empty. If the folder is empty, and we can find the
 
234
                # script that does population, populate a database in it.
 
235
                if os.path.isdir(pathname) and not os.listdir(pathname):
227
236
                    self._rebuild_and_reopen_local_db(pathname)
228
 
        except xapian.DatabaseOpeningError:
229
 
            # Couldn't use that folder as a database
230
 
            # This may be because we are in a bzr checkout and that
231
 
            #   folder is empty. If the folder is empty, and we can find the
232
 
            # script that does population, populate a database in it.
233
 
            if os.path.isdir(pathname) and not os.listdir(pathname):
234
 
                self._rebuild_and_reopen_local_db(pathname)
235
 
        except xapian.DatabaseCorruptError:
236
 
            LOG.exception("xapian open failed")
237
 
            dialogs.error(None, 
238
 
                          _("Sorry, can not open the software database"),
239
 
                          _("Please re-install the 'software-center' "
240
 
                            "package."))
241
 
            # FIXME: force rebuild by providing a dbus service for this
242
 
            sys.exit(1)
 
237
            except xapian.DatabaseCorruptError:
 
238
                LOG.exception("xapian open failed")
 
239
                dialogs.error(None, 
 
240
                              _("Sorry, can not open the software database"),
 
241
                              _("Please re-install the 'software-center' "
 
242
                                "package."))
 
243
                # FIXME: force rebuild by providing a dbus service for this
 
244
                sys.exit(1)
243
245
 
244
246
        # additional icons come from app-install-data
245
 
        self.icons = get_sc_icon_theme(self.datadir)
 
247
        with ExecutionTime("building the icon cache"):
 
248
            self.icons = get_sc_icon_theme(self.datadir)
246
249
 
247
250
        # backend
248
 
        self.backend = get_install_backend()
249
 
        self.backend.ui = InstallBackendUI()
250
 
        self.backend.connect("transaction-finished", self._on_transaction_finished)
251
 
        self.backend.connect("channels-changed", self.on_channels_changed)
 
251
        with ExecutionTime("creating the backend"):
 
252
            self.backend = get_install_backend()
 
253
            self.backend.ui = InstallBackendUI()
 
254
            self.backend.connect("transaction-finished", self._on_transaction_finished)
 
255
            self.backend.connect("channels-changed", self.on_channels_changed)
252
256
 
253
257
        # high level app management
254
 
        self.app_manager = ApplicationManager(self.db, self.backend, self.icons)
 
258
        with ExecutionTime("get the app-manager"):
 
259
            self.app_manager = ApplicationManager(self.db, self.backend, self.icons)
255
260
 
256
261
        # misc state
257
262
        self._block_menuitem_view = False
276
281
                                 datadir)
277
282
 
278
283
        # register view manager and create view panes/widgets
279
 
        self.view_manager = ViewManager(self.notebook_view, options)
280
 
 
281
 
        self.global_pane = GlobalPane(self.view_manager, self.datadir, self.db, self.cache, self.icons)
282
 
        self.vbox1.pack_start(self.global_pane, False, False, 0)
283
 
        self.vbox1.reorder_child(self.global_pane, 1)
284
 
 
285
 
        # available pane
286
 
        self.available_pane = AvailablePane(self.cache,
 
284
        with ExecutionTime("ViewManager"):
 
285
            self.view_manager = ViewManager(self.notebook_view, options)
 
286
 
 
287
        with ExecutionTime("building panes"):
 
288
            self.global_pane = GlobalPane(self.view_manager, self.datadir, self.db, self.cache, self.icons)
 
289
            self.vbox1.pack_start(self.global_pane, False, False, 0)
 
290
            self.vbox1.reorder_child(self.global_pane, 1)
 
291
 
 
292
            # available pane
 
293
            self.available_pane = AvailablePane(self.cache,
 
294
                                                self.db,
 
295
                                                self.distro,
 
296
                                                self.icons,
 
297
                                                self.datadir,
 
298
                                                self.navhistory_back_action,
 
299
                                                self.navhistory_forward_action)
 
300
            self.available_pane.connect("available-pane-created", self.on_available_pane_created)
 
301
            self.view_manager.register(self.available_pane, ViewPages.AVAILABLE)
 
302
 
 
303
            # installed pane (view not fully initialized at this point)
 
304
            self.installed_pane = InstalledPane(self.cache,
 
305
                                                self.db, 
 
306
                                                self.distro,
 
307
                                                self.icons,
 
308
                                                self.datadir)
 
309
            #~ self.installed_pane.connect("installed-pane-created", self.on_installed_pane_created)
 
310
            self.view_manager.register(self.installed_pane, ViewPages.INSTALLED)
 
311
 
 
312
            # history pane (not fully loaded at this point)
 
313
            self.history_pane = HistoryPane(self.cache,
287
314
                                            self.db,
288
315
                                            self.distro,
289
316
                                            self.icons,
290
 
                                            self.datadir,
291
 
                                            self.navhistory_back_action,
292
 
                                            self.navhistory_forward_action)
293
 
        self.available_pane.connect("available-pane-created", self.on_available_pane_created)
294
 
        self.view_manager.register(self.available_pane, ViewPages.AVAILABLE)
295
 
 
296
 
        # installed pane (view not fully initialized at this point)
297
 
        self.installed_pane = InstalledPane(self.cache,
298
 
                                            self.db, 
299
 
                                            self.distro,
300
 
                                            self.icons,
301
317
                                            self.datadir)
302
 
        #~ self.installed_pane.connect("installed-pane-created", self.on_installed_pane_created)
303
 
        self.view_manager.register(self.installed_pane, ViewPages.INSTALLED)
304
 
 
305
 
        # history pane (not fully loaded at this point)
306
 
        self.history_pane = HistoryPane(self.cache,
307
 
                                        self.db,
308
 
                                        self.distro,
309
 
                                        self.icons,
310
 
                                        self.datadir)
311
 
        self.view_manager.register(self.history_pane, ViewPages.HISTORY)
312
 
 
313
 
        # pending pane
314
 
        self.pending_pane = PendingPane(self.icons)
315
 
        self.view_manager.register(self.pending_pane, ViewPages.PENDING)
 
318
            self.view_manager.register(self.history_pane, ViewPages.HISTORY)
 
319
 
 
320
            # pending pane
 
321
            self.pending_pane = PendingPane(self.icons)
 
322
            self.view_manager.register(self.pending_pane, ViewPages.PENDING)
316
323
 
317
324
        # TRANSLATORS: this is the help menuitem label, e.g. Ubuntu Software Center _Help
318
325
        self.menuitem_help.set_label(_("%s _Help")%self.distro.get_app_name())
321
328
        self.window_main.set_size_request(730, 470)
322
329
 
323
330
        # reviews
324
 
        self.review_loader = get_review_loader(self.cache, self.db)
325
 
        # FIXME: add some kind of throttle, I-M-S here
326
 
        self.review_loader.refresh_review_stats(self.on_review_stats_loaded)
327
 
        #load usefulness votes from server when app starts
328
 
        self.useful_cache = UsefulnessCache(True)
329
 
        self.setup_database_rebuilding_listener()
 
331
        with ExecutionTime("create review loader"):
 
332
            self.review_loader = get_review_loader(self.cache, self.db)
 
333
            # FIXME: add some kind of throttle, I-M-S here
 
334
            self.review_loader.refresh_review_stats(self.on_review_stats_loaded)
 
335
            #load usefulness votes from server when app starts
 
336
            self.useful_cache = UsefulnessCache(True)
 
337
            self.setup_database_rebuilding_listener()
330
338
 
331
 
        # open plugin manager and load plugins
332
 
        self.plugin_manager = PluginManager(self, SOFTWARE_CENTER_PLUGIN_DIRS)
333
 
        self.plugin_manager.load_plugins()
 
339
        with ExecutionTime("create plugin manager"):
 
340
            # open plugin manager and load plugins
 
341
            self.plugin_manager = PluginManager(self, SOFTWARE_CENTER_PLUGIN_DIRS)
 
342
            self.plugin_manager.load_plugins()
334
343
 
335
344
        # setup window name and about information (needs branding)
336
345
        name = self.distro.get_app_name()
384
393
            if not (options.enable_lp or och):
385
394
                file_menu.remove(self.builder.get_object("separator_login"))
386
395
        else:
387
 
            sc_agent_update = os.path.join(
388
 
                self.datadir, "update-software-center-agent")
389
 
            (pid, stdin, stdout, stderr) = GObject.spawn_async(
390
 
                [sc_agent_update, "--datadir", datadir], 
391
 
                flags=GObject.SPAWN_DO_NOT_REAP_CHILD)
392
 
            GObject.child_watch_add(
393
 
                pid, self._on_update_software_center_agent_finished)
 
396
            with ExecutionTime("run update-software-center-agent"):
 
397
                sc_agent_update = os.path.join(
 
398
                    self.datadir, "update-software-center-agent")
 
399
                (pid, stdin, stdout, stderr) = GObject.spawn_async(
 
400
                    [sc_agent_update, "--datadir", datadir], 
 
401
                    flags=GObject.SPAWN_DO_NOT_REAP_CHILD)
 
402
                GObject.child_watch_add(
 
403
                    pid, self._on_update_software_center_agent_finished)
394
404
 
395
405
        # TODO: Remove the following two lines once we have remove repository
396
406
        #       support in aptdaemon (see LP: #723911)
1223
1233
        self.show_available_packages(args)
1224
1234
 
1225
1235
        atexit.register(self.save_state)
1226
 
        SimpleGtkbuilderApp.run(self)