kallithea Changeset - 747cc853b5e9

Changeset - 747cc853b5e9

Parent rev.

Child rev.

[Not reviewed]

Merge stable

54 270 49

Thomas De Schampheleire - 5 years ago 2021-05-27 21:27:37
thomas.de_schampheleire@nokia.com

release: merge default to stable for 0.7.0

55 files changed:

.coveragerc

.hgignore

CONTRIBUTORS

MANIFEST.in

README.rst

dev_requirements.txt

development.ini

docs/conf.py

docs/contributing.rst

106

docs/index.rst

docs/installation.rst

docs/overview.rst

docs/setup.rst

117

docs/upgrade.rst

docs/usage/customization.rst

docs/usage/email.rst

docs/usage/general.rst

docs/usage/performance.rst

docs/usage/troubleshooting.rst

init.d/kallithea-daemon-debian

init.d/kallithea-daemon-gentoo

init.d/kallithea-daemon-redhat

kallithea/__init__.py

kallithea/alembic/env.py

kallithea/alembic/versions/7ba0d2cad930_hooks_migrate_internal_hooks_to_.py

kallithea/alembic/versions/a020f7044fd6_rename_hooks.py

kallithea/alembic/versions/ad357ccd9521_drop_locking.py

kallithea/alembic/versions/f62826179f39_add_unique_constraint_on_.py

kallithea/bin/kallithea_cli_base.py

kallithea/bin/kallithea_cli_celery.py

kallithea/bin/kallithea_cli_config.py

kallithea/bin/kallithea_cli_db.py

kallithea/bin/kallithea_cli_extensions.py

kallithea/bin/kallithea_cli_iis.py

kallithea/bin/kallithea_cli_index.py

kallithea/bin/kallithea_cli_repo.py

kallithea/bin/kallithea_cli_ssh.py

kallithea/bin/vcs_hooks.py

260

kallithea/config/app_cfg.py

kallithea/config/application.py

kallithea/config/environment.py

kallithea/config/middleware/__init__.py

rename

kallithea/config/middleware/https_fixup.py

kallithea/config/middleware/permanent_repo_url.py

kallithea/config/middleware/pygrack.py

kallithea/config/middleware/simplegit.py

kallithea/config/middleware/simplehg.py

kallithea/config/middleware/wrapper.py

kallithea/config/pre_receive_tmpl.py

kallithea/controllers/admin/admin.py

kallithea/controllers/admin/auth_settings.py

kallithea/controllers/admin/defaults.py

kallithea/controllers/admin/gists.py

kallithea/controllers/admin/my_account.py

kallithea/controllers/admin/permissions.py

Changeset was too big and was cut off... Show full diff anyway

0 comments (0 inline, 0 general)

.coveragerc

➞

Show inline comments

 [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

.hgignore

➞

Show inline comments

 syntax: glob
 *.pyc
 *.swp
 *.sqlite
 *.tox
 *.egg-info
 *.egg
 *.mo
 *.orig
 *.rej
 *.bak
 .eggs/
 tarballcache/
 syntax: regexp
 ^rcextensions
 ^build
 ^dist/
 ^docs/build/
 ^docs/_build/
 ^extensions\.py$
 ^build$
 ^dist$
 ^docs/build$
 ^docs/_build$
 ^data$
-^sql_dumps/
+^sql_dumps$
 ^\.settings$
 ^\.project$
 ^\.pydevproject$
 ^\.coverage$
 ^kallithea/front-end/node_modules$
 ^kallithea/front-end/package-lock\.json$
 ^kallithea/front-end/theme\.less$
 ^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$
 ^kallithea\.db$
 ^test\.db$
 ^Kallithea\.egg-info$
 ^my\.ini$
 ^fabfile.py
+^fabfile\.py$
 ^\.idea$
 ^\.cache$
 ^\.pytest_cache$
 ^venv$
 /__pycache__$
 ^deps\.dot$
 ^deps\.svg$
 ^deps\.txt$
 ^\.pytype/

CONTRIBUTORS

➞

Show inline comments

 List of contributors to Kallithea project:
     Thomas De Schampheleire <thomas.de_schampheleire@nokia.com> 2014-2020
     Mads Kiilerich <mads@kiilerich.com> 2016-2020
     Thomas De Schampheleire <thomas.de_schampheleire@nokia.com> 2014-2021
     Mads Kiilerich <mads@kiilerich.com> 2016-2021
     ssantos <ssantos@web.de> 2018-2021
     Private <adamantine.sword@gmail.com> 2019-2021
     Étienne Gilli <etienne@gilli.io> 2020-2021
     fresh <fresh190@protonmail.com> 2020-2021
     robertus <robertuss12@gmail.com> 2020-2021
     Eugenia Russell <eugenia.russell2019@gmail.com> 2021
     Michalis <michalisntovas@yahoo.gr> 2021
     vs <vsuhachev@yandex.ru> 2021
     Александр <akonn7@mail.ru> 2021
     Asterios Dimitriou <steve@pci.gr> 2016-2017 2020
     Allan Nordhøy <epost@anotheragency.no> 2017-2020
     Anton Schur <tonich.sh@gmail.com> 2017 2020
     ssantos <ssantos@web.de> 2018-2020
     Manuel Jacob <me@manueljacob.de> 2019-2020
-    Private <adamantine.sword@gmail.com> 2019-2020
+    Artem <kovalevartem.ru@gmail.com> 2020
     David Ignjić <ignjic@gmail.com> 2020
     Dennis Fink <dennis.fink@c3l.lu> 2020
     Étienne Gilli <etienne@gilli.io> 2020
     J. Lavoie <j.lavoie@net-c.ca> 2020
     robertus <robertuss12@gmail.com> 2020
     Ross Thomas <ross@lns-nevasoft.com> 2020
     Tim Ooms <tatankat@users.noreply.github.com> 2020
     Andrej Shadura <andrew@shadura.me> 2012 2014-2017 2019
     Étienne Gilli <etienne.gilli@gmail.com> 2015-2017 2019
     Adi Kriegisch <adi@cg.tuwien.ac.at> 2019
     Danni Randeris <danniranderis@gmail.com> 2019
     Edmund Wong <ewong@crazy-cat.org> 2019
     Elizabeth Sherrock <lizzyd710@gmail.com> 2019
     Hüseyin Tunç <huseyin.tunc@bulutfon.com> 2019
     leela <53352@protonmail.com> 2019
     Mateusz Mendel <mendelm9@gmail.com> 2019
     Nathan <bonnemainsnathan@gmail.com> 2019
     Oleksandr Shtalinberg <o.shtalinberg@gmail.com> 2019
     THANOS SIOURDAKIS <siourdakisthanos@gmail.com> 2019
     Wolfgang Scherer <wolfgang.scherer@gmx.de> 2019
     Христо Станев <hstanev@gmail.com> 2019
     Dominik Ruf <dominikruf@gmail.com> 2012 2014-2018
     Michal Čihař <michal@cihar.com> 2014-2015 2018
     Branko Majic <branko@majic.rs> 2015 2018
     Chris Rule <crule@aegistg.com> 2018
     Jesús Sánchez <jsanchezfdz95@gmail.com> 2018
     Patrick Vane <patrick_vane@lowentry.com> 2018
     Pheng Heong Tan <phtan90@gmail.com> 2018
     Максим Якимчук <xpinovo@gmail.com> 2018
     Марс Ямбар <mjambarmeta@gmail.com> 2018
     Mads Kiilerich <madski@unity3d.com> 2012-2017

MANIFEST.in

➞

Show inline comments

 include           .coveragerc
 include           .eslintrc.js
 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           conftest.py
 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/lib/paster_commands/template.ini.mako
 recursive-include kallithea/front-end *
 recursive-include kallithea/i18n *
 recursive-include kallithea/public *
 recursive-include kallithea/templates *
 recursive-include kallithea/tests/fixtures *
 recursive-include kallithea/tests/scripts *
 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

➞

Show inline comments

@@ @@ -53,50 +53,50 @@ https://kallithea-scm.org/repos/kallithe @@
 Kallithea features
 ------------------
 - Has its own middleware to handle Mercurial_ and Git_ protocol requests. Each
   request is authenticated and logged together with IP address.
 - Built for speed and performance. You can make multiple pulls/pushes
   simultaneously. Proven to work with thousands of repositories and users.
 - Supports HTTP/HTTPS with LDAP, AD, or proxy-pass authentication.
 - Supports SSH access with server-side public key management.
 - Full permissions (private/read/write/admin) together with IP restrictions for
   each repository, additional explicit forking, repositories group and
   repository creation permissions.
 - User groups for easier permission management.
 - Repository groups let you group repos and manage them easier. They come with
   permission delegation features, so you can delegate groups management.
 - Users can fork other users repos, and compare them at any time.
 - Built-in versioned paste functionality (Gist) for sharing code snippets.
 - Integrates easily with other systems, with custom created mappers you can
   connect it to almost any issue tracker, and with a JSON-RPC API you can make
   much more.
 - Built-in commit API lets you add, edit and commit files right from Kallithea
   web interface using simple editor or upload binary files using simple form.
 - Powerful pull request driven review system with inline commenting, changeset
   statuses, and notification system.
 - Importing and syncing repositories from remote locations for Git_, Mercurial_
   and Subversion.
 - Importing and syncing repositories from remote locations for Git_ and
   Mercurial_.
 - Mako templates let you customize the look and feel of the application.
 - Beautiful diffs, annotations and source code browsing all colored by
   pygments. Raw diffs are made in Git-diff format for both VCS systems,
   including Git_ binary-patches.
 - Mercurial_ and Git_ DAG graphs and Flot-powered graphs with zooming and
   statistics to track activity for repositories.
 - Admin interface with user/permission management. Admin activity journal logs
   pulls, pushes, forks, registrations and other actions made by all users.
 - Server side forks. It is possible to fork a project and modify it freely
   without breaking the main repository.
 - reST and Markdown README support for repositories.
 - Full text search powered by Whoosh on the source files, commit messages, and
   file names. Built-in indexing daemons, with optional incremental index build
   (no external search servers required all in one application).
 - Setup project descriptions/tags and info inside built in DB for easy,
   non-filesystem operations.
 - Intelligent cache with invalidation after push or project change, provides
   high performance and always up to date data.
 - RSS/Atom feeds, Gravatar support, downloadable sources as zip/tar/gz.
 - Optional async tasks for speed and performance using Celery_.
 - Backup scripts can do backup of whole app and send it over scp to desired
   location.
 - Based on TurboGears2, SQLAlchemy, Whoosh, Bootstrap, and other open source
   libraries.
@@ @@ -154,29 +154,28 @@ version can be found on https://docs.kal @@
 You can also build the documentation locally: go to ``docs/`` and run::
    make html
 .. note:: You need to have Sphinx_ installed to build the
           documentation. If you don't have Sphinx_ installed you can
           install it via the command: ``pip install sphinx`` .
 Migrating from RhodeCode
 ------------------------
 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.
 .. _Python: http://www.python.org/
 .. _Sphinx: http://sphinx.pocoo.org/
 .. _Mercurial: http://mercurial.selenic.com/
 .. _Bitbucket: http://bitbucket.org/
 .. _GitHub: http://github.com/
 .. _Subversion: http://subversion.tigris.org/
 .. _Git: http://git-scm.com/
 .. _Celery: http://celeryproject.org/
 .. _Software Freedom Conservancy: http://sfconservancy.org/
 .. _Puppet module: https://forge.puppetlabs.com/rauch/kallithea

dev_requirements.txt

➞

Show inline comments

-pytest >= 4.6.6, < 5.4
+pytest >= 4.6.6, < 5.5
 pytest-sugar >= 0.9.2, < 0.10
 pytest-benchmark >= 3.2.2, < 3.3
 pytest-localserver >= 0.5.0, < 0.6
 mock >= 3.0.0, < 4.1
-Sphinx >= 1.8.0, < 2.4
+Sphinx >= 1.8.0, < 3.1
 WebTest >= 2.0.6, < 2.1
 isort == 4.3.21
 pyflakes == 2.1.1
 isort == 5.1.2
 pyflakes == 2.2.0

development.ini

➞

Show inline comments

@@ @@ -46,97 +46,104 @@ email_to = @@
 ## Default: (none)
 ## Examples:
 #error_email_from = Kallithea Errors <kallithea-noreply@example.com>
 #error_email_from = kallithea_errors@example.com
 error_email_from =
 ## SMTP server settings
 ## 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 =
 smtp_use_ssl = false
 smtp_use_tls = false
 ## Entry point for 'gearbox serve'
 [server:main]
 #host = 127.0.0.1
 host = 0.0.0.0
 port = 5000
-## WAITRESS ##
+## Gearbox serve uses the Waitress web server ##
 use = egg:waitress#main
-## number of worker threads
+## avoid multi threading
 threads = 1
-## MAX BODY SIZE 100GB
+## allow push of repos bigger than the default of 1 GB
 max_request_body_size = 107374182400
 ## use poll instead of select, fixes fd limits, may not work on old
 ## windows systems.
 #asyncore_use_poll = True
 ## middleware for hosting the WSGI application under a URL prefix
 #[filter:proxy-prefix]
 #use = egg:PasteDeploy#prefix
 #prefix = /<your-prefix>
 #translate_forwarded_server = False
 [app:main]
 use = egg:kallithea
 ## enable proxy prefix middleware
 #filter-with = proxy-prefix
 full_stack = true
 static_files = true
 ## Internationalization (see setup documentation for details)
 ## By default, the languages requested by the browser are used if available, with English as default.
 ## Set i18n.enabled=false to disable automatic language choice.
 #i18n.enabled = true
 ## To Force a language, set i18n.enabled=false and specify the language in i18n.lang.
 ## Valid values are the names of subdirectories in kallithea/i18n with a LC_MESSAGES/kallithea.mo
 #i18n.lang = en
 cache_dir = %(here)s/data
 index_dir = %(here)s/data/index
 ## uncomment and set this path to use archive download cache
 archive_cache_dir = %(here)s/tarballcache
+archive_cache_dir = %(here)s/data/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
 ## force https in Kallithea, fixes https redirects, assumes it's always https
 force_https = false
 ## WSGI environment variable to get the IP address of the client (default REMOTE_ADDR)
 #remote_addr_variable = HTTP_X_FORWARDED_FOR
 ## WSGI environment variable to get the protocol (http or https) of the client connection (default wsgi.url_scheme)
 #url_scheme_variable = HTTP_X_FORWARDED_PROTO
 ## use Strict-Transport-Security headers
 use_htsts = false
 ## always pretend the client connected using HTTPS (default false)
 #force_https = true
 ## use Strict-Transport-Security headers (default false)
 #use_htsts = true
 ## number of commits stats will parse on each iteration
 commit_parse_limit = 25
 ## Path to Python executable to be used for git hooks.
 ## This value will be written inside the git hook scripts as the text
 ## after '#!' (shebang). When empty or not defined, the value of
 ## 'sys.executable' at the time of installation of the git hooks is
 ## used, which is correct in many cases but for example not when using uwsgi.
 ## If you change this setting, you should reinstall the Git hooks via
 ## Admin > Settings > Remap and Rescan.
 #git_hook_interpreter = /srv/kallithea/venv/bin/python3
 ## path to git executable
 git_path = git
 ## git rev filter option, --all is the default filter, if you need to
 ## hide all refs in changelog switch this to --branches --tags
 #git_rev_filter = --branches --tags
 ## RSS feed options
 rss_cut_off_limit = 256000
 rss_items_per_page = 10
 rss_include_diff = false
@@ @@ -238,57 +245,50 @@ ssh_enabled = false @@
 ## File where users' SSH keys will be stored *if* ssh_enabled is true.
 #ssh_authorized_keys = /home/kallithea/.ssh/authorized_keys
 ## Path to be used in ssh_authorized_keys file to invoke kallithea-cli with ssh-serve.
 #kallithea_cli_path = /srv/kallithea/venv/bin/kallithea-cli
 ## Locale to be used in the ssh-serve command.
 ## This is needed because an SSH client may try to use its own locale
 ## settings, which may not be available on the server.
 ## See `locale -a` for valid values on this system.
 #ssh_locale = C.UTF-8
 ####################################
 ##         CELERY CONFIG          ##
 ####################################
 ## Note: Celery doesn't support Windows.
 use_celery = false
 ## Celery config settings from https://docs.celeryproject.org/en/4.4.0/userguide/configuration.html prefixed with 'celery.'.
 ## Example: use the message queue on the local virtual host 'kallitheavhost' as the RabbitMQ user 'kallithea':
 celery.broker_url = amqp://kallithea:thepassword@localhost:5672/kallitheavhost
 celery.result_backend = db+sqlite:///celery-results.db
 #celery.amqp.task.result.expires = 18000
 celery.worker_concurrency = 2
 celery.worker_max_tasks_per_child = 1
 ## If true, tasks will never be sent to the queue, but executed locally instead.
 celery.task_always_eager = false
 celery.worker_max_tasks_per_child = 100
 ####################################
 ##          BEAKER CACHE          ##
 ####################################
 beaker.cache.data_dir = %(here)s/data/cache/data
 beaker.cache.lock_dir = %(here)s/data/cache/lock
 beaker.cache.regions = long_term,long_term_file
 beaker.cache.long_term.type = memory
 beaker.cache.long_term.expire = 36000
 beaker.cache.long_term.key_length = 256
 beaker.cache.long_term_file.type = file
 beaker.cache.long_term_file.expire = 604800
 beaker.cache.long_term_file.key_length = 256
 ####################################
 ##        BEAKER SESSION          ##
 ####################################
 ## Name of session cookie. Should be unique for a given host and path, even when running
 ## on different ports. Otherwise, cookie sessions will be shared and messed up.
@@ @@ -325,65 +325,64 @@ session.secret = development-not-secret @@
 ## Show a nice error page for application HTTP errors and exceptions (default true)
 #errorpage.enabled = true
 ## Enable Backlash client-side interactive debugger (default false)
 ## WARNING: *THIS MUST BE false IN PRODUCTION ENVIRONMENTS!!!*
 ## This debug mode will allow all visitors to execute malicious code.
 #debug = false
 debug = true
 ## Enable Backlash server-side error reporting (unless debug mode handles it client-side) (default true)
 #trace_errors.enable = true
 ## Errors will be reported by mail if trace_errors.error_email is set.
 ## Propagate email settings to ErrorReporter of TurboGears2
 ## You do not normally need to change these lines
 get trace_errors.smtp_server = smtp_server
 get trace_errors.smtp_port = smtp_port
 get trace_errors.from_address = error_email_from
 get trace_errors.error_email = email_to
 get trace_errors.smtp_username = smtp_username
 get trace_errors.smtp_password = smtp_password
 get trace_errors.smtp_use_tls = smtp_use_tls
 ##################################
 ##        LOGVIEW CONFIG        ##
 ##################################
 logview.sqlalchemy = #faa
 logview.pylons.templating = #bfb
 logview.pylons.util = #eee
 #########################
 ##      DB CONFIG      ##
 #########################
 ## SQLITE [default]
 sqlalchemy.url = sqlite:///%(here)s/kallithea.db?timeout=60
 ## see sqlalchemy docs for other backends
 #sqlalchemy.url = postgresql://kallithea:password@localhost/kallithea
 #sqlalchemy.url = mysql://kallithea:password@localhost/kallithea?charset=utf8mb4
 ## Note: the mysql:// prefix should also be used for MariaDB
 sqlalchemy.pool_recycle = 3600
 ################################
 ##   ALEMBIC CONFIGURATION    ##
 ################################
 [alembic]
 script_location = kallithea:alembic
 ################################
 ##   LOGGING CONFIGURATION    ##
 ################################
 [loggers]
 keys = root, routes, kallithea, sqlalchemy, tg, gearbox, beaker, templates, whoosh_indexer, werkzeug, backlash
 [handlers]
 keys = console, console_color, console_color_sql, null
 [formatters]
 keys = generic, color_formatter, color_formatter_sql
 #############

docs/conf.py

➞

Show inline comments

 # -*- coding: utf-8 -*-
+#
 # Kallithea documentation build configuration file, created by
 # sphinx-quickstart on Sun Oct 10 16:46:37 2010.
+#
 # This file is execfile()d with the current directory set to its containing dir.
+#
 # Note that not all possible configuration values are present in this
 # autogenerated file.
+#
 # All configuration values have a default; values that are commented out
 # serve to show the default.
 import os
 import sys
-from kallithea import __version__
+import kallithea
 # If extensions (or modules to document with autodoc) are in another directory,
 # add these directories to sys.path here. If the directory is relative to the
 # documentation root, use os.path.abspath to make it absolute, like shown here.
 sys.path.insert(0, os.path.abspath('..'))
 # -- General configuration -----------------------------------------------------
 # If your documentation needs a minimal Sphinx version, state it here.
 #needs_sphinx = '1.0'
 # Add any Sphinx extension module names here, as strings. They can be extensions
 # coming with Sphinx (named 'sphinx.ext.*') or your custom ones.
 extensions = ['sphinx.ext.autodoc', 'sphinx.ext.doctest',
               'sphinx.ext.intersphinx', 'sphinx.ext.todo',
               'sphinx.ext.viewcode']
 # Add any paths that contain templates here, relative to this directory.
 templates_path = ['_templates']
 # The suffix of source filenames.
 source_suffix = '.rst'
 # The encoding of source files.
 #source_encoding = 'utf-8-sig'
 # The master toctree document.
 master_doc = 'index'
 # General information about the project.
 project = 'Kallithea'
-copyright = '2010-2020 by various authors, licensed as GPLv3.'
+copyright = '2010-2021 by various authors, licensed as GPLv3.'
 # The version info for the project you're documenting, acts as replacement for
 # |version| and |release|, also used in various other places throughout the
 # built documents.
+#
 # The short X.Y version.
 root = os.path.dirname(os.path.dirname(__file__))
 sys.path.append(root)
 version = __version__
+version = kallithea.__version__
 # The full version, including alpha/beta/rc tags.
 release = __version__
+release = kallithea.__version__
 # The language for content autogenerated by Sphinx. Refer to documentation
 # for a list of supported languages.
 #language = None
 # There are two options for replacing |today|: either, you set today to some
 # non-false value, then it is used:
 #today = ''
 # Else, today_fmt is used as the format for a strftime call.
 #today_fmt = '%B %d, %Y'
 # List of patterns, relative to source directory, that match files and
 # directories to ignore when looking for source files.
 exclude_patterns = ['_build']
 # The reST default role (used for this markup: `text`) to use for all documents.
 #default_role = None
 # If true, '()' will be appended to :func: etc. cross-reference text.
 #add_function_parentheses = True
 # If true, the current module name will be prepended to all description
 # unit titles (such as .. function::).
 #add_module_names = True

docs/contributing.rst

➞

Show inline comments

@@ @@ -5,106 +5,206 @@ Contributing to Kallithea @@
 =========================
 Kallithea is developed and maintained by its users. Please join us and scratch
 your own itch.
 Infrastructure
 --------------
 The main repository is hosted on Our Own Kallithea (aka OOK) at
 https://kallithea-scm.org/repos/kallithea/, our self-hosted instance
 of Kallithea.
 Please use the `mailing list`_ to send patches or report issues.
 We use Weblate_ to translate the user interface messages into languages other
 than English. Join our project on `Hosted Weblate`_ to help us.
 To register, you can use your Bitbucket or GitHub account. See :ref:`translations`
 for more details.
 Getting started
 ---------------
 To get started with Kallithea development::
 To get started with Kallithea development run the following commands in your
 bash shell::
         hg clone https://kallithea-scm.org/repos/kallithea
         cd kallithea
         python3 -m venv ../kallithea-venv
         source ../kallithea-venv/bin/activate
         python3 -m venv venv
         . venv/bin/activate
         pip install --upgrade pip setuptools
         pip install --upgrade -e . -r dev_requirements.txt python-ldap python-pam
         kallithea-cli config-create my.ini
         kallithea-cli db-create -c my.ini --user=user --email=user@example.com --password=password --repos=/tmp
         kallithea-cli front-end-build
         gearbox serve -c my.ini --reload &
         firefox http://127.0.0.1:5000/
 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, via the mailing list (via ``hg email``).
 .. _contributing-tests:
 Internal dependencies
 ---------------------
 We try to keep the code base clean and modular and avoid circular dependencies.
 Code should only invoke code in layers below itself.
 Imports should import whole modules ``from`` their parent module, perhaps
 ``as`` a shortened name. Avoid imports ``from`` modules.
 To avoid cycles and partially initialized modules, ``__init__.py`` should *not*
 contain any non-trivial imports. The top level of a module should *not* be a
 facade for the module functionality.
 Common code for a module is often in ``base.py``.
 The important part of the dependency graph is approximately linear. In the
 following list, modules may only depend on modules below them:
 ``tests``
   Just get the job done - anything goes.
 ``bin/`` & ``config/`` & ``alembic/``
   The main entry points, defined in ``setup.py``. Note: The TurboGears template
   use ``config`` for the high WSGI application - this is not for low level
   configuration.
 ``controllers/``
   The top level web application, with TurboGears using the ``root`` controller
   as entry point, and ``routing`` dispatching to other controllers.
 ``templates/**.html``
   The "view", rendering to HTML. Invoked by controllers which can pass them
   anything from lower layers - especially ``helpers`` available as ``h`` will
   cut through all layers, and ``c`` gives access to global variables.
 ``lib/helpers.py``
   High level helpers, exposing everything to templates as ``h``. It depends on
   everything and has a huge dependency chain, so it should not be used for
   anything else. TODO.
 ``controllers/base.py``
   The base class of controllers, with lots of model knowledge.
 ``lib/auth.py``
   All things related to authentication. TODO.
 ``lib/utils.py``
   High level utils with lots of model knowledge. TODO.
 ``lib/hooks.py``
   Hooks into "everything" to give centralized logging to database, cache
   invalidation, and extension handling. TODO.
 ``model/``
   Convenience business logic wrappers around database models.
 ``model/db.py``
   Defines the database schema and provides some additional logic.
 ``model/scm.py``
   All things related to anything. TODO.
 SQLAlchemy
   Database session and transaction in thread-local variables.
 ``lib/utils2.py``
   Low level utils specific to Kallithea.
 ``lib/webutils.py``
   Low level generic utils with awareness of the TurboGears environment.
 TurboGears
   Request, response and state like i18n gettext in thread-local variables.
   External dependency with global state - usage should be minimized.
 ``lib/vcs/``
   Previously an independent library. No awareness of web, database, or state.
 ``lib/*``
   Various "pure" functionality not depending on anything else.
 ``__init__``
   Very basic Kallithea constants - some of them are set very early based on ``.ini``.
 This is not exactly how it is right now, but we aim for something like that.
 Especially the areas marked as TODO have some problems that need untangling.
 Running tests
 -------------
 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 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.
 Tests can be run on PostgreSQL like::
     sudo -u postgres createuser 'kallithea-test' --pwprompt  # password password
     sudo -u postgres createdb 'kallithea-test' --owner 'kallithea-test'
     REUSE_TEST_DB='postgresql://kallithea-test:password@localhost/kallithea-test' py.test
 Tests can be run on MariaDB/MySQL like::
     echo "GRANT ALL PRIVILEGES ON \`kallithea-test\`.* TO 'kallithea-test'@'localhost' IDENTIFIED BY 'password'" | sudo -u mysql mysql
     TEST_DB='mysql://kallithea-test:password@localhost/kallithea-test?charset=utf8mb4' py.test
 You can also use ``tox`` to run the tests with all supported Python versions.
 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::
     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)
 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::
     -k EXPRESSION         only run tests which match the given substring
                           expression. An expression is a python evaluable
@@ @@ -126,50 +226,51 @@ 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:
 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 commits hosted on your own Kallithea instance, or patches sent by
 email to the `kallithea-general`_ mailing list.
 Contributions will be accepted in most formats -- such as commits hosted on your
 own Kallithea instance, or patches sent by email to the `kallithea-general`_
 mailing list.
 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:

docs/index.rst

➞

Show inline comments

@@ @@ -60,29 +60,28 @@ User guide @@
 .. toctree::
    :maxdepth: 1
    usage/general
    usage/vcs_notes
    usage/statistics
    api/api
 Developer guide
 ***************
 .. toctree::
    :maxdepth: 1
    contributing
    dev/i18n
    dev/dbmigrations
 .. _python: http://www.python.org/
 .. _django: http://www.djangoproject.com/
 .. _mercurial: https://www.mercurial-scm.org/
 .. _subversion: http://subversion.tigris.org/
 .. _git: http://git-scm.com/
 .. _celery: http://celeryproject.org/
 .. _Sphinx: http://sphinx.pocoo.org/
 .. _vcs: http://pypi.python.org/pypi/vcs

docs/installation.rst

➞

Show inline comments

 .. _installation:
 ==========================
 Installation on Unix/Linux
 ==========================
 The following describes three different ways of installing Kallithea:
 - :ref:`installation-source`: The simplest way to keep the installation
   up-to-date and track any local customizations is to run directly from
   source in a Kallithea repository clone, preferably inside a virtualenv
   virtual Python environment.
 - :ref:`installation-virtualenv`: If you prefer to only use released versions
   of Kallithea, the recommended method is to install Kallithea in a virtual
   Python environment using `virtualenv`. The advantages of this method over
   direct installation is that Kallithea and its dependencies are completely
   contained inside the virtualenv (which also means you can have multiple
   installations side by side or remove it entirely by just removing the
   virtualenv directory) and does not require root privileges.
 - :ref:`installation-without-virtualenv`: The alternative method of installing
   a Kallithea release is using standard pip. The package will be installed in
   the same location as all other Python packages you have ever installed. As a
   result, removing it is not as straightforward as with a virtualenv, as you'd
   have to remove its dependencies manually and make sure that they are not
   needed by other packages.
 - Kallithea can also be installed with plain pip - globally or with ``--user``
   or similar. The package will be installed in the same location as all other
   Python packages you have ever installed. As a result, removing it is not as
   straightforward as with a virtualenv, as you'd have to remove its
   dependencies manually and make sure that they are not needed by other
   packages. We recommend using virtualenv.
 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 libffi-dev python3-dev
 For Fedora and RHEL-derivatives, the following command will ensure that a
 reasonable set of dependencies is installed::
     sudo yum install gcc git libffi-devel python3-devel
 .. _installation-source:
 Installation from repository source
 -----------------------------------
 To install Kallithea in a virtualenv using the stable branch of the development
-repository, follow the instructions below::
+repository, use the following commands in your bash shell::
         hg clone https://kallithea-scm.org/repos/kallithea -u stable
         cd kallithea
         python3 -m venv ../kallithea-venv
         . ../kallithea-venv/bin/activate
         python3 -m venv venv
         . venv/bin/activate
         pip install --upgrade pip setuptools
         pip install --upgrade -e .
         python3 setup.py compile_catalog   # for translation of the UI
 You can now proceed to :ref:`setup`.
 .. note::
    This will install all Python dependencies into the virtualenv. Kallithea
    itself will however only be installed as a pointer to the source location.
    The source clone must thus be kept in the same location, and it shouldn't be
    updated to other revisions unless you want to upgrade. Edits in the source
    tree will have immediate impact (possibly after a restart of the service).
 You can now proceed to :ref:`prepare-front-end-files`.
 .. _installation-virtualenv:
 Installing a released version in a virtualenv
 ---------------------------------------------
 It is highly recommended to use a separate virtualenv for installing Kallithea.
 This way, all libraries required by Kallithea will be installed separately from your
 main Python installation and other applications and things will be less
 problematic when upgrading the system or Kallithea.
 An additional benefit of virtualenv is that it doesn't require root privileges.
 - Assuming you have installed virtualenv, create a new virtual environment
   for example, in `/srv/kallithea/venv`, using the venv command::
 - Don't install as root - install as a dedicated user like ``kallithea``.
   If necessary, create the top directory for the virtualenv (like
   ``/srv/kallithea/venv``) as root and assign ownership to the user.
   Make a parent folder for the virtualenv (and perhaps also Kallithea
   configuration and data files) such as ``/srv/kallithea``. Create the
   directory as root if necessary and grant ownership to the ``kallithea`` user.
 - Create a new virtual environment, for example in ``/srv/kallithea/venv``,
   specifying the right Python binary::
     python3 -m venv /srv/kallithea/venv
 - Activate the virtualenv in your current shell session and make sure the
   basic requirements are up-to-date by running::
   basic requirements are up-to-date by running the following commands in your
   bash shell::
     . /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
    acceptable (and desirable) to create a virtualenv as a normal user.
 .. note:: You can't use UNIX ``sudo`` to source the ``activate`` script; it
    will "activate" a shell that terminates immediately.
 - Make a folder for Kallithea data files, and configuration somewhere on the
   filesystem. For example::
     mkdir /srv/kallithea
 - Go into the created directory and run this command to install Kallithea::
 - Install Kallithea in the activated virtualenv::
     pip install --upgrade kallithea
 .. note:: Some dependencies are optional. If you need them, install them in
    the virtualenv too::
      pip install --upgrade kallithea python-ldap python-pam psycopg2
    This might require installation of development packages using your
    distribution's package manager.
   Alternatively, download a .tar.gz from http://pypi.python.org/pypi/Kallithea,
   extract it and install from source by running::
    Alternatively, download a .tar.gz from http://pypi.python.org/pypi/Kallithea,
    extract it and install from source by running::
     pip install --upgrade .
+     pip install --upgrade .
 - This will install Kallithea together with all other required
   Python libraries into the activated virtualenv.
-You can now proceed to :ref:`setup`.
+You can now proceed to :ref:`prepare-front-end-files`.
-.. _installation-without-virtualenv:
+.. _prepare-front-end-files:
 Installing a released version without virtualenv
 ------------------------------------------------
 For installation without virtualenv, 'just' use::
     pip install kallithea
 Prepare front-end files
 -----------------------
 Note that this method requires root privileges and will install packages
 globally without using the system's package manager.
 Finally, the front-end files with CSS and JavaScript must be prepared. This
 depends on having some commands available in the shell search path: ``npm``
 version 6 or later, and ``node.js`` (version 12 or later) available as
 ``node``. The installation method for these dependencies varies between
 operating systems and distributions.
-To install as a regular user in ``~/.local``, you can use::
+Prepare the front-end by running::
-    pip install --user kallithea
+    kallithea-cli front-end-build
 You can now proceed to :ref:`setup`.

docs/overview.rst

➞

Show inline comments

 .. _overview:
 =====================
 Installation overview
 =====================
 Some overview and some details that can help understanding the options when
 installing Kallithea.
 . **Prepare environment and external dependencies.**
     Kallithea needs:
     * A filesystem where the Mercurial and Git repositories can be stored.
     * A database where meta data can be stored.
     * A Python environment where the Kallithea application and its dependencies
       can be installed.
     * A web server that can host the Kallithea web application using the WSGI
       API.
 . **Install Kallithea software.**
     This makes the ``kallithea-cli`` command line tool available.
 . **Create low level configuration file.**
 . **Prepare front-end files**
     Some front-end files must be fetched or created using ``npm`` and ``node``
     tooling so they can be served to the client as static files.
 . **Create low level configuration file.**
     Use ``kallithea-cli config-create`` to create a ``.ini`` file with database
     connection info, mail server information, configuration for the specified
     web server, etc.
-. **Populate the database.**
+. **Populate the database.**
     Use ``kallithea-cli db-create`` with the ``.ini`` file to create the
     database schema and insert the most basic information: the location of the
     repository store and an initial local admin user.
-. **Configure the web server.**
+. **Configure the web server.**
     The web server must invoke the WSGI entrypoint for the Kallithea software
     using the ``.ini`` file (and thus the database). This makes the web
     application available so the local admin user can log in and tweak the
     configuration further.
-. **Configure users.**
+. **Configure users.**
     The initial admin user can create additional local users, or configure how
     users can be created and authenticated from other user directories.
 See the subsequent sections, the separate OS-specific instructions, and
 :ref:`setup` for details on these steps.
 File system location
 --------------------
 Kallithea can be installed in many different ways. The main parts are:
 - A location for the Kallithea software and its dependencies. This includes
   the Python code, template files, and front-end code. After installation, this
   will be read-only (except when upgrading).
 - A location for the ``.ini`` configuration file that tells the Kallithea
   instance which database to use (and thus also the repository location).
   After installation, this will be read-only (except when upgrading).
 - A location for various data files and caches for the Kallithea instance. This
   is by default in a ``data`` directory next to the ``.ini`` file. This will
   have to be writable by the running Kallithea service.
 - A database. The ``.ini`` file specifies which database to use. The database
   will be a separate service and live elsewhere in the filesystem if using
   PostgreSQL or MariaDB/MySQL. If using SQLite, it will by default live next to
   the ``.ini`` file, as ``kallithea.db``.
 - A location for the repositories that are hosted by this Kallithea instance.
   This will have to be writable by the running Kallithea service. The path to
   this location will be configured in the database.
 For production setups, one recommendation is to use ``/srv/kallithea`` for the
 ``.ini`` and ``data``, place the virtualenv in ``venv``, and use a Kallithea
 clone in ``kallithea``. Create a ``kallithea`` user, let it own
 ``/srv/kallithea``, and run as that user when installing.
 For simple setups, it is fine to just use something like a ``kallithea`` user
 with home in ``/home/kallithea`` and place everything there.
 For experiments, it might be convenient to run everything as yourself and work
 inside a clone of Kallithea, with the ``.ini`` and SQLite database in the root
 of the clone, and a virtualenv in ``venv``.
 Python environment
 ------------------
 **Kallithea** is written entirely in Python_ and requires Python version
 .6 or higher.
 Given a Python installation, there are different ways of providing the
 environment for running Python applications. Each of them pretty much
 corresponds to a ``site-packages`` directory somewhere where packages can be
 installed.
 Kallithea itself can be run from source or be installed, but even when running
 from source, there are some dependencies that must be installed in the Python
 environment used for running Kallithea.
 - Packages *could* be installed in Python's ``site-packages`` directory ... but
   that would require running pip_ as root and it would be hard to uninstall or
   upgrade and is probably not a good idea unless using a package manager.
 - Packages could also be installed in ``~/.local`` ... but that is probably
   only a good idea if using a dedicated user per application or instance.
 - Finally, it can be installed in a virtualenv. That is a very lightweight
   "container" where each Kallithea instance can get its own dedicated and
@@ @@ -156,77 +199,77 @@ server that serves WSGI applications ove @@
 Kallithea itself is not serving HTTP (or HTTPS); that is the web server's
 responsibility. Kallithea does however need to know its own user facing URL
 (protocol, address, port and path) for each HTTP request. Kallithea will
 usually use its own HTML/cookie based authentication but can also be configured
 to use web server authentication.
 There are several web server options:
 - 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.
   Gearbox comes with its own built-in web server for development but Kallithea
   defaults to using Waitress_. Gunicorn_ and Gevent_ are also options. These
   web servers have different limited feature sets.
   The web server used by ``gearbox serve`` is configured in the ``.ini`` file.
   Create it with ``config-create`` using for example ``http_server=waitress``
   to get a configuration starting point for your choice of web server.
   (Gearbox will do like ``paste`` and use the WSGI application entry point
-  ``kallithea.config.middleware:make_app`` as specified in ``setup.py``.)
+  ``kallithea.config.application:make_app`` as specified in ``setup.py``.)
 - `Apache httpd`_ can serve WSGI applications directly using mod_wsgi_ and a
   simple Python file with the necessary configuration. This is a good option if
   Apache is an option.
 - uWSGI_ is also a full web server with built-in WSGI module. Use
   ``config-create`` with ``http_server=uwsgi`` to get a ``.ini`` file with
   uWSGI configuration.
 - IIS_ can also server WSGI applications directly using isapi-wsgi_.
 - A `reverse HTTP proxy <https://en.wikipedia.org/wiki/Reverse_proxy>`_
   can be put in front of another web server which has WSGI support.
   Such a layered setup can be complex but might in some cases be the right
   option, for example to standardize on one internet-facing web server, to add
   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 ``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
 dynamically generated pages from a relatively slow Python process. Kallithea is
 also often used inside organizations with a limited amount of users and thus no
 continuous hammering from the internet.
 .. note::
    Kallithea, the libraries it uses, and Python itself do in several places use
    simple caching in memory. Caches and memory are not always released in a way
    that is suitable for long-running processes. They might appear to be leaking
    memory. The worker processes should thus regularly be restarted - for
    example after 1000 requests and/or one hour. This can usually be done by the
    web server or the tool used for running it as a system service.
 .. _Python: http://www.python.org/
 .. _Gunicorn: http://gunicorn.org/
 .. _Gevent: http://www.gevent.org/
 .. _Waitress: http://waitress.readthedocs.org/en/latest/
 .. _Gearbox: http://turbogears.readthedocs.io/en/latest/turbogears/gearbox.html
 .. _Waitress: https://docs.pylonsproject.org/projects/waitress/
 .. _Gearbox: https://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/
+.. _mod_wsgi: https://modwsgi.readthedocs.io/
 .. _isapi-wsgi: https://github.com/hexdump42/isapi-wsgi
-.. _uWSGI: https://uwsgi-docs.readthedocs.org/en/latest/
+.. _uWSGI: https://uwsgi-docs.readthedocs.io/
 .. _nginx: http://nginx.org/en/
 .. _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
 .. _HAProxy: http://www.haproxy.org/
 .. _Varnish: https://www.varnish-cache.org/
 .. _npm: https://www.npmjs.com/

docs/setup.rst

➞

Show inline comments

 .. _setup:
 =====
 Setup
 =====
 Setting up Kallithea
 --------------------
 Setting up a Kallithea instance
 -------------------------------
 Some further details to the steps mentioned in the overview.
 First, you will need to create a Kallithea configuration file. Run the
 following command to do so::
 Create low level configuration file
 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 First, you will need to create a Kallithea configuration file. The
 configuration file is a ``.ini`` file that contains various low level settings
 for Kallithea, e.g. configuration of how to use database, web server, email,
 and logging.
     kallithea-cli config-create my.ini
 Change to the desired directory (such as ``/srv/kallithea``) as the right user
 and run the following command to create the file ``my.ini`` in the current
 directory::
     kallithea-cli config-create my.ini http_server=waitress
 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. Extra settings can be specified like::
 To get a good starting point for your configuration, specify the http server
 you intend to use. It can be ``waitress``, ``gearbox``, ``gevent``,
 ``gunicorn``, or ``uwsgi``. (Apache ``mod_wsgi`` will not use this
 configuration file, and it is fine to keep the default http_server configuration
 unused. ``mod_wsgi`` is configured using ``httpd.conf`` directives and a WSGI
 wrapper script.)
 Extra custom 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
 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 MariaDB/MySQL databases. Create the database by running
 the following command::
 Populate the database
 ^^^^^^^^^^^^^^^^^^^^^
 Next, you need to create the databases used by Kallithea. Kallithea currently
 supports PostgreSQL, SQLite and MariaDB/MySQL databases. It is recommended to
 start out using SQLite (the default) and move to PostgreSQL if it becomes a
 bottleneck or to get a "proper" database. MariaDB/MySQL is also supported.
 For PostgreSQL, run ``pip install psycopg2`` to get the database driver. Make
 sure the PostgreSQL server is initialized and running. Make sure you have a
 database user with password authentication with permissions to create databases
 - for example by running::
     sudo -u postgres createuser 'kallithea' --pwprompt --createdb
 For MariaDB/MySQL, run ``pip install mysqlclient`` to get the ``MySQLdb``
 database driver. Make sure the database server is initialized and running. Make
 sure you have a database user with password authentication with permissions to
 create the database - for example by running::
     echo 'CREATE USER "kallithea"@"localhost" IDENTIFIED BY "password"' | sudo -u mysql mysql
     echo 'GRANT ALL PRIVILEGES ON `kallithea`.* TO "kallithea"@"localhost"' | sudo -u mysql mysql
 Check and adjust ``sqlalchemy.url`` in your ``my.ini`` configuration file to use
 this database.
 Create the database, tables, and initial content by running the following
 command::
     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 ``db-create`` will also prompt you for a username
 and password for the initial admin account which ``db-create`` sets
 up for you.
 This will first prompt you for a "root" path. This "root" path is the location
 where Kallithea will store all of its repositories on the current machine. This
 location must be writable for the running Kallithea application. Next,
 ``db-create`` will prompt you for a username and password for the initial admin
 account it sets up for you.
 The ``db-create`` values can also be given on the command line.
 Example::
     kallithea-cli db-create -c my.ini --user=nn --password=secret --email=nn@example.com --repos=/srv/repos
 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
 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.
 .. note:: It is also possible to use an existing database. For example,
           when using PostgreSQL without granting general createdb privileges to
           the PostgreSQL kallithea user, set ``sqlalchemy.url =
           postgresql://kallithea:password@localhost/kallithea`` and create the
           database like::
 Finally, the front-end files must be prepared. This requires ``npm`` version 6
 or later, which needs ``node.js`` (version 12 or later). Prepare the front-end
 by running::
               sudo -u postgres createdb 'kallithea' --owner 'kallithea'
               kallithea-cli db-create -c my.ini --reuse
     kallithea-cli front-end-build
 Running
 ^^^^^^^
 You are now ready to use Kallithea. To run it simply execute::
 You are now ready to use Kallithea. To run it using a gearbox web server,
 simply execute::
     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 ``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
   settings, as well as edit more advanced options on users and
   repositories.
 Internationalization (i18n support)
 -----------------------------------
 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), English is used.
 If you want to disable automatic language detection and instead configure a
@@ @@ -165,49 +203,49 @@ be writeable by the Kallithea user. @@
    location will apply to all system users, and that multiple entries for the
    same SSH key will shadow each other.
 .. warning:: The handling of SSH access is steered directly by the command
     specified in the ``authorized_keys`` file. There is no interaction with the
     web UI.  Once SSH access is correctly configured and enabled, it will work
     regardless of whether the Kallithea web process is actually running. Hence,
     if you want to perform repository or server maintenance and want to fully
     disable all access to the repositories, disable SSH access by setting
     ``ssh_enabled = false`` in the correct ``.ini`` file (i.e. the ``.ini`` file
     specified in the ``authorized_keys`` file.)
 The ``authorized_keys`` file can be updated manually with ``kallithea-cli
 ssh-update-authorized-keys -c my.ini``. This command is not needed in normal
 operation but is for example useful after changing SSH-related settings in the
 ``.ini`` file or renaming that file. (The path to the ``.ini`` file is used in
 the generated ``authorized_keys`` file).
 Setting up Whoosh full text search
 ----------------------------------
 Kallithea provides full text search of repositories using `Whoosh`__.
-.. __: https://whoosh.readthedocs.io/en/latest/
 .. __: https://whoosh.readthedocs.io/
 For an incremental index build, run::
     kallithea-cli index-create -c my.ini
 For a full index rebuild, run::
     kallithea-cli index-create -c my.ini --full
 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::
     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::
 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
 available. The indexing daemon checks for any removed files and removes them
@@ @@ -279,57 +317,63 @@ not cause a match, but ``issue #123`` wi @@
     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, also demonstrating the use of named groups::
     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:
 .. code-block:: html
   <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
 ---------------
-Hooks can be managed in similar way to that used in ``.hgrc`` files.
+Custom Mercurial hooks can be managed in a 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``.
 Kallithea will also use some hooks internally. They cannot be modified, but
 some of them can be enabled or disabled in the *VCS* section.
 Kallithea does not actively support custom Git hooks, but hooks can be installed
 manually in the file system. Kallithea will install and use the
 ``post-receive`` Git hook internally, but it will then invoke
 ``post-receive-custom`` if present.
 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.
 The Mercurial encoding is configurable as ``hgencoding``. It is similar to
 setting the ``HGENCODING`` environment variable, but will override it.
 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
@@ @@ -341,60 +385,91 @@ 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.*`` configuration variables.
 Configuration settings are prefixed with 'celery.', so for example setting
 `broker_url` in Celery means setting `celery.broker_url` in the configuration
 file.
 To start the Celery process, run::
   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
    user that Kallithea runs.
 Proxy setups
 ------------
 When Kallithea is processing HTTP requests from a user, it will see and use
 some of the basic properties of the connection, both at the TCP/IP level and at
 the HTTP level. The WSGI server will provide this information to Kallithea in
 the "environment".
 In some setups, a proxy server will take requests from users and forward
 them to the actual Kallithea server. The proxy server will thus be the
 immediate client of the Kallithea WSGI server, and Kallithea will basically see
 it as such. To make sure Kallithea sees the request as it arrived from the
 client to the proxy server, the proxy server must be configured to
 somehow pass the original information on to Kallithea, and Kallithea must be
 configured to pick that information up and trust it.
 Kallithea will by default rely on its WSGI server to provide the IP of the
 client in the WSGI environment as ``REMOTE_ADDR``, but it can be configured to
 get it from an HTTP header that has been set by the proxy server. For
 example, if the proxy server puts the client IP in the ``X-Forwarded-For``
 HTTP header, set::
     remote_addr_variable = HTTP_X_FORWARDED_FOR
 Kallithea will by default rely on finding the protocol (``http`` or ``https``)
 in the WSGI environment as ``wsgi.url_scheme``. If the proxy server puts
 the protocol of the client request in the ``X-Forwarded-Proto`` HTTP header,
 Kallithea can be configured to trust that header by setting::
     url_scheme_variable = HTTP_X_FORWARDED_PROTO
 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 ``url_scheme_variable`` set, the scheme will be taken from that HTTP
   header.
 - With ``force_https = true``, the scheme will be seen as ``https``.
 - With ``use_htsts = true``, Kallithea will set ``Strict-Transport-Security`` when using https.
 .. _nginx_virtual_host:
 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;
@@ @@ -535,114 +610,81 @@ then change ``PREFIX`` into your chosen @@
 .. _apache_mod_wsgi:
 Apache with mod_wsgi
 --------------------
 Alternatively, Kallithea can be set up with Apache under mod_wsgi. For
 that, you'll need to:
 - Install mod_wsgi. If using a Debian-based distro, you can install
   the package libapache2-mod-wsgi::
     aptitude install libapache2-mod-wsgi
 - Enable mod_wsgi::
     a2enmod wsgi
 - Add global Apache configuration to tell mod_wsgi that Python only will be
   used in the WSGI processes and shouldn't be initialized in the Apache
   processes::
     WSGIRestrictEmbedded On
 - Create a WSGI dispatch script, like the one below. Make sure you
   check that the paths correctly point to where you installed Kallithea
   and its Python Virtual Environment.
 - Create a WSGI dispatch script, like the one below. The ``WSGIDaemonProcess``
   ``python-home`` directive will make sure it uses the right Python Virtual
   Environment and that paste thus can pick up the right Kallithea
   application.
   .. code-block:: python
       import os
       os.environ['PYTHON_EGG_CACHE'] = '/srv/kallithea/.egg-cache'
       # sometimes it's needed to set the current dir
       os.chdir('/srv/kallithea/')
       import site
       site.addsitedir("/srv/kallithea/venv/lib/python3.7/site-packages")
       ini = '/srv/kallithea/my.ini'
       from logging.config import fileConfig
       fileConfig(ini, {'__file__': ini, 'here': '/srv/kallithea'})
       from paste.deploy import loadapp
       application = loadapp('config:' + ini)
   Or using proper virtualenv activation:
   .. code-block:: python
       activate_this = '/srv/kallithea/venv/bin/activate_this.py'
       execfile(activate_this, dict(__file__=activate_this))
       import os
       os.environ['HOME'] = '/srv/kallithea'
       ini = '/srv/kallithea/kallithea.ini'
       from logging.config import fileConfig
       fileConfig(ini, {'__file__': ini, 'here': '/srv/kallithea'})
       from paste.deploy import loadapp
       application = loadapp('config:' + ini)
 - Add the necessary ``WSGI*`` directives to the Apache Virtual Host configuration
   file, like in the example below. Notice that the WSGI dispatch script created
   above is referred to with the ``WSGIScriptAlias`` directive.
   The default locale settings Apache provides for web services are often not
   adequate, with `C` as the default language and `ASCII` as the encoding.
   Instead, use the ``lang`` parameter of ``WSGIDaemonProcess`` to specify a
   suitable locale. See also the :ref:`overview` section and the
   `WSGIDaemonProcess documentation`_.
   Apache will by default run as a special Apache user, on Linux systems
   usually ``www-data`` or ``apache``. If you need to have the repositories
   directory owned by a different user, use the user and group options to
   WSGIDaemonProcess to set the name of the user and group.
   Once again, check that all paths are correctly specified.
   .. code-block:: apache
       WSGIDaemonProcess kallithea processes=5 threads=1 maximum-requests=100 \
           python-home=/srv/kallithea/venv lang=C.UTF-8
       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 lang=en_US.utf8
       WSGIProcessGroup kallithea
       WSGIScriptAlias / /srv/kallithea/dispatch.wsgi
       WSGIPassAuthorization On
 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/ .
 .. _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/
 .. _mercurial-server: http://www.lshift.net/mercurial-server.html
 .. _PublishingRepositories: https://www.mercurial-scm.org/wiki/PublishingRepositories
 .. _WSGIDaemonProcess documentation: https://modwsgi.readthedocs.io/en/develop/configuration-directives/WSGIDaemonProcess.html

docs/upgrade.rst

➞

Show inline comments

@@ @@ -18,50 +18,50 @@ Kallithea installation method. @@
 . 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.
 . 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.
 If you are using custom :ref:`extensions <customization>`, you should also
 make a copy of the ``extensions.py`` file.
 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 MariaDB/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``.
 . Activate or recreate the Kallithea virtual environment (if any)
 ------------------------------------------------------------------
 .. note::
     If you did not install Kallithea in a virtual environment, skip this step.
@@ @@ -204,40 +204,47 @@ following command:: @@
 It is recommended that you rebuild the Whoosh index after upgrading since
 new Whoosh versions can introduce incompatible index changes.
 . 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.
 . Update Git repository hooks
 -------------------------------
 . Reinstall internal 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:
 To update the hooks of your Git repositories, run::
     kallithea-cli repo-scan -c my.ini --install-git-hooks
 Watch out for warnings like ``skipping overwriting hook file X``, then fix it
 and rerun, or consider using ``--overwrite-git-hooks`` instead.
 Or:
 * 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.

docs/usage/customization.rst

➞

Show inline comments

@@ @@ -18,54 +18,60 @@ you can enter HTML code (possibly with J @@
 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 directory
 ``kallithea/front-end/`` inside the Kallithea installation, 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
 --------------------------------------
 Behavioral customization: Kallithea extensions
 ----------------------------------------------
 Some behavioral customization can be done in Python using ``rcextensions``, a
 custom Python package that can extend Kallithea functionality.
 Some behavioral customization can be done in Python using Kallithea
 ``extensions``, a custom Python file you can create to extend Kallithea
 functionality.
-With ``rcextensions`` it's possible to add additional mappings for Whoosh
+With ``extensions`` 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.
 This will create an ``extensions.py`` file next to the specified ``ini`` file.
 You can find more details inside this file.
 For compatibility with previous releases of Kallithea, a directory named
 ``rcextensions`` with a file ``__init__.py`` inside of it can also be used. If
 both an ``extensions.py`` file and an ``rcextensions`` directory are found, only
 ``extensions.py`` will be loaded. Note that the name ``rcextensions`` is
 deprecated and support for it will be removed in a future release.
 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.

docs/usage/email.rst

➞

Show inline comments

@@ @@ -68,29 +68,29 @@ where ``<type>`` is one of: @@
 - ``pull_request_comment``: a comment was given on a pull request
 - ``cs_comment``: a comment was given on a changeset
 - ``registration``: a new user was registered
 - ``message``: another type of email
 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 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
 contain only an email address, like `kallithea-noreply@example.com`, or both
 a name and an address in the following format: `Kallithea Errors
 <kallithea-noreply@example.com>`.
 References
 ----------
 - `Error Middleware (Pylons documentation) <http://pylons-webframework.readthedocs.org/en/latest/debugging.html#error-middleware>`_
 - `ErrorHandler (Pylons modules documentation) <http://pylons-webframework.readthedocs.org/en/latest/modules/middleware.html#pylons.middleware.ErrorHandler>`_
 - `Error Middleware (Pylons documentation) <https://pylons-webframework.readthedocs.io/en/latest/debugging.html#error-middleware>`_
 - `ErrorHandler (Pylons modules documentation) <https://pylons-webframework.readthedocs.io/en/latest/modules/middleware.html#pylons.middleware.ErrorHandler>`_
 .. _backlash: https://github.com/TurboGears/backlash

docs/usage/general.rst

➞

Show inline comments

@@ @@ -97,64 +97,57 @@ In the example, the repository could als @@
   http://kallithea.example.com/_<ID>
 The ID of a given repository can be shown from the repository ``Summary`` page,
 by selecting the ``Show by ID`` button next to ``Clone URL``.
 Email notifications
 -------------------
 With email settings properly configured in the Kallithea
 configuration file, Kallithea will send emails on user registration and when
 errors occur.
 Emails are also sent for comments on changesets. In this case, an email is sent
 to the committer of the changeset (if known to Kallithea), to all reviewers of
 the pull request (if applicable) and to all people mentioned in the comment
 using @mention notation.
 Trending source files
 ---------------------
 Trending source files are calculated based on a predefined dictionary of known
 types and extensions. If an extension is missing or you would like to scan
 custom files, it is possible to extend the ``LANGUAGES_EXTENSIONS_MAP``
 dictionary located in ``kallithea/config/conf.py`` with new types.
 custom files, it is possible to add additional file extensions with
 ``EXTRA_MAPPINGS`` in your custom Kallithea extensions.py file. See
 :ref:`customization`.
 Cloning remote repositories
 ---------------------------
 Kallithea has the ability to clone repositories from given remote locations.
 Currently it supports the following options:
 - hg  -> hg clone
 - svn -> hg clone
 - git -> git clone
 .. note:: svn -> hg cloning requires the ``hgsubversion`` library to be
    installed.
 If you need to clone repositories that are protected via basic authentication,
 you can pass the credentials in the URL, e.g.
 ``http://user:passw@remote.example.com/repo``. Kallithea will then try to login and
 clone using the given credentials. Please note that the given credentials will
 be stored as plaintext inside the database. However, the authentication
 information will not be shown in the clone URL on the summary page.
 Specific features configurable in the Admin settings
 ----------------------------------------------------
 In general, the Admin settings should be self-explanatory and will not be
 described in more detail in this documentation. However, there are a few
 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.
 Once enabled site-wide, the custom fields can be edited per-repository under
 *Options* | *Settings* | *Extra Fields*.

docs/usage/performance.rst

➞

Show inline comments

@@ @@ -27,101 +27,99 @@ questionable. @@
     Beaker has no upper bound on cache size and will never drop any caches. For
     memory cache, the only option is to regularly restart the worker process.
     For file cache, it must be cleaned manually, as described in the `Beaker
     documentation <https://beaker.readthedocs.io/en/latest/sessions.html#removing-expired-old-sessions>`_::
         find data/cache -type f -mtime +30 -print -exec rm {} \;
 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 PostgreSQL or MariaDB/MySQL will result in an immediate performance
 increase. A tool like SQLAlchemyGrate_ can be used for migrating to another
 database platform.
 Horizontal scaling
 ------------------
 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.
 Scaling horizontally means running several Kallithea instances (also known as
 worker processes) and let them share the load. That is essential to serve other
 users while processing a long-running request from a user. Usually, the
 bottleneck on a Kallithea server is not CPU but I/O speed - especially network
 speed. It is thus a good idea to run multiple worker processes on one server.
 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.
 .. note::
 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.
     Kallithea and the embedded Mercurial backend are not thread-safe. Each
     worker process must thus be single-threaded.
 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.
 Web servers can usually launch multiple worker processes - for example ``mod_wsgi`` with the
 ``WSGIDaemonProcess`` ``processes`` parameter or ``uWSGI`` or ``gunicorn`` with
 their ``workers`` setting.
 Web servers with multiple worker processes (such as ``mod_wsgi`` with the
 ``WSGIDaemonProcess`` ``processes`` parameter) will work out of the box.
 Kallithea can also be scaled horizontally across multiple machines.
 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
       task locking (so it is safe across multiple instances). Set the
       ``cache_dir``, ``index_dir``, ``beaker.cache.data_dir``, ``beaker.cache.lock_dir``
       variables in each .ini file to a shared location across Kallithea instances
     - If using several Celery instances,
       the message broker should be common to all of them (e.g.,  one
       shared RabbitMQ server)
     - Load balance using round robin or IP hash, recommended is writing LB rules
       that will separate regular user traffic from automated processes like CI
       servers or build bots.
 - Each instance's ``data`` storage needs to be configured to be stored on a
   shared disk storage, preferably together with repositories. This ``data``
   dir contains template caches, sessions, whoosh index and is used for
   task locking (so it is safe across multiple instances). Set the
   ``cache_dir``, ``index_dir``, ``beaker.cache.data_dir``, ``beaker.cache.lock_dir``
   variables in each .ini file to a shared location across Kallithea instances
 - If using several Celery instances,
   the message broker should be common to all of them (e.g.,  one
   shared RabbitMQ server)
 - Load balance using round robin or IP hash, recommended is writing LB rules
   that will separate regular user traffic from automated processes like CI
   servers or build bots.
 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
 .. _mod_wsgi: https://modwsgi.readthedocs.io/
 .. _uWSGI: https://uwsgi-docs.readthedocs.io/
 .. _gunicorn: http://pypi.python.org/pypi/gunicorn

docs/usage/troubleshooting.rst

➞

Show inline comments

@@ @@ -22,53 +22,60 @@ Troubleshooting @@
 :A: Make sure you set a longer timeout in your proxy/fcgi settings. Timeouts
     are caused by the http server and not Kallithea.
+|
 :Q: **Large pushes timeouts?**
 :A: Make sure you set a proper ``max_body_size`` for the http server. Very often
     Apache, Nginx, or other http servers kill the connection due to to large
     body.
+|
 :Q: **Apache doesn't pass basicAuth on pull/push?**
 :A: Make sure you added ``WSGIPassAuthorization true``.
+|
 :Q: **Git fails on push/pull?**
 :A: Make sure you're using a WSGI http server that can handle chunked encoding
     such as ``waitress`` or ``gunicorn``.
+|
 :Q: **How can I use hooks in Kallithea?**
 :A: It's easy if they are Python hooks: just use advanced link in
     hooks section in Admin panel, that works only for Mercurial. If
     you want to use Git hooks, just install th proper one in the repository,
     e.g., create a file `/gitrepo/hooks/pre-receive`. You can also use
     Kallithea-extensions to connect to callback hooks, for both Git
     and Mercurial.
 :A: If using Mercurial, use *Admin > Settings > Hooks* to install
     global hooks. Inside the hooks, you can use the current working directory to
     control different behaviour for different repositories.
     If using Git, install the hooks manually in each repository, for example by
     creating a file ``gitrepo/hooks/pre-receive``.
     Note that Kallithea uses the ``post-receive`` hook internally.
     Kallithea will not work properly if another post-receive hook is installed instead.
     You might also accidentally overwrite your own post-receive hook with the Kallithea hook.
     Instead, put your post-receive hook in ``post-receive-custom``, and the Kallithea hook will invoke it.
     You can also use Kallithea-extensions to connect to callback hooks,
     for both Git and Mercurial.
+|
 :Q: **Kallithea is slow for me, how can I make it faster?**
 :A: See the :ref:`performance` section.
+|
 :Q: **UnicodeDecodeError on Apache mod_wsgi**
 :A: Please read: https://docs.djangoproject.com/en/dev/howto/deployment/wsgi/modwsgi/#if-you-get-a-unicodeencodeerror.
+|
 :Q: **Requests hanging on Windows**
 :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).
 .. _python: http://www.python.org/
 .. _mercurial: https://www.mercurial-scm.org/
 .. _celery: http://celeryproject.org/
 .. _rabbitmq: http://www.rabbitmq.com/
 .. _python-ldap: http://www.python-ldap.org/

init.d/kallithea-daemon-debian

➞

Show inline comments

@@ @@ -16,49 +16,49 @@ @@
 APP_NAME="kallithea"
 APP_HOMEDIR="opt"
 APP_PATH="/$APP_HOMEDIR/$APP_NAME"
 CONF_NAME="production.ini"
 PID_PATH="$APP_PATH/$APP_NAME.pid"
 LOG_PATH="$APP_PATH/$APP_NAME.log"
 PYTHON_PATH="/$APP_HOMEDIR/$APP_NAME-venv"
 RUN_AS="root"
 DAEMON="$PYTHON_PATH/bin/gearbox"
 DAEMON_OPTS="serve --daemon \
  --user=$RUN_AS \
  --group=$RUN_AS \
  --pid-file=$PID_PATH \
  --log-file=$LOG_PATH -c $APP_PATH/$CONF_NAME"
 start() {
   echo "Starting $APP_NAME"
-  PYTHON_EGG_CACHE="/tmp" start-stop-daemon -d $APP_PATH \
   start-stop-daemon -d $APP_PATH \
       --start --quiet \
       --pidfile $PID_PATH \
       --user $RUN_AS \
       --exec $DAEMON -- $DAEMON_OPTS
+}
 stop() {
   echo "Stopping $APP_NAME"
   start-stop-daemon -d $APP_PATH \
       --stop --quiet \
       --pidfile $PID_PATH || echo "$APP_NAME - Not running!"
   if [ -f $PID_PATH ]; then
     rm $PID_PATH
   fi
+}
 status() {
   echo -n "Checking status of $APP_NAME ... "
   pid=`cat $PID_PATH`
   status=`ps ax | grep $pid | grep -ve grep`
   if [ "$?" -eq 0 ]; then
     echo "running"
   else

init.d/kallithea-daemon-gentoo

➞

Show inline comments

@@ @@ -12,49 +12,49 @@ CONF_NAME="production.ini" @@
 PID_PATH="$APP_PATH/$APP_NAME.pid"
 LOG_PATH="$APP_PATH/$APP_NAME.log"
 PYTHON_PATH="/home/$APP_HOMEDIR/v-env"
 RUN_AS="username"
 DAEMON="$PYTHON_PATH/bin/gearbox"
 DAEMON_OPTS="serve --daemon \
 --user=$RUN_AS \
 --group=$RUN_AS \
 --pid-file=$PID_PATH \
 --log-file=$LOG_PATH -c $APP_PATH/$CONF_NAME"
 #extra options
 opts="${opts} restartdelay"
 depend() {
     need nginx
+}
 start() {
     ebegin "Starting $APP_NAME"
-    start-stop-daemon -d $APP_PATH -e PYTHON_EGG_CACHE="/tmp" \
     start-stop-daemon -d $APP_PATH \
         --start --quiet \
         --pidfile $PID_PATH \
         --user $RUN_AS \
         --exec $DAEMON -- $DAEMON_OPTS
     eend $?
+}
 stop() {
     ebegin "Stopping $APP_NAME"
     start-stop-daemon -d $APP_PATH \
         --stop --quiet \
         --pidfile $PID_PATH || echo "$APP_NAME - Not running!"
     if [ -f $PID_PATH ]; then
         rm $PID_PATH
     fi
     eend $?
+}
 restartdelay() {
     #stop()
     echo "sleep3"
     sleep 3
     #start()

init.d/kallithea-daemon-redhat

➞

Show inline comments

@@ @@ -42,49 +42,49 @@ DAEMON_OPTS="serve --daemon \ @@
 DESC="kallithea-server"
 LOCK_FILE="/var/lock/subsys/$APP_NAME"
 # source CentOS init functions
 . /etc/init.d/functions
 RETVAL=0
 remove_pid () {
   rm -f ${PID_PATH}
   rmdir `dirname ${PID_PATH}`
+}
 ensure_pid_dir () {
   PID_DIR=`dirname ${PID_PATH}`
   if [ ! -d ${PID_DIR} ] ; then
     mkdir -p ${PID_DIR}
     chown -R ${RUN_AS}:${RUN_AS} ${PID_DIR}
     chmod 755 ${PID_DIR}
   fi
+}
 start_kallithea () {
     ensure_pid_dir
-    PYTHON_EGG_CACHE="/tmp" daemon --pidfile $PID_PATH \
     daemon --pidfile $PID_PATH \
         --user $RUN_AS "$DAEMON $DAEMON_OPTS"
     RETVAL=$?
     [ $RETVAL -eq 0 ] && touch $LOCK_FILE
     return $RETVAL
+}
 stop_kallithea () {
     if [ -e $LOCK_FILE ]; then
       killproc -p $PID_PATH
       RETVAL=$?
       rm -f $LOCK_FILE
       rm -f $PID_PATH
     else
       RETVAL=1
     fi
     return $RETVAL
+}
 status_kallithea() {
   if [ -e $LOCK_FILE ]; then
     # exit with non-zero to indicate failure
     RETVAL=1
   else
     RETVAL=0

kallithea/__init__.py

➞

Show inline comments

@@ @@ -9,51 +9,57 @@ @@
 # 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/>.
 """
 kallithea
 ~~~~~~~~~
 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:
 :created_on: Apr 9, 2010
 :author: marcink
 :copyright: (c) 2013 RhodeCode GmbH, (C) 2014 Bradley M. Kuhn, and others.
 :license: GPLv3, see LICENSE.md for more details.
 """
 import platform
 import sys
 import celery
 if sys.version_info < (3, 6):
     raise Exception('Kallithea requires python 3.6 or later')
-VERSION = (0, 6, 3)
+VERSION = (0, 6, 99)
 BACKENDS = {
     'hg': 'Mercurial repository',
     'git': 'Git repository',
+}
 CELERY_APP = None  # set to Celery app instance if using Celery
 CELERY_EAGER = False
 CELERY_APP = celery.Celery()  # needed at import time but is lazy and can be configured later
 CONFIG = {}
 DEFAULT_USER_ID: int  # set by setup_configuration
 CONFIG = {}  # set to tg.config when TG app is initialized and calls app_cfg
 # URL prefix for non repository related links - must start with `/`
 ADMIN_PREFIX = '/_admin'
 URL_SEP = '/'
 # Linked module for extensions
 EXTENSIONS = {}
 __version__ = '.'.join(str(each) for each in VERSION)
 __platform__ = platform.system()
 __license__ = 'GPLv3'
 __py_version__ = sys.version_info
 __author__ = "Various Authors"
 __url__ = 'https://kallithea-scm.org/'
 is_windows = __platform__ in ['Windows']
 is_unix = not is_windows

kallithea/alembic/env.py

➞

Show inline comments

 # -*- 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
 import os
 from logging.config import fileConfig
 from alembic import context
 from sqlalchemy import engine_from_config, pool
-from kallithea.model import db
+from kallithea.model import meta
 # 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,
         {'__file__': config.config_file_name, 'here': os.path.dirname(config.config_file_name)},
@@ @@ -72,37 +72,37 @@ def run_migrations_offline(): @@
     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,
+            target_metadata=meta.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/versions/7ba0d2cad930_hooks_migrate_internal_hooks_to_.py

➞

Show inline comments

@@ new file 100644 @@
 # 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/>.
 """hooks: migrate internal hooks to kallithea namespace
 Revision ID: 7ba0d2cad930
 Revises: f62826179f39
 Create Date: 2021-01-11 00:10:13.576586
 """
 # The following opaque hexadecimal identifiers ("revisions") are used
 # by Alembic to track this migration script and its relations to others.
 revision = '7ba0d2cad930'
 down_revision = 'f62826179f39'
 branch_labels = None
 depends_on = None
 from alembic import op
 from sqlalchemy import MetaData, Table
 from kallithea.model import db
 meta = MetaData()
 def upgrade():
     meta.bind = op.get_bind()
     ui = Table(db.Ui.__tablename__, meta, autoload=True)
     ui.update(values={
         'ui_key': 'changegroup.kallithea_update',
         'ui_value': 'python:',  # value in db isn't used
     }).where(ui.c.ui_key == 'changegroup.update').execute()
     ui.update(values={
         'ui_key': 'changegroup.kallithea_repo_size',
         'ui_value': 'python:',  # value in db isn't used
     }).where(ui.c.ui_key == 'changegroup.repo_size').execute()
     # 642847355a10 moved these hooks out of db - remove old entries
     ui.delete().where(ui.c.ui_key == 'changegroup.push_logger').execute()
     ui.delete().where(ui.c.ui_key == 'outgoing.pull_logger').execute()
 def downgrade():
     pass

kallithea/alembic/versions/a020f7044fd6_rename_hooks.py

➞

Show inline comments

@@ @@ -8,56 +8,56 @@ @@
 # 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 sqlalchemy import MetaData, Table
-from kallithea.model.db import Ui
+from kallithea.model import db
 meta = MetaData()
 def upgrade():
     meta.bind = op.get_bind()
     ui = Table(Ui.__tablename__, meta, autoload=True)
+    ui = Table(db.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 = Table(db.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/alembic/versions/ad357ccd9521_drop_locking.py

➞

Show inline comments

@@ @@ -9,53 +9,53 @@ @@
 # 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 locking
 Revision ID: ad357ccd9521
 Revises: a020f7044fd6
 Create Date: 2019-01-08
 """
 # The following opaque hexadecimal identifiers ("revisions") are used
 # by Alembic to track this migration script and its relations to others.
 revision = 'ad357ccd9521'
 down_revision = 'a020f7044fd6'
 branch_labels = None
 depends_on = None
 import sqlalchemy as sa
 from alembic import op
 from sqlalchemy import MetaData, Table
-from kallithea.model.db import Ui
+from kallithea.model import db
 meta = MetaData()
 def upgrade():
     with op.batch_alter_table('groups', schema=None) as batch_op:
         batch_op.drop_column('enable_locking')
     with op.batch_alter_table('repositories', schema=None) as batch_op:
         batch_op.drop_column('locked')
         batch_op.drop_column('enable_locking')
     meta.bind = op.get_bind()
     ui = Table(Ui.__tablename__, meta, autoload=True)
+    ui = Table(db.Ui.__tablename__, meta, autoload=True)
     ui.delete().where(ui.c.ui_key == 'prechangegroup.push_lock_handling').execute()
     ui.delete().where(ui.c.ui_key == 'preoutgoing.pull_lock_handling').execute()
 def downgrade():
     with op.batch_alter_table('repositories', schema=None) as batch_op:
         batch_op.add_column(sa.Column('enable_locking', sa.BOOLEAN(), nullable=False, default=False))
         batch_op.add_column(sa.Column('locked', sa.VARCHAR(length=255), nullable=True, default=False))
     with op.batch_alter_table('groups', schema=None) as batch_op:
         batch_op.add_column(sa.Column('enable_locking', sa.BOOLEAN(), nullable=False, default=False))
     # Note: not restoring hooks

kallithea/alembic/versions/f62826179f39_add_unique_constraint_on_.py

➞

Show inline comments

@@ new file 100644 @@
 # 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/>.
 """add unique constraint on PullRequestReviewer
 Revision ID: f62826179f39
 Revises: a0a1bf09c143
 Create Date: 2020-06-15 12:30:37.420321
 """
 # The following opaque hexadecimal identifiers ("revisions") are used
 # by Alembic to track this migration script and its relations to others.
 revision = 'f62826179f39'
 down_revision = 'a0a1bf09c143'
 branch_labels = None
 depends_on = None
 import sqlalchemy as sa
 from alembic import op
 from kallithea.model import db
 def upgrade():
     session = sa.orm.session.Session(bind=op.get_bind())
     # there may be existing duplicates in the database, remove them first
     seen = set()
     # duplicate_values contains one copy of each duplicated pair
     duplicate_values = (
         session
         .query(db.PullRequestReviewer.pull_request_id, db.PullRequestReviewer.user_id)
         .group_by(db.PullRequestReviewer.pull_request_id, db.PullRequestReviewer.user_id)
         .having(sa.func.count(db.PullRequestReviewer.pull_request_reviewers_id) > 1)
+    )
     for pull_request_id, user_id in duplicate_values:
         # duplicate_occurrences contains all db records of the duplicate_value
         # currently being processed
         duplicate_occurrences = (
             session
             .query(db.PullRequestReviewer)
             .filter(db.PullRequestReviewer.pull_request_id == pull_request_id)
             .filter(db.PullRequestReviewer.user_id == user_id)
+        )
         for prr in duplicate_occurrences:
             if (pull_request_id, user_id) in seen:
                 session.delete(prr)
             else:
                 seen.add((pull_request_id, user_id))
     session.commit()
     # after deleting all duplicates, add the unique constraint
     with op.batch_alter_table('pull_request_reviewers', schema=None) as batch_op:
         batch_op.create_unique_constraint(batch_op.f('uq_pull_request_reviewers_pull_request_id'), ['pull_request_id', 'user_id'])
 def downgrade():
     with op.batch_alter_table('pull_request_reviewers', schema=None) as batch_op:
         batch_op.drop_constraint(batch_op.f('uq_pull_request_reviewers_pull_request_id'), type_='unique')

kallithea/bin/kallithea_cli_base.py

➞

Show inline comments

@@ @@ -2,83 +2,85 @@ @@
 # 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 configparser
 import functools
 import logging.config
 import os
 import re
 import sys
 import click
 import paste.deploy
 import kallithea
-import kallithea.config.middleware
+import kallithea.config.application
 # kallithea_cli is usually invoked through the 'kallithea-cli' wrapper script
 # that is installed by setuptools, as specified in setup.py console_scripts
 # entry_points. The script will be using the right virtualenv (if any), and for
 # Unix, it will contain #! pointing at the right python executable. The script
 # also makes sure sys.argv[0] points back at the script path, and that is what
 # can be used to invoke 'kallithea-cli' later.
 kallithea_cli_path = sys.argv[0]
 def read_config(ini_file_name, strip_section_prefix):
     """Read ini_file_name content, and for all sections like '[X:Y]' where X is
     strip_section_prefix, replace the section name with '[Y]'."""
     def repl(m):
         if m.group(1) == strip_section_prefix:
             return '[%s]' % m.group(2)
         return m.group(0)
     with open(ini_file_name) as f:
         return re.sub(r'^\[([^:]+):(.*)]', repl, f.read(), flags=re.MULTILINE)
 # This placeholder is the main entry point for the kallithea-cli command
 @click.group(context_settings=dict(help_option_names=['-h', '--help']))
 def cli():
     """Various commands to manage a Kallithea instance."""
-def register_command(config_file=False, config_file_initialize_app=False, hidden=False):
+def register_command(needs_config_file=False, config_file_initialize_app=False, hidden=False):
     """Register a kallithea-cli subcommand.
-    If one of the config_file flags are true, a config file must be specified
+    If one of the needs_config_file flags are true, a config file must be specified
     with -c and it is read and logging is configured. The configuration is
     available in the kallithea.CONFIG dict.
     If config_file_initialize_app is true, Kallithea, TurboGears global state
     (including tg.config), and database access will also be fully initialized.
     """
     cli_command = cli.command(hidden=hidden)
-    if config_file or config_file_initialize_app:
+    if needs_config_file or config_file_initialize_app:
         def annotator(annotated):
             @click.option('--config_file', '-c', help="Path to .ini file with app configuration.",
                 type=click.Path(dir_okay=False, exists=True, readable=True), required=True)
             @functools.wraps(annotated) # reuse meta data from the wrapped function so click can see other options
             def runtime_wrapper(config_file, *args, **kwargs):
                 path_to_ini_file = os.path.realpath(config_file)
-                kallithea.CONFIG = paste.deploy.appconfig('config:' + path_to_ini_file)
+                config = paste.deploy.appconfig('config:' + path_to_ini_file)
                 cp = configparser.ConfigParser(strict=False)
                 cp.read_string(read_config(path_to_ini_file, strip_section_prefix=annotated.__name__))
                 logging.config.fileConfig(cp,
                     {'__file__': path_to_ini_file, 'here': os.path.dirname(path_to_ini_file)})
                 if needs_config_file:
                     annotated(*args, config=config, **kwargs)
                 if config_file_initialize_app:
                     kallithea.config.middleware.make_app(kallithea.CONFIG.global_conf, **kallithea.CONFIG.local_conf)
                 return annotated(*args, **kwargs)
                     kallithea.config.application.make_app(config.global_conf, **config.local_conf)
                     annotated(*args, **kwargs)
             return cli_command(runtime_wrapper)
         return annotator
     return cli_command

kallithea/bin/kallithea_cli_celery.py

➞

Show inline comments

 # -*- 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 celery.bin.worker
 import click
 from celery.bin.celery import celery as celery_command
 import kallithea
 import kallithea.bin.kallithea_cli_base as cli_base
 from kallithea.lib import celery_app
 from kallithea.lib.utils2 import asbool
-@cli_base.register_command(config_file_initialize_app=True)
+@cli_base.register_command(needs_config_file=True)
 @click.argument('celery_args', nargs=-1)
 def celery_run(celery_args):
+def celery_run(celery_args, config):
     """Start Celery worker(s) for asynchronous tasks.
     This commands starts the Celery daemon which will spawn workers to handle
     certain asynchronous tasks for Kallithea.
     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.
     """
-    if not kallithea.CELERY_APP:
+    if not asbool(config.get('use_celery')):
         raise Exception('Please set use_celery = true in .ini config '
                         'file before running this command')
     cmd = celery.bin.worker.worker(kallithea.CELERY_APP)
     return cmd.run_from_argv(None, command='celery-run -c CONFIG_FILE --', argv=list(celery_args))
     kallithea.CELERY_APP.config_from_object(celery_app.make_celery_config(config))
     kallithea.CELERY_APP.loader.on_worker_process_init = lambda: kallithea.config.application.make_app(config.global_conf, **config.local_conf)
     args = list(celery_args)
     # args[0] is generally ignored when prog_name is specified, but -h *needs* it to be 'worker' ... but will also suggest that users specify 'worker' explicitly
     if not args or args[0] != 'worker':
         args.insert(0, 'worker')
     # inline kallithea.CELERY_APP.start in order to allow specifying prog_name
     assert celery_command.params[0].name == 'app'
     celery_command.params[0].default = kallithea.CELERY_APP
     celery_command.main(args=args, prog_name='kallithea-cli celery-run -c CONFIG_FILE --')

kallithea/bin/kallithea_cli_config.py

➞

Show inline comments

 # -*- 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 os
 import sys
 import uuid
 from collections import defaultdict
 import click
 import mako.exceptions
 import kallithea.bin.kallithea_cli_base as cli_base
-import kallithea.lib.locale
+import kallithea.lib.locales
 from kallithea.lib import inifile
 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
     for key, value in inifile.default_variables.items():
         click.echo('%s=%s' % (key, value))
     ctx.exit()
 @cli_base.register_command()
 @click.option('--show-defaults', callback=show_defaults,
               is_flag=True, expose_value=False, is_eager=True,
               help='Show the default values that can be overridden')
 @click.argument('config_file', type=click.Path(dir_okay=False, writable=True), required=True)
 @click.argument('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.
     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.
     Additional key=value arguments will be patched/inserted in the [app:main]
     section ... until another section name specifies where any following values
     should go.
     """
     mako_variable_values = {
         'version': kallithea.__version__,
         'git_hook_interpreter': sys.executable,
         'user_home_path': os.path.expanduser('~'),
         'kallithea_cli_path': cli_base.kallithea_cli_path,
-        'ssh_locale': kallithea.lib.locale.get_current_locale(),
+        'ssh_locale': kallithea.lib.locales.get_current_locale(),
+    }
     ini_settings = defaultdict(dict)
     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
     mako_variable_values.update({
         'uuid': lambda: uuid.uuid4().hex,
     })

kallithea/bin/kallithea_cli_db.py

➞

Show inline comments

 # -*- 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 kallithea.lib.utils
 import kallithea.model.scm
 from kallithea.lib.db_manage import DbManage
-from kallithea.model.meta import Session
+from kallithea.model import meta
 @cli_base.register_command(config_file=True)
 @cli_base.register_command(needs_config_file=True, config_file_initialize_app=True)
 @click.option('--reuse/--no-reuse', default=False,
         help='Reuse and clean existing database instead of dropping and creating (default: no reuse)')
 @click.option('--user', help='Username of administrator account.')
 @click.option('--password', help='Password for administrator account.')
 @click.option('--email', help='Email address of administrator account.')
 @click.option('--repos', help='Absolute path to repositories location.')
 @click.option('--force-yes', is_flag=True, help='Answer yes to every question.')
 @click.option('--force-no', is_flag=True, help='Answer no to every question.')
 @click.option('--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):
+def db_create(user, password, email, repos, force_yes, force_no, public_access, reuse, config=None):
     """Initialize the database.
     Create all required tables in the database specified in the configuration
     file. Create the administrator account. Set certain settings based on
     values you provide.
     You can pass the answers to all questions as options to this command.
     """
     dbconf = kallithea.CONFIG['sqlalchemy.url']
     if config is not None:  # first called with config, before app initialization
         dbconf = config['sqlalchemy.url']
     # 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
         # 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
     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)
     repo_root_path = dbmanage.prompt_repo_root_path(None)
     dbmanage.create_settings(repo_root_path)
     dbmanage.create_default_user()
     dbmanage.admin_prompt()
     dbmanage.create_permissions()
     dbmanage.populate_default_permissions()
     Session().commit()
         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=config['here'],
                             cli_args=cli_args)
         dbmanage.create_tables(reuse_database=reuse)
         repo_root_path = dbmanage.prompt_repo_root_path(None)
         dbmanage.create_settings(repo_root_path)
         dbmanage.create_default_user()
         dbmanage.create_admin_user()
         dbmanage.create_permissions()
         dbmanage.populate_default_permissions()
         meta.Session().commit()
     # initial repository scan
     kallithea.config.middleware.make_app(
             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.')
     else:  # then called again after app initialization
         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'.")
         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

➞

Show inline comments

@@ @@ -3,55 +3,54 @@ @@
 # 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: Mar 6, 2012
 :author: marcink
 :copyright: (c) 2013 RhodeCode GmbH, and others.
 :license: GPLv3, see LICENSE.md for more details.
 """
 import os
 import click
 import pkg_resources
 import kallithea
 import kallithea.bin.kallithea_cli_base as cli_base
 from kallithea.lib.utils2 import ask_ok
 @cli_base.register_command(config_file=True)
 def extensions_create():
 @cli_base.register_command(needs_config_file=True)
 def extensions_create(config):
     """Write template file for extending Kallithea in Python.
     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.
     Create a template `extensions.py` file 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']
+    here = config['here']
     content = pkg_resources.resource_string(
-        'kallithea', os.path.join('config', 'rcextensions', '__init__.py')
+        'kallithea', os.path.join('templates', 'py', 'extensions.py')
+    )
-    ext_file = os.path.join(here, 'rcextensions', '__init__.py')
+    ext_file = os.path.join(here, 'extensions.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
     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

➞

Show inline comments

 # -*- 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 os
 import sys
 import click
 import kallithea
 import kallithea.bin.kallithea_cli_base as cli_base
 dispath_py_template = '''\
 # Created by Kallithea 'kallithea-cli iis-install'
 import sys
 if hasattr(sys, "isapidllhandle"):
     import win32traceutil
 import isapi_wsgi
 import os
 def __ExtensionFactory__():
     from paste.deploy import loadapp
     from logging.config import fileConfig
     fileConfig('%(inifile)s', {'__file__': '%(inifile)s', 'here': '%(inifiledir)s'})
     application = loadapp('config:%(inifile)s')
     def app(environ, start_response):
         user = environ.get('REMOTE_USER', None)
         if user is not None:
             os.environ['REMOTE_USER'] = user
         return application(environ, start_response)
     return isapi_wsgi.ISAPIThreadPoolHandler(app)
 if __name__=='__main__':
     from isapi.install import *
     params = ISAPIParameters()
     sm = [ScriptMapParams(Extension="*", Flags=0)]
     vd = VirtualDirParameters(Name="%(virtualdir)s",
                               Description = "Kallithea",
                               ScriptMaps = sm,
                               ScriptMapUpdate = "replace")
     params.VirtualDirs = [vd]
     HandleCommandLine(params)
 '''
-@cli_base.register_command(config_file=True)
+@cli_base.register_command(needs_config_file=True)
 @click.option('--virtualdir', default='/',
         help='The virtual folder to install into on IIS.')
 def iis_install(virtualdir):
+def iis_install(virtualdir, config):
     """Install into IIS using isapi-wsgi."""
-    config_file_abs = kallithea.CONFIG['__file__']
+    config_file_abs = config['__file__']
     try:
         import isapi_wsgi
+        import isapi_wsgi  # pytype: disable=import-error
         assert isapi_wsgi
     except ImportError:
         sys.stderr.write('missing requirement: isapi-wsgi not installed\n')
         sys.exit(1)
     dispatchfile = os.path.join(os.getcwd(), 'dispatch.py')
     click.echo('Writing %s' % dispatchfile)
     with open(dispatchfile, 'w') as f:
         f.write(dispath_py_template % {
             'inifile': config_file_abs.replace('\\', '\\\\'),
             'inifiledir': os.path.dirname(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

➞

Show inline comments

@@ @@ -7,56 +7,56 @@ @@
 # 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: Aug 17, 2010
 :author: marcink
 :copyright: (c) 2013 RhodeCode GmbH, and others.
 :license: GPLv3, see LICENSE.md for more details.
 """
 import os
 import sys
 import click
 import kallithea
 import kallithea.bin.kallithea_cli_base as cli_base
 from kallithea.lib.indexers.daemon import WhooshIndexingDaemon
 from kallithea.lib.pidlock import DaemonLock, LockHeld
-from kallithea.lib.utils import load_rcextensions
+from kallithea.lib.utils import load_extensions
 from kallithea.model.repo import RepoModel
 @cli_base.register_command(config_file_initialize_app=True)
 @click.option('--repo-location', help='Base path of repositories to index. Default: all')
 @click.option('--index-only', help='Comma-separated list of repositories to build index on. Default: all')
 @click.option('--update-only', help='Comma-separated list of repositories to re-build index on. Default: all')
 @click.option('-f', '--full/--no-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"""
     index_location = kallithea.CONFIG['index_dir']
-    load_rcextensions(kallithea.CONFIG['here'])
+    load_extensions(kallithea.CONFIG['here'])
     if not repo_location:
         repo_location = RepoModel().repos_path
     repo_list = [x.strip() for x in index_only.split(',')] \
         if index_only else None
     repo_update_list = [x.strip() for x in update_only.split(',')] \
         if update_only else None
     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_repo.py

➞

Show inline comments

@@ @@ -9,105 +9,110 @@ @@
 # 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 datetime
 import os
 import re
 import shutil
 import click
 import kallithea
 import kallithea.bin.kallithea_cli_base as cli_base
 from kallithea.lib.utils import REMOVED_REPO_PAT, repo2db_mapper
 from kallithea.lib.utils2 import ask_ok
 from kallithea.model.db import Repository
 from kallithea.model.meta import Session
 from kallithea.model import db, meta
 from kallithea.model.scm import ScmModel
 @cli_base.register_command(config_file_initialize_app=True)
 @click.option('--remove-missing', is_flag=True,
         help='Remove missing repositories from the Kallithea database.')
 def repo_scan(remove_missing):
 @click.option('--install-git-hooks', is_flag=True,
         help='(Re)install Kallithea Git hooks without overwriting other hooks.')
 @click.option('--overwrite-git-hooks', is_flag=True,
         help='(Re)install Kallithea Git hooks, overwriting other hooks.')
 def repo_scan(remove_missing, install_git_hooks, overwrite_git_hooks):
     """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)
                                     remove_obsolete=remove_missing,
                                     install_git_hooks=install_git_hooks,
                                     overwrite_git_hooks=overwrite_git_hooks)
     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)
 @click.argument('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()
+        repo_list = db.Repository.query().all()
     else:
         repo_names = [n.strip() for n in repositories]
         repo_list = list(Repository.query()
                         .filter(Repository.repo_name.in_(repo_names)))
         repo_list = list(db.Repository.query()
                         .filter(db.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()
+    meta.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)
 @click.option('--ask/--no-ask', default=True, help='Ask for confirmation or not. Default is --ask.')
 @click.option('--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 = {}

kallithea/bin/kallithea_cli_ssh.py

➞

Show inline comments

 # -*- 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 logging
 import os
 import shlex
 import sys
 import click
 import kallithea
 import kallithea.bin.kallithea_cli_base as cli_base
 from kallithea.lib.utils2 import str2bool
 from kallithea.lib.vcs.backends.git.ssh import GitSshHandler
 from kallithea.lib.vcs.backends.hg.ssh import MercurialSshHandler
 from kallithea.lib.utils2 import asbool
 from kallithea.lib.vcs.ssh.git import GitSshHandler
 from kallithea.lib.vcs.ssh.hg import MercurialSshHandler
 from kallithea.model.ssh_key import SshKeyModel, SshKeyModelException
 log = logging.getLogger(__name__)
 @cli_base.register_command(config_file_initialize_app=True, hidden=True)
 @click.argument('user-id', type=click.INT, required=True)
 @click.argument('key-id', type=click.INT, required=True)
 def ssh_serve(user_id, key_id):
     """Serve SSH repository protocol access.
     The trusted command that is invoked from .ssh/authorized_keys to serve SSH
     protocol access. The access will be granted as the specified user ID, and
     logged as using the specified key ID.
     """
     ssh_enabled = kallithea.CONFIG.get('ssh_enabled', False)
     if not str2bool(ssh_enabled):
     if not asbool(kallithea.CONFIG.get('ssh_enabled', False)):
         sys.stderr.write("SSH access is disabled.\n")
         return sys.exit(1)
     ssh_locale = kallithea.CONFIG.get('ssh_locale')
     if ssh_locale:
         os.environ['LC_ALL'] = ssh_locale # trumps everything, including LANG, except LANGUAGE
         os.environ['LANGUAGE'] = ssh_locale # trumps LC_ALL for GNU gettext message handling
     ssh_original_command = os.environ.get('SSH_ORIGINAL_COMMAND', '')
     client_ip = os.environ.get('SSH_CONNECTION', '').split(' ', 1)[0] or '0.0.0.0'
     log.debug('ssh-serve was invoked for SSH command %r from %s', ssh_original_command, client_ip)
     if not ssh_original_command:
         if os.environ.get('SSH_CONNECTION'):
             sys.stderr.write("'kallithea-cli ssh-serve' can only provide protocol access over SSH. Interactive SSH login for this user is disabled.\n")
         else:
             sys.stderr.write("'kallithea-cli ssh-serve' cannot be called directly. It must be specified as command in an SSH authorized_keys file.\n")
         return sys.exit(1)
     try:
         ssh_command_parts = shlex.split(ssh_original_command)
     except ValueError as e:
         sys.stderr.write('Error parsing SSH command %r: %s\n' % (ssh_original_command, e))
         sys.exit(1)
     for VcsHandler in [MercurialSshHandler, GitSshHandler]:
         vcs_handler = VcsHandler.make(ssh_command_parts)
         if vcs_handler is not None:
             vcs_handler.serve(user_id, key_id, client_ip)
-            assert False # serve is written so it never will terminate
+            sys.exit(0)
     sys.stderr.write("This account can only be used for repository access. SSH command %r is not supported.\n" % ssh_original_command)
     sys.exit(1)
 @cli_base.register_command(config_file_initialize_app=True)
 def ssh_update_authorized_keys():
     """Update .ssh/authorized_keys file.
     The file is usually maintained automatically, but this command will also re-write it.
     """
     try:
         SshKeyModel().write_authorized_keys()
     except SshKeyModelException as e:
         sys.stderr.write("%s\n" % e)
         sys.exit(1)

kallithea/bin/vcs_hooks.py

➞

Show inline comments

@@ file copied from kallithea/lib/hooks.py to kallithea/bin/vcs_hooks.py @@
 # -*- 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/>.
 """
 kallithea.lib.hooks
 ~~~~~~~~~~~~~~~~~~~
 kallithea.bin.vcs_hooks
 ~~~~~~~~~~~~~~~~~~~~~~~
-Hooks run by Kallithea
+Entry points for Kallithea hooking into Mercurial and Git.
 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: Aug 6, 2010
 :author: marcink
 :copyright: (c) 2013 RhodeCode GmbH, and others.
 :license: GPLv3, see LICENSE.md for more details.
 """
 import logging
 import os
 import sys
 import time
 import mercurial.scmutil
 from kallithea.lib import helpers as h
 from kallithea.lib.exceptions import UserCreationError
 from kallithea.lib.utils import action_logger, make_ui
 import mercurial.hg
 import mercurial.scmutil
 import paste.deploy
 import kallithea
 import kallithea.config.application
 from kallithea.lib import hooks, webutils
 from kallithea.lib.utils2 import HookEnvironmentError, ascii_str, get_hook_environment, safe_bytes, safe_str
 from kallithea.lib.vcs.backends.base import EmptyChangeset
 from kallithea.model.db import Repository, User
 from kallithea.lib.vcs.utils.helpers import get_scm_size
 from kallithea.model import db
 def _get_scm_size(alias, root_path):
     if not alias.startswith('.'):
         alias += '.'
     size_scm, size_root = 0, 0
     for path, dirs, files in os.walk(root_path):
         if path.find(alias) != -1:
             for f in files:
                 try:
                     size_scm += os.path.getsize(os.path.join(path, f))
                 except OSError:
                     pass
         else:
             for f in files:
                 try:
                     size_root += os.path.getsize(os.path.join(path, f))
                 except OSError:
                     pass
     size_scm_f = h.format_byte_size(size_scm)
     size_root_f = h.format_byte_size(size_root)
     size_total_f = h.format_byte_size(size_root + size_scm)
     return size_scm_f, size_root_f, size_total_f
 log = logging.getLogger(__name__)
 def repo_size(ui, repo, hooktype=None, **kwargs):
     """Show size of Mercurial repository.
-    Called as Mercurial hook changegroup.repo_size after push.
+    Called as Mercurial hook changegroup.kallithea_repo_size after push.
     """
-    size_hg_f, size_root_f, size_total_f = _get_scm_size('.hg', safe_str(repo.root))
+    size_hg, size_root = get_scm_size('.hg', safe_str(repo.root))
     last_cs = repo[len(repo) - 1]
     msg = ('Repository size .hg: %s Checkout: %s Total: %s\n'
            'Last revision is now r%s:%s\n') % (
         size_hg_f, size_root_f, size_total_f, last_cs.rev(), ascii_str(last_cs.hex())[:12]
         webutils.format_byte_size(size_hg),
         webutils.format_byte_size(size_root),
         webutils.format_byte_size(size_hg + size_root),
         last_cs.rev(),
         ascii_str(last_cs.hex())[:12],
+    )
     ui.status(safe_bytes(msg))
 def log_pull_action(ui, repo, **kwargs):
     """Logs user last pull action
     Called as Mercurial hook outgoing.pull_logger or from Kallithea before invoking Git.
     Does *not* use the action from the hook environment but is always 'pull'.
     """
     ex = get_hook_environment()
 def update(ui, repo, hooktype=None, **kwargs):
     """Update repo after push. The equivalent to 'hg update' but using the same
     Mercurial as everything else.
     user = User.get_by_username(ex.username)
     action = 'pull'
     action_logger(user, action, ex.repository, ex.ip, commit=True)
     # extension hook call
     from kallithea import EXTENSIONS
     callback = getattr(EXTENSIONS, 'PULL_HOOK', None)
     if callable(callback):
         kw = {}
         kw.update(ex)
         callback(**kw)
     return 0
     Called as Mercurial hook changegroup.kallithea_update after push.
     """
     try:
         ui.pushbuffer(error=True, subproc=True)
         rev = brev = None
         mercurial.hg.updatetotally(ui, repo, rev, brev)
     finally:
         s = ui.popbuffer()  # usually just "x files updated, x files merged, x files removed, x files unresolved"
         log.info('%s update hook output: %s', safe_str(repo.root), safe_str(s).rstrip())
 def log_push_action(ui, repo, node, node_last, **kwargs):
 def pull_action(ui, repo, **kwargs):
     """Logs user pull action
     Called as Mercurial hook outgoing.kallithea_pull_action.
     """
     hooks.log_pull_action()
 def push_action(ui, repo, node, node_last, **kwargs):
     """
     Register that changes have been added to the repo - log the action *and* invalidate caches.
     Note: This hook is not only logging, but also the side effect invalidating
     caches! The function should perhaps be renamed.
-    Called as Mercurial hook changegroup.kallithea_log_push_action .
+    Called as Mercurial hook changegroup.kallithea_push_action .
     The pushed changesets is given by the revset 'node:node_last'.
     """
     revs = [ascii_str(repo[r].hex()) for r in mercurial.scmutil.revrange(repo, [b'%s:%s' % (node, node_last)])]
     process_pushed_raw_ids(revs)
     return 0
 def process_pushed_raw_ids(revs):
     """
     Register that changes have been added to the repo - log the action *and* invalidate caches.
     Called from Mercurial changegroup.kallithea_log_push_action calling hook log_push_action,
     or from the Git post-receive hook calling handle_git_post_receive ...
     or from scm _handle_push.
     """
     ex = get_hook_environment()
     action = '%s:%s' % (ex.action, ','.join(revs))
     action_logger(ex.username, action, ex.repository, ex.ip, commit=True)
     from kallithea.model.scm import ScmModel
     ScmModel().mark_for_invalidation(ex.repository)
     # extension hook call
     from kallithea import EXTENSIONS
     callback = getattr(EXTENSIONS, 'PUSH_HOOK', None)
     if callable(callback):
         kw = {'pushed_revs': revs}
         kw.update(ex)
         callback(**kw)
 def log_create_repository(repository_dict, created_by, **kwargs):
     """
     Post create repository Hook.
     :param repository: dict dump of repository object
     :param created_by: username who created repository
     available keys of repository_dict:
      'repo_type',
      'description',
      'private',
      'created_on',
      'enable_downloads',
      'repo_id',
      'owner_id',
      'enable_statistics',
      'clone_uri',
      'fork_id',
      'group_id',
      'repo_name'
     """
     from kallithea import EXTENSIONS
     callback = getattr(EXTENSIONS, 'CREATE_REPO_HOOK', None)
     if callable(callback):
         kw = {}
         kw.update(repository_dict)
         kw.update({'created_by': created_by})
         kw.update(kwargs)
         return callback(**kw)
     return 0
 def check_allowed_create_user(user_dict, created_by, **kwargs):
     # pre create hooks
     from kallithea import EXTENSIONS
     callback = getattr(EXTENSIONS, 'PRE_CREATE_USER_HOOK', None)
     if callable(callback):
         allowed, reason = callback(created_by=created_by, **user_dict)
         if not allowed:
             raise UserCreationError(reason)
     hooks.process_pushed_raw_ids(revs)
 def log_create_user(user_dict, created_by, **kwargs):
     """
     Post create user Hook.
     :param user_dict: dict dump of user object
     available keys for user_dict:
      'username',
      'full_name_or_username',
      'full_contact',
      'user_id',
      'name',
      'firstname',
      'short_contact',
      'admin',
      'lastname',
      'ip_addresses',
      'ldap_dn',
      'email',
      'api_key',
      'last_login',
      'full_name',
      'active',
      'password',
      'emails',
     """
     from kallithea import EXTENSIONS
     callback = getattr(EXTENSIONS, 'CREATE_USER_HOOK', None)
     if callable(callback):
         return callback(created_by=created_by, **user_dict)
     return 0
 def log_delete_repository(repository_dict, deleted_by, **kwargs):
     """
     Post delete repository Hook.
     :param repository: dict dump of repository object
     :param deleted_by: username who deleted the repository
     available keys of repository_dict:
      'repo_type',
      'description',
      'private',
      'created_on',
      'enable_downloads',
      'repo_id',
      'owner_id',
      'enable_statistics',
      'clone_uri',
      'fork_id',
      'group_id',
      'repo_name'
     """
     from kallithea import EXTENSIONS
     callback = getattr(EXTENSIONS, 'DELETE_REPO_HOOK', None)
     if callable(callback):
         kw = {}
         kw.update(repository_dict)
         kw.update({'deleted_by': deleted_by,
                    'deleted_on': time.time()})
         kw.update(kwargs)
         return callback(**kw)
     return 0
 def log_delete_user(user_dict, deleted_by, **kwargs):
     """
     Post delete user Hook.
     :param user_dict: dict dump of user object
     available keys for user_dict:
      'username',
      'full_name_or_username',
      'full_contact',
      'user_id',
      'name',
      'firstname',
      'short_contact',
      'admin',
      'lastname',
      'ip_addresses',
      'ldap_dn',
      'email',
      'api_key',
      'last_login',
      'full_name',
      'active',
      'password',
      'emails',
     """
     from kallithea import EXTENSIONS
     callback = getattr(EXTENSIONS, 'DELETE_USER_HOOK', None)
     if callable(callback):
         return callback(deleted_by=deleted_by, **user_dict)
     return 0
 def _hook_environment(repo_path):
 def _git_hook_environment(repo_path):
     """
     Create a light-weight environment for stand-alone scripts and return an UI and the
     db repository.
     Git hooks are executed as subprocess of Git while Kallithea is waiting, and
     they thus need enough info to be able to create an app environment and
     connect to the database.
     """
     import paste.deploy
     import kallithea.config.middleware
     extras = get_hook_environment()
     path_to_ini_file = extras['config']
-    kallithea.CONFIG = paste.deploy.appconfig('config:' + path_to_ini_file)
+    config = paste.deploy.appconfig('config:' + path_to_ini_file)
     #logging.config.fileConfig(ini_file_path) # Note: we are in a different process - don't use configured logging
-    kallithea.config.middleware.make_app(kallithea.CONFIG.global_conf, **kallithea.CONFIG.local_conf)
+    kallithea.config.application.make_app(config.global_conf, **config.local_conf)
     # fix if it's not a bare repo
     if repo_path.endswith(os.sep + '.git'):
         repo_path = repo_path[:-5]
     repo = Repository.get_by_full_path(repo_path)
+    repo = db.Repository.get_by_full_path(repo_path)
     if not repo:
         raise OSError('Repository %s not found in database' % repo_path)
     baseui = make_ui()
     return baseui, repo
     return repo
 def handle_git_pre_receive(repo_path, git_stdin_lines):
     """Called from Git pre-receive hook"""
     # Currently unused. TODO: remove?
     return 0
 def handle_git_post_receive(repo_path, git_stdin_lines):
     """Called from Git post-receive hook"""
 def post_receive(repo_path, git_stdin_lines):
     """Called from Git post-receive hook.
     The returned value is used as hook exit code and must be 0.
     """
     try:
-        baseui, repo = _hook_environment(repo_path)
+        repo = _git_hook_environment(repo_path)
     except HookEnvironmentError as e:
-        sys.stderr.write("Skipping Kallithea Git post-recieve hook %r.\nGit was apparently not invoked by Kallithea: %s\n" % (sys.argv[0], e))
+        sys.stderr.write("Skipping Kallithea Git post-receive hook %r.\nGit was apparently not invoked by Kallithea: %s\n" % (sys.argv[0], e))
         return 0
     # the post push hook should never use the cached instance
     scm_repo = repo.scm_instance_no_cache()
     rev_data = []
     for l in git_stdin_lines:
         old_rev, new_rev, ref = l.strip().split(' ')
         _ref_data = ref.split('/')
         if _ref_data[1] in ['tags', 'heads']:
             rev_data.append({'old_rev': old_rev,
                              'new_rev': new_rev,
                              'ref': ref,
                              'type': _ref_data[1],
                              'name': '/'.join(_ref_data[2:])})
     git_revs = []
     for push_ref in rev_data:
         _type = push_ref['type']
         if _type == 'heads':
             if push_ref['old_rev'] == EmptyChangeset().raw_id:
                 # update the symbolic ref if we push new repo
                 if scm_repo.is_empty():
                     scm_repo._repo.refs.set_symbolic_ref(
@@ @@ -370,35 +167,37 @@ def handle_git_post_receive(repo_path, g @@
                 # build exclude list without the ref
                 cmd = ['for-each-ref', '--format=%(refname)', 'refs/heads/*']
                 stdout = scm_repo.run_git_command(cmd)
                 ref = push_ref['ref']
                 heads = [head for head in stdout.splitlines() if head != ref]
                 # now list the git revs while excluding from the list
                 cmd = ['log', push_ref['new_rev'], '--reverse', '--pretty=format:%H']
                 cmd.append('--not')
                 cmd.extend(heads) # empty list is ok
                 stdout = scm_repo.run_git_command(cmd)
                 git_revs += stdout.splitlines()
             elif push_ref['new_rev'] == EmptyChangeset().raw_id:
                 # delete branch case
                 git_revs += ['delete_branch=>%s' % push_ref['name']]
             else:
                 cmd = ['log', '%(old_rev)s..%(new_rev)s' % push_ref,
                        '--reverse', '--pretty=format:%H']
                 stdout = scm_repo.run_git_command(cmd)
                 git_revs += stdout.splitlines()
         elif _type == 'tags':
             git_revs += ['tag=>%s' % push_ref['name']]
     process_pushed_raw_ids(git_revs)
+    hooks.process_pushed_raw_ids(git_revs)
     return 0
 # Almost exactly like Mercurial contrib/hg-ssh:
 def rejectpush(ui, **kwargs):
     """Mercurial hook to be installed as pretxnopen and prepushkey for read-only repos"""
     """Mercurial hook to be installed as pretxnopen and prepushkey for read-only repos.
     Return value 1 will make the hook fail and reject the push.
     """
     ex = get_hook_environment()
     ui.warn(safe_bytes("Push access to %r denied\n" % ex.repository))
     return 1

kallithea/config/app_cfg.py

➞

Show inline comments

@@ @@ -7,208 +7,159 @@ @@
 # 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 logging
 import os
 import platform
 import sys
 import alembic.config
 import mercurial
 import tg
 from alembic.migration import MigrationContext
 from alembic.script.base import ScriptDirectory
 from sqlalchemy import create_engine
 from tg.configuration import AppConfig
 from tg.support.converters import asbool
 from tg import FullStackApplicationConfigurator
-import kallithea.lib.locale
+import kallithea.lib.locales
 import kallithea.model.base
 import kallithea.model.meta
 from kallithea.lib import celerypylons
 from kallithea.lib.middleware.https_fixup import HttpsFixup
 from kallithea.lib.middleware.permanent_repo_url import PermanentRepoUrl
 from kallithea.lib.middleware.simplegit import SimpleGit
 from kallithea.lib.middleware.simplehg import SimpleHg
 from kallithea.lib.middleware.wrapper import RequestWrapper
 from kallithea.lib.utils import check_git_version, load_rcextensions, set_app_settings, set_indexer_config, set_vcs_config
 from kallithea.lib.utils2 import str2bool
 from kallithea.lib import celery_app
 from kallithea.lib.utils import load_extensions, set_app_settings, set_indexer_config, set_vcs_config
 from kallithea.lib.utils2 import asbool, check_git_version
 from kallithea.model import db
 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.
 base_config = FullStackApplicationConfigurator()
     # 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.
 base_config.update_blueprint({
     'package': kallithea,
     def __init__(self):
         super(KallitheaAppConfig, self).__init__()
         self['package'] = kallithea
     # Rendering Engines Configuration
     'renderers': [
         'json',
         'mako',
     ],
     'default_renderer': 'mako',
     'use_dotted_templatenames': False,
         self['prefer_toscawidgets2'] = False
         self['use_toscawidgets'] = False
         self['renderers'] = []
         # Enable json in expose
         self['renderers'].append('json')
     # Configure Sessions, store data as JSON to avoid pickle security issues
     'session.enabled': True,
     'session.data_serializer': 'json',
         # Configure template rendering
         self['renderers'].append('mako')
         self['default_renderer'] = 'mako'
         self['use_dotted_templatenames'] = False
     # Configure the base SQLALchemy Setup
     'use_sqlalchemy': True,
     'model': kallithea.model.base,
     'DBSession': kallithea.model.meta.Session,
         # 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.
     'auth_backend': None,
         # 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]
     # 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.
     'errorpage.status_codes': [400, 401, 403, 404],
         # Disable transaction manager -- currently Kallithea takes care of transactions itself
         self['tm.enabled'] = False
     # Disable transaction manager -- currently Kallithea takes care of transactions itself
     'tm.enabled': False,
         # Set the default i18n source language so TG doesn't search beyond 'en' in Accept-Language.
         self['i18n.lang'] = 'en'
 base_config = KallitheaAppConfig()
     # Set the default i18n source language so TG doesn't search beyond 'en' in Accept-Language.
     'i18n.lang': 'en',
 })
 # 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:
     import kajiki  # only to check its existence
     from tgext.debugbar import enable_debugbar
     import kajiki # only to check its existence
     assert kajiki
 except ImportError:
     pass
 else:
-    base_config['renderers'].append('kajiki')
+    base_config.get_blueprint_value('renderers').append('kajiki')
     enable_debugbar(base_config)
 def setup_configuration(app):
     config = app.config
-    if not kallithea.lib.locale.current_locale_is_valid():
+    if not kallithea.lib.locales.current_locale_is_valid():
         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')
+        log.warning('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.DEFAULT_USER_ID = db.User.get_default_user().user_id
     if str2bool(config.get('use_celery')):
         kallithea.CELERY_APP = celerypylons.make_app()
     if asbool(config.get('use_celery')) and not kallithea.CELERY_APP.finalized:
         kallithea.CELERY_APP.config_from_object(celery_app.make_celery_config(config))
     kallithea.CONFIG = config
-    load_rcextensions(root_path=config['here'])
+    load_extensions(root_path=config['here'])
     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()
     kallithea.model.meta.Session.remove()
 tg.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)
     app = PermanentRepoUrl(app, config)
     # Optional and undocumented wrapper - gives more verbose request/response logging, but has a slight overhead
     if str2bool(config.get('use_wsgi_wrapper')):
         app = RequestWrapper(app, config)
     return app
 tg.hooks.register('before_config', setup_application)

kallithea/config/application.py

➞

Show inline comments

 # -*- 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/>.
 """WSGI middleware initialization for the Kallithea application."""
 from kallithea.config.app_cfg import base_config
 from kallithea.config.environment import load_environment
 from kallithea.config.middleware.https_fixup import HttpsFixup
 from kallithea.config.middleware.permanent_repo_url import PermanentRepoUrl
 from kallithea.config.middleware.simplegit import SimpleGit
 from kallithea.config.middleware.simplehg import SimpleHg
 from kallithea.config.middleware.wrapper import RequestWrapper
 from kallithea.lib.utils2 import asbool
 __all__ = ['make_app']
 # 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)
 def wrap_app(app):
     """Wrap the TG WSGI application in Kallithea middleware"""
     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 ['url_scheme_variable', 'force_https', 'use_htsts']):
         app = HttpsFixup(app, config)
     app = PermanentRepoUrl(app, config)
     # Optional and undocumented wrapper - gives more verbose request/response logging, but has a slight overhead
     if asbool(config.get('use_wsgi_wrapper')):
         app = RequestWrapper(app, config)
     return app
-def make_app(global_conf, full_stack=True, **app_conf):
 def make_app(global_conf, **app_conf):
     """
     Set up Kallithea with the settings found in the PasteDeploy configuration
     file used.
     :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.
     This is the PasteDeploy factory for the Kallithea application.
     ``app_conf`` contains all the application-specific settings (those defined
     under ``[app:main]``.
     """
     assert app_conf.get('sqlalchemy.url')  # must be called with a Kallithea .ini file, which for example must have this config option
     assert global_conf.get('here') and global_conf.get('__file__')  # app config should be initialized the paste way ...
     return make_base_app(global_conf, full_stack=full_stack, **app_conf)
     return base_config.make_wsgi_app(global_conf, app_conf, wrap_app=wrap_app)

kallithea/config/environment.py

➞

Show inline comments

deleted file

kallithea/config/middleware/__init__.py

➞

Show inline comments

file renamed from kallithea/lib/middleware/__init__.py to kallithea/config/middleware/__init__.py

kallithea/config/middleware/https_fixup.py

➞

Show inline comments

 # -*- 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/>.
 """
 kallithea.lib.middleware.https_fixup
 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 kallithea.config.middleware.https_fixup
 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 middleware to handle https correctly
 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: May 23, 2010
 :author: marcink
 :copyright: (c) 2013 RhodeCode GmbH, and others.
 :license: GPLv3, see LICENSE.md for more details.
 """
 from kallithea.lib.utils2 import str2bool
 import kallithea
 from kallithea.lib.utils2 import asbool
 class HttpsFixup(object):
     def __init__(self, app, config):
         self.application = app
         self.config = config
     def __call__(self, environ, start_response):
         self.__fixup(environ)
-        debug = str2bool(self.config.get('debug'))
+        debug = asbool(self.config.get('debug'))
         is_ssl = environ['wsgi.url_scheme'] == 'https'
         def custom_start_response(status, headers, exc_info=None):
-            if is_ssl and str2bool(self.config.get('use_htsts')) and not debug:
+            if is_ssl and asbool(self.config.get('use_htsts')) and not debug:
                 headers.append(('Strict-Transport-Security',
                                 'max-age=8640000; includeSubDomains'))
             return start_response(status, headers, exc_info)
         return self.application(environ, custom_start_response)
     def __fixup(self, environ):
         """
         Function to fixup the environ as needed. In order to use this
         middleware you should set this header inside your
         proxy ie. nginx, apache etc.
         """
         # DETECT PROTOCOL !
         if 'HTTP_X_URL_SCHEME' in environ:
             proto = environ.get('HTTP_X_URL_SCHEME')
         elif 'HTTP_X_FORWARDED_SCHEME' in environ:
             proto = environ.get('HTTP_X_FORWARDED_SCHEME')
         elif 'HTTP_X_FORWARDED_PROTO' in environ:
             proto = environ.get('HTTP_X_FORWARDED_PROTO')
         else:
             proto = 'http'
         org_proto = proto
         proto = None
         # if we have force, just override
-        if str2bool(self.config.get('force_https')):
+        if asbool(self.config.get('force_https')):
             proto = 'https'
         else:
             # get protocol from configured WSGI environment variable
             url_scheme_variable = kallithea.CONFIG.get('url_scheme_variable')
             if url_scheme_variable:
                 proto = environ.get(url_scheme_variable)
         environ['wsgi.url_scheme'] = proto
         environ['wsgi._org_proto'] = org_proto
         if proto:
             environ['wsgi._org_proto'] = environ.get('wsgi.url_scheme')
             environ['wsgi.url_scheme'] = proto

kallithea/config/middleware/permanent_repo_url.py

➞

Show inline comments

 # -*- 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/>.
 """
 kallithea.lib.middleware.permanent_repo_url
 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 kallithea.config.middleware.permanent_repo_url
 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 middleware to handle permanent repo URLs, replacing PATH_INFO '/_123/yada' with
 '/name/of/repo/yada' after looking 123 up in the database.
 """
 from kallithea.lib.utils import fix_repo_id_name
 from kallithea.lib.utils2 import safe_bytes, safe_str
 class PermanentRepoUrl(object):
     def __init__(self, app, config):
         self.application = app
         self.config = config
     def __call__(self, environ, start_response):
         # Extract path_info as get_path_info does, but do it explicitly because
         # we also have to do the reverse operation when patching it back in
         path_info = safe_str(environ['PATH_INFO'].encode('latin1'))
         if path_info.startswith('/'): # it must
             path_info = '/' + fix_repo_id_name(path_info[1:])
             environ['PATH_INFO'] = safe_bytes(path_info).decode('latin1')

kallithea/config/middleware/pygrack.py

➞

Show inline comments

 # -*- 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/>.
 """
 kallithea.lib.middleware.pygrack
 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 kallithea.config.middleware.pygrack
 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 Python implementation of git-http-backend's Smart HTTP protocol
 Based on original code from git_http_backend.py project.
 Copyright (c) 2010 Daniel Dotsenko <dotsa@hotmail.com>
 Copyright (c) 2012 Marcin Kuzminski <marcin@python-works.com>
 This file was forked by the Kallithea project in July 2014.
 """
 import logging
 import os
 import socket
 import traceback
 from dulwich.server import update_server_info
 from dulwich.web import GunzipFilter, LimitedInputFilter
 from webob import Request, Response, exc
 import kallithea
 from kallithea.lib.utils2 import ascii_bytes
 from kallithea.lib.vcs import subprocessio
+from kallithea.lib.vcs import get_repo, subprocessio
 log = logging.getLogger(__name__)
 class FileWrapper(object):
     def __init__(self, fd, content_length):
         self.fd = fd
         self.content_length = content_length
         self.remain = content_length
     def read(self, size):
         if size <= self.remain:
             try:
                 data = self.fd.read(size)
             except socket.error:
                 raise IOError(self)
             self.remain -= size
         elif self.remain:
             data = self.fd.read(self.remain)
             self.remain = 0
         else:
             data = None
@@ @@ -147,50 +149,48 @@ class GitRepository(object): @@
             inputstream = FileWrapper(environ['wsgi.input'],
                                       req.content_length)
         else:
             inputstream = environ['wsgi.input']
         gitenv = dict(os.environ)
         # forget all configs
         gitenv['GIT_CONFIG_NOGLOBAL'] = '1'
         cmd = [_git_path, git_command[4:], '--stateless-rpc', self.content_path]
         log.debug('handling cmd %s', cmd)
         try:
             out = subprocessio.SubprocessIOChunker(
                 cmd,
                 inputstream=inputstream,
                 env=gitenv,
                 cwd=self.content_path,
+            )
         except EnvironmentError as e:
             log.error(traceback.format_exc())
             raise exc.HTTPExpectationFailed()
         if git_command in ['git-receive-pack']:
             # updating refs manually after each push.
             # Needed for pre-1.7.0.4 git clients using regular HTTP mode.
             from kallithea.lib.vcs import get_repo
             from dulwich.server import update_server_info
             repo = get_repo(self.content_path)
             if repo:
                 update_server_info(repo._repo)
         resp = Response()
         resp.content_type = 'application/x-%s-result' % git_command
         resp.charset = None
         resp.app_iter = out
         return resp
     def __call__(self, environ, start_response):
         req = Request(environ)
         _path = self._get_fixedpath(req.path_info)
         if _path.startswith('info/refs'):
             app = self.inforefs
         elif req.accept.acceptable_offers(self.valid_accepts):
             app = self.backend
         try:
             resp = app(req, environ)
         except exc.HTTPException as e:
             resp = e
             log.error(traceback.format_exc())
         except Exception as e:
             log.error(traceback.format_exc())
@@ @@ -202,27 +202,26 @@ class GitDirectory(object): @@
     def __init__(self, repo_root, repo_name):
         repo_location = os.path.join(repo_root, repo_name)
         if not os.path.isdir(repo_location):
             raise OSError(repo_location)
         self.content_path = repo_location
         self.repo_name = repo_name
         self.repo_location = repo_location
     def __call__(self, environ, start_response):
         content_path = self.content_path
         try:
             app = GitRepository(self.repo_name, content_path)
         except (AssertionError, OSError):
             content_path = os.path.join(content_path, '.git')
             if os.path.isdir(content_path):
                 app = GitRepository(self.repo_name, content_path)
             else:
                 return exc.HTTPNotFound()(environ, start_response)
         return app(environ, start_response)
 def make_wsgi_app(repo_name, repo_root):
     from dulwich.web import LimitedInputFilter, GunzipFilter
     app = GitDirectory(repo_root, repo_name)
     return GunzipFilter(LimitedInputFilter(app))

kallithea/config/middleware/simplegit.py

➞

Show inline comments

 # -*- 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/>.
 """
 kallithea.lib.middleware.simplegit
 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 kallithea.config.middleware.simplegit
 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 SimpleGit middleware for handling Git protocol requests (push/clone etc.)
 It's implemented with basic auth function
 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: Apr 28, 2010
 :author: marcink
 :copyright: (c) 2013 RhodeCode GmbH, and others.
 :license: GPLv3, see LICENSE.md for more details.
 """
 import logging
 import re
 from kallithea.lib.base import BaseVCSController, get_path_info
 from kallithea.lib.hooks import log_pull_action
 from kallithea.lib.middleware.pygrack import make_wsgi_app
 from kallithea.lib.utils import make_ui
 from kallithea.model.db import Repository
 from kallithea.config.middleware.pygrack import make_wsgi_app
 from kallithea.controllers import base
 from kallithea.lib import hooks
 log = logging.getLogger(__name__)
 GIT_PROTO_PAT = re.compile(r'^/(.+)/(info/refs|git-upload-pack|git-receive-pack)$')
 cmd_mapping = {
     'git-receive-pack': 'push',
     'git-upload-pack': 'pull',
+}
 class SimpleGit(BaseVCSController):
+class SimpleGit(base.BaseVCSController):
     scm_alias = 'git'
     @classmethod
     def parse_request(cls, environ):
         path_info = get_path_info(environ)
+        path_info = base.get_path_info(environ)
         m = GIT_PROTO_PAT.match(path_info)
         if m is None:
             return None
         class parsed_request(object):
             # See https://git-scm.com/book/en/v2/Git-Internals-Transfer-Protocols#_the_smart_protocol
             repo_name = m.group(1).rstrip('/')
             cmd = m.group(2)
             query_string = environ['QUERY_STRING']
             if cmd == 'info/refs' and query_string.startswith('service='):
                 service = query_string.split('=', 1)[1]
                 action = cmd_mapping.get(service)
             else:
                 service = None
                 action = cmd_mapping.get(cmd)
         return parsed_request
     def _make_app(self, parsed_request):
         """
         Return a pygrack wsgi application.
         """
         pygrack_app = make_wsgi_app(parsed_request.repo_name, self.basepath)
         def wrapper_app(environ, start_response):
             if (parsed_request.cmd == 'info/refs' and
                 parsed_request.service == 'git-upload-pack'
             ):
                 baseui = make_ui()
                 repo = Repository.get_by_repo_name(parsed_request.repo_name)
                 scm_repo = repo.scm_instance
                 # Run hooks, like Mercurial outgoing.pull_logger does
                 log_pull_action(ui=baseui, repo=scm_repo._repo)
                 # Run hooks like Mercurial outgoing.kallithea_pull_action does
                 hooks.log_pull_action()
             # Note: push hooks are handled by post-receive hook
             return pygrack_app(environ, start_response)
         return wrapper_app

kallithea/config/middleware/simplehg.py

➞

Show inline comments

 # -*- 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/>.
 """
 kallithea.lib.middleware.simplehg
 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 kallithea.config.middleware.simplehg
 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 SimpleHg middleware for handling Mercurial protocol requests (push/clone etc.).
 It's implemented with basic auth function
 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: Apr 28, 2010
 :author: marcink
 :copyright: (c) 2013 RhodeCode GmbH, and others.
 :license: GPLv3, see LICENSE.md for more details.
 """
 import logging
 import os
 import urllib.parse
 import mercurial.hgweb
-from kallithea.lib.base import BaseVCSController, get_path_info
+from kallithea.controllers import base
 from kallithea.lib.utils import make_ui
 from kallithea.lib.utils2 import safe_bytes
 log = logging.getLogger(__name__)
 def get_header_hgarg(environ):
     """Decode the special Mercurial encoding of big requests over multiple headers.
     >>> get_header_hgarg({})
     ''
     >>> get_header_hgarg({'HTTP_X_HGARG_0': ' ', 'HTTP_X_HGARG_1': 'a','HTTP_X_HGARG_2': '','HTTP_X_HGARG_3': 'b+c %20'})
     'ab+c %20'
     """
     chunks = []
     i = 1
     while True:
         v = environ.get('HTTP_X_HGARG_%d' % i)
         if v is None:
             break
         chunks.append(v)
         i += 1
     return ''.join(chunks)
@@ @@ -70,58 +70,58 @@ cmd_mapping = { @@
     'changegroupsubset': 'pull',
     'changesetdata': 'pull',
     'clonebundles': 'pull',
     'debugwireargs': 'pull',
     'filedata': 'pull',
     'getbundle': 'pull',
     'getlfile': 'pull',
     'heads': 'pull',
     'hello': 'pull',
     'known': 'pull',
     'lheads': 'pull',
     'listkeys': 'pull',
     'lookup': 'pull',
     'manifestdata': 'pull',
     'narrow_widen': 'pull',
     'protocaps': 'pull',
     'statlfile': 'pull',
     'stream_out': 'pull',
     'pushkey': 'push',
     'putlfile': 'push',
     'unbundle': 'push',
+    }
 class SimpleHg(BaseVCSController):
+class SimpleHg(base.BaseVCSController):
     scm_alias = 'hg'
     @classmethod
     def parse_request(cls, environ):
         http_accept = environ.get('HTTP_ACCEPT', '')
         if not http_accept.startswith('application/mercurial'):
             return None
         path_info = get_path_info(environ)
+        path_info = base.get_path_info(environ)
         if not path_info.startswith('/'): # it must!
             return None
         class parsed_request(object):
             repo_name = path_info[1:].rstrip('/')
             query_string = environ['QUERY_STRING']
             action = None
             for qry in query_string.split('&'):
                 parts = qry.split('=', 1)
                 if len(parts) == 2 and parts[0] == 'cmd':
                     cmd = parts[1]
                     if cmd == 'batch':
                         hgarg = get_header_hgarg(environ)
                         if not hgarg.startswith('cmds='):
                             action = 'push' # paranoid and safe
                             break
                         action = 'pull'
                         for cmd_arg in hgarg[5:].split(';'):
                             cmd, _args = urllib.parse.unquote_plus(cmd_arg).split(' ', 1)
                             op = cmd_mapping.get(cmd, 'push')
                             if op != 'pull':
                                 assert op == 'push'

kallithea/config/middleware/wrapper.py

➞

Show inline comments

 # -*- 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/>.
 """
 kallithea.lib.middleware.wrapper
 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 kallithea.config.middleware.wrapper
 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 Wrap app to measure request and response time ... all the way to the response
 WSGI iterator has been closed.
 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: May 23, 2013
 :author: marcink
 :copyright: (c) 2013 RhodeCode GmbH, and others.
 :license: GPLv3, see LICENSE.md for more details.
 """
 import logging
 import time
-from kallithea.lib.base import _get_ip_addr, get_path_info
+from kallithea.controllers import base
 log = logging.getLogger(__name__)
 class Meter:
     def __init__(self, start_response):
         self._start_response = start_response
         self._start = time.time()
         self.status = None
         self._size = 0
     def duration(self):
         return time.time() - self._start
     def start_response(self, status, response_headers, exc_info=None):
         self.status = status
         write = self._start_response(status, response_headers, exc_info)
         def metered_write(s):
             self.measure(s)
             write(s)
         return metered_write
@@ @@ -70,33 +70,33 @@ class ResultIter: @@
         self._description = description
     def __iter__(self):
         return self
     def __next__(self):
         chunk = self._next()
         self._meter.measure(chunk)
         return chunk
     def close(self):
         self._result_close()
         log.info("%s responded %r after %.3fs with %s bytes", self._description, self._meter.status, self._meter.duration(), self._meter.size())
 class RequestWrapper(object):
     def __init__(self, app, config):
         self.application = app
         self.config = config
     def __call__(self, environ, start_response):
         meter = Meter(start_response)
         description = "Request from %s for %s" % (
             _get_ip_addr(environ),
             get_path_info(environ),
             base.get_ip_addr(environ),
             base.get_path_info(environ),
+        )
         log.info("%s received", description)
         try:
             result = self.application(environ, meter.start_response)
         finally:
             log.info("%s responding %r after %.3fs", description, meter.status, meter.duration())
         return ResultIter(result, meter, description)

kallithea/config/pre_receive_tmpl.py

➞

Show inline comments

deleted file

kallithea/controllers/admin/admin.py

➞

Show inline comments

@@ @@ -15,133 +15,134 @@ @@
 kallithea.controllers.admin.admin
 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 Controller for Admin panel of 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: Apr 7, 2010
 :author: marcink
 :copyright: (c) 2013 RhodeCode GmbH, and others.
 :license: GPLv3, see LICENSE.md for more details.
 """
 import logging
 from sqlalchemy.orm import joinedload
 from sqlalchemy.sql.expression import and_, func, or_
 from tg import request
 from tg import tmpl_context as c
 from whoosh import query
 from whoosh.qparser.dateparse import DateParserPlugin
 from whoosh.qparser.default import QueryParser
 from kallithea.controllers import base
 from kallithea.lib.auth import HasPermissionAnyDecorator, LoginRequired
 from kallithea.lib.base import BaseController, render
 from kallithea.lib.indexers import JOURNAL_SCHEMA
 from kallithea.lib.page import Page
 from kallithea.lib.utils2 import remove_prefix, remove_suffix, safe_int
-from kallithea.model.db import UserLog
+from kallithea.model import db
 log = logging.getLogger(__name__)
 def _journal_filter(user_log, search_term):
     """
     Filters sqlalchemy user_log based on search_term with whoosh Query language
     http://packages.python.org/Whoosh/querylang.html
     :param user_log:
     :param search_term:
     """
     log.debug('Initial search term: %r', search_term)
     qry = None
     if search_term:
         qp = QueryParser('repository', schema=JOURNAL_SCHEMA)
         qp.add_plugin(DateParserPlugin())
         qry = qp.parse(search_term)
         log.debug('Filtering using parsed query %r', qry)
     def wildcard_handler(col, wc_term):
         if wc_term.startswith('*') and not wc_term.endswith('*'):
             # postfix == endswith
             wc_term = remove_prefix(wc_term, prefix='*')
             return func.lower(col).endswith(func.lower(wc_term))
         elif wc_term.startswith('*') and wc_term.endswith('*'):
             # wildcard == ilike
             wc_term = remove_prefix(wc_term, prefix='*')
             wc_term = remove_suffix(wc_term, suffix='*')
             return func.lower(col).contains(func.lower(wc_term))
     def get_filterion(field, val, term):
         if field == 'repository':
             field = getattr(UserLog, 'repository_name')
+            field = getattr(db.UserLog, 'repository_name')
         elif field == 'ip':
             field = getattr(UserLog, 'user_ip')
+            field = getattr(db.UserLog, 'user_ip')
         elif field == 'date':
             field = getattr(UserLog, 'action_date')
+            field = getattr(db.UserLog, 'action_date')
         elif field == 'username':
             field = getattr(UserLog, 'username')
+            field = getattr(db.UserLog, 'username')
         else:
             field = getattr(UserLog, field)
+            field = getattr(db.UserLog, field)
         log.debug('filter field: %s val=>%s', field, val)
         # sql filtering
         if isinstance(term, query.Wildcard):
             return wildcard_handler(field, val)
         elif isinstance(term, query.Prefix):
             return func.lower(field).startswith(func.lower(val))
         elif isinstance(term, query.DateRange):
             return and_(field >= val[0], field <= val[1])
         return func.lower(field) == func.lower(val)
     if isinstance(qry, (query.And, query.Term, query.Prefix, query.Wildcard,
                         query.DateRange)):
         if not isinstance(qry, query.And):
             qry = [qry]
         for term in qry:
             assert term is not None, term
             field = term.fieldname
             val = (term.text if not isinstance(term, query.DateRange)
                    else [term.startdate, term.enddate])
             user_log = user_log.filter(get_filterion(field, val, term))
     elif isinstance(qry, query.Or):
         filters = []
         for term in qry:
             field = term.fieldname
             val = (term.text if not isinstance(term, query.DateRange)
                    else [term.startdate, term.enddate])
             filters.append(get_filterion(field, val, term))
         user_log = user_log.filter(or_(*filters))
     return user_log
 class AdminController(BaseController):
+class AdminController(base.BaseController):
     @LoginRequired(allow_default_user=True)
     def _before(self, *args, **kwargs):
         super(AdminController, self)._before(*args, **kwargs)
     @HasPermissionAnyDecorator('hg.admin')
     def index(self):
         users_log = UserLog.query() \
                 .options(joinedload(UserLog.user)) \
                 .options(joinedload(UserLog.repository))
         users_log = db.UserLog.query() \
                 .options(joinedload(db.UserLog.user)) \
                 .options(joinedload(db.UserLog.repository))
         # 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())
+        users_log = users_log.order_by(db.UserLog.action_date.desc())
         p = safe_int(request.GET.get('page'), 1)
         c.users_log = Page(users_log, page=p, items_per_page=10,
                            filter=c.search_term)
         if request.environ.get('HTTP_X_PARTIAL_XHR'):
             return render('admin/admin_log.html')
+            return base.render('admin/admin_log.html')
         return render('admin/admin.html')
+        return base.render('admin/admin.html')

kallithea/controllers/admin/auth_settings.py

➞

Show inline comments

@@ @@ -11,140 +11,138 @@ @@
+#
 # 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.controllers.admin.auth_settings
 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 pluggable authentication controller 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: Nov 26, 2010
 :author: akesterson
 """
 import logging
 import traceback
 import formencode.htmlfill
 from tg import request
 from tg import 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 auth_modules
 from kallithea.lib import helpers as h
 from kallithea.controllers import base
 from kallithea.lib import auth_modules, webutils
 from kallithea.lib.auth import HasPermissionAnyDecorator, LoginRequired
 from kallithea.lib.base import BaseController, render
 from kallithea.model.db import Setting
 from kallithea.lib.webutils import url
 from kallithea.model import db, meta
 from kallithea.model.forms import AuthSettingsForm
 from kallithea.model.meta import Session
 log = logging.getLogger(__name__)
 class AuthSettingsController(BaseController):
+class AuthSettingsController(base.BaseController):
     @LoginRequired()
     @HasPermissionAnyDecorator('hg.admin')
     def _before(self, *args, **kwargs):
         super(AuthSettingsController, self)._before(*args, **kwargs)
     def __load_defaults(self):
         c.available_plugins = [
             'kallithea.lib.auth_modules.auth_internal',
             'kallithea.lib.auth_modules.auth_container',
             'kallithea.lib.auth_modules.auth_ldap',
             'kallithea.lib.auth_modules.auth_crowd',
             'kallithea.lib.auth_modules.auth_pam'
+        ]
         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 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_%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)
+                setting = db.Setting.get_by_name(fullname)
                 if setting is not None:
                     c.defaults[fullname] = setting.app_settings_value
         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('defaults: %s', defaults)
         return formencode.htmlfill.render(
             render('admin/auth/auth_settings.html'),
+            base.render('admin/auth/auth_settings.html'),
             defaults=c.defaults,
             errors=errors,
             prefix_error=False,
             encoding="UTF-8",
             force_defaults=False)
     def index(self):
         self.__load_defaults()
         return self.__render(defaults=None, errors=None)
     def auth_settings(self):
         """POST create and store auth settings"""
         self.__load_defaults()
         log.debug("POST Result: %s", dict(request.POST))
         # First, parse only the plugin list (not the plugin settings).
         _auth_plugins_validator = AuthSettingsForm([]).fields['auth_plugins']
         try:
             new_enabled_plugins = _auth_plugins_validator.to_python(request.POST.get('auth_plugins'))
         except formencode.Invalid:
             # User provided an invalid plugin list. Just fall back to
             # the list of currently enabled plugins. (We'll re-validate
             # and show an error message to the user, below.)
             pass
         else:
             # Hide plugins that the user has asked to be disabled, but
             # do not show plugins that the user has asked to be enabled
             # (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_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_plugin_names)()
         try:
             form_result = _form.to_python(dict(request.POST))
             for k, v in form_result.items():
                 if k == 'auth_plugins':
                     # we want to store it comma separated inside our settings
                     v = ','.join(v)
                 log.debug("%s = %s", k, str(v))
                 setting = Setting.create_or_update(k, v)
             Session().commit()
             h.flash(_('Auth settings updated successfully'),
                 setting = db.Setting.create_or_update(k, v)
             meta.Session().commit()
             webutils.flash(_('Auth settings updated successfully'),
                        category='success')
         except formencode.Invalid as errors:
             log.error(traceback.format_exc())
             e = errors.error_dict or {}
             return self.__render(
                 defaults=errors.value,
                 errors=e,
+            )
         except Exception:
             log.error(traceback.format_exc())
-            h.flash(_('error occurred during update of auth settings'),
+            webutils.flash(_('error occurred during update of auth settings'),
                     category='error')
         raise HTTPFound(location=url('auth_home'))

kallithea/controllers/admin/defaults.py

➞

Show inline comments

@@ @@ -13,80 +13,79 @@ @@
 # along with this program.  If not, see <http://www.gnu.org/licenses/>.
 """
 kallithea.controllers.admin.defaults
 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 default settings controller 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: Apr 27, 2010
 :author: marcink
 :copyright: (c) 2013 RhodeCode GmbH, and others.
 :license: GPLv3, see LICENSE.md for more details.
 """
 import logging
 import traceback
 import formencode
 from formencode import htmlfill
 from tg import request
 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.controllers import base
 from kallithea.lib import webutils
 from kallithea.lib.auth import HasPermissionAnyDecorator, LoginRequired
 from kallithea.lib.base import BaseController, render
 from kallithea.model.db import Setting
 from kallithea.lib.webutils import url
 from kallithea.model import db, meta
 from kallithea.model.forms import DefaultsForm
 from kallithea.model.meta import Session
 log = logging.getLogger(__name__)
 class DefaultsController(BaseController):
+class DefaultsController(base.BaseController):
     @LoginRequired()
     @HasPermissionAnyDecorator('hg.admin')
     def _before(self, *args, **kwargs):
         super(DefaultsController, self)._before(*args, **kwargs)
     def index(self, format='html'):
         defaults = Setting.get_default_repo_settings()
+        defaults = db.Setting.get_default_repo_settings()
         return htmlfill.render(
             render('admin/defaults/defaults.html'),
+            base.render('admin/defaults/defaults.html'),
             defaults=defaults,
             encoding="UTF-8",
             force_defaults=False
+        )
     def update(self, id):
         _form = DefaultsForm()()
         try:
             form_result = _form.to_python(dict(request.POST))
             for k, v in form_result.items():
                 setting = Setting.create_or_update(k, v)
             Session().commit()
             h.flash(_('Default settings updated successfully'),
                 setting = db.Setting.create_or_update(k, v)
             meta.Session().commit()
             webutils.flash(_('Default settings updated successfully'),
                     category='success')
         except formencode.Invalid as errors:
             defaults = errors.value
             return htmlfill.render(
                 render('admin/defaults/defaults.html'),
+                base.render('admin/defaults/defaults.html'),
                 defaults=defaults,
                 errors=errors.error_dict or {},
                 prefix_error=False,
                 encoding="UTF-8",
                 force_defaults=False)
         except Exception:
             log.error(traceback.format_exc())
-            h.flash(_('Error occurred during update of defaults'),
+            webutils.flash(_('Error occurred during update of defaults'),
                     category='error')
         raise HTTPFound(location=url('defaults'))

kallithea/controllers/admin/gists.py

➞

Show inline comments

@@ @@ -14,254 +14,252 @@ @@
 """
 kallithea.controllers.admin.gists
 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 gist controller 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: May 9, 2013
 :author: marcink
 :copyright: (c) 2013 RhodeCode GmbH, and others.
 :license: GPLv3, see LICENSE.md for more details.
 """
 import logging
 import traceback
 import formencode.htmlfill
 from sqlalchemy.sql.expression import or_
 from tg import request, response
 from tg import tmpl_context as c
 from tg.i18n import ugettext as _
 from webob.exc import HTTPForbidden, HTTPFound, HTTPNotFound
 from kallithea.config.routing import url
 from kallithea.lib import helpers as h
 from kallithea.controllers import base
 from kallithea.lib import auth, webutils
 from kallithea.lib.auth import LoginRequired
 from kallithea.lib.base import BaseController, jsonify, render
 from kallithea.lib.page import Page
 from kallithea.lib.utils2 import safe_int, safe_str, time_to_datetime
 from kallithea.lib.vcs.exceptions import NodeNotChangedError, VCSError
 from kallithea.model.db import Gist
 from kallithea.lib.webutils import url
 from kallithea.model import db, meta
 from kallithea.model.forms import GistForm
 from kallithea.model.gist import GistModel
 from kallithea.model.meta import Session
 log = logging.getLogger(__name__)
 class GistsController(BaseController):
     """REST Controller styled on the Atom Publishing Protocol"""
 class GistsController(base.BaseController):
     def __load_defaults(self, extra_values=None):
         c.lifetime_values = [
             (str(-1), _('Forever')),
             (str(5), _('5 minutes')),
             (str(60), _('1 hour')),
             (str(60 * 24), _('1 day')),
             (str(60 * 24 * 30), _('1 month')),
+        ]
         if extra_values:
             c.lifetime_values.append(extra_values)
         c.lifetime_options = [(c.lifetime_values, _("Lifetime"))]
     @LoginRequired(allow_default_user=True)
     def index(self):
         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
         url_params = {}
         if c.show_public:
             url_params['public'] = 1
         elif c.show_private:
             url_params['private'] = 1
         gists = Gist().query() \
+        gists = db.Gist().query() \
             .filter_by(is_expired=False) \
             .order_by(Gist.created_on.desc())
+            .order_by(db.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.owner_id == request.authuser.user_id)
             gists = gists.filter(db.Gist.gist_type == db.Gist.GIST_PRIVATE) \
                              .filter(db.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.owner_id == request.authuser.user_id)
             gists = gists.filter(db.Gist.gist_type == db.Gist.GIST_PUBLIC) \
                              .filter(db.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.owner_id == request.authuser.user_id)
             gists = gists.filter(or_(db.Gist.gist_type == db.Gist.GIST_PUBLIC,
                                      db.Gist.gist_type == db.Gist.GIST_PRIVATE)) \
                              .filter(db.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)
+            gists = gists.filter(db.Gist.gist_type == db.Gist.GIST_PUBLIC)
         c.gists = gists
         p = safe_int(request.GET.get('page'), 1)
         c.gists_pager = Page(c.gists, page=p, items_per_page=10,
                              **url_params)
         return render('admin/gists/index.html')
+        return base.render('admin/gists/index.html')
     @LoginRequired()
     def create(self):
         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
             filename = form_result['filename'] or Gist.DEFAULT_FILENAME
+            filename = form_result['filename'] or db.Gist.DEFAULT_FILENAME
             nodes = {
                 filename: {
                     'content': form_result['content'],
                     'lexer': form_result['mimetype']  # None is autodetect
+                }
+            }
             _public = form_result['public']
             gist_type = Gist.GIST_PUBLIC if _public else Gist.GIST_PRIVATE
+            gist_type = db.Gist.GIST_PUBLIC if _public else db.Gist.GIST_PRIVATE
             gist = GistModel().create(
                 description=form_result['description'],
                 owner=request.authuser.user_id,
                 ip_addr=request.ip_addr,
                 gist_mapping=nodes,
                 gist_type=gist_type,
                 lifetime=form_result['lifetime']
+            )
             Session().commit()
+            meta.Session().commit()
             new_gist_id = gist.gist_access_id
         except formencode.Invalid as errors:
             defaults = errors.value
             return formencode.htmlfill.render(
                 render('admin/gists/new.html'),
+                base.render('admin/gists/new.html'),
                 defaults=defaults,
                 errors=errors.error_dict or {},
                 prefix_error=False,
                 encoding="UTF-8",
                 force_defaults=False)
         except Exception as e:
             log.error(traceback.format_exc())
-            h.flash(_('Error occurred during gist creation'), category='error')
+            webutils.flash(_('Error occurred during gist creation'), category='error')
             raise HTTPFound(location=url('new_gist'))
         raise HTTPFound(location=url('gist', gist_id=new_gist_id))
     @LoginRequired()
     def new(self, format='html'):
         self.__load_defaults()
         return render('admin/gists/new.html')
+        return base.render('admin/gists/new.html')
     @LoginRequired()
     def delete(self, gist_id):
         gist = GistModel().get_gist(gist_id)
         owner = gist.owner_id == request.authuser.user_id
-        if h.HasPermissionAny('hg.admin')() or owner:
+        if auth.HasPermissionAny('hg.admin')() or owner:
             GistModel().delete(gist)
             Session().commit()
             h.flash(_('Deleted gist %s') % gist.gist_access_id, category='success')
             meta.Session().commit()
             webutils.flash(_('Deleted gist %s') % gist.gist_access_id, category='success')
         else:
             raise HTTPForbidden()
         raise HTTPFound(location=url('gists'))
     @LoginRequired(allow_default_user=True)
     def show(self, gist_id, revision='tip', format='html', f_path=None):
         c.gist = Gist.get_or_404(gist_id)
+        c.gist = db.Gist.get_or_404(gist_id)
         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)
         except VCSError:
             log.error(traceback.format_exc())
             raise HTTPNotFound()
         if format == 'raw':
             content = '\n\n'.join(
                 safe_str(f.content)
                 for f in c.files if (f_path is None or f.path == f_path)
+            )
             response.content_type = 'text/plain'
             return content
         return render('admin/gists/show.html')
+        return base.render('admin/gists/show.html')
     @LoginRequired()
     def edit(self, gist_id, format='html'):
         c.gist = Gist.get_or_404(gist_id)
+        c.gist = db.Gist.get_or_404(gist_id)
         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:
             log.error(traceback.format_exc())
             raise HTTPNotFound()
         self.__load_defaults(extra_values=('0', _('Unmodified')))
         rendered = render('admin/gists/edit.html')
+        rendered = base.render('admin/gists/edit.html')
         if request.POST:
             rpost = request.POST
             nodes = {}
             for org_filename, filename, mimetype, content in zip(
                                                     rpost.getall('org_files'),
                                                     rpost.getall('files'),
                                                     rpost.getall('mimetypes'),
                                                     rpost.getall('contents')):
                 nodes[org_filename] = {
                     'org_filename': org_filename,
                     'filename': filename,
                     'content': content,
                     'lexer': mimetype,
+                }
             try:
                 GistModel().update(
                     gist=c.gist,
                     description=rpost['description'],
                     owner=c.gist.owner, # FIXME: request.authuser.user_id ?
                     ip_addr=request.ip_addr,
                     gist_mapping=nodes,
                     gist_type=c.gist.gist_type,
                     lifetime=rpost['lifetime']
+                )
                 Session().commit()
                 h.flash(_('Successfully updated gist content'), category='success')
                 meta.Session().commit()
                 webutils.flash(_('Successfully updated gist content'), category='success')
             except NodeNotChangedError:
                 # raised if nothing was changed in repo itself. We anyway then
                 # store only DB stuff for gist
                 Session().commit()
                 h.flash(_('Successfully updated gist data'), category='success')
                 meta.Session().commit()
                 webutils.flash(_('Successfully updated gist data'), category='success')
             except Exception:
                 log.error(traceback.format_exc())
-                h.flash(_('Error occurred during update of gist %s') % gist_id,
+                webutils.flash(_('Error occurred during update of gist %s') % gist_id,
                         category='error')
             raise HTTPFound(location=url('gist', gist_id=gist_id))
         return rendered
     @LoginRequired()
     @jsonify
+    @base.jsonify
     def check_revision(self, gist_id):
         c.gist = Gist.get_or_404(gist_id)
+        c.gist = db.Gist.get_or_404(gist_id)
         last_rev = c.gist.scm_instance.get_changeset()
         success = True
         revision = request.POST.get('revision')
         # 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)
             # our gist has newer version than we
             success = False
         return {'success': success}

kallithea/controllers/admin/my_account.py

➞

Show inline comments

@@ @@ -14,283 +14,276 @@ @@
 """
 kallithea.controllers.admin.my_account
 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 my account controller for Kallithea admin
 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: August 20, 2013
 :author: marcink
 :copyright: (c) 2013 RhodeCode GmbH, and others.
 :license: GPLv3, see LICENSE.md for more details.
 """
 import logging
 import traceback
 import formencode
 from formencode import htmlfill
 from tg import request
 from tg import 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 auth_modules
 from kallithea.lib import helpers as h
 from kallithea.controllers import base
 from kallithea.lib import auth_modules, webutils
 from kallithea.lib.auth import AuthUser, LoginRequired
 from kallithea.lib.base import BaseController, IfSshEnabled, render
 from kallithea.lib.utils2 import generate_api_key, safe_int
 from kallithea.lib.webutils import url
 from kallithea.model import db, meta
 from kallithea.model.api_key import ApiKeyModel
 from kallithea.model.db import Repository, User, UserEmailMap, UserFollowing
 from kallithea.model.forms import PasswordChangeForm, UserForm
 from kallithea.model.meta import Session
 from kallithea.model.repo import RepoModel
 from kallithea.model.ssh_key import SshKeyModel, SshKeyModelException
 from kallithea.model.user import UserModel
 log = logging.getLogger(__name__)
 class MyAccountController(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('setting', 'settings', controller='admin/settings',
     #         path_prefix='/admin', name_prefix='admin_')
 class MyAccountController(base.BaseController):
     @LoginRequired()
     def _before(self, *args, **kwargs):
         super(MyAccountController, self)._before(*args, **kwargs)
     def __load_data(self):
         c.user = User.get(request.authuser.user_id)
+        c.user = db.User.get(request.authuser.user_id)
         if c.user.is_default_user:
-            h.flash(_("You can't edit this user since it's"
+            webutils.flash(_("You can't edit this user since it's"
                       " crucial for entire application"), category='warning')
             raise HTTPFound(location=url('users'))
     def _load_my_repos_data(self, watched=False):
         if watched:
             admin = False
             repos_list = Session().query(Repository) \
                          .join(UserFollowing) \
                          .filter(UserFollowing.user_id ==
             repos_list = meta.Session().query(db.Repository) \
                          .join(db.UserFollowing) \
                          .filter(db.UserFollowing.user_id ==
                                  request.authuser.user_id).all()
         else:
             admin = True
             repos_list = Session().query(Repository) \
                          .filter(Repository.owner_id ==
             repos_list = meta.Session().query(db.Repository) \
                          .filter(db.Repository.owner_id ==
                                  request.authuser.user_id).all()
         return RepoModel().get_repos_as_dict(repos_list, admin=admin)
     def my_account(self):
         c.active = 'profile'
         self.__load_data()
         c.perm_user = AuthUser(user_id=request.authuser.user_id)
         managed_fields = auth_modules.get_managed_fields(c.user)
-        def_user_perms = AuthUser(dbuser=User.get_default_user()).permissions['global']
+        def_user_perms = AuthUser(dbuser=db.User.get_default_user()).global_permissions
         if 'hg.register.none' in def_user_perms:
             managed_fields.extend(['username', 'firstname', 'lastname', 'email'])
         c.readonly = lambda n: 'readonly' if n in managed_fields else None
         defaults = c.user.get_dict()
         update = False
         if request.POST:
             _form = UserForm(edit=True,
                              old_data={'user_id': request.authuser.user_id,
                                        'email': request.authuser.email})()
             form_result = {}
             try:
                 post_data = dict(request.POST)
                 post_data['new_password'] = ''
                 post_data['password_confirmation'] = ''
                 form_result = _form.to_python(post_data)
                 # skip updating those attrs for my account
                 skip_attrs = ['admin', 'active', 'extern_type', 'extern_name',
                               'new_password', 'password_confirmation',
                              ] + managed_fields
                 UserModel().update(request.authuser.user_id, form_result,
                                    skip_attrs=skip_attrs)
-                h.flash(_('Your account was updated successfully'),
+                webutils.flash(_('Your account was updated successfully'),
                         category='success')
                 Session().commit()
+                meta.Session().commit()
                 update = True
             except formencode.Invalid as errors:
                 return htmlfill.render(
                     render('admin/my_account/my_account.html'),
+                    base.render('admin/my_account/my_account.html'),
                     defaults=errors.value,
                     errors=errors.error_dict or {},
                     prefix_error=False,
                     encoding="UTF-8",
                     force_defaults=False)
             except Exception:
                 log.error(traceback.format_exc())
-                h.flash(_('Error occurred during update of user %s')
+                webutils.flash(_('Error occurred during update of user %s')
                         % form_result.get('username'), category='error')
         if update:
             raise HTTPFound(location='my_account')
         return htmlfill.render(
             render('admin/my_account/my_account.html'),
+            base.render('admin/my_account/my_account.html'),
             defaults=defaults,
             encoding="UTF-8",
             force_defaults=False)
     def my_account_password(self):
         c.active = 'password'
         self.__load_data()
         managed_fields = auth_modules.get_managed_fields(c.user)
         c.can_change_password = 'password' not in managed_fields
         if request.POST and c.can_change_password:
             _form = PasswordChangeForm(request.authuser.username)()
             try:
                 form_result = _form.to_python(request.POST)
                 UserModel().update(request.authuser.user_id, form_result)
                 Session().commit()
                 h.flash(_("Successfully updated password"), category='success')
                 meta.Session().commit()
                 webutils.flash(_("Successfully updated password"), category='success')
             except formencode.Invalid as errors:
                 return htmlfill.render(
                     render('admin/my_account/my_account.html'),
+                    base.render('admin/my_account/my_account.html'),
                     defaults=errors.value,
                     errors=errors.error_dict or {},
                     prefix_error=False,
                     encoding="UTF-8",
                     force_defaults=False)
             except Exception:
                 log.error(traceback.format_exc())
-                h.flash(_('Error occurred during update of user password'),
+                webutils.flash(_('Error occurred during update of user password'),
                         category='error')
         return render('admin/my_account/my_account.html')
+        return base.render('admin/my_account/my_account.html')
     def my_account_repos(self):
         c.active = 'repos'
         self.__load_data()
         # data used to render the grid
         c.data = self._load_my_repos_data()
         return render('admin/my_account/my_account.html')
+        return base.render('admin/my_account/my_account.html')
     def my_account_watched(self):
         c.active = 'watched'
         self.__load_data()
         # data used to render the grid
         c.data = self._load_my_repos_data(watched=True)
         return render('admin/my_account/my_account.html')
+        return base.render('admin/my_account/my_account.html')
     def my_account_perms(self):
         c.active = 'perms'
         self.__load_data()
         c.perm_user = AuthUser(user_id=request.authuser.user_id)
         return render('admin/my_account/my_account.html')
+        return base.render('admin/my_account/my_account.html')
     def my_account_emails(self):
         c.active = 'emails'
         self.__load_data()
         c.user_email_map = UserEmailMap.query() \
             .filter(UserEmailMap.user == c.user).all()
         return render('admin/my_account/my_account.html')
         c.user_email_map = db.UserEmailMap.query() \
             .filter(db.UserEmailMap.user == c.user).all()
         return base.render('admin/my_account/my_account.html')
     def my_account_emails_add(self):
         email = request.POST.get('new_email')
         try:
             UserModel().add_extra_email(request.authuser.user_id, email)
             Session().commit()
             h.flash(_("Added email %s to user") % email, category='success')
             meta.Session().commit()
             webutils.flash(_("Added email %s to user") % email, category='success')
         except formencode.Invalid as error:
             msg = error.error_dict['email']
-            h.flash(msg, category='error')
+            webutils.flash(msg, category='error')
         except Exception:
             log.error(traceback.format_exc())
-            h.flash(_('An error occurred during email saving'),
+            webutils.flash(_('An error occurred during email saving'),
                     category='error')
         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(request.authuser.user_id, email_id)
         Session().commit()
         h.flash(_("Removed email from user"), category='success')
         meta.Session().commit()
         webutils.flash(_("Removed email from user"), category='success')
         raise HTTPFound(location=url('my_account_emails'))
     def my_account_api_keys(self):
         c.active = 'api_keys'
         self.__load_data()
         show_expired = True
         c.lifetime_values = [
             (str(-1), _('Forever')),
             (str(5), _('5 minutes')),
             (str(60), _('1 hour')),
             (str(60 * 24), _('1 day')),
             (str(60 * 24 * 30), _('1 month')),
+        ]
         c.lifetime_options = [(c.lifetime_values, _("Lifetime"))]
         c.user_api_keys = ApiKeyModel().get_api_keys(request.authuser.user_id,
                                                      show_expired=show_expired)
         return render('admin/my_account/my_account.html')
+        return base.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(request.authuser.user_id, description, lifetime)
         Session().commit()
         h.flash(_("API key successfully created"), category='success')
         meta.Session().commit()
         webutils.flash(_("API key successfully created"), category='success')
         raise HTTPFound(location=url('my_account_api_keys'))
     def my_account_api_keys_delete(self):
         api_key = request.POST.get('del_api_key')
         if request.POST.get('del_api_key_builtin'):
             user = User.get(request.authuser.user_id)
+            user = db.User.get(request.authuser.user_id)
             user.api_key = generate_api_key()
             Session().commit()
             h.flash(_("API key successfully reset"), category='success')
             meta.Session().commit()
             webutils.flash(_("API key successfully reset"), category='success')
         elif api_key:
             ApiKeyModel().delete(api_key, request.authuser.user_id)
             Session().commit()
             h.flash(_("API key successfully deleted"), category='success')
             meta.Session().commit()
             webutils.flash(_("API key successfully deleted"), category='success')
         raise HTTPFound(location=url('my_account_api_keys'))
     @IfSshEnabled
+    @base.IfSshEnabled
     def my_account_ssh_keys(self):
         c.active = 'ssh_keys'
         self.__load_data()
         c.user_ssh_keys = SshKeyModel().get_ssh_keys(request.authuser.user_id)
         return render('admin/my_account/my_account.html')
+        return base.render('admin/my_account/my_account.html')
     @IfSshEnabled
+    @base.IfSshEnabled
     def my_account_ssh_keys_add(self):
         description = request.POST.get('description')
         public_key = request.POST.get('public_key')
         try:
             new_ssh_key = SshKeyModel().create(request.authuser.user_id,
                                                description, public_key)
             Session().commit()
+            meta.Session().commit()
             SshKeyModel().write_authorized_keys()
-            h.flash(_("SSH key %s successfully added") % new_ssh_key.fingerprint, category='success')
+            webutils.flash(_("SSH key %s successfully added") % new_ssh_key.fingerprint, category='success')
         except SshKeyModelException as e:
-            h.flash(e.args[0], category='error')
+            webutils.flash(e.args[0], category='error')
         raise HTTPFound(location=url('my_account_ssh_keys'))
     @IfSshEnabled
+    @base.IfSshEnabled
     def my_account_ssh_keys_delete(self):
         fingerprint = request.POST.get('del_public_key_fingerprint')
         try:
             SshKeyModel().delete(fingerprint, request.authuser.user_id)
             Session().commit()
+            meta.Session().commit()
             SshKeyModel().write_authorized_keys()
-            h.flash(_("SSH key successfully deleted"), category='success')
+            webutils.flash(_("SSH key successfully deleted"), category='success')
         except SshKeyModelException as e:
-            h.flash(e.args[0], category='error')
+            webutils.flash(e.args[0], category='error')
         raise HTTPFound(location=url('my_account_ssh_keys'))

kallithea/controllers/admin/permissions.py

➞

Show inline comments

@@ @@ -15,185 +15,168 @@ @@
 kallithea.controllers.admin.permissions
 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 permissions controller 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: Apr 27, 2010
 :author: marcink
 :copyright: (c) 2013 RhodeCode GmbH, and others.
 :license: GPLv3, see LICENSE.md for more details.
 """
 import logging
 import traceback
 import formencode
 from formencode import htmlfill
 from tg import request
 from tg import 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.controllers import base
 from kallithea.lib import webutils
 from kallithea.lib.auth import AuthUser, HasPermissionAnyDecorator, LoginRequired
 from kallithea.lib.base import BaseController, render
 from kallithea.model.db import User, UserIpMap
 from kallithea.lib.webutils import url
 from kallithea.model import db, meta
 from kallithea.model.forms import DefaultPermissionsForm
 from kallithea.model.meta import Session
 from kallithea.model.permission import PermissionModel
 log = logging.getLogger(__name__)
 class PermissionsController(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('permission', 'permissions')
 class PermissionsController(base.BaseController):
     @LoginRequired()
     @HasPermissionAnyDecorator('hg.admin')
     def _before(self, *args, **kwargs):
         super(PermissionsController, self)._before(*args, **kwargs)
     def __load_data(self):
         # Permissions for the Default user on new repositories
         c.repo_perms_choices = [('repository.none', _('None'),),
                                    ('repository.read', _('Read'),),
                                    ('repository.write', _('Write'),),
                                    ('repository.admin', _('Admin'),)]
         # Permissions for the Default user on new repository groups
         c.group_perms_choices = [('group.none', _('None'),),
                                  ('group.read', _('Read'),),
                                  ('group.write', _('Write'),),
                                  ('group.admin', _('Admin'),)]
         # Permissions for the Default user on new user groups
         c.user_group_perms_choices = [('usergroup.none', _('None'),),
                                       ('usergroup.read', _('Read'),),
                                       ('usergroup.write', _('Write'),),
                                       ('usergroup.admin', _('Admin'),)]
         # Registration - allow new Users to create an account
         c.register_choices = [
             ('hg.register.none',
                 _('Disabled')),
             ('hg.register.manual_activate',
                 _('Allowed with manual account activation')),
             ('hg.register.auto_activate',
                 _('Allowed with automatic account activation')), ]
+        # External auth account activation
         c.extern_activate_choices = [
             ('hg.extern_activate.manual', _('Manual activation of external account')),
             ('hg.extern_activate.auto', _('Automatic activation of external account')),
+        ]
+        # Top level repository creation
         c.repo_create_choices = [('hg.create.none', _('Disabled')),
                                  ('hg.create.repository', _('Enabled'))]
         c.repo_create_on_write_choices = [
             ('hg.create.write_on_repogroup.true', _('Enabled')),
             ('hg.create.write_on_repogroup.false', _('Disabled')),
+        ]
         # User group creation
         c.user_group_create_choices = [('hg.usergroup.create.false', _('Disabled')),
                                        ('hg.usergroup.create.true', _('Enabled'))]
         c.repo_group_create_choices = [('hg.repogroup.create.false', _('Disabled')),
                                        ('hg.repogroup.create.true', _('Enabled'))]
         # Repository forking:
         c.fork_choices = [('hg.fork.none', _('Disabled')),
                           ('hg.fork.repository', _('Enabled'))]
     def permission_globals(self):
         c.active = 'globals'
         self.__load_data()
         if request.POST:
             _form = DefaultPermissionsForm(
                 [x[0] for x in c.repo_perms_choices],
                 [x[0] for x in c.group_perms_choices],
                 [x[0] for x in c.user_group_perms_choices],
                 [x[0] for x in c.repo_create_choices],
                 [x[0] for x in c.repo_create_on_write_choices],
                 [x[0] for x in c.repo_group_create_choices],
                 [x[0] for x in c.user_group_create_choices],
                 [x[0] for x in c.fork_choices],
                 [x[0] for x in c.register_choices],
                 [x[0] for x in c.extern_activate_choices])()
             try:
                 form_result = _form.to_python(dict(request.POST))
                 form_result.update({'perm_user_name': 'default'})
                 PermissionModel().update(form_result)
                 Session().commit()
                 h.flash(_('Global permissions updated successfully'),
                 meta.Session().commit()
                 webutils.flash(_('Global permissions updated successfully'),
                         category='success')
             except formencode.Invalid as errors:
                 defaults = errors.value
                 return htmlfill.render(
                     render('admin/permissions/permissions.html'),
+                    base.render('admin/permissions/permissions.html'),
                     defaults=defaults,
                     errors=errors.error_dict or {},
                     prefix_error=False,
                     encoding="UTF-8",
                     force_defaults=False)
             except Exception:
                 log.error(traceback.format_exc())
-                h.flash(_('Error occurred during update of permissions'),
+                webutils.flash(_('Error occurred during update of permissions'),
                         category='error')
             raise HTTPFound(location=url('admin_permissions'))
         c.user = User.get_default_user()
+        c.user = db.User.get_default_user()
         defaults = {'anonymous': c.user.active}
         for p in c.user.user_perms:
             if p.permission.permission_name.startswith('repository.'):
                 defaults['default_repo_perm'] = p.permission.permission_name
             if p.permission.permission_name.startswith('group.'):
                 defaults['default_group_perm'] = p.permission.permission_name
             if p.permission.permission_name.startswith('usergroup.'):
                 defaults['default_user_group_perm'] = p.permission.permission_name
             if p.permission.permission_name.startswith('hg.create.write_on_repogroup.'):
                 defaults['create_on_write'] = p.permission.permission_name
             elif p.permission.permission_name.startswith('hg.create.'):
                 defaults['default_repo_create'] = p.permission.permission_name
             if p.permission.permission_name.startswith('hg.repogroup.'):
                 defaults['default_repo_group_create'] = p.permission.permission_name
             if p.permission.permission_name.startswith('hg.usergroup.'):
                 defaults['default_user_group_create'] = p.permission.permission_name
             if p.permission.permission_name.startswith('hg.register.'):
                 defaults['default_register'] = p.permission.permission_name
             if p.permission.permission_name.startswith('hg.extern_activate.'):
                 defaults['default_extern_activate'] = p.permission.permission_name
             if p.permission.permission_name.startswith('hg.fork.'):
                 defaults['default_fork'] = p.permission.permission_name
         return htmlfill.render(
             render('admin/permissions/permissions.html'),
+            base.render('admin/permissions/permissions.html'),
             defaults=defaults,
             encoding="UTF-8",
             force_defaults=False)
     def permission_ips(self):
         c.active = 'ips'
         c.user = User.get_default_user()
         c.user_ip_map = UserIpMap.query() \
                         .filter(UserIpMap.user == c.user).all()
         c.user = db.User.get_default_user()
         c.user_ip_map = db.UserIpMap.query() \
                         .filter(db.UserIpMap.user == c.user).all()
         return render('admin/permissions/permissions.html')
+        return base.render('admin/permissions/permissions.html')
     def permission_perms(self):
         c.active = 'perms'
         c.user = User.get_default_user()
+        c.user = db.User.get_default_user()
         c.perm_user = AuthUser(dbuser=c.user)
         return render('admin/permissions/permissions.html')
+        return base.render('admin/permissions/permissions.html')

Changeset was too big and was cut off... Show full diff anyway

0 comments (0 inline, 0 general)