- 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

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

  .. code-block:: python

      import os

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

      # sometimes it's needed to set the current dir

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

      import site

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

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

      from logging.config import fileConfig

      from paste.deploy import loadapp

      application = loadapp('config:' + 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 logging.config import fileConfig

      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

from kallithea.model import db

# The alembic.config.Config object, which wraps the current .ini file.

config = context.config

# Default to use the main Kallithea database string in [app:main].

# For advanced uses, this can be overridden by specifying an explicit

# [alembic] sqlalchemy.url.

database_url = (

    config.get_main_option('sqlalchemy.url') or

    config.get_section_option('app:main', 'sqlalchemy.url')

)

# Configure default logging for Alembic. (This can be overriden by the

# config file, but usually isn't.)

logging.getLogger('alembic').setLevel(logging.INFO)

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

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

# stamping during "kallithea-cli db-create"), config_file_name is not available,

# and loggers are assumed to already have been configured.

if config.config_file_name:

def include_in_autogeneration(object, name, type, reflected, compare_to):

    """Filter changes subject to autogeneration of migrations. """

    # Don't include changes to sqlite_sequence.

    if type == 'table' and name == 'sqlite_sequence':

        return False

    return True

def run_migrations_offline():

    """Run migrations in 'offline' (--sql) mode.

    This produces an SQL script instead of directly applying the changes.

    Some migrations may not run in offline mode.

    """

    context.configure(

        url=database_url,

        literal_binds=True,

    )

    with context.begin_transaction():

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

def cli():

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

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

    """Register a kallithea-cli subcommand.

    If one of the 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 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)

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

                config_bytes = read_config(path_to_ini_file, strip_section_prefix=annotated.__name__)

                if config_file_initialize_app:

                    kallithea.config.middleware.make_app_without_logging(kallithea.CONFIG.global_conf, **kallithea.CONFIG.local_conf)

                    kallithea.lib.utils.setup_cache_regions(kallithea.CONFIG)

                return annotated(*args, **kwargs)

            return cli_command(runtime_wrapper)

        return annotator

    return cli_command

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

import sys

import click

import kallithea

import kallithea.bin.kallithea_cli_base as cli_base

dispath_py_template = '''\

# Created by Kallithea 'kallithea-cli iis-install'

import sys

if hasattr(sys, "isapidllhandle"):

    import win32traceutil

import isapi_wsgi

import os

def __ExtensionFactory__():

    from paste.deploy import loadapp

    from logging.config import fileConfig

    application = loadapp('config:%(inifile)s')

    def app(environ, start_response):

        user = environ.get('REMOTE_USER', None)

        if user is not None:

            os.environ['REMOTE_USER'] = user

        return application(environ, start_response)

    return isapi_wsgi.ISAPIThreadPoolHandler(app)

if __name__=='__main__':

    from isapi.install import *

    params = ISAPIParameters()

    sm = [ScriptMapParams(Extension="*", Flags=0)]

    vd = VirtualDirParameters(Name="%(virtualdir)s",

                              Description = "Kallithea",

                              ScriptMaps = sm,

                              ScriptMapUpdate = "replace")

    params.VirtualDirs = [vd]

    HandleCommandLine(params)

'''

@cli_base.register_command(config_file=True)

@click.option('--virtualdir', default='/',

        help='The virtual folder to install into on IIS.')

def iis_install(virtualdir):

    """Install into IIS using isapi-wsgi."""

    config_file_abs = kallithea.CONFIG['__file__']

    try:

        import isapi_wsgi

    except ImportError:

        sys.stderr.write('missing requirement: isapi-wsgi not installed\n')

        sys.exit(1)

    dispatchfile = os.path.join(os.getcwd(), 'dispatch.py')

    click.echo('Writing %s' % dispatchfile)

    with open(dispatchfile, 'w') as f:

        f.write(dispath_py_template % {

            'inifile': config_file_abs.replace('\\', '\\\\'),

            'virtualdir': virtualdir,

            })

    click.echo('Run \'python "%s" install\' with administrative privileges '

        'to generate the _dispatch.dll file and install it into the '

        'default web site' % dispatchfile)