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

    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/

                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

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

    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

#

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

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

        if authuser is None: # fall back to anonymous

            authuser = AuthUser(dbuser=default_user) # TODO: somehow use .make?

        return authuser

    @staticmethod

    def _basic_security_checks():

        """Perform basic security/sanity checks before processing the request."""

        # Only allow the following HTTP request methods.

        if request.method not in ['GET', 'HEAD', 'POST']:

            raise webob.exc.HTTPMethodNotAllowed()

        # Also verify the _method override - no longer allowed.

            pass # no override, no problem

        else:

            raise webob.exc.HTTPMethodNotAllowed()

        # Make sure CSRF token never appears in the URL. If so, invalidate it.

        if webutils.session_csrf_secret_name in request.GET:

            log.error('CSRF key leak detected')

            session.pop(webutils.session_csrf_secret_name, None)

            session.save()

            webutils.flash(_('CSRF token leak has been detected - all form tokens have been expired'),

                    category='error')

        offset = date.tzinfo.utcoffset(date)

        timezone = (offset.days * 24 * 60) + (offset.seconds / 60)

        hour, minute = divmod(timezone, 60)

        return time_str + "%+03d:%02d" % (hour, minute)

    else:

        return date.strftime('%Y-%m-%dT%H:%M:%SZ')

# From ``django.utils.feedgenerator`` via webhelpers.feedgenerator

def get_tag_uri(url, date):

    "Creates a TagURI. See http://diveintomark.org/archives/2004/05/28/howto-atom-id"

    tag = re.sub('^http://', '', url)

    if date is not None:

    tag = re.sub('#', '/', tag)

    return 'tag:' + tag

class Attributes(object):

    """Simple namespace for attribute dict access in mako and elsewhere"""

    def __init__(self, a_dict):

        self.__dict__ = a_dict

class _Feeder(object):

            lineno, sha, changeset lazy loader and line

        """

        # TODO: This function now uses os underlying 'git' command which is

        # generally not good. Should be replaced with algorithm iterating

        # commits.

        cmd = ['blame', '-l', '--root', '-r', self.raw_id, '--', path]

        # -l     ==> outputs long shas (and we need all 40 characters)

        # --root ==> doesn't put '^' character for boundaries

        # -r sha ==> blames for the given revision

        so = self.repository.run_git_command(cmd)

        for i, blame_line in enumerate(so.split('\n')[:-1]):

            yield (i + 1, sha, lambda sha=sha: self.repository.get_changeset(sha), line)

    def fill_archive(self, stream=None, kind='tgz', prefix=None,

                     subrepos=False):

        """

        Fills up given stream.

        :param stream: file like object.

        :param kind: one of following: ``zip``, ``tgz`` or ``tbz2``.

            Default: ``tgz``.

        :param prefix: name of root directory in archive.

            Default is repository name and changeset's raw_id joined with dash

"""

Mercurial libs compatibility

"""

import mercurial.encoding

import mercurial.localrepo

def monkey_do():

    """Apply some Mercurial monkey patching"""

    # workaround for 3.3 94ac64bcf6fe and not calling largefiles reposetup correctly, and test_archival failing

    mercurial.localrepo.localrepository._lfstatuswriters = [lambda *msg, **opts: None]

    # 3.5 7699d3212994 added the invariant that repo.lfstatus must exist before hitting overridearchive

    mercurial.localrepo.localrepository.lfstatus = False

    # Minimize potential impact from custom configuration

    mercurial.encoding.environ[b'HGPLAIN'] = b'1'

  <a href="http://sfconservancy.org/">Software Freedom Conservancy, Inc.</a>

  and is released under the terms of the

  <a href="http://www.gnu.org/copyleft/gpl.html">GNU General Public License,

  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&ndash;2024, Mads Kiilerich</li>

  <li>Copyright &copy; 2024, Aristotelis Stageiritis</li>

  <li>Copyright &copy; 2024, Poesty Li</li>

  <li>Copyright &copy; 2019&ndash;2020, 2022&ndash;2023, Manuel Jacob</li>

  <li>Copyright &copy; 2023, Mathias De Mare</li>

  <li>Copyright &copy; 2023, qy117121</li>

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

  <li>Copyright &copy; 2016&ndash;2017, 2020, 2022, Asterios Dimitriou</li>

  <li>Copyright &copy; 2022, Jaime Marquínez Ferrándiz</li>

  <li>Copyright &copy; 2022, Louis Bertrand</li>

  <li>Copyright &copy; 2022, toras9000</li>

  <li>Copyright &copy; 2022, yzqzss</li>

  <li>Copyright &copy; 2022, МАН69К</li>

  <li>Copyright &copy; 2014&ndash;2021, Thomas De Schampheleire</li>

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

from sqlalchemy import engine_from_config

import kallithea.config.application

from kallithea.lib.utils2 import get_crypt_password

from kallithea.model import db, meta

from kallithea.model.base import init_model

from kallithea.model.repo import RepoModel

from kallithea.tests.base import HG_REPO, TEST_USER_ADMIN_LOGIN, TEST_USER_ADMIN_PASS

rel_path = dirname(dirname(dirname(dirname(os.path.abspath(__file__)))))

conf = appconfig('config:development.ini', relative_to=rel_path)

USER = TEST_USER_ADMIN_LOGIN

PASS = TEST_USER_ADMIN_PASS

HOST = 'server.local'

METHOD = 'pull'

DEBUG = True

log = logging.getLogger(__name__)

class Command(object):

    def __init__(self, cwd):