a18445b85d407294da0b7f1d8be3bedef5ffdea6 0.3.7

8db761c407685e7b08b800c947890035b0d67025 0.4.0rc1

60f726162fd6c515bd819feb423be73cad01d7d3 0.4.0rc2

19086c5de05f4984d7a90cd31624c45dd893f6bb 0.4.0

da65398a62fff50f3d241796cbf17acdea2092ef 0.4.1

bfa0b0a814644f0af3f492d17a9ed169cc3b89fe 0.5.0

List of contributors to Kallithea project:

    Andrej Shadura <andrew@shadura.me> 2012 2014-2017 2019

    Étienne Gilli <etienne.gilli@gmail.com> 2015-2017 2019

    Allan Nordhøy <epost@anotheragency.no> 2017-2019

    ssantos <ssantos@web.de> 2018-2019

    Danni Randeris <danniranderis@gmail.com> 2019

    Edmund Wong <ewong@crazy-cat.org> 2019

    Elizabeth Sherrock <lizzyd710@gmail.com> 2019

    Hüseyin Tunç <huseyin.tunc@bulutfon.com> 2019

    leela <53352@protonmail.com> 2019

    Manuel Jacob <me@manueljacob.de> 2019

    Mateusz Mendel <mendelm9@gmail.com> 2019

    Nathan <bonnemainsnathan@gmail.com> 2019

    Oleksandr Shtalinberg <o.shtalinberg@gmail.com> 2019

    THANOS SIOURDAKIS <siourdakisthanos@gmail.com> 2019

    Wolfgang Scherer <wolfgang.scherer@gmx.de> 2019

    Христо Станев <hstanev@gmail.com> 2019

    Dominik Ruf <dominikruf@gmail.com> 2012 2014-2018

    Michal Čihař <michal@cihar.com> 2014-2015 2018

    Branko Majic <branko@majic.rs> 2015 2018

#filter-with = proxy-prefix

full_stack = true

static_files = true

## Internationalization (see setup documentation for details)

cache_dir = %(here)s/data

index_dir = %(here)s/data/index

## uncomment and set this path to use archive download cache

archive_cache_dir = %(here)s/tarballcache

# The master toctree document.

master_doc = 'index'

# General information about the project.

project = u'Kallithea'

# The version info for the project you're documenting, acts as replacement for

# |version| and |release|, also used in various other places throughout the

# built documents.

#

# The short X.Y version.

-----------------------------------

The Kallithea web interface is automatically displayed in the user's preferred

language, as indicated by the browser. Thus, different users may see the

application in different languages. If the requested language is not available

(because the translation file for that language does not yet exist or is

If you want to disable automatic language detection and instead configure a

fixed language regardless of user preference, set ``i18n.enabled = false`` and

Using Kallithea with SSH

------------------------

Kallithea supports repository access via SSH key based authentication.

      import site

      site.addsitedir("/srv/kallithea/venv/lib/python2.7/site-packages")

      ini = '/srv/kallithea/my.ini'

      from logging.config import fileConfig

      from paste.deploy import loadapp

      application = loadapp('config:' + ini)

  Or using proper virtualenv activation:

  .. code-block:: python

      import os

      os.environ['HOME'] = '/srv/kallithea'

      ini = '/srv/kallithea/kallithea.ini'

      from logging.config import fileConfig

      from paste.deploy import loadapp

      application = loadapp('config:' + ini)

- Add the necessary ``WSGI*`` directives to the Apache Virtual Host configuration

  file, like in the example below. Notice that the WSGI dispatch script created

  above is referred to with the ``WSGIScriptAlias`` directive.

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

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

# Alembic migration environment (configuration).

import logging

from logging.config import fileConfig

from alembic import context

from sqlalchemy import engine_from_config, pool

from kallithea.model import db

# Setup Python loggers based on the config file provided to the alembic

# command. If we're being invoked via the Alembic API (presumably for

# stamping during "kallithea-cli db-create"), config_file_name is not available,

# and loggers are assumed to already have been configured.

if config.config_file_name:

def include_in_autogeneration(object, name, type, reflected, compare_to):

    """Filter changes subject to autogeneration of migrations. """

    # Don't include changes to sqlite_sequence.

import sqlalchemy as sa

from alembic import op

def upgrade():

def downgrade():

    with op.batch_alter_table('user_ssh_keys', schema=None) as batch_op:

        batch_op.drop_index('usk_public_key_idx')

                type=click.Path(dir_okay=False, exists=True, readable=True), required=True)

            @functools.wraps(annotated) # reuse meta data from the wrapped function so click can see other options

            def runtime_wrapper(config_file, *args, **kwargs):

                path_to_ini_file = os.path.realpath(config_file)

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

                config_string = read_config(path_to_ini_file, strip_section_prefix=annotated.__name__)

                if config_file_initialize_app:

                    kallithea.config.middleware.make_app_without_logging(kallithea.CONFIG.global_conf, **kallithea.CONFIG.local_conf)

                return annotated(*args, **kwargs)

            return cli_command(runtime_wrapper)

        return annotator

    return cli_command

import isapi_wsgi

import os

def __ExtensionFactory__():

    from paste.deploy import loadapp

    from logging.config import fileConfig

    application = loadapp('config:%(inifile)s')

    def app(environ, start_response):

        user = environ.get('REMOTE_USER', None)

        if user is not None:

            os.environ['REMOTE_USER'] = user

    dispatchfile = os.path.join(os.getcwd(), 'dispatch.py')

    click.echo('Writing %s' % dispatchfile)

    with open(dispatchfile, 'w') as f:

        f.write(dispath_py_template % {

            'inifile': config_file_abs.replace('\\', '\\\\'),

            'virtualdir': virtualdir,

            })

    click.echo('Run \'python "%s" install\' with administrative privileges '

        'to generate the _dispatch.dll file and install it into the '

        'default web site' % dispatchfile)

import kallithea

import kallithea.bin.kallithea_cli_base as cli_base

from kallithea.lib.utils2 import str2bool

from kallithea.lib.vcs.backends.git.ssh import GitSshHandler

from kallithea.lib.vcs.backends.hg.ssh import MercurialSshHandler

log = logging.getLogger(__name__)

@cli_base.register_command(config_file_initialize_app=True, hidden=True)

@cli_base.register_command(config_file_initialize_app=True)

def ssh_update_authorized_keys():

    """Update .ssh/authorized_keys file.

    The file is usually maintained automatically, but this command will also re-write it.

    """

    SshKeyModel().write_authorized_keys()

        # in light of possible future framework changes.

        self['errorpage.status_codes'] = [400, 401, 403, 404]

        # Disable transaction manager -- currently Kallithea takes care of transactions itself

        self['tm.enabled'] = False

base_config = KallitheaAppConfig()

# TODO still needed as long as we use pylonslib

sys.modules['pylons'] = tg

# 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/>.

"""WSGI middleware initialization for the Kallithea application."""

from kallithea.config.app_cfg import base_config

from kallithea.config.environment import load_environment

__all__ = ['make_app']

    This is the PasteDeploy factory for the Kallithea application.

    ``app_conf`` contains all the application-specific settings (those defined

    under ``[app:main]``.

    """

    return make_app_without_logging(global_conf, full_stack=full_stack, **app_conf)

        except SshKeyModelException as errors:

            h.flash(errors.message, category='error')

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

    @IfSshEnabled

    def my_account_ssh_keys_delete(self):

        try:

            Session().commit()

            SshKeyModel().write_authorized_keys()

            h.flash(_("SSH key successfully deleted"), category='success')

        except SshKeyModelException as errors:

            h.flash(errors.message, category='error')

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

        raise HTTPFound(location=url('edit_user_ssh_keys', id=c.user.user_id))

    @IfSshEnabled

    def ssh_keys_delete(self, id):

        c.user = self._get_user_or_raise_if_default(id)

        try:

            Session().commit()

            SshKeyModel().write_authorized_keys()

            h.flash(_("SSH key successfully deleted"), category='success')

        except SshKeyModelException as errors:

            h.flash(errors.message, category='error')

        raise HTTPFound(location=url('edit_user_ssh_keys', id=c.user.user_id))

        # only ever perform the actual password change on POST (since

        # GET requests are not allowed to have side effects, and do not

        # receive automatic CSRF protection).

        # The template needs the email address outside of the form.

        c.email = request.params.get('email')

        if not request.POST:

        form = PasswordResetConfirmationForm()()

        try:

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

        except formencode.Invalid as errors:

            return htmlfill.render(

: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

    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

    """

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

    elif is_unix:

        import bcrypt

        try:

            return bcrypt.checkpw(safe_bytes(password), ascii_bytes(hashed))

        except ValueError as e:

:author: marcink

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

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

"""

import os

import time

import mercurial.scmutil

from kallithea.lib import helpers as h

from kallithea.lib.exceptions import UserCreationError

from kallithea.lib.utils import action_logger, make_ui

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

from kallithea.model.db import Repository, User

def _get_scm_size(alias, root_path):

    if not alias.startswith('.'):

    # Currently unused. TODO: remove?

    return 0

def handle_git_post_receive(repo_path, git_stdin_lines):

    """Called from Git post-receive hook"""

    baseui, repo = _hook_environment(repo_path)

    # the post push hook should never use the cached instance

    scm_repo = repo.scm_instance_no_cache()

    rev_data = []

    for l in git_stdin_lines:

#filter-with = proxy-prefix

full_stack = true

static_files = true

<%text>## Internationalization (see setup documentation for details)</%text>

cache_dir = %(here)s/data

index_dir = %(here)s/data/index

<%text>## uncomment and set this path to use archive download cache</%text>

archive_cache_dir = %(here)s/tarballcache

    Traceback (most recent call last):

    ...

    SshKeyParseError: SSH key is missing

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

    Traceback (most recent call last):

    ...

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

    Traceback (most recent call last):

    ...

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

    >>> parse_pub_key('''ssh-rsa  AAAAB3NzaC1yc2EAAAALVGhpcyBpcyBmYWtlIQ''')

    Traceback (most recent call last):

    """

    if not ssh_key:

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

    parts = ssh_key.split(None, 2)

    if len(parts) < 2:

    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):

    return keytype, key_bytes, comment

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')

    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)

    base64_key = ascii_str(base64.b64encode(key_bytes))

    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)

        return engine

    if _url.password:

        _url.password = 'XXXXX'

    return str(_url)

def get_hook_environment():

    """

    Get hook context by deserializing the global KALLITHEA_EXTRAS environment

    variable.

    Called early in Git out-of-process hooks to get .ini config path so the

    basic environment can be configured properly. Also used in all hooks to get

    information about the action that triggered it.

    """

    try:

    except KeyError:

    try:

            extras[k]

    except KeyError:

    return AttributeDict(extras)

def set_hook_environment(username, ip_addr, repo_name, repo_alias, action=None):

    """Prepare global context for running hooks by serializing data in the

        return get_repo(os.path.join(safe_str(base_path), safe_str(self.gist_access_id)))

class UserSshKeys(Base, BaseDbModel):

    __tablename__ = 'user_ssh_keys'

    __table_args__ = (

        Index('usk_fingerprint_idx', 'fingerprint'),

        UniqueConstraint('fingerprint'),

        _table_args_default_dict

    )

    __mapper_args__ = {}

from tg import config

from tg.i18n import ugettext as _

from kallithea.lib import ssh

from kallithea.lib.utils2 import str2bool

from kallithea.model.db import User, UserSshKeys

from kallithea.model.meta import Session

log = logging.getLogger(__name__)

    """Exception raised by SshKeyModel methods to report errors"""

class SshKeyModel(object):

    def create(self, user, description, public_key):

                                       (new_ssh_key.fingerprint, ssh_key.user.username))

        Session().add(new_ssh_key)

        return new_ssh_key

        """

        Will raise SshKeyModelException on errors

        """

            user = User.guess_instance(user)

            ssh_key = ssh_key.filter(UserSshKeys.user_id == user.user_id)

        ssh_key = ssh_key.scalar()

        if ssh_key is None:

        Session().delete(ssh_key)

    def get_ssh_keys(self, user):

        user = User.guess_instance(user)

        user_ssh_keys = UserSshKeys.query() \

            .filter(UserSshKeys.user_id == user.user_id).all()

        except OSError as exception:

            if exception.errno != errno.EEXIST:

                raise

        # Now, test that the directory is or was created in a readable way by previous.

        if not (os.path.isdir(authorized_keys_dir) and

                os.access(authorized_keys_dir, os.W_OK)):

        # Make sure we don't overwrite a key file with important content

        if os.path.exists(authorized_keys):

            with open(authorized_keys) as f:

                for l in f:

                    if not l.strip() or l.startswith('#'):

                        pass # accept empty lines and comments

                    elif ssh.SSH_OPTIONS in l and ' ssh-serve ' in l:

                        pass # Kallithea entries are ok to overwrite

                    else:

        fh, tmp_authorized_keys = tempfile.mkstemp('.authorized_keys', dir=os.path.dirname(authorized_keys))

        with os.fdopen(fh, 'w') as f:

            for key in UserSshKeys.query().join(UserSshKeys.user).filter(User.active == True):

                f.write(ssh.authorized_keys_line(kallithea_cli_path, config['__file__'], key))

        os.chmod(tmp_authorized_keys, stat.S_IRUSR | stat.S_IWUSR)

        # This preliminary remove is needed for Windows, not for Unix.

        # TODO In Python 3, the remove+rename sequence below should become os.replace.

        if os.path.exists(authorized_keys):

  v 3.0 (GPLv3)</a>.</p>

  <p>Kallithea is copyrighted by various authors, including but not

  necessarily limited to the following:</p>

  <ul>

  <li>Copyright &copy; 2012, 2014&ndash;2017, 2019, Andrej Shadura</li>

  <li>Copyright &copy; 2015&ndash;2017, 2019, Étienne Gilli</li>

  <li>Copyright &copy; 2017&ndash;2019, Allan Nordhøy</li>

  <li>Copyright &copy; 2018&ndash;2019, ssantos</li>

  <li>Copyright &copy; 2019, Danni Randeris</li>

  <li>Copyright &copy; 2019, Edmund Wong</li>

  <li>Copyright &copy; 2019, Elizabeth Sherrock</li>

  <li>Copyright &copy; 2019, Hüseyin Tunç</li>

  <li>Copyright &copy; 2019, leela</li>

  <li>Copyright &copy; 2019, Manuel Jacob</li>

  <li>Copyright &copy; 2019, Mateusz Mendel</li>

  <li>Copyright &copy; 2019, Nathan</li>

  <li>Copyright &copy; 2019, Oleksandr Shtalinberg</li>

  <li>Copyright &copy; 2019, THANOS SIOURDAKIS</li>

  <li>Copyright &copy; 2019, Wolfgang Scherer</li>

  <li>Copyright &copy; 2019, Христо Станев</li>

  <li>Copyright &copy; 2012, 2014&ndash;2018, Dominik Ruf</li>

  <li>Copyright &copy; 2014&ndash;2015, 2018, Michal Čihař</li>

  <li>Copyright &copy; 2015, 2018, Branko Majic</li>

              %else:

                ${_('Never')}

              %endif

            </td>

            <td>

                ${h.form(url('my_account_ssh_keys_delete'))}

                    <button class="btn btn-danger btn-xs" type="submit"

                            onclick="return confirm('${_('Confirm to remove this SSH key: %s') % ssh_key.fingerprint}');">

                        <i class="icon-trashcan"></i>

                        ${_('Remove')}

                    </button>

                ${h.end_form()}

              %else:

                ${_('Never')}

              %endif

            </td>

            <td>

                ${h.form(url('edit_user_ssh_keys_delete', id=c.user.user_id))}

                    <button class="btn btn-danger btn-xs" type="submit"

                            onclick="return confirm('${_('Confirm to remove this SSH key: %s') % ssh_key.fingerprint}');">

                        <i class="icon-trashcan"></i>

                        ${_('Remove')}

                    </button>

                ${h.end_form()}