startlist = startlist[:-1]

    # recurse because there may be more escaped separators

    endlist = _escape_split(after, sep)

    # finish building the escaped value. we use endlist[0] because the first

    # part of the string sent in recursion is the rest of the escaped value.

    unfinished += sep + endlist[0]

    return startlist + [unfinished] + endlist[1:]  # put together all the parts

def _run(args):

    if args.config_file is None:

        if not args.show_defaults:

            raise ValueError("Missing argument: config_file")

    else:

        if args.show_defaults:

            raise ValueError("Can't specify both config_file and --show_defaults")

    # defaults that can be overwritten by arguments

    tmpl_stored_args = {

        'http_server': 'waitress',

        'lang': 'en',

        'database_engine': 'sqlite',

        'host': '127.0.0.1',

        'port': 5000,

        'error_aggregation_service': None,

    }

    for custom in args.custom:

        # parse arguments

        kwargs = {}

        for el in _escape_split(custom, ','):

            kv = _escape_split(el, '=')

            if len(kv) == 2:

                k, v = kv

                kwargs[k] = v

        # update our template stored args

        tmpl_stored_args.update(kwargs)

    if args.show_defaults:

        for k,v in tmpl_stored_args.iteritems():

            print '%s=%s' % (k, v)

        sys.exit(0)

    # use default that cannot be replaced

    tmpl_stored_args.update({

        'uuid': lambda: uuid.uuid4().hex,

    })

    try:

        # built in template

        tmpl_file = os.path.join(here, TMPL)

        with open(tmpl_file, 'rb') as f:

            tmpl_data = f.read().decode('utf-8')

            tmpl = Template(tmpl_data).render(**tmpl_stored_args)

        with open(args.config_file, 'wb') as f:

            f.write(tmpl.encode('utf-8'))

        print 'Wrote new config file in %s' % (os.path.abspath(args.config_file))

    except Exception:

        from mako import exceptions

        print exceptions.text_error_template().render()

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

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

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

# Kallithea - config file generated with kallithea-config                      #

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

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

[DEFAULT]

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

<%text>## Email settings                                                             ##</%text>

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

<%text>## Refer to the documentation ("Email settings") for more details.            ##</%text>

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

<%text>## It is recommended to use a valid sender address that passes access         ##</%text>

<%text>## validation and spam filtering in mail servers.                             ##</%text>

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

<%text>## 'From' header for application emails. You can optionally add a name.</%text>

<%text>## Default:</%text>

#app_email_from = Kallithea

<%text>## Examples:</%text>

#app_email_from = Kallithea <kallithea-noreply@example.com>

#app_email_from = kallithea-noreply@example.com

<%text>## Subject prefix for application emails.</%text>

<%text>## A space between this prefix and the real subject is automatically added.</%text>

<%text>## Default:</%text>

#email_prefix =

<%text>## Example:</%text>

#email_prefix = [Kallithea]

<%text>## Recipients for error emails and fallback recipients of application mails.</%text>

<%text>## Multiple addresses can be specified, space-separated.</%text>

<%text>## Only addresses are allowed, do not add any name part.</%text>

<%text>## Default:</%text>

#email_to =

<%text>## Examples:</%text>

#email_to = admin@example.com

#email_to = admin@example.com another_admin@example.com

email_to =

<%text>## 'From' header for error emails. You can optionally add a name.</%text>

<%text>## Default: (none)</%text>

<%text>## Examples:</%text>

#error_email_from = Kallithea Errors <kallithea-noreply@example.com>

#error_email_from = kallithea_errors@example.com

error_email_from =

<%text>## SMTP server settings</%text>

<%text>## If specifying credentials, make sure to use secure connections.</%text>

<%text>## Default: Send unencrypted unauthenticated mails to the specified smtp_server.</%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 =

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

<%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>## 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>## Canonical URL to use when creating full URLs in UI and texts.</%text>

<%text>## Useful when the site is available under different names or protocols.</%text>

<%text>## Defaults to what is provided in the WSGI environment.</%text>

#canonical_url = https://kallithea.example.com/repos

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

lock_ret_code = 423

<%text>## allows to change the repository location in settings page</%text>

allow_repo_location_change = True

<%text>## allows to setup custom hooks in settings page</%text>

allow_custom_hooks_settings = True

<%text>## extra extensions for indexing, space separated and without the leading '.'.</%text>

# index.extensions =

#    gemfile

#    lock

<%text>## extra filenames for indexing, space separated</%text>

# index.filenames =

#    .dockerignore

#    .editorconfig

#    INSTALL

#    CHANGELOG

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

<%text>###        CELERY CONFIG        ####</%text>

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

use_celery = false

<%text>## Example: connect to the virtual host 'rabbitmqhost' on localhost as rabbitmq:</%text>

broker.url = amqp://rabbitmq:qewqew@localhost:5672/rabbitmqhost

celery.imports = kallithea.lib.celerylib.tasks

celery.accept.content = pickle

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.max.tasks.per.child = 1

<%text>## If true, tasks will never be sent to the queue, but executed locally instead.</%text>

celery.always.eager = false

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

<%text>###         BEAKER CACHE        ####</%text>

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

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

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

<%text>###       BEAKER SESSION        ####</%text>

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

<%text>## Name of session cookie. Should be unique for a given host and path, even when running</%text>

<%text>## on different ports. Otherwise, cookie sessions will be shared and messed up.</%text>

beaker.session.key = kallithea

<%text>## Sessions should always only be accessible by the browser, not directly by JavaScript.</%text>

beaker.session.httponly = true

<%text>## Session lifetime. 2592000 seconds is 30 days.</%text>

beaker.session.timeout = 2592000

<%text>## Server secret used with HMAC to ensure integrity of cookies.</%text>

beaker.session.secret = ${uuid()}

<%text>## Further, encrypt the data with AES.</%text>

#beaker.session.encrypt_key = <key_for_encryption>

#beaker.session.validate_key = <validation_key>

<%text>## Type of storage used for the session, current types are</%text>

<%text>## dbm, file, memcached, database, and memory.</%text>

<%text>## File system storage of session data. (default)</%text>

#beaker.session.type = file

<%text>## Cookie only, store all session data inside the cookie. Requires secure secrets.</%text>

#beaker.session.type = cookie

<%text>## Database storage of session data.</%text>

#beaker.session.type = ext:database

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

#beaker.session.table_name = db_session

%if error_aggregation_service == 'appenlight':

appenlight.request_keys_blacklist =

<%text>## list of namespaces that should be ignores when gathering log entries</%text>

<%text>## can be string with comma separated list of namespaces</%text>

<%text>## (by default the client ignores own entries: appenlight_client.client)</%text>

appenlight.log_namespace_blacklist =

%elif error_aggregation_service == 'sentry':

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

<%text>### [sentry] ###</%text>

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

<%text>## sentry is a alternative open source error aggregator</%text>

<%text>## you must install python packages `sentry` and `raven` to enable</%text>

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 =

%endif

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

<%text>## WARNING: *DEBUG MODE MUST BE OFF IN A PRODUCTION ENVIRONMENT*              ##</%text>

<%text>## Debug mode will enable the interactive debugging tool, allowing ANYONE to  ##</%text>

<%text>## execute malicious code after an exception is raised.                       ##</%text>

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

debug = false

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

<%text>###       LOGVIEW CONFIG       ###</%text>

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

logview.sqlalchemy = #faa

logview.pylons.templating = #bfb

logview.pylons.util = #eee

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

<%text>### DB CONFIGS - EACH DB WILL HAVE IT'S OWN CONFIG    ###</%text>

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

%if database_engine == 'sqlite':

# SQLITE [default]

%elif database_engine == 'postgres':

# POSTGRESQL

sqlalchemy.url = postgresql://user:pass@localhost/kallithea

%elif database_engine == 'mysql':

# MySQL

sqlalchemy.url = mysql://user:pass@localhost/kallithea?charset=utf8

%endif

# see sqlalchemy docs for others

sqlalchemy.pool_recycle = 3600

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

<%text>### ALEMBIC CONFIGURATION   ####</%text>

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

[alembic]

script_location = kallithea:alembic

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

<%text>### LOGGING CONFIGURATION   ####</%text>

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

[loggers]

keys = root, routes, kallithea, sqlalchemy, tg, gearbox, beaker, templates, whoosh_indexer

[handlers]

keys = console, console_sql

[formatters]

keys = generic, color_formatter, color_formatter_sql

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

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

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

[logger_root]

level = NOTSET

handlers = console

[logger_routes]

level = DEBUG

handlers =

qualname = routes.middleware

<%text>## "level = DEBUG" logs the route matched and routing variables.</%text>

propagate = 1

#!/usr/bin/env python2

"""

Based on kallithea/lib/paster_commands/template.ini.mako, generate

  development.ini

  kallithea/tests/test.ini

"""

import re

makofile = 'kallithea/lib/paster_commands/template.ini.mako'

# the mako conditionals used in all other ini files and templates

selected_mako_conditionals = set([

    "database_engine == 'sqlite'",

    "http_server == 'waitress'",

    "error_aggregation_service == 'appenlight'",

    "error_aggregation_service == 'sentry'",

])

# the mako variables used in all other ini files and templates

mako_variable_values = {

    'host': '127.0.0.1',

    'port': '5000',

    'uuid()': '${app_instance_uuid}',

}

# files to be generated from the mako template

ini_files = [

    ('kallithea/tests/test.ini',

        '''

        Kallithea - config for tests:

        sqlalchemy and kallithea_test.sqlite

        custom logging

        ''',

        {

            '[server:main]': {

                'port': '4999',

            },

            '[app:main]': {

                'app_instance_uuid': 'test',

                'show_revision_number': 'true',

                'beaker.cache.sql_cache_short.expire': '1',

                'beaker.session.secret': '{74e0cd75-b339-478b-b129-07dd221def1f}',

                'cache_dir': '%(here)s/../../data/test/cache',

                'index_dir': '%(here)s/../../data/test/index',

                'archive_cache_dir': '%(here)s/../../data/test/tarballcache',

                'beaker.cache.data_dir': '%(here)s/../../data/test/cache/data',

                'beaker.cache.lock_dir': '%(here)s/../../data/test/cache/lock',

                'sqlalchemy.url': 'sqlite:///%(here)s/kallithea_test.sqlite',

            },

            '[handler_console]': {

                'level': 'DEBUG',

                'formatter': 'color_formatter',

            },

            # The 'handler_console_sql' block is very similar to the one in

            # development.ini, but without the explicit 'level=DEBUG' setting:

            # it causes duplicate sqlalchemy debug logs, one through

            # handler_console_sql and another through another path.

            '[handler_console_sql]': {

                'formatter': 'color_formatter_sql',

            },

        },

    ),

    ('development.ini',

        '''

        Kallithea - Development config:

        listening on *:5000

        sqlite and kallithea.db

        initial_repo_scan = true

        debug = true

        verbose and colorful logging

        ''',

        {

            '[server:main]': {

                'host': '0.0.0.0',

            },

            '[app:main]': {

                'initial_repo_scan': 'true',

                'debug': 'true',

                'app_instance_uuid': 'development-not-secret',

                'beaker.session.secret': 'development-not-secret',

            },

            '[handler_console]': {

                'level': 'DEBUG',

                'formatter': 'color_formatter',

            },

            '[handler_console_sql]': {

                'level': 'DEBUG',

                'formatter': 'color_formatter_sql',

            },

        },

    ),

]

def main():

    # make sure all mako lines starting with '#' (the '##' comments) are marked up as <text>

    print 'reading:', makofile

    mako_org = file(makofile).read()

    mako_no_text_markup = re.sub(r'</?%text>', '', mako_org)

    mako_marked_up = re.sub(r'\n(##.*)', r'\n<%text>\1</%text>', mako_no_text_markup, flags=re.MULTILINE)

    if mako_marked_up != mako_org:

        print 'writing:', makofile

        file(makofile, 'w').write(mako_marked_up)

    # select the right mako conditionals for the other less sophisticated formats

    def sub_conditionals(m):

        """given a %if...%endif match, replace with just the selected

        conditional sections enabled and the rest as comments

        """

        conditional_lines = m.group(1)

        def sub_conditional(m):

            """given a conditional and the corresponding lines, return them raw

            or commented out, based on whether conditional is selected

            """

            criteria, lines = m.groups()

            if criteria not in selected_mako_conditionals:

                lines = '\n'.join((l if not l or l.startswith('#') else '#' + l) for l in lines.split('\n'))

            return lines