#smtp_use_tls = false

[server:main]

## nr of worker threads to spawn

#threadpool_workers = 1

## max request before thread respawn

## option to use threads of process

#use_threadpool = true

## WAITRESS ##

use = egg:waitress#main

## number of worker threads

################################

[loggers]

[handlers]

keys = console, console_sql

qualname = kallithea

propagate = 1

[logger_sqlalchemy]

level = INFO

handlers = console_sql

        source ../kallithea-venv/bin/activate

        pip install --upgrade pip setuptools

        pip install -e .

        firefox http://127.0.0.1:5000/

You can also start out by forking https://bitbucket.org/conservancy/kallithea

It is possible to avoid recreating the full test database on each invocation of

the tests, thus eliminating the initial delay. To achieve this, run the tests as::

    KALLITHEA_WHOOSH_TEST_DISABLE=1 KALLITHEA_NO_TMP_PATH=1 py.test

    kill -9 $(cat test.pid)

2. Create a separate throwaway configuration for iterating on the actual

   database changes::

   Edit the file to change database settings. SQLite is typically fine,

   but make sure to change the path to e.g. ``temp.db``, to avoid

   to test the changes::

    rm temp.db

5. Once satisfied with the schema changes, auto-generate a draft Alembic

   script using the development database that has *not* been upgraded.

The ISAPI handler can be generated using::

This will generate a ``dispatch.py`` file in the current directory that contains

the necessary components to finalize an installation into IIS. Once this file

The ISAPI handler is registered to all file extensions, so it will automatically

be the one handling all requests to the specified virtual directory. When the website starts

middleware WSGI handler that Kallithea runs within and each HTTP request to the

site will be processed through this logic henceforth.

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

Typically, any issues in this setup will either be entirely in IIS or entirely

different options for finding issues exist: IIS' failed request tracking which

is great at finding issues until they exist inside Kallithea, at which point the

ISAPI-WSGI wrapper above uses ``win32traceutil``, which is part of ``pywin32``.

one). When ready, type::

  cd C:\Kallithea\Bin

Then you must edit production.ini to fit your needs (IP address, IP

port, mail settings, database, etc.). `NotePad++`__ or a similar text

For the sake of simplicity, run it with the default settings. After your edits (if any) in the previous command prompt, type::

.. warning:: This time a *new* database will be installed. You must

             follow a different process to later :ref:`upgrade <upgrade>`

In the previous command prompt, being in the C:\\Kallithea\\Bin folder, type::

Open your web server, and go to http://127.0.0.1:5000

"activate" one). When ready, just type::

  cd C:\Kallithea\Bin

Then, you must edit production.ini to fit your needs (network address and

port, mail settings, database, whatever). I recommend using NotePad++

For the sake of simplicity lets run it with the default settings. After

your edits (if any), in the previous Command Prompt, type::

.. warning:: This time a *new* database will be installed. You must

             follow a different process to later :ref:`upgrade <upgrade>`

In the previous command prompt, being in the C:\\Kallithea\\Bin folder,

just type::

Open yout web server, and go to http://127.0.0.1:5000

There are several web server options:

  from the command line. That is perfect for development and evaluation.

  Actual use in production might have different requirements and need extra

  work to make it manageable as a scalable system service.

  Waitress_. Gunicorn_ is also an option. These web servers have different

  limited feature sets.

  to it. The entry point for the WSGI application is configured

  in ``setup.py`` as ``kallithea.config.middleware:make_app``.

  encryption or special authentication or for other security reasons, to

  provide caching of static files, or to provide load balancing or fail-over.

  Nginx_, Varnish_ and HAProxy_ are often used for this purpose, often in front

The best option depends on what you are familiar with and the requirements for

performance and stability. Also, keep in mind that Kallithea mainly is serving

.. _Gunicorn: http://gunicorn.org/

.. _Waitress: http://waitress.readthedocs.org/en/latest/

.. _virtualenv: http://pypi.python.org/pypi/virtualenv

.. _PyPI: https://pypi.python.org/pypi

.. _Apache httpd: http://httpd.apache.org/

.. _mod_wsgi: https://code.google.com/p/modwsgi/

First, you will need to create a Kallithea configuration file. Run the

following command to do so::

This will create the file ``my.ini`` in the current directory. This

configuration file contains the various settings for Kallithea, e.g.

PostgreSQL, SQLite and MySQL databases. Create the database by running

the following command::

This will prompt you for a "root" path. This "root" path is the location where

Kallithea will store all of its repositories on the current machine. After

The ``setup-db`` values can also be given on the command line.

Example::

The ``setup-db`` command will create all needed tables and an

admin account. When choosing a root path you can either use a new

You are now ready to use Kallithea. To run it simply execute::

- This command runs the Kallithea server. The web app should be available at

  http://127.0.0.1:5000. The IP address and port is configurable via the

For an incremental index build, run::

For a full index rebuild, run::

The ``--repo-location`` option allows the location of the repositories to be overridden;

usually, the location is retrieved from the Kallithea database.

The ``--index-only`` option can be used to limit the indexed repositories to a comma-separated list::

To keep your index up-to-date it is necessary to do periodic index builds;

for this, it is recommended to use a crontab entry. Example::

When using incremental mode (the default), Whoosh will check the last

modification date of each file and add it to be reindexed if a newer file is

To start the Celery process, run::

.. note::

   Make sure you run this command from the same virtualenv, and with the same

Run the following command to upgrade your configuration (``.ini``) file::

This will display any changes made by the new version of Kallithea to your

current configuration, and attempt an automatic merge. It is recommended

To generate a skeleton extensions package, run::

This will create an ``rcextensions`` package next to the specified ``ini`` file.

See the ``__init__.py`` file inside the generated ``rcextensions`` package

There is a special command for cleaning up such archived repositories::

This command scans for archived repositories that are older than

30 days, displays them, and asks if you want to delete them (unless given

Large Git pushes require an HTTP server with support for

chunked encoding for POST. The Python web servers waitress_ and

gunicorn_ (Linux only) can be used. By default, Kallithea uses

server.

    use = egg:waitress#main

# env GROUP=hg

script

    if [ -z "$GROUP" ]; then

        exec sudo -u $USER $COMMAND

    else

CONF_NAME="production.ini"

LOG_FILE="/var/log/$DAEMON.log"

PID_FILE="/run/daemons/$DAEMON"

RUN_AS="*****"

ARGS="serve --daemon \

--group=$RUN_AS \

--pid-file=$PID_FILE \

--log-file=$LOG_FILE \

[ -r /etc/conf.d/$DAEMON ] && . /etc/conf.d/$DAEMON

RUN_AS="root"

DAEMON_OPTS="serve --daemon \

 --user=$RUN_AS \

 --group=$RUN_AS \

 --pid-file=$PID_PATH \

start() {

RUN_AS="username"

DAEMON_OPTS="serve --daemon \

--user=$RUN_AS \

--group=$RUN_AS \

--pid-file=$PID_PATH \

#extra options

opts="${opts} restartdelay"

CONF_NAME="production.ini"

# write to wherever the PID should be stored, just ensure

# same goes for the log file

PID_PATH="/var/run/kallithea/pid"

LOG_PATH="/var/log/kallithea/kallithea.log"

RUN_AS="kallithea"

DAEMON_OPTS="serve --daemon \

    --user=$RUN_AS \

    --group=$RUN_AS \

    --pid-file=$PID_PATH \

DESC="kallithea-server"

LOCK_FILE="/var/lock/subsys/$APP_NAME"

env USER=hg

env GROUP=hg

post-stop script

    rm -f $PIDFILE

numprocs = 1

numprocs_start = 5000 # possible should match ports

directory=/srv/kallithea

process_name = %(program_name)s_%(process_num)04d

redirect_stderr=true

stdout_logfile=/%(here)s/kallithea.log

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

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

# and loggers are assumed to already have been configured.

if config.config_file_name:

    fileConfig(config.config_file_name, disable_existing_loggers=False)

#smtp_use_tls = false

[server:main]

<%text>## nr of worker threads to spawn</%text>

threadpool_workers = 1

<%text>## max request before thread respawn</%text>

<%text>## option to use threads of process</%text>

use_threadpool = true

%elif http_server == 'waitress':

<%text>## WAITRESS ##</%text>

use = egg:waitress#main

<%text>################################</%text>

[loggers]

[handlers]

keys = console, console_sql

qualname = kallithea

propagate = 1

[logger_sqlalchemy]

level = INFO

handlers = console_sql

#smtp_use_tls = false

[server:main]

## nr of worker threads to spawn

#threadpool_workers = 1

## max request before thread respawn

## option to use threads of process

#use_threadpool = true

## WAITRESS ##

use = egg:waitress#main

## number of worker threads

################################

[loggers]

[handlers]

keys = console, console_sql

qualname = kallithea

propagate = 1

[logger_sqlalchemy]

level = INFO

handlers = console_sql

class UpgradeDb(Command):

    def run(self, args):

        raise SystemExit(

kallithea.lib.paster_commands.cache_keys

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

This file was forked by the Kallithea project in July 2014.

class Command(BasePasterCommand):

        _caches = CacheInvalidation.query().order_by(CacheInvalidation.cache_key).all()

            for c_obj in _caches:

                print 'key:%s active:%s' % (safe_str(c_obj.cache_key), c_obj.cache_active)

            for c_obj in _caches:

                Session().delete(c_obj)

                print 'Removing key: %s' % (safe_str(c_obj.cache_key))

        else:

            print 'Nothing done, exiting...'

            '--show',

            action='store_true',

            dest='show',

        )

            '--cleanup',

            action="store_true",

            dest="cleanup",

        )

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

import kallithea

from kallithea.lib.paster_commands.common import BasePasterCommand

from kallithea.lib.utils import load_rcextensions

class Command(BasePasterCommand):

        from kallithea.lib import celerypylons

        from tg import config

        try:

        load_rcextensions(config['here'])

        cmd = celerypylons.worker.worker(celerypylons.app.app_or_default())

kallithea.lib.paster_commands.cleanup

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

This file was forked by the Kallithea project in July 2014.

class Command(BasePasterCommand):

    def _parse_older_than(self, val):

        regex = re.compile(r'((?P<days>\d+?)d)?((?P<hours>\d+?)h)?((?P<minutes>\d+?)m)?((?P<seconds>\d+?)s)?')

        date_part = name[4:19]  # 4:19 since we don't parse milliseconds

        return datetime.datetime.strptime(date_part, '%Y%m%d_%H%M%S')

        repos_location = Ui.get_repos_location()

        to_remove = []

        for dn_, dirs, f in os.walk(safe_str(repos_location)):

        #filter older than (if present)!

        now = datetime.datetime.now()

        if older_than:

            to_remove_filtered = []

            older_than_date = self._parse_older_than(older_than)

                % (len(to_remove), older_than, older_than_date)

        else:

            print 'Removing all %s deleted repos' % len(to_remove)

            # don't ask just remove !

            remove = True

        else:

        else:

            print 'Nothing done, exiting...'

            '--older-than',

            action='store',

            dest='older_than',

                 "removed more than 30 days ago.")

            )

            '--dont-ask',

            action="store_true",

            dest="dont_ask",

            help="remove repositories without asking for confirmation."

        )

kallithea.lib.paster_commands.common

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

This file was forked by the Kallithea project in July 2014.

Original author and date, and relevant copyright and licensing information is below:

"""

import os