caches: store computation time inside context manager as helper. Since the with block is full

calculation we can use it to calculate the function execution time.

rhodecode/apps/repository/views/repo_feed.py

@@ -1,244 +1,242 b''
 # -*- coding: utf-8 -*-
 
 # Copyright (C) 2017-2018 RhodeCode GmbH
 #
 # This program is free software: you can redistribute it and/or modify
 # it under the terms of the GNU Affero General Public License, version 3
 # (only), as published by the Free Software Foundation.
 #
 # This program is distributed in the hope that it will be useful,
 # but WITHOUT ANY WARRANTY; without even the implied warranty of
 # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 # GNU General Public License for more details.
 #
 # You should have received a copy of the GNU Affero General Public License
 # along with this program.  If not, see <http://www.gnu.org/licenses/>.
 #
 # This program is dual-licensed. If you wish to learn more about the
 # RhodeCode Enterprise Edition, including its added features, Support services,
 # and proprietary license terms, please see https://rhodecode.com/licenses/
-import time
 import pytz
 import logging
 
 from pyramid.view import view_config
 from pyramid.response import Response
 from webhelpers.feedgenerator import Rss201rev2Feed, Atom1Feed
 
 from rhodecode.apps._base import RepoAppView
 from rhodecode.lib import audit_logger
 from rhodecode.lib import rc_cache
 from rhodecode.lib import helpers as h
 from rhodecode.lib.auth import (
     LoginRequired, HasRepoPermissionAnyDecorator)
 from rhodecode.lib.diffs import DiffProcessor, LimitedDiffContainer
 from rhodecode.lib.utils2 import str2bool, safe_int, md5_safe
 from rhodecode.model.db import UserApiKeys, CacheKey
 
 log = logging.getLogger(__name__)
 
 
 class RepoFeedView(RepoAppView):
     def load_default_context(self):
         c = self._get_local_tmpl_context()
 
 
         self._load_defaults()
         return c
 
     def _get_config(self):
         import rhodecode
         config = rhodecode.CONFIG
 
         return {
             'language': 'en-us',
             'feed_ttl': '5',  # TTL of feed,
             'feed_include_diff':
                 str2bool(config.get('rss_include_diff', False)),
             'feed_items_per_page':
                 safe_int(config.get('rss_items_per_page', 20)),
             'feed_diff_limit':
                 # we need to protect from parsing huge diffs here other way
                 # we can kill the server
                 safe_int(config.get('rss_cut_off_limit', 32 * 1024)),
         }
 
     def _load_defaults(self):
         _ = self.request.translate
         config = self._get_config()
         # common values for feeds
         self.description = _('Changes on %s repository')
         self.title = self.title = _('%s %s feed') % (self.db_repo_name, '%s')
         self.language = config["language"]
         self.ttl = config["feed_ttl"]
         self.feed_include_diff = config['feed_include_diff']
         self.feed_diff_limit = config['feed_diff_limit']
         self.feed_items_per_page = config['feed_items_per_page']
 
     def _changes(self, commit):
         diff_processor = DiffProcessor(
             commit.diff(), diff_limit=self.feed_diff_limit)
         _parsed = diff_processor.prepare(inline_diff=False)
         limited_diff = isinstance(_parsed, LimitedDiffContainer)
 
         return diff_processor, _parsed, limited_diff
 
     def _get_title(self, commit):
         return h.shorter(commit.message, 160)
 
     def _get_description(self, commit):
         _renderer = self.request.get_partial_renderer(
             'rhodecode:templates/feed/atom_feed_entry.mako')
         diff_processor, parsed_diff, limited_diff = self._changes(commit)
         filtered_parsed_diff, has_hidden_changes = self.path_filter.filter_patchset(parsed_diff)
         return _renderer(
             'body',
             commit=commit,
             parsed_diff=filtered_parsed_diff,
             limited_diff=limited_diff,
             feed_include_diff=self.feed_include_diff,
             diff_processor=diff_processor,
             has_hidden_changes=has_hidden_changes
         )
 
     def _set_timezone(self, date, tzinfo=pytz.utc):
         if not getattr(date, "tzinfo", None):
             date.replace(tzinfo=tzinfo)
         return date
 
     def _get_commits(self):
         return list(self.rhodecode_vcs_repo[-self.feed_items_per_page:])
 
     def uid(self, repo_id, commit_id):
         return '{}:{}'.format(md5_safe(repo_id), md5_safe(commit_id))
 
     @LoginRequired(auth_token_access=[UserApiKeys.ROLE_FEED])
     @HasRepoPermissionAnyDecorator(
         'repository.read', 'repository.write', 'repository.admin')
     @view_config(
         route_name='atom_feed_home', request_method='GET',
         renderer=None)
     def atom(self):
         """
         Produce an atom-1.0 feed via feedgenerator module
         """
         self.load_default_context()
 
         cache_namespace_uid = 'cache_repo_instance.{}_{}'.format(
             self.db_repo.repo_id, CacheKey.CACHE_TYPE_FEED)
         invalidation_namespace = CacheKey.REPO_INVALIDATION_NAMESPACE.format(
             repo_id=self.db_repo.repo_id)
 
         region = rc_cache.get_or_create_region('cache_repo_longterm',
                                                cache_namespace_uid)
 
         condition = not self.path_filter.is_enabled
 
         @region.conditional_cache_on_arguments(namespace=cache_namespace_uid,
                                                condition=condition)
         def generate_atom_feed(repo_id, _repo_name, _feed_type):
             feed = Atom1Feed(
                 title=self.title % _repo_name,
                 link=h.route_url('repo_summary', repo_name=_repo_name),
                 description=self.description % _repo_name,
                 language=self.language,
                 ttl=self.ttl
             )
 
             for commit in reversed(self._get_commits()):
                 date = self._set_timezone(commit.date)
                 feed.add_item(
                     unique_id=self.uid(repo_id, commit.raw_id),
                     title=self._get_title(commit),
                     author_name=commit.author,
                     description=self._get_description(commit),
                     link=h.route_url(
                         'repo_commit', repo_name=_repo_name,
                         commit_id=commit.raw_id),
                     pubdate=date,)
 
             return feed.mime_type, feed.writeString('utf-8')
 
-        start = time.time()
         inv_context_manager = rc_cache.InvalidationContext(
             uid=cache_namespace_uid, invalidation_namespace=invalidation_namespace)
         with inv_context_manager as invalidation_context:
             # check for stored invalidation signal, and maybe purge the cache
             # before computing it again
             if invalidation_context.should_invalidate():
                 generate_atom_feed.invalidate(
                     self.db_repo.repo_id, self.db_repo.repo_name, 'atom')
 
             mime_type, feed = generate_atom_feed(
                 self.db_repo.repo_id, self.db_repo.repo_name, 'atom')
-            compute_time = time.time() - start
-            log.debug('Repo ATOM feed computed in %.3fs', compute_time)
+
+            log.debug('Repo ATOM feed computed in %.3fs',
+                      inv_context_manager.compute_time)
 
         response = Response(feed)
         response.content_type = mime_type
         return response
 
     @LoginRequired(auth_token_access=[UserApiKeys.ROLE_FEED])
     @HasRepoPermissionAnyDecorator(
         'repository.read', 'repository.write', 'repository.admin')
     @view_config(
         route_name='rss_feed_home', request_method='GET',
         renderer=None)
     def rss(self):
         """
         Produce an rss2 feed via feedgenerator module
         """
         self.load_default_context()
 
         cache_namespace_uid = 'cache_repo_instance.{}_{}'.format(
             self.db_repo.repo_id, CacheKey.CACHE_TYPE_FEED)
         invalidation_namespace = CacheKey.REPO_INVALIDATION_NAMESPACE.format(
             repo_id=self.db_repo.repo_id)
         region = rc_cache.get_or_create_region('cache_repo_longterm',
                                                cache_namespace_uid)
 
         condition = not self.path_filter.is_enabled
 
         @region.conditional_cache_on_arguments(namespace=cache_namespace_uid,
                                                condition=condition)
         def generate_rss_feed(repo_id, _repo_name, _feed_type):
             feed = Rss201rev2Feed(
                 title=self.title % _repo_name,
                 link=h.route_url('repo_summary', repo_name=_repo_name),
                 description=self.description % _repo_name,
                 language=self.language,
                 ttl=self.ttl
             )
 
             for commit in reversed(self._get_commits()):
                 date = self._set_timezone(commit.date)
                 feed.add_item(
                     unique_id=self.uid(repo_id, commit.raw_id),
                     title=self._get_title(commit),
                     author_name=commit.author,
                     description=self._get_description(commit),
                     link=h.route_url(
                         'repo_commit', repo_name=_repo_name,
                         commit_id=commit.raw_id),
                     pubdate=date,)
 
             return feed.mime_type, feed.writeString('utf-8')
 
-        start = time.time()
         inv_context_manager = rc_cache.InvalidationContext(
             uid=cache_namespace_uid, invalidation_namespace=invalidation_namespace)
         with inv_context_manager as invalidation_context:
             # check for stored invalidation signal, and maybe purge the cache
             # before computing it again
             if invalidation_context.should_invalidate():
                 generate_rss_feed.invalidate(
                     self.db_repo.repo_id, self.db_repo.repo_name, 'rss')
 
             mime_type, feed = generate_rss_feed(
                 self.db_repo.repo_id, self.db_repo.repo_name, 'rss')
-            compute_time = time.time() - start
-            log.debug('Repo RSS feed computed in %.3fs', compute_time)
+            log.debug(
+                'Repo RSS feed computed in %.3fs', inv_context_manager.compute_time)
 
         response = Response(feed)
         response.content_type = mime_type
         return response

rhodecode/apps/repository/views/repo_summary.py

@@ -1,392 +1,392 b''
 # -*- coding: utf-8 -*-
 
 # Copyright (C) 2011-2018 RhodeCode GmbH
 #
 # This program is free software: you can redistribute it and/or modify
 # it under the terms of the GNU Affero General Public License, version 3
 # (only), as published by the Free Software Foundation.
 #
 # This program is distributed in the hope that it will be useful,
 # but WITHOUT ANY WARRANTY; without even the implied warranty of
 # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 # GNU General Public License for more details.
 #
 # You should have received a copy of the GNU Affero General Public License
 # along with this program.  If not, see <http://www.gnu.org/licenses/>.
 #
 # This program is dual-licensed. If you wish to learn more about the
 # RhodeCode Enterprise Edition, including its added features, Support services,
 # and proprietary license terms, please see https://rhodecode.com/licenses/
 
-import time
 import logging
 import string
 import rhodecode
 
 from pyramid.view import view_config
 
 from rhodecode.controllers import utils
 from rhodecode.apps._base import RepoAppView
 from rhodecode.config.conf import (LANGUAGES_EXTENSIONS_MAP)
 from rhodecode.lib import helpers as h, rc_cache
 from rhodecode.lib.utils2 import safe_str, safe_int
 from rhodecode.lib.auth import LoginRequired, HasRepoPermissionAnyDecorator
 from rhodecode.lib.markup_renderer import MarkupRenderer, relative_links
 from rhodecode.lib.ext_json import json
 from rhodecode.lib.vcs.backends.base import EmptyCommit
 from rhodecode.lib.vcs.exceptions import (
     CommitError, EmptyRepositoryError, CommitDoesNotExistError)
 from rhodecode.model.db import Statistics, CacheKey, User
 from rhodecode.model.meta import Session
 from rhodecode.model.repo import ReadmeFinder
 from rhodecode.model.scm import ScmModel
 
 log = logging.getLogger(__name__)
 
 
 class RepoSummaryView(RepoAppView):
 
     def load_default_context(self):
         c = self._get_local_tmpl_context(include_app_defaults=True)
         c.rhodecode_repo = None
         if not c.repository_requirements_missing:
             c.rhodecode_repo = self.rhodecode_vcs_repo
         return c
 
     def _get_readme_data(self, db_repo, renderer_type):
 
         log.debug('Looking for README file')
 
         cache_namespace_uid = 'cache_repo_instance.{}_{}'.format(
             db_repo.repo_id, CacheKey.CACHE_TYPE_README)
         invalidation_namespace = CacheKey.REPO_INVALIDATION_NAMESPACE.format(
             repo_id=self.db_repo.repo_id)
         region = rc_cache.get_or_create_region('cache_repo_longterm', cache_namespace_uid)
 
         @region.conditional_cache_on_arguments(namespace=cache_namespace_uid)
         def generate_repo_readme(repo_id, _repo_name, _renderer_type):
             readme_data = None
             readme_node = None
             readme_filename = None
             commit = self._get_landing_commit_or_none(db_repo)
             if commit:
                 log.debug("Searching for a README file.")
                 readme_node = ReadmeFinder(_renderer_type).search(commit)
             if readme_node:
                 relative_urls = {
                     'raw': h.route_path(
                         'repo_file_raw', repo_name=_repo_name,
                         commit_id=commit.raw_id, f_path=readme_node.path),
                     'standard': h.route_path(
                         'repo_files', repo_name=_repo_name,
                         commit_id=commit.raw_id, f_path=readme_node.path),
                 }
                 readme_data = self._render_readme_or_none(
                     commit, readme_node, relative_urls)
                 readme_filename = readme_node.path
             return readme_data, readme_filename
 
-        start = time.time()
         inv_context_manager = rc_cache.InvalidationContext(
             uid=cache_namespace_uid, invalidation_namespace=invalidation_namespace)
         with inv_context_manager as invalidation_context:
             # check for stored invalidation signal, and maybe purge the cache
             # before computing it again
             if invalidation_context.should_invalidate():
                 generate_repo_readme.invalidate(
                     db_repo.repo_id, db_repo.repo_name, renderer_type)
 
             instance = generate_repo_readme(
                 db_repo.repo_id, db_repo.repo_name, renderer_type)
-            compute_time = time.time() - start
-            log.debug('Repo readme generated and computed in %.3fs', compute_time)
+
+            log.debug(
+                'Repo readme generated and computed in %.3fs',
+                inv_context_manager.compute_time)
             return instance
 
     def _get_landing_commit_or_none(self, db_repo):
         log.debug("Getting the landing commit.")
         try:
             commit = db_repo.get_landing_commit()
             if not isinstance(commit, EmptyCommit):
                 return commit
             else:
                 log.debug("Repository is empty, no README to render.")
         except CommitError:
             log.exception(
                 "Problem getting commit when trying to render the README.")
 
     def _render_readme_or_none(self, commit, readme_node, relative_urls):
         log.debug(
             'Found README file `%s` rendering...', readme_node.path)
         renderer = MarkupRenderer()
         try:
             html_source = renderer.render(
                 readme_node.content, filename=readme_node.path)
             if relative_urls:
                 return relative_links(html_source, relative_urls)
             return html_source
         except Exception:
             log.exception(
                 "Exception while trying to render the README")
 
     def _load_commits_context(self, c):
         p = safe_int(self.request.GET.get('page'), 1)
         size = safe_int(self.request.GET.get('size'), 10)
 
         def url_generator(**kw):
             query_params = {
                 'size': size
             }
             query_params.update(kw)
             return h.route_path(
                 'repo_summary_commits',
                 repo_name=c.rhodecode_db_repo.repo_name, _query=query_params)
 
         pre_load = ['author', 'branch', 'date', 'message']
         try:
             collection = self.rhodecode_vcs_repo.get_commits(pre_load=pre_load)
         except EmptyRepositoryError:
             collection = self.rhodecode_vcs_repo
 
         c.repo_commits = h.RepoPage(
             collection, page=p, items_per_page=size, url=url_generator)
         page_ids = [x.raw_id for x in c.repo_commits]
         c.comments = self.db_repo.get_comments(page_ids)
         c.statuses = self.db_repo.statuses(page_ids)
 
     @LoginRequired()
     @HasRepoPermissionAnyDecorator(
         'repository.read', 'repository.write', 'repository.admin')
     @view_config(
         route_name='repo_summary_commits', request_method='GET',
         renderer='rhodecode:templates/summary/summary_commits.mako')
     def summary_commits(self):
         c = self.load_default_context()
         self._load_commits_context(c)
         return self._get_template_context(c)
 
     @LoginRequired()
     @HasRepoPermissionAnyDecorator(
         'repository.read', 'repository.write', 'repository.admin')
     @view_config(
         route_name='repo_summary', request_method='GET',
         renderer='rhodecode:templates/summary/summary.mako')
     @view_config(
         route_name='repo_summary_slash', request_method='GET',
         renderer='rhodecode:templates/summary/summary.mako')
     @view_config(
         route_name='repo_summary_explicit', request_method='GET',
         renderer='rhodecode:templates/summary/summary.mako')
     def summary(self):
         c = self.load_default_context()
 
         # Prepare the clone URL
         username = ''
         if self._rhodecode_user.username != User.DEFAULT_USER:
             username = safe_str(self._rhodecode_user.username)
 
         _def_clone_uri = _def_clone_uri_id = c.clone_uri_tmpl
         _def_clone_uri_ssh = c.clone_uri_ssh_tmpl
 
         if '{repo}' in _def_clone_uri:
             _def_clone_uri_id = _def_clone_uri.replace(
                 '{repo}', '_{repoid}')
         elif '{repoid}' in _def_clone_uri:
             _def_clone_uri_id = _def_clone_uri.replace(
                 '_{repoid}', '{repo}')
 
         c.clone_repo_url = self.db_repo.clone_url(
             user=username, uri_tmpl=_def_clone_uri)
         c.clone_repo_url_id = self.db_repo.clone_url(
             user=username, uri_tmpl=_def_clone_uri_id)
         c.clone_repo_url_ssh = self.db_repo.clone_url(
             uri_tmpl=_def_clone_uri_ssh, ssh=True)
 
         # If enabled, get statistics data
 
         c.show_stats = bool(self.db_repo.enable_statistics)
 
         stats = Session().query(Statistics) \
             .filter(Statistics.repository == self.db_repo) \
             .scalar()
 
         c.stats_percentage = 0
 
         if stats and stats.languages:
             c.no_data = False is self.db_repo.enable_statistics
             lang_stats_d = json.loads(stats.languages)
 
             # Sort first by decreasing count and second by the file extension,
             # so we have a consistent output.
             lang_stats_items = sorted(lang_stats_d.iteritems(),
                                       key=lambda k: (-k[1], k[0]))[:10]
             lang_stats = [(x, {"count": y,
                                "desc": LANGUAGES_EXTENSIONS_MAP.get(x)})
                           for x, y in lang_stats_items]
 
             c.trending_languages = json.dumps(lang_stats)
         else:
             c.no_data = True
             c.trending_languages = json.dumps({})
 
         scm_model = ScmModel()
         c.enable_downloads = self.db_repo.enable_downloads
         c.repository_followers = scm_model.get_followers(self.db_repo)
         c.repository_forks = scm_model.get_forks(self.db_repo)
         c.repository_is_user_following = scm_model.is_following_repo(
             self.db_repo_name, self._rhodecode_user.user_id)
 
         # first interaction with the VCS instance after here...
         if c.repository_requirements_missing:
             self.request.override_renderer = \
                 'rhodecode:templates/summary/missing_requirements.mako'
             return self._get_template_context(c)
 
         c.readme_data, c.readme_file = \
             self._get_readme_data(self.db_repo, c.visual.default_renderer)
 
         # loads the summary commits template context
         self._load_commits_context(c)
 
         return self._get_template_context(c)
 
     def get_request_commit_id(self):
         return self.request.matchdict['commit_id']
 
     @LoginRequired()
     @HasRepoPermissionAnyDecorator(
         'repository.read', 'repository.write', 'repository.admin')
     @view_config(
         route_name='repo_stats', request_method='GET',
         renderer='json_ext')
     def repo_stats(self):
         commit_id = self.get_request_commit_id()
         show_stats = bool(self.db_repo.enable_statistics)
         repo_id = self.db_repo.repo_id
 
         cache_seconds = safe_int(
             rhodecode.CONFIG.get('rc_cache.cache_repo.expiration_time'))
         cache_on = cache_seconds > 0
         log.debug(
             'Computing REPO TREE for repo_id %s commit_id `%s` '
             'with caching: %s[TTL: %ss]' % (
                 repo_id, commit_id, cache_on, cache_seconds or 0))
 
         cache_namespace_uid = 'cache_repo.{}'.format(repo_id)
         region = rc_cache.get_or_create_region('cache_repo', cache_namespace_uid)
 
         @region.conditional_cache_on_arguments(namespace=cache_namespace_uid,
                                                condition=cache_on)
         def compute_stats(repo_id, commit_id, show_stats):
             code_stats = {}
             size = 0
             try:
                 scm_instance = self.db_repo.scm_instance()
                 commit = scm_instance.get_commit(commit_id)
 
                 for node in commit.get_filenodes_generator():
                     size += node.size
                     if not show_stats:
                         continue
                     ext = string.lower(node.extension)
                     ext_info = LANGUAGES_EXTENSIONS_MAP.get(ext)
                     if ext_info:
                         if ext in code_stats:
                             code_stats[ext]['count'] += 1
                         else:
                             code_stats[ext] = {"count": 1, "desc": ext_info}
             except (EmptyRepositoryError, CommitDoesNotExistError):
                 pass
             return {'size': h.format_byte_size_binary(size),
                     'code_stats': code_stats}
 
         stats = compute_stats(self.db_repo.repo_id, commit_id, show_stats)
         return stats
 
     @LoginRequired()
     @HasRepoPermissionAnyDecorator(
         'repository.read', 'repository.write', 'repository.admin')
     @view_config(
         route_name='repo_refs_data', request_method='GET',
         renderer='json_ext')
     def repo_refs_data(self):
         _ = self.request.translate
         self.load_default_context()
 
         repo = self.rhodecode_vcs_repo
         refs_to_create = [
             (_("Branch"), repo.branches, 'branch'),
             (_("Tag"), repo.tags, 'tag'),
             (_("Bookmark"), repo.bookmarks, 'book'),
         ]
         res = self._create_reference_data(
             repo, self.db_repo_name, refs_to_create)
         data = {
             'more': False,
             'results': res
         }
         return data
 
     @LoginRequired()
     @HasRepoPermissionAnyDecorator(
         'repository.read', 'repository.write', 'repository.admin')
     @view_config(
         route_name='repo_refs_changelog_data', request_method='GET',
         renderer='json_ext')
     def repo_refs_changelog_data(self):
         _ = self.request.translate
         self.load_default_context()
 
         repo = self.rhodecode_vcs_repo
 
         refs_to_create = [
             (_("Branches"), repo.branches, 'branch'),
             (_("Closed branches"), repo.branches_closed, 'branch_closed'),
             # TODO: enable when vcs can handle bookmarks filters
             # (_("Bookmarks"), repo.bookmarks, "book"),
         ]
         res = self._create_reference_data(
             repo, self.db_repo_name, refs_to_create)
         data = {
             'more': False,
             'results': res
         }
         return data
 
     def _create_reference_data(self, repo, full_repo_name, refs_to_create):
         format_ref_id = utils.get_format_ref_id(repo)
 
         result = []
         for title, refs, ref_type in refs_to_create:
             if refs:
                 result.append({
                     'text': title,
                     'children': self._create_reference_items(
                         repo, full_repo_name, refs, ref_type,
                         format_ref_id),
                 })
         return result
 
     def _create_reference_items(self, repo, full_repo_name, refs, ref_type,
                                 format_ref_id):
         result = []
         is_svn = h.is_svn(repo)
         for ref_name, raw_id in refs.iteritems():
             files_url = self._create_files_url(
                 repo, full_repo_name, ref_name, raw_id, is_svn)
             result.append({
                 'text': ref_name,
                 'id': format_ref_id(ref_name, raw_id),
                 'raw_id': raw_id,
                 'type': ref_type,
                 'files_url': files_url,
             })
         return result
 
     def _create_files_url(self, repo, full_repo_name, ref_name, raw_id, is_svn):
         use_commit_id = '/' in ref_name or is_svn
         return h.route_path(
             'repo_files',
             repo_name=full_repo_name,
             f_path=ref_name if is_svn else '',
             commit_id=raw_id if use_commit_id else ref_name,
             _query=dict(at=ref_name))

rhodecode/lib/rc_cache/utils.py

@@ -1,318 +1,319 b''
 # -*- coding: utf-8 -*-
 
 # Copyright (C) 2015-2018 RhodeCode GmbH
 #
 # This program is free software: you can redistribute it and/or modify
 # it under the terms of the GNU Affero General Public License, version 3
 # (only), as published by the Free Software Foundation.
 #
 # This program is distributed in the hope that it will be useful,
 # but WITHOUT ANY WARRANTY; without even the implied warranty of
 # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 # GNU General Public License for more details.
 #
 # You should have received a copy of the GNU Affero General Public License
 # along with this program.  If not, see <http://www.gnu.org/licenses/>.
 #
 # This program is dual-licensed. If you wish to learn more about the
 # RhodeCode Enterprise Edition, including its added features, Support services,
 # and proprietary license terms, please see https://rhodecode.com/licenses/
 import os
+import time
 import logging
 import functools
 import threading
 
 from dogpile.cache import CacheRegion
 from dogpile.cache.util import compat
 
 import rhodecode
 from rhodecode.lib.utils import safe_str, sha1
 from rhodecode.lib.utils2 import safe_unicode, str2bool
 from rhodecode.model.db import Session, CacheKey, IntegrityError
 
 from . import region_meta
 
 log = logging.getLogger(__name__)
 
 
 class RhodeCodeCacheRegion(CacheRegion):
 
     def conditional_cache_on_arguments(
             self, namespace=None,
             expiration_time=None,
             should_cache_fn=None,
             to_str=compat.string_type,
             function_key_generator=None,
             condition=True):
         """
         Custom conditional decorator, that will not touch any dogpile internals if
         condition isn't meet. This works a bit different than should_cache_fn
         And it's faster in cases we don't ever want to compute cached values
         """
         expiration_time_is_callable = compat.callable(expiration_time)
 
         if function_key_generator is None:
             function_key_generator = self.function_key_generator
 
         def decorator(fn):
             if to_str is compat.string_type:
                 # backwards compatible
                 key_generator = function_key_generator(namespace, fn)
             else:
                 key_generator = function_key_generator(namespace, fn, to_str=to_str)
 
             @functools.wraps(fn)
             def decorate(*arg, **kw):
                 key = key_generator(*arg, **kw)
 
                 @functools.wraps(fn)
                 def creator():
                     return fn(*arg, **kw)
 
                 if not condition:
                     return creator()
 
                 timeout = expiration_time() if expiration_time_is_callable \
                     else expiration_time
 
                 return self.get_or_create(key, creator, timeout, should_cache_fn)
 
             def invalidate(*arg, **kw):
                 key = key_generator(*arg, **kw)
                 self.delete(key)
 
             def set_(value, *arg, **kw):
                 key = key_generator(*arg, **kw)
                 self.set(key, value)
 
             def get(*arg, **kw):
                 key = key_generator(*arg, **kw)
                 return self.get(key)
 
             def refresh(*arg, **kw):
                 key = key_generator(*arg, **kw)
                 value = fn(*arg, **kw)
                 self.set(key, value)
                 return value
 
             decorate.set = set_
             decorate.invalidate = invalidate
             decorate.refresh = refresh
             decorate.get = get
             decorate.original = fn
             decorate.key_generator = key_generator
 
             return decorate
 
         return decorator
 
 
 def make_region(*arg, **kw):
     return RhodeCodeCacheRegion(*arg, **kw)
 
 
 def get_default_cache_settings(settings, prefixes=None):
     prefixes = prefixes or []
     cache_settings = {}
     for key in settings.keys():
         for prefix in prefixes:
             if key.startswith(prefix):
                 name = key.split(prefix)[1].strip()
                 val = settings[key]
                 if isinstance(val, basestring):
                     val = val.strip()
                 cache_settings[name] = val
     return cache_settings
 
 
 def compute_key_from_params(*args):
     """
     Helper to compute key from given params to be used in cache manager
     """
     return sha1("_".join(map(safe_str, args)))
 
 
 def key_generator(namespace, fn):
     fname = fn.__name__
 
     def generate_key(*args):
         namespace_pref = namespace or 'default'
         arg_key = compute_key_from_params(*args)
         final_key = "{}:{}_{}".format(namespace_pref, fname, arg_key)
 
         return final_key
 
     return generate_key
 
 
 def get_or_create_region(region_name, region_namespace=None):
     from rhodecode.lib.rc_cache.backends import FileNamespaceBackend
     region_obj = region_meta.dogpile_cache_regions.get(region_name)
     if not region_obj:
         raise EnvironmentError(
             'Region `{}` not in configured: {}.'.format(
                 region_name, region_meta.dogpile_cache_regions.keys()))
 
     region_uid_name = '{}:{}'.format(region_name, region_namespace)
     if isinstance(region_obj.actual_backend, FileNamespaceBackend):
         region_exist = region_meta.dogpile_cache_regions.get(region_namespace)
         if region_exist:
             log.debug('Using already configured region: %s', region_namespace)
             return region_exist
         cache_dir = region_meta.dogpile_config_defaults['cache_dir']
         expiration_time = region_obj.expiration_time
 
         if not os.path.isdir(cache_dir):
             os.makedirs(cache_dir)
         new_region = make_region(
             name=region_uid_name, function_key_generator=key_generator
         )
         namespace_filename = os.path.join(
             cache_dir, "{}.cache.dbm".format(region_namespace))
         # special type that allows 1db per namespace
         new_region.configure(
             backend='dogpile.cache.rc.file_namespace',
             expiration_time=expiration_time,
             arguments={"filename": namespace_filename}
         )
 
         # create and save in region caches
         log.debug('configuring new region: %s',region_uid_name)
         region_obj = region_meta.dogpile_cache_regions[region_namespace] = new_region
 
     return region_obj
 
 
 def clear_cache_namespace(cache_region, cache_namespace_uid):
     region = get_or_create_region(cache_region, cache_namespace_uid)
     cache_keys = region.backend.list_keys(prefix=cache_namespace_uid)
     region.delete_multi(cache_keys)
     return len(cache_keys)
 
 
 class ActiveRegionCache(object):
     def __init__(self, context):
         self.context = context
 
     def should_invalidate(self):
         return False
 
 
 class FreshRegionCache(object):
     def __init__(self, context):
         self.context = context
 
     def should_invalidate(self):
         return True
 
 
 class InvalidationContext(object):
     """
     usage::
 
-        import time
         from rhodecode.lib import rc_cache
-        my_id = 1
-        cache_namespace_uid = 'cache_demo.{}'.format(my_id)
-        invalidation_namespace = 'repo_cache:1'
+
+        cache_namespace_uid = CacheKey.SOME_NAMESPACE.format(1)
         region = rc_cache.get_or_create_region('cache_perms', cache_namespace_uid)
 
-        @region.conditional_cache_on_arguments(namespace=cache_namespace_uid,
-                                               expiration_time=30,
-                                               condition=True)
+        @region.conditional_cache_on_arguments(namespace=cache_namespace_uid, condition=True)
         def heavy_compute(cache_name, param1, param2):
             print('COMPUTE {}, {}, {}'.format(cache_name, param1, param2))
-            import time
-            time.sleep(30)
-            return True
 
-        start = time.time()
+        # invalidation namespace is shared namespace key for all process caches
+        # we use it to send a global signal
+        invalidation_namespace = 'repo_cache:1'
+
         inv_context_manager = rc_cache.InvalidationContext(
             uid=cache_namespace_uid, invalidation_namespace=invalidation_namespace)
         with inv_context_manager as invalidation_context:
             # check for stored invalidation signal, and maybe purge the cache
             # before computing it again
             if invalidation_context.should_invalidate():
                 heavy_compute.invalidate('some_name', 'param1', 'param2')
 
             result = heavy_compute('some_name', 'param1', 'param2')
-            compute_time = time.time() - start
+            compute_time = inv_context_manager.compute_time
             print(compute_time)
 
         # To send global invalidation signal, simply run
         CacheKey.set_invalidate(invalidation_namespace)
 
     """
 
     def __repr__(self):
         return '<InvalidationContext:{}[{}]>'.format(
             safe_str(self.cache_key), safe_str(self.uid))
 
     def __init__(self, uid, invalidation_namespace='',
                  raise_exception=False, thread_scoped=None):
         self.uid = uid
         self.invalidation_namespace = invalidation_namespace
         self.raise_exception = raise_exception
         self.proc_id = safe_unicode(rhodecode.CONFIG.get('instance_id') or 'DEFAULT')
         self.thread_id = 'global'
 
         if thread_scoped is None:
             # if we set "default" we can override this via .ini settings
             thread_scoped = str2bool(rhodecode.CONFIG.get('cache_thread_scoped'))
 
         # Append the thread id to the cache key if this invalidation context
         # should be scoped to the current thread.
         if thread_scoped is True:
             self.thread_id = threading.current_thread().ident
 
         self.cache_key = compute_key_from_params(uid)
         self.cache_key = 'proc:{}_thread:{}_{}'.format(
             self.proc_id, self.thread_id, self.cache_key)
+        self.compute_time = 0
 
     def get_or_create_cache_obj(self, uid, invalidation_namespace=''):
         log.debug('Checking if %s cache key is present and active', self.cache_key)
         cache_obj = CacheKey.get_active_cache(self.cache_key)
         invalidation_namespace = invalidation_namespace or self.invalidation_namespace
         if not cache_obj:
             cache_obj = CacheKey(self.cache_key, cache_args=invalidation_namespace)
         return cache_obj
 
     def __enter__(self):
         """
         Test if current object is valid, and return CacheRegion function
         that does invalidation and calculation
         """
         # register or get a new key based on uid
         self.cache_obj = self.get_or_create_cache_obj(uid=self.uid)
-
+        self._start_time = time.time()
         if self.cache_obj.cache_active:
             # means our cache obj is existing and marked as it's
             # cache is not outdated, we return ActiveRegionCache
             self.skip_cache_active_change = True
+
             return ActiveRegionCache(context=self)
 
         # the key is either not existing or set to False, we return
         # the real invalidator which re-computes value. We additionally set
         # the flag to actually update the Database objects
         self.skip_cache_active_change = False
         return FreshRegionCache(context=self)
 
     def __exit__(self, exc_type, exc_val, exc_tb):
+        # save compute time
+        self.compute_time = time.time() - self._start_time
 
         if self.skip_cache_active_change:
             return
 
         try:
             self.cache_obj.cache_active = True
             Session().add(self.cache_obj)
             Session().commit()
         except IntegrityError:
             # if we catch integrity error, it means we inserted this object
             # assumption is that's really an edge race-condition case and
             # it's safe is to skip it
             Session().rollback()
         except Exception:
             log.exception('Failed to commit on cache key update')
             Session().rollback()
             if self.raise_exception:
                 raise