##// END OF EJS Templates
svn-support: Use utf-8 to encode mod_dav_svn configuration before writing to disk....
svn-support: Use utf-8 to encode mod_dav_svn configuration before writing to disk. Repository or group names may contain non ASCII characters. Therfore we have to encode the configuration before writing it to the file.

File last commit:

r423:9930e2c8 default
r830:7ca2d1db default
Show More
files.py
1114 lines | 43.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/
"""
Files controller for RhodeCode Enterprise
"""
import itertools
import logging
import os
import shutil
import tempfile
from pylons import request, response, tmpl_context as c, url
from pylons.i18n.translation import _
from pylons.controllers.util import redirect
from webob.exc import HTTPNotFound, HTTPBadRequest
from rhodecode.controllers.utils import parse_path_ref
from rhodecode.lib import diffs, helpers as h, caches
from rhodecode.lib.compat import OrderedDict
from rhodecode.lib.utils import jsonify, action_logger
from rhodecode.lib.utils2 import (
convert_line_endings, detect_mode, safe_str, str2bool)
from rhodecode.lib.auth import (
LoginRequired, HasRepoPermissionAnyDecorator, CSRFRequired, XHRRequired)
from rhodecode.lib.base import BaseRepoController, render
from rhodecode.lib.vcs import path as vcspath
from rhodecode.lib.vcs.backends.base import EmptyCommit
from rhodecode.lib.vcs.conf import settings
from rhodecode.lib.vcs.exceptions import (
RepositoryError, CommitDoesNotExistError, EmptyRepositoryError,
ImproperArchiveTypeError, VCSError, NodeAlreadyExistsError,
NodeDoesNotExistError, CommitError, NodeError)
from rhodecode.lib.vcs.nodes import FileNode
from rhodecode.model.repo import RepoModel
from rhodecode.model.scm import ScmModel
from rhodecode.model.db import Repository
from rhodecode.controllers.changeset import (
_ignorews_url, _context_url, get_line_ctx, get_ignore_ws)
from rhodecode.lib.exceptions import NonRelativePathError
log = logging.getLogger(__name__)
class FilesController(BaseRepoController):
def __before__(self):
super(FilesController, self).__before__()
c.cut_off_limit = self.cut_off_limit_file
def _get_default_encoding(self):
enc_list = getattr(c, 'default_encodings', [])
return enc_list[0] if enc_list else 'UTF-8'
def __get_commit_or_redirect(self, commit_id, repo_name,
redirect_after=True):
"""
This is a safe way to get commit. If an error occurs it redirects to
tip with proper message
:param commit_id: id of commit to fetch
:param repo_name: repo name to redirect after
:param redirect_after: toggle redirection
"""
try:
return c.rhodecode_repo.get_commit(commit_id)
except EmptyRepositoryError:
if not redirect_after:
return None
url_ = url('files_add_home',
repo_name=c.repo_name,
revision=0, f_path='', anchor='edit')
if h.HasRepoPermissionAny(
'repository.write', 'repository.admin')(c.repo_name):
add_new = h.link_to(
_('Click here to add a new file.'),
url_, class_="alert-link")
else:
add_new = ""
h.flash(h.literal(
_('There are no files yet. %s') % add_new), category='warning')
redirect(h.url('summary_home', repo_name=repo_name))
except (CommitDoesNotExistError, LookupError):
msg = _('No such commit exists for this repository')
h.flash(msg, category='error')
raise HTTPNotFound()
except RepositoryError as e:
h.flash(safe_str(e), category='error')
raise HTTPNotFound()
def __get_filenode_or_redirect(self, repo_name, commit, path):
"""
Returns file_node, if error occurs or given path is directory,
it'll redirect to top level path
:param repo_name: repo_name
:param commit: given commit
:param path: path to lookup
"""
try:
file_node = commit.get_node(path)
if file_node.is_dir():
raise RepositoryError('The given path is a directory')
except CommitDoesNotExistError:
msg = _('No such commit exists for this repository')
log.exception(msg)
h.flash(msg, category='error')
raise HTTPNotFound()
except RepositoryError as e:
h.flash(safe_str(e), category='error')
raise HTTPNotFound()
return file_node
def __get_tree_cache_manager(self, repo_name, namespace_type):
_namespace = caches.get_repo_namespace_key(namespace_type, repo_name)
return caches.get_cache_manager('repo_cache_long', _namespace)
def _get_tree_at_commit(self, repo_name, commit_id, f_path,
full_load=False, force=False):
def _cached_tree():
log.debug('Generating cached file tree for %s, %s, %s',
repo_name, commit_id, f_path)
c.full_load = full_load
return render('files/files_browser_tree.html')
cache_manager = self.__get_tree_cache_manager(
repo_name, caches.FILE_TREE)
cache_key = caches.compute_key_from_params(
repo_name, commit_id, f_path)
if force:
# we want to force recompute of caches
cache_manager.remove_value(cache_key)
return cache_manager.get(cache_key, createfunc=_cached_tree)
def _get_nodelist_at_commit(self, repo_name, commit_id, f_path):
def _cached_nodes():
log.debug('Generating cached nodelist for %s, %s, %s',
repo_name, commit_id, f_path)
_d, _f = ScmModel().get_nodes(
repo_name, commit_id, f_path, flat=False)
return _d + _f
cache_manager = self.__get_tree_cache_manager(
repo_name, caches.FILE_SEARCH_TREE_META)
cache_key = caches.compute_key_from_params(
repo_name, commit_id, f_path)
return cache_manager.get(cache_key, createfunc=_cached_nodes)
@LoginRequired()
@HasRepoPermissionAnyDecorator(
'repository.read', 'repository.write', 'repository.admin')
def index(
self, repo_name, revision, f_path, annotate=False, rendered=False):
commit_id = revision
# redirect to given commit_id from form if given
get_commit_id = request.GET.get('at_rev', None)
if get_commit_id:
self.__get_commit_or_redirect(get_commit_id, repo_name)
c.commit = self.__get_commit_or_redirect(commit_id, repo_name)
c.branch = request.GET.get('branch', None)
c.f_path = f_path
c.annotate = annotate
# default is false, but .rst/.md files later are autorendered, we can
# overwrite autorendering by setting this GET flag
c.renderer = rendered or not request.GET.get('no-render', False)
# prev link
try:
prev_commit = c.commit.prev(c.branch)
c.prev_commit = prev_commit
c.url_prev = url('files_home', repo_name=c.repo_name,
revision=prev_commit.raw_id, f_path=f_path)
if c.branch:
c.url_prev += '?branch=%s' % c.branch
except (CommitDoesNotExistError, VCSError):
c.url_prev = '#'
c.prev_commit = EmptyCommit()
# next link
try:
next_commit = c.commit.next(c.branch)
c.next_commit = next_commit
c.url_next = url('files_home', repo_name=c.repo_name,
revision=next_commit.raw_id, f_path=f_path)
if c.branch:
c.url_next += '?branch=%s' % c.branch
except (CommitDoesNotExistError, VCSError):
c.url_next = '#'
c.next_commit = EmptyCommit()
# files or dirs
try:
c.file = c.commit.get_node(f_path)
c.file_author = True
c.file_tree = ''
if c.file.is_file():
c.renderer = (
c.renderer and h.renderer_from_filename(c.file.path))
c.file_last_commit = c.file.last_commit
c.on_branch_head = self._is_valid_head(
commit_id, c.rhodecode_repo)
c.branch_or_raw_id = c.commit.branch or c.commit.raw_id
author = c.file_last_commit.author
c.authors = [(h.email(author),
h.person(author, 'username_or_name_or_email'))]
else:
c.authors = []
c.file_tree = self._get_tree_at_commit(
repo_name, c.commit.raw_id, f_path)
except RepositoryError as e:
h.flash(safe_str(e), category='error')
raise HTTPNotFound()
if request.environ.get('HTTP_X_PJAX'):
return render('files/files_pjax.html')
return render('files/files.html')
@LoginRequired()
@HasRepoPermissionAnyDecorator('repository.read', 'repository.write',
'repository.admin')
@jsonify
def history(self, repo_name, revision, f_path):
commit = self.__get_commit_or_redirect(revision, repo_name)
f_path = f_path
_file = commit.get_node(f_path)
if _file.is_file():
file_history, _hist = self._get_node_history(commit, f_path)
res = []
for obj in file_history:
res.append({
'text': obj[1],
'children': [{'id': o[0], 'text': o[1]} for o in obj[0]]
})
data = {
'more': False,
'results': res
}
return data
@LoginRequired()
@HasRepoPermissionAnyDecorator('repository.read', 'repository.write',
'repository.admin')
def authors(self, repo_name, revision, f_path):
commit = self.__get_commit_or_redirect(revision, repo_name)
file_node = commit.get_node(f_path)
if file_node.is_file():
c.file_last_commit = file_node.last_commit
if request.GET.get('annotate') == '1':
# use _hist from annotation if annotation mode is on
commit_ids = set(x[1] for x in file_node.annotate)
_hist = (
c.rhodecode_repo.get_commit(commit_id)
for commit_id in commit_ids)
else:
_f_history, _hist = self._get_node_history(commit, f_path)
c.file_author = False
c.authors = []
for author in set(commit.author for commit in _hist):
c.authors.append((
h.email(author),
h.person(author, 'username_or_name_or_email')))
return render('files/file_authors_box.html')
@LoginRequired()
@HasRepoPermissionAnyDecorator('repository.read', 'repository.write',
'repository.admin')
def rawfile(self, repo_name, revision, f_path):
"""
Action for download as raw
"""
commit = self.__get_commit_or_redirect(revision, repo_name)
file_node = self.__get_filenode_or_redirect(repo_name, commit, f_path)
response.content_disposition = 'attachment; filename=%s' % \
safe_str(f_path.split(Repository.NAME_SEP)[-1])
response.content_type = file_node.mimetype
charset = self._get_default_encoding()
if charset:
response.charset = charset
return file_node.content
@LoginRequired()
@HasRepoPermissionAnyDecorator('repository.read', 'repository.write',
'repository.admin')
def raw(self, repo_name, revision, f_path):
"""
Action for show as raw, some mimetypes are "rendered",
those include images, icons.
"""
commit = self.__get_commit_or_redirect(revision, repo_name)
file_node = self.__get_filenode_or_redirect(repo_name, commit, f_path)
raw_mimetype_mapping = {
# map original mimetype to a mimetype used for "show as raw"
# you can also provide a content-disposition to override the
# default "attachment" disposition.
# orig_type: (new_type, new_dispo)
# show images inline:
# Do not re-add SVG: it is unsafe and permits XSS attacks. One can
# for example render an SVG with javascript inside or even render
# HTML.
'image/x-icon': ('image/x-icon', 'inline'),
'image/png': ('image/png', 'inline'),
'image/gif': ('image/gif', 'inline'),
'image/jpeg': ('image/jpeg', 'inline'),
}
mimetype = file_node.mimetype
try:
mimetype, dispo = raw_mimetype_mapping[mimetype]
except KeyError:
# we don't know anything special about this, handle it safely
if file_node.is_binary:
# do same as download raw for binary files
mimetype, dispo = 'application/octet-stream', 'attachment'
else:
# do not just use the original mimetype, but force text/plain,
# otherwise it would serve text/html and that might be unsafe.
# Note: underlying vcs library fakes text/plain mimetype if the
# mimetype can not be determined and it thinks it is not
# binary.This might lead to erroneous text display in some
# cases, but helps in other cases, like with text files
# without extension.
mimetype, dispo = 'text/plain', 'inline'
if dispo == 'attachment':
dispo = 'attachment; filename=%s' % safe_str(
f_path.split(os.sep)[-1])
response.content_disposition = dispo
response.content_type = mimetype
charset = self._get_default_encoding()
if charset:
response.charset = charset
return file_node.content
@CSRFRequired()
@LoginRequired()
@HasRepoPermissionAnyDecorator('repository.write', 'repository.admin')
def delete(self, repo_name, revision, f_path):
commit_id = revision
repo = c.rhodecode_db_repo
if repo.enable_locking and repo.locked[0]:
h.flash(_('This repository has been locked by %s on %s')
% (h.person_by_id(repo.locked[0]),
h.format_date(h.time_to_datetime(repo.locked[1]))),
'warning')
return redirect(h.url('files_home',
repo_name=repo_name, revision='tip'))
if not self._is_valid_head(commit_id, repo.scm_instance()):
h.flash(_('You can only delete files with revision '
'being a valid branch '), category='warning')
return redirect(h.url('files_home',
repo_name=repo_name, revision='tip',
f_path=f_path))
c.commit = self.__get_commit_or_redirect(commit_id, repo_name)
c.file = self.__get_filenode_or_redirect(repo_name, c.commit, f_path)
c.default_message = _(
'Deleted file %s via RhodeCode Enterprise') % (f_path)
c.f_path = f_path
node_path = f_path
author = c.rhodecode_user.full_contact
message = request.POST.get('message') or c.default_message
try:
nodes = {
node_path: {
'content': ''
}
}
self.scm_model.delete_nodes(
user=c.rhodecode_user.user_id, repo=c.rhodecode_db_repo,
message=message,
nodes=nodes,
parent_commit=c.commit,
author=author,
)
h.flash(_('Successfully deleted file %s') % f_path,
category='success')
except Exception:
msg = _('Error occurred during commit')
log.exception(msg)
h.flash(msg, category='error')
return redirect(url('changeset_home',
repo_name=c.repo_name, revision='tip'))
@LoginRequired()
@HasRepoPermissionAnyDecorator('repository.write', 'repository.admin')
def delete_home(self, repo_name, revision, f_path):
commit_id = revision
repo = c.rhodecode_db_repo
if repo.enable_locking and repo.locked[0]:
h.flash(_('This repository has been locked by %s on %s')
% (h.person_by_id(repo.locked[0]),
h.format_date(h.time_to_datetime(repo.locked[1]))),
'warning')
return redirect(h.url('files_home',
repo_name=repo_name, revision='tip'))
if not self._is_valid_head(commit_id, repo.scm_instance()):
h.flash(_('You can only delete files with revision '
'being a valid branch '), category='warning')
return redirect(h.url('files_home',
repo_name=repo_name, revision='tip',
f_path=f_path))
c.commit = self.__get_commit_or_redirect(commit_id, repo_name)
c.file = self.__get_filenode_or_redirect(repo_name, c.commit, f_path)
c.default_message = _(
'Deleted file %s via RhodeCode Enterprise') % (f_path)
c.f_path = f_path
return render('files/files_delete.html')
@CSRFRequired()
@LoginRequired()
@HasRepoPermissionAnyDecorator('repository.write', 'repository.admin')
def edit(self, repo_name, revision, f_path):
commit_id = revision
repo = c.rhodecode_db_repo
if repo.enable_locking and repo.locked[0]:
h.flash(_('This repository has been locked by %s on %s')
% (h.person_by_id(repo.locked[0]),
h.format_date(h.time_to_datetime(repo.locked[1]))),
'warning')
return redirect(h.url('files_home',
repo_name=repo_name, revision='tip'))
if not self._is_valid_head(commit_id, repo.scm_instance()):
h.flash(_('You can only edit files with revision '
'being a valid branch '), category='warning')
return redirect(h.url('files_home',
repo_name=repo_name, revision='tip',
f_path=f_path))
c.commit = self.__get_commit_or_redirect(commit_id, repo_name)
c.file = self.__get_filenode_or_redirect(repo_name, c.commit, f_path)
if c.file.is_binary:
return redirect(url('files_home', repo_name=c.repo_name,
revision=c.commit.raw_id, f_path=f_path))
c.default_message = _(
'Edited file %s via RhodeCode Enterprise') % (f_path)
c.f_path = f_path
old_content = c.file.content
sl = old_content.splitlines(1)
first_line = sl[0] if sl else ''
# modes: 0 - Unix, 1 - Mac, 2 - DOS
mode = detect_mode(first_line, 0)
content = convert_line_endings(request.POST.get('content', ''), mode)
message = request.POST.get('message') or c.default_message
org_f_path = c.file.unicode_path
filename = request.POST['filename']
org_filename = c.file.name
if content == old_content and filename == org_filename:
h.flash(_('No changes'), category='warning')
return redirect(url('changeset_home', repo_name=c.repo_name,
revision='tip'))
try:
mapping = {
org_f_path: {
'org_filename': org_f_path,
'filename': os.path.join(c.file.dir_path, filename),
'content': content,
'lexer': '',
'op': 'mod',
}
}
ScmModel().update_nodes(
user=c.rhodecode_user.user_id,
repo=c.rhodecode_db_repo,
message=message,
nodes=mapping,
parent_commit=c.commit,
)
h.flash(_('Successfully committed to %s') % f_path,
category='success')
except Exception:
msg = _('Error occurred during commit')
log.exception(msg)
h.flash(msg, category='error')
return redirect(url('changeset_home',
repo_name=c.repo_name, revision='tip'))
@LoginRequired()
@HasRepoPermissionAnyDecorator('repository.write', 'repository.admin')
def edit_home(self, repo_name, revision, f_path):
commit_id = revision
repo = c.rhodecode_db_repo
if repo.enable_locking and repo.locked[0]:
h.flash(_('This repository has been locked by %s on %s')
% (h.person_by_id(repo.locked[0]),
h.format_date(h.time_to_datetime(repo.locked[1]))),
'warning')
return redirect(h.url('files_home',
repo_name=repo_name, revision='tip'))
if not self._is_valid_head(commit_id, repo.scm_instance()):
h.flash(_('You can only edit files with revision '
'being a valid branch '), category='warning')
return redirect(h.url('files_home',
repo_name=repo_name, revision='tip',
f_path=f_path))
c.commit = self.__get_commit_or_redirect(commit_id, repo_name)
c.file = self.__get_filenode_or_redirect(repo_name, c.commit, f_path)
if c.file.is_binary:
return redirect(url('files_home', repo_name=c.repo_name,
revision=c.commit.raw_id, f_path=f_path))
c.default_message = _(
'Edited file %s via RhodeCode Enterprise') % (f_path)
c.f_path = f_path
return render('files/files_edit.html')
def _is_valid_head(self, commit_id, repo):
# check if commit is a branch identifier- basically we cannot
# create multiple heads via file editing
valid_heads = repo.branches.keys() + repo.branches.values()
if h.is_svn(repo) and not repo.is_empty():
# Note: Subversion only has one head, we add it here in case there
# is no branch matched.
valid_heads.append(repo.get_commit(commit_idx=-1).raw_id)
# check if commit is a branch name or branch hash
return commit_id in valid_heads
@CSRFRequired()
@LoginRequired()
@HasRepoPermissionAnyDecorator('repository.write', 'repository.admin')
def add(self, repo_name, revision, f_path):
repo = Repository.get_by_repo_name(repo_name)
if repo.enable_locking and repo.locked[0]:
h.flash(_('This repository has been locked by %s on %s')
% (h.person_by_id(repo.locked[0]),
h.format_date(h.time_to_datetime(repo.locked[1]))),
'warning')
return redirect(h.url('files_home',
repo_name=repo_name, revision='tip'))
r_post = request.POST
c.commit = self.__get_commit_or_redirect(
revision, repo_name, redirect_after=False)
if c.commit is None:
c.commit = EmptyCommit(alias=c.rhodecode_repo.alias)
c.default_message = (_('Added file via RhodeCode Enterprise'))
c.f_path = f_path
unix_mode = 0
content = convert_line_endings(r_post.get('content', ''), unix_mode)
message = r_post.get('message') or c.default_message
filename = r_post.get('filename')
location = r_post.get('location', '') # dir location
file_obj = r_post.get('upload_file', None)
if file_obj is not None and hasattr(file_obj, 'filename'):
filename = file_obj.filename
content = file_obj.file
if hasattr(content, 'file'):
# non posix systems store real file under file attr
content = content.file
# If there's no commit, redirect to repo summary
if type(c.commit) is EmptyCommit:
redirect_url = "summary_home"
else:
redirect_url = "changeset_home"
if not filename:
h.flash(_('No filename'), category='warning')
return redirect(url(redirect_url, repo_name=c.repo_name,
revision='tip'))
# extract the location from filename,
# allows using foo/bar.txt syntax to create subdirectories
subdir_loc = filename.rsplit('/', 1)
if len(subdir_loc) == 2:
location = os.path.join(location, subdir_loc[0])
# strip all crap out of file, just leave the basename
filename = os.path.basename(filename)
node_path = os.path.join(location, filename)
author = c.rhodecode_user.full_contact
try:
nodes = {
node_path: {
'content': content
}
}
self.scm_model.create_nodes(
user=c.rhodecode_user.user_id,
repo=c.rhodecode_db_repo,
message=message,
nodes=nodes,
parent_commit=c.commit,
author=author,
)
h.flash(_('Successfully committed to %s') % node_path,
category='success')
except NonRelativePathError as e:
h.flash(_(
'The location specified must be a relative path and must not '
'contain .. in the path'), category='warning')
return redirect(url('changeset_home', repo_name=c.repo_name,
revision='tip'))
except (NodeError, NodeAlreadyExistsError) as e:
h.flash(_(e), category='error')
except Exception:
msg = _('Error occurred during commit')
log.exception(msg)
h.flash(msg, category='error')
return redirect(url('changeset_home',
repo_name=c.repo_name, revision='tip'))
@LoginRequired()
@HasRepoPermissionAnyDecorator('repository.write', 'repository.admin')
def add_home(self, repo_name, revision, f_path):
repo = Repository.get_by_repo_name(repo_name)
if repo.enable_locking and repo.locked[0]:
h.flash(_('This repository has been locked by %s on %s')
% (h.person_by_id(repo.locked[0]),
h.format_date(h.time_to_datetime(repo.locked[1]))),
'warning')
return redirect(h.url('files_home',
repo_name=repo_name, revision='tip'))
c.commit = self.__get_commit_or_redirect(
revision, repo_name, redirect_after=False)
if c.commit is None:
c.commit = EmptyCommit(alias=c.rhodecode_repo.alias)
c.default_message = (_('Added file via RhodeCode Enterprise'))
c.f_path = f_path
return render('files/files_add.html')
@LoginRequired()
@HasRepoPermissionAnyDecorator('repository.read', 'repository.write',
'repository.admin')
def archivefile(self, repo_name, fname):
fileformat = None
commit_id = None
ext = None
subrepos = request.GET.get('subrepos') == 'true'
for a_type, ext_data in settings.ARCHIVE_SPECS.items():
archive_spec = fname.split(ext_data[1])
if len(archive_spec) == 2 and archive_spec[1] == '':
fileformat = a_type or ext_data[1]
commit_id = archive_spec[0]
ext = ext_data[1]
dbrepo = RepoModel().get_by_repo_name(repo_name)
if not dbrepo.enable_downloads:
return _('Downloads disabled')
try:
commit = c.rhodecode_repo.get_commit(commit_id)
content_type = settings.ARCHIVE_SPECS[fileformat][0]
except CommitDoesNotExistError:
return _('Unknown revision %s') % commit_id
except EmptyRepositoryError:
return _('Empty repository')
except KeyError:
return _('Unknown archive type')
# archive cache
from rhodecode import CONFIG
archive_name = '%s-%s%s%s' % (
safe_str(repo_name.replace('/', '_')),
'-sub' if subrepos else '',
safe_str(commit.short_id), ext)
use_cached_archive = False
archive_cache_enabled = CONFIG.get(
'archive_cache_dir') and not request.GET.get('no_cache')
if archive_cache_enabled:
# check if we it's ok to write
if not os.path.isdir(CONFIG['archive_cache_dir']):
os.makedirs(CONFIG['archive_cache_dir'])
cached_archive_path = os.path.join(
CONFIG['archive_cache_dir'], archive_name)
if os.path.isfile(cached_archive_path):
log.debug('Found cached archive in %s', cached_archive_path)
fd, archive = None, cached_archive_path
use_cached_archive = True
else:
log.debug('Archive %s is not yet cached', archive_name)
if not use_cached_archive:
# generate new archive
fd, archive = tempfile.mkstemp()
log.debug('Creating new temp archive in %s' % (archive,))
try:
commit.archive_repo(archive, kind=fileformat, subrepos=subrepos)
except ImproperArchiveTypeError:
return _('Unknown archive type')
if archive_cache_enabled:
# if we generated the archive and we have cache enabled
# let's use this for future
log.debug('Storing new archive in %s' % (cached_archive_path,))
shutil.move(archive, cached_archive_path)
archive = cached_archive_path
def get_chunked_archive(archive):
with open(archive, 'rb') as stream:
while True:
data = stream.read(16 * 1024)
if not data:
if fd: # fd means we used temporary file
os.close(fd)
if not archive_cache_enabled:
log.debug('Destroying temp archive %s', archive)
os.remove(archive)
break
yield data
# store download action
action_logger(user=c.rhodecode_user,
action='user_downloaded_archive:%s' % archive_name,
repo=repo_name, ipaddr=self.ip_addr, commit=True)
response.content_disposition = str(
'attachment; filename=%s' % archive_name)
response.content_type = str(content_type)
return get_chunked_archive(archive)
@LoginRequired()
@HasRepoPermissionAnyDecorator('repository.read', 'repository.write',
'repository.admin')
def diff(self, repo_name, f_path):
ignore_whitespace = request.GET.get('ignorews') == '1'
line_context = request.GET.get('context', 3)
diff1 = request.GET.get('diff1', '')
path1, diff1 = parse_path_ref(diff1, default_path=f_path)
diff2 = request.GET.get('diff2', '')
c.action = request.GET.get('diff')
c.no_changes = diff1 == diff2
c.f_path = f_path
c.big_diff = False
c.ignorews_url = _ignorews_url
c.context_url = _context_url
c.changes = OrderedDict()
c.changes[diff2] = []
if not any((diff1, diff2)):
h.flash(
'Need query parameter "diff1" or "diff2" to generate a diff.',
category='error')
raise HTTPBadRequest()
# special case if we want a show commit_id only, it's impl here
# to reduce JS and callbacks
if request.GET.get('show_rev') and diff1:
if str2bool(request.GET.get('annotate', 'False')):
_url = url('files_annotate_home', repo_name=c.repo_name,
revision=diff1, f_path=path1)
else:
_url = url('files_home', repo_name=c.repo_name,
revision=diff1, f_path=path1)
return redirect(_url)
try:
node1 = self._get_file_node(diff1, path1)
node2 = self._get_file_node(diff2, f_path)
except (RepositoryError, NodeError):
log.exception("Exception while trying to get node from repository")
return redirect(url(
'files_home', repo_name=c.repo_name, f_path=f_path))
if all(isinstance(node.commit, EmptyCommit)
for node in (node1, node2)):
raise HTTPNotFound
c.commit_1 = node1.commit
c.commit_2 = node2.commit
if c.action == 'download':
_diff = diffs.get_gitdiff(node1, node2,
ignore_whitespace=ignore_whitespace,
context=line_context)
diff = diffs.DiffProcessor(_diff, format='gitdiff')
diff_name = '%s_vs_%s.diff' % (diff1, diff2)
response.content_type = 'text/plain'
response.content_disposition = (
'attachment; filename=%s' % (diff_name,)
)
charset = self._get_default_encoding()
if charset:
response.charset = charset
return diff.as_raw()
elif c.action == 'raw':
_diff = diffs.get_gitdiff(node1, node2,
ignore_whitespace=ignore_whitespace,
context=line_context)
diff = diffs.DiffProcessor(_diff, format='gitdiff')
response.content_type = 'text/plain'
charset = self._get_default_encoding()
if charset:
response.charset = charset
return diff.as_raw()
else:
fid = h.FID(diff2, node2.path)
line_context_lcl = get_line_ctx(fid, request.GET)
ign_whitespace_lcl = get_ignore_ws(fid, request.GET)
__, commit1, commit2, diff, st, data = diffs.wrapped_diff(
filenode_old=node1,
filenode_new=node2,
diff_limit=self.cut_off_limit_diff,
file_limit=self.cut_off_limit_file,
show_full_diff=request.GET.get('fulldiff'),
ignore_whitespace=ign_whitespace_lcl,
line_context=line_context_lcl,)
c.lines_added = data['stats']['added'] if data else 0
c.lines_deleted = data['stats']['deleted'] if data else 0
c.files = [data]
c.commit_ranges = [c.commit_1, c.commit_2]
c.ancestor = None
c.statuses = []
c.target_repo = c.rhodecode_db_repo
c.filename1 = node1.path
c.filename = node2.path
c.binary_file = node1.is_binary or node2.is_binary
operation = data['operation'] if data else ''
commit_changes = {
# TODO: it's passing the old file to the diff to keep the
# standard but this is not being used for this template,
# but might need both files in the future or a more standard
# way to work with that
'fid': [commit1, commit2, operation,
c.filename, diff, st, data]
}
c.changes = commit_changes
return render('files/file_diff.html')
@LoginRequired()
@HasRepoPermissionAnyDecorator('repository.read', 'repository.write',
'repository.admin')
def diff_2way(self, repo_name, f_path):
diff1 = request.GET.get('diff1', '')
diff2 = request.GET.get('diff2', '')
nodes = []
unknown_commits = []
for commit in [diff1, diff2]:
try:
nodes.append(self._get_file_node(commit, f_path))
except (RepositoryError, NodeError):
log.exception('%(commit)s does not exist' % {'commit': commit})
unknown_commits.append(commit)
h.flash(h.literal(
_('Commit %(commit)s does not exist.') % {'commit': commit}
), category='error')
if unknown_commits:
return redirect(url('files_home', repo_name=c.repo_name,
f_path=f_path))
if all(isinstance(node.commit, EmptyCommit) for node in nodes):
raise HTTPNotFound
node1, node2 = nodes
f_gitdiff = diffs.get_gitdiff(node1, node2, ignore_whitespace=False)
diff_processor = diffs.DiffProcessor(f_gitdiff, format='gitdiff')
diff_data = diff_processor.prepare()
if not diff_data or diff_data[0]['raw_diff'] == '':
h.flash(h.literal(_('%(file_path)s has not changed '
'between %(commit_1)s and %(commit_2)s.') % {
'file_path': f_path,
'commit_1': node1.commit.id,
'commit_2': node2.commit.id
}), category='error')
return redirect(url('files_home', repo_name=c.repo_name,
f_path=f_path))
c.diff_data = diff_data[0]
c.FID = h.FID(diff2, node2.path)
# cleanup some unneeded data
del c.diff_data['raw_diff']
del c.diff_data['chunks']
c.node1 = node1
c.commit_1 = node1.commit
c.node2 = node2
c.commit_2 = node2.commit
return render('files/diff_2way.html')
def _get_file_node(self, commit_id, f_path):
if commit_id not in ['', None, 'None', '0' * 12, '0' * 40]:
commit = c.rhodecode_repo.get_commit(commit_id=commit_id)
try:
node = commit.get_node(f_path)
if node.is_dir():
raise NodeError('%s path is a %s not a file'
% (node, type(node)))
except NodeDoesNotExistError:
commit = EmptyCommit(
commit_id=commit_id,
idx=commit.idx,
repo=commit.repository,
alias=commit.repository.alias,
message=commit.message,
author=commit.author,
date=commit.date)
node = FileNode(f_path, '', commit=commit)
else:
commit = EmptyCommit(
repo=c.rhodecode_repo,
alias=c.rhodecode_repo.alias)
node = FileNode(f_path, '', commit=commit)
return node
def _get_node_history(self, commit, f_path, commits=None):
"""
get commit history for given node
:param commit: commit to calculate history
:param f_path: path for node to calculate history for
:param commits: if passed don't calculate history and take
commits defined in this list
"""
# calculate history based on tip
tip = c.rhodecode_repo.get_commit()
if commits is None:
pre_load = ["author", "branch"]
try:
commits = tip.get_file_history(f_path, pre_load=pre_load)
except (NodeDoesNotExistError, CommitError):
# this node is not present at tip!
commits = commit.get_file_history(f_path, pre_load=pre_load)
history = []
commits_group = ([], _("Changesets"))
for commit in commits:
branch = ' (%s)' % commit.branch if commit.branch else ''
n_desc = 'r%s:%s%s' % (commit.idx, commit.short_id, branch)
commits_group[0].append((commit.raw_id, n_desc,))
history.append(commits_group)
symbolic_reference = self._symbolic_reference
if c.rhodecode_repo.alias == 'svn':
adjusted_f_path = self._adjust_file_path_for_svn(
f_path, c.rhodecode_repo)
if adjusted_f_path != f_path:
log.debug(
'Recognized svn tag or branch in file "%s", using svn '
'specific symbolic references', f_path)
f_path = adjusted_f_path
symbolic_reference = self._symbolic_reference_svn
branches = self._create_references(
c.rhodecode_repo.branches, symbolic_reference, f_path)
branches_group = (branches, _("Branches"))
tags = self._create_references(
c.rhodecode_repo.tags, symbolic_reference, f_path)
tags_group = (tags, _("Tags"))
history.append(branches_group)
history.append(tags_group)
return history, commits
def _adjust_file_path_for_svn(self, f_path, repo):
"""
Computes the relative path of `f_path`.
This is mainly based on prefix matching of the recognized tags and
branches in the underlying repository.
"""
tags_and_branches = itertools.chain(
repo.branches.iterkeys(),
repo.tags.iterkeys())
tags_and_branches = sorted(tags_and_branches, key=len, reverse=True)
for name in tags_and_branches:
if f_path.startswith(name + '/'):
f_path = vcspath.relpath(f_path, name)
break
return f_path
def _create_references(
self, branches_or_tags, symbolic_reference, f_path):
items = []
for name, commit_id in branches_or_tags.items():
sym_ref = symbolic_reference(commit_id, name, f_path)
items.append((sym_ref, name))
return items
def _symbolic_reference(self, commit_id, name, f_path):
return commit_id
def _symbolic_reference_svn(self, commit_id, name, f_path):
new_f_path = vcspath.join(name, f_path)
return u'%s@%s' % (new_f_path, commit_id)
@LoginRequired()
@XHRRequired()
@HasRepoPermissionAnyDecorator(
'repository.read', 'repository.write', 'repository.admin')
@jsonify
def nodelist(self, repo_name, revision, f_path):
commit = self.__get_commit_or_redirect(revision, repo_name)
metadata = self._get_nodelist_at_commit(
repo_name, commit.raw_id, f_path)
return {'nodes': metadata}
@LoginRequired()
@XHRRequired()
@HasRepoPermissionAnyDecorator(
'repository.read', 'repository.write', 'repository.admin')
def nodetree_full(self, repo_name, commit_id, f_path):
"""
Returns rendered html of file tree that contains commit date,
author, revision for the specified combination of
repo, commit_id and file path
:param repo_name: name of the repository
:param commit_id: commit_id of file tree
:param f_path: file path of the requested directory
"""
commit = self.__get_commit_or_redirect(commit_id, repo_name)
try:
dir_node = commit.get_node(f_path)
except RepositoryError as e:
return 'error {}'.format(safe_str(e))
if dir_node.is_file():
return ''
c.file = dir_node
c.commit = commit
# using force=True here, make a little trick. We flush the cache and
# compute it using the same key as without full_load, so the fully
# loaded cached tree is now returned instead of partial
return self._get_tree_at_commit(
repo_name, commit.raw_id, dir_node.path, full_load=True,
force=True)