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 09, 2013

:author: marcink

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

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

"""

import os

import pprint

import random

import sys

from kallithea.lib import ext_json

from kallithea.lib.utils2 import ascii_bytes

CONFIG_NAME = '.config/kallithea'

FORMAT_PRETTY = 'pretty'

FORMAT_JSON = 'json'

def api_call(apikey, apihost, method=None, **kw):

    """

        """

        return {

            "id": random_id,

            "api_key": apikey,

            "method": method,

            "args": kw

        }

    if not method:

        raise Exception('please specify method name !')

    apihost = apihost.rstrip('/')

    id_ = random.randrange(1, 9999)

                      data=ascii_bytes(ext_json.dumps(_build_data(id_))),

                      headers={'content-type': 'text/plain'})

    raw_json = ret.read()

    json_data = ext_json.loads(raw_json)

    id_ret = json_data['id']

    if id_ret == id_:

        return json_data

    else:

        _formatted_json = pprint.pformat(json_data)

        raise Exception('something went wrong. '

                        'ID mismatch got %s, expected %s | %s' % (

                                            id_ret, id_, _formatted_json))

LDAP sync script

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: Mar 06, 2013

:author: marcink

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

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

"""

from __future__ import print_function

import uuid

from configparser import ConfigParser

import ldap

from kallithea.lib import ext_json

from kallithea.lib.utils2 import ascii_bytes

config = ConfigParser()

config.read('ldap_sync.conf')

    def post(self, method, args):

        """Send a generic API post to Kallithea.

        This will generate the UUID for validation check after the

        response is returned. Handle errors and get the result back.

        """

        uid = str(uuid.uuid1())

        data = self.get_api_data(uid, method, args)

        data = ascii_bytes(ext_json.dumps(data))

        headers = {'content-type': 'text/plain'}

        response = ext_json.load(response)

        if uid != response["id"]:

            raise InvalidResponseIDError("UUID does not match.")

        if response["error"] is not None:

            raise ResponseError(response["error"])

        return response["result"]

    def create_group(self, name, active=True):

        """Create the Kallithea user group."""

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: Created on Nov 17, 2012

:author: marcink

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

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

"""

import base64

import logging

from kallithea.lib import auth_modules, ext_json

from kallithea.lib.compat import hybrid_property

from kallithea.lib.utils2 import ascii_bytes, ascii_str, safe_bytes

log = logging.getLogger(__name__)

class CrowdServer(object):

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

        """

        self.set_credentials(kwargs.get("user", ""),

                             kwargs.get("passwd", ""))

        self._version = kwargs.get("version", "latest")

        self._url_list = None

        self._appname = "crowd"

    def set_credentials(self, user, passwd):

        self.user = user

        self.passwd = passwd

        self._make_opener()

    def _make_opener(self):

        mgr.add_password(None, self._uri, self.user, self.passwd)

    def _request(self, url, body=None, headers=None,

                 method=None, noformat=False,

                 empty_response_ok=False):

        _headers = {"Content-type": "application/json",

                    "Accept": "application/json"}

        if self.user and self.passwd:

            authstring = ascii_str(base64.b64encode(safe_bytes("%s:%s" % (self.user, self.passwd))))

            _headers["Authorization"] = "Basic %s" % authstring

        if headers:

            _headers.update(headers)

        log.debug("Sent to crowd at %s:\nHeaders: %s\nBody:\n%s", url, _headers, body)

        if method:

            req.get_method = lambda: method

        global msg

        msg = ""

        try:

            rdoc = self.opener.open(req)

            msg = "".join(rdoc.readlines())

            if not msg and empty_response_ok:

                rval = {}

                rval["status"] = True

                rval["error"] = "Response body was empty"

            if not noformat:

                rval = {"status": False,

                        "body": body,

                        "error": str(e) + "\n" + msg}

            else:

                rval = None

        return rval

    def user_auth(self, username, password):

        """Authenticate a user against crowd. Returns brief information about

        the user."""

        url = ("%s/rest/usermanagement/%s/authentication?username=%s"

        body = ascii_bytes(ext_json.dumps({"value": password}))

        return self._request(url, body)

    def user_groups(self, username):

        """Retrieve a list of groups to which this user belongs."""

        url = ("%s/rest/usermanagement/%s/user/group/nested?username=%s"

        return self._request(url)

class KallitheaAuthPlugin(auth_modules.KallitheaExternalAuthPlugin):

    def __init__(self):

        self._protocol_values = ["http", "https"]

    @hybrid_property

    def name(self):

        return "crowd"

    def settings(self):

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 28, 2010

:author: marcink

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

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

"""

import logging

import os

import mercurial.hgweb

from kallithea.lib.base import BaseVCSController, get_path_info

from kallithea.lib.utils import make_ui

from kallithea.lib.utils2 import safe_bytes, safe_str, safe_unicode

log = logging.getLogger(__name__)

def get_header_hgarg(environ):

            action = None

            for qry in query_string.split('&'):

                parts = qry.split('=', 1)

                if len(parts) == 2 and parts[0] == 'cmd':

                    cmd = parts[1]

                    if cmd == 'batch':

                        hgarg = get_header_hgarg(environ)

                        if not hgarg.startswith('cmds='):

                            action = 'push' # paranoid and safe

                            break

                        action = 'pull'

                        for cmd_arg in hgarg[5:].split(';'):

                            op = cmd_mapping.get(cmd, 'push')

                            if op != 'pull':

                                assert op == 'push'

                                action = 'push'

                                break

                    else:

                        action = cmd_mapping.get(cmd, 'push')

                    break # only process one cmd

        return parsed_request

    def _make_app(self, parsed_request):

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

import json

class RecaptchaResponse(object):

    def __init__(self, is_valid, error_code=None):

        self.is_valid = is_valid

        self.error_code = error_code

    def __repr__(self):

        return '<RecaptchaResponse:%s>' % (self.is_valid)

def submit(g_recaptcha_response, private_key, remoteip):

    private_key -- your reCAPTCHA private key

    remoteip -- the user's IP address

    """

    if not (g_recaptcha_response and len(g_recaptcha_response)):

        return RecaptchaResponse(is_valid=False, error_code='incorrect-captcha-sol')

    def encode_if_necessary(s):

        if isinstance(s, unicode):

            return s.encode('utf-8')

        return s

        'secret': encode_if_necessary(private_key),

        'remoteip': encode_if_necessary(remoteip),

        'response': encode_if_necessary(g_recaptcha_response),

    }).encode('ascii')

        url="https://www.google.com/recaptcha/api/siteverify",

        data=params,

        headers={

            "Content-type": "application/x-www-form-urlencoded",

            "User-agent": "reCAPTCHA Python"

        }

    )

    return_values = json.loads(httpresp.read())

    httpresp.close()

    if not (isinstance(return_values, dict)):

        return RecaptchaResponse(is_valid=False, error_code='incorrect-captcha-sol')

    elif (("success" in return_values) and ((return_values["success"] is True) or (return_values["success"] == "true"))):

        return RecaptchaResponse(is_valid=True)

    elif (("error-codes" in return_values) and isinstance(return_values["error-codes"], list) and (len(return_values["error-codes"]) > 0)):

        return RecaptchaResponse(is_valid=False, error_code=return_values["error-codes"][0])

    else:

        return RecaptchaResponse(is_valid=False, error_code='incorrect-captcha-sol')

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

"""

from __future__ import print_function

import binascii

import datetime

import json

import os

import pwd

import re

import time

import urlobject

from tg.i18n import ugettext as _

from tg.i18n import ungettext

from webhelpers2.text import collapse, remove_formatting, strip_tags

from kallithea.lib.vcs.utils import ascii_bytes, ascii_str, safe_bytes, safe_str, safe_unicode  # re-export

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

def str2bool(_str):

    """

    """

    uri = uri_filter(uri)

    # check if we have port

    if len(uri) > 2 and uri[2]:

        uri[2] = ':' + uri[2]

    return ''.join(uri)

def get_clone_url(clone_uri_tmpl, prefix_url, repo_name, repo_id, username=None):

    parsed_url = urlobject.URLObject(prefix_url)

    try:

        system_user = pwd.getpwuid(os.getuid()).pw_name

    except Exception: # TODO: support all systems - especially Windows

        system_user = 'kallithea' # hardcoded default value ...

    args = {

        'scheme': parsed_url.scheme,

        'netloc': parsed_url.netloc + prefix,  # like "hostname:port/prefix" (with optional ":port" and "/prefix")

        'prefix': prefix, # undocumented, empty or starting with /

        'repo': repo_name,

        'repoid': str(repo_id),

        'system_user': safe_unicode(system_user),

        'hostname': parsed_url.hostname,

    }

    url = re.sub('{([^{}]+)}', lambda m: args.get(m.group(1), m.group(0)), clone_uri_tmpl)

    # remove leading @ sign if it's present. Case of empty user

    url_obj = urlobject.URLObject(url)

    if not url_obj.username:

    Git repository implementation.

    :created_on: Apr 8, 2010

    :copyright: (c) 2010-2011 by Marcin Kuzminski, Lukasz Balcerzak.

"""

import errno

import logging

import os

import re

import time

from collections import OrderedDict

import mercurial.url  # import httpbasicauthhandler, httpdigestauthhandler

import mercurial.util  # import url as hg_url

from dulwich.config import ConfigFile

from dulwich.objects import Tag

from dulwich.repo import NotGitRepository, Repo

from kallithea.lib.vcs import subprocessio

from kallithea.lib.vcs.backends.base import BaseRepository, CollectionGenerator

from kallithea.lib.vcs.conf import settings

from kallithea.lib.vcs.exceptions import (

        handlers = []

        url_obj = mercurial.util.url(safe_bytes(url))

        test_uri, authinfo = url_obj.authinfo()

        if not test_uri.endswith('info/refs'):

            test_uri = test_uri.rstrip('/') + '/info/refs'

        url_obj.passwd = b'*****'

        cleaned_uri = str(url_obj)

        if authinfo:

            # create a password manager

            passmgr.add_password(*authinfo)

            handlers.extend((mercurial.url.httpbasicauthhandler(passmgr),

                             mercurial.url.httpdigestauthhandler(passmgr)))

        o.addheaders = [('User-Agent', 'git/1.7.8.0')]  # fake some git

            "%s?%s" % (

                test_uri,

            ))

        try:

            resp = o.open(req)

            if resp.code != 200:

                raise Exception('Return Code is not 200')

        except Exception as e:

            # means it cannot be cloned

        # now detect if it's proper git repo

        gitdata = resp.read()

        if 'service=git-upload-pack' not in gitdata:

                "url [%s] does not look like an git" % cleaned_uri)

        return True

    def _get_repo(self, create, src_url=None, update_after_clone=False,

                  bare=False):

        if create and os.path.exists(self.path):

            raise RepositoryError("Location already exist")

        if src_url and not create:

            raise RepositoryError("Create should be set to True if src_url is "

                                  "given (clone operation creates repository)")

        try:

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

    Mercurial repository implementation.

    :created_on: Apr 8, 2010

    :copyright: (c) 2010-2011 by Marcin Kuzminski, Lukasz Balcerzak.

"""

import datetime

import logging

import os

import time

from collections import OrderedDict

import mercurial.commands

import mercurial.error

import mercurial.exchange

import mercurial.hg

import mercurial.hgweb

import mercurial.httppeer

import mercurial.localrepo

import mercurial.match

import mercurial.mdiff

import mercurial.node

        url_prefix = None

        if b'+' in url[:url.find(b'://')]:

            url_prefix, url = url.split(b'+', 1)

        handlers = []

        url_obj = mercurial.util.url(url)

        test_uri, authinfo = url_obj.authinfo()

        url_obj.passwd = b'*****'

        cleaned_uri = str(url_obj)

        if authinfo:

            # create a password manager

            passmgr.add_password(*authinfo)

            handlers.extend((mercurial.url.httpbasicauthhandler(passmgr),

                             mercurial.url.httpdigestauthhandler(passmgr)))

        o.addheaders = [('Content-Type', 'application/mercurial-0.1'),

                        ('Accept', 'application/mercurial-0.1')]

            "%s?%s" % (

                test_uri,

                    'cmd': 'between',

                    'pairs': "%s-%s" % ('0' * 40, '0' * 40),

                })

            ))

        try:

            resp = o.open(req)

            if resp.code != 200:

                raise Exception('Return Code is not 200')

        except Exception as e:

            # means it cannot be cloned

        if not url_prefix: # skip svn+http://... (and git+... too)

            # now check if it's a proper hg repo

            try:

                mercurial.httppeer.instance(repoui or mercurial.ui.ui(), url, False).lookup(b'tip')

            except Exception as e:

                    "url [%s] does not look like an hg repo org_exc: %s"

                    % (cleaned_uri, e))

        return True

    def _get_repo(self, create, src_url=None, update_after_clone=False):

        """

        Function will check for mercurial repository in given path and return

        a localrepo object. If there is no repository in that path it will

        raise an exception unless ``create`` parameter is set to True - in

        that case repository would be created and returned.

        If ``src_url`` is given, would try to clone repository from the

                                                           b"allow" + name,

                                                           untrusted=True):

                yield {"type": name, "extension": ext, "node": archive_name}

    def _get_url(self, url):

        """

        Returns normalized url. If schema is not given, would fall

        to filesystem

        (``file:///``) schema.

        """

        url = safe_str(url)

        if url != 'default' and '://' not in url:

        return url

    def get_changeset(self, revision=None):

        """

        Returns ``MercurialChangeset`` object representing repository's

        changeset at the given ``revision``.

        """

        return MercurialChangeset(repository=self, revision=self._get_revision(revision))

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

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

        """

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

import os

import mock

import pytest

from kallithea.lib import vcs

from kallithea.lib.utils2 import safe_str, safe_unicode

from kallithea.model.db import Permission, RepoGroup, Repository, Ui, User, UserRepoToPerm

from kallithea.model.meta import Session

from kallithea.model.repo import RepoModel

from kallithea.model.repo_group import RepoGroupModel

from kallithea.model.user import UserModel

from kallithea.tests import base

        description_unicode = safe_unicode(description)

        response = self.app.post(base.url('repos'),

                        fixture._get_repo_create_params(repo_private=False,

                                                repo_name=repo_name,

                                                repo_type=self.REPO_TYPE,

                                                repo_description=description,

                                                _session_csrf_secret_token=self.session_csrf_secret_token()))

        ## run the check page that triggers the flash message

        response = self.app.get(base.url('repo_check_home', repo_name=repo_name))

        assert response.json == {u'result': True}

        self.checkSessionFlash(response,

                               u'Created repository <a href="/%s">%s</a>'

        # test if the repo was created in the database

        new_repo = Session().query(Repository) \

            .filter(Repository.repo_name == repo_name_unicode).one()

        assert new_repo.repo_name == repo_name_unicode

        assert new_repo.description == description_unicode

        # test if the repository is visible in the list ?

        response = self.app.get(base.url('summary_home', repo_name=repo_name))

        response.mustcontain(repo_name)

        response.mustcontain(self.REPO_TYPE)

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

from kallithea.lib.utils2 import safe_str, safe_unicode

from kallithea.model.db import Repository, User

from kallithea.model.meta import Session

from kallithea.model.repo import RepoModel

from kallithea.model.user import UserModel

from kallithea.tests import base

from kallithea.tests.fixture import Fixture

fixture = Fixture()

            'repo_group': u'-1',

            'fork_parent_id': org_repo.repo_id,

            'repo_type': self.REPO_TYPE,

            'description': 'unicode repo 1',

            'private': 'False',

            'landing_rev': 'rev:tip',

            '_session_csrf_secret_token': self.session_csrf_secret_token()}

        self.app.post(base.url(controller='forks', action='fork_create',

                          repo_name=repo_name), creation_args)

        response = self.app.get(base.url(controller='forks', action='forks',

                                    repo_name=repo_name))

        response.mustcontain(

        )

        fork_repo = Repository.get_by_repo_name(safe_unicode(fork_name))

        assert fork_repo

        # fork the fork

        fork_name_2 = safe_str(self.REPO_FORK + u'-blåbærgrød')

        creation_args = {

            'repo_name': fork_name_2,

            'repo_group': u'-1',

            'fork_parent_id': fork_repo.repo_id,

            'repo_type': self.REPO_TYPE,

            'description': 'unicode repo 2',

            'private': 'False',

            'landing_rev': 'rev:tip',

            '_session_csrf_secret_token': self.session_csrf_secret_token()}

        self.app.post(base.url(controller='forks', action='fork_create',

                          repo_name=fork_name), creation_args)

        response = self.app.get(base.url(controller='forks', action='forks',

                                    repo_name=fork_name))

        response.mustcontain(

        )

        # remove these forks

        response = self.app.post(base.url('delete_repo', repo_name=fork_name_2),

            params={'_session_csrf_secret_token': self.session_csrf_secret_token()})

        response = self.app.post(base.url('delete_repo', repo_name=fork_name),

            params={'_session_csrf_secret_token': self.session_csrf_secret_token()})

    def test_fork_create_and_permissions(self):

        self.log_user()

        fork_name = self.REPO_FORK

        description = 'fork of vcs test'

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

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

"""

from __future__ import print_function

import json

import os

import re

import tempfile

import time

from subprocess import PIPE, Popen

from tempfile import _RandomNameSequence

import pytest

from kallithea import CONFIG

from kallithea.lib.utils2 import ascii_bytes

from kallithea.model.db import CacheInvalidation, Repository, Ui, User, UserIpMap, UserLog

from kallithea.model.meta import Session

from kallithea.model.ssh_key import SshKeyModel

from kallithea.model.user import UserModel

from kallithea.tests import base

        # Create an empty server repo using the API

        repo_name = u'new_%s_%s' % (vt.repo_type, next(_RandomNameSequence()))

        usr = User.get_by_username(base.TEST_USER_ADMIN_LOGIN)

        params = {

            "id": 7,

            "api_key": usr.api_key,

            "method": 'create_repo',

            "args": dict(repo_name=repo_name,

                         owner=base.TEST_USER_ADMIN_LOGIN,

                         repo_type=vt.repo_type),

        }

            'http://%s:%s/_admin/api' % webserver.server_address,

            data=ascii_bytes(json.dumps(params)),

            headers={'content-type': 'application/json'})

        result = json.loads(response.read())

        # Expect something like:

        # {u'result': {u'msg': u'Created new repository `new_XXX`', u'task': None, u'success': True}, u'id': 7, u'error': None}

        assert result[u'result'][u'success']

        # Create local clone of the empty server repo

        local_clone_dir = _get_tmp_dir()

        clone_url = vt.repo_url_param(webserver, repo_name)

        stdout, stderr = Command(base.TESTS_TMP_PATH).execute(vt.repo_type, 'clone', clone_url, local_clone_dir)

        # Make 3 commits and push to the empty server repo.

        # The server repo doesn't have any other heads than the

:author: marcink

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

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

"""

from __future__ import print_function

import http.cookiejar

import os

import sys

import tempfile

import time

from os.path import dirname

from kallithea.lib import vcs

from kallithea.lib.compat import OrderedSet

from kallithea.lib.vcs.exceptions import RepositoryError

__here__ = os.path.abspath(__file__)

__root__ = dirname(dirname(dirname(__here__)))

sys.path.append(__root__)

print('Crawling @ %s' % BASE_URI)

BASE_URI += '%s'

PROJECT_PATH = os.path.join('/', 'home', 'username', 'repos')

PROJECTS = [

    # 'linux-magx-pbranch',

    'CPython',

    'kallithea',

]

cj = http.cookiejar.FileCookieJar(os.path.join(tempfile.gettempdir(), 'rc_test_cookie.txt'))

o.addheaders = [

    ('User-agent', 'kallithea-crawler'),

    ('Accept-Language', 'en - us, en;q = 0.5')

]

def _get_repo(proj):

    if isinstance(proj, str):