# get our arglist and check if we provided them as args

        for arg, default in func_kwargs.iteritems():

            if arg == USER_SESSION_ATTR:

                # USER_SESSION_ATTR is something translated from API key and

                # this is checked before so we don't need validate it

                continue

            # skip the required param check if it's default value is

            # NotImplementedType (default_empty)

            if default == default_empty and arg not in self._request_params:

                raise JSONRPCErrorResponse(

                    retid=self._req_id,

                    message='Missing non optional `%s` arg in JSON DATA' % arg,

                )

        extra = set(self._request_params).difference(func_kwargs)

        if extra:

            raise JSONRPCErrorResponse(

                retid=self._req_id,

                message='Unknown %s arg in JSON DATA' %

                        ', '.join('`%s`' % arg for arg in extra),

            )

        self._rpc_args = {}

        self._rpc_args.update(self._request_params)

        self._rpc_args['action'] = self._req_method

        self._rpc_args['environ'] = environ

        log.info('IP: %s Request to %s time: %.3fs' % (

            self._get_ip_addr(environ),

            safe_unicode(_get_access_path(environ)), time.time() - start)

        )

        state.set_action(self._rpc_call, [])

        state.set_params(self._rpc_args)

        return state

    def _rpc_call(self, action, environ, **rpc_args):

        """

        Call the specified RPC Method

        """

        raw_response = ''

        try:

            raw_response = getattr(self, action)(**rpc_args)

            if isinstance(raw_response, HTTPError):

                self._error = str(raw_response)

        except JSONRPCError as e:

        except Exception as e:

            log.error('Encountered unhandled exception: %s',

                      traceback.format_exc(),)

            json_exc = JSONRPCError('Internal server error')

        if self._error is not None:

            raw_response = None

        response = dict(id=self._req_id, result=raw_response, error=self._error)

        try:

            return json.dumps(response)

        except TypeError as e:

            log.error('API FAILED. Error encoding response: %s', e)

            return json.dumps(

                dict(

                    id=self._req_id,

                    result=None,

                    error="Error encoding response"

                )

            )

    def _find_method(self):

        """

        Return method named by `self._req_method` in controller if able

        """

        log.debug('Trying to find JSON-RPC method: %s', self._req_method)

        if self._req_method.startswith('_'):

            raise AttributeError("Method not allowed")

        try:

            func = getattr(self, self._req_method, None)

        except UnicodeEncodeError:

            raise AttributeError("Problem decoding unicode in requested "

                                 "method name.")

        if isinstance(func, types.MethodType):

            return func

        else:

            raise AttributeError("No such method: %s" % (self._req_method,))

:created_on: Apr 21, 2010

:author: marcink

:copyright: (c) 2013 RhodeCode GmbH, and others.

:license: GPLv3, see LICENSE.md for more details.

"""

import logging

import traceback

from tg import request, session

from tg import tmpl_context as c

from tg.i18n import ugettext as _

from webob.exc import HTTPBadRequest, HTTPFound, HTTPNotFound

import kallithea.lib.helpers as h

from kallithea.config.routing import url

from kallithea.lib.auth import HasRepoPermissionLevelDecorator, LoginRequired

from kallithea.lib.base import BaseRepoController, render

from kallithea.lib.graphmod import graph_data

from kallithea.lib.page import Page

from kallithea.lib.utils2 import safe_int, safe_str

from kallithea.lib.vcs.exceptions import ChangesetDoesNotExistError, ChangesetError, EmptyRepositoryError, NodeDoesNotExistError, RepositoryError

log = logging.getLogger(__name__)

class ChangelogController(BaseRepoController):

    def _before(self, *args, **kwargs):

        super(ChangelogController, self)._before(*args, **kwargs)

        c.affected_files_cut_off = 60

    @staticmethod

    def __get_cs(rev, repo):

        """

        Safe way to get changeset. If error occur fail with error message.

        :param rev: revision to fetch

        :param repo: repo instance

        """

        try:

            return c.db_repo_scm_instance.get_changeset(rev)

        except EmptyRepositoryError as e:

            h.flash(_('There are no changesets yet'), category='error')

        except RepositoryError as e:

            log.error(traceback.format_exc())

        raise HTTPBadRequest()

    @LoginRequired(allow_default_user=True)

    @HasRepoPermissionLevelDecorator('read')

    def index(self, repo_name, revision=None, f_path=None):

        limit = 2000

        default = 100

        if request.GET.get('size'):

            c.size = max(min(safe_int(request.GET.get('size')), limit), 1)

            session['changelog_size'] = c.size

            session.save()

        else:

            c.size = int(session.get('changelog_size', default))

        # min size must be 1

        c.size = max(c.size, 1)

        p = safe_int(request.GET.get('page'), 1)

        branch_name = request.GET.get('branch', None)

        if (branch_name and

            branch_name not in c.db_repo_scm_instance.branches and

            branch_name not in c.db_repo_scm_instance.closed_branches and

            not revision

        ):

            raise HTTPFound(location=url('changelog_file_home', repo_name=c.repo_name,

                                    revision=branch_name, f_path=f_path or ''))

        if revision == 'tip':

            revision = None

        c.changelog_for_path = f_path

        try:

            if f_path:

                log.debug('generating changelog for path %s', f_path)

                # get the history for the file !

                tip_cs = c.db_repo_scm_instance.get_changeset()

                try:

                    collection = tip_cs.get_file_history(f_path)

                except (NodeDoesNotExistError, ChangesetError):

                    # this node is not present at tip !

                    try:

                        cs = self.__get_cs(revision, repo_name)

                        collection = cs.get_file_history(f_path)

                    except RepositoryError as e:

                        raise HTTPFound(location=h.url('changelog_home', repo_name=repo_name))

            else:

                collection = c.db_repo_scm_instance.get_changesets(start=0, end=revision,

                                                        branch_name=branch_name, reverse=True)

            c.total_cs = len(collection)

            c.cs_pagination = Page(collection, page=p, item_count=c.total_cs, items_per_page=c.size,

                                   branch=branch_name)

            page_revisions = [x.raw_id for x in c.cs_pagination]

            c.cs_comments = c.db_repo.get_comments(page_revisions)

            c.cs_statuses = c.db_repo.statuses(page_revisions)

        except EmptyRepositoryError as e:

            raise HTTPFound(location=url('summary_home', repo_name=c.repo_name))

        except (RepositoryError, ChangesetDoesNotExistError, Exception) as e:

            log.error(traceback.format_exc())

            raise HTTPFound(location=url('changelog_home', repo_name=c.repo_name))

        c.branch_name = branch_name

        c.branch_filters = [('', _('None'))] + \

            [(k, k) for k in c.db_repo_scm_instance.branches.keys()]

        if c.db_repo_scm_instance.closed_branches:

            prefix = _('(closed)') + ' '

            c.branch_filters += [('-', '-')] + \

                [(k, prefix + k) for k in c.db_repo_scm_instance.closed_branches.keys()]

        revs = []

        if not f_path:

            revs = [x.revision for x in c.cs_pagination]

        c.jsdata = graph_data(c.db_repo_scm_instance, revs)

        c.revision = revision # requested revision ref

        c.first_revision = c.cs_pagination[0] # pagination is never empty here!

        return render('changelog/changelog.html')

    @LoginRequired(allow_default_user=True)

    @HasRepoPermissionLevelDecorator('read')

    def changelog_details(self, cs):

        if request.environ.get('HTTP_X_PARTIAL_XHR'):

            c.cs = c.db_repo_scm_instance.get_changeset(cs)

            return render('changelog/changelog_details.html')

        raise HTTPNotFound()

from kallithea.lib.auth import HasRepoPermissionLevelDecorator, LoginRequired

from kallithea.lib.base import BaseRepoController, jsonify, render

from kallithea.lib.exceptions import NonRelativePathError

from kallithea.lib.utils import action_logger

from kallithea.lib.utils2 import convert_line_endings, detect_mode, safe_int, safe_str, str2bool

from kallithea.lib.vcs.backends.base import EmptyChangeset

from kallithea.lib.vcs.conf import settings

from kallithea.lib.vcs.exceptions import (

    ChangesetDoesNotExistError, ChangesetError, EmptyRepositoryError, ImproperArchiveTypeError, NodeAlreadyExistsError, NodeDoesNotExistError, NodeError, RepositoryError, VCSError)

from kallithea.lib.vcs.nodes import FileNode

from kallithea.model.db import Repository

from kallithea.model.repo import RepoModel

from kallithea.model.scm import ScmModel

log = logging.getLogger(__name__)

class FilesController(BaseRepoController):

    def _before(self, *args, **kwargs):

        super(FilesController, self)._before(*args, **kwargs)

    def __get_cs(self, rev, silent_empty=False):

        """

        Safe way to get changeset if error occur it redirects to tip with

        proper message

        :param rev: revision to fetch

        :silent_empty: return None if repository is empty

        """

        try:

            return c.db_repo_scm_instance.get_changeset(rev)

        except EmptyRepositoryError as e:

            if silent_empty:

                return None

            url_ = url('files_add_home',

                       repo_name=c.repo_name,

                       revision=0, f_path='', anchor='edit')

            add_new = h.link_to(_('Click here to add new file'), url_, class_="alert-link")

            h.flash(_('There are no files yet.') + ' ' + add_new, category='warning')

            raise HTTPNotFound()

        except (ChangesetDoesNotExistError, LookupError):

            msg = _('Such revision does not exist for this repository')

            h.flash(msg, category='error')

            raise HTTPNotFound()

        except RepositoryError as e:

            raise HTTPNotFound()

    def __get_filenode(self, cs, path):

        """

        Returns file_node or raise HTTP error.

        :param cs: given changeset

        :param path: path to lookup

        """

        try:

            file_node = cs.get_node(path)

            if file_node.is_dir():

                raise RepositoryError('given path is a directory')

        except ChangesetDoesNotExistError:

            msg = _('Such revision does not exist for this repository')

            h.flash(msg, category='error')

            raise HTTPNotFound()

        except RepositoryError as e:

            raise HTTPNotFound()

        return file_node

    @LoginRequired(allow_default_user=True)

    @HasRepoPermissionLevelDecorator('read')

    def index(self, repo_name, revision, f_path, annotate=False):

        # redirect to given revision from form if given

        post_revision = request.POST.get('at_rev', None)

        if post_revision:

            cs = self.__get_cs(post_revision) # FIXME - unused!

        c.revision = revision

        c.changeset = self.__get_cs(revision)

        c.branch = request.GET.get('branch', None)

        c.f_path = f_path

        c.annotate = annotate

        cur_rev = c.changeset.revision

        # used in files_source.html:

        c.cut_off_limit = self.cut_off_limit

        c.fulldiff = request.GET.get('fulldiff')

        # prev link

        try:

            prev_rev = c.db_repo_scm_instance.get_changeset(cur_rev).prev(c.branch)

            c.url_prev = url('files_home', repo_name=c.repo_name,

                         revision=prev_rev.raw_id, f_path=f_path)

            if c.branch:

                c.url_prev += '?branch=%s' % c.branch

        except (ChangesetDoesNotExistError, VCSError):

            c.url_prev = '#'

        # next link

        try:

            next_rev = c.db_repo_scm_instance.get_changeset(cur_rev).next(c.branch)

            c.url_next = url('files_home', repo_name=c.repo_name,

                     revision=next_rev.raw_id, f_path=f_path)

            if c.branch:

                c.url_next += '?branch=%s' % c.branch

        except (ChangesetDoesNotExistError, VCSError):

            c.url_next = '#'

        # files or dirs

        try:

            c.file = c.changeset.get_node(f_path)

            if c.file.is_submodule():

                raise HTTPFound(location=c.file.url)

            elif c.file.is_file():

                c.load_full_history = False

                # determine if we're on branch head

                _branches = c.db_repo_scm_instance.branches

                c.on_branch_head = revision in _branches or revision in _branches.values()

                _hist = []

                c.file_history = []

                if c.load_full_history:

                    c.file_history, _hist = self._get_node_history(c.changeset, f_path)

                c.authors = []

                for a in set([x.author for x in _hist]):

                    c.authors.append((h.email(a), h.person(a)))

            else:

                c.authors = c.file_history = []

        except RepositoryError as e:

            raise HTTPNotFound()

        if request.environ.get('HTTP_X_PARTIAL_XHR'):

            return render('files/files_ypjax.html')

        # TODO: tags and bookmarks?

        c.revision_options = [(c.changeset.raw_id,

                              _('%s at %s') % (b, h.short_id(c.changeset.raw_id))) for b in c.changeset.branches] + \

            [(n, b) for b, n in c.db_repo_scm_instance.branches.items()]

        if c.db_repo_scm_instance.closed_branches:

            prefix = _('(closed)') + ' '

            c.revision_options += [('-', '-')] + \

                [(n, prefix + b) for b, n in c.db_repo_scm_instance.closed_branches.items()]

        return render('files/files.html')

    @LoginRequired(allow_default_user=True)

    @HasRepoPermissionLevelDecorator('read')

    @jsonify

    def history(self, repo_name, revision, f_path):

        changeset = self.__get_cs(revision)

        _file = changeset.get_node(f_path)

        if _file.is_file():

            file_history, _hist = self._get_node_history(changeset, 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(allow_default_user=True)

    @HasRepoPermissionLevelDecorator('read')

    def authors(self, repo_name, revision, f_path):

        changeset = self.__get_cs(revision)

        _file = changeset.get_node(f_path)

        if _file.is_file():

            file_history, _hist = self._get_node_history(changeset, f_path)

            c.authors = []

            for a in set([x.author for x in _hist]):

                c.authors.append((h.email(a), h.person(a)))

class SummaryController(BaseRepoController):

    def __get_readme_data(self, db_repo):

        repo_name = db_repo.repo_name

        log.debug('Looking for README file')

        @cache_region('long_term', '_get_readme_from_cache')

        def _get_readme_from_cache(*_cache_keys):  # parameters are not really used - only as caching key

            readme_data = None

            readme_file = None

            try:

                # gets the landing revision! or tip if fails

                cs = db_repo.get_landing_changeset()

                if isinstance(cs, EmptyChangeset):

                    raise EmptyRepositoryError()

                renderer = MarkupRenderer()

                for f in README_FILES:

                    try:

                        readme = cs.get_node(f)

                        if not isinstance(readme, FileNode):

                            continue

                        readme_file = f

                        log.debug('Found README file `%s` rendering...',

                                  readme_file)

                        readme_data = renderer.render(readme.content,

                                                      filename=f)

                        break

                    except NodeDoesNotExistError:

                        continue

            except ChangesetError:

                log.error(traceback.format_exc())

                pass

            except EmptyRepositoryError:

                pass

            return readme_data, readme_file

        kind = 'README'

        return _get_readme_from_cache(repo_name, kind, c.db_repo.changeset_cache.get('raw_id'))

    @LoginRequired(allow_default_user=True)

    @HasRepoPermissionLevelDecorator('read')

    def index(self, repo_name):

        p = safe_int(request.GET.get('page'), 1)

        size = safe_int(request.GET.get('size'), 10)

        try:

            collection = c.db_repo_scm_instance.get_changesets(reverse=True)

        except EmptyRepositoryError as e:

            collection = []

        c.cs_pagination = Page(collection, page=p, items_per_page=size)

        page_revisions = [x.raw_id for x in list(c.cs_pagination)]

        c.cs_comments = c.db_repo.get_comments(page_revisions)

        c.cs_statuses = c.db_repo.statuses(page_revisions)

        c.ssh_repo_url = None

        if request.authuser.is_default_user:

            username = None

        else:

            username = request.authuser.username

            if c.ssh_enabled:

                c.ssh_repo_url = c.db_repo.clone_url(clone_uri_tmpl=c.clone_ssh_tmpl)

        c.clone_repo_url = c.db_repo.clone_url(clone_uri_tmpl=c.clone_uri_tmpl, with_id=False, username=username)

        c.clone_repo_url_id = c.db_repo.clone_url(clone_uri_tmpl=c.clone_uri_tmpl, with_id=True, username=username)

        if c.db_repo.enable_statistics:

            c.show_stats = True

        else:

            c.show_stats = False

        stats = Statistics.query() \

            .filter(Statistics.repository == c.db_repo) \

            .scalar()

        c.stats_percentage = 0

        if stats and stats.languages:

            c.no_data = False is c.db_repo.enable_statistics

            lang_stats_d = json.loads(stats.languages)

            lang_stats = [(x, {"count": y,

                               "desc": LANGUAGES_EXTENSIONS_MAP.get(x, '?')})

                          for x, y in lang_stats_d.items()]

            lang_stats.sort(key=lambda k: (-k[1]['count'], k[0]))

            c.trending_languages = lang_stats[:10]

        else:

            c.no_data = True

            c.trending_languages = []

        c.enable_downloads = c.db_repo.enable_downloads

        c.readme_data, c.readme_file = \

            self.__get_readme_data(c.db_repo)

        return render('summary/summary.html')

    @LoginRequired()

            # allow to delete repos that are somehow damages in filesystem

            if route in ['delete_repo']:

                return

            if _dbr.repo_state in [Repository.STATE_PENDING]:

                if route in ['repo_creating_home']:

                    return

                check_url = url('repo_creating_home', repo_name=c.repo_name)

                raise webob.exc.HTTPFound(location=check_url)

            dbr = c.db_repo = _dbr

            c.db_repo_scm_instance = c.db_repo.scm_instance

            if c.db_repo_scm_instance is None:

                log.error('%s this repository is present in database but it '

                          'cannot be created as an scm instance', c.repo_name)

                from kallithea.lib import helpers as h

                h.flash(_('Repository not found in the filesystem'),

                        category='error')

                raise webob.exc.HTTPNotFound()

            # some globals counter for menu

            c.repository_followers = self.scm_model.get_followers(dbr)

            c.repository_forks = self.scm_model.get_forks(dbr)

            c.repository_pull_requests = self.scm_model.get_pull_requests(dbr)

            c.repository_following = self.scm_model.is_following_repo(

                                    c.repo_name, request.authuser.user_id)

    @staticmethod

    def _get_ref_rev(repo, ref_type, ref_name, returnempty=False):

        """

        Safe way to get changeset. If error occurs show error.

        """

        from kallithea.lib import helpers as h

        try:

            return repo.scm_instance.get_ref_revision(ref_type, ref_name)

        except EmptyRepositoryError as e:

            if returnempty:

                return repo.scm_instance.EMPTY_CHANGESET

            h.flash(_('There are no changesets yet'), category='error')

            raise webob.exc.HTTPNotFound()

        except ChangesetDoesNotExistError as e:

            h.flash(_('Changeset for %s %s not found in %s') %

                              (ref_type, ref_name, repo.repo_name),

                    category='error')

            raise webob.exc.HTTPNotFound()

        except RepositoryError as e:

            log.error(traceback.format_exc())

            raise webob.exc.HTTPBadRequest()

@decorator.decorator

def jsonify(func, *args, **kwargs):

    """Action decorator that formats output for JSON

    Given a function that will return content, this decorator will turn

    the result into JSON, with a content-type of 'application/json' and

    output it.

    """

    response.headers['Content-Type'] = 'application/json; charset=utf-8'

    data = func(*args, **kwargs)

    if isinstance(data, (list, tuple)):

        # A JSON list response is syntactically valid JavaScript and can be

        # loaded and executed as JavaScript by a malicious third-party site

        # using <script>, which can lead to cross-site data leaks.

        # JSON responses should therefore be scalars or objects (i.e. Python

        # dicts), because a JSON object is a syntax error if intepreted as JS.

        msg = "JSON responses with Array envelopes are susceptible to " \

              "cross-site data leak attacks, see " \

              "https://web.archive.org/web/20120519231904/http://wiki.pylonshq.com/display/pylonsfaq/Warnings"

        warnings.warn(msg, Warning, 2)

        log.warning(msg)

    log.debug("Returning JSON wrapped action output")

    return json.dumps(data)

@decorator.decorator

def IfSshEnabled(func, *args, **kwargs):

    """Decorator for functions that can only be called if SSH access is enabled.

    If SSH access is disabled in the configuration file, HTTPNotFound is raised.

    """

    if not c.ssh_enabled:

        from kallithea.lib import helpers as h

        h.flash(_("SSH access is disabled."), category='warning')

        raise webob.exc.HTTPNotFound()

    return func(*args, **kwargs)

    try:

        val = int(val)

    except (ValueError, TypeError):

        val = default

    return val

def safe_unicode(s):

    """

    Safe unicode function. Use a few tricks to turn s into unicode string:

    In case of UnicodeDecodeError with configured default encodings, try to

    detect encoding with chardet library, then fall back to first encoding with

    errors replaced.

    """

    if isinstance(s, unicode):

        return s

    if not isinstance(s, str):  # use __str__ / __unicode__ and don't expect UnicodeDecodeError

        return unicode(s)

    from kallithea.lib.vcs.conf import settings

    for enc in settings.DEFAULT_ENCODINGS:

        try:

            return unicode(s, enc)

        except UnicodeDecodeError:

            pass

    try:

        import chardet

        encoding = chardet.detect(s)['encoding']

        if encoding is not None:

            return s.decode(encoding)

    except (ImportError, UnicodeDecodeError):

        pass

    return unicode(s, settings.DEFAULT_ENCODINGS[0], 'replace')

def safe_str(s):

    """

    Safe str function. Use a few tricks to turn s into bytes string:

    In case of UnicodeEncodeError with configured default encodings, fall back

    to first configured encoding with errors replaced.

    """

    if isinstance(s, str):

        return s

    from kallithea.lib.vcs.conf import settings

    for enc in settings.DEFAULT_ENCODINGS:

        try:

            return s.encode(enc)

        except UnicodeEncodeError:

            pass

    return s.encode(settings.DEFAULT_ENCODINGS[0], 'replace')

# Regex taken from http://www.regular-expressions.info/email.html

email_re = re.compile(

    r"""[a-z0-9!#$%&'*+/=?^_`{|}~-]+(?:\.[a-z0-9!#$%&'*+/=?^_`{|}~-]+)*@"""

    r"""(?:[a-z0-9](?:[a-z0-9-]*[a-z0-9])?\.)+[a-z0-9](?:[a-z0-9-]*[a-z0-9])?""",

    re.IGNORECASE)

def author_email(author):

    """

    Returns email address of given author string.

    If author contains <> brackets, only look inside that.

    If any RFC valid email address is found, return that.

    Else, return empty string.

    """

    if not author:

        return ''

    l = author.find('<') + 1

    if l != 0:

        r = author.find('>', l)

        if r != -1:

            author = author[l:r]

    m = email_re.search(author)

    if m is None:

        return ''

    return safe_str(m.group(0))

def author_name(author):

    """

    get name of author, or else username.

    It'll try to find an email in the author string and just cut it off

    to get the username

    """

    if not author: