files.py
1114 lines
| 43.7 KiB
| text/x-python
|
PythonLexer
| r1 | # -*- 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): | ||||
| def _cached_tree(): | ||||
| log.debug('Generating cached file tree for %s, %s, %s', | ||||
| repo_name, commit_id, f_path) | ||||
| return render('files/files_browser.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) | ||||
| 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) | ||||
| def _get_metadata_at_commit(self, repo_name, commit, dir_node): | ||||
| def _cached_metadata(): | ||||
| log.debug('Generating cached metadata for %s, %s, %s', | ||||
| repo_name, commit.raw_id, safe_str(dir_node.path)) | ||||
| data = ScmModel().get_dirnode_metadata(commit, dir_node) | ||||
| return data | ||||
| cache_manager = self.__get_tree_cache_manager( | ||||
| repo_name, caches.FILE_TREE_META) | ||||
| cache_key = caches.compute_key_from_params( | ||||
| repo_name, commit.raw_id, safe_str(dir_node.path)) | ||||
| return cache_manager.get(cache_key, createfunc=_cached_metadata) | ||||
| @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') | ||||
| @jsonify | ||||
| def metadata_list(self, repo_name, revision, f_path): | ||||
| """ | ||||
| Returns a json dict that contains commit date, author, revision | ||||
| and id for the specified repo, revision and file path | ||||
| :param repo_name: name of the repository | ||||
| :param revision: revision of files | ||||
| :param f_path: file path of the requested directory | ||||
| """ | ||||
| commit = self.__get_commit_or_redirect(revision, repo_name) | ||||
| try: | ||||
| file_node = commit.get_node(f_path) | ||||
| except RepositoryError as e: | ||||
| return {'error': safe_str(e)} | ||||
| metadata = self._get_metadata_at_commit( | ||||
| repo_name, commit, file_node) | ||||
| return {'metadata': metadata} | ||||
