##// END OF EJS Templates
vcs: Remove custom response header which contains backend key....
vcs: Remove custom response header which contains backend key. We used this custom header to skip the error handling. This is no linger needed since the VCS middleware is moved above of the error handling.

File last commit:

r821:618c046d default
r950:21c331ba default
Show More
summary.py
318 lines | 11.6 KiB | text/x-python | PythonLexer
# -*- coding: utf-8 -*-
# Copyright (C) 2010-2016 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/
"""
Summary controller for RhodeCode Enterprise
"""
import logging
from string import lower
from pylons import tmpl_context as c, request
from pylons.i18n.translation import _
from beaker.cache import cache_region, region_invalidate
from rhodecode.config.conf import (LANGUAGES_EXTENSIONS_MAP)
from rhodecode.controllers import utils
from rhodecode.controllers.changelog import _load_changelog_summary
from rhodecode.lib import caches, helpers as h
from rhodecode.lib.utils import jsonify
from rhodecode.lib.utils2 import safe_str
from rhodecode.lib.auth import (
LoginRequired, HasRepoPermissionAnyDecorator, NotAnonymous, XHRRequired)
from rhodecode.lib.base import BaseRepoController, render
from rhodecode.lib.markup_renderer import MarkupRenderer
from rhodecode.lib.ext_json import json
from rhodecode.lib.vcs.backends.base import EmptyCommit
from rhodecode.lib.vcs.exceptions import (
CommitError, EmptyRepositoryError, NodeDoesNotExistError)
from rhodecode.model.db import Statistics, CacheKey, User
from rhodecode.model.repo import ReadmeFinder
log = logging.getLogger(__name__)
class SummaryController(BaseRepoController):
def __before__(self):
super(SummaryController, self).__before__()
def __get_readme_data(self, db_repo):
repo_name = db_repo.repo_name
log.debug('Looking for README file')
default_renderer = c.visual.default_renderer
@cache_region('long_term')
def _generate_readme(cache_key):
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(default_renderer).search(commit)
if readme_node:
readme_data = self._render_readme_or_none(commit, readme_node)
readme_filename = readme_node.path
return readme_data, readme_filename
invalidator_context = CacheKey.repo_context_cache(
_generate_readme, repo_name, CacheKey.CACHE_TYPE_README)
with invalidator_context as context:
context.invalidate()
computed = context.compute()
return computed
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):
log.debug(
'Found README file `%s` rendering...', readme_node.path)
renderer = MarkupRenderer()
try:
return renderer.render(
readme_node.content, filename=readme_node.path)
except Exception:
log.exception(
"Exception while trying to render the README")
@LoginRequired()
@HasRepoPermissionAnyDecorator(
'repository.read', 'repository.write', 'repository.admin')
def index(self, repo_name):
# Prepare the clone URL
username = ''
if c.rhodecode_user.username != User.DEFAULT_USER:
username = safe_str(c.rhodecode_user.username)
_def_clone_uri = _def_clone_uri_by_id = c.clone_uri_tmpl
if '{repo}' in _def_clone_uri:
_def_clone_uri_by_id = _def_clone_uri.replace(
'{repo}', '_{repoid}')
elif '{repoid}' in _def_clone_uri:
_def_clone_uri_by_id = _def_clone_uri.replace(
'_{repoid}', '{repo}')
c.clone_repo_url = c.rhodecode_db_repo.clone_url(
user=username, uri_tmpl=_def_clone_uri)
c.clone_repo_url_id = c.rhodecode_db_repo.clone_url(
user=username, uri_tmpl=_def_clone_uri_by_id)
# If enabled, get statistics data
c.show_stats = bool(c.rhodecode_db_repo.enable_statistics)
stats = self.sa.query(Statistics)\
.filter(Statistics.repository == c.rhodecode_db_repo)\
.scalar()
c.stats_percentage = 0
if stats and stats.languages:
c.no_data = False is c.rhodecode_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({})
c.enable_downloads = c.rhodecode_db_repo.enable_downloads
c.repository_followers = self.scm_model.get_followers(
c.rhodecode_db_repo)
c.repository_forks = self.scm_model.get_forks(c.rhodecode_db_repo)
c.repository_is_user_following = self.scm_model.is_following_repo(
c.repo_name, c.rhodecode_user.user_id)
if c.repository_requirements_missing:
return render('summary/missing_requirements.html')
c.readme_data, c.readme_file = \
self.__get_readme_data(c.rhodecode_db_repo)
_load_changelog_summary()
if request.is_xhr:
return render('changelog/changelog_summary_data.html')
return render('summary/summary.html')
@LoginRequired()
@XHRRequired()
@HasRepoPermissionAnyDecorator(
'repository.read', 'repository.write', 'repository.admin')
@jsonify
def repo_stats(self, repo_name, commit_id):
_namespace = caches.get_repo_namespace_key(
caches.SUMMARY_STATS, repo_name)
show_stats = bool(c.rhodecode_db_repo.enable_statistics)
cache_manager = caches.get_cache_manager('repo_cache_long', _namespace)
_cache_key = caches.compute_key_from_params(
repo_name, commit_id, show_stats)
def compute_stats():
code_stats = {}
size = 0
try:
scm_instance = c.rhodecode_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 = 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:
pass
return {'size': h.format_byte_size_binary(size),
'code_stats': code_stats}
stats = cache_manager.get(_cache_key, createfunc=compute_stats)
return stats
def _switcher_reference_data(self, repo_name, references, is_svn):
"""Prepare reference data for given `references`"""
items = []
for name, commit_id in references.items():
use_commit_id = '/' in name or is_svn
items.append({
'name': name,
'commit_id': commit_id,
'files_url': h.url(
'files_home',
repo_name=repo_name,
f_path=name if is_svn else '',
revision=commit_id if use_commit_id else name,
at=name)
})
return items
@LoginRequired()
@HasRepoPermissionAnyDecorator('repository.read', 'repository.write',
'repository.admin')
@jsonify
def repo_refs_data(self, repo_name):
repo = c.rhodecode_repo
refs_to_create = [
(_("Branch"), repo.branches, 'branch'),
(_("Tag"), repo.tags, 'tag'),
(_("Bookmark"), repo.bookmarks, 'book'),
]
res = self._create_reference_data(repo, repo_name, refs_to_create)
data = {
'more': False,
'results': res
}
return data
@LoginRequired()
@HasRepoPermissionAnyDecorator('repository.read', 'repository.write',
'repository.admin')
@jsonify
def repo_default_reviewers_data(self, repo_name):
return {
'reviewers': [utils.reviewer_as_json(
user=c.rhodecode_db_repo.user, reasons=None)]
}
@jsonify
def repo_refs_changelog_data(self, repo_name):
repo = c.rhodecode_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, 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.url(
'files_home',
repo_name=full_repo_name,
f_path=ref_name if is_svn else '',
revision=raw_id if use_commit_id else ref_name,
at=ref_name)