ProxyPassReverse http://127.0.0.1:5000/PREFIX

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

then change ``PREFIX`` into your chosen prefix

.. _apache_mod_wsgi:

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

- 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

      # sometimes it's needed to set the current dir

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

      import site

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

      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)

  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

      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 \

#!/bin/sh -e

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

#### THIS IS A DEBIAN INIT.D SCRIPT ####

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

### BEGIN INIT INFO

# Provides:          kallithea

# Required-Start:    $all

# Required-Stop:     $all

# Default-Start:     2 3 4 5

# Default-Stop:      0 1 6

# Short-Description: starts instance of kallithea

# Description:       starts instance of kallithea using start-stop-daemon

### END INIT INFO

APP_NAME="kallithea"

APP_HOMEDIR="opt"

APP_PATH="/$APP_HOMEDIR/$APP_NAME"

CONF_NAME="production.ini"

PID_PATH="$APP_PATH/$APP_NAME.pid"

LOG_PATH="$APP_PATH/$APP_NAME.log"

PYTHON_PATH="/$APP_HOMEDIR/$APP_NAME-venv"

RUN_AS="root"

DAEMON="$PYTHON_PATH/bin/gearbox"

DAEMON_OPTS="serve --daemon \

 --user=$RUN_AS \

 --group=$RUN_AS \

 --pid-file=$PID_PATH \

 --log-file=$LOG_PATH -c $APP_PATH/$CONF_NAME"

start() {

  echo "Starting $APP_NAME"

      --start --quiet \

      --pidfile $PID_PATH \

      --user $RUN_AS \

      --exec $DAEMON -- $DAEMON_OPTS

}

stop() {

  echo "Stopping $APP_NAME"

  start-stop-daemon -d $APP_PATH \

      --stop --quiet \

      --pidfile $PID_PATH || echo "$APP_NAME - Not running!"

  if [ -f $PID_PATH ]; then

    rm $PID_PATH

  fi

}

status() {

  echo -n "Checking status of $APP_NAME ... "

  pid=`cat $PID_PATH`

  status=`ps ax | grep $pid | grep -ve grep`

  if [ "$?" -eq 0 ]; then

    echo "running"

  else

    echo "NOT running"

  fi

}

case "$1" in

  status)

   status

    ;;

  start)

    start

    ;;

  stop)

    stop

    ;;

  restart)

    echo "Restarting $APP_NAME"

    ### stop ###

    stop

    wait

    ### start ###

    start

    ;;

  *)

    echo "Usage: $0 {start|stop|restart}"

#!/sbin/runscript

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

#### THIS IS AN GENTOO INIT.D SCRIPT####

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

APP_NAME="kallithea"

APP_HOMEDIR="username/python_workspace"

APP_PATH="/home/$APP_HOMEDIR/$APP_NAME"

CONF_NAME="production.ini"

PID_PATH="$APP_PATH/$APP_NAME.pid"

LOG_PATH="$APP_PATH/$APP_NAME.log"

PYTHON_PATH="/home/$APP_HOMEDIR/v-env"

RUN_AS="username"

DAEMON="$PYTHON_PATH/bin/gearbox"

DAEMON_OPTS="serve --daemon \

--user=$RUN_AS \

--group=$RUN_AS \

--pid-file=$PID_PATH \

--log-file=$LOG_PATH -c $APP_PATH/$CONF_NAME"

#extra options

opts="${opts} restartdelay"

depend() {

    need nginx

}

start() {

    ebegin "Starting $APP_NAME"

        --start --quiet \

        --pidfile $PID_PATH \

        --user $RUN_AS \

        --exec $DAEMON -- $DAEMON_OPTS

    eend $?

}

stop() {

    ebegin "Stopping $APP_NAME"

    start-stop-daemon -d $APP_PATH \

        --stop --quiet \

        --pidfile $PID_PATH || echo "$APP_NAME - Not running!"

    if [ -f $PID_PATH ]; then

        rm $PID_PATH

    fi

    eend $?

}

restartdelay() {

    #stop()

    echo "sleep3"

    sleep 3

    #start()

}

APP_PATH="/var/www/$APP_NAME"

CONF_NAME="production.ini"

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

# that the user you run gearbox as has the appropriate permissions

# same goes for the log file

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

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

# replace this with the path to the virtual environment you

# made for Kallithea

PYTHON_PATH="/opt/python_virtualenvironments/kallithea-venv"

RUN_AS="kallithea"

DAEMON="$PYTHON_PATH/bin/gearbox"

DAEMON_OPTS="serve --daemon \

    --user=$RUN_AS \

    --group=$RUN_AS \

    --pid-file=$PID_PATH \

    --log-file=$LOG_PATH -c $APP_PATH/$CONF_NAME"

DESC="kallithea-server"

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

# source CentOS init functions

. /etc/init.d/functions

RETVAL=0

remove_pid () {

  rm -f ${PID_PATH}

  rmdir `dirname ${PID_PATH}`

}

ensure_pid_dir () {

  PID_DIR=`dirname ${PID_PATH}`

  if [ ! -d ${PID_DIR} ] ; then

    mkdir -p ${PID_DIR}

    chown -R ${RUN_AS}:${RUN_AS} ${PID_DIR}

    chmod 755 ${PID_DIR}

  fi

}

start_kallithea () {

    ensure_pid_dir

        --user $RUN_AS "$DAEMON $DAEMON_OPTS"

    RETVAL=$?

    [ $RETVAL -eq 0 ] && touch $LOCK_FILE

    return $RETVAL

}

stop_kallithea () {

    if [ -e $LOCK_FILE ]; then

      killproc -p $PID_PATH

      RETVAL=$?

      rm -f $LOCK_FILE

      rm -f $PID_PATH

    else

      RETVAL=1

    fi

    return $RETVAL

}

status_kallithea() {

  if [ -e $LOCK_FILE ]; then

    # exit with non-zero to indicate failure

    RETVAL=1

  else

    RETVAL=0

  fi

  return $RETVAL

}

restart_kallithea () {

    stop_kallithea

    start_kallithea

    RETVAL=$?

}

case "$1" in

  start)

    echo -n $"Starting $DESC: "

    start_kallithea

    echo

    ;;

  stop)

    echo -n $"Stopping $DESC: "

    stop_kallithea

    echo

    ;;

  status)

    status_kallithea

    RETVAL=$?