from dulwich.server import update_server_info

from dulwich.web import GunzipFilter, LimitedInputFilter

from webob import Request, Response, exc

import kallithea

from kallithea.lib.utils2 import ascii_bytes

log = logging.getLogger(__name__)

class FileWrapper(object):

            log.error(traceback.format_exc())

            raise exc.HTTPExpectationFailed()

        if git_command in ['git-receive-pack']:

            # updating refs manually after each push.

            # Needed for pre-1.7.0.4 git clients using regular HTTP mode.

            repo = get_repo(self.content_path)

            if repo:

                update_server_info(repo._repo)

        resp = Response()

        resp.content_type = 'application/x-%s-result' % git_command

from formencode import htmlfill

from tg import config, request

from tg import tmpl_context as c

from tg.i18n import ugettext as _

from webob.exc import HTTPFound

from kallithea.lib import webutils

from kallithea.lib.auth import HasPermissionAnyDecorator, LoginRequired

from kallithea.lib.base import BaseController, render

from kallithea.lib.celerylib import tasks

from kallithea.lib.utils import repo2db_mapper, set_app_settings

from kallithea.lib.utils2 import safe_str

            webutils.flash(_('Send email task created'), category='success')

            raise HTTPFound(location=url('admin_settings_email'))

        defaults = db.Setting.get_app_settings()

        defaults.update(self._get_hg_ui_settings())

        c.ini = kallithea.CONFIG

        return htmlfill.render(

            render('admin/settings/settings.html'),

            defaults=defaults,

            encoding="UTF-8",

    def settings_system(self):

        c.active = 'system'

        defaults = db.Setting.get_app_settings()

        defaults.update(self._get_hg_ui_settings())

        c.ini = kallithea.CONFIG

        server_info = db.Setting.get_server_info()

        for key, val in server_info.items():

            setattr(c, key, val)

        return htmlfill.render(

from webob.exc import HTTPBadRequest, HTTPFound

from kallithea.lib import webutils

from kallithea.lib.auth import AuthUser, HasPermissionAnyDecorator

from kallithea.lib.base import BaseController, log_in_user, render

from kallithea.lib.exceptions import UserCreationError

from kallithea.lib.webutils import url

from kallithea.model import db, meta

from kallithea.model.forms import LoginForm, PasswordResetConfirmationForm, PasswordResetRequestForm, RegisterForm

from kallithea.model.user import UserModel

            register_form = RegisterForm()()

            try:

                form_result = register_form.to_python(dict(request.POST))

                form_result['active'] = c.auto_active

                if c.captcha_active:

                    response = submit(request.POST.get('g-recaptcha-response'),

                                      private_key=captcha_private_key,

                                      remoteip=request.ip_addr)

                    if not response.is_valid:

                        _value = form_result

                        _msg = _('Bad captcha')

        if request.POST:

            password_reset_form = PasswordResetRequestForm()()

            try:

                form_result = password_reset_form.to_python(dict(request.POST))

                if c.captcha_active:

                    response = submit(request.POST.get('g-recaptcha-response'),

                                      private_key=captcha_private_key,

                                      remoteip=request.ip_addr)

                    if not response.is_valid:

                        _value = form_result

                        _msg = _('Bad captcha')

refer to the routes manual at http://routes.groovie.org/docs/

"""

import routes

import kallithea

from kallithea.lib.utils2 import safe_str

class Mapper(routes.Mapper):

    """

    Subclassed Mapper with routematch patched to decode "unicode" str url to

    """Create, configure and return the routes Mapper"""

    rmap = Mapper(directory=config['paths']['controllers'],

                  always_scan=config['debug'])

    rmap.minimization = False

    rmap.explicit = False

    def check_repo(environ, match_dict):

        """

        Check for valid repository for proper 404 handling.

        Also, a bit of side effect modifying match_dict ...

        """

        if match_dict.get('f_path'):

import textwrap

import urllib.parse

from beaker.cache import cache_region

from pygments import highlight as code_highlight

from pygments.formatters.html import HtmlFormatter

from tg.i18n import ugettext as _

import kallithea

from kallithea.lib.annotate import annotate_highlight

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

# PERMS

def gravatar_div(email_address, cls='', size=30, **div_attributes):

    """Return an html literal with a span around a gravatar if they are enabled.

    Extra keyword parameters starting with 'div_' will get the prefix removed

    and '_' changed to '-' and be used as attributes on the div. The default

    class is 'gravatar'.

    """

    if not c.visual.use_gravatar:

        return ''

    if 'div_class' not in div_attributes:

        div_attributes['div_class'] = "gravatar"

    attributes = []

    for k, v in sorted(div_attributes.items()):

    This method will return an <img> with the resolution double the size (for

    retina screens) of the image. If the url returned from gravatar_url is

    empty then we fallback to using an icon.

    """

    if not c.visual.use_gravatar:

        return ''

    src = gravatar_url(email_address, size * 2)

    if src:

            .format(cls=cls, size=size))

    return literal(html)

def gravatar_url(email_address, size=30, default=''):

    if not c.visual.use_gravatar:

        return ""

    _def = 'anonymous@kallithea-scm.org'  # default gravatar

    email_address = email_address or _def

import os

import sys

import time

import mercurial.scmutil

import kallithea

from kallithea.lib import webutils

from kallithea.lib.exceptions import UserCreationError

from kallithea.lib.utils import action_logger, make_ui

from kallithea.lib.utils2 import HookEnvironmentError, ascii_str, get_hook_environment, safe_bytes, safe_str

    db repository.

    Git hooks are executed as subprocess of Git while Kallithea is waiting, and

    they thus need enough info to be able to create an app environment and

    connect to the database.

    """

    import kallithea.config.application

    extras = get_hook_environment()

    path_to_ini_file = extras['config']

    config = paste.deploy.appconfig('config:' + path_to_ini_file)

import urllib.parse

import urlobject

from dateutil import relativedelta

from sqlalchemy.engine import url as sa_url

from sqlalchemy.exc import ArgumentError

from tg.i18n import ugettext as _

from tg.i18n import ungettext

from tg.support.converters import asbool, aslist

from webhelpers2.text import collapse, remove_formatting, strip_tags

import kallithea

def get_current_authuser():

    """

    Gets kallithea user from threadlocal tmpl_context variable if it's

    defined, else returns None.

    """

    try:

        return getattr(tmpl_context, 'authuser', None)

    except TypeError:  # No object (name: context) has been registered for this thread

        return None

from dulwich import objects

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

from kallithea.lib.vcs.exceptions import RepositoryError

from kallithea.lib.vcs.utils import ascii_str, safe_bytes

class GitInMemoryChangeset(BaseInMemoryChangeset):

    def commit(self, message, author, parents=None, branch=None, date=None,

               **kwargs):

        """

          branch would be used.

        :raises ``CommitError``: if any error occurs while committing

        """

        self.check_integrity(parents)

        if branch is None:

        repo = self.repository._repo

        object_store = repo.object_store

        ENCODING = b"UTF-8"  # TODO: should probably be kept in sync with safe_str/safe_bytes and vcs/conf/settings.py DEFAULT_ENCODINGS

                                          TagDoesNotExistError)

from kallithea.lib.vcs.utils import ascii_bytes, ascii_str, date_fromtimestamp, makedate, safe_bytes, safe_str

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

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

from kallithea.lib.vcs.utils.paths import abspath, get_user_home

SHA_PATTERN = re.compile(r'^([0-9a-fA-F]{12}|[0-9a-fA-F]{40})$')

log = logging.getLogger(__name__)

    def get_changeset(self, revision=None):

        """

        Returns ``GitChangeset`` object representing commit from git repository

        at the given revision or head (most recent commit) if None given.

        """

            return revision

    def get_changesets(self, start=None, end=None, start_date=None,

           end_date=None, branch_name=None, reverse=False, max_revisions=None):

        """

        Returns iterator of ``GitChangeset`` objects from start to end (both

        are inclusive), in ascending date order (unless ``reverse`` is set).

    @LazyProperty

    def in_memory_changeset(self):

        """

        Returns ``GitInMemoryChangeset`` object for this repository.

        """

    def clone(self, url, update_after_clone=True, bare=False):

        """

        Tries to clone changes from external location.

        :param update_after_clone: If set to ``False``, git won't checkout

    @LazyProperty

    def workdir(self):

        """

        Returns ``Workdir`` instance for this repository.

        """

    def get_config_value(self, section, name, config_file=None):

        """

        Returns configuration value for a given [``section``] and ``name``.

        :param section: Section we want to retrieve value from

import mercurial.node

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

from kallithea.lib.vcs.exceptions import RepositoryError

from kallithea.lib.vcs.utils import ascii_str, safe_bytes, safe_str

class MercurialInMemoryChangeset(BaseInMemoryChangeset):

    def commit(self, message, author, parents=None, branch=None, date=None,

               **kwargs):

        """

        if not isinstance(message, str):

            raise RepositoryError('message must be a str - got %r' % type(message))

        if not isinstance(author, str):

            raise RepositoryError('author must be a str - got %r' % type(author))

        if branch is None:

        kwargs[b'branch'] = safe_bytes(branch)

        def filectxfn(_repo, memctx, bytes_path):

            """

            Callback from Mercurial, returning ctx to commit for the given

            path.

                                          TagDoesNotExistError, VCSError)

from kallithea.lib.vcs.utils import ascii_bytes, ascii_str, author_email, author_name, date_fromtimestamp, makedate, safe_bytes, safe_str

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

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

from kallithea.lib.vcs.utils.paths import abspath

log = logging.getLogger(__name__)

class MercurialRepository(BaseRepository):

                msg = "Not valid repository at %s. Original error was %s" \

                    % (self.name, err)

            raise RepositoryError(msg)

    @LazyProperty

    def in_memory_changeset(self):

    @LazyProperty

    def description(self):

        _desc = self._repo.ui.config(b'web', b'description', None, untrusted=True)

        return safe_str(_desc or b'unknown')

    def get_changeset(self, revision=None):

        """

        Returns ``MercurialChangeset`` object representing repository's

        changeset at the given ``revision``.

        """

    def get_changesets(self, start=None, end=None, start_date=None,

                       end_date=None, branch_name=None, reverse=False, max_revisions=None):

        """

        Returns iterator of ``MercurialChangeset`` objects from start to end

        (both are inclusive)

    @LazyProperty

    def workdir(self):

        """

        Returns ``Workdir`` instance for this repository.

        """

    def get_config_value(self, section, name=None, config_file=None):

        """

        Returns configuration value for a given [``section``] and ``name``.

        :param section: Section we want to retrieve value from

import mercurial.url

from pygments import highlight

from pygments.formatters import TerminalFormatter

from pygments.lexers import ClassNotFound, guess_lexer_for_filename

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

from kallithea.lib.vcs.utils import safe_str

from kallithea.lib.vcs.utils.paths import abspath

ALIASES = ['hg', 'git']

    - empty list is returned.

    :param path: path to directory which should be checked. May be callable.

    :raises VCSError: if given ``path`` is not a directory

    """

    if hasattr(path, '__call__'):

        path = path()

    if not os.path.isdir(path):

        raise VCSError("Given path %r is not a directory" % path)

    result = []

        dirname = os.path.join(path, 'rm__.' + key)

        if os.path.isdir(dirname):

            return result

        # We still need to check if it's not bare repository as

        # bare repos don't have working directories

        try:

            result.append(key)

            continue

        except RepositoryError:

            # Wrong backend

            pass

        except VCSError:

import os

import time

import traceback

import ipaddr

import sqlalchemy

from sqlalchemy import Boolean, Column, DateTime, Float, ForeignKey, Index, Integer, LargeBinary, String, Unicode, UnicodeText, UniqueConstraint

from sqlalchemy.ext.hybrid import hybrid_property

from sqlalchemy.orm import class_mapper, joinedload, relationship, validates

from tg.i18n import lazy_ugettext as _

from webob.exc import HTTPNotFound

import kallithea

from kallithea.lib import ext_json, ssh, webutils

from kallithea.lib.exceptions import DefaultUserException

from kallithea.lib.utils2 import asbool, ascii_bytes, aslist, get_changeset_safe, get_clone_url, remove_prefix, safe_bytes, safe_int, safe_str, urlreadable

from kallithea.lib.vcs import get_backend, get_repo

from kallithea.lib.vcs.utils import author_email, author_name

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

from kallithea.model import meta

log = logging.getLogger(__name__)

        return self.updated_on

    @property

    def clone_uri_hidden(self):

        clone_uri = self.clone_uri

        if clone_uri:

            url_obj = urlobject.URLObject(self.clone_uri)

            if url_obj.password:

                clone_uri = url_obj.with_password('*****')

        return clone_uri

    def clone_url(self, clone_uri_tmpl, with_id=False, username=None):

            message

            date

            author

        :param cs_cache:

        """

        if cs_cache is None:

            cs_cache = EmptyChangeset()

            # use no-cache version here

            scm_repo = self.scm_instance_no_cache()

            if scm_repo:

                cs_cache = scm_repo.get_changeset()

from tg import config

from tg.i18n import ugettext as _

from kallithea.lib import webutils

from kallithea.lib.exceptions import DefaultUserException, UserOwnsReposException

from kallithea.lib.utils2 import generate_api_key, get_current_authuser

log = logging.getLogger(__name__)

class UserModel(object):

        """

        Adds email address to UserEmailMap

        :param user:

        :param email:

        """

        form = forms.UserExtraEmailForm()()

        data = form.to_python(dict(email=email))

        user = db.User.guess_instance(user)

        obj = db.UserEmailMap()

        obj.user = user

        """

        Adds IP address to UserIpMap

        :param user:

        :param ip:

        """

        form = forms.UserExtraIpForm()()

        data = form.to_python(dict(ip=ip))

        user = db.User.guess_instance(user)

        obj = db.UserIpMap()

        obj.user = user

import sqlalchemy

from formencode.validators import CIDR, Bool, Email, FancyValidator, Int, IPAddress, NotEmpty, Number, OneOf, Regex, Set, String, StringBoolean, UnicodeString

from sqlalchemy import func

from tg.i18n import ugettext as _

import kallithea

from kallithea.lib.compat import OrderedSet

from kallithea.lib.exceptions import InvalidCloneUriException, LdapImportError

from kallithea.lib.utils import is_valid_repo_uri

from kallithea.lib.utils2 import asbool, aslist, repo_name_slug

from kallithea.model import db

        def _validate_python(self, value, state):

            gr = db.RepoGroup.get(value)

            gr_name = gr.group_name if gr is not None else None # None means ROOT location

            # create repositories with write permission on group is set to true

                                            'can write into group validator')

                                            'can write into group validator')

            forbidden = not (group_admin or group_write)

            gid = (old_data['repo_group'].get('group_id')

                   if (old_data and 'repo_group' in old_data) else None)

            value_changed = gid != value

            new = not old_data

            # do check if we changed the value, there's a case that someone got

            # revoked write permissions to a repository, he still created, we

            if can_create_in_root and gr is None:

                # we can create in root, we're fine no validations required

                return

            forbidden_in_root = gr is None and not can_create_in_root

            if forbidden_in_root or forbidden:

                msg = self.message('permission_denied', state)

                raise formencode.Invalid(msg, value, state,

                    error_dict=dict(parent_group_id=msg)

                )

Tests for the JSON-RPC web api.

"""

import os

import random

import re

import mock

import pytest

from kallithea.lib import ext_json

from kallithea.lib.auth import AuthUser

        id_, params = _build_data(self.apikey, 'get_users', )

        params = params.replace('"args": {}', '"args": 1')

        response = api_call(self, params)

        assert response.status == '200 OK'

    def test_api_args_different_args(self):

        expected = {

            'ascii_letters': string.ascii_letters,

            'ws': string.whitespace,

            'printables': string.printable

        }

        id_, params = _build_data(self.apikey, 'test', args=expected)

import os

import re

import tempfile

import time

import pytest

from webtest import TestApp

from kallithea.lib.utils2 import ascii_str

from kallithea.model import db

def invalidate_all_caches():

    """Invalidate all beaker caches currently configured.

    Useful when manipulating IP permissions in a test and changes need to take

    effect immediately.

    Note: Any use of this function is probably a workaround - it should be

    replaced with a more specific cache invalidation in code or test."""

    for cache in cache_managers.values():

        cache.clear()

class NullHandler(logging.Handler):

    def emit(self, record):

from kallithea.lib import inifile

from kallithea.lib.utils import repo2db_mapper

from kallithea.model import db, meta

from kallithea.model.scm import ScmModel

from kallithea.model.user import UserModel

from kallithea.tests.base import TEST_USER_ADMIN_LOGIN, TEST_USER_ADMIN_PASS, TEST_USER_REGULAR_LOGIN, TESTS_TMP_PATH, invalidate_all_caches

def pytest_configure():

    os.environ['TZ'] = 'UTC'

    if not kallithea.is_windows:

        time.tzset() # only available on Unix

        ini_settings['[app:main]']['sqlalchemy.url'] = reuse_database

    test_ini_file = os.path.join(TESTS_TMP_PATH, 'test.ini')

    inifile.create(test_ini_file, None, ini_settings)

    context = loadwsgi.loadcontext(loadwsgi.APP, 'config:%s' % test_ini_file)

    # set KALLITHEA_NO_TMP_PATH=1 to disable re-creating the database and test repos

    if not int(os.environ.get('KALLITHEA_NO_TMP_PATH', 0)):

        create_test_env(TESTS_TMP_PATH, context.config(), reuse_database=bool(reuse_database))

    # set KALLITHEA_WHOOSH_TEST_DISABLE=1 to disable whoosh index during tests

from tg import request

from tg.util.webtest import test_context

from kallithea.lib.auth import AuthUser

from kallithea.lib.db_manage import DbManage

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

from kallithea.model import db, meta

from kallithea.model.changeset_status import ChangesetStatusModel

from kallithea.model.comment import ChangesetCommentsModel

from kallithea.model.gist import GistModel

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

from kallithea.model.scm import ScmModel

from kallithea.model.user import UserModel

from kallithea.model.user_group import UserGroupModel

from kallithea.tests.base import (GIT_REPO, HG_REPO, IP_ADDR, TEST_USER_ADMIN_EMAIL, TEST_USER_ADMIN_LOGIN, TEST_USER_ADMIN_PASS, TEST_USER_REGULAR2_EMAIL,

                                  TEST_USER_REGULAR2_LOGIN, TEST_USER_REGULAR2_PASS, TEST_USER_REGULAR_EMAIL, TEST_USER_REGULAR_LOGIN, TEST_USER_REGULAR_PASS,

                                  TESTS_TMP_PATH, invalidate_all_caches)

log = logging.getLogger(__name__)

FIXTURES = os.path.join(dirname(dirname(os.path.abspath(__file__))), 'tests', 'fixtures')

    tar = tarfile.open(os.path.join(FIXTURES, 'vcs_test_git.tar.gz'))

    tar.extractall(os.path.join(TESTS_TMP_PATH, GIT_REPO))

    tar.close()

    # LOAD VCS test stuff

    setup_package()

def create_test_index(repo_location, config, full_index):

    """

    Makes default test index

    """

    index_location = os.path.join(config['index_dir'])

    if not os.path.exists(index_location):

        os.makedirs(index_location)

    l = DaemonLock(os.path.join(index_location, 'make_index.lock'))

    WhooshIndexingDaemon(index_location=index_location,

# -*- coding: utf-8 -*-

from tg.util.webtest import test_context

from kallithea.lib import webutils

from kallithea.model.user import UserModel

from kallithea.tests import base

from kallithea.tests.fixture import Fixture

fixture = Fixture()

                                            firstname='NewName',

                                            lastname='NewLastname',

                                            email=new_email,

                                            _session_csrf_secret_token=self.session_csrf_secret_token()))

        response.mustcontain('An email address must contain a single @')

        with test_context(self.app):

            msg = validators.ValidUsername(edit=False, old_data={}) \

                    ._messages['username_exists']

        msg = webutils.html_escape(msg % {'username': base.TEST_USER_ADMIN_LOGIN})

        response.mustcontain(msg)

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