This file was forked by the Kallithea project in July 2014.

Original author and date, and relevant copyright and licensing information is below:

:created_on: May 6, 2012

:author: marcink

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

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

"""

import logging

import re

from tg import request

from tg import tmpl_context as c

from tg.i18n import ugettext as _

from webob.exc import HTTPBadRequest, HTTPFound, HTTPNotFound

from kallithea.config.routing import url

from kallithea.controllers.changeset import _context_url, _ignorews_url

from kallithea.lib import diffs

from kallithea.lib import helpers as h

from kallithea.lib.auth import HasRepoPermissionLevelDecorator, LoginRequired

from kallithea.lib.base import BaseRepoController, render

from kallithea.lib.graphmod import graph_data

from kallithea.lib.vcs.utils.hgcompat import unionrepo

from kallithea.model.db import Repository

log = logging.getLogger(__name__)

class CompareController(BaseRepoController):

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

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

        # The base repository has already been retrieved.

        c.a_repo = c.db_repo

        # Retrieve the "changeset" repository (default: same as base).

        other_repo = request.GET.get('other_repo', None)

        if other_repo is None:

            c.cs_repo = c.a_repo

        else:

            c.cs_repo = Repository.get_by_repo_name(other_repo)

            if c.cs_repo is None:

                msg = _('Could not find other repository %s') % other_repo

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

        :param org_repo: repo object, that is most likely the original repo we forked from

        :param org_rev: the revision we want our compare to be made

        :param other_repo: repo object, most likely the fork of org_repo. It has

            all changesets that we need to obtain

        :param other_rev: revision we want out compare to be made on other_repo

        """

        ancestors = None

        if org_rev == other_rev:

            org_changesets = []

            other_changesets = []

        elif alias == 'hg':

            # case two independent repos

            if org_repo != other_repo:

                hgrepo = unionrepo.makeunionrepository(other_repo.baseui,

                                                       other_repo.path,

                                                       org_repo.path)

                # all ancestors of other_rev will be in other_repo and

                # rev numbers from hgrepo can be used in other_repo - org_rev ancestors cannot

            # no remote compare do it on the same repository

            else:

                hgrepo = other_repo._repo

            if ancestors:

                log.debug("shortcut found: %s is already an ancestor of %s", other_rev, org_rev)

            else:

                log.debug("no shortcut found: %s is not an ancestor of %s", other_rev, org_rev)

            other_changesets = [

                other_repo.get_changeset(rev)

                for rev in hgrepo.revs(

                    b"ancestors(id(%s)) and not ancestors(id(%s)) and not id(%s)",

            ]

            org_changesets = [

                for rev in hgrepo.revs(

                    b"ancestors(id(%s)) and not ancestors(id(%s)) and not id(%s)",

            ]

        elif alias == 'git':

            if org_repo != other_repo:

                from dulwich.repo import Repo

                from dulwich.client import SubprocessGitClient

                gitrepo = Repo(org_repo.path)

                SubprocessGitClient(thin_packs=False).fetch(safe_str(other_repo.path), gitrepo)

                gitrepo_remote = Repo(other_repo.path)

                SubprocessGitClient(thin_packs=False).fetch(safe_str(org_repo.path), gitrepo_remote)

                revs = [

                ]

                other_changesets = [other_repo.get_changeset(rev) for rev in reversed(revs)]

                if other_changesets:

                    ancestors = [other_changesets[0].parents[0].raw_id]

                else:

                    # no changesets from other repo, ancestor is the other_rev

                    ancestors = [other_rev]

                gitrepo.close()

                gitrepo_remote.close()

            else:

                so = org_repo.run_git_command(

                    ['log', '--reverse', '--pretty=format:%H',

                     '-s', '%s..%s' % (org_rev, other_rev)]

                )

                other_changesets = [org_repo.get_changeset(cs)

                              for cs in re.findall(r'[0-9a-fA-F]{40}', so)]

                so = org_repo.run_git_command(

                    ['merge-base', org_rev, other_rev]

                )

                ancestors = [re.findall(r'[0-9a-fA-F]{40}', so)[0]]

            org_changesets = []

Original author and date, and relevant copyright and licensing information is below:

:created_on: May 7, 2012

:author: marcink

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

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

"""

import logging

import traceback

import formencode

from tg import request

from tg import tmpl_context as c

from tg.i18n import ugettext as _

from webob.exc import HTTPBadRequest, HTTPForbidden, HTTPFound, HTTPNotFound

from kallithea.config.routing import url

from kallithea.controllers.changeset import _context_url, _ignorews_url, create_cs_pr_comment, delete_cs_pr_comment

from kallithea.lib import diffs

from kallithea.lib import helpers as h

from kallithea.lib.auth import HasRepoPermissionLevelDecorator, LoginRequired

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

from kallithea.lib.graphmod import graph_data

from kallithea.lib.page import Page

from kallithea.lib.vcs.exceptions import ChangesetDoesNotExistError, EmptyRepositoryError

from kallithea.lib.vcs.utils.hgcompat import unionrepo

from kallithea.model.changeset_status import ChangesetStatusModel

from kallithea.model.comment import ChangesetCommentsModel

from kallithea.model.db import ChangesetStatus, PullRequest, PullRequestReviewer, Repository, User

from kallithea.model.forms import PullRequestForm, PullRequestPostForm

from kallithea.model.meta import Session

from kallithea.model.pull_request import CreatePullRequestAction, CreatePullRequestIterationAction, PullRequestModel

log = logging.getLogger(__name__)

def _get_reviewer(user_id):

    """Look up user by ID and validate it as a potential reviewer."""

    try:

        user = User.get(int(user_id))

    except ValueError:

        user = None

    if user is None or user.is_default_user:

        h.flash(_('Invalid reviewer "%s" specified') % user_id, category='error')

        raise HTTPBadRequest()

    return user

class PullrequestsController(BaseRepoController):

    def _get_repo_refs(self, repo, rev=None, branch=None, branch_rev=None):

        """return a structure with repo's interesting changesets, suitable for

        the selectors in pullrequest.html

        rev: a revision that must be in the list somehow and selected by default

        branch: a branch that must be in the list and selected by default - even if closed

        branch_rev: a revision of which peers should be preferred and available."""

        # list named branches that has been merged to this named branch - it should probably merge back

        peers = []

        if rev:

            rev = safe_str(rev)

        if branch:

            branch = safe_str(branch)

        if branch_rev:

            # a revset not restricting to merge() would be better

            # (especially because it would get the branch point)

            # ... but is currently too expensive

            # including branches of children could be nice too

            peerbranches = set()

            for i in repo._repo.revs(

                b"sort(parents(branch(id(%s)) and merge()) - branch(id(%s)), -rev)",

            ):

                for abranch in repo.get_changeset(i).branches:

                    if abranch not in peerbranches:

                        n = 'branch:%s:%s' % (abranch, repo.get_changeset(abranch).raw_id)

                        peers.append((n, abranch))

                        peerbranches.add(abranch)

        selected = None

        tiprev = repo.tags.get('tip')

        tipbranch = None

        branches = []

        for abranch, branchrev in repo.branches.iteritems():

            n = 'branch:%s:%s' % (abranch, branchrev)

            desc = abranch

            if branchrev == tiprev:

                tipbranch = abranch

                desc = '%s (current tip)' % desc

            branches.append((n, desc))

            if rev == branchrev:

                selected = n

            if branch == abranch:

                if not rev:

                    selected = n

This file was forked by the Kallithea project in July 2014.

Original author and date, and relevant copyright and licensing information is below:

:created_on: Apr 4, 2010

:author: marcink

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

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

"""

import hashlib

import itertools

import logging

import os

import ipaddr

from decorator import decorator

from sqlalchemy.orm import joinedload

from sqlalchemy.orm.exc import ObjectDeletedError

from tg import request

from tg.i18n import ugettext as _

from webob.exc import HTTPForbidden, HTTPFound

from kallithea import __platform__, is_unix, is_windows

from kallithea.config.routing import url

from kallithea.lib.caching_query import FromCache

from kallithea.lib.utils import conditional_cache, get_repo_group_slug, get_repo_slug, get_user_group_slug

from kallithea.lib.vcs.utils.lazy import LazyProperty

from kallithea.model.db import (

    Permission, RepoGroup, Repository, User, UserApiKeys, UserGroup, UserGroupMember, UserGroupRepoGroupToPerm, UserGroupRepoToPerm, UserGroupToPerm, UserGroupUserGroupToPerm, UserIpMap, UserToPerm)

from kallithea.model.meta import Session

from kallithea.model.user import UserModel

log = logging.getLogger(__name__)

class PasswordGenerator(object):

    """

    This is a simple class for generating password from different sets of

    characters

    usage::

        passwd_gen = PasswordGenerator()

        #print 8-letter password containing only big and small letters

            of alphabet

        passwd_gen.gen_password(8, passwd_gen.ALPHABETS_BIG_SMALL)

    """

    ALPHABETS_NUM = r'''1234567890'''

    ALPHABETS_SMALL = r'''qwertyuiopasdfghjklzxcvbnm'''

    ALPHABETS_BIG = r'''QWERTYUIOPASDFGHJKLZXCVBNM'''

    ALPHABETS_ALPHANUM_BIG = ALPHABETS_BIG + ALPHABETS_NUM

    ALPHABETS_ALPHANUM_SMALL = ALPHABETS_SMALL + ALPHABETS_NUM

    def gen_password(self, length, alphabet=ALPHABETS_FULL):

        assert len(alphabet) <= 256, alphabet

        l = []

        while len(l) < length:

            i = ord(os.urandom(1))

            if i < len(alphabet):

                l.append(alphabet[i])

        return ''.join(l)

def get_crypt_password(password):

    """

    Cryptographic function used for password hashing based on pybcrypt

    or Python's own OpenSSL wrapper on windows

    :param password: password to hash

    """

    if is_windows:

        return hashlib.sha256(password).hexdigest()

    elif is_unix:

        import bcrypt

    else:

        raise Exception('Unknown or unsupported platform %s'

                        % __platform__)

def check_password(password, hashed):

    """

    Checks matching password with it's hashed value, runs different

    implementation based on platform it runs on

    :param password: password

    :param hashed: password in hashed form

    """

    if is_windows:

        return hashlib.sha256(password).hexdigest() == hashed

    elif is_unix:

        import bcrypt

        try:

        except ValueError as e:

            # bcrypt will throw ValueError 'Invalid hashed_password salt' on all password errors

            log.error('error from bcrypt checking password: %s', e)

            return False

    else:

        raise Exception('Unknown or unsupported platform %s'

                        % __platform__)

def _cached_perms_data(user_id, user_is_admin):

    RK = 'repositories'

    GK = 'repositories_groups'

    UK = 'user_groups'

    GLOBAL = 'global'

    PERM_WEIGHTS = Permission.PERM_WEIGHTS

    permissions = {RK: {}, GK: {}, UK: {}, GLOBAL: set()}

    def bump_permission(kind, key, new_perm):

        """Add a new permission for kind and key.

        Assuming the permissions are comparable, set the new permission if it

        has higher weight, else drop it and keep the old permission.

        """

        cur_perm = permissions[kind][key]

        new_perm_val = PERM_WEIGHTS[new_perm]

# the Free Software Foundation, either version 3 of the License, or

# (at your option) any later version.

#

# 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 General Public License

# along with this program.  If not, see <http://www.gnu.org/licenses/>.

"""

kallithea.lib.hooks

~~~~~~~~~~~~~~~~~~~

Hooks run by Kallithea

This file was forked by the Kallithea project in July 2014.

Original author and date, and relevant copyright and licensing information is below:

:created_on: Aug 6, 2010

:author: marcink

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

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

"""

import os

import time

from kallithea.lib import helpers as h

from kallithea.lib.exceptions import UserCreationError

from kallithea.lib.utils import action_logger, make_ui, setup_cache_regions

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

from kallithea.lib.vcs.utils.hgcompat import revrange

from kallithea.model.db import Repository, User

def _get_scm_size(alias, root_path):

    if not alias.startswith('.'):

        alias += '.'

    size_scm, size_root = 0, 0

    for path, dirs, files in os.walk(safe_str(root_path)):

        if path.find(alias) != -1:

            for f in files:

                try:

                    size_scm += os.path.getsize(os.path.join(path, f))

                except OSError:

                    pass

        else:

            for f in files:

                try:

                    size_root += os.path.getsize(os.path.join(path, f))

                except OSError:

                    pass

    size_scm_f = h.format_byte_size(size_scm)

    size_root_f = h.format_byte_size(size_root)

    size_total_f = h.format_byte_size(size_root + size_scm)

    return size_scm_f, size_root_f, size_total_f

def repo_size(ui, repo, hooktype=None, **kwargs):

    """Presents size of repository after push"""

    size_hg_f, size_root_f, size_total_f = _get_scm_size('.hg', repo.root)

    last_cs = repo[len(repo) - 1]

    msg = ('Repository size .hg: %s Checkout: %s Total: %s\n'

           'Last revision is now r%s:%s\n') % (

    )

    ui.status(msg)

def log_pull_action(ui, repo, **kwargs):

    """Logs user last pull action

    Called as Mercurial hook outgoing.pull_logger or from Kallithea before invoking Git.

    Does *not* use the action from the hook environment but is always 'pull'.

    """

    ex = get_hook_environment()

    user = User.get_by_username(ex.username)

    action = 'pull'

    action_logger(user, action, ex.repository, ex.ip, commit=True)

    # extension hook call

    from kallithea import EXTENSIONS

    callback = getattr(EXTENSIONS, 'PULL_HOOK', None)

    if callable(callback):

        kw = {}

        kw.update(ex)

        callback(**kw)

    return 0

def log_push_action(ui, repo, node, node_last, **kwargs):

    """

    Entry point for Mercurial hook changegroup.push_logger.

    The pushed changesets is given by the revset 'node:node_last'.

    Note: This hook is not only logging, but also the side effect invalidating

    cahes! The function should perhaps be renamed.

    """

    process_pushed_raw_ids(revs)

    return 0

def process_pushed_raw_ids(revs):

    """

    Register that changes have been added to the repo - log the action *and* invalidate caches.

    Called from  Mercurial changegroup.push_logger calling hook log_push_action,

    or from the Git post-receive hook calling handle_git_post_receive ...

    or from scm _handle_push.

    """

    ex = get_hook_environment()

    action = '%s:%s' % (ex.action, ','.join(revs))

    action_logger(ex.username, action, ex.repository, ex.ip, commit=True)

    from kallithea.model.scm import ScmModel

    ScmModel().mark_for_invalidation(ex.repository)

    # extension hook call

    from kallithea import EXTENSIONS

    callback = getattr(EXTENSIONS, 'PUSH_HOOK', None)

    if callable(callback):

# You should have received a copy of the GNU General Public License

# along with this program.  If not, see <http://www.gnu.org/licenses/>.

"""

kallithea.lib.middleware.pygrack

~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

Python implementation of git-http-backend's Smart HTTP protocol

Based on original code from git_http_backend.py project.

Copyright (c) 2010 Daniel Dotsenko <dotsa@hotmail.com>

Copyright (c) 2012 Marcin Kuzminski <marcin@python-works.com>

This file was forked by the Kallithea project in July 2014.

"""

import logging

import os

import socket

import traceback

from webob import Request, Response, exc

import kallithea

from kallithea.lib.vcs import subprocessio

log = logging.getLogger(__name__)

class FileWrapper(object):

    def __init__(self, fd, content_length):

        self.fd = fd

        self.content_length = content_length

        self.remain = content_length

    def read(self, size):

        if size <= self.remain:

            try:

                data = self.fd.read(size)

            except socket.error:

                raise IOError(self)

            self.remain -= size

        elif self.remain:

            data = self.fd.read(self.remain)

            self.remain = 0

        else:

        return path[len(self.repo_name) + 2:].strip('/')

    def inforefs(self, req, environ):

        """

        WSGI Response producer for HTTP GET Git Smart

        HTTP /info/refs request.

        """

        git_command = req.GET.get('service')

        if git_command not in self.commands:

            log.debug('command %s not allowed', git_command)

            return exc.HTTPMethodNotAllowed()

        # From Documentation/technical/http-protocol.txt shipped with Git:

        #

        # Clients MUST verify the first pkt-line is `# service=$servicename`.

        # Servers MUST set $servicename to be the request parameter value.

        # Servers SHOULD include an LF at the end of this line.

        # Clients MUST ignore an LF at the end of the line.

        #

        #  smart_reply     =  PKT-LINE("# service=$servicename" LF)

        #                     ref_list

        #                     "0000"

        server_advert = '# service=%s\n' % git_command

        _git_path = kallithea.CONFIG.get('git_path', 'git')

        cmd = [_git_path, git_command[4:],

               '--stateless-rpc', '--advertise-refs', self.content_path]

        log.debug('handling cmd %s', cmd)

        try:

            out = subprocessio.SubprocessIOChunker(cmd,

            )

        except EnvironmentError as e:

            log.error(traceback.format_exc())

            raise exc.HTTPExpectationFailed()

        resp = Response()

        resp.content_type = 'application/x-%s-advertisement' % str(git_command)

        resp.charset = None

        resp.app_iter = out

        return resp

    def backend(self, req, environ):

        """

        WSGI Response producer for HTTP POST Git Smart HTTP requests.

        Reads commands and data from HTTP POST's body.

        returns an iterator obj with contents of git command's

        response to stdout

        """

        _git_path = kallithea.CONFIG.get('git_path', 'git')

        git_command = self._get_fixedpath(req.path_info)

        if git_command not in self.commands:

            log.debug('command %s not allowed', git_command)

            return exc.HTTPMethodNotAllowed()

        if 'CONTENT_LENGTH' in environ:

    :created_on: Dec 10, 2012

    :author: ir4y

    :copyright: (C) 2012 Ilya Beda <ir4y.ix@gmail.com>

    :license: GPLv3, see COPYING for more details.

"""

# This program is free software: you can redistribute it and/or modify

# it under the terms of the GNU General Public License as published by

# the Free Software Foundation, either version 3 of the License, or

# (at your option) any later version.

#

# 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 General Public License

# along with this program.  If not, see <http://www.gnu.org/licenses/>.

import base64

import logging

import re

from tg.i18n import ugettext as _

log = logging.getLogger(__name__)

class SshKeyParseError(Exception):

    """Exception raised by parse_pub_key"""

def parse_pub_key(ssh_key):

    r"""Parse SSH public key string, raise SshKeyParseError or return decoded keytype, data and comment

    >>> getfixture('doctest_mock_ugettext')

    >>> parse_pub_key('')

    Traceback (most recent call last):

    ...

    SshKeyParseError: SSH key is missing

    >>> parse_pub_key('''AAAAB3NzaC1yc2EAAAALVGhpcyBpcyBmYWtlIQ''')

    Traceback (most recent call last):

    ...

    SshKeyParseError: Incorrect SSH key - it must have both a key type and a base64 part

    >>> parse_pub_key('''abc AAAAB3NzaC1yc2EAAAALVGhpcyBpcyBmYWtlIQ''')

    Traceback (most recent call last):

    ...

    SshKeyParseError: Incorrect SSH key - it must start with 'ssh-(rsa|dss|ed25519)'

    Traceback (most recent call last):

    ...

    SshKeyParseError: Incorrect SSH key - unexpected characters in base64 part "AAAAB3NzaC1yc2EAAAA'LVGhpcyBpcyBmYWtlIQ"

    >>> parse_pub_key(''' ssh-rsa  AAAAB3NzaC1yc2EAAAALVGhpcyBpcyBmYWtlIQ== and a comment

    ... ''')

    ('ssh-rsa', '\x00\x00\x00\x07ssh-rsa\x00\x00\x00\x0bThis is fake!', 'and a comment\n')

    >>> parse_pub_key('''ssh-ed25519 AAAAC3NzaC1lZDI1NTE5AAAAIP1NA2kBQIKe74afUXmIWD9ByDYQJqUwW44Y4gJOBRuo''')

    ('ssh-ed25519', '\x00\x00\x00\x0bssh-ed25519\x00\x00\x00 \xfdM\x03i\x01@\x82\x9e\xef\x86\x9fQy\x88X?A\xc86\x10&\xa50[\x8e\x18\xe2\x02N\x05\x1b\xa8', '')

    """

    if not ssh_key:

        raise SshKeyParseError(_("SSH key is missing"))

    parts = ssh_key.split(None, 2)

    if len(parts) < 2:

        raise SshKeyParseError(_("Incorrect SSH key - it must have both a key type and a base64 part"))

    keytype, keyvalue, comment = (parts + [''])[:3]

    if keytype not in ('ssh-rsa', 'ssh-dss', 'ssh-ed25519'):

        raise SshKeyParseError(_("Incorrect SSH key - it must start with 'ssh-(rsa|dss|ed25519)'"))

    if re.search(r'[^a-zA-Z0-9+/=]', keyvalue):

        raise SshKeyParseError(_("Incorrect SSH key - unexpected characters in base64 part %r") % keyvalue)

    try:

    except TypeError:

        raise SshKeyParseError(_("Incorrect SSH key - failed to decode base64 part %r") % keyvalue)

SSH_OPTIONS = 'no-pty,no-port-forwarding,no-X11-forwarding,no-agent-forwarding'

def authorized_keys_line(kallithea_cli_path, config_file, key):

    """

    Return a line as it would appear in .authorized_keys

    >>> from kallithea.model.db import UserSshKeys, User

    >>> user = User(user_id=7, username='uu')

    >>> key = UserSshKeys(user_ssh_key_id=17, user=user, description='test key')

    >>> key.public_key='''ssh-rsa  AAAAB3NzaC1yc2EAAAALVGhpcyBpcyBmYWtlIQ== and a comment'''

    >>> authorized_keys_line('/srv/kallithea/venv/bin/kallithea-cli', '/srv/kallithea/my.ini', key)

    'no-pty,no-port-forwarding,no-X11-forwarding,no-agent-forwarding,command="/srv/kallithea/venv/bin/kallithea-cli ssh-serve -c /srv/kallithea/my.ini 7 17" ssh-rsa AAAAB3NzaC1yc2EAAAALVGhpcyBpcyBmYWtlIQ==\\n'

    """

    try:

        keytype, key_bytes, comment = parse_pub_key(key.public_key)

    except SshKeyParseError:

        return '# Invalid Kallithea SSH key: %s %s\n' % (key.user.user_id, key.user_ssh_key_id)

    assert '\n' not in base64_key

    return '%s,command="%s ssh-serve -c %s %s %s" %s %s\n' % (

        SSH_OPTIONS, kallithea_cli_path, config_file,

        key.user.user_id, key.user_ssh_key_id,

        keytype, base64_key)

Utilities library for Kallithea

This file was forked by the Kallithea project in July 2014.

Original author and date, and relevant copyright and licensing information is below:

:created_on: Apr 18, 2010

:author: marcink

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

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

"""

import datetime

import logging

import os

import re

import sys

import traceback

from distutils.version import StrictVersion

import beaker

from beaker.cache import _cache_decorate

from tg.i18n import ugettext as _

import kallithea.config.conf

from kallithea.lib.exceptions import HgsubversionImportError

from kallithea.lib.vcs.backends.git.repository import GitRepository

from kallithea.lib.vcs.backends.hg.repository import MercurialRepository

from kallithea.lib.vcs.conf import settings

from kallithea.lib.vcs.exceptions import RepositoryError, VCSError

from kallithea.lib.vcs.utils.fakemod import create_module

from kallithea.lib.vcs.utils.helpers import get_scm

from kallithea.lib.vcs.utils.hgcompat import config, ui

from kallithea.model import meta

from kallithea.model.db import RepoGroup, Repository, Setting, Ui, User, UserGroup, UserLog

log = logging.getLogger(__name__)

REMOVED_REPO_PAT = re.compile(r'rm__\d{8}_\d{6}_\d{6}_.*')

#==============================================================================

# PERM DECORATOR HELPERS FOR EXTRACTING NAMES FOR PERM CHECKS

#==============================================================================

def get_repo_slug(request):

    _repo = request.environ['pylons.routes_dict'].get('repo_name')

    if _repo:

        _repo = _repo.rstrip('/')

    return _repo

                'smtp', 'patch',

                'paths', 'profiling',

                'server', 'trusted',

                'ui', 'web', ]

def make_ui(repo_path=None):

    """

    Create an Mercurial 'ui' object based on database Ui settings, possibly

    augmenting with content from a hgrc file.

    """

    baseui = ui.ui()

    # clean the baseui object

    baseui._ocfg = config.config()

    baseui._ucfg = config.config()

    baseui._tcfg = config.config()

    sa = meta.Session()

    for ui_ in sa.query(Ui).all():

        if ui_.ui_active:

            ui_val = b'' if ui_.ui_value is None else safe_str(ui_.ui_value)

            log.debug('config from db: [%s] %s=%r', ui_.ui_section,

                      ui_.ui_key, ui_val)

                             ui_val)

    # force set push_ssl requirement to False, Kallithea handles that

    baseui.setconfig(b'web', b'push_ssl', False)

    baseui.setconfig(b'web', b'allow_push', b'*')

    # prevent interactive questions for ssh password / passphrase

    ssh = baseui.config(b'ui', b'ssh', default=b'ssh')

    baseui.setconfig(b'ui', b'ssh', b'%s -oBatchMode=yes -oIdentitiesOnly=yes' % ssh)

    # push / pull hooks

    baseui.setconfig(b'hooks', b'changegroup.kallithea_log_push_action', b'python:kallithea.lib.hooks.log_push_action')

    baseui.setconfig(b'hooks', b'outgoing.kallithea_log_pull_action', b'python:kallithea.lib.hooks.log_pull_action')

    if repo_path is not None:

        hgrc_path = os.path.join(repo_path, '.hg', 'hgrc')

        if os.path.isfile(hgrc_path):

            log.debug('reading hgrc from %s', hgrc_path)

            cfg = config.config()

            cfg.read(hgrc_path)

            for section in ui_sections:

                for k, v in cfg.items(section):

                    log.debug('config from file: [%s] %s=%s', section, k, v)