rhodecode/controllers/files.py

# -*- 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}