#use = egg:gunicorn#main

## number of process workers. You must set `instance_id = *` when this option

## is set to more than one worker

#workers = 1

## process name

#proc_name = kallithea

## type of worker class, one of sync, eventlet, gevent, tornado

## recommended for bigger setup is using of of other than sync one

#worker_class = sync

#max_requests = 1000

## ammount of time a worker can handle request before it gets killed and

## restarted

#timeout = 3600

## UWSGI ##

## run with uwsgi --ini-paste-logged <inifile.ini>

#[uwsgi]

#socket = /tmp/uwsgi.sock

#master = true

#http = 127.0.0.1:5000

## set as deamon and redirect all output to file

#daemonize = ./uwsgi_kallithea.log

## master process PID

#pidfile = ./uwsgi_kallithea.pid

## stats server with workers statistics, use uwsgitop

## for monitoring, `uwsgitop 127.0.0.1:1717`

#stats = 127.0.0.1:1717

#memory-report = true

## log 5XX errors

#log-5xx = true

## Set the socket listen queue size.

#listen = 256

## Gracefully Reload workers after the specified amount of managed requests

## (avoid memory leaks).

#max-requests = 1000

## enable large buffers

#buffer-size = 65535

## socket and http timeouts ##

#http-timeout = 3600

#socket-timeout = 3600

## Log requests slower than the specified number of milliseconds.

#log-slow = 10

## Exit if no app can be loaded.

#need-app = true

## Set lazy mode (load apps in workers instead of master).

#lazy = true

## scaling ##

## set cheaper algorithm to use, if not set default will be used

#cheaper-algo = spare

## minimum number of workers to keep at all times

#cheaper = 1

## number of workers to spawn at startup

#cheaper-initial = 1

## maximum number of workers that can be spawned

#workers = 4

## how many workers should be spawned at a time

#cheaper-step = 1

## COMMON ##

host = 0.0.0.0

port = 5000

## middleware for hosting the WSGI application under a URL prefix

#[filter:proxy-prefix]

#use = egg:PasteDeploy#prefix

#prefix = /<your-prefix>

[app:main]

use = egg:kallithea

## enable proxy prefix middleware

#filter-with = proxy-prefix

full_stack = true

static_files = true

## Available Languages:

## cs de fr hu ja nl_BE pl pt_BR ru sk zh_CN zh_TW

lang =

cache_dir = %(here)s/data

index_dir = %(here)s/data/index

## perform a full repository scan on each server start, this should be

## set to false after first startup, to allow faster server restarts.

#initial_repo_scan = false

initial_repo_scan = true

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

archive_cache_dir = %(here)s/tarballcache

## change this to unique ID for security

app_instance_uuid = development-not-secret

## cut off limit for large diffs (size in bytes)

cut_off_limit = 256000

## use cache version of scm repo everywhere

vcs_full_cache = true

## force https in Kallithea, fixes https redirects, assumes it's always https

force_https = false

## use Strict-Transport-Security headers

use_htsts = false

## number of commits stats will parse on each iteration

commit_parse_limit = 25

## path to git executable

git_path = git

## git rev filter option, --all is the default filter, if you need to

## hide all refs in changelog switch this to --branches --tags

#git_rev_filter = --branches --tags

## RSS feed options

rss_cut_off_limit = 256000

rss_items_per_page = 10

rss_include_diff = false

## options for showing and identifying changesets

show_sha_length = 12

show_revision_number = false

## gist URL alias, used to create nicer urls for gist. This should be an

## url that does rewrites to _admin/gists/<gistid>.

## example: http://gist.example.com/{gistid}. Empty means use the internal

## Kallithea url, ie. http[s]://kallithea.example.com/_admin/gists/<gistid>

gist_alias_url =

## white list of API enabled controllers. This allows to add list of

## controllers to which access will be enabled by api_key. eg: to enable

## api access to raw_files put `FilesController:raw`, to enable access to patches

## add `ChangesetController:changeset_patch`. This list should be "," separated

## Syntax is <ControllerClass>:<function>. Check debug logs for generated names

## Recommended settings below are commented out:

api_access_controllers_whitelist =

#    ChangesetController:changeset_patch,

#    ChangesetController:changeset_raw,

#    FilesController:raw,

#    FilesController:archivefile

## default encoding used to convert from and to unicode

## can be also a comma seperated list of encoding in case of mixed encodings

default_encoding = utf8

## issue tracker for Kallithea (leave blank to disable, absent for default)

#bugtracker = https://bitbucket.org/conservancy/kallithea/issues

## issue tracking mapping for commits messages

## comment out issue_pat, issue_server, issue_prefix to enable

## pattern to get the issues from commit messages

## default one used here is #<numbers> with a regex passive group for `#`

## {id} will be all groups matched from this pattern

issue_pat = (?:\s*#)(\d+)

## server url to the issue, each {id} will be replaced with match

## fetched from the regex and {repo} is replaced with full repository name

## including groups {repo_name} is replaced with just name of repo

issue_server_link = https://issues.example.com/{repo}/issue/{id}

## prefix to add to link to indicate it's an url

## #314 will be replaced by <issue_prefix><id>

issue_prefix = #

## issue_pat, issue_server_link, issue_prefix can have suffixes to specify

## multiple patterns, to other issues server, wiki or others

## below an example how to create a wiki pattern

# wiki-some-id -> https://wiki.example.com/some-id

#issue_pat_wiki = (?:wiki-)(.+)

#issue_server_link_wiki = https://wiki.example.com/{id}

#issue_prefix_wiki = WIKI-

## alternative return HTTP header for failed authentication. Default HTTP

## response is 401 HTTPUnauthorized. Currently Mercurial clients have trouble with

## handling that. Set this variable to 403 to return HTTPForbidden

auth_ret_code =

## locking return code. When repository is locked return this HTTP code. 2XX

## codes don't break the transactions while 4XX codes do

lock_ret_code = 423

## allows to change the repository location in settings page

allow_repo_location_change = True

## allows to setup custom hooks in settings page

allow_custom_hooks_settings = True

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

###        CELERY CONFIG        ####

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

use_celery = false

broker.host = localhost

broker.vhost = rabbitmqhost

broker.port = 5672

broker.user = rabbitmq

broker.password = qweqwe

celery.imports = kallithea.lib.celerylib.tasks

celery.result.backend = amqp

celery.result.dburi = amqp://

celery.result.serialier = json

#celery.send.task.error.emails = true

#celery.amqp.task.result.expires = 18000

celeryd.concurrency = 2

#celeryd.log.file = celeryd.log

celeryd.log.level = DEBUG

celeryd.max.tasks.per.child = 1

## tasks will never be sent to the queue, but executed locally instead.

celery.always.eager = false

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

###         BEAKER CACHE        ####

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

beaker.cache.data_dir = %(here)s/data/cache/data

beaker.cache.lock_dir = %(here)s/data/cache/lock

beaker.cache.regions = short_term,long_term,sql_cache_short

beaker.cache.short_term.type = memory

beaker.cache.short_term.expire = 60

beaker.cache.short_term.key_length = 256

beaker.cache.long_term.type = memory

beaker.cache.long_term.expire = 36000

beaker.cache.long_term.key_length = 256

beaker.cache.sql_cache_short.type = memory

beaker.cache.sql_cache_short.expire = 10

beaker.cache.sql_cache_short.key_length = 256

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

###       BEAKER SESSION        ####

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

## Name of session cookie. Should be unique for a given host and path, even when running

## on different ports. Otherwise, cookie sessions will be shared and messed up.

beaker.session.key = kallithea

## Sessions should always only be accessible by the browser, not directly by JavaScript.

beaker.session.httponly = true

## Session lifetime. 2592000 seconds is 30 days.

beaker.session.timeout = 2592000

## Server secret used with HMAC to ensure integrity of cookies.

beaker.session.secret = development-not-secret

## Further, encrypt the data with AES.

#beaker.session.encrypt_key = <key_for_encryption>

#beaker.session.validate_key = <validation_key>

## Type of storage used for the session, current types are

## dbm, file, memcached, database, and memory.

## File system storage of session data. (default)

#beaker.session.type = file

## Cookie only, store all session data inside the cookie. Requires secure secrets.

#beaker.session.type = cookie

## Database storage of session data.

#beaker.session.type = ext:database

#beaker.session.sa.url = postgresql://postgres:qwe@localhost/kallithea

#beaker.session.table_name = db_session

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

## ERROR HANDLING SYSTEMS ##

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

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

### [errormator] ###

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

## Errormator is tailored to work with Kallithea, see

## http://errormator.com for details how to obtain an account

## you must install python package `errormator_client` to make it work

## errormator enabled

errormator = false

errormator.server_url = https://api.errormator.com

errormator.api_key = YOUR_API_KEY

## TWEAK AMOUNT OF INFO SENT HERE

## enables 404 error logging (default False)

errormator.report_404 = false

## time in seconds after request is considered being slow (default 1)

errormator.slow_request_time = 1

## record slow requests in application

## (needs to be enabled for slow datastore recording and time tracking)

errormator.slow_requests = true

## enable hooking to application loggers

#errormator.logging = true

## minimum log level for log capture

#errormator.logging.level = WARNING

## send logs only from erroneous/slow requests

## (saves API quota for intensive logging)

errormator.logging_on_error = false

## list of additonal keywords that should be grabbed from environ object

## can be string with comma separated list of words in lowercase

## (by default client will always send following info:

## 'REMOTE_USER', 'REMOTE_ADDR', 'SERVER_NAME', 'CONTENT_TYPE' + all keys that

## start with HTTP* this list be extended with additional keywords here

errormator.environ_keys_whitelist =

## list of keywords that should be blanked from request object

## can be string with comma separated list of words in lowercase

## (by default client will always blank keys that contain following words

## 'password', 'passwd', 'pwd', 'auth_tkt', 'secret', 'csrf'

## this list be extended with additional keywords set here

errormator.request_keys_blacklist =

## list of namespaces that should be ignores when gathering log entries

## can be string with comma separated list of namespaces

## (by default the client ignores own entries: errormator_client.client)

errormator.log_namespace_blacklist =

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

### [sentry] ###

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

## sentry is a alternative open source error aggregator

## you must install python packages `sentry` and `raven` to enable

sentry.dsn = YOUR_DNS

sentry.servers =

sentry.name =

sentry.key =

sentry.public_key =

sentry.secret_key =

sentry.project =

sentry.site =

sentry.include_paths =

sentry.exclude_paths =

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

## WARNING: *THE LINE BELOW MUST BE UNCOMMENTED ON A PRODUCTION ENVIRONMENT*  ##

## Debug mode will enable the interactive debugging tool, allowing ANYONE to  ##

## execute malicious code after an exception is raised.                       ##

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

#set debug = false

set debug = true

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

###       LOGVIEW CONFIG       ###

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

logview.sqlalchemy = #faa

logview.pylons.templating = #bfb

logview.pylons.util = #eee

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

### DB CONFIGS - EACH DB WILL HAVE IT'S OWN CONFIG    ###

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

Sample config for Nginx using proxy:

.. code-block:: nginx

    upstream kallithea {

        server 127.0.0.1:5000;

        # add more instances for load balancing

        #server 127.0.0.1:5001;

        #server 127.0.0.1:5002;

    }

    ## gist alias

    server {

       listen          443;

       server_name     gist.example.com;

       access_log      /var/log/nginx/gist.access.log;

       error_log       /var/log/nginx/gist.error.log;

       ssl on;

       ssl_certificate     gist.your.kallithea.server.crt;

       ssl_certificate_key gist.your.kallithea.server.key;

       ssl_session_timeout 5m;

       ssl_protocols SSLv3 TLSv1;

       ssl_ciphers DHE-RSA-AES256-SHA:DHE-RSA-AES128-SHA:EDH-RSA-DES-CBC3-SHA:AES256-SHA:DES-CBC3-SHA:AES128-SHA:RC4-SHA:RC4-MD5;

       ssl_prefer_server_ciphers on;

       rewrite ^/(.+)$ https://kallithea.example.com/_admin/gists/$1;

       rewrite (.*)    https://kallithea.example.com/_admin/gists;

    }

    server {

       listen          443;

       server_name     kallithea.example.com

       access_log      /var/log/nginx/kallithea.access.log;

       error_log       /var/log/nginx/kallithea.error.log;

       ssl on;

       ssl_certificate     your.kallithea.server.crt;

       ssl_certificate_key your.kallithea.server.key;

       ssl_session_timeout 5m;

       ssl_protocols SSLv3 TLSv1;

       ssl_ciphers DHE-RSA-AES256-SHA:DHE-RSA-AES128-SHA:EDH-RSA-DES-CBC3-SHA:AES256-SHA:DES-CBC3-SHA:AES128-SHA:RC4-SHA:RC4-MD5;

       ssl_prefer_server_ciphers on;

       ## uncomment root directive if you want to serve static files by nginx

       ## requires static_files = false in .ini file

       #root /path/to/installation/kallithea/public;

       include         /etc/nginx/proxy.conf;

       location / {

            try_files $uri @kallithea;

       }

       location @kallithea {

            proxy_pass      http://127.0.0.1:5000;

       }

    }

Here's the proxy.conf. It's tuned so it will not timeout on long

pushes or large pushes::

    proxy_redirect              off;

    proxy_set_header            Host $host;

    ## needed for container auth

    #proxy_set_header            REMOTE_USER $remote_user;

    #proxy_set_header            X-Forwarded-User $remote_user;

    proxy_set_header            X-Url-Scheme $scheme;

    proxy_set_header            X-Host $http_host;

    proxy_set_header            X-Real-IP $remote_addr;

    proxy_set_header            X-Forwarded-For $proxy_add_x_forwarded_for;

    proxy_set_header            Proxy-host $proxy_host;

    proxy_buffering             off;

    proxy_connect_timeout       7200;

    proxy_send_timeout          7200;

    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 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 pylons

            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 as subdirectory

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

Apache subdirectory part:

.. code-block:: apache

    <Location /<someprefix> >

      ProxyPass http://127.0.0.1:5000/<someprefix>

      ProxyPassReverse http://127.0.0.1:5000/<someprefix>

      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 = /<someprefix>

then change ``<someprefix>`` into your chosen prefix

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

- Create a wsgi dispatch script, like the one below. Make sure you

  check that the paths correctly point to where you installed Kallithea

  and its Python Virtual Environment.

- Enable the ``WSGIScriptAlias`` directive for the WSGI dispatch script,

  as in the following example. Once again, check the paths are

  correctly specified.

Here is a sample excerpt from an Apache Virtual Host configuration file:

.. code-block:: apache

    WSGIDaemonProcess kallithea \

        processes=1 threads=4 \

        python-path=/srv/kallithea/pyenv/lib/python2.7/site-packages

    WSGIScriptAlias / /srv/kallithea/dispatch.wsgi

    WSGIPassAuthorization On

Or if using a dispatcher WSGI script with proper virtualenv activation:

.. code-block:: apache

    WSGIDaemonProcess kallithea processes=1 threads=4

    WSGIScriptAlias / /srv/kallithea/dispatch.wsgi

    WSGIPassAuthorization On

.. note::

   When running apache as root, please make sure it doesn't run Kallithea as

   root, for examply by adding: ``user=www-data group=www-data`` to the configuration.

Example WSGI dispatch script:

.. code-block:: python

    import os

    os.environ["HGENCODING"] = "UTF-8"

    os.environ['PYTHON_EGG_CACHE'] = '/srv/kallithea/.egg-cache'

    # sometimes it's needed to set the curent dir

    os.chdir('/srv/kallithea/')

    import site

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

    from paste.deploy import loadapp

    from paste.script.util.logging_config import fileConfig

    fileConfig('/srv/kallithea/my.ini')

    application = loadapp('config:/srv/kallithea/my.ini')

Or using proper virtualenv activation:

.. code-block:: python

    activate_this = '/srv/kallithea/venv/bin/activate_this.py'

    execfile(activate_this, dict(__file__=activate_this))

    import os

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

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

    from paste.script.util.logging_config import fileConfig

    fileConfig(ini)

    from paste.deploy import loadapp

    application = loadapp('config:' + ini)

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

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

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

.. _Mercurial: http://mercurial.selenic.com/

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

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

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

.. _PublishingRepositories: http://mercurial.selenic.com/wiki/PublishingRepositories

.. _performance:

================================

Optimizing Kallithea performance

================================

When serving a large amount of big repositories, Kallithea can start

performing slower than expected. Because of the demanding nature of handling large

amounts of data from version control systems, here are some tips on how to get

the best performance.

* Kallithea is often I/O bound, and hence a fast disk (SSD/SAN) is

  usually more important than a fast CPU.

* Sluggish loading of the front page can easily be fixed by grouping repositories or by

  increasing cache size (see below). This includes using the lightweight dashboard

  option and ``vcs_full_cache`` setting in .ini file.

Follow these few steps to improve performance of Kallithea system.

1. Increase cache

    Tweak beaker cache settings in the ini file. The actual effect of that

    is questionable.

2. Switch from SQLite to PostgreSQL or MySQL

    SQLite is a good option when having a small load on the system. But due to

    locking issues with SQLite, it is not recommended to use it for larger

    deployments. Switching to MySQL or PostgreSQL will result in an immediate

    performance increase. A tool like SQLAlchemyGrate_ can be used for

    migrating to another database platform.

3. Scale Kallithea horizontally

    Scaling horizontally can give huge performance benefits when dealing with

    large amounts of traffic (many users, CI servers, etc.). Kallithea can be

    scaled horizontally on one (recommended) or multiple machines. In order

    to scale horizontally you need to do the following:

    - Each instance's ``data`` storage needs to be configured to be stored on a

      shared disk storage, preferably together with repositories. This ``data``

      dir contains template caches, sessions, whoosh index and is used for

      task locking (so it is safe across multiple instances). Set the

      ``cache_dir``, ``index_dir``, ``beaker.cache.data_dir``, ``beaker.cache.lock_dir``

      variables in each .ini file to a shared location across Kallithea instances

    - If celery is used each instance should run a separate Celery instance, but

      the message broker should be common to all of them (e.g.,  one

      shared RabbitMQ server)

    - Load balance using round robin or IP hash, recommended is writing LB rules

      that will separate regular user traffic from automated processes like CI

      servers or build bots.

.. _SQLAlchemyGrate: https://github.com/shazow/sqlalchemygrate

<%text>## number of process workers. You must set `instance_id = *` when this option</%text>

<%text>## is set to more than one worker</%text>

workers = 1

<%text>## process name</%text>

proc_name = kallithea

<%text>## type of worker class, one of sync, eventlet, gevent, tornado</%text>

<%text>## recommended for bigger setup is using of of other than sync one</%text>

worker_class = sync

max_requests = 1000

<%text>## ammount of time a worker can handle request before it gets killed and</%text>

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

timeout = 3600

%elif http_server == 'uwsgi':

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

<%text>## run with uwsgi --ini-paste-logged <inifile.ini></%text>

[uwsgi]

socket = /tmp/uwsgi.sock

master = true

http = 127.0.0.1:5000

<%text>## set as deamon and redirect all output to file</%text>

#daemonize = ./uwsgi_kallithea.log

<%text>## master process PID</%text>

pidfile = ./uwsgi_kallithea.pid

<%text>## stats server with workers statistics, use uwsgitop</%text>

<%text>## for monitoring, `uwsgitop 127.0.0.1:1717`</%text>

stats = 127.0.0.1:1717

memory-report = true

<%text>## log 5XX errors</%text>

log-5xx = true

<%text>## Set the socket listen queue size.</%text>

listen = 256

<%text>## Gracefully Reload workers after the specified amount of managed requests</%text>

<%text>## (avoid memory leaks).</%text>

max-requests = 1000

<%text>## enable large buffers</%text>

buffer-size = 65535

<%text>## socket and http timeouts ##</%text>

http-timeout = 3600

socket-timeout = 3600

<%text>## Log requests slower than the specified number of milliseconds.</%text>

log-slow = 10

<%text>## Exit if no app can be loaded.</%text>

need-app = true

<%text>## Set lazy mode (load apps in workers instead of master).</%text>

lazy = true

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

<%text>## set cheaper algorithm to use, if not set default will be used</%text>

cheaper-algo = spare

<%text>## minimum number of workers to keep at all times</%text>

cheaper = 1

<%text>## number of workers to spawn at startup</%text>

cheaper-initial = 1

<%text>## maximum number of workers that can be spawned</%text>

workers = 4

<%text>## how many workers should be spawned at a time</%text>

cheaper-step = 1

%endif

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

host = ${host}

port = ${port}

<%text>## middleware for hosting the WSGI application under a URL prefix</%text>

#[filter:proxy-prefix]

#use = egg:PasteDeploy#prefix

#prefix = /<your-prefix>

[app:main]

use = egg:kallithea

<%text>## enable proxy prefix middleware</%text>

#filter-with = proxy-prefix

full_stack = true

static_files = true

<%text>## Available Languages:</%text>

<%text>## cs de fr hu ja nl_BE pl pt_BR ru sk zh_CN zh_TW</%text>

lang =

cache_dir = ${here}/data

index_dir = ${here}/data/index

<%text>## perform a full repository scan on each server start, this should be</%text>

<%text>## set to false after first startup, to allow faster server restarts.</%text>

initial_repo_scan = false

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

archive_cache_dir = ${here}/tarballcache

<%text>## change this to unique ID for security</%text>

app_instance_uuid = ${uuid()}

<%text>## cut off limit for large diffs (size in bytes)</%text>

cut_off_limit = 256000

<%text>## use cache version of scm repo everywhere</%text>

vcs_full_cache = true

<%text>## force https in Kallithea, fixes https redirects, assumes it's always https</%text>

force_https = false

<%text>## use Strict-Transport-Security headers</%text>

use_htsts = false

<%text>## number of commits stats will parse on each iteration</%text>

commit_parse_limit = 25

<%text>## path to git executable</%text>

git_path = git

<%text>## git rev filter option, --all is the default filter, if you need to</%text>

<%text>## hide all refs in changelog switch this to --branches --tags</%text>

#git_rev_filter = --branches --tags

<%text>## RSS feed options</%text>

rss_cut_off_limit = 256000

rss_items_per_page = 10

rss_include_diff = false

<%text>## options for showing and identifying changesets</%text>

show_sha_length = 12

show_revision_number = false

<%text>## gist URL alias, used to create nicer urls for gist. This should be an</%text>

<%text>## url that does rewrites to _admin/gists/<gistid>.</%text>

<%text>## example: http://gist.example.com/{gistid}. Empty means use the internal</%text>

<%text>## Kallithea url, ie. http[s]://kallithea.example.com/_admin/gists/<gistid></%text>

gist_alias_url =

<%text>## white list of API enabled controllers. This allows to add list of</%text>

<%text>## controllers to which access will be enabled by api_key. eg: to enable</%text>

<%text>## api access to raw_files put `FilesController:raw`, to enable access to patches</%text>

<%text>## add `ChangesetController:changeset_patch`. This list should be "," separated</%text>

<%text>## Syntax is <ControllerClass>:<function>. Check debug logs for generated names</%text>

<%text>## Recommended settings below are commented out:</%text>

api_access_controllers_whitelist =

#    ChangesetController:changeset_patch,

#    ChangesetController:changeset_raw,

#    FilesController:raw,

#    FilesController:archivefile

<%text>## default encoding used to convert from and to unicode</%text>

<%text>## can be also a comma seperated list of encoding in case of mixed encodings</%text>

default_encoding = utf8

<%text>## issue tracker for Kallithea (leave blank to disable, absent for default)</%text>

#bugtracker = https://bitbucket.org/conservancy/kallithea/issues