merge default to stable for 0.4.0

.coveragerc

@@ -0,0 +1,33 b''
+[run]
+omit =
+    # the bin scripts are not part of the Kallithea web app
+    kallithea/bin/*
+    # we ship with no active extensions
+    kallithea/config/rcextensions/*
+    # dbmigrate is not a part of the Kallithea web app
+    kallithea/lib/dbmigrate/*
+    # the tests themselves should not be part of the coverage report
+    kallithea/tests/*
+    # the scm hooks are not run in the kallithea process
+    kallithea/config/post_receive_tmpl.py
+    kallithea/config/pre_receive_tmpl.py
+
+# same omit lines should be present in sections 'run' and 'report'
+[report]
+omit =
+    # the bin scripts are not part of the Kallithea web app
+    kallithea/bin/*
+    # we ship with no active extensions
+    kallithea/config/rcextensions/*
+    # dbmigrate is not a part of the Kallithea web app
+    kallithea/lib/dbmigrate/*
+    # the tests themselves should not be part of the coverage report
+    kallithea/tests/*
+    # the scm hooks are not run in the kallithea process
+    kallithea/config/post_receive_tmpl.py
+    kallithea/config/pre_receive_tmpl.py
+
+[paths]
+source =
+    kallithea/
+    **/workspace/*/kallithea

Jenkinsfile

@@ -0,0 +1,212 b''
+def createvirtualenv = ''
+def activatevirtualenv = ''
+
+node {
+    properties([[$class: 'BuildDiscarderProperty',
+                  strategy: [$class: 'LogRotator',
+                              artifactDaysToKeepStr: '',
+                              artifactNumToKeepStr: '10',
+                              daysToKeepStr: '',
+                              numToKeepStr: '']]]);
+    if (isUnix()) {
+        createvirtualenv = 'rm -r $JENKINS_HOME/venv/$JOB_NAME || true && virtualenv $JENKINS_HOME/venv/$JOB_NAME'
+        activatevirtualenv = '. $JENKINS_HOME/venv/$JOB_NAME/bin/activate'
+    } else {
+        createvirtualenv = 'rmdir /s /q %JENKINS_HOME%\\venv\\%JOB_NAME% || true && virtualenv %JENKINS_HOME%\\venv\\%JOB_NAME%'
+        activatevirtualenv = 'call %JENKINS_HOME%\\venv\\%JOB_NAME%\\Scripts\\activate.bat'
+    }
+
+    stage('checkout') {
+        checkout scm
+        if (isUnix()) {
+            sh 'hg --config extensions.purge= purge --all'
+        } else {
+            bat 'hg --config extensions.purge= purge --all'
+        }
+    }
+    stage('virtual env') {
+        def virtualenvscript = """$createvirtualenv
+            $activatevirtualenv
+            python -m pip install --upgrade pip
+            pip install --upgrade setuptools
+            pip install --upgrade pylint
+            pip install --upgrade pytest-cov
+            """
+        if (isUnix()) {
+            virtualenvscript += """
+                pip install --upgrade python-ldap
+                pip install --upgrade python-pam
+                """
+            sh virtualenvscript
+        } else {
+            bat virtualenvscript
+        }
+    }
+    stage('setup') {
+        def virtualenvscript = """$activatevirtualenv
+            pip install --upgrade -e .
+            pip install -r dev_requirements.txt
+            python setup.py compile_catalog
+            """
+        if (isUnix()) {
+            sh virtualenvscript
+        } else {
+            bat virtualenvscript
+        }
+        stash name: 'kallithea', useDefaultExcludes: false
+    }
+    stage('pylint') {
+        sh script: """$activatevirtualenv
+            pylint -j 0 --disable=C -f parseable kallithea > pylint.out
+            """, returnStatus: true
+        archiveArtifacts 'pylint.out'
+        try {
+            step([$class: 'WarningsPublisher', canComputeNew: false, canResolveRelativePaths: false, defaultEncoding: '', excludePattern: '', healthy: '', includePattern: '', messagesPattern: '', parserConfigurations: [[parserName: 'PyLint', pattern: 'pylint.out']], unHealthy: ''])
+        } catch (java.lang.IllegalArgumentException exc) {
+            echo "You need to install the 'Warnings Plug-in' to display the pylint report."
+            currentBuild.result = 'UNSTABLE'
+            echo "Caught: ${exc}"
+        }
+    }
+}
+
+def pytests = [:]
+pytests['sqlite'] = {
+    node {
+        ws {
+            deleteDir()
+            unstash name: 'kallithea'
+            if (isUnix()) {
+                sh script: """$activatevirtualenv
+                    py.test -p no:sugar --cov-config .coveragerc --junit-xml=pytest_sqlite.xml --cov=kallithea
+                    """, returnStatus: true
+            } else {
+                bat script: """$activatevirtualenv
+                    py.test -p no:sugar --cov-config .coveragerc --junit-xml=pytest_sqlite.xml --cov=kallithea
+                    """, returnStatus: true
+            }
+            sh 'sed --in-place "s/\\(classname=[\'\\"]\\)/\\1SQLITE./g" pytest_sqlite.xml'
+            archiveArtifacts 'pytest_sqlite.xml'
+            junit 'pytest_sqlite.xml'
+            writeFile(file: '.coverage.sqlite', text: readFile('.coverage'))
+            stash name: 'coverage.sqlite', includes: '.coverage.sqlite'
+        }
+    }
+}
+
+pytests['de'] = {
+    node {
+        if (isUnix()) {
+            ws {
+                deleteDir()
+                unstash name: 'kallithea'
+                withEnv(['LANG=de_DE.UTF-8',
+                    'LANGUAGE=de',
+                    'LC_ADDRESS=de_DE.UTF-8',
+                    'LC_IDENTIFICATION=de_DE.UTF-8',
+                    'LC_MEASUREMENT=de_DE.UTF-8',
+                    'LC_MONETARY=de_DE.UTF-8',
+                    'LC_NAME=de_DE.UTF-8',
+                    'LC_NUMERIC=de_DE.UTF-8',
+                    'LC_PAPER=de_DE.UTF-8',
+                    'LC_TELEPHONE=de_DE.UTF-8',
+                    'LC_TIME=de_DE.UTF-8',
+                ]) {
+                    sh script: """$activatevirtualenv
+                        py.test -p no:sugar --cov-config .coveragerc --junit-xml=pytest_de.xml --cov=kallithea
+                        """, returnStatus: true
+                }
+                sh 'sed --in-place "s/\\(classname=[\'\\"]\\)/\\1DE./g" pytest_de.xml'
+                archiveArtifacts 'pytest_de.xml'
+                junit 'pytest_de.xml'
+                writeFile(file: '.coverage.de', text: readFile('.coverage'))
+                stash name: 'coverage.de', includes: '.coverage.de'
+            }
+        }
+    }
+}
+pytests['mysql'] = {
+    node {
+        if (isUnix()) {
+            ws {
+                deleteDir()
+                unstash name: 'kallithea'
+                sh """$activatevirtualenv
+                    pip install --upgrade MySQL-python
+                    """
+                withEnv(['TEST_DB=mysql://kallithea:kallithea@jenkins_mysql/kallithea_test?charset=utf8']) {
+                    if (isUnix()) {
+                        sh script: """$activatevirtualenv
+                            py.test -p no:sugar --cov-config .coveragerc --junit-xml=pytest_mysql.xml --cov=kallithea
+                            """, returnStatus: true
+                    } else {
+                        bat script: """$activatevirtualenv
+                            py.test -p no:sugar --cov-config .coveragerc --junit-xml=pytest_mysql.xml --cov=kallithea
+                            """, returnStatus: true
+                    }
+                }
+                sh 'sed --in-place "s/\\(classname=[\'\\"]\\)/\\1MYSQL./g" pytest_mysql.xml'
+                archiveArtifacts 'pytest_mysql.xml'
+                junit 'pytest_mysql.xml'
+                writeFile(file: '.coverage.mysql', text: readFile('.coverage'))
+                stash name: 'coverage.mysql', includes: '.coverage.mysql'
+            }
+        }
+    }
+}
+pytests['postgresql'] = {
+    node {
+        if (isUnix()) {
+            ws {
+                deleteDir()
+                unstash name: 'kallithea'
+                sh """$activatevirtualenv
+                    pip install --upgrade psycopg2
+                    """
+                withEnv(['TEST_DB=postgresql://kallithea:kallithea@jenkins_postgresql/kallithea_test']) {
+                    if (isUnix()) {
+                        sh script: """$activatevirtualenv
+                            py.test -p no:sugar --cov-config .coveragerc --junit-xml=pytest_postgresql.xml --cov=kallithea
+                            """, returnStatus: true
+                    } else {
+                        bat script: """$activatevirtualenv
+                            py.test -p no:sugar --cov-config .coveragerc --junit-xml=pytest_postgresql.xml --cov=kallithea
+                            """, returnStatus: true
+                    }
+                }
+                sh 'sed --in-place "s/\\(classname=[\'\\"]\\)/\\1POSTGRES./g" pytest_postgresql.xml'
+                archiveArtifacts 'pytest_postgresql.xml'
+                junit 'pytest_postgresql.xml'
+                writeFile(file: '.coverage.postgresql', text: readFile('.coverage'))
+                stash name: 'coverage.postgresql', includes: '.coverage.postgresql'
+            }
+        }
+    }
+}
+stage('Tests') {
+    parallel pytests
+    node {
+        unstash 'coverage.sqlite'
+        unstash 'coverage.de'
+        unstash 'coverage.mysql'
+        unstash 'coverage.postgresql'
+        if (isUnix()) {
+            sh script: """$activatevirtualenv
+                coverage combine .coverage.sqlite .coverage.de .coverage.mysql .coverage.postgresql
+                coverage xml
+                """, returnStatus: true
+        } else {
+            bat script: """$activatevirtualenv
+                coverage combine .coverage.sqlite .coverage.de .coverage.mysql .coverage.postgresql
+                coverage xml
+                """, returnStatus: true
+        }
+        try {
+            step([$class: 'CoberturaPublisher', autoUpdateHealth: false, autoUpdateStability: false, coberturaReportFile: 'coverage.xml', failNoReports: false, failUnhealthy: false, failUnstable: false, maxNumberOfBuilds: 0, onlyStable: false, zoomCoverageChart: false])
+        } catch (java.lang.IllegalArgumentException exc) {
+            echo "You need to install the pipeline compatible 'CoberturaPublisher Plug-in' to display the coverage report."
+            currentBuild.result = 'UNSTABLE'
+            echo "Caught: ${exc}"
+        }
+    }
+}

dev_requirements.txt

@@ -0,0 +1,8 b''
+pytest >= 3.3.0, < 3.8
+pytest-runner < 4.3
+pytest-sugar >= 0.7.0, < 0.10
+pytest-benchmark < 3.2
+pytest-localserver < 0.5
+mock < 2.1
+Sphinx < 1.8
+WebTest < 2.1

docs/dev/dbmigrations.rst

@@ -0,0 +1,74 b''
+=======================
+Database schema changes
+=======================
+
+Kallithea uses Alembic for :ref:`database migrations <upgrade_db>`
+(upgrades and downgrades).
+
+If you are developing a Kallithea feature that requires database schema
+changes, you should make a matching Alembic database migration script:
+
+1. :ref:`Create a Kallithea configuration and database <setup>` for testing
+   the migration script, or use existing ``development.ini`` setup.
+
+   Ensure that this database is up to date with the latest database
+   schema *before* the changes you're currently developing. (Do not
+   create the database while your new schema changes are applied.)
+
+2. Create a separate throwaway configuration for iterating on the actual
+   database changes::
+
+    kallithea-cli config-create temp.ini
+
+   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
+   clobbering any existing database file.
+
+3. Make your code changes (including database schema changes in ``db.py``).
+
+4. After every database schema change, recreate the throwaway database
+   to test the changes::
+
+    rm temp.db
+    kallithea-cli db-create -c temp.ini --repos=/var/repos --user=doe --email [e-mail] --password=123456 --no-public-access --force-yes
+    kallithea-cli repo-scan -c temp.ini
+
+5. Once satisfied with the schema changes, auto-generate a draft Alembic
+   script using the development database that has *not* been upgraded.
+   (The generated script will upgrade the database to match the code.)
+
+   ::
+
+    alembic -c development.ini revision -m "area: add cool feature" --autogenerate
+
+6. Edit the script to clean it up and fix any problems.
+
+   Note that for changes that simply add columns, it may be appropriate
+   to not remove them in the downgrade script (and instead do nothing),
+   to avoid the loss of data. Unknown columns will simply be ignored by
+   Kallithea versions predating your changes.
+
+7. Run ``alembic -c development.ini upgrade head`` to apply changes to
+   the (non-throwaway) database, and test the upgrade script. Also test
+   downgrades.
+
+   The included ``development.ini`` has full SQL logging enabled. If
+   you're using another configuration file, you may want to enable it
+   by setting ``level = DEBUG`` in section ``[handler_console_sql]``.
+
+The Alembic migration script should be committed in the same revision as
+the database schema (``db.py``) changes.
+
+See the `Alembic documentation`__ for more information, in particular
+the tutorial and the section about auto-generating migration scripts.
+
+.. __: http://alembic.zzzcomputing.com/en/latest/
+
+
+Troubleshooting
+---------------
+
+* If ``alembic --autogenerate`` responds "Target database is not up to
+  date", you need to either first use Alembic to upgrade the database
+  to the most recent version (before your changes), or recreate the
+  database from scratch (without your schema changes applied).

docs/dev/translation.rst

@@ -0,0 +1,2 b''
+.. _translations:
+.. include:: ./../../kallithea/i18n/how_to

docs/upgrade.rst

@@ -0,0 +1,246 b''
+.. _upgrade:
+
+===================
+Upgrading Kallithea
+===================
+
+This describes the process for upgrading Kallithea, independently of the
+Kallithea installation method.
+
+.. note::
+    If you are upgrading from a RhodeCode installation, you must first
+    install Kallithea 0.3.2 and follow the instructions in the 0.3.2
+    README to perform a one-time conversion of the database from
+    RhodeCode to Kallithea, before upgrading to the latest version
+    of Kallithea.
+
+
+1. Stop the Kallithea web application
+-------------------------------------
+
+This step depends entirely on the web server software used to serve
+Kallithea, but in any case, Kallithea should not be running during
+the upgrade.
+
+.. note::
+    If you're using Celery, make sure you stop all instances during the
+    upgrade.
+
+
+2. Create a backup of both database and configuration
+-----------------------------------------------------
+
+You are of course strongly recommended to make backups regularly, but it
+is *especially* important to make a full database and configuration
+backup before performing a Kallithea upgrade.
+
+Back up your configuration
+^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+Make a copy of your Kallithea configuration (``.ini``) file.
+
+If you are using :ref:`rcextensions <customization>`, you should also
+make a copy of the entire ``rcextensions`` directory.
+
+Back up your database
+^^^^^^^^^^^^^^^^^^^^^
+
+If using SQLite, simply make a copy of the Kallithea database (``.db``)
+file.
+
+If using PostgreSQL, please consult the documentation for the ``pg_dump``
+utility.
+
+If using MySQL, please consult the documentation for the ``mysqldump``
+utility.
+
+Look for ``sqlalchemy.url`` in your configuration file to determine
+database type, settings, location, etc. If you were running Kallithea 0.3.x or
+older, this was ``sqlalchemy.db1.url``.
+
+
+3. Activate or recreate the Kallithea virtual environment (if any)
+------------------------------------------------------------------
+
+.. note::
+    If you did not install Kallithea in a virtual environment, skip this step.
+
+For major upgrades, e.g. from 0.3.x to 0.4.x, it is recommended to create a new
+virtual environment, rather than reusing the old. For minor upgrades, e.g.
+within the 0.4.x range, this is not really necessary (but equally fine).
+
+To create a new virtual environment, please refer to the appropriate
+installation page for details. After creating and activating the new virtual
+environment, proceed with the rest of the upgrade process starting from the next
+section.
+
+To reuse the same virtual environment, first activate it, then verify that you
+are using the correct environment by running::
+
+    pip freeze
+
+This will list all packages installed in the current environment. If
+Kallithea isn't listed, deactivate the environment and then activate the correct
+one, or recreate a new environment. See the appropriate installation page for
+details.
+
+
+4. Install new version of Kallithea
+-----------------------------------
+
+Please refer to the instructions for the installation method you
+originally used to install Kallithea.
+
+If you originally installed using pip, it is as simple as::
+
+    pip install --upgrade kallithea
+
+If you originally installed from version control, assuming you did not make
+private changes (in which case you should adapt the instructions accordingly)::
+
+    cd my-kallithea-clone
+    hg parent   # make a note of the original revision
+    hg pull
+    hg update
+    hg parent   # make a note of the new revision
+    pip install --upgrade -e .
+
+.. _upgrade_config:
+
+
+5. Upgrade your configuration
+-----------------------------
+
+Run the following command to create a new configuration (``.ini``) file::
+
+    kallithea-cli config-create new.ini
+
+Then compare it with your old config file and copy over the required
+configuration values from the old to the new file.
+
+.. note::
+    Please always make sure your ``.ini`` files are up to date. Errors
+    can often be caused by missing parameters added in new versions.
+
+.. _upgrade_db:
+
+
+6. Upgrade your database
+------------------------
+
+.. note::
+    If you are *downgrading* Kallithea, you should perform the database
+    migration step *before* installing the older version. (That is,
+    always perform migrations using the most recent of the two versions
+    you're migrating between.)
+
+First, run the following command to see your current database version::
+
+    alembic -c new.ini current
+
+Typical output will be something like "9358dc3d6828 (head)", which is
+the current Alembic database "revision ID". Write down the entire output
+for troubleshooting purposes.
+
+The output will be empty if you're upgrading from Kallithea 0.3.x or
+older. That's expected. If you get an error that the config file was not
+found or has no ``[alembic]`` section, see the next section.
+
+Next, if you are performing an *upgrade*: Run the following command to
+upgrade your database to the current Kallithea version::
+
+    alembic -c new.ini upgrade head
+
+If you are performing a *downgrade*: Run the following command to
+downgrade your database to the given version::
+
+    alembic -c new.ini downgrade 0.4
+
+Alembic will show the necessary migrations (if any) as it executes them.
+If no "ERROR" is displayed, the command was successful.
+
+Should an error occur, the database may be "stranded" half-way
+through the migration, and you should restore it from backup.
+
+Enabling old Kallithea config files for Alembic use
+^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+Kallithea configuration files created before the introduction of Alembic
+(i.e. predating Kallithea 0.4) need to be updated for use with Alembic.
+Without this, Alembic will fail with an error like this::
+
+    FAILED: No config file 'my.ini' found, or file has no '[alembic]' section
+
+.. note::
+    If you followed this upgrade guide correctly, you will have created a
+    new configuration file in section :ref:`Upgrading your configuration
+    <upgrade_config>`. When calling Alembic, make
+    sure to use this new config file. In this case, you should not get any
+    errors and the below manual steps should not be needed.
+
+If Alembic complains specifically about a missing ``alembic.ini``, it is
+likely because you did not specify a config file using the ``-c`` option.
+On the other hand, if the mentioned config file actually exists, you
+need to append the following lines to it::
+
+    [alembic]
+    script_location = kallithea:alembic
+
+Your config file should now work with Alembic.
+
+
+7. Prepare the front-end
+------------------------
+
+Starting with Kallithea 0.4, external front-end dependencies are no longer
+shipped but need to be downloaded and/or generated at installation time. Run the
+following command::
+
+    kallithea-cli front-end-build
+
+
+8. Rebuild the Whoosh full-text index
+-------------------------------------
+
+It is recommended that you rebuild the Whoosh index after upgrading since
+new Whoosh versions can introduce incompatible index changes.
+
+
+9. Start the Kallithea web application
+--------------------------------------
+
+This step once again depends entirely on the web server software used to
+serve Kallithea.
+
+If you were running Kallithea 0.3.x or older and were using ``paster serve
+my.ini`` before, then the corresponding command in Kallithea 0.4 and later is::
+
+    gearbox serve -c new.ini
+
+Before starting the new version of Kallithea, you may find it helpful to
+clear out your log file so that new errors are readily apparent.
+
+.. note::
+    If you're using Celery, make sure you restart all instances of it after
+    upgrade.
+
+
+10. Update Git repository hooks
+-------------------------------
+
+It is possible that an upgrade involves changes to the Git hooks installed by
+Kallithea. As these hooks are created inside the repositories on the server
+filesystem, they are not updated automatically when upgrading Kallithea itself.
+
+To update the hooks of your Git repositories:
+
+* Go to *Admin > Settings > Remap and Rescan*
+* Select the checkbox *Install Git hooks*
+* Click the button *Rescan repositories*
+
+.. note::
+    Kallithea does not use hooks on Mercurial repositories. This step is thus
+    not necessary if you only have Mercurial repositories.
+
+
+.. _virtualenv: http://pypi.python.org/pypi/virtualenv

docs/usage/customization.rst

@@ -0,0 +1,70 b''
+.. _customization:
+
+=============
+Customization
+=============
+
+There are several ways to customize Kallithea to your needs depending on what
+you want to achieve.
+
+
+HTML/JavaScript/CSS customization
+---------------------------------
+
+To customize the look-and-feel of the web interface (for example to add a
+company banner or some JavaScript widget or to tweak the CSS style definitions)
+you can enter HTML code (possibly with JavaScript and/or CSS) directly via the
+*Admin > Settings > Global > HTML/JavaScript customization
+block*.
+
+
+Style sheet customization with Less
+-----------------------------------
+
+Kallithea uses `Bootstrap 3`_ and Less_ for its style definitions. If you want
+to make some customizations, we recommend to do so by creating a ``theme.less``
+file. When you create a file named ``theme.less`` in the Kallithea root
+directory, you can use this file to override the default style. For example,
+you can use this to override ``@kallithea-theme-main-color``,
+``@kallithea-logo-url`` or other `Bootstrap variables`_.
+
+After creating the ``theme.less`` file, you need to regenerate the CSS files, by
+running::
+
+    kallithea-cli front-end-build --no-install-deps
+
+.. _bootstrap 3: https://getbootstrap.com/docs/3.3/
+.. _bootstrap variables: https://getbootstrap.com/docs/3.3/customize/#less-variables
+.. _less: http://lesscss.org/
+
+
+Behavioral customization: rcextensions
+--------------------------------------
+
+Some behavioral customization can be done in Python using ``rcextensions``, a
+custom Python package that can extend Kallithea functionality.
+
+With ``rcextensions`` it's possible to add additional mappings for Whoosh
+indexing and statistics, to add additional code into the push/pull/create/delete
+repository hooks (for example to send signals to build bots such as Jenkins) and
+even to monkey-patch certain parts of the Kallithea source code (for example
+overwrite an entire function, change a global variable, ...).
+
+To generate a skeleton extensions package, run::
+
+    kallithea-cli extensions-create -c my.ini
+
+This will create an ``rcextensions`` package next to the specified ``ini`` file.
+See the ``__init__.py`` file inside the generated ``rcextensions`` package
+for more details.
+
+
+Behavioral customization: code changes
+--------------------------------------
+
+As Kallithea is open-source software, you can make any changes you like directly
+in the source code.
+
+We encourage you to send generic improvements back to the
+community so that Kallithea can become better. See :ref:`contributing` for more
+details.

kallithea/alembic/env.py

@@ -0,0 +1,105 b''
+# -*- coding: utf-8 -*-
+# This program is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+# Alembic migration environment (configuration).
+
+import logging
+from logging.config import fileConfig
+
+from alembic import context
+from sqlalchemy import engine_from_config, pool
+
+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:
+    fileConfig(config.config_file_name, disable_existing_loggers=False)
+
+
+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():
+        context.run_migrations()
+
+
+def run_migrations_online():
+    """Run migrations in 'online' mode.
+
+    Connects to the database and directly applies the necessary
+    migrations.
+    """
+    cfg = config.get_section(config.config_ini_section)
+    cfg['sqlalchemy.url'] = database_url
+    connectable = engine_from_config(
+        cfg,
+        prefix='sqlalchemy.',
+        poolclass=pool.NullPool)
+
+    with connectable.connect() as connection:
+        context.configure(
+            connection=connection,
+
+            # Support autogeneration of migration scripts based on "diff" between
+            # current database schema and kallithea.model.db schema.
+            target_metadata=db.Base.metadata,
+            include_object=include_in_autogeneration,
+            render_as_batch=True, # batch mode is needed for SQLite support
+        )
+
+        with context.begin_transaction():
+            context.run_migrations()
+
+
+if context.is_offline_mode():
+    run_migrations_offline()
+else:
+    run_migrations_online()

kallithea/alembic/script.py.mako

@@ -0,0 +1,40 b''
+# -*- coding: utf-8 -*-
+# This program is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+## Template for creating new Alembic migration scripts.
+"""${message}
+
+Revision ID: ${up_revision}
+Revises: ${down_revision | comma,n}
+Create Date: ${create_date}
+
+"""
+
+# The following opaque hexadecimal identifiers ("revisions") are used
+# by Alembic to track this migration script and its relations to others.
+revision = ${repr(up_revision)}
+down_revision = ${repr(down_revision)}
+branch_labels = ${repr(branch_labels)}
+depends_on = ${repr(depends_on)}
+
+from alembic import op
+import sqlalchemy as sa
+${imports if imports else ""}
+
+def upgrade():
+    ${upgrades if upgrades else "pass"}
+
+
+def downgrade():
+    ${downgrades if downgrades else "pass"}

kallithea/alembic/versions/9358dc3d6828_drop_sqlalchemy_migrate_support.py

@@ -0,0 +1,37 b''
+# This program is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+"""Drop SQLAlchemy Migrate support
+
+Revision ID: 9358dc3d6828
+Revises:
+Create Date: 2016-03-01 15:21:30.896585
+
+"""
+
+# The following opaque hexadecimal identifiers ("revisions") are used
+# by Alembic to track this migration script and its relations to others.
+revision = '9358dc3d6828'
+down_revision = None
+branch_labels = None
+depends_on = None
+
+from alembic import op
+
+
+def upgrade():
+    op.drop_table('db_migrate_version')
+
+
+def downgrade():
+    raise NotImplementedError('cannot revert to SQLAlchemy Migrate')

kallithea/alembic/versions/a020f7044fd6_rename_hooks.py

@@ -0,0 +1,61 b''
+# This program is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+"""rename hooks
+
+Revision ID: a020f7044fd6
+Revises: 9358dc3d6828
+Create Date: 2017-11-24 13:35:14.374000
+
+"""
+
+# The following opaque hexadecimal identifiers ("revisions") are used
+# by Alembic to track this migration script and its relations to others.
+revision = 'a020f7044fd6'
+down_revision = '9358dc3d6828'
+branch_labels = None
+depends_on = None
+
+from alembic import op
+from kallithea.model.db import Ui
+from sqlalchemy import Table, MetaData
+
+meta = MetaData()
+
+
+def upgrade():
+    meta.bind = op.get_bind()
+    ui = Table(Ui.__tablename__, meta, autoload=True)
+
+    ui.update(values={
+        'ui_key': 'prechangegroup.push_lock_handling',
+        'ui_value': 'python:kallithea.lib.hooks.push_lock_handling',
+    }).where(ui.c.ui_key == 'prechangegroup.pre_push').execute()
+    ui.update(values={
+        'ui_key': 'preoutgoing.pull_lock_handling',
+        'ui_value': 'python:kallithea.lib.hooks.pull_lock_handling',
+    }).where(ui.c.ui_key == 'preoutgoing.pre_pull').execute()
+
+
+def downgrade():
+    meta.bind = op.get_bind()
+    ui = Table(Ui.__tablename__, meta, autoload=True)
+
+    ui.update(values={
+        'ui_key': 'prechangegroup.pre_push',
+        'ui_value': 'python:kallithea.lib.hooks.pre_push',
+    }).where(ui.c.ui_key == 'prechangegroup.push_lock_handling').execute()
+    ui.update(values={
+        'ui_key': 'preoutgoing.pre_pull',
+        'ui_value': 'python:kallithea.lib.hooks.pre_pull',
+    }).where(ui.c.ui_key == 'preoutgoing.pull_lock_handling').execute()

kallithea/bin/kallithea_cli.py

@@ -0,0 +1,27 b''
+# -*- coding: utf-8 -*-
+# This program is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+# 'cli' is the main entry point for 'kallithea-cli', specified in setup.py as entry_points console_scripts
+from kallithea.bin.kallithea_cli_base import cli
+
+# import commands (they will add themselves to the 'cli' object)
+import kallithea.bin.kallithea_cli_celery
+import kallithea.bin.kallithea_cli_config
+import kallithea.bin.kallithea_cli_db
+import kallithea.bin.kallithea_cli_extensions
+import kallithea.bin.kallithea_cli_front_end
+import kallithea.bin.kallithea_cli_iis
+import kallithea.bin.kallithea_cli_index
+import kallithea.bin.kallithea_cli_ishell
+import kallithea.bin.kallithea_cli_repo

kallithea/bin/kallithea_cli_base.py

@@ -0,0 +1,55 b''
+# -*- coding: utf-8 -*-
+# This program is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# 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 click
+import functools
+import os
+
+import kallithea
+import logging.config
+import paste.deploy
+
+
+# This placeholder is the main entry point for the kallithea-cli command
[e-mail]()
+def cli():
+    """Various commands to manage a Kallithea instance."""
+
+def register_command(config_file=False, config_file_initialize_app=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()
+    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)
+                logging.config.fileConfig(path_to_ini_file)
+                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

kallithea/bin/kallithea_cli_front_end.py

@@ -0,0 +1,108 b''
+# -*- coding: utf-8 -*-
+# This program is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# 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 click
+import kallithea.bin.kallithea_cli_base as cli_base
+
+import os
+import shutil
+import subprocess
+import json
+
+import kallithea
+
+@cli_base.register_command()
[e-mail]('--install-deps/--no-install-deps', default=True,
+        help='Skip installation of dependencies, via "npm".')
[e-mail]('--generate/--no-generate', default=True,
+        help='Skip generation of front-end files.')
+def front_end_build(install_deps, generate):
+    """Build the front-end.
+
+    Install required dependencies for the front-end and generate the necessary
+    files.  This step is complementary to any 'pip install' step which only
+    covers Python dependencies.
+
+    The installation of front-end dependencies happens via the tool 'npm' which
+    is expected to be installed already.
+    """
+    front_end_dir = os.path.abspath(os.path.join(kallithea.__file__, '..', 'front-end'))
+    public_dir = os.path.abspath(os.path.join(kallithea.__file__, '..', 'public'))
+
+    if install_deps:
+        click.echo("Running 'npm install' to install front-end dependencies from package.json")
+        subprocess.check_call(['npm', 'install'], cwd=front_end_dir, shell=kallithea.is_windows)
+
+    if generate:
+        tmp_dir = os.path.join(front_end_dir, 'tmp')
+        if not os.path.isdir(tmp_dir):
+            os.mkdir(tmp_dir)
+
+        click.echo("Building CSS styling based on Bootstrap")
+        with open(os.path.join(tmp_dir, 'pygments.css'), 'w') as f:
+            subprocess.check_call(['pygmentize',
+                    '-S', 'default',
+                    '-f', 'html',
+                    '-a', '.code-highlight'],
+                    stdout=f)
+        lesscpath = os.path.join(front_end_dir, 'node_modules', '.bin', 'lessc')
+        lesspath = os.path.join(front_end_dir, 'main.less')
+        csspath = os.path.join(public_dir, 'css', 'style.css')
+        subprocess.check_call([lesscpath, '--source-map',
+                '--source-map-less-inline', lesspath, csspath],
+                cwd=front_end_dir, shell=kallithea.is_windows)
+
+        click.echo("Preparing Bootstrap JS")
+        shutil.copy(os.path.join(front_end_dir, 'node_modules', 'bootstrap', 'dist', 'js', 'bootstrap.js'), os.path.join(public_dir, 'js', 'bootstrap.js'))
+
+        click.echo("Preparing jQuery JS with Flot, Caret and Atwho")
+        shutil.copy(os.path.join(front_end_dir, 'node_modules', 'jquery', 'dist', 'jquery.min.js'), os.path.join(public_dir, 'js', 'jquery.min.js'))
+        shutil.copy(os.path.join(front_end_dir, 'node_modules', 'jquery.flot', 'jquery.flot.js'), os.path.join(public_dir, 'js', 'jquery.flot.js'))
+        shutil.copy(os.path.join(front_end_dir, 'node_modules', 'jquery.flot', 'jquery.flot.selection.js'), os.path.join(public_dir, 'js', 'jquery.flot.selection.js'))
+        shutil.copy(os.path.join(front_end_dir, 'node_modules', 'jquery.flot', 'jquery.flot.time.js'), os.path.join(public_dir, 'js', 'jquery.flot.time.js'))
+        shutil.copy(os.path.join(front_end_dir, 'node_modules', 'jquery.caret', 'dist', 'jquery.caret.min.js'), os.path.join(public_dir, 'js', 'jquery.caret.min.js'))
+        shutil.copy(os.path.join(front_end_dir, 'node_modules', 'at.js', 'dist', 'js', 'jquery.atwho.min.js'), os.path.join(public_dir, 'js', 'jquery.atwho.min.js'))
+
+        click.echo("Preparing DataTables JS")
+        shutil.copy(os.path.join(front_end_dir, 'node_modules', 'datatables.net', 'js', 'jquery.dataTables.js'), os.path.join(public_dir, 'js', 'jquery.dataTables.js'))
+        shutil.copy(os.path.join(front_end_dir, 'node_modules', 'datatables.net-bs', 'js', 'dataTables.bootstrap.js'), os.path.join(public_dir, 'js', 'dataTables.bootstrap.js'))
+
+        click.echo("Preparing Select2 JS")
+        shutil.copy(os.path.join(front_end_dir, 'node_modules', 'select2', 'select2.js'), os.path.join(public_dir, 'js', 'select2.js'))
+        shutil.copy(os.path.join(front_end_dir, 'node_modules', 'select2', 'select2.png'), os.path.join(public_dir, 'css', 'select2.png'))
+        shutil.copy(os.path.join(front_end_dir, 'node_modules', 'select2', 'select2x2.png'), os.path.join(public_dir, 'css', 'select2x2.png'))
+        shutil.copy(os.path.join(front_end_dir, 'node_modules', 'select2', 'select2-spinner.gif'), os.path.join(public_dir, 'css', 'select2-spinner.gif'))
+
+        click.echo("Preparing CodeMirror JS")
+        if os.path.isdir(os.path.join(public_dir, 'codemirror')):
+            shutil.rmtree(os.path.join(public_dir, 'codemirror'))
+        shutil.copytree(os.path.join(front_end_dir, 'node_modules', 'codemirror'), os.path.join(public_dir, 'codemirror'))
+
+        click.echo("Generating LICENSES.txt")
+        license_checker_path = os.path.join(front_end_dir, 'node_modules', '.bin', 'license-checker')
+        check_licensing_json_path = os.path.join(tmp_dir, 'licensing.json')
+        licensing_txt_path = os.path.join(public_dir, 'LICENSES.txt')
+        subprocess.check_call([license_checker_path, '--json', '--out', check_licensing_json_path],
+                cwd=front_end_dir, shell=kallithea.is_windows)
+        with open(check_licensing_json_path) as jsonfile:
+            rows = json.loads(jsonfile.read())
+            with open(licensing_txt_path, 'w') as out:
+                out.write("The Kallithea front-end was built using the following Node modules:\n\n")
+                for name_version, values in sorted(rows.items()):
+                    name, version = name_version.rsplit('@', 1)
+                    line = "%s from https://www.npmjs.com/package/%s/v/%s\n  License: %s\n  Repository: %s\n" % (
+                        name_version, name, version, values['licenses'], values.get('repository', '-'))
+                    if values.get('copyright'):
+                        line += "  Copyright: %s\n" % (values['copyright'])
+                    out.write(line + '\n')

kallithea/bin/kallithea_cli_repo.py

@@ -0,0 +1,185 b''
+# -*- coding: utf-8 -*-
+# This program is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program.  If not, see <http://www.gnu.org/licenses/>.
+"""
+This file was forked by the Kallithea project in July 2014 and later moved.
+Original author and date, and relevant copyright and licensing information is below:
+:created_on: Feb 9, 2013
+:author: marcink
+:copyright: (c) 2013 RhodeCode GmbH, and others.
+:license: GPLv3, see LICENSE.md for more details.
+"""
+import click
+import kallithea.bin.kallithea_cli_base as cli_base
+
+import datetime
+import os
+import re
+import shutil
+
+from kallithea.lib.utils import repo2db_mapper, REMOVED_REPO_PAT
+from kallithea.lib.utils2 import safe_unicode, safe_str, ask_ok
+from kallithea.model.db import Repository, Ui
+from kallithea.model.meta import Session
+from kallithea.model.scm import ScmModel
+
+@cli_base.register_command(config_file_initialize_app=True)
[e-mail]('--remove-missing', is_flag=True,
+        help='Remove missing repositories from the Kallithea database.')
+def repo_scan(remove_missing):
+    """Scan filesystem for repositories.
+
+    Search the configured repository root for new repositories and add them
+    into Kallithea.
+    Additionally, report repositories that were previously known to Kallithea
+    but are no longer present on the filesystem. If option --remove-missing is
+    given, remove the missing repositories from the Kallithea database.
+    """
+    click.echo('Now scanning root location for new repos ...')
+    added, removed = repo2db_mapper(ScmModel().repo_scan(),
+                                    remove_obsolete=remove_missing)
+    click.echo('Scan completed.')
+    if added:
+        click.echo('Added: %s' % ', '.join(added))
+    if removed:
+        click.echo('%s: %s' % ('Removed' if remove_missing else 'Missing',
+                          ', '.join(removed)))
+
+@cli_base.register_command(config_file_initialize_app=True)
[e-mail]('repositories', nargs=-1)
+def repo_update_metadata(repositories):
+    """
+    Update repository metadata in database from repository content.
+
+    In normal operation, Kallithea will keep caches up-to-date
+    automatically. However, if repositories are externally modified, e.g. by
+    a direct push via the filesystem rather than via a Kallithea URL,
+    Kallithea is not aware of it. In this case, you should manually run this
+    command to update the repository cache.
+
+    If no repositories are specified, the caches of all repositories are
+    updated.
+    """
+    if not repositories:
+        repo_list = Repository.query().all()
+    else:
+        repo_names = [safe_unicode(n.strip()) for n in repositories]
+        repo_list = list(Repository.query()
+                        .filter(Repository.repo_name.in_(repo_names)))
+
+    for repo in repo_list:
+        # update latest revision metadata in database
+        repo.update_changeset_cache()
+        # invalidate in-memory VCS object cache... will be repopulated on
+        # first access
+        repo.set_invalidate()
+
+    Session().commit()
+
+    click.echo('Updated database with information about latest change in the following %s repositories:' % (len(repo_list)))
+    click.echo('\n'.join(repo.repo_name for repo in repo_list))
+
+@cli_base.register_command(config_file_initialize_app=True)
[e-mail]('--ask/--no-ask', default=True, help='Ask for confirmation or not. Default is --ask.')
[e-mail]('--older-than',
+        help="""Only purge repositories that have been removed at least the given time ago.
+        For example, '--older-than=30d' purges repositories deleted 30 days ago or longer.
+        Possible suffixes: d (days), h (hours), m (minutes), s (seconds).""")
+def repo_purge_deleted(ask, older_than):
+    """Purge backups of deleted repositories.
+
+    When a repository is deleted via the Kallithea web interface, the actual
+    data is still present on the filesystem but set aside using a special name.
+    This command allows to delete these files permanently.
+    """
+    def _parse_older_than(val):
+        regex = re.compile(r'((?P<days>\d+?)d)?((?P<hours>\d+?)h)?((?P<minutes>\d+?)m)?((?P<seconds>\d+?)s)?')
+        parts = regex.match(val)
+        if not parts:
+            return
+        parts = parts.groupdict()
+        time_params = {}
+        for (name, param) in parts.iteritems():
+            if param:
+                time_params[name] = int(param)
+        return datetime.timedelta(**time_params)
+
+    def _extract_date(name):
+        """
+        Extract the date part from rm__<date> pattern of removed repos,
+        and convert it to datetime object
+
+        :param name:
+        """
+        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)):
+        alldirs = list(dirs)
+        del dirs[:]
+        if ('.hg' in alldirs or
+            '.git' in alldirs or
+            '.svn' in alldirs or
+            'objects' in alldirs and ('refs' in alldirs or 'packed-refs' in f)):
+            continue
+        for loc in alldirs:
+            if REMOVED_REPO_PAT.match(loc):
+                to_remove.append([os.path.join(dn_, loc),
+                                  _extract_date(loc)])
+            else:
+                dirs.append(loc)
+        if dirs:
+            click.echo('Scanning: %s' % dn_)
+
+    if not to_remove:
+        click.echo('There are no deleted repositories.')
+        return
+
+    # filter older than (if present)!
+    if older_than:
+        now = datetime.datetime.now()
+        to_remove_filtered = []
+        older_than_date = _parse_older_than(older_than)
+        for name, date_ in to_remove:
+            repo_age = now - date_
+            if repo_age > older_than_date:
+                to_remove_filtered.append([name, date_])
+
+        to_remove = to_remove_filtered
+
+        if not to_remove:
+            click.echo('There are no deleted repositories older than %s (%s)'
+                    % (older_than, older_than_date))
+            return
+
+        click.echo('Considering %s deleted repositories older than %s (%s).'
+            % (len(to_remove), older_than, older_than_date))
+    else:
+        click.echo('Considering %s deleted repositories.' % len(to_remove))
+
+    if not ask:
+        remove = True
+    else:
+        remove = ask_ok('The following repositories will be removed completely:\n%s\n'
+                'Do you want to proceed? [y/n] '
+                % '\n'.join(['%s deleted on %s' % (safe_str(x[0]), safe_str(x[1]))
+                                     for x in to_remove]))
+
+    if remove:
+        for path, date_ in to_remove:
+            click.echo('Purging repository %s' % path)
+            shutil.rmtree(path)
+    else:
+        click.echo('Nothing done, exiting...')

kallithea/config/app_cfg.py

@@ -0,0 +1,214 b''
+# -*- coding: utf-8 -*-
+# This program is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program.  If not, see <http://www.gnu.org/licenses/>.
+"""
+Global configuration file for TurboGears2 specific settings in Kallithea.
+
+This file complements the .ini file.
+"""
+
+import platform
+import os, sys, logging
+
+import tg
+from tg import hooks
+from tg.configuration import AppConfig
+from tg.support.converters import asbool
+import alembic.config
+from alembic.script.base import ScriptDirectory
+from alembic.migration import MigrationContext
+from sqlalchemy import create_engine
+import mercurial
+
+from kallithea.lib.middleware.https_fixup import HttpsFixup
+from kallithea.lib.middleware.simplegit import SimpleGit
+from kallithea.lib.middleware.simplehg import SimpleHg
+from kallithea.lib.auth import set_available_permissions
+from kallithea.lib.utils import load_rcextensions, make_ui, set_app_settings, set_vcs_config, \
+    set_indexer_config, check_git_version, repo2db_mapper
+from kallithea.lib.utils2 import str2bool
+import kallithea.model.base
+from kallithea.model.scm import ScmModel
+
+import formencode
+
+log = logging.getLogger(__name__)
+
+
+class KallitheaAppConfig(AppConfig):
+    # Note: AppConfig has a misleading name, as it's not the application
+    # configuration, but the application configurator. The AppConfig values are
+    # used as a template to create the actual configuration, which might
+    # overwrite or extend the one provided by the configurator template.
+
+    # To make it clear, AppConfig creates the config and sets into it the same
+    # values that AppConfig itself has. Then the values from the config file and
+    # gearbox options are loaded and merged into the configuration. Then an
+    # after_init_config(conf) method of AppConfig is called for any change that
+    # might depend on options provided by configuration files.
+
+    def __init__(self):
+        super(KallitheaAppConfig, self).__init__()
+
+        self['package'] = kallithea
+
+        self['prefer_toscawidgets2'] = False
+        self['use_toscawidgets'] = False
+
+        self['renderers'] = []
+
+        # Enable json in expose
+        self['renderers'].append('json')
+
+        # Configure template rendering
+        self['renderers'].append('mako')
+        self['default_renderer'] = 'mako'
+        self['use_dotted_templatenames'] = False
+
+        # Configure Sessions, store data as JSON to avoid pickle security issues
+        self['session.enabled'] = True
+        self['session.data_serializer'] = 'json'
+
+        # Configure the base SQLALchemy Setup
+        self['use_sqlalchemy'] = True
+        self['model'] = kallithea.model.base
+        self['DBSession'] = kallithea.model.meta.Session
+
+        # Configure App without an authentication backend.
+        self['auth_backend'] = None
+
+        # Use custom error page for these errors. By default, Turbogears2 does not add
+        # 400 in this list.
+        # Explicitly listing all is considered more robust than appending to defaults,
+        # in light of possible future framework changes.
+        self['errorpage.status_codes'] = [400, 401, 403, 404]
+
+        # Disable transaction manager -- currently Kallithea takes care of transactions itself
+        self['tm.enabled'] = False
+
+
+base_config = KallitheaAppConfig()
+
+# TODO still needed as long as we use pylonslib
+sys.modules['pylons'] = tg
+
+# DebugBar, a debug toolbar for TurboGears2.
+# (https://github.com/TurboGears/tgext.debugbar)
+# To enable it, install 'tgext.debugbar' and 'kajiki', and run Kallithea with
+# 'debug = true' (not in production!)
+# See the Kallithea documentation for more information.
+try:
+    from tgext.debugbar import enable_debugbar
+    import kajiki # only to check its existence
+except ImportError:
+    pass
+else:
+    base_config['renderers'].append('kajiki')
+    enable_debugbar(base_config)
+
+
+def setup_configuration(app):
+    config = app.config
+
+    # Verify that things work when Dulwich passes unicode paths to the file system layer.
+    # Note: UTF-8 is preferred, but for example ISO-8859-1 or mbcs should also work under the right cirumstances.
+    try:
+        u'\xe9'.encode(sys.getfilesystemencoding()) # Test using é (&eacute;)
+    except UnicodeEncodeError:
+        log.error("Cannot encode Unicode paths to file system encoding %r", sys.getfilesystemencoding())
+        for var in ['LC_CTYPE', 'LC_ALL', 'LANG']:
+            if var in os.environ:
+                val = os.environ[var]
+                log.error("Note: Environment variable %s is %r - perhaps change it to some other value from 'locale -a', like 'C.UTF-8' or 'en_US.UTF-8'", var, val)
+                break
+        else:
+            log.error("Note: No locale setting found in environment variables - perhaps set LC_CTYPE to some value from 'locale -a', like 'C.UTF-8' or 'en_US.UTF-8'")
+        log.error("Terminating ...")
+        sys.exit(1)
+
+    # Mercurial sets encoding at module import time, so we have to monkey patch it
+    hgencoding = config.get('hgencoding')
+    if hgencoding:
+        mercurial.encoding.encoding = hgencoding
+
+    if config.get('ignore_alembic_revision', False):
+        log.warn('database alembic revision checking is disabled')
+    else:
+        dbconf = config['sqlalchemy.url']
+        alembic_cfg = alembic.config.Config()
+        alembic_cfg.set_main_option('script_location', 'kallithea:alembic')
+        alembic_cfg.set_main_option('sqlalchemy.url', dbconf)
+        script_dir = ScriptDirectory.from_config(alembic_cfg)
+        available_heads = sorted(script_dir.get_heads())
+
+        engine = create_engine(dbconf)
+        with engine.connect() as conn:
+            context = MigrationContext.configure(conn)
+            current_heads = sorted(str(s) for s in context.get_current_heads())
+        if current_heads != available_heads:
+            log.error('Failed to run Kallithea:\n\n'
+                      'The database version does not match the Kallithea version.\n'
+                      'Please read the documentation on how to upgrade or downgrade the database.\n'
+                      'Current database version id(s): %s\n'
+                      'Expected database version id(s): %s\n'
+                      'If you are a developer and you know what you are doing, you can add `ignore_alembic_revision = True` '
+                      'to your .ini file to skip the check.\n' % (' '.join(current_heads), ' '.join(available_heads)))
+            sys.exit(1)
+
+    # store some globals into kallithea
+    kallithea.CELERY_ON = str2bool(config['app_conf'].get('use_celery'))
+    kallithea.CELERY_EAGER = str2bool(config['app_conf'].get('celery.always.eager'))
+    kallithea.CONFIG = config
+
+    load_rcextensions(root_path=config['here'])
+
+    set_available_permissions(config)
+    repos_path = make_ui('db').configitems('paths')[0][1]
+    config['base_path'] = repos_path
+    set_app_settings(config)
+
+    instance_id = kallithea.CONFIG.get('instance_id', '*')
+    if instance_id == '*':
+        instance_id = '%s-%s' % (platform.uname()[1], os.getpid())
+        kallithea.CONFIG['instance_id'] = instance_id
+
+    # update kallithea.CONFIG with the meanwhile changed 'config'
+    kallithea.CONFIG.update(config)
+
+    # configure vcs and indexer libraries (they are supposed to be independent
+    # as much as possible and thus avoid importing tg.config or
+    # kallithea.CONFIG).
+    set_vcs_config(kallithea.CONFIG)
+    set_indexer_config(kallithea.CONFIG)
+
+    check_git_version()
+
+
+hooks.register('configure_new_app', setup_configuration)
+
+
+def setup_application(app):
+    config = app.config
+
+    # we want our low level middleware to get to the request ASAP. We don't
+    # need any stack middleware in them - especially no StatusCodeRedirect buffering
+    app = SimpleHg(app, config)
+    app = SimpleGit(app, config)
+
+    # Enable https redirects based on HTTP_X_URL_SCHEME set by proxy
+    if any(asbool(config.get(x)) for x in ['https_fixup', 'force_https', 'use_htsts']):
+        app = HttpsFixup(app, config)
+    return app
+
+
+hooks.register('before_config', setup_application)

.hgignore

@@ -16,12 +16,31 b' syntax: regexp'
 ^docs/build/
 ^docs/_build/
 ^data$
-^kallithea/tests/data$
 ^sql_dumps/
 ^\.settings$
 ^\.project$
 ^\.pydevproject$
 ^\.coverage$
+^kallithea/front-end/node_modules$
+^kallithea/front-end/package-lock\.json$
+^kallithea/front-end/tmp$
+^kallithea/public/codemirror$
+^kallithea/public/css/select2-spinner\.gif$
+^kallithea/public/css/select2\.png$
+^kallithea/public/css/select2x2\.png$
+^kallithea/public/css/style\.css$
+^kallithea/public/css/style\.css\.map$
+^kallithea/public/js/bootstrap\.js$
+^kallithea/public/js/dataTables\.bootstrap\.js$
+^kallithea/public/js/jquery\.atwho\.min\.js$
+^kallithea/public/js/jquery\.caret\.min\.js$
+^kallithea/public/js/jquery\.dataTables\.js$
+^kallithea/public/js/jquery\.flot\.js$
+^kallithea/public/js/jquery\.flot\.selection\.js$
+^kallithea/public/js/jquery\.flot\.time\.js$
+^kallithea/public/js/jquery\.min\.js$
+^kallithea/public/js/select2\.js$
+^theme\.less$
 ^kallithea\.db$
 ^test\.db$
 ^Kallithea\.egg-info$
@@ -29,3 +48,5 b' syntax: regexp'
 ^fabfile.py
 ^\.idea$
 ^\.cache$
+^\.pytest_cache$
+/__pycache__$

.hgtags

@@ -69,3 +69,5 b' cf635c823ea059cc3a1581b82d8672e46b682384'
 4cca4cc6a0a97f4c4763317184cd41aca4297630 0.3.5
 082c9b8f0f17bd34740eb90c69bdc4c80d4b5b31 0.3.6
 a18445b85d407294da0b7f1d8be3bedef5ffdea6 0.3.7
+8db761c407685e7b08b800c947890035b0d67025 0.4.0rc1
+60f726162fd6c515bd819feb423be73cad01d7d3 0.4.0rc2

CONTRIBUTORS

@@ -1,28 +1,51 b''
 List of contributors to Kallithea project:
 
+    Andrej Shadura <[e-mail]> 2012 2014-2017 2019
     Thomas De Schampheleire <[e-mail]> 2014-2019
+    Étienne Gilli <[e-mail]> 2015-2017 2019
     Mads Kiilerich <[e-mail]> 2016-2019
+    Allan Nordhøy <[e-mail]> 2017-2019
+    Danni Randeris <[e-mail]> 2019
+    Edmund Wong <[e-mail]> 2019
+    Manuel Jacob <[e-mail]> 2019
+    Dominik Ruf <[e-mail]> 2012 2014-2018
     Michal Čihař <[e-mail]> 2014-2015 2018
     Branko Majic <[e-mail]> 2015 2018
+    Chris Rule <[e-mail]> 2018
+    Jesús Sánchez <[e-mail]> 2018
+    Patrick Vane <[e-mail]> 2018
+    Pheng Heong Tan <[e-mail]> 2018
     ssantos <[e-mail]> 2018
     Максим Якимчук <[e-mail]> 2018
     Марс Ямбар <[e-mail]> 2018
     Mads Kiilerich <[e-mail]> 2012-2017
     Unity Technologies 2012-2017
-    Andrew Shadura <[e-mail]> 2012 2014-2017
-    Dominik Ruf <[e-mail]> 2012 2014 2016-2017
-    Étienne Gilli <[e-mail]> 2015 2017
+    Søren Løvborg <[e-mail]> 2015-2017
     Sam Jaques <[e-mail]> 2015 2017
-    Allan Nordhøy <[e-mail]> 2017
+    Asterios Dimitriou <[e-mail]> 2016-2017
+    Alessandro Molina <[e-mail]> 2017
+    Anton Schur <[e-mail]> 2017
     Ching-Chen Mao <[e-mail]> 2017
+    Eivind Tagseth <[e-mail]> 2017
     FUJIWARA Katsunori <[e-mail]> 2017
+    Holger Schramm <[e-mail]> 2017
+    Karl Goetz <[e-mail]> 2017
+    Lars Kruse <[e-mail]> 2017
+    Marko Semet <[e-mail]> 2017
     Viktar Vauchkevich <[e-mail]> 2017
     Takumi IINO <[e-mail]> 2012-2016
-    Søren Løvborg <[e-mail]> 2015-2016
+    Jan Heylen <[e-mail]> 2015-2016
+    Robert Martinez <[e-mail]> 2015-2016
+    Robert Rauch <[e-mail]> 2015-2016
+    Angel Ezquerra <[e-mail]> 2016
     Anton Shestakov <[e-mail]> 2016
     Brandon Jones <[e-mail]> 2016
+    Kateryna Musina <[e-mail]> 2016
     Konstantin Veretennicov <[e-mail]> 2016
+    Oscar Curero <[e-mail]> 2016
     Robert James Dennington <[e-mail]> 2016
+    [e-mail] 2016
+    YFdyh000 <[e-mail]> 2016
     Aras Pranckevičius <[e-mail]> 2012-2013 2015
     Sean Farley <[e-mail]> 2013-2015
     Christian Oyarzun <[e-mail]> 2014-2015
@@ -37,7 +60,7 b' List of contributors to Kallithea projec'
     duanhongyi <[e-mail]> 2015
     EriCSN Chang <[e-mail]> 2015
     Grzegorz Krason <[e-mail]> 2015
-    Jan Heylen <[e-mail]> 2015
+    Jiří Suchan <[e-mail]> 2015
     Kazunari Kobayashi <[e-mail]> 2015
     Kevin Bullock <[e-mail]> 2015
     kobanari <[e-mail]> 2015
@@ -50,11 +73,10 b' List of contributors to Kallithea projec'
     Nick High <[e-mail]> 2015
     Niemand Jedermann <[e-mail]> 2015
     Peter Vitt <[e-mail]> 2015
-    Robert Martinez <[e-mail]> 2015
-    Robert Rauch <[e-mail]> 2015
     Ronny Pfannschmidt <[e-mail]> 2015
     Tuux <[e-mail]> 2015
     Viktar Palstsiuk <[e-mail]> 2015
+    Ante Ilic <[e-mail]> 2014
     Bradley M. Kuhn <[e-mail]> 2014
     Calinou <[e-mail]> 2014
     Daniel Anderson <[e-mail]> 2014

LICENSE.md

@@ -22,27 +22,39 b' Various third-party code under GPLv3-com'
 of Kallithea.
 
 
+Alembic
+-------
+
+Kallithea incorporates an [Alembic](http://alembic.zzzcomputing.com/en/latest/)
+"migration environment" in `kallithea/alembic`, portions of which is:
+
+Copyright © 2009-2016 by Michael Bayer.
+Alembic is a trademark of Michael Bayer.
+
+and licensed under the MIT-permissive license, which is
+[included in this distribution](MIT-Permissive-License.txt).
+
 
 Bootstrap
 ---------
 
-Kallithea incorporates parts of the Javascript system called
+Kallithea uses the web framework called
 [Bootstrap](http://getbootstrap.com/), which is:
 
-Copyright © 2012 Twitter, Inc.
+Copyright © 2011-2016 Twitter, Inc.
 
-and licensed under
-[the Apache License 2.0](http://www.apache.org/licenses/LICENSE-2.0.html).
+and licensed under the MIT-permissive license, which is
+[included in this distribution](MIT-Permissive-License.txt).
 
-A copy of the Apache License 2.0 is also included in this distribution in its
-entirety in the file Apache-License-2.0.txt
+It is not distributed with Kallithea, but will be downloaded
+using the ''kallithea-cli front-end-build'' command.
 
 
 
 Codemirror
 ----------
 
-Kallithea incorporates parts of the Javascript system called
+Kallithea uses the Javascript system called
 [Codemirror](http://codemirror.net/), version 4.7.0, which is primarily:
 
 Copyright &copy; 2013-2014 by Marijn Haverbeke <[e-mail]>
@@ -51,40 +63,70 b' and licensed under the MIT-permissive li'
 [included in this distribution](MIT-Permissive-License.txt).
 
 Additional files from upstream Codemirror are copyrighted by various authors
-and licensed under other permissive licenses.  The sub-directories under
-[.../public/codemirror](kallithea/public/codemirror) include the copyright and
-license notice and information as they appeared in Codemirror's upstream
-release.
+and licensed under other permissive licenses.
+
+It is not distributed with Kallithea, but will be downloaded
+using the ''kallithea-cli front-end-build'' command.
 
 
 
 jQuery
 ------
 
-Kallithea incorporates the Javascript system called
-[jQuery](http://jquery.org/),
-[herein](kallithea/public/js/jquery-1.11.1.min.js), and the Corresponding
-Source can be found in https://github.com/jquery/jquery at tag 1.11.1
-(mirrored at https://kallithea-scm.org/repos/mirror/jquery/files/1.11.1/ ).
+Kallithea uses the Javascript system called
+[jQuery](http://jquery.org/).
 
 It is Copyright 2013 jQuery Foundation and other contributors http://jquery.com/ and is under an
 [MIT-permissive license](MIT-Permissive-License.txt).
 
+It is not distributed with Kallithea, but will be downloaded
+using the ''kallithea-cli front-end-build'' command.
+
+
+
+At.js
+-----
+
+Kallithea uses the Javascript system called
+[At.js](http://ichord.github.com/At.js),
+which can be found together with its Corresponding Source in
+https://github.com/ichord/At.js at tag v1.5.4.
+
+It is Copyright 2013 [e-mail] and is under an
+[MIT-permissive license](MIT-Permissive-License.txt).
+
+It is not distributed with Kallithea, but will be downloaded
+using the ''kallithea-cli front-end-build'' command.
+
 
 
-Mousetrap
----------
+Caret.js
+--------
 
-Kallithea incorporates parts of the Javascript system called
-[Mousetrap](http://craig.is/killing/mice/), which is:
+Kallithea uses the Javascript system called
+[Caret.js](http://ichord.github.com/Caret.js/),
+which can be found together with its Corresponding Source in
+https://github.com/ichord/Caret.js at tag v0.3.1.
+
+It is Copyright 2013 [e-mail] and is under an
+[MIT-permissive license](MIT-Permissive-License.txt).
+
+It is not distributed with Kallithea, but will be downloaded
+using the ''kallithea-cli front-end-build'' command.
 
-   Copyright 2013 Craig Campbell
+
+
+DataTables
+----------
 
-and licensed under
-[the Apache License 2.0](http://www.apache.org/licenses/LICENSE-2.0.html).
+Kallithea uses the Javascript system called
+[DataTables](http://www.datatables.net/).
 
-A [copy of the Apache License 2.0](Apache-License-2.0.txt) is also included
-in this distribution.
+It is Copyright 2008-2015 SpryMedia Ltd. and is under an
+[MIT-permissive license](MIT-Permissive-License.txt).
+
+It is not distributed with Kallithea, but will be downloaded
+using the ''kallithea-cli front-end-build'' command.
 
 
 
@@ -103,7 +145,7 b' tri-license.'
 Select2
 -------
 
-Kallithea incorporates parts of the Javascript system called
+Kallithea uses the Javascript system called
 [Select2](http://ivaynberg.github.io/select2/), which is:
 
 Copyright 2012 Igor Vaynberg (and probably others)
@@ -122,12 +164,15 b' in this distribution.'
 Kallithea will take the Apache license fork of the dual license, since
 Kallithea is GPLv3'd.
 
+It is not distributed with Kallithea, but will be downloaded
+using the ''kallithea-cli front-end-build'' command.
+
 
 
 Select2-Bootstrap-CSS
 ---------------------
 
-Kallithea incorporates some CSS from a system called
+Kallithea uses some CSS from a system called
 [Select2-bootstrap-css](https://github.com/t0m/select2-bootstrap-css), which
 is:
 
@@ -136,122 +181,43 b' Copyright &copy; 2013 Tom Terrace (and l'
 and licensed under the MIT-permissive license, which is
 [included in this distribution](MIT-Permissive-License.txt).
 
-
-
-History.js
-----------
-
-Kallithea incorporates some CSS from a system called History.js, which is
-
-Copyright 2010-2011 Benjamin Arthur Lupton <[e-mail]>
-
-Redistribution and use in source and binary forms, with or without
-modification, are permitted provided that the following conditions are met:
-
-1. Redistributions of source code must retain the above copyright notice,
-   this list of conditions and the following disclaimer.
-
-2. Redistributions in binary form must reproduce the above copyright notice,
-   this list of conditions and the following disclaimer in the documentation
-   and/or other materials provided with the distribution.
-
-THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
-AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
-IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
-ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
-LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
-CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
-SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
-INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
-CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
-ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
-POSSIBILITY OF SUCH DAMAGE.
-
-
-
-YUI
----
-
-Kallithea incorporates parts of the Javascript system called
-[YUI 2 — Yahoo! User Interface Library](http://yui.github.io/yui2/docs/yui_2.9.0_full/),
-which is made available under the [BSD License](http://yuilibrary.com/license/):
-
-Copyright &copy; 2013 Yahoo! Inc. All rights reserved.
-
-Redistribution and use of this software in source and binary forms, with or
-without modification, are permitted provided that the following conditions are
-met:
-
-* Redistributions of source code must retain the above copyright notice, this
-  list of conditions and the following disclaimer.
-
-* Redistributions in binary form must reproduce the above copyright notice,
-  this list of conditions and the following disclaimer in the documentation
-  and/or other materials provided with the distribution.
-
-* Neither the name of Yahoo! Inc. nor the names of YUI's contributors may be
-  used to endorse or promote products derived from this software without
-  specific prior written permission of Yahoo! Inc.
-
-THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
-ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
-WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
-DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR
-ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
-(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
-LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
-ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
-SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-
-Kallithea includes a minified version of YUI 2.9. To build yui.2.9.js:
-
-    git clone https://github.com/yui/builder
-    git clone https://github.com/yui/yui2
-    cd yui2/
-    git checkout hudson-yui2-2800
-    ln -sf JumpToPageDropDown.js src/paginator/js/JumpToPageDropdown.js # work around inconsistent casing
-    rm -f tmp.js
-    for m in yahoo event dom connection animation dragdrop element datasource autocomplete container event-delegate json datatable paginator; do
-      rm -f build/\$m/\$m.js
-      ( cd src/\$m && ant build deploybuild ) && sed -e 's,@VERSION@,2.9.0,g' -e 's,@BUILD@,2800,g' build/\$m/\$m.js >> tmp.js
-    done
-    java -jar ../builder/componentbuild/lib/yuicompressor/yuicompressor-2.4.4.jar tmp.js -o yui.2.9.js
-
-In compliance with GPLv3 the Corresponding Source for this Object Code is made
-available on
-[https://kallithea-scm.org/repos/mirror](https://kallithea-scm.org/repos/mirror).
+It is not distributed with Kallithea, but will be downloaded
+using the ''kallithea-cli front-end-build'' command.
 
 
 
 Flot
 ----
 
-Kallithea incorporates some CSS from a system called
-[Flot](http://code.google.com/p/flot/), which is:
+Kallithea uses some parts of a Javascript system called
+[Flot](http://www.flotcharts.org/), which is:
 
-Copyright 2006 Google Inc.
+Copyright (c) 2007-2014 IOLA and Ole Laursen
 
-Licensed under the Apache License, Version 2.0 (the "License");
-you may not use this file except in compliance with the License.
-
-A [copy of the Apache License 2.0](Apache-License-2.0.txt) is also included
-in this distribution.
-
+Permission is hereby granted, free of charge, to any person
+obtaining a copy of this software and associated documentation
+files (the "Software"), to deal in the Software without
+restriction, including without limitation the rights to use,
+copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the
+Software is furnished to do so, subject to the following
+conditions:
 
-
-Migrate
--------
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
 
-Kallithea incorporates in kallithea/lib/dbmigrate/migrate parts of the Python
-system called [Migrate or sqlalchemy-migrate](https://github.com/stackforge/sqlalchemy-migrate),
-which is:
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+OTHER DEALINGS IN THE SOFTWARE.
 
-Copyright (c) 2009 Evan Rosson, Jan Dittberner, Domen Kožar
+It is not distributed with Kallithea, but will be downloaded
+using the ''kallithea-cli front-end-build'' command.
 
-and licensed under the MIT-permissive license, which is
-[included in this distribution](MIT-Permissive-License.txt).
 
 
 Icon fonts
@@ -261,7 +227,7 b' Kallithea incorporates subsets of both'
 [Font Awesome](http://fontawesome.io) and
 [GitHub Octicons](https://octicons.github.com) for icons. Font Awesome is:
 
-Copyright (c) 2012, Dave Gandy
+Copyright (c) 2016, Dave Gandy
 
 Octicons is:
 

MANIFEST.in

@@ -1,21 +1,29 b''
+include           .coveragerc
 include           Apache-License-2.0.txt
 include           CONTRIBUTORS
 include           COPYING
+include           Jenkinsfile
 include           LICENSE-MERGELY.html
 include           LICENSE.md
 include           MIT-Permissive-License.txt
 include           README.rst
+include           dev_requirements.txt
 include           development.ini
+include           pytest.ini
+include           requirements.txt
+include           tox.ini
 recursive-include docs *
 recursive-include init.d *
+recursive-include kallithea/alembic *
 include           kallithea/bin/ldap_sync.conf
-include           kallithea/bin/template.ini.mako
-include           kallithea/config/deployment.ini_tmpl
+include           kallithea/lib/paster_commands/template.ini.mako
+recursive-include kallithea/front-end *
 recursive-include kallithea/i18n *
-recursive-include kallithea/lib/dbmigrate *.py_tmpl README migrate.cfg
 recursive-include kallithea/public *
 recursive-include kallithea/templates *
 recursive-include kallithea/tests/fixtures *
 recursive-include kallithea/tests/scripts *
-include           kallithea/tests/test.ini
+include           kallithea/tests/models/test_dump_html_mails.ref.html
+include           kallithea/tests/performance/test_vcs.py
 include           kallithea/tests/vcs/aconfig
+recursive-include scripts *

README.rst

@@ -162,76 +162,14 b' You can also build the documentation loc'
           install it via the command: ``pip install sphinx`` .
 
 
-Converting from RhodeCode
--------------------------
-
-Currently, you have two options for working with an existing RhodeCode
-database:
-
-- keep the database unconverted (intended for testing and evaluation)
-- convert the database in a one-time step
-
-Maintaining interoperability
-~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-
-Interoperability with RhodeCode 2.2.X installations is provided so you don't
-have to immediately commit to switching to Kallithea. This option will most
-likely go away once the two projects have diverged significantly.
-
-To run Kallithea on a RhodeCode database, run::
-
-   echo "BRAND = 'rhodecode'" > kallithea/brand.py
-
-This location will depend on where you installed Kallithea. If you installed
-via::
-
-   python2 setup.py install
-
-then you will find this location at
-``$VIRTUAL_ENV/lib/python2.7/site-packages/Kallithea-0.1-py2.7.egg/kallithea``.
-
-One-time conversion
-~~~~~~~~~~~~~~~~~~~
+Migrating from RhodeCode
+------------------------
 
-Alternatively, if you would like to convert the database for good, you can use
-a helper script provided by Kallithea. This script will operate directly on the
-database, using the database string you can find in your ``production.ini`` (or
-``development.ini``) file. For example, if using SQLite::
-
-   cd /path/to/kallithea
-   cp /path/to/rhodecode/rhodecode.db kallithea.db
-   pip install sqlalchemy-migrate
-   python2 kallithea/bin/rebranddb.py sqlite:///kallithea.db
-
-.. Note::
-
-   If you started out using the branding interoperability approach mentioned
-   above, watch out for stray brand.pyc after removing brand.py.
-
-Git hooks
-~~~~~~~~~
-
-After switching to Kallithea, it will be necessary to update the Git_ hooks in
-your repositories. If not, the Git_ hooks from RhodeCode will still be called,
-which will cause ``git push`` to fail every time.
-
-If you do not have any custom Git_ hooks deployed, perform the following steps
-(this may take some time depending on the number and size of repositories you
-have):
-
-1. Log-in as an administrator.
-
-2. Open page *Admin > Settings > Remap and Rescan*.
-
-3. Turn on the option **Install Git Hooks**.
-
-4. Turn on the option **Overwrite existing Git hooks**.
-
-5. Click on the button **Rescan Repositories**.
-
-If you do have custom hooks, you will need to merge those changes manually. In
-order to get sample hooks from Kallithea, the easiest way is to create a new Git_
-repository, and have a look at the hooks deployed there.
+Kallithea 0.3.2 and earlier supports migrating from an existing RhodeCode
+installation. To migrate, install Kallithea 0.3.2 and follow the
+instructions in the 0.3.2 README to perform a one-time conversion of the
+database from RhodeCode to Kallithea, before upgrading to this version
+of Kallithea.
 
 
 .. _virtualenv: http://pypi.python.org/pypi/virtualenv

development.ini

@@ -1,19 +1,12 b''
 ################################################################################
 ################################################################################
-# Kallithea - Development config:                                              #
-# listening on *:5000                                                          #
-# sqlite and kallithea.db                                                      #
-# initial_repo_scan = true                                                     #
-# set debug = true                                                             #
-# verbose and colorful logging                                                 #
+# Kallithea - config file generated with kallithea-config                      #
 #                                                                              #
 # The %(here)s variable will be replaced with the parent directory of this file#
 ################################################################################
 ################################################################################
 
 [DEFAULT]
-debug = true
-pdebug = false
 
 ################################################################################
 ## Email settings                                                             ##
@@ -39,43 +32,39 b' pdebug = false'
 #email_prefix = [Kallithea]
 
 ## Recipients for error emails and fallback recipients of application mails.
-## Multiple addresses can be specified, space-separated.
+## Multiple addresses can be specified, comma-separated.
 ## Only addresses are allowed, do not add any name part.
 ## Default:
 #email_to =
 ## Examples:
 #email_to = [e-mail]
-#email_to = [e-mail] [e-mail]
+#email_to = [e-mail],[e-mail]
+email_to =
 
 ## 'From' header for error emails. You can optionally add a name.
-## Default:
-#error_email_from = [e-mail]
+## Default: (none)
 ## Examples:
 #error_email_from = Kallithea Errors <[e-mail]>
-#error_email_from = [e-mail]
+#error_email_from = [e-mail]
+error_email_from =
 
 ## SMTP server settings
-## Only smtp_server is mandatory. All other settings take the specified default
-## values.
-#smtp_server = smtp.example.com
+## If specifying credentials, make sure to use secure connections.
+## Default: Send unencrypted unauthenticated mails to the specified smtp_server.
+## For "SSL", use smtp_use_ssl = true and smtp_port = 465.
+## For "STARTTLS", use smtp_use_tls = true and smtp_port = 587.
+smtp_server =
 #smtp_username =
 #smtp_password =
-#smtp_port = 25
-#smtp_use_tls = false
+smtp_port =
 #smtp_use_ssl = false
-## SMTP authentication parameters to use (e.g. LOGIN PLAIN CRAM-MD5, etc.).
-## If empty, use any of the authentication parameters supported by the server.
-#smtp_auth =
+#smtp_use_tls = false
 
+## Entry point for 'gearbox serve'
 [server:main]
-## PASTE ##
-#use = egg:Paste#http
-## nr of worker threads to spawn
-#threadpool_workers = 1
-## max request before thread respawn
-#threadpool_max_requests = 100
-## option to use threads of process
-#use_threadpool = true
+#host = 127.0.0.1
+host = 0.0.0.0
+port = 5000
 
 ## WAITRESS ##
 use = egg:waitress#main
@@ -87,85 +76,6 b' max_request_body_size = 107374182400'
 ## windows systems.
 #asyncore_use_poll = True
 
-## GUNICORN ##
-#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
@@ -178,29 +88,26 b' use = egg:kallithea'
 
 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 =
+
+## Internationalization (see setup documentation for details)
+## By default, the language requested by the browser is used if available.
+#i18n.enable = false
+## Fallback language, empty for English (valid values are the names of subdirectories in kallithea/i18n):
+i18n.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 = VERY-SECRET
 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
 
@@ -226,6 +133,11 b' rss_include_diff = false'
 show_sha_length = 12
 show_revision_number = false
 
+## Canonical URL to use when creating full URLs in UI and texts.
+## Useful when the site is available under different names or protocols.
+## Defaults to what is provided in the WSGI environment.
+#canonical_url = https://kallithea.example.com/repos
+
 ## 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
@@ -245,46 +157,53 b' api_access_controllers_whitelist ='
 #    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
+## can be also a comma separated list of encoding in case of mixed encodings
+default_encoding = utf-8
+
+## Set Mercurial encoding, similar to setting HGENCODING before launching Kallithea
+hgencoding = utf-8
 
 ## 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
+## issue tracking mapping for commit messages, comments, PR descriptions, ...
+## Refer to the documentation ("Integration with issue trackers") for more details.
 
-## 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
+## regular expression to match issue references
+## This pattern may/should contain parenthesized groups, that can
+## be referred to in issue_server_link or issue_sub using Python backreferences
+## (e.g. \1, \2, ...). You can also create named groups with '(?P<groupname>)'.
+## To require mandatory whitespace before the issue pattern, use:
+## (?:^|(?<=\s)) before the actual pattern, and for mandatory whitespace
+## behind the issue pattern, use (?:$|(?=\s)) after the actual pattern.
 
-issue_pat = (?:\s*#)(\d+)
+issue_pat = #(\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}
+## server url to the issue
+## This pattern may/should contain backreferences to parenthesized groups in issue_pat.
+## A backreference can be \1, \2, ... or \g<groupname> if you specified a named group
+## called 'groupname' in issue_pat.
+## The special token {repo} is replaced with the full repository name
+## including repository groups, while {repo_name} is replaced with just
+## the name of the repository.
 
-## prefix to add to link to indicate it's an url
-## #314 will be replaced by <issue_prefix><id>
+issue_server_link = https://issues.example.com/{repo}/issue/\1
 
-issue_prefix = #
+## substitution pattern to use as the link text
+## If issue_sub is empty, the text matched by issue_pat is retained verbatim
+## for the link text. Otherwise, the link text is that of issue_sub, with any
+## backreferences to groups in issue_pat replaced.
 
-## issue_pat, issue_server_link, issue_prefix can have suffixes to specify
+issue_sub =
+
+## issue_pat, issue_server_link and issue_sub 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-
-
-## instance-id prefix
-## a prefix key for this instance used for cache invalidation when running
-## multiple instances of kallithea, make sure it's globally unique for
-## all running kallithea instances. Leave empty if you don't use it
-instance_id =
+#issue_pat_wiki = wiki-(\S+)
+#issue_server_link_wiki = https://wiki.example.com/\1
+#issue_sub_wiki = WIKI-\1
 
 ## alternative return HTTP header for failed authentication. Default HTTP
 ## response is 401 HTTPUnauthorized. Currently Mercurial clients have trouble with
@@ -301,19 +220,29 b' allow_repo_location_change = True'
 ## allows to setup custom hooks in settings page
 allow_custom_hooks_settings = True
 
+## extra extensions for indexing, space separated and without the leading '.'.
+# index.extensions =
+#    gemfile
+#    lock
+
+## extra filenames for indexing, space separated
+# index.filenames =
+#    .dockerignore
+#    .editorconfig
+#    INSTALL
+#    CHANGELOG
+
 ####################################
 ###        CELERY CONFIG        ####
 ####################################
 
 use_celery = false
-broker.host = localhost
-broker.vhost = rabbitmqhost
-broker.port = 5672
-broker.user = rabbitmq
-broker.password = qweqwe
+
+## Example: connect to the virtual host 'rabbitmqhost' on localhost as rabbitmq:
+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
@@ -322,11 +251,9 b' celery.result.serialier = json'
 #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.
+## If true, tasks will never be sent to the queue, but executed locally instead.
 celery.always.eager = false
 
 ####################################
@@ -363,6 +290,7 b' beaker.session.httponly = true'
 beaker.session.timeout = 2592000
 
 ## Server secret used with HMAC to ensure integrity of cookies.
+#beaker.session.secret = VERY-SECRET
 beaker.session.secret = development-not-secret
 ## Further, encrypt the data with AES.
 #beaker.session.encrypt_key = <key_for_encryption>
@@ -382,90 +310,13 b' beaker.session.secret = development-not-'
 #beaker.session.sa.url = postgresql://postgres:qwe@localhost/kallithea
 #beaker.session.table_name = db_session
 
-############################
-## ERROR HANDLING SYSTEMS ##
-############################
-
-####################
-### [appenlight] ###
-####################
-
-## AppEnlight is tailored to work with Kallithea, see
-## http://appenlight.com for details how to obtain an account
-## you must install python package `appenlight_client` to make it work
-
-## appenlight enabled
-appenlight = false
-
-appenlight.server_url = https://api.appenlight.com
-appenlight.api_key = YOUR_API_KEY
-
-## TWEAK AMOUNT OF INFO SENT HERE
-
-## enables 404 error logging (default False)
-appenlight.report_404 = false
-
-## time in seconds after request is considered being slow (default 1)
-appenlight.slow_request_time = 1
-
-## record slow requests in application
-## (needs to be enabled for slow datastore recording and time tracking)
-appenlight.slow_requests = true
-
-## enable hooking to application loggers
-#appenlight.logging = true
-
-## minimum log level for log capture
-#appenlight.logging.level = WARNING
-
-## send logs only from erroneous/slow requests
-## (saves API quota for intensive logging)
-appenlight.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
-appenlight.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
-appenlight.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: appenlight_client.client)
-appenlight.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*  ##
+## WARNING: *DEBUG MODE MUST BE OFF IN 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
+#debug = false
+debug = true
 
 ##################################
 ###       LOGVIEW CONFIG       ###
@@ -480,26 +331,25 b' logview.pylons.util = #eee'
 #########################################################
 
 # SQLITE [default]
-sqlalchemy.db1.url = sqlite:///%(here)s/kallithea.db?timeout=60
-
-# POSTGRESQL
-#sqlalchemy.db1.url = postgresql://user:pass@localhost/kallithea
-
-# MySQL
-#sqlalchemy.db1.url = mysql://user:pass@localhost/kallithea
+sqlalchemy.url = sqlite:///%(here)s/kallithea.db?timeout=60
 
 # see sqlalchemy docs for others
 
-sqlalchemy.db1.echo = false
-sqlalchemy.db1.pool_recycle = 3600
-sqlalchemy.db1.convert_unicode = true
+sqlalchemy.pool_recycle = 3600
+
+################################
+### ALEMBIC CONFIGURATION   ####
+################################
+
+[alembic]
+script_location = kallithea:alembic
 
 ################################
 ### LOGGING CONFIGURATION   ####
 ################################
 
 [loggers]
-keys = root, routes, kallithea, sqlalchemy, beaker, templates, whoosh_indexer
+keys = root, routes, kallithea, sqlalchemy, tg, gearbox, beaker, templates, whoosh_indexer, werkzeug, backlash
 
 [handlers]
 keys = console, console_sql
@@ -516,6 +366,7 b' level = NOTSET'
 handlers = console
 
 [logger_routes]
+#level = WARN
 level = DEBUG
 handlers =
 qualname = routes.middleware
@@ -523,35 +374,65 b' qualname = routes.middleware'
 propagate = 1
 
 [logger_beaker]
+#level = WARN
 level = DEBUG
 handlers =
 qualname = beaker.container
 propagate = 1
 
 [logger_templates]
+#level = WARN
 level = INFO
 handlers =
 qualname = pylons.templating
 propagate = 1
 
 [logger_kallithea]
+#level = WARN
 level = DEBUG
 handlers =
 qualname = kallithea
 propagate = 1
 
+[logger_tg]
+#level = WARN
+level = DEBUG
+handlers =
+qualname = tg
+propagate = 1
+
+[logger_gearbox]
+#level = WARN
+level = DEBUG
+handlers =
+qualname = gearbox
+propagate = 1
+
 [logger_sqlalchemy]
-level = INFO
+level = WARN
 handlers = console_sql
 qualname = sqlalchemy.engine
 propagate = 0
 
 [logger_whoosh_indexer]
+#level = WARN
 level = DEBUG
 handlers =
 qualname = whoosh_indexer
 propagate = 1
 
+[logger_werkzeug]
+level = WARN
+handlers =
+qualname = werkzeug
+propagate = 1
+
+[logger_backlash]
+level = WARN
+handlers =
+qualname = backlash
+propagate = 1
+
 ##############
 ## HANDLERS ##
 ##############
@@ -559,17 +440,13 b' propagate = 1'
 [handler_console]
 class = StreamHandler
 args = (sys.stderr,)
-#level = INFO
 #formatter = generic
-level = DEBUG
 formatter = color_formatter
 
 [handler_console_sql]
 class = StreamHandler
 args = (sys.stderr,)
-#level = WARN
 #formatter = generic
-level = DEBUG
 formatter = color_formatter_sql
 
 ################

docs/administrator_guide/auth.rst

@@ -1,164 +1,18 b''
-.. _setup:
-
-=====
-Setup
-=====
-
-
-Setting up Kallithea
---------------------
-
-First, you will need to create a Kallithea configuration file. Run the
-following command to do so::
-
-    paster make-config Kallithea my.ini
-
-This will create the file ``my.ini`` in the current directory. This
-configuration file contains the various settings for Kallithea, e.g.
-proxy port, email settings, usage of static files, cache, Celery
-settings, and logging.
-
-Next, you need to create the databases used by Kallithea. It is recommended to
-use PostgreSQL or SQLite (default). If you choose a database other than the
-default, ensure you properly adjust the database URL in your ``my.ini``
-configuration file to use this other database. Kallithea currently supports
-PostgreSQL, SQLite and MySQL databases. Create the database by running
-the following command::
-
-    paster setup-db my.ini
-
-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
-entering this "root" path ``setup-db`` will also prompt you for a username
-and password for the initial admin account which ``setup-db`` sets
-up for you.
-
-The ``setup-db`` values can also be given on the command line.
-Example::
-
-    paster setup-db my.ini --user=nn --password=secret --email=[e-mail] --repos=/srv/repos
-
-The ``setup-db`` command will create all needed tables and an
-admin account. When choosing a root path you can either use a new
-empty location, or a location which already contains existing
-repositories. If you choose a location which contains existing
-repositories Kallithea will add all of the repositories at the chosen
-location to its database.  (Note: make sure you specify the correct
-path to the root).
-
-.. note:: the given path for Mercurial_ repositories **must** be write
-          accessible for the application. It's very important since
-          the Kallithea web interface will work without write access,
-          but when trying to do a push it will fail with permission
-          denied errors unless it has write access.
-
-You are now ready to use Kallithea. To run it simply execute::
-
-    paster serve my.ini
-
-- 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
-  configuration file created in the previous step.
-- Log in to Kallithea using the admin account created when running ``setup-db``.
-- The default permissions on each repository is read, and the owner is admin.
-  Remember to update these if needed.
-- In the admin panel you can toggle LDAP, anonymous, and permissions
-  settings, as well as edit more advanced options on users and
-  repositories.
-
-
-Extensions
-----------
-
-Optionally one can create an ``rcextensions`` package that extends Kallithea
-functionality.
-To generate a skeleton extensions package, run::
-
-    paster make-rcext my.ini
+.. _authentication:
 
-This will create an ``rcextensions`` package next to the specified ``ini`` file.
-With ``rcextensions`` it's possible to add additional mapping for whoosh,
-stats and add additional code into the push/pull/create/delete repo hooks,
-for example for sending signals to build-bots such as Jenkins.
-
-See the ``__init__.py`` file inside the generated ``rcextensions`` package
-for more details.
-
-
-Using Kallithea with SSH
-------------------------
-
-Kallithea currently only hosts repositories using http and https. (The addition
-of ssh hosting is a planned future feature.) However you can easily use ssh in
-parallel with Kallithea. (Repository access via ssh is a standard "out of
-the box" feature of Mercurial_ and you can use this to access any of the
-repositories that Kallithea is hosting. See PublishingRepositories_)
-
-Kallithea repository structures are kept in directories with the same name
-as the project. When using repository groups, each group is a subdirectory.
-This allows you to easily use ssh for accessing repositories.
-
-In order to use ssh you need to make sure that your web server and the users'
-login accounts have the correct permissions set on the appropriate directories.
-
-.. note:: These permissions are independent of any permissions you
-          have set up using the Kallithea web interface.
-
-If your main directory (the same as set in Kallithea settings) is for
-example set to ``/srv/repos`` and the repository you are using is
-named ``kallithea``, then to clone via ssh you should run::
-
-    hg clone ssh://[e-mail]/srv/repos/kallithea
-
-Using other external tools such as mercurial-server_ or using ssh key-based
-authentication is fully supported.
+====================
+Authentication setup
+====================
 
-.. note:: In an advanced setup, in order for your ssh access to use
-          the same permissions as set up via the Kallithea web
-          interface, you can create an authentication hook to connect
-          to the Kallithea db and run check functions for permissions
-          against that.
-
-
-Setting up Whoosh full text search
-----------------------------------
-
-Kallithea provides full text search of repositories using `Whoosh`__.
-
-.. __: https://whoosh.readthedocs.io/en/latest/
-
-For an incremental index build, run::
-
-    paster make-index my.ini
-
-For a full index rebuild, run::
-
-    paster make-index my.ini -f
-
-The ``--repo-location`` option allows the location of the repositories to be overriden;
-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::
-
-    paster make-index my.ini --index-only=vcs,kallithea
-
-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::
-
-    0  3  *  *  *  /path/to/virtualenv/bin/paster make-index /path/to/kallithea/my.ini
-
-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
-available. The indexing daemon checks for any removed files and removes them
-from index.
-
-If you want to rebuild the index from scratch, you can use the ``-f`` flag as above,
-or in the admin panel you can check the "build from scratch" checkbox.
+Users can be authenticated in different ways. By default, Kallithea
+uses its internal user database. Alternative authentication
+methods include LDAP, PAM, Crowd, and container-based authentication.
 
 .. _ldap-setup:
 
-Setting up LDAP support
------------------------
+
+LDAP Authentication
+-------------------
 
 Kallithea supports LDAP authentication. In order
 to use LDAP, you have to install the python-ldap_ package. This package is
@@ -178,10 +32,9 b" Here's a typical LDAP setup::"
  Connection settings
  Enable LDAP          = checked
  Host                 = host.example.com
- Port                 = 389
  Account              = <account>
  Password             = <password>
- Connection Security  = LDAPS connection
+ Connection Security  = LDAPS
  Certificate Checks   = DEMAND
 
  Search settings
@@ -215,8 +68,9 b' Host : required'
 
 .. _Port:
 
-Port : required
-    389 for un-encrypted LDAP, 636 for SSL-encrypted LDAP.
+Port : optional
+    Defaults to 389 for PLAIN un-encrypted LDAP and START_TLS.
+    Defaults to 636 for LDAPS.
 
 .. _ldap_account:
 
@@ -236,26 +90,27 b' Password : optional'
 Connection Security : required
     Defines the connection to LDAP server
 
-    No encryption
-        Plain non encrypted connection
+    PLAIN
+        Plain unencrypted LDAP connection.
+        This will by default use `Port`_ 389.
 
-    LDAPS connection
-        Enable LDAPS connections. It will likely require `Port`_ to be set to
-        a different value (standard LDAPS port is 636). When LDAPS is enabled
-        then `Certificate Checks`_ is required.
+    LDAPS
+        Use secure LDAPS connections according to `Certificate
+        Checks`_ configuration.
+        This will by default use `Port`_ 636.
 
-    START_TLS on LDAP connection
-        START TLS connection
+    START_TLS
+        Use START TLS according to `Certificate Checks`_ configuration on an
+        apparently "plain" LDAP connection.
+        This will by default use `Port`_ 389.
 
 .. _Certificate Checks:
 
 Certificate Checks : optional
     How SSL certificates verification is handled -- this is only useful when
     `Enable LDAPS`_ is enabled.  Only DEMAND or HARD offer full SSL security
-    while the other options are susceptible to man-in-the-middle attacks.  SSL
-    certificates can be installed to /etc/openldap/cacerts so that the
-    DEMAND or HARD options can be used with self-signed certificates or
-    certificates that do not have traceable certificates of authority.
+    with mandatory certificate validation, while the other options are
+    susceptible to man-in-the-middle attacks.
 
     NEVER
         A serve certificate will never be requested or checked.
@@ -277,6 +132,16 b' Certificate Checks : optional'
     HARD
         The same as DEMAND.
 
+.. _Custom CA Certificates:
+
+Custom CA Certificates : optional
+    Directory used by OpenSSL to find CAs for validating the LDAP server certificate.
+    Python 2.7.10 and later default to using the system certificate store, and
+    this should thus not be necessary when using certificates signed by a CA
+    trusted by the system.
+    It can be set to something like `/etc/openldap/cacerts` on older systems or
+    if using self-signed certificates.
+
 .. _Base DN:
 
 Base DN : required
@@ -347,7 +212,7 b' information check out the Kallithea logs'
 will be saved there.
 
 Active Directory
-''''''''''''''''
+^^^^^^^^^^^^^^^^
 
 Kallithea can use Microsoft Active Directory for user authentication.  This
 is done through an LDAP or LDAPS connection to Active Directory.  The
@@ -384,24 +249,24 b" It's also possible for an administrator "
 permissions before the user logs in for the first time, using the :ref:`create-user` API.
 
 Container-based authentication
-''''''''''''''''''''''''''''''
+^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 In a container-based authentication setup, Kallithea reads the user name from
 the ``REMOTE_USER`` server variable provided by the WSGI container.
 
-After setting up your container (see `Apache with mod_wsgi`_), you'll need
+After setting up your container (see :ref:`apache_mod_wsgi`), you'll need
 to configure it to require authentication on the location configured for
 Kallithea.
 
 Proxy pass-through authentication
-'''''''''''''''''''''''''''''''''
+^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 In a proxy pass-through authentication setup, Kallithea reads the user name
 from the ``X-Forwarded-User`` request header, which should be configured to be
 sent by the reverse-proxy server.
 
-After setting up your proxy solution (see `Apache virtual host reverse proxy example`_,
-`Apache as subdirectory`_ or `Nginx virtual host example`_), you'll need to
+After setting up your proxy solution (see :ref:`apache_virtual_host_reverse_proxy`,
+:ref:`apache_subdirectory` or :ref:`nginx_virtual_host`), you'll need to
 configure the authentication and add the username in a request header named
 ``X-Forwarded-User``.
 
@@ -428,6 +293,73 b' reverse-proxy setup with basic auth:'
       RequestHeader set X-Forwarded-User %{RU}e
     </Location>
 
+Setting metadata in container/reverse-proxy
+"""""""""""""""""""""""""""""""""""""""""""
+When a new user account is created on the first login, Kallithea has no information about
+the user's email and full name. So you can set some additional request headers like in the
+example below. In this example the user is authenticated via Kerberos and an Apache
+mod_python fixup handler is used to get the user information from a LDAP server. But you
+could set the request headers however you want.
+
+.. 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
+
+      AuthName "Kerberos Login"
+      AuthType Kerberos
+      Krb5Keytab /etc/apache2/http.keytab
+      KrbMethodK5Passwd off
+      KrbVerifyKDC on
+      Require valid-user
+
+      PythonFixupHandler ldapmetadata
+
+      RequestHeader set X_REMOTE_USER %{X_REMOTE_USER}e
+      RequestHeader set X_REMOTE_EMAIL %{X_REMOTE_EMAIL}e
+      RequestHeader set X_REMOTE_FIRSTNAME %{X_REMOTE_FIRSTNAME}e
+      RequestHeader set X_REMOTE_LASTNAME %{X_REMOTE_LASTNAME}e
+    </Location>
+
+.. code-block:: python
+
+    from mod_python import apache
+    import ldap
+
+    LDAP_SERVER = "ldaps://server.mydomain.com:636"
+    LDAP_USER = ""
+    LDAP_PASS = ""
+    LDAP_ROOT = "dc=mydomain,dc=com"
+    LDAP_FILTER = "sAMAccountName=%s"
+    LDAP_ATTR_LIST = ['sAMAccountName','givenname','sn','mail']
+
+    def fixuphandler(req):
+        if req.user is None:
+            # no user to search for
+            return apache.OK
+        else:
+            try:
+                if('\\' in req.user):
+                    username = req.user.split('\\')[1]
+                elif('@' in req.user):
+                    username = req.user.split('@')[0]
+                else:
+                    username = req.user
+                l = ldap.initialize(LDAP_SERVER)
+                l.simple_bind_s(LDAP_USER, LDAP_PASS)
+                r = l.search_s(LDAP_ROOT, ldap.SCOPE_SUBTREE, LDAP_FILTER % username, attrlist=LDAP_ATTR_LIST)
+
+                req.subprocess_env['X_REMOTE_USER'] = username
+                req.subprocess_env['X_REMOTE_EMAIL'] = r[0][1]['mail'][0].lower()
+                req.subprocess_env['X_REMOTE_FIRSTNAME'] = "%s" % r[0][1]['givenname'][0]
+                req.subprocess_env['X_REMOTE_LASTNAME'] = "%s" % r[0][1]['sn'][0]
+            except Exception, e:
+                apache.log_error("error getting data from ldap %s" % str(e), apache.APLOG_ERR)
+
+            return apache.OK
+
 .. note::
    If you enable proxy pass-through authentication, make sure your server is
    only accessible through the proxy. Otherwise, any client would be able to
@@ -435,384 +367,4 b' reverse-proxy setup with basic auth:'
    using any account of their liking.
 
 
-Integration with issue trackers
--------------------------------
-
-Kallithea provides a simple integration with issue trackers. It's possible
-to define a regular expression that will match an issue ID in commit messages,
-and have that replaced with a URL to the issue. To enable this simply
-uncomment the following variables in the ini file::
-
-    issue_pat = (?:^#|\s#)(\w+)
-    issue_server_link = https://issues.example.com/{repo}/issue/{id}
-    issue_prefix = #
-
-``issue_pat`` is the regular expression describing which strings in
-commit messages will be treated as issue references. A match group in
-parentheses should be used to specify the actual issue id.
-
-The default expression matches issues in the format ``#<number>``, e.g., ``#300``.
-
-Matched issue references are replaced with the link specified in
-``issue_server_link``. ``{id}`` is replaced with the issue ID, and
-``{repo}`` with the repository name.  Since the # is stripped away,
-``issue_prefix`` is prepended to the link text.  ``issue_prefix`` doesn't
-necessarily need to be ``#``: if you set issue prefix to ``ISSUE-`` this will
-generate a URL in the format:
-
-.. code-block:: html
-
-  <a href="https://issues.example.com/example_repo/issue/300">ISSUE-300</a>
-
-If needed, more than one pattern can be specified by appending a unique suffix to
-the variables. For example::
-
-    issue_pat_wiki = (?:wiki-)(.+)
-    issue_server_link_wiki = https://wiki.example.com/{id}
-    issue_prefix_wiki = WIKI-
-
-With these settings, wiki pages can be referenced as wiki-some-id, and every
-such reference will be transformed into:
-
-.. code-block:: html
-
-  <a href="https://wiki.example.com/some-id">WIKI-some-id</a>
-
-
-Hook management
----------------
-
-Hooks can be managed in similar way to that used in ``.hgrc`` files.
-To manage hooks, choose *Admin > Settings > Hooks*.
-
-The built-in hooks cannot be modified, though they can be enabled or disabled in the *VCS* section.
-
-To add another custom hook simply fill in the first textbox with
-``<name>.<hook_type>`` and the second with the hook path. Example hooks
-can be found in ``kallithea.lib.hooks``.
-
-
-Changing default encoding
--------------------------
-
-By default, Kallithea uses UTF-8 encoding.
-This is configurable as ``default_encoding`` in the .ini file.
-This affects many parts in Kallithea including user names, filenames, and
-encoding of commit messages. In addition Kallithea can detect if the ``chardet``
-library is installed. If ``chardet`` is detected Kallithea will fallback to it
-when there are encode/decode errors.
-
-
-Celery configuration
---------------------
-
-Kallithea can use the distributed task queue system Celery_ to run tasks like
-cloning repositories or sending emails.
-
-Kallithea will in most setups work perfectly fine out of the box (without
-Celery), executing all tasks in the web server process. Some tasks can however
-take some time to run and it can be better to run such tasks asynchronously in
-a separate process so the web server can focus on serving web requests.
-
-For installation and configuration of Celery, see the `Celery documentation`_.
-Note that Celery requires a message broker service like RabbitMQ_ (recommended)
-or Redis_.
-
-The use of Celery is configured in the Kallithea ini configuration file.
-To enable it, simply set::
-
-  use_celery = true
-
-and add or change the ``celery.*`` and ``broker.*`` configuration variables.
-
-Remember that the ini files use the format with '.' and not with '_' like
-Celery. So for example setting `BROKER_HOST` in Celery means setting
-`broker.host` in the configuration file.
-
-To start the Celery process, run::
-
- paster celeryd <configfile.ini>
-
-.. note::
-   Make sure you run this command from the same virtualenv, and with the same
-   user that Kallithea runs.
-
-
-HTTPS support
--------------
-
-Kallithea will by default generate URLs based on the WSGI environment.
-
-Alternatively, you can use some special configuration settings to control
-directly which scheme/protocol Kallithea will use when generating URLs:
-
-- With ``https_fixup = true``, the scheme will be taken from the
-  ``X-Url-Scheme``, ``X-Forwarded-Scheme`` or ``X-Forwarded-Proto`` HTTP header
-  (default ``http``).
-- With ``force_https = true`` the default will be ``https``.
-- With ``use_htsts = true``, Kallithea will set ``Strict-Transport-Security`` when using https.
-
-
-Nginx virtual host example
---------------------------
-
-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
-
-- 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.
-- 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=5 threads=1 maximum-requests=100 \
-        python-home=/srv/kallithea/venv
-    WSGIProcessGroup kallithea
-    WSGIScriptAlias / /srv/kallithea/dispatch.wsgi
-    WSGIPassAuthorization On
-
-Or if using a dispatcher WSGI script with proper virtualenv activation:
-
-.. code-block:: apache
-
-    WSGIDaemonProcess kallithea processes=5 threads=1 maximum-requests=100
-    WSGIProcessGroup kallithea
-    WSGIScriptAlias / /srv/kallithea/dispatch.wsgi
-    WSGIPassAuthorization On
-
-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.
-
-.. note::
-   If running Kallithea in multiprocess mode,
-   make sure you set ``instance_id = *`` in the configuration so each process
-   gets it's own cache invalidation key.
-
-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/venv/lib/python2.7/site-packages")
-
-    ini = '/srv/kallithea/my.ini'
-    from paste.script.util.logging_config import fileConfig
-    fileConfig(ini)
-    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 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: https://www.mercurial-scm.org/
-.. _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: https://www.mercurial-scm.org/wiki/PublishingRepositories

docs/administrator_guide/vcs_setup.rst

@@ -1,14 +1,15 b''
-.. _vcs_support:
+.. _vcs_setup:
 
-===============================
-Version control systems support
-===============================
+=============================
+Version control systems setup
+=============================
 
 Kallithea supports Git and Mercurial repositories out-of-the-box.
 For Git, you do need the ``git`` command line client installed on the server.
 
 You can always disable Git or Mercurial support by editing the
-file ``kallithea/__init__.py`` and commenting out the backend.
+file ``kallithea/__init__.py`` and commenting out the backend. For example, to
+disable Git but keep Mercurial enabled:
 
 .. code-block:: python
 
@@ -18,20 +19,20 b' file ``kallithea/__init__.py`` and comme'
    }
 
 
-Git support
------------
+Git-specific setup
+------------------
 
 
 Web server with chunked encoding
-````````````````````````````````
+^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 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
-waitress_ for `paster serve` instead of the built-in `paste` WSGI
+waitress_ for `gearbox serve` instead of the built-in `paste` WSGI
 server.
 
-The paster server is controlled in the .ini file::
+The web server used by gearbox is controlled in the .ini file::
 
     use = egg:waitress#main
 
@@ -45,41 +46,14 b' Also make sure to comment out the follow'
     threadpool_max_requests =
     use_threadpool =
 
-
-Mercurial support
------------------
-
-
-Working with Mercurial subrepositories
-``````````````````````````````````````
-
-This section explains how to use Mercurial subrepositories_ in Kallithea.
-
-Example usage::
+Increasing Git HTTP POST buffer size
+^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
-    ## init a simple repo
-    hg init mainrepo
-    cd mainrepo
-    echo "file" > file
-    hg add file
-    hg ci --message "initial file"
-
-    # clone subrepo we want to add from Kallithea
-    hg clone http://kallithea.local/subrepo
+If Git pushes fail with HTTP error code 411 (Length Required), you may need to
+increase the Git HTTP POST buffer. Run the following command as the user that
+runs Kallithea to set a global Git variable to this effect::
 
-    ## specify URL to existing repo in Kallithea as subrepository path
-    echo "subrepo = http://kallithea.local/subrepo" > .hgsub
-    hg add .hgsub
-    hg ci --message "added remote subrepo"
-
-In the file list of a clone of ``mainrepo`` you will see a connected
-subrepository at the revision it was cloned with. Clicking on the
-subrepository link sends you to the proper repository in Kallithea.
-
-Cloning ``mainrepo`` will also clone the attached subrepository.
-
-Next we can edit the subrepository data, and push back to Kallithea. This will
-update both repositories.
+    git config --global http.postBuffer 524288000
 
 
 .. _waitress: http://pypi.python.org/pypi/waitress

docs/api/api.rst

@@ -9,34 +9,16 b' methods. Everything is available by send'
 ``<your_server>/_admin/api``.
 
 
-API access for web views
-++++++++++++++++++++++++
-
-API access can also be turned on for each web view in Kallithea that is
-decorated with the ``@LoginRequired`` decorator. Some views use
-``@LoginRequired(api_access=True)`` and are always available. By default only
-RSS/Atom feed views are enabled. Other views are
-only available if they have been whitelisted. Edit the
-``api_access_controllers_whitelist`` option in your .ini file and define views
-that should have API access enabled.
+API keys
+--------
 
-For example, to enable API access to patch/diff, raw file and archive::
-
-    api_access_controllers_whitelist =
-        ChangesetController:changeset_patch,
-        ChangesetController:changeset_raw,
-        FilesController:raw,
-        FilesController:archivefile
-
-After this change, a Kallithea view can be accessed without login by adding a
-GET parameter ``?api_key=<api_key>`` to the URL.
-
-Exposing raw diffs is a good way to integrate with
-third-party services like code review, or build farms that can download archives.
+Every Kallithea user automatically receives an API key, which they can
+view under "My Account". On this page, API keys can also be revoked, and
+additional API keys can be generated.
 
 
 API access
-++++++++++
+----------
 
 Clients must send JSON encoded JSON-RPC requests::
 
@@ -76,7 +58,7 b' the reponse will have a failure descript'
 
 
 API client
-++++++++++
+----------
 
 Kallithea comes with a ``kallithea-api`` command line tool, providing a convenient
 way to call the JSON-RPC API.
@@ -110,11 +92,11 b" so you don't have to specify them every "
 
 
 API methods
-+++++++++++
+-----------
 
 
 pull
-----
+^^^^
 
 Pull the given repo from remote location. Can be used to automatically keep
 remote repos up to date.
@@ -136,7 +118,7 b' OUTPUT::'
     error :  null
 
 rescan_repos
-------------
+^^^^^^^^^^^^
 
 Rescan repositories. If ``remove_obsolete`` is set,
 Kallithea will delete repos that are in the database but not in the filesystem.
@@ -159,7 +141,7 b' OUTPUT::'
     error :  null
 
 invalidate_cache
-----------------
+^^^^^^^^^^^^^^^^
 
 Invalidate the cache for a repository.
 This command can only be executed using the api_key of a user with admin rights,
@@ -181,7 +163,7 b' OUTPUT::'
     error :  null
 
 lock
-----
+^^^^
 
 Set the locking state on the given repository by the given user.
 If the param ``userid`` is skipped, it is set to the ID of the user who is calling this method.
@@ -212,7 +194,7 b' OUTPUT::'
     error :  null
 
 get_ip
-------
+^^^^^^
 
 Return IP address as seen from Kallithea server, together with all
 defined IP addresses for given user.
@@ -244,12 +226,12 b' OUTPUT::'
     error :  null
 
 get_user
---------
+^^^^^^^^
 
 Get a user by username or userid. The result is empty if user can't be found.
 If userid param is skipped, it is set to id of user who is calling this method.
 Any userid can be specified when the command is executed using the api_key of a user with admin rights.
-Regular users can only speicy their own userid.
+Regular users can only specify their own userid.
 
 INPUT::
 
@@ -288,7 +270,7 b' OUTPUT::'
     error:  null
 
 get_users
----------
+^^^^^^^^^
 
 List all existing users.
 This command can only be executed using the api_key of a user with admin rights.
@@ -325,7 +307,7 b' OUTPUT::'
 .. _create-user:
 
 create_user
------------
+^^^^^^^^^^^
 
 Create new user.
 This command can only be executed using the api_key of a user with admin rights.
@@ -371,7 +353,7 b' Example::'
     kallithea-api create_user username:bent email:[e-mail] firstname:Bent lastname:Bentsen extern_type:ldap extern_name:uid=bent,dc=example,dc=com
 
 update_user
------------
+^^^^^^^^^^^
 
 Update the given user if such user exists.
 This command can only be executed using the api_key of a user with admin rights.
@@ -415,7 +397,7 b' OUTPUT::'
     error:  null
 
 delete_user
------------
+^^^^^^^^^^^
 
 Delete the given user if such a user exists.
 This command can only be executed using the api_key of a user with admin rights.
@@ -439,7 +421,7 b' OUTPUT::'
     error:  null
 
 get_user_group
---------------
+^^^^^^^^^^^^^^
 
 Get an existing user group.
 This command can only be executed using the api_key of a user with admin rights.
@@ -481,7 +463,7 b' OUTPUT::'
     error : null
 
 get_user_groups
----------------
+^^^^^^^^^^^^^^^
 
 List all existing user groups.
 This command can only be executed using the api_key of a user with admin rights.
@@ -507,7 +489,7 b' OUTPUT::'
     error : null
 
 create_user_group
------------------
+^^^^^^^^^^^^^^^^^
 
 Create a new user group.
 This command can only be executed using the api_key of a user with admin rights.
@@ -537,7 +519,7 b' OUTPUT::'
     error:  null
 
 add_user_to_user_group
-----------------------
+^^^^^^^^^^^^^^^^^^^^^^
 
 Adds a user to a user group. If the user already is in that group, success will be
 ``false``.
@@ -564,7 +546,7 b' OUTPUT::'
     error:  null
 
 remove_user_from_user_group
----------------------------
+^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 Remove a user from a user group. If the user isn't in the given group, success will
 be ``false``.
@@ -591,7 +573,7 b' OUTPUT::'
     error:  null
 
 get_repo
---------
+^^^^^^^^
 
 Get an existing repository by its name or repository_id. Members will contain
 either users_group or users associated to that repository.
@@ -604,7 +586,9 b' INPUT::'
     api_key : "<api_key>"
     method :  "get_repo"
     args:     {
-                "repoid" : "<reponame or repo_id>"
+                "repoid" : "<reponame or repo_id>",
+                "with_revision_names": "<bool> = Optional(False)",
+                "with_pullrequests": "<bool> = Optional(False)",
               }
 
 OUTPUT::
@@ -630,7 +614,7 b' OUTPUT::'
                                        "raw_id":   "<raw_id>",
                                        "revision": "<numeric_revision>",
                                        "short_id": "<short_id>"
-                                     }
+                                     },
                 "owner":             "<repo_owner>",
                 "fork_of":           "<name_of_fork_parent>",
                 "members" :     [
@@ -658,7 +642,7 b' OUTPUT::'
                                     "permission" : "repository.(read|write|admin)"
                                   },
                                   …
-                                ]
+                                ],
                  "followers":   [
                                   {
                                     "user_id" :     "<user_id>",
@@ -675,12 +659,74 b' OUTPUT::'
                                     "last_login":   "<last_login>",
                                   },
                                   …
-                 ]
+                                ],
+                 <if with_revision_names == True>
+                 "tags": {
+                            "<tagname>": "<raw_id>",
+                            ...
+                         },
+                 "branches": {
+                            "<branchname>": "<raw_id>",
+                            ...
+                         },
+                 "bookmarks": {
+                            "<bookmarkname>": "<raw_id>",
+                            ...
+                         },
+                <if with_pullrequests == True>
+                "pull_requests": [
+                  {
+                    "status": "<pull_request_status>",
+                    "pull_request_id": <pull_request_id>,
+                    "description": "<pull_request_description>",
+                    "title": "<pull_request_title>",
+                    "url": "<pull_request_url>",
+                    "reviewers": [
+                      {
+                        "username": "<user_id>",
+                      },
+                      ...
+                    ],
+                    "org_repo_url": "<repo_url>",
+                    "org_ref_parts": [
+                      "<ref_type>",
+                      "<ref_name>",
+                      "<raw_id>"
+                    ],
+                    "other_ref_parts": [
+                      "<ref_type>",
+                      "<ref_name>",
+                      "<raw_id>"
+                    ],
+                    "comments": [
+                      {
+                        "username": "<user_id>",
+                        "text": "<comment text>",
+                        "comment_id": "<comment_id>",
+                      },
+                      ...
+                    ],
+                    "owner": "<username>",
+                    "statuses": [
+                      {
+                        "status": "<status_of_review>",        # "under_review", "approved" or "rejected"
+                        "reviewer": "<user_id>",
+                        "modified_at": "<date_time_of_review>" # iso 8601 date, server's timezone
+                      },
+                      ...
+                    ],
+                    "revisions": [
+                      "<raw_id>",
+                      ...
+                    ]
+                  },
+                  ...
+                ]
             }
     error:  null
 
 get_repos
----------
+^^^^^^^^^
 
 List all existing repositories.
 This command can only be executed using the api_key of a user with admin rights,
@@ -717,7 +763,7 b' OUTPUT::'
     error:  null
 
 get_repo_nodes
---------------
+^^^^^^^^^^^^^^
 
 Return a list of files and directories for a given path at the given revision.
 It is possible to specify ret_type to show only ``files`` or ``dirs``.
@@ -748,7 +794,7 b' OUTPUT::'
     error:  null
 
 create_repo
------------
+^^^^^^^^^^^
 
 Create a repository. If the repository name contains "/", the repository will be
 created in the repository group indicated by that path. Any such repository
@@ -802,7 +848,7 b' OUTPUT::'
     error:  null
 
 update_repo
------------
+^^^^^^^^^^^
 
 Update a repository.
 This command can only be executed using the api_key of a user with admin rights,
@@ -862,7 +908,7 b' OUTPUT::'
     error:  null
 
 fork_repo
----------
+^^^^^^^^^
 
 Create a fork of the given repo. If using Celery, this will
 return success message immediately and a fork will be created
@@ -898,7 +944,7 b' OUTPUT::'
     error:  null
 
 delete_repo
------------
+^^^^^^^^^^^
 
 Delete a repository.
 This command can only be executed using the api_key of a user with admin rights,
@@ -925,7 +971,7 b' OUTPUT::'
     error:  null
 
 grant_user_permission
----------------------
+^^^^^^^^^^^^^^^^^^^^^
 
 Grant permission for a user on the given repository, or update the existing one if found.
 This command can only be executed using the api_key of a user with admin rights.
@@ -951,7 +997,7 b' OUTPUT::'
     error:  null
 
 revoke_user_permission
-----------------------
+^^^^^^^^^^^^^^^^^^^^^^
 
 Revoke permission for a user on the given repository.
 This command can only be executed using the api_key of a user with admin rights.
@@ -976,7 +1022,7 b' OUTPUT::'
     error:  null
 
 grant_user_group_permission
----------------------------
+^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 Grant permission for a user group on the given repository, or update the
 existing one if found.
@@ -1003,7 +1049,7 b' OUTPUT::'
     error:  null
 
 revoke_user_group_permission
-----------------------------
+^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 Revoke permission for a user group on the given repository.
 This command can only be executed using the api_key of a user with admin rights.
@@ -1026,3 +1072,235 b' OUTPUT::'
               "success": true
             }
     error:  null
+
+get_changesets
+^^^^^^^^^^^^^^
+
+Get changesets of a given repository. This command can only be executed using the api_key
+of a user with read permissions to the repository.
+
+INPUT::
+
+    id : <id_for_response>
+    api_key : "<api_key>"
+    method  : "get_changesets"
+    args:     {
+                "repoid" : "<reponame or repo_id>",
+                "start": "<revision number> = Optional(None)",
+                "end": "<revision number> = Optional(None)",
+                "start_date": "<date> = Optional(None)",    # in "%Y-%m-%dT%H:%M:%S" format
+                "end_date": "<date> = Optional(None)",      # in "%Y-%m-%dT%H:%M:%S" format
+                "branch_name": "<branch name filter> = Optional(None)",
+                "reverse": "<bool> = Optional(False)",
+                "with_file_list": "<bool> = Optional(False)"
+              }
+
+OUTPUT::
+
+    id : <id_given_in_input>
+    result: [
+    {
+      "raw_id": "<raw_id>",
+      "short_id": "short_id": "<short_id>",
+      "author": "<full_author>",
+      "date": "<date_time_of_commit>",
+      "message": "<commit_message>",
+      "revision": "<numeric_revision>",
+      <if with_file_list == True>
+      "added": [<list of added files>],
+      "changed": [<list of changed files>],
+      "removed": [<list of removed files>]
+    },
+    ...
+    ]
+    error:  null
+
+get_changeset
+^^^^^^^^^^^^^
+
+Get information and review status for a given changeset. This command can only
+be executed using the api_key of a user with read permissions to the
+repository.
+
+INPUT::
+
+    id : <id_for_response>
+    api_key : "<api_key>"
+    method  : "get_changeset"
+    args:     {
+                "repoid" : "<reponame or repo_id>",
+                "raw_id" : "<raw_id>",
+                "with_reviews": "<bool> = Optional(False)"
+              }
+
+OUTPUT::
+
+    id : <id_given_in_input>
+    result: {
+              "author":   "<full_author>",
+              "date":     "<date_time_of_commit>",
+              "message":  "<commit_message>",
+              "raw_id":   "<raw_id>",
+              "revision": "<numeric_revision>",
+              "short_id": "<short_id>",
+              "reviews": [{
+                    "reviewer":   "<username>",
+                    "modified_at": "<date_time_of_review>",  # iso 8601 date, server's timezone
+                    "status":   "<status_of_review>",        # "under_review", "approved" or "rejected"
+                 },
+                 ...
+              ]
+            }
+    error:  null
+
+Example output::
+
+    {
+      "id" : 1,
+      "error" : null,
+      "result" : {
+        "author" : {
+          "email" : "[e-mail]",
+          "name" : "Kallithea Admin"
+        },
+        "changed" : [],
+        "short_id" : "e1022d3d28df",
+        "date" : "2017-03-28T09:09:03",
+        "added" : [
+          "README.rst"
+        ],
+        "removed" : [],
+        "revision" : 0,
+        "raw_id" : "e1022d3d28dfba02f626cde65dbe08f4ceb0e4e7",
+        "message" : "Added file via Kallithea",
+        "id" : "e1022d3d28dfba02f626cde65dbe08f4ceb0e4e7",
+        "reviews" : [
+          {
+            "status" : "under_review",
+            "modified_at" : "2017-03-28T09:17:08.618",
+            "reviewer" : "user"
+          }
+        ]
+      }
+    }
+
+get_pullrequest
+^^^^^^^^^^^^^^^
+
+Get information and review status for a given pull request. This command can only be executed
+using the api_key of a user with read permissions to the original repository.
+
+INPUT::
+
+    id : <id_for_response>
+    api_key : "<api_key>"
+    method  : "get_pullrequest"
+    args:     {
+                "pullrequest_id" : "<pullrequest_id>",
+              }
+
+OUTPUT::
+
+    id : <id_given_in_input>
+    result: {
+        "status": "<pull_request_status>",
+        "pull_request_id": <pull_request_id>,
+        "description": "<pull_request_description>",
+        "title": "<pull_request_title>",
+        "url": "<pull_request_url>",
+        "reviewers": [
+          {
+            "username": "<user_name>",
+          },
+          ...
+        ],
+        "org_repo_url": "<repo_url>",
+        "org_ref_parts": [
+          "<ref_type>",
+          "<ref_name>",
+          "<raw_id>"
+        ],
+        "other_ref_parts": [
+          "<ref_type>",
+          "<ref_name>",
+          "<raw_id>"
+        ],
+        "comments": [
+          {
+            "username": "<user_name>",
+            "text": "<comment text>",
+            "comment_id": "<comment_id>",
+          },
+          ...
+        ],
+        "owner": "<username>",
+        "statuses": [
+          {
+            "status": "<status_of_review>",        # "under_review", "approved" or "rejected"
+            "reviewer": "<user_name>",
+            "modified_at": "<date_time_of_review>" # iso 8601 date, server's timezone
+          },
+          ...
+        ],
+        "revisions": [
+          "<raw_id>",
+          ...
+        ]
+    },
+    error:  null
+
+comment_pullrequest
+^^^^^^^^^^^^^^^^^^^
+
+Add comment, change status or close a given pull request. This command can only be executed
+using the api_key of a user with read permissions to the original repository.
+
+INPUT::
+
+    id : <id_for_response>
+    api_key : "<api_key>"
+    method  : "comment_pullrequest"
+    args:     {
+                "pull_request_id":  "<pull_request_id>",
+                "comment_msg":      Optional(''),
+                "status":           Optional(None),     # "under_review", "approved" or "rejected"
+                "close_pr":         Optional(False)",
+              }
+
+OUTPUT::
+
+    id : <id_given_in_input>
+    result: True
+    error:  null
+
+
+API access for web views
+------------------------
+
+API access can also be turned on for each web view in Kallithea that is
+decorated with the ``@LoginRequired`` decorator. Some views use
+``@LoginRequired(api_access=True)`` and are always available. By default only
+RSS/Atom feed views are enabled. Other views are
+only available if they have been whitelisted. Edit the
+``api_access_controllers_whitelist`` option in your .ini file and define views
+that should have API access enabled.
+
+For example, to enable API access to patch/diff, raw file and archive::
+
+    api_access_controllers_whitelist =
+        ChangesetController:changeset_patch,
+        ChangesetController:changeset_raw,
+        FilesController:raw,
+        FilesController:archivefile
+
+After this change, a Kallithea view can be accessed without login using
+bearer authentication, by including this header with the request::
+
+    Authentication: Bearer <api_key>
+
+Alternatively, the API key can be passed in the URL query string using
+``?api_key=<api_key>``, though this is not recommended due to the increased
+risk of API key leaks, and support will likely be removed in the future.
+
+Exposing raw diffs is a good way to integrate with
+third-party services like code review, or build farms that can download archives.

docs/api/models.rst

@@ -10,9 +10,6 b' The :mod:`models` module'
 .. automodule:: kallithea.model.comment
    :members:
 
-.. automodule:: kallithea.model.notification
-   :members:
-
 .. automodule:: kallithea.model.permission
    :members:
 

docs/contributing.rst

@@ -28,62 +28,179 b' for more details.'
 Getting started
 ---------------
 
-To get started with development::
+To get started with Kallithea development::
 
         hg clone https://kallithea-scm.org/repos/kallithea
         cd kallithea
         virtualenv ../kallithea-venv
         source ../kallithea-venv/bin/activate
-        pip install --upgrade pip "setuptools<34"
-        pip install -e .
-        paster make-config Kallithea my.ini
-        paster setup-db my.ini --user=user --email=[e-mail] --password=password --repos=/tmp
-        paster serve my.ini --reload &
+        pip install --upgrade pip setuptools
+        pip install --upgrade -e .
+        pip install --upgrade -r dev_requirements.txt
+        kallithea-cli config-create my.ini
+        kallithea-cli db-create -c my.ini --user=user --email=[e-mail] --password=password --repos=/tmp
+        kallithea-cli front-end-build
+        gearbox serve -c my.ini --reload &
         firefox http://127.0.0.1:5000/
 
-You can also start out by forking https://bitbucket.org/conservancy/kallithea
-on Bitbucket_ and create a local clone of your own fork.
+If you plan to use Bitbucket_ for sending contributions, you can also fork
+Kallithea on Bitbucket_ first (https://bitbucket.org/conservancy/kallithea) and
+then replace the clone step above by a clone of your fork. In this case, please
+see :ref:`contributing-guidelines` below for configuring your fork correctly.
+
+
+Contribution flow
+-----------------
+
+Starting from an existing Kallithea clone, make sure it is up to date with the
+latest upstream changes::
+
+        hg pull
+        hg update
+
+Review the :ref:`contributing-guidelines` and :ref:`coding-guidelines`.
+
+If you are new to Mercurial, refer to Mercurial `Quick Start`_ and `Beginners
+Guide`_ on the Mercurial wiki.
+
+Now, make some changes and test them (see :ref:`contributing-tests`). Don't
+forget to add new tests to cover new functionality or bug fixes.
+
+For documentation changes, run ``make html`` from the ``docs`` directory to
+generate the HTML result, then review them in your browser.
+
+Before submitting any changes, run the cleanup script::
+
+        ./scripts/run-all-cleanup
+
+When you are completely ready, you can send your changes to the community for
+review and inclusion. Most commonly used methods are sending patches to the
+mailing list (via ``hg email``) or by creating a pull request on Bitbucket_.
+
+.. _contributing-tests:
 
 
 Running tests
 -------------
 
-After finishing your changes make sure all tests pass cleanly. You can run
-the testsuite running ``nosetests`` from the project root, or if you use tox
-run ``tox`` for Python 2.6--2.7 with multiple database test.
+After finishing your changes make sure all tests pass cleanly. Run the testsuite
+by invoking ``py.test`` from the project root::
+
+    py.test
+
+Note that testing on Python 2.6 also requires ``unittest2``.
 
-When running tests, Kallithea uses `kallithea/tests/test.ini` and populates the
-SQLite database specified there.
+Note that on unix systems, the temporary directory (``/tmp`` or where
+``$TMPDIR`` points) must allow executable files; Git hooks must be executable,
+and the test suite creates repositories in the temporary directory. Linux
+systems with /tmp mounted noexec will thus fail.
+
+You can also use ``tox`` to run the tests with all supported Python versions
+(currently Python 2.6--2.7).
+
+When running tests, Kallithea generates a `test.ini` based on template values
+in `kallithea/tests/conftest.py` and populates the SQLite database specified
+there.
 
 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::
 
-    paster serve kallithea/tests/test.ini --pid-file=test.pid --daemon
-    KALLITHEA_WHOOSH_TEST_DISABLE=1 KALLITHEA_NO_TMP_PATH=1 nosetests
+    gearbox serve -c /tmp/kallithea-test-XXX/test.ini --pid-file=test.pid --daemon
+    KALLITHEA_WHOOSH_TEST_DISABLE=1 KALLITHEA_NO_TMP_PATH=1 py.test
     kill -9 $(cat test.pid)
 
-You can run individual tests by specifying their path as argument to nosetests.
-nosetests also has many more options, see `nosetests -h`. Some useful options
+In these commands, the following variables are used::
+
+    KALLITHEA_WHOOSH_TEST_DISABLE=1 - skip whoosh index building and tests
+    KALLITHEA_NO_TMP_PATH=1 - disable new temp path for tests, used mostly for testing_vcs_operations
+
+You can run individual tests by specifying their path as argument to py.test.
+py.test also has many more options, see `py.test -h`. Some useful options
 are::
 
-    -x, --stop            Stop running tests after the first error or failure
-    -s, --nocapture       Don't capture stdout (any stdout output will be
-                          printed immediately) [NOSE_NOCAPTURE]
-    --failed              Run the tests that failed in the last test run.
+    -k EXPRESSION         only run tests which match the given substring
+                          expression. An expression is a python evaluable
+                          expression where all names are substring-matched
+                          against test names and their parent classes. Example:
+    -x, --exitfirst       exit instantly on first error or failed test.
+    --lf                  rerun only the tests that failed at the last run (or
+                          all if none failed)
+    --ff                  run all tests but run the last failures first. This
+                          may re-order tests and thus lead to repeated fixture
+                          setup/teardown
+    --pdb                 start the interactive Python debugger on errors.
+    -s, --capture=no      don't capture stdout (any stdout output will be
+                          printed immediately)
+
+Performance tests
+^^^^^^^^^^^^^^^^^
+
+A number of performance tests are present in the test suite, but they are
+not run in a standard test run. These tests are useful to
+evaluate the impact of certain code changes with respect to performance.
+
+To run these tests::
+
+    env TEST_PERFORMANCE=1 py.test kallithea/tests/performance
+
+To analyze performance, you could install pytest-profiling_, which enables the
+--profile and --profile-svg options to py.test.
+
+.. _pytest-profiling: https://github.com/manahl/pytest-plugins/tree/master/pytest-profiling
+
+.. _contributing-guidelines:
 
 
-Coding/contribution guidelines
-------------------------------
+Contribution guidelines
+-----------------------
 
 Kallithea is GPLv3 and we assume all contributions are made by the
 committer/contributor and under GPLv3 unless explicitly stated. We do care a
 lot about preservation of copyright and license information for existing code
 that is brought into the project.
 
+Contributions will be accepted in most formats -- such as pull requests on
+Bitbucket, something hosted on your own Kallithea instance, or patches sent by
+email to the `kallithea-general`_ mailing list.
+
+When contributing via Bitbucket, please make your fork of
+https://bitbucket.org/conservancy/kallithea/ `non-publishing`_ -- it is one of
+the settings on "Repository details" page. This ensures your commits are in
+"draft" phase and makes it easier for you to address feedback and for project
+maintainers to integrate your changes.
+
+.. _non-publishing: https://www.mercurial-scm.org/wiki/Phases#Publishing_Repository
+
+Make sure to test your changes both manually and with the automatic tests
+before posting.
+
+We care about quality and review and keeping a clean repository history. We
+might give feedback that requests polishing contributions until they are
+"perfect". We might also rebase and collapse and make minor adjustments to your
+changes when we apply them.
+
+We try to make sure we have consensus on the direction the project is taking.
+Everything non-sensitive should be discussed in public -- preferably on the
+mailing list.  We aim at having all non-trivial changes reviewed by at least
+one other core developer before pushing. Obvious non-controversial changes will
+be handled more casually.
+
+There is a main development branch ("default") which is generally stable so that
+it can be (and is) used in production. There is also a "stable" branch that is
+almost exclusively reserved for bug fixes or trivial changes. Experimental
+changes should live elsewhere (for example in a pull request) until they are
+ready.
+
+.. _coding-guidelines:
+
+
+Coding guidelines
+-----------------
+
 We don't have a formal coding/formatting standard. We are currently using a mix
 of Mercurial's (https://www.mercurial-scm.org/wiki/CodingStyle), pep8, and
-consistency with existing code. Run whitespacecleanup.sh to avoid stupid
-whitespace noise in your patches.
+consistency with existing code. Run ``scripts/run-all-cleanup`` before
+committing to ensure some basic code formatting consistency.
 
 We support both Python 2.6.x and 2.7.x and nothing else. For now we don't care
 about Python 3 compatibility.
@@ -112,30 +229,66 b' page titles, button labels, headers, and'
 
 .. _English title case: https://en.wikipedia.org/wiki/Capitalization#Title_case
 
-Contributions will be accepted in most formats -- such as pull requests on
-bitbucket, something hosted on your own Kallithea instance, or patches sent by
-email to the `kallithea-general`_ mailing list.
+Template helpers (that is, everything in ``kallithea.lib.helpers``)
+should only be referenced from templates. If you need to call a
+helper from the Python code, consider moving the function somewhere
+else (e.g. to the model).
+
+Notes on the SQLAlchemy session
+^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+Each HTTP request runs inside an independent SQLAlchemy session (as well
+as in an independent database transaction). ``Session`` is the session manager
+and factory. ``Session()`` will create a new session on-demand or return the
+current session for the active thread. Many database operations are methods on
+such session instances - only ``Session.remove()`` should be called directly on
+the manager.
 
-Make sure to test your changes both manually and with the automatic tests
-before posting.
+Database model objects
+(almost) always belong to a particular SQLAlchemy session, which means
+that SQLAlchemy will ensure that they're kept in sync with the database
+(but also means that they cannot be shared across requests).
 
-We care about quality and review and keeping a clean repository history. We
-might give feedback that requests polishing contributions until they are
-"perfect". We might also rebase and collapse and make minor adjustments to your
-changes when we apply them.
+Objects can be added to the session using ``Session().add``, but this is
+rarely needed:
+
+* When creating a database object by calling the constructor directly,
+  it must explicitly be added to the session.
+
+* When creating an object using a factory function (like
+  ``create_repo``), the returned object has already (by convention)
+  been added to the session, and should not be added again.
 
-We try to make sure we have consensus on the direction the project is taking.
-Everything non-sensitive should be discussed in public -- preferably on the
-mailing list.  We aim at having all non-trivial changes reviewed by at least
-one other core developer before pushing. Obvious non-controversial changes will
-be handled more casually.
+* When getting an object from the session (via ``Session().query`` or
+  any of the utility functions that look up objects in the database),
+  it's already part of the session, and should not be added again.
+  SQLAlchemy monitors attribute modifications automatically for all
+  objects it knows about and syncs them to the database.
+
+SQLAlchemy also flushes changes to the database automatically; manually
+calling ``Session().flush`` is usually only necessary when the Python
+code needs the database to assign an "auto-increment" primary key ID to
+a freshly created model object (before flushing, the ID attribute will
+be ``None``).
+
+TurboGears2 DebugBar
+^^^^^^^^^^^^^^^^^^^^
 
-For now we just have one official branch ("default") and will keep it so stable
-that it can be (and is) used in production. Experimental changes should live
-elsewhere (for example in a pull request) until they are ready.
+It is possible to enable the TurboGears2-provided DebugBar_, a toolbar overlayed
+over the Kallithea web interface, allowing you to see:
+
+* timing information of the current request, including profiling information
+* request data, including GET data, POST data, cookies, headers and environment
+  variables
+* a list of executed database queries, including timing and result values
 
-.. _translations:
-.. include:: ./../kallithea/i18n/how_to
+DebugBar is only activated when ``debug = true`` is set in the configuration
+file. This is important, because the DebugBar toolbar will be visible for all
+users, and allow them to see information they should not be allowed to see. Like
+is anyway the case for ``debug = true``, do not use this in production!
+
+To enable DebugBar, install ``tgext.debugbar`` and ``kajiki`` (typically via
+``pip``) and restart Kallithea (in debug mode).
 
 
 "Roadmap"
@@ -158,3 +311,6 b' Thank you for your contribution!'
 .. _kallithea-general: http://lists.sfconservancy.org/mailman/listinfo/kallithea-general
 .. _Hosted Weblate: https://hosted.weblate.org/projects/kallithea/kallithea/
 .. _wiki: https://bitbucket.org/conservancy/kallithea/wiki/Home
+.. _DebugBar: https://github.com/TurboGears/tgext.debugbar
+.. _Quick Start: https://www.mercurial-scm.org/wiki/QuickStart
+.. _Beginners Guide: https://www.mercurial-scm.org/wiki/BeginnersGuides

docs/index.rst

@@ -4,14 +4,23 b''
 Kallithea Documentation
 #######################
 
-**Readme**
+* :ref:`genindex`
+* :ref:`search`
+
+
+Readme
+******
 
 .. toctree::
    :maxdepth: 1
 
    readme
 
-**Installation**
+
+Administrator guide
+*******************
+
+**Installation and upgrade**
 
 .. toctree::
    :maxdepth: 1
@@ -21,52 +30,53 b' Kallithea Documentation'
    installation_win
    installation_win_old
    installation_iis
+   installation_puppet
+   upgrade
+
+**Setup and configuration**
+
+.. toctree::
+   :maxdepth: 1
+
    setup
-   installation_puppet
+   administrator_guide/auth
+   administrator_guide/vcs_setup
+   usage/email
+   usage/customization
+
+**Maintenance**
 
-**Usage**
+.. toctree::
+   :maxdepth: 1
+
+   usage/backup
+   usage/performance
+   usage/debugging
+   usage/troubleshooting
+
+
+User guide
+**********
 
 .. toctree::
    :maxdepth: 1
 
    usage/general
-   usage/vcs_support
+   usage/vcs_notes
    usage/locking
    usage/statistics
-
-**Administrator's guide**
+   api/api
 
-.. toctree::
-   :maxdepth: 1
 
-   usage/email
-   usage/performance
-   usage/backup
-   usage/debugging
-   usage/troubleshooting
-
-**Development**
+Developer guide
+***************
 
 .. toctree::
    :maxdepth: 1
 
    contributing
-   changelog
-
-**API**
-
-.. toctree::
-   :maxdepth: 1
-
-   api/api
-   api/models
-
-
-Other topics
-------------
-
-* :ref:`genindex`
-* :ref:`search`
+   dev/translation
+   dev/dbmigrations
 
 
 .. _virtualenv: http://pypi.python.org/pypi/virtualenv

docs/installation.rst

@@ -26,6 +26,22 b' The following describes three different '
   have to remove its dependencies manually and make sure that they are not
   needed by other packages.
 
+Regardless of the installation method you may need to make sure you have
+appropriate development packages installed, as installation of some of the
+Kallithea dependencies requires a working C compiler and libffi library
+headers. Depending on your configuration, you may also need to install
+Git and development packages for the database of your choice.
+
+For Debian and Ubuntu, the following command will ensure that a reasonable
+set of dependencies is installed::
+
+    sudo apt-get install build-essential git python-pip python-virtualenv libffi-dev python-dev
+
+For Fedora and RHEL-derivatives, the following command will ensure that a
+reasonable set of dependencies is installed::
+
+    sudo yum install gcc git python-pip python-virtualenv libffi-devel python-devel
+
 .. _installation-source:
 
 
@@ -38,16 +54,13 b' repository, follow the instructions belo'
         hg clone https://kallithea-scm.org/repos/kallithea -u stable
         cd kallithea
         virtualenv ../kallithea-venv
-        source ../kallithea-venv/bin/activate
-        pip install --upgrade pip "setuptools<34"
-        pip install -e .
+        . ../kallithea-venv/bin/activate
+        pip install --upgrade pip setuptools
+        pip install --upgrade -e .
         python2 setup.py compile_catalog   # for translation of the UI
 
 You can now proceed to :ref:`setup`.
 
-To upgrade, simply update the repository with ``hg pull -u`` and restart the
-server.
-
 .. _installation-virtualenv:
 
 
@@ -68,8 +81,8 b' An additional benefit of virtualenv_ is '
 - Activate the virtualenv_ in your current shell session and make sure the
   basic requirements are up-to-date by running::
 
-    source /srv/kallithea/venv/bin/activate
-    pip install --upgrade pip "setuptools<34"
+    . /srv/kallithea/venv/bin/activate
+    pip install --upgrade pip setuptools
 
 .. note:: You can't use UNIX ``sudo`` to source the ``virtualenv`` script; it
    will "activate" a shell that terminates immediately. It is also perfectly
@@ -78,8 +91,8 b' An additional benefit of virtualenv_ is '
 .. note:: Some dependencies are optional. If you need them, install them in
    the virtualenv too::
 
-     pip install psycopg2
-     pip install python-ldap
+     pip install --upgrade psycopg2
+     pip install --upgrade python-ldap
 
    This might require installation of development packages using your
    distribution's package manager.
@@ -91,15 +104,15 b' An additional benefit of virtualenv_ is '
 
 - Go into the created directory and run this command to install Kallithea::
 
-    pip install kallithea
+    pip install --upgrade kallithea
 
   Alternatively, download a .tar.gz from http://pypi.python.org/pypi/Kallithea,
   extract it and run::
 
-    pip install .
+    pip install --upgrade .
 
-- This will install Kallithea together with pylons_ and all other required
-  python libraries into the activated virtualenv.
+- This will install Kallithea together with all other required
+  Python libraries into the activated virtualenv.
 
 You can now proceed to :ref:`setup`.
 
@@ -123,90 +136,4 b' To install as a regular user in ``~/.loc'
 You can now proceed to :ref:`setup`.
 
 
-Upgrading Kallithea from Python Package Index (PyPI)
-----------------------------------------------------
-
-.. note::
-   It is strongly recommended that you **always** perform a database and
-   configuration backup before doing an upgrade.
-
-   These directions will use '{version}' to note that this is the version of
-   Kallithea that these files were used with.  If backing up your Kallithea
-   instance from version 0.1 to 0.2, the ``my.ini`` file could be
-   backed up to ``my.ini.0-1``.
-
-If using a SQLite database, stop the Kallithea process/daemon/service, and
-then make a copy of the database file::
-
- service kallithea stop
- cp kallithea.db kallithea.db.{version}
-
-Back up your configuration file::
-
- cp my.ini my.ini.{version}
-
-Ensure that you are using the Python virtual environment that you originally
-installed Kallithea in by running::
-
- pip freeze
-
-This will list all packages installed in the current environment.  If
-Kallithea isn't listed, activate the correct virtual environment::
-
- source /srv/kallithea/venv/bin/activate
-
-Once you have verified the environment you can upgrade Kallithea with::
-
- pip install --upgrade kallithea
-
-Then run the following command from the installation directory::
-
- paster make-config Kallithea my.ini
-
-This will display any changes made by the new version of Kallithea to your
-current configuration. It will try to perform an automerge. It is recommended
-that you recheck the content after the automerge.
-
-.. note::
-   Please always make sure your .ini files are up to date. Errors can
-   often be caused by missing parameters added in new versions.
-
-It is also recommended that you rebuild the whoosh index after upgrading since
-the new whoosh version could introduce some incompatible index changes. Please
-read the changelog to see if there were any changes to whoosh.
-
-The final step is to upgrade the database. To do this simply run::
-
- paster upgrade-db my.ini
-
-This will upgrade the schema and update some of the defaults in the database,
-and will always recheck the settings of the application, if there are no new
-options that need to be set.
-
-.. note::
-   The DB schema upgrade library has some limitations and can sometimes fail if you try to
-   upgrade from older major releases. In such a case simply run upgrades sequentially, e.g.,
-   upgrading from 0.1.X to 0.3.X should be done like this: 0.1.X. > 0.2.X > 0.3.X
-   You can always specify what version of Kallithea you want to install for example in pip
-   `pip install Kallithea==0.2`
-
-You may find it helpful to clear out your log file so that new errors are
-readily apparent::
-
- echo > kallithea.log
-
-Once that is complete, you may now start your upgraded Kallithea Instance::
-
- service kallithea start
-
-Or::
-
- paster serve /srv/kallithea/my.ini
-
-.. note::
-   If you're using Celery, make sure you restart all instances of it after
-   upgrade.
-
-
 .. _virtualenv: http://pypi.python.org/pypi/virtualenv
-.. _pylons: http://www.pylonsproject.org/

docs/installation_iis.rst

@@ -39,7 +39,7 b' will be served from the root of its own '
 own virtual folder will be noted where appropriate.
 
 Application pool
-................
+^^^^^^^^^^^^^^^^
 
 Make sure that there is a unique application pool for the Kallithea application
 with an identity that has read access to the Kallithea distribution.
@@ -55,11 +55,11 b' to run on the website and neither will K'
     as long as the Kallithea requirements are met by the existing pool.
 
 ISAPI handler
-.............
+^^^^^^^^^^^^^
 
 The ISAPI handler can be generated using::
 
-    paster install-iis my.ini --virtualdir=/
+    kallithea-cli iis-install -c my.ini --virtualdir=/
 
 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
@@ -74,12 +74,12 b' This accomplishes two things: generating'
 
 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
-the ISAPI handler, it will start a thread pool managed wrapper around the paster
+the ISAPI handler, it will start a thread pool managed wrapper around the
 middleware WSGI handler that Kallithea runs within and each HTTP request to the
 site will be processed through this logic henceforth.
 
 Authentication with Kallithea using IIS authentication modules
-..............................................................
+^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 The recommended way to handle authentication with Kallithea using IIS is to let
 IIS handle all the authentication and just pass it to Kallithea.
@@ -111,7 +111,7 b' Troubleshooting'
 ---------------
 
 Typically, any issues in this setup will either be entirely in IIS or entirely
-in Kallithea (or Kallithea's WSGI/paster middleware). Consequently, two
+in Kallithea (or Kallithea's WSGI middleware). Consequently, two
 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``.

docs/installation_puppet.rst

@@ -90,7 +90,7 b' customizing the setup process. You have '
 parameter in the :ref:`example above <simple_manifest>`, but there are more.
 For example, you can specify the installation directory, the name of the user
 under which Kallithea gets installed, the initial admin password, etc.
-Notably, you can provide arbitrary modifications to Kallitheas configuration
+Notably, you can provide arbitrary modifications to Kallithea's configuration
 file by means of the ``config_hash`` parameter.
 
 Parameters, which have not been set explicitly, will be set to default values,

docs/installation_win.rst

@@ -1,12 +1,12 b''
 .. _installation_win:
 
-================================================================
-Installation and upgrade on Windows (7/Server 2008 R2 and newer)
-================================================================
+====================================================
+Installation on Windows (7/Server 2008 R2 and newer)
+====================================================
 
 
 First time install
-::::::::::::::::::
+------------------
 
 Target OS: Windows 7 and newer or Windows Server 2008 R2 and newer
 
@@ -15,7 +15,7 b' Tested on Windows 8.1, Windows Server 20'
 To install on an older version of Windows, see `<installation_win_old.html>`_
 
 Step 1 -- Install Python
-------------------------
+^^^^^^^^^^^^^^^^^^^^^^^^
 
 Install Python 2.x.y (x = 6 or 7). Latest version is recommended. If you need another version, they can run side by side.
 
@@ -31,7 +31,7 b' Remember the specific major and minor ve'
 be needed in the next step. In this case, it is "2.7".
 
 Step 2 -- Python BIN
---------------------
+^^^^^^^^^^^^^^^^^^^^
 
 Add Python BIN folder to the path. This can be done manually (editing
 "PATH" environment variable) or by using Windows Support Tools that
@@ -45,7 +45,7 b' Please substitute [your-python-path] wit'
 path. Typically this is ``C:\\Python27``.
 
 Step 3 -- Install pywin32 extensions
-------------------------------------
+^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 Download pywin32 from:
 http://sourceforge.net/projects/pywin32/files/
@@ -61,7 +61,7 b' http://sourceforge.net/projects/pywin32/'
   (Win32)
 
 Step 4 -- Install pip
----------------------
+^^^^^^^^^^^^^^^^^^^^^
 
 pip is a package management system for Python. You will need it to install Kallithea and its dependencies.
 
@@ -85,7 +85,7 b' open a CMD and type::'
   SETX PATH "%PATH%;[your-python-path]\Scripts" /M
 
 Step 5 -- Kallithea folder structure
-------------------------------------
+^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 Create a Kallithea folder structure.
 
@@ -102,7 +102,7 b' Create the following folder structure::'
   C:\Kallithea\Repos
 
 Step 6 -- Install virtualenv
-----------------------------
+^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 .. note::
    A python virtual environment will allow for isolation between the Python packages of your system and those used for Kallithea.
@@ -119,7 +119,7 b' To create a virtual environment, run::'
   virtualenv C:\Kallithea\Env
 
 Step 7 -- Install Kallithea
----------------------------
+^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 In order to install Kallithea, you need to be able to run "pip install kallithea". It will use pip to install the Kallithea Python package and its dependencies.
 Some Python packages use managed code and need to be compiled.
@@ -134,7 +134,7 b' In a command prompt type (adapting paths'
 
   cd C:\Kallithea\Env\Scripts
   activate
-  pip install --upgrade pip "setuptools<34"
+  pip install --upgrade pip setuptools
 
 The prompt will change into "(Env) C:\\Kallithea\\Env\\Scripts" or similar
 (depending of your folder structure). Then type::
@@ -145,17 +145,19 b' The prompt will change into "(Env) C:\\\\K'
           complete. Some warnings will appear. Don't worry, they are
           normal.
 
-Step 8 -- Install git (optional)
---------------------------------
+Step 8 -- Install Git (optional)
+^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+Mercurial being a python package, was installed automatically when doing ``pip install kallithea``.
 
-Mercurial being a python package, it was installed automatically when doing "pip install kallithea".
-
-You need to install git manually if you want Kallithea to be able to host git repositories.
-
+You need to install Git manually if you want Kallithea to be able to host Git repositories.
 See http://git-scm.com/book/en/v2/Getting-Started-Installing-Git#Installing-on-Windows for instructions.
+The location of the Git binaries (like ``c:\path\to\git\bin``) must be
+added to the ``PATH`` environment variable so ``git.exe`` and other tools like
+``gzip.exe`` are available.
 
 Step 9 -- Configuring Kallithea
--------------------------------
+^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 Steps taken from `<setup.html>`_
 
@@ -164,9 +166,9 b' it, reopen it following the same command'
 one). When ready, type::
 
   cd C:\Kallithea\Bin
-  paster make-config Kallithea production.ini
+  kallithea-cli config-create my.ini
 
-Then you must edit production.ini to fit your needs (IP address, IP
+Then you must edit my.ini to fit your needs (IP address, IP
 port, mail settings, database, etc.). `NotePad++`__ or a similar text
 editor is recommended to properly handle the newline character
 differences between Unix and Windows.
@@ -175,11 +177,11 b' differences between Unix and Windows.'
 
 For the sake of simplicity, run it with the default settings. After your edits (if any) in the previous command prompt, type::
 
-  paster setup-db production.ini
+  kallithea-cli db-create -c my.ini
 
 .. warning:: This time a *new* database will be installed. You must
-             follow a different step to later *upgrade* to a newer
-             Kallithea version)
+             follow a different process to later :ref:`upgrade <upgrade>`
+             to a newer Kallithea version.
 
 The script will ask you for confirmation about creating a new database, answer yes (y)
 
@@ -191,14 +193,14 b' The script will ask you for admin mail, '
 
 If you make a mistake and the script doesn't end, don't worry: start it again.
 
-If you decided not to install git, you will get errors about it that you can ignore.
+If you decided not to install Git, you will get errors about it that you can ignore.
 
 Step 10 -- Running Kallithea
-----------------------------
+^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 In the previous command prompt, being in the C:\\Kallithea\\Bin folder, type::
 
-  paster serve production.ini
+  gearbox serve -c my.ini
 
 Open your web server, and go to http://127.0.0.1:5000
 
@@ -219,27 +221,3 b' What this guide does not cover:'
 - Using Apache. You can investigate here:
 
   - https://groups.google.com/group/rhodecode/msg/c433074e813ffdc4
-
-
-Upgrading
-:::::::::
-
-Stop running Kallithea
-Open a CommandPrompt like in Step 7 (cd to C:\Kallithea\Env\Scripts and activate) and type::
-
-  pip install kallithea --upgrade
-  cd \Kallithea\Bin
-
-Backup your production.ini file now.
-
-Then run::
-
-  paster make-config Kallithea production.ini
-
-Look for changes and update your production.ini accordingly.
-
-Next, update the database::
-
-  paster upgrade-db production.ini
-
-More details can be found in `<upgrade.html>`_.

docs/installation_win_old.rst

@@ -1,12 +1,12 b''
 .. _installation_win_old:
 
-======================================================================
-Installation and upgrade on Windows (XP/Vista/Server 2003/Server 2008)
-======================================================================
+==========================================================
+Installation on Windows (XP/Vista/Server 2003/Server 2008)
+==========================================================
 
 
 First-time install
-::::::::::::::::::
+------------------
 
 Target OS: Windows XP SP3 32-bit English (Clean installation)
 + All Windows Updates until 24-may-2012
@@ -24,7 +24,7 b' Target OS: Windows XP SP3 32-bit English'
    - http://bugs.python.org/issue7511
 
 Step 1 -- Install Visual Studio 2008 Express
---------------------------------------------
+^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 Optional: You can also install MinGW, but VS2008 installation is easier.
 
@@ -58,7 +58,7 b' choose "Visual C++ 2008 Express" when in'
    Copy C:\Program Files (x86)\Microsoft Visual Studio 9.0\VC\bin\vcvars64.bat to C:\Program Files (x86)\Microsoft Visual Studio 9.0\VC\bin\amd64\vcvarsamd64.bat
 
 Step 2 -- Install Python
-------------------------
+^^^^^^^^^^^^^^^^^^^^^^^^
 
 Install Python 2.x.y (x = 6 or 7) x86 version (32-bit). DO NOT USE A 3.x version.
 Download Python 2.x.y from:
@@ -74,7 +74,7 b' be needed in the next step. In this case'
    64-bit: Just download and install the 64-bit version of python.
 
 Step 3 -- Install Win32py extensions
-------------------------------------
+^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 Download pywin32 from:
 http://sourceforge.net/projects/pywin32/files/
@@ -93,7 +93,7 b' http://sourceforge.net/projects/pywin32/'
      http://sourceforge.net/projects/pywin32/files/pywin32/Build%20218/pywin32-218.win-amd64-py2.7.exe/download
 
 Step 4 -- Python BIN
---------------------
+^^^^^^^^^^^^^^^^^^^^
 
 Add Python BIN folder to the path
 
@@ -120,7 +120,7 b' that came preinstalled in Vista/7 and ca'
   Typically: C:\\Python27
 
 Step 5 -- Kallithea folder structure
-------------------------------------
+^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 Create a Kallithea folder structure
 
@@ -137,7 +137,7 b' Create the following folder structure::'
   C:\Kallithea\Repos
 
 Step 6 -- Install virtualenv
-----------------------------
+^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 Install Virtual Env for Python
 
@@ -157,7 +157,7 b' where you downloaded "virtualenv.py", an'
 to include it)
 
 Step 7 -- Install Kallithea
----------------------------
+^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 Finally, install Kallithea
 
@@ -183,7 +183,7 b' In that CMD (loaded with VS2008 PATHs) t'
 
   cd C:\Kallithea\Env\Scripts (or similar)
   activate
-  pip install --upgrade pip "setuptools<34"
+  pip install --upgrade pip setuptools
 
 The prompt will change into "(Env) C:\\Kallithea\\Env\\Scripts" or similar
 (depending of your folder structure). Then type::
@@ -195,7 +195,7 b' The prompt will change into "(Env) C:\\\\K'
 Some warnings will appear, don't worry as they are normal.
 
 Step 8 -- Configuring Kallithea
--------------------------------
+^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 steps taken from http://packages.python.org/Kallithea/setup.html
 
@@ -204,9 +204,9 b' if you closed it reopen it following the'
 "activate" one). When ready, just type::
 
   cd C:\Kallithea\Bin
-  paster make-config Kallithea production.ini
+  kallithea-cli config-create my.ini
 
-Then, you must edit production.ini to fit your needs (network address and
+Then, you must edit my.ini to fit your needs (network address and
 port, mail settings, database, whatever). I recommend using NotePad++
 (free) or similar text editor, as it handles well the EndOfLine
 character differences between Unix and Windows
@@ -215,10 +215,11 b' character differences between Unix and W'
 For the sake of simplicity lets run it with the default settings. After
 your edits (if any), in the previous Command Prompt, type::
 
- paster setup-db production.ini
+  kallithea-cli db-create -c my.ini
 
-(this time a NEW database will be installed, you must follow a different
-step to later UPGRADE to a newer Kallithea version)
+.. warning:: This time a *new* database will be installed. You must
+             follow a different process to later :ref:`upgrade <upgrade>`
+             to a newer Kallithea version.
 
 The script will ask you for confirmation about creating a NEW database,
 answer yes (y)
@@ -233,12 +234,12 b' If you make some mistake and the script '
 it again.
 
 Step 9 -- Running Kallithea
----------------------------
+^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 In the previous command prompt, being in the C:\\Kallithea\\Bin folder,
 just type::
 
- paster serve production.ini
+ gearbox serve -c my.ini
 
 Open yout web server, and go to http://127.0.0.1:5000
 
@@ -260,23 +261,3 b' What this Guide does not cover:'
 - Using Apache. You can investigate here:
 
   - https://groups.google.com/group/rhodecode/msg/c433074e813ffdc4
-
-
-Upgrading
-:::::::::
-
-Stop running Kallithea
-Open a CommandPrompt like in Step7 (VS2008 path + activate) and type::
-
- easy_install -U kallithea
- cd \Kallithea\Bin
-
-{ backup your production.ini file now} ::
-
- paster make-config Kallithea production.ini
-
-(check changes and update your production.ini accordingly) ::
-
- paster upgrade-db production.ini (update database)
-
-Full steps in http://packages.python.org/Kallithea/upgrade.html

docs/make.bat

@@ -3,153 +3,153 b''
 REM Command file for Sphinx documentation
 
 if "%SPHINXBUILD%" == "" (
-	set SPHINXBUILD=sphinx-build
+    set SPHINXBUILD=sphinx-build
 )
 set BUILDDIR=_build
 set ALLSPHINXOPTS=-d %BUILDDIR%/doctrees %SPHINXOPTS% .
 if NOT "%PAPER%" == "" (
-	set ALLSPHINXOPTS=-D latex_paper_size=%PAPER% %ALLSPHINXOPTS%
+    set ALLSPHINXOPTS=-D latex_paper_size=%PAPER% %ALLSPHINXOPTS%
 )
 
 if "%1" == "" goto help
 
 if "%1" == "help" (
-	:help
-	echo.Please use `make ^<target^>` where ^<target^> is one of
-	echo.  html       to make standalone HTML files
-	echo.  dirhtml    to make HTML files named index.html in directories
-	echo.  singlehtml to make a single large HTML file
-	echo.  pickle     to make pickle files
-	echo.  json       to make JSON files
-	echo.  htmlhelp   to make HTML files and a HTML help project
-	echo.  qthelp     to make HTML files and a qthelp project
-	echo.  devhelp    to make HTML files and a Devhelp project
-	echo.  epub       to make an epub
-	echo.  latex      to make LaTeX files, you can set PAPER=a4 or PAPER=letter
-	echo.  text       to make text files
-	echo.  man        to make manual pages
-	echo.  changes    to make an overview over all changed/added/deprecated items
-	echo.  linkcheck  to check all external links for integrity
-	echo.  doctest    to run all doctests embedded in the documentation if enabled
-	goto end
+    :help
+    echo.Please use `make ^<target^>` where ^<target^> is one of
+    echo.  html       to make standalone HTML files
+    echo.  dirhtml    to make HTML files named index.html in directories
+    echo.  singlehtml to make a single large HTML file
+    echo.  pickle     to make pickle files
+    echo.  json       to make JSON files
+    echo.  htmlhelp   to make HTML files and a HTML help project
+    echo.  qthelp     to make HTML files and a qthelp project
+    echo.  devhelp    to make HTML files and a Devhelp project
+    echo.  epub       to make an epub
+    echo.  latex      to make LaTeX files, you can set PAPER=a4 or PAPER=letter
+    echo.  text       to make text files
+    echo.  man        to make manual pages
+    echo.  changes    to make an overview over all changed/added/deprecated items
+    echo.  linkcheck  to check all external links for integrity
+    echo.  doctest    to run all doctests embedded in the documentation if enabled
+    goto end
 )
 
 if "%1" == "clean" (
-	for /d %%i in (%BUILDDIR%\*) do rmdir /q /s %%i
-	del /q /s %BUILDDIR%\*
-	goto end
+    for /d %%i in (%BUILDDIR%\*) do rmdir /q /s %%i
+    del /q /s %BUILDDIR%\*
+    goto end
 )
 
 if "%1" == "html" (
-	%SPHINXBUILD% -b html %ALLSPHINXOPTS% %BUILDDIR%/html
-	echo.
-	echo.Build finished. The HTML pages are in %BUILDDIR%/html.
-	goto end
+    %SPHINXBUILD% -b html %ALLSPHINXOPTS% %BUILDDIR%/html
+    echo.
+    echo.Build finished. The HTML pages are in %BUILDDIR%/html.
+    goto end
 )
 
 if "%1" == "dirhtml" (
-	%SPHINXBUILD% -b dirhtml %ALLSPHINXOPTS% %BUILDDIR%/dirhtml
-	echo.
-	echo.Build finished. The HTML pages are in %BUILDDIR%/dirhtml.
-	goto end
+    %SPHINXBUILD% -b dirhtml %ALLSPHINXOPTS% %BUILDDIR%/dirhtml
+    echo.
+    echo.Build finished. The HTML pages are in %BUILDDIR%/dirhtml.
+    goto end
 )
 
 if "%1" == "singlehtml" (
-	%SPHINXBUILD% -b singlehtml %ALLSPHINXOPTS% %BUILDDIR%/singlehtml
-	echo.
-	echo.Build finished. The HTML pages are in %BUILDDIR%/singlehtml.
-	goto end
+    %SPHINXBUILD% -b singlehtml %ALLSPHINXOPTS% %BUILDDIR%/singlehtml
+    echo.
+    echo.Build finished. The HTML pages are in %BUILDDIR%/singlehtml.
+    goto end
 )
 
 if "%1" == "pickle" (
-	%SPHINXBUILD% -b pickle %ALLSPHINXOPTS% %BUILDDIR%/pickle
-	echo.
-	echo.Build finished; now you can process the pickle files.
-	goto end
+    %SPHINXBUILD% -b pickle %ALLSPHINXOPTS% %BUILDDIR%/pickle
+    echo.
+    echo.Build finished; now you can process the pickle files.
+    goto end
 )
 
 if "%1" == "json" (
-	%SPHINXBUILD% -b json %ALLSPHINXOPTS% %BUILDDIR%/json
-	echo.
-	echo.Build finished; now you can process the JSON files.
-	goto end
+    %SPHINXBUILD% -b json %ALLSPHINXOPTS% %BUILDDIR%/json
+    echo.
+    echo.Build finished; now you can process the JSON files.
+    goto end
 )
 
 if "%1" == "htmlhelp" (
-	%SPHINXBUILD% -b htmlhelp %ALLSPHINXOPTS% %BUILDDIR%/htmlhelp
-	echo.
-	echo.Build finished; now you can run HTML Help Workshop with the ^
+    %SPHINXBUILD% -b htmlhelp %ALLSPHINXOPTS% %BUILDDIR%/htmlhelp
+    echo.
+    echo.Build finished; now you can run HTML Help Workshop with the ^
 .hhp project file in %BUILDDIR%/htmlhelp.
-	goto end
+    goto end
 )
 
 if "%1" == "qthelp" (
-	%SPHINXBUILD% -b qthelp %ALLSPHINXOPTS% %BUILDDIR%/qthelp
-	echo.
-	echo.Build finished; now you can run "qcollectiongenerator" with the ^
+    %SPHINXBUILD% -b qthelp %ALLSPHINXOPTS% %BUILDDIR%/qthelp
+    echo.
+    echo.Build finished; now you can run "qcollectiongenerator" with the ^
 .qhcp project file in %BUILDDIR%/qthelp, like this:
-	echo.^> qcollectiongenerator %BUILDDIR%\qthelp\Kallithea.qhcp
-	echo.To view the help file:
-	echo.^> assistant -collectionFile %BUILDDIR%\qthelp\Kallithea.ghc
-	goto end
+    echo.^> qcollectiongenerator %BUILDDIR%\qthelp\Kallithea.qhcp
+    echo.To view the help file:
+    echo.^> assistant -collectionFile %BUILDDIR%\qthelp\Kallithea.ghc
+    goto end
 )
 
 if "%1" == "devhelp" (
-	%SPHINXBUILD% -b devhelp %ALLSPHINXOPTS% %BUILDDIR%/devhelp
-	echo.
-	echo.Build finished.
-	goto end
+    %SPHINXBUILD% -b devhelp %ALLSPHINXOPTS% %BUILDDIR%/devhelp
+    echo.
+    echo.Build finished.
+    goto end
 )
 
 if "%1" == "epub" (
-	%SPHINXBUILD% -b epub %ALLSPHINXOPTS% %BUILDDIR%/epub
-	echo.
-	echo.Build finished. The epub file is in %BUILDDIR%/epub.
-	goto end
+    %SPHINXBUILD% -b epub %ALLSPHINXOPTS% %BUILDDIR%/epub
+    echo.
+    echo.Build finished. The epub file is in %BUILDDIR%/epub.
+    goto end
 )
 
 if "%1" == "latex" (
-	%SPHINXBUILD% -b latex %ALLSPHINXOPTS% %BUILDDIR%/latex
-	echo.
-	echo.Build finished; the LaTeX files are in %BUILDDIR%/latex.
-	goto end
+    %SPHINXBUILD% -b latex %ALLSPHINXOPTS% %BUILDDIR%/latex
+    echo.
+    echo.Build finished; the LaTeX files are in %BUILDDIR%/latex.
+    goto end
 )
 
 if "%1" == "text" (
-	%SPHINXBUILD% -b text %ALLSPHINXOPTS% %BUILDDIR%/text
-	echo.
-	echo.Build finished. The text files are in %BUILDDIR%/text.
-	goto end
+    %SPHINXBUILD% -b text %ALLSPHINXOPTS% %BUILDDIR%/text
+    echo.
+    echo.Build finished. The text files are in %BUILDDIR%/text.
+    goto end
 )
 
 if "%1" == "man" (
-	%SPHINXBUILD% -b man %ALLSPHINXOPTS% %BUILDDIR%/man
-	echo.
-	echo.Build finished. The manual pages are in %BUILDDIR%/man.
-	goto end
+    %SPHINXBUILD% -b man %ALLSPHINXOPTS% %BUILDDIR%/man
+    echo.
+    echo.Build finished. The manual pages are in %BUILDDIR%/man.
+    goto end
 )
 
 if "%1" == "changes" (
-	%SPHINXBUILD% -b changes %ALLSPHINXOPTS% %BUILDDIR%/changes
-	echo.
-	echo.The overview file is in %BUILDDIR%/changes.
-	goto end
+    %SPHINXBUILD% -b changes %ALLSPHINXOPTS% %BUILDDIR%/changes
+    echo.
+    echo.The overview file is in %BUILDDIR%/changes.
+    goto end
 )
 
 if "%1" == "linkcheck" (
-	%SPHINXBUILD% -b linkcheck %ALLSPHINXOPTS% %BUILDDIR%/linkcheck
-	echo.
-	echo.Link check complete; look for any errors in the above output ^
+    %SPHINXBUILD% -b linkcheck %ALLSPHINXOPTS% %BUILDDIR%/linkcheck
+    echo.
+    echo.Link check complete; look for any errors in the above output ^
 or in %BUILDDIR%/linkcheck/output.txt.
-	goto end
+    goto end
 )
 
 if "%1" == "doctest" (
-	%SPHINXBUILD% -b doctest %ALLSPHINXOPTS% %BUILDDIR%/doctest
-	echo.
-	echo.Testing of doctests in the sources finished, look at the ^
+    %SPHINXBUILD% -b doctest %ALLSPHINXOPTS% %BUILDDIR%/doctest
+    echo.
+    echo.Testing of doctests in the sources finished, look at the ^
 results in %BUILDDIR%/doctest/output.txt.
-	goto end
+    goto end
 )
 
 :end

docs/overview.rst

@@ -69,6 +69,11 b' installed.'
   (``pip install kallithea`` from a source tree will do pretty much the same
   but build the Kallithea package itself locally instead of downloading it.)
 
+.. note::
+   Kallithea includes front-end code that needs to be processed first.
+   The tool npm_ is used to download external dependencies and orchestrate the
+   processing. The ``npm`` binary must thus be available.
+
 
 Web server
 ----------
@@ -84,17 +89,17 b' to use web server authentication.'
 
 There are several web server options:
 
-- Kallithea uses the Paste_ tool as command line interface. Paste provides
-  ``paster serve`` as a convenient way to launch a Python WSGI / web server
+- Kallithea uses the Gearbox_ tool as command line interface. Gearbox provides
+  ``gearbox serve`` as a convenient way to launch a Python WSGI / web server
   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.
 
-  Paste comes with its own built-in web server but Kallithea defaults to use
+  Gearbox comes with its own built-in web server but Kallithea defaults to use
   Waitress_. Gunicorn_ is also an option. These web servers have different
   limited feature sets.
 
-  The web server used by ``paster`` is configured in the ``.ini`` file passed
+  The web server used by ``gearbox`` is configured in the ``.ini`` file passed
   to it. The entry point for the WSGI application is configured
   in ``setup.py`` as ``kallithea.config.middleware:make_app``.
 
@@ -113,7 +118,7 b' There are several web server options:'
   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
-  of a ``paster`` server that somehow is wrapped as a service.
+  of a ``gearbox serve`` that somehow is wrapped as a service.
 
 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
@@ -126,7 +131,7 b' continuous hammering from the internet.'
 .. _Gunicorn: http://gunicorn.org/
 .. _Waitress: http://waitress.readthedocs.org/en/latest/
 .. _virtualenv: http://pypi.python.org/pypi/virtualenv
-.. _Paste: http://pythonpaste.org/
+.. _Gearbox: http://turbogears.readthedocs.io/en/latest/turbogears/gearbox.html
 .. _PyPI: https://pypi.python.org/pypi
 .. _Apache httpd: http://httpd.apache.org/
 .. _mod_wsgi: https://code.google.com/p/modwsgi/
@@ -136,6 +141,6 b' continuous hammering from the internet.'
 .. _iis: http://en.wikipedia.org/wiki/Internet_Information_Services
 .. _pip: http://en.wikipedia.org/wiki/Pip_%28package_manager%29
 .. _WSGI: http://en.wikipedia.org/wiki/Web_Server_Gateway_Interface
-.. _pylons: http://www.pylonsproject.org/
 .. _HAProxy: http://www.haproxy.org/
 .. _Varnish: https://www.varnish-cache.org/
+.. _npm: https://www.npmjs.com/

docs/setup.rst

@@ -11,12 +11,14 b' Setting up Kallithea'
 First, you will need to create a Kallithea configuration file. Run the
 following command to do so::
 
-    paster make-config Kallithea my.ini
+    kallithea-cli config-create my.ini
 
 This will create the file ``my.ini`` in the current directory. This
 configuration file contains the various settings for Kallithea, e.g.
 proxy port, email settings, usage of static files, cache, Celery
-settings, and logging.
+settings, and logging. Extra settings can be specified like::
+
+    kallithea-cli config-create my.ini host=8.8.8.8 "[handler_console]" formatter=color_formatter
 
 Next, you need to create the databases used by Kallithea. It is recommended to
 use PostgreSQL or SQLite (default). If you choose a database other than the
@@ -25,20 +27,20 b' configuration file to use this other dat'
 PostgreSQL, SQLite and MySQL databases. Create the database by running
 the following command::
 
-    paster setup-db my.ini
+    kallithea-cli db-create -c my.ini
 
 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
-entering this "root" path ``setup-db`` will also prompt you for a username
-and password for the initial admin account which ``setup-db`` sets
+entering this "root" path ``db-create`` will also prompt you for a username
+and password for the initial admin account which ``db-create`` sets
 up for you.
 
-The ``setup-db`` values can also be given on the command line.
+The ``db-create`` values can also be given on the command line.
 Example::
 
-    paster setup-db my.ini --user=nn --password=secret --email=[e-mail] --repos=/srv/repos
+    kallithea-cli db-create -c my.ini --user=nn --password=secret --email=[e-mail] --repos=/srv/repos
 
-The ``setup-db`` command will create all needed tables and an
+The ``db-create`` command will create all needed tables and an
 admin account. When choosing a root path you can either use a new
 empty location, or a location which already contains existing
 repositories. If you choose a location which contains existing
@@ -52,14 +54,18 b' path to the root).'
           but when trying to do a push it will fail with permission
           denied errors unless it has write access.
 
+Finally, prepare the front-end by running::
+
+    kallithea-cli front-end-build
+
 You are now ready to use Kallithea. To run it simply execute::
 
-    paster serve my.ini
+    gearbox serve -c my.ini
 
 - 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
   configuration file created in the previous step.
-- Log in to Kallithea using the admin account created when running ``setup-db``.
+- Log in to Kallithea using the admin account created when running ``db-create``.
 - The default permissions on each repository is read, and the owner is admin.
   Remember to update these if needed.
 - In the admin panel you can toggle LDAP, anonymous, and permissions
@@ -67,22 +73,20 b' You are now ready to use Kallithea. To r'
   repositories.
 
 
-Extensions
-----------
-
-Optionally one can create an ``rcextensions`` package that extends Kallithea
-functionality.
-To generate a skeleton extensions package, run::
+Internationalization (i18n support)
+-----------------------------------
 
-    paster make-rcext my.ini
+The Kallithea web interface is automatically displayed in the user's preferred
+language, as indicated by the browser. Thus, different users may see the
+application in different languages. If the requested language is not available
+(because the translation file for that language does not yet exist or is
+incomplete), the language specified in setting ``i18n.lang`` in the Kallithea
+configuration file is used as fallback. If no fallback language is explicitly
+specified, English is used.
 
-This will create an ``rcextensions`` package next to the specified ``ini`` file.
-With ``rcextensions`` it's possible to add additional mapping for whoosh,
-stats and add additional code into the push/pull/create/delete repo hooks,
-for example for sending signals to build-bots such as Jenkins.
-
-See the ``__init__.py`` file inside the generated ``rcextensions`` package
-for more details.
+If you want to disable automatic language detection and instead configure a
+fixed language regardless of user preference, set ``i18n.enabled = false`` and
+set ``i18n.lang`` to the desired language (or leave empty for English).
 
 
 Using Kallithea with SSH
@@ -129,23 +133,23 b' Kallithea provides full text search of r'
 
 For an incremental index build, run::
 
-    paster make-index my.ini
+    kallithea-cli index-create -c my.ini
 
 For a full index rebuild, run::
 
-    paster make-index my.ini -f
+    kallithea-cli index-create -c my.ini --full
 
-The ``--repo-location`` option allows the location of the repositories to be overriden;
+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::
 
-    paster make-index my.ini --index-only=vcs,kallithea
+    kallithea-cli index-create -c my.ini --index-only=vcs,kallithea
 
 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::
 
-    0  3  *  *  *  /path/to/virtualenv/bin/paster make-index /path/to/kallithea/my.ini
+    0  3  *  *  *  /path/to/virtualenv/bin/kallithea-cli index-create -c /path/to/kallithea/my.ini
 
 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
@@ -155,321 +159,75 b' from index.'
 If you want to rebuild the index from scratch, you can use the ``-f`` flag as above,
 or in the admin panel you can check the "build from scratch" checkbox.
 
-.. _ldap-setup:
-
-Setting up LDAP support
------------------------
-
-Kallithea supports LDAP authentication. In order
-to use LDAP, you have to install the python-ldap_ package. This package is
-available via PyPI, so you can install it by running::
-
-    pip install python-ldap
-
-.. note:: ``python-ldap`` requires some libraries to be installed on
-          your system, so before installing it check that you have at
-          least the ``openldap`` and ``sasl`` libraries.
-
-Choose *Admin > Authentication*, click the ``kallithea.lib.auth_modules.auth_ldap`` button
-and then *Save*, to enable the LDAP plugin and configure its settings.
-
-Here's a typical LDAP setup::
-
- Connection settings
- Enable LDAP          = checked
- Host                 = host.example.com
- Port                 = 389
- Account              = <account>
- Password             = <password>
- Connection Security  = LDAPS connection
- Certificate Checks   = DEMAND
-
- Search settings
- Base DN              = CN=users,DC=host,DC=example,DC=org
- LDAP Filter          = (&(objectClass=user)(!(objectClass=computer)))
- LDAP Search Scope    = SUBTREE
-
- Attribute mappings
- Login Attribute      = uid
- First Name Attribute = firstName
- Last Name Attribute  = lastName
- Email Attribute      = mail
-
-If your user groups are placed in an Organisation Unit (OU) structure, the Search Settings configuration differs::
-
- Search settings
- Base DN              = DC=host,DC=example,DC=org
- LDAP Filter          = (&(memberOf=CN=your user group,OU=subunit,OU=unit,DC=host,DC=example,DC=org)(objectClass=user))
- LDAP Search Scope    = SUBTREE
-
-.. _enable_ldap:
-
-Enable LDAP : required
-    Whether to use LDAP for authenticating users.
-
-.. _ldap_host:
-
-Host : required
-    LDAP server hostname or IP address. Can be also a comma separated
-    list of servers to support LDAP fail-over.
-
-.. _Port:
-
-Port : required
-    389 for un-encrypted LDAP, 636 for SSL-encrypted LDAP.
-
-.. _ldap_account:
-
-Account : optional
-    Only required if the LDAP server does not allow anonymous browsing of
-    records.  This should be a special account for record browsing.  This
-    will require `LDAP Password`_ below.
-
-.. _LDAP Password:
-
-Password : optional
-    Only required if the LDAP server does not allow anonymous browsing of
-    records.
-
-.. _Enable LDAPS:
-
-Connection Security : required
-    Defines the connection to LDAP server
-
-    No encryption
-        Plain non encrypted connection
-
-    LDAPS connection
-        Enable LDAPS connections. It will likely require `Port`_ to be set to
-        a different value (standard LDAPS port is 636). When LDAPS is enabled
-        then `Certificate Checks`_ is required.
-
-    START_TLS on LDAP connection
-        START TLS connection
-
-.. _Certificate Checks:
-
-Certificate Checks : optional
-    How SSL certificates verification is handled -- this is only useful when
-    `Enable LDAPS`_ is enabled.  Only DEMAND or HARD offer full SSL security
-    while the other options are susceptible to man-in-the-middle attacks.  SSL
-    certificates can be installed to /etc/openldap/cacerts so that the
-    DEMAND or HARD options can be used with self-signed certificates or
-    certificates that do not have traceable certificates of authority.
-
-    NEVER
-        A serve certificate will never be requested or checked.
-
-    ALLOW
-        A server certificate is requested.  Failure to provide a
-        certificate or providing a bad certificate will not terminate the
-        session.
-
-    TRY
-        A server certificate is requested.  Failure to provide a
-        certificate does not halt the session; providing a bad certificate
-        halts the session.
-
-    DEMAND
-        A server certificate is requested and must be provided and
-        authenticated for the session to proceed.
-
-    HARD
-        The same as DEMAND.
-
-.. _Base DN:
-
-Base DN : required
-    The Distinguished Name (DN) where searches for users will be performed.
-    Searches can be controlled by `LDAP Filter`_ and `LDAP Search Scope`_.
-
-.. _LDAP Filter:
-
-LDAP Filter : optional
-    A LDAP filter defined by RFC 2254.  This is more useful when `LDAP
-    Search Scope`_ is set to SUBTREE.  The filter is useful for limiting
-    which LDAP objects are identified as representing Users for
-    authentication.  The filter is augmented by `Login Attribute`_ below.
-    This can commonly be left blank.
-
-.. _LDAP Search Scope:
-
-LDAP Search Scope : required
-    This limits how far LDAP will search for a matching object.
-
-    BASE
-        Only allows searching of `Base DN`_ and is usually not what you
-        want.
-
-    ONELEVEL
-        Searches all entries under `Base DN`_, but not Base DN itself.
-
-    SUBTREE
-        Searches all entries below `Base DN`_, but not Base DN itself.
-        When using SUBTREE `LDAP Filter`_ is useful to limit object
-        location.
-
-.. _Login Attribute:
-
-Login Attribute : required
-    The LDAP record attribute that will be matched as the USERNAME or
-    ACCOUNT used to connect to Kallithea.  This will be added to `LDAP
-    Filter`_ for locating the User object.  If `LDAP Filter`_ is specified as
-    "LDAPFILTER", `Login Attribute`_ is specified as "uid" and the user has
-    connected as "jsmith" then the `LDAP Filter`_ will be augmented as below
-    ::
-
-        (&(LDAPFILTER)(uid=jsmith))
-
-.. _ldap_attr_firstname:
-
-First Name Attribute : required
-    The LDAP record attribute which represents the user's first name.
-
-.. _ldap_attr_lastname:
-
-Last Name Attribute : required
-    The LDAP record attribute which represents the user's last name.
-
-.. _ldap_attr_email:
-
-Email Attribute : required
-    The LDAP record attribute which represents the user's email address.
-
-If all data are entered correctly, and python-ldap_ is properly installed
-users should be granted access to Kallithea with LDAP accounts.  At this
-time user information is copied from LDAP into the Kallithea user database.
-This means that updates of an LDAP user object may not be reflected as a
-user update in Kallithea.
-
-If You have problems with LDAP access and believe You entered correct
-information check out the Kallithea logs, any error messages sent from LDAP
-will be saved there.
-
-Active Directory
-''''''''''''''''
-
-Kallithea can use Microsoft Active Directory for user authentication.  This
-is done through an LDAP or LDAPS connection to Active Directory.  The
-following LDAP configuration settings are typical for using Active
-Directory ::
-
- Base DN              = OU=SBSUsers,OU=Users,OU=MyBusiness,DC=v3sys,DC=local
- Login Attribute      = sAMAccountName
- First Name Attribute = givenName
- Last Name Attribute  = sn
- Email Attribute     = mail
-
-All other LDAP settings will likely be site-specific and should be
-appropriately configured.
-
-
-Authentication by container or reverse-proxy
---------------------------------------------
-
-Kallithea supports delegating the authentication
-of users to its WSGI container, or to a reverse-proxy server through which all
-clients access the application.
-
-When these authentication methods are enabled in Kallithea, it uses the
-username that the container/proxy (Apache or Nginx, etc.) provides and doesn't
-perform the authentication itself. The authorization, however, is still done by
-Kallithea according to its settings.
-
-When a user logs in for the first time using these authentication methods,
-a matching user account is created in Kallithea with default permissions. An
-administrator can then modify it using Kallithea's admin interface.
-
-It's also possible for an administrator to create accounts and configure their
-permissions before the user logs in for the first time, using the :ref:`create-user` API.
-
-Container-based authentication
-''''''''''''''''''''''''''''''
-
-In a container-based authentication setup, Kallithea reads the user name from
-the ``REMOTE_USER`` server variable provided by the WSGI container.
-
-After setting up your container (see `Apache with mod_wsgi`_), you'll need
-to configure it to require authentication on the location configured for
-Kallithea.
-
-Proxy pass-through authentication
-'''''''''''''''''''''''''''''''''
-
-In a proxy pass-through authentication setup, Kallithea reads the user name
-from the ``X-Forwarded-User`` request header, which should be configured to be
-sent by the reverse-proxy server.
-
-After setting up your proxy solution (see `Apache virtual host reverse proxy example`_,
-`Apache as subdirectory`_ or `Nginx virtual host example`_), you'll need to
-configure the authentication and add the username in a request header named
-``X-Forwarded-User``.
-
-For example, the following config section for Apache sets a subdirectory in a
-reverse-proxy setup with basic auth:
-
-.. 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
-
-      AuthType Basic
-      AuthName "Kallithea authentication"
-      AuthUserFile /srv/kallithea/.htpasswd
-      Require valid-user
-
-      RequestHeader unset X-Forwarded-User
-
-      RewriteEngine On
-      RewriteCond %{LA-U:REMOTE_USER} (.+)
-      RewriteRule .* - [E=RU:%1]
-      RequestHeader set X-Forwarded-User %{RU}e
-    </Location>
-
-.. note::
-   If you enable proxy pass-through authentication, make sure your server is
-   only accessible through the proxy. Otherwise, any client would be able to
-   forge the authentication header and could effectively become authenticated
-   using any account of their liking.
-
 
 Integration with issue trackers
 -------------------------------
 
 Kallithea provides a simple integration with issue trackers. It's possible
 to define a regular expression that will match an issue ID in commit messages,
-and have that replaced with a URL to the issue. To enable this simply
-uncomment the following variables in the ini file::
+and have that replaced with a URL to the issue.
+
+This is achieved with following three variables in the ini file::
 
-    issue_pat = (?:^#|\s#)(\w+)
-    issue_server_link = https://issues.example.com/{repo}/issue/{id}
-    issue_prefix = #
+    issue_pat = #(\d+)
+    issue_server_link = https://issues.example.com/{repo}/issue/\1
+    issue_sub =
 
 ``issue_pat`` is the regular expression describing which strings in
-commit messages will be treated as issue references. A match group in
-parentheses should be used to specify the actual issue id.
+commit messages will be treated as issue references. The expression can/should
+have one or more parenthesized groups that can later be referred to in
+``issue_server_link`` and ``issue_sub`` (see below). If you prefer, named groups
+can be used instead of simple parenthesized groups.
 
-The default expression matches issues in the format ``#<number>``, e.g., ``#300``.
+If the pattern should only match if it is preceded by whitespace, add the
+following string before the actual pattern: ``(?:^|(?<=\s))``.
+If the pattern should only match if it is followed by whitespace, add the
+following string after the actual pattern: ``(?:$|(?=\s))``.
+These expressions use lookbehind and lookahead assertions of the Python regular
+expression module to avoid the whitespace to be part of the actual pattern,
+otherwise the link text will also contain that whitespace.
 
 Matched issue references are replaced with the link specified in
-``issue_server_link``. ``{id}`` is replaced with the issue ID, and
-``{repo}`` with the repository name.  Since the # is stripped away,
-``issue_prefix`` is prepended to the link text.  ``issue_prefix`` doesn't
-necessarily need to be ``#``: if you set issue prefix to ``ISSUE-`` this will
-generate a URL in the format:
+``issue_server_link``, in which any backreferences are resolved. Backreferences
+can be ``\1``, ``\2``, ... or for named groups ``\g<groupname>``.
+The special token ``{repo}`` is replaced with the full repository path
+(including repository groups), while token ``{repo_name}`` is replaced with the
+repository name (without repository groups).
+
+The link text is determined by ``issue_sub``, which can be a string containing
+backreferences to the groups specified in ``issue_pat``. If ``issue_sub`` is
+empty, then the text matched by ``issue_pat`` is used verbatim.
+
+The example settings shown above match issues in the format ``#<number>``.
+This will cause the text ``#300`` to be transformed into a link:
 
 .. code-block:: html
 
-  <a href="https://issues.example.com/example_repo/issue/300">ISSUE-300</a>
+  <a href="https://issues.example.com/example_repo/issue/300">#300</a>
+
+The following example transforms a text starting with either of 'pullrequest',
+'pull request' or 'PR', followed by an optional space, then a pound character
+(#) and one or more digits, into a link with the text 'PR #' followed by the
+digits::
+
+    issue_pat = (pullrequest|pull request|PR) ?#(\d+)
+    issue_server_link = https://issues.example.com/\2
+    issue_sub = PR #\2
+
+The following example demonstrates how to require whitespace before the issue
+reference in order for it to be recognized, such that the text ``issue#123`` will
+not cause a match, but ``issue #123`` will::
+
+    issue_pat = (?:^|(?<=\s))#(\d+)
+    issue_server_link = https://issues.example.com/\1
+    issue_sub =
 
 If needed, more than one pattern can be specified by appending a unique suffix to
-the variables. For example::
+the variables. For example, also demonstrating the use of named groups::
 
-    issue_pat_wiki = (?:wiki-)(.+)
-    issue_server_link_wiki = https://wiki.example.com/{id}
-    issue_prefix_wiki = WIKI-
+    issue_pat_wiki = wiki-(?P<pagename>\S+)
+    issue_server_link_wiki = https://wiki.example.com/\g<pagename>
+    issue_sub_wiki = WIKI-\g<pagename>
 
 With these settings, wiki pages can be referenced as wiki-some-id, and every
 such reference will be transformed into:
@@ -478,6 +236,9 b' such reference will be transformed into:'
 
   <a href="https://wiki.example.com/some-id">WIKI-some-id</a>
 
+Refer to the `Python regular expression documentation`_ for more details about
+the supported syntax in ``issue_pat``, ``issue_server_link`` and ``issue_sub``.
+
 
 Hook management
 ---------------
@@ -502,6 +263,9 b' encoding of commit messages. In addition'
 library is installed. If ``chardet`` is detected Kallithea will fallback to it
 when there are encode/decode errors.
 
+The Mercurial encoding is configurable as ``hgencoding``. It is similar to
+setting the ``HGENCODING`` environment variable, but will override it.
+
 
 Celery configuration
 --------------------
@@ -531,7 +295,10 b' Celery. So for example setting `BROKER_H'
 
 To start the Celery process, run::
 
- paster celeryd <configfile.ini>
+  kallithea-cli celery-run -c my.ini
+
+Extra options to the Celery worker can be passed after ``--`` - see ``-- -h``
+for more info.
 
 .. note::
    Make sure you run this command from the same virtualenv, and with the same
@@ -552,6 +319,8 b' directly which scheme/protocol Kallithea'
 - With ``force_https = true`` the default will be ``https``.
 - With ``use_htsts = true``, Kallithea will set ``Strict-Transport-Security`` when using https.
 
+.. _nginx_virtual_host:
+
 
 Nginx virtual host example
 --------------------------
@@ -606,7 +375,7 b' Sample config for Nginx using proxy:'
 
        ## 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;
+       #root /srv/kallithea/kallithea/kallithea/public;
        include         /etc/nginx/proxy.conf;
        location / {
             try_files $uri @kallithea;
@@ -640,6 +409,8 b' pushes or large pushes::'
     client_body_buffer_size     128k;
     large_client_header_buffers 8 64k;
 
+.. _apache_virtual_host_reverse_proxy:
+
 
 Apache virtual host reverse proxy example
 -----------------------------------------
@@ -661,7 +432,7 b' Here is a sample configuration file for '
             </Proxy>
 
             #important !
-            #Directive to properly generate url (clone url) for pylons
+            #Directive to properly generate url (clone url) for Kallithea
             ProxyPreserveHost On
 
             #kallithea instance
@@ -675,6 +446,8 b' Here is a sample configuration file for '
 Additional tutorial
 http://pylonsbook.com/en/1.1/deployment.html#using-apache-to-proxy-requests-to-pylons
 
+.. _apache_subdirectory:
+
 
 Apache as subdirectory
 ----------------------
@@ -683,9 +456,9 b' Apache subdirectory part:'
 
 .. code-block:: apache
 
-    <Location /<someprefix> >
-      ProxyPass http://127.0.0.1:5000/<someprefix>
-      ProxyPassReverse http://127.0.0.1:5000/<someprefix>
+    <Location /PREFIX >
+      ProxyPass http://127.0.0.1:5000/PREFIX
+      ProxyPassReverse http://127.0.0.1:5000/PREFIX
       SetEnvIf X-Url-Scheme https HTTPS=1
     </Location>
 
@@ -698,9 +471,11 b' Add the following at the end of the .ini'
 
     [filter:proxy-prefix]
     use = egg:PasteDeploy#prefix
-    prefix = /<someprefix>
+    prefix = /PREFIX
 
-then change ``<someprefix>`` into your chosen prefix
+then change ``PREFIX`` into your chosen prefix
+
+.. _apache_mod_wsgi:
 
 
 Apache with mod_wsgi
@@ -755,27 +530,21 b' usually ``www-data`` or ``apache``. If y'
 directory owned by a different user, use the user and group options to
 WSGIDaemonProcess to set the name of the user and group.
 
-.. note::
-   If running Kallithea in multiprocess mode,
-   make sure you set ``instance_id = *`` in the configuration so each process
-   gets it's own cache invalidation key.
-
 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
+    # 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 paste.script.util.logging_config import fileConfig
+    from logging.config import fileConfig
     fileConfig(ini)
     from paste.deploy import loadapp
     application = loadapp('config:' + ini)
@@ -791,7 +560,7 b' Or using proper virtualenv activation:'
     os.environ['HOME'] = '/srv/kallithea'
 
     ini = '/srv/kallithea/kallithea.ini'
-    from paste.script.util.logging_config import fileConfig
+    from logging.config import fileConfig
     fileConfig(ini)
     from paste.deploy import loadapp
     application = loadapp('config:' + ini)
@@ -808,11 +577,11 b' the ``init.d`` directory of the Kallithe'
 
 .. _virtualenv: http://pypi.python.org/pypi/virtualenv
 .. _python: http://www.python.org/
+.. _Python regular expression documentation: https://docs.python.org/2/library/re.html
 .. _Mercurial: https://www.mercurial-scm.org/
 .. _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: https://www.mercurial-scm.org/wiki/PublishingRepositories

docs/theme/nature/static/nature.css_t

@@ -2,11 +2,11 b''
  * Sphinx stylesheet -- default theme
  * ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
  */
- 
+
 @import url("basic.css");
- 
+
 /* -- page layout ----------------------------------------------------------- */
- 
+
 body {
     font-family: Arial, sans-serif;
     font-size: 100%;
@@ -28,18 +28,18 b' div.bodywrapper {'
 hr{
     border: 1px solid #B1B4B6;
 }
- 
+
 div.document {
     background-color: #eee;
 }
- 
+
 div.body {
     background-color: #ffffff;
     color: #3E4349;
     padding: 0 30px 30px 30px;
     font-size: 0.8em;
 }
- 
+
 div.footer {
     color: #555;
     width: 100%;
@@ -47,12 +47,12 b' div.footer {'
     text-align: center;
     font-size: 75%;
 }
- 
+
 div.footer a {
     color: #444;
     text-decoration: underline;
 }
- 
+
 div.related {
     background-color: #577632;
     line-height: 32px;
@@ -60,11 +60,11 b' div.related {'
     text-shadow: 0px 1px 0 #444;
     font-size: 0.80em;
 }
- 
+
 div.related a {
     color: #E2F3CC;
 }
- 
+
 div.sphinxsidebar {
     font-size: 0.75em;
     line-height: 1.5em;
@@ -73,7 +73,7 b' div.sphinxsidebar {'
 div.sphinxsidebarwrapper{
     padding: 20px 0;
 }
- 
+
 div.sphinxsidebar h3,
 div.sphinxsidebar h4 {
     font-family: Arial, sans-serif;
@@ -89,30 +89,29 b' div.sphinxsidebar h4 {'
 div.sphinxsidebar h4{
     font-size: 1.1em;
 }
- 
+
 div.sphinxsidebar h3 a {
     color: #444;
 }
- 
- 
+
 div.sphinxsidebar p {
     color: #888;
     padding: 5px 20px;
 }
- 
+
 div.sphinxsidebar p.topless {
 }
- 
+
 div.sphinxsidebar ul {
     margin: 10px 20px;
     padding: 0;
     color: #000;
 }
- 
+
 div.sphinxsidebar a {
     color: #444;
 }
- 
+
 div.sphinxsidebar input {
     border: 1px solid #ccc;
     font-family: sans-serif;
@@ -126,19 +125,19 b' div.sphinxsidebar input[type=text]{'
 div.sphinxsidebar input[type=image] {
     border: 0;
 }
- 
+
 /* -- body styles ----------------------------------------------------------- */
- 
+
 a {
     color: #005B81;
     text-decoration: none;
 }
- 
+
 a:hover {
     color: #E32E00;
     text-decoration: underline;
 }
- 
+
 div.body h1,
 div.body h2,
 div.body h3,
@@ -153,30 +152,30 b' div.body h6 {'
     padding: 5px 0 5px 10px;
     text-shadow: 0px 1px 0 white
 }
- 
+
 div.body h1 { border-top: 20px solid white; margin-top: 0; font-size: 200%; }
 div.body h2 { font-size: 150%; background-color: #C8D5E3; }
 div.body h3 { font-size: 120%; background-color: #D8DEE3; }
 div.body h4 { font-size: 110%; background-color: #D8DEE3; }
 div.body h5 { font-size: 100%; background-color: #D8DEE3; }
 div.body h6 { font-size: 100%; background-color: #D8DEE3; }
- 
+
 a.headerlink {
     color: #c60f0f;
     font-size: 0.8em;
     padding: 0 4px 0 4px;
     text-decoration: none;
 }
- 
+
 a.headerlink:hover {
     background-color: #c60f0f;
     color: white;
 }
- 
+
 div.body p, div.body dd, div.body li {
     line-height: 1.5em;
 }
- 
+
 div.admonition p.admonition-title + p {
     display: inline;
 }
@@ -189,29 +188,29 b' div.note {'
     background-color: #eee;
     border: 1px solid #ccc;
 }
- 
+
 div.seealso {
     background-color: #ffc;
     border: 1px solid #ff6;
 }
- 
+
 div.topic {
     background-color: #eee;
 }
- 
+
 div.warning {
     background-color: #ffe4e4;
     border: 1px solid #f66;
 }
- 
+
 p.admonition-title {
     display: inline;
 }
- 
+
 p.admonition-title:after {
     content: ":";
 }
- 
+
 pre {
     padding: 10px;
     background-color: White;
@@ -222,7 +221,7 b' pre {'
     margin: 1.5em 0 1.5em 0;
     box-shadow: 1px 1px 1px #d8d8d8;
 }
- 
+
 tt {
     background-color: #ecf0f3;
     color: #222;

docs/usage/debugging.rst

@@ -25,7 +25,7 b' Enable interactive debug mode'
 
 To enable interactive debug mode simply comment out ``set debug = false`` in
 the .ini file. This will trigger an interactive debugger each time
-there is an error in the browser, or send a http link if an error occured in the backend. This
+there is an error in the browser, or send a http link if an error occurred in the backend. This
 is a great tool for fast debugging as you get a handy Python console right
 in the web view.
 

docs/usage/email.rst

@@ -12,8 +12,17 b' cannot be sent, all mails will show up i'
 Before any email can be sent, an SMTP server has to be configured using the
 configuration file setting ``smtp_server``. If required for that server, specify
 a username (``smtp_username``) and password (``smtp_password``), a non-standard
-port (``smtp_port``), encryption settings (``smtp_use_tls`` or ``smtp_use_ssl``)
-and/or specific authentication parameters (``smtp_auth``).
+port (``smtp_port``), whether to use "SSL" when connecting (``smtp_use_ssl``)
+or use STARTTLS (``smtp_use_tls``), and/or specify special ESMTP "auth" features
+(``smtp_auth``).
+
+For example, for sending through gmail, use::
+
+    smtp_server = smtp.gmail.com
+    smtp_username = username
+    smtp_password = password
+    smtp_port = 465
+    smtp_use_ssl = true
 
 
 Application emails
@@ -67,9 +76,8 b' Error emails'
 
 When an exception occurs in Kallithea -- and unless interactive debugging is
 enabled using ``set debug = true`` in the ``[app:main]`` section of the
-configuration file -- an email with exception details is sent by WebError_'s
-``ErrorMiddleware`` to the addresses specified in ``email_to`` in the
-configuration file.
+configuration file -- an email with exception details is sent by backlash_
+to the addresses specified in ``email_to`` in the configuration file.
 
 Recipients will see these emails originating from the sender specified in the
 ``error_email_from`` setting in the configuration file. This setting can either
@@ -77,10 +85,6 b' contain only an email address, like `kal'
 a name and an address in the following format: `Kallithea Errors
 <[e-mail]>`.
 
-*Note:* The WebError_ package does not respect ``smtp_port`` and assumes the
-standard SMTP port (25). If you have a remote SMTP server with a different port,
-you could set up a local forwarding SMTP server on port 25.
-
 
 References
 ----------
@@ -89,4 +93,4 b' References'
 - `ErrorHandler (Pylons modules documentation) <http://pylons-webframework.readthedocs.org/en/latest/modules/middleware.html#pylons.middleware.ErrorHandler>`_
 
 
-.. _WebError: https://pypi.python.org/pypi/WebError
+.. _backlash: https://github.com/TurboGears/backlash

docs/usage/general.rst

@@ -8,18 +8,18 b' General Kallithea usage'
 Repository deletion
 -------------------
 
-Currently when an admin or owner deletes a repository, Kallithea does
+When an admin or owner deletes a repository, Kallithea does
 not physically delete said repository from the filesystem, but instead
 renames it in a special way so that it is not possible to push, clone
 or access the repository.
 
 There is a special command for cleaning up such archived repositories::
 
-    paster cleanup-repos --older-than=30d my.ini
+    kallithea-cli repo-purge-deleted -c my.ini --older-than=30d
 
 This command scans for archived repositories that are older than
 30 days, displays them, and asks if you want to delete them (unless given
-the ``--dont-ask`` flag). If you host a large amount of repositories with
+the ``--no-ask`` flag). If you host a large amount of repositories with
 forks that are constantly being deleted, it is recommended that you run this
 command via crontab.
 
@@ -151,7 +151,7 b' described in more detail in this documen'
 features that merit further explanation.
 
 Repository extra fields
-~~~~~~~~~~~~~~~~~~~~~~~
+^^^^^^^^^^^^^^^^^^^^^^^
 
 In the *Visual* tab, there is an option "Use repository extra
 fields", which allows to set custom fields for each repository in the system.
@@ -165,7 +165,7 b' about a manager of each repository. The'
 Newly created fields are accessible via the API.
 
 Meta tagging
-~~~~~~~~~~~~
+^^^^^^^^^^^^
 
 In the *Visual* tab, option "Stylify recognised meta tags" will cause Kallithea
 to turn certain text fragments in repository and repository group

docs/usage/performance.rst

@@ -4,59 +4,65 b''
 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.
+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.
+Fast storage
+------------
 
-* 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.
+Kallithea is often I/O bound, and hence a fast disk (SSD/SAN) and plenty of RAM
+is usually more important than a fast CPU.
+
 
-Follow these few steps to improve performance of Kallithea system.
+Caching
+-------
 
-1. Increase cache
+Tweak beaker cache settings in the ini file. The actual effect of that is
+questionable.
 
-    Tweak beaker cache settings in the ini file. The actual effect of that
-    is questionable.
 
-2. Switch from SQLite to PostgreSQL or MySQL
+Database
+--------
 
-    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.
+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.
 
-3. Scale Kallithea horizontally
+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.
+
 
-    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.
+Horizontal scaling
+------------------
 
-    It is generally possible to run WSGI applications multithreaded, so that
-    several HTTP requests are served from the same Python process at once. That
-    can in principle give better utilization of internal caches and less
-    process overhead.
+Scaling horizontally means running several Kallithea instances and let them
+share the load. That 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.
 
-    One danger of running multithreaded is that program execution becomes much
-    more complex; programs must be written to consider all combinations of
-    events and problems might depend on timing and be impossible to reproduce.
+It is generally possible to run WSGI applications multithreaded, so that
+several HTTP requests are served from the same Python process at once. That can
+in principle give better utilization of internal caches and less process
+overhead.
 
-    Kallithea can't promise to be thread-safe, just like the embedded Mercurial
-    backend doesn't make any strong promises when used as Kallithea uses it.
-    Instead, we recommend scaling by using multiple server processes.
+One danger of running multithreaded is that program execution becomes much more
+complex; programs must be written to consider all combinations of events and
+problems might depend on timing and be impossible to reproduce.
 
-    Web servers with multiple worker processes (such as ``mod_wsgi`` with the
-    ``WSGIDaemonProcess`` ``processes`` parameter) will work out of the box.
+Kallithea can't promise to be thread-safe, just like the embedded Mercurial
+backend doesn't make any strong promises when used as Kallithea uses it.
+Instead, we recommend scaling by using multiple server processes.
 
-    In order to scale horizontally on multiple machines, you need to do the
-    following:
+Web servers with multiple worker processes (such as ``mod_wsgi`` with the
+``WSGIDaemonProcess`` ``processes`` parameter) will work out of the box.
 
-    - Each instance needs its own .ini file and unique ``instance_id`` set.
+In order to scale horizontally on multiple machines, 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
@@ -71,4 +77,42 b' 3. Scale Kallithea horizontally'
       servers or build bots.
 
 
+Serve static files directly from the web server
+-----------------------------------------------
+
+With the default ``static_files`` ini setting, the Kallithea WSGI application
+will take care of serving the static files from ``kallithea/public/`` at the
+root of the application URL.
+
+The actual serving of the static files is very fast and unlikely to be a
+problem in a Kallithea setup - the responses generated by Kallithea from
+database and repository content will take significantly more time and
+resources.
+
+To serve static files from the web server, use something like this Apache config
+snippet::
+
+        Alias /images/ /srv/kallithea/kallithea/kallithea/public/images/
+        Alias /css/ /srv/kallithea/kallithea/kallithea/public/css/
+        Alias /js/ /srv/kallithea/kallithea/kallithea/public/js/
+        Alias /codemirror/ /srv/kallithea/kallithea/kallithea/public/codemirror/
+        Alias /fontello/ /srv/kallithea/kallithea/kallithea/public/fontello/
+
+Then disable serving of static files in the ``.ini`` ``app:main`` section::
+
+        static_files = false
+
+If using Kallithea installed as a package, you should be able to find the files
+under ``site-packages/kallithea``, either in your Python installation or in your
+virtualenv. When upgrading, make sure to update the web server configuration
+too if necessary.
+
+It might also be possible to improve performance by configuring the web server
+to compress responses (served from static files or generated by Kallithea) when
+serving them. That might also imply buffering of responses - that is more
+likely to be a problem; large responses (clones or pulls) will have to be fully
+processed and spooled to disk or memory before the client will see any
+response. See the documentation for your web server.
+
+
 .. _SQLAlchemyGrate: https://github.com/shazow/sqlalchemygrate

docs/usage/troubleshooting.rst

@@ -63,7 +63,7 b' Troubleshooting'
 |
 
 :Q: **Requests hanging on Windows**
-:A: Please try out with disabled Antivirus software, there are some known problems with Eset Anitivirus. Make sure
+:A: Please try out with disabled Antivirus software, there are some known problems with Eset Antivirus. Make sure
     you have installed the latest Windows patches (especially KB2789397).
 
 

docs/usage/vcs_notes.rst

@@ -1,57 +1,80 b''
-.. _vcs_support:
-
-===============================
-Version control systems support
-===============================
-
-Kallithea supports Git and Mercurial repositories out-of-the-box.
-For Git, you do need the ``git`` command line client installed on the server.
+.. _vcs_notes:
 
-You can always disable Git or Mercurial support by editing the
-file ``kallithea/__init__.py`` and commenting out the backend.
-
-.. code-block:: python
+===================================
+Version control systems usage notes
+===================================
 
-   BACKENDS = {
-       'hg': 'Mercurial repository',
-       #'git': 'Git repository',
-   }
-
-
-Git support
------------
+.. _importing:
 
 
-Web server with chunked encoding
-````````````````````````````````
+Importing existing repositories
+-------------------------------
+
+There are two main methods to import repositories in Kallithea: via the web
+interface or via the filesystem. If you have a large number of repositories to
+import, importing them via the filesystem is more convenient.
+
+Importing via web interface
+^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+For a small number of repositories, it may be easier to create the target
+repositories through the Kallithea web interface, via *Admin > Repositories* or
+via the *Add Repository* button on the entry page of the web interface.
 
-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
-waitress_ for `paster serve` instead of the built-in `paste` WSGI
-server.
+Repositories can be nested in repository groups by first creating the group (via
+*Admin > Repository Groups* or via the *Add Repository Group* button on the
+entry page of the web interface) and then selecting the appropriate group when
+adding the repository.
 
-The paster server is controlled in the .ini file::
+After creation of the (empty) repository, push the existing commits to the
+*Clone URL* displayed on the repository summary page. For Git repositories,
+first add the *Clone URL* as remote, then push the commits to that remote.  The
+specific commands to execute are shown under the *Existing repository?* section
+of the new repository's summary page.
+
+A benefit of this method particular for Git repositories, is that the
+Kallithea-specific Git hooks are installed automatically.  For Mercurial, no
+hooks are required anyway.
 
-    use = egg:waitress#main
+Importing via the filesystem
+^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+The alternative method of importing repositories consists of creating the
+repositories in the desired hierarchy on the filesystem and letting Kallithea
+scan that location.
 
-or::
-
-    use = egg:gunicorn#main
+All repositories are stored in a central location on the filesystem. This
+location is specified during installation (via ``db-create``) and can be reviewed
+at *Admin > Settings > VCS > Location of repositories*. Repository groups
+(defined in *Admin > Repository Groups*) are represented by a directory in that
+repository location. Repositories of the repository group are nested under that
+directory.
 
-Also make sure to comment out the following options::
+To import a set of repositories and organize them in a certain repository group
+structure, first place clones in the desired hierarchy at the configured
+repository location.
+These clones should be created without working directory. For Mercurial, this is
+done with ``hg clone -U``, for Git with ``git clone --bare``.
+
+When the repositories are added correctly on the filesystem:
 
-    threadpool_workers =
-    threadpool_max_requests =
-    use_threadpool =
+* go to *Admin > Settings > Remap and Rescan* in the Kallithea web interface
+* select the *Install Git hooks* checkbox when importing Git repositories
+* click *Rescan Repositories*
+
+This step will scan the filesystem and create the appropriate repository groups
+and repositories in Kallithea.
+
+*Note*: Once repository groups have been created this way, manage their access
+permissions through the Kallithea web interface.
 
 
-Mercurial support
------------------
+Mercurial-specific notes
+------------------------
 
 
-Working with Mercurial subrepositories
-``````````````````````````````````````
+Working with subrepositories
+^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 This section explains how to use Mercurial subrepositories_ in Kallithea.
 
@@ -82,6 +105,4 b' Next we can edit the subrepository data,'
 update both repositories.
 
 
-.. _waitress: http://pypi.python.org/pypi/waitress
-.. _gunicorn: http://pypi.python.org/pypi/gunicorn
 .. _subrepositories: http://mercurial.aragost.com/kick-start/en/subrepositories/

init.d/celeryd-upstart.conf

@@ -2,8 +2,8 b''
 # Change variables/paths as necessary and place file /etc/init/celeryd.conf
 # start/stop/restart as normal upstart job (ie: $ start celeryd)
 
-description	"Celery for Kallithea Mercurial Server"
-author		"Matt Zuba <[e-mail]"
+description     "Celery for Kallithea Mercurial Server"
+author          "Matt Zuba <[e-mail]"
 
 start on starting kallithea
 stop on stopped kallithea
@@ -21,7 +21,7 b' env USER=hg'
 # env GROUP=hg
 
 script
-    COMMAND="/var/hg/.virtualenvs/kallithea/bin/paster celeryd $APPINI --pidfile=$PIDFILE"
+    COMMAND="/var/hg/.virtualenvs/kallithea/bin/kallithea-cli celery-run -c $APPINI -- --pidfile=$PIDFILE"
     if [ -z "$GROUP" ]; then
         exec sudo -u $USER $COMMAND
     else

init.d/kallithea-daemon-arch

@@ -12,7 +12,7 b' APP_PATH="$APP_HOMEDIR/$DAEMON"'
 CONF_NAME="production.ini"
 LOG_FILE="/var/log/$DAEMON.log"
 PID_FILE="/run/daemons/$DAEMON"
-APPL=/usr/bin/paster
+APPL=/usr/bin/gearbox
 RUN_AS="*****"
 
 ARGS="serve --daemon \
@@ -20,7 +20,7 b' ARGS="serve --daemon \\'
 --group=$RUN_AS \
 --pid-file=$PID_FILE \
 --log-file=$LOG_FILE \
-$APP_PATH/$CONF_NAME"
+-c $APP_PATH/$CONF_NAME"
 
 [ -r /etc/conf.d/$DAEMON ] && . /etc/conf.d/$DAEMON
 
@@ -47,7 +47,7 b' start)'
     ;;
 stop)
     stat_busy "Stopping $DAEMON"
-    [ -n "$PID" ] && kill $PID &>/dev/null 
+    [ -n "$PID" ] && kill $PID &>/dev/null
     if [ $? = 0 ]; then
         rm_daemon $DAEMON
         stat_done
@@ -67,4 +67,4 b' status)'
     ;;
 *)
     echo "usage: $0 {start|stop|restart|status}"
-esac
  No newline at end of file
+esac

init.d/kallithea-daemon-debian

@@ -2,9 +2,9 b''
 ########################################
 #### THIS IS A DEBIAN INIT.D SCRIPT ####
 ########################################
- 
+
 ### BEGIN INIT INFO
-# Provides:          kallithea          
+# Provides:          kallithea
 # Required-Start:    $all
 # Required-Stop:     $all
 # Default-Start:     2 3 4 5
@@ -12,29 +12,29 b''
 # 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/paster"
- 
+
+DAEMON="$PYTHON_PATH/bin/gearbox"
+
 DAEMON_OPTS="serve --daemon \
  --user=$RUN_AS \
  --group=$RUN_AS \
  --pid-file=$PID_PATH \
- --log-file=$LOG_PATH  $APP_PATH/$CONF_NAME"
- 
- 
+ --log-file=$LOG_PATH -c $APP_PATH/$CONF_NAME"
+
+
 start() {
   echo "Starting $APP_NAME"
   PYTHON_EGG_CACHE="/tmp" start-stop-daemon -d $APP_PATH \
@@ -43,18 +43,18 b' start() {'
       --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`
@@ -65,7 +65,7 b' status() {'
     echo "NOT running"
   fi
 }
- 
+
 case "$1" in
   status)
    status
@@ -87,4 +87,4 b' case "$1" in'
   *)
     echo "Usage: $0 {start|stop|restart}"
     exit 1
-esac
  No newline at end of file
+esac

init.d/kallithea-daemon-gentoo

@@ -16,13 +16,13 b' PYTHON_PATH="/home/$APP_HOMEDIR/v-env"'
 
 RUN_AS="username"
 
-DAEMON="$PYTHON_PATH/bin/paster"
+DAEMON="$PYTHON_PATH/bin/gearbox"
 
 DAEMON_OPTS="serve --daemon \
 --user=$RUN_AS \
 --group=$RUN_AS \
 --pid-file=$PID_PATH \
---log-file=$LOG_PATH  $APP_PATH/$CONF_NAME"
+--log-file=$LOG_PATH -c $APP_PATH/$CONF_NAME"
 
 #extra options
 opts="${opts} restartdelay"
@@ -56,6 +56,6 b' restartdelay() {'
     #stop()
     echo "sleep3"
     sleep 3
-    
+
     #start()
 }

init.d/kallithea-daemon-redhat

@@ -20,7 +20,7 b' 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 paster as has the appropriate permissions
+# 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"
@@ -31,13 +31,13 b' PYTHON_PATH="/opt/python_virtualenvironm'
 
 RUN_AS="kallithea"
 
-DAEMON="$PYTHON_PATH/bin/paster"
+DAEMON="$PYTHON_PATH/bin/gearbox"
 
 DAEMON_OPTS="serve --daemon \
     --user=$RUN_AS \
     --group=$RUN_AS \
     --pid-file=$PID_PATH \
-    --log-file=$LOG_PATH $APP_PATH/$CONF_NAME"
+    --log-file=$LOG_PATH -c $APP_PATH/$CONF_NAME"
 
 DESC="kallithea-server"
 LOCK_FILE="/var/lock/subsys/$APP_NAME"
@@ -129,4 +129,4 b' case "$1" in'
     ;;
 esac
 
-exit $RETVAL
  No newline at end of file
+exit $RETVAL

init.d/kallithea-upstart.conf

@@ -2,8 +2,8 b''
 # Change variables/paths as necessary and place file /etc/init/kallithea.conf
 # start/stop/restart as normal upstart job (ie: $ start kallithea)
 
-description	"Kallithea Mercurial Server"
-author		"Matt Zuba <[e-mail]"
+description     "Kallithea Mercurial Server"
+author          "Matt Zuba <[e-mail]"
 
 start on (local-filesystems and runlevel [2345])
 stop on runlevel [!2345]
@@ -19,8 +19,8 b' env HOME=/var/hg'
 env USER=hg
 env GROUP=hg
 
-exec /var/hg/.virtualenvs/kallithea/bin/paster serve --user=$USER --group=$GROUP --pid-file=$PIDFILE --log-file=$LOGFILE $APPINI
+exec /var/hg/.virtualenvs/kallithea/bin/gearbox serve --user=$USER --group=$GROUP --pid-file=$PIDFILE --log-file=$LOGFILE -c $APPINI
 
 post-stop script
-	rm -f $PIDFILE
+    rm -f $PIDFILE
 end script

init.d/supervisord.conf

@@ -45,7 +45,7 b' serverurl=http://127.0.0.1:9001 ; use an'
 numprocs = 1
 numprocs_start = 5000 # possible should match ports
 directory=/srv/kallithea
-command = /srv/kallithea/venv/bin/paster serve my.ini
+command = /srv/kallithea/venv/bin/gearbox serve -c my.ini
 process_name = %(program_name)s_%(process_num)04d
-redirect_stderr=true 
-stdout_logfile=/%(here)s/kallithea.log 
+redirect_stderr=true
+stdout_logfile=/%(here)s/kallithea.log

kallithea/__init__.py

@@ -15,8 +15,9 b''
 kallithea
 ~~~~~~~~~
 
-Kallithea, a web based repository management based on pylons
-versioning implementation: http://www.python.org/dev/peps/pep-0386/
+Kallithea, a web based repository management system.
+
+Versioning implementation: http://www.python.org/dev/peps/pep-0386/
 
 This file was forked by the Kallithea project in July 2014.
 Original author and date, and relevant copyright and licensing information is below:
@@ -29,7 +30,7 b' Original author and date, and relevant c'
 import sys
 import platform
 
-VERSION = (0, 3, 7)
+VERSION = (0, 4, 0, 'rc2')
 BACKENDS = {
     'hg': 'Mercurial repository',
     'git': 'Git repository',
@@ -38,45 +39,20 b' BACKENDS = {'
 CELERY_ON = False
 CELERY_EAGER = False
 
-# link to config for pylons
 CONFIG = {}
 
 # Linked module for extensions
 EXTENSIONS = {}
 
-# BRAND controls internal references in database and config to the products
-# own name.
-#
-# NOTE: If you want compatibility with a database that was originally created
-#  for use with the RhodeCode software product, change BRAND to "rhodecode",
-#  either by editing here or by creating a new file:
-#  echo "BRAND = 'rhodecode'" > kallithea/brand.py
-
-BRAND = "kallithea"
 try:
-    from kallithea.brand import BRAND
+    import kallithea.brand
 except ImportError:
     pass
-
-# Prefix for the ui and settings table names
-DB_PREFIX = (BRAND + "_") if BRAND != "kallithea" else ""
-
-# Users.extern_type and .extern_name value for local users
-EXTERN_TYPE_INTERNAL = BRAND if BRAND != 'kallithea' else 'internal'
-
-# db_migrate_version.repository_id value, same as kallithea/lib/dbmigrate/migrate.cfg
-DB_MIGRATIONS = BRAND + "_db_migrations"
+else:
+    assert False, 'Database rebranding is no longer supported; see README.'
 
-try:
-    from kallithea.lib import get_current_revision
-    _rev = get_current_revision(quiet=True)
-    if _rev and len(VERSION) > 3:
-        VERSION += (_rev[0],)
-except ImportError:
-    pass
 
-__version__ = ('.'.join((str(each) for each in VERSION[:3])))
-__dbversion__ = 31  # defines current db version for migrations
+__version__ = '.'.join(str(each) for each in VERSION)
 __platform__ = platform.system()
 __license__ = 'GPLv3'
 __py_version__ = sys.version_info
@@ -85,17 +61,3 b' except ImportError:'
 
 is_windows = __platform__ in ['Windows']
 is_unix = not is_windows
-
-if len(VERSION) > 3:
-    __version__ += '.'+VERSION[3]
-
-    if len(VERSION) > 4:
-        __version__ += VERSION[4]
-    else:
-        __version__ += '0'
-
-# Hack for making the celery dependency kombu==1.5.1 compatible with Python
-# 2.7.11 which has https://hg.python.org/releases/2.7.11/rev/24bdc4940e81
-import uuid
-if not hasattr(uuid, '_uuid_generate_random'):
-    uuid._uuid_generate_random = None

kallithea/bin/base.py

@@ -111,8 +111,8 b' class RcConf(object):'
             return True
         return False
 
-    def __eq__(self):
-        return self._conf.__eq__()
+    def __eq__(self, other):
+        return self._conf.__eq__(other)
 
     def __repr__(self):
         return 'RcConf<%s>' % self._conf.__repr__()
@@ -158,7 +158,7 b' class RcConf(object):'
         """
         try:
             with open(self._conf_name, 'rb') as conf:
-                return  json.load(conf)
+                return json.load(conf)
         except IOError as e:
             #sys.stderr.write(str(e) + '\n')
             pass

kallithea/bin/kallithea_api.py

@@ -121,5 +121,6 b' def main(argv=None):'
         )
     return 0
 
+
 if __name__ == '__main__':
     sys.exit(main(sys.argv))

kallithea/bin/kallithea_backup.py

@@ -28,11 +28,11 b' Original author and date, and relevant c'
 
 import os
 import sys
-
 import logging
 import tarfile
 import datetime
 import subprocess
+import tempfile
 
 logging.basicConfig(level=logging.DEBUG,
                     format="%(asctime)s %(levelname)-5.5s %(message)s")
@@ -47,7 +47,7 b' class BackupManager(object):'
         self.repos_path = self.get_repos_path(repos_location)
         self.backup_server = backup_server
 
-        self.backup_file_path = '/tmp'
+        self.backup_file_path = tempfile.gettempdir()
 
         logging.info('starting backup for %s', self.repos_path)
         logging.info('backup target %s', self.backup_file_path)
@@ -86,12 +86,13 b' class BackupManager(object):'
                '%(backup_server)s' % params]
 
         subprocess.call(cmd)
-        logging.info('Transfered file %s to %s', self.backup_file_name, cmd[4])
+        logging.info('Transferred file %s to %s', self.backup_file_name, cmd[4])
 
     def rm_file(self):
         logging.info('Removing file %s', self.backup_file_name)
         os.remove(os.path.join(self.backup_file_path, self.backup_file_name))
 
+
 if __name__ == "__main__":
 
     repo_location = '/home/repo_path'

kallithea/bin/kallithea_cli_celery.py

@@ -1,100 +1,39 b''
 # -*- coding: utf-8 -*-
+# This program is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# 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 click
+import kallithea.bin.kallithea_cli_base as cli_base
 
 import kallithea
-from kallithea.lib.utils import BasePasterCommand, Command, load_rcextensions
-from celery.app import app_or_default
-from celery.bin import camqadm, celerybeat, celeryd, celeryev
 
-from kallithea.lib.utils2 import str2bool
+@cli_base.register_command(config_file_initialize_app=True)
[e-mail]('celery_args', nargs=-1)
+def celery_run(celery_args):
+    """Start Celery worker(s) for asynchronous tasks.
 
-__all__ = ['CeleryDaemonCommand', 'CeleryBeatCommand',
-           'CAMQPAdminCommand', 'CeleryEventCommand']
-
+    This commands starts the Celery daemon which will spawn workers to handle
+    certain asynchronous tasks for Kallithea.
 
-class CeleryCommand(BasePasterCommand):
-    """Abstract class implements run methods needed for celery
-
-    Starts the celery worker that uses a paste.deploy configuration
-    file.
+    Any extra arguments you pass to this command will be passed through to
+    Celery. Use '--' before such extra arguments to avoid options to be parsed
+    by this CLI command.
     """
 
-    def update_parser(self):
-        """
-        Abstract method.  Allows for the class's parser to be updated
-        before the superclass's `run` method is called.  Necessary to
-        allow options/arguments to be passed through to the underlying
-        celery command.
-        """
-
-        cmd = self.celery_command(app_or_default())
-        for x in cmd.get_options():
-            self.parser.add_option(x)
-
-    def command(self):
-        from pylons import config
-        try:
-            CELERY_ON = str2bool(config['app_conf'].get('use_celery'))
-        except KeyError:
-            CELERY_ON = False
-
-        if not CELERY_ON:
-            raise Exception('Please set use_celery = true in .ini config '
-                            'file before running celeryd')
-        kallithea.CELERY_ON = CELERY_ON
-        load_rcextensions(config['here'])
-        cmd = self.celery_command(app_or_default())
-        return cmd.run(**vars(self.options))
-
-
-class CeleryDaemonCommand(CeleryCommand):
-    """Start the celery worker
-
-    Starts the celery worker that uses a paste.deploy configuration
-    file.
-    """
-    usage = 'CONFIG_FILE [celeryd options...]'
-    summary = __doc__.splitlines()[0]
-    description = "".join(__doc__.splitlines()[2:])
+    if not kallithea.CELERY_ON:
+        raise Exception('Please set use_celery = true in .ini config '
+                        'file before running this command')
 
-    parser = Command.standard_parser(quiet=True)
-    celery_command = celeryd.WorkerCommand
-
-
-class CeleryBeatCommand(CeleryCommand):
-    """Start the celery beat server
-
-    Starts the celery beat server using a paste.deploy configuration
-    file.
-    """
-    usage = 'CONFIG_FILE [celerybeat options...]'
-    summary = __doc__.splitlines()[0]
-    description = "".join(__doc__.splitlines()[2:])
-
-    parser = Command.standard_parser(quiet=True)
-    celery_command = celerybeat.BeatCommand
-
-
-class CAMQPAdminCommand(CeleryCommand):
-    """CAMQP Admin
-
-    CAMQP celery admin tool.
-    """
-    usage = 'CONFIG_FILE [camqadm options...]'
-    summary = __doc__.splitlines()[0]
-    description = "".join(__doc__.splitlines()[2:])
-
-    parser = Command.standard_parser(quiet=True)
-    celery_command = camqadm.AMQPAdminCommand
-
-
-class CeleryEventCommand(CeleryCommand):
-    """Celery event command.
-
-    Capture celery events.
-    """
-    usage = 'CONFIG_FILE [celeryev options...]'
-    summary = __doc__.splitlines()[0]
-    description = "".join(__doc__.splitlines()[2:])
-
-    parser = Command.standard_parser(quiet=True)
-    celery_command = celeryev.EvCommand
+    from kallithea.lib import celerypylons
+    cmd = celerypylons.worker.worker(celerypylons.app)
+    return cmd.run_from_argv(None, command='celery-run -c CONFIG_FILE --', argv=list(celery_args))

kallithea/bin/kallithea_cli_config.py

@@ -1,5 +1,3 b''
-#!/usr/bin/env python2
-
 # -*- coding: utf-8 -*-
 # This program is free software: you can redistribute it and/or modify
 # it under the terms of the GNU General Public License as published by
@@ -13,148 +11,82 b''
 #
 # You should have received a copy of the GNU General Public License
 # along with this program.  If not, see <http://www.gnu.org/licenses/>.
-"""
-kallithea.bin.kallithea_config
-~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
-configuration generator for Kallithea
-
-This file was forked by the Kallithea project in July 2014.
-Original author and date, and relevant copyright and licensing information is below:
-:created_on: Jun 18, 2013
-:author: marcink
-:copyright: (c) 2013 RhodeCode GmbH, and others.
-:license: GPLv3, see LICENSE.md for more details.
-"""
-
+import click
+import kallithea.bin.kallithea_cli_base as cli_base
 
 import os
-import sys
 import uuid
-import argparse
-from mako.template import Template
-TMPL = 'template.ini.mako'
-here = os.path.dirname(os.path.abspath(__file__))
+from collections import defaultdict
+
+import mako.exceptions
+
+from kallithea.lib import inifile
 
-def argparser(argv):
-    usage = (
-      "kallithea-config [-h] [--filename=FILENAME] [--template=TEMPLATE] \n"
-      "VARS optional specify extra template variable that will be available in "
-      "template. Use comma separated key=val format eg.\n"
-      "key1=val1,port=5000,host=127.0.0.1,elements='a\,b\,c'\n"
-    )
+def show_defaults(ctx, param, value):
+    # Following construct is taken from the Click documentation:
+    # https://click.palletsprojects.com/en/7.x/options/#callbacks-and-eager-options
+    # "The resilient_parsing flag is applied to the context if Click wants to
+    # parse the command line without any destructive behavior that would change
+    # the execution flow. In this case, because we would exit the program, we
+    # instead do nothing."
+    if not value or ctx.resilient_parsing:
+        return
 
-    parser = argparse.ArgumentParser(
-        description='Kallithea CONFIG generator with variable replacement',
-        usage=usage
-    )
+    for key, value in inifile.default_variables.items():
+        click.echo('%s=%s' % (key, value))
 
-    ## config
-    group = parser.add_argument_group('CONFIG')
-    group.add_argument('--filename', help='Output ini filename.')
-    group.add_argument('--template', help='Mako template file to use instead of '
-                                          'the default builtin template')
-    group.add_argument('--raw', help='Store given mako template as raw without '
-                                     'parsing. Use this to create custom template '
-                                     'initially', action='store_true')
-    group.add_argument('--show-defaults', help='Show all default variables for '
-                                               'builtin template', action='store_true')
-    args, other = parser.parse_known_args()
-    return parser, args, other
+    ctx.exit()
+
+@cli_base.register_command()
[e-mail]('--show-defaults', callback=show_defaults,
+              is_flag=True, expose_value=False, is_eager=True,
+              help='Show the default values that can be overridden')
[e-mail]('config_file', type=click.Path(dir_okay=False, writable=True), required=True)
[e-mail]('key_value_pairs', nargs=-1)
+def config_create(config_file, key_value_pairs):
+    """Create a new configuration file.
 
+    This command creates a default configuration file, possibly adding/updating
+    settings you specify.
 
-def _escape_split(text, sep):
-    """
-    Allows for escaping of the separator: e.g. arg='foo\, bar'
+    The primary high level configuration keys and their default values are
+    shown with --show-defaults . Custom values for these keys can be specified
+    on the command line as key=value arguments.
 
-    It should be noted that the way bash et. al. do command line parsing, those
-    single quotes are required. a shameless ripoff from fabric project.
-
+    Additional key=value arguments will be patched/inserted in the [app:main]
+    section ... until another section name specifies where any following values
+    should go.
     """
-    escaped_sep = r'\%s' % sep
 
-    if escaped_sep not in text:
-        return text.split(sep)
-
-    before, _, after = text.partition(escaped_sep)
-    startlist = before.split(sep)  # a regular split is fine here
-    unfinished = startlist[-1]
-    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] becaue 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
+    mako_variable_values = {}
+    ini_settings = defaultdict(dict)
 
-def _run(argv):
-    parser, args, other = argparser(argv)
-    if not len(sys.argv) > 1:
-        print parser.print_help()
-        sys.exit(0)
-    # 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,
-    }
-    if other:
-        # parse arguments, we assume only first is correct
-        kwargs = {}
-        for el in _escape_split(other[0], ','):
-            kv = _escape_split(el, '=')
-            if len(kv) == 2:
-                k, v = kv
-                kwargs[k] = v
-        # update our template stored args
-        tmpl_stored_args.update(kwargs)
+    section_name = None
+    for parameter in key_value_pairs:
+        parts = parameter.split('=', 1)
+        if len(parts) == 1 and parameter.startswith('[') and parameter.endswith(']'):
+            section_name = parameter
+        elif len(parts) == 2:
+            key, value = parts
+            if section_name is None and key in inifile.default_variables:
+                mako_variable_values[key] = value
+            else:
+                if section_name is None:
+                    section_name = '[app:main]'
+                ini_settings[section_name][key] = value
+        else:
+            raise ValueError("Invalid name=value parameter %r" % parameter)
 
     # use default that cannot be replaced
-    tmpl_stored_args.update({
+    mako_variable_values.update({
         'uuid': lambda: uuid.uuid4().hex,
-        'here': os.path.abspath(os.curdir),
     })
-    if args.show_defaults:
-        for k,v in tmpl_stored_args.iteritems():
-            print '%s=%s' % (k, v)
-        sys.exit(0)
     try:
-        # built in template
-        tmpl_file = os.path.join(here, TMPL)
-        if args.template:
-            tmpl_file = args.template
-
-        with open(tmpl_file, 'rb') as f:
-            tmpl_data = f.read().decode('utf-8')
-            if args.raw:
-                tmpl = tmpl_data
-            else:
-                tmpl = Template(tmpl_data).render(**tmpl_stored_args)
-        with open(args.filename, 'wb') as f:
-            f.write(tmpl.encode('utf-8'))
-        print 'Wrote new config file in %s' % (os.path.abspath(args.filename))
+        config_file_abs = os.path.abspath(config_file)
+        inifile.create(config_file_abs, mako_variable_values, ini_settings)
+        click.echo('Wrote new config file in %s' % config_file_abs)
+        click.echo("Don't forget to build the front-end using 'kallithea-cli front-end-build'.")
 
     except Exception:
-        from mako import exceptions
-        print exceptions.text_error_template().render()
-
-def main(argv=None):
-    """
-    Main execution function for cli
-
-    :param argv:
-    """
-    if argv is None:
-        argv = sys.argv
-
-    return _run(argv)
-
-
-if __name__ == '__main__':
-    sys.exit(main(sys.argv))
+        click.echo(mako.exceptions.text_error_template().render())

kallithea/bin/kallithea_cli_db.py

@@ -1,112 +1,79 b''
-import os
-import sys
-from paste.script.appinstall import AbstractInstallCommand
-from paste.script.command import BadCommand
-from paste.deploy import appconfig
+# -*- coding: utf-8 -*-
+# This program is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# 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 click
+import kallithea.bin.kallithea_cli_base as cli_base
 
-# Add location of top level folder to sys.path
-from os.path import dirname as dn
-rc_path = dn(dn(dn(os.path.realpath(__file__))))
-sys.path.append(rc_path)
-
-
-class Command(AbstractInstallCommand):
+import kallithea
+from kallithea.lib.db_manage import DbManage
+from kallithea.model.meta import Session
 
-    default_verbosity = 1
-    max_args = 1
-    min_args = 1
-    summary = "Setup an application, given a config file"
-    usage = "CONFIG_FILE"
-    group_name = "Kallithea"
+@cli_base.register_command(config_file=True)
[e-mail]('--user', help='Username of administrator account.')
[e-mail]('--password', help='Password for administrator account.')
[e-mail]('--email', help='Email address of administrator account.')
[e-mail]('--repos', help='Absolute path to repositories location.')
[e-mail]('--force-yes', is_flag=True, help='Answer yes to every question.')
[e-mail]('--force-no', is_flag=True, help='Answer no to every question.')
[e-mail]('--public-access/--no-public-access', default=True,
+        help='Enable/disable public access on this installation (default: enable)')
+def db_create(user, password, email, repos, force_yes, force_no, public_access):
+    """Initialize the database.
 
-    description = """\
+    Create all required tables in the database specified in the configuration
+    file. Create the administrator account. Set certain settings based on
+    values you provide.
 
-    Setup Kallithea according to its configuration file.  This is
-    the second part of a two-phase web application installation
-    process (the first phase is prepare-app).  The setup process
-    consist of things like setting up databases, creating super user
+    You can pass the answers to all questions as options to this command.
     """
+    dbconf = kallithea.CONFIG['sqlalchemy.url']
 
-    parser = AbstractInstallCommand.standard_parser(
-        simulate=True, quiet=True, interactive=True)
-    parser.add_option('--user',
-                      action='store',
-                      dest='username',
-                      default=None,
-                      help='Admin Username')
-    parser.add_option('--email',
-                      action='store',
-                      dest='email',
-                      default=None,
-                      help='Admin Email')
-    parser.add_option('--password',
-                      action='store',
-                      dest='password',
-                      default=None,
-                      help='Admin password min 6 chars')
-    parser.add_option('--repos',
-                      action='store',
-                      dest='repos_location',
-                      default=None,
-                      help='Absolute path to repositories location')
-    parser.add_option('--name',
-                      action='store',
-                      dest='section_name',
-                      default=None,
-                      help='The name of the section to set up (default: app:main)')
-    parser.add_option('--force-yes',
-                       action='store_true',
-                       dest='force_ask',
-                       default=None,
-                       help='Force yes to every question')
-    parser.add_option('--force-no',
-                       action='store_false',
-                       dest='force_ask',
-                       default=None,
-                       help='Force no to every question')
-    parser.add_option('--public-access',
-                       action='store_true',
-                       dest='public_access',
-                       default=None,
-                       help='Enable public access on this installation (default)')
-    parser.add_option('--no-public-access',
-                       action='store_false',
-                       dest='public_access',
-                       default=None,
-                       help='Disable public access on this installation ')
-    def command(self):
-        config_spec = self.args[0]
-        section = self.options.section_name
-        if section is None:
-            if '#' in config_spec:
-                config_spec, section = config_spec.split('#', 1)
-            else:
-                section = 'main'
-        if not ':' in section:
-            plain_section = section
-            section = 'app:' + section
-        else:
-            plain_section = section.split(':', 1)[0]
-        if not config_spec.startswith('config:'):
-            config_spec = 'config:' + config_spec
-        if plain_section != 'main':
-            config_spec += '#' + plain_section
-        config_file = config_spec[len('config:'):].split('#', 1)[0]
-        config_file = os.path.join(os.getcwd(), config_file)
-        self.logging_file_config(config_file)
-        conf = appconfig(config_spec, relative_to=os.getcwd())
-        ep_name = conf.context.entry_point_name
-        ep_group = conf.context.protocol
-        dist = conf.context.distribution
-        if dist is None:
-            raise BadCommand(
-                "The section %r is not the application (probably a filter).  "
-                "You should add #section_name, where section_name is the "
-                "section that configures your application" % plain_section)
-        installer = self.get_installer(dist, ep_group, ep_name)
-        installer.setup_config(
-            self, config_file, section, self.sysconfig_install_vars(installer))
-        self.call_sysconfig_functions(
-            'post_setup_hook', installer, config_file)
+    # force_ask should be True (yes), False (no), or None (ask)
+    if force_yes:
+        force_ask = True
+    elif force_no:
+        force_ask = False
+    else:
+        force_ask = None
 
-        print 'Database set up successfully.'
+    cli_args = dict(
+            username=user,
+            password=password,
+            email=email,
+            repos_location=repos,
+            force_ask=force_ask,
+            public_access=public_access,
+    )
+    dbmanage = DbManage(dbconf=dbconf, root=kallithea.CONFIG['here'],
+                        tests=False, cli_args=cli_args)
+    dbmanage.create_tables(override=True)
+    opts = dbmanage.config_prompt(None)
+    dbmanage.create_settings(opts)
+    dbmanage.create_default_user()
+    dbmanage.admin_prompt()
+    dbmanage.create_permissions()
+    dbmanage.populate_default_permissions()
+    Session().commit()
+
+    # initial repository scan
+    kallithea.config.middleware.make_app_without_logging(
+            kallithea.CONFIG.global_conf, **kallithea.CONFIG.local_conf)
+    added, _ = kallithea.lib.utils.repo2db_mapper(kallithea.model.scm.ScmModel().repo_scan())
+    if added:
+        click.echo('Initial repository scan: added following repositories:')
+        click.echo('\t%s' % '\n\t'.join(added))
+    else:
+        click.echo('Initial repository scan: no repositories found.')
+
+    click.echo('Database set up successfully.')
+    click.echo("Don't forget to build the front-end using 'kallithea-cli front-end-build'.")

kallithea/bin/kallithea_cli_extensions.py

@@ -12,70 +12,45 b''
 # You should have received a copy of the GNU General Public License
 # along with this program.  If not, see <http://www.gnu.org/licenses/>.
 """
-kallithea.lib.paster_commands.make_rcextensions
-~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-
-make-rcext paster command for Kallithea
-
-This file was forked by the Kallithea project in July 2014.
+This file was forked by the Kallithea project in July 2014 and later moved.
 Original author and date, and relevant copyright and licensing information is below:
 :created_on: Mar 6, 2012
 :author: marcink
 :copyright: (c) 2013 RhodeCode GmbH, and others.
 :license: GPLv3, see LICENSE.md for more details.
-
 """
-
+import click
+import kallithea.bin.kallithea_cli_base as cli_base
 
 import os
-import sys
 import pkg_resources
 
-from kallithea.lib.utils import BasePasterCommand, ask_ok
-
-# Add location of top level folder to sys.path
-from os.path import dirname as dn
-rc_path = dn(dn(dn(os.path.realpath(__file__))))
-sys.path.append(rc_path)
-
-
-class Command(BasePasterCommand):
+import kallithea
+from kallithea.lib.utils2 import ask_ok
 
-    max_args = 1
-    min_args = 1
-
-    group_name = "Kallithea"
-    takes_config_file = -1
-    parser = BasePasterCommand.standard_parser(verbose=True)
-    summary = "Write template file for extending Kallithea in Python."
-    usage = "CONFIG_FILE"
-    description = '''\
-        A rcextensions directory with a __init__.py file will be created next to
-        the ini file. Local customizations in that file will survive upgrades.
-        The file contains instructions on how it can be customized.
-        '''
+@cli_base.register_command(config_file=True)
+def extensions_create():
+    """Write template file for extending Kallithea in Python.
 
-    def command(self):
-        from pylons import config
+    An rcextensions directory with a __init__.py file will be created next to
+    the ini file. Local customizations in that file will survive upgrades.
+    The file contains instructions on how it can be customized.
+    """
+    here = kallithea.CONFIG['here']
+    content = pkg_resources.resource_string(
+        'kallithea', os.path.join('config', 'rcextensions', '__init__.py')
+    )
+    ext_file = os.path.join(here, 'rcextensions', '__init__.py')
+    if os.path.exists(ext_file):
+        msg = ('Extension file %s already exists, do you want '
+               'to overwrite it ? [y/n] ') % ext_file
+        if not ask_ok(msg):
+            click.echo('Nothing done, exiting...')
+            return
 
-        here = config['here']
-        content = pkg_resources.resource_string(
-            'kallithea', os.path.join('config', 'rcextensions', '__init__.py')
-        )
-        ext_file = os.path.join(here, 'rcextensions', '__init__.py')
-        if os.path.exists(ext_file):
-            msg = ('Extension file already exists, do you want '
-                   'to overwrite it ? [y/n]')
-            if not ask_ok(msg):
-                print 'Nothing done...'
-                return
-
-        dirname = os.path.dirname(ext_file)
-        if not os.path.isdir(dirname):
-            os.makedirs(dirname)
-        with open(ext_file, 'wb') as f:
-            f.write(content)
-            print 'Wrote new extensions file to %s' % ext_file
-
-    def update_parser(self):
-        pass
+    dirname = os.path.dirname(ext_file)
+    if not os.path.isdir(dirname):
+        os.makedirs(dirname)
+    with open(ext_file, 'wb') as f:
+        f.write(content)
+        click.echo('Wrote new extensions file to %s' % ext_file)

kallithea/bin/kallithea_cli_iis.py

@@ -1,43 +1,26 b''
+# -*- coding: utf-8 -*-
+# This program is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# 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 click
+import kallithea
+import kallithea.bin.kallithea_cli_base as cli_base
+
 import os
 import sys
-from paste.script.appinstall import AbstractInstallCommand
-from paste.script.command import BadCommand
 
-# Add location of top level folder to sys.path
-from os.path import dirname as dn
-rc_path = dn(dn(dn(os.path.realpath(__file__))))
-sys.path.append(rc_path)
-
-class Command(AbstractInstallCommand):
-    default_verbosity = 1
-    max_args = 1
-    min_args = 1
-    summary = 'Setup IIS given a config file'
-    usage = 'CONFIG_FILE'
-
-    description = '''
-    Script for installing into IIS using isapi-wsgi.
-    '''
-    parser = AbstractInstallCommand.standard_parser(
-        simulate=True, quiet=True, interactive=True)
-    parser.add_option('--virtualdir',
-                      action='store',
-                      dest='virtualdir',
-                      default='/',
-                      help='The virtual folder to install into on IIS')
-
-    def command(self):
-        config_spec = self.args[0]
-        if not config_spec.startswith('config:'):
-            config_spec = 'config:' + config_spec
-        config_file = config_spec[len('config:'):].split('#', 1)[0]
-        config_file = os.path.join(os.getcwd(), config_file)
-        try:
-            import isapi_wsgi
-        except ImportError:
-            raise BadCommand('missing requirement: isapi-wsgi not installed')
-
-        file = '''import sys
+dispath_py_template = '''\
+# Created by Kallithea 'kallithea-cli iis-install'
+import sys
 
 if hasattr(sys, "isapidllhandle"):
     import win32traceutil
@@ -47,7 +30,7 b' import os'
 
 def __ExtensionFactory__():
     from paste.deploy import loadapp
-    from paste.script.util.logging_config import fileConfig
+    from logging.config import fileConfig
     fileConfig('%(inifile)s')
     application = loadapp('config:%(inifile)s')
 
@@ -71,15 +54,28 b" if __name__=='__main__':"
     HandleCommandLine(params)
 '''
 
-        outdata = file % {
-                'inifile': config_file.replace('\\', '\\\\'),
-                'virtualdir': self.options.virtualdir
-                }
+@cli_base.register_command(config_file=True)
[e-mail]('--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__']
 
-        dispatchfile = os.path.join(os.getcwd(), 'dispatch.py')
-        self.ensure_file(dispatchfile, outdata, False)
-        print 'generating', dispatchfile
+    try:
+        import isapi_wsgi
+    except ImportError:
+        sys.stderr.write('missing requirement: isapi-wsgi not installed\n')
+        sys.exit(1)
 
-        print ('run \'python "%s" install\' with administrative privileges '
-            'to generate the _dispatch.dll file and install it into the '
-            'default web site') % (dispatchfile,)
+    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)

kallithea/bin/kallithea_cli_index.py

@@ -12,101 +12,51 b''
 # You should have received a copy of the GNU General Public License
 # along with this program.  If not, see <http://www.gnu.org/licenses/>.
 """
-kallithea.lib.paster_commands.make_index
-~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-
-make-index paster command for Kallithea
-
-This file was forked by the Kallithea project in July 2014.
+This file was forked by the Kallithea project in July 2014 and later moved.
 Original author and date, and relevant copyright and licensing information is below:
 :created_on: Aug 17, 2010
 :author: marcink
 :copyright: (c) 2013 RhodeCode GmbH, and others.
 :license: GPLv3, see LICENSE.md for more details.
-
 """
-
+import click
+import kallithea.bin.kallithea_cli_base as cli_base
 
 import os
+from string import strip
 import sys
-import logging
-
-from string import strip
-from kallithea.model.repo import RepoModel
-from kallithea.lib.utils import BasePasterCommand, load_rcextensions
-
-# Add location of top level folder to sys.path
-from os.path import dirname as dn
-rc_path = dn(dn(dn(os.path.realpath(__file__))))
-sys.path.append(rc_path)
-
-
-class Command(BasePasterCommand):
-
-    max_args = 1
-    min_args = 1
 
-    usage = "CONFIG_FILE"
-    group_name = "Kallithea"
-    takes_config_file = -1
-    parser = BasePasterCommand.standard_parser(verbose=True)
-    summary = "Creates or updates full text search index"
+import kallithea
+from kallithea.lib.indexers.daemon import WhooshIndexingDaemon
+from kallithea.lib.pidlock import LockHeld, DaemonLock
+from kallithea.lib.utils import load_rcextensions
+from kallithea.model.repo import RepoModel
 
-    def command(self):
-        logging.config.fileConfig(self.path_to_ini_file)
-        #get SqlAlchemy session
-        self._init_session()
-        from pylons import config
-        index_location = config['index_dir']
-        load_rcextensions(config['here'])
-
-        repo_location = self.options.repo_location \
-            if self.options.repo_location else RepoModel().repos_path
-        repo_list = map(strip, self.options.repo_list.split(',')) \
-            if self.options.repo_list else None
-
-        repo_update_list = map(strip, self.options.repo_update_list.split(',')) \
-            if self.options.repo_update_list else None
+@cli_base.register_command(config_file_initialize_app=True)
[e-mail]('--repo-location', help='Base path of repositories to index. Default: all')
[e-mail]('--index-only', help='Comma-separated list of repositories to build index on. Default: all')
[e-mail]('--update-only', help='Comma-separated list of repositories to re-build index on. Default: all')
[e-mail]('-f', '--full', 'full_index', help='Recreate the index from scratch')
+def index_create(repo_location, index_only, update_only, full_index):
+    """Create or update full text search index"""
 
-        #======================================================================
-        # WHOOSH DAEMON
-        #======================================================================
-        from kallithea.lib.pidlock import LockHeld, DaemonLock
-        from kallithea.lib.indexers.daemon import WhooshIndexingDaemon
-        try:
-            l = DaemonLock(file_=os.path.join(dn(dn(index_location)),
-                                              'make_index.lock'))
-            WhooshIndexingDaemon(index_location=index_location,
-                                 repo_location=repo_location,
-                                 repo_list=repo_list,
-                                 repo_update_list=repo_update_list)\
-                .run(full_index=self.options.full_index)
-            l.release()
-        except LockHeld:
-            sys.exit(1)
+    index_location = kallithea.CONFIG['index_dir']
+    load_rcextensions(kallithea.CONFIG['here'])
+
+    if not repo_location:
+        repo_location = RepoModel().repos_path
+    repo_list = map(strip, index_only.split(',')) \
+        if index_only else None
+    repo_update_list = map(strip, update_only.split(',')) \
+        if update_only else None
 
-    def update_parser(self):
-        self.parser.add_option('--repo-location',
-                          action='store',
-                          dest='repo_location',
-                          help="Specifies repositories location to index OPTIONAL",
-                          )
-        self.parser.add_option('--index-only',
-                          action='store',
-                          dest='repo_list',
-                          help="Specifies a comma separated list of repositories "
-                                "to build index on. If not given all repositories "
-                                "are scanned for indexing. OPTIONAL",
-                          )
-        self.parser.add_option('--update-only',
-                          action='store',
-                          dest='repo_update_list',
-                          help="Specifies a comma separated list of repositories "
-                                "to re-build index on. OPTIONAL",
-                          )
-        self.parser.add_option('-f',
-                          action='store_true',
-                          dest='full_index',
-                          help="Specifies that index should be made full i.e"
-                                " destroy old and build from scratch",
-                          default=False)
+    try:
+        l = DaemonLock(os.path.join(index_location, 'make_index.lock'))
+        WhooshIndexingDaemon(index_location=index_location,
+                             repo_location=repo_location,
+                             repo_list=repo_list,
+                             repo_update_list=repo_update_list) \
+            .run(full_index=full_index)
+        l.release()
+    except LockHeld:
+        sys.exit(1)

kallithea/bin/kallithea_cli_ishell.py

@@ -12,66 +12,30 b''
 # You should have received a copy of the GNU General Public License
 # along with this program.  If not, see <http://www.gnu.org/licenses/>.
 """
-kallithea.lib.paster_commands.ishell
-~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-
-interactive shell paster command for Kallithea
-
-This file was forked by the Kallithea project in July 2014.
+This file was forked by the Kallithea project in July 2014 and later moved.
 Original author and date, and relevant copyright and licensing information is below:
 :created_on: Apr 4, 2013
 :author: marcink
 :copyright: (c) 2013 RhodeCode GmbH, and others.
 :license: GPLv3, see LICENSE.md for more details.
 """
-
-
-import os
-import sys
-import logging
-
-from kallithea.lib.utils import BasePasterCommand
+import click
+import kallithea.bin.kallithea_cli_base as cli_base
 
-# Add location of top level folder to sys.path
-from os.path import dirname as dn
-rc_path = dn(dn(dn(os.path.realpath(__file__))))
-sys.path.append(rc_path)
+import sys
 
-log = logging.getLogger(__name__)
-
-
-class Command(BasePasterCommand):
-
-    max_args = 1
-    min_args = 1
+# make following imports directly available inside the ishell
+from kallithea.model.db import *
 
-    usage = "CONFIG_FILE"
-    group_name = "Kallithea"
-    takes_config_file = -1
-    parser = BasePasterCommand.standard_parser(verbose=True)
-    summary = "Interactive shell"
-
-    def command(self):
-        #get SqlAlchemy session
-        self._init_session()
-
-        # imports, used in ipython shell
-        import os
-        import sys
-        import time
-        import shutil
-        import datetime
-        from kallithea.model.db import *
-
-        try:
-            from IPython import embed
-            from IPython.config.loader import Config
-            cfg = Config()
-            cfg.InteractiveShellEmbed.confirm_exit = False
-            embed(config=cfg, banner1="Kallithea IShell.")
-        except ImportError:
-            print 'ipython installation required for ishell'
-            sys.exit(-1)
-
-    def update_parser(self):
-        pass
+@cli_base.register_command(config_file_initialize_app=True)
+def ishell():
+    """Interactive shell for Kallithea."""
+    try:
+        from IPython import embed
+    except ImportError:
+        print 'Kallithea ishell requires the Python package IPython 4 or later'
+        sys.exit(-1)
+    from traitlets.config.loader import Config
+    cfg = Config()
+    cfg.InteractiveShellEmbed.confirm_exit = False
+    embed(config=cfg, banner1="Kallithea IShell.")

kallithea/bin/ldap_sync.conf

@@ -3,9 +3,9 b' api_url = http://kallithea.example.com/_'
 api_user = admin
 api_key = XXXXXXXXXXXX
 
-ldap_uri = ldap://ldap.example.com:389
+ldap_uri = ldaps://ldap.example.com:636
 ldap_user = cn=kallithea,dc=example,dc=com
 ldap_key = XXXXXXXXX
 base_dn = dc=example,dc=com
 
-sync_users = True
  No newline at end of file
+sync_users = True

kallithea/bin/ldap_sync.py

@@ -207,7 +207,7 b' class LdapSync(object):'
         groups = self.ldap_client.get_groups()
         for group in groups:
             try:
-                self.kallithea_api.create_repo_group(group)
+                self.kallithea_api.create_group(group)
                 added += 1
             except Exception:
                 existing += 1

kallithea/config/conf.py

@@ -25,19 +25,21 b' Original author and date, and relevant c'
 :license: GPLv3, see LICENSE.md for more details.
 """
 
-from kallithea.lib.utils2 import __get_lem
+from kallithea.lib import pygmentsutils
 
 
 # language map is also used by whoosh indexer, which for those specified
 # extensions will index it's content
-LANGUAGES_EXTENSIONS_MAP = __get_lem()
+LANGUAGES_EXTENSIONS_MAP = pygmentsutils.get_extension_descriptions()
+
+# Whoosh index targets
 
-#==============================================================================
-# WHOOSH INDEX EXTENSIONS
-#==============================================================================
-# EXTENSIONS WE WANT TO INDEX CONTENT OFF USING WHOOSH
+# Extensions we want to index content of using whoosh
 INDEX_EXTENSIONS = LANGUAGES_EXTENSIONS_MAP.keys()
 
+# Filenames we want to index content of using whoosh
+INDEX_FILENAMES = pygmentsutils.get_index_filenames()
+
 # list of readme files to search in file tree and display in summary
 # attached weights defines the search  order lower is first
 ALL_READMES = [
@@ -65,7 +67,3 b' MARKDOWN_EXTS = ['
 PLAIN_EXTS = [('.text', 2), ('.TEXT', 2)]
 
 ALL_EXTS = MARKDOWN_EXTS + RST_EXTS + PLAIN_EXTS
-
-DATETIME_FORMAT = "%Y-%m-%d %H:%M:%S"
-
-DATE_FORMAT = "%Y-%m-%d"

kallithea/config/environment.py

@@ -11,130 +11,11 b''
 #
 # You should have received a copy of the GNU General Public License
 # along with this program.  If not, see <http://www.gnu.org/licenses/>.
-"""
-    Pylons environment configuration
-"""
-
-import os
-import logging
-import kallithea
-import platform
-
-import pylons
-import mako.lookup
-import beaker
-
-# don't remove this import it does magic for celery
-from kallithea.lib import celerypylons
-
-import kallithea.lib.app_globals as app_globals
-
-from kallithea.config.routing import make_map
-
-from kallithea.lib import helpers
-from kallithea.lib.auth import set_available_permissions
-from kallithea.lib.utils import repo2db_mapper, make_ui, set_app_settings,\
-    load_rcextensions, check_git_version, set_vcs_config
-from kallithea.lib.utils2 import engine_from_config, str2bool
-from kallithea.lib.db_manage import DbManage
-from kallithea.model import init_model
-from kallithea.model.scm import ScmModel
-
-log = logging.getLogger(__name__)
+"""WSGI environment setup for Kallithea."""
 
-
-def load_environment(global_conf, app_conf, initial=False,
-                     test_env=None, test_index=None):
-    """
-    Configure the Pylons environment via the ``pylons.config``
-    object
-    """
-    config = pylons.configuration.PylonsConfig()
-
-    # Pylons paths
-    root = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
-    paths = dict(
-        root=root,
-        controllers=os.path.join(root, 'controllers'),
-        static_files=os.path.join(root, 'public'),
-        templates=[os.path.join(root, 'templates')]
-    )
-
-    # Initialize config with the basic options
-    config.init_app(global_conf, app_conf, package='kallithea', paths=paths)
-
-    # store some globals into kallithea
-    kallithea.CELERY_ON = str2bool(config['app_conf'].get('use_celery'))
-    kallithea.CELERY_EAGER = str2bool(config['app_conf'].get('celery.always.eager'))
-
-    config['routes.map'] = make_map(config)
-    config['pylons.app_globals'] = app_globals.Globals(config)
-    config['pylons.h'] = helpers
-    kallithea.CONFIG = config
-
-    load_rcextensions(root_path=config['here'])
+from kallithea.config.app_cfg import base_config
 
-    # Setup cache object as early as possible
-    pylons.cache._push_object(config['pylons.app_globals'].cache)
-
-    # Create the Mako TemplateLookup, with the default auto-escaping
-    config['pylons.app_globals'].mako_lookup = mako.lookup.TemplateLookup(
-        directories=paths['templates'],
-        error_handler=pylons.error.handle_mako_error,
-        module_directory=os.path.join(app_conf['cache_dir'], 'templates'),
-        input_encoding='utf-8', default_filters=['escape'],
-        imports=['from webhelpers.html import escape'])
-
-    # sets the c attribute access when don't existing attribute are accessed
-    config['pylons.strict_tmpl_context'] = True
-    test = os.path.split(config['__file__'])[-1] == 'test.ini'
-    if test:
-        if test_env is None:
-            test_env = not int(os.environ.get('KALLITHEA_NO_TMP_PATH', 0))
-        if test_index is None:
-            test_index = not int(os.environ.get('KALLITHEA_WHOOSH_TEST_DISABLE', 0))
-        if os.environ.get('TEST_DB'):
-            # swap config if we pass enviroment variable
-            config['sqlalchemy.db1.url'] = os.environ.get('TEST_DB')
+__all__ = ['load_environment']
 
-        from kallithea.lib.utils import create_test_env, create_test_index
-        from kallithea.tests import TESTS_TMP_PATH
-        #set KALLITHEA_NO_TMP_PATH=1 to disable re-creating the database and
-        #test repos
-        if test_env:
-            create_test_env(TESTS_TMP_PATH, config)
-        #set KALLITHEA_WHOOSH_TEST_DISABLE=1 to disable whoosh index during tests
-        if test_index:
-            create_test_index(TESTS_TMP_PATH, config, True)
-
-    DbManage.check_waitress()
-    # MULTIPLE DB configs
-    # Setup the SQLAlchemy database engine
-    sa_engine_db1 = engine_from_config(config, 'sqlalchemy.db1.')
-    init_model(sa_engine_db1)
-
-    set_available_permissions(config)
-    repos_path = make_ui('db').configitems('paths')[0][1]
-    config['base_path'] = repos_path
-    set_app_settings(config)
-
-    instance_id = kallithea.CONFIG.get('instance_id')
-    if instance_id == '*':
-        instance_id = '%s-%s' % (platform.uname()[1], os.getpid())
-        kallithea.CONFIG['instance_id'] = instance_id
-
-    # CONFIGURATION OPTIONS HERE (note: all config options will override
-    # any Pylons config options)
-
-    # store config reference into our module to skip import magic of
-    # pylons
-    kallithea.CONFIG.update(config)
-    set_vcs_config(kallithea.CONFIG)
-
-    #check git version
-    check_git_version()
-
-    if str2bool(config.get('initial_repo_scan', True)):
-        repo2db_mapper(ScmModel().repo_scan(repos_path),
-                       remove_obsolete=False, install_git_hooks=False)
-    return config
+# Use base_config to setup the environment loader function
+load_environment = base_config.make_load_environment()

kallithea/config/middleware.py

@@ -11,102 +11,41 b''
 #
 # You should have received a copy of the GNU General Public License
 # along with this program.  If not, see <http://www.gnu.org/licenses/>.
-"""
-    Pylons middleware initialization
-"""
+"""WSGI middleware initialization for the Kallithea application."""
+
+import logging.config
+from kallithea.config.app_cfg import base_config
+from kallithea.config.environment import load_environment
+
+__all__ = ['make_app']
 
-from routes.middleware import RoutesMiddleware
-from paste.cascade import Cascade
-from paste.registry import RegistryManager
-from paste.urlparser import StaticURLParser
-from paste.deploy.converters import asbool
-from paste.gzipper import make_gzip_middleware
+# Use base_config to setup the necessary PasteDeploy application factory.
+# make_base_app will wrap the TurboGears2 app with all the middleware it needs.
+make_base_app = base_config.setup_tg_wsgi_app(load_environment)
 
-from pylons.middleware import ErrorHandler, StatusCodeRedirect
-from pylons.wsgiapp import PylonsApp
 
-from kallithea.lib.middleware.simplehg import SimpleHg
-from kallithea.lib.middleware.simplegit import SimpleGit
-from kallithea.lib.middleware.https_fixup import HttpsFixup
-from kallithea.lib.middleware.sessionmiddleware import SecureSessionMiddleware
-from kallithea.config.environment import load_environment
-from kallithea.lib.middleware.wrapper import RequestWrapper
+def make_app_without_logging(global_conf, full_stack=True, **app_conf):
+    """The core of make_app for use from gearbox commands (other than 'serve')"""
+    return make_base_app(global_conf, full_stack=full_stack, **app_conf)
 
 
-def make_app(global_conf, full_stack=True, static_files=True, **app_conf):
-    """Create a Pylons WSGI application and return it
-
-    ``global_conf``
-        The inherited configuration for this application. Normally from
-        the [DEFAULT] section of the Paste ini file.
-
-    ``full_stack``
-        Whether or not this application provides a full WSGI stack (by
-        default, meaning it handles its own exceptions and errors).
-        Disable full_stack when this application is "managed" by
-        another WSGI middleware.
-
-    ``app_conf``
-        The application's local configuration. Normally specified in
-        the [app:<name>] section of the Paste ini file (where <name>
-        defaults to main).
-
+def make_app(global_conf, full_stack=True, **app_conf):
     """
-    # Configure the Pylons environment
-    config = load_environment(global_conf, app_conf)
-
-    # The Pylons WSGI app
-    app = PylonsApp(config=config)
-
-    # Routing/Session/Cache Middleware
-    app = RoutesMiddleware(app, config['routes.map'])
-    app = SecureSessionMiddleware(app, config)
-
-    # CUSTOM MIDDLEWARE HERE (filtered by error handling middlewares)
-    if asbool(config['pdebug']):
-        from kallithea.lib.profiler import ProfilingMiddleware
-        app = ProfilingMiddleware(app)
-
-    if asbool(full_stack):
+    Set up Kallithea with the settings found in the PasteDeploy configuration
+    file used.
 
-        from kallithea.lib.middleware.sentry import Sentry
-        from kallithea.lib.middleware.appenlight import AppEnlight
-        if AppEnlight and asbool(config['app_conf'].get('appenlight')):
-            app = AppEnlight(app, config)
-        elif Sentry:
-            app = Sentry(app, config)
-
-        # Handle Python exceptions
-        app = ErrorHandler(app, global_conf, **config['pylons.errorware'])
-
-        # Display error documents for 401, 403, 404 status codes (and
-        # 500 when debug is disabled)
-        # Note: will buffer the output in memory!
-        if asbool(config['debug']):
-            app = StatusCodeRedirect(app)
-        else:
-            app = StatusCodeRedirect(app, [400, 401, 403, 404, 500])
+    :param global_conf: The global settings for Kallithea (those
+        defined under the ``[DEFAULT]`` section).
+    :type global_conf: dict
+    :param full_stack: Should the whole TurboGears2 stack be set up?
+    :type full_stack: str or bool
+    :return: The Kallithea application with all the relevant middleware
+        loaded.
 
-        # we want our low level middleware to get to the request ASAP. We don't
-        # need any pylons stack middleware in them - especially no StatusCodeRedirect buffering
-        app = SimpleHg(app, config)
-        app = SimpleGit(app, config)
-
-        # Enable https redirects based on HTTP_X_URL_SCHEME set by proxy
-        if any(asbool(config.get(x)) for x in ['https_fixup', 'force_https', 'use_htsts']):
-            app = HttpsFixup(app, config)
-
-        app = RequestWrapper(app, config) # logging
+    This is the PasteDeploy factory for the Kallithea application.
 
-    # Establish the Registry for this application
-    app = RegistryManager(app) # thread / request-local module globals / variables
-
-    if asbool(static_files):
-        # Serve static files
-        static_app = StaticURLParser(config['pylons.paths']['static_files'])
-        app = Cascade([static_app, app])
-        app = make_gzip_middleware(app, global_conf, compress_level=1)
-
-    app.config = config
-
-    return app
+    ``app_conf`` contains all the application-specific settings (those defined
+    under ``[app:main]``.
+    """
+    logging.config.fileConfig(global_conf['__file__'])
+    return make_app_without_logging(global_conf, full_stack=full_stack, **app_conf)

kallithea/config/post_receive_tmpl.py

@@ -1,34 +1,35 b''
-#!/usr/bin/env python2
+"""Kallithea Git hook
+
+This hook is installed and maintained by Kallithea. It will be overwritten
+by Kallithea - don't customize it manually!
+
+When Kallithea invokes Git, the KALLITHEA_EXTRAS environment variable will
+contain additional info like the Kallithea instance and user info that this
+hook will use.
+"""
+
 import os
 import sys
 
-try:
-    import kallithea
-    KALLITHEA_HOOK_VER = '_TMPL_'
-    os.environ['KALLITHEA_HOOK_VER'] = KALLITHEA_HOOK_VER
-    from kallithea.lib.hooks import handle_git_post_receive as _handler
-except ImportError:
-    if os.environ.get('RC_DEBUG_GIT_HOOK'):
-        import traceback
-        print traceback.format_exc()
-    kallithea = None
+# Set output mode on windows to binary for stderr.
+# This prevents python (or the windows console) from replacing \n with \r\n.
+# Git doesn't display remote output lines that contain \r,
+# and therefore without this modification git would display empty lines
+# instead of the exception output.
+if sys.platform == "win32":
+    import msvcrt
+    msvcrt.setmode(sys.stderr.fileno(), os.O_BINARY)
+
+KALLITHEA_HOOK_VER = '_TMPL_'
+os.environ['KALLITHEA_HOOK_VER'] = KALLITHEA_HOOK_VER
+import kallithea.lib.hooks
 
 
 def main():
-    if kallithea is None:
-        # exit with success if we cannot import kallithea !!
-        # this allows simply push to this repo even without
-        # kallithea
-        sys.exit(0)
+    repo_path = os.path.abspath('.')
+    git_stdin_lines = sys.stdin.readlines()
+    sys.exit(kallithea.lib.hooks.handle_git_post_receive(repo_path, git_stdin_lines))
 
-    repo_path = os.path.abspath('.')
-    push_data = sys.stdin.readlines()
-    # os.environ is modified here by a subprocess call that
-    # runs git and later git executes this hook.
-    # Environ gets some additional info from kallithea system
-    # like IP or username from basic-auth
-    _handler(repo_path, push_data, os.environ)
-    sys.exit(0)
 
 if __name__ == '__main__':
     main()

kallithea/config/pre_receive_tmpl.py

@@ -1,34 +1,35 b''
-#!/usr/bin/env python2
+"""Kallithea Git hook
+
+This hook is installed and maintained by Kallithea. It will be overwritten
+by Kallithea - don't customize it manually!
+
+When Kallithea invokes Git, the KALLITHEA_EXTRAS environment variable will
+contain additional info like the Kallithea instance and user info that this
+hook will use.
+"""
+
 import os
 import sys
 
-try:
-    import kallithea
-    KALLITHEA_HOOK_VER = '_TMPL_'
-    os.environ['KALLITHEA_HOOK_VER'] = KALLITHEA_HOOK_VER
-    from kallithea.lib.hooks import handle_git_pre_receive as _handler
-except ImportError:
-    if os.environ.get('RC_DEBUG_GIT_HOOK'):
-        import traceback
-        print traceback.format_exc()
-    kallithea = None
+# Set output mode on windows to binary for stderr.
+# This prevents python (or the windows console) from replacing \n with \r\n.
+# Git doesn't display remote output lines that contain \r,
+# and therefore without this modification git would display empty lines
+# instead of the exception output.
+if sys.platform == "win32":
+    import msvcrt
+    msvcrt.setmode(sys.stderr.fileno(), os.O_BINARY)
+
+KALLITHEA_HOOK_VER = '_TMPL_'
+os.environ['KALLITHEA_HOOK_VER'] = KALLITHEA_HOOK_VER
+import kallithea.lib.hooks
 
 
 def main():
-    if kallithea is None:
-        # exit with success if we cannot import kallithea !!
-        # this allows simply push to this repo even without
-        # kallithea
-        sys.exit(0)
+    repo_path = os.path.abspath('.')
+    git_stdin_lines = sys.stdin.readlines()
+    sys.exit(kallithea.lib.hooks.handle_git_pre_receive(repo_path, git_stdin_lines))
 
-    repo_path = os.path.abspath('.')
-    push_data = sys.stdin.readlines()
-    # os.environ is modified here by a subprocess call that
-    # runs git and later git executes this hook.
-    # Environ gets some additional info from kallithea system
-    # like IP or username from basic-auth
-    _handler(repo_path, push_data, os.environ)
-    sys.exit(0)
 
 if __name__ == '__main__':
     main()

kallithea/config/rcextensions/__init__.py

@@ -41,7 +41,7 b' def _crrepohook(*args, **kwargs):'
      :param created_on:
      :param enable_downloads:
      :param repo_id:
-     :param user_id:
+     :param owner_id:
      :param enable_statistics:
      :param clone_uri:
      :param fork_id:
@@ -49,6 +49,8 b' def _crrepohook(*args, **kwargs):'
      :param created_by:
     """
     return 0
+
+
 CREATE_REPO_HOOK = _crrepohook
 
 
@@ -73,6 +75,8 b' def _pre_cruserhook(*args, **kwargs):'
     """
     reason = 'allowed'
     return True, reason
+
+
 PRE_CREATE_USER_HOOK = _pre_cruserhook
 
 #==============================================================================
@@ -105,6 +109,8 b' def _cruserhook(*args, **kwargs):'
       :param created_by:
     """
     return 0
+
+
 CREATE_USER_HOOK = _cruserhook
 
 
@@ -123,7 +129,7 b' def _dlrepohook(*args, **kwargs):'
      :param created_on:
      :param enable_downloads:
      :param repo_id:
-     :param user_id:
+     :param owner_id:
      :param enable_statistics:
      :param clone_uri:
      :param fork_id:
@@ -132,6 +138,8 b' def _dlrepohook(*args, **kwargs):'
      :param deleted_on:
     """
     return 0
+
+
 DELETE_REPO_HOOK = _dlrepohook
 
 
@@ -165,6 +173,8 b' def _dluserhook(*args, **kwargs):'
       :param deleted_by:
     """
     return 0
+
+
 DELETE_USER_HOOK = _dluserhook
 
 
@@ -189,6 +199,8 b' def _pushhook(*args, **kwargs):'
       :param pushed_revs: list of pushed revisions
     """
     return 0
+
+
 PUSH_HOOK = _pushhook
 
 
@@ -212,4 +224,6 b' def _pullhook(*args, **kwargs):'
       :param repository: repository name
     """
     return 0
+
+
 PULL_HOOK = _pullhook

kallithea/config/routing.py

@@ -19,6 +19,7 b' may take precedent over the more generic'
 refer to the routes manual at http://routes.groovie.org/docs/
 """
 
+from tg import request
 from routes import Mapper
 
 # prefix for non repository related links needs to be prefixed with `/`
@@ -27,7 +28,7 b" ADMIN_PREFIX = '/_admin'"
 
 def make_map(config):
     """Create, configure and return the routes Mapper"""
-    rmap = Mapper(directory=config['pylons.paths']['controllers'],
+    rmap = Mapper(directory=config['paths']['controllers'],
                   always_scan=config['debug'])
     rmap.minimization = False
     rmap.explicit = False
@@ -45,7 +46,7 b' def make_map(config):'
         repo_name = match_dict.get('repo_name')
 
         if match_dict.get('f_path'):
-            #fix for multiple initial slashes that causes errors
+            # fix for multiple initial slashes that causes errors
             match_dict['f_path'] = match_dict['f_path'].lstrip('/')
 
         by_id_match = get_repo_by_id(repo_name)
@@ -89,20 +90,18 b' def make_map(config):'
     def check_int(environ, match_dict):
         return match_dict.get('id').isdigit()
 
-    # The ErrorController route (handles 404/500 error pages); it should
-    # likely stay at the top, ensuring it can always be resolved
-    rmap.connect('/error/{action}', controller='error')
-    rmap.connect('/error/{action}/{id}', controller='error')
-
     #==========================================================================
     # CUSTOM ROUTES HERE
     #==========================================================================
 
-    #MAIN PAGE
+    # MAIN PAGE
     rmap.connect('home', '/', controller='home', action='index')
     rmap.connect('about', '/about', controller='home', action='about')
+    rmap.redirect('/favicon.ico', '/images/favicon.ico')
     rmap.connect('repo_switcher_data', '/_repos', controller='home',
                  action='repo_switcher_data')
+    rmap.connect('users_and_groups_data', '/_users_and_groups', controller='home',
+                 action='users_and_groups_data')
 
     rmap.connect('rst_help',
                  "http://docutils.sourceforge.net/docs/user/rst/quickref.html",
@@ -110,7 +109,7 b' def make_map(config):'
     rmap.connect('kallithea_project_url', "https://kallithea-scm.org/", _static=True)
     rmap.connect('issues_url', 'https://bitbucket.org/conservancy/kallithea/issues', _static=True)
 
-    #ADMIN REPOSITORY ROUTES
+    # ADMIN REPOSITORY ROUTES
     with rmap.submapper(path_prefix=ADMIN_PREFIX,
                         controller='admin/repos') as m:
         m.connect("repos", "/repos",
@@ -119,14 +118,13 b' def make_map(config):'
                   action="index", conditions=dict(method=["GET"]))
         m.connect("new_repo", "/create_repository",
                   action="create_repository", conditions=dict(method=["GET"]))
-        m.connect("put_repo", "/repos/{repo_name:.*?}",
-                  action="update", conditions=dict(method=["PUT"],
+        m.connect("update_repo", "/repos/{repo_name:.*?}",
+                  action="update", conditions=dict(method=["POST"],
                   function=check_repo))
-        m.connect("delete_repo", "/repos/{repo_name:.*?}",
-                  action="delete", conditions=dict(method=["DELETE"],
-                  ))
+        m.connect("delete_repo", "/repos/{repo_name:.*?}/delete",
+                  action="delete", conditions=dict(method=["POST"]))
 
-    #ADMIN REPOSITORY GROUPS ROUTES
+    # ADMIN REPOSITORY GROUPS ROUTES
     with rmap.submapper(path_prefix=ADMIN_PREFIX,
                         controller='admin/repo_groups') as m:
         m.connect("repos_groups", "/repo_groups",
@@ -136,47 +134,40 b' def make_map(config):'
         m.connect("new_repos_group", "/repo_groups/new",
                   action="new", conditions=dict(method=["GET"]))
         m.connect("update_repos_group", "/repo_groups/{group_name:.*?}",
-                  action="update", conditions=dict(method=["PUT"],
+                  action="update", conditions=dict(method=["POST"],
                                                    function=check_group))
 
         m.connect("repos_group", "/repo_groups/{group_name:.*?}",
                   action="show", conditions=dict(method=["GET"],
                                                  function=check_group))
 
-        #EXTRAS REPO GROUP ROUTES
+        # EXTRAS REPO GROUP ROUTES
         m.connect("edit_repo_group", "/repo_groups/{group_name:.*?}/edit",
                   action="edit",
                   conditions=dict(method=["GET"], function=check_group))
-        m.connect("edit_repo_group", "/repo_groups/{group_name:.*?}/edit",
-                  action="edit",
-                  conditions=dict(method=["PUT"], function=check_group))
 
         m.connect("edit_repo_group_advanced", "/repo_groups/{group_name:.*?}/edit/advanced",
                   action="edit_repo_group_advanced",
                   conditions=dict(method=["GET"], function=check_group))
-        m.connect("edit_repo_group_advanced", "/repo_groups/{group_name:.*?}/edit/advanced",
-                  action="edit_repo_group_advanced",
-                  conditions=dict(method=["PUT"], function=check_group))
 
         m.connect("edit_repo_group_perms", "/repo_groups/{group_name:.*?}/edit/permissions",
                   action="edit_repo_group_perms",
                   conditions=dict(method=["GET"], function=check_group))
-        m.connect("edit_repo_group_perms", "/repo_groups/{group_name:.*?}/edit/permissions",
+        m.connect("edit_repo_group_perms_update", "/repo_groups/{group_name:.*?}/edit/permissions",
                   action="update_perms",
-                  conditions=dict(method=["PUT"], function=check_group))
-        m.connect("edit_repo_group_perms", "/repo_groups/{group_name:.*?}/edit/permissions",
+                  conditions=dict(method=["POST"], function=check_group))
+        m.connect("edit_repo_group_perms_delete", "/repo_groups/{group_name:.*?}/edit/permissions/delete",
                   action="delete_perms",
-                  conditions=dict(method=["DELETE"], function=check_group))
+                  conditions=dict(method=["POST"], function=check_group))
 
-        m.connect("delete_repo_group", "/repo_groups/{group_name:.*?}",
-                  action="delete", conditions=dict(method=["DELETE"],
+        m.connect("delete_repo_group", "/repo_groups/{group_name:.*?}/delete",
+                  action="delete", conditions=dict(method=["POST"],
                                                    function=check_group_skip_path))
 
-
-    #ADMIN USER ROUTES
+    # ADMIN USER ROUTES
     with rmap.submapper(path_prefix=ADMIN_PREFIX,
                         controller='admin/users') as m:
-        m.connect("users", "/users",
+        m.connect("new_user", "/users/new",
                   action="create", conditions=dict(method=["POST"]))
         m.connect("users", "/users",
                   action="index", conditions=dict(method=["GET"]))
@@ -185,47 +176,43 b' def make_map(config):'
         m.connect("new_user", "/users/new",
                   action="new", conditions=dict(method=["GET"]))
         m.connect("update_user", "/users/{id}",
-                  action="update", conditions=dict(method=["PUT"]))
-        m.connect("delete_user", "/users/{id}",
-                  action="delete", conditions=dict(method=["DELETE"]))
+                  action="update", conditions=dict(method=["POST"]))
+        m.connect("delete_user", "/users/{id}/delete",
+                  action="delete", conditions=dict(method=["POST"]))
         m.connect("edit_user", "/users/{id}/edit",
                   action="edit", conditions=dict(method=["GET"]))
-        m.connect("user", "/users/{id}",
-                  action="show", conditions=dict(method=["GET"]))
 
-        #EXTRAS USER ROUTES
+        # EXTRAS USER ROUTES
         m.connect("edit_user_advanced", "/users/{id}/edit/advanced",
                   action="edit_advanced", conditions=dict(method=["GET"]))
-        m.connect("edit_user_advanced", "/users/{id}/edit/advanced",
-                  action="update_advanced", conditions=dict(method=["PUT"]))
 
         m.connect("edit_user_api_keys", "/users/{id}/edit/api_keys",
                   action="edit_api_keys", conditions=dict(method=["GET"]))
-        m.connect("edit_user_api_keys", "/users/{id}/edit/api_keys",
+        m.connect("edit_user_api_keys_update", "/users/{id}/edit/api_keys",
                   action="add_api_key", conditions=dict(method=["POST"]))
-        m.connect("edit_user_api_keys", "/users/{id}/edit/api_keys",
-                  action="delete_api_key", conditions=dict(method=["DELETE"]))
+        m.connect("edit_user_api_keys_delete", "/users/{id}/edit/api_keys/delete",
+                  action="delete_api_key", conditions=dict(method=["POST"]))
 
         m.connect("edit_user_perms", "/users/{id}/edit/permissions",
                   action="edit_perms", conditions=dict(method=["GET"]))
-        m.connect("edit_user_perms", "/users/{id}/edit/permissions",
-                  action="update_perms", conditions=dict(method=["PUT"]))
+        m.connect("edit_user_perms_update", "/users/{id}/edit/permissions",
+                  action="update_perms", conditions=dict(method=["POST"]))
 
         m.connect("edit_user_emails", "/users/{id}/edit/emails",
                   action="edit_emails", conditions=dict(method=["GET"]))
-        m.connect("edit_user_emails", "/users/{id}/edit/emails",
-                  action="add_email", conditions=dict(method=["PUT"]))
-        m.connect("edit_user_emails", "/users/{id}/edit/emails",
-                  action="delete_email", conditions=dict(method=["DELETE"]))
+        m.connect("edit_user_emails_update", "/users/{id}/edit/emails",
+                  action="add_email", conditions=dict(method=["POST"]))
+        m.connect("edit_user_emails_delete", "/users/{id}/edit/emails/delete",
+                  action="delete_email", conditions=dict(method=["POST"]))
 
         m.connect("edit_user_ips", "/users/{id}/edit/ips",
                   action="edit_ips", conditions=dict(method=["GET"]))
-        m.connect("edit_user_ips", "/users/{id}/edit/ips",
-                  action="add_ip", conditions=dict(method=["PUT"]))
-        m.connect("edit_user_ips", "/users/{id}/edit/ips",
-                  action="delete_ip", conditions=dict(method=["DELETE"]))
+        m.connect("edit_user_ips_update", "/users/{id}/edit/ips",
+                  action="add_ip", conditions=dict(method=["POST"]))
+        m.connect("edit_user_ips_delete", "/users/{id}/edit/ips/delete",
+                  action="delete_ip", conditions=dict(method=["POST"]))
 
-    #ADMIN USER GROUPS REST ROUTES
+    # ADMIN USER GROUPS REST ROUTES
     with rmap.submapper(path_prefix=ADMIN_PREFIX,
                         controller='admin/user_groups') as m:
         m.connect("users_groups", "/user_groups",
@@ -235,28 +222,25 b' def make_map(config):'
         m.connect("new_users_group", "/user_groups/new",
                   action="new", conditions=dict(method=["GET"]))
         m.connect("update_users_group", "/user_groups/{id}",
-                  action="update", conditions=dict(method=["PUT"]))
-        m.connect("delete_users_group", "/user_groups/{id}",
-                  action="delete", conditions=dict(method=["DELETE"]))
+                  action="update", conditions=dict(method=["POST"]))
+        m.connect("delete_users_group", "/user_groups/{id}/delete",
+                  action="delete", conditions=dict(method=["POST"]))
         m.connect("edit_users_group", "/user_groups/{id}/edit",
                   action="edit", conditions=dict(method=["GET"]),
                   function=check_user_group)
-        m.connect("users_group", "/user_groups/{id}",
-                  action="show", conditions=dict(method=["GET"]))
 
-        #EXTRAS USER GROUP ROUTES
+        # EXTRAS USER GROUP ROUTES
         m.connect("edit_user_group_default_perms", "/user_groups/{id}/edit/default_perms",
                   action="edit_default_perms", conditions=dict(method=["GET"]))
-        m.connect("edit_user_group_default_perms", "/user_groups/{id}/edit/default_perms",
-                  action="update_default_perms", conditions=dict(method=["PUT"]))
-
+        m.connect("edit_user_group_default_perms_update", "/user_groups/{id}/edit/default_perms",
+                  action="update_default_perms", conditions=dict(method=["POST"]))
 
         m.connect("edit_user_group_perms", "/user_groups/{id}/edit/perms",
                   action="edit_perms", conditions=dict(method=["GET"]))
-        m.connect("edit_user_group_perms", "/user_groups/{id}/edit/perms",
-                  action="update_perms", conditions=dict(method=["PUT"]))
-        m.connect("edit_user_group_perms", "/user_groups/{id}/edit/perms",
-                  action="delete_perms", conditions=dict(method=["DELETE"]))
+        m.connect("edit_user_group_perms_update", "/user_groups/{id}/edit/perms",
+                  action="update_perms", conditions=dict(method=["POST"]))
+        m.connect("edit_user_group_perms_delete", "/user_groups/{id}/edit/perms/delete",
+                  action="delete_perms", conditions=dict(method=["POST"]))
 
         m.connect("edit_user_group_advanced", "/user_groups/{id}/edit/advanced",
                   action="edit_advanced", conditions=dict(method=["GET"]))
@@ -264,9 +248,7 b' def make_map(config):'
         m.connect("edit_user_group_members", "/user_groups/{id}/edit/members",
                   action="edit_members", conditions=dict(method=["GET"]))
 
-
-
-    #ADMIN PERMISSIONS ROUTES
+    # ADMIN PERMISSIONS ROUTES
     with rmap.submapper(path_prefix=ADMIN_PREFIX,
                         controller='admin/permissions') as m:
         m.connect("admin_permissions", "/permissions",
@@ -275,28 +257,27 b' def make_map(config):'
                   action="permission_globals", conditions=dict(method=["GET"]))
 
         m.connect("admin_permissions_ips", "/permissions/ips",
-                  action="permission_ips", conditions=dict(method=["POST"]))
-        m.connect("admin_permissions_ips", "/permissions/ips",
                   action="permission_ips", conditions=dict(method=["GET"]))
 
         m.connect("admin_permissions_perms", "/permissions/perms",
-                  action="permission_perms", conditions=dict(method=["POST"]))
-        m.connect("admin_permissions_perms", "/permissions/perms",
                   action="permission_perms", conditions=dict(method=["GET"]))
 
+    # ADMIN DEFAULTS ROUTES
+    with rmap.submapper(path_prefix=ADMIN_PREFIX,
+                        controller='admin/defaults') as m:
+        m.connect('defaults', 'defaults',
+                  action="index")
+        m.connect('defaults_update', 'defaults/{id}/update',
+                  action="update", conditions=dict(method=["POST"]))
 
-    #ADMIN DEFAULTS REST ROUTES
-    rmap.resource('default', 'defaults',
-                  controller='admin/defaults', path_prefix=ADMIN_PREFIX)
-
-    #ADMIN AUTH SETTINGS
+    # ADMIN AUTH SETTINGS
     rmap.connect('auth_settings', '%s/auth' % ADMIN_PREFIX,
                  controller='admin/auth_settings', action='auth_settings',
                  conditions=dict(method=["POST"]))
     rmap.connect('auth_home', '%s/auth' % ADMIN_PREFIX,
                  controller='admin/auth_settings')
 
-    #ADMIN SETTINGS ROUTES
+    # ADMIN SETTINGS ROUTES
     with rmap.submapper(path_prefix=ADMIN_PREFIX,
                         controller='admin/settings') as m:
         m.connect("admin_settings", "/settings",
@@ -326,8 +307,8 b' def make_map(config):'
 
         m.connect("admin_settings_hooks", "/settings/hooks",
                   action="settings_hooks", conditions=dict(method=["POST"]))
-        m.connect("admin_settings_hooks", "/settings/hooks",
-                  action="settings_hooks", conditions=dict(method=["DELETE"]))
+        m.connect("admin_settings_hooks_delete", "/settings/hooks/delete",
+                  action="settings_hooks", conditions=dict(method=["POST"]))
         m.connect("admin_settings_hooks", "/settings/hooks",
                   action="settings_hooks", conditions=dict(method=["GET"]))
 
@@ -343,7 +324,7 b' def make_map(config):'
         m.connect("admin_settings_system_update", "/settings/system/updates",
                   action="settings_system_update", conditions=dict(method=["GET"]))
 
-    #ADMIN MY ACCOUNT
+    # ADMIN MY ACCOUNT
     with rmap.submapper(path_prefix=ADMIN_PREFIX,
                         controller='admin/my_account') as m:
 
@@ -370,46 +351,17 b' def make_map(config):'
                   action="my_account_emails", conditions=dict(method=["GET"]))
         m.connect("my_account_emails", "/my_account/emails",
                   action="my_account_emails_add", conditions=dict(method=["POST"]))
-        m.connect("my_account_emails", "/my_account/emails",
-                  action="my_account_emails_delete", conditions=dict(method=["DELETE"]))
+        m.connect("my_account_emails_delete", "/my_account/emails/delete",
+                  action="my_account_emails_delete", conditions=dict(method=["POST"]))
 
         m.connect("my_account_api_keys", "/my_account/api_keys",
                   action="my_account_api_keys", conditions=dict(method=["GET"]))
         m.connect("my_account_api_keys", "/my_account/api_keys",
                   action="my_account_api_keys_add", conditions=dict(method=["POST"]))
-        m.connect("my_account_api_keys", "/my_account/api_keys",
-                  action="my_account_api_keys_delete", conditions=dict(method=["DELETE"]))
+        m.connect("my_account_api_keys_delete", "/my_account/api_keys/delete",
+                  action="my_account_api_keys_delete", conditions=dict(method=["POST"]))
 
-    #NOTIFICATION REST ROUTES
-    with rmap.submapper(path_prefix=ADMIN_PREFIX,
-                        controller='admin/notifications') as m:
-        m.connect("notifications", "/notifications",
-                  action="create", conditions=dict(method=["POST"]))
-        m.connect("notifications", "/notifications",
-                  action="index", conditions=dict(method=["GET"]))
-        m.connect("notifications_mark_all_read", "/notifications/mark_all_read",
-                  action="mark_all_read", conditions=dict(method=["GET"]))
-        m.connect("formatted_notifications", "/notifications.{format}",
-                  action="index", conditions=dict(method=["GET"]))
-        m.connect("new_notification", "/notifications/new",
-                  action="new", conditions=dict(method=["GET"]))
-        m.connect("formatted_new_notification", "/notifications/new.{format}",
-                  action="new", conditions=dict(method=["GET"]))
-        m.connect("/notifications/{notification_id}",
-                  action="update", conditions=dict(method=["PUT"]))
-        m.connect("/notifications/{notification_id}",
-                  action="delete", conditions=dict(method=["DELETE"]))
-        m.connect("edit_notification", "/notifications/{notification_id}/edit",
-                  action="edit", conditions=dict(method=["GET"]))
-        m.connect("formatted_edit_notification",
-                  "/notifications/{notification_id}.{format}/edit",
-                  action="edit", conditions=dict(method=["GET"]))
-        m.connect("notification", "/notifications/{notification_id}",
-                  action="show", conditions=dict(method=["GET"]))
-        m.connect("formatted_notification", "/notifications/{notification_id}.{format}",
-                  action="show", conditions=dict(method=["GET"]))
-
-    #ADMIN GIST
+    # ADMIN GIST
     with rmap.submapper(path_prefix=ADMIN_PREFIX,
                         controller='admin/gists') as m:
         m.connect("gists", "/gists",
@@ -419,17 +371,13 b' def make_map(config):'
         m.connect("new_gist", "/gists/new",
                   action="new", conditions=dict(method=["GET"]))
 
-
-        m.connect("/gists/{gist_id}",
-                  action="update", conditions=dict(method=["PUT"]))
-        m.connect("/gists/{gist_id}",
-                  action="delete", conditions=dict(method=["DELETE"]))
+        m.connect("gist_delete", "/gists/{gist_id}/delete",
+                  action="delete", conditions=dict(method=["POST"]))
         m.connect("edit_gist", "/gists/{gist_id}/edit",
                   action="edit", conditions=dict(method=["GET", "POST"]))
         m.connect("edit_gist_check_revision", "/gists/{gist_id}/edit/check_revision",
                   action="check_revision", conditions=dict(method=["POST"]))
 
-
         m.connect("gist", "/gists/{gist_id}",
                   action="show", conditions=dict(method=["GET"]))
         m.connect("gist_rev", "/gists/{gist_id}/{revision}",
@@ -442,7 +390,7 b' def make_map(config):'
                   revision='tip',
                   action="show", conditions=dict(method=["GET"]))
 
-    #ADMIN MAIN PAGES
+    # ADMIN MAIN PAGES
     with rmap.submapper(path_prefix=ADMIN_PREFIX,
                         controller='admin/admin') as m:
         m.connect('admin_home', '', action='index')
@@ -451,11 +399,11 b' def make_map(config):'
     #==========================================================================
     # API V2
     #==========================================================================
-    with rmap.submapper(path_prefix=ADMIN_PREFIX,
-                        controller='api/api') as m:
+    with rmap.submapper(path_prefix=ADMIN_PREFIX, controller='api/api',
+                        action='_dispatch') as m:
         m.connect('api', '/api')
 
-    #USER JOURNAL
+    # USER JOURNAL
     rmap.connect('journal', '%s/journal' % ADMIN_PREFIX,
                  controller='journal', action='index')
     rmap.connect('journal_rss', '%s/journal/rss' % ADMIN_PREFIX,
@@ -484,7 +432,7 b' def make_map(config):'
                  controller='journal', action='toggle_following',
                  conditions=dict(method=["POST"]))
 
-    #SEARCH
+    # SEARCH
     rmap.connect('search', '%s/search' % ADMIN_PREFIX, controller='search',)
     rmap.connect('search_repo_admin', '%s/search/{repo_name:.*}' % ADMIN_PREFIX,
                  controller='search',
@@ -494,7 +442,7 b' def make_map(config):'
                  conditions=dict(function=check_repo),
                  )
 
-    #LOGIN/LOGOUT/REGISTER/SIGN IN
+    # LOGIN/LOGOUT/REGISTER/SIGN IN
     rmap.connect('authentication_token', '%s/authentication_token' % ADMIN_PREFIX, controller='login', action='authentication_token')
     rmap.connect('login_home', '%s/login' % ADMIN_PREFIX, controller='login')
     rmap.connect('logout_home', '%s/logout' % ADMIN_PREFIX, controller='login',
@@ -510,7 +458,7 b' def make_map(config):'
                  '%s/password_reset_confirmation' % ADMIN_PREFIX,
                  controller='login', action='password_reset_confirmation')
 
-    #FEEDS
+    # FEEDS
     rmap.connect('rss_feed_home', '/{repo_name:.*?}/feed/rss',
                 controller='feed', action='rss',
                 conditions=dict(function=check_repo))
@@ -543,8 +491,6 b' def make_map(config):'
                 controller='summary', action='repo_size',
                 conditions=dict(function=check_repo))
 
-    rmap.connect('branch_tag_switcher', '/{repo_name:.*?}/branches-tags',
-                 controller='home', action='branch_tag_switcher')
     rmap.connect('repo_refs_data', '/{repo_name:.*?}/refs-data',
                  controller='home', action='repo_refs_data')
 
@@ -568,21 +514,20 b' def make_map(config):'
                  conditions=dict(method=["GET"], function=check_repo))
     rmap.connect("edit_repo_perms_update", "/{repo_name:.*?}/settings/permissions",
                  controller='admin/repos', action="edit_permissions_update",
-                 conditions=dict(method=["PUT"], function=check_repo))
-    rmap.connect("edit_repo_perms_revoke", "/{repo_name:.*?}/settings/permissions",
+                 conditions=dict(method=["POST"], function=check_repo))
+    rmap.connect("edit_repo_perms_revoke", "/{repo_name:.*?}/settings/permissions/delete",
                  controller='admin/repos', action="edit_permissions_revoke",
-                 conditions=dict(method=["DELETE"], function=check_repo))
+                 conditions=dict(method=["POST"], function=check_repo))
 
     rmap.connect("edit_repo_fields", "/{repo_name:.*?}/settings/fields",
                  controller='admin/repos', action="edit_fields",
                  conditions=dict(method=["GET"], function=check_repo))
     rmap.connect('create_repo_fields', "/{repo_name:.*?}/settings/fields/new",
                  controller='admin/repos', action="create_repo_field",
-                 conditions=dict(method=["PUT"], function=check_repo))
-    rmap.connect('delete_repo_fields', "/{repo_name:.*?}/settings/fields/{field_id}",
+                 conditions=dict(method=["POST"], function=check_repo))
+    rmap.connect('delete_repo_fields', "/{repo_name:.*?}/settings/fields/{field_id}/delete",
                  controller='admin/repos', action="delete_repo_field",
-                 conditions=dict(method=["DELETE"], function=check_repo))
-
+                 conditions=dict(method=["POST"], function=check_repo))
 
     rmap.connect("edit_repo_advanced", "/{repo_name:.*?}/settings/advanced",
                  controller='admin/repos', action="edit_advanced",
@@ -590,43 +535,41 b' def make_map(config):'
 
     rmap.connect("edit_repo_advanced_locking", "/{repo_name:.*?}/settings/advanced/locking",
                  controller='admin/repos', action="edit_advanced_locking",
-                 conditions=dict(method=["PUT"], function=check_repo))
+                 conditions=dict(method=["POST"], function=check_repo))
     rmap.connect('toggle_locking', "/{repo_name:.*?}/settings/advanced/locking_toggle",
                  controller='admin/repos', action="toggle_locking",
                  conditions=dict(method=["GET"], function=check_repo))
 
     rmap.connect("edit_repo_advanced_journal", "/{repo_name:.*?}/settings/advanced/journal",
                  controller='admin/repos', action="edit_advanced_journal",
-                 conditions=dict(method=["PUT"], function=check_repo))
+                 conditions=dict(method=["POST"], function=check_repo))
 
     rmap.connect("edit_repo_advanced_fork", "/{repo_name:.*?}/settings/advanced/fork",
                  controller='admin/repos', action="edit_advanced_fork",
-                 conditions=dict(method=["PUT"], function=check_repo))
-
+                 conditions=dict(method=["POST"], function=check_repo))
 
     rmap.connect("edit_repo_caches", "/{repo_name:.*?}/settings/caches",
                  controller='admin/repos', action="edit_caches",
                  conditions=dict(method=["GET"], function=check_repo))
-    rmap.connect("edit_repo_caches", "/{repo_name:.*?}/settings/caches",
+    rmap.connect("update_repo_caches", "/{repo_name:.*?}/settings/caches",
                  controller='admin/repos', action="edit_caches",
-                 conditions=dict(method=["PUT"], function=check_repo))
-
+                 conditions=dict(method=["POST"], function=check_repo))
 
     rmap.connect("edit_repo_remote", "/{repo_name:.*?}/settings/remote",
                  controller='admin/repos', action="edit_remote",
                  conditions=dict(method=["GET"], function=check_repo))
-    rmap.connect("edit_repo_remote", "/{repo_name:.*?}/settings/remote",
+    rmap.connect("edit_repo_remote_update", "/{repo_name:.*?}/settings/remote",
                  controller='admin/repos', action="edit_remote",
-                 conditions=dict(method=["PUT"], function=check_repo))
+                 conditions=dict(method=["POST"], function=check_repo))
 
     rmap.connect("edit_repo_statistics", "/{repo_name:.*?}/settings/statistics",
                  controller='admin/repos', action="edit_statistics",
                  conditions=dict(method=["GET"], function=check_repo))
-    rmap.connect("edit_repo_statistics", "/{repo_name:.*?}/settings/statistics",
+    rmap.connect("edit_repo_statistics_update", "/{repo_name:.*?}/settings/statistics",
                  controller='admin/repos', action="edit_statistics",
-                 conditions=dict(method=["PUT"], function=check_repo))
+                 conditions=dict(method=["POST"], function=check_repo))
 
-    #still working url for backward compat.
+    # still working url for backward compat.
     rmap.connect('raw_changeset_home_depraced',
                  '/{repo_name:.*?}/raw-changeset/{revision}',
                  controller='changeset', action='changeset_raw',
@@ -653,16 +596,11 b' def make_map(config):'
                 controller='changeset', revision='tip', action='comment',
                 conditions=dict(function=check_repo))
 
-    rmap.connect('changeset_comment_preview',
-                 '/{repo_name:.*?}/changeset-comment-preview',
-                controller='changeset', action='preview_comment',
+    rmap.connect('changeset_comment_delete',
+                 '/{repo_name:.*?}/changeset-comment/{comment_id}/delete',
+                controller='changeset', action='delete_comment',
                 conditions=dict(function=check_repo, method=["POST"]))
 
-    rmap.connect('changeset_comment_delete',
-                 '/{repo_name:.*?}/changeset-comment-delete/{comment_id}',
-                controller='changeset', action='delete_comment',
-                conditions=dict(function=check_repo, method=["DELETE"]))
-
     rmap.connect('changeset_info', '/changeset_info/{repo_name:.*?}/{revision}',
                  controller='changeset', action='changeset_info')
 
@@ -706,10 +644,10 b' def make_map(config):'
                  action='post', conditions=dict(function=check_repo,
                                                 method=["POST"]))
     rmap.connect('pullrequest_delete',
-                 '/{repo_name:.*?}/pull-request/{pull_request_id}',
+                 '/{repo_name:.*?}/pull-request/{pull_request_id}/delete',
                  controller='pullrequests',
                  action='delete', conditions=dict(function=check_repo,
-                                                method=["DELETE"]))
+                                                  method=["POST"]))
 
     rmap.connect('pullrequest_show_all',
                  '/{repo_name:.*?}/pull-request',
@@ -731,27 +669,14 b' def make_map(config):'
     rmap.connect('pullrequest_comment_delete',
                  '/{repo_name:.*?}/pull-request-comment/{comment_id}/delete',
                 controller='pullrequests', action='delete_comment',
-                conditions=dict(function=check_repo, method=["DELETE"]))
+                conditions=dict(function=check_repo, method=["POST"]))
 
     rmap.connect('summary_home_summary', '/{repo_name:.*?}/summary',
                 controller='summary', conditions=dict(function=check_repo))
 
-    rmap.connect('branches_home', '/{repo_name:.*?}/branches',
-                controller='branches', conditions=dict(function=check_repo))
-
-    rmap.connect('tags_home', '/{repo_name:.*?}/tags',
-                controller='tags', conditions=dict(function=check_repo))
-
-    rmap.connect('bookmarks_home', '/{repo_name:.*?}/bookmarks',
-                controller='bookmarks', conditions=dict(function=check_repo))
-
     rmap.connect('changelog_home', '/{repo_name:.*?}/changelog',
                 controller='changelog', conditions=dict(function=check_repo))
 
-    rmap.connect('changelog_summary_home', '/{repo_name:.*?}/changelog_summary',
-                controller='changelog', action='changelog_summary',
-                conditions=dict(function=check_repo))
-
     rmap.connect('changelog_file_home', '/{repo_name:.*?}/changelog/{revision}/{f_path:.*}',
                 controller='changelog', f_path=None,
                 conditions=dict(function=check_repo))
@@ -842,3 +767,29 b' def make_map(config):'
                  conditions=dict(function=check_repo))
 
     return rmap
+
+
+class UrlGenerator(object):
+    """Emulate pylons.url in providing a wrapper around routes.url
+
+    This code was added during migration from Pylons to Turbogears2. Pylons
+    already provided a wrapper like this, but Turbogears2 does not.
+
+    When the routing of Kallithea is changed to use less Routes and more
+    Turbogears2-style routing, this class may disappear or change.
+
+    url() (the __call__ method) returns the URL based on a route name and
+    arguments.
+    url.current() returns the URL of the current page with arguments applied.
+
+    Refer to documentation of Routes for details:
+    https://routes.readthedocs.io/en/latest/generating.html#generation
+    """
+    def __call__(self, *args, **kwargs):
+        return request.environ['routes.url'](*args, **kwargs)
+
+    def current(self, *args, **kwargs):
+        return request.environ['routes.url'].current(*args, **kwargs)
+
+
+url = UrlGenerator()

kallithea/controllers/admin/admin.py

@@ -28,19 +28,20 b' Original author and date, and relevant c'
 
 import logging
 
-from pylons import request, tmpl_context as c, url
+from tg import request, tmpl_context as c
 from sqlalchemy.orm import joinedload
 from whoosh.qparser.default import QueryParser
 from whoosh.qparser.dateparse import DateParserPlugin
 from whoosh import query
 from sqlalchemy.sql.expression import or_, and_, func
 
+from kallithea.config.routing import url
 from kallithea.model.db import UserLog
-from kallithea.lib.auth import LoginRequired, HasPermissionAllDecorator
+from kallithea.lib.auth import LoginRequired, HasPermissionAnyDecorator
 from kallithea.lib.base import BaseController, render
 from kallithea.lib.utils2 import safe_int, remove_prefix, remove_suffix
 from kallithea.lib.indexers import JOURNAL_SCHEMA
-from kallithea.lib.helpers import Page
+from kallithea.lib.page import Page
 
 
 log = logging.getLogger(__name__)
@@ -64,14 +65,14 b' def _journal_filter(user_log, search_ter'
 
     def wildcard_handler(col, wc_term):
         if wc_term.startswith('*') and not wc_term.endswith('*'):
-            #postfix == endswith
+            # postfix == endswith
             wc_term = remove_prefix(wc_term, prefix='*')
-            return func.lower(col).endswith(wc_term)
+            return func.lower(col).endswith(func.lower(wc_term))
         elif wc_term.startswith('*') and wc_term.endswith('*'):
-            #wildcard == ilike
+            # wildcard == ilike
             wc_term = remove_prefix(wc_term, prefix='*')
             wc_term = remove_suffix(wc_term, suffix='*')
-            return func.lower(col).contains(wc_term)
+            return func.lower(col).contains(func.lower(wc_term))
 
     def get_filterion(field, val, term):
 
@@ -87,7 +88,7 b' def _journal_filter(user_log, search_ter'
             field = getattr(UserLog, field)
         log.debug('filter field: %s val=>%s', field, val)
 
-        #sql filtering
+        # sql filtering
         if isinstance(term, query.Wildcard):
             return wildcard_handler(field, val)
         elif isinstance(term, query.Prefix):
@@ -119,23 +120,23 b' def _journal_filter(user_log, search_ter'
 
 class AdminController(BaseController):
 
-    @LoginRequired()
-    def __before__(self):
-        super(AdminController, self).__before__()
+    @LoginRequired(allow_default_user=True)
+    def _before(self, *args, **kwargs):
+        super(AdminController, self)._before(*args, **kwargs)
 
-    @HasPermissionAllDecorator('hg.admin')
+    @HasPermissionAnyDecorator('hg.admin')
     def index(self):
-        users_log = UserLog.query()\
-                .options(joinedload(UserLog.user))\
+        users_log = UserLog.query() \
+                .options(joinedload(UserLog.user)) \
                 .options(joinedload(UserLog.repository))
 
-        #FILTERING
+        # FILTERING
         c.search_term = request.GET.get('filter')
         users_log = _journal_filter(users_log, c.search_term)
 
         users_log = users_log.order_by(UserLog.action_date.desc())
 
-        p = safe_int(request.GET.get('page', 1), 1)
+        p = safe_int(request.GET.get('page'), 1)
 
         def url_generator(**kw):
             return url.current(filter=c.search_term, **kw)

kallithea/controllers/admin/auth_settings.py

@@ -27,14 +27,15 b' import logging'
 import formencode.htmlfill
 import traceback
 
-from pylons import request, tmpl_context as c, url
-from pylons.controllers.util import redirect
-from pylons.i18n.translation import _
+from tg import request, tmpl_context as c
+from tg.i18n import ugettext as _
+from webob.exc import HTTPFound
 
+from kallithea.config.routing import url
 from kallithea.lib import helpers as h
 from kallithea.lib.compat import formatted_json
 from kallithea.lib.base import BaseController, render
-from kallithea.lib.auth import LoginRequired, HasPermissionAllDecorator
+from kallithea.lib.auth import LoginRequired, HasPermissionAnyDecorator
 from kallithea.lib import auth_modules
 from kallithea.model.forms import AuthSettingsForm
 from kallithea.model.db import Setting
@@ -46,9 +47,9 b' log = logging.getLogger(__name__)'
 class AuthSettingsController(BaseController):
 
     @LoginRequired()
-    @HasPermissionAllDecorator('hg.admin')
-    def __before__(self):
-        super(AuthSettingsController, self).__before__()
+    @HasPermissionAnyDecorator('hg.admin')
+    def _before(self, *args, **kwargs):
+        super(AuthSettingsController, self)._before(*args, **kwargs)
 
     def __load_defaults(self):
         c.available_plugins = [
@@ -58,32 +59,32 b' class AuthSettingsController(BaseControl'
             'kallithea.lib.auth_modules.auth_crowd',
             'kallithea.lib.auth_modules.auth_pam'
         ]
-        c.enabled_plugins = Setting.get_auth_plugins()
+        self.enabled_plugins = auth_modules.get_auth_plugins()
+        c.enabled_plugin_names = [plugin.__class__.__module__ for plugin in self.enabled_plugins]
 
     def __render(self, defaults, errors):
         c.defaults = {}
         c.plugin_settings = {}
         c.plugin_shortnames = {}
 
-        for module in c.enabled_plugins:
-            plugin = auth_modules.loadplugin(module)
-            plugin_name = plugin.name
-            c.plugin_shortnames[module] = plugin_name
+        for plugin in self.enabled_plugins:
+            module = plugin.__class__.__module__
+            c.plugin_shortnames[module] = plugin.name
             c.plugin_settings[module] = plugin.plugin_settings()
             for v in c.plugin_settings[module]:
-                fullname = ("auth_" + plugin_name + "_" + v["name"])
+                fullname = "auth_%s_%s" % (plugin.name, v["name"])
                 if "default" in v:
                     c.defaults[fullname] = v["default"]
                 # Current values will be the default on the form, if there are any
                 setting = Setting.get_by_name(fullname)
                 if setting is not None:
                     c.defaults[fullname] = setting.app_settings_value
-        # we want to show , separated list of enabled plugins
-        c.defaults['auth_plugins'] = ','.join(c.enabled_plugins)
-
         if defaults:
             c.defaults.update(defaults)
 
+        # we want to show , separated list of enabled plugins
+        c.defaults['auth_plugins'] = ','.join(c.enabled_plugin_names)
+
         log.debug(formatted_json(defaults))
         return formencode.htmlfill.render(
             render('admin/auth/auth_settings.html'),
@@ -117,10 +118,10 b' class AuthSettingsController(BaseControl'
             # (yet), since that'll cause validation errors and/or wrong
             # settings being applied (e.g. checkboxes being cleared),
             # since the plugin settings will not be in the POST data.
-            c.enabled_plugins = [ p for p in c.enabled_plugins if p in new_enabled_plugins ]
+            c.enabled_plugin_names = [p for p in c.enabled_plugin_names if p in new_enabled_plugins]
 
         # Next, parse everything including plugin settings.
-        _form = AuthSettingsForm(c.enabled_plugins)()
+        _form = AuthSettingsForm(c.enabled_plugin_names)()
 
         try:
             form_result = _form.to_python(dict(request.POST))
@@ -130,7 +131,6 b' class AuthSettingsController(BaseControl'
                     v = ','.join(v)
                 log.debug("%s = %s", k, str(v))
                 setting = Setting.create_or_update(k, v)
-                Session().add(setting)
             Session().commit()
             h.flash(_('Auth settings updated successfully'),
                        category='success')
@@ -146,4 +146,4 b' class AuthSettingsController(BaseControl'
             h.flash(_('error occurred during update of auth settings'),
                     category='error')
 
-        return redirect(url('auth_home'))
+        raise HTTPFound(location=url('auth_home'))

kallithea/controllers/admin/defaults.py

@@ -30,12 +30,13 b' import traceback'
 import formencode
 from formencode import htmlfill
 
-from pylons import request, tmpl_context as c, url
-from pylons.controllers.util import redirect
-from pylons.i18n.translation import _
+from tg import request, tmpl_context as c
+from tg.i18n import ugettext as _
+from webob.exc import HTTPFound
 
+from kallithea.config.routing import url
 from kallithea.lib import helpers as h
-from kallithea.lib.auth import LoginRequired, HasPermissionAllDecorator
+from kallithea.lib.auth import LoginRequired, HasPermissionAnyDecorator
 from kallithea.lib.base import BaseController, render
 from kallithea.model.forms import DefaultsForm
 from kallithea.model.meta import Session
@@ -46,19 +47,13 b' log = logging.getLogger(__name__)'
 
 
 class DefaultsController(BaseController):
-    """REST Controller styled on the Atom Publishing Protocol"""
-    # To properly map this controller, ensure your config/routing.py
-    # file has a resource setup:
-    #     map.resource('default', 'defaults')
 
     @LoginRequired()
-    @HasPermissionAllDecorator('hg.admin')
-    def __before__(self):
-        super(DefaultsController, self).__before__()
+    @HasPermissionAnyDecorator('hg.admin')
+    def _before(self, *args, **kwargs):
+        super(DefaultsController, self)._before(*args, **kwargs)
 
     def index(self, format='html'):
-        """GET /defaults: All items in the collection"""
-        # url('defaults')
         c.backends = BACKENDS.keys()
         defaults = Setting.get_default_repo_settings()
 
@@ -69,30 +64,13 b' class DefaultsController(BaseController)'
             force_defaults=False
         )
 
-    def create(self):
-        """POST /defaults: Create a new item"""
-        # url('defaults')
-
-    def new(self, format='html'):
-        """GET /defaults/new: Form to create a new item"""
-        # url('new_default')
-
     def update(self, id):
-        """PUT /defaults/id: Update an existing item"""
-        # Forms posted to this method should contain a hidden field:
-        #    <input type="hidden" name="_method" value="PUT" />
-        # Or using helpers:
-        #    h.form(url('default', id=ID),
-        #           method='put')
-        # url('default', id=ID)
-
         _form = DefaultsForm()()
 
         try:
             form_result = _form.to_python(dict(request.POST))
             for k, v in form_result.iteritems():
                 setting = Setting.create_or_update(k, v)
-                Session().add(setting)
             Session().commit()
             h.flash(_('Default settings updated successfully'),
                     category='success')
@@ -112,21 +90,4 b' class DefaultsController(BaseController)'
             h.flash(_('Error occurred during update of defaults'),
                     category='error')
 
-        return redirect(url('defaults'))
-
-    def delete(self, id):
-        """DELETE /defaults/id: Delete an existing item"""
-        # Forms posted to this method should contain a hidden field:
-        #    <input type="hidden" name="_method" value="DELETE" />
-        # Or using helpers:
-        #    h.form(url('default', id=ID),
-        #           method='delete')
-        # url('default', id=ID)
-
-    def show(self, id, format='html'):
-        """GET /defaults/id: Show a specific item"""
-        # url('default', id=ID)
-
-    def edit(self, id, format='html'):
-        """GET /defaults/id/edit: Form to edit an existing item"""
-        # url('edit_default', id=ID)
+        raise HTTPFound(location=url('defaults'))

kallithea/controllers/admin/gists.py

@@ -30,21 +30,20 b' import logging'
 import traceback
 import formencode.htmlfill
 
-from pylons import request, response, tmpl_context as c, url
-from pylons.controllers.util import redirect
-from pylons.i18n.translation import _
+from tg import request, response, tmpl_context as c
+from tg.i18n import ugettext as _
+from webob.exc import HTTPFound, HTTPNotFound, HTTPForbidden
 
+from kallithea.config.routing import url
 from kallithea.model.forms import GistForm
 from kallithea.model.gist import GistModel
 from kallithea.model.meta import Session
 from kallithea.model.db import Gist, User
 from kallithea.lib import helpers as h
-from kallithea.lib.base import BaseController, render
-from kallithea.lib.auth import LoginRequired, NotAnonymous
-from kallithea.lib.utils import jsonify
+from kallithea.lib.base import BaseController, render, jsonify
+from kallithea.lib.auth import LoginRequired
 from kallithea.lib.utils2 import safe_int, safe_unicode, time_to_datetime
-from kallithea.lib.helpers import Page
-from webob.exc import HTTPNotFound, HTTPForbidden
+from kallithea.lib.page import Page
 from sqlalchemy.sql.expression import or_
 from kallithea.lib.vcs.exceptions import VCSError, NodeNotChangedError
 
@@ -66,52 +65,47 b' class GistsController(BaseController):'
             c.lifetime_values.append(extra_values)
         c.lifetime_options = [(c.lifetime_values, _("Lifetime"))]
 
-    @LoginRequired()
+    @LoginRequired(allow_default_user=True)
     def index(self):
-        """GET /admin/gists: All items in the collection"""
-        # url('gists')
-        not_default_user = c.authuser.username != User.DEFAULT_USER
+        not_default_user = not request.authuser.is_default_user
         c.show_private = request.GET.get('private') and not_default_user
         c.show_public = request.GET.get('public') and not_default_user
 
-        gists = Gist().query()\
-            .filter(or_(Gist.gist_expires == -1, Gist.gist_expires >= time.time()))\
+        gists = Gist().query() \
+            .filter_by(is_expired=False) \
             .order_by(Gist.created_on.desc())
 
         # MY private
         if c.show_private and not c.show_public:
-            gists = gists.filter(Gist.gist_type == Gist.GIST_PRIVATE)\
-                             .filter(Gist.gist_owner == c.authuser.user_id)
+            gists = gists.filter(Gist.gist_type == Gist.GIST_PRIVATE) \
+                             .filter(Gist.owner_id == request.authuser.user_id)
         # MY public
         elif c.show_public and not c.show_private:
-            gists = gists.filter(Gist.gist_type == Gist.GIST_PUBLIC)\
-                             .filter(Gist.gist_owner == c.authuser.user_id)
+            gists = gists.filter(Gist.gist_type == Gist.GIST_PUBLIC) \
+                             .filter(Gist.owner_id == request.authuser.user_id)
 
         # MY public+private
         elif c.show_private and c.show_public:
             gists = gists.filter(or_(Gist.gist_type == Gist.GIST_PUBLIC,
-                                     Gist.gist_type == Gist.GIST_PRIVATE))\
-                             .filter(Gist.gist_owner == c.authuser.user_id)
+                                     Gist.gist_type == Gist.GIST_PRIVATE)) \
+                             .filter(Gist.owner_id == request.authuser.user_id)
 
         # default show ALL public gists
         if not c.show_public and not c.show_private:
             gists = gists.filter(Gist.gist_type == Gist.GIST_PUBLIC)
 
         c.gists = gists
-        p = safe_int(request.GET.get('page', 1), 1)
+        p = safe_int(request.GET.get('page'), 1)
         c.gists_pager = Page(c.gists, page=p, items_per_page=10)
         return render('admin/gists/index.html')
 
     @LoginRequired()
-    @NotAnonymous()
     def create(self):
-        """POST /admin/gists: Create a new item"""
-        # url('gists')
         self.__load_defaults()
         gist_form = GistForm([x[0] for x in c.lifetime_values])()
         try:
             form_result = gist_form.to_python(dict(request.POST))
-            #TODO: multiple files support, from the form
+            # TODO: multiple files support, from the form
             filename = form_result['filename'] or Gist.DEFAULT_FILENAME
             nodes = {
                 filename: {
@@ -123,7 +117,7 b' class GistsController(BaseController):'
             gist_type = Gist.GIST_PUBLIC if _public else Gist.GIST_PRIVATE
             gist = GistModel().create(
                 description=form_result['description'],
-                owner=c.authuser.user_id,
+                owner=request.authuser.user_id,
                 gist_mapping=nodes,
                 gist_type=gist_type,
                 lifetime=form_result['lifetime']
@@ -144,40 +138,18 b' class GistsController(BaseController):'
         except Exception as e:
             log.error(traceback.format_exc())
             h.flash(_('Error occurred during gist creation'), category='error')
-            return redirect(url('new_gist'))
-        return redirect(url('gist', gist_id=new_gist_id))
+            raise HTTPFound(location=url('new_gist'))
+        raise HTTPFound(location=url('gist', gist_id=new_gist_id))
 
     @LoginRequired()
-    @NotAnonymous()
     def new(self, format='html'):
-        """GET /admin/gists/new: Form to create a new item"""
-        # url('new_gist')
         self.__load_defaults()
         return render('admin/gists/new.html')
 
     @LoginRequired()
-    @NotAnonymous()
-    def update(self, gist_id):
-        """PUT /admin/gists/gist_id: Update an existing item"""
-        # Forms posted to this method should contain a hidden field:
-        #    <input type="hidden" name="_method" value="PUT" />
-        # Or using helpers:
-        #    h.form(url('gist', gist_id=ID),
-        #           method='put')
-        # url('gist', gist_id=ID)
-
-    @LoginRequired()
-    @NotAnonymous()
     def delete(self, gist_id):
-        """DELETE /admin/gists/gist_id: Delete an existing item"""
-        # Forms posted to this method should contain a hidden field:
-        #    <input type="hidden" name="_method" value="DELETE" />
-        # Or using helpers:
-        #    h.form(url('gist', gist_id=ID),
-        #           method='delete')
-        # url('gist', gist_id=ID)
         gist = GistModel().get_gist(gist_id)
-        owner = gist.gist_owner == c.authuser.user_id
+        owner = gist.owner_id == request.authuser.user_id
         if h.HasPermissionAny('hg.admin')() or owner:
             GistModel().delete(gist)
             Session().commit()
@@ -185,20 +157,16 b' class GistsController(BaseController):'
         else:
             raise HTTPForbidden()
 
-        return redirect(url('gists'))
+        raise HTTPFound(location=url('gists'))
 
-    @LoginRequired()
+    @LoginRequired(allow_default_user=True)
     def show(self, gist_id, revision='tip', format='html', f_path=None):
-        """GET /admin/gists/gist_id: Show a specific item"""
-        # url('gist', gist_id=ID)
         c.gist = Gist.get_or_404(gist_id)
 
-        #check if this gist is not expired
-        if c.gist.gist_expires != -1:
-            if time.time() > c.gist.gist_expires:
-                log.error('Gist expired at %s',
-                          time_to_datetime(c.gist.gist_expires))
-                raise HTTPNotFound()
+        if c.gist.is_expired:
+            log.error('Gist expired at %s',
+                      time_to_datetime(c.gist.gist_expires))
+            raise HTTPNotFound()
         try:
             c.file_changeset, c.files = GistModel().get_gist_files(gist_id,
                                                             revision=revision)
@@ -212,18 +180,13 b' class GistsController(BaseController):'
         return render('admin/gists/show.html')
 
     @LoginRequired()
-    @NotAnonymous()
     def edit(self, gist_id, format='html'):
-        """GET /admin/gists/gist_id/edit: Form to edit an existing item"""
-        # url('edit_gist', gist_id=ID)
         c.gist = Gist.get_or_404(gist_id)
 
-        #check if this gist is not expired
-        if c.gist.gist_expires != -1:
-            if time.time() > c.gist.gist_expires:
-                log.error('Gist expired at %s',
-                          time_to_datetime(c.gist.gist_expires))
-                raise HTTPNotFound()
+        if c.gist.is_expired:
+            log.error('Gist expired at %s',
+                      time_to_datetime(c.gist.gist_expires))
+            raise HTTPNotFound()
         try:
             c.file_changeset, c.files = GistModel().get_gist_files(gist_id)
         except VCSError:
@@ -270,12 +233,11 b' class GistsController(BaseController):'
                 h.flash(_('Error occurred during update of gist %s') % gist_id,
                         category='error')
 
-            return redirect(url('gist', gist_id=gist_id))
+            raise HTTPFound(location=url('gist', gist_id=gist_id))
 
         return rendered
 
     @LoginRequired()
-    @NotAnonymous()
     @jsonify
     def check_revision(self, gist_id):
         c.gist = Gist.get_or_404(gist_id)
@@ -283,7 +245,7 b' class GistsController(BaseController):'
         success = True
         revision = request.POST.get('revision')
 
-        ##TODO: maybe move this to model ?
+        # TODO: maybe move this to model ?
         if revision != last_rev.raw_id:
             log.error('Last revision %s is different than submitted %s',
                       revision, last_rev)

kallithea/controllers/admin/my_account.py

@@ -31,17 +31,16 b' import formencode'
 
 from sqlalchemy import func
 from formencode import htmlfill
-from pylons import request, tmpl_context as c, url
-from pylons.controllers.util import redirect
-from pylons.i18n.translation import _
+from tg import request, tmpl_context as c
+from tg.i18n import ugettext as _
+from webob.exc import HTTPFound
 
-from kallithea import EXTERN_TYPE_INTERNAL
+from kallithea.config.routing import url
 from kallithea.lib import helpers as h
 from kallithea.lib import auth_modules
-from kallithea.lib.auth import LoginRequired, NotAnonymous, AuthUser
+from kallithea.lib.auth import LoginRequired, AuthUser
 from kallithea.lib.base import BaseController, render
 from kallithea.lib.utils2 import generate_api_key, safe_int
-from kallithea.lib.compat import json
 from kallithea.model.db import Repository, UserEmailMap, User, UserFollowing
 from kallithea.model.forms import UserForm, PasswordChangeForm
 from kallithea.model.user import UserModel
@@ -60,48 +59,37 b' class MyAccountController(BaseController'
     #         path_prefix='/admin', name_prefix='admin_')
 
     @LoginRequired()
-    @NotAnonymous()
-    def __before__(self):
-        super(MyAccountController, self).__before__()
+    def _before(self, *args, **kwargs):
+        super(MyAccountController, self)._before(*args, **kwargs)
 
     def __load_data(self):
-        c.user = User.get(self.authuser.user_id)
-        if c.user.username == User.DEFAULT_USER:
+        c.user = User.get(request.authuser.user_id)
+        if c.user.is_default_user:
             h.flash(_("You can't edit this user since it's"
                       " crucial for entire application"), category='warning')
-            return redirect(url('users'))
-        c.EXTERN_TYPE_INTERNAL = EXTERN_TYPE_INTERNAL
+            raise HTTPFound(location=url('users'))
 
     def _load_my_repos_data(self, watched=False):
         if watched:
             admin = False
-            repos_list = [x.follows_repository for x in
-                          Session().query(UserFollowing).filter(
-                              UserFollowing.user_id ==
-                              self.authuser.user_id).all()]
+            repos_list = Session().query(Repository) \
+                         .join(UserFollowing) \
+                         .filter(UserFollowing.user_id ==
+                                 request.authuser.user_id).all()
         else:
             admin = True
-            repos_list = Session().query(Repository)\
-                         .filter(Repository.user_id ==
-                                 self.authuser.user_id)\
-                         .order_by(func.lower(Repository.repo_name)).all()
+            repos_list = Session().query(Repository) \
+                         .filter(Repository.owner_id ==
+                                 request.authuser.user_id).all()
 
-        repos_data = RepoModel().get_repos_as_dict(repos_list=repos_list,
-                                                   admin=admin)
-        #json used to render the grid
-        return json.dumps(repos_data)
+        return RepoModel().get_repos_as_dict(repos_list, admin=admin)
 
     def my_account(self):
-        """
-        GET /_admin/my_account Displays info about my account
-        """
-        # url('my_account')
         c.active = 'profile'
         self.__load_data()
-        c.perm_user = AuthUser(user_id=self.authuser.user_id)
-        c.ip_addr = self.ip_addr
+        c.perm_user = AuthUser(user_id=request.authuser.user_id)
         managed_fields = auth_modules.get_managed_fields(c.user)
-        def_user_perms = User.get_default_user().AuthUser.permissions['global']
+        def_user_perms = AuthUser(dbuser=User.get_default_user()).permissions['global']
         if 'hg.register.none' in def_user_perms:
             managed_fields.extend(['username', 'firstname', 'lastname', 'email'])
 
@@ -111,8 +99,8 b' class MyAccountController(BaseController'
         update = False
         if request.POST:
             _form = UserForm(edit=True,
-                             old_data={'user_id': self.authuser.user_id,
-                                       'email': self.authuser.email})()
+                             old_data={'user_id': request.authuser.user_id,
+                                       'email': request.authuser.email})()
             form_result = {}
             try:
                 post_data = dict(request.POST)
@@ -124,7 +112,7 b' class MyAccountController(BaseController'
                               'new_password', 'password_confirmation',
                              ] + managed_fields
 
-                UserModel().update(self.authuser.user_id, form_result,
+                UserModel().update(request.authuser.user_id, form_result,
                                    skip_attrs=skip_attrs)
                 h.flash(_('Your account was updated successfully'),
                         category='success')
@@ -141,10 +129,10 b' class MyAccountController(BaseController'
                     force_defaults=False)
             except Exception:
                 log.error(traceback.format_exc())
-                h.flash(_('Error occurred during update of user %s') \
+                h.flash(_('Error occurred during update of user %s')
                         % form_result.get('username'), category='error')
         if update:
-            return redirect('my_account')
+            raise HTTPFound(location='my_account')
         return htmlfill.render(
             render('admin/my_account/my_account.html'),
             defaults=defaults,
@@ -159,10 +147,10 b' class MyAccountController(BaseController'
         c.can_change_password = 'password' not in managed_fields
 
         if request.POST and c.can_change_password:
-            _form = PasswordChangeForm(self.authuser.username)()
+            _form = PasswordChangeForm(request.authuser.username)()
             try:
                 form_result = _form.to_python(request.POST)
-                UserModel().update(self.authuser.user_id, form_result)
+                UserModel().update(request.authuser.user_id, form_result)
                 Session().commit()
                 h.flash(_("Successfully updated password"), category='success')
             except formencode.Invalid as errors:
@@ -183,7 +171,7 b' class MyAccountController(BaseController'
         c.active = 'repos'
         self.__load_data()
 
-        #json used to render the grid
+        # data used to render the grid
         c.data = self._load_my_repos_data()
         return render('admin/my_account/my_account.html')
 
@@ -191,15 +179,14 b' class MyAccountController(BaseController'
         c.active = 'watched'
         self.__load_data()
 
-        #json used to render the grid
+        # data used to render the grid
         c.data = self._load_my_repos_data(watched=True)
         return render('admin/my_account/my_account.html')
 
     def my_account_perms(self):
         c.active = 'perms'
         self.__load_data()
-        c.perm_user = AuthUser(user_id=self.authuser.user_id)
-        c.ip_addr = self.ip_addr
+        c.perm_user = AuthUser(user_id=request.authuser.user_id)
 
         return render('admin/my_account/my_account.html')
 
@@ -207,7 +194,7 b' class MyAccountController(BaseController'
         c.active = 'emails'
         self.__load_data()
 
-        c.user_email_map = UserEmailMap.query()\
+        c.user_email_map = UserEmailMap.query() \
             .filter(UserEmailMap.user == c.user).all()
         return render('admin/my_account/my_account.html')
 
@@ -215,7 +202,7 b' class MyAccountController(BaseController'
         email = request.POST.get('new_email')
 
         try:
-            UserModel().add_extra_email(self.authuser.user_id, email)
+            UserModel().add_extra_email(request.authuser.user_id, email)
             Session().commit()
             h.flash(_("Added email %s to user") % email, category='success')
         except formencode.Invalid as error:
@@ -225,15 +212,15 b' class MyAccountController(BaseController'
             log.error(traceback.format_exc())
             h.flash(_('An error occurred during email saving'),
                     category='error')
-        return redirect(url('my_account_emails'))
+        raise HTTPFound(location=url('my_account_emails'))
 
     def my_account_emails_delete(self):
         email_id = request.POST.get('del_email_id')
         user_model = UserModel()
-        user_model.delete_extra_email(self.authuser.user_id, email_id)
+        user_model.delete_extra_email(request.authuser.user_id, email_id)
         Session().commit()
         h.flash(_("Removed email from user"), category='success')
-        return redirect(url('my_account_emails'))
+        raise HTTPFound(location=url('my_account_emails'))
 
     def my_account_api_keys(self):
         c.active = 'api_keys'
@@ -247,31 +234,28 b' class MyAccountController(BaseController'
             (str(60 * 24 * 30), _('1 month')),
         ]
         c.lifetime_options = [(c.lifetime_values, _("Lifetime"))]
-        c.user_api_keys = ApiKeyModel().get_api_keys(self.authuser.user_id,
+        c.user_api_keys = ApiKeyModel().get_api_keys(request.authuser.user_id,
                                                      show_expired=show_expired)
         return render('admin/my_account/my_account.html')
 
     def my_account_api_keys_add(self):
         lifetime = safe_int(request.POST.get('lifetime'), -1)
         description = request.POST.get('description')
-        ApiKeyModel().create(self.authuser.user_id, description, lifetime)
+        ApiKeyModel().create(request.authuser.user_id, description, lifetime)
         Session().commit()
         h.flash(_("API key successfully created"), category='success')
-        return redirect(url('my_account_api_keys'))
+        raise HTTPFound(location=url('my_account_api_keys'))
 
     def my_account_api_keys_delete(self):
         api_key = request.POST.get('del_api_key')
-        user_id = self.authuser.user_id
         if request.POST.get('del_api_key_builtin'):
-            user = User.get(user_id)
-            if user is not None:
-                user.api_key = generate_api_key()
-                Session().add(user)
-                Session().commit()
-                h.flash(_("API key successfully reset"), category='success')
+            user = User.get(request.authuser.user_id)
+            user.api_key = generate_api_key()
+            Session().commit()
+            h.flash(_("API key successfully reset"), category='success')
         elif api_key:
-            ApiKeyModel().delete(api_key, self.authuser.user_id)
+            ApiKeyModel().delete(api_key, request.authuser.user_id)
             Session().commit()
             h.flash(_("API key successfully deleted"), category='success')
 
-        return redirect(url('my_account_api_keys'))
+        raise HTTPFound(location=url('my_account_api_keys'))

kallithea/controllers/admin/permissions.py

@@ -31,12 +31,13 b' import traceback'
 import formencode
 from formencode import htmlfill
 
-from pylons import request, tmpl_context as c, url
-from pylons.controllers.util import redirect
-from pylons.i18n.translation import _
+from tg import request, tmpl_context as c
+from tg.i18n import ugettext as _
+from webob.exc import HTTPFound
 
+from kallithea.config.routing import url
 from kallithea.lib import helpers as h
-from kallithea.lib.auth import LoginRequired, HasPermissionAllDecorator
+from kallithea.lib.auth import LoginRequired, HasPermissionAnyDecorator, AuthUser
 from kallithea.lib.base import BaseController, render
 from kallithea.model.forms import DefaultPermissionsForm
 from kallithea.model.permission import PermissionModel
@@ -53,9 +54,9 b' class PermissionsController(BaseControll'
     #     map.resource('permission', 'permissions')
 
     @LoginRequired()
-    @HasPermissionAllDecorator('hg.admin')
-    def __before__(self):
-        super(PermissionsController, self).__before__()
+    @HasPermissionAnyDecorator('hg.admin')
+    def _before(self, *args, **kwargs):
+        super(PermissionsController, self)._before(*args, **kwargs)
 
     def __load_data(self):
         c.repo_perms_choices = [('repository.none', _('None'),),
@@ -139,7 +140,7 b' class PermissionsController(BaseControll'
                 h.flash(_('Error occurred during update of permissions'),
                         category='error')
 
-            return redirect(url('admin_permissions'))
+            raise HTTPFound(location=url('admin_permissions'))
 
         c.user = User.get_default_user()
         defaults = {'anonymous': c.user.active}
@@ -184,7 +185,7 b' class PermissionsController(BaseControll'
     def permission_ips(self):
         c.active = 'ips'
         c.user = User.get_default_user()
-        c.user_ip_map = UserIpMap.query()\
+        c.user_ip_map = UserIpMap.query() \
                         .filter(UserIpMap.user == c.user).all()
 
         return render('admin/permissions/permissions.html')
@@ -192,5 +193,5 b' class PermissionsController(BaseControll'
     def permission_perms(self):
         c.active = 'perms'
         c.user = User.get_default_user()
-        c.perm_user = c.user.AuthUser
+        c.perm_user = AuthUser(dbuser=c.user)
         return render('admin/permissions/permissions.html')

kallithea/controllers/admin/repo_groups.py

@@ -32,16 +32,16 b' import itertools'
 
 from formencode import htmlfill
 
-from pylons import request, tmpl_context as c, url
-from pylons.controllers.util import abort, redirect
-from pylons.i18n.translation import _, ungettext
+from tg import request, tmpl_context as c, app_globals
+from tg.i18n import ugettext as _, ungettext
+from webob.exc import HTTPFound, HTTPForbidden, HTTPNotFound, HTTPInternalServerError
 
 import kallithea
+from kallithea.config.routing import url
 from kallithea.lib import helpers as h
-from kallithea.lib.compat import json
 from kallithea.lib.auth import LoginRequired, \
-    HasRepoGroupPermissionAnyDecorator, HasRepoGroupPermissionAll, \
-    HasPermissionAll
+    HasRepoGroupPermissionLevelDecorator, HasRepoGroupPermissionLevel, \
+    HasPermissionAny
 from kallithea.lib.base import BaseController, render
 from kallithea.model.db import RepoGroup, Repository
 from kallithea.model.scm import RepoGroupList, AvailableRepoGroupChoices
@@ -49,7 +49,6 b' from kallithea.model.repo_group import R'
 from kallithea.model.forms import RepoGroupForm, RepoGroupPermsForm
 from kallithea.model.meta import Session
 from kallithea.model.repo import RepoModel
-from webob.exc import HTTPInternalServerError, HTTPNotFound
 from kallithea.lib.utils2 import safe_int
 from sqlalchemy.sql.expression import func
 
@@ -59,24 +58,20 b' log = logging.getLogger(__name__)'
 
 class RepoGroupsController(BaseController):
 
-    @LoginRequired()
-    def __before__(self):
-        super(RepoGroupsController, self).__before__()
+    @LoginRequired(allow_default_user=True)
+    def _before(self, *args, **kwargs):
+        super(RepoGroupsController, self)._before(*args, **kwargs)
 
     def __load_defaults(self, extras=(), exclude=()):
         """extras is used for keeping current parent ignoring permissions
         exclude is used for not moving group to itself TODO: also exclude descendants
         Note: only admin can create top level groups
         """
-        repo_groups = AvailableRepoGroupChoices([], ['group.admin'], extras)
+        repo_groups = AvailableRepoGroupChoices([], 'admin', extras)
         exclude_group_ids = set(rg.group_id for rg in exclude)
         c.repo_groups = [rg for rg in repo_groups
                          if rg[0] not in exclude_group_ids]
 
-        repo_model = RepoModel()
-        c.users_array = repo_model.get_users_js()
-        c.user_groups_array = repo_model.get_user_groups_js()
-
     def __load_data(self, group_id):
         """
         Load defaults settings for edit, and update
@@ -100,24 +95,20 b' class RepoGroupsController(BaseControlle'
         return data
 
     def _revoke_perms_on_yourself(self, form_result):
-        _up = filter(lambda u: c.authuser.username == u[0],
+        _up = filter(lambda u: request.authuser.username == u[0],
                      form_result['perms_updates'])
-        _new = filter(lambda u: c.authuser.username == u[0],
+        _new = filter(lambda u: request.authuser.username == u[0],
                       form_result['perms_new'])
         if _new and _new[0][1] != 'group.admin' or _up and _up[0][1] != 'group.admin':
             return True
         return False
 
     def index(self, format='html'):
-        """GET /repo_groups: All items in the collection"""
-        # url('repos_groups')
-        _list = RepoGroup.query()\
-                    .order_by(func.lower(RepoGroup.group_name))\
-                    .all()
-        group_iter = RepoGroupList(_list, perm_set=['group.admin'])
+        _list = RepoGroup.query(sorted=True).all()
+        group_iter = RepoGroupList(_list, perm_level='admin')
         repo_groups_data = []
         total_records = len(group_iter)
-        _tmpl_lookup = kallithea.CONFIG['pylons.app_globals'].mako_lookup
+        _tmpl_lookup = app_globals.mako_lookup
         template = _tmpl_lookup.get_template('data_table/_dt_elements.html')
 
         repo_group_name = lambda repo_group_name, children_groups: (
@@ -140,25 +131,20 b' class RepoGroupsController(BaseControlle'
                 "group_name": repo_group_name(repo_gr.group_name, children_groups),
                 "desc": h.escape(repo_gr.group_description),
                 "repos": repo_count,
-                "owner": h.person(repo_gr.user),
+                "owner": h.person(repo_gr.owner),
                 "action": repo_group_actions(repo_gr.group_id, repo_gr.group_name,
                                              repo_count)
             })
 
-        c.data = json.dumps({
-            "totalRecords": total_records,
-            "startIndex": 0,
+        c.data = {
             "sort": None,
             "dir": "asc",
             "records": repo_groups_data
-        })
+        }
 
         return render('admin/repo_groups/repo_groups.html')
 
     def create(self):
-        """POST /repo_groups: Create a new item"""
-        # url('repos_groups')
-
         self.__load_defaults()
 
         # permissions for can create group based on parent_id are checked
@@ -169,12 +155,12 b' class RepoGroupsController(BaseControlle'
             gr = RepoGroupModel().create(
                 group_name=form_result['group_name'],
                 group_description=form_result['group_description'],
-                parent=form_result['group_parent_id'],
-                owner=self.authuser.user_id, # TODO: make editable
+                parent=form_result['parent_group_id'],
+                owner=request.authuser.user_id, # TODO: make editable
                 copy_permissions=form_result['group_copy_permissions']
             )
             Session().commit()
-            #TODO: in futureaction_logger(, '', '', '', self.sa)
+            # TODO: in future action_logger(, '', '', '')
         except formencode.Invalid as errors:
             return htmlfill.render(
                 render('admin/repo_groups/repo_group_add.html'),
@@ -185,20 +171,18 b' class RepoGroupsController(BaseControlle'
                 force_defaults=False)
         except Exception:
             log.error(traceback.format_exc())
-            h.flash(_('Error occurred during creation of repository group %s') \
+            h.flash(_('Error occurred during creation of repository group %s')
                     % request.POST.get('group_name'), category='error')
-            parent_group_id = form_result['group_parent_id']
-            #TODO: maybe we should get back to the main view, not the admin one
-            return redirect(url('repos_groups', parent_group=parent_group_id))
+            parent_group_id = form_result['parent_group_id']
+            # TODO: maybe we should get back to the main view, not the admin one
+            raise HTTPFound(location=url('repos_groups', parent_group=parent_group_id))
         h.flash(_('Created repository group %s') % gr.group_name,
                 category='success')
-        return redirect(url('repos_group_home', group_name=gr.group_name))
+        raise HTTPFound(location=url('repos_group_home', group_name=gr.group_name))
 
     def new(self):
-        """GET /repo_groups/new: Form to create a new item"""
-        # url('new_repos_group')
-        if HasPermissionAll('hg.admin')('group create'):
-            #we're global admin, we're ok and we can create TOP level groups
+        if HasPermissionAny('hg.admin')('group create'):
+            # we're global admin, we're ok and we can create TOP level groups
             pass
         else:
             # we pass in parent group into creation form, thus we know
@@ -206,31 +190,23 b' class RepoGroupsController(BaseControlle'
             group_id = safe_int(request.GET.get('parent_group'))
             group = RepoGroup.get(group_id) if group_id else None
             group_name = group.group_name if group else None
-            if HasRepoGroupPermissionAll('group.admin')(group_name, 'group create'):
+            if HasRepoGroupPermissionLevel('admin')(group_name, 'group create'):
                 pass
             else:
-                return abort(403)
+                raise HTTPForbidden()
 
         self.__load_defaults()
         return render('admin/repo_groups/repo_group_add.html')
 
-    @HasRepoGroupPermissionAnyDecorator('group.admin')
+    @HasRepoGroupPermissionLevelDecorator('admin')
     def update(self, group_name):
-        """PUT /repo_groups/group_name: Update an existing item"""
-        # Forms posted to this method should contain a hidden field:
-        #    <input type="hidden" name="_method" value="PUT" />
-        # Or using helpers:
-        #    h.form(url('repos_group', group_name=GROUP_NAME),
-        #           method='put')
-        # url('repos_group', group_name=GROUP_NAME)
-
-        c.repo_group = RepoGroupModel()._get_repo_group(group_name)
+        c.repo_group = RepoGroup.guess_instance(group_name)
         self.__load_defaults(extras=[c.repo_group.parent_group],
                              exclude=[c.repo_group])
 
         # TODO: kill allow_empty_group - it is only used for redundant form validation!
-        if HasPermissionAll('hg.admin')('group edit'):
-            #we're global admin, we're ok and we can create TOP level groups
+        if HasPermissionAny('hg.admin')('group edit'):
+            # we're global admin, we're ok and we can create TOP level groups
             allow_empty_group = True
         elif not c.repo_group.parent_group:
             allow_empty_group = True
@@ -247,13 +223,13 b' class RepoGroupsController(BaseControlle'
 
             new_gr = RepoGroupModel().update(group_name, form_result)
             Session().commit()
-            h.flash(_('Updated repository group %s') \
+            h.flash(_('Updated repository group %s')
                     % form_result['group_name'], category='success')
             # we now have new name !
             group_name = new_gr.group_name
-            #TODO: in future action_logger(, '', '', '', self.sa)
+            # TODO: in future action_logger(, '', '', '')
         except formencode.Invalid as errors:
-
+            c.active = 'settings'
             return htmlfill.render(
                 render('admin/repo_groups/repo_group_edit.html'),
                 defaults=errors.value,
@@ -263,48 +239,40 b' class RepoGroupsController(BaseControlle'
                 force_defaults=False)
         except Exception:
             log.error(traceback.format_exc())
-            h.flash(_('Error occurred during update of repository group %s') \
+            h.flash(_('Error occurred during update of repository group %s')
                     % request.POST.get('group_name'), category='error')
 
-        return redirect(url('edit_repo_group', group_name=group_name))
+        raise HTTPFound(location=url('edit_repo_group', group_name=group_name))
 
-    @HasRepoGroupPermissionAnyDecorator('group.admin')
+    @HasRepoGroupPermissionLevelDecorator('admin')
     def delete(self, group_name):
-        """DELETE /repo_groups/group_name: Delete an existing item"""
-        # Forms posted to this method should contain a hidden field:
-        #    <input type="hidden" name="_method" value="DELETE" />
-        # Or using helpers:
-        #    h.form(url('repos_group', group_name=GROUP_NAME),
-        #           method='delete')
-        # url('repos_group', group_name=GROUP_NAME)
-
-        gr = c.repo_group = RepoGroupModel()._get_repo_group(group_name)
+        gr = c.repo_group = RepoGroup.guess_instance(group_name)
         repos = gr.repositories.all()
         if repos:
             h.flash(_('This group contains %s repositories and cannot be '
                       'deleted') % len(repos), category='warning')
-            return redirect(url('repos_groups'))
+            raise HTTPFound(location=url('repos_groups'))
 
         children = gr.children.all()
         if children:
             h.flash(_('This group contains %s subgroups and cannot be deleted'
                       % (len(children))), category='warning')
-            return redirect(url('repos_groups'))
+            raise HTTPFound(location=url('repos_groups'))
 
         try:
             RepoGroupModel().delete(group_name)
             Session().commit()
             h.flash(_('Removed repository group %s') % group_name,
                     category='success')
-            #TODO: in future action_logger(, '', '', '', self.sa)
+            # TODO: in future action_logger(, '', '', '')
         except Exception:
             log.error(traceback.format_exc())
             h.flash(_('Error occurred during deletion of repository group %s')
                     % group_name, category='error')
 
         if gr.parent_group:
-            return redirect(url('repos_group_home', group_name=gr.parent_group.group_name))
-        return redirect(url('repos_groups'))
+            raise HTTPFound(location=url('repos_group_home', group_name=gr.parent_group.group_name))
+        raise HTTPFound(location=url('repos_groups'))
 
     def show_by_name(self, group_name):
         """
@@ -317,42 +285,27 b' class RepoGroupsController(BaseControlle'
             return self.show(group_name)
         raise HTTPNotFound
 
-    @HasRepoGroupPermissionAnyDecorator('group.read', 'group.write',
-                                         'group.admin')
+    @HasRepoGroupPermissionLevelDecorator('read')
     def show(self, group_name):
-        """GET /repo_groups/group_name: Show a specific item"""
-        # url('repos_group', group_name=GROUP_NAME)
         c.active = 'settings'
 
-        c.group = c.repo_group = RepoGroupModel()._get_repo_group(group_name)
-        c.group_repos = c.group.repositories.all()
+        c.group = c.repo_group = RepoGroup.guess_instance(group_name)
 
-        #overwrite our cached list with current filter
-        c.repo_cnt = 0
-
-        groups = RepoGroup.query().order_by(RepoGroup.group_name)\
-            .filter(RepoGroup.group_parent_id == c.group.group_id).all()
-        c.groups = self.scm_model.get_repo_groups(groups)
+        groups = RepoGroup.query(sorted=True).filter_by(parent_group=c.group).all()
+        repo_groups_list = self.scm_model.get_repo_groups(groups)
 
-        c.repos_list = Repository.query()\
-                        .filter(Repository.group_id == c.group.group_id)\
-                        .order_by(func.lower(Repository.repo_name))\
-                        .all()
-
-        repos_data = RepoModel().get_repos_as_dict(repos_list=c.repos_list,
-                                                   admin=False)
-        #json used to render the grid
-        c.data = json.dumps(repos_data)
+        repos_list = Repository.query(sorted=True).filter_by(group=c.group).all()
+        c.data = RepoModel().get_repos_as_dict(repos_list,
+                                               repo_groups_list=repo_groups_list,
+                                               short_name=True)
 
         return render('admin/repo_groups/repo_group_show.html')
 
-    @HasRepoGroupPermissionAnyDecorator('group.admin')
+    @HasRepoGroupPermissionLevelDecorator('admin')
     def edit(self, group_name):
-        """GET /repo_groups/group_name/edit: Form to edit an existing item"""
-        # url('edit_repo_group', group_name=GROUP_NAME)
         c.active = 'settings'
 
-        c.repo_group = RepoGroupModel()._get_repo_group(group_name)
+        c.repo_group = RepoGroup.guess_instance(group_name)
         self.__load_defaults(extras=[c.repo_group.parent_group],
                              exclude=[c.repo_group])
         defaults = self.__load_data(c.repo_group.group_id)
@@ -364,21 +317,17 b' class RepoGroupsController(BaseControlle'
             force_defaults=False
         )
 
-    @HasRepoGroupPermissionAnyDecorator('group.admin')
+    @HasRepoGroupPermissionLevelDecorator('admin')
     def edit_repo_group_advanced(self, group_name):
-        """GET /repo_groups/group_name/edit: Form to edit an existing item"""
-        # url('edit_repo_group', group_name=GROUP_NAME)
         c.active = 'advanced'
-        c.repo_group = RepoGroupModel()._get_repo_group(group_name)
+        c.repo_group = RepoGroup.guess_instance(group_name)
 
         return render('admin/repo_groups/repo_group_edit.html')
 
-    @HasRepoGroupPermissionAnyDecorator('group.admin')
+    @HasRepoGroupPermissionLevelDecorator('admin')
     def edit_repo_group_perms(self, group_name):
-        """GET /repo_groups/group_name/edit: Form to edit an existing item"""
-        # url('edit_repo_group', group_name=GROUP_NAME)
         c.active = 'perms'
-        c.repo_group = RepoGroupModel()._get_repo_group(group_name)
+        c.repo_group = RepoGroup.guess_instance(group_name)
         self.__load_defaults()
         defaults = self.__load_data(c.repo_group.group_id)
 
@@ -389,7 +338,7 b' class RepoGroupsController(BaseControlle'
             force_defaults=False
         )
 
-    @HasRepoGroupPermissionAnyDecorator('group.admin')
+    @HasRepoGroupPermissionLevelDecorator('admin')
     def update_perms(self, group_name):
         """
         Update permissions for given repository group
@@ -397,14 +346,14 b' class RepoGroupsController(BaseControlle'
         :param group_name:
         """
 
-        c.repo_group = RepoGroupModel()._get_repo_group(group_name)
+        c.repo_group = RepoGroup.guess_instance(group_name)
         valid_recursive_choices = ['none', 'repos', 'groups', 'all']
         form_result = RepoGroupPermsForm(valid_recursive_choices)().to_python(request.POST)
-        if not c.authuser.is_admin:
+        if not request.authuser.is_admin:
             if self._revoke_perms_on_yourself(form_result):
                 msg = _('Cannot revoke permission for yourself as admin')
                 h.flash(msg, category='warning')
-                return redirect(url('edit_repo_group_perms', group_name=group_name))
+                raise HTTPFound(location=url('edit_repo_group_perms', group_name=group_name))
         recursive = form_result['recursive']
         # iterate over all members(if in recursive mode) of this groups and
         # set the permissions !
@@ -413,20 +362,15 b' class RepoGroupsController(BaseControlle'
                                              form_result['perms_new'],
                                              form_result['perms_updates'],
                                              recursive)
-        #TODO: implement this
-        #action_logger(self.authuser, 'admin_changed_repo_permissions',
-        #              repo_name, self.ip_addr, self.sa)
+        # TODO: implement this
+        #action_logger(request.authuser, 'admin_changed_repo_permissions',
+        #              repo_name, request.ip_addr)
         Session().commit()
         h.flash(_('Repository group permissions updated'), category='success')
-        return redirect(url('edit_repo_group_perms', group_name=group_name))
+        raise HTTPFound(location=url('edit_repo_group_perms', group_name=group_name))
 
-    @HasRepoGroupPermissionAnyDecorator('group.admin')
+    @HasRepoGroupPermissionLevelDecorator('admin')
     def delete_perms(self, group_name):
-        """
-        DELETE an existing repository group permission user
-
-        :param group_name:
-        """
         try:
             obj_type = request.POST.get('obj_type')
             obj_id = None
@@ -435,8 +379,8 b' class RepoGroupsController(BaseControlle'
             elif obj_type == 'user_group':
                 obj_id = safe_int(request.POST.get('user_group_id'))
 
-            if not c.authuser.is_admin:
-                if obj_type == 'user' and c.authuser.user_id == obj_id:
+            if not request.authuser.is_admin:
+                if obj_type == 'user' and request.authuser.user_id == obj_id:
                     msg = _('Cannot revoke permission for yourself as admin')
                     h.flash(msg, category='warning')
                     raise Exception('revoke admin permission on self')

kallithea/controllers/admin/repos.py

@@ -29,26 +29,24 b' import logging'
 import traceback
 import formencode
 from formencode import htmlfill
-from webob.exc import HTTPInternalServerError, HTTPForbidden, HTTPNotFound
-from pylons import request, tmpl_context as c, url
-from pylons.controllers.util import redirect
-from pylons.i18n.translation import _
+from tg import request, tmpl_context as c
+from tg.i18n import ugettext as _
 from sqlalchemy.sql.expression import func
+from webob.exc import HTTPFound, HTTPInternalServerError, HTTPForbidden, HTTPNotFound
 
+from kallithea.config.routing import url
 from kallithea.lib import helpers as h
 from kallithea.lib.auth import LoginRequired, \
-    HasRepoPermissionAllDecorator, NotAnonymous, HasPermissionAny, \
-    HasRepoPermissionAnyDecorator
-from kallithea.lib.base import BaseRepoController, render
-from kallithea.lib.utils import action_logger, jsonify
+    HasRepoPermissionLevelDecorator, NotAnonymous, HasPermissionAny
+from kallithea.lib.base import BaseRepoController, render, jsonify
+from kallithea.lib.utils import action_logger
 from kallithea.lib.vcs import RepositoryError
 from kallithea.model.meta import Session
-from kallithea.model.db import User, Repository, UserFollowing, RepoGroup,\
+from kallithea.model.db import User, Repository, UserFollowing, RepoGroup, \
     Setting, RepositoryField
 from kallithea.model.forms import RepoForm, RepoFieldForm, RepoPermsForm
 from kallithea.model.scm import ScmModel, AvailableRepoGroupChoices, RepoList
 from kallithea.model.repo import RepoModel
-from kallithea.lib.compat import json
 from kallithea.lib.exceptions import AttachedForksError
 from kallithea.lib.utils2 import safe_int
 
@@ -62,81 +60,68 b' class ReposController(BaseRepoController'
     # file has a resource setup:
     #     map.resource('repo', 'repos')
 
-    @LoginRequired()
-    def __before__(self):
-        super(ReposController, self).__before__()
+    @LoginRequired(allow_default_user=True)
+    def _before(self, *args, **kwargs):
+        super(ReposController, self)._before(*args, **kwargs)
 
-    def _load_repo(self, repo_name):
-        repo_obj = Repository.get_by_repo_name(repo_name)
+    def _load_repo(self):
+        repo_obj = c.db_repo
 
         if repo_obj is None:
-            h.not_mapped_error(repo_name)
-            return redirect(url('repos'))
+            h.not_mapped_error(c.repo_name)
+            raise HTTPFound(location=url('repos'))
 
         return repo_obj
 
     def __load_defaults(self, repo=None):
         top_perms = ['hg.create.repository']
-        repo_group_perms = ['group.admin']
         if HasPermissionAny('hg.create.write_on_repogroup.true')():
-            repo_group_perms.append('group.write')
+            repo_group_perm_level = 'write'
+        else:
+            repo_group_perm_level = 'admin'
         extras = [] if repo is None else [repo.group]
 
-        c.repo_groups = AvailableRepoGroupChoices(top_perms, repo_group_perms, extras)
+        c.repo_groups = AvailableRepoGroupChoices(top_perms, repo_group_perm_level, extras)
 
         c.landing_revs_choices, c.landing_revs = ScmModel().get_repo_landing_revs(repo)
 
-    def __load_data(self, repo_name=None):
+    def __load_data(self):
         """
         Load defaults settings for edit, and update
-
-        :param repo_name:
         """
-        c.repo_info = self._load_repo(repo_name)
+        c.repo_info = self._load_repo()
         self.__load_defaults(c.repo_info)
 
-        defaults = RepoModel()._get_defaults(repo_name)
+        defaults = RepoModel()._get_defaults(c.repo_name)
         defaults['clone_uri'] = c.repo_info.clone_uri_hidden # don't show password
 
         return defaults
 
     def index(self, format='html'):
-        """GET /repos: All items in the collection"""
-        # url('repos')
-        _list = Repository.query()\
-                        .order_by(func.lower(Repository.repo_name))\
-                        .all()
+        _list = Repository.query(sorted=True).all()
 
-        c.repos_list = RepoList(_list, perm_set=['repository.admin'])
-        repos_data = RepoModel().get_repos_as_dict(repos_list=c.repos_list,
-                                                   admin=True,
-                                                   super_user_actions=True)
-        #json used to render the grid
-        c.data = json.dumps(repos_data)
+        c.repos_list = RepoList(_list, perm_level='admin')
+        # the repo list will be filtered to only show repos where the user has read permissions
+        repos_data = RepoModel().get_repos_as_dict(c.repos_list, admin=True)
+        # data used to render the grid
+        c.data = repos_data
 
         return render('admin/repos/repos.html')
 
     @NotAnonymous()
     def create(self):
-        """
-        POST /repos: Create a new item"""
-        # url('repos')
-
         self.__load_defaults()
         form_result = {}
-        task_id = None
         try:
             # CanWriteGroup validators checks permissions of this POST
             form_result = RepoForm(repo_groups=c.repo_groups,
-                                   landing_revs=c.landing_revs_choices)()\
+                                   landing_revs=c.landing_revs_choices)() \
                             .to_python(dict(request.POST))
 
             # create is done sometimes async on celery, db transaction
             # management is handled there.
-            task = RepoModel().create(form_result, self.authuser.user_id)
-            from celery.result import BaseAsyncResult
-            if isinstance(task, BaseAsyncResult):
-                task_id = task.task_id
+            task = RepoModel().create(form_result, request.authuser.user_id)
+            task_id = task.task_id
         except formencode.Invalid as errors:
             log.info(errors)
             return htmlfill.render(
@@ -152,15 +137,14 b' class ReposController(BaseRepoController'
             msg = (_('Error creating repository %s')
                    % form_result.get('repo_name'))
             h.flash(msg, category='error')
-            return redirect(url('home'))
+            raise HTTPFound(location=url('home'))
 
-        return redirect(h.url('repo_creating_home',
+        raise HTTPFound(location=h.url('repo_creating_home',
                               repo_name=form_result['repo_name_full'],
                               task_id=task_id))
 
     @NotAnonymous()
     def create_repository(self):
-        """GET /_admin/create_repository: Form to create a new item"""
         self.__load_defaults()
         if not c.repo_groups:
             raise HTTPForbidden
@@ -184,7 +168,6 b' class ReposController(BaseRepoController'
             force_defaults=False)
 
     @LoginRequired()
-    @NotAnonymous()
     def repo_creating(self, repo_name):
         c.repo = repo_name
         c.task_id = request.GET.get('task_id')
@@ -193,7 +176,6 b' class ReposController(BaseRepoController'
         return render('admin/repos/repo_creating.html')
 
     @LoginRequired()
-    @NotAnonymous()
     @jsonify
     def repo_check(self, repo_name):
         c.repo = repo_name
@@ -201,9 +183,9 b' class ReposController(BaseRepoController'
 
         if task_id and task_id not in ['None']:
             from kallithea import CELERY_ON
-            from celery.result import AsyncResult
+            from kallithea.lib import celerypylons
             if CELERY_ON:
-                task = AsyncResult(task_id)
+                task = celerypylons.result.AsyncResult(task_id)
                 if task.failed():
                     raise HTTPInternalServerError(task.traceback)
 
@@ -227,20 +209,12 b' class ReposController(BaseRepoController'
             return {'result': True}
         return {'result': False}
 
-    @HasRepoPermissionAllDecorator('repository.admin')
+    @HasRepoPermissionLevelDecorator('admin')
     def update(self, repo_name):
-        """
-        PUT /repos/repo_name: Update an existing item"""
-        # Forms posted to this method should contain a hidden field:
-        #    <input type="hidden" name="_method" value="PUT" />
-        # Or using helpers:
-        #    h.form(url('put_repo', repo_name=ID),
-        #           method='put')
-        # url('put_repo', repo_name=ID)
-        c.repo_info = self._load_repo(repo_name)
+        c.repo_info = self._load_repo()
         self.__load_defaults(c.repo_info)
         c.active = 'settings'
-        c.repo_fields = RepositoryField.query()\
+        c.repo_fields = RepositoryField.query() \
             .filter(RepositoryField.repository == c.repo_info).all()
 
         repo_model = RepoModel()
@@ -262,14 +236,13 b' class ReposController(BaseRepoController'
             h.flash(_('Repository %s updated successfully') % repo_name,
                     category='success')
             changed_name = repo.repo_name
-            action_logger(self.authuser, 'admin_updated_repo',
-                              changed_name, self.ip_addr, self.sa)
+            action_logger(request.authuser, 'admin_updated_repo',
+                changed_name, request.ip_addr)
             Session().commit()
         except formencode.Invalid as errors:
             log.info(errors)
-            defaults = self.__load_data(repo_name)
+            defaults = self.__load_data()
             defaults.update(errors.value)
-            c.users_array = repo_model.get_users_js()
             return htmlfill.render(
                 render('admin/repos/repo_edit.html'),
                 defaults=defaults,
@@ -280,26 +253,17 b' class ReposController(BaseRepoController'
 
         except Exception:
             log.error(traceback.format_exc())
-            h.flash(_('Error occurred during update of repository %s') \
+            h.flash(_('Error occurred during update of repository %s')
                     % repo_name, category='error')
-        return redirect(url('edit_repo', repo_name=changed_name))
+        raise HTTPFound(location=url('edit_repo', repo_name=changed_name))
 
-    @HasRepoPermissionAllDecorator('repository.admin')
+    @HasRepoPermissionLevelDecorator('admin')
     def delete(self, repo_name):
-        """
-        DELETE /repos/repo_name: Delete an existing item"""
-        # Forms posted to this method should contain a hidden field:
-        #    <input type="hidden" name="_method" value="DELETE" />
-        # Or using helpers:
-        #    h.form(url('delete_repo', repo_name=ID),
-        #           method='delete')
-        # url('delete_repo', repo_name=ID)
-
         repo_model = RepoModel()
         repo = repo_model.get_by_repo_name(repo_name)
         if not repo:
             h.not_mapped_error(repo_name)
-            return redirect(url('repos'))
+            raise HTTPFound(location=url('repos'))
         try:
             _forks = repo.forks.count()
             handle_forks = None
@@ -312,8 +276,8 b' class ReposController(BaseRepoController'
                     handle_forks = 'delete'
                     h.flash(_('Deleted %s forks') % _forks, category='success')
             repo_model.delete(repo, forks=handle_forks)
-            action_logger(self.authuser, 'admin_deleted_repo',
-                  repo_name, self.ip_addr, self.sa)
+            action_logger(request.authuser, 'admin_deleted_repo',
+                repo_name, request.ip_addr)
             ScmModel().mark_for_invalidation(repo_name)
             h.flash(_('Deleted repository %s') % repo_name, category='success')
             Session().commit()
@@ -327,18 +291,14 b' class ReposController(BaseRepoController'
                     category='error')
 
         if repo.group:
-            return redirect(url('repos_group_home', group_name=repo.group.group_name))
-        return redirect(url('repos'))
+            raise HTTPFound(location=url('repos_group_home', group_name=repo.group.group_name))
+        raise HTTPFound(location=url('repos'))
 
-    @HasRepoPermissionAllDecorator('repository.admin')
+    @HasRepoPermissionLevelDecorator('admin')
     def edit(self, repo_name):
-        """GET /repo_name/settings: Form to edit an existing item"""
-        # url('edit_repo', repo_name=ID)
-        defaults = self.__load_data(repo_name)
-        c.repo_fields = RepositoryField.query()\
+        defaults = self.__load_data()
+        c.repo_fields = RepositoryField.query() \
             .filter(RepositoryField.repository == c.repo_info).all()
-        repo_model = RepoModel()
-        c.users_array = repo_model.get_users_js()
         c.active = 'settings'
         return htmlfill.render(
             render('admin/repos/repo_edit.html'),
@@ -346,14 +306,9 b' class ReposController(BaseRepoController'
             encoding="UTF-8",
             force_defaults=False)
 
-    @HasRepoPermissionAllDecorator('repository.admin')
+    @HasRepoPermissionLevelDecorator('admin')
     def edit_permissions(self, repo_name):
-        """GET /repo_name/settings: Form to edit an existing item"""
-        # url('edit_repo', repo_name=ID)
-        c.repo_info = self._load_repo(repo_name)
-        repo_model = RepoModel()
-        c.users_array = repo_model.get_users_js()
-        c.user_groups_array = repo_model.get_user_groups_js()
+        c.repo_info = self._load_repo()
         c.active = 'permissions'
         defaults = RepoModel()._get_defaults(repo_name)
 
@@ -363,19 +318,19 b' class ReposController(BaseRepoController'
             encoding="UTF-8",
             force_defaults=False)
 
-    @HasRepoPermissionAllDecorator('repository.admin')
+    @HasRepoPermissionLevelDecorator('admin')
     def edit_permissions_update(self, repo_name):
         form = RepoPermsForm()().to_python(request.POST)
         RepoModel()._update_permissions(repo_name, form['perms_new'],
                                         form['perms_updates'])
-        #TODO: implement this
-        #action_logger(self.authuser, 'admin_changed_repo_permissions',
-        #              repo_name, self.ip_addr, self.sa)
+        # TODO: implement this
+        #action_logger(request.authuser, 'admin_changed_repo_permissions',
+        #              repo_name, request.ip_addr)
         Session().commit()
         h.flash(_('Repository permissions updated'), category='success')
-        return redirect(url('edit_repo_perms', repo_name=repo_name))
+        raise HTTPFound(location=url('edit_repo_perms', repo_name=repo_name))
 
-    @HasRepoPermissionAllDecorator('repository.admin')
+    @HasRepoPermissionLevelDecorator('admin')
     def edit_permissions_revoke(self, repo_name):
         try:
             obj_type = request.POST.get('obj_type')
@@ -384,6 +339,7 b' class ReposController(BaseRepoController'
                 obj_id = safe_int(request.POST.get('user_id'))
             elif obj_type == 'user_group':
                 obj_id = safe_int(request.POST.get('user_group_id'))
+            else: assert False
 
             if obj_type == 'user':
                 RepoModel().revoke_user_permission(repo=repo_name, user=obj_id)
@@ -391,30 +347,30 b' class ReposController(BaseRepoController'
                 RepoModel().revoke_user_group_permission(
                     repo=repo_name, group_name=obj_id
                 )
-            #TODO: implement this
-            #action_logger(self.authuser, 'admin_revoked_repo_permissions',
-            #              repo_name, self.ip_addr, self.sa)
+            else: assert False
+            # TODO: implement this
+            #action_logger(request.authuser, 'admin_revoked_repo_permissions',
+            #              repo_name, request.ip_addr)
             Session().commit()
         except Exception:
             log.error(traceback.format_exc())
             h.flash(_('An error occurred during revoking of permission'),
                     category='error')
             raise HTTPInternalServerError()
+        return []
 
-    @HasRepoPermissionAllDecorator('repository.admin')
+    @HasRepoPermissionLevelDecorator('admin')
     def edit_fields(self, repo_name):
-        """GET /repo_name/settings: Form to edit an existing item"""
-        # url('edit_repo', repo_name=ID)
-        c.repo_info = self._load_repo(repo_name)
-        c.repo_fields = RepositoryField.query()\
+        c.repo_info = self._load_repo()
+        c.repo_fields = RepositoryField.query() \
             .filter(RepositoryField.repository == c.repo_info).all()
         c.active = 'fields'
         if request.POST:
 
-            return redirect(url('repo_edit_fields'))
+            raise HTTPFound(location=url('repo_edit_fields'))
         return render('admin/repos/repo_edit.html')
 
-    @HasRepoPermissionAllDecorator('repository.admin')
+    @HasRepoPermissionLevelDecorator('admin')
     def create_repo_field(self, repo_name):
         try:
             form_result = RepoFieldForm()().to_python(dict(request.POST))
@@ -427,15 +383,14 b' class ReposController(BaseRepoController'
             new_field.field_label = form_result['new_field_label']
             Session().add(new_field)
             Session().commit()
+        except formencode.Invalid as e:
+            h.flash(_('Field validation error: %s') % e.msg, category='error')
         except Exception as e:
             log.error(traceback.format_exc())
-            msg = _('An error occurred during creation of field')
-            if isinstance(e, formencode.Invalid):
-                msg += ". " + e.msg
-            h.flash(msg, category='error')
-        return redirect(url('edit_repo_fields', repo_name=repo_name))
+            h.flash(_('An error occurred during creation of field: %r') % e, category='error')
+        raise HTTPFound(location=url('edit_repo_fields', repo_name=repo_name))
 
-    @HasRepoPermissionAllDecorator('repository.admin')
+    @HasRepoPermissionLevelDecorator('admin')
     def delete_repo_field(self, repo_name, field_id):
         field = RepositoryField.get_or_404(field_id)
         try:
@@ -445,39 +400,37 b' class ReposController(BaseRepoController'
             log.error(traceback.format_exc())
             msg = _('An error occurred during removal of field')
             h.flash(msg, category='error')
-        return redirect(url('edit_repo_fields', repo_name=repo_name))
+        raise HTTPFound(location=url('edit_repo_fields', repo_name=repo_name))
 
-    @HasRepoPermissionAllDecorator('repository.admin')
+    @HasRepoPermissionLevelDecorator('admin')
     def edit_advanced(self, repo_name):
-        """GET /repo_name/settings: Form to edit an existing item"""
-        # url('edit_repo', repo_name=ID)
-        c.repo_info = self._load_repo(repo_name)
+        c.repo_info = self._load_repo()
         c.default_user_id = User.get_default_user().user_id
-        c.in_public_journal = UserFollowing.query()\
-            .filter(UserFollowing.user_id == c.default_user_id)\
+        c.in_public_journal = UserFollowing.query() \
+            .filter(UserFollowing.user_id == c.default_user_id) \
             .filter(UserFollowing.follows_repository == c.repo_info).scalar()
 
-        _repos = Repository.query().order_by(Repository.repo_name).all()
-        read_access_repos = RepoList(_repos)
+        _repos = Repository.query(sorted=True).all()
+        read_access_repos = RepoList(_repos, perm_level='read')
         c.repos_list = [(None, _('-- Not a fork --'))]
         c.repos_list += [(x.repo_id, x.repo_name)
                          for x in read_access_repos
                          if x.repo_id != c.repo_info.repo_id]
 
         defaults = {
-            'id_fork_of': c.repo_info.fork.repo_id if c.repo_info.fork else ''
+            'id_fork_of': c.repo_info.fork_id if c.repo_info.fork_id else ''
         }
 
         c.active = 'advanced'
         if request.POST:
-            return redirect(url('repo_edit_advanced'))
+            raise HTTPFound(location=url('repo_edit_advanced'))
         return htmlfill.render(
             render('admin/repos/repo_edit.html'),
             defaults=defaults,
             encoding="UTF-8",
             force_defaults=False)
 
-    @HasRepoPermissionAllDecorator('repository.admin')
+    @HasRepoPermissionLevelDecorator('admin')
     def edit_advanced_journal(self, repo_name):
         """
         Sets this repository to be visible in public journal,
@@ -497,10 +450,9 b' class ReposController(BaseRepoController'
             h.flash(_('An error occurred during setting this'
                       ' repository in public journal'),
                     category='error')
-        return redirect(url('edit_repo_advanced', repo_name=repo_name))
+        raise HTTPFound(location=url('edit_repo_advanced', repo_name=repo_name))
 
-
-    @HasRepoPermissionAllDecorator('repository.admin')
+    @HasRepoPermissionLevelDecorator('admin')
     def edit_advanced_fork(self, repo_name):
         """
         Mark given repository as a fork of another
@@ -510,7 +462,7 b' class ReposController(BaseRepoController'
         try:
             fork_id = request.POST.get('id_fork_of')
             repo = ScmModel().mark_as_fork(repo_name, fork_id,
-                                           self.authuser.username)
+                                           request.authuser.username)
             fork = repo.fork.repo_name if repo.fork else _('Nothing')
             Session().commit()
             h.flash(_('Marked repository %s as fork of %s') % (repo_name, fork),
@@ -523,9 +475,9 b' class ReposController(BaseRepoController'
             h.flash(_('An error occurred during this operation'),
                     category='error')
 
-        return redirect(url('edit_repo_advanced', repo_name=repo_name))
+        raise HTTPFound(location=url('edit_repo_advanced', repo_name=repo_name))
 
-    @HasRepoPermissionAllDecorator('repository.admin')
+    @HasRepoPermissionLevelDecorator('admin')
     def edit_advanced_locking(self, repo_name):
         """
         Unlock repository when it is locked !
@@ -535,7 +487,7 b' class ReposController(BaseRepoController'
         try:
             repo = Repository.get_by_repo_name(repo_name)
             if request.POST.get('set_lock'):
-                Repository.lock(repo, c.authuser.user_id)
+                Repository.lock(repo, request.authuser.user_id)
                 h.flash(_('Repository has been locked'), category='success')
             elif request.POST.get('set_unlock'):
                 Repository.unlock(repo)
@@ -544,16 +496,10 b' class ReposController(BaseRepoController'
             log.error(traceback.format_exc())
             h.flash(_('An error occurred during unlocking'),
                     category='error')
-        return redirect(url('edit_repo_advanced', repo_name=repo_name))
+        raise HTTPFound(location=url('edit_repo_advanced', repo_name=repo_name))
 
-    @HasRepoPermissionAnyDecorator('repository.write', 'repository.admin')
+    @HasRepoPermissionLevelDecorator('write')
     def toggle_locking(self, repo_name):
-        """
-        Toggle locking of repository by simple GET call to url
-
-        :param repo_name:
-        """
-
         try:
             repo = Repository.get_by_repo_name(repo_name)
 
@@ -562,24 +508,22 b' class ReposController(BaseRepoController'
                     Repository.unlock(repo)
                     h.flash(_('Repository has been unlocked'), category='success')
                 else:
-                    Repository.lock(repo, c.authuser.user_id)
+                    Repository.lock(repo, request.authuser.user_id)
                     h.flash(_('Repository has been locked'), category='success')
 
         except Exception as e:
             log.error(traceback.format_exc())
             h.flash(_('An error occurred during unlocking'),
                     category='error')
-        return redirect(url('summary_home', repo_name=repo_name))
+        raise HTTPFound(location=url('summary_home', repo_name=repo_name))
 
-    @HasRepoPermissionAllDecorator('repository.admin')
+    @HasRepoPermissionLevelDecorator('admin')
     def edit_caches(self, repo_name):
-        """GET /repo_name/settings: Form to edit an existing item"""
-        # url('edit_repo', repo_name=ID)
-        c.repo_info = self._load_repo(repo_name)
+        c.repo_info = self._load_repo()
         c.active = 'caches'
         if request.POST:
             try:
-                ScmModel().mark_for_invalidation(repo_name, delete=True)
+                ScmModel().mark_for_invalidation(repo_name)
                 Session().commit()
                 h.flash(_('Cache invalidation successful'),
                         category='success')
@@ -588,31 +532,27 b' class ReposController(BaseRepoController'
                 h.flash(_('An error occurred during cache invalidation'),
                         category='error')
 
-            return redirect(url('edit_repo_caches', repo_name=c.repo_name))
+            raise HTTPFound(location=url('edit_repo_caches', repo_name=c.repo_name))
         return render('admin/repos/repo_edit.html')
 
-    @HasRepoPermissionAllDecorator('repository.admin')
+    @HasRepoPermissionLevelDecorator('admin')
     def edit_remote(self, repo_name):
-        """GET /repo_name/settings: Form to edit an existing item"""
-        # url('edit_repo', repo_name=ID)
-        c.repo_info = self._load_repo(repo_name)
+        c.repo_info = self._load_repo()
         c.active = 'remote'
         if request.POST:
             try:
-                ScmModel().pull_changes(repo_name, self.authuser.username)
+                ScmModel().pull_changes(repo_name, request.authuser.username)
                 h.flash(_('Pulled from remote location'), category='success')
             except Exception as e:
                 log.error(traceback.format_exc())
                 h.flash(_('An error occurred during pull from remote location'),
                         category='error')
-            return redirect(url('edit_repo_remote', repo_name=c.repo_name))
+            raise HTTPFound(location=url('edit_repo_remote', repo_name=c.repo_name))
         return render('admin/repos/repo_edit.html')
 
-    @HasRepoPermissionAllDecorator('repository.admin')
+    @HasRepoPermissionLevelDecorator('admin')
     def edit_statistics(self, repo_name):
-        """GET /repo_name/settings: Form to edit an existing item"""
-        # url('edit_repo', repo_name=ID)
-        c.repo_info = self._load_repo(repo_name)
+        c.repo_info = self._load_repo()
         repo = c.repo_info.scm_instance
 
         if c.repo_info.stats:
@@ -638,6 +578,6 b' class ReposController(BaseRepoController'
                 log.error(traceback.format_exc())
                 h.flash(_('An error occurred during deletion of repository stats'),
                         category='error')
-            return redirect(url('edit_repo_statistics', repo_name=c.repo_name))
+            raise HTTPFound(location=url('edit_repo_statistics', repo_name=c.repo_name))
 
         return render('admin/repos/repo_edit.html')

kallithea/controllers/admin/settings.py

@@ -30,16 +30,18 b' import traceback'
 import formencode
 
 from formencode import htmlfill
-from pylons import request, tmpl_context as c, url, config
-from pylons.controllers.util import redirect
-from pylons.i18n.translation import _
+from tg import request, tmpl_context as c, config
+from tg.i18n import ugettext as _
+from webob.exc import HTTPFound
 
+from kallithea.config.routing import url
 from kallithea.lib import helpers as h
-from kallithea.lib.auth import LoginRequired, HasPermissionAllDecorator
+from kallithea.lib.auth import LoginRequired, HasPermissionAnyDecorator
 from kallithea.lib.base import BaseController, render
-from kallithea.lib.celerylib import tasks, run_task
+from kallithea.lib.celerylib import tasks
 from kallithea.lib.exceptions import HgsubversionImportError
 from kallithea.lib.utils import repo2db_mapper, set_app_settings
+from kallithea.lib.vcs import VCSError
 from kallithea.model.db import Ui, Repository, Setting
 from kallithea.model.forms import ApplicationSettingsForm, \
     ApplicationUiSettingsForm, ApplicationVisualisationForm
@@ -57,38 +59,30 b' class SettingsController(BaseController)'
     #     map.resource('setting', 'settings', controller='admin/settings',
     #         path_prefix='/admin', name_prefix='admin_')
 
-    @LoginRequired()
-    def __before__(self):
-        super(SettingsController, self).__before__()
+    @LoginRequired(allow_default_user=True)
+    def _before(self, *args, **kwargs):
+        super(SettingsController, self)._before(*args, **kwargs)
 
     def _get_hg_ui_settings(self):
         ret = Ui.query().all()
 
-        if not ret:
-            raise Exception('Could not get application ui settings !')
         settings = {}
         for each in ret:
-            k = each.ui_key
+            k = each.ui_section + '_' + each.ui_key
             v = each.ui_value
-            if k == '/':
-                k = 'root_path'
+            if k == 'paths_/':
+                k = 'paths_root_path'
 
-            if k == 'push_ssl':
-                v = str2bool(v)
-
-            if k.find('.') != -1:
-                k = k.replace('.', '_')
+            k = k.replace('.', '_')
 
             if each.ui_section in ['hooks', 'extensions']:
                 v = each.ui_active
 
-            settings[each.ui_section + '_' + k] = v
+            settings[k] = v
         return settings
 
-    @HasPermissionAllDecorator('hg.admin')
+    @HasPermissionAnyDecorator('hg.admin')
     def settings_vcs(self):
-        """GET /admin/settings: All items in the collection"""
-        # url('admin_settings')
         c.active = 'vcs'
         if request.POST:
             application_form = ApplicationUiSettingsForm()()
@@ -104,66 +98,37 b' class SettingsController(BaseController)'
                      force_defaults=False)
 
             try:
-                sett = Ui.get_by_key('push_ssl')
-                sett.ui_value = form_result['web_push_ssl']
-                Session().add(sett)
                 if c.visual.allow_repo_location_change:
-                    sett = Ui.get_by_key('/')
+                    sett = Ui.get_by_key('paths', '/')
                     sett.ui_value = form_result['paths_root_path']
-                    Session().add(sett)
 
-                #HOOKS
-                sett = Ui.get_by_key(Ui.HOOK_UPDATE)
+                # HOOKS
+                sett = Ui.get_by_key('hooks', Ui.HOOK_UPDATE)
                 sett.ui_active = form_result['hooks_changegroup_update']
-                Session().add(sett)
 
-                sett = Ui.get_by_key(Ui.HOOK_REPO_SIZE)
+                sett = Ui.get_by_key('hooks', Ui.HOOK_REPO_SIZE)
                 sett.ui_active = form_result['hooks_changegroup_repo_size']
-                Session().add(sett)
 
-                sett = Ui.get_by_key(Ui.HOOK_PUSH)
+                sett = Ui.get_by_key('hooks', Ui.HOOK_PUSH_LOG)
                 sett.ui_active = form_result['hooks_changegroup_push_logger']
-                Session().add(sett)
 
-                sett = Ui.get_by_key(Ui.HOOK_PULL)
+                sett = Ui.get_by_key('hooks', Ui.HOOK_PULL_LOG)
                 sett.ui_active = form_result['hooks_outgoing_pull_logger']
 
-                Session().add(sett)
-
                 ## EXTENSIONS
-                sett = Ui.get_by_key('largefiles')
-                if not sett:
-                    #make one if it's not there !
-                    sett = Ui()
-                    sett.ui_key = 'largefiles'
-                    sett.ui_section = 'extensions'
+                sett = Ui.get_or_create('extensions', 'largefiles')
                 sett.ui_active = form_result['extensions_largefiles']
-                Session().add(sett)
 
-                sett = Ui.get_by_key('hgsubversion')
-                if not sett:
-                    #make one if it's not there !
-                    sett = Ui()
-                    sett.ui_key = 'hgsubversion'
-                    sett.ui_section = 'extensions'
-
+                sett = Ui.get_or_create('extensions', 'hgsubversion')
                 sett.ui_active = form_result['extensions_hgsubversion']
                 if sett.ui_active:
                     try:
                         import hgsubversion  # pragma: no cover
                     except ImportError:
                         raise HgsubversionImportError
-                Session().add(sett)
 
-#                sett = Ui.get_by_key('hggit')
-#                if not sett:
-#                    #make one if it's not there !
-#                    sett = Ui()
-#                    sett.ui_key = 'hggit'
-#                    sett.ui_section = 'extensions'
-#
+#                sett = Ui.get_or_create('extensions', 'hggit')
 #                sett.ui_active = form_result['extensions_hggit']
-#                Session().add(sett)
 
                 Session().commit()
 
@@ -189,15 +154,13 b' class SettingsController(BaseController)'
             encoding="UTF-8",
             force_defaults=False)
 
-    @HasPermissionAllDecorator('hg.admin')
+    @HasPermissionAnyDecorator('hg.admin')
     def settings_mapping(self):
-        """GET /admin/settings/mapping: All items in the collection"""
-        # url('admin_settings_mapping')
         c.active = 'mapping'
         if request.POST:
             rm_obsolete = request.POST.get('destroy', False)
             install_git_hooks = request.POST.get('hooks', False)
-            overwrite_git_hooks = request.POST.get('hooks_overwrite', False);
+            overwrite_git_hooks = request.POST.get('hooks_overwrite', False)
             invalidate_cache = request.POST.get('invalidate', False)
             log.debug('rescanning repo location with destroy obsolete=%s, '
                       'install git hooks=%s and '
@@ -206,7 +169,7 b' class SettingsController(BaseController)'
             filesystem_repos = ScmModel().repo_scan()
             added, removed = repo2db_mapper(filesystem_repos, rm_obsolete,
                                             install_git_hooks=install_git_hooks,
-                                            user=c.authuser.username,
+                                            user=request.authuser.username,
                                             overwrite_git_hooks=overwrite_git_hooks)
             h.flash(h.literal(_('Repositories successfully rescanned. Added: %s. Removed: %s.') %
                 (', '.join(h.link_to(safe_unicode(repo_name), h.url('summary_home', repo_name=repo_name))
@@ -217,15 +180,15 b' class SettingsController(BaseController)'
             if invalidate_cache:
                 log.debug('invalidating all repositories cache')
                 i = 0
-                for repo in Repository.get_all():
+                for repo in Repository.query():
                     try:
-                        ScmModel().mark_for_invalidation(repo.repo_name, delete=True)
+                        ScmModel().mark_for_invalidation(repo.repo_name)
                         i += 1
                     except VCSError as e:
                         log.warning('VCS error invalidating %s: %s', repo.repo_name, e)
                 h.flash(_('Invalidated %s repositories') % i, category='success')
 
-            return redirect(url('admin_settings_mapping'))
+            raise HTTPFound(location=url('admin_settings_mapping'))
 
         defaults = Setting.get_app_settings()
         defaults.update(self._get_hg_ui_settings())
@@ -236,10 +199,8 b' class SettingsController(BaseController)'
             encoding="UTF-8",
             force_defaults=False)
 
-    @HasPermissionAllDecorator('hg.admin')
+    @HasPermissionAnyDecorator('hg.admin')
     def settings_global(self):
-        """GET /admin/settings/global: All items in the collection"""
-        # url('admin_settings_global')
         c.active = 'global'
         if request.POST:
             application_form = ApplicationSettingsForm()()
@@ -255,25 +216,14 b' class SettingsController(BaseController)'
                     force_defaults=False)
 
             try:
-                sett1 = Setting.create_or_update('title',
-                                            form_result['title'])
-                Session().add(sett1)
-
-                sett2 = Setting.create_or_update('realm',
-                                            form_result['realm'])
-                Session().add(sett2)
-
-                sett3 = Setting.create_or_update('ga_code',
-                                            form_result['ga_code'])
-                Session().add(sett3)
-
-                sett4 = Setting.create_or_update('captcha_public_key',
-                                    form_result['captcha_public_key'])
-                Session().add(sett4)
-
-                sett5 = Setting.create_or_update('captcha_private_key',
-                                    form_result['captcha_private_key'])
-                Session().add(sett5)
+                for setting in (
+                    'title',
+                    'realm',
+                    'ga_code',
+                    'captcha_public_key',
+                    'captcha_private_key',
+                ):
+                    Setting.create_or_update(setting, form_result[setting])
 
                 Session().commit()
                 set_app_settings(config)
@@ -285,7 +235,7 b' class SettingsController(BaseController)'
                           'application settings'),
                           category='error')
 
-            return redirect(url('admin_settings_global'))
+            raise HTTPFound(location=url('admin_settings_global'))
 
         defaults = Setting.get_app_settings()
         defaults.update(self._get_hg_ui_settings())
@@ -296,10 +246,8 b' class SettingsController(BaseController)'
             encoding="UTF-8",
             force_defaults=False)
 
-    @HasPermissionAllDecorator('hg.admin')
+    @HasPermissionAnyDecorator('hg.admin')
     def settings_visual(self):
-        """GET /admin/settings/visual: All items in the collection"""
-        # url('admin_settings_visual')
         c.active = 'visual'
         if request.POST:
             application_form = ApplicationVisualisationForm()()
@@ -318,7 +266,7 b' class SettingsController(BaseController)'
                 settings = [
                     ('show_public_icon', 'show_public_icon', 'bool'),
                     ('show_private_icon', 'show_private_icon', 'bool'),
-                    ('stylify_metatags', 'stylify_metatags', 'bool'),
+                    ('stylify_metalabels', 'stylify_metalabels', 'bool'),
                     ('repository_fields', 'repository_fields', 'bool'),
                     ('dashboard_items', 'dashboard_items', 'int'),
                     ('admin_grid_items', 'admin_grid_items', 'int'),
@@ -328,9 +276,7 b' class SettingsController(BaseController)'
                     ('clone_uri_tmpl', 'clone_uri_tmpl', 'unicode'),
                 ]
                 for setting, form_key, type_ in settings:
-                    sett = Setting.create_or_update(setting,
-                                        form_result[form_key], type_)
-                    Session().add(sett)
+                    Setting.create_or_update(setting, form_result[form_key], type_)
 
                 Session().commit()
                 set_app_settings(config)
@@ -343,7 +289,7 b' class SettingsController(BaseController)'
                           'visualisation settings'),
                         category='error')
 
-            return redirect(url('admin_settings_visual'))
+            raise HTTPFound(location=url('admin_settings_visual'))
 
         defaults = Setting.get_app_settings()
         defaults.update(self._get_hg_ui_settings())
@@ -354,10 +300,8 b' class SettingsController(BaseController)'
             encoding="UTF-8",
             force_defaults=False)
 
-    @HasPermissionAllDecorator('hg.admin')
+    @HasPermissionAnyDecorator('hg.admin')
     def settings_email(self):
-        """GET /admin/settings/email: All items in the collection"""
-        # url('admin_settings_email')
         c.active = 'email'
         if request.POST:
             test_email = request.POST.get('test_email')
@@ -366,22 +310,22 b' class SettingsController(BaseController)'
                                'Kallithea version: %s' % c.kallithea_version)
             if not test_email:
                 h.flash(_('Please enter email address'), category='error')
-                return redirect(url('admin_settings_email'))
+                raise HTTPFound(location=url('admin_settings_email'))
 
-            test_email_txt_body = EmailNotificationModel()\
+            test_email_txt_body = EmailNotificationModel() \
                 .get_email_tmpl(EmailNotificationModel.TYPE_DEFAULT,
                                 'txt', body=test_body)
-            test_email_html_body = EmailNotificationModel()\
+            test_email_html_body = EmailNotificationModel() \
                 .get_email_tmpl(EmailNotificationModel.TYPE_DEFAULT,
                                 'html', body=test_body)
 
             recipients = [test_email] if test_email else None
 
-            run_task(tasks.send_email, recipients, test_email_subj,
-                     test_email_txt_body, test_email_html_body)
+            tasks.send_email(recipients, test_email_subj,
+                             test_email_txt_body, test_email_html_body)
 
             h.flash(_('Send email task created'), category='success')
-            return redirect(url('admin_settings_email'))
+            raise HTTPFound(location=url('admin_settings_email'))
 
         defaults = Setting.get_app_settings()
         defaults.update(self._get_hg_ui_settings())
@@ -395,10 +339,8 b' class SettingsController(BaseController)'
             encoding="UTF-8",
             force_defaults=False)
 
-    @HasPermissionAllDecorator('hg.admin')
+    @HasPermissionAnyDecorator('hg.admin')
     def settings_hooks(self):
-        """GET /admin/settings/hooks: All items in the collection"""
-        # url('admin_settings_hooks')
         c.active = 'hooks'
         if request.POST:
             if c.visual.allow_custom_hooks_settings:
@@ -409,7 +351,11 b' class SettingsController(BaseController)'
 
                 try:
                     ui_key = ui_key and ui_key.strip()
-                    if ui_value and ui_key:
+                    if ui_key in (x.ui_key for x in Ui.get_custom_hooks()):
+                        h.flash(_('Hook already exists'), category='error')
+                    elif ui_key in (x.ui_key for x in Ui.get_builtin_hooks()):
+                        h.flash(_('Builtin hooks are read-only. Please use another hook name.'), category='error')
+                    elif ui_value and ui_key:
                         Ui.create_or_update_hook(ui_key, ui_value)
                         h.flash(_('Added new hook'), category='success')
                     elif hook_id:
@@ -419,10 +365,12 b' class SettingsController(BaseController)'
                     # check for edits
                     update = False
                     _d = request.POST.dict_of_lists()
-                    for k, v in zip(_d.get('hook_ui_key', []),
-                                    _d.get('hook_ui_value_new', [])):
-                        Ui.create_or_update_hook(k, v)
-                        update = True
+                    for k, v, ov in zip(_d.get('hook_ui_key', []),
+                                        _d.get('hook_ui_value_new', []),
+                                        _d.get('hook_ui_value', [])):
+                        if v != ov:
+                            Ui.create_or_update_hook(k, v)
+                            update = True
 
                     if update:
                         h.flash(_('Updated hooks'), category='success')
@@ -432,7 +380,7 b' class SettingsController(BaseController)'
                     h.flash(_('Error occurred during hook creation'),
                             category='error')
 
-                return redirect(url('admin_settings_hooks'))
+                raise HTTPFound(location=url('admin_settings_hooks'))
 
         defaults = Setting.get_app_settings()
         defaults.update(self._get_hg_ui_settings())
@@ -446,17 +394,15 b' class SettingsController(BaseController)'
             encoding="UTF-8",
             force_defaults=False)
 
-    @HasPermissionAllDecorator('hg.admin')
+    @HasPermissionAnyDecorator('hg.admin')
     def settings_search(self):
-        """GET /admin/settings/search: All items in the collection"""
-        # url('admin_settings_search')
         c.active = 'search'
         if request.POST:
             repo_location = self._get_hg_ui_settings()['paths_root_path']
             full_index = request.POST.get('full_index', False)
-            run_task(tasks.whoosh_index, repo_location, full_index)
+            tasks.whoosh_index(repo_location, full_index)
             h.flash(_('Whoosh reindex task scheduled'), category='success')
-            return redirect(url('admin_settings_search'))
+            raise HTTPFound(location=url('admin_settings_search'))
 
         defaults = Setting.get_app_settings()
         defaults.update(self._get_hg_ui_settings())
@@ -467,10 +413,8 b' class SettingsController(BaseController)'
             encoding="UTF-8",
             force_defaults=False)
 
-    @HasPermissionAllDecorator('hg.admin')
+    @HasPermissionAnyDecorator('hg.admin')
     def settings_system(self):
-        """GET /admin/settings/system: All items in the collection"""
-        # url('admin_settings_system')
         c.active = 'system'
 
         defaults = Setting.get_app_settings()
@@ -489,10 +433,8 b' class SettingsController(BaseController)'
             encoding="UTF-8",
             force_defaults=False)
 
-    @HasPermissionAllDecorator('hg.admin')
+    @HasPermissionAnyDecorator('hg.admin')
     def settings_system_update(self):
-        """GET /admin/settings/system/updates: All items in the collection"""
-        # url('admin_settings_system_update')
         import json
         import urllib2
         from kallithea.lib.verlib import NormalizedVersion
@@ -503,7 +445,7 b' class SettingsController(BaseController)'
         _update_url = defaults.get('update_url', '')
         _update_url = "" # FIXME: disabled
 
-        _err = lambda s: '<div style="color:#ff8888; padding:4px 0px">%s</div>' % (s)
+        _err = lambda s: '<div class="alert alert-danger">%s</div>' % (s)
         try:
             import kallithea
             ver = kallithea.__version__