[Rigo] use context manager with Entropy.rwsem()

2013-12-06 15:38:24 +01:00
parent 7378906396
commit b7eeb5ce8a
6 changed files with 142 additions and 297 deletions
--- a/rigo/rigo/controllers/daemon.py
+++ b/rigo/rigo/controllers/daemon.py
@@ -945,14 +945,11 @@ class RigoServiceController(GObject.Object):

        if self._nc is not None:

-            self._entropy.rwsem().reader_acquire()
-            try:
+            with self._entropy.rwsem().reader():
                def _key_func(x):
                    return self._entropy.open_repository(
                        x[1]).retrieveName(x[0]).lower()
                update.sort(key=_key_func)
-            finally:
-                self._entropy.rwsem().reader_release()

            def _on_upgrade(box):
                self._nc.remove(box)
@@ -1028,12 +1025,9 @@ class RigoServiceController(GObject.Object):

        if self._confc is not None and self._nc is not None:

-            self._entropy.rwsem().reader_acquire()
-            try:
-                repository_id = self._entropy.installed_repository(
-                    ).repository_id()
-            finally:
-                self._entropy.rwsem().reader_release()
+            with self._entropy.rwsem().reader():
+                inst_repo = self._entropy.installed_repository()
+                repository_id = inst_repo.repository_id()

            config_updates = []
            for root, source, dest, pkg_ids, auto in updates:
@@ -1061,12 +1055,9 @@ class RigoServiceController(GObject.Object):
            "%s, normal: %s" % (
                manual_package_ids, package_ids))

-        self._entropy.rwsem().reader_acquire()
-        try:
-            repository_id = self._entropy.installed_repository(
-                ).repository_id()
-        finally:
-            self._entropy.rwsem().reader_release()
+        with self._entropy.rwsem().reader():
+            inst_repo = self._entropy.installed_repository()
+            repository_id = inst_repo.repository_id()

        if manual_package_ids or package_ids:
            manual_apps = []
@@ -1121,11 +1112,8 @@ class RigoServiceController(GObject.Object):
        # so that Entropy.repositories() and other internal
        # metadata is consistent with the newly available
        # repositories.
-        self._entropy.rwsem().writer_acquire()
-        try:
+        with self._entropy.rwsem().writer():
            self._entropy._validate_repositories()
-        finally:
-            self._entropy.rwsem().writer_release()

        local_activity = LocalActivityStates.UPDATING_REPOSITORIES
        # we don't expect to fail here, it would
@@ -1627,12 +1615,8 @@ class RigoServiceController(GObject.Object):
        """
        Return the Entropy Package Groups object.
        """
-        self._entropy.rwsem().reader_acquire()
-        try:
-            groups = self._entropy.get_package_groups()
-            return groups
-        finally:
-            self._entropy.rwsem().reader_release()
+        with self._entropy.rwsem().reader():
+            return self._entropy.get_package_groups()

    def list_repositories(self):
        """
@@ -1640,8 +1624,8 @@ class RigoServiceController(GObject.Object):
        repository_id. Each list item is a tuple composed by
        (repository_id, description, enabled/disabled)
        """
-        self._entropy.rwsem().reader_acquire()
-        try:
+        with self._entropy.rwsem().reader():
+
            settings = self._entropy.Settings()
            repo_data = settings['repositories']
            available = repo_data['available']
@@ -1657,8 +1641,6 @@ class RigoServiceController(GObject.Object):

            repositories.sort(key=lambda x: x[0])
            return repositories
-        finally:
-            self._entropy.rwsem().reader_release()

    def enable_repository(self, repository_id):
        """
@@ -1971,8 +1953,7 @@ class RigoServiceController(GObject.Object):
        """
        Release all the local package file repositories.
        """
-        self._entropy.rwsem().writer_acquire()
-        try:
+        with self._entropy.rwsem().writer():
            while True:
                try:
                    repository_id = self._package_repositories.popleft()
@@ -1980,8 +1961,6 @@ class RigoServiceController(GObject.Object):
                    break
                self._entropy.remove_repository(
                    repository_id)
-        finally:
-            self._entropy.rwsem().writer_release()

    def _release_local_resources(self, clear_avc=True,
                                 clear_avc_silent=False,
@@ -1992,8 +1971,8 @@ class RigoServiceController(GObject.Object):
        For example, leaving EntropyRepository objects open
        would cause sqlite3 to deadlock.
        """
-        self._entropy.rwsem().writer_acquire()
-        try:
+        with self._entropy.rwsem().writer():
+
            if clear_avc and self._avc is not None:
                if clear_avc_silent:
                    self._avc.clear_silent_safe()
@@ -2002,8 +1981,6 @@ class RigoServiceController(GObject.Object):
            self._entropy.close_repositories()
            if clear_callback is not None:
                clear_callback()
-        finally:
-            self._entropy.rwsem().writer_release()

    def _please_wait(self, show):
        """
@@ -2614,23 +2591,21 @@ class RigoServiceController(GObject.Object):
        """
        Forward Application Package Install request to RigoDaemon.
        """
-        self._entropy.rwsem().writer_acquire()
-        try:
-            package_matches = self._entropy.add_package_repository(
-                package_path)
-        except EntropyPackageException as exc:
-            def _notify():
-                msg = _("Package Install Error: <i>%s</i>") % (exc,)
-                box = self.ServiceNotificationBox(
-                    prepare_markup(msg),
-                    Gtk.MessageType.ERROR,
-                    context_id=self.PKG_INSTALL_CONTEXT_ID)
-                box.add_destroy_button(_("Okay"))
-                self._nc.append(box)
-            GLib.idle_add(_notify)
-            return
-        finally:
-            self._entropy.rwsem().writer_release()
+        with self._entropy.rwsem().writer():
+            try:
+                package_matches = self._entropy.add_package_repository(
+                    package_path)
+            except EntropyPackageException as exc:
+                def _notify():
+                    msg = _("Package Install Error: <i>%s</i>") % (exc,)
+                    box = self.ServiceNotificationBox(
+                        prepare_markup(msg),
+                        Gtk.MessageType.ERROR,
+                        context_id=self.PKG_INSTALL_CONTEXT_ID)
+                    box.add_destroy_button(_("Okay"))
+                    self._nc.append(box)
+                GLib.idle_add(_notify)
+                return

        accepted = False
        accepted_count = 0
@@ -2648,13 +2623,10 @@ class RigoServiceController(GObject.Object):
            accepted_count += 1

        if accepted_count == 0:
-            self._entropy.rwsem().writer_acquire()
-            try:
+            with self._entropy.rwsem().writer():
                for repository_id in repository_ids:
                    self._entropy.remove_repository(
                        repository_id)
-            finally:
-                self._entropy.rwsem().writer_release()
        else:
            for repository_id in repository_ids:
                self._package_repositories.append(
@@ -2763,8 +2735,8 @@ class RigoServiceController(GObject.Object):
        Examine Applications that are going to be upgraded looking for
        licenses to read and accept.
        """
-        self._entropy.rwsem().reader_acquire()
-        try:
+        with self._entropy.rwsem().reader():
+
            outcome = self._entropy.calculate_updates()

            update = outcome['update']
@@ -2775,9 +2747,6 @@ class RigoServiceController(GObject.Object):
            if not licenses:
                return True

-        finally:
-            self._entropy.rwsem().reader_release()
-
        license_map = {}
        for lic_id, pkg_matches in licenses.items():
            obj = license_map.setdefault(lic_id, [])
--- a/rigo/rigo/models/application.py
+++ b/rigo/rigo/models/application.py
@@ -975,8 +975,7 @@ class Application(object):
    @property
    def name(self):
        """Show user visible name"""
-        self._entropy.rwsem().reader_acquire()
-        try:
+        with self._entropy.rwsem().reader():
            repo = self._entropy.open_repository(self._repo_id)
            name = repo.retrieveName(self._pkg_id)
            if name is None:
@@ -986,8 +985,6 @@ class Application(object):
            name = " ".join([x.capitalize() for x in \
                                 name.replace("-"," ").split()])
            return escape_markup(name)
-        finally:
-            self._entropy.rwsem().reader_release()

    @property
    def path(self):
@@ -1018,11 +1015,8 @@ class Application(object):
        Return whether this Application object describes an
        Installed one.
        """
-        self._entropy.rwsem().reader_acquire()
-        try:
+        with self._entropy.rwsem().reader():
            return self._is_installed_app()
-        finally:
-            self._entropy.rwsem().reader_release()

    def _is_installed_app(self):
        """
@@ -1086,19 +1080,15 @@ class Application(object):
        application (rather than the available one), or
        None if not installed.
        """
-        self._entropy.rwsem().reader_acquire()
-        try:
+        with self._entropy.rwsem().reader():
            return self._get_installed()
-        finally:
-            self._entropy.rwsem().reader_release()

    def is_updatable(self):
        """
        Return if Application can be updated.
        With "updated" we also mean "downgraded".
        """
-        self._entropy.rwsem().reader_acquire()
-        try:
+        with self._entropy.rwsem().reader():
            inst_repo = self._entropy.installed_repository()
            repo = self._entropy.open_repository(self._repo_id)
            if repo is inst_repo:
@@ -1117,8 +1107,6 @@ class Application(object):
                return False
            else:
                return True
-        finally:
-            self._entropy.rwsem().reader_release()

    def _get_removal_queue(self):
        """
@@ -1136,8 +1124,7 @@ class Application(object):
        Please note that if the Application is not removable,
        None is returned.
        """
-        self._entropy.rwsem().reader_acquire()
-        try:
+        with self._entropy.rwsem().reader():
            queue = self._get_removal_queue()
            if queue is None:
                return None
@@ -1148,8 +1135,6 @@ class Application(object):
                    self._service, pkg_match)
                remove.append(app)
            return remove
-        finally:
-            self._entropy.rwsem().reader_release()

    def is_removable(self):
        """
@@ -1160,8 +1145,7 @@ class Application(object):
        if installed is not self:
            return installed.is_removable()

-        self._entropy.rwsem().reader_acquire()
-        try:
+        with self._entropy.rwsem().reader():
            removable = self._entropy.validate_package_removal(
                self._pkg_id)
            if removable:
@@ -1172,8 +1156,6 @@ class Application(object):
                return True
            except DependenciesNotRemovable:
                return False
-        finally:
-            self._entropy.rwsem().reader_release()

    def _get_install_queue(self):
        """
@@ -1206,31 +1188,28 @@ class Application(object):
        Apps that would need to be removed of this Application
        is installed.
        """
-        self._entropy.rwsem().reader_acquire()
-        try:
+        with self._entropy.rwsem().reader():
+            try:
+                apps = []
+                queues = self._get_install_queue()
+                if queues is None:
+                    return apps
+                install, removal = queues
+                del install

-            apps = []
-            queues = self._get_install_queue()
-            if queues is None:
+                inst_repo = self._entropy.installed_repository()
+                inst_repo_id = inst_repo.repository_id()
+                for inst_pkg_id in removal:
+                    app = Application(
+                        self._entropy, self._entropy_ws,
+                        self._service, (inst_pkg_id, inst_repo_id))
+                    apps.append(app)
                return apps
-            install, removal = queues
-            del install

-            inst_repo = self._entropy.installed_repository()
-            inst_repo_id = inst_repo.repository_id()
-            for inst_pkg_id in removal:
-                app = Application(
-                    self._entropy, self._entropy_ws,
-                    self._service, (inst_pkg_id, inst_repo_id))
-                apps.append(app)
-            return apps
-
-        except DependenciesNotFound:
-            return None
-        except DependenciesCollision:
-            return None
-        finally:
-            self._entropy.rwsem().reader_release()
+            except DependenciesNotFound:
+                return None
+            except DependenciesCollision:
+                return None

    def get_install_queue(self):
        """
@@ -1241,42 +1220,40 @@ class Application(object):
        None is returned.
        """
        app_install, app_remove = [], []
-        self._entropy.rwsem().reader_acquire()
-        try:
-            queues = self._get_install_queue()
-            if queues is None:
+        with self._entropy.rwsem().reader():
+
+            try:
+                queues = self._get_install_queue()
+                if queues is None:
+                    return None
+                install, removal = queues
+
+                for pkg_match in install:
+                    app = Application(
+                        self._entropy, self._entropy_ws,
+                        self._service, pkg_match)
+                    app_install.append(app)
+
+                inst_repo = self._entropy.installed_repository()
+                inst_repo_id = inst_repo.repository_id()
+                for inst_pkg_id in removal:
+                    app = Application(
+                        self._entropy, self._entropy_ws,
+                        self._service, (inst_pkg_id, inst_repo_id))
+                    app_remove.append(app)
+
+                return app_install, app_remove
+
+            except DependenciesNotFound as err:
+                const_debug_write(
+                    __name__,
+                    "get_install_queue: DependenciesNotFound: %s" % (err,))
+                return None
+            except DependenciesCollision as err:
+                const_debug_write(
+                    __name__,
+                    "get_install_queue: DependenciesCollision: %s" % (err,))
                return None
-            install, removal = queues
-
-            for pkg_match in install:
-                app = Application(
-                    self._entropy, self._entropy_ws,
-                    self._service, pkg_match)
-                app_install.append(app)
-
-            inst_repo = self._entropy.installed_repository()
-            inst_repo_id = inst_repo.repository_id()
-            for inst_pkg_id in removal:
-                app = Application(
-                    self._entropy, self._entropy_ws,
-                    self._service, (inst_pkg_id, inst_repo_id))
-                app_remove.append(app)
-
-            return app_install, app_remove
-
-        except DependenciesNotFound as err:
-            const_debug_write(
-                __name__,
-                "get_install_queue: DependenciesNotFound: %s" % (err,))
-            return None
-        except DependenciesCollision as err:
-            const_debug_write(
-                __name__,
-                "get_install_queue: DependenciesCollision: %s" % (err,))
-            return None
-
-        finally:
-            self._entropy.rwsem().reader_release()

    def accept_licenses(self, install_queue):
        """
@@ -1285,8 +1262,7 @@ class Application(object):
        value.
        """
        pkg_map = dict((x.get_details().pkg, x) for x in install_queue)
-        self._entropy.rwsem().reader_acquire()
-        try:
+        with self._entropy.rwsem().reader():
            license_map = {}
            licenses = self._entropy.get_licenses_to_accept(
                list(pkg_map.keys()))
@@ -1296,33 +1272,28 @@ class Application(object):
                    for pkg_match in pkg_matches:
                        obj.append(pkg_map[pkg_match])
            return license_map
-        finally:
-            self._entropy.rwsem().reader_release()

    def is_installable(self):
        """
        Return if Application can be installed or it's masked
        or one of its dependencies are.
        """
-        self._entropy.rwsem().reader_acquire()
-        try:
-            queues = self._get_install_queue()
-            if queues is None:
+        with self._entropy.rwsem().reader():
+            try:
+                queues = self._get_install_queue()
+                if queues is None:
+                    return False
+                install, removal = queues
+
+                # check licenses
+                license_map = self.accept_licenses(install)
+                if license_map:
+                    raise Application.AcceptLicenseError(license_map)
+
+            except DependenciesNotFound:
+                return False
+            except DependenciesCollision:
                return False
-            install, removal = queues
-
-            # check licenses
-            license_map = self.accept_licenses(install)
-            if license_map:
-                raise Application.AcceptLicenseError(license_map)
-
-        except DependenciesNotFound:
-            return False
-        except DependenciesCollision:
-            return False
-
-        finally:
-            self._entropy.rwsem().reader_release()

        return True

@@ -1333,20 +1304,16 @@ class Application(object):
        The actual semantics of this method in softwarecenter
        seems quite ambiguous to me.
        """
-        self._entropy.rwsem().reader_acquire()
-        try:
+        with self._entropy.rwsem().reader():
            repo = self._entropy.open_repository(self._repo_id)
            return repo.isPackageIdAvailable(self._pkg_id)
-        finally:
-            self._entropy.rwsem().reader_release()

    def get_markup(self):
        """
        Get Application markup text.
        """
        name = self.name
-        self._entropy.rwsem().reader_acquire()
-        try:
+        with self._entropy.rwsem().reader():
            repo = self._entropy.open_repository(self._repo_id)
            if self._vanished_callback is not None:
                if not repo.isPackageIdAvailable(self._pkg_id):
@@ -1371,8 +1338,6 @@ class Application(object):
                escape_markup(tag),
                escape_markup(description))
            return text
-        finally:
-            self._entropy.rwsem().reader_release()

    def search(self, keyword):
        """
@@ -1388,8 +1353,7 @@ class Application(object):
        """
        Get Application markup text (extended version).
        """
-        self._entropy.rwsem().reader_acquire()
-        try:
+        with self._entropy.rwsem().reader():
            repo = self._entropy.open_repository(self._repo_id)
            if self._vanished_callback is not None:
                if not repo.isPackageIdAvailable(self._pkg_id):
@@ -1457,8 +1421,6 @@ class Application(object):
                    installed_str,
                    )
            return text
-        finally:
-            self._entropy.rwsem().reader_release()

    def get_info_markup(self):
        """
@@ -1466,8 +1428,7 @@ class Application(object):
        """
        app_store_url = build_application_store_url(self, "")

-        self._entropy.rwsem().reader_acquire()
-        try:
+        with self._entropy.rwsem().reader():
            lic_url = "%s/license/" % (etpConst['packages_website_url'],)
            repo = self._entropy.open_repository(self._repo_id)

@@ -1572,8 +1533,6 @@ class Application(object):
                more_txt,
                )
            return text
-        finally:
-            self._entropy.rwsem().reader_release()

    def get_review_stats(self, _still_visible_cb=None, cached=False):
        """
@@ -1581,8 +1540,7 @@ class Application(object):
        information about this Application, like
        votes and number of downloads.
        """
-        self._entropy.rwsem().reader_acquire()
-        try:
+        with self._entropy.rwsem().reader():
            stat = ReviewStats(self)
            stat.ratings_average = ReviewStats.NO_RATING

@@ -1612,8 +1570,6 @@ class Application(object):
                # otherwise 0 is shown
                stat.downloads_total = down
            return stat
-        finally:
-            self._entropy.rwsem().reader_release()

    def get_icon(self, _still_visible_cb=None, cached=False):
        """
@@ -1623,8 +1579,7 @@ class Application(object):
        by the Document object (or None) and cache hit information
        (True if got from local cache, False if not in local cache)
        """
-        self._entropy.rwsem().reader_acquire()
-        try:
+        with self._entropy.rwsem().reader():
            repo = self._entropy.open_repository(self._repo_id)
            key_slot = repo.retrieveKeySlot(self._pkg_id)
            if key_slot is None:
@@ -1650,8 +1605,6 @@ class Application(object):
                        icon, cache_hit))

            return icon, cache_hit
-        finally:
-            self._entropy.rwsem().reader_release()

    def download_comments(self, callback, offset=0):
        """
@@ -1659,8 +1612,7 @@ class Application(object):
        In case of missing comments (locally), None is returned.
        The actual outcome of this method is a DocumentList object.
        """
-        self._entropy.rwsem().reader_acquire()
-        try:
+        with self._entropy.rwsem().reader():
            repo = self._entropy.open_repository(self._repo_id)
            key_slot = repo.retrieveKeySlot(self._pkg_id)
            if key_slot is None:
@@ -1679,8 +1631,6 @@ class Application(object):
                const_debug_write(__name__,
                    "Application{%s}.download_comments called" % (
                        self._pkg_match,))
-        finally:
-            self._entropy.rwsem().reader_release()

    def download_images(self, callback, offset=0):
        """
@@ -1688,8 +1638,7 @@ class Application(object):
        In case of missing comments (locally), None is returned.
        The actual outcome of this method is a DocumentList object.
        """
-        self._entropy.rwsem().reader_acquire()
-        try:
+        with self._entropy.rwsem().reader():
            repo = self._entropy.open_repository(self._repo_id)
            key_slot = repo.retrieveKeySlot(self._pkg_id)
            if key_slot is None:
@@ -1708,8 +1657,6 @@ class Application(object):
                const_debug_write(__name__,
                    "Application{%s}.download_images called" % (
                        self._pkg_match,))
-        finally:
-            self._entropy.rwsem().reader_release()

    def is_webservice_available(self):
        """
@@ -1754,13 +1701,10 @@ class Application(object):
                          redraw_callback=self._redraw_callback)

    def __str__(self):
-        self._entropy.rwsem().reader_acquire()
-        try:
+        with self._entropy.rwsem().reader():
            repo = self._entropy.open_repository(self._repo_id)
            atom = repo.retrieveAtom(self._pkg_id)
            return "(%s: %s)" % (self._pkg_match, atom)
-        finally:
-            self._entropy.rwsem().reader_release()

    def __repr__(self):
        return str(self)
@@ -1800,24 +1744,18 @@ class AppDetails(object):
        Application, the Channel of the original repository shall
        be returned).
        """
-        self._entropy.rwsem().reader_acquire()
-        try:
+        with self._entropy.rwsem().reader():
            repo = self._entropy.open_repository(self._repo_id)
            return self._app._source_repository_id(repo)
-        finally:
-            self._entropy.rwsem().reader_release()

    @property
    def description(self):
        """
        Return Application short description.
        """
-        self._entropy.rwsem().reader_acquire()
-        try:
+        with self._entropy.rwsem().reader():
            repo = self._entropy.open_repository(self._repo_id)
            return repo.retrieveDescription(self._pkg_id)
-        finally:
-            self._entropy.rwsem().reader_release()

    @property
    def error(self):
@@ -1829,8 +1767,7 @@ class AppDetails(object):
        Return human readable representation of the installation
        date, if installed, or None otherwise.
        """
-        self._entropy.rwsem().reader_acquire()
-        try:
+        with self._entropy.rwsem().reader():
            repo = self._entropy.open_repository(self._repo_id)
            inst_repo = self._entropy.installed_repository()
            if repo is inst_repo:
@@ -1841,8 +1778,6 @@ class AppDetails(object):
            if pkg_id != -1:
                return entropy.tools.convert_unix_time_to_human_time(
                    float(inst_repo.retrieveCreationDate(pkg_id)))
-        finally:
-            self._entropy.rwsem().reader_release()

    @property
    def date(self):
@@ -1850,52 +1785,41 @@ class AppDetails(object):
        Return human readable representation of the date the
        Application has been last updated.
        """
-        self._entropy.rwsem().reader_acquire()
-        try:
+        with self._entropy.rwsem().reader():
            repo = self._entropy.open_repository(self._repo_id)
            return entropy.tools.convert_unix_time_to_human_time(
                float(repo.retrieveCreationDate(self._pkg_id)))
-        finally:
-            self._entropy.rwsem().reader_release()

    @property
    def licenses(self):
        """
        Return list of license identifiers for Application.
        """
-        self._entropy.rwsem().reader_acquire()
-        try:
+        with self._entropy.rwsem().reader():
            repo = self._entropy.open_repository(self._repo_id)
            licenses = repo.retrieveLicense(self._pkg_id)
            if not licenses:
                return []
            return licenses.split()
-        finally:
-            self._entropy.rwsem().reader_release()

    @property
    def downsize(self):
        """
        Return the download size in bytes.
        """
-        self._entropy.rwsem().reader_acquire()
-        try:
+        with self._entropy.rwsem().reader():
            repo = self._entropy.open_repository(self._repo_id)
            return repo.retrieveSize(self._pkg_id)
-        finally:
-            self._entropy.rwsem().reader_release()

    @property
    def disksize(self):
        """
        Return the disk size in bytes.
        """
-        self._entropy.rwsem().reader_acquire()
-        try:
+        with self._entropy.rwsem().reader():
            repo = self._entropy.open_repository(self._repo_id)
            return repo.retrieveOnDiskSize(self._pkg_id)
-        finally:
-            self._entropy.rwsem().reader_release()
+

    @property
    def humansize(self):
@@ -1940,37 +1864,28 @@ class AppDetails(object):
        """
        Return unmangled package name belonging to this Application.
        """
-        self._entropy.rwsem().reader_acquire()
-        try:
+        with self._entropy.rwsem().reader():
            repo = self._entropy.open_repository(self._repo_id)
            return repo.retrieveName(self._pkg_id)
-        finally:
-            self._entropy.rwsem().reader_release()

    @property
    def fullname(self):
        """
        Return unmangled package name belonging to this Application.
        """
-        self._entropy.rwsem().reader_acquire()
-        try:
+        with self._entropy.rwsem().reader():
            repo = self._entropy.open_repository(self._repo_id)
            return repo.retrieveAtom(self._pkg_id)
-        finally:
-            self._entropy.rwsem().reader_release()

    @property
    def pkgkey(self):
        """
        Return unmangled package key name belonging to this Application.
        """
-        self._entropy.rwsem().reader_acquire()
-        try:
+        with self._entropy.rwsem().reader():
            repo = self._entropy.open_repository(self._repo_id)
            key, slot = repo.retrieveKeySlot(self._pkg_id)
            return key
-        finally:
-            self._entropy.rwsem().reader_release()

    @property
    def signing_key_id(self):
@@ -1984,11 +1899,8 @@ class AppDetails(object):
        """
        Return Application version (without revision and tag).
        """
-        self._entropy.rwsem().reader_acquire()
-        try:
+        with self._entropy.rwsem().reader():
            return self._version
-        finally:
-            self._entropy.rwsem().reader_release()

    @property
    def _version(self):
@@ -2007,9 +1919,6 @@ class AppDetails(object):
        """
        Return Application official Website URL or None.
        """
-        self._entropy.rwsem().reader_acquire()
-        try:
+        with self._entropy.rwsem().reader():
            repo = self._entropy.open_repository(self._repo_id)
            return repo.retrieveHomepage(self._pkg_id)
-        finally:
-            self._entropy.rwsem().reader_release()
--- a/rigo/rigo/ui/gtk3/controllers/application.py
+++ b/rigo/rigo/ui/gtk3/controllers/application.py
@@ -590,11 +590,8 @@ class ApplicationViewController(GObject.Object):
        """
        Logout from any configured repository.
        """
-        self._entropy.rwsem().reader_acquire()
-        try:
+        with self._entropy.rwsem().reader():
            repositories = self._entropy.repositories()
-        finally:
-            self._entropy.rwsem().reader_release()

        for repository in repositories:
            webserv = self._entropy_ws.get(repository)
--- a/rigo/rigo/ui/gtk3/controllers/applications.py
+++ b/rigo/rigo/ui/gtk3/controllers/applications.py
@@ -171,10 +171,7 @@ class ApplicationsViewController(GObject.Object):
        search_cmd, search_args = split_text[0], split_text[1:]
        sort = False

-        show_exact = search_cmd == ApplicationsViewController.SHOW_EXACT_MATCH
-
-        self._entropy.rwsem().reader_acquire()
-        try:
+        with self._entropy.rwsem().reader():
            matches = []
            use_fallback = True

@@ -246,8 +243,6 @@ class ApplicationsViewController(GObject.Object):
            if sort:
                matches.sort(key=self._sort_key)
            return matches
-        finally:
-            self._entropy.rwsem().reader_release()

    def install(self, dependency, simulate=False):
        """
@@ -257,11 +252,9 @@ class ApplicationsViewController(GObject.Object):
        const_debug_write(
            __name__,
            "install: %s" % (dependency,))
-        self._entropy.rwsem().reader_acquire()
-        try:
+
+        with self._entropy.rwsem().reader():
            pkg_match = self._entropy.atom_match(dependency)
-        finally:
-            self._entropy.rwsem().reader_release()

        pkg_id, pkg_repo = pkg_match
        if pkg_id == -1:
@@ -317,13 +310,11 @@ class ApplicationsViewController(GObject.Object):
        const_debug_write(
            __name__,
            "remove: %s" % (dependency,))
-        self._entropy.rwsem().reader_acquire()
-        try:
+
+        with self._entropy.rwsem().reader():
            inst_repo = self._entropy.installed_repository()
            pkg_repo = inst_repo.repository_id()
            pkg_id, rc = inst_repo.atomMatch(dependency)
-        finally:
-            self._entropy.rwsem().reader_release()

        if pkg_id == -1:
            const_debug_write(
@@ -382,16 +373,13 @@ class ApplicationsViewController(GObject.Object):
                    " %s" % (app,))
                matches.append(app.get_details().pkg)
        else:
-            self._entropy.rwsem().reader_acquire()
-            try:
+            with self._entropy.rwsem().reader():
                inst_repo = self._entropy.installed_repository()
                repo_name = inst_repo.repository_id()
                matches.extend(
                    [(-2, repo_name),
                     (-5, repo_name),
                     (-10, repo_name)])
-            finally:
-                self._entropy.rwsem().reader_release()

        if matches:
            self.set_many_safe(matches,
@@ -403,13 +391,10 @@ class ApplicationsViewController(GObject.Object):
            __name__,
            "__simulate_orphaned_apps: "
            "%s" % (text,))
-        self._entropy.rwsem().reader_acquire()
-        try:
+        with self._entropy.rwsem().reader():
            inst_repo = self._entropy.installed_repository()
            pkg_ids = inst_repo.searchPackages(text, just_id=True)
            manual_pkg_ids, rc = inst_repo.atomMatch(text, multiMatch=True)
-        finally:
-            self._entropy.rwsem().reader_release()

        def _notify():
            self._service._unsupported_applications_signal(
@@ -479,11 +464,8 @@ class ApplicationsViewController(GObject.Object):
                self.remove(sim_str)

        def _do_optimize_mirrors():
-            self._entropy.rwsem().reader_acquire()
-            try:
+            with self._entropy.rwsem().reader():
                repository_ids = self._entropy.repositories()
-            finally:
-                self._entropy.rwsem().reader_release()
            self._service.optimize_mirrors(repository_ids)

        special_keys_map = {
@@ -561,8 +543,7 @@ class ApplicationsViewController(GObject.Object):
        Setup "not found" message label and layout
        """
        nf_box = self._not_found_box
-        self._entropy.rwsem().reader_acquire()
-        try:
+        with self._entropy.rwsem().reader():
            # now self._not_found_label is available
            meant_packages = self._entropy.get_meant_packages(
                search_text)
@@ -582,8 +563,6 @@ class ApplicationsViewController(GObject.Object):
                    prepare_markup(_("did you mean <a href=\"%s\">%s</a>?")) % (
                        escape_markup(name),
                        escape_markup(name),),)
-        finally:
-            self._entropy.rwsem().reader_release()

        self._not_found_label.set_markup(msg)

@@ -773,11 +752,8 @@ class ApplicationsViewController(GObject.Object):
        self._prefc.append(pref)

        def _optimize_mirrors():
-            self._entropy.rwsem().reader_acquire()
-            try:
+            with self._entropy.rwsem().reader():
                repository_ids = self._entropy.repositories()
-            finally:
-                self._entropy.rwsem().reader_release()
            self._service.optimize_mirrors(repository_ids)
        pref = Preference(
            50, _("Optimize Download Speed"),
--- a/rigo/rigo/ui/gtk3/controllers/notifications.py
+++ b/rigo/rigo/ui/gtk3/controllers/notifications.py
@@ -139,8 +139,7 @@ class UpperNotificationViewController(NotificationViewController):
        Execute connectivity check basing on Entropy
        Web Services availability.
        """
-        self._entropy.rwsem().reader_acquire()
-        try:
+        with self._entropy.rwsem().reader():
            repositories = self._entropy.repositories()
            available = False
            for repository_id in repositories:
@@ -153,8 +152,6 @@ class UpperNotificationViewController(NotificationViewController):

            if not available:
                GLib.idle_add(self._notify_connectivity_issues)
-        finally:
-            self._entropy.rwsem().reader_release()

    def _notify_connectivity_issues(self):
        """
--- a/rigo/rigo/ui/gtk3/widgets/notifications.py
+++ b/rigo/rigo/ui/gtk3/widgets/notifications.py
@@ -559,15 +559,12 @@ class LicensesNotificationBox(NotificationBox):
            if not repos:
                return

-            self._entropy.rwsem().reader_acquire()
-            try:
+            with self._entropy.rwsem().reader():
                for repo_id in repos:
                    repo = self._entropy.open_repository(repo_id)
                    license_text = repo.retrieveLicenseText(uri)
                    if license_text is not None:
                        break
-            finally:
-                self._entropy.rwsem().reader_release()

            if license_text is not None:
                tmp_fd, tmp_path = const_mkstemp(suffix=".txt")