List of contributors to Kallithea project:

    Mads Kiilerich <mads@kiilerich.com> 2016-2024

    Aristotelis Stageiritis <aristotelis79@gmail.com> 2024

    Poesty Li <poesty7450@gmail.com> 2024

    Manuel Jacob <me@manueljacob.de> 2019-2020 2022-2023

    Mathias De Mare <mathias.de_mare@nokia.com> 2023

    qy117121 <mixuan121@gmail.com> 2023

    Asterios Dimitriou <steve@pci.gr> 2016-2017 2020 2022

    Étienne Gilli <etienne@gilli.io> 2020-2022

    Jaime Marquínez Ferrándiz <weblate@jregistros.fastmail.net> 2022

    Louis Bertrand <louis.bertrand@durhamcollege.ca> 2022

    toras9000 <toras9000@gmail.com> 2022

    yzqzss <yzqzss@othing.xyz> 2022

    МАН69К <weblate@mah69k.net> 2022

    Thomas De Schampheleire <thomas.de_schampheleire@nokia.com> 2014-2021

    ssantos <ssantos@web.de> 2018-2021

    Private <adamantine.sword@gmail.com> 2019-2021

    fresh <fresh190@protonmail.com> 2020-2021

    robertus <robertuss12@gmail.com> 2020-2021

    Eugenia Russell <eugenia.russell2019@gmail.com> 2021

    Michalis <michalisntovas@yahoo.gr> 2021

    vs <vsuhachev@yandex.ru> 2021

    Александр <akonn7@mail.ru> 2021

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

    Anton Schur <tonich.sh@gmail.com> 2017 2020

    Artem <kovalevartem.ru@gmail.com> 2020

    David Ignjić <ignjic@gmail.com> 2020

    Dennis Fink <dennis.fink@c3l.lu> 2020

    J. Lavoie <j.lavoie@net-c.ca> 2020

    Ross Thomas <ross@lns-nevasoft.com> 2020

    Tim Ooms <tatankat@users.noreply.github.com> 2020

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

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

    Adi Kriegisch <adi@cg.tuwien.ac.at> 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

    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

    Chris Rule <crule@aegistg.com> 2018

    Jesús Sánchez <jsanchezfdz95@gmail.com> 2018

    Patrick Vane <patrick_vane@lowentry.com> 2018

    Pheng Heong Tan <phtan90@gmail.com> 2018

    Максим Якимчук <xpinovo@gmail.com> 2018

    Марс Ямбар <mjambarmeta@gmail.com> 2018

    Mads Kiilerich <madski@unity3d.com> 2012-2017

    Unity Technologies 2012-2017

    Søren Løvborg <sorenl@unity3d.com> 2015-2017

    Sam Jaques <sam.jaques@me.com> 2015 2017

    Alessandro Molina <alessandro.molina@axant.it> 2017

    Ching-Chen Mao <mao@lins.fju.edu.tw> 2017

    Eivind Tagseth <eivindt@gmail.com> 2017

    FUJIWARA Katsunori <foozy@lares.dti.ne.jp> 2017

    Holger Schramm <info@schramm.by> 2017

    Karl Goetz <karl@kgoetz.id.au> 2017

    Lars Kruse <devel@sumpfralle.de> 2017

    Marko Semet <markosemet@googlemail.com> 2017

    Viktar Vauchkevich <victorenator@gmail.com> 2017

    Takumi IINO <trot.thunder@gmail.com> 2012-2016

    Jan Heylen <heyleke@gmail.com> 2015-2016

    Robert Martinez <ntttq@inboxen.org> 2015-2016

    Robert Rauch <mail@robertrauch.de> 2015-2016

    Angel Ezquerra <angel.ezquerra@gmail.com> 2016

    Anton Shestakov <av6@dwimlabs.net> 2016

    Brandon Jones <bjones14@gmail.com> 2016

    Kateryna Musina <kateryna@unity3d.com> 2016

    Konstantin Veretennicov <kveretennicov@gmail.com> 2016

    Oscar Curero <oscar@naiandei.net> 2016

    Robert James Dennington <tinytimrob@googlemail.com> 2016

    timeless@gmail.com 2016

    YFdyh000 <yfdyh000@gmail.com> 2016

    Aras Pranckevičius <aras@unity3d.com> 2012-2013 2015

    Sean Farley <sean.michael.farley@gmail.com> 2013-2015

    Bradley M. Kuhn <bkuhn@sfconservancy.org> 2014-2015

    Christian Oyarzun <oyarzun@gmail.com> 2014-2015

    Joseph Rivera <rivera.d.joseph@gmail.com> 2014-2015

    Anatoly Bubenkov <bubenkoff@gmail.com> 2015

    Andrew Bartlett <abartlet@catalyst.net.nz> 2015

    Balázs Úr <urbalazs@gmail.com> 2015

    Ben Finney <ben@benfinney.id.au> 2015

    Daniel Hobley <danielh@unity3d.com> 2015

    David Avigni <david.avigni@ankapi.com> 2015

    Denis Blanchette <dblanchette@coveo.com> 2015

    duanhongyi <duanhongyi@doopai.com> 2015

    EriCSN Chang <ericsning@gmail.com> 2015

    Grzegorz Krason <grzegorz.krason@gmail.com> 2015

    Jiří Suchan <yed@vanyli.net> 2015

    Kazunari Kobayashi <kobanari@nifty.com> 2015

    Kevin Bullock <kbullock@ringworld.org> 2015

    kobanari <kobanari@nifty.com> 2015

    Marc Abramowitz <marc@marc-abramowitz.com> 2015

    proxy_read_timeout          7200;

    proxy_buffers               8 32k;

    client_max_body_size        1024m;

    client_body_buffer_size     128k;

    large_client_header_buffers 8 64k;

.. _apache_virtual_host_reverse_proxy:

Apache virtual host reverse proxy example

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

Here is a sample configuration file for Apache using proxy:

.. code-block:: apache

    <VirtualHost *:80>

            ServerName kallithea.example.com

            <Proxy *>

              # For Apache 2.4 and later:

              Require all granted

              # For Apache 2.2 and earlier, instead use:

              # Order allow,deny

              # Allow from all

            </Proxy>

            #important !

            #Directive to properly generate url (clone url) for Kallithea

            ProxyPreserveHost On

            #kallithea instance

            ProxyPass / http://127.0.0.1:5000/

            ProxyPassReverse / http://127.0.0.1:5000/

            #to enable https use line below

            #SetEnvIf X-Url-Scheme https HTTPS=1

    </VirtualHost>

Additional tutorial

http://pylonsbook.com/en/1.1/deployment.html#using-apache-to-proxy-requests-to-pylons

.. _apache_subdirectory:

Apache as subdirectory

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

Apache subdirectory part:

.. code-block:: apache

    <Location /PREFIX >

      ProxyPass http://127.0.0.1:5000/PREFIX

      ProxyPassReverse http://127.0.0.1:5000/PREFIX

      SetEnvIf X-Url-Scheme https HTTPS=1

    </Location>

Besides the regular apache setup you will need to add the following line

into ``[app:main]`` section of your .ini file::

    filter-with = proxy-prefix

Add the following at the end of the .ini file::

    [filter:proxy-prefix]

    use = egg:PasteDeploy#prefix

    prefix = /PREFIX

then change ``PREFIX`` into your chosen prefix

.. _apache_mod_wsgi:

Apache with mod_wsgi

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

Alternatively, Kallithea can be set up with Apache under mod_wsgi. For

that, you'll need to:

- Install mod_wsgi. If using a Debian-based distro, you can install

  the package libapache2-mod-wsgi::

    aptitude install libapache2-mod-wsgi

- Enable mod_wsgi::

    a2enmod wsgi

- Add global Apache configuration to tell mod_wsgi that Python only will be

  used in the WSGI processes and shouldn't be initialized in the Apache

  processes::

    WSGIRestrictEmbedded On

  .. code-block:: python

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

      from logging.config import fileConfig

      fileConfig(ini, {'__file__': ini, 'here': '/srv/kallithea'})

      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.

  The default locale settings Apache provides for web services are often not

  adequate, with `C` as the default language and `ASCII` as the encoding.

  Instead, use the ``lang`` parameter of ``WSGIDaemonProcess`` to specify a

  suitable locale. See also the :ref:`overview` section and the

  `WSGIDaemonProcess documentation`_.

  Apache will by default run as a special Apache user, on Linux systems

  usually ``www-data`` or ``apache``. If you need to have the repositories

  directory owned by a different user, use the user and group options to

  WSGIDaemonProcess to set the name of the user and group.

  Once again, check that all paths are correctly specified.

  .. code-block:: apache

      WSGIDaemonProcess kallithea processes=5 threads=1 maximum-requests=100 \

          python-home=/srv/kallithea/venv lang=C.UTF-8

      WSGIProcessGroup kallithea

      WSGIPassAuthorization On

Other configuration files

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

A number of `example init.d scripts`__ can be found in

the ``init.d`` directory of the Kallithea source.

.. __: https://kallithea-scm.org/repos/kallithea/files/tip/init.d/ .

.. _python: http://www.python.org/

.. _Python regular expression documentation: https://docs.python.org/2/library/re.html

.. _Mercurial: https://www.mercurial-scm.org/

.. _Celery: http://celeryproject.org/

.. _Celery documentation: http://docs.celeryproject.org/en/latest/getting-started/index.html

.. _RabbitMQ: http://www.rabbitmq.com/

.. _Redis: http://redis.io/

.. _mercurial-server: http://www.lshift.net/mercurial-server.html

.. _PublishingRepositories: https://www.mercurial-scm.org/wiki/PublishingRepositories

.. _WSGIDaemonProcess documentation: https://modwsgi.readthedocs.io/en/develop/configuration-directives/WSGIDaemonProcess.html

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

# 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 configparser

import functools

import logging.config

import os

import re

import sys

import click

import paste.deploy

import kallithea

import kallithea.config.application

# kallithea_cli is usually invoked through the 'kallithea-cli' wrapper script

# that is installed by setuptools, as specified in setup.py console_scripts

# entry_points. The script will be using the right virtualenv (if any), and for

# Unix, it will contain #! pointing at the right python executable. The script

# also makes sure sys.argv[0] points back at the script path, and that is what

# can be used to invoke 'kallithea-cli' later.

kallithea_cli_path = sys.argv[0]

def read_config(ini_file_name, strip_section_prefix):

    """Read ini_file_name content, and for all sections like '[X:Y]' where X is

    strip_section_prefix, replace the section name with '[Y]'."""

    def repl(m):

        if m.group(1) == strip_section_prefix:

            return '[%s]' % m.group(2)

        return m.group(0)

    with open(ini_file_name) as f:

        return re.sub(r'^\[([^:]+):(.*)]', repl, f.read(), flags=re.MULTILINE)

# This placeholder is the main entry point for the kallithea-cli command

@click.group(context_settings=dict(help_option_names=['-h', '--help']))

def cli():

    """Various commands to manage a Kallithea instance."""

def register_command(needs_config_file=False, config_file_initialize_app=False, hidden=False):

    """Register a kallithea-cli subcommand.

    If one of the needs_config_file flags are true, a config file must be specified

    with -c and it is read and logging is configured. The configuration is

    available in the kallithea.CONFIG dict.

    If config_file_initialize_app is true, Kallithea, TurboGears global state

    (including tg.config), and database access will also be fully initialized.

    """

    cli_command = cli.command(hidden=hidden)

    if needs_config_file or config_file_initialize_app:

        def annotator(annotated):

            @click.option('--config_file', '-c', help="Path to .ini file with app configuration.",

                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)

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

                cp = configparser.ConfigParser(strict=False)

                cp.read_string(read_config(path_to_ini_file, strip_section_prefix=annotated.__name__))

                logging.config.fileConfig(cp,

                    {'__file__': path_to_ini_file, 'here': os.path.dirname(path_to_ini_file)})

                if needs_config_file:

                    annotated(*args, config=config, **kwargs)

                if config_file_initialize_app:

                    annotated(*args, **kwargs)

            return cli_command(runtime_wrapper)

        return annotator

    return cli_command

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

# 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 click

from celery.bin.celery import celery as celery_command

import kallithea

import kallithea.bin.kallithea_cli_base as cli_base

from kallithea.lib import celery_app

from kallithea.lib.utils2 import asbool

@cli_base.register_command(needs_config_file=True)

@click.argument('celery_args', nargs=-1)

def celery_run(celery_args, config):

    """Start Celery worker(s) for asynchronous tasks.

    This commands starts the Celery daemon which will spawn workers to handle

    certain asynchronous tasks for Kallithea.

    Any extra arguments you pass to this command will be passed through to

    Celery. Use '--' before such extra arguments to avoid options to be parsed

    by this CLI command.

    """

    if not asbool(config.get('use_celery')):

        raise Exception('Please set use_celery = true in .ini config '

                        'file before running this command')

    kallithea.CELERY_APP.config_from_object(celery_app.make_celery_config(config))

    args = list(celery_args)

    # args[0] is generally ignored when prog_name is specified, but -h *needs* it to be 'worker' ... but will also suggest that users specify 'worker' explicitly

    if not args or args[0] != 'worker':

        args.insert(0, 'worker')

    # inline kallithea.CELERY_APP.start in order to allow specifying prog_name

    assert celery_command.params[0].name == 'app'

    celery_command.params[0].default = kallithea.CELERY_APP

    celery_command.main(args=args, prog_name='kallithea-cli celery-run -c CONFIG_FILE --')

:author: marcink

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

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

"""

import logging

import os

import sys

import mercurial.hg

import mercurial.scmutil

import paste.deploy

import kallithea

import kallithea.config.application

from kallithea.lib import hooks, webutils

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

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

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

from kallithea.model import db

log = logging.getLogger(__name__)

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

    """Show size of Mercurial repository.

    Called as Mercurial hook changegroup.kallithea_repo_size after push.

    """

    size_hg, size_root = get_scm_size('.hg', safe_str(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') % (

        webutils.format_byte_size(size_hg),

        webutils.format_byte_size(size_root),

        webutils.format_byte_size(size_hg + size_root),

        last_cs.rev(),

        ascii_str(last_cs.hex())[:12],

    )

    ui.status(safe_bytes(msg))

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

    """Update repo after push. The equivalent to 'hg update' but using the same

    Mercurial as everything else.

    Called as Mercurial hook changegroup.kallithea_update after push.

    """

    try:

        ui.pushbuffer(error=True, subproc=True)

        rev = brev = None

        mercurial.hg.updatetotally(ui, repo, rev, brev)

    finally:

        s = ui.popbuffer()  # usually just "x files updated, x files merged, x files removed, x files unresolved"

        log.info('%s update hook output: %s', safe_str(repo.root), safe_str(s).rstrip())

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

    """Logs user pull action

    Called as Mercurial hook outgoing.kallithea_pull_action.

    """

    hooks.log_pull_action()

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

    """

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

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

    caches! The function should perhaps be renamed.

    Called as Mercurial hook changegroup.kallithea_push_action .

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

    """

    revs = [ascii_str(repo[r].hex()) for r in mercurial.scmutil.revrange(repo, [b'%s:%s' % (node, node_last)])]

    hooks.process_pushed_raw_ids(revs)

def _git_hook_environment(repo_path):

    """

    Create a light-weight environment for stand-alone scripts and return an UI and the

    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.

    """

    extras = get_hook_environment()

    path_to_ini_file = extras['config']

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

    #logging.config.fileConfig(ini_file_path) # Note: we are in a different process - don't use configured logging

    # fix if it's not a bare repo

    if repo_path.endswith(os.sep + '.git'):

        repo_path = repo_path[:-5]

    repo = db.Repository.get_by_full_path(repo_path)

    if not repo:

        raise OSError('Repository %s not found in database' % repo_path)

    return repo

def post_receive(repo_path, git_stdin_lines):

    """Called from Git post-receive hook.

    The returned value is used as hook exit code and must be 0.

    """

    try:

        repo = _git_hook_environment(repo_path)

    except HookEnvironmentError as e:

        sys.stderr.write("Skipping Kallithea Git post-receive hook %r.\nGit was apparently not invoked by Kallithea: %s\n" % (sys.argv[0], e))

        return 0

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

        old_rev, new_rev, ref = l.strip().split(' ')

        _ref_data = ref.split('/')

        if _ref_data[1] in ['tags', 'heads']:

            rev_data.append({'old_rev': old_rev,

                             'new_rev': new_rev,

                             'ref': ref,

                             'type': _ref_data[1],

                             'name': '/'.join(_ref_data[2:])})

    git_revs = []

    for push_ref in rev_data:

        _type = push_ref['type']

        if _type == 'heads':

            if push_ref['old_rev'] == EmptyChangeset().raw_id:

                # update the symbolic ref if we push new repo

                if scm_repo.is_empty():

                    scm_repo._repo.refs.set_symbolic_ref(

                        b'HEAD',

                        b'refs/heads/%s' % safe_bytes(push_ref['name']))

                # build exclude list without the ref

                cmd = ['for-each-ref', '--format=%(refname)', 'refs/heads/*']

                stdout = scm_repo.run_git_command(cmd)

                ref = push_ref['ref']

                heads = [head for head in stdout.splitlines() if head != ref]

                # now list the git revs while excluding from the list

                cmd = ['log', push_ref['new_rev'], '--reverse', '--pretty=format:%H']

                cmd.append('--not')

                cmd.extend(heads) # empty list is ok

                stdout = scm_repo.run_git_command(cmd)

                git_revs += stdout.splitlines()

            elif push_ref['new_rev'] == EmptyChangeset().raw_id:

                # delete branch case

                git_revs += ['delete_branch=>%s' % push_ref['name']]

            else:

                cmd = ['log', '%(old_rev)s..%(new_rev)s' % push_ref,

                       '--reverse', '--pretty=format:%H']

                stdout = scm_repo.run_git_command(cmd)

                git_revs += stdout.splitlines()

        elif _type == 'tags':

            git_revs += ['tag=>%s' % push_ref['name']]

    hooks.process_pushed_raw_ids(git_revs)

    return 0

# Almost exactly like Mercurial contrib/hg-ssh:

def rejectpush(ui, **kwargs):

    """Mercurial hook to be installed as pretxnopen and prepushkey for read-only repos.

    Return value 1 will make the hook fail and reject the push.

    """

    ex = get_hook_environment()

    ui.warn(safe_bytes("Push access to %r denied\n" % ex.repository))

    return 1

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

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

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

from kallithea.config.app_cfg import base_config

from kallithea.config.middleware.https_fixup import HttpsFixup

from kallithea.config.middleware.permanent_repo_url import PermanentRepoUrl

from kallithea.config.middleware.simplegit import SimpleGit

from kallithea.config.middleware.simplehg import SimpleHg

from kallithea.config.middleware.wrapper import RequestWrapper

from kallithea.lib.utils2 import asbool

__all__ = ['make_app']

def wrap_app(app):

    """Wrap the TG WSGI application in Kallithea middleware"""

    config = app.config

    # we want our low level middleware to get to the request ASAP. We don't

    # need any stack middleware in them - especially no StatusCodeRedirect buffering

    app = SimpleHg(app, config)

    app = SimpleGit(app, config)

    # Enable https redirects based on HTTP_X_URL_SCHEME set by proxy

    if config.get('url_scheme_variable') or asbool(config.get('force_https')) or asbool(config.get('use_htsts')):

        app = HttpsFixup(app, config)

    app = PermanentRepoUrl(app, config)

    # Optional and undocumented wrapper - gives more verbose request/response logging, but has a slight overhead

    if asbool(config.get('use_wsgi_wrapper')):

        app = RequestWrapper(app, config)

    return app

def make_app(global_conf, **app_conf):

    """

    Set up Kallithea with the settings found in the PasteDeploy configuration

    file used.

    :param global_conf: The global settings for Kallithea (those

        defined under the ``[DEFAULT]`` section).

    :return: The Kallithea application with all the relevant middleware

        loaded.

    This is the PasteDeploy factory for the Kallithea application.

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

    under ``[app:main]``.

    """

    assert app_conf.get('sqlalchemy.url')  # must be called with a Kallithea .ini file, which for example must have this config option

    assert global_conf.get('here') and global_conf.get('__file__')  # app config should be initialized the paste way ...

    return base_config.make_wsgi_app(global_conf, app_conf, wrap_app=wrap_app)

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

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

"""

kallithea.config.middleware.simplehg

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

SimpleHg middleware for handling Mercurial protocol requests (push/clone etc.).

It's implemented with basic auth function

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 urllib.parse

import mercurial.hgweb

from kallithea.controllers import base

from kallithea.lib.utils import make_ui

from kallithea.lib.utils2 import safe_bytes

log = logging.getLogger(__name__)

def get_header_hgarg(environ):

    """Decode the special Mercurial encoding of big requests over multiple headers.

    >>> get_header_hgarg({})

    ''

    >>> get_header_hgarg({'HTTP_X_HGARG_0': ' ', 'HTTP_X_HGARG_1': 'a','HTTP_X_HGARG_2': '','HTTP_X_HGARG_3': 'b+c %20'})

    'ab+c %20'

    """

    chunks = []

    i = 1

    while True:

        v = environ.get('HTTP_X_HGARG_%d' % i)

        if v is None:

            break

        chunks.append(v)

        i += 1

    return ''.join(chunks)

cmd_mapping = {

    # 'batch' is not in this list - it is handled explicitly

    'between': 'pull',

    'branches': 'pull',

    'branchmap': 'pull',

    'capabilities': 'pull',

    'changegroup': 'pull',

    'changegroupsubset': 'pull',

    'changesetdata': 'pull',

    'clonebundles': 'pull',

    'debugwireargs': 'pull',

    'filedata': 'pull',

    'getbundle': 'pull',

    'getlfile': 'pull',

    'heads': 'pull',

    'hello': 'pull',

    'known': 'pull',

    'lheads': 'pull',

    'listkeys': 'pull',

    'lookup': 'pull',

    'manifestdata': 'pull',

    'narrow_widen': 'pull',

    'protocaps': 'pull',

    'statlfile': 'pull',

    'stream_out': 'pull',

    'pushkey': 'push',

    'putlfile': 'push',

    'unbundle': 'push',

    }

class SimpleHg(base.BaseVCSController):

    scm_alias = 'hg'

    @classmethod

    def parse_request(cls, environ):

        http_accept = environ.get('HTTP_ACCEPT', '')

        if not http_accept.startswith('application/mercurial'):

            return None

        path_info = base.get_path_info(environ)

        if not path_info.startswith('/'): # it must!

            return None

        class parsed_request(object):

            repo_name = path_info[1:].rstrip('/')

            query_string = environ['QUERY_STRING']

            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(';'):

                            cmd, _args = urllib.parse.unquote_plus(cmd_arg).split(' ', 1)

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

        """

        Make an hgweb wsgi application.

        """

        repo_name = parsed_request.repo_name

        repo_path = os.path.join(self.basepath, repo_name)

        baseui = make_ui(repo_path=repo_path)

        hgweb_app = mercurial.hgweb.hgweb(safe_bytes(repo_path), name=safe_bytes(repo_name), baseui=baseui)

        def wrapper_app(environ, start_response):

            environ['REPO_NAME'] = repo_name # used by mercurial.hgweb.hgweb

            return hgweb_app(environ, start_response)

        return wrapper_app

        # Visual options

        c.visual = AttributeDict({})

        ## DB stored

        c.visual.show_public_icon = asbool(settings.get('show_public_icon'))

        c.visual.show_private_icon = asbool(settings.get('show_private_icon'))

        c.visual.stylify_metalabels = asbool(settings.get('stylify_metalabels'))

        c.visual.page_size = safe_int(settings.get('dashboard_items', 100))

        c.visual.admin_grid_items = safe_int(settings.get('admin_grid_items', 100))

        c.visual.repository_fields = asbool(settings.get('repository_fields'))

        c.visual.show_version = asbool(settings.get('show_version'))

        c.visual.use_gravatar = asbool(settings.get('use_gravatar'))

        c.visual.gravatar_url = settings.get('gravatar_url')

        c.ga_code = settings.get('ga_code')

        # TODO: replace undocumented backwards compatibility hack with db upgrade and rename ga_code

        if c.ga_code and '<' not in c.ga_code:

            c.ga_code = '''<script type="text/javascript">

                var _gaq = _gaq || [];

                _gaq.push(['_setAccount', '%s']);

                _gaq.push(['_trackPageview']);

                (function() {

                    var ga = document.createElement('script'); ga.type = 'text/javascript'; ga.async = true;

                    ga.src = ('https:' == document.location.protocol ? 'https://ssl' : 'http://www') + '.google-analytics.com/ga.js';

                    var s = document.getElementsByTagName('script')[0]; s.parentNode.insertBefore(ga, s);

                    })();