Changeset - 12b47803189f
Parent rev.
Child rev.
[Not reviewed]
stable
0 21 0
Søren Løvborg - 10 years ago 2015-09-11 13:00:47
sorenl@unity3d.com
cleanup: use example.com for tests and examples

example.com is explicitly reserved for this purpose. Using that means
we won't accidentally hammer a real server or real email address if an
example value escapes into the wild, e.g. in an automated test.

The domain "kallithea.example.com" has been used throughout to refer to the
example Kallithea server.
21 files changed with 124 insertions and 124 deletions:
development.ini
6
6
docs/api/api.rst
1
1
docs/setup.rst
12
12
docs/usage/general.rst
4
4
kallithea/bin/kallithea_api.py
1
1
kallithea/bin/kallithea_gist.py
1
1
kallithea/bin/ldap_sync.conf
4
4
kallithea/bin/template.ini.mako
6
6
kallithea/config/deployment.ini_tmpl
6
6
kallithea/lib/rcmail/response.py
1
1
kallithea/tests/__init__.py
3
3
kallithea/tests/api/api_base.py
6
6
kallithea/tests/functional/test_admin_users.py
3
3
kallithea/tests/functional/test_files.py
1
1
kallithea/tests/functional/test_login.py
5
5
kallithea/tests/functional/test_my_account.py
4
4
kallithea/tests/other/manual_test_vcs_operations.py
2
2
kallithea/tests/other/test_libs.py
33
33
kallithea/tests/scripts/manual_test_concurrency.py
1
1
kallithea/tests/test.ini
6
6
kallithea/tests/vcs/test_utils.py
18
18
0 comments (0 inline, 0 general)
development.ini
➞
Show inline comments
 
################################################################################
 
################################################################################
 
# Kallithea - Development config:                                              #
 
# listening on *:5000                                                          #
 
# sqlite and kallithea.db                                                      #
 
# initial_repo_scan = true                                                     #
 
# set debug = true                                                             #
 
# verbose and colorful logging                                                 #
 
#                                                                              #
 
# The %(here)s variable will be replaced with the parent directory of this file#
 
################################################################################
 
################################################################################
 

			




	
	
	
		
 
[DEFAULT]

			




	
	
	
		
 
debug = true

			




	
	
	
		
 
pdebug = false

			




	
	
	
		
 

			




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

			




	
	
	
		
 
## Email settings                                                             ##

			




	
	
	
		
 
##                                                                            ##

			




	
	
	
		
 
## Refer to the documentation ("Email settings") for more details.            ##

			




	
	
	
		
 
##                                                                            ##

			




	
	
	
		
 
## It is recommended to use a valid sender address that passes access         ##

			




	
	
	
		
 
## validation and spam filtering in mail servers.                             ##

			




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

			




	
	
	
		
 

			




	
	
	
		
 
## 'From' header for application emails. You can optionally add a name.

			




	
	
	
		
 
## Default:

			




	
	
	
		
 
#app_email_from = Kallithea

			




	
	
	
		
 
## Examples:

			




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

			




	
	
	
		
 
#app_email_from = kallithea-noreply@example.com

			




	
	
	
		
 

			




	
	
	
		
 
## Subject prefix for application emails.

			




	
	
	
		
 
## A space between this prefix and the real subject is automatically added.

			




	
	
	
		
 
## Default:

			




	
	
	
		
 
#email_prefix =

			




	
	
	
		
 
## Example:

			




	
	
	
		
 
#email_prefix = [Kallithea]

			




	
	
	
		
 

			




	
	
	
		
 
## Recipients for error emails and fallback recipients of application mails.

			




	
	
	
		
 
## Multiple addresses can be specified, space-separated.

			




	
	
	
		
 
## Only addresses are allowed, do not add any name part.

			




	
	
	
		
 
## Default:

			




	
	
	
		
 
#email_to =

			




	
	
	
		
 
## Examples:

			




	
	
	
		
 
#email_to = admin@example.com

			




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

			




	
	
	
		
 

			




	
	
	
		
 
## 'From' header for error emails. You can optionally add a name.

			




	
	
	
		
 
## Default:

			




	
	
	
		
 
#error_email_from = pylons@yourapp.com

			




	
	
	
		
 
## Examples:

			




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

			




	
	
	
		
 
#error_email_from = paste_error@example.com

			




	
	
	
		
 

			




	
	
	
		
 
## SMTP server settings

			




	
	
	
		
 
## Only smtp_server is mandatory. All other settings take the specified default

			




	
	
	
		
 
## values.

			




	
	
	
		
 
#smtp_server = mail.server.com

			




	
	
	
		
 
#smtp_server = smtp.example.com

			




	
	
	
		
 
#smtp_username =

			




	
	
	
		
 
#smtp_password =

			




	
	
	
		
 
#smtp_port = 25

			




	
	
	
		
 
#smtp_use_tls = false

			




	
	
	
		
 
#smtp_use_ssl = false

			




	
	
	
		
 
## SMTP authentication parameters to use (e.g. LOGIN PLAIN CRAM-MD5, etc.).

			




	
	
	
		
 
## If empty, use any of the authentication parameters supported by the server.

			




	
	
	
		
 
#smtp_auth =

			




	
	
	
		
 

			




	
	
	
		
 
[server:main]

			




	
	
	
		
 
## PASTE ##

			




	
	
	
		
 
#use = egg:Paste#http

			




	
	
	
		
 
## nr of worker threads to spawn

			




	
	
	
		
 
#threadpool_workers = 5

			




	
	
	
		
 
## max request before thread respawn

			




	
	
	
		
 
#threadpool_max_requests = 10

			




	
	
	
		
 
## option to use threads of process

			




	
	
	
		
 
#use_threadpool = true

			




	
	
	
		
 

			




	
	
	
		
 
## WAITRESS ##

			




	
	
	
		
 
use = egg:waitress#main

			




	
	
	
		
 
## number of worker threads

			




	
	
	
		
 
threads = 5

			




	
	
	
		
 
## MAX BODY SIZE 100GB

			




	
	
	
		
 
max_request_body_size = 107374182400

			




	
	
	
		
 
## use poll instead of select, fixes fd limits, may not work on old

			




	
	
	
		
 
## windows systems.

			




	
	
	
		
 
#asyncore_use_poll = True

			




	
	
	
		
 

			




	
	
	
		
 
## GUNICORN ##

			




	
	
	
		
 
#use = egg:gunicorn#main

			




	
	
	
		
 
## number of process workers. You must set `instance_id = *` when this option

			




	
	
	
		
 
## is set to more than one worker

			




	
	
	
		
 
#workers = 1

			




	
	
	
		
 
## process name

			




	
	
	
		
 
#proc_name = kallithea

			




	
	
	
		
 
## type of worker class, one of sync, eventlet, gevent, tornado

			




	
	
	
		
 
## recommended for bigger setup is using of of other than sync one

			




	
	
	
		
 
#worker_class = sync

			




	
	
	
		
 
#max_requests = 1000

			




	
	
	
		
 
## ammount of time a worker can handle request before it gets killed and

			




	
	
	
		
 
## restarted

			




	
	
	
		
 
#timeout = 3600

			




	
	
	
		
 

			




	
	
	
		
 
## UWSGI ##

			




	
	
	
		
 
## run with uwsgi --ini-paste-logged <inifile.ini>

			




	
	
	
		
 
#[uwsgi]

			




	
	
	
		
 
#socket = /tmp/uwsgi.sock

			




	
	
	
		
 
#master = true

			




	
	
	
		
 
#http = 127.0.0.1:5000

			




	
	
	
		
 

			




	
	
	
		
 
## set as deamon and redirect all output to file

			




	
	
	
		
 
#daemonize = ./uwsgi_kallithea.log

			




	
	
	
		
 

			




	
	
	
		
 
## master process PID

			




	
	
	
		
 
#pidfile = ./uwsgi_kallithea.pid

			




	
	
	
		
 

			




	
	
	
		
 
## stats server with workers statistics, use uwsgitop

			




	
	
	
		
 
## for monitoring, `uwsgitop 127.0.0.1:1717`

			




	
	
	
		
 
#stats = 127.0.0.1:1717

			




	
	
	
		
 
#memory-report = true

			




	
	
	
		
 

			




	
	
	
		
 
## log 5XX errors

			




	
	
	
		
 
#log-5xx = true

			




	
	
	
		
 

			




	
	
	
		
 
## Set the socket listen queue size.

			




	
	
	
		
 
#listen = 256

			




	
	
	
		
 

			




	
	
	
		
 
## Gracefully Reload workers after the specified amount of managed requests

			




	
	
	
		
 
## (avoid memory leaks).

			




	
	
	
		
 
#max-requests = 1000

			




	
	
	
		
 

			




	
	
	
		
 
## enable large buffers

			




	
	
	
		
 
#buffer-size = 65535

			




	
	
	
		
 

			




	
	
	
		
 
## socket and http timeouts ##

			




	
	
	
		
 
#http-timeout = 3600

			




	
	
	
		
 
#socket-timeout = 3600

			




	
	
	
		
 

			




	
	
	
		
 
## Log requests slower than the specified number of milliseconds.

			




	
	
	
		
 
#log-slow = 10

			




	
	
	
		
 

			




	
	
	
		
 
## Exit if no app can be loaded.

			




	
	
	
		
 
#need-app = true

			




	
	
	
		
 

			




	
	
	
		
 
## Set lazy mode (load apps in workers instead of master).

			




	
	
	
		
 
#lazy = true

			




	
	
	
		
 

			




	
	
	
		
 
## scaling ##

			




	
	
	
		
 
## set cheaper algorithm to use, if not set default will be used

			




	
	
	
		
 
#cheaper-algo = spare

			




	
	
	
		
 

			




	
	
	
		
 
## minimum number of workers to keep at all times

			




	
	
	
		
 
#cheaper = 1

			




	
	
	
		
 

			




	
	
	
		
 
## number of workers to spawn at startup

			




	
	
	
		
 
#cheaper-initial = 1

			




	
	
	
		
 

			




	
	
	
		
 
## maximum number of workers that can be spawned

			




	
	
	
		
 
#workers = 4

			




	
	
	
		
 

			




	
	
	
		
 
## how many workers should be spawned at a time

			




	
	
	
		
 
#cheaper-step = 1

			




	
	
	
		
 

			




	
	
	
		
 
## COMMON ##

			




	
	
	
		
 
host = 0.0.0.0

			




	
	
	
		
 
port = 5000

			




	
	
	
		
 

			




	
	
	
		
 
## middleware for hosting the WSGI application under a URL prefix

			




	
	
	
		
 
#[filter:proxy-prefix]

			




	
	
	
		
 
#use = egg:PasteDeploy#prefix

			




	
	
	
		
 
#prefix = /<your-prefix>

			




	
	
	
		
 

			




	
	
	
		
 
[app:main]

			




	
	
	
		
 
use = egg:kallithea

			




	
	
	
		
 
## enable proxy prefix middleware

			




	
	
	
		
 
#filter-with = proxy-prefix

			




	
	
	
		
 

			




	
	
	
		
 
full_stack = true

			




	
	
	
		
 
static_files = true

			




	
	
	
		
 
## Available Languages:

			




	
	
	
		
 
## cs de fr hu ja nl_BE pl pt_BR ru sk zh_CN zh_TW

			




	
	
	
		
 
lang =

			




	
	
	
		
 
cache_dir = %(here)s/data

			




	
	
	
		
 
index_dir = %(here)s/data/index

			




	
	
	
		
 

			




	
	
	
		
 
## perform a full repository scan on each server start, this should be

			




	
	
	
		
 
## set to false after first startup, to allow faster server restarts.

			




	
	
	
		
 
#initial_repo_scan = false

			




	
	
	
		
 
initial_repo_scan = true

			




	
	
	
		
 

			




	
	
	
		
 
## uncomment and set this path to use archive download cache

			




	
	
	
		
 
archive_cache_dir = %(here)s/tarballcache

			




	
	
	
		
 

			




	
	
	
		
 
## change this to unique ID for security

			




	
	
	
		
 
app_instance_uuid = development-not-secret

			




	
	
	
		
 

			




	
	
	
		
 
## cut off limit for large diffs (size in bytes)

			




	
	
	
		
 
cut_off_limit = 256000

			




	
	
	
		
 

			




	
	
	
		
 
## use cache version of scm repo everywhere

			




	
	
	
		
 
vcs_full_cache = true

			




	
	
	
		
 

			




	
	
	
		
 
## force https in Kallithea, fixes https redirects, assumes it's always https

			




	
	
	
		
 
force_https = false

			




	
	
	
		
 

			




	
	
	
		
 
## use Strict-Transport-Security headers

			




	
	
	
		
 
use_htsts = false

			




	
	
	
		
 

			




	
	
	
		
 
## number of commits stats will parse on each iteration

			




	
	
	
		
 
commit_parse_limit = 25

			




	
	
	
		
 

			




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

			




	
	
	
		
 

			




	
	
	
		
 
## options for showing and identifying changesets

			




	
	
	
		
 
show_sha_length = 12

			




	
	
	
		
 
show_revision_number = false

			




	
	
	
		
 

			




	
	
	
		
 
## gist URL alias, used to create nicer urls for gist. This should be an

			




	
	
	
		
 
## url that does rewrites to _admin/gists/<gistid>.

			




	
	
	
		
 
## example: http://gist.kallithea.server/{gistid}. Empty means use the internal

			




	
	
	
		
 
## Kallithea url, ie. http[s]://your.kallithea.server/_admin/gists/<gistid>

			




	
	
	
		
 
## example: http://gist.example.com/{gistid}. Empty means use the internal

			




	
	
	
		
 
## Kallithea url, ie. http[s]://kallithea.example.com/_admin/gists/<gistid>

			




	
	
	
		
 
gist_alias_url =

			




	
	
	
		
 

			




	
	
	
		
 
## white list of API enabled controllers. This allows to add list of

			




	
	
	
		
 
## controllers to which access will be enabled by api_key. eg: to enable

			




	
	
	
		
 
## api access to raw_files put `FilesController:raw`, to enable access to patches

			




	
	
	
		
 
## add `ChangesetController:changeset_patch`. This list should be "," separated

			




	
	
	
		
 
## Syntax is <ControllerClass>:<function>. Check debug logs for generated names

			




	
	
	
		
 
## Recommended settings below are commented out:

			




	
	
	
		
 
api_access_controllers_whitelist =

			




	
	
	
		
 
#    ChangesetController:changeset_patch,

			




	
	
	
		
 
#    ChangesetController:changeset_raw,

			




	
	
	
		
 
#    FilesController:raw,

			




	
	
	
		
 
#    FilesController:archivefile

			




	
	
	
		
 

			




	
	
	
		
 
## default encoding used to convert from and to unicode

			




	
	
	
		
 
## can be also a comma seperated list of encoding in case of mixed encodings

			




	
	
	
		
 
default_encoding = utf8

			




	
	
	
		
 

			




	
	
	
		
 
## issue tracker for Kallithea (leave blank to disable, absent for default)

			




	
	
	
		
 
#bugtracker = https://bitbucket.org/conservancy/kallithea/issues

			




	
	
	
		
 

			




	
	
	
		
 
## issue tracking mapping for commits messages

			




	
	
	
		
 
## comment out issue_pat, issue_server, issue_prefix to enable

			




	
	
	
		
 

			




	
	
	
		
 
## pattern to get the issues from commit messages

			




	
	
	
		
 
## default one used here is #<numbers> with a regex passive group for `#`

			




	
	
	
		
 
## {id} will be all groups matched from this pattern

			




	
	
	
		
 

			




	
	
	
		
 
issue_pat = (?:\s*#)(\d+)

			




	
	
	
		
 

			




	
	
	
		
 
## server url to the issue, each {id} will be replaced with match

			




	
	
	
		
 
## fetched from the regex and {repo} is replaced with full repository name

			




	
	
	
		
 
## including groups {repo_name} is replaced with just name of repo

			




	
	
	
		
 

			




	
	
	
		
 
issue_server_link = https://myissueserver.com/{repo}/issue/{id}

			




	
	
	
		
 
issue_server_link = https://issues.example.com/{repo}/issue/{id}

			




	
	
	
		
 

			




	
	
	
		
 
## prefix to add to link to indicate it's an url

			




	
	
	
		
 
## #314 will be replaced by <issue_prefix><id>

			




	
	
	
		
 

			




	
	
	
		
 
issue_prefix = #

			




	
	
	
		
 

			




	
	
	
		
 
## issue_pat, issue_server_link, issue_prefix can have suffixes to specify

			




	
	
	
		
 
## multiple patterns, to other issues server, wiki or others

			




	
	
	
		
 
## below an example how to create a wiki pattern

			




	
	
	
		
 
# wiki-some-id -> https://mywiki.com/some-id

			




	
	
	
		
 
# wiki-some-id -> https://wiki.example.com/some-id

			




	
	
	
		
 

			




	
	
	
		
 
#issue_pat_wiki = (?:wiki-)(.+)

			




	
	
	
		
 
#issue_server_link_wiki = https://mywiki.com/{id}

			




	
	
	
		
 
#issue_server_link_wiki = https://wiki.example.com/{id}

			




	
	
	
		
 
#issue_prefix_wiki = WIKI-

			




	
	
	
		
 

			




	
	
	
		
 
## instance-id prefix

			




	
	
	
		
 
## a prefix key for this instance used for cache invalidation when running

			




	
	
	
		
 
## multiple instances of kallithea, make sure it's globally unique for

			




	
	
	
		
 
## all running kallithea instances. Leave empty if you don't use it

			




	
	
	
		
 
instance_id =

			




	
	
	
		
 

			




	
	
	
		
 
## alternative return HTTP header for failed authentication. Default HTTP

			




	
	
	
		
 
## response is 401 HTTPUnauthorized. Currently Mercurial clients have trouble with

			




	
	
	
		
 
## handling that. Set this variable to 403 to return HTTPForbidden

			




	
	
	
		
 
auth_ret_code =

			




	
	
	
		
 

			




	
	
	
		
 
## locking return code. When repository is locked return this HTTP code. 2XX

			




	
	
	
		
 
## codes don't break the transactions while 4XX codes do

			




	
	
	
		
 
lock_ret_code = 423

			




	
	
	
		
 

			




	
	
	
		
 
## allows to change the repository location in settings page

			




	
	
	
		
 
allow_repo_location_change = True

			




	
	
	
		
 

			




	
	
	
		
 
## allows to setup custom hooks in settings page

			




	
	
	
		
 
allow_custom_hooks_settings = True

			




	
	
	
		
 

			




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

			




	
	
	
		
 
###        CELERY CONFIG        ####

			




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

			




	
	
	
		
 

			




	
	
	
		
 
use_celery = false

			




	
	
	
		
 
broker.host = localhost

			




	
	
	
		
 
broker.vhost = rabbitmqhost

			




	
	
	
		
 
broker.port = 5672

			




	
	
	
		
 
broker.user = rabbitmq

			




	
	
	
		
 
broker.password = qweqwe

			




	
	
	
		
 

			




	
	
	
		
 
celery.imports = kallithea.lib.celerylib.tasks

			




	
	
	
		
 

			




	
	
	
		
 
celery.result.backend = amqp

			




	
	
	
		
 
celery.result.dburi = amqp://

			




	
	
	
		
 
celery.result.serialier = json

			




	
	
	
		
 

			




	
	
	
		
 
#celery.send.task.error.emails = true

			




	
	
	
		
 
#celery.amqp.task.result.expires = 18000

			




	
	
	
		
 

			




	
	
	
		
 
celeryd.concurrency = 2

			




	
	
	
		
 
#celeryd.log.file = celeryd.log

			




	
	
	
		
 
celeryd.log.level = DEBUG

			




	
	
	
		
 
celeryd.max.tasks.per.child = 1

			




	
	
	
		
 

			




	
	
	
		
 
## tasks will never be sent to the queue, but executed locally instead.

			




	
	
	
		
 
celery.always.eager = false

			




	
	
	
		
 

			




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

			




	
	
	
		
 
###         BEAKER CACHE        ####

			




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

			




	
	
	
		
 

			




	
	
	
		
 
beaker.cache.data_dir = %(here)s/data/cache/data

			




	
	
	
		
 
beaker.cache.lock_dir = %(here)s/data/cache/lock

			




	
	
	
		
 

			




	
	
	
		
 
beaker.cache.regions = short_term,long_term,sql_cache_short

			




	
	
	
		
 

			




	
	
	
		
 
beaker.cache.short_term.type = memory

			




	
	
	
		
 
beaker.cache.short_term.expire = 60

			




	
	
	
		
 
beaker.cache.short_term.key_length = 256

			




	
	
	
		
 

			




	
	
	
		
 
beaker.cache.long_term.type = memory

			




	
	
	
		
 
beaker.cache.long_term.expire = 36000

			




	
	
	
		
 
beaker.cache.long_term.key_length = 256

			




	
	
	
		
 

			




	
	
	
		
 
beaker.cache.sql_cache_short.type = memory

			




	
	
	
		
 
beaker.cache.sql_cache_short.expire = 10

			




	
	
	
		
 
beaker.cache.sql_cache_short.key_length = 256

			




	
	
	
		
 

			




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

			




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

			




	
	
	
		
 
beaker.session.key = kallithea

			




	
	
	
		
 
## Sessions should always only be accessible by the browser, not directly by JavaScript.

			




	
	
	
		
 
beaker.session.httponly = true

			




	
	
	
		
 
## Session lifetime. 2592000 seconds is 30 days.

			




	
	
	
		
 
beaker.session.timeout = 2592000

			




	
	
	
		
 

			




	
	
	
		
 
## Server secret used with HMAC to ensure integrity of cookies.

			




	
	
	
		
 
beaker.session.secret = development-not-secret

			




	
	
	
		
 
## Further, encrypt the data with AES.

			




	
	
	
		
 
#beaker.session.encrypt_key = <key_for_encryption>

			




	
	
	
		
 
#beaker.session.validate_key = <validation_key>

			




	
	
	
		
 

			




	
	
	
		
 
## Type of storage used for the session, current types are

			




	
	
	
		
 
## dbm, file, memcached, database, and memory.

			




	
	
	
		
 

			




	
	
	
		
 
## File system storage of session data. (default)

			




	
	
	
		
 
#beaker.session.type = file

			




	
	
	
		
 

			




	
	
	
		
 
## Cookie only, store all session data inside the cookie. Requires secure secrets.

			




	
	
	
		
 
#beaker.session.type = cookie

			




	
	
	
		
 

			




	
	
	
		
 
## Database storage of session data.

			




	
	
	
		
 
#beaker.session.type = ext:database

			




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

			




	
	
	
		
 
#beaker.session.table_name = db_session

			




	
	
	
		
 

			




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

			




	
	
	
		
 
## ERROR HANDLING SYSTEMS ##

			




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

			




	
	
	
		
 

			




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

			




	
	
	
		
 
### [errormator] ###

			




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

			




	
	
	
		
 

			




	
	
	
		
 
## Errormator is tailored to work with Kallithea, see

			




	
	
	
		
 
## http://errormator.com for details how to obtain an account

			




	
	
	
		
 
## you must install python package `errormator_client` to make it work

			




	
	
	
		
 

			




	
	
	
		
 
## errormator enabled

			




	
	
	
		
 
errormator = false

			




	
	
	
		
 

			




	
	
	
		
 
errormator.server_url = https://api.errormator.com

			




	
	
	
		
 
errormator.api_key = YOUR_API_KEY

			




	
	
	
		
 

			




	
	
	
		
 
## TWEAK AMOUNT OF INFO SENT HERE

			




	
	
	
		
 

			




	
	
	
		
 
## enables 404 error logging (default False)

			




	
	
	
		
 
errormator.report_404 = false

			




	
	
	
		
 

			




	
	
	
		
 
## time in seconds after request is considered being slow (default 1)

			




	
	
	
		
 
errormator.slow_request_time = 1

			




	
	
	
		
 

			




	
	
	
		
 
## record slow requests in application

			




	
	
	
		
 
## (needs to be enabled for slow datastore recording and time tracking)

			




	
	
	
		
 
errormator.slow_requests = true

			




	
	
	
		
 

			




	
	
	
		
 
## enable hooking to application loggers

			




	
	
	
		
 
#errormator.logging = true

			




	
	
	
		
 

			




	
	
	
		
 
## minimum log level for log capture

			




	
	
	
		
 
#errormator.logging.level = WARNING

			




	
	
	
		
 

			




	
	
	
		
 
## send logs only from erroneous/slow requests

			




	
	
	
		
 
## (saves API quota for intensive logging)

			




	
	
	
		
 
errormator.logging_on_error = false

			




	
	
	
		
 

			




	
	
	
		
 
## list of additonal keywords that should be grabbed from environ object

			




	
	
	
		
 
## can be string with comma separated list of words in lowercase

			




	
	
	
		
 
## (by default client will always send following info:

			




	
	
	
		
 
## 'REMOTE_USER', 'REMOTE_ADDR', 'SERVER_NAME', 'CONTENT_TYPE' + all keys that

			




	
	
	
		
 
## start with HTTP* this list be extended with additional keywords here

			




	
	
	
		
 
errormator.environ_keys_whitelist =

			




	
	
	
		
 

			




	
	
	
		
 
## list of keywords that should be blanked from request object

			




	
	
	
		
 
## can be string with comma separated list of words in lowercase

			




	
	
	
		
 
## (by default client will always blank keys that contain following words

			




	
	
	
		
 
## 'password', 'passwd', 'pwd', 'auth_tkt', 'secret', 'csrf'

			




	
	
	
		
 
## this list be extended with additional keywords set here

			




	
	
	
		
 
errormator.request_keys_blacklist =

			




	
	
	
		
 

			




	
	
	
		
 
## list of namespaces that should be ignores when gathering log entries

			




	
	
	
		
 
## can be string with comma separated list of namespaces

			




	
	
	
		
 
## (by default the client ignores own entries: errormator_client.client)

			




	
	
	
		
 
errormator.log_namespace_blacklist =

			




	
	
	
		
 

			




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

			




	
	
	
		
 
### [sentry] ###

			




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

			




	
	
	
		
 

			




	
	
	
		
 
## sentry is a alternative open source error aggregator

			




	
	
	
		
 
## you must install python packages `sentry` and `raven` to enable

			




	
	
	
		
 

			




	
	
	
		
 
sentry.dsn = YOUR_DNS

			




	
	
	
		
 
sentry.servers =

			




	
	
	
		
 
sentry.name =

			




	
	
	
		
 
sentry.key =

			




	
	
	
		
 
sentry.public_key =

			




	
	
	
		
 
sentry.secret_key =

			




	
	
	
		
 
sentry.project =

			




	
	
	
		
 
sentry.site =

			




	
	
	
		
 
sentry.include_paths =

			




	
	
	
		
 
sentry.exclude_paths =

			




	
	
	
		
 

			




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

			




	
	
	
		
 
## WARNING: *THE LINE BELOW MUST BE UNCOMMENTED ON A PRODUCTION ENVIRONMENT*  ##

			




	
	
	
		
 
## Debug mode will enable the interactive debugging tool, allowing ANYONE to  ##

			




	
	
	
		
 
## execute malicious code after an exception is raised.                       ##

			




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

			




	
	
	
		
 
#set debug = false

			




	
	
	
		
 
set debug = true

			




	
	
	
		
 

			




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

			




	
	
	
		
 
###       LOGVIEW CONFIG       ###

			




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

			




        

    


    
    

    

        

                

                    docs/api/api.rst
                

                

                  
                      
                        

                      ➞

                      
                        
                  

                  
                      
                  
                      
                  
                      
                  
                      
                  
                  
                

                

                    Show inline comments
                    
                

        

        

            



	
	
	
		
 
.. _api:

			




	
	
	
		
 

			




	
	
	
		
 
===

			




	
	
	
		
 
API

			




	
	
	
		
 
===

			




	
	
	
		
 

			




	
	
	
		
 
Kallithea has a simple JSON RPC API with a single schema for calling all API

			




	
	
	
		
 
methods. Everything is available by sending JSON encoded http(s) requests to

			




	
	
	
		
 
``<your_server>/_admin/api``.

			




	
	
	
		
 

			




	
	
	
		
 

			




	
	
	
		
 
API access for web views

			




	
	
	
		
 
++++++++++++++++++++++++

			




	
	
	
		
 

			




	
	
	
		
 
API access can also be turned on for each web view in Kallithea that is

			




	
	
	
		
 
decorated with the ``@LoginRequired`` decorator. Some views use

			




	
	
	
		
 
``@LoginRequired(api_access=True)`` and are always available. By default only

			




	
	
	
		
 
RSS/Atom feed views are enabled. Other views are

			




	
	
	
		
 
only available if they have been whitelisted. Edit the

			




	
	
	
		
 
``api_access_controllers_whitelist`` option in your .ini file and define views

			




	
	
	
		
 
that should have API access enabled.

			




	
	
	
		
 

			




	
	
	
		
 
For example, to enable API access to patch/diff, raw file and archive::

			




	
	
	
		
 

			




	
	
	
		
 
    api_access_controllers_whitelist =

			




	
	
	
		
 
        ChangesetController:changeset_patch,

			




	
	
	
		
 
        ChangesetController:changeset_raw,

			




	
	
	
		
 
        FilesController:raw,

			




	
	
	
		
 
        FilesController:archivefile

			




	
	
	
		
 

			




	
	
	
		
 
After this change, a Kallithea view can be accessed without login by adding a

			




	
	
	
		
 
GET parameter ``?api_key=<api_key>`` to the URL.

			




	
	
	
		
 

			




	
	
	
		
 
Exposing raw diffs is a good way to integrate with

			




	
	
	
		
 
third-party services like code review, or build farms that can download archives.

			




	
	
	
		
 

			




	
	
	
		
 

			




	
	
	
		
 
API access

			




	
	
	
		
 
++++++++++

			




	
	
	
		
 

			




	
	
	
		
 
Clients must send JSON encoded JSON-RPC requests::

			




	
	
	
		
 

			




	
	
	
		
 
    {

			




	
	
	
		
 
        "id: "<id>",

			




	
	
	
		
 
        "api_key": "<api_key>",

			




	
	
	
		
 
        "method": "<method_name>",

			




	
	
	
		
 
        "args": {"<arg_key>": "<arg_val>"}

			




	
	
	
		
 
    }

			




	
	
	
		
 

			




	
	
	
		
 
For example, to pull to a local "CPython" mirror using curl::

			




	
	
	
		
 

			




	
	
	
		
 
    curl https://example.com/_admin/api -X POST -H 'content-type:text/plain' \

			




	
	
	
		
 
    curl https://kallithea.example.com/_admin/api -X POST -H 'content-type:text/plain' \

			




	
	
	
		
 
        --data-binary '{"id":1,"api_key":"xe7cdb2v278e4evbdf5vs04v832v0efvcbcve4a3","method":"pull","args":{"repo":"CPython"}}'

			




	
	
	
		
 

			




	
	
	
		
 
In general, provide

			




	
	
	
		
 
 - *id*, a value of any type, can be used to match the response with the request that it is replying to.

			




	
	
	
		
 
 - *api_key*, for authentication and permission validation.

			




	
	
	
		
 
 - *method*, the name of the method to call -- a list of available methods can be found below.

			




	
	
	
		
 
 - *args*, the arguments to pass to the method.

			




	
	
	
		
 

			




	
	
	
		
 
.. note::

			




	
	
	
		
 

			




	
	
	
		
 
    api_key can be found or set on the user account page.

			




	
	
	
		
 

			




	
	
	
		
 
The response to the JSON-RPC API call will always be a JSON structure::

			




	
	
	
		
 

			




	
	
	
		
 
    {

			




	
	
	
		
 
        "id": <id>,  # the id that was used in the request

			




	
	
	
		
 
        "result": <result>|null,  # JSON formatted result (null on error)

			




	
	
	
		
 
        "error": null|<error_message>  # JSON formatted error (null on success)

			




	
	
	
		
 
    }

			




	
	
	
		
 

			




	
	
	
		
 
All responses from the API will be ``HTTP/1.0 200 OK``. If an error occurs,

			




	
	
	
		
 
the reponse will have a failure description in *error* and

			




	
	
	
		
 
*result* will be null.

			




	
	
	
		
 

			




	
	
	
		
 

			




	
	
	
		
 
API client

			




	
	
	
		
 
++++++++++

			




	
	
	
		
 

			




	
	
	
		
 
Kallithea comes with a ``kallithea-api`` command line tool, providing a convenient

			




	
	
	
		
 
way to call the JSON-RPC API.

			




	
	
	
		
 

			




	
	
	
		
 
For example, to call ``get_repo``::

			




	
	
	
		
 

			




	
	
	
		
 
    kallithea-api --apihost=<Kallithea URL> --apikey=<API key> get_repo

			




	
	
	
		
 

			




	
	
	
		
 
    Calling method get_repo => <Kallithea URL>

			




	
	
	
		
 
    Server response

			




	
	
	
		
 
    ERROR:"Missing non optional `repoid` arg in JSON DATA"

			




	
	
	
		
 

			




	
	
	
		
 
Oops, looks like we forgot to add an argument. Let's try again, now

			




	
	
	
		
 
providing the ``repoid`` as a parameter::

			




	
	
	
		
 

			




	
	
	
		
 
    kallithea-api --apihost=<Kallithea URL> --apikey=<API key> get_repo repoid:myrepo

			




	
	
	
		
 

			




	
	
	
		
 
    Calling method get_repo => <Kallithea URL>

			




	
	
	
		
 
    Server response

			




	
	
	
		
 
    {

			




	
	
	
		
 
        "clone_uri": null,

			




	
	
	
		
 
        "created_on": "2015-08-31T14:55:19.042",

			




	
	
	
		
 
    ...

			




	
	
	
		
 

			




	
	
	
		
 
To avoid specifying ``apihost`` and ``apikey`` every time, run::

			




	
	
	
		
 

			




	
	
	
		
 
    kallithea-api --save-config --apihost=<Kallithea URL> --apikey=<API key>

			




	
	
	
		
 

			




	
	
	
		
 
This will create a ``~/.config/kallithea`` with the specified URL and API key

			




	
	
	
		
 
so you don't have to specify them every time.

			




	
	
	
		
 

			




	
	
	
		
 

			




	
	
	
		
 
API methods

			




	
	
	
		
 
+++++++++++

			




	
	
	
		
 

			




	
	
	
		
 

			




	
	
	
		
 
pull

			




	
	
	
		
 
----

			




	
	
	
		
 

			




	
	
	
		
 
Pull the given repo from remote location. Can be used to automatically keep

			




	
	
	
		
 
remote repos up to date.

			




	
	
	
		
 
This command can only be executed using the api_key of a user with admin rights.

			




	
	
	
		
 

			




	
	
	
		
 
INPUT::

			




	
	
	
		
 

			




	
	
	
		
 
    id : <id_for_response>

			




	
	
	
		
 
    api_key : "<api_key>"

			




	
	
	
		
 
    method :  "pull"

			




	
	
	
		
 
    args :    {

			




	
	
	
		
 
                "repoid" : "<reponame or repo_id>"

			




	
	
	
		
 
              }

			




	
	
	
		
 

			




	
	
	
		
 
OUTPUT::

			




	
	
	
		
 

			




	
	
	
		
 
    id : <id_given_in_input>

			




	
	
	
		
 
    result : "Pulled from `<reponame>`"

			




	
	
	
		
 
    error :  null

			




	
	
	
		
 

			




	
	
	
		
 
rescan_repos

			




	
	
	
		
 
------------

			




	
	
	
		
 

			




	
	
	
		
 
Rescan repositories. If ``remove_obsolete`` is set,

			




	
	
	
		
 
Kallithea will delete repos that are in the database but not in the filesystem.

			




	
	
	
		
 
This command can only be executed using the api_key of a user with admin rights.

			




	
	
	
		
 

			




	
	
	
		
 
INPUT::

			




	
	
	
		
 

			




	
	
	
		
 
    id : <id_for_response>

			




	
	
	
		
 
    api_key : "<api_key>"

			




	
	
	
		
 
    method :  "rescan_repos"

			




	
	
	
		
 
    args :    {

			




	
	
	
		
 
                "remove_obsolete" : "<boolean = Optional(False)>"

			




	
	
	
		
 
              }

			




	
	
	
		
 

			




	
	
	
		
 
OUTPUT::

			




	
	
	
		
 

			




	
	
	
		
 
    id : <id_given_in_input>

			




	
	
	
		
 
    result : "{'added': [<list of names of added repos>],

			




	
	
	
		
 
               'removed': [<list of names of removed repos>]}"

			




	
	
	
		
 
    error :  null

			




	
	
	
		
 

			




	
	
	
		
 
invalidate_cache

			




	
	
	
		
 
----------------

			




	
	
	
		
 

			




	
	
	
		
 
Invalidate the cache for a repository.

			




	
	
	
		
 
This command can only be executed using the api_key of a user with admin rights,

			




	
	
	
		
 
or that of a regular user with admin or write access to the repository.

			




	
	
	
		
 

			




	
	
	
		
 
INPUT::

			




	
	
	
		
 

			




	
	
	
		
 
    id : <id_for_response>

			




	
	
	
		
 
    api_key : "<api_key>"

			




	
	
	
		
 
    method :  "invalidate_cache"

			




	
	
	
		
 
    args :    {

			




	
	
	
		
 
                "repoid" : "<reponame or repo_id>"

			




	
	
	
		
 
              }

			




	
	
	
		
 

			




	
	
	
		
 
OUTPUT::

			




	
	
	
		
 

			




	
	
	
		
 
    id : <id_given_in_input>

			




	
	
	
		
 
    result : "Caches of repository `<reponame>`"

			




	
	
	
		
 
    error :  null

			




	
	
	
		
 

			




	
	
	
		
 
lock

			




	
	
	
		
 
----

			




	
	
	
		
 

			




	
	
	
		
 
Set the locking state on the given repository by the given user.

			




	
	
	
		
 
If the param ``userid`` is skipped, it is set to the ID of the user who is calling this method.

			




	
	
	
		
 
If param ``locked`` is skipped, the current lock state of the repository is returned.

			




	
	
	
		
 
This command can only be executed using the api_key of a user with admin rights, or that of a regular user with admin or write access to the repository.

			




	
	
	
		
 

			




	
	
	
		
 
INPUT::

			




	
	
	
		
 

			




	
	
	
		
 
    id : <id_for_response>

			




	
	
	
		
 
    api_key : "<api_key>"

			




	
	
	
		
 
    method :  "lock"

			




	
	
	
		
 
    args :    {

			




	
	
	
		
 
                "repoid" : "<reponame or repo_id>"

			




	
	
	
		
 
                "userid" : "<user_id or username = Optional(=apiuser)>",

			




	
	
	
		
 
                "locked" : "<bool true|false = Optional(=None)>"

			




	
	
	
		
 
              }

			




	
	
	
		
 

			




	
	
	
		
 
OUTPUT::

			




	
	
	
		
 

			




	
	
	
		
 
    id : <id_given_in_input>

			




	
	
	
		
 
    result : {

			




	
	
	
		
 
                 "repo": "<reponame>",

			




	
	
	
		
 
                 "locked": "<bool true|false>",

			




	
	
	
		
 
                 "locked_since": "<float lock_time>",

			




	
	
	
		
 
                 "locked_by": "<username>",

			




	
	
	
		
 
                 "msg": "User `<username>` set lock state for repo `<reponame>` to `<false|true>`"

			




	
	
	
		
 
             }

			




	
	
	
		
 
    error :  null

			




	
	
	
		
 

			




	
	
	
		
 
get_ip

			




	
	
	
		
 
------

			




	
	
	
		
 

			




	
	
	
		
 
Return IP address as seen from Kallithea server, together with all

			




	
	
	
		
 
defined IP addresses for given user.

			




	
	
	
		
 
This command can only be executed using the api_key of a user with admin rights.

			




	
	
	
		
 

			




	
	
	
		
 
INPUT::

			




	
	
	
		
 

			




	
	
	
		
 
    id : <id_for_response>

			




	
	
	
		
 
    api_key : "<api_key>"

			




	
	
	
		
 
    method :  "get_ip"

			




	
	
	
		
 
    args :    {

			




	
	
	
		
 
                "userid" : "<user_id or username>",

			




	
	
	
		
 
              }

			




	
	
	
		
 

			




	
	
	
		
 
OUTPUT::

			




	
	
	
		
 

			




	
	
	
		
 
    id : <id_given_in_input>

			




	
	
	
		
 
    result : {

			




	
	
	
		
 
                 "ip_addr_server": <ip_from_clien>",

			




	
	
	
		
 
                 "user_ips": [

			




	
	
	
		
 
                                {

			




	
	
	
		
 
                                   "ip_addr": "<ip_with_mask>",

			




	
	
	
		
 
                                   "ip_range": ["<start_ip>", "<end_ip>"],

			




	
	
	
		
 
                                },

			




	
	
	
		
 
                                ...

			




	
	
	
		
 
                             ]

			




	
	
	
		
 
             }

			




	
	
	
		
 

			




	
	
	
		
 
    error :  null

			




        

    


    
    

    

        

                

                    docs/setup.rst
                

                

                  
                      
                        

                      ➞

                      
                        
                  

                  
                      
                  
                      
                  
                      
                  
                      
                  
                  
                

                

                    Show inline comments
                    
                

        

        

            



	
	
	
		
 
.. _setup:

			




	
	
	
		
 

			




	
	
	
		
 
=====

			




	
	
	
		
 
Setup

			




	
	
	
		
 
=====

			




	
	
	
		
 

			




	
	
	
		
 

			




	
	
	
		
 
Setting up Kallithea

			




	
	
	
		
 
--------------------

			




	
	
	
		
 

			




	
	
	
		
 
First, you will need to create a Kallithea configuration file. Run the

			




	
	
	
		
 
following command to do so::

			




	
	
	
		
 

			




	
	
	
		
 
    paster make-config Kallithea my.ini

			




	
	
	
		
 

			




	
	
	
		
 
This will create the file ``my.ini`` in the current directory. This

			




	
	
	
		
 
configuration file contains the various settings for Kallithea, e.g.

			




	
	
	
		
 
proxy port, email settings, usage of static files, cache, Celery

			




	
	
	
		
 
settings, and logging.

			




	
	
	
		
 

			




	
	
	
		
 
Next, you need to create the databases used by Kallithea. It is recommended to

			




	
	
	
		
 
use PostgreSQL or SQLite (default). If you choose a database other than the

			




	
	
	
		
 
default, ensure you properly adjust the database URL in your ``my.ini``

			




	
	
	
		
 
configuration file to use this other database. Kallithea currently supports

			




	
	
	
		
 
PostgreSQL, SQLite and MySQL databases. Create the database by running

			




	
	
	
		
 
the following command::

			




	
	
	
		
 

			




	
	
	
		
 
    paster setup-db my.ini

			




	
	
	
		
 

			




	
	
	
		
 
This will prompt you for a "root" path. This "root" path is the location where

			




	
	
	
		
 
Kallithea will store all of its repositories on the current machine. After

			




	
	
	
		
 
entering this "root" path ``setup-db`` will also prompt you for a username

			




	
	
	
		
 
and password for the initial admin account which ``setup-db`` sets

			




	
	
	
		
 
up for you.

			




	
	
	
		
 

			




	
	
	
		
 
The ``setup-db`` values can also be given on the command line.

			




	
	
	
		
 
Example::

			




	
	
	
		
 

			




	
	
	
		
 
    paster setup-db my.ini --user=nn --password=secret --email=nn@example.org --repos=/srv/repos

			




	
	
	
		
 
    paster setup-db my.ini --user=nn --password=secret --email=nn@example.com --repos=/srv/repos

			




	
	
	
		
 

			




	
	
	
		
 
The ``setup-db`` command will create all needed tables and an

			




	
	
	
		
 
admin account. When choosing a root path you can either use a new

			




	
	
	
		
 
empty location, or a location which already contains existing

			




	
	
	
		
 
repositories. If you choose a location which contains existing

			




	
	
	
		
 
repositories Kallithea will add all of the repositories at the chosen

			




	
	
	
		
 
location to its database.  (Note: make sure you specify the correct

			




	
	
	
		
 
path to the root).

			




	
	
	
		
 

			




	
	
	
		
 
.. note:: the given path for Mercurial_ repositories **must** be write

			




	
	
	
		
 
          accessible for the application. It's very important since

			




	
	
	
		
 
          the Kallithea web interface will work without write access,

			




	
	
	
		
 
          but when trying to do a push it will fail with permission

			




	
	
	
		
 
          denied errors unless it has write access.

			




	
	
	
		
 

			




	
	
	
		
 
You are now ready to use Kallithea. To run it simply execute::

			




	
	
	
		
 

			




	
	
	
		
 
    paster serve my.ini

			




	
	
	
		
 

			




	
	
	
		
 
- This command runs the Kallithea server. The web app should be available at

			




	
	
	
		
 
  http://127.0.0.1:5000. The IP address and port is configurable via the

			




	
	
	
		
 
  configuration file created in the previous step.

			




	
	
	
		
 
- Log in to Kallithea using the admin account created when running ``setup-db``.

			




	
	
	
		
 
- The default permissions on each repository is read, and the owner is admin.

			




	
	
	
		
 
  Remember to update these if needed.

			




	
	
	
		
 
- In the admin panel you can toggle LDAP, anonymous, and permissions

			




	
	
	
		
 
  settings, as well as edit more advanced options on users and

			




	
	
	
		
 
  repositories.

			




	
	
	
		
 

			




	
	
	
		
 

			




	
	
	
		
 
Extensions

			




	
	
	
		
 
----------

			




	
	
	
		
 

			




	
	
	
		
 
Optionally one can create an ``rcextensions`` package that extends Kallithea

			




	
	
	
		
 
functionality.

			




	
	
	
		
 
To generate a skeleton extensions package, run::

			




	
	
	
		
 

			




	
	
	
		
 
    paster make-rcext my.ini

			




	
	
	
		
 

			




	
	
	
		
 
This will create an ``rcextensions`` package next to the specified ``ini`` file.

			




	
	
	
		
 
With ``rcextensions`` it's possible to add additional mapping for whoosh,

			




	
	
	
		
 
stats and add additional code into the push/pull/create/delete repo hooks,

			




	
	
	
		
 
for example for sending signals to build-bots such as Jenkins.

			




	
	
	
		
 

			




	
	
	
		
 
See the ``__init__.py`` file inside the generated ``rcextensions`` package

			




	
	
	
		
 
for more details.

			




	
	
	
		
 

			




	
	
	
		
 

			




	
	
	
		
 
Using Kallithea with SSH

			




	
	
	
		
 
------------------------

			




	
	
	
		
 

			




	
	
	
		
 
Kallithea currently only hosts repositories using http and https. (The addition

			




	
	
	
		
 
of ssh hosting is a planned future feature.) However you can easily use ssh in

			




	
	
	
		
 
parallel with Kallithea. (Repository access via ssh is a standard "out of

			




	
	
	
		
 
the box" feature of Mercurial_ and you can use this to access any of the

			




	
	
	
		
 
repositories that Kallithea is hosting. See PublishingRepositories_)

			




	
	
	
		
 

			




	
	
	
		
 
Kallithea repository structures are kept in directories with the same name

			




	
	
	
		
 
as the project. When using repository groups, each group is a subdirectory.

			




	
	
	
		
 
This allows you to easily use ssh for accessing repositories.

			




	
	
	
		
 

			




	
	
	
		
 
In order to use ssh you need to make sure that your web server and the users'

			




	
	
	
		
 
login accounts have the correct permissions set on the appropriate directories.

			




	
	
	
		
 

			




	
	
	
		
 
.. note:: These permissions are independent of any permissions you

			




	
	
	
		
 
          have set up using the Kallithea web interface.

			




	
	
	
		
 

			




	
	
	
		
 
If your main directory (the same as set in Kallithea settings) is for

			




	
	
	
		
 
example set to ``/srv/repos`` and the repository you are using is

			




	
	
	
		
 
named ``kallithea``, then to clone via ssh you should run::

			




	
	
	
		
 

			




	
	
	
		
 
    hg clone ssh://user@server.com//srv/repos/kallithea

			




	
	
	
		
 
    hg clone ssh://user@kallithea.example.com/srv/repos/kallithea

			




	
	
	
		
 

			




	
	
	
		
 
Using other external tools such as mercurial-server_ or using ssh key-based

			




	
	
	
		
 
authentication is fully supported.

			




	
	
	
		
 

			




	
	
	
		
 
.. note:: In an advanced setup, in order for your ssh access to use

			




	
	
	
		
 
          the same permissions as set up via the Kallithea web

			




	
	
	
		
 
          interface, you can create an authentication hook to connect

			




	
	
	
		
 
          to the Kallithea db and run check functions for permissions

			




	
	
	
		
 
          against that.

			




	
	
	
		
 

			




	
	
	
		
 

			




	
	
	
		
 
Setting up Whoosh full text search

			




	
	
	
		
 
----------------------------------

			




	
	
	
		
 

			




	
	
	
		
 
Kallithea provides full text search of repositories using `Whoosh`__.

			




	
	
	
		
 

			




	
	
	
		
 
.. __: https://pythonhosted.org/Whoosh/

			




	
	
	
		
 

			




	
	
	
		
 
For an incremental index build, run::

			




	
	
	
		
 

			




	
	
	
		
 
    paster make-index my.ini

			




	
	
	
		
 

			




	
	
	
		
 
For a full index rebuild, run::

			




	
	
	
		
 

			




	
	
	
		
 
    paster make-index my.ini -f

			




	
	
	
		
 

			




	
	
	
		
 
The ``--repo-location`` option allows the location of the repositories to be overriden;

			




	
	
	
		
 
usually, the location is retrieved from the Kallithea database.

			




	
	
	
		
 

			




	
	
	
		
 
The ``--index-only`` option can be used to limit the indexed repositories to a comma-separated list::

			




	
	
	
		
 

			




	
	
	
		
 
    paster make-index my.ini --index-only=vcs,kallithea

			




	
	
	
		
 

			




	
	
	
		
 
To keep your index up-to-date it is necessary to do periodic index builds;

			




	
	
	
		
 
for this, it is recommended to use a crontab entry. Example::

			




	
	
	
		
 

			




	
	
	
		
 
    0  3  *  *  *  /path/to/virtualenv/bin/paster make-index /path/to/kallithea/my.ini

			




	
	
	
		
 

			




	
	
	
		
 
When using incremental mode (the default), Whoosh will check the last

			




	
	
	
		
 
modification date of each file and add it to be reindexed if a newer file is

			




	
	
	
		
 
available. The indexing daemon checks for any removed files and removes them

			




	
	
	
		
 
from index.

			




	
	
	
		
 

			




	
	
	
		
 
If you want to rebuild the index from scratch, you can use the ``-f`` flag as above,

			




	
	
	
		
 
or in the admin panel you can check the "build from scratch" checkbox.

			




	
	
	
		
 

			




	
	
	
		
 

			




	
	
	
		
 
Setting up LDAP support

			




	
	
	
		
 
-----------------------

			




	
	
	
		
 

			




	
	
	
		
 
Kallithea supports LDAP authentication. In order

			




	
	
	
		
 
to use LDAP, you have to install the python-ldap_ package. This package is

			




	
	
	
		
 
available via PyPI, so you can install it by running::

			




	
	
	
		
 

			




	
	
	
		
 
    pip install python-ldap

			




	
	
	
		
 

			




	
	
	
		
 
.. note:: ``python-ldap`` requires some libraries to be installed on

			




	
	
	
		
 
          your system, so before installing it check that you have at

			




	
	
	
		
 
          least the ``openldap`` and ``sasl`` libraries.

			




	
	
	
		
 

			




	
	
	
		
 
Choose *Admin > Authentication*, click the ``kallithea.lib.auth_modules.auth_ldap`` button

			




	
	
	
		
 
and then *Save*, to enable the LDAP plugin and configure its settings.

			




	
	
	
		
 

			




	
	
	
		
 
Here's a typical LDAP setup::

			




	
	
	
		
 

			




	
	
	
		
 
 Connection settings

			




	
	
	
		
 
 Enable LDAP          = checked

			




	
	
	
		
 
 Host                 = host.example.org

			




	
	
	
		
 
 Host                 = host.example.com

			




	
	
	
		
 
 Port                 = 389

			




	
	
	
		
 
 Account              = <account>

			




	
	
	
		
 
 Password             = <password>

			




	
	
	
		
 
 Connection Security  = LDAPS connection

			




	
	
	
		
 
 Certificate Checks   = DEMAND

			




	
	
	
		
 

			




	
	
	
		
 
 Search settings

			




	
	
	
		
 
 Base DN              = CN=users,DC=host,DC=example,DC=org

			




	
	
	
		
 
 LDAP Filter          = (&(objectClass=user)(!(objectClass=computer)))

			




	
	
	
		
 
 LDAP Search Scope    = SUBTREE

			




	
	
	
		
 

			




	
	
	
		
 
 Attribute mappings

			




	
	
	
		
 
 Login Attribute      = uid

			




	
	
	
		
 
 First Name Attribute = firstName

			




	
	
	
		
 
 Last Name Attribute  = lastName

			




	
	
	
		
 
 Email Attribute      = mail

			




	
	
	
		
 

			




	
	
	
		
 
If your user groups are placed in an Organisation Unit (OU) structure, the Search Settings configuration differs::

			




	
	
	
		
 

			




	
	
	
		
 
 Search settings

			




	
	
	
		
 
 Base DN              = DC=host,DC=example,DC=org

			




	
	
	
		
 
 LDAP Filter          = (&(memberOf=CN=your user group,OU=subunit,OU=unit,DC=host,DC=example,DC=org)(objectClass=user))

			




	
	
	
		
 
 LDAP Search Scope    = SUBTREE

			




	
	
	
		
 

			




	
	
	
		
 
.. _enable_ldap:

			




	
	
	
		
 

			




	
	
	
		
 
Enable LDAP : required

			




	
	
	
		
 
    Whether to use LDAP for authenticating users.

			




	
	
	
		
 

			




	
	
	
		
 
.. _ldap_host:

			




	
	
	
		
 

			




	
	
	
		
 
Host : required

			




	
	
	
		
 
    LDAP server hostname or IP address. Can be also a comma separated

			




	
	
	
		
 
    list of servers to support LDAP fail-over.

			




	
	
	
		
 

			




	
	
	
		
 
.. _Port:

			




	
	
	
		
 

			




	
	
	
		
 
Port : required

			




	
	
	
		
 
    389 for un-encrypted LDAP, 636 for SSL-encrypted LDAP.

			




	
	
	
		
 

			




	
	
	
		
 
.. _ldap_account:

			




	
	
	
		
 

			




	
	
	
		
 
Account : optional

			




	
	
	
		
 
    Only required if the LDAP server does not allow anonymous browsing of

			




	
	
	
		
 
    records.  This should be a special account for record browsing.  This

			




	
	
	
		
 
    will require `LDAP Password`_ below.

			




	
	
	
		
 

			




	
	
	
		
 
.. _LDAP Password:

			




	
	
	
		
 

			




	
	
	
		
 
Password : optional

			




	
	
	
		
 
    Only required if the LDAP server does not allow anonymous browsing of

			




	
	
	
		
 
    records.

			




	
	
	
		
 

			




	
	
	
		
 
.. _Enable LDAPS:

			




	
	
	
		
 

			




	
	
	
		
 
Connection Security : required

			




	
	
	
		
 
    Defines the connection to LDAP server

			




	
	
	
		
 

			




	
	
	
		
 
    No encryption

			




	
	
	
		
 
        Plain non encrypted connection

			




	
	
	
		
 

			




	
	
	
		
 
    LDAPS connection

			




	
	
	
		
 
        Enable LDAPS connections. It will likely require `Port`_ to be set to

			




	
	
	
		
 
        a different value (standard LDAPS port is 636). When LDAPS is enabled

			




	
	
	
		
 
        then `Certificate Checks`_ is required.

			




	
	
	
		
 

			




	
	
	
		
 
    START_TLS on LDAP connection

			




	
	
	
		
 
        START TLS connection

			




	
	
	
		
 

			




	
	
	
		
 
.. _Certificate Checks:

			




	
	
	
		
 

			




	
	
	
		
 
Certificate Checks : optional

			




	
	
	
		
 
    How SSL certificates verification is handled -- this is only useful when

			




	
	
	
		
 
    `Enable LDAPS`_ is enabled.  Only DEMAND or HARD offer full SSL security

			




	
	
	
		
 
    while the other options are susceptible to man-in-the-middle attacks.  SSL

			




	
	
	
		
 
    certificates can be installed to /etc/openldap/cacerts so that the

			




	
	
	
		
 
    DEMAND or HARD options can be used with self-signed certificates or

			




	
	
	
		
 
    certificates that do not have traceable certificates of authority.

			




	
	
	
		
 

			




	
	
	
		
 
    NEVER

			




	
	
	
		
 
        A serve certificate will never be requested or checked.

			




	
	
	
		
 

			




	
	
	
		
 
    ALLOW

			




	
	
	
		
 
        A server certificate is requested.  Failure to provide a

			




	
	
	
		
 
        certificate or providing a bad certificate will not terminate the

			




	
	
	
		
 
        session.

			




	
	
	
		
 

			




	
	
	
		
 
    TRY

			




	
	
	
		
 
        A server certificate is requested.  Failure to provide a

			




	
	
	
		
 
        certificate does not halt the session; providing a bad certificate

			




	
	
	
		
 
        halts the session.

			




	
	
	
		
 

			




	
	
	
		
 
    DEMAND

			




	
	
	
		
 
        A server certificate is requested and must be provided and

			




	
	
	
		
 
        authenticated for the session to proceed.

			




	
	
	
		
 

			




	
	
	
		
 
    HARD

			




	
	
	
		
 
        The same as DEMAND.

			




	
	
	
		
 

			




	
	
	
		
 
.. _Base DN:

			




	
	
	
		
 

			




	
	
	
		
 
Base DN : required

			




	
	
	
		
 
    The Distinguished Name (DN) where searches for users will be performed.

			




	
	
	
		
 
    Searches can be controlled by `LDAP Filter`_ and `LDAP Search Scope`_.

			




	
	
	
		
 

			




	
	
	
		
 
.. _LDAP Filter:

			




	
	
	
		
 

			




	
	
	
		
 
LDAP Filter : optional

			




	
	
	
		
 
    A LDAP filter defined by RFC 2254.  This is more useful when `LDAP

			




	
	
	
		
 
    Search Scope`_ is set to SUBTREE.  The filter is useful for limiting

			




	
	
	
		
 
    which LDAP objects are identified as representing Users for

			




	
	
	
		
 
    authentication.  The filter is augmented by `Login Attribute`_ below.

			




	
	
	
		
 
    This can commonly be left blank.

			




	
	
	
		
 

			




	
	
	
		
 
.. _LDAP Search Scope:

			




	
	
	
		
 

			




	
	
	
		
 
LDAP Search Scope : required

			




	
	
	
		
 
    This limits how far LDAP will search for a matching object.

			




	
	
	
		
 

			




	
	
	
		
 
    BASE

			




	
	
	
		
 
        Only allows searching of `Base DN`_ and is usually not what you

			




	
	
	
		
 
        want.

			




	
	
	
		
 

			




	
	
	
		
 
    ONELEVEL

			




	
	
	
		
 
        Searches all entries under `Base DN`_, but not Base DN itself.

			




	
	
	
		
 

			




	
	
	
		
 
    SUBTREE

			




	
	
	
		
 
        Searches all entries below `Base DN`_, but not Base DN itself.

			




	
	
	
		
 
        When using SUBTREE `LDAP Filter`_ is useful to limit object

			




	
	
	
		
 
        location.

			




	
	
	
		
 

			




	
	
	
		
 
.. _Login Attribute:

			




	
	
	
		
 

			




	
	
	
		
 
Login Attribute : required

			




	
	
	
		
 
    The LDAP record attribute that will be matched as the USERNAME or

			




	
	
	
		
 
    ACCOUNT used to connect to Kallithea.  This will be added to `LDAP

			




	
	
	
		
 
    Filter`_ for locating the User object.  If `LDAP Filter`_ is specified as

			




	
	
	
		
 
    "LDAPFILTER", `Login Attribute`_ is specified as "uid" and the user has

			




	
	
	
		
 
    connected as "jsmith" then the `LDAP Filter`_ will be augmented as below

			




	
	
	
		
 
    ::

			




	
	
	
		
 

			




	
	
	
		
 
        (&(LDAPFILTER)(uid=jsmith))

			




	
	
	
		
 

			




	
	
	
		
 
.. _ldap_attr_firstname:

			




	
	
	
		
 

			




	
	
	
		
 
First Name Attribute : required

			




	
	
	
		
 
    The LDAP record attribute which represents the user's first name.

			




	
	
	
		
 

			




	
	
	
		
 
.. _ldap_attr_lastname:

			




	
	
	
		
 

			




	
	
	
		
 
Last Name Attribute : required

			




	
	
	
		
 
    The LDAP record attribute which represents the user's last name.

			




	
	
	
		
 

			




	
	
	
		
 
.. _ldap_attr_email:

			




	
	
	
		
 

			




	
	
	
		
 
Email Attribute : required

			




	
	
	
		
 
    The LDAP record attribute which represents the user's email address.

			




	
	
	
		
 

			




	
	
	
		
 
If all data are entered correctly, and python-ldap_ is properly installed

			




	
	
	
		
 
users should be granted access to Kallithea with LDAP accounts.  At this

			




	
	
	
		
 
time user information is copied from LDAP into the Kallithea user database.

			




	
	
	
		
 
This means that updates of an LDAP user object may not be reflected as a

			




	
	
	
		
 
user update in Kallithea.

			




	
	
	
		
 

			




	
	
	
		
 
If You have problems with LDAP access and believe You entered correct

			




	
	
	
		
 
information check out the Kallithea logs, any error messages sent from LDAP

			




	
	
	
		
 
will be saved there.

			




	
	
	
		
 

			




	
	
	
		
 
Active Directory

			




	
	
	
		
 
''''''''''''''''

			




	
	
	
		
 

			




	
	
	
		
 
Kallithea can use Microsoft Active Directory for user authentication.  This

			




	
	
	
		
 
is done through an LDAP or LDAPS connection to Active Directory.  The

			




	
	
	
		
 
following LDAP configuration settings are typical for using Active

			




	
	
	
		
 
Directory ::

			




	
	
	
		
 

			




	
	
	
		
 
 Base DN              = OU=SBSUsers,OU=Users,OU=MyBusiness,DC=v3sys,DC=local

			




	
	
	
		
 
 Login Attribute      = sAMAccountName

			




	
	
	
		
 
 First Name Attribute = givenName

			




	
	
	
		
 
 Last Name Attribute  = sn

			




	
	
	
		
 
 Email Attribute     = mail

			




	
	
	
		
 

			




	
	
	
		
 
All other LDAP settings will likely be site-specific and should be

			




	
	
	
		
 
appropriately configured.

			




	
	
	
		
 

			




	
	
	
		
 

			




	
	
	
		
 
Authentication by container or reverse-proxy

			




	
	
	
		
 
--------------------------------------------

			




	
	
	
		
 

			




	
	
	
		
 
Kallithea supports delegating the authentication

			




	
	
	
		
 
of users to its WSGI container, or to a reverse-proxy server through which all

			




	
	
	
		
 
clients access the application.

			




	
	
	
		
 

			




	
	
	
		
 
When these authentication methods are enabled in Kallithea, it uses the

			




	
	
	
		
 
username that the container/proxy (Apache or Nginx, etc.) provides and doesn't

			




	
	
	
		
 
perform the authentication itself. The authorization, however, is still done by

			




	
	
	
		
 
Kallithea according to its settings.

			




	
	
	
		
 

			




	
	
	
		
 
When a user logs in for the first time using these authentication methods,

			




	
	
	
		
 
a matching user account is created in Kallithea with default permissions. An

			




	
	
	
		
 
administrator can then modify it using Kallithea's admin interface.

			




	
	
	
		
 

			




	
	
	
		
 
It's also possible for an administrator to create accounts and configure their

			




	
	
	
		
 
permissions before the user logs in for the first time, using the :ref:`create-user` API.

			




	
	
	
		
 

			




	
	
	
		
 
Container-based authentication

			




	
	
	
		
 
''''''''''''''''''''''''''''''

			




	
	
	
		
 

			




	
	
	
		
 
In a container-based authentication setup, Kallithea reads the user name from

			




	
	
	
		
 
the ``REMOTE_USER`` server variable provided by the WSGI container.

			




	
	
	
		
 

			




	
	
	
		
 
After setting up your container (see `Apache with mod_wsgi`_), you'll need

			




	
	
	
		
 
to configure it to require authentication on the location configured for

			




	
	
	
		
 
Kallithea.

			




	
	
	
		
 

			




	
	
	
		
 
Proxy pass-through authentication

			




	
	
	
		
 
'''''''''''''''''''''''''''''''''

			




	
	
	
		
 

			




	
	
	
		
 
In a proxy pass-through authentication setup, Kallithea reads the user name

			




	
	
	
		
 
from the ``X-Forwarded-User`` request header, which should be configured to be

			




	
	
	
		
 
sent by the reverse-proxy server.

			




	
	
	
		
 

			




	
	
	
		
 
After setting up your proxy solution (see `Apache virtual host reverse proxy example`_,

			




	
	
	
		
 
`Apache as subdirectory`_ or `Nginx virtual host example`_), you'll need to

			




	
	
	
		
 
configure the authentication and add the username in a request header named

			




	
	
	
		
 
``X-Forwarded-User``.

			




	
	
	
		
 

			




	
	
	
		
 
For example, the following config section for Apache sets a subdirectory in a

			




	
	
	
		
 
reverse-proxy setup with basic auth:

			




	
	
	
		
 

			




	
	
	
		
 
.. code-block:: apache

			




	
	
	
		
 

			




	
	
	
		
 
    <Location /someprefix>

			




	
	
	
		
 
      ProxyPass http://127.0.0.1:5000/someprefix

			




	
	
	
		
 
      ProxyPassReverse http://127.0.0.1:5000/someprefix

			




	
	
	
		
 
      SetEnvIf X-Url-Scheme https HTTPS=1

			




	
	
	
		
 

			




	
	
	
		
 
      AuthType Basic

			




	
	
	
		
 
      AuthName "Kallithea authentication"

			




	
	
	
		
 
      AuthUserFile /srv/kallithea/.htpasswd

			




	
	
	
		
 
      Require valid-user

			




	
	
	
		
 

			




	
	
	
		
 
      RequestHeader unset X-Forwarded-User

			




	
	
	
		
 

			




	
	
	
		
 
      RewriteEngine On

			




	
	
	
		
 
      RewriteCond %{LA-U:REMOTE_USER} (.+)

			




	
	
	
		
 
      RewriteRule .* - [E=RU:%1]

			




	
	
	
		
 
      RequestHeader set X-Forwarded-User %{RU}e

			




	
	
	
		
 
    </Location>

			




	
	
	
		
 

			




	
	
	
		
 
.. note::

			




	
	
	
		
 
   If you enable proxy pass-through authentication, make sure your server is

			




	
	
	
		
 
   only accessible through the proxy. Otherwise, any client would be able to

			




	
	
	
		
 
   forge the authentication header and could effectively become authenticated

			




	
	
	
		
 
   using any account of their liking.

			




	
	
	
		
 

			




	
	
	
		
 

			




	
	
	
		
 
Integration with issue trackers

			




	
	
	
		
 
-------------------------------

			




	
	
	
		
 

			




	
	
	
		
 
Kallithea provides a simple integration with issue trackers. It's possible

			




	
	
	
		
 
to define a regular expression that will match an issue ID in commit messages,

			




	
	
	
		
 
and have that replaced with a URL to the issue. To enable this simply

			




	
	
	
		
 
uncomment the following variables in the ini file::

			




	
	
	
		
 

			




	
	
	
		
 
    issue_pat = (?:^#|\s#)(\w+)

			




	
	
	
		
 
    issue_server_link = https://myissueserver.com/{repo}/issue/{id}

			




	
	
	
		
 
    issue_server_link = https://issues.example.com/{repo}/issue/{id}

			




	
	
	
		
 
    issue_prefix = #

			




	
	
	
		
 

			




	
	
	
		
 
``issue_pat`` is the regular expression describing which strings in

			




	
	
	
		
 
commit messages will be treated as issue references. A match group in

			




	
	
	
		
 
parentheses should be used to specify the actual issue id.

			




	
	
	
		
 

			




	
	
	
		
 
The default expression matches issues in the format ``#<number>``, e.g., ``#300``.

			




	
	
	
		
 

			




	
	
	
		
 
Matched issue references are replaced with the link specified in

			




	
	
	
		
 
``issue_server_link``. ``{id}`` is replaced with the issue ID, and

			




	
	
	
		
 
``{repo}`` with the repository name.  Since the # is stripped away,

			




	
	
	
		
 
``issue_prefix`` is prepended to the link text.  ``issue_prefix`` doesn't

			




	
	
	
		
 
necessarily need to be ``#``: if you set issue prefix to ``ISSUE-`` this will

			




	
	
	
		
 
generate a URL in the format:

			




	
	
	
		
 

			




	
	
	
		
 
.. code-block:: html

			




	
	
	
		
 

			




	
	
	
		
 
  <a href="https://myissueserver.com/example_repo/issue/300">ISSUE-300</a>

			




	
	
	
		
 
  <a href="https://issues.example.com/example_repo/issue/300">ISSUE-300</a>

			




	
	
	
		
 

			




	
	
	
		
 
If needed, more than one pattern can be specified by appending a unique suffix to

			




	
	
	
		
 
the variables. For example::

			




	
	
	
		
 

			




	
	
	
		
 
    issue_pat_wiki = (?:wiki-)(.+)

			




	
	
	
		
 
    issue_server_link_wiki = https://mywiki.com/{id}

			




	
	
	
		
 
    issue_server_link_wiki = https://wiki.example.com/{id}

			




	
	
	
		
 
    issue_prefix_wiki = WIKI-

			




	
	
	
		
 

			




	
	
	
		
 
With these settings, wiki pages can be referenced as wiki-some-id, and every

			




	
	
	
		
 
such reference will be transformed into:

			




	
	
	
		
 

			




	
	
	
		
 
.. code-block:: html

			




	
	
	
		
 

			




	
	
	
		
 
  <a href="https://mywiki.com/some-id">WIKI-some-id</a>

			




	
	
	
		
 
  <a href="https://wiki.example.com/some-id">WIKI-some-id</a>

			




	
	
	
		
 

			




	
	
	
		
 

			




	
	
	
		
 
Hook management

			




	
	
	
		
 
---------------

			




	
	
	
		
 

			




	
	
	
		
 
Hooks can be managed in similar way to that used in ``.hgrc`` files.

			




	
	
	
		
 
To manage hooks, choose *Admin > Settings > Hooks*.

			




	
	
	
		
 

			




	
	
	
		
 
The built-in hooks cannot be modified, though they can be enabled or disabled in the *VCS* section.

			




	
	
	
		
 

			




	
	
	
		
 
To add another custom hook simply fill in the first textbox with

			




	
	
	
		
 
``<name>.<hook_type>`` and the second with the hook path. Example hooks

			




	
	
	
		
 
can be found in ``kallithea.lib.hooks``.

			




	
	
	
		
 

			




	
	
	
		
 

			




	
	
	
		
 
Changing default encoding

			




	
	
	
		
 
-------------------------

			




	
	
	
		
 

			




	
	
	
		
 
By default, Kallithea uses UTF-8 encoding.

			




	
	
	
		
 
This is configurable as ``default_encoding`` in the .ini file.

			




	
	
	
		
 
This affects many parts in Kallithea including user names, filenames, and

			




	
	
	
		
 
encoding of commit messages. In addition Kallithea can detect if the ``chardet``

			




	
	
	
		
 
library is installed. If ``chardet`` is detected Kallithea will fallback to it

			




	
	
	
		
 
when there are encode/decode errors.

			




	
	
	
		
 

			




	
	
	
		
 

			




	
	
	
		
 
Celery configuration

			




	
	
	
		
 
--------------------

			




	
	
	
		
 

			




	
	
	
		
 
Kallithea can use the distributed task queue system Celery_ to run tasks like

			




	
	
	
		
 
cloning repositories or sending emails.

			




	
	
	
		
 

			




	
	
	
		
 
Kallithea will in most setups work perfectly fine out of the box (without

			




	
	
	
		
 
Celery), executing all tasks in the web server process. Some tasks can however

			




	
	
	
		
 
take some time to run and it can be better to run such tasks asynchronously in

			




	
	
	
		
 
a separate process so the web server can focus on serving web requests.

			




	
	
	
		
 

			




	
	
	
		
 
For installation and configuration of Celery, see the `Celery documentation`_.

			




	
	
	
		
 
Note that Celery requires a message broker service like RabbitMQ_ (recommended)

			




	
	
	
		
 
or Redis_.

			




	
	
	
		
 

			




	
	
	
		
 
The use of Celery is configured in the Kallithea ini configuration file.

			




	
	
	
		
 
To enable it, simply set::

			




	
	
	
		
 

			




	
	
	
		
 
  use_celery = true

			




	
	
	
		
 

			




	
	
	
		
 
and add or change the ``celery.*`` and ``broker.*`` configuration variables.

			




	
	
	
		
 

			




	
	
	
		
 
Remember that the ini files use the format with '.' and not with '_' like

			




	
	
	
		
 
Celery. So for example setting `BROKER_HOST` in Celery means setting

			




	
	
	
		
 
`broker.host` in the configuration file.

			




	
	
	
		
 

			




	
	
	
		
 
To start the Celery process, run::

			




	
	
	
		
 

			




	
	
	
		
 
 paster celeryd <configfile.ini>

			




	
	
	
		
 

			




	
	
	
		
 
.. note::

			




	
	
	
		
 
   Make sure you run this command from the same virtualenv, and with the same

			




	
	
	
		
 
   user that Kallithea runs.

			




	
	
	
		
 

			




	
	
	
		
 

			




	
	
	
		
 
HTTPS support

			




	
	
	
		
 
-------------

			




	
	
	
		
 

			




	
	
	
		
 
Kallithea will by default generate URLs based on the WSGI environment.

			




	
	
	
		
 

			




	
	
	
		
 
Alternatively, you can use some special configuration settings to control

			




	
	
	
		
 
directly which scheme/protocol Kallithea will use when generating URLs:

			




	
	
	
		
 

			




	
	
	
		
 
- With ``https_fixup = true``, the scheme will be taken from the

			




	
	
	
		
 
  ``X-Url-Scheme``, ``X-Forwarded-Scheme`` or ``X-Forwarded-Proto`` HTTP header

			




	
	
	
		
 
  (default ``http``).

			




	
	
	
		
 
- With ``force_https = true`` the default will be ``https``.

			




	
	
	
		
 
- With ``use_htsts = true``, Kallithea will set ``Strict-Transport-Security`` when using https.

			




	
	
	
		
 

			




	
	
	
		
 

			




	
	
	
		
 
Nginx virtual host example

			




	
	
	
		
 
--------------------------

			




	
	
	
		
 

			




	
	
	
		
 
Sample config for Nginx using proxy:

			




	
	
	
		
 

			




	
	
	
		
 
.. code-block:: nginx

			




	
	
	
		
 

			




	
	
	
		
 
    upstream kallithea {

			




	
	
	
		
 
        server 127.0.0.1:5000;

			




	
	
	
		
 
        # add more instances for load balancing

			




	
	
	
		
 
        #server 127.0.0.1:5001;

			




	
	
	
		
 
        #server 127.0.0.1:5002;

			




	
	
	
		
 
    }

			




	
	
	
		
 

			




	
	
	
		
 
    ## gist alias

			




	
	
	
		
 
    server {

			




	
	
	
		
 
       listen          443;

			




	
	
	
		
 
       server_name     gist.myserver.com;

			




	
	
	
		
 
       server_name     gist.example.com;

			




	
	
	
		
 
       access_log      /var/log/nginx/gist.access.log;

			




	
	
	
		
 
       error_log       /var/log/nginx/gist.error.log;

			




	
	
	
		
 

			




	
	
	
		
 
       ssl on;

			




	
	
	
		
 
       ssl_certificate     gist.your.kallithea.server.crt;

			




	
	
	
		
 
       ssl_certificate_key gist.your.kallithea.server.key;

			




	
	
	
		
 

			




	
	
	
		
 
       ssl_session_timeout 5m;

			




	
	
	
		
 

			




	
	
	
		
 
       ssl_protocols SSLv3 TLSv1;

			




	
	
	
		
 
       ssl_ciphers DHE-RSA-AES256-SHA:DHE-RSA-AES128-SHA:EDH-RSA-DES-CBC3-SHA:AES256-SHA:DES-CBC3-SHA:AES128-SHA:RC4-SHA:RC4-MD5;

			




	
	
	
		
 
       ssl_prefer_server_ciphers on;

			




	
	
	
		
 

			




	
	
	
		
 
       rewrite ^/(.+)$ https://your.kallithea.server/_admin/gists/$1;

			




	
	
	
		
 
       rewrite (.*)    https://your.kallithea.server/_admin/gists;

			




	
	
	
		
 
       rewrite ^/(.+)$ https://kallithea.example.com/_admin/gists/$1;

			




	
	
	
		
 
       rewrite (.*)    https://kallithea.example.com/_admin/gists;

			




	
	
	
		
 
    }

			




	
	
	
		
 

			




	
	
	
		
 
    server {

			




	
	
	
		
 
       listen          443;

			




	
	
	
		
 
       server_name     your.kallithea.server;

			




	
	
	
		
 
       server_name     kallithea.example.com

			




	
	
	
		
 
       access_log      /var/log/nginx/kallithea.access.log;

			




	
	
	
		
 
       error_log       /var/log/nginx/kallithea.error.log;

			




	
	
	
		
 

			




	
	
	
		
 
       ssl on;

			




	
	
	
		
 
       ssl_certificate     your.kallithea.server.crt;

			




	
	
	
		
 
       ssl_certificate_key your.kallithea.server.key;

			




	
	
	
		
 

			




	
	
	
		
 
       ssl_session_timeout 5m;

			




	
	
	
		
 

			




	
	
	
		
 
       ssl_protocols SSLv3 TLSv1;

			




	
	
	
		
 
       ssl_ciphers DHE-RSA-AES256-SHA:DHE-RSA-AES128-SHA:EDH-RSA-DES-CBC3-SHA:AES256-SHA:DES-CBC3-SHA:AES128-SHA:RC4-SHA:RC4-MD5;

			




	
	
	
		
 
       ssl_prefer_server_ciphers on;

			




	
	
	
		
 

			




	
	
	
		
 
       ## uncomment root directive if you want to serve static files by nginx

			




	
	
	
		
 
       ## requires static_files = false in .ini file

			




	
	
	
		
 
       #root /path/to/installation/kallithea/public;

			




	
	
	
		
 
       include         /etc/nginx/proxy.conf;

			




	
	
	
		
 
       location / {

			




	
	
	
		
 
            try_files $uri @kallithea;

			




	
	
	
		
 
       }

			




	
	
	
		
 

			




	
	
	
		
 
       location @kallithea {

			




	
	
	
		
 
            proxy_pass      http://127.0.0.1:5000;

			




	
	
	
		
 
       }

			




	
	
	
		
 

			




	
	
	
		
 
    }

			




	
	
	
		
 

			




	
	
	
		
 
Here's the proxy.conf. It's tuned so it will not timeout on long

			




	
	
	
		
 
pushes or large pushes::

			




	
	
	
		
 

			




	
	
	
		
 
    proxy_redirect              off;

			




	
	
	
		
 
    proxy_set_header            Host $host;

			




	
	
	
		
 
    ## needed for container auth

			




	
	
	
		
 
    #proxy_set_header            REMOTE_USER $remote_user;

			




	
	
	
		
 
    #proxy_set_header            X-Forwarded-User $remote_user;

			




	
	
	
		
 
    proxy_set_header            X-Url-Scheme $scheme;

			




	
	
	
		
 
    proxy_set_header            X-Host $http_host;

			




	
	
	
		
 
    proxy_set_header            X-Real-IP $remote_addr;

			




	
	
	
		
 
    proxy_set_header            X-Forwarded-For $proxy_add_x_forwarded_for;

			




	
	
	
		
 
    proxy_set_header            Proxy-host $proxy_host;

			




	
	
	
		
 
    proxy_buffering             off;

			




	
	
	
		
 
    proxy_connect_timeout       7200;

			




	
	
	
		
 
    proxy_send_timeout          7200;

			




	
	
	
		
 
    proxy_read_timeout          7200;

			




	
	
	
		
 
    proxy_buffers               8 32k;

			




	
	
	
		
 
    client_max_body_size        1024m;

			




	
	
	
		
 
    client_body_buffer_size     128k;

			




	
	
	
		
 
    large_client_header_buffers 8 64k;

			




	
	
	
		
 

			




	
	
	
		
 

			




	
	
	
		
 
Apache virtual host reverse proxy example

			




	
	
	
		
 
-----------------------------------------

			




	
	
	
		
 

			




	
	
	
		
 
Here is a sample configuration file for Apache using proxy:

			




	
	
	
		
 

			




	
	
	
		
 
.. code-block:: apache

			




	
	
	
		
 

			




	
	
	
		
 
    <VirtualHost *:80>

			




	
	
	
		
 
            ServerName hg.myserver.com

			




	
	
	
		
 
            ServerName kallithea.example.com

			




	
	
	
		
 

			




	
	
	
		
 
            <Proxy *>

			




	
	
	
		
 
              # For Apache 2.4 and later:

			




	
	
	
		
 
              Require all granted

			




	
	
	
		
 

			




	
	
	
		
 
              # For Apache 2.2 and earlier, instead use:

			




	
	
	
		
 
              # Order allow,deny

			




	
	
	
		
 
              # Allow from all

			




	
	
	
		
 
            </Proxy>

			




	
	
	
		
 

			




	
	
	
		
 
            #important !

			




	
	
	
		
 
            #Directive to properly generate url (clone url) for pylons

			




	
	
	
		
 
            ProxyPreserveHost On

			




	
	
	
		
 

			




	
	
	
		
 
            #kallithea instance

			




	
	
	
		
 
            ProxyPass / http://127.0.0.1:5000/

			




	
	
	
		
 
            ProxyPassReverse / http://127.0.0.1:5000/

			




	
	
	
		
 

			




	
	
	
		
 
            #to enable https use line below

			




	
	
	
		
 
            #SetEnvIf X-Url-Scheme https HTTPS=1

			




	
	
	
		
 
    </VirtualHost>

			




	
	
	
		
 

			




	
	
	
		
 
Additional tutorial

			




	
	
	
		
 
http://pylonsbook.com/en/1.1/deployment.html#using-apache-to-proxy-requests-to-pylons

			




	
	
	
		
 

			




	
	
	
		
 

			




	
	
	
		
 
Apache as subdirectory

			




	
	
	
		
 
----------------------

			




	
	
	
		
 

			




	
	
	
		
 
Apache subdirectory part:

			




	
	
	
		
 

			




	
	
	
		
 
.. code-block:: apache

			




	
	
	
		
 

			




	
	
	
		
 
    <Location /<someprefix> >

			




	
	
	
		
 
      ProxyPass http://127.0.0.1:5000/<someprefix>

			




	
	
	
		
 
      ProxyPassReverse http://127.0.0.1:5000/<someprefix>

			




	
	
	
		
 
      SetEnvIf X-Url-Scheme https HTTPS=1

			




	
	
	
		
 
    </Location>

			




	
	
	
		
 

			




	
	
	
		
 
Besides the regular apache setup you will need to add the following line

			




	
	
	
		
 
into ``[app:main]`` section of your .ini file::

			




	
	
	
		
 

			




	
	
	
		
 
    filter-with = proxy-prefix

			




	
	
	
		
 

			




	
	
	
		
 
Add the following at the end of the .ini file::

			




	
	
	
		
 

			




	
	
	
		
 
    [filter:proxy-prefix]

			




	
	
	
		
 
    use = egg:PasteDeploy#prefix

			




	
	
	
		
 
    prefix = /<someprefix>

			




	
	
	
		
 

			




	
	
	
		
 
then change ``<someprefix>`` into your chosen prefix

			




	
	
	
		
 

			




	
	
	
		
 

			




	
	
	
		
 
Apache with mod_wsgi

			




	
	
	
		
 
--------------------

			




	
	
	
		
 

			




	
	
	
		
 
Alternatively, Kallithea can be set up with Apache under mod_wsgi. For

			




	
	
	
		
 
that, you'll need to:

			




	
	
	
		
 

			




	
	
	
		
 
- Install mod_wsgi. If using a Debian-based distro, you can install

			




	
	
	
		
 
  the package libapache2-mod-wsgi::

			




	
	
	
		
 

			




	
	
	
		
 
    aptitude install libapache2-mod-wsgi

			




	
	
	
		
 

			




	
	
	
		
 
- Enable mod_wsgi::

			




	
	
	
		
 

			




	
	
	
		
 
    a2enmod wsgi

			




	
	
	
		
 

			




	
	
	
		
 
- Create a wsgi dispatch script, like the one below. Make sure you

			




	
	
	
		
 
  check that the paths correctly point to where you installed Kallithea

			




	
	
	
		
 
  and its Python Virtual Environment.

			




	
	
	
		
 
- Enable the ``WSGIScriptAlias`` directive for the WSGI dispatch script,

			




	
	
	
		
 
  as in the following example. Once again, check the paths are

			




	
	
	
		
 
  correctly specified.

			




	
	
	
		
 

			




	
	
	
		
 
Here is a sample excerpt from an Apache Virtual Host configuration file:

			




	
	
	
		
 

			




	
	
	
		
 
.. code-block:: apache

			




	
	
	
		
 

			




	
	
	
		
 
    WSGIDaemonProcess kallithea \

			




	
	
	
		
 
        processes=1 threads=4 \

			




	
	
	
		
 
        python-path=/srv/kallithea/pyenv/lib/python2.7/site-packages

			




	
	
	
		
 
    WSGIScriptAlias / /srv/kallithea/dispatch.wsgi

			




	
	
	
		
 
    WSGIPassAuthorization On

			




	
	
	
		
 

			




	
	
	
		
 
Or if using a dispatcher WSGI script with proper virtualenv activation:

			




	
	
	
		
 

			




	
	
	
		
 
.. code-block:: apache

			




	
	
	
		
 

			




	
	
	
		
 
    WSGIDaemonProcess kallithea processes=1 threads=4

			




	
	
	
		
 
    WSGIScriptAlias / /srv/kallithea/dispatch.wsgi

			




	
	
	
		
 
    WSGIPassAuthorization On

			




	
	
	
		
 

			




	
	
	
		
 
.. note::

			




	
	
	
		
 
   When running apache as root, please make sure it doesn't run Kallithea as

			




	
	
	
		
 
   root, for examply by adding: ``user=www-data group=www-data`` to the configuration.

			




	
	
	
		
 

			




	
	
	
		
 
.. note::

			




	
	
	
		
 
   If running Kallithea in multiprocess mode,

			




	
	
	
		
 
   make sure you set ``instance_id = *`` in the configuration so each process

			




	
	
	
		
 
   gets it's own cache invalidation key.

			




	
	
	
		
 

			




	
	
	
		
 
Example WSGI dispatch script:

			




	
	
	
		
 

			




	
	
	
		
 
.. code-block:: python

			




	
	
	
		
 

			




	
	
	
		
 
    import os

			




	
	
	
		
 
    os.environ["HGENCODING"] = "UTF-8"

			




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

			




	
	
	
		
 

			




	
	
	
		
 
    # sometimes it's needed to set the curent dir

			




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

			




	
	
	
		
 

			




	
	
	
		
 
    import site

			




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

			




	
	
	
		
 

			




	
	
	
		
 
    from paste.deploy import loadapp

			




	
	
	
		
 
    from paste.script.util.logging_config import fileConfig

			




	
	
	
		
 

			




	
	
	
		
 
    fileConfig('/srv/kallithea/my.ini')

			




	
	
	
		
 
    application = loadapp('config:/srv/kallithea/my.ini')

			




	
	
	
		
 

			




	
	
	
		
 
Or using proper virtualenv activation:

			




	
	
	
		
 

			




	
	
	
		
 
.. code-block:: python

			




	
	
	
		
 

			




	
	
	
		
 
    activate_this = '/srv/kallithea/venv/bin/activate_this.py'

			




	
	
	
		
 
    execfile(activate_this, dict(__file__=activate_this))

			




	
	
	
		
 

			




	
	
	
		
 
    import os

			




	
	
	
		
 
    os.environ['HOME'] = '/srv/kallithea'

			




	
	
	
		
 

			




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

			




	
	
	
		
 
    from paste.script.util.logging_config import fileConfig

			




	
	
	
		
 
    fileConfig(ini)

			




	
	
	
		
 
    from paste.deploy import loadapp

			




	
	
	
		
 
    application = loadapp('config:' + ini)

			




	
	
	
		
 

			




	
	
	
		
 

			




	
	
	
		
 
Other configuration files

			




	
	
	
		
 
-------------------------

			




	
	
	
		
 

			




	
	
	
		
 
A number of `example init.d scripts`__ can be found in

			




	
	
	
		
 
the ``init.d`` directory of the Kallithea source.

			




	
	
	
		
 

			




	
	
	
		
 
.. __: https://kallithea-scm.org/repos/kallithea/files/tip/init.d/ .

			




	
	
	
		
 

			




	
	
	
		
 

			




	
	
	
		
 
.. _virtualenv: http://pypi.python.org/pypi/virtualenv

			




	
	
	
		
 
.. _python: http://www.python.org/

			




	
	
	
		
 
.. _Mercurial: http://mercurial.selenic.com/

			




	
	
	
		
 
.. _Celery: http://celeryproject.org/

			




	
	
	
		
 
.. _Celery documentation: http://docs.celeryproject.org/en/latest/getting-started/index.html

			




	
	
	
		
 
.. _RabbitMQ: http://www.rabbitmq.com/

			




	
	
	
		
 
.. _Redis: http://redis.io/

			




	
	
	
		
 
.. _python-ldap: http://www.python-ldap.org/

			




	
	
	
		
 
.. _mercurial-server: http://www.lshift.net/mercurial-server.html

			




	
	
	
		
 
.. _PublishingRepositories: http://mercurial.selenic.com/wiki/PublishingRepositories

			




        

    


    
    

    

        

                

                    docs/usage/general.rst
                

                

                  
                      
                        

                      ➞

                      
                        
                  

                  
                      
                  
                      
                  
                      
                  
                      
                  
                  
                

                

                    Show inline comments
                    
                

        

        

            



	
	
	
		
 
.. _general:

			




	
	
	
		
 

			




	
	
	
		
 
=======================

			




	
	
	
		
 
General Kallithea usage

			




	
	
	
		
 
=======================

			




	
	
	
		
 

			




	
	
	
		
 

			




	
	
	
		
 
Repository deletion

			




	
	
	
		
 
-------------------

			




	
	
	
		
 

			




	
	
	
		
 
Currently when an admin or owner deletes a repository, Kallithea does

			




	
	
	
		
 
not physically delete said repository from the filesystem, but instead

			




	
	
	
		
 
renames it in a special way so that it is not possible to push, clone

			




	
	
	
		
 
or access the repository.

			




	
	
	
		
 

			




	
	
	
		
 
There is a special command for cleaning up such archived repositories::

			




	
	
	
		
 

			




	
	
	
		
 
    paster cleanup-repos --older-than=30d my.ini

			




	
	
	
		
 

			




	
	
	
		
 
This command scans for archived repositories that are older than

			




	
	
	
		
 
30 days, displays them, and asks if you want to delete them (unless given

			




	
	
	
		
 
the ``--dont-ask`` flag). If you host a large amount of repositories with

			




	
	
	
		
 
forks that are constantly being deleted, it is recommended that you run this

			




	
	
	
		
 
command via crontab.

			




	
	
	
		
 

			




	
	
	
		
 
It is worth noting that even if someone is given administrative access to

			




	
	
	
		
 
Kallithea and deletes a repository, you can easily restore such an action by

			




	
	
	
		
 
renaming the repository directory, removing the ``rm__<date>`` prefix.

			




	
	
	
		
 

			




	
	
	
		
 

			




	
	
	
		
 
File view: follow current branch

			




	
	
	
		
 
--------------------------------

			




	
	
	
		
 

			




	
	
	
		
 
In the file view, left and right arrows allow to jump to the previous and next

			




	
	
	
		
 
revision. Depending on the way revisions were created in the repository, this

			




	
	
	
		
 
could jump to a different branch.  When the checkbox ``Follow current branch``

			




	
	
	
		
 
is checked, these arrows will only jump to revisions on the same branch as the

			




	
	
	
		
 
currently visible revision.  So for example, if someone is viewing files in the

			




	
	
	
		
 
``beta`` branch and marks the `Follow current branch` checkbox, the < and >

			




	
	
	
		
 
arrows will only show revisions on the ``beta`` branch.

			




	
	
	
		
 

			




	
	
	
		
 

			




	
	
	
		
 
Changelog features

			




	
	
	
		
 
------------------

			




	
	
	
		
 

			




	
	
	
		
 
The core feature of a repository's ``changelog`` page is to show the revisions

			




	
	
	
		
 
in a repository. However, there are several other features available from the

			




	
	
	
		
 
changelog.

			




	
	
	
		
 

			




	
	
	
		
 
Branch filter

			




	
	
	
		
 
  By default, the changelog shows revisions from all branches in the

			




	
	
	
		
 
  repository. Use the branch filter to restrict to a given branch.

			




	
	
	
		
 

			




	
	
	
		
 
Viewing a changeset

			




	
	
	
		
 
  A particular changeset can be opened by clicking on either the changeset

			




	
	
	
		
 
  hash or the commit message, or by ticking the checkbox and clicking the

			




	
	
	
		
 
  ``Show selected changeset`` button at the top.

			




	
	
	
		
 

			




	
	
	
		
 
Viewing all changes between two changesets

			




	
	
	
		
 
  To get a list of all changesets between two selected changesets, along with

			




	
	
	
		
 
  the changes in each one of them, tick the checkboxes of the first and

			




	
	
	
		
 
  last changeset in the desired range and click the ``Show selected changesets``

			




	
	
	
		
 
  button at the top. You can only show the range between the first and last

			




	
	
	
		
 
  checkbox (no cherry-picking).

			




	
	
	
		
 

			




	
	
	
		
 
  From that page, you can proceed to viewing the overall delta between the

			




	
	
	
		
 
  selected changesets, by clicking the ``Compare revisions`` button.

			




	
	
	
		
 

			




	
	
	
		
 
Creating a pull request

			




	
	
	
		
 
  You can create a new pull request for the changes of a particular changeset

			




	
	
	
		
 
  (and its ancestors) by selecting it and clicking the ``Open new pull request

			




	
	
	
		
 
  for selected changesets`` button.

			




	
	
	
		
 

			




	
	
	
		
 

			




	
	
	
		
 
Permanent repository URLs

			




	
	
	
		
 
-------------------------

			




	
	
	
		
 

			




	
	
	
		
 
Due to the complicated nature of repository grouping, URLs of repositories

			




	
	
	
		
 
can often change. For example, a repository originally accessible from::

			




	
	
	
		
 

			




	
	
	
		
 
  http://example.com/repo_name

			




	
	
	
		
 
  http://kallithea.example.com/repo_name

			




	
	
	
		
 

			




	
	
	
		
 
would get a new URL after moving it to test_group::

			




	
	
	
		
 

			




	
	
	
		
 
  http://example.com/test_group/repo_name

			




	
	
	
		
 
  http://kallithea.example.com/test_group/repo_name

			




	
	
	
		
 

			




	
	
	
		
 
Such moving of a repository to a group can be an issue for build systems and

			




	
	
	
		
 
other scripts where the repository paths are hardcoded. To mitigate this,

			




	
	
	
		
 
Kallithea provides permanent URLs using the repository ID prefixed with an

			




	
	
	
		
 
underscore. In all Kallithea URLs, for example those for the changelog and the

			




	
	
	
		
 
file view, a repository name can be replaced by this ``_ID`` string. Since IDs

			




	
	
	
		
 
are always the same, moving the repository to a different group will not affect

			




	
	
	
		
 
such URLs.

			




	
	
	
		
 

			




	
	
	
		
 
In the example, the repository could also be accessible as::

			




	
	
	
		
 

			




	
	
	
		
 
  http://example.com/_<ID>

			




	
	
	
		
 
  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.

			




	
	
	
		
 

			




	
	
	
		
 

			




	
	
	
		
 
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.server/repo``. Kallithea will then try to login and

			




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

			




	
	
	
		
 

			




	
	
	
		
 
Example usage of such fields would be to define company-specific information

			




	
	
	
		
 
into repositories, e.g., defining a ``repo_manager`` key that would give info

			




	
	
	
		
 
about a manager of each repository.  There's no limit for adding custom fields.

			




	
	
	
		
 
Newly created fields are accessible via the API.

			




	
	
	
		
 

			




	
	
	
		
 
Meta tagging

			




	
	
	
		
 
~~~~~~~~~~~~

			




	
	
	
		
 

			




	
	
	
		
 
In the *Visual* tab, option "Stylify recognised meta tags" will cause Kallithea

			




	
	
	
		
 
to turn certain text fragments in repository and repository group

			




	
	
	
		
 
descriptions into colored tags. Currently recognised tags are::

			




	
	
	
		
 

			




	
	
	
		
 
    [featured]

			




	
	
	
		
 
    [stale]

			




	
	
	
		
 
    [dead]

			




	
	
	
		
 
    [lang => lang]

			




	
	
	
		
 
    [license => License]

			




	
	
	
		
 
    [requires => Repo]

			




	
	
	
		
 
    [recommends => Repo]

			




	
	
	
		
 
    [see => URI]

			




        

    


    
    

    

        

                

                    kallithea/bin/kallithea_api.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.bin.kallithea_api

			




	
	
	
		
 
~~~~~~~~~~~~~~~~~~~~~~~~~~~

			




	
	
	
		
 

			




	
	
	
		
 
Api CLI client for Kallithea

			




	
	
	
		
 

			




	
	
	
		
 
This file was forked by the Kallithea project in July 2014.

			




	
	
	
		
 
Original author and date, and relevant copyright and licensing information is below:

			




	
	
	
		
 
:created_on: Jun 3, 2012

			




	
	
	
		
 
:author: marcink

			




	
	
	
		
 
:copyright: (c) 2013 RhodeCode GmbH, and others.

			




	
	
	
		
 
:license: GPLv3, see LICENSE.md for more details.

			




	
	
	
		
 
"""

			




	
	
	
		
 

			




	
	
	
		
 
import sys

			




	
	
	
		
 
import argparse

			




	
	
	
		
 

			




	
	
	
		
 
from kallithea.bin.base import json, api_call, RcConf, FORMAT_JSON, FORMAT_PRETTY

			




	
	
	
		
 

			




	
	
	
		
 

			




	
	
	
		
 
def argparser(argv):

			




	
	
	
		
 
    usage = (

			




	
	
	
		
 
      "kallithea-api [-h] [--format=FORMAT] [--apikey=APIKEY] [--apihost=APIHOST] "

			




	
	
	
		
 
      "[--config=CONFIG] [--save-config] "

			




	
	
	
		
 
      "METHOD <key:val> <key2:val> ...\n"

			




	
	
	
		
 
      "Create config file: kallithea-api --apikey=<key> --apihost=http://your.kallithea.server --save-config"

			




	
	
	
		
 
      "Create config file: kallithea-api --apikey=<key> --apihost=http://kallithea.example.com --save-config"

			




	
	
	
		
 
    )

			




	
	
	
		
 

			




	
	
	
		
 
    parser = argparse.ArgumentParser(description='Kallithea API cli',

			




	
	
	
		
 
                                     usage=usage)

			




	
	
	
		
 

			




	
	
	
		
 
    ## config

			




	
	
	
		
 
    group = parser.add_argument_group('config')

			




	
	
	
		
 
    group.add_argument('--apikey', help='api access key')

			




	
	
	
		
 
    group.add_argument('--apihost', help='api host')

			




	
	
	
		
 
    group.add_argument('--config', help='config file')

			




	
	
	
		
 
    group.add_argument('--save-config', action='store_true', help='save the given config into a file')

			




	
	
	
		
 

			




	
	
	
		
 
    group = parser.add_argument_group('API')

			




	
	
	
		
 
    group.add_argument('method', metavar='METHOD', nargs='?', type=str, default=None,

			




	
	
	
		
 
            help='API method name to call followed by key:value attributes',

			




	
	
	
		
 
    )

			




	
	
	
		
 
    group.add_argument('--format', dest='format', type=str,

			




	
	
	
		
 
            help='output format default: `%s` can '

			




	
	
	
		
 
                 'be also `%s`' % (FORMAT_PRETTY, FORMAT_JSON),

			




	
	
	
		
 
            default=FORMAT_PRETTY

			




	
	
	
		
 
    )

			




	
	
	
		
 
    args, other = parser.parse_known_args()

			




	
	
	
		
 
    return parser, args, other

			




	
	
	
		
 

			




	
	
	
		
 

			




	
	
	
		
 
def main(argv=None):

			




	
	
	
		
 
    """

			




	
	
	
		
 
    Main execution function for cli

			




	
	
	
		
 

			




	
	
	
		
 
    :param argv:

			




	
	
	
		
 
    """

			




	
	
	
		
 
    if argv is None:

			




	
	
	
		
 
        argv = sys.argv

			




	
	
	
		
 

			




	
	
	
		
 
    conf = None

			




	
	
	
		
 
    parser, args, other = argparser(argv)

			




	
	
	
		
 

			




	
	
	
		
 
    api_credentials_given = (args.apikey and args.apihost)

			




	
	
	
		
 
    if args.save_config:

			




	
	
	
		
 
        if not api_credentials_given:

			




	
	
	
		
 
            raise parser.error('--save-config requires --apikey and --apihost')

			




	
	
	
		
 
        conf = RcConf(config_location=args.config,

			




	
	
	
		
 
                      autocreate=True, config={'apikey': args.apikey,

			




	
	
	
		
 
                                               'apihost': args.apihost})

			




	
	
	
		
 
        sys.exit()

			




	
	
	
		
 

			




	
	
	
		
 
    if not conf:

			




	
	
	
		
 
        conf = RcConf(config_location=args.config, autoload=True)

			




	
	
	
		
 
        if not conf:

			




	
	
	
		
 
            if not api_credentials_given:

			




	
	
	
		
 
                parser.error('Could not find config file and missing '

			




	
	
	
		
 
                             '--apikey or --apihost in params')

			




	
	
	
		
 

			




	
	
	
		
 
    apikey = args.apikey or conf['apikey']

			




	
	
	
		
 
    apihost = args.apihost or conf['apihost']

			




	
	
	
		
 
    method = args.method

			




	
	
	
		
 

			




	
	
	
		
 
    # if we don't have method here it's an error

			




	
	
	
		
 
    if not method:

			




	
	
	
		
 
        parser.error('Please specify method name')

			




	
	
	
		
 

			




	
	
	
		
 
    try:

			




	
	
	
		
 
        margs = dict(map(lambda s: s.split(':', 1), other))

			




	
	
	
		
 
    except ValueError:

			




	
	
	
		
 
        sys.stderr.write('Error parsing arguments \n')

			




	
	
	
		
 
        sys.exit()

			




	
	
	
		
 
    if args.format == FORMAT_PRETTY:

			




	
	
	
		
 
        print 'Calling method %s => %s' % (method, apihost)

			




	
	
	
		
 

			




	
	
	
		
 
    json_resp = api_call(apikey, apihost, method, **margs)

			




	
	
	
		
 
    error_prefix = ''

			




	
	
	
		
 
    if json_resp['error']:

			




	
	
	
		
 
        error_prefix = 'ERROR:'

			




	
	
	
		
 
        json_data = json_resp['error']

			




	
	
	
		
 
    else:

			




	
	
	
		
 
        json_data = json_resp['result']

			




	
	
	
		
 
    if args.format == FORMAT_JSON:

			




	
	
	
		
 
        print json.dumps(json_data)

			




	
	
	
		
 
    elif args.format == FORMAT_PRETTY:

			




	
	
	
		
 
        print 'Server response \n%s%s' % (

			




	
	
	
		
 
            error_prefix, json.dumps(json_data, indent=4, sort_keys=True)

			




	
	
	
		
 
        )

			




	
	
	
		
 
    return 0

			




	
	
	
		
 

			




	
	
	
		
 
if __name__ == '__main__':

			




	
	
	
		
 
    sys.exit(main(sys.argv))

			




        

    


    
    

    

        

                

                    kallithea/bin/kallithea_gist.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.bin.kallithea_gist

			




	
	
	
		
 
~~~~~~~~~~~~~~~~~~~~~~~~~~~~

			




	
	
	
		
 

			




	
	
	
		
 
Gist CLI client 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 os

			




	
	
	
		
 
import sys

			




	
	
	
		
 
import stat

			




	
	
	
		
 
import argparse

			




	
	
	
		
 
import fileinput

			




	
	
	
		
 

			




	
	
	
		
 
from kallithea.bin.base import json, api_call, RcConf, FORMAT_JSON, FORMAT_PRETTY

			




	
	
	
		
 

			




	
	
	
		
 

			




	
	
	
		
 
def argparser(argv):

			




	
	
	
		
 
    usage = (

			




	
	
	
		
 
      "kallithea-gist [-h] [--format=FORMAT] [--apikey=APIKEY] [--apihost=APIHOST] "

			




	
	
	
		
 
      "[--config=CONFIG] [--save-config] [GIST OPTIONS] "

			




	
	
	
		
 
      "[filename or stdin use - for terminal stdin ]\n"

			




	
	
	
		
 
      "Create config file: kallithea-gist --apikey=<key> --apihost=http://your.kallithea.server --save-config"

			




	
	
	
		
 
      "Create config file: kallithea-gist --apikey=<key> --apihost=http://kallithea.example.com --save-config"

			




	
	
	
		
 
    )

			




	
	
	
		
 

			




	
	
	
		
 
    parser = argparse.ArgumentParser(description='Kallithea Gist cli',

			




	
	
	
		
 
                                     usage=usage)

			




	
	
	
		
 

			




	
	
	
		
 
    ## config

			




	
	
	
		
 
    group = parser.add_argument_group('config')

			




	
	
	
		
 
    group.add_argument('--apikey', help='api access key')

			




	
	
	
		
 
    group.add_argument('--apihost', help='api host')

			




	
	
	
		
 
    group.add_argument('--config', help='config file path DEFAULT: ~/.config/kallithea')

			




	
	
	
		
 
    group.add_argument('--save-config', action='store_true',

			




	
	
	
		
 
                       help='save the given config into a file')

			




	
	
	
		
 

			




	
	
	
		
 
    group = parser.add_argument_group('GIST')

			




	
	
	
		
 
    group.add_argument('-p', '--private', action='store_true',

			




	
	
	
		
 
                       help='create private Gist')

			




	
	
	
		
 
    group.add_argument('-f', '--filename',

			




	
	
	
		
 
                       help='set uploaded gist filename, '

			




	
	
	
		
 
                            'also defines syntax highlighting')

			




	
	
	
		
 
    group.add_argument('-d', '--description', help='Gist description')

			




	
	
	
		
 
    group.add_argument('-l', '--lifetime', metavar='MINUTES',

			




	
	
	
		
 
                       help='gist lifetime in minutes, -1 (DEFAULT) is forever')

			




	
	
	
		
 
    group.add_argument('--format', dest='format', type=str,

			




	
	
	
		
 
                       help='output format DEFAULT: `%s` can '

			




	
	
	
		
 
                       'be also `%s`' % (FORMAT_PRETTY, FORMAT_JSON),

			




	
	
	
		
 
            default=FORMAT_PRETTY

			




	
	
	
		
 
    )

			




	
	
	
		
 
    args, other = parser.parse_known_args()

			




	
	
	
		
 
    return parser, args, other

			




	
	
	
		
 

			




	
	
	
		
 

			




	
	
	
		
 
def _run(argv):

			




	
	
	
		
 
    conf = None

			




	
	
	
		
 
    parser, args, other = argparser(argv)

			




	
	
	
		
 

			




	
	
	
		
 
    api_credentials_given = (args.apikey and args.apihost)

			




	
	
	
		
 
    if args.save_config:

			




	
	
	
		
 
        if not api_credentials_given:

			




	
	
	
		
 
            raise parser.error('--save-config requires --apikey and --apihost')

			




	
	
	
		
 
        conf = RcConf(config_location=args.config,

			




	
	
	
		
 
                      autocreate=True, config={'apikey': args.apikey,

			




	
	
	
		
 
                                               'apihost': args.apihost})

			




	
	
	
		
 
        sys.exit()

			




	
	
	
		
 

			




	
	
	
		
 
    if not conf:

			




	
	
	
		
 
        conf = RcConf(config_location=args.config, autoload=True)

			




	
	
	
		
 
        if not conf:

			




	
	
	
		
 
            if not api_credentials_given:

			




	
	
	
		
 
                parser.error('Could not find config file and missing '

			




	
	
	
		
 
                             '--apikey or --apihost in params')

			




	
	
	
		
 

			




	
	
	
		
 
    apikey = args.apikey or conf['apikey']

			




	
	
	
		
 
    host = args.apihost or conf['apihost']

			




	
	
	
		
 
    DEFAULT_FILENAME = 'gistfile1.txt'

			




	
	
	
		
 
    if other:

			




	
	
	
		
 
        # skip multifiles for now

			




	
	
	
		
 
        filename = other[0]

			




	
	
	
		
 
        if filename == '-':

			




	
	
	
		
 
            filename = DEFAULT_FILENAME

			




	
	
	
		
 
            gist_content = ''

			




	
	
	
		
 
            for line in fileinput.input('-'):

			




	
	
	
		
 
                gist_content += line

			




	
	
	
		
 
        else:

			




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

			




	
	
	
		
 
                gist_content = f.read()

			




	
	
	
		
 

			




	
	
	
		
 
    else:

			




	
	
	
		
 
        filename = DEFAULT_FILENAME

			




	
	
	
		
 
        gist_content = None

			




	
	
	
		
 
        # little bit hacky but cross platform check where the

			




	
	
	
		
 
        # stdin comes from we skip the terminal case it can be handled by '-'

			




	
	
	
		
 
        mode = os.fstat(0).st_mode

			




	
	
	
		
 
        if stat.S_ISFIFO(mode):

			




	
	
	
		
 
            # "stdin is piped"

			




	
	
	
		
 
            gist_content = sys.stdin.read()

			




	
	
	
		
 
        elif stat.S_ISREG(mode):

			




	
	
	
		
 
            # "stdin is redirected"

			




	
	
	
		
 
            gist_content = sys.stdin.read()

			




	
	
	
		
 
        else:

			




	
	
	
		
 
            # "stdin is terminal"

			




	
	
	
		
 
            pass

			




	
	
	
		
 

			




	
	
	
		
 
    # make sure we don't upload binary stuff

			




	
	
	
		
 
    if gist_content and '\0' in gist_content:

			




	
	
	
		
 
        raise Exception('Error: binary files upload is not possible')

			




	
	
	
		
 

			




	
	
	
		
 
    filename = os.path.basename(args.filename or filename)

			




	
	
	
		
 
    if gist_content:

			




	
	
	
		
 
        files = {

			




	
	
	
		
 
            filename: {

			




	
	
	
		
 
                'content': gist_content,

			




	
	
	
		
 
                'lexer': None

			




	
	
	
		
 
            }

			




	
	
	
		
 
        }

			




	
	
	
		
 

			




	
	
	
		
 
        margs = dict(

			




	
	
	
		
 
            lifetime=args.lifetime,

			




	
	
	
		
 
            description=args.description,

			




	
	
	
		
 
            gist_type='private' if args.private else 'public',

			




	
	
	
		
 
            files=files

			




	
	
	
		
 
        )

			




	
	
	
		
 

			




	
	
	
		
 
        json_data = api_call(apikey, host, 'create_gist', **margs)['result']

			




	
	
	
		
 
        if args.format == FORMAT_JSON:

			




	
	
	
		
 
            print json.dumps(json_data)

			




	
	
	
		
 
        elif args.format == FORMAT_PRETTY:

			




	
	
	
		
 
            print json_data

			




	
	
	
		
 
            print 'Created %s gist %s' % (json_data['gist']['type'],

			




	
	
	
		
 
                                          json_data['gist']['url'])

			




	
	
	
		
 
    return 0

			




	
	
	
		
 

			




	
	
	
		
 

			




	
	
	
		
 
def main(argv=None):

			




	
	
	
		
 
    """

			




	
	
	
		
 
    Main execution function for cli

			




	
	
	
		
 

			




	
	
	
		
 
    :param argv:

			




	
	
	
		
 
    """

			




	
	
	
		
 
    if argv is None:

			




	
	
	
		
 
        argv = sys.argv

			




	
	
	
		
 

			




	
	
	
		
 
    try:

			




	
	
	
		
 
        return _run(argv)

			




	
	
	
		
 
    except Exception as e:

			




	
	
	
		
 
        print e

			




	
	
	
		
 
        return 1

			




	
	
	
		
 

			




	
	
	
		
 

			




	
	
	
		
 
if __name__ == '__main__':

			




	
	
	
		
 
    sys.exit(main(sys.argv))

			




        

    


    
    

    

        

                

                    kallithea/bin/ldap_sync.conf
                

                

                  
                      
                        

                      ➞

                      
                        
                  

                  
                      
                  
                      
                  
                      
                  
                      
                  
                  
                

                

                    Show inline comments
                    
                

        

        

            



	
	
	
		
 
[default]

			




	
	
	
		
 
api_url = http://your.kallithea.server:5000/_admin/api

			




	
	
	
		
 
api_url = http://kallithea.example.com/_admin/api

			




	
	
	
		
 
api_user = admin

			




	
	
	
		
 
api_key = XXXXXXXXXXXX

			




	
	
	
		
 

			




	
	
	
		
 
ldap_uri = ldap://your.ldap.server:389

			




	
	
	
		
 
ldap_user = cn=kallithea,ou=binders,dc=linaro,dc=org

			




	
	
	
		
 
ldap_uri = ldap://ldap.example.com:389

			




	
	
	
		
 
ldap_user = cn=kallithea,dc=example,dc=com

			




	
	
	
		
 
ldap_key = XXXXXXXXX

			




	
	
	
		
 
base_dn = dc=linaro,dc=org

			




	
	
	
		
 
base_dn = dc=example,dc=com

			




	
	
	
		
 

			




	
	
	
		
 
sync_users = True

			




	
	
		
 
\ No newline at end of file

			




        

    


    
    

    

        

                

                    kallithea/bin/template.ini.mako
                

                

                  
                      
                        

                      ➞

                      
                        
                  

                  
                      
                  
                      
                  
                      
                  
                      
                  
                  
                

                

                    Show inline comments
                    
                

        

        

            



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

			




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

			




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

			




	
	
	
		
 
# Kallithea - config file generated with kallithea-config                      #

			




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

			




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

			




	
	
	
		
 

			




	
	
	
		
 
[DEFAULT]

			




	
	
	
		
 
debug = true

			




	
	
	
		
 
pdebug = false

			




	
	
	
		
 

			




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

			




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

			




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

			




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

			




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

			




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

			




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

			




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

			




	
	
	
		
 

			




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

			




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

			




	
	
	
		
 
#app_email_from = Kallithea

			




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

			




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

			




	
	
	
		
 
#app_email_from = kallithea-noreply@example.com

			




	
	
	
		
 

			




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

			




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

			




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

			




	
	
	
		
 
#email_prefix =

			




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

			




	
	
	
		
 
#email_prefix = [Kallithea]

			




	
	
	
		
 

			




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

			




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

			




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

			




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

			




	
	
	
		
 
#email_to =

			




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

			




	
	
	
		
 
#email_to = admin@example.com

			




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

			




	
	
	
		
 

			




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

			




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

			




	
	
	
		
 
#error_email_from = pylons@yourapp.com

			




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

			




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

			




	
	
	
		
 
#error_email_from = paste_error@example.com

			




	
	
	
		
 

			




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

			




	
	
	
		
 
<%text>## Only smtp_server is mandatory. All other settings take the specified default</%text>

			




	
	
	
		
 
<%text>## values.</%text>

			




	
	
	
		
 
#smtp_server = mail.server.com

			




	
	
	
		
 
#smtp_server = smtp.example.com

			




	
	
	
		
 
#smtp_username =

			




	
	
	
		
 
#smtp_password =

			




	
	
	
		
 
#smtp_port = 25

			




	
	
	
		
 
#smtp_use_tls = false

			




	
	
	
		
 
#smtp_use_ssl = false

			




	
	
	
		
 
<%text>## SMTP authentication parameters to use (e.g. LOGIN PLAIN CRAM-MD5, etc.).</%text>

			




	
	
	
		
 
<%text>## If empty, use any of the authentication parameters supported by the server.</%text>

			




	
	
	
		
 
#smtp_auth =

			




	
	
	
		
 

			




	
	
	
		
 
[server:main]

			




	
	
	
		
 
%if http_server == 'paste':

			




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

			




	
	
	
		
 
use = egg:Paste#http

			




	
	
	
		
 
<%text>## nr of worker threads to spawn</%text>

			




	
	
	
		
 
threadpool_workers = 5

			




	
	
	
		
 
<%text>## max request before thread respawn</%text>

			




	
	
	
		
 
threadpool_max_requests = 10

			




	
	
	
		
 
<%text>## option to use threads of process</%text>

			




	
	
	
		
 
use_threadpool = true

			




	
	
	
		
 

			




	
	
	
		
 
%elif http_server == 'waitress':

			




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

			




	
	
	
		
 
use = egg:waitress#main

			




	
	
	
		
 
<%text>## number of worker threads</%text>

			




	
	
	
		
 
threads = 5

			




	
	
	
		
 
<%text>## MAX BODY SIZE 100GB</%text>

			




	
	
	
		
 
max_request_body_size = 107374182400

			




	
	
	
		
 
<%text>## use poll instead of select, fixes fd limits, may not work on old</%text>

			




	
	
	
		
 
<%text>## windows systems.</%text>

			




	
	
	
		
 
#asyncore_use_poll = True

			




	
	
	
		
 

			




	
	
	
		
 
%elif http_server == 'gunicorn':

			




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

			




	
	
	
		
 
use = egg:gunicorn#main

			




	
	
	
		
 
<%text>## number of process workers. You must set `instance_id = *` when this option</%text>

			




	
	
	
		
 
<%text>## is set to more than one worker</%text>

			




	
	
	
		
 
workers = 1

			




	
	
	
		
 
<%text>## process name</%text>

			




	
	
	
		
 
proc_name = kallithea

			




	
	
	
		
 
<%text>## type of worker class, one of sync, eventlet, gevent, tornado</%text>

			




	
	
	
		
 
<%text>## recommended for bigger setup is using of of other than sync one</%text>

			




	
	
	
		
 
worker_class = sync

			




	
	
	
		
 
max_requests = 1000

			




	
	
	
		
 
<%text>## ammount of time a worker can handle request before it gets killed and</%text>

			




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

			




	
	
	
		
 
timeout = 3600

			




	
	
	
		
 

			




	
	
	
		
 
%elif http_server == 'uwsgi':

			




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

			




	
	
	
		
 
<%text>## run with uwsgi --ini-paste-logged <inifile.ini></%text>

			




	
	
	
		
 
[uwsgi]

			




	
	
	
		
 
socket = /tmp/uwsgi.sock

			




	
	
	
		
 
master = true

			




	
	
	
		
 
http = 127.0.0.1:5000

			




	
	
	
		
 

			




	
	
	
		
 
<%text>## set as deamon and redirect all output to file</%text>

			




	
	
	
		
 
#daemonize = ./uwsgi_kallithea.log

			




	
	
	
		
 

			




	
	
	
		
 
<%text>## master process PID</%text>

			




	
	
	
		
 
pidfile = ./uwsgi_kallithea.pid

			




	
	
	
		
 

			




	
	
	
		
 
<%text>## stats server with workers statistics, use uwsgitop</%text>

			




	
	
	
		
 
<%text>## for monitoring, `uwsgitop 127.0.0.1:1717`</%text>

			




	
	
	
		
 
stats = 127.0.0.1:1717

			




	
	
	
		
 
memory-report = true

			




	
	
	
		
 

			




	
	
	
		
 
<%text>## log 5XX errors</%text>

			




	
	
	
		
 
log-5xx = true

			




	
	
	
		
 

			




	
	
	
		
 
<%text>## Set the socket listen queue size.</%text>

			




	
	
	
		
 
listen = 256

			




	
	
	
		
 

			




	
	
	
		
 
<%text>## Gracefully Reload workers after the specified amount of managed requests</%text>

			




	
	
	
		
 
<%text>## (avoid memory leaks).</%text>

			




	
	
	
		
 
max-requests = 1000

			




	
	
	
		
 

			




	
	
	
		
 
<%text>## enable large buffers</%text>

			




	
	
	
		
 
buffer-size = 65535

			




	
	
	
		
 

			




	
	
	
		
 
<%text>## socket and http timeouts ##</%text>

			




	
	
	
		
 
http-timeout = 3600

			




	
	
	
		
 
socket-timeout = 3600

			




	
	
	
		
 

			




	
	
	
		
 
<%text>## Log requests slower than the specified number of milliseconds.</%text>

			




	
	
	
		
 
log-slow = 10

			




	
	
	
		
 

			




	
	
	
		
 
<%text>## Exit if no app can be loaded.</%text>

			




	
	
	
		
 
need-app = true

			




	
	
	
		
 

			




	
	
	
		
 
<%text>## Set lazy mode (load apps in workers instead of master).</%text>

			




	
	
	
		
 
lazy = true

			




	
	
	
		
 

			




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

			




	
	
	
		
 
<%text>## set cheaper algorithm to use, if not set default will be used</%text>

			




	
	
	
		
 
cheaper-algo = spare

			




	
	
	
		
 

			




	
	
	
		
 
<%text>## minimum number of workers to keep at all times</%text>

			




	
	
	
		
 
cheaper = 1

			




	
	
	
		
 

			




	
	
	
		
 
<%text>## number of workers to spawn at startup</%text>

			




	
	
	
		
 
cheaper-initial = 1

			




	
	
	
		
 

			




	
	
	
		
 
<%text>## maximum number of workers that can be spawned</%text>

			




	
	
	
		
 
workers = 4

			




	
	
	
		
 

			




	
	
	
		
 
<%text>## how many workers should be spawned at a time</%text>

			




	
	
	
		
 
cheaper-step = 1

			




	
	
	
		
 

			




	
	
	
		
 
%endif

			




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

			




	
	
	
		
 
host = ${host}

			




	
	
	
		
 
port = ${port}

			




	
	
	
		
 

			




	
	
	
		
 
<%text>## middleware for hosting the WSGI application under a URL prefix</%text>

			




	
	
	
		
 
#[filter:proxy-prefix]

			




	
	
	
		
 
#use = egg:PasteDeploy#prefix

			




	
	
	
		
 
#prefix = /<your-prefix>

			




	
	
	
		
 

			




	
	
	
		
 
[app:main]

			




	
	
	
		
 
use = egg:kallithea

			




	
	
	
		
 
<%text>## enable proxy prefix middleware</%text>

			




	
	
	
		
 
#filter-with = proxy-prefix

			




	
	
	
		
 

			




	
	
	
		
 
full_stack = true

			




	
	
	
		
 
static_files = true

			




	
	
	
		
 
<%text>## Available Languages:</%text>

			




	
	
	
		
 
<%text>## cs de fr hu ja nl_BE pl pt_BR ru sk zh_CN zh_TW</%text>

			




	
	
	
		
 
lang =

			




	
	
	
		
 
cache_dir = ${here}/data

			




	
	
	
		
 
index_dir = ${here}/data/index

			




	
	
	
		
 

			




	
	
	
		
 
<%text>## perform a full repository scan on each server start, this should be</%text>

			




	
	
	
		
 
<%text>## set to false after first startup, to allow faster server restarts.</%text>

			




	
	
	
		
 
initial_repo_scan = false

			




	
	
	
		
 

			




	
	
	
		
 
<%text>## uncomment and set this path to use archive download cache</%text>

			




	
	
	
		
 
archive_cache_dir = ${here}/tarballcache

			




	
	
	
		
 

			




	
	
	
		
 
<%text>## change this to unique ID for security</%text>

			




	
	
	
		
 
app_instance_uuid = ${uuid()}

			




	
	
	
		
 

			




	
	
	
		
 
<%text>## cut off limit for large diffs (size in bytes)</%text>

			




	
	
	
		
 
cut_off_limit = 256000

			




	
	
	
		
 

			




	
	
	
		
 
<%text>## use cache version of scm repo everywhere</%text>

			




	
	
	
		
 
vcs_full_cache = true

			




	
	
	
		
 

			




	
	
	
		
 
<%text>## force https in Kallithea, fixes https redirects, assumes it's always https</%text>

			




	
	
	
		
 
force_https = false

			




	
	
	
		
 

			




	
	
	
		
 
<%text>## use Strict-Transport-Security headers</%text>

			




	
	
	
		
 
use_htsts = false

			




	
	
	
		
 

			




	
	
	
		
 
<%text>## number of commits stats will parse on each iteration</%text>

			




	
	
	
		
 
commit_parse_limit = 25

			




	
	
	
		
 

			




	
	
	
		
 
<%text>## path to git executable</%text>

			




	
	
	
		
 
git_path = git

			




	
	
	
		
 

			




	
	
	
		
 
<%text>## git rev filter option, --all is the default filter, if you need to</%text>

			




	
	
	
		
 
<%text>## hide all refs in changelog switch this to --branches --tags</%text>

			




	
	
	
		
 
#git_rev_filter = --branches --tags

			




	
	
	
		
 

			




	
	
	
		
 
<%text>## RSS feed options</%text>

			




	
	
	
		
 
rss_cut_off_limit = 256000

			




	
	
	
		
 
rss_items_per_page = 10

			




	
	
	
		
 
rss_include_diff = false

			




	
	
	
		
 

			




	
	
	
		
 
<%text>## options for showing and identifying changesets</%text>

			




	
	
	
		
 
show_sha_length = 12

			




	
	
	
		
 
show_revision_number = false

			




	
	
	
		
 

			




	
	
	
		
 
<%text>## gist URL alias, used to create nicer urls for gist. This should be an</%text>

			




	
	
	
		
 
<%text>## url that does rewrites to _admin/gists/<gistid>.</%text>

			




	
	
	
		
 
<%text>## example: http://gist.kallithea.server/{gistid}. Empty means use the internal</%text>

			




	
	
	
		
 
<%text>## Kallithea url, ie. http[s]://your.kallithea.server/_admin/gists/<gistid></%text>

			




	
	
	
		
 
<%text>## example: http://gist.example.com/{gistid}. Empty means use the internal</%text>

			




	
	
	
		
 
<%text>## Kallithea url, ie. http[s]://kallithea.example.com/_admin/gists/<gistid></%text>

			




	
	
	
		
 
gist_alias_url =

			




	
	
	
		
 

			




	
	
	
		
 
<%text>## white list of API enabled controllers. This allows to add list of</%text>

			




	
	
	
		
 
<%text>## controllers to which access will be enabled by api_key. eg: to enable</%text>

			




	
	
	
		
 
<%text>## api access to raw_files put `FilesController:raw`, to enable access to patches</%text>

			




	
	
	
		
 
<%text>## add `ChangesetController:changeset_patch`. This list should be "," separated</%text>

			




	
	
	
		
 
<%text>## Syntax is <ControllerClass>:<function>. Check debug logs for generated names</%text>

			




	
	
	
		
 
<%text>## Recommended settings below are commented out:</%text>

			




	
	
	
		
 
api_access_controllers_whitelist =

			




	
	
	
		
 
#    ChangesetController:changeset_patch,

			




	
	
	
		
 
#    ChangesetController:changeset_raw,

			




	
	
	
		
 
#    FilesController:raw,

			




	
	
	
		
 
#    FilesController:archivefile

			




	
	
	
		
 

			




	
	
	
		
 
<%text>## default encoding used to convert from and to unicode</%text>

			




	
	
	
		
 
<%text>## can be also a comma seperated list of encoding in case of mixed encodings</%text>

			




	
	
	
		
 
default_encoding = utf8

			




	
	
	
		
 

			




	
	
	
		
 
<%text>## issue tracker for Kallithea (leave blank to disable, absent for default)</%text>

			




	
	
	
		
 
#bugtracker = https://bitbucket.org/conservancy/kallithea/issues

			




	
	
	
		
 

			




	
	
	
		
 
<%text>## issue tracking mapping for commits messages</%text>

			




	
	
	
		
 
<%text>## comment out issue_pat, issue_server, issue_prefix to enable</%text>

			




	
	
	
		
 

			




	
	
	
		
 
<%text>## pattern to get the issues from commit messages</%text>

			




	
	
	
		
 
<%text>## default one used here is #<numbers> with a regex passive group for `#`</%text>

			




	
	
	
		
 
<%text>## {id} will be all groups matched from this pattern</%text>

			




	
	
	
		
 

			




	
	
	
		
 
issue_pat = (?:\s*#)(\d+)

			




	
	
	
		
 

			




	
	
	
		
 
<%text>## server url to the issue, each {id} will be replaced with match</%text>

			




	
	
	
		
 
<%text>## fetched from the regex and {repo} is replaced with full repository name</%text>

			




	
	
	
		
 
<%text>## including groups {repo_name} is replaced with just name of repo</%text>

			




	
	
	
		
 

			




	
	
	
		
 
issue_server_link = https://myissueserver.com/{repo}/issue/{id}

			




	
	
	
		
 
issue_server_link = https://issues.example.com/{repo}/issue/{id}

			




	
	
	
		
 

			




	
	
	
		
 
<%text>## prefix to add to link to indicate it's an url</%text>

			




	
	
	
		
 
<%text>## #314 will be replaced by <issue_prefix><id></%text>

			




	
	
	
		
 

			




	
	
	
		
 
issue_prefix = #

			




	
	
	
		
 

			




	
	
	
		
 
<%text>## issue_pat, issue_server_link, issue_prefix can have suffixes to specify</%text>

			




	
	
	
		
 
<%text>## multiple patterns, to other issues server, wiki or others</%text>

			




	
	
	
		
 
<%text>## below an example how to create a wiki pattern</%text>

			




	
	
	
		
 
# wiki-some-id -> https://mywiki.com/some-id

			




	
	
	
		
 
# wiki-some-id -> https://wiki.example.com/some-id

			




	
	
	
		
 

			




	
	
	
		
 
#issue_pat_wiki = (?:wiki-)(.+)

			




	
	
	
		
 
#issue_server_link_wiki = https://mywiki.com/{id}

			




	
	
	
		
 
#issue_server_link_wiki = https://wiki.example.com/{id}

			




	
	
	
		
 
#issue_prefix_wiki = WIKI-

			




	
	
	
		
 

			




	
	
	
		
 
<%text>## instance-id prefix</%text>

			




	
	
	
		
 
<%text>## a prefix key for this instance used for cache invalidation when running</%text>

			




	
	
	
		
 
<%text>## multiple instances of kallithea, make sure it's globally unique for</%text>

			




	
	
	
		
 
<%text>## all running kallithea instances. Leave empty if you don't use it</%text>

			




	
	
	
		
 
instance_id =

			




	
	
	
		
 

			




	
	
	
		
 
<%text>## alternative return HTTP header for failed authentication. Default HTTP</%text>

			




	
	
	
		
 
<%text>## response is 401 HTTPUnauthorized. Currently Mercurial clients have trouble with</%text>

			




	
	
	
		
 
<%text>## handling that. Set this variable to 403 to return HTTPForbidden</%text>

			




	
	
	
		
 
auth_ret_code =

			




	
	
	
		
 

			




	
	
	
		
 
<%text>## locking return code. When repository is locked return this HTTP code. 2XX</%text>

			




	
	
	
		
 
<%text>## codes don't break the transactions while 4XX codes do</%text>

			




	
	
	
		
 
lock_ret_code = 423

			




	
	
	
		
 

			




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

			




	
	
	
		
 
allow_repo_location_change = True

			




	
	
	
		
 

			




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

			




	
	
	
		
 
allow_custom_hooks_settings = True

			




	
	
	
		
 

			




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

			




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

			




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

			




	
	
	
		
 

			




	
	
	
		
 
use_celery = false

			




	
	
	
		
 
broker.host = localhost

			




	
	
	
		
 
broker.vhost = rabbitmqhost

			




	
	
	
		
 
broker.port = 5672

			




	
	
	
		
 
broker.user = rabbitmq

			




	
	
	
		
 
broker.password = qweqwe

			




	
	
	
		
 

			




	
	
	
		
 
celery.imports = kallithea.lib.celerylib.tasks

			




	
	
	
		
 

			




	
	
	
		
 
celery.result.backend = amqp

			




	
	
	
		
 
celery.result.dburi = amqp://

			




	
	
	
		
 
celery.result.serialier = json

			




	
	
	
		
 

			




	
	
	
		
 
#celery.send.task.error.emails = true

			




	
	
	
		
 
#celery.amqp.task.result.expires = 18000

			




	
	
	
		
 

			




	
	
	
		
 
celeryd.concurrency = 2

			




	
	
	
		
 
#celeryd.log.file = celeryd.log

			




	
	
	
		
 
celeryd.log.level = DEBUG

			




	
	
	
		
 
celeryd.max.tasks.per.child = 1

			




	
	
	
		
 

			




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

			




	
	
	
		
 
celery.always.eager = false

			




	
	
	
		
 

			




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

			




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

			




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

			




	
	
	
		
 

			




	
	
	
		
 
beaker.cache.data_dir = ${here}/data/cache/data

			




	
	
	
		
 
beaker.cache.lock_dir = ${here}/data/cache/lock

			




	
	
	
		
 

			




	
	
	
		
 
beaker.cache.regions = short_term,long_term,sql_cache_short

			




	
	
	
		
 

			




	
	
	
		
 
beaker.cache.short_term.type = memory

			




	
	
	
		
 
beaker.cache.short_term.expire = 60

			




	
	
	
		
 
beaker.cache.short_term.key_length = 256

			




	
	
	
		
 

			




	
	
	
		
 
beaker.cache.long_term.type = memory

			




	
	
	
		
 
beaker.cache.long_term.expire = 36000

			




	
	
	
		
 
beaker.cache.long_term.key_length = 256

			




	
	
	
		
 

			




	
	
	
		
 
beaker.cache.sql_cache_short.type = memory

			




	
	
	
		
 
beaker.cache.sql_cache_short.expire = 10

			




	
	
	
		
 
beaker.cache.sql_cache_short.key_length = 256

			




	
	
	
		
 

			




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

			




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

			




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

			




	
	
	
		
 

			




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

			




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

			




	
	
	
		
 
beaker.session.key = kallithea

			




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

			




	
	
	
		
 
beaker.session.httponly = true

			




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

			




	
	
	
		
 
beaker.session.timeout = 2592000

			




	
	
	
		
 

			




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

			




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

			




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

			




	
	
	
		
 
#beaker.session.encrypt_key = <key_for_encryption>

			




	
	
	
		
 
#beaker.session.validate_key = <validation_key>

			




	
	
	
		
 

			




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

			




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

			




	
	
	
		
 

			




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

			




	
	
	
		
 
#beaker.session.type = file

			




	
	
	
		
 

			




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

			




	
	
	
		
 
#beaker.session.type = cookie

			




	
	
	
		
 

			




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

			




	
	
	
		
 
#beaker.session.type = ext:database

			




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

			




	
	
	
		
 
#beaker.session.table_name = db_session

			




	
	
	
		
 

			




	
	
	
		
 
%if error_aggregation_service == 'errormator':

			




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

			




	
	
	
		
 
<%text>## ERROR HANDLING SYSTEMS ##</%text>

			




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

			




	
	
	
		
 

			




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

			




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

			




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

			




	
	
	
		
 

			




	
	
	
		
 
<%text>## Errormator is tailored to work with Kallithea, see</%text>

			




	
	
	
		
 
<%text>## http://errormator.com for details how to obtain an account</%text>

			




	
	
	
		
 
<%text>## you must install python package `errormator_client` to make it work</%text>

			




	
	
	
		
 

			




	
	
	
		
 
<%text>## errormator enabled</%text>

			




	
	
	
		
 
errormator = false

			




	
	
	
		
 

			




	
	
	
		
 
errormator.server_url = https://api.errormator.com

			




	
	
	
		
 
errormator.api_key = YOUR_API_KEY

			




	
	
	
		
 

			




	
	
	
		
 
<%text>## TWEAK AMOUNT OF INFO SENT HERE</%text>

			




	
	
	
		
 

			




	
	
	
		
 
<%text>## enables 404 error logging (default False)</%text>

			




	
	
	
		
 
errormator.report_404 = false

			




	
	
	
		
 

			




	
	
	
		
 
<%text>## time in seconds after request is considered being slow (default 1)</%text>

			




	
	
	
		
 
errormator.slow_request_time = 1

			




	
	
	
		
 

			




	
	
	
		
 
<%text>## record slow requests in application</%text>

			




	
	
	
		
 
<%text>## (needs to be enabled for slow datastore recording and time tracking)</%text>

			




	
	
	
		
 
errormator.slow_requests = true

			




	
	
	
		
 

			




	
	
	
		
 
<%text>## enable hooking to application loggers</%text>

			




	
	
	
		
 
#errormator.logging = true

			




	
	
	
		
 

			




	
	
	
		
 
<%text>## minimum log level for log capture</%text>

			




	
	
	
		
 
#errormator.logging.level = WARNING

			




	
	
	
		
 

			




	
	
	
		
 
<%text>## send logs only from erroneous/slow requests</%text>

			




	
	
	
		
 
<%text>## (saves API quota for intensive logging)</%text>

			




	
	
	
		
 
errormator.logging_on_error = false

			




	
	
	
		
 

			




	
	
	
		
 
<%text>## list of additonal keywords that should be grabbed from environ object</%text>

			




	
	
	
		
 
<%text>## can be string with comma separated list of words in lowercase</%text>

			




	
	
	
		
 
<%text>## (by default client will always send following info:</%text>

			




	
	
	
		
 
<%text>## 'REMOTE_USER', 'REMOTE_ADDR', 'SERVER_NAME', 'CONTENT_TYPE' + all keys that</%text>

			




	
	
	
		
 
<%text>## start with HTTP* this list be extended with additional keywords here</%text>

			




	
	
	
		
 
errormator.environ_keys_whitelist =

			




	
	
	
		
 

			




	
	
	
		
 
<%text>## list of keywords that should be blanked from request object</%text>

			




	
	
	
		
 
<%text>## can be string with comma separated list of words in lowercase</%text>

			




	
	
	
		
 
<%text>## (by default client will always blank keys that contain following words</%text>

			




	
	
	
		
 
<%text>## 'password', 'passwd', 'pwd', 'auth_tkt', 'secret', 'csrf'</%text>

			




	
	
	
		
 
<%text>## this list be extended with additional keywords set here</%text>

			




	
	
	
		
 
errormator.request_keys_blacklist =

			




	
	
	
		
 

			




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

			




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

			




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

			




	
	
	
		
 
errormator.log_namespace_blacklist =

			




	
	
	
		
 

			




	
	
	
		
 
%elif error_aggregation_service == 'sentry':

			




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

			




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

			




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

			




	
	
	
		
 

			




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

			




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

			




	
	
	
		
 

			




	
	
	
		
 
sentry.dsn = YOUR_DNS

			




	
	
	
		
 
sentry.servers =

			




	
	
	
		
 
sentry.name =

			




	
	
	
		
 
sentry.key =

			




	
	
	
		
 
sentry.public_key =

			




	
	
	
		
 
sentry.secret_key =

			




	
	
	
		
 
sentry.project =

			




	
	
	
		
 
sentry.site =

			




	
	
	
		
 
sentry.include_paths =

			




	
	
	
		
 
sentry.exclude_paths =

			




	
	
	
		
 

			




	
	
	
		
 
%endif

			




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

			




	
	
	
		
 
<%text>## WARNING: *THE LINE BELOW MUST BE UNCOMMENTED ON A PRODUCTION ENVIRONMENT*  ##</%text>

			




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

			




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

			




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

			




	
	
	
		
 
set debug = false

			




	
	
	
		
 

			




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

			




        

    


    
    

    

        

                

                    kallithea/config/deployment.ini_tmpl
                

                

                  
                      
                        

                      ➞

                      
                        
                  

                  
                      
                  
                      
                  
                      
                  
                      
                  
                  
                

                

                    Show inline comments
                    
                

        

        

            



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

			




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

			




	
	
	
		
 
# Kallithea - Example config                                                   #

			




	
	
	
		
 
#                                                                              #

			




	
	
	
		
 
# The %(here)s variable will be replaced with the parent directory of this file#

			




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

			




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

			




	
	
	
		
 

			




	
	
	
		
 
[DEFAULT]

			




	
	
	
		
 
debug = true

			




	
	
	
		
 
pdebug = false

			




	
	
	
		
 

			




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

			




	
	
	
		
 
## Email settings                                                             ##

			




	
	
	
		
 
##                                                                            ##

			




	
	
	
		
 
## Refer to the documentation ("Email settings") for more details.            ##

			




	
	
	
		
 
##                                                                            ##

			




	
	
	
		
 
## It is recommended to use a valid sender address that passes access         ##

			




	
	
	
		
 
## validation and spam filtering in mail servers.                             ##

			




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

			




	
	
	
		
 

			




	
	
	
		
 
## 'From' header for application emails. You can optionally add a name.

			




	
	
	
		
 
## Default:

			




	
	
	
		
 
#app_email_from = Kallithea

			




	
	
	
		
 
## Examples:

			




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

			




	
	
	
		
 
#app_email_from = kallithea-noreply@example.com

			




	
	
	
		
 

			




	
	
	
		
 
## Subject prefix for application emails.

			




	
	
	
		
 
## A space between this prefix and the real subject is automatically added.

			




	
	
	
		
 
## Default:

			




	
	
	
		
 
#email_prefix =

			




	
	
	
		
 
## Example:

			




	
	
	
		
 
#email_prefix = [Kallithea]

			




	
	
	
		
 

			




	
	
	
		
 
## Recipients for error emails and fallback recipients of application mails.

			




	
	
	
		
 
## Multiple addresses can be specified, space-separated.

			




	
	
	
		
 
## Only addresses are allowed, do not add any name part.

			




	
	
	
		
 
## Default:

			




	
	
	
		
 
#email_to =

			




	
	
	
		
 
## Examples:

			




	
	
	
		
 
#email_to = admin@example.com

			




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

			




	
	
	
		
 

			




	
	
	
		
 
## 'From' header for error emails. You can optionally add a name.

			




	
	
	
		
 
## Default:

			




	
	
	
		
 
#error_email_from = pylons@yourapp.com

			




	
	
	
		
 
## Examples:

			




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

			




	
	
	
		
 
#error_email_from = paste_error@example.com

			




	
	
	
		
 

			




	
	
	
		
 
## SMTP server settings

			




	
	
	
		
 
## Only smtp_server is mandatory. All other settings take the specified default

			




	
	
	
		
 
## values.

			




	
	
	
		
 
#smtp_server = mail.server.com

			




	
	
	
		
 
#smtp_server = smtp.example.com

			




	
	
	
		
 
#smtp_username =

			




	
	
	
		
 
#smtp_password =

			




	
	
	
		
 
#smtp_port = 25

			




	
	
	
		
 
#smtp_use_tls = false

			




	
	
	
		
 
#smtp_use_ssl = false

			




	
	
	
		
 
## SMTP authentication parameters to use (e.g. LOGIN PLAIN CRAM-MD5, etc.).

			




	
	
	
		
 
## If empty, use any of the authentication parameters supported by the server.

			




	
	
	
		
 
#smtp_auth =

			




	
	
	
		
 

			




	
	
	
		
 
[server:main]

			




	
	
	
		
 
## PASTE ##

			




	
	
	
		
 
#use = egg:Paste#http

			




	
	
	
		
 
## nr of worker threads to spawn

			




	
	
	
		
 
#threadpool_workers = 5

			




	
	
	
		
 
## max request before thread respawn

			




	
	
	
		
 
#threadpool_max_requests = 10

			




	
	
	
		
 
## option to use threads of process

			




	
	
	
		
 
#use_threadpool = true

			




	
	
	
		
 

			




	
	
	
		
 
## WAITRESS ##

			




	
	
	
		
 
use = egg:waitress#main

			




	
	
	
		
 
## number of worker threads

			




	
	
	
		
 
threads = 5

			




	
	
	
		
 
## MAX BODY SIZE 100GB

			




	
	
	
		
 
max_request_body_size = 107374182400

			




	
	
	
		
 
## use poll instead of select, fixes fd limits, may not work on old

			




	
	
	
		
 
## windows systems.

			




	
	
	
		
 
#asyncore_use_poll = True

			




	
	
	
		
 

			




	
	
	
		
 
## GUNICORN ##

			




	
	
	
		
 
#use = egg:gunicorn#main

			




	
	
	
		
 
## number of process workers. You must set `instance_id = *` when this option

			




	
	
	
		
 
## is set to more than one worker

			




	
	
	
		
 
#workers = 1

			




	
	
	
		
 
## process name

			




	
	
	
		
 
#proc_name = kallithea

			




	
	
	
		
 
## type of worker class, one of sync, eventlet, gevent, tornado

			




	
	
	
		
 
## recommended for bigger setup is using of of other than sync one

			




	
	
	
		
 
#worker_class = sync

			




	
	
	
		
 
#max_requests = 1000

			




	
	
	
		
 
## ammount of time a worker can handle request before it gets killed and

			




	
	
	
		
 
## restarted

			




	
	
	
		
 
#timeout = 3600

			




	
	
	
		
 

			




	
	
	
		
 
## UWSGI ##

			




	
	
	
		
 
## run with uwsgi --ini-paste-logged <inifile.ini>

			




	
	
	
		
 
#[uwsgi]

			




	
	
	
		
 
#socket = /tmp/uwsgi.sock

			




	
	
	
		
 
#master = true

			




	
	
	
		
 
#http = 127.0.0.1:5000

			




	
	
	
		
 

			




	
	
	
		
 
## set as deamon and redirect all output to file

			




	
	
	
		
 
#daemonize = ./uwsgi_kallithea.log

			




	
	
	
		
 

			




	
	
	
		
 
## master process PID

			




	
	
	
		
 
#pidfile = ./uwsgi_kallithea.pid

			




	
	
	
		
 

			




	
	
	
		
 
## stats server with workers statistics, use uwsgitop

			




	
	
	
		
 
## for monitoring, `uwsgitop 127.0.0.1:1717`

			




	
	
	
		
 
#stats = 127.0.0.1:1717

			




	
	
	
		
 
#memory-report = true

			




	
	
	
		
 

			




	
	
	
		
 
## log 5XX errors

			




	
	
	
		
 
#log-5xx = true

			




	
	
	
		
 

			




	
	
	
		
 
## Set the socket listen queue size.

			




	
	
	
		
 
#listen = 256

			




	
	
	
		
 

			




	
	
	
		
 
## Gracefully Reload workers after the specified amount of managed requests

			




	
	
	
		
 
## (avoid memory leaks).

			




	
	
	
		
 
#max-requests = 1000

			




	
	
	
		
 

			




	
	
	
		
 
## enable large buffers

			




	
	
	
		
 
#buffer-size = 65535

			




	
	
	
		
 

			




	
	
	
		
 
## socket and http timeouts ##

			




	
	
	
		
 
#http-timeout = 3600

			




	
	
	
		
 
#socket-timeout = 3600

			




	
	
	
		
 

			




	
	
	
		
 
## Log requests slower than the specified number of milliseconds.

			




	
	
	
		
 
#log-slow = 10

			




	
	
	
		
 

			




	
	
	
		
 
## Exit if no app can be loaded.

			




	
	
	
		
 
#need-app = true

			




	
	
	
		
 

			




	
	
	
		
 
## Set lazy mode (load apps in workers instead of master).

			




	
	
	
		
 
#lazy = true

			




	
	
	
		
 

			




	
	
	
		
 
## scaling ##

			




	
	
	
		
 
## set cheaper algorithm to use, if not set default will be used

			




	
	
	
		
 
#cheaper-algo = spare

			




	
	
	
		
 

			




	
	
	
		
 
## minimum number of workers to keep at all times

			




	
	
	
		
 
#cheaper = 1

			




	
	
	
		
 

			




	
	
	
		
 
## number of workers to spawn at startup

			




	
	
	
		
 
#cheaper-initial = 1

			




	
	
	
		
 

			




	
	
	
		
 
## maximum number of workers that can be spawned

			




	
	
	
		
 
#workers = 4

			




	
	
	
		
 

			




	
	
	
		
 
## how many workers should be spawned at a time

			




	
	
	
		
 
#cheaper-step = 1

			




	
	
	
		
 

			




	
	
	
		
 
## COMMON ##

			




	
	
	
		
 
host = 127.0.0.1

			




	
	
	
		
 
port = 5000

			




	
	
	
		
 

			




	
	
	
		
 
## middleware for hosting the WSGI application under a URL prefix

			




	
	
	
		
 
#[filter:proxy-prefix]

			




	
	
	
		
 
#use = egg:PasteDeploy#prefix

			




	
	
	
		
 
#prefix = /<your-prefix>

			




	
	
	
		
 

			




	
	
	
		
 
[app:main]

			




	
	
	
		
 
use = egg:kallithea

			




	
	
	
		
 
## enable proxy prefix middleware

			




	
	
	
		
 
#filter-with = proxy-prefix

			




	
	
	
		
 

			




	
	
	
		
 
full_stack = true

			




	
	
	
		
 
static_files = true

			




	
	
	
		
 
## Available Languages:

			




	
	
	
		
 
## cs de fr hu ja nl_BE pl pt_BR ru sk zh_CN zh_TW

			




	
	
	
		
 
lang =

			




	
	
	
		
 
cache_dir = %(here)s/data

			




	
	
	
		
 
index_dir = %(here)s/data/index

			




	
	
	
		
 

			




	
	
	
		
 
## perform a full repository scan on each server start, this should be

			




	
	
	
		
 
## set to false after first startup, to allow faster server restarts.

			




	
	
	
		
 
initial_repo_scan = false

			




	
	
	
		
 

			




	
	
	
		
 
## uncomment and set this path to use archive download cache

			




	
	
	
		
 
archive_cache_dir = %(here)s/tarballcache

			




	
	
	
		
 

			




	
	
	
		
 
## change this to unique ID for security

			




	
	
	
		
 
app_instance_uuid = ${app_instance_uuid}

			




	
	
	
		
 

			




	
	
	
		
 
## cut off limit for large diffs (size in bytes)

			




	
	
	
		
 
cut_off_limit = 256000

			




	
	
	
		
 

			




	
	
	
		
 
## use cache version of scm repo everywhere

			




	
	
	
		
 
vcs_full_cache = true

			




	
	
	
		
 

			




	
	
	
		
 
## force https in Kallithea, fixes https redirects, assumes it's always https

			




	
	
	
		
 
force_https = false

			




	
	
	
		
 

			




	
	
	
		
 
## use Strict-Transport-Security headers

			




	
	
	
		
 
use_htsts = false

			




	
	
	
		
 

			




	
	
	
		
 
## number of commits stats will parse on each iteration

			




	
	
	
		
 
commit_parse_limit = 25

			




	
	
	
		
 

			




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

			




	
	
	
		
 

			




	
	
	
		
 
## options for showing and identifying changesets

			




	
	
	
		
 
show_sha_length = 12

			




	
	
	
		
 
show_revision_number = false

			




	
	
	
		
 

			




	
	
	
		
 
## gist URL alias, used to create nicer urls for gist. This should be an

			




	
	
	
		
 
## url that does rewrites to _admin/gists/<gistid>.

			




	
	
	
		
 
## example: http://gist.kallithea.server/{gistid}. Empty means use the internal

			




	
	
	
		
 
## Kallithea url, ie. http[s]://your.kallithea.server/_admin/gists/<gistid>

			




	
	
	
		
 
## example: http://gist.example.com/{gistid}. Empty means use the internal

			




	
	
	
		
 
## Kallithea url, ie. http[s]://kallithea.example.com/_admin/gists/<gistid>

			




	
	
	
		
 
gist_alias_url =

			




	
	
	
		
 

			




	
	
	
		
 
## white list of API enabled controllers. This allows to add list of

			




	
	
	
		
 
## controllers to which access will be enabled by api_key. eg: to enable

			




	
	
	
		
 
## api access to raw_files put `FilesController:raw`, to enable access to patches

			




	
	
	
		
 
## add `ChangesetController:changeset_patch`. This list should be "," separated

			




	
	
	
		
 
## Syntax is <ControllerClass>:<function>. Check debug logs for generated names

			




	
	
	
		
 
## Recommended settings below are commented out:

			




	
	
	
		
 
api_access_controllers_whitelist =

			




	
	
	
		
 
#    ChangesetController:changeset_patch,

			




	
	
	
		
 
#    ChangesetController:changeset_raw,

			




	
	
	
		
 
#    FilesController:raw,

			




	
	
	
		
 
#    FilesController:archivefile

			




	
	
	
		
 

			




	
	
	
		
 
## default encoding used to convert from and to unicode

			




	
	
	
		
 
## can be also a comma seperated list of encoding in case of mixed encodings

			




	
	
	
		
 
default_encoding = utf8

			




	
	
	
		
 

			




	
	
	
		
 
## issue tracker for Kallithea (leave blank to disable, absent for default)

			




	
	
	
		
 
#bugtracker = https://bitbucket.org/conservancy/kallithea/issues

			




	
	
	
		
 

			




	
	
	
		
 
## issue tracking mapping for commits messages

			




	
	
	
		
 
## comment out issue_pat, issue_server, issue_prefix to enable

			




	
	
	
		
 

			




	
	
	
		
 
## pattern to get the issues from commit messages

			




	
	
	
		
 
## default one used here is #<numbers> with a regex passive group for `#`

			




	
	
	
		
 
## {id} will be all groups matched from this pattern

			




	
	
	
		
 

			




	
	
	
		
 
issue_pat = (?:\s*#)(\d+)

			




	
	
	
		
 

			




	
	
	
		
 
## server url to the issue, each {id} will be replaced with match

			




	
	
	
		
 
## fetched from the regex and {repo} is replaced with full repository name

			




	
	
	
		
 
## including groups {repo_name} is replaced with just name of repo

			




	
	
	
		
 

			




	
	
	
		
 
issue_server_link = https://myissueserver.com/{repo}/issue/{id}

			




	
	
	
		
 
issue_server_link = https://issues.example.com/{repo}/issue/{id}

			




	
	
	
		
 

			




	
	
	
		
 
## prefix to add to link to indicate it's an url

			




	
	
	
		
 
## #314 will be replaced by <issue_prefix><id>

			




	
	
	
		
 

			




	
	
	
		
 
issue_prefix = #

			




	
	
	
		
 

			




	
	
	
		
 
## issue_pat, issue_server_link, issue_prefix can have suffixes to specify

			




	
	
	
		
 
## multiple patterns, to other issues server, wiki or others

			




	
	
	
		
 
## below an example how to create a wiki pattern

			




	
	
	
		
 
# wiki-some-id -> https://mywiki.com/some-id

			




	
	
	
		
 
# wiki-some-id -> https://wiki.example.com/some-id

			




	
	
	
		
 

			




	
	
	
		
 
#issue_pat_wiki = (?:wiki-)(.+)

			




	
	
	
		
 
#issue_server_link_wiki = https://mywiki.com/{id}

			




	
	
	
		
 
#issue_server_link_wiki = https://wiki.example.com/{id}

			




	
	
	
		
 
#issue_prefix_wiki = WIKI-

			




	
	
	
		
 

			




	
	
	
		
 
## instance-id prefix

			




	
	
	
		
 
## a prefix key for this instance used for cache invalidation when running

			




	
	
	
		
 
## multiple instances of kallithea, make sure it's globally unique for

			




	
	
	
		
 
## all running kallithea instances. Leave empty if you don't use it

			




	
	
	
		
 
instance_id =

			




	
	
	
		
 

			




	
	
	
		
 
## alternative return HTTP header for failed authentication. Default HTTP

			




	
	
	
		
 
## response is 401 HTTPUnauthorized. Currently Mercurial clients have trouble with

			




	
	
	
		
 
## handling that. Set this variable to 403 to return HTTPForbidden

			




	
	
	
		
 
auth_ret_code =

			




	
	
	
		
 

			




	
	
	
		
 
## locking return code. When repository is locked return this HTTP code. 2XX

			




	
	
	
		
 
## codes don't break the transactions while 4XX codes do

			




	
	
	
		
 
lock_ret_code = 423

			




	
	
	
		
 

			




	
	
	
		
 
## allows to change the repository location in settings page

			




	
	
	
		
 
allow_repo_location_change = True

			




	
	
	
		
 

			




	
	
	
		
 
## allows to setup custom hooks in settings page

			




	
	
	
		
 
allow_custom_hooks_settings = True

			




	
	
	
		
 

			




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

			




	
	
	
		
 
###        CELERY CONFIG        ####

			




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

			




	
	
	
		
 

			




	
	
	
		
 
use_celery = false

			




	
	
	
		
 
broker.host = localhost

			




	
	
	
		
 
broker.vhost = rabbitmqhost

			




	
	
	
		
 
broker.port = 5672

			




	
	
	
		
 
broker.user = rabbitmq

			




	
	
	
		
 
broker.password = qweqwe

			




	
	
	
		
 

			




	
	
	
		
 
celery.imports = kallithea.lib.celerylib.tasks

			




	
	
	
		
 

			




	
	
	
		
 
celery.result.backend = amqp

			




	
	
	
		
 
celery.result.dburi = amqp://

			




	
	
	
		
 
celery.result.serialier = json

			




	
	
	
		
 

			




	
	
	
		
 
#celery.send.task.error.emails = true

			




	
	
	
		
 
#celery.amqp.task.result.expires = 18000

			




	
	
	
		
 

			




	
	
	
		
 
celeryd.concurrency = 2

			




	
	
	
		
 
#celeryd.log.file = celeryd.log

			




	
	
	
		
 
celeryd.log.level = DEBUG

			




	
	
	
		
 
celeryd.max.tasks.per.child = 1

			




	
	
	
		
 

			




	
	
	
		
 
## tasks will never be sent to the queue, but executed locally instead.

			




	
	
	
		
 
celery.always.eager = false

			




	
	
	
		
 

			




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

			




	
	
	
		
 
###         BEAKER CACHE        ####

			




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

			




	
	
	
		
 

			




	
	
	
		
 
beaker.cache.data_dir = %(here)s/data/cache/data

			




	
	
	
		
 
beaker.cache.lock_dir = %(here)s/data/cache/lock

			




	
	
	
		
 

			




	
	
	
		
 
beaker.cache.regions = short_term,long_term,sql_cache_short

			




	
	
	
		
 

			




	
	
	
		
 
beaker.cache.short_term.type = memory

			




	
	
	
		
 
beaker.cache.short_term.expire = 60

			




	
	
	
		
 
beaker.cache.short_term.key_length = 256

			




	
	
	
		
 

			




	
	
	
		
 
beaker.cache.long_term.type = memory

			




	
	
	
		
 
beaker.cache.long_term.expire = 36000

			




	
	
	
		
 
beaker.cache.long_term.key_length = 256

			




	
	
	
		
 

			




	
	
	
		
 
beaker.cache.sql_cache_short.type = memory

			




	
	
	
		
 
beaker.cache.sql_cache_short.expire = 10

			




	
	
	
		
 
beaker.cache.sql_cache_short.key_length = 256

			




	
	
	
		
 

			




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

			




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

			




	
	
	
		
 
beaker.session.key = kallithea

			




	
	
	
		
 
## Sessions should always only be accessible by the browser, not directly by JavaScript.

			




	
	
	
		
 
beaker.session.httponly = true

			




	
	
	
		
 
## Session lifetime. 2592000 seconds is 30 days.

			




	
	
	
		
 
beaker.session.timeout = 2592000

			




	
	
	
		
 

			




	
	
	
		
 
## Server secret used with HMAC to ensure integrity of cookies.

			




	
	
	
		
 
beaker.session.secret = ${app_instance_uuid}

			




	
	
	
		
 
## Further, encrypt the data with AES.

			




	
	
	
		
 
#beaker.session.encrypt_key = <key_for_encryption>

			




	
	
	
		
 
#beaker.session.validate_key = <validation_key>

			




	
	
	
		
 

			




	
	
	
		
 
## Type of storage used for the session, current types are

			




	
	
	
		
 
## dbm, file, memcached, database, and memory.

			




	
	
	
		
 

			




	
	
	
		
 
## File system storage of session data. (default)

			




	
	
	
		
 
#beaker.session.type = file

			




	
	
	
		
 

			




	
	
	
		
 
## Cookie only, store all session data inside the cookie. Requires secure secrets.

			




	
	
	
		
 
#beaker.session.type = cookie

			




	
	
	
		
 

			




	
	
	
		
 
## Database storage of session data.

			




	
	
	
		
 
#beaker.session.type = ext:database

			




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

			




	
	
	
		
 
#beaker.session.table_name = db_session

			




	
	
	
		
 

			




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

			




	
	
	
		
 
## ERROR HANDLING SYSTEMS ##

			




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

			




	
	
	
		
 

			




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

			




	
	
	
		
 
### [errormator] ###

			




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

			




	
	
	
		
 

			




	
	
	
		
 
## Errormator is tailored to work with Kallithea, see

			




	
	
	
		
 
## http://errormator.com for details how to obtain an account

			




	
	
	
		
 
## you must install python package `errormator_client` to make it work

			




	
	
	
		
 

			




	
	
	
		
 
## errormator enabled

			




	
	
	
		
 
errormator = false

			




	
	
	
		
 

			




	
	
	
		
 
errormator.server_url = https://api.errormator.com

			




	
	
	
		
 
errormator.api_key = YOUR_API_KEY

			




	
	
	
		
 

			




	
	
	
		
 
## TWEAK AMOUNT OF INFO SENT HERE

			




	
	
	
		
 

			




	
	
	
		
 
## enables 404 error logging (default False)

			




	
	
	
		
 
errormator.report_404 = false

			




	
	
	
		
 

			




	
	
	
		
 
## time in seconds after request is considered being slow (default 1)

			




	
	
	
		
 
errormator.slow_request_time = 1

			




	
	
	
		
 

			




	
	
	
		
 
## record slow requests in application

			




	
	
	
		
 
## (needs to be enabled for slow datastore recording and time tracking)

			




	
	
	
		
 
errormator.slow_requests = true

			




	
	
	
		
 

			




	
	
	
		
 
## enable hooking to application loggers

			




	
	
	
		
 
#errormator.logging = true

			




	
	
	
		
 

			




	
	
	
		
 
## minimum log level for log capture

			




	
	
	
		
 
#errormator.logging.level = WARNING

			




	
	
	
		
 

			




	
	
	
		
 
## send logs only from erroneous/slow requests

			




	
	
	
		
 
## (saves API quota for intensive logging)

			




	
	
	
		
 
errormator.logging_on_error = false

			




	
	
	
		
 

			




	
	
	
		
 
## list of additonal keywords that should be grabbed from environ object

			




	
	
	
		
 
## can be string with comma separated list of words in lowercase

			




	
	
	
		
 
## (by default client will always send following info:

			




	
	
	
		
 
## 'REMOTE_USER', 'REMOTE_ADDR', 'SERVER_NAME', 'CONTENT_TYPE' + all keys that

			




	
	
	
		
 
## start with HTTP* this list be extended with additional keywords here

			




	
	
	
		
 
errormator.environ_keys_whitelist =

			




	
	
	
		
 

			




	
	
	
		
 
## list of keywords that should be blanked from request object

			




	
	
	
		
 
## can be string with comma separated list of words in lowercase

			




	
	
	
		
 
## (by default client will always blank keys that contain following words

			




	
	
	
		
 
## 'password', 'passwd', 'pwd', 'auth_tkt', 'secret', 'csrf'

			




	
	
	
		
 
## this list be extended with additional keywords set here

			




	
	
	
		
 
errormator.request_keys_blacklist =

			




	
	
	
		
 

			




	
	
	
		
 
## list of namespaces that should be ignores when gathering log entries

			




	
	
	
		
 
## can be string with comma separated list of namespaces

			




	
	
	
		
 
## (by default the client ignores own entries: errormator_client.client)

			




	
	
	
		
 
errormator.log_namespace_blacklist =

			




	
	
	
		
 

			




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

			




	
	
	
		
 
### [sentry] ###

			




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

			




	
	
	
		
 

			




	
	
	
		
 
## sentry is a alternative open source error aggregator

			




	
	
	
		
 
## you must install python packages `sentry` and `raven` to enable

			




	
	
	
		
 

			




	
	
	
		
 
sentry.dsn = YOUR_DNS

			




	
	
	
		
 
sentry.servers =

			




	
	
	
		
 
sentry.name =

			




	
	
	
		
 
sentry.key =

			




	
	
	
		
 
sentry.public_key =

			




	
	
	
		
 
sentry.secret_key =

			




	
	
	
		
 
sentry.project =

			




	
	
	
		
 
sentry.site =

			




	
	
	
		
 
sentry.include_paths =

			




	
	
	
		
 
sentry.exclude_paths =

			




	
	
	
		
 

			




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

			




	
	
	
		
 
## WARNING: *THE LINE BELOW MUST BE UNCOMMENTED ON A PRODUCTION ENVIRONMENT*  ##

			




	
	
	
		
 
## Debug mode will enable the interactive debugging tool, allowing ANYONE to  ##

			




	
	
	
		
 
## execute malicious code after an exception is raised.                       ##

			




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

			




	
	
	
		
 
set debug = false

			




	
	
	
		
 

			




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

			




	
	
	
		
 
###       LOGVIEW CONFIG       ###

			




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

			




	
	
	
		
 

			




        

    


    
    

    

        

                

                    kallithea/lib/rcmail/response.py
                

                

                  
                      
                        

                      ➞

                      
                        
                  

                  
                      
                  
                      
                  
                      
                  
                      
                  
                  
                

                

                    Show inline comments
                    
                

        

        

            



	
	
	
		
 
# The code in this module is entirely lifted from the Lamson project

			




	
	
	
		
 
# (http://lamsonproject.org/).  Its copyright is:

			




	
	
	
		
 

			




	
	
	
		
 
# Copyright (c) 2008, Zed A. Shaw

			




	
	
	
		
 
# All rights reserved.

			




	
	
	
		
 

			




	
	
	
		
 
# It is provided under this license:

			




	
	
	
		
 

			




	
	
	
		
 
# Redistribution and use in source and binary forms, with or without

			




	
	
	
		
 
# modification, are permitted provided that the following conditions are met:

			




	
	
	
		
 

			




	
	
	
		
 
# * Redistributions of source code must retain the above copyright notice, this

			




	
	
	
		
 
#   list of conditions and the following disclaimer.

			




	
	
	
		
 

			




	
	
	
		
 
# * Redistributions in binary form must reproduce the above copyright notice,

			




	
	
	
		
 
#   this list of conditions and the following disclaimer in the documentation

			




	
	
	
		
 
#   and/or other materials provided with the distribution.

			




	
	
	
		
 

			




	
	
	
		
 
# * Neither the name of the Zed A. Shaw nor the names of its contributors may

			




	
	
	
		
 
#   be used to endorse or promote products derived from this software without

			




	
	
	
		
 
#   specific prior written permission.

			




	
	
	
		
 

			




	
	
	
		
 
# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS

			




	
	
	
		
 
# "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT

			




	
	
	
		
 
# LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS

			




	
	
	
		
 
# FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE

			




	
	
	
		
 
# COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT,

			




	
	
	
		
 
# INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES

			




	
	
	
		
 
# (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR

			




	
	
	
		
 
# SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)

			




	
	
	
		
 
# HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,

			




	
	
	
		
 
# STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)

			




	
	
	
		
 
# ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE

			




	
	
	
		
 
# POSSIBILITY OF SUCH DAMAGE.

			




	
	
	
		
 

			




	
	
	
		
 
import os

			




	
	
	
		
 
import mimetypes

			




	
	
	
		
 
import string

			




	
	
	
		
 
from email import encoders

			




	
	
	
		
 
from email.charset import Charset

			




	
	
	
		
 
from email.utils import parseaddr

			




	
	
	
		
 
from email.mime.base import MIMEBase

			




	
	
	
		
 

			




	
	
	
		
 
ADDRESS_HEADERS_WHITELIST = ['From', 'To', 'Delivered-To', 'Cc']

			




	
	
	
		
 
DEFAULT_ENCODING = "utf-8"

			




	
	
	
		
 
VALUE_IS_EMAIL_ADDRESS = lambda v: '@' in v

			




	
	
	
		
 

			




	
	
	
		
 

			




	
	
	
		
 
def normalize_header(header):

			




	
	
	
		
 
    return string.capwords(header.lower(), '-')

			




	
	
	
		
 

			




	
	
	
		
 

			




	
	
	
		
 
class EncodingError(Exception):

			




	
	
	
		
 
    """Thrown when there is an encoding error."""

			




	
	
	
		
 
    pass

			




	
	
	
		
 

			




	
	
	
		
 

			




	
	
	
		
 
class MailBase(object):

			




	
	
	
		
 
    """MailBase is used as the basis of lamson.mail and contains the basics of

			




	
	
	
		
 
    encoding an email.  You actually can do all your email processing with this

			




	
	
	
		
 
    class, but it's more raw.

			




	
	
	
		
 
    """

			




	
	
	
		
 
    def __init__(self, items=()):

			




	
	
	
		
 
        self.headers = dict(items)

			




	
	
	
		
 
        self.parts = []

			




	
	
	
		
 
        self.body = None

			




	
	
	
		
 
        self.content_encoding = {'Content-Type': (None, {}),

			




	
	
	
		
 
                                 'Content-Disposition': (None, {}),

			




	
	
	
		
 
                                 'Content-Transfer-Encoding': (None, {})}

			




	
	
	
		
 

			




	
	
	
		
 
    def __getitem__(self, key):

			




	
	
	
		
 
        return self.headers.get(normalize_header(key), None)

			




	
	
	
		
 

			




	
	
	
		
 
    def __len__(self):

			




	
	
	
		
 
        return len(self.headers)

			




	
	
	
		
 

			




	
	
	
		
 
    def __iter__(self):

			




	
	
	
		
 
        return iter(self.headers)

			




	
	
	
		
 

			




	
	
	
		
 
    def __contains__(self, key):

			




	
	
	
		
 
        return normalize_header(key) in self.headers

			




	
	
	
		
 

			




	
	
	
		
 
    def __setitem__(self, key, value):

			




	
	
	
		
 
        self.headers[normalize_header(key)] = value

			




	
	
	
		
 

			




	
	
	
		
 
    def __delitem__(self, key):

			




	
	
	
		
 
        del self.headers[normalize_header(key)]

			




	
	
	
		
 

			




	
	
	
		
 
    def __nonzero__(self):

			




	
	
	
		
 
        return self.body is not None or len(self.headers) > 0 or len(self.parts) > 0

			




	
	
	
		
 

			




	
	
	
		
 
    def keys(self):

			




	
	
	
		
 
        """Returns the sorted keys."""

			




	
	
	
		
 
        return sorted(self.headers.keys())

			




	
	
	
		
 

			




	
	
	
		
 
    def attach_file(self, filename, data, ctype, disposition):

			




	
	
	
		
 
        """

			




	
	
	
		
 
        A file attachment is a raw attachment with a disposition that

			




	
	
	
		
 
        indicates the file name.

			




	
	
	
		
 
        """

			




	
	
	
		
 
        assert filename, "You can't attach a file without a filename."

			




	
	
	
		
 
        ctype = ctype.lower()

			




	
	
	
		
 

			




	
	
	
		
 
        part = MailBase()

			




	
	
	
		
 
        part.body = data

			




	
	
	
		
 
        part.content_encoding['Content-Type'] = (ctype, {'name': filename})

			




	
	
	
		
 
        part.content_encoding['Content-Disposition'] = (disposition,

			




	
	
	
		
 
                                                        {'filename': filename})

			




	
	
	
		
 
        self.parts.append(part)

			




	
	
	
		
 

			




	
	
	
		
 
    def attach_text(self, data, ctype):

			




	
	
	
		
 
        """

			




	
	
	
		
 
        This attaches a simpler text encoded part, which doesn't have a

			




	
	
	
		
 
        filename.

			




	
	
	
		
 
        """

			




	
	
	
		
 
        ctype = ctype.lower()

			




	
	
	
		
 

			




	
	
	
		
 
        part = MailBase()

			




	
	
	
		
 
        part.body = data

			




	
	
	
		
 
        part.content_encoding['Content-Type'] = (ctype, {})

			




	
	
	
		
 
        self.parts.append(part)

			




	
	
	
		
 

			




	
	
	
		
 
    def walk(self):

			




	
	
	
		
 
        for p in self.parts:

			




	
	
	
		
 
            yield p

			




	
	
	
		
 
            for x in p.walk():

			




	
	
	
		
 
                yield x

			




	
	
	
		
 

			




	
	
	
		
 

			




	
	
	
		
 
class MailResponse(object):

			




	
	
	
		
 
    """

			




	
	
	
		
 
    You are given MailResponse objects from the lamson.view methods, and

			




	
	
	
		
 
    whenever you want to generate an email to send to someone.  It has the

			




	
	
	
		
 
    same basic functionality as MailRequest, but it is designed to be written

			




	
	
	
		
 
    to, rather than read from (although you can do both).

			




	
	
	
		
 

			




	
	
	
		
 
    You can easily set a Body or Html during creation or after by passing it

			




	
	
	
		
 
    as __init__ parameters, or by setting those attributes.

			




	
	
	
		
 

			




	
	
	
		
 
    You can initially set the From, To, and Subject, but they are headers so

			




	
	
	
		
 
    use the dict notation to change them: msg['From'] = 'joe@test.com'.

			




	
	
	
		
 
    use the dict notation to change them: msg['From'] = 'joe@example.com'.

			




	
	
	
		
 

			




	
	
	
		
 
    The message is not fully crafted until right when you convert it with

			




	
	
	
		
 
    MailResponse.to_message.  This lets you change it and work with it, then

			




	
	
	
		
 
    send it out when it's ready.

			




	
	
	
		
 
    """

			




	
	
	
		
 
    def __init__(self, To=None, From=None, Subject=None, Body=None, Html=None,

			




	
	
	
		
 
                 separator="; "):

			




	
	
	
		
 
        self.Body = Body

			




	
	
	
		
 
        self.Html = Html

			




	
	
	
		
 
        self.base = MailBase([('To', To), ('From', From), ('Subject', Subject)])

			




	
	
	
		
 
        self.multipart = self.Body and self.Html

			




	
	
	
		
 
        self.attachments = []

			




	
	
	
		
 
        self.separator = separator

			




	
	
	
		
 

			




	
	
	
		
 
    def __contains__(self, key):

			




	
	
	
		
 
        return self.base.__contains__(key)

			




	
	
	
		
 

			




	
	
	
		
 
    def __getitem__(self, key):

			




	
	
	
		
 
        return self.base.__getitem__(key)

			




	
	
	
		
 

			




	
	
	
		
 
    def __setitem__(self, key, val):

			




	
	
	
		
 
        return self.base.__setitem__(key, val)

			




	
	
	
		
 

			




	
	
	
		
 
    def __delitem__(self, name):

			




	
	
	
		
 
        del self.base[name]

			




	
	
	
		
 

			




	
	
	
		
 
    def attach(self, filename=None, content_type=None, data=None,

			




	
	
	
		
 
               disposition=None):

			




	
	
	
		
 
        """

			




	
	
	
		
 

			




	
	
	
		
 
        Simplifies attaching files from disk or data as files.  To attach

			




	
	
	
		
 
        simple text simple give data and a content_type.  To attach a file,

			




	
	
	
		
 
        give the data/content_type/filename/disposition combination.

			




	
	
	
		
 

			




	
	
	
		
 
        For convenience, if you don't give data and only a filename, then it

			




	
	
	
		
 
        will read that file's contents when you call to_message() later.  If

			




	
	
	
		
 
        you give data and filename then it will assume you've filled data

			




	
	
	
		
 
        with what the file's contents are and filename is just the name to

			




	
	
	
		
 
        use.

			




	
	
	
		
 
        """

			




	
	
	
		
 

			




	
	
	
		
 
        assert filename or data, ("You must give a filename or some data to "

			




	
	
	
		
 
                                  "attach.")

			




	
	
	
		
 
        assert data or os.path.exists(filename), ("File doesn't exist, and no "

			




	
	
	
		
 
                                                  "data given.")

			




	
	
	
		
 

			




	
	
	
		
 
        self.multipart = True

			




	
	
	
		
 

			




	
	
	
		
 
        if filename and not content_type:

			




	
	
	
		
 
            content_type, encoding = mimetypes.guess_type(filename)

			




	
	
	
		
 

			




	
	
	
		
 
        assert content_type, ("No content type given, and couldn't guess "

			




	
	
	
		
 
                              "from the filename: %r" % filename)

			




	
	
	
		
 

			




	
	
	
		
 
        self.attachments.append({'filename': filename,

			




	
	
	
		
 
                                 'content_type': content_type,

			




	
	
	
		
 
                                 'data': data,

			




	
	
	
		
 
                                 'disposition': disposition,})

			




	
	
	
		
 

			




	
	
	
		
 
    def attach_part(self, part):

			




	
	
	
		
 
        """

			




	
	
	
		
 
        Attaches a raw MailBase part from a MailRequest (or anywhere)

			




	
	
	
		
 
        so that you can copy it over.

			




	
	
	
		
 
        """

			




	
	
	
		
 
        self.multipart = True

			




	
	
	
		
 

			




	
	
	
		
 
        self.attachments.append({'filename': None,

			




	
	
	
		
 
                                 'content_type': None,

			




	
	
	
		
 
                                 'data': None,

			




	
	
	
		
 
                                 'disposition': None,

			




	
	
	
		
 
                                 'part': part,

			




	
	
	
		
 
                                 })

			




	
	
	
		
 

			




	
	
	
		
 
    def attach_all_parts(self, mail_request):

			




	
	
	
		
 
        """

			




	
	
	
		
 
        Used for copying the attachment parts of a mail.MailRequest

			




	
	
	
		
 
        object for mailing lists that need to maintain attachments.

			




	
	
	
		
 
        """

			




	
	
	
		
 
        for part in mail_request.all_parts():

			




	
	
	
		
 
            self.attach_part(part)

			




	
	
	
		
 

			




	
	
	
		
 
        self.base.content_encoding = mail_request.base.content_encoding.copy()

			




	
	
	
		
 

			




	
	
	
		
 
    def clear(self):

			




	
	
	
		
 
        """

			




	
	
	
		
 
        Clears out the attachments so you can redo them.  Use this to keep the

			




	
	
	
		
 
        headers for a series of different messages with different attachments.

			




	
	
	
		
 
        """

			




	
	
	
		
 
        del self.attachments[:]

			




	
	
	
		
 
        del self.base.parts[:]

			




	
	
	
		
 
        self.multipart = False

			




	
	
	
		
 

			




	
	
	
		
 
    def update(self, message):

			




	
	
	
		
 
        """

			




	
	
	
		
 
        Used to easily set a bunch of heading from another dict

			




	
	
	
		
 
        like object.

			




	
	
	
		
 
        """

			




	
	
	
		
 
        for k in message.keys():

			




	
	
	
		
 
            self.base[k] = message[k]

			




	
	
	
		
 

			




	
	
	
		
 
    def __str__(self):

			




	
	
	
		
 
        """

			




	
	
	
		
 
        Converts to a string.

			




	
	
	
		
 
        """

			




	
	
	
		
 
        return self.to_message().as_string()

			




	
	
	
		
 

			




	
	
	
		
 
    def _encode_attachment(self, filename=None, content_type=None, data=None,

			




	
	
	
		
 
                           disposition=None, part=None):

			




	
	
	
		
 
        """

			




	
	
	
		
 
        Used internally to take the attachments mentioned in self.attachments

			




	
	
	
		
 
        and do the actual encoding in a lazy way when you call to_message.

			




	
	
	
		
 
        """

			




	
	
	
		
 
        if part:

			




	
	
	
		
 
            self.base.parts.append(part)

			




	
	
	
		
 
        elif filename:

			




	
	
	
		
 
            if not data:

			




	
	
	
		
 
                data = open(filename).read()

			




	
	
	
		
 

			




	
	
	
		
 
            self.base.attach_file(filename, data, content_type,

			




	
	
	
		
 
                                  disposition or 'attachment')

			




	
	
	
		
 
        else:

			




	
	
	
		
 
            self.base.attach_text(data, content_type)

			




	
	
	
		
 

			




	
	
	
		
 
        ctype = self.base.content_encoding['Content-Type'][0]

			




	
	
	
		
 

			




	
	
	
		
 
        if ctype and not ctype.startswith('multipart'):

			




	
	
	
		
 
            self.base.content_encoding['Content-Type'] = ('multipart/mixed', {})

			




	
	
	
		
 

			




	
	
	
		
 
    def to_message(self):

			




	
	
	
		
 
        """

			




	
	
	
		
 
        Figures out all the required steps to finally craft the

			




	
	
	
		
 
        message you need and return it.  The resulting message

			




	
	
	
		
 
        is also available as a self.base attribute.

			




	
	
	
		
 

			




	
	
	
		
 
        What is returned is a Python email API message you can

			




	
	
	
		
 
        use with those APIs.  The self.base attribute is the raw

			




	
	
	
		
 
        lamson.encoding.MailBase.

			




	
	
	
		
 
        """

			




	
	
	
		
 
        del self.base.parts[:]

			




	
	
	
		
 

			




	
	
	
		
 
        if self.Body and self.Html:

			




	
	
	
		
 
            self.multipart = True

			




	
	
	
		
 
            self.base.content_encoding['Content-Type'] = (

			




	
	
	
		
 
                'multipart/alternative', {})

			




	
	
	
		
 

			




	
	
	
		
 
        if self.multipart:

			




	
	
	
		
 
            self.base.body = None

			




	
	
	
		
 
            if self.Body:

			




	
	
	
		
 
                self.base.attach_text(self.Body, 'text/plain')

			




	
	
	
		
 

			




	
	
	
		
 
            if self.Html:

			




	
	
	
		
 
                self.base.attach_text(self.Html, 'text/html')

			




	
	
	
		
 

			




	
	
	
		
 
            for args in self.attachments:

			




	
	
	
		
 
                self._encode_attachment(**args)

			




	
	
	
		
 

			




	
	
	
		
 
        elif self.Body:

			




	
	
	
		
 
            self.base.body = self.Body

			




	
	
	
		
 
            self.base.content_encoding['Content-Type'] = ('text/plain', {})

			




	
	
	
		
 

			




	
	
	
		
 
        elif self.Html:

			




	
	
	
		
 
            self.base.body = self.Html

			




	
	
	
		
 
            self.base.content_encoding['Content-Type'] = ('text/html', {})

			




	
	
	
		
 

			




	
	
	
		
 
        return to_message(self.base, separator=self.separator)

			




	
	
	
		
 

			




	
	
	
		
 
    def all_parts(self):

			




	
	
	
		
 
        """

			




	
	
	
		
 
        Returns all the encoded parts.  Only useful for debugging

			




	
	
	
		
 
        or inspecting after calling to_message().

			




	
	
	
		
 
        """

			




	
	
	
		
 
        return self.base.parts

			




	
	
	
		
 

			




	
	
	
		
 
    def keys(self):

			




	
	
	
		
 
        return self.base.keys()

			




	
	
	
		
 

			




	
	
	
		
 

			




	
	
	
		
 
def to_message(mail, separator="; "):

			




	
	
	
		
 
    """

			




	
	
	
		
 
    Given a MailBase message, this will construct a MIMEPart

			




	
	
	
		
 
    that is canonicalized for use with the Python email API.

			




	
	
	
		
 
    """

			




	
	
	
		
 
    ctype, params = mail.content_encoding['Content-Type']

			




	
	
	
		
 

			




	
	
	
		
 
    if not ctype:

			




	
	
	
		
 
        if mail.parts:

			




	
	
	
		
 
            ctype = 'multipart/mixed'

			




	
	
	
		
 
        else:

			




	
	
	
		
 
            ctype = 'text/plain'

			




	
	
	
		
 
    else:

			




	
	
	
		
 
        if mail.parts:

			




	
	
	
		
 
            assert ctype.startswith(("multipart", "message")), \

			




        

    


    
    

    

        

                

                    kallithea/tests/__init__.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/>.

			




	
	
	
		
 

			




	
	
	
		
 
"""

			




	
	
	
		
 
Pylons application test package

			




	
	
	
		
 

			




	
	
	
		
 
This package assumes the Pylons environment is already loaded, such as

			




	
	
	
		
 
when this script is imported from the `nosetests --with-pylons=test.ini`

			




	
	
	
		
 
command.

			




	
	
	
		
 

			




	
	
	
		
 
This module initializes the application via ``websetup`` (`paster

			




	
	
	
		
 
setup-app`) and provides the base testing objects.

			




	
	
	
		
 

			




	
	
	
		
 
nosetests -x - fail on first error

			




	
	
	
		
 
nosetests kallithea.tests.functional.test_admin_settings:TestSettingsController.test_my_account

			




	
	
	
		
 
nosetests --pdb --pdb-failures

			




	
	
	
		
 
nosetests --with-coverage --cover-package=kallithea.model.validators kallithea.tests.test_validators

			




	
	
	
		
 

			




	
	
	
		
 
optional FLAGS:

			




	
	
	
		
 
    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 test_vcs_operations

			




	
	
	
		
 

			




	
	
	
		
 
"""

			




	
	
	
		
 
import os

			




	
	
	
		
 
import re

			




	
	
	
		
 
import time

			




	
	
	
		
 
import logging

			




	
	
	
		
 
import datetime

			




	
	
	
		
 
import hashlib

			




	
	
	
		
 
import tempfile

			




	
	
	
		
 
from os.path import join as jn

			




	
	
	
		
 

			




	
	
	
		
 
from tempfile import _RandomNameSequence

			




	
	
	
		
 

			




	
	
	
		
 
import pylons

			




	
	
	
		
 
import pylons.test

			




	
	
	
		
 
from pylons import config, url

			




	
	
	
		
 
from pylons.i18n.translation import _get_translator

			




	
	
	
		
 
from pylons.util import ContextObj

			




	
	
	
		
 

			




	
	
	
		
 
from routes.util import URLGenerator

			




	
	
	
		
 
from webtest import TestApp

			




	
	
	
		
 
from nose.plugins.skip import SkipTest

			




	
	
	
		
 

			




	
	
	
		
 
from kallithea.lib.compat import unittest

			




	
	
	
		
 
from kallithea import is_windows

			




	
	
	
		
 
from kallithea.model.db import Notification, User, UserNotification

			




	
	
	
		
 
from kallithea.model.meta import Session

			




	
	
	
		
 
from kallithea.tests.parameterized import parameterized

			




	
	
	
		
 
from kallithea.lib.utils2 import safe_str

			




	
	
	
		
 

			




	
	
	
		
 

			




	
	
	
		
 
os.environ['TZ'] = 'UTC'

			




	
	
	
		
 
if not is_windows:

			




	
	
	
		
 
    time.tzset()

			




	
	
	
		
 

			




	
	
	
		
 
log = logging.getLogger(__name__)

			




	
	
	
		
 

			




	
	
	
		
 
__all__ = [

			




	
	
	
		
 
    'parameterized', 'environ', 'url', 'TestController',

			




	
	
	
		
 
    'SkipTest', 'ldap_lib_installed', 'pam_lib_installed', 'BaseTestCase', 'init_stack',

			




	
	
	
		
 
    'TESTS_TMP_PATH', 'HG_REPO', 'GIT_REPO', 'NEW_HG_REPO', 'NEW_GIT_REPO',

			




	
	
	
		
 
    'HG_FORK', 'GIT_FORK', 'TEST_USER_ADMIN_LOGIN', 'TEST_USER_ADMIN_PASS',

			




	
	
	
		
 
    'TEST_USER_ADMIN_EMAIL', 'TEST_USER_REGULAR_LOGIN', 'TEST_USER_REGULAR_PASS',

			




	
	
	
		
 
    'TEST_USER_REGULAR_EMAIL', 'TEST_USER_REGULAR2_LOGIN',

			




	
	
	
		
 
    'TEST_USER_REGULAR2_PASS', 'TEST_USER_REGULAR2_EMAIL', 'TEST_HG_REPO',

			




	
	
	
		
 
    'TEST_HG_REPO_CLONE', 'TEST_HG_REPO_PULL', 'TEST_GIT_REPO',

			




	
	
	
		
 
    'TEST_GIT_REPO_CLONE', 'TEST_GIT_REPO_PULL', 'HG_REMOTE_REPO',

			




	
	
	
		
 
    'GIT_REMOTE_REPO', 'SCM_TESTS',

			




	
	
	
		
 
]

			




	
	
	
		
 

			




	
	
	
		
 
# Invoke websetup with the current config file

			




	
	
	
		
 
# SetupCommand('setup-app').run([config_file])

			




	
	
	
		
 

			




	
	
	
		
 
environ = {}

			




	
	
	
		
 

			




	
	
	
		
 
#SOME GLOBALS FOR TESTS

			




	
	
	
		
 

			




	
	
	
		
 
TESTS_TMP_PATH = jn('/', 'tmp', 'rc_test_%s' % _RandomNameSequence().next())

			




	
	
	
		
 
TEST_USER_ADMIN_LOGIN = 'test_admin'

			




	
	
	
		
 
TEST_USER_ADMIN_PASS = 'test12'

			




	
	
	
		
 
TEST_USER_ADMIN_EMAIL = 'test_admin@mail.com'

			




	
	
	
		
 
TEST_USER_ADMIN_EMAIL = 'test_admin@example.com'

			




	
	
	
		
 

			




	
	
	
		
 
TEST_USER_REGULAR_LOGIN = 'test_regular'

			




	
	
	
		
 
TEST_USER_REGULAR_PASS = 'test12'

			




	
	
	
		
 
TEST_USER_REGULAR_EMAIL = 'test_regular@mail.com'

			




	
	
	
		
 
TEST_USER_REGULAR_EMAIL = 'test_regular@example.com'

			




	
	
	
		
 

			




	
	
	
		
 
TEST_USER_REGULAR2_LOGIN = 'test_regular2'

			




	
	
	
		
 
TEST_USER_REGULAR2_PASS = 'test12'

			




	
	
	
		
 
TEST_USER_REGULAR2_EMAIL = 'test_regular2@mail.com'

			




	
	
	
		
 
TEST_USER_REGULAR2_EMAIL = 'test_regular2@example.com'

			




	
	
	
		
 

			




	
	
	
		
 
HG_REPO = 'vcs_test_hg'

			




	
	
	
		
 
GIT_REPO = 'vcs_test_git'

			




	
	
	
		
 

			




	
	
	
		
 
NEW_HG_REPO = 'vcs_test_hg_new'

			




	
	
	
		
 
NEW_GIT_REPO = 'vcs_test_git_new'

			




	
	
	
		
 

			




	
	
	
		
 
HG_FORK = 'vcs_test_hg_fork'

			




	
	
	
		
 
GIT_FORK = 'vcs_test_git_fork'

			




	
	
	
		
 

			




	
	
	
		
 
## VCS

			




	
	
	
		
 
SCM_TESTS = ['hg', 'git']

			




	
	
	
		
 
uniq_suffix = str(int(time.mktime(datetime.datetime.now().timetuple())))

			




	
	
	
		
 

			




	
	
	
		
 
GIT_REMOTE_REPO = 'git://github.com/codeinn/vcs.git'

			




	
	
	
		
 

			




	
	
	
		
 
TEST_GIT_REPO = jn(TESTS_TMP_PATH, GIT_REPO)

			




	
	
	
		
 
TEST_GIT_REPO_CLONE = jn(TESTS_TMP_PATH, 'vcsgitclone%s' % uniq_suffix)

			




	
	
	
		
 
TEST_GIT_REPO_PULL = jn(TESTS_TMP_PATH, 'vcsgitpull%s' % uniq_suffix)

			




	
	
	
		
 

			




	
	
	
		
 

			




	
	
	
		
 
HG_REMOTE_REPO = 'http://bitbucket.org/marcinkuzminski/vcs'

			




	
	
	
		
 

			




	
	
	
		
 
TEST_HG_REPO = jn(TESTS_TMP_PATH, HG_REPO)

			




	
	
	
		
 
TEST_HG_REPO_CLONE = jn(TESTS_TMP_PATH, 'vcshgclone%s' % uniq_suffix)

			




	
	
	
		
 
TEST_HG_REPO_PULL = jn(TESTS_TMP_PATH, 'vcshgpull%s' % uniq_suffix)

			




	
	
	
		
 

			




	
	
	
		
 
TEST_DIR = tempfile.gettempdir()

			




	
	
	
		
 
TEST_REPO_PREFIX = 'vcs-test'

			




	
	
	
		
 

			




	
	
	
		
 
# cached repos if any !

			




	
	
	
		
 
# comment out to get some other repos from bb or github

			




	
	
	
		
 
GIT_REMOTE_REPO = jn(TESTS_TMP_PATH, GIT_REPO)

			




	
	
	
		
 
HG_REMOTE_REPO = jn(TESTS_TMP_PATH, HG_REPO)

			




	
	
	
		
 

			




	
	
	
		
 
#skip ldap tests if LDAP lib is not installed

			




	
	
	
		
 
ldap_lib_installed = False

			




	
	
	
		
 
try:

			




	
	
	
		
 
    import ldap

			




	
	
	
		
 
    ldap.API_VERSION

			




	
	
	
		
 
    ldap_lib_installed = True

			




	
	
	
		
 
except ImportError:

			




	
	
	
		
 
    # means that python-ldap is not installed

			




	
	
	
		
 
    pass

			




	
	
	
		
 

			




	
	
	
		
 
try:

			




	
	
	
		
 
    import pam

			




	
	
	
		
 
    pam.PAM_TEXT_INFO

			




	
	
	
		
 
    pam_lib_installed = True

			




	
	
	
		
 
except ImportError:

			




	
	
	
		
 
    pam_lib_installed = False

			




	
	
	
		
 

			




	
	
	
		
 
import logging

			




	
	
	
		
 

			




	
	
	
		
 
class NullHandler(logging.Handler):

			




	
	
	
		
 
    def emit(self, record):

			




	
	
	
		
 
        pass

			




	
	
	
		
 

			




	
	
	
		
 
def init_stack(config=None):

			




	
	
	
		
 
    if not config:

			




	
	
	
		
 
        config = pylons.test.pylonsapp.config

			




	
	
	
		
 
    url._push_object(URLGenerator(config['routes.map'], environ))

			




	
	
	
		
 
    pylons.app_globals._push_object(config['pylons.app_globals'])

			




	
	
	
		
 
    pylons.config._push_object(config)

			




	
	
	
		
 
    pylons.tmpl_context._push_object(ContextObj())

			




	
	
	
		
 
    # Initialize a translator for tests that utilize i18n

			




	
	
	
		
 
    translator = _get_translator(pylons.config.get('lang'))

			




	
	
	
		
 
    pylons.translator._push_object(translator)

			




	
	
	
		
 
    h = NullHandler()

			




	
	
	
		
 
    logging.getLogger("kallithea").addHandler(h)

			




	
	
	
		
 

			




	
	
	
		
 

			




	
	
	
		
 
class BaseTestCase(unittest.TestCase):

			




	
	
	
		
 
    def __init__(self, *args, **kwargs):

			




	
	
	
		
 
        self.wsgiapp = pylons.test.pylonsapp

			




	
	
	
		
 
        init_stack(self.wsgiapp.config)

			




	
	
	
		
 
        unittest.TestCase.__init__(self, *args, **kwargs)

			




	
	
	
		
 

			




	
	
	
		
 
    def remove_all_notifications(self):

			




	
	
	
		
 
        Notification.query().delete()

			




	
	
	
		
 

			




	
	
	
		
 
        # Because query().delete() does not (by default) trigger cascades.

			




	
	
	
		
 
        # http://docs.sqlalchemy.org/en/rel_0_7/orm/collections.html#passive-deletes

			




	
	
	
		
 
        UserNotification.query().delete()

			




	
	
	
		
 

			




	
	
	
		
 
        Session().commit()

			




	
	
	
		
 

			




	
	
	
		
 

			




	
	
	
		
 
class TestController(BaseTestCase):

			




	
	
	
		
 

			




	
	
	
		
 
    def __init__(self, *args, **kwargs):

			




	
	
	
		
 
        BaseTestCase.__init__(self, *args, **kwargs)

			




	
	
	
		
 
        self.app = TestApp(self.wsgiapp)

			




	
	
	
		
 
        self.maxDiff = None

			




	
	
	
		
 
        self.index_location = config['app_conf']['index_dir']

			




	
	
	
		
 

			




	
	
	
		
 
    def log_user(self, username=TEST_USER_ADMIN_LOGIN,

			




	
	
	
		
 
                 password=TEST_USER_ADMIN_PASS):

			




	
	
	
		
 
        self._logged_username = username

			




	
	
	
		
 
        response = self.app.post(url(controller='login', action='index'),

			




	
	
	
		
 
                                 {'username': username,

			




	
	
	
		
 
                                  'password': password})

			




	
	
	
		
 

			




	
	
	
		
 
        if 'Invalid username or password' in response.body:

			




	
	
	
		
 
            self.fail('could not login using %s %s' % (username, password))

			




	
	
	
		
 

			




	
	
	
		
 
        self.assertEqual(response.status, '302 Found')

			




	
	
	
		
 
        self.assert_authenticated_user(response, username)

			




	
	
	
		
 

			




	
	
	
		
 
        response = response.follow()

			




	
	
	
		
 
        return response.session['authuser']

			




	
	
	
		
 

			




	
	
	
		
 
    def _get_logged_user(self):

			




	
	
	
		
 
        return User.get_by_username(self._logged_username)

			




	
	
	
		
 

			




	
	
	
		
 
    def assert_authenticated_user(self, response, expected_username):

			




	
	
	
		
 
        cookie = response.session.get('authuser')

			




	
	
	
		
 
        user = cookie and cookie.get('user_id')

			




	
	
	
		
 
        user = user and User.get(user)

			




	
	
	
		
 
        user = user and user.username

			




	
	
	
		
 
        self.assertEqual(user, expected_username)

			




	
	
	
		
 
        self.assertEqual(cookie.get('is_authenticated'), True)

			




	
	
	
		
 

			




	
	
	
		
 
    def authentication_token(self):

			




	
	
	
		
 
        return self.app.get(url('authentication_token')).body

			




	
	
	
		
 

			




	
	
	
		
 
    def checkSessionFlash(self, response, msg=None, skip=0, _matcher=lambda msg, m: msg in m):

			




	
	
	
		
 
        if 'flash' not in response.session:

			




	
	
	
		
 
            self.fail(safe_str(u'msg `%s` not found - session has no flash:\n%s' % (msg, response)))

			




	
	
	
		
 
        try:

			




	
	
	
		
 
            level, m = response.session['flash'][-1 - skip]

			




	
	
	
		
 
            if _matcher(msg, m):

			




	
	
	
		
 
                return

			




	
	
	
		
 
        except IndexError:

			




	
	
	
		
 
            pass

			




	
	
	
		
 
        self.fail(safe_str(u'msg `%s` not found in session flash (skipping %s): %s' %

			




	
	
	
		
 
                           (msg, skip,

			




	
	
	
		
 
                            ', '.join('`%s`' % m for level, m in response.session['flash']))))

			




	
	
	
		
 

			




	
	
	
		
 
    def checkSessionFlashRegex(self, response, regex, skip=0):

			




	
	
	
		
 
        self.checkSessionFlash(response, regex, skip=skip, _matcher=re.search)

			




        

    


    
    

    

        

                

                    kallithea/tests/api/api_base.py
                

                

                  
                      
                        

                      ➞

                      
                        
                  

                  
                      
                  
                      
                  
                      
                  
                      
                  
                  
                

                

                    Show inline comments
                    
                

        

        

            



	
	
		
 
@@ -363,468 +363,468 @@ class _BaseTestApi(object):

			




	
	
	
		
 
            'locked_by': TEST_USER_ADMIN_LOGIN,

			




	
	
	
		
 
            'lock_state_changed': True,

			




	
	
	
		
 
            'msg': ('User `%s` set lock state for repo `%s` to `%s`'

			




	
	
	
		
 
                    % (TEST_USER_ADMIN_LOGIN, self.REPO, True))

			




	
	
	
		
 
        }

			




	
	
	
		
 
        self._compare_ok(id_, expected, given=response.body)

			




	
	
	
		
 

			




	
	
	
		
 
    def test_api_lock_repo_lock_aquire_by_non_admin(self):

			




	
	
	
		
 
        repo_name = 'api_delete_me'

			




	
	
	
		
 
        fixture.create_repo(repo_name, repo_type=self.REPO_TYPE,

			




	
	
	
		
 
                            cur_user=self.TEST_USER_LOGIN)

			




	
	
	
		
 
        try:

			




	
	
	
		
 
            id_, params = _build_data(self.apikey_regular, 'lock',

			




	
	
	
		
 
                                      repoid=repo_name,

			




	
	
	
		
 
                                      locked=True)

			




	
	
	
		
 
            response = api_call(self, params)

			




	
	
	
		
 
            expected = {

			




	
	
	
		
 
                'repo': repo_name,

			




	
	
	
		
 
                'locked': True,

			




	
	
	
		
 
                'locked_since': response.json['result']['locked_since'],

			




	
	
	
		
 
                'locked_by': self.TEST_USER_LOGIN,

			




	
	
	
		
 
                'lock_state_changed': True,

			




	
	
	
		
 
                'msg': ('User `%s` set lock state for repo `%s` to `%s`'

			




	
	
	
		
 
                        % (self.TEST_USER_LOGIN, repo_name, True))

			




	
	
	
		
 
            }

			




	
	
	
		
 
            self._compare_ok(id_, expected, given=response.body)

			




	
	
	
		
 
        finally:

			




	
	
	
		
 
            fixture.destroy_repo(repo_name)

			




	
	
	
		
 

			




	
	
	
		
 
    def test_api_lock_repo_lock_aquire_non_admin_with_userid(self):

			




	
	
	
		
 
        repo_name = 'api_delete_me'

			




	
	
	
		
 
        fixture.create_repo(repo_name, repo_type=self.REPO_TYPE,

			




	
	
	
		
 
                            cur_user=self.TEST_USER_LOGIN)

			




	
	
	
		
 
        try:

			




	
	
	
		
 
            id_, params = _build_data(self.apikey_regular, 'lock',

			




	
	
	
		
 
                                      userid=TEST_USER_ADMIN_LOGIN,

			




	
	
	
		
 
                                      repoid=repo_name,

			




	
	
	
		
 
                                      locked=True)

			




	
	
	
		
 
            response = api_call(self, params)

			




	
	
	
		
 
            expected = 'userid is not the same as your user'

			




	
	
	
		
 
            self._compare_error(id_, expected, given=response.body)

			




	
	
	
		
 
        finally:

			




	
	
	
		
 
            fixture.destroy_repo(repo_name)

			




	
	
	
		
 

			




	
	
	
		
 
    def test_api_lock_repo_lock_aquire_non_admin_not_his_repo(self):

			




	
	
	
		
 
        id_, params = _build_data(self.apikey_regular, 'lock',

			




	
	
	
		
 
                                  repoid=self.REPO,

			




	
	
	
		
 
                                  locked=True)

			




	
	
	
		
 
        response = api_call(self, params)

			




	
	
	
		
 
        expected = 'repository `%s` does not exist' % (self.REPO)

			




	
	
	
		
 
        self._compare_error(id_, expected, given=response.body)

			




	
	
	
		
 

			




	
	
	
		
 
    def test_api_lock_repo_lock_release(self):

			




	
	
	
		
 
        id_, params = _build_data(self.apikey, 'lock',

			




	
	
	
		
 
                                  userid=TEST_USER_ADMIN_LOGIN,

			




	
	
	
		
 
                                  repoid=self.REPO,

			




	
	
	
		
 
                                  locked=False)

			




	
	
	
		
 
        response = api_call(self, params)

			




	
	
	
		
 
        expected = {

			




	
	
	
		
 
            'repo': self.REPO,

			




	
	
	
		
 
            'locked': False,

			




	
	
	
		
 
            'locked_since': None,

			




	
	
	
		
 
            'locked_by': TEST_USER_ADMIN_LOGIN,

			




	
	
	
		
 
            'lock_state_changed': True,

			




	
	
	
		
 
            'msg': ('User `%s` set lock state for repo `%s` to `%s`'

			




	
	
	
		
 
                    % (TEST_USER_ADMIN_LOGIN, self.REPO, False))

			




	
	
	
		
 
        }

			




	
	
	
		
 
        self._compare_ok(id_, expected, given=response.body)

			




	
	
	
		
 

			




	
	
	
		
 
    def test_api_lock_repo_lock_aquire_optional_userid(self):

			




	
	
	
		
 
        id_, params = _build_data(self.apikey, 'lock',

			




	
	
	
		
 
                                  repoid=self.REPO,

			




	
	
	
		
 
                                  locked=True)

			




	
	
	
		
 
        response = api_call(self, params)

			




	
	
	
		
 
        time_ = response.json['result']['locked_since']

			




	
	
	
		
 
        expected = {

			




	
	
	
		
 
            'repo': self.REPO,

			




	
	
	
		
 
            'locked': True,

			




	
	
	
		
 
            'locked_since': time_,

			




	
	
	
		
 
            'locked_by': TEST_USER_ADMIN_LOGIN,

			




	
	
	
		
 
            'lock_state_changed': True,

			




	
	
	
		
 
            'msg': ('User `%s` set lock state for repo `%s` to `%s`'

			




	
	
	
		
 
                    % (TEST_USER_ADMIN_LOGIN, self.REPO, True))

			




	
	
	
		
 
        }

			




	
	
	
		
 

			




	
	
	
		
 
        self._compare_ok(id_, expected, given=response.body)

			




	
	
	
		
 

			




	
	
	
		
 
    def test_api_lock_repo_lock_optional_locked(self):

			




	
	
	
		
 
        id_, params = _build_data(self.apikey, 'lock',

			




	
	
	
		
 
                                  repoid=self.REPO)

			




	
	
	
		
 
        response = api_call(self, params)

			




	
	
	
		
 
        time_ = response.json['result']['locked_since']

			




	
	
	
		
 
        expected = {

			




	
	
	
		
 
            'repo': self.REPO,

			




	
	
	
		
 
            'locked': True,

			




	
	
	
		
 
            'locked_since': time_,

			




	
	
	
		
 
            'locked_by': TEST_USER_ADMIN_LOGIN,

			




	
	
	
		
 
            'lock_state_changed': False,

			




	
	
	
		
 
            'msg': ('Repo `%s` locked by `%s` on `%s`.'

			




	
	
	
		
 
                    % (self.REPO, TEST_USER_ADMIN_LOGIN,

			




	
	
	
		
 
                       json.dumps(time_to_datetime(time_))))

			




	
	
	
		
 
        }

			




	
	
	
		
 
        self._compare_ok(id_, expected, given=response.body)

			




	
	
	
		
 

			




	
	
	
		
 
    def test_api_lock_repo_lock_optional_not_locked(self):

			




	
	
	
		
 
        repo_name = 'api_not_locked'

			




	
	
	
		
 
        repo = fixture.create_repo(repo_name, repo_type=self.REPO_TYPE,

			




	
	
	
		
 
                            cur_user=self.TEST_USER_LOGIN)

			




	
	
	
		
 
        self.assertEqual(repo.locked, [None, None])

			




	
	
	
		
 
        try:

			




	
	
	
		
 
            id_, params = _build_data(self.apikey, 'lock',

			




	
	
	
		
 
                                      repoid=repo.repo_id)

			




	
	
	
		
 
            response = api_call(self, params)

			




	
	
	
		
 
            expected = {

			




	
	
	
		
 
                'repo': repo_name,

			




	
	
	
		
 
                'locked': False,

			




	
	
	
		
 
                'locked_since': None,

			




	
	
	
		
 
                'locked_by': None,

			




	
	
	
		
 
                'lock_state_changed': False,

			




	
	
	
		
 
                'msg': ('Repo `%s` not locked.' % (repo_name,))

			




	
	
	
		
 
            }

			




	
	
	
		
 
            self._compare_ok(id_, expected, given=response.body)

			




	
	
	
		
 
        finally:

			




	
	
	
		
 
            fixture.destroy_repo(repo_name)

			




	
	
	
		
 

			




	
	
	
		
 
    @mock.patch.object(Repository, 'lock', crash)

			




	
	
	
		
 
    def test_api_lock_error(self):

			




	
	
	
		
 
        id_, params = _build_data(self.apikey, 'lock',

			




	
	
	
		
 
                                  userid=TEST_USER_ADMIN_LOGIN,

			




	
	
	
		
 
                                  repoid=self.REPO,

			




	
	
	
		
 
                                  locked=True)

			




	
	
	
		
 
        response = api_call(self, params)

			




	
	
	
		
 

			




	
	
	
		
 
        expected = 'Error occurred locking repository `%s`' % self.REPO

			




	
	
	
		
 
        self._compare_error(id_, expected, given=response.body)

			




	
	
	
		
 

			




	
	
	
		
 
    def test_api_get_locks_regular_user(self):

			




	
	
	
		
 
        id_, params = _build_data(self.apikey_regular, 'get_locks')

			




	
	
	
		
 
        response = api_call(self, params)

			




	
	
	
		
 
        expected = []

			




	
	
	
		
 
        self._compare_ok(id_, expected, given=response.body)

			




	
	
	
		
 

			




	
	
	
		
 
    def test_api_get_locks_with_userid_regular_user(self):

			




	
	
	
		
 
        id_, params = _build_data(self.apikey_regular, 'get_locks',

			




	
	
	
		
 
                                  userid=TEST_USER_ADMIN_LOGIN)

			




	
	
	
		
 
        response = api_call(self, params)

			




	
	
	
		
 
        expected = 'userid is not the same as your user'

			




	
	
	
		
 
        self._compare_error(id_, expected, given=response.body)

			




	
	
	
		
 

			




	
	
	
		
 
    def test_api_get_locks(self):

			




	
	
	
		
 
        id_, params = _build_data(self.apikey, 'get_locks')

			




	
	
	
		
 
        response = api_call(self, params)

			




	
	
	
		
 
        expected = []

			




	
	
	
		
 
        self._compare_ok(id_, expected, given=response.body)

			




	
	
	
		
 

			




	
	
	
		
 
    def test_api_get_locks_with_one_locked_repo(self):

			




	
	
	
		
 
        repo_name = 'api_delete_me'

			




	
	
	
		
 
        repo = fixture.create_repo(repo_name, repo_type=self.REPO_TYPE,

			




	
	
	
		
 
                                   cur_user=self.TEST_USER_LOGIN)

			




	
	
	
		
 
        Repository.lock(repo, User.get_by_username(self.TEST_USER_LOGIN).user_id)

			




	
	
	
		
 
        try:

			




	
	
	
		
 
            id_, params = _build_data(self.apikey, 'get_locks')

			




	
	
	
		
 
            response = api_call(self, params)

			




	
	
	
		
 
            expected = [repo.get_api_data()]

			




	
	
	
		
 
            self._compare_ok(id_, expected, given=response.body)

			




	
	
	
		
 
        finally:

			




	
	
	
		
 
            fixture.destroy_repo(repo_name)

			




	
	
	
		
 

			




	
	
	
		
 
    def test_api_get_locks_with_one_locked_repo_for_specific_user(self):

			




	
	
	
		
 
        repo_name = 'api_delete_me'

			




	
	
	
		
 
        repo = fixture.create_repo(repo_name, repo_type=self.REPO_TYPE,

			




	
	
	
		
 
                                   cur_user=self.TEST_USER_LOGIN)

			




	
	
	
		
 
        Repository.lock(repo, User.get_by_username(self.TEST_USER_LOGIN).user_id)

			




	
	
	
		
 
        try:

			




	
	
	
		
 
            id_, params = _build_data(self.apikey, 'get_locks',

			




	
	
	
		
 
                                      userid=self.TEST_USER_LOGIN)

			




	
	
	
		
 
            response = api_call(self, params)

			




	
	
	
		
 
            expected = [repo.get_api_data()]

			




	
	
	
		
 
            self._compare_ok(id_, expected, given=response.body)

			




	
	
	
		
 
        finally:

			




	
	
	
		
 
            fixture.destroy_repo(repo_name)

			




	
	
	
		
 

			




	
	
	
		
 
    def test_api_get_locks_with_userid(self):

			




	
	
	
		
 
        id_, params = _build_data(self.apikey, 'get_locks',

			




	
	
	
		
 
                                  userid=TEST_USER_REGULAR_LOGIN)

			




	
	
	
		
 
        response = api_call(self, params)

			




	
	
	
		
 
        expected = []

			




	
	
	
		
 
        self._compare_ok(id_, expected, given=response.body)

			




	
	
	
		
 

			




	
	
	
		
 
    def test_api_create_existing_user(self):

			




	
	
	
		
 
        id_, params = _build_data(self.apikey, 'create_user',

			




	
	
	
		
 
                                  username=TEST_USER_ADMIN_LOGIN,

			




	
	
	
		
 
                                  email='test@foo.com',

			




	
	
	
		
 
                                  email='test@example.com',

			




	
	
	
		
 
                                  password='trololo')

			




	
	
	
		
 
        response = api_call(self, params)

			




	
	
	
		
 

			




	
	
	
		
 
        expected = "user `%s` already exist" % TEST_USER_ADMIN_LOGIN

			




	
	
	
		
 
        self._compare_error(id_, expected, given=response.body)

			




	
	
	
		
 

			




	
	
	
		
 
    def test_api_create_user_with_existing_email(self):

			




	
	
	
		
 
        id_, params = _build_data(self.apikey, 'create_user',

			




	
	
	
		
 
                                  username=TEST_USER_ADMIN_LOGIN + 'new',

			




	
	
	
		
 
                                  email=TEST_USER_REGULAR_EMAIL,

			




	
	
	
		
 
                                  password='trololo')

			




	
	
	
		
 
        response = api_call(self, params)

			




	
	
	
		
 

			




	
	
	
		
 
        expected = "email `%s` already exist" % TEST_USER_REGULAR_EMAIL

			




	
	
	
		
 
        self._compare_error(id_, expected, given=response.body)

			




	
	
	
		
 

			




	
	
	
		
 
    def test_api_create_user(self):

			




	
	
	
		
 
        username = 'test_new_api_user'

			




	
	
	
		
 
        email = username + "@foo.com"

			




	
	
	
		
 
        email = username + "@example.com"

			




	
	
	
		
 

			




	
	
	
		
 
        id_, params = _build_data(self.apikey, 'create_user',

			




	
	
	
		
 
                                  username=username,

			




	
	
	
		
 
                                  email=email,

			




	
	
	
		
 
                                  password='trololo')

			




	
	
	
		
 
        response = api_call(self, params)

			




	
	
	
		
 

			




	
	
	
		
 
        usr = User.get_by_username(username)

			




	
	
	
		
 
        ret = dict(

			




	
	
	
		
 
            msg='created new user `%s`' % username,

			




	
	
	
		
 
            user=jsonify(usr.get_api_data())

			




	
	
	
		
 
        )

			




	
	
	
		
 

			




	
	
	
		
 
        try:

			




	
	
	
		
 
            expected = ret

			




	
	
	
		
 
            self._compare_ok(id_, expected, given=response.body)

			




	
	
	
		
 
        finally:

			




	
	
	
		
 
            fixture.destroy_user(usr.user_id)

			




	
	
	
		
 

			




	
	
	
		
 
    def test_api_create_user_without_password(self):

			




	
	
	
		
 
        username = 'test_new_api_user_passwordless'

			




	
	
	
		
 
        email = username + "@foo.com"

			




	
	
	
		
 
        email = username + "@example.com"

			




	
	
	
		
 

			




	
	
	
		
 
        id_, params = _build_data(self.apikey, 'create_user',

			




	
	
	
		
 
                                  username=username,

			




	
	
	
		
 
                                  email=email)

			




	
	
	
		
 
        response = api_call(self, params)

			




	
	
	
		
 

			




	
	
	
		
 
        usr = User.get_by_username(username)

			




	
	
	
		
 
        ret = dict(

			




	
	
	
		
 
            msg='created new user `%s`' % username,

			




	
	
	
		
 
            user=jsonify(usr.get_api_data())

			




	
	
	
		
 
        )

			




	
	
	
		
 
        try:

			




	
	
	
		
 
            expected = ret

			




	
	
	
		
 
            self._compare_ok(id_, expected, given=response.body)

			




	
	
	
		
 
        finally:

			




	
	
	
		
 
            fixture.destroy_user(usr.user_id)

			




	
	
	
		
 

			




	
	
	
		
 
    def test_api_create_user_with_extern_name(self):

			




	
	
	
		
 
        username = 'test_new_api_user_passwordless'

			




	
	
	
		
 
        email = username + "@foo.com"

			




	
	
	
		
 
        email = username + "@example.com"

			




	
	
	
		
 

			




	
	
	
		
 
        id_, params = _build_data(self.apikey, 'create_user',

			




	
	
	
		
 
                                  username=username,

			




	
	
	
		
 
                                  email=email, extern_name='internal')

			




	
	
	
		
 
        response = api_call(self, params)

			




	
	
	
		
 

			




	
	
	
		
 
        usr = User.get_by_username(username)

			




	
	
	
		
 
        ret = dict(

			




	
	
	
		
 
            msg='created new user `%s`' % username,

			




	
	
	
		
 
            user=jsonify(usr.get_api_data())

			




	
	
	
		
 
        )

			




	
	
	
		
 
        try:

			




	
	
	
		
 
            expected = ret

			




	
	
	
		
 
            self._compare_ok(id_, expected, given=response.body)

			




	
	
	
		
 
        finally:

			




	
	
	
		
 
            fixture.destroy_user(usr.user_id)

			




	
	
	
		
 

			




	
	
	
		
 
    @mock.patch.object(UserModel, 'create_or_update', crash)

			




	
	
	
		
 
    def test_api_create_user_when_exception_happened(self):

			




	
	
	
		
 

			




	
	
	
		
 
        username = 'test_new_api_user'

			




	
	
	
		
 
        email = username + "@foo.com"

			




	
	
	
		
 
        email = username + "@example.com"

			




	
	
	
		
 

			




	
	
	
		
 
        id_, params = _build_data(self.apikey, 'create_user',

			




	
	
	
		
 
                                  username=username,

			




	
	
	
		
 
                                  email=email,

			




	
	
	
		
 
                                  password='trololo')

			




	
	
	
		
 
        response = api_call(self, params)

			




	
	
	
		
 
        expected = 'failed to create user `%s`' % username

			




	
	
	
		
 
        self._compare_error(id_, expected, given=response.body)

			




	
	
	
		
 

			




	
	
	
		
 
    def test_api_delete_user(self):

			




	
	
	
		
 
        usr = UserModel().create_or_update(username=u'test_user',

			




	
	
	
		
 
                                           password=u'qweqwe',

			




	
	
	
		
 
                                           email=u'u232@example.com',

			




	
	
	
		
 
                                           firstname=u'u1', lastname=u'u1')

			




	
	
	
		
 
        Session().commit()

			




	
	
	
		
 
        username = usr.username

			




	
	
	
		
 
        email = usr.email

			




	
	
	
		
 
        usr_id = usr.user_id

			




	
	
	
		
 
        ## DELETE THIS USER NOW

			




	
	
	
		
 

			




	
	
	
		
 
        id_, params = _build_data(self.apikey, 'delete_user',

			




	
	
	
		
 
                                  userid=username, )

			




	
	
	
		
 
        response = api_call(self, params)

			




	
	
	
		
 

			




	
	
	
		
 
        ret = {'msg': 'deleted user ID:%s %s' % (usr_id, username),

			




	
	
	
		
 
               'user': None}

			




	
	
	
		
 
        expected = ret

			




	
	
	
		
 
        self._compare_ok(id_, expected, given=response.body)

			




	
	
	
		
 

			




	
	
	
		
 
    @mock.patch.object(UserModel, 'delete', crash)

			




	
	
	
		
 
    def test_api_delete_user_when_exception_happened(self):

			




	
	
	
		
 
        usr = UserModel().create_or_update(username=u'test_user',

			




	
	
	
		
 
                                           password=u'qweqwe',

			




	
	
	
		
 
                                           email=u'u232@example.com',

			




	
	
	
		
 
                                           firstname=u'u1', lastname=u'u1')

			




	
	
	
		
 
        Session().commit()

			




	
	
	
		
 
        username = usr.username

			




	
	
	
		
 

			




	
	
	
		
 
        id_, params = _build_data(self.apikey, 'delete_user',

			




	
	
	
		
 
                                  userid=username, )

			




	
	
	
		
 
        response = api_call(self, params)

			




	
	
	
		
 
        ret = 'failed to delete user ID:%s %s' % (usr.user_id,

			




	
	
	
		
 
                                                  usr.username)

			




	
	
	
		
 
        expected = ret

			




	
	
	
		
 
        self._compare_error(id_, expected, given=response.body)

			




	
	
	
		
 

			




	
	
	
		
 
    @parameterized.expand([('firstname', 'new_username'),

			




	
	
	
		
 
                           ('lastname', 'new_username'),

			




	
	
	
		
 
                           ('email', 'new_username'),

			




	
	
	
		
 
                           ('admin', True),

			




	
	
	
		
 
                           ('admin', False),

			




	
	
	
		
 
                           ('extern_type', 'ldap'),

			




	
	
	
		
 
                           ('extern_type', None),

			




	
	
	
		
 
                           ('extern_name', 'test'),

			




	
	
	
		
 
                           ('extern_name', None),

			




	
	
	
		
 
                           ('active', False),

			




	
	
	
		
 
                           ('active', True),

			




	
	
	
		
 
                           ('password', 'newpass')

			




	
	
	
		
 
    ])

			




	
	
	
		
 
    def test_api_update_user(self, name, expected):

			




	
	
	
		
 
        usr = User.get_by_username(self.TEST_USER_LOGIN)

			




	
	
	
		
 
        kw = {name: expected,

			




	
	
	
		
 
              'userid': usr.user_id}

			




	
	
	
		
 
        id_, params = _build_data(self.apikey, 'update_user', **kw)

			




	
	
	
		
 
        response = api_call(self, params)

			




	
	
	
		
 

			




	
	
	
		
 
        ret = {

			




	
	
	
		
 
            'msg': 'updated user ID:%s %s' % (

			




	
	
	
		
 
                usr.user_id, self.TEST_USER_LOGIN),

			




	
	
	
		
 
            'user': jsonify(User \

			




	
	
	
		
 
                .get_by_username(self.TEST_USER_LOGIN) \

			




	
	
	
		
 
                .get_api_data())

			




	
	
	
		
 
        }

			




	
	
	
		
 

			




	
	
	
		
 
        expected = ret

			




	
	
	
		
 
        self._compare_ok(id_, expected, given=response.body)

			




	
	
	
		
 

			




	
	
	
		
 
    def test_api_update_user_no_changed_params(self):

			




	
	
	
		
 
        usr = User.get_by_username(TEST_USER_ADMIN_LOGIN)

			




	
	
	
		
 
        ret = jsonify(usr.get_api_data())

			




	
	
	
		
 
        id_, params = _build_data(self.apikey, 'update_user',

			




	
	
	
		
 
                                  userid=TEST_USER_ADMIN_LOGIN)

			




	
	
	
		
 

			




	
	
	
		
 
        response = api_call(self, params)

			




	
	
	
		
 
        ret = {

			




	
	
	
		
 
            'msg': 'updated user ID:%s %s' % (

			




	
	
	
		
 
                usr.user_id, TEST_USER_ADMIN_LOGIN),

			




	
	
	
		
 
            'user': ret

			




	
	
	
		
 
        }

			




	
	
	
		
 
        expected = ret

			




	
	
	
		
 
        self._compare_ok(id_, expected, given=response.body)

			




	
	
	
		
 

			




	
	
	
		
 
    def test_api_update_user_by_user_id(self):

			




	
	
	
		
 
        usr = User.get_by_username(TEST_USER_ADMIN_LOGIN)

			




	
	
	
		
 
        ret = jsonify(usr.get_api_data())

			




	
	
	
		
 
        id_, params = _build_data(self.apikey, 'update_user',

			




	
	
	
		
 
                                  userid=usr.user_id)

			




	
	
	
		
 

			




	
	
	
		
 
        response = api_call(self, params)

			




	
	
	
		
 
        ret = {

			




	
	
	
		
 
            'msg': 'updated user ID:%s %s' % (

			




	
	
	
		
 
                usr.user_id, TEST_USER_ADMIN_LOGIN),

			




	
	
	
		
 
            'user': ret

			




	
	
	
		
 
        }

			




	
	
	
		
 
        expected = ret

			




	
	
	
		
 
        self._compare_ok(id_, expected, given=response.body)

			




	
	
	
		
 

			




	
	
	
		
 
    def test_api_update_user_default_user(self):

			




	
	
	
		
 
        usr = User.get_default_user()

			




	
	
	
		
 
        id_, params = _build_data(self.apikey, 'update_user',

			




	
	
	
		
 
                                  userid=usr.user_id)

			




	
	
	
		
 

			




	
	
	
		
 
        response = api_call(self, params)

			




	
	
	
		
 
        expected = 'editing default user is forbidden'

			




	
	
	
		
 
        self._compare_error(id_, expected, given=response.body)

			




	
	
	
		
 

			




	
	
	
		
 
    @mock.patch.object(UserModel, 'update_user', crash)

			




	
	
	
		
 
    def test_api_update_user_when_exception_happens(self):

			




	
	
	
		
 
        usr = User.get_by_username(TEST_USER_ADMIN_LOGIN)

			




	
	
	
		
 
        ret = jsonify(usr.get_api_data())

			




	
	
	
		
 
        id_, params = _build_data(self.apikey, 'update_user',

			




	
	
	
		
 
                                  userid=usr.user_id)

			




	
	
	
		
 

			




	
	
	
		
 
        response = api_call(self, params)

			




	
	
	
		
 
        ret = 'failed to update user `%s`' % usr.user_id

			




	
	
	
		
 

			




	
	
	
		
 
        expected = ret

			




	
	
	
		
 
        self._compare_error(id_, expected, given=response.body)

			




	
	
	
		
 

			




	
	
	
		
 
    def test_api_get_repo(self):

			




	
	
	
		
 
        new_group = 'some_new_group'

			




	
	
	
		
 
        make_user_group(new_group)

			




	
	
	
		
 
        RepoModel().grant_user_group_permission(repo=self.REPO,

			




	
	
	
		
 
                                                group_name=new_group,

			




	
	
	
		
 
                                                perm='repository.read')

			




	
	
	
		
 
        Session().commit()

			




	
	
	
		
 
        id_, params = _build_data(self.apikey, 'get_repo',

			




	
	
	
		
 
                                  repoid=self.REPO)

			




	
	
	
		
 
        response = api_call(self, params)

			




	
	
	
		
 

			




	
	
	
		
 
        repo = RepoModel().get_by_repo_name(self.REPO)

			




	
	
	
		
 
        ret = repo.get_api_data()

			




	
	
	
		
 

			




	
	
	
		
 
        members = []

			




	
	
	
		
 
        followers = []

			




	
	
	
		
 
        for user in repo.repo_to_perm:

			




	
	
	
		
 
            perm = user.permission.permission_name

			




	
	
	
		
 
            user = user.user

			




	
	
	
		
 
            user_data = {'name': user.username, 'type': "user",

			




	
	
	
		
 
                         'permission': perm}

			




	
	
	
		
 
            members.append(user_data)

			




	
	
	
		
 

			




	
	
	
		
 
        for user_group in repo.users_group_to_perm:

			




	
	
	
		
 
            perm = user_group.permission.permission_name

			




	
	
	
		
 
            user_group = user_group.users_group

			




	
	
	
		
 
            user_group_data = {'name': user_group.users_group_name,

			




	
	
	
		
 
                               'type': "user_group", 'permission': perm}

			




	
	
	
		
 
            members.append(user_group_data)

			




	
	
	
		
 

			




	
	
	
		
 
        for user in repo.followers:

			




	
	
	
		
 
            followers.append(user.user.get_api_data())

			




	
	
	
		
 

			




	
	
	
		
 
        ret['members'] = members

			




	
	
	
		
 
        ret['followers'] = followers

			




	
	
	
		
 

			




	
	
	
		
 
        expected = ret

			




	
	
	
		
 
        self._compare_ok(id_, expected, given=response.body)

			




	
	
	
		
 
        fixture.destroy_user_group(new_group)

			




	
	
	
		
 

			




	
	
	
		
 
    @parameterized.expand([

			




	
	
	
		
 
        ('repository.admin',),

			




	
	
	
		
 
        ('repository.write',),

			




	
	
	
		
 
        ('repository.read',),

			




	
	
	
		
 
    ])

			




	
	
	
		
 
    def test_api_get_repo_by_non_admin(self, grant_perm):

			




	
	
	
		
 
        RepoModel().grant_user_permission(repo=self.REPO,

			




	
	
	
		
 
                                          user=self.TEST_USER_LOGIN,

			




	
	
	
		
 
                                          perm=grant_perm)

			




	
	
	
		
 
        Session().commit()

			




	
	
	
		
 
        id_, params = _build_data(self.apikey_regular, 'get_repo',

			




	
	
	
		
 
                                  repoid=self.REPO)

			




	
	
	
		
 
        response = api_call(self, params)

			




	
	
	
		
 

			




	
	
	
		
 
        repo = RepoModel().get_by_repo_name(self.REPO)

			




	
	
	
		
 
        ret = repo.get_api_data()

			




	
	
	
		
 

			




	
	
	
		
 
        members = []

			




	
	
	
		
 
        followers = []

			




	
	
	
		
 
        self.assertEqual(2, len(repo.repo_to_perm))

			




	
	
	
		
 
        for user in repo.repo_to_perm:

			




	
	
	
		
 
            perm = user.permission.permission_name

			




	
	
	
		
 
            user_obj = user.user

			




	
	
		
 
@@ -949,385 +949,385 @@ class _BaseTestApi(object):

			




	
	
	
		
 
                    % (','.join(['files', 'dirs', 'all'])))

			




	
	
	
		
 
        self._compare_error(id_, expected, given=response.body)

			




	
	
	
		
 

			




	
	
	
		
 
    @parameterized.expand([('all', 'all', 'repository.write'),

			




	
	
	
		
 
                           ('dirs', 'dirs', 'repository.admin'),

			




	
	
	
		
 
                           ('files', 'files', 'repository.read'), ])

			




	
	
	
		
 
    def test_api_get_repo_nodes_by_regular_user(self, name, ret_type, grant_perm):

			




	
	
	
		
 
        RepoModel().grant_user_permission(repo=self.REPO,

			




	
	
	
		
 
                                          user=self.TEST_USER_LOGIN,

			




	
	
	
		
 
                                          perm=grant_perm)

			




	
	
	
		
 
        Session().commit()

			




	
	
	
		
 

			




	
	
	
		
 
        rev = 'tip'

			




	
	
	
		
 
        path = '/'

			




	
	
	
		
 
        id_, params = _build_data(self.apikey_regular, 'get_repo_nodes',

			




	
	
	
		
 
                                  repoid=self.REPO, revision=rev,

			




	
	
	
		
 
                                  root_path=path,

			




	
	
	
		
 
                                  ret_type=ret_type)

			




	
	
	
		
 
        response = api_call(self, params)

			




	
	
	
		
 

			




	
	
	
		
 
        # we don't the actual return types here since it's tested somewhere

			




	
	
	
		
 
        # else

			




	
	
	
		
 
        expected = response.json['result']

			




	
	
	
		
 
        try:

			




	
	
	
		
 
            self._compare_ok(id_, expected, given=response.body)

			




	
	
	
		
 
        finally:

			




	
	
	
		
 
            RepoModel().revoke_user_permission(self.REPO, self.TEST_USER_LOGIN)

			




	
	
	
		
 

			




	
	
	
		
 
    def test_api_create_repo(self):

			




	
	
	
		
 
        repo_name = 'api-repo'

			




	
	
	
		
 
        id_, params = _build_data(self.apikey, 'create_repo',

			




	
	
	
		
 
                                  repo_name=repo_name,

			




	
	
	
		
 
                                  owner=TEST_USER_ADMIN_LOGIN,

			




	
	
	
		
 
                                  repo_type=self.REPO_TYPE,

			




	
	
	
		
 
        )

			




	
	
	
		
 
        response = api_call(self, params)

			




	
	
	
		
 

			




	
	
	
		
 
        repo = RepoModel().get_by_repo_name(repo_name)

			




	
	
	
		
 
        self.assertNotEqual(repo, None)

			




	
	
	
		
 
        ret = {

			




	
	
	
		
 
            'msg': 'Created new repository `%s`' % repo_name,

			




	
	
	
		
 
            'success': True,

			




	
	
	
		
 
            'task': None,

			




	
	
	
		
 
        }

			




	
	
	
		
 
        expected = ret

			




	
	
	
		
 
        self._compare_ok(id_, expected, given=response.body)

			




	
	
	
		
 
        fixture.destroy_repo(repo_name)

			




	
	
	
		
 

			




	
	
	
		
 
    def test_api_create_repo_and_repo_group(self):

			




	
	
	
		
 
        repo_name = 'my_gr/api-repo'

			




	
	
	
		
 
        id_, params = _build_data(self.apikey, 'create_repo',

			




	
	
	
		
 
                                  repo_name=repo_name,

			




	
	
	
		
 
                                  owner=TEST_USER_ADMIN_LOGIN,

			




	
	
	
		
 
                                  repo_type=self.REPO_TYPE,)

			




	
	
	
		
 
        response = api_call(self, params)

			




	
	
	
		
 
        print params

			




	
	
	
		
 
        repo = RepoModel().get_by_repo_name(repo_name)

			




	
	
	
		
 
        self.assertNotEqual(repo, None)

			




	
	
	
		
 
        ret = {

			




	
	
	
		
 
            'msg': 'Created new repository `%s`' % repo_name,

			




	
	
	
		
 
            'success': True,

			




	
	
	
		
 
            'task': None,

			




	
	
	
		
 
        }

			




	
	
	
		
 
        expected = ret

			




	
	
	
		
 
        self._compare_ok(id_, expected, given=response.body)

			




	
	
	
		
 
        fixture.destroy_repo(repo_name)

			




	
	
	
		
 
        fixture.destroy_repo_group('my_gr')

			




	
	
	
		
 

			




	
	
	
		
 
    def test_api_create_repo_in_repo_group_without_permission(self):

			




	
	
	
		
 
        repo_group_name = '%s/api-repo-repo' % TEST_REPO_GROUP

			




	
	
	
		
 
        repo_name = '%s/api-repo' % repo_group_name

			




	
	
	
		
 

			




	
	
	
		
 
        rg = fixture.create_repo_group(repo_group_name)

			




	
	
	
		
 
        Session().commit()

			




	
	
	
		
 
        RepoGroupModel().grant_user_permission(repo_group_name,

			




	
	
	
		
 
                                               self.TEST_USER_LOGIN,

			




	
	
	
		
 
                                               'group.none')

			




	
	
	
		
 
        Session().commit()

			




	
	
	
		
 

			




	
	
	
		
 
        id_, params = _build_data(self.apikey_regular, 'create_repo',

			




	
	
	
		
 
                                  repo_name=repo_name,

			




	
	
	
		
 
                                  repo_type=self.REPO_TYPE,

			




	
	
	
		
 
        )

			




	
	
	
		
 
        response = api_call(self, params)

			




	
	
	
		
 

			




	
	
	
		
 
        # Current result when API access control is different from Web:

			




	
	
	
		
 
        ret = {

			




	
	
	
		
 
            'msg': 'Created new repository `%s`' % repo_name,

			




	
	
	
		
 
            'success': True,

			




	
	
	
		
 
            'task': None,

			




	
	
	
		
 
        }

			




	
	
	
		
 
        expected = ret

			




	
	
	
		
 
        self._compare_ok(id_, expected, given=response.body)

			




	
	
	
		
 
        fixture.destroy_repo(repo_name)

			




	
	
	
		
 

			




	
	
	
		
 
        # Expected and arguably more correct result:

			




	
	
	
		
 
        #expected = 'failed to create repository `%s`' % repo_name

			




	
	
	
		
 
        #self._compare_error(id_, expected, given=response.body)

			




	
	
	
		
 

			




	
	
	
		
 
        fixture.destroy_repo_group(repo_group_name)

			




	
	
	
		
 

			




	
	
	
		
 
    def test_api_create_repo_unknown_owner(self):

			




	
	
	
		
 
        repo_name = 'api-repo'

			




	
	
	
		
 
        owner = 'i-dont-exist'

			




	
	
	
		
 
        id_, params = _build_data(self.apikey, 'create_repo',

			




	
	
	
		
 
                                  repo_name=repo_name,

			




	
	
	
		
 
                                  owner=owner,

			




	
	
	
		
 
                                  repo_type=self.REPO_TYPE,

			




	
	
	
		
 
        )

			




	
	
	
		
 
        response = api_call(self, params)

			




	
	
	
		
 
        expected = 'user `%s` does not exist' % owner

			




	
	
	
		
 
        self._compare_error(id_, expected, given=response.body)

			




	
	
	
		
 

			




	
	
	
		
 
    def test_api_create_repo_dont_specify_owner(self):

			




	
	
	
		
 
        repo_name = 'api-repo'

			




	
	
	
		
 
        owner = 'i-dont-exist'

			




	
	
	
		
 
        id_, params = _build_data(self.apikey, 'create_repo',

			




	
	
	
		
 
                                  repo_name=repo_name,

			




	
	
	
		
 
                                  repo_type=self.REPO_TYPE,

			




	
	
	
		
 
        )

			




	
	
	
		
 
        response = api_call(self, params)

			




	
	
	
		
 

			




	
	
	
		
 
        repo = RepoModel().get_by_repo_name(repo_name)

			




	
	
	
		
 
        self.assertNotEqual(repo, None)

			




	
	
	
		
 
        ret = {

			




	
	
	
		
 
            'msg': 'Created new repository `%s`' % repo_name,

			




	
	
	
		
 
            'success': True,

			




	
	
	
		
 
            'task': None,

			




	
	
	
		
 
        }

			




	
	
	
		
 
        expected = ret

			




	
	
	
		
 
        self._compare_ok(id_, expected, given=response.body)

			




	
	
	
		
 
        fixture.destroy_repo(repo_name)

			




	
	
	
		
 

			




	
	
	
		
 
    def test_api_create_repo_by_non_admin(self):

			




	
	
	
		
 
        repo_name = 'api-repo'

			




	
	
	
		
 
        owner = 'i-dont-exist'

			




	
	
	
		
 
        id_, params = _build_data(self.apikey_regular, 'create_repo',

			




	
	
	
		
 
                                  repo_name=repo_name,

			




	
	
	
		
 
                                  repo_type=self.REPO_TYPE,

			




	
	
	
		
 
        )

			




	
	
	
		
 
        response = api_call(self, params)

			




	
	
	
		
 

			




	
	
	
		
 
        repo = RepoModel().get_by_repo_name(repo_name)

			




	
	
	
		
 
        self.assertNotEqual(repo, None)

			




	
	
	
		
 
        ret = {

			




	
	
	
		
 
            'msg': 'Created new repository `%s`' % repo_name,

			




	
	
	
		
 
            'success': True,

			




	
	
	
		
 
            'task': None,

			




	
	
	
		
 
        }

			




	
	
	
		
 
        expected = ret

			




	
	
	
		
 
        self._compare_ok(id_, expected, given=response.body)

			




	
	
	
		
 
        fixture.destroy_repo(repo_name)

			




	
	
	
		
 

			




	
	
	
		
 
    def test_api_create_repo_by_non_admin_specify_owner(self):

			




	
	
	
		
 
        repo_name = 'api-repo'

			




	
	
	
		
 
        owner = 'i-dont-exist'

			




	
	
	
		
 
        id_, params = _build_data(self.apikey_regular, 'create_repo',

			




	
	
	
		
 
                                  repo_name=repo_name,

			




	
	
	
		
 
                                  repo_type=self.REPO_TYPE,

			




	
	
	
		
 
                                  owner=owner)

			




	
	
	
		
 
        response = api_call(self, params)

			




	
	
	
		
 

			




	
	
	
		
 
        expected = 'Only Kallithea admin can specify `owner` param'

			




	
	
	
		
 
        self._compare_error(id_, expected, given=response.body)

			




	
	
	
		
 
        fixture.destroy_repo(repo_name)

			




	
	
	
		
 

			




	
	
	
		
 
    def test_api_create_repo_exists(self):

			




	
	
	
		
 
        repo_name = self.REPO

			




	
	
	
		
 
        id_, params = _build_data(self.apikey, 'create_repo',

			




	
	
	
		
 
                                  repo_name=repo_name,

			




	
	
	
		
 
                                  owner=TEST_USER_ADMIN_LOGIN,

			




	
	
	
		
 
                                  repo_type=self.REPO_TYPE,)

			




	
	
	
		
 
        response = api_call(self, params)

			




	
	
	
		
 
        expected = "repo `%s` already exist" % repo_name

			




	
	
	
		
 
        self._compare_error(id_, expected, given=response.body)

			




	
	
	
		
 

			




	
	
	
		
 
    @mock.patch.object(RepoModel, 'create', crash)

			




	
	
	
		
 
    def test_api_create_repo_exception_occurred(self):

			




	
	
	
		
 
        repo_name = 'api-repo'

			




	
	
	
		
 
        id_, params = _build_data(self.apikey, 'create_repo',

			




	
	
	
		
 
                                  repo_name=repo_name,

			




	
	
	
		
 
                                  owner=TEST_USER_ADMIN_LOGIN,

			




	
	
	
		
 
                                  repo_type=self.REPO_TYPE,)

			




	
	
	
		
 
        response = api_call(self, params)

			




	
	
	
		
 
        expected = 'failed to create repository `%s`' % repo_name

			




	
	
	
		
 
        self._compare_error(id_, expected, given=response.body)

			




	
	
	
		
 

			




	
	
	
		
 
    @parameterized.expand([

			




	
	
	
		
 
        ('owner', {'owner': TEST_USER_REGULAR_LOGIN}),

			




	
	
	
		
 
        ('description', {'description': 'new description'}),

			




	
	
	
		
 
        ('active', {'active': True}),

			




	
	
	
		
 
        ('active', {'active': False}),

			




	
	
	
		
 
        ('clone_uri', {'clone_uri': 'http://foo.com/repo'}),

			




	
	
	
		
 
        ('clone_uri', {'clone_uri': 'http://example.com/repo'}),

			




	
	
	
		
 
        ('clone_uri', {'clone_uri': None}),

			




	
	
	
		
 
        ('landing_rev', {'landing_rev': 'branch:master'}),

			




	
	
	
		
 
        ('enable_statistics', {'enable_statistics': True}),

			




	
	
	
		
 
        ('enable_locking', {'enable_locking': True}),

			




	
	
	
		
 
        ('enable_downloads', {'enable_downloads': True}),

			




	
	
	
		
 
        ('name', {'name': 'new_repo_name'}),

			




	
	
	
		
 
        ('repo_group', {'group': 'test_group_for_update'}),

			




	
	
	
		
 
    ])

			




	
	
	
		
 
    def test_api_update_repo(self, changing_attr, updates):

			




	
	
	
		
 
        repo_name = 'api_update_me'

			




	
	
	
		
 
        repo = fixture.create_repo(repo_name, repo_type=self.REPO_TYPE)

			




	
	
	
		
 
        if changing_attr == 'repo_group':

			




	
	
	
		
 
            fixture.create_repo_group(updates['group'])

			




	
	
	
		
 

			




	
	
	
		
 
        id_, params = _build_data(self.apikey, 'update_repo',

			




	
	
	
		
 
                                  repoid=repo_name, **updates)

			




	
	
	
		
 
        response = api_call(self, params)

			




	
	
	
		
 
        if changing_attr == 'name':

			




	
	
	
		
 
            repo_name = updates['name']

			




	
	
	
		
 
        if changing_attr == 'repo_group':

			




	
	
	
		
 
            repo_name = '/'.join([updates['group'], repo_name])

			




	
	
	
		
 
        try:

			




	
	
	
		
 
            expected = {

			




	
	
	
		
 
                'msg': 'updated repo ID:%s %s' % (repo.repo_id, repo_name),

			




	
	
	
		
 
                'repository': repo.get_api_data()

			




	
	
	
		
 
            }

			




	
	
	
		
 
            self._compare_ok(id_, expected, given=response.body)

			




	
	
	
		
 
        finally:

			




	
	
	
		
 
            fixture.destroy_repo(repo_name)

			




	
	
	
		
 
            if changing_attr == 'repo_group':

			




	
	
	
		
 
                fixture.destroy_repo_group(updates['group'])

			




	
	
	
		
 

			




	
	
	
		
 
    def test_api_update_repo_repo_group_does_not_exist(self):

			




	
	
	
		
 
        repo_name = 'admin_owned'

			




	
	
	
		
 
        fixture.create_repo(repo_name)

			




	
	
	
		
 
        updates = {'group': 'test_group_for_update'}

			




	
	
	
		
 
        id_, params = _build_data(self.apikey, 'update_repo',

			




	
	
	
		
 
                                  repoid=repo_name, **updates)

			




	
	
	
		
 
        response = api_call(self, params)

			




	
	
	
		
 
        try:

			




	
	
	
		
 
            expected = 'repository group `%s` does not exist' % updates['group']

			




	
	
	
		
 
            self._compare_error(id_, expected, given=response.body)

			




	
	
	
		
 
        finally:

			




	
	
	
		
 
            fixture.destroy_repo(repo_name)

			




	
	
	
		
 

			




	
	
	
		
 
    def test_api_update_repo_regular_user_not_allowed(self):

			




	
	
	
		
 
        repo_name = 'admin_owned'

			




	
	
	
		
 
        fixture.create_repo(repo_name)

			




	
	
	
		
 
        updates = {'active': False}

			




	
	
	
		
 
        id_, params = _build_data(self.apikey_regular, 'update_repo',

			




	
	
	
		
 
                                  repoid=repo_name, **updates)

			




	
	
	
		
 
        response = api_call(self, params)

			




	
	
	
		
 
        try:

			




	
	
	
		
 
            expected = 'repository `%s` does not exist' % repo_name

			




	
	
	
		
 
            self._compare_error(id_, expected, given=response.body)

			




	
	
	
		
 
        finally:

			




	
	
	
		
 
            fixture.destroy_repo(repo_name)

			




	
	
	
		
 

			




	
	
	
		
 
    @mock.patch.object(RepoModel, 'update', crash)

			




	
	
	
		
 
    def test_api_update_repo_exception_occurred(self):

			




	
	
	
		
 
        repo_name = 'api_update_me'

			




	
	
	
		
 
        fixture.create_repo(repo_name, repo_type=self.REPO_TYPE)

			




	
	
	
		
 
        id_, params = _build_data(self.apikey, 'update_repo',

			




	
	
	
		
 
                                  repoid=repo_name, owner=TEST_USER_ADMIN_LOGIN,)

			




	
	
	
		
 
        response = api_call(self, params)

			




	
	
	
		
 
        try:

			




	
	
	
		
 
            expected = 'failed to update repo `%s`' % repo_name

			




	
	
	
		
 
            self._compare_error(id_, expected, given=response.body)

			




	
	
	
		
 
        finally:

			




	
	
	
		
 
            fixture.destroy_repo(repo_name)

			




	
	
	
		
 

			




	
	
	
		
 
    def test_api_update_repo_regular_user_change_repo_name(self):

			




	
	
	
		
 
        repo_name = 'admin_owned'

			




	
	
	
		
 
        new_repo_name = 'new_repo_name'

			




	
	
	
		
 
        fixture.create_repo(repo_name, repo_type=self.REPO_TYPE)

			




	
	
	
		
 
        RepoModel().grant_user_permission(repo=repo_name,

			




	
	
	
		
 
                                          user=self.TEST_USER_LOGIN,

			




	
	
	
		
 
                                          perm='repository.admin')

			




	
	
	
		
 
        UserModel().revoke_perm('default', 'hg.create.repository')

			




	
	
	
		
 
        UserModel().grant_perm('default', 'hg.create.none')

			




	
	
	
		
 
        updates = {'name': new_repo_name}

			




	
	
	
		
 
        id_, params = _build_data(self.apikey_regular, 'update_repo',

			




	
	
	
		
 
                                  repoid=repo_name, **updates)

			




	
	
	
		
 
        response = api_call(self, params)

			




	
	
	
		
 
        try:

			




	
	
	
		
 
            expected = 'no permission to create (or move) repositories'

			




	
	
	
		
 
            self._compare_error(id_, expected, given=response.body)

			




	
	
	
		
 
        finally:

			




	
	
	
		
 
            fixture.destroy_repo(repo_name)

			




	
	
	
		
 
            fixture.destroy_repo(new_repo_name)

			




	
	
	
		
 

			




	
	
	
		
 
    def test_api_update_repo_regular_user_change_repo_name_allowed(self):

			




	
	
	
		
 
        repo_name = 'admin_owned'

			




	
	
	
		
 
        new_repo_name = 'new_repo_name'

			




	
	
	
		
 
        repo = fixture.create_repo(repo_name, repo_type=self.REPO_TYPE)

			




	
	
	
		
 
        RepoModel().grant_user_permission(repo=repo_name,

			




	
	
	
		
 
                                          user=self.TEST_USER_LOGIN,

			




	
	
	
		
 
                                          perm='repository.admin')

			




	
	
	
		
 
        UserModel().revoke_perm('default', 'hg.create.none')

			




	
	
	
		
 
        UserModel().grant_perm('default', 'hg.create.repository')

			




	
	
	
		
 
        updates = {'name': new_repo_name}

			




	
	
	
		
 
        id_, params = _build_data(self.apikey_regular, 'update_repo',

			




	
	
	
		
 
                                  repoid=repo_name, **updates)

			




	
	
	
		
 
        response = api_call(self, params)

			




	
	
	
		
 
        try:

			




	
	
	
		
 
            expected = {

			




	
	
	
		
 
                'msg': 'updated repo ID:%s %s' % (repo.repo_id, new_repo_name),

			




	
	
	
		
 
                'repository': repo.get_api_data()

			




	
	
	
		
 
            }

			




	
	
	
		
 
            self._compare_ok(id_, expected, given=response.body)

			




	
	
	
		
 
        finally:

			




	
	
	
		
 
            fixture.destroy_repo(repo_name)

			




	
	
	
		
 
            fixture.destroy_repo(new_repo_name)

			




	
	
	
		
 

			




	
	
	
		
 
    def test_api_update_repo_regular_user_change_owner(self):

			




	
	
	
		
 
        repo_name = 'admin_owned'

			




	
	
	
		
 
        fixture.create_repo(repo_name, repo_type=self.REPO_TYPE)

			




	
	
	
		
 
        RepoModel().grant_user_permission(repo=repo_name,

			




	
	
	
		
 
                                          user=self.TEST_USER_LOGIN,

			




	
	
	
		
 
                                          perm='repository.admin')

			




	
	
	
		
 
        updates = {'owner': TEST_USER_ADMIN_LOGIN}

			




	
	
	
		
 
        id_, params = _build_data(self.apikey_regular, 'update_repo',

			




	
	
	
		
 
                                  repoid=repo_name, **updates)

			




	
	
	
		
 
        response = api_call(self, params)

			




	
	
	
		
 
        try:

			




	
	
	
		
 
            expected = 'Only Kallithea admin can specify `owner` param'

			




	
	
	
		
 
            self._compare_error(id_, expected, given=response.body)

			




	
	
	
		
 
        finally:

			




	
	
	
		
 
            fixture.destroy_repo(repo_name)

			




	
	
	
		
 

			




	
	
	
		
 
    def test_api_delete_repo(self):

			




	
	
	
		
 
        repo_name = 'api_delete_me'

			




	
	
	
		
 
        fixture.create_repo(repo_name, repo_type=self.REPO_TYPE)

			




	
	
	
		
 

			




	
	
	
		
 
        id_, params = _build_data(self.apikey, 'delete_repo',

			




	
	
	
		
 
                                  repoid=repo_name, )

			




	
	
	
		
 
        response = api_call(self, params)

			




	
	
	
		
 

			




	
	
	
		
 
        ret = {

			




	
	
	
		
 
            'msg': 'Deleted repository `%s`' % repo_name,

			




	
	
	
		
 
            'success': True

			




	
	
	
		
 
        }

			




	
	
	
		
 
        try:

			




	
	
	
		
 
            expected = ret

			




	
	
	
		
 
            self._compare_ok(id_, expected, given=response.body)

			




	
	
	
		
 
        finally:

			




	
	
	
		
 
            fixture.destroy_repo(repo_name)

			




	
	
	
		
 

			




	
	
	
		
 
    def test_api_delete_repo_by_non_admin(self):

			




	
	
	
		
 
        repo_name = 'api_delete_me'

			




	
	
	
		
 
        fixture.create_repo(repo_name, repo_type=self.REPO_TYPE,

			




	
	
	
		
 
                            cur_user=self.TEST_USER_LOGIN)

			




	
	
	
		
 
        id_, params = _build_data(self.apikey_regular, 'delete_repo',

			




	
	
	
		
 
                                  repoid=repo_name, )

			




	
	
	
		
 
        response = api_call(self, params)

			




	
	
	
		
 

			




	
	
	
		
 
        ret = {

			




	
	
	
		
 
            'msg': 'Deleted repository `%s`' % repo_name,

			




	
	
	
		
 
            'success': True

			




	
	
	
		
 
        }

			




	
	
	
		
 
        try:

			




	
	
	
		
 
            expected = ret

			




	
	
	
		
 
            self._compare_ok(id_, expected, given=response.body)

			




	
	
	
		
 
        finally:

			




	
	
	
		
 
            fixture.destroy_repo(repo_name)

			




	
	
	
		
 

			




	
	
	
		
 
    def test_api_delete_repo_by_non_admin_no_permission(self):

			




	
	
	
		
 
        repo_name = 'api_delete_me'

			




	
	
	
		
 
        fixture.create_repo(repo_name, repo_type=self.REPO_TYPE)

			




	
	
	
		
 
        try:

			




	
	
	
		
 
            id_, params = _build_data(self.apikey_regular, 'delete_repo',

			




	
	
	
		
 
                                      repoid=repo_name, )

			




	
	
	
		
 
            response = api_call(self, params)

			




	
	
	
		
 
            expected = 'repository `%s` does not exist' % (repo_name)

			




	
	
	
		
 
            self._compare_error(id_, expected, given=response.body)

			




	
	
	
		
 
        finally:

			




	
	
	
		
 
            fixture.destroy_repo(repo_name)

			




	
	
	
		
 

			




	
	
	
		
 
    def test_api_delete_repo_exception_occurred(self):

			




	
	
	
		
 
        repo_name = 'api_delete_me'

			




	
	
	
		
 
        fixture.create_repo(repo_name, repo_type=self.REPO_TYPE)

			




	
	
	
		
 
        try:

			




	
	
	
		
 
            with mock.patch.object(RepoModel, 'delete', crash):

			




	
	
	
		
 
                id_, params = _build_data(self.apikey, 'delete_repo',

			




	
	
	
		
 
                                          repoid=repo_name, )

			




	
	
	
		
 
                response = api_call(self, params)

			




	
	
	
		
 

			




	
	
	
		
 
                expected = 'failed to delete repository `%s`' % repo_name

			




	
	
	
		
 
                self._compare_error(id_, expected, given=response.body)

			




	
	
	
		
 
        finally:

			




	
	
	
		
 
            fixture.destroy_repo(repo_name)

			




	
	
	
		
 

			




        

    


    
    

    

        

                

                    kallithea/tests/functional/test_admin_users.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/>.

			




	
	
	
		
 

			




	
	
	
		
 
from sqlalchemy.orm.exc import NoResultFound

			




	
	
	
		
 

			




	
	
	
		
 
from kallithea.tests import *

			




	
	
	
		
 
from kallithea.tests.fixture import Fixture

			




	
	
	
		
 
from kallithea.model.db import User, Permission, UserIpMap, UserApiKeys

			




	
	
	
		
 
from kallithea.lib.auth import check_password

			




	
	
	
		
 
from kallithea.model.user import UserModel

			




	
	
	
		
 
from kallithea.model import validators

			




	
	
	
		
 
from kallithea.lib import helpers as h

			




	
	
	
		
 
from kallithea.model.meta import Session

			




	
	
	
		
 

			




	
	
	
		
 
fixture = Fixture()

			




	
	
	
		
 

			




	
	
	
		
 

			




	
	
	
		
 
class TestAdminUsersController(TestController):

			




	
	
	
		
 
    test_user_1 = 'testme'

			




	
	
	
		
 

			




	
	
	
		
 
    @classmethod

			




	
	
	
		
 
    def teardown_class(cls):

			




	
	
	
		
 
        if User.get_by_username(cls.test_user_1):

			




	
	
	
		
 
            UserModel().delete(cls.test_user_1)

			




	
	
	
		
 
            Session().commit()

			




	
	
	
		
 

			




	
	
	
		
 
    def test_index(self):

			




	
	
	
		
 
        self.log_user()

			




	
	
	
		
 
        response = self.app.get(url('users'))

			




	
	
	
		
 
        # Test response...

			




	
	
	
		
 

			




	
	
	
		
 
    def test_create(self):

			




	
	
	
		
 
        self.log_user()

			




	
	
	
		
 
        username = 'newtestuser'

			




	
	
	
		
 
        password = 'test12'

			




	
	
	
		
 
        password_confirmation = password

			




	
	
	
		
 
        name = 'name'

			




	
	
	
		
 
        lastname = 'lastname'

			




	
	
	
		
 
        email = 'mail@mail.com'

			




	
	
	
		
 
        email = 'mail@example.com'

			




	
	
	
		
 

			




	
	
	
		
 
        response = self.app.post(url('users'),

			




	
	
	
		
 
            {'username': username,

			




	
	
	
		
 
             'password': password,

			




	
	
	
		
 
             'password_confirmation': password_confirmation,

			




	
	
	
		
 
             'firstname': name,

			




	
	
	
		
 
             'active': True,

			




	
	
	
		
 
             'lastname': lastname,

			




	
	
	
		
 
             'extern_name': 'internal',

			




	
	
	
		
 
             'extern_type': 'internal',

			




	
	
	
		
 
             'email': email,

			




	
	
	
		
 
             '_authentication_token': self.authentication_token()})

			




	
	
	
		
 

			




	
	
	
		
 
        self.checkSessionFlash(response, '''Created user <a href="/_admin/users/''')

			




	
	
	
		
 
        self.checkSessionFlash(response, '''/edit">%s</a>''' % (username))

			




	
	
	
		
 

			




	
	
	
		
 
        new_user = Session().query(User).\

			




	
	
	
		
 
            filter(User.username == username).one()

			




	
	
	
		
 

			




	
	
	
		
 
        self.assertEqual(new_user.username, username)

			




	
	
	
		
 
        self.assertEqual(check_password(password, new_user.password), True)

			




	
	
	
		
 
        self.assertEqual(new_user.name, name)

			




	
	
	
		
 
        self.assertEqual(new_user.lastname, lastname)

			




	
	
	
		
 
        self.assertEqual(new_user.email, email)

			




	
	
	
		
 

			




	
	
	
		
 
        response.follow()

			




	
	
	
		
 
        response = response.follow()

			




	
	
	
		
 
        response.mustcontain("""newtestuser""")

			




	
	
	
		
 

			




	
	
	
		
 
    def test_create_err(self):

			




	
	
	
		
 
        self.log_user()

			




	
	
	
		
 
        username = 'new_user'

			




	
	
	
		
 
        password = ''

			




	
	
	
		
 
        name = 'name'

			




	
	
	
		
 
        lastname = 'lastname'

			




	
	
	
		
 
        email = 'errmail.com'

			




	
	
	
		
 
        email = 'errmail.example.com'

			




	
	
	
		
 

			




	
	
	
		
 
        response = self.app.post(url('users'), {'username': username,

			




	
	
	
		
 
                                               'password': password,

			




	
	
	
		
 
                                               'name': name,

			




	
	
	
		
 
                                               'active': False,

			




	
	
	
		
 
                                               'lastname': lastname,

			




	
	
	
		
 
                                               'email': email,

			




	
	
	
		
 
                                               '_authentication_token': self.authentication_token()})

			




	
	
	
		
 

			




	
	
	
		
 
        msg = validators.ValidUsername(False, {})._messages['system_invalid_username']

			




	
	
	
		
 
        msg = h.html_escape(msg % {'username': 'new_user'})

			




	
	
	
		
 
        response.mustcontain("""<span class="error-message">%s</span>""" % msg)

			




	
	
	
		
 
        response.mustcontain("""<span class="error-message">Please enter a value</span>""")

			




	
	
	
		
 
        response.mustcontain("""<span class="error-message">An email address must contain a single @</span>""")

			




	
	
	
		
 

			




	
	
	
		
 
        def get_user():

			




	
	
	
		
 
            Session().query(User).filter(User.username == username).one()

			




	
	
	
		
 

			




	
	
	
		
 
        self.assertRaises(NoResultFound, get_user), 'found user in database'

			




	
	
	
		
 

			




	
	
	
		
 
    def test_new(self):

			




	
	
	
		
 
        self.log_user()

			




	
	
	
		
 
        response = self.app.get(url('new_user'))

			




	
	
	
		
 

			




	
	
	
		
 
    @parameterized.expand(

			




	
	
	
		
 
        [('firstname', {'firstname': 'new_username'}),

			




	
	
	
		
 
         ('lastname', {'lastname': 'new_username'}),

			




	
	
	
		
 
         ('admin', {'admin': True}),

			




	
	
	
		
 
         ('admin', {'admin': False}),

			




	
	
	
		
 
         ('extern_type', {'extern_type': 'ldap'}),

			




	
	
	
		
 
         ('extern_type', {'extern_type': None}),

			




	
	
	
		
 
         ('extern_name', {'extern_name': 'test'}),

			




	
	
	
		
 
         ('extern_name', {'extern_name': None}),

			




	
	
	
		
 
         ('active', {'active': False}),

			




	
	
	
		
 
         ('active', {'active': True}),

			




	
	
	
		
 
         ('email', {'email': 'some@email.com'}),

			




	
	
	
		
 
         ('email', {'email': 'someemail@example.com'}),

			




	
	
	
		
 
        # ('new_password', {'new_password': 'foobar123',

			




	
	
	
		
 
        #                   'password_confirmation': 'foobar123'})

			




	
	
	
		
 
        ])

			




	
	
	
		
 
    def test_update(self, name, attrs):

			




	
	
	
		
 
        self.log_user()

			




	
	
	
		
 
        usr = fixture.create_user(self.test_user_1, password='qweqwe',

			




	
	
	
		
 
                                  email='testme@example.com',

			




	
	
	
		
 
                                  extern_type='internal',

			




	
	
	
		
 
                                  extern_name=self.test_user_1,

			




	
	
	
		
 
                                  skip_if_exists=True)

			




	
	
	
		
 
        Session().commit()

			




	
	
	
		
 
        params = usr.get_api_data(True)

			




	
	
	
		
 
        params.update({'password_confirmation': ''})

			




	
	
	
		
 
        params.update({'new_password': ''})

			




	
	
	
		
 
        params.update(attrs)

			




	
	
	
		
 
        if name == 'email':

			




	
	
	
		
 
            params['emails'] = [attrs['email']]

			




	
	
	
		
 
        if name == 'extern_type':

			




	
	
	
		
 
            #cannot update this via form, expected value is original one

			




	
	
	
		
 
            params['extern_type'] = "internal"

			




	
	
	
		
 
        if name == 'extern_name':

			




	
	
	
		
 
            #cannot update this via form, expected value is original one

			




	
	
	
		
 
            params['extern_name'] = self.test_user_1

			




	
	
	
		
 
            # special case since this user is not

			




	
	
	
		
 
                                          # logged in yet his data is not filled

			




	
	
	
		
 
                                          # so we use creation data

			




	
	
	
		
 

			




	
	
	
		
 
        params.update({'_authentication_token': self.authentication_token()})

			




	
	
	
		
 
        response = self.app.put(url('user', id=usr.user_id), params)

			




	
	
	
		
 
        self.checkSessionFlash(response, 'User updated successfully')

			




	
	
	
		
 
        params.pop('_authentication_token')

			




	
	
	
		
 

			




	
	
	
		
 
        updated_user = User.get_by_username(self.test_user_1)

			




	
	
	
		
 
        updated_params = updated_user.get_api_data(True)

			




	
	
	
		
 
        updated_params.update({'password_confirmation': ''})

			




	
	
	
		
 
        updated_params.update({'new_password': ''})

			




	
	
	
		
 

			




	
	
	
		
 
        self.assertEqual(params, updated_params)

			




	
	
	
		
 

			




	
	
	
		
 
    def test_delete(self):

			




	
	
	
		
 
        self.log_user()

			




	
	
	
		
 
        username = 'newtestuserdeleteme'

			




	
	
	
		
 

			




	
	
	
		
 
        fixture.create_user(name=username)

			




	
	
	
		
 

			




	
	
	
		
 
        new_user = Session().query(User)\

			




	
	
	
		
 
            .filter(User.username == username).one()

			




	
	
	
		
 
        response = self.app.post(url('user', id=new_user.user_id),

			




	
	
	
		
 
            params={'_method': 'delete', '_authentication_token': self.authentication_token()})

			




	
	
	
		
 

			




	
	
	
		
 
        self.checkSessionFlash(response, 'Successfully deleted user')

			




	
	
	
		
 

			




	
	
	
		
 
    def test_delete_repo_err(self):

			




	
	
	
		
 
        self.log_user()

			




	
	
	
		
 
        username = 'repoerr'

			




	
	
	
		
 
        reponame = 'repoerr_fail'

			




	
	
	
		
 

			




	
	
	
		
 
        fixture.create_user(name=username)

			




	
	
	
		
 
        fixture.create_repo(name=reponame, cur_user=username)

			




	
	
	
		
 

			




	
	
	
		
 
        new_user = Session().query(User)\

			




	
	
	
		
 
            .filter(User.username == username).one()

			




	
	
	
		
 
        response = self.app.post(url('user', id=new_user.user_id),

			




	
	
	
		
 
            params={'_method': 'delete', '_authentication_token': self.authentication_token()})

			




	
	
	
		
 
        self.checkSessionFlash(response, 'User "%s" still '

			




	
	
	
		
 
                               'owns 1 repositories and cannot be removed. '

			




	
	
	
		
 
                               'Switch owners or remove those repositories: '

			




	
	
	
		
 
                               '%s' % (username, reponame))

			




	
	
	
		
 

			




	
	
	
		
 
        response = self.app.post(url('delete_repo', repo_name=reponame),

			




	
	
	
		
 
            params={'_method': 'delete', '_authentication_token': self.authentication_token()})

			




	
	
	
		
 
        self.checkSessionFlash(response, 'Deleted repository %s' % reponame)

			




	
	
	
		
 

			




	
	
	
		
 
        response = self.app.post(url('user', id=new_user.user_id),

			




	
	
	
		
 
            params={'_method': 'delete', '_authentication_token': self.authentication_token()})

			




	
	
	
		
 
        self.checkSessionFlash(response, 'Successfully deleted user')

			




	
	
	
		
 

			




	
	
	
		
 
    def test_delete_repo_group_err(self):

			




	
	
	
		
 
        self.log_user()

			




	
	
	
		
 
        username = 'repogrouperr'

			




	
	
	
		
 
        groupname = 'repogroup_fail'

			




	
	
	
		
 

			




	
	
	
		
 
        fixture.create_user(name=username)

			




	
	
	
		
 
        fixture.create_repo_group(name=groupname, cur_user=username)

			




	
	
	
		
 

			




	
	
	
		
 
        new_user = Session().query(User)\

			




	
	
	
		
 
            .filter(User.username == username).one()

			




	
	
	
		
 
        response = self.app.post(url('user', id=new_user.user_id),

			




	
	
	
		
 
            params={'_method': 'delete', '_authentication_token': self.authentication_token()})

			




	
	
	
		
 
        self.checkSessionFlash(response, 'User "%s" still '

			




	
	
	
		
 
                               'owns 1 repository groups and cannot be removed. '

			




	
	
	
		
 
                               'Switch owners or remove those repository groups: '

			




	
	
	
		
 
                               '%s' % (username, groupname))

			




	
	
	
		
 

			




	
	
	
		
 
        # Relevant _if_ the user deletion succeeded to make sure we can render groups without owner

			




	
	
	
		
 
        # rg = RepoGroup.get_by_group_name(group_name=groupname)

			




	
	
	
		
 
        # response = self.app.get(url('repos_groups', id=rg.group_id))

			




	
	
	
		
 

			




	
	
	
		
 
        response = self.app.post(url('delete_repo_group', group_name=groupname),

			




	
	
	
		
 
            params={'_method': 'delete', '_authentication_token': self.authentication_token()})

			




	
	
	
		
 
        self.checkSessionFlash(response, 'Removed repository group %s' % groupname)

			




	
	
	
		
 

			




	
	
	
		
 
        response = self.app.post(url('user', id=new_user.user_id),

			




	
	
	
		
 
            params={'_method': 'delete', '_authentication_token': self.authentication_token()})

			




	
	
	
		
 
        self.checkSessionFlash(response, 'Successfully deleted user')

			




	
	
	
		
 

			




	
	
	
		
 
    def test_delete_user_group_err(self):

			




	
	
	
		
 
        self.log_user()

			




	
	
	
		
 
        username = 'usergrouperr'

			




	
	
	
		
 
        groupname = 'usergroup_fail'

			




	
	
	
		
 

			




	
	
	
		
 
        fixture.create_user(name=username)

			




	
	
	
		
 
        ug = fixture.create_user_group(name=groupname, cur_user=username)

			




	
	
	
		
 

			




	
	
	
		
 
        new_user = Session().query(User)\

			




	
	
	
		
 
            .filter(User.username == username).one()

			




	
	
	
		
 
        response = self.app.post(url('user', id=new_user.user_id),

			




	
	
	
		
 
            params={'_method': 'delete', '_authentication_token': self.authentication_token()})

			




	
	
	
		
 
        self.checkSessionFlash(response, 'User "%s" still '

			




	
	
	
		
 
                               'owns 1 user groups and cannot be removed. '

			




	
	
	
		
 
                               'Switch owners or remove those user groups: '

			




	
	
	
		
 
                               '%s' % (username, groupname))

			




	
	
	
		
 

			




	
	
	
		
 
        # TODO: why do this fail?

			




	
	
	
		
 
        #response = self.app.delete(url('delete_users_group', id=groupname))

			




	
	
	
		
 
        #self.checkSessionFlash(response, 'Removed user group %s' % groupname)

			




	
	
	
		
 

			




	
	
	
		
 
        fixture.destroy_user_group(ug.users_group_id)

			




	
	
	
		
 

			




	
	
	
		
 
        response = self.app.post(url('user', id=new_user.user_id),

			




	
	
	
		
 
            params={'_method': 'delete', '_authentication_token': self.authentication_token()})

			




	
	
	
		
 
        self.checkSessionFlash(response, 'Successfully deleted user')

			




	
	
	
		
 

			




	
	
	
		
 
    def test_show(self):

			




	
	
	
		
 
        response = self.app.get(url('user', id=1))

			




	
	
	
		
 

			




	
	
	
		
 
    def test_edit(self):

			




	
	
	
		
 
        self.log_user()

			




	
	
	
		
 
        user = User.get_by_username(TEST_USER_ADMIN_LOGIN)

			




	
	
	
		
 
        response = self.app.get(url('edit_user', id=user.user_id))

			




	
	
	
		
 

			




	
	
	
		
 
    def test_add_perm_create_repo(self):

			




	
	
	
		
 
        self.log_user()

			




	
	
	
		
 
        perm_none = Permission.get_by_key('hg.create.none')

			




	
	
	
		
 
        perm_create = Permission.get_by_key('hg.create.repository')

			




	
	
	
		
 

			




	
	
	
		
 
        user = UserModel().create_or_update(username='dummy', password='qwe',

			




	
	
	
		
 
                                            email='dummy', firstname='a',

			




	
	
	
		
 
                                            lastname='b')

			




	
	
	
		
 
        Session().commit()

			




	
	
	
		
 
        uid = user.user_id

			




	
	
	
		
 

			




	
	
	
		
 
        try:

			




	
	
	
		
 
            #User should have None permission on creation repository

			




	
	
	
		
 
            self.assertEqual(UserModel().has_perm(user, perm_none), False)

			




	
	
	
		
 
            self.assertEqual(UserModel().has_perm(user, perm_create), False)

			




	
	
	
		
 

			




	
	
	
		
 
            response = self.app.post(url('edit_user_perms', id=uid),

			




	
	
	
		
 
                                     params=dict(_method='put',

			




	
	
	
		
 
                                                 create_repo_perm=True,

			




	
	
	
		
 
                                                 _authentication_token=self.authentication_token()))

			




	
	
	
		
 

			




	
	
	
		
 
            perm_none = Permission.get_by_key('hg.create.none')

			




	
	
	
		
 
            perm_create = Permission.get_by_key('hg.create.repository')

			




	
	
	
		
 

			




	
	
	
		
 
            #User should have None permission on creation repository

			




	
	
	
		
 
            self.assertEqual(UserModel().has_perm(uid, perm_none), False)

			




	
	
	
		
 
            self.assertEqual(UserModel().has_perm(uid, perm_create), True)

			




	
	
	
		
 
        finally:

			




	
	
	
		
 
            UserModel().delete(uid)

			




	
	
	
		
 
            Session().commit()

			




	
	
	
		
 

			




	
	
	
		
 
    def test_revoke_perm_create_repo(self):

			




	
	
	
		
 
        self.log_user()

			




	
	
	
		
 
        perm_none = Permission.get_by_key('hg.create.none')

			




	
	
	
		
 
        perm_create = Permission.get_by_key('hg.create.repository')

			




	
	
	
		
 

			




	
	
	
		
 
        user = UserModel().create_or_update(username='dummy', password='qwe',

			




	
	
	
		
 
                                            email='dummy', firstname='a',

			




	
	
	
		
 
                                            lastname='b')

			




	
	
	
		
 
        Session().commit()

			




	
	
	
		
 
        uid = user.user_id

			




	
	
	
		
 

			




	
	
	
		
 
        try:

			




	
	
	
		
 
            #User should have None permission on creation repository

			




	
	
	
		
 
            self.assertEqual(UserModel().has_perm(user, perm_none), False)

			




	
	
	
		
 
            self.assertEqual(UserModel().has_perm(user, perm_create), False)

			




	
	
	
		
 

			




	
	
	
		
 
            response = self.app.post(url('edit_user_perms', id=uid),

			




	
	
	
		
 
                                     params=dict(_method='put', _authentication_token=self.authentication_token()))

			




	
	
	
		
 

			




	
	
	
		
 
            perm_none = Permission.get_by_key('hg.create.none')

			




        

    


    
    

    

        

                

                    kallithea/tests/functional/test_files.py
                

                

                  
                      
                        

                      ➞

                      
                        
                  

                  
                      
                  
                      
                  
                      
                  
                      
                  
                  
                

                

                    Show inline comments
                    
                

        

        

            



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

			




	
	
	
		
 
import os

			




	
	
	
		
 
from kallithea.tests import *

			




	
	
	
		
 
from kallithea.model.db import Repository

			




	
	
	
		
 
from kallithea.model.meta import Session

			




	
	
	
		
 
from kallithea.tests.fixture import Fixture

			




	
	
	
		
 

			




	
	
	
		
 
fixture = Fixture()

			




	
	
	
		
 

			




	
	
	
		
 
ARCHIVE_SPECS = {

			




	
	
	
		
 
    '.tar.bz2': ('application/x-bzip2', 'tbz2', ''),

			




	
	
	
		
 
    '.tar.gz': ('application/x-gzip', 'tgz', ''),

			




	
	
	
		
 
    '.zip': ('application/zip', 'zip', ''),

			




	
	
	
		
 
}

			




	
	
	
		
 

			




	
	
	
		
 
HG_NODE_HISTORY = fixture.load_resource('hg_node_history_response.json')

			




	
	
	
		
 
GIT_NODE_HISTORY = fixture.load_resource('git_node_history_response.json')

			




	
	
	
		
 

			




	
	
	
		
 

			




	
	
	
		
 
def _set_downloads(repo_name, set_to):

			




	
	
	
		
 
    repo = Repository.get_by_repo_name(repo_name)

			




	
	
	
		
 
    repo.enable_downloads = set_to

			




	
	
	
		
 
    Session().add(repo)

			




	
	
	
		
 
    Session().commit()

			




	
	
	
		
 

			




	
	
	
		
 

			




	
	
	
		
 
class TestFilesController(TestController):

			




	
	
	
		
 

			




	
	
	
		
 
    def test_index(self):

			




	
	
	
		
 
        self.log_user()

			




	
	
	
		
 
        response = self.app.get(url(controller='files', action='index',

			




	
	
	
		
 
                                    repo_name=HG_REPO,

			




	
	
	
		
 
                                    revision='tip',

			




	
	
	
		
 
                                    f_path='/'))

			




	
	
	
		
 
        # Test response...

			




	
	
	
		
 
        response.mustcontain('<a class="browser-dir ypjax-link" href="/%s/files/96507bd11ecc815ebc6270fdf6db110928c09c1e/docs"><i class="icon-folder-open"></i><span>docs</span></a>' % HG_REPO)

			




	
	
	
		
 
        response.mustcontain('<a class="browser-dir ypjax-link" href="/%s/files/96507bd11ecc815ebc6270fdf6db110928c09c1e/vcs"><i class="icon-folder-open"></i><span>vcs</span></a>' % HG_REPO)

			




	
	
	
		
 
        response.mustcontain('<a class="browser-file ypjax-link" href="/%s/files/96507bd11ecc815ebc6270fdf6db110928c09c1e/.gitignore"><i class="icon-doc"></i><span>.gitignore</span></a>' % HG_REPO)

			




	
	
	
		
 
        response.mustcontain('<a class="browser-file ypjax-link" href="/%s/files/96507bd11ecc815ebc6270fdf6db110928c09c1e/.hgignore"><i class="icon-doc"></i><span>.hgignore</span></a>' % HG_REPO)

			




	
	
	
		
 
        response.mustcontain('<a class="browser-file ypjax-link" href="/%s/files/96507bd11ecc815ebc6270fdf6db110928c09c1e/.hgtags"><i class="icon-doc"></i><span>.hgtags</span></a>' % HG_REPO)

			




	
	
	
		
 
        response.mustcontain('<a class="browser-file ypjax-link" href="/%s/files/96507bd11ecc815ebc6270fdf6db110928c09c1e/.travis.yml"><i class="icon-doc"></i><span>.travis.yml</span></a>' % HG_REPO)

			




	
	
	
		
 
        response.mustcontain('<a class="browser-file ypjax-link" href="/%s/files/96507bd11ecc815ebc6270fdf6db110928c09c1e/MANIFEST.in"><i class="icon-doc"></i><span>MANIFEST.in</span></a>' % HG_REPO)

			




	
	
	
		
 
        response.mustcontain('<a class="browser-file ypjax-link" href="/%s/files/96507bd11ecc815ebc6270fdf6db110928c09c1e/README.rst"><i class="icon-doc"></i><span>README.rst</span></a>' % HG_REPO)

			




	
	
	
		
 
        response.mustcontain('<a class="browser-file ypjax-link" href="/%s/files/96507bd11ecc815ebc6270fdf6db110928c09c1e/run_test_and_report.sh"><i class="icon-doc"></i><span>run_test_and_report.sh</span></a>' % HG_REPO)

			




	
	
	
		
 
        response.mustcontain('<a class="browser-file ypjax-link" href="/%s/files/96507bd11ecc815ebc6270fdf6db110928c09c1e/setup.cfg"><i class="icon-doc"></i><span>setup.cfg</span></a>' % HG_REPO)

			




	
	
	
		
 
        response.mustcontain('<a class="browser-file ypjax-link" href="/%s/files/96507bd11ecc815ebc6270fdf6db110928c09c1e/setup.py"><i class="icon-doc"></i><span>setup.py</span></a>' % HG_REPO)

			




	
	
	
		
 
        response.mustcontain('<a class="browser-file ypjax-link" href="/%s/files/96507bd11ecc815ebc6270fdf6db110928c09c1e/test_and_report.sh"><i class="icon-doc"></i><span>test_and_report.sh</span></a>' % HG_REPO)

			




	
	
	
		
 
        response.mustcontain('<a class="browser-file ypjax-link" href="/%s/files/96507bd11ecc815ebc6270fdf6db110928c09c1e/tox.ini"><i class="icon-doc"></i><span>tox.ini</span></a>' % HG_REPO)

			




	
	
	
		
 

			




	
	
	
		
 
    def test_index_revision(self):

			




	
	
	
		
 
        self.log_user()

			




	
	
	
		
 

			




	
	
	
		
 
        response = self.app.get(

			




	
	
	
		
 
            url(controller='files', action='index',

			




	
	
	
		
 
                repo_name=HG_REPO,

			




	
	
	
		
 
                revision='7ba66bec8d6dbba14a2155be32408c435c5f4492',

			




	
	
	
		
 
                f_path='/')

			




	
	
	
		
 
        )

			




	
	
	
		
 

			




	
	
	
		
 
        #Test response...

			




	
	
	
		
 

			




	
	
	
		
 
        response.mustcontain('<a class="browser-dir ypjax-link" href="/%s/files/7ba66bec8d6dbba14a2155be32408c435c5f4492/docs"><i class="icon-folder-open"></i><span>docs</span></a>' % HG_REPO)

			




	
	
	
		
 
        response.mustcontain('<a class="browser-dir ypjax-link" href="/%s/files/7ba66bec8d6dbba14a2155be32408c435c5f4492/tests"><i class="icon-folder-open"></i><span>tests</span></a>' % HG_REPO)

			




	
	
	
		
 
        response.mustcontain('<a class="browser-file ypjax-link" href="/%s/files/7ba66bec8d6dbba14a2155be32408c435c5f4492/README.rst"><i class="icon-doc"></i><span>README.rst</span></a>' % HG_REPO)

			




	
	
	
		
 
        response.mustcontain('1.1 KiB')

			




	
	
	
		
 

			




	
	
	
		
 
    def test_index_different_branch(self):

			




	
	
	
		
 
        self.log_user()

			




	
	
	
		
 

			




	
	
	
		
 
        response = self.app.get(url(controller='files', action='index',

			




	
	
	
		
 
                                    repo_name=HG_REPO,

			




	
	
	
		
 
                                    revision='97e8b885c04894463c51898e14387d80c30ed1ee',

			




	
	
	
		
 
                                    f_path='/'))

			




	
	
	
		
 

			




	
	
	
		
 
        response.mustcontain("""<option selected="selected" value="97e8b885c04894463c51898e14387d80c30ed1ee">git at 97e8b885c048</option>""")

			




	
	
	
		
 

			




	
	
	
		
 
    def test_index_paging(self):

			




	
	
	
		
 
        self.log_user()

			




	
	
	
		
 

			




	
	
	
		
 
        for r in [(73, 'a066b25d5df7016b45a41b7e2a78c33b57adc235'),

			




	
	
	
		
 
                  (92, 'cc66b61b8455b264a7a8a2d8ddc80fcfc58c221e'),

			




	
	
	
		
 
                  (109, '75feb4c33e81186c87eac740cee2447330288412'),

			




	
	
	
		
 
                  (1, '3d8f361e72ab303da48d799ff1ac40d5ac37c67e'),

			




	
	
	
		
 
                  (0, 'b986218ba1c9b0d6a259fac9b050b1724ed8e545')]:

			




	
	
	
		
 

			




	
	
	
		
 
            response = self.app.get(url(controller='files', action='index',

			




	
	
	
		
 
                                    repo_name=HG_REPO,

			




	
	
	
		
 
                                    revision=r[1],

			




	
	
	
		
 
                                    f_path='/'))

			




	
	
	
		
 

			




	
	
	
		
 
            response.mustcontain("""@ r%s:%s""" % (r[0], r[1][:12]))

			




	
	
	
		
 

			




	
	
	
		
 
    def test_file_source(self):

			




	
	
	
		
 
        self.log_user()

			




	
	
	
		
 
        response = self.app.get(url(controller='files', action='index',

			




	
	
	
		
 
                                    repo_name=HG_REPO,

			




	
	
	
		
 
                                    revision='8911406ad776fdd3d0b9932a2e89677e57405a48',

			




	
	
	
		
 
                                    f_path='vcs/nodes.py'))

			




	
	
	
		
 

			




	
	
	
		
 
        response.mustcontain("""<div class="commit">Partially implemented <a class="issue-tracker-link" href="https://myissueserver.com/vcs_test_hg/issue/16">#16</a>. filecontent/commit message/author/node name are safe_unicode now.

			




	
	
	
		
 
        response.mustcontain("""<div class="commit">Partially implemented <a class="issue-tracker-link" href="https://issues.example.com/vcs_test_hg/issue/16">#16</a>. filecontent/commit message/author/node name are safe_unicode now.

			




	
	
	
		
 
In addition some other __str__ are unicode as well

			




	
	
	
		
 
Added test for unicode

			




	
	
	
		
 
Improved test to clone into uniq repository.

			




	
	
	
		
 
removed extra unicode conversion in diff.</div>

			




	
	
	
		
 
""")

			




	
	
	
		
 

			




	
	
	
		
 
        response.mustcontain("""<option selected="selected" value="8911406ad776fdd3d0b9932a2e89677e57405a48">default at 8911406ad776</option>""")

			




	
	
	
		
 

			




	
	
	
		
 
    def test_file_source_history(self):

			




	
	
	
		
 
        self.log_user()

			




	
	
	
		
 
        response = self.app.get(url(controller='files', action='history',

			




	
	
	
		
 
                                    repo_name=HG_REPO,

			




	
	
	
		
 
                                    revision='tip',

			




	
	
	
		
 
                                    f_path='vcs/nodes.py'),

			




	
	
	
		
 
                                extra_environ={'HTTP_X_PARTIAL_XHR': '1'},)

			




	
	
	
		
 
        self.assertEqual(response.body, HG_NODE_HISTORY)

			




	
	
	
		
 

			




	
	
	
		
 
    def test_file_source_history_git(self):

			




	
	
	
		
 
        self.log_user()

			




	
	
	
		
 
        response = self.app.get(url(controller='files', action='history',

			




	
	
	
		
 
                                    repo_name=GIT_REPO,

			




	
	
	
		
 
                                    revision='master',

			




	
	
	
		
 
                                    f_path='vcs/nodes.py'),

			




	
	
	
		
 
                                extra_environ={'HTTP_X_PARTIAL_XHR': '1'},)

			




	
	
	
		
 
        self.assertEqual(response.body, GIT_NODE_HISTORY)

			




	
	
	
		
 

			




	
	
	
		
 
    def test_file_annotation(self):

			




	
	
	
		
 
        self.log_user()

			




	
	
	
		
 
        response = self.app.get(url(controller='files', action='index',

			




	
	
	
		
 
                                    repo_name=HG_REPO,

			




	
	
	
		
 
                                    revision='tip',

			




	
	
	
		
 
                                    f_path='vcs/nodes.py',

			




	
	
	
		
 
                                    annotate=True))

			




	
	
	
		
 

			




	
	
	
		
 
        response.mustcontain("""r356:25213a5fbb04""")

			




	
	
	
		
 

			




	
	
	
		
 
    def test_file_annotation_git(self):

			




	
	
	
		
 
        self.log_user()

			




	
	
	
		
 
        response = self.app.get(url(controller='files', action='index',

			




	
	
	
		
 
                                    repo_name=GIT_REPO,

			




	
	
	
		
 
                                    revision='master',

			




	
	
	
		
 
                                    f_path='vcs/nodes.py',

			




	
	
	
		
 
                                    annotate=True))

			




	
	
	
		
 
        response.mustcontain("""r345:c994f0de03b2""")

			




	
	
	
		
 

			




	
	
	
		
 
    def test_file_annotation_history(self):

			




	
	
	
		
 
        self.log_user()

			




	
	
	
		
 
        response = self.app.get(url(controller='files', action='history',

			




	
	
	
		
 
                                    repo_name=HG_REPO,

			




	
	
	
		
 
                                    revision='tip',

			




	
	
	
		
 
                                    f_path='vcs/nodes.py',

			




	
	
	
		
 
                                    annotate=True),

			




	
	
	
		
 
                                extra_environ={'HTTP_X_PARTIAL_XHR': '1'})

			




	
	
	
		
 

			




	
	
	
		
 
        self.assertEqual(response.body, HG_NODE_HISTORY)

			




	
	
	
		
 

			




	
	
	
		
 
    def test_file_annotation_history_git(self):

			




	
	
	
		
 
        self.log_user()

			




	
	
	
		
 
        response = self.app.get(url(controller='files', action='history',

			




	
	
	
		
 
                                    repo_name=GIT_REPO,

			




	
	
	
		
 
                                    revision='master',

			




	
	
	
		
 
                                    f_path='vcs/nodes.py',

			




	
	
	
		
 
                                    annotate=True),

			




	
	
	
		
 
                                extra_environ={'HTTP_X_PARTIAL_XHR': '1'})

			




	
	
	
		
 

			




	
	
	
		
 
        self.assertEqual(response.body, GIT_NODE_HISTORY)

			




	
	
	
		
 

			




	
	
	
		
 
    def test_file_authors(self):

			




	
	
	
		
 
        self.log_user()

			




	
	
	
		
 
        response = self.app.get(url(controller='files', action='authors',

			




	
	
	
		
 
                                    repo_name=HG_REPO,

			




	
	
	
		
 
                                    revision='tip',

			




	
	
	
		
 
                                    f_path='vcs/nodes.py',

			




	
	
	
		
 
                                    annotate=True))

			




	
	
	
		
 
        response.mustcontain('Marcin Kuzminski')

			




	
	
	
		
 
        response.mustcontain('Lukasz Balcerzak')

			




	
	
	
		
 

			




	
	
	
		
 
    def test_file_authors_git(self):

			




	
	
	
		
 
        self.log_user()

			




	
	
	
		
 
        response = self.app.get(url(controller='files', action='authors',

			




	
	
	
		
 
                                    repo_name=GIT_REPO,

			




	
	
	
		
 
                                    revision='master',

			




	
	
	
		
 
                                    f_path='vcs/nodes.py',

			




	
	
	
		
 
                                    annotate=True))

			




	
	
	
		
 
        response.mustcontain('Marcin Kuzminski')

			




	
	
	
		
 
        response.mustcontain('Lukasz Balcerzak')

			




	
	
	
		
 

			




	
	
	
		
 
    def test_archival(self):

			




	
	
	
		
 
        self.log_user()

			




	
	
	
		
 
        _set_downloads(HG_REPO, set_to=True)

			




	
	
	
		
 
        for arch_ext, info in ARCHIVE_SPECS.items():

			




	
	
	
		
 
            short = '27cd5cce30c9%s' % arch_ext

			




	
	
	
		
 
            fname = '27cd5cce30c96924232dffcd24178a07ffeb5dfc%s' % arch_ext

			




	
	
	
		
 
            filename = '%s-%s' % (HG_REPO, short)

			




	
	
	
		
 
            response = self.app.get(url(controller='files',

			




	
	
	
		
 
                                        action='archivefile',

			




	
	
	
		
 
                                        repo_name=HG_REPO,

			




	
	
	
		
 
                                        fname=fname))

			




	
	
	
		
 

			




	
	
	
		
 
            self.assertEqual(response.status, '200 OK')

			




	
	
	
		
 
            heads = [

			




	
	
	
		
 
                ('Pragma', 'no-cache'),

			




	
	
	
		
 
                ('Cache-Control', 'no-cache'),

			




	
	
	
		
 
                ('Content-Disposition', 'attachment; filename=%s' % filename),

			




	
	
	
		
 
                ('Content-Type', '%s; charset=utf-8' % info[0]),

			




	
	
	
		
 
            ]

			




	
	
	
		
 
            self.assertEqual(response.response._headers.items(), heads)

			




	
	
	
		
 

			




	
	
	
		
 
    def test_archival_wrong_ext(self):

			




	
	
	
		
 
        self.log_user()

			




	
	
	
		
 
        _set_downloads(HG_REPO, set_to=True)

			




	
	
	
		
 
        for arch_ext in ['tar', 'rar', 'x', '..ax', '.zipz']:

			




	
	
	
		
 
            fname = '27cd5cce30c96924232dffcd24178a07ffeb5dfc%s' % arch_ext

			




	
	
	
		
 

			




	
	
	
		
 
            response = self.app.get(url(controller='files',

			




	
	
	
		
 
                                        action='archivefile',

			




	
	
	
		
 
                                        repo_name=HG_REPO,

			




	
	
	
		
 
                                        fname=fname))

			




	
	
	
		
 
            response.mustcontain('Unknown archive type')

			




	
	
	
		
 

			




	
	
	
		
 
    def test_archival_wrong_revision(self):

			




	
	
	
		
 
        self.log_user()

			




	
	
	
		
 
        _set_downloads(HG_REPO, set_to=True)

			




	
	
	
		
 
        for rev in ['00x000000', 'tar', 'wrong', '@##$@$42413232', '232dffcd']:

			




	
	
	
		
 
            fname = '%s.zip' % rev

			




	
	
	
		
 

			




	
	
	
		
 
            response = self.app.get(url(controller='files',

			




	
	
	
		
 
                                        action='archivefile',

			




	
	
	
		
 
                                        repo_name=HG_REPO,

			




	
	
	
		
 
                                        fname=fname))

			




	
	
	
		
 
            response.mustcontain('Unknown revision')

			




	
	
	
		
 

			




	
	
	
		
 
    #==========================================================================

			




	
	
	
		
 
    # RAW FILE

			




	
	
	
		
 
    #==========================================================================

			




	
	
	
		
 
    def test_raw_file_ok(self):

			




	
	
	
		
 
        self.log_user()

			




	
	
	
		
 
        response = self.app.get(url(controller='files', action='rawfile',

			




	
	
	
		
 
                                    repo_name=HG_REPO,

			




	
	
	
		
 
                                    revision='27cd5cce30c96924232dffcd24178a07ffeb5dfc',

			




	
	
	
		
 
                                    f_path='vcs/nodes.py'))

			




	
	
	
		
 

			




	
	
	
		
 
        self.assertEqual(response.content_disposition, "attachment; filename=nodes.py")

			




	
	
	
		
 
        self.assertEqual(response.content_type, "text/x-python")

			




	
	
	
		
 

			




	
	
	
		
 
    def test_raw_file_wrong_cs(self):

			




	
	
	
		
 
        self.log_user()

			




	
	
	
		
 
        rev = u'ERRORce30c96924232dffcd24178a07ffeb5dfc'

			




	
	
	
		
 
        f_path = 'vcs/nodes.py'

			




	
	
	
		
 

			




	
	
	
		
 
        response = self.app.get(url(controller='files', action='rawfile',

			




	
	
	
		
 
                                    repo_name=HG_REPO,

			




	
	
	
		
 
                                    revision=rev,

			




	
	
	
		
 
                                    f_path=f_path), status=404)

			




	
	
	
		
 

			




	
	
	
		
 
        msg = """Such revision does not exist for this repository"""

			




	
	
	
		
 
        response.mustcontain(msg)

			




	
	
	
		
 

			




	
	
	
		
 
    def test_raw_file_wrong_f_path(self):

			




	
	
	
		
 
        self.log_user()

			




	
	
	
		
 
        rev = '27cd5cce30c96924232dffcd24178a07ffeb5dfc'

			




	
	
	
		
 
        f_path = 'vcs/ERRORnodes.py'

			




	
	
	
		
 
        response = self.app.get(url(controller='files', action='rawfile',

			




	
	
	
		
 
                                    repo_name=HG_REPO,

			




	
	
	
		
 
                                    revision=rev,

			




	
	
	
		
 
                                    f_path=f_path), status=404)

			




	
	
	
		
 

			




	
	
	
		
 
        msg = "There is no file nor directory at the given path: &#39;%s&#39; at revision %s" % (f_path, rev[:12])

			




	
	
	
		
 
        response.mustcontain(msg)

			




	
	
	
		
 

			




	
	
	
		
 
    #==========================================================================

			




	
	
	
		
 
    # RAW RESPONSE - PLAIN

			




	
	
	
		
 
    #==========================================================================

			




	
	
	
		
 
    def test_raw_ok(self):

			




	
	
	
		
 
        self.log_user()

			




	
	
	
		
 
        response = self.app.get(url(controller='files', action='raw',

			




	
	
	
		
 
                                    repo_name=HG_REPO,

			




	
	
	
		
 
                                    revision='27cd5cce30c96924232dffcd24178a07ffeb5dfc',

			




	
	
	
		
 
                                    f_path='vcs/nodes.py'))

			




	
	
	
		
 

			




	
	
	
		
 
        self.assertEqual(response.content_type, "text/plain")

			




	
	
	
		
 

			




	
	
	
		
 
    def test_raw_wrong_cs(self):

			




	
	
	
		
 
        self.log_user()

			




	
	
	
		
 
        rev = u'ERRORcce30c96924232dffcd24178a07ffeb5dfc'

			




	
	
	
		
 
        f_path = 'vcs/nodes.py'

			




	
	
	
		
 

			




	
	
	
		
 
        response = self.app.get(url(controller='files', action='raw',

			




	
	
	
		
 
                                    repo_name=HG_REPO,

			




	
	
	
		
 
                                    revision=rev,

			




	
	
	
		
 
                                    f_path=f_path), status=404)

			




	
	
	
		
 

			




        

    


    
    

    

        

                

                    kallithea/tests/functional/test_login.py
                

                

                  
                      
                        

                      ➞

                      
                        
                  

                  
                      
                  
                      
                  
                      
                  
                      
                  
                  
                

                

                    Show inline comments
                    
                

        

        

            



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

			




	
	
	
		
 
import re

			




	
	
	
		
 
import time

			




	
	
	
		
 

			




	
	
	
		
 
import mock

			




	
	
	
		
 

			




	
	
	
		
 
from kallithea.tests import *

			




	
	
	
		
 
from kallithea.tests.fixture import Fixture

			




	
	
	
		
 
from kallithea.lib.utils2 import generate_api_key

			




	
	
	
		
 
from kallithea.lib.auth import check_password

			




	
	
	
		
 
from kallithea.lib import helpers as h

			




	
	
	
		
 
from kallithea.model.api_key import ApiKeyModel

			




	
	
	
		
 
from kallithea.model import validators

			




	
	
	
		
 
from kallithea.model.db import User, Notification

			




	
	
	
		
 
from kallithea.model.meta import Session

			




	
	
	
		
 
from kallithea.model.user import UserModel

			




	
	
	
		
 

			




	
	
	
		
 
fixture = Fixture()

			




	
	
	
		
 

			




	
	
	
		
 

			




	
	
	
		
 
class TestLoginController(TestController):

			




	
	
	
		
 
    def setUp(self):

			




	
	
	
		
 
        self.remove_all_notifications()

			




	
	
	
		
 
        self.assertEqual(Notification.query().all(), [])

			




	
	
	
		
 

			




	
	
	
		
 
    def test_index(self):

			




	
	
	
		
 
        response = self.app.get(url(controller='login', action='index'))

			




	
	
	
		
 
        self.assertEqual(response.status, '200 OK')

			




	
	
	
		
 
        # Test response...

			




	
	
	
		
 

			




	
	
	
		
 
    def test_login_admin_ok(self):

			




	
	
	
		
 
        response = self.app.post(url(controller='login', action='index'),

			




	
	
	
		
 
                                 {'username': TEST_USER_ADMIN_LOGIN,

			




	
	
	
		
 
                                  'password': TEST_USER_ADMIN_PASS})

			




	
	
	
		
 
        self.assertEqual(response.status, '302 Found')

			




	
	
	
		
 
        self.assert_authenticated_user(response, TEST_USER_ADMIN_LOGIN)

			




	
	
	
		
 

			




	
	
	
		
 
        response = response.follow()

			




	
	
	
		
 
        response.mustcontain('/%s' % HG_REPO)

			




	
	
	
		
 

			




	
	
	
		
 
    def test_login_regular_ok(self):

			




	
	
	
		
 
        response = self.app.post(url(controller='login', action='index'),

			




	
	
	
		
 
                                 {'username': TEST_USER_REGULAR_LOGIN,

			




	
	
	
		
 
                                  'password': TEST_USER_REGULAR_PASS})

			




	
	
	
		
 

			




	
	
	
		
 
        self.assertEqual(response.status, '302 Found')

			




	
	
	
		
 
        self.assert_authenticated_user(response, TEST_USER_REGULAR_LOGIN)

			




	
	
	
		
 

			




	
	
	
		
 
        response = response.follow()

			




	
	
	
		
 
        response.mustcontain('/%s' % HG_REPO)

			




	
	
	
		
 

			




	
	
	
		
 
    def test_login_ok_came_from(self):

			




	
	
	
		
 
        test_came_from = '/_admin/users'

			




	
	
	
		
 
        response = self.app.post(url(controller='login', action='index',

			




	
	
	
		
 
                                     came_from=test_came_from),

			




	
	
	
		
 
                                 {'username': TEST_USER_ADMIN_LOGIN,

			




	
	
	
		
 
                                  'password': TEST_USER_ADMIN_PASS})

			




	
	
	
		
 
        self.assertEqual(response.status, '302 Found')

			




	
	
	
		
 
        response = response.follow()

			




	
	
	
		
 

			




	
	
	
		
 
        self.assertEqual(response.status, '200 OK')

			




	
	
	
		
 
        response.mustcontain('Users Administration')

			




	
	
	
		
 

			




	
	
	
		
 
    def test_login_do_not_remember(self):

			




	
	
	
		
 
        response = self.app.post(url(controller='login', action='index'),

			




	
	
	
		
 
                                 {'username': TEST_USER_REGULAR_LOGIN,

			




	
	
	
		
 
                                  'password': TEST_USER_REGULAR_PASS,

			




	
	
	
		
 
                                  'remember': False})

			




	
	
	
		
 

			




	
	
	
		
 
        self.assertIn('Set-Cookie', response.headers)

			




	
	
	
		
 
        for cookie in response.headers.getall('Set-Cookie'):

			




	
	
	
		
 
            self.assertFalse(re.search(r';\s+(Max-Age|Expires)=', cookie, re.IGNORECASE),

			




	
	
	
		
 
                'Cookie %r has expiration date, but should be a session cookie' % cookie)

			




	
	
	
		
 

			




	
	
	
		
 
    def test_login_remember(self):

			




	
	
	
		
 
        response = self.app.post(url(controller='login', action='index'),

			




	
	
	
		
 
                                 {'username': TEST_USER_REGULAR_LOGIN,

			




	
	
	
		
 
                                  'password': TEST_USER_REGULAR_PASS,

			




	
	
	
		
 
                                  'remember': True})

			




	
	
	
		
 

			




	
	
	
		
 
        self.assertIn('Set-Cookie', response.headers)

			




	
	
	
		
 
        for cookie in response.headers.getall('Set-Cookie'):

			




	
	
	
		
 
            self.assertTrue(re.search(r';\s+(Max-Age|Expires)=', cookie, re.IGNORECASE),

			




	
	
	
		
 
                'Cookie %r should have expiration date, but is a session cookie' % cookie)

			




	
	
	
		
 

			




	
	
	
		
 
    def test_logout(self):

			




	
	
	
		
 
        response = self.app.post(url(controller='login', action='index'),

			




	
	
	
		
 
                                 {'username': TEST_USER_REGULAR_LOGIN,

			




	
	
	
		
 
                                  'password': TEST_USER_REGULAR_PASS})

			




	
	
	
		
 

			




	
	
	
		
 
        # Verify that a login session has been established.

			




	
	
	
		
 
        response = self.app.get(url(controller='login', action='index'))

			




	
	
	
		
 
        response = response.follow()

			




	
	
	
		
 
        self.assertIn('authuser', response.session)

			




	
	
	
		
 

			




	
	
	
		
 
        response.click('Log Out')

			




	
	
	
		
 

			




	
	
	
		
 
        # Verify that the login session has been terminated.

			




	
	
	
		
 
        response = self.app.get(url(controller='login', action='index'))

			




	
	
	
		
 
        self.assertNotIn('authuser', response.session)

			




	
	
	
		
 

			




	
	
	
		
 
    @parameterized.expand([

			




	
	
	
		
 
          ('data:text/html,<script>window.alert("xss")</script>',),

			




	
	
	
		
 
          ('mailto:test@example.com',),

			




	
	
	
		
 
          ('file:///etc/passwd',),

			




	
	
	
		
 
          ('ftp://some.ftp.server',),

			




	
	
	
		
 
          ('http://other.domain/bl%C3%A5b%C3%A6rgr%C3%B8d',),

			




	
	
	
		
 
          ('ftp://ftp.example.com',),

			




	
	
	
		
 
          ('http://other.example.com/bl%C3%A5b%C3%A6rgr%C3%B8d',),

			




	
	
	
		
 
    ])

			




	
	
	
		
 
    def test_login_bad_came_froms(self, url_came_from):

			




	
	
	
		
 
        response = self.app.post(url(controller='login', action='index',

			




	
	
	
		
 
                                     came_from=url_came_from),

			




	
	
	
		
 
                                 {'username': TEST_USER_ADMIN_LOGIN,

			




	
	
	
		
 
                                  'password': TEST_USER_ADMIN_PASS})

			




	
	
	
		
 
        self.assertEqual(response.status, '302 Found')

			




	
	
	
		
 
        self.assertEqual(response._environ['paste.testing_variables']

			




	
	
	
		
 
                         ['tmpl_context'].came_from, '/')

			




	
	
	
		
 
        response = response.follow()

			




	
	
	
		
 

			




	
	
	
		
 
        self.assertEqual(response.status, '200 OK')

			




	
	
	
		
 

			




	
	
	
		
 
    def test_login_short_password(self):

			




	
	
	
		
 
        response = self.app.post(url(controller='login', action='index'),

			




	
	
	
		
 
                                 {'username': TEST_USER_ADMIN_LOGIN,

			




	
	
	
		
 
                                  'password': 'as'})

			




	
	
	
		
 
        self.assertEqual(response.status, '200 OK')

			




	
	
	
		
 

			




	
	
	
		
 
        response.mustcontain('Enter 3 characters or more')

			




	
	
	
		
 

			




	
	
	
		
 
    def test_login_wrong_username_password(self):

			




	
	
	
		
 
        response = self.app.post(url(controller='login', action='index'),

			




	
	
	
		
 
                                 {'username': 'error',

			




	
	
	
		
 
                                  'password': 'test12'})

			




	
	
	
		
 

			




	
	
	
		
 
        response.mustcontain('Invalid username or password')

			




	
	
	
		
 

			




	
	
	
		
 
    # verify that get arguments are correctly passed along login redirection

			




	
	
	
		
 

			




	
	
	
		
 
    @parameterized.expand([

			




	
	
	
		
 
        ({'foo':'one', 'bar':'two'}, ('foo=one', 'bar=two')),

			




	
	
	
		
 
        ({'blue': u'blå'.encode('utf-8'), 'green':u'grøn'},

			




	
	
	
		
 
             ('blue=bl%C3%A5', 'green=gr%C3%B8n')),

			




	
	
	
		
 
    ])

			




	
	
	
		
 
    def test_redirection_to_login_form_preserves_get_args(self, args, args_encoded):

			




	
	
	
		
 
        with fixture.anon_access(False):

			




	
	
	
		
 
            response = self.app.get(url(controller='summary', action='index',

			




	
	
	
		
 
                                        repo_name=HG_REPO,

			




	
	
	
		
 
                                        **args))

			




	
	
	
		
 
            self.assertEqual(response.status, '302 Found')

			




	
	
	
		
 
            for encoded in args_encoded:

			




	
	
	
		
 
                self.assertIn(encoded, response.location)

			




	
	
	
		
 

			




	
	
	
		
 
    @parameterized.expand([

			




	
	
	
		
 
        ({'foo':'one', 'bar':'two'}, ('foo=one', 'bar=two')),

			




	
	
	
		
 
        ({'blue': u'blå'.encode('utf-8'), 'green':u'grøn'},

			




	
	
	
		
 
             ('blue=bl%C3%A5', 'green=gr%C3%B8n')),

			




	
	
	
		
 
    ])

			




	
	
	
		
 
    def test_login_form_preserves_get_args(self, args, args_encoded):

			




	
	
	
		
 
        response = self.app.get(url(controller='login', action='index',

			




	
	
	
		
 
                                    came_from = '/_admin/users',

			




	
	
	
		
 
                                    **args))

			




	
	
	
		
 
        for encoded in args_encoded:

			




	
	
	
		
 
            self.assertIn(encoded, response.form.action)

			




	
	
	
		
 

			




	
	
	
		
 
    @parameterized.expand([

			




	
	
	
		
 
        ({'foo':'one', 'bar':'two'}, ('foo=one', 'bar=two')),

			




	
	
	
		
 
        ({'blue': u'blå'.encode('utf-8'), 'green':u'grøn'},

			




	
	
	
		
 
             ('blue=bl%C3%A5', 'green=gr%C3%B8n')),

			




	
	
	
		
 
    ])

			




	
	
	
		
 
    def test_redirection_after_successful_login_preserves_get_args(self, args, args_encoded):

			




	
	
	
		
 
        response = self.app.post(url(controller='login', action='index',

			




	
	
	
		
 
                                     came_from = '/_admin/users',

			




	
	
	
		
 
                                     **args),

			




	
	
	
		
 
                                 {'username': TEST_USER_ADMIN_LOGIN,

			




	
	
	
		
 
                                  'password': TEST_USER_ADMIN_PASS})

			




	
	
	
		
 
        self.assertEqual(response.status, '302 Found')

			




	
	
	
		
 
        for encoded in args_encoded:

			




	
	
	
		
 
            self.assertIn(encoded, response.location)

			




	
	
	
		
 

			




	
	
	
		
 
    @parameterized.expand([

			




	
	
	
		
 
        ({'foo':'one', 'bar':'two'}, ('foo=one', 'bar=two')),

			




	
	
	
		
 
        ({'blue': u'blå'.encode('utf-8'), 'green':u'grøn'},

			




	
	
	
		
 
             ('blue=bl%C3%A5', 'green=gr%C3%B8n')),

			




	
	
	
		
 
    ])

			




	
	
	
		
 
    def test_login_form_after_incorrect_login_preserves_get_args(self, args, args_encoded):

			




	
	
	
		
 
        response = self.app.post(url(controller='login', action='index',

			




	
	
	
		
 
                                     came_from = '/_admin/users',

			




	
	
	
		
 
                                     **args),

			




	
	
	
		
 
                                 {'username': 'error',

			




	
	
	
		
 
                                  'password': 'test12'})

			




	
	
	
		
 

			




	
	
	
		
 
        response.mustcontain('Invalid username or password')

			




	
	
	
		
 
        for encoded in args_encoded:

			




	
	
	
		
 
            self.assertIn(encoded, response.form.action)

			




	
	
	
		
 

			




	
	
	
		
 
    #==========================================================================

			




	
	
	
		
 
    # REGISTRATIONS

			




	
	
	
		
 
    #==========================================================================

			




	
	
	
		
 
    def test_register(self):

			




	
	
	
		
 
        response = self.app.get(url(controller='login', action='register'))

			




	
	
	
		
 
        response.mustcontain('Sign Up')

			




	
	
	
		
 

			




	
	
	
		
 
    def test_register_err_same_username(self):

			




	
	
	
		
 
        uname = TEST_USER_ADMIN_LOGIN

			




	
	
	
		
 
        response = self.app.post(url(controller='login', action='register'),

			




	
	
	
		
 
                                            {'username': uname,

			




	
	
	
		
 
                                             'password': 'test12',

			




	
	
	
		
 
                                             'password_confirmation': 'test12',

			




	
	
	
		
 
                                             'email': 'goodmail@domain.com',

			




	
	
	
		
 
                                             'email': 'goodmail@example.com',

			




	
	
	
		
 
                                             'firstname': 'test',

			




	
	
	
		
 
                                             'lastname': 'test'})

			




	
	
	
		
 

			




	
	
	
		
 
        msg = validators.ValidUsername()._messages['username_exists']

			




	
	
	
		
 
        msg = h.html_escape(msg % {'username': uname})

			




	
	
	
		
 
        response.mustcontain(msg)

			




	
	
	
		
 

			




	
	
	
		
 
    def test_register_err_same_email(self):

			




	
	
	
		
 
        response = self.app.post(url(controller='login', action='register'),

			




	
	
	
		
 
                                            {'username': 'test_admin_0',

			




	
	
	
		
 
                                             'password': 'test12',

			




	
	
	
		
 
                                             'password_confirmation': 'test12',

			




	
	
	
		
 
                                             'email': TEST_USER_ADMIN_EMAIL,

			




	
	
	
		
 
                                             'firstname': 'test',

			




	
	
	
		
 
                                             'lastname': 'test'})

			




	
	
	
		
 

			




	
	
	
		
 
        msg = validators.UniqSystemEmail()()._messages['email_taken']

			




	
	
	
		
 
        response.mustcontain(msg)

			




	
	
	
		
 

			




	
	
	
		
 
    def test_register_err_same_email_case_sensitive(self):

			




	
	
	
		
 
        response = self.app.post(url(controller='login', action='register'),

			




	
	
	
		
 
                                            {'username': 'test_admin_1',

			




	
	
	
		
 
                                             'password': 'test12',

			




	
	
	
		
 
                                             'password_confirmation': 'test12',

			




	
	
	
		
 
                                             'email': TEST_USER_ADMIN_EMAIL.title(),

			




	
	
	
		
 
                                             'firstname': 'test',

			




	
	
	
		
 
                                             'lastname': 'test'})

			




	
	
	
		
 
        msg = validators.UniqSystemEmail()()._messages['email_taken']

			




	
	
	
		
 
        response.mustcontain(msg)

			




	
	
	
		
 

			




	
	
	
		
 
    def test_register_err_wrong_data(self):

			




	
	
	
		
 
        response = self.app.post(url(controller='login', action='register'),

			




	
	
	
		
 
                                            {'username': 'xs',

			




	
	
	
		
 
                                             'password': 'test',

			




	
	
	
		
 
                                             'password_confirmation': 'test',

			




	
	
	
		
 
                                             'email': 'goodmailm',

			




	
	
	
		
 
                                             'firstname': 'test',

			




	
	
	
		
 
                                             'lastname': 'test'})

			




	
	
	
		
 
        self.assertEqual(response.status, '200 OK')

			




	
	
	
		
 
        response.mustcontain('An email address must contain a single @')

			




	
	
	
		
 
        response.mustcontain('Enter a value 6 characters long or more')

			




	
	
	
		
 

			




	
	
	
		
 
    def test_register_err_username(self):

			




	
	
	
		
 
        response = self.app.post(url(controller='login', action='register'),

			




	
	
	
		
 
                                            {'username': 'error user',

			




	
	
	
		
 
                                             'password': 'test12',

			




	
	
	
		
 
                                             'password_confirmation': 'test12',

			




	
	
	
		
 
                                             'email': 'goodmailm',

			




	
	
	
		
 
                                             'firstname': 'test',

			




	
	
	
		
 
                                             'lastname': 'test'})

			




	
	
	
		
 

			




	
	
	
		
 
        response.mustcontain('An email address must contain a single @')

			




	
	
	
		
 
        response.mustcontain('Username may only contain '

			




	
	
	
		
 
                'alphanumeric characters underscores, '

			




	
	
	
		
 
                'periods or dashes and must begin with an '

			




	
	
	
		
 
                'alphanumeric character')

			




	
	
	
		
 

			




	
	
	
		
 
    def test_register_err_case_sensitive(self):

			




	
	
	
		
 
        usr = TEST_USER_ADMIN_LOGIN.title()

			




	
	
	
		
 
        response = self.app.post(url(controller='login', action='register'),

			




	
	
	
		
 
                                            {'username': usr,

			




	
	
	
		
 
                                             'password': 'test12',

			




	
	
	
		
 
                                             'password_confirmation': 'test12',

			




	
	
	
		
 
                                             'email': 'goodmailm',

			




	
	
	
		
 
                                             'firstname': 'test',

			




	
	
	
		
 
                                             'lastname': 'test'})

			




	
	
	
		
 

			




	
	
	
		
 
        response.mustcontain('An email address must contain a single @')

			




	
	
	
		
 
        msg = validators.ValidUsername()._messages['username_exists']

			




	
	
	
		
 
        msg = h.html_escape(msg % {'username': usr})

			




	
	
	
		
 
        response.mustcontain(msg)

			




	
	
	
		
 

			




	
	
	
		
 
    def test_register_special_chars(self):

			




	
	
	
		
 
        response = self.app.post(url(controller='login', action='register'),

			




	
	
	
		
 
                                        {'username': 'xxxaxn',

			




	
	
	
		
 
                                         'password': 'ąćźżąśśśś',

			




	
	
	
		
 
                                         'password_confirmation': 'ąćźżąśśśś',

			




	
	
	
		
 
                                         'email': 'goodmailm@test.plx',

			




	
	
	
		
 
                                         'firstname': 'test',

			




	
	
	
		
 
                                         'lastname': 'test'})

			




	
	
	
		
 

			




	
	
	
		
 
        msg = validators.ValidPassword()._messages['invalid_password']

			




	
	
	
		
 
        response.mustcontain(msg)

			




	
	
	
		
 

			




	
	
	
		
 
    def test_register_password_mismatch(self):

			




	
	
	
		
 
        response = self.app.post(url(controller='login', action='register'),

			




	
	
	
		
 
                                            {'username': 'xs',

			




	
	
	
		
 
                                             'password': '123qwe',

			




	
	
	
		
 
                                             'password_confirmation': 'qwe123',

			




	
	
	
		
 
                                             'email': 'goodmailm@test.plxa',

			




	
	
	
		
 
                                             'firstname': 'test',

			




	
	
	
		
 
                                             'lastname': 'test'})

			




	
	
	
		
 
        msg = validators.ValidPasswordsMatch('password', 'password_confirmation')._messages['password_mismatch']

			




	
	
	
		
 
        response.mustcontain(msg)

			




	
	
	
		
 

			




	
	
	
		
 
    def test_register_ok(self):

			




	
	
	
		
 
        username = 'test_regular4'

			




	
	
	
		
 
        password = 'qweqwe'

			




	
	
	
		
 
        email = 'username@test.com'

			




	
	
	
		
 
        email = 'user4@example.com'

			




	
	
	
		
 
        name = 'testname'

			




	
	
	
		
 
        lastname = 'testlastname'

			




	
	
	
		
 

			




	
	
	
		
 
        response = self.app.post(url(controller='login', action='register'),

			




	
	
	
		
 
                                            {'username': username,

			




	
	
	
		
 
                                             'password': password,

			




	
	
	
		
 
                                             'password_confirmation': password,

			




	
	
	
		
 
                                             'email': email,

			




	
	
	
		
 
                                             'firstname': name,

			




	
	
	
		
 
                                             'lastname': lastname,

			




	
	
	
		
 
                                             'admin': True})  # This should be overriden

			




	
	
	
		
 
        self.assertEqual(response.status, '302 Found')

			




	
	
	
		
 
        self.checkSessionFlash(response, 'You have successfully registered into Kallithea')

			




	
	
	
		
 

			




	
	
	
		
 
        ret = Session().query(User).filter(User.username == 'test_regular4').one()

			




	
	
	
		
 
        self.assertEqual(ret.username, username)

			




	
	
	
		
 
        self.assertEqual(check_password(password, ret.password), True)

			




	
	
	
		
 
        self.assertEqual(ret.email, email)

			




	
	
	
		
 
        self.assertEqual(ret.name, name)

			




	
	
	
		
 
        self.assertEqual(ret.lastname, lastname)

			




	
	
	
		
 
        self.assertNotEqual(ret.api_key, None)

			




	
	
	
		
 
        self.assertEqual(ret.admin, False)

			




	
	
	
		
 

			




	
	
	
		
 
    #==========================================================================

			




	
	
	
		
 
    # PASSWORD RESET

			




	
	
	
		
 
    #==========================================================================

			




	
	
	
		
 

			




	
	
	
		
 
    def test_forgot_password_wrong_mail(self):

			




	
	
	
		
 
        bad_email = 'username%wrongmail.org'

			




	
	
	
		
 
        response = self.app.post(

			




	
	
	
		
 
                        url(controller='login', action='password_reset'),

			




	
	
	
		
 
                            {'email': bad_email, }

			




	
	
	
		
 
        )

			




	
	
	
		
 

			




	
	
	
		
 
        response.mustcontain('An email address must contain a single @')

			




	
	
	
		
 

			




	
	
	
		
 
    def test_forgot_password(self):

			




	
	
	
		
 
        response = self.app.get(url(controller='login',

			




	
	
	
		
 
                                    action='password_reset'))

			




	
	
	
		
 
        self.assertEqual(response.status, '200 OK')

			




	
	
	
		
 

			




	
	
	
		
 
        username = 'test_password_reset_1'

			




	
	
	
		
 
        password = 'qweqwe'

			




	
	
	
		
 
        email = 'username@python-works.com'

			




	
	
	
		
 
        email = 'username@example.com'

			




	
	
	
		
 
        name = 'passwd'

			




	
	
	
		
 
        lastname = 'reset'

			




	
	
	
		
 
        timestamp = int(time.time())

			




	
	
	
		
 

			




	
	
	
		
 
        new = User()

			




	
	
	
		
 
        new.username = username

			




	
	
	
		
 
        new.password = password

			




	
	
	
		
 
        new.email = email

			




	
	
	
		
 
        new.name = name

			




	
	
	
		
 
        new.lastname = lastname

			




	
	
	
		
 
        new.api_key = generate_api_key()

			




	
	
	
		
 
        Session().add(new)

			




	
	
	
		
 
        Session().commit()

			




	
	
	
		
 

			




	
	
	
		
 
        response = self.app.post(url(controller='login',

			




	
	
	
		
 
                                     action='password_reset'),

			




	
	
	
		
 
                                 {'email': email, })

			




	
	
	
		
 

			




	
	
	
		
 
        self.checkSessionFlash(response, 'A password reset confirmation code has been sent')

			




	
	
	
		
 

			




	
	
	
		
 
        response = response.follow()

			




	
	
	
		
 

			




	
	
	
		
 
        # BAD TOKEN

			




	
	
	
		
 

			




	
	
	
		
 
        token = "bad"

			




	
	
	
		
 

			




	
	
	
		
 
        response = self.app.post(url(controller='login',

			




	
	
	
		
 
                                     action='password_reset_confirmation'),

			




	
	
	
		
 
                                 {'email': email,

			




	
	
	
		
 
                                  'timestamp': timestamp,

			




	
	
	
		
 
                                  'password': "p@ssw0rd",

			




	
	
	
		
 
                                  'password_confirm': "p@ssw0rd",

			




	
	
	
		
 
                                  'token': token,

			




	
	
	
		
 
                                 })

			




	
	
	
		
 
        self.assertEqual(response.status, '200 OK')

			




	
	
	
		
 
        response.mustcontain('Invalid password reset token')

			




	
	
	
		
 

			




	
	
	
		
 
        # GOOD TOKEN

			




	
	
	
		
 

			




	
	
	
		
 
        # TODO: The token should ideally be taken from the mail sent

			




	
	
	
		
 
        # above, instead of being recalculated.

			




	
	
	
		
 

			




	
	
	
		
 
        token = UserModel().get_reset_password_token(

			




	
	
	
		
 
            User.get_by_username(username), timestamp, self.authentication_token())

			




	
	
	
		
 

			




	
	
	
		
 
        response = self.app.get(url(controller='login',

			




	
	
	
		
 
                                    action='password_reset_confirmation',

			




	
	
	
		
 
                                    email=email,

			




	
	
	
		
 
                                    timestamp=timestamp,

			




	
	
	
		
 
                                    token=token))

			




	
	
	
		
 
        self.assertEqual(response.status, '200 OK')

			




	
	
	
		
 
        response.mustcontain("You are about to set a new password for the email address %s" % email)

			




	
	
	
		
 

			




	
	
	
		
 
        response = self.app.post(url(controller='login',

			




	
	
	
		
 
                                     action='password_reset_confirmation'),

			




	
	
	
		
 
                                 {'email': email,

			




	
	
	
		
 
                                  'timestamp': timestamp,

			




	
	
	
		
 
                                  'password': "p@ssw0rd",

			




	
	
	
		
 
                                  'password_confirm': "p@ssw0rd",

			




	
	
	
		
 
                                  'token': token,

			




	
	
	
		
 
                                 })

			




	
	
	
		
 
        self.assertEqual(response.status, '302 Found')

			




	
	
	
		
 
        self.checkSessionFlash(response, 'Successfully updated password')

			




	
	
	
		
 

			




	
	
	
		
 
        response = response.follow()

			




	
	
	
		
 

			




	
	
	
		
 
    #==========================================================================

			




	
	
	
		
 
    # API

			




	
	
	
		
 
    #==========================================================================

			




	
	
	
		
 

			




	
	
	
		
 
    def _get_api_whitelist(self, values=None):

			




	
	
	
		
 
        config = {'api_access_controllers_whitelist': values or []}

			




	
	
	
		
 
        return config

			




	
	
	
		
 

			




	
	
	
		
 
    @parameterized.expand([

			




	
	
	
		
 
        ('none', None),

			




	
	
	
		
 
        ('empty_string', ''),

			




	
	
	
		
 
        ('fake_number', '123456'),

			




	
	
	
		
 
        ('proper_api_key', None)

			




	
	
	
		
 
    ])

			




	
	
	
		
 
    def test_access_not_whitelisted_page_via_api_key(self, test_name, api_key):

			




	
	
	
		
 
        whitelist = self._get_api_whitelist([])

			




	
	
	
		
 
        with mock.patch('kallithea.CONFIG', whitelist):

			




	
	
	
		
 
            self.assertEqual([],

			




	
	
	
		
 
                             whitelist['api_access_controllers_whitelist'])

			




	
	
	
		
 
            if test_name == 'proper_api_key':

			




	
	
	
		
 
                #use builtin if api_key is None

			




	
	
	
		
 
                api_key = User.get_first_admin().api_key

			




	
	
	
		
 

			




	
	
	
		
 
            with fixture.anon_access(False):

			




	
	
	
		
 
                self.app.get(url(controller='changeset',

			




	
	
	
		
 
                                 action='changeset_raw',

			




	
	
	
		
 
                                 repo_name=HG_REPO, revision='tip', api_key=api_key),

			




	
	
	
		
 
                             status=403)

			




	
	
	
		
 

			




	
	
	
		
 
    @parameterized.expand([

			




	
	
	
		
 
        ('none', None, 302),

			




	
	
	
		
 
        ('empty_string', '', 302),

			




	
	
	
		
 
        ('fake_number', '123456', 302),

			




	
	
	
		
 
        ('fake_not_alnum', 'a-z', 302),

			




	
	
	
		
 
        ('fake_api_key', '0123456789abcdef0123456789ABCDEF01234567', 302),

			




	
	
	
		
 
        ('proper_api_key', None, 200)

			




	
	
	
		
 
    ])

			




	
	
	
		
 
    def test_access_whitelisted_page_via_api_key(self, test_name, api_key, code):

			




	
	
	
		
 
        whitelist = self._get_api_whitelist(['ChangesetController:changeset_raw'])

			




	
	
	
		
 
        with mock.patch('kallithea.CONFIG', whitelist):

			




	
	
	
		
 
            self.assertEqual(['ChangesetController:changeset_raw'],

			




	
	
	
		
 
                             whitelist['api_access_controllers_whitelist'])

			




	
	
	
		
 
            if test_name == 'proper_api_key':

			




	
	
	
		
 
                api_key = User.get_first_admin().api_key

			




	
	
	
		
 

			




	
	
	
		
 
            with fixture.anon_access(False):

			




	
	
	
		
 
                self.app.get(url(controller='changeset',

			




	
	
	
		
 
                                 action='changeset_raw',

			




	
	
	
		
 
                                 repo_name=HG_REPO, revision='tip', api_key=api_key),

			




	
	
	
		
 
                             status=code)

			




	
	
	
		
 

			




	
	
	
		
 
    def test_access_page_via_extra_api_key(self):

			




	
	
	
		
 
        whitelist = self._get_api_whitelist(['ChangesetController:changeset_raw'])

			




	
	
	
		
 
        with mock.patch('kallithea.CONFIG', whitelist):

			




	
	
	
		
 
            self.assertEqual(['ChangesetController:changeset_raw'],

			




	
	
	
		
 
                             whitelist['api_access_controllers_whitelist'])

			




	
	
	
		
 

			




	
	
	
		
 
            new_api_key = ApiKeyModel().create(TEST_USER_ADMIN_LOGIN, u'test')

			




	
	
	
		
 
            Session().commit()

			




	
	
	
		
 
            with fixture.anon_access(False):

			




	
	
	
		
 
                self.app.get(url(controller='changeset',

			




	
	
	
		
 
                                 action='changeset_raw',

			




	
	
	
		
 
                                 repo_name=HG_REPO, revision='tip', api_key=new_api_key.api_key),

			




	
	
	
		
 
                             status=200)

			




	
	
	
		
 

			




	
	
	
		
 
    def test_access_page_via_expired_api_key(self):

			




	
	
	
		
 
        whitelist = self._get_api_whitelist(['ChangesetController:changeset_raw'])

			




	
	
	
		
 
        with mock.patch('kallithea.CONFIG', whitelist):

			




	
	
	
		
 
            self.assertEqual(['ChangesetController:changeset_raw'],

			




	
	
	
		
 
                             whitelist['api_access_controllers_whitelist'])

			




	
	
	
		
 

			




	
	
	
		
 
            new_api_key = ApiKeyModel().create(TEST_USER_ADMIN_LOGIN, u'test')

			




	
	
	
		
 
            Session().commit()

			




	
	
	
		
 
            #patch the API key and make it expired

			




	
	
	
		
 
            new_api_key.expires = 0

			




	
	
	
		
 
            Session().add(new_api_key)

			




	
	
	
		
 
            Session().commit()

			




	
	
	
		
 
            with fixture.anon_access(False):

			




	
	
	
		
 
                self.app.get(url(controller='changeset',

			




	
	
	
		
 
                                 action='changeset_raw',

			




	
	
	
		
 
                                 repo_name=HG_REPO, revision='tip',

			




	
	
	
		
 
                                 api_key=new_api_key.api_key),

			




	
	
	
		
 
                             status=302)

			




        

    


    
    

    

        

                

                    kallithea/tests/functional/test_my_account.py
                

                

                  
                      
                        

                      ➞

                      
                        
                  

                  
                      
                  
                      
                  
                      
                  
                      
                  
                  
                

                

                    Show inline comments
                    
                

        

        

            



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

			




	
	
	
		
 

			




	
	
	
		
 
from kallithea.model.db import User, UserFollowing, Repository, UserApiKeys

			




	
	
	
		
 
from kallithea.tests import *

			




	
	
	
		
 
from kallithea.tests.fixture import Fixture

			




	
	
	
		
 
from kallithea.lib import helpers as h

			




	
	
	
		
 
from kallithea.model.user import UserModel

			




	
	
	
		
 
from kallithea.model.meta import Session

			




	
	
	
		
 

			




	
	
	
		
 
fixture = Fixture()

			




	
	
	
		
 

			




	
	
	
		
 

			




	
	
	
		
 
class TestMyAccountController(TestController):

			




	
	
	
		
 
    test_user_1 = 'testme'

			




	
	
	
		
 

			




	
	
	
		
 
    @classmethod

			




	
	
	
		
 
    def teardown_class(cls):

			




	
	
	
		
 
        if User.get_by_username(cls.test_user_1):

			




	
	
	
		
 
            UserModel().delete(cls.test_user_1)

			




	
	
	
		
 
            Session().commit()

			




	
	
	
		
 

			




	
	
	
		
 
    def test_my_account(self):

			




	
	
	
		
 
        self.log_user()

			




	
	
	
		
 
        response = self.app.get(url('my_account'))

			




	
	
	
		
 

			




	
	
	
		
 
        response.mustcontain('value="%s' % TEST_USER_ADMIN_LOGIN)

			




	
	
	
		
 

			




	
	
	
		
 
    def test_my_account_my_repos(self):

			




	
	
	
		
 
        self.log_user()

			




	
	
	
		
 
        response = self.app.get(url('my_account_repos'))

			




	
	
	
		
 
        cnt = Repository.query().filter(Repository.user ==

			




	
	
	
		
 
                           User.get_by_username(TEST_USER_ADMIN_LOGIN)).count()

			




	
	
	
		
 
        response.mustcontain('"totalRecords": %s' % cnt)

			




	
	
	
		
 

			




	
	
	
		
 
    def test_my_account_my_watched(self):

			




	
	
	
		
 
        self.log_user()

			




	
	
	
		
 
        response = self.app.get(url('my_account_watched'))

			




	
	
	
		
 

			




	
	
	
		
 
        cnt = UserFollowing.query().filter(UserFollowing.user ==

			




	
	
	
		
 
                            User.get_by_username(TEST_USER_ADMIN_LOGIN)).count()

			




	
	
	
		
 
        response.mustcontain('"totalRecords": %s' % cnt)

			




	
	
	
		
 

			




	
	
	
		
 
    def test_my_account_my_emails(self):

			




	
	
	
		
 
        self.log_user()

			




	
	
	
		
 
        response = self.app.get(url('my_account_emails'))

			




	
	
	
		
 
        response.mustcontain('No additional emails specified')

			




	
	
	
		
 

			




	
	
	
		
 
    def test_my_account_my_emails_add_existing_email(self):

			




	
	
	
		
 
        self.log_user()

			




	
	
	
		
 
        response = self.app.get(url('my_account_emails'))

			




	
	
	
		
 
        response.mustcontain('No additional emails specified')

			




	
	
	
		
 
        response = self.app.post(url('my_account_emails'),

			




	
	
	
		
 
                                 {'new_email': TEST_USER_REGULAR_EMAIL, '_authentication_token': self.authentication_token()})

			




	
	
	
		
 
        self.checkSessionFlash(response, 'This email address is already in use')

			




	
	
	
		
 

			




	
	
	
		
 
    def test_my_account_my_emails_add_mising_email_in_form(self):

			




	
	
	
		
 
        self.log_user()

			




	
	
	
		
 
        response = self.app.get(url('my_account_emails'))

			




	
	
	
		
 
        response.mustcontain('No additional emails specified')

			




	
	
	
		
 
        response = self.app.post(url('my_account_emails'),

			




	
	
	
		
 
            {'_authentication_token': self.authentication_token()})

			




	
	
	
		
 
        self.checkSessionFlash(response, 'Please enter an email address')

			




	
	
	
		
 

			




	
	
	
		
 
    def test_my_account_my_emails_add_remove(self):

			




	
	
	
		
 
        self.log_user()

			




	
	
	
		
 
        response = self.app.get(url('my_account_emails'))

			




	
	
	
		
 
        response.mustcontain('No additional emails specified')

			




	
	
	
		
 

			




	
	
	
		
 
        response = self.app.post(url('my_account_emails'),

			




	
	
	
		
 
                                 {'new_email': 'foo@barz.com', '_authentication_token': self.authentication_token()})

			




	
	
	
		
 
                                 {'new_email': 'barz@example.com', '_authentication_token': self.authentication_token()})

			




	
	
	
		
 

			




	
	
	
		
 
        response = self.app.get(url('my_account_emails'))

			




	
	
	
		
 

			




	
	
	
		
 
        from kallithea.model.db import UserEmailMap

			




	
	
	
		
 
        email_id = UserEmailMap.query()\

			




	
	
	
		
 
            .filter(UserEmailMap.user == User.get_by_username(TEST_USER_ADMIN_LOGIN))\

			




	
	
	
		
 
            .filter(UserEmailMap.email == 'foo@barz.com').one().email_id

			




	
	
	
		
 
            .filter(UserEmailMap.email == 'barz@example.com').one().email_id

			




	
	
	
		
 

			




	
	
	
		
 
        response.mustcontain('foo@barz.com')

			




	
	
	
		
 
        response.mustcontain('barz@example.com')

			




	
	
	
		
 
        response.mustcontain('<input id="del_email_id" name="del_email_id" type="hidden" value="%s" />' % email_id)

			




	
	
	
		
 

			




	
	
	
		
 
        response = self.app.post(url('my_account_emails'),

			




	
	
	
		
 
                                 {'del_email_id': email_id, '_method': 'delete', '_authentication_token': self.authentication_token()})

			




	
	
	
		
 
        self.checkSessionFlash(response, 'Removed email from user')

			




	
	
	
		
 
        response = self.app.get(url('my_account_emails'))

			




	
	
	
		
 
        response.mustcontain('No additional emails specified')

			




	
	
	
		
 

			




	
	
	
		
 

			




	
	
	
		
 
    @parameterized.expand(

			




	
	
	
		
 
        [('firstname', {'firstname': 'new_username'}),

			




	
	
	
		
 
         ('lastname', {'lastname': 'new_username'}),

			




	
	
	
		
 
         ('admin', {'admin': True}),

			




	
	
	
		
 
         ('admin', {'admin': False}),

			




	
	
	
		
 
         ('extern_type', {'extern_type': 'ldap'}),

			




	
	
	
		
 
         ('extern_type', {'extern_type': None}),

			




	
	
	
		
 
         #('extern_name', {'extern_name': 'test'}),

			




	
	
	
		
 
         #('extern_name', {'extern_name': None}),

			




	
	
	
		
 
         ('active', {'active': False}),

			




	
	
	
		
 
         ('active', {'active': True}),

			




	
	
	
		
 
         ('email', {'email': 'some@email.com'}),

			




	
	
	
		
 
         ('email', {'email': 'someemail@example.com'}),

			




	
	
	
		
 
        # ('new_password', {'new_password': 'foobar123',

			




	
	
	
		
 
        #                   'password_confirmation': 'foobar123'})

			




	
	
	
		
 
        ])

			




	
	
	
		
 
    def test_my_account_update(self, name, attrs):

			




	
	
	
		
 
        usr = fixture.create_user(self.test_user_1, password='qweqwe',

			




	
	
	
		
 
                                  email='testme@example.com',

			




	
	
	
		
 
                                  extern_type='internal',

			




	
	
	
		
 
                                  extern_name=self.test_user_1,

			




	
	
	
		
 
                                  skip_if_exists=True)

			




	
	
	
		
 
        params = usr.get_api_data(True)  # current user data

			




	
	
	
		
 
        user_id = usr.user_id

			




	
	
	
		
 
        self.log_user(username=self.test_user_1, password='qweqwe')

			




	
	
	
		
 

			




	
	
	
		
 
        params.update({'password_confirmation': ''})

			




	
	
	
		
 
        params.update({'new_password': ''})

			




	
	
	
		
 
        params.update({'extern_type': 'internal'})

			




	
	
	
		
 
        params.update({'extern_name': self.test_user_1})

			




	
	
	
		
 
        params.update({'_authentication_token': self.authentication_token()})

			




	
	
	
		
 

			




	
	
	
		
 
        params.update(attrs)

			




	
	
	
		
 
        response = self.app.post(url('my_account'), params)

			




	
	
	
		
 

			




	
	
	
		
 
        self.checkSessionFlash(response,

			




	
	
	
		
 
                               'Your account was updated successfully')

			




	
	
	
		
 

			




	
	
	
		
 
        updated_user = User.get_by_username(self.test_user_1)

			




	
	
	
		
 
        updated_params = updated_user.get_api_data(True)

			




	
	
	
		
 
        updated_params.update({'password_confirmation': ''})

			




	
	
	
		
 
        updated_params.update({'new_password': ''})

			




	
	
	
		
 

			




	
	
	
		
 
        params['last_login'] = updated_params['last_login']

			




	
	
	
		
 
        if name == 'email':

			




	
	
	
		
 
            params['emails'] = [attrs['email']]

			




	
	
	
		
 
        if name == 'extern_type':

			




	
	
	
		
 
            #cannot update this via form, expected value is original one

			




	
	
	
		
 
            params['extern_type'] = "internal"

			




	
	
	
		
 
        if name == 'extern_name':

			




	
	
	
		
 
            #cannot update this via form, expected value is original one

			




	
	
	
		
 
            params['extern_name'] = str(user_id)

			




	
	
	
		
 
        if name == 'active':

			




	
	
	
		
 
            #my account cannot deactivate account

			




	
	
	
		
 
            params['active'] = True

			




	
	
	
		
 
        if name == 'admin':

			




	
	
	
		
 
            #my account cannot make you an admin !

			




	
	
	
		
 
            params['admin'] = False

			




	
	
	
		
 

			




	
	
	
		
 
        params.pop('_authentication_token')

			




	
	
	
		
 
        self.assertEqual(params, updated_params)

			




	
	
	
		
 

			




	
	
	
		
 
    def test_my_account_update_err_email_exists(self):

			




	
	
	
		
 
        self.log_user()

			




	
	
	
		
 

			




	
	
	
		
 
        new_email = TEST_USER_REGULAR_EMAIL  # already existing email

			




	
	
	
		
 
        response = self.app.post(url('my_account'),

			




	
	
	
		
 
                                params=dict(

			




	
	
	
		
 
                                    username=TEST_USER_ADMIN_LOGIN,

			




	
	
	
		
 
                                    new_password=TEST_USER_ADMIN_PASS,

			




	
	
	
		
 
                                    password_confirmation='test122',

			




	
	
	
		
 
                                    firstname='NewName',

			




	
	
	
		
 
                                    lastname='NewLastname',

			




	
	
	
		
 
                                    email=new_email,

			




	
	
	
		
 
                                    _authentication_token=self.authentication_token())

			




	
	
	
		
 
                                )

			




	
	
	
		
 

			




	
	
	
		
 
        response.mustcontain('This email address is already in use')

			




	
	
	
		
 

			




	
	
	
		
 
    def test_my_account_update_err(self):

			




	
	
	
		
 
        self.log_user(TEST_USER_REGULAR2_LOGIN, TEST_USER_REGULAR2_PASS)

			




	
	
	
		
 

			




	
	
	
		
 
        new_email = 'newmail.pl'

			




	
	
	
		
 
        response = self.app.post(url('my_account'),

			




	
	
	
		
 
                                 params=dict(

			




	
	
	
		
 
                                            username=TEST_USER_ADMIN_LOGIN,

			




	
	
	
		
 
                                            new_password=TEST_USER_ADMIN_PASS,

			




	
	
	
		
 
                                            password_confirmation='test122',

			




	
	
	
		
 
                                            firstname='NewName',

			




	
	
	
		
 
                                            lastname='NewLastname',

			




	
	
	
		
 
                                            email=new_email,

			




	
	
	
		
 
                                            _authentication_token=self.authentication_token()))

			




	
	
	
		
 

			




	
	
	
		
 
        response.mustcontain('An email address must contain a single @')

			




	
	
	
		
 
        from kallithea.model import validators

			




	
	
	
		
 
        msg = validators.ValidUsername(edit=False, old_data={})\

			




	
	
	
		
 
                ._messages['username_exists']

			




	
	
	
		
 
        msg = h.html_escape(msg % {'username': TEST_USER_ADMIN_LOGIN})

			




	
	
	
		
 
        response.mustcontain(msg)

			




	
	
	
		
 

			




	
	
	
		
 
    def test_my_account_api_keys(self):

			




	
	
	
		
 
        usr = self.log_user(TEST_USER_REGULAR2_LOGIN, TEST_USER_REGULAR2_PASS)

			




	
	
	
		
 
        user = User.get(usr['user_id'])

			




	
	
	
		
 
        response = self.app.get(url('my_account_api_keys'))

			




	
	
	
		
 
        response.mustcontain(user.api_key)

			




	
	
	
		
 
        response.mustcontain('Expires: Never')

			




	
	
	
		
 

			




	
	
	
		
 
    @parameterized.expand([

			




	
	
	
		
 
        ('forever', -1),

			




	
	
	
		
 
        ('5mins', 60*5),

			




	
	
	
		
 
        ('30days', 60*60*24*30),

			




	
	
	
		
 
    ])

			




	
	
	
		
 
    def test_my_account_add_api_keys(self, desc, lifetime):

			




	
	
	
		
 
        usr = self.log_user(TEST_USER_REGULAR2_LOGIN, TEST_USER_REGULAR2_PASS)

			




	
	
	
		
 
        user = User.get(usr['user_id'])

			




	
	
	
		
 
        response = self.app.post(url('my_account_api_keys'),

			




	
	
	
		
 
                                 {'description': desc, 'lifetime': lifetime, '_authentication_token': self.authentication_token()})

			




	
	
	
		
 
        self.checkSessionFlash(response, 'API key successfully created')

			




	
	
	
		
 
        try:

			




	
	
	
		
 
            response = response.follow()

			




	
	
	
		
 
            user = User.get(usr['user_id'])

			




	
	
	
		
 
            for api_key in user.api_keys:

			




	
	
	
		
 
                response.mustcontain(api_key)

			




	
	
	
		
 
        finally:

			




	
	
	
		
 
            for api_key in UserApiKeys.query().all():

			




	
	
	
		
 
                Session().delete(api_key)

			




	
	
	
		
 
                Session().commit()

			




	
	
	
		
 

			




	
	
	
		
 
    def test_my_account_remove_api_key(self):

			




	
	
	
		
 
        usr = self.log_user(TEST_USER_REGULAR2_LOGIN, TEST_USER_REGULAR2_PASS)

			




	
	
	
		
 
        user = User.get(usr['user_id'])

			




	
	
	
		
 
        response = self.app.post(url('my_account_api_keys'),

			




	
	
	
		
 
                                 {'description': 'desc', 'lifetime': -1, '_authentication_token': self.authentication_token()})

			




	
	
	
		
 
        self.checkSessionFlash(response, 'API key successfully created')

			




	
	
	
		
 
        response = response.follow()

			




	
	
	
		
 

			




	
	
	
		
 
        #now delete our key

			




	
	
	
		
 
        keys = UserApiKeys.query().all()

			




	
	
	
		
 
        self.assertEqual(1, len(keys))

			




	
	
	
		
 

			




	
	
	
		
 
        response = self.app.post(url('my_account_api_keys'),

			




	
	
	
		
 
                 {'_method': 'delete', 'del_api_key': keys[0].api_key, '_authentication_token': self.authentication_token()})

			




	
	
	
		
 
        self.checkSessionFlash(response, 'API key successfully deleted')

			




	
	
	
		
 
        keys = UserApiKeys.query().all()

			




	
	
	
		
 
        self.assertEqual(0, len(keys))

			




	
	
	
		
 

			




	
	
	
		
 

			




	
	
	
		
 
    def test_my_account_reset_main_api_key(self):

			




	
	
	
		
 
        usr = self.log_user(TEST_USER_REGULAR2_LOGIN, TEST_USER_REGULAR2_PASS)

			




	
	
	
		
 
        user = User.get(usr['user_id'])

			




	
	
	
		
 
        api_key = user.api_key

			




	
	
	
		
 
        response = self.app.get(url('my_account_api_keys'))

			




	
	
	
		
 
        response.mustcontain(api_key)

			




	
	
	
		
 
        response.mustcontain('Expires: Never')

			




	
	
	
		
 

			




	
	
	
		
 
        response = self.app.post(url('my_account_api_keys'),

			




	
	
	
		
 
                 {'_method': 'delete', 'del_api_key_builtin': api_key, '_authentication_token': self.authentication_token()})

			




	
	
	
		
 
        self.checkSessionFlash(response, 'API key successfully reset')

			




	
	
	
		
 
        response = response.follow()

			




	
	
	
		
 
        response.mustcontain(no=[api_key])

			




        

    


    
    

    

        

                

                    kallithea/tests/other/manual_test_vcs_operations.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.tests.other.manual_test_vcs_operations

			




	
	
	
		
 
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

			




	
	
	
		
 

			




	
	
	
		
 
Test suite for making push/pull operations.

			




	
	
	
		
 

			




	
	
	
		
 
Run it in two terminals::

			




	
	
	
		
 
 paster serve kallithea/tests/test.ini

			




	
	
	
		
 
 KALLITHEA_WHOOSH_TEST_DISABLE=1 KALLITHEA_NO_TMP_PATH=1 nosetests kallithea/tests/other/manual_test_vcs_operations.py

			




	
	
	
		
 

			




	
	
	
		
 
You must have git > 1.8.1 for tests to work fine

			




	
	
	
		
 

			




	
	
	
		
 
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: Dec 30, 2010

			




	
	
	
		
 
:author: marcink

			




	
	
	
		
 
:copyright: (c) 2013 RhodeCode GmbH, and others.

			




	
	
	
		
 
:license: GPLv3, see LICENSE.md for more details.

			




	
	
	
		
 

			




	
	
	
		
 
"""

			




	
	
	
		
 

			




	
	
	
		
 
import re

			




	
	
	
		
 
import tempfile

			




	
	
	
		
 
import time

			




	
	
	
		
 
from os.path import join as jn

			




	
	
	
		
 

			




	
	
	
		
 
from tempfile import _RandomNameSequence

			




	
	
	
		
 
from subprocess import Popen, PIPE

			




	
	
	
		
 

			




	
	
	
		
 
from kallithea.tests import *

			




	
	
	
		
 
from kallithea.model.db import User, Repository, UserIpMap, CacheInvalidation

			




	
	
	
		
 
from kallithea.model.meta import Session

			




	
	
	
		
 
from kallithea.model.repo import RepoModel

			




	
	
	
		
 
from kallithea.model.user import UserModel

			




	
	
	
		
 

			




	
	
	
		
 
DEBUG = True

			




	
	
	
		
 
HOST = '127.0.0.1:4999'  # test host

			




	
	
	
		
 

			




	
	
	
		
 

			




	
	
	
		
 
class Command(object):

			




	
	
	
		
 

			




	
	
	
		
 
    def __init__(self, cwd):

			




	
	
	
		
 
        self.cwd = cwd

			




	
	
	
		
 

			




	
	
	
		
 
    def execute(self, cmd, *args):

			




	
	
	
		
 
        """

			




	
	
	
		
 
        Runs command on the system with given ``args``.

			




	
	
	
		
 
        """

			




	
	
	
		
 

			




	
	
	
		
 
        command = cmd + ' ' + ' '.join(args)

			




	
	
	
		
 
        if DEBUG:

			




	
	
	
		
 
            print '*** CMD %s ***' % command

			




	
	
	
		
 
        p = Popen(command, shell=True, stdout=PIPE, stderr=PIPE, cwd=self.cwd)

			




	
	
	
		
 
        stdout, stderr = p.communicate()

			




	
	
	
		
 
        if DEBUG:

			




	
	
	
		
 
            print 'stdout:', repr(stdout)

			




	
	
	
		
 
            print 'stderr:', repr(stderr)

			




	
	
	
		
 
        return stdout, stderr

			




	
	
	
		
 

			




	
	
	
		
 

			




	
	
	
		
 
def _get_tmp_dir():

			




	
	
	
		
 
    return tempfile.mkdtemp(prefix='rc_integration_test')

			




	
	
	
		
 

			




	
	
	
		
 

			




	
	
	
		
 
def _construct_url(repo, dest=None, **kwargs):

			




	
	
	
		
 
    if dest is None:

			




	
	
	
		
 
        #make temp clone

			




	
	
	
		
 
        dest = _get_tmp_dir()

			




	
	
	
		
 
    params = {

			




	
	
	
		
 
        'user': TEST_USER_ADMIN_LOGIN,

			




	
	
	
		
 
        'passwd': TEST_USER_ADMIN_PASS,

			




	
	
	
		
 
        'host': HOST,

			




	
	
	
		
 
        'cloned_repo': repo,

			




	
	
	
		
 
        'dest': dest

			




	
	
	
		
 
    }

			




	
	
	
		
 
    params.update(**kwargs)

			




	
	
	
		
 
    if params['user'] and params['passwd']:

			




	
	
	
		
 
        _url = 'http://%(user)s:%(passwd)s@%(host)s/%(cloned_repo)s %(dest)s' % params

			




	
	
	
		
 
    else:

			




	
	
	
		
 
        _url = 'http://(host)s/%(cloned_repo)s %(dest)s' % params

			




	
	
	
		
 
    return _url

			




	
	
	
		
 

			




	
	
	
		
 

			




	
	
	
		
 
def _add_files_and_push(vcs, DEST, **kwargs):

			




	
	
	
		
 
    """

			




	
	
	
		
 
    Generate some files, add it to DEST repo and push back

			




	
	
	
		
 
    vcs is git or hg and defines what VCS we want to make those files for

			




	
	
	
		
 

			




	
	
	
		
 
    :param vcs:

			




	
	
	
		
 
    :param DEST:

			




	
	
	
		
 
    """

			




	
	
	
		
 
    # commit some stuff into this repo

			




	
	
	
		
 
    cwd = path = jn(DEST)

			




	
	
	
		
 
    #added_file = jn(path, '%ssetupążźć.py' % _RandomNameSequence().next())

			




	
	
	
		
 
    added_file = jn(path, '%ssetup.py' % _RandomNameSequence().next())

			




	
	
	
		
 
    Command(cwd).execute('touch %s' % added_file)

			




	
	
	
		
 
    Command(cwd).execute('%s add %s' % (vcs, added_file))

			




	
	
	
		
 

			




	
	
	
		
 
    for i in xrange(kwargs.get('files_no', 3)):

			




	
	
	
		
 
        cmd = """echo 'added_line%s' >> %s""" % (i, added_file)

			




	
	
	
		
 
        Command(cwd).execute(cmd)

			




	
	
	
		
 
        author_str = 'User ǝɯɐᴎ <me@email.com>'

			




	
	
	
		
 
        author_str = 'User ǝɯɐᴎ <me@example.com>'

			




	
	
	
		
 
        if vcs == 'hg':

			




	
	
	
		
 
            cmd = """hg commit -m 'commited new %s' -u '%s' %s """ % (

			




	
	
	
		
 
                i, author_str, added_file

			




	
	
	
		
 
            )

			




	
	
	
		
 
        elif vcs == 'git':

			




	
	
	
		
 
            cmd = """EMAIL="me@email.com" git commit -m 'commited new %s' --author '%s' %s """ % (

			




	
	
	
		
 
            cmd = """EMAIL="me@example.com" git commit -m 'commited new %s' --author '%s' %s """ % (

			




	
	
	
		
 
                i, author_str, added_file

			




	
	
	
		
 
            )

			




	
	
	
		
 
        Command(cwd).execute(cmd)

			




	
	
	
		
 

			




	
	
	
		
 
    # PUSH it back

			




	
	
	
		
 
    _REPO = None

			




	
	
	
		
 
    if vcs == 'hg':

			




	
	
	
		
 
        _REPO = HG_REPO

			




	
	
	
		
 
    elif vcs == 'git':

			




	
	
	
		
 
        _REPO = GIT_REPO

			




	
	
	
		
 

			




	
	
	
		
 
    kwargs['dest'] = ''

			




	
	
	
		
 
    clone_url = _construct_url(_REPO, **kwargs)

			




	
	
	
		
 
    if 'clone_url' in kwargs:

			




	
	
	
		
 
        clone_url = kwargs['clone_url']

			




	
	
	
		
 
    stdout = stderr = None

			




	
	
	
		
 
    if vcs == 'hg':

			




	
	
	
		
 
        stdout, stderr = Command(cwd).execute('hg push --verbose', clone_url)

			




	
	
	
		
 
    elif vcs == 'git':

			




	
	
	
		
 
        stdout, stderr = Command(cwd).execute('git push --verbose', clone_url + " master")

			




	
	
	
		
 

			




	
	
	
		
 
    return stdout, stderr

			




	
	
	
		
 

			




	
	
	
		
 

			




	
	
	
		
 
def set_anonymous_access(enable=True):

			




	
	
	
		
 
    user = User.get_by_username(User.DEFAULT_USER)

			




	
	
	
		
 
    user.active = enable

			




	
	
	
		
 
    Session().add(user)

			




	
	
	
		
 
    Session().commit()

			




	
	
	
		
 
    print '\tanonymous access is now:', enable

			




	
	
	
		
 
    if enable != User.get_by_username(User.DEFAULT_USER).active:

			




	
	
	
		
 
        raise Exception('Cannot set anonymous access')

			




	
	
	
		
 

			




	
	
	
		
 

			




	
	
	
		
 
#==============================================================================

			




	
	
	
		
 
# TESTS

			




	
	
	
		
 
#==============================================================================

			




	
	
	
		
 

			




	
	
	
		
 

			




	
	
	
		
 
def _check_proper_git_push(stdout, stderr):

			




	
	
	
		
 
    #WTF Git stderr is output ?!

			




	
	
	
		
 
    assert 'fatal' not in stderr

			




	
	
	
		
 
    assert 'rejected' not in stderr

			




	
	
	
		
 
    assert 'Pushing to' in stderr

			




	
	
	
		
 
    assert 'master -> master' in stderr

			




	
	
	
		
 

			




	
	
	
		
 

			




	
	
	
		
 
class TestVCSOperations(BaseTestCase):

			




	
	
	
		
 

			




	
	
	
		
 
    @classmethod

			




	
	
	
		
 
    def setup_class(cls):

			




	
	
	
		
 
        #DISABLE ANONYMOUS ACCESS

			




	
	
	
		
 
        set_anonymous_access(False)

			




	
	
	
		
 

			




	
	
	
		
 
    def setUp(self):

			




	
	
	
		
 
        r = Repository.get_by_repo_name(GIT_REPO)

			




	
	
	
		
 
        Repository.unlock(r)

			




	
	
	
		
 
        r.enable_locking = False

			




	
	
	
		
 
        Session().add(r)

			




	
	
	
		
 
        Session().commit()

			




	
	
	
		
 

			




	
	
	
		
 
        r = Repository.get_by_repo_name(HG_REPO)

			




	
	
	
		
 
        Repository.unlock(r)

			




	
	
	
		
 
        r.enable_locking = False

			




	
	
	
		
 
        Session().add(r)

			




	
	
	
		
 
        Session().commit()

			




	
	
	
		
 

			




	
	
	
		
 
    def test_clone_hg_repo_by_admin(self):

			




	
	
	
		
 
        clone_url = _construct_url(HG_REPO)

			




	
	
	
		
 
        stdout, stderr = Command('/tmp').execute('hg clone', clone_url)

			




	
	
	
		
 

			




	
	
	
		
 
        assert 'requesting all changes' in stdout

			




	
	
	
		
 
        assert 'adding changesets' in stdout

			




	
	
	
		
 
        assert 'adding manifests' in stdout

			




	
	
	
		
 
        assert 'adding file changes' in stdout

			




	
	
	
		
 

			




	
	
	
		
 
        assert stderr == ''

			




	
	
	
		
 

			




	
	
	
		
 
    def test_clone_git_repo_by_admin(self):

			




	
	
	
		
 
        clone_url = _construct_url(GIT_REPO)

			




	
	
	
		
 
        stdout, stderr = Command('/tmp').execute('git clone', clone_url)

			




	
	
	
		
 

			




	
	
	
		
 
        assert 'Cloning into' in stdout + stderr

			




	
	
	
		
 
        assert stderr == '' or stdout == ''

			




	
	
	
		
 

			




	
	
	
		
 
    def test_clone_wrong_credentials_hg(self):

			




	
	
	
		
 
        clone_url = _construct_url(HG_REPO, passwd='bad!')

			




	
	
	
		
 
        stdout, stderr = Command('/tmp').execute('hg clone', clone_url)

			




	
	
	
		
 
        assert 'abort: authorization failed' in stderr

			




	
	
	
		
 

			




	
	
	
		
 
    def test_clone_wrong_credentials_git(self):

			




	
	
	
		
 
        clone_url = _construct_url(GIT_REPO, passwd='bad!')

			




	
	
	
		
 
        stdout, stderr = Command('/tmp').execute('git clone', clone_url)

			




	
	
	
		
 
        assert 'fatal: Authentication failed' in stderr

			




	
	
	
		
 

			




	
	
	
		
 
    def test_clone_git_dir_as_hg(self):

			




	
	
	
		
 
        clone_url = _construct_url(GIT_REPO)

			




	
	
	
		
 
        stdout, stderr = Command('/tmp').execute('hg clone', clone_url)

			




	
	
	
		
 
        assert 'HTTP Error 404: Not Found' in stderr

			




	
	
	
		
 

			




	
	
	
		
 
    def test_clone_hg_repo_as_git(self):

			




	
	
	
		
 
        clone_url = _construct_url(HG_REPO)

			




	
	
	
		
 
        stdout, stderr = Command('/tmp').execute('git clone', clone_url)

			




	
	
	
		
 
        assert 'not found' in stderr

			




	
	
	
		
 

			




	
	
	
		
 
    def test_clone_non_existing_path_hg(self):

			




	
	
	
		
 
        clone_url = _construct_url('trololo')

			




	
	
	
		
 
        stdout, stderr = Command('/tmp').execute('hg clone', clone_url)

			




	
	
	
		
 
        assert 'HTTP Error 404: Not Found' in stderr

			




	
	
	
		
 

			




	
	
	
		
 
    def test_clone_non_existing_path_git(self):

			




	
	
	
		
 
        clone_url = _construct_url('trololo')

			




	
	
	
		
 
        stdout, stderr = Command('/tmp').execute('git clone', clone_url)

			




	
	
	
		
 
        assert 'not found' in stderr

			




	
	
	
		
 

			




	
	
	
		
 
    def test_push_new_file_hg(self):

			




	
	
	
		
 
        DEST = _get_tmp_dir()

			




	
	
	
		
 
        clone_url = _construct_url(HG_REPO, dest=DEST)

			




	
	
	
		
 
        stdout, stderr = Command('/tmp').execute('hg clone', clone_url)

			




	
	
	
		
 

			




	
	
	
		
 
        stdout, stderr = _add_files_and_push('hg', DEST)

			




	
	
	
		
 

			




	
	
	
		
 
        assert 'pushing to' in stdout

			




	
	
	
		
 
        assert 'Repository size' in stdout

			




	
	
	
		
 
        assert 'Last revision is now' in stdout

			




	
	
	
		
 

			




	
	
	
		
 
    def test_push_new_file_git(self):

			




	
	
	
		
 
        DEST = _get_tmp_dir()

			




	
	
	
		
 
        clone_url = _construct_url(GIT_REPO, dest=DEST)

			




	
	
	
		
 
        stdout, stderr = Command('/tmp').execute('git clone', clone_url)

			




	
	
	
		
 

			




	
	
	
		
 
        # commit some stuff into this repo

			




	
	
	
		
 
        stdout, stderr = _add_files_and_push('git', DEST)

			




	
	
	
		
 

			




	
	
	
		
 
        print [(x.repo_full_path,x.repo_path) for x in Repository.get_all()]

			




	
	
	
		
 
        _check_proper_git_push(stdout, stderr)

			




	
	
	
		
 

			




	
	
	
		
 
    def test_push_invalidates_cache_hg(self):

			




	
	
	
		
 
        key = CacheInvalidation.query().filter(CacheInvalidation.cache_key

			




	
	
	
		
 
                                               ==HG_REPO).scalar()

			




	
	
	
		
 
        if not key:

			




	
	
	
		
 
            key = CacheInvalidation(HG_REPO, HG_REPO)

			




	
	
	
		
 

			




	
	
	
		
 
        key.cache_active = True

			




	
	
	
		
 
        Session().add(key)

			




	
	
	
		
 
        Session().commit()

			




	
	
	
		
 

			




	
	
	
		
 
        DEST = _get_tmp_dir()

			




	
	
	
		
 
        clone_url = _construct_url(HG_REPO, dest=DEST)

			




	
	
	
		
 
        stdout, stderr = Command('/tmp').execute('hg clone', clone_url)

			




	
	
	
		
 

			




	
	
	
		
 
        stdout, stderr = _add_files_and_push('hg', DEST, files_no=1)

			




	
	
	
		
 

			




	
	
	
		
 
        key = CacheInvalidation.query().filter(CacheInvalidation.cache_key

			




	
	
	
		
 
                                               ==HG_REPO).one()

			




	
	
	
		
 
        self.assertEqual(key.cache_active, False)

			




	
	
	
		
 

			




	
	
	
		
 
    def test_push_invalidates_cache_git(self):

			




	
	
	
		
 
        key = CacheInvalidation.query().filter(CacheInvalidation.cache_key

			




	
	
	
		
 
                                               ==GIT_REPO).scalar()

			




	
	
	
		
 
        if not key:

			




	
	
	
		
 
            key = CacheInvalidation(GIT_REPO, GIT_REPO)

			




	
	
	
		
 

			




	
	
	
		
 
        key.cache_active = True

			




	
	
	
		
 
        Session().add(key)

			




	
	
	
		
 
        Session().commit()

			




	
	
	
		
 

			




	
	
	
		
 
        DEST = _get_tmp_dir()

			




	
	
	
		
 
        clone_url = _construct_url(GIT_REPO, dest=DEST)

			




	
	
	
		
 
        stdout, stderr = Command('/tmp').execute('git clone', clone_url)

			




	
	
	
		
 

			




	
	
	
		
 
        # commit some stuff into this repo

			




	
	
	
		
 
        stdout, stderr = _add_files_and_push('git', DEST, files_no=1)

			




	
	
	
		
 
        _check_proper_git_push(stdout, stderr)

			




	
	
	
		
 

			




	
	
	
		
 
        key = CacheInvalidation.query().filter(CacheInvalidation.cache_key

			




	
	
	
		
 
                                               ==GIT_REPO).one()

			




	
	
	
		
 
        print CacheInvalidation.get_all()

			




	
	
	
		
 
        self.assertEqual(key.cache_active, False)

			




	
	
	
		
 

			




	
	
	
		
 
    def test_push_wrong_credentials_hg(self):

			




	
	
	
		
 
        DEST = _get_tmp_dir()

			




	
	
	
		
 
        clone_url = _construct_url(HG_REPO, dest=DEST)

			




	
	
	
		
 
        stdout, stderr = Command('/tmp').execute('hg clone', clone_url)

			




	
	
	
		
 

			




	
	
	
		
 
        stdout, stderr = _add_files_and_push('hg', DEST, user='bad',

			




	
	
	
		
 
                                             passwd='name')

			




	
	
	
		
 

			




	
	
	
		
 
        assert 'abort: authorization failed' in stderr

			




	
	
	
		
 

			




	
	
	
		
 
    def test_push_wrong_credentials_git(self):

			




	
	
	
		
 
        DEST = _get_tmp_dir()

			




        

    


    
    

    

        

                

                    kallithea/tests/other/test_libs.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.tests.other.test_libs

			




	
	
	
		
 
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

			




	
	
	
		
 

			




	
	
	
		
 
Package for testing various lib/helper functions in kallithea

			




	
	
	
		
 

			




	
	
	
		
 
This file was forked by the Kallithea project in July 2014.

			




	
	
	
		
 
Original author and date, and relevant copyright and licensing information is below:

			




	
	
	
		
 
:created_on: Jun 9, 2011

			




	
	
	
		
 
:author: marcink

			




	
	
	
		
 
:copyright: (c) 2013 RhodeCode GmbH, and others.

			




	
	
	
		
 
:license: GPLv3, see LICENSE.md for more details.

			




	
	
	
		
 
"""

			




	
	
	
		
 

			




	
	
	
		
 
import datetime

			




	
	
	
		
 
import hashlib

			




	
	
	
		
 
import mock

			




	
	
	
		
 
from kallithea.tests import *

			




	
	
	
		
 
from kallithea.lib.utils2 import AttributeDict

			




	
	
	
		
 
from kallithea.model.db import Repository

			




	
	
	
		
 

			




	
	
	
		
 
proto = 'http'

			




	
	
	
		
 
TEST_URLS = [

			




	
	
	
		
 
    ('%s://127.0.0.1' % proto, ['%s://' % proto, '127.0.0.1'],

			




	
	
	
		
 
     '%s://127.0.0.1' % proto),

			




	
	
	
		
 
    ('%s://username@127.0.0.1' % proto, ['%s://' % proto, '127.0.0.1'],

			




	
	
	
		
 
     '%s://127.0.0.1' % proto),

			




	
	
	
		
 
    ('%s://username:pass@127.0.0.1' % proto, ['%s://' % proto, '127.0.0.1'],

			




	
	
	
		
 
     '%s://127.0.0.1' % proto),

			




	
	
	
		
 
    ('%s://127.0.0.1:8080' % proto, ['%s://' % proto, '127.0.0.1', '8080'],

			




	
	
	
		
 
     '%s://127.0.0.1:8080' % proto),

			




	
	
	
		
 
    ('%s://domain.org' % proto, ['%s://' % proto, 'domain.org'],

			




	
	
	
		
 
     '%s://domain.org' % proto),

			




	
	
	
		
 
    ('%s://user:pass@domain.org:8080' % proto, ['%s://' % proto, 'domain.org',

			




	
	
	
		
 
    ('%s://example.com' % proto, ['%s://' % proto, 'example.com'],

			




	
	
	
		
 
     '%s://example.com' % proto),

			




	
	
	
		
 
    ('%s://user:pass@example.com:8080' % proto, ['%s://' % proto, 'example.com',

			




	
	
	
		
 
                                                '8080'],

			




	
	
	
		
 
     '%s://domain.org:8080' % proto),

			




	
	
	
		
 
     '%s://example.com:8080' % proto),

			




	
	
	
		
 
]

			




	
	
	
		
 

			




	
	
	
		
 
proto = 'https'

			




	
	
	
		
 
TEST_URLS += [

			




	
	
	
		
 
    ('%s://127.0.0.1' % proto, ['%s://' % proto, '127.0.0.1'],

			




	
	
	
		
 
     '%s://127.0.0.1' % proto),

			




	
	
	
		
 
    ('%s://username@127.0.0.1' % proto, ['%s://' % proto, '127.0.0.1'],

			




	
	
	
		
 
     '%s://127.0.0.1' % proto),

			




	
	
	
		
 
    ('%s://username:pass@127.0.0.1' % proto, ['%s://' % proto, '127.0.0.1'],

			




	
	
	
		
 
     '%s://127.0.0.1' % proto),

			




	
	
	
		
 
    ('%s://127.0.0.1:8080' % proto, ['%s://' % proto, '127.0.0.1', '8080'],

			




	
	
	
		
 
     '%s://127.0.0.1:8080' % proto),

			




	
	
	
		
 
    ('%s://domain.org' % proto, ['%s://' % proto, 'domain.org'],

			




	
	
	
		
 
     '%s://domain.org' % proto),

			




	
	
	
		
 
    ('%s://user:pass@domain.org:8080' % proto, ['%s://' % proto, 'domain.org',

			




	
	
	
		
 
    ('%s://example.com' % proto, ['%s://' % proto, 'example.com'],

			




	
	
	
		
 
     '%s://example.com' % proto),

			




	
	
	
		
 
    ('%s://user:pass@example.com:8080' % proto, ['%s://' % proto, 'example.com',

			




	
	
	
		
 
                                                '8080'],

			




	
	
	
		
 
     '%s://domain.org:8080' % proto),

			




	
	
	
		
 
     '%s://example.com:8080' % proto),

			




	
	
	
		
 
]

			




	
	
	
		
 

			




	
	
	
		
 

			




	
	
	
		
 
class TestLibs(BaseTestCase):

			




	
	
	
		
 

			




	
	
	
		
 
    @parameterized.expand(TEST_URLS)

			




	
	
	
		
 
    def test_uri_filter(self, test_url, expected, expected_creds):

			




	
	
	
		
 
        from kallithea.lib.utils2 import uri_filter

			




	
	
	
		
 
        self.assertEqual(uri_filter(test_url), expected)

			




	
	
	
		
 

			




	
	
	
		
 
    @parameterized.expand(TEST_URLS)

			




	
	
	
		
 
    def test_credentials_filter(self, test_url, expected, expected_creds):

			




	
	
	
		
 
        from kallithea.lib.utils2 import credentials_filter

			




	
	
	
		
 
        self.assertEqual(credentials_filter(test_url), expected_creds)

			




	
	
	
		
 

			




	
	
	
		
 
    @parameterized.expand([('t', True),

			




	
	
	
		
 
                           ('true', True),

			




	
	
	
		
 
                           ('y', True),

			




	
	
	
		
 
                           ('yes', True),

			




	
	
	
		
 
                           ('on', True),

			




	
	
	
		
 
                           ('1', True),

			




	
	
	
		
 
                           ('Y', True),

			




	
	
	
		
 
                           ('yeS', True),

			




	
	
	
		
 
                           ('Y', True),

			




	
	
	
		
 
                           ('TRUE', True),

			




	
	
	
		
 
                           ('T', True),

			




	
	
	
		
 
                           ('False', False),

			




	
	
	
		
 
                           ('F', False),

			




	
	
	
		
 
                           ('FALSE', False),

			




	
	
	
		
 
                           ('0', False),

			




	
	
	
		
 
                           ('-1', False),

			




	
	
	
		
 
                           ('', False)

			




	
	
	
		
 
    ])

			




	
	
	
		
 
    def test_str2bool(self, str_bool, expected):

			




	
	
	
		
 
        from kallithea.lib.utils2 import str2bool

			




	
	
	
		
 
        self.assertEqual(str2bool(str_bool), expected)

			




	
	
	
		
 

			




	
	
	
		
 
    def test_mention_extractor(self):

			




	
	
	
		
 
        from kallithea.lib.utils2 import extract_mentioned_users

			




	
	
	
		
 
        sample = (

			




	
	
	
		
 
            "@first hi there @world here's my email username@email.com "

			




	
	
	
		
 
            "@first hi there @world here's my email username@example.com "

			




	
	
	
		
 
            "@lukaszb check @one_more22 it pls @ ttwelve @D[] @one@two@three "

			




	
	
	
		
 
            "@UPPER    @cAmEL @2one_more22 @john please see this http://org.pl "

			




	
	
	
		
 
            "@marian.user just do it @marco-polo and next extract @marco_polo "

			




	
	
	
		
 
            "user.dot  hej ! not-needed maril@domain.org"

			




	
	
	
		
 
            "user.dot  hej ! not-needed maril@example.com"

			




	
	
	
		
 
        )

			




	
	
	
		
 

			




	
	
	
		
 
        s = sorted([

			




	
	
	
		
 
            '2one_more22', 'first', 'lukaszb', 'one', 'one_more22', 'UPPER', 'cAmEL', 'john',

			




	
	
	
		
 
            'marian.user', 'marco-polo', 'marco_polo', 'world'], key=lambda k: k.lower())

			




	
	
	
		
 
        self.assertEqual(s, extract_mentioned_users(sample))

			




	
	
	
		
 

			




	
	
	
		
 
    @parameterized.expand([

			




	
	
	
		
 
        (dict(), u'just now'),

			




	
	
	
		
 
        (dict(seconds= -1), u'1 second ago'),

			




	
	
	
		
 
        (dict(seconds= -60 * 2), u'2 minutes ago'),

			




	
	
	
		
 
        (dict(hours= -1), u'1 hour ago'),

			




	
	
	
		
 
        (dict(hours= -24), u'1 day ago'),

			




	
	
	
		
 
        (dict(hours= -24 * 5), u'5 days ago'),

			




	
	
	
		
 
        (dict(months= -1), u'1 month ago'),

			




	
	
	
		
 
        (dict(months= -1, days= -2), u'1 month and 2 days ago'),

			




	
	
	
		
 
        (dict(months= -1, days= -20), u'1 month and 19 days ago'),

			




	
	
	
		
 
        (dict(years= -1, months= -1), u'1 year and 1 month ago'),

			




	
	
	
		
 
        (dict(years= -1, months= -10), u'1 year and 10 months ago'),

			




	
	
	
		
 
        (dict(years= -2, months= -4), u'2 years and 4 months ago'),

			




	
	
	
		
 
        (dict(years= -2, months= -11), u'2 years and 11 months ago'),

			




	
	
	
		
 
        (dict(years= -3, months= -2), u'3 years and 2 months ago'),

			




	
	
	
		
 
    ])

			




	
	
	
		
 
    def test_age(self, age_args, expected):

			




	
	
	
		
 
        from kallithea.lib.utils2 import age

			




	
	
	
		
 
        from dateutil import relativedelta

			




	
	
	
		
 
        n = datetime.datetime(year=2012, month=5, day=17)

			




	
	
	
		
 
        delt = lambda *args, **kwargs: relativedelta.relativedelta(*args, **kwargs)

			




	
	
	
		
 
        self.assertEqual(age(n + delt(**age_args), now=n), expected)

			




	
	
	
		
 

			




	
	
	
		
 
    @parameterized.expand([

			




	
	
	
		
 
        (dict(), u'just now'),

			




	
	
	
		
 
        (dict(seconds= -1), u'1 second ago'),

			




	
	
	
		
 
        (dict(seconds= -60 * 2), u'2 minutes ago'),

			




	
	
	
		
 
        (dict(hours= -1), u'1 hour ago'),

			




	
	
	
		
 
        (dict(hours= -24), u'1 day ago'),

			




	
	
	
		
 
        (dict(hours= -24 * 5), u'5 days ago'),

			




	
	
	
		
 
        (dict(months= -1), u'1 month ago'),

			




	
	
	
		
 
        (dict(months= -1, days= -2), u'1 month ago'),

			




	
	
	
		
 
        (dict(months= -1, days= -20), u'1 month ago'),

			




	
	
	
		
 
        (dict(years= -1, months= -1), u'13 months ago'),

			




	
	
	
		
 
        (dict(years= -1, months= -10), u'22 months ago'),

			




	
	
	
		
 
        (dict(years= -2, months= -4), u'2 years ago'),

			




	
	
	
		
 
        (dict(years= -2, months= -11), u'3 years ago'),

			




	
	
	
		
 
        (dict(years= -3, months= -2), u'3 years ago'),

			




	
	
	
		
 
        (dict(years= -4, months= -8), u'5 years ago'),

			




	
	
	
		
 
    ])

			




	
	
	
		
 
    def test_age_short(self, age_args, expected):

			




	
	
	
		
 
        from kallithea.lib.utils2 import age

			




	
	
	
		
 
        from dateutil import relativedelta

			




	
	
	
		
 
        n = datetime.datetime(year=2012, month=5, day=17)

			




	
	
	
		
 
        delt = lambda *args, **kwargs: relativedelta.relativedelta(*args, **kwargs)

			




	
	
	
		
 
        self.assertEqual(age(n + delt(**age_args), show_short_version=True, now=n), expected)

			




	
	
	
		
 

			




	
	
	
		
 
    @parameterized.expand([

			




	
	
	
		
 
        (dict(), u'just now'),

			




	
	
	
		
 
        (dict(seconds=1), u'in 1 second'),

			




	
	
	
		
 
        (dict(seconds=60 * 2), u'in 2 minutes'),

			




	
	
	
		
 
        (dict(hours=1), u'in 1 hour'),

			




	
	
	
		
 
        (dict(hours=24), u'in 1 day'),

			




	
	
	
		
 
        (dict(hours=24 * 5), u'in 5 days'),

			




	
	
	
		
 
        (dict(months=1), u'in 1 month'),

			




	
	
	
		
 
        (dict(months=1, days=1), u'in 1 month and 1 day'),

			




	
	
	
		
 
        (dict(years=1, months=1), u'in 1 year and 1 month')

			




	
	
	
		
 
    ])

			




	
	
	
		
 
    def test_age_in_future(self, age_args, expected):

			




	
	
	
		
 
        from kallithea.lib.utils2 import age

			




	
	
	
		
 
        from dateutil import relativedelta

			




	
	
	
		
 
        n = datetime.datetime(year=2012, month=5, day=17)

			




	
	
	
		
 
        delt = lambda *args, **kwargs: relativedelta.relativedelta(*args, **kwargs)

			




	
	
	
		
 
        self.assertEqual(age(n + delt(**age_args), now=n), expected)

			




	
	
	
		
 

			




	
	
	
		
 
    def test_tag_exctrator(self):

			




	
	
	
		
 
        sample = (

			




	
	
	
		
 
            "hello pta[tag] gog [[]] [[] sda ero[or]d [me =>>< sa]"

			




	
	
	
		
 
            "[requires] [stale] [see<>=>] [see => http://url.com]"

			




	
	
	
		
 
            "[requires] [stale] [see<>=>] [see => http://example.com]"

			




	
	
	
		
 
            "[requires => url] [lang => python] [just a tag]"

			




	
	
	
		
 
            "[,d] [ => ULR ] [obsolete] [desc]]"

			




	
	
	
		
 
        )

			




	
	
	
		
 
        from kallithea.lib.helpers import urlify_text

			




	
	
	
		
 
        res = urlify_text(sample, stylize=True)

			




	
	
	
		
 
        self.assertIn('<div class="metatag" tag="tag">tag</div>', res)

			




	
	
	
		
 
        self.assertIn('<div class="metatag" tag="obsolete">obsolete</div>', res)

			




	
	
	
		
 
        self.assertIn('<div class="metatag" tag="stale">stale</div>', res)

			




	
	
	
		
 
        self.assertIn('<div class="metatag" tag="lang">python</div>', res)

			




	
	
	
		
 
        self.assertIn('<div class="metatag" tag="requires">requires =&gt; <a href="/url">url</a></div>', res)

			




	
	
	
		
 
        self.assertIn('<div class="metatag" tag="tag">tag</div>', res)

			




	
	
	
		
 

			




	
	
	
		
 
    def test_alternative_gravatar(self):

			




	
	
	
		
 
        from kallithea.lib.helpers import gravatar_url

			




	
	
	
		
 
        _md5 = lambda s: hashlib.md5(s).hexdigest()

			




	
	
	
		
 

			




	
	
	
		
 
        #mock pylons.url

			




	
	
	
		
 
        class fake_url(object):

			




	
	
	
		
 
            @classmethod

			




	
	
	
		
 
            def current(cls, *args, **kwargs):

			




	
	
	
		
 
                return 'https://server.com'

			




	
	
	
		
 
                return 'https://example.com'

			




	
	
	
		
 

			




	
	
	
		
 
        #mock pylons.tmpl_context

			




	
	
	
		
 
        def fake_tmpl_context(_url):

			




	
	
	
		
 
            _c = AttributeDict()

			




	
	
	
		
 
            _c.visual = AttributeDict()

			




	
	
	
		
 
            _c.visual.use_gravatar = True

			




	
	
	
		
 
            _c.visual.gravatar_url = _url

			




	
	
	
		
 

			




	
	
	
		
 
            return _c

			




	
	
	
		
 

			




	
	
	
		
 

			




	
	
	
		
 
        with mock.patch('pylons.url', fake_url):

			




	
	
	
		
 
            fake = fake_tmpl_context(_url='http://test.com/{email}')

			




	
	
	
		
 
            fake = fake_tmpl_context(_url='http://example.com/{email}')

			




	
	
	
		
 
            with mock.patch('pylons.tmpl_context', fake):

			




	
	
	
		
 
                    from pylons import url

			




	
	
	
		
 
                    assert url.current() == 'https://server.com'

			




	
	
	
		
 
                    grav = gravatar_url(email_address='test@foo.com', size=24)

			




	
	
	
		
 
                    assert grav == 'http://test.com/test@foo.com'

			




	
	
	
		
 
                    assert url.current() == 'https://example.com'

			




	
	
	
		
 
                    grav = gravatar_url(email_address='test@example.com', size=24)

			




	
	
	
		
 
                    assert grav == 'http://example.com/test@example.com'

			




	
	
	
		
 

			




	
	
	
		
 
            fake = fake_tmpl_context(_url='http://test.com/{email}')

			




	
	
	
		
 
            fake = fake_tmpl_context(_url='http://example.com/{email}')

			




	
	
	
		
 
            with mock.patch('pylons.tmpl_context', fake):

			




	
	
	
		
 
                grav = gravatar_url(email_address='test@foo.com', size=24)

			




	
	
	
		
 
                assert grav == 'http://test.com/test@foo.com'

			




	
	
	
		
 
                grav = gravatar_url(email_address='test@example.com', size=24)

			




	
	
	
		
 
                assert grav == 'http://example.com/test@example.com'

			




	
	
	
		
 

			




	
	
	
		
 
            fake = fake_tmpl_context(_url='http://test.com/{md5email}')

			




	
	
	
		
 
            fake = fake_tmpl_context(_url='http://example.com/{md5email}')

			




	
	
	
		
 
            with mock.patch('pylons.tmpl_context', fake):

			




	
	
	
		
 
                em = 'test@foo.com'

			




	
	
	
		
 
                em = 'test@example.com'

			




	
	
	
		
 
                grav = gravatar_url(email_address=em, size=24)

			




	
	
	
		
 
                assert grav == 'http://test.com/%s' % (_md5(em))

			




	
	
	
		
 
                assert grav == 'http://example.com/%s' % (_md5(em))

			




	
	
	
		
 

			




	
	
	
		
 
            fake = fake_tmpl_context(_url='http://test.com/{md5email}/{size}')

			




	
	
	
		
 
            fake = fake_tmpl_context(_url='http://example.com/{md5email}/{size}')

			




	
	
	
		
 
            with mock.patch('pylons.tmpl_context', fake):

			




	
	
	
		
 
                em = 'test@foo.com'

			




	
	
	
		
 
                em = 'test@example.com'

			




	
	
	
		
 
                grav = gravatar_url(email_address=em, size=24)

			




	
	
	
		
 
                assert grav == 'http://test.com/%s/%s' % (_md5(em), 24)

			




	
	
	
		
 
                assert grav == 'http://example.com/%s/%s' % (_md5(em), 24)

			




	
	
	
		
 

			




	
	
	
		
 
            fake = fake_tmpl_context(_url='{scheme}://{netloc}/{md5email}/{size}')

			




	
	
	
		
 
            with mock.patch('pylons.tmpl_context', fake):

			




	
	
	
		
 
                em = 'test@foo.com'

			




	
	
	
		
 
                em = 'test@example.com'

			




	
	
	
		
 
                grav = gravatar_url(email_address=em, size=24)

			




	
	
	
		
 
                assert grav == 'https://server.com/%s/%s' % (_md5(em), 24)

			




	
	
	
		
 
                assert grav == 'https://example.com/%s/%s' % (_md5(em), 24)

			




	
	
	
		
 

			




	
	
	
		
 
    @parameterized.expand([

			




	
	
	
		
 
        (Repository.DEFAULT_CLONE_URI, 'group/repo1', {}, '', 'http://vps1:8000/group/repo1'),

			




	
	
	
		
 
        (Repository.DEFAULT_CLONE_URI, 'group/repo1', {'user': 'username'}, '', 'http://username@vps1:8000/group/repo1'),

			




	
	
	
		
 
        (Repository.DEFAULT_CLONE_URI, 'group/repo1', {}, '/prefix', 'http://vps1:8000/prefix/group/repo1'),

			




	
	
	
		
 
        (Repository.DEFAULT_CLONE_URI, 'group/repo1', {'user': 'user'}, '/prefix', 'http://user@vps1:8000/prefix/group/repo1'),

			




	
	
	
		
 
        (Repository.DEFAULT_CLONE_URI, 'group/repo1', {'user': 'username'}, '/prefix', 'http://username@vps1:8000/prefix/group/repo1'),

			




	
	
	
		
 
        (Repository.DEFAULT_CLONE_URI, 'group/repo1', {'user': 'user'}, '/prefix/', 'http://user@vps1:8000/prefix/group/repo1'),

			




	
	
	
		
 
        (Repository.DEFAULT_CLONE_URI, 'group/repo1', {'user': 'username'}, '/prefix/', 'http://username@vps1:8000/prefix/group/repo1'),

			




	
	
	
		
 
        ('{scheme}://{user}@{netloc}/_{repoid}', 'group/repo1', {}, '', 'http://vps1:8000/_23'),

			




	
	
	
		
 
        ('{scheme}://{user}@{netloc}/_{repoid}', 'group/repo1', {'user': 'username'}, '', 'http://username@vps1:8000/_23'),

			




	
	
	
		
 
        ('http://{user}@{netloc}/_{repoid}', 'group/repo1', {'user': 'username'}, '', 'http://username@vps1:8000/_23'),

			




	
	
	
		
 
        ('http://{netloc}/_{repoid}', 'group/repo1', {'user': 'username'}, '', 'http://vps1:8000/_23'),

			




	
	
	
		
 
        ('https://{user}@proxy1.server.com/{repo}', 'group/repo1', {'user': 'username'}, '', 'https://username@proxy1.server.com/group/repo1'),

			




	
	
	
		
 
        ('https://{user}@proxy1.server.com/{repo}', 'group/repo1', {}, '', 'https://proxy1.server.com/group/repo1'),

			




	
	
	
		
 
        ('https://proxy1.server.com/{user}/{repo}', 'group/repo1', {'user': 'username'}, '', 'https://proxy1.server.com/username/group/repo1'),

			




	
	
	
		
 
        ('https://{user}@proxy1.example.com/{repo}', 'group/repo1', {'user': 'username'}, '', 'https://username@proxy1.example.com/group/repo1'),

			




	
	
	
		
 
        ('https://{user}@proxy1.example.com/{repo}', 'group/repo1', {}, '', 'https://proxy1.example.com/group/repo1'),

			




	
	
	
		
 
        ('https://proxy1.example.com/{user}/{repo}', 'group/repo1', {'user': 'username'}, '', 'https://proxy1.example.com/username/group/repo1'),

			




	
	
	
		
 
    ])

			




	
	
	
		
 
    def test_clone_url_generator(self, tmpl, repo_name, overrides, prefix, expected):

			




	
	
	
		
 
        from kallithea.lib.utils2 import get_clone_url

			




	
	
	
		
 
        clone_url = get_clone_url(uri_tmpl=tmpl, qualified_home_url='http://vps1:8000'+prefix,

			




	
	
	
		
 
                                  repo_name=repo_name, repo_id=23, **overrides)

			




	
	
	
		
 
        self.assertEqual(clone_url, expected)

			




	
	
	
		
 

			




	
	
	
		
 
    def _quick_url(self, text, tmpl="""<a class="revision-link" href="%s">%s</a>""", url_=None):

			




	
	
	
		
 
        """

			




	
	
	
		
 
        Changes `some text url[foo]` => `some text <a href="/">foo</a>

			




	
	
	
		
 

			




	
	
	
		
 
        :param text:

			




	
	
	
		
 
        """

			




	
	
	
		
 
        import re

			




	
	
	
		
 
        # quickly change expected url[] into a link

			




	
	
	
		
 
        URL_PAT = re.compile(r'(?:url\[)(.+?)(?:\])')

			




	
	
	
		
 

			




	
	
	
		
 
        def url_func(match_obj):

			




	
	
	
		
 
            _url = match_obj.groups()[0]

			




	
	
	
		
 
            return tmpl % (url_ or '/some-url', _url)

			




	
	
	
		
 
        return URL_PAT.sub(url_func, text)

			




	
	
	
		
 

			




	
	
	
		
 
    @parameterized.expand([

			




	
	
	
		
 
      ("",

			




	
	
	
		
 
       ""),

			




	
	
	
		
 
      ("git-svn-id: https://svn.apache.org/repos/asf/libcloud/trunk@1441655 13f79535-47bb-0310-9956-ffa450edef68",

			




	
	
	
		
 
       "git-svn-id: https://svn.apache.org/repos/asf/libcloud/trunk@1441655 13f79535-47bb-0310-9956-ffa450edef68"),

			




	
	
	
		
 
      ("from rev 000000000000",

			




	
	
	
		
 
       "from rev url[000000000000]"),

			




	
	
	
		
 
      ("from rev 000000000000123123 also rev 000000000000",

			




	
	
	
		
 
       "from rev url[000000000000123123] also rev url[000000000000]"),

			




	
	
	
		
 
      ("this should-000 00",

			




	
	
	
		
 
       "this should-000 00"),

			




	
	
	
		
 
      ("longtextffffffffff rev 123123123123",

			




	
	
	
		
 
       "longtextffffffffff rev url[123123123123]"),

			




	
	
	
		
 
      ("rev ffffffffffffffffffffffffffffffffffffffffffffffffff",

			




	
	
	
		
 
       "rev ffffffffffffffffffffffffffffffffffffffffffffffffff"),

			




	
	
	
		
 
      ("ffffffffffff some text traalaa",

			




	
	
	
		
 
       "url[ffffffffffff] some text traalaa"),

			




	
	
	
		
 
       ("""Multi line

			




	
	
	
		
 
       123123123123

			




	
	
	
		
 
       some text 123123123123

			




	
	
	
		
 
       sometimes !

			




	
	
	
		
 
       """,

			




	
	
	
		
 
       """Multi line

			




	
	
	
		
 
       url[123123123123]

			




	
	
	
		
 
       some text url[123123123123]

			




	
	
	
		
 
       sometimes !

			




	
	
	
		
 
       """)

			




	
	
	
		
 
    ])

			




	
	
	
		
 
    def test_urlify_changesets(self, sample, expected):

			




	
	
	
		
 
        def fake_url(self, *args, **kwargs):

			




	
	
	
		
 
            return '/some-url'

			




	
	
	
		
 

			




	
	
	
		
 
        expected = self._quick_url(expected)

			




	
	
	
		
 

			




	
	
	
		
 
        with mock.patch('pylons.url', fake_url):

			




	
	
	
		
 
            from kallithea.lib.helpers import urlify_changesets

			




	
	
	
		
 
            self.assertEqual(urlify_changesets(sample, 'repo_name'), expected)

			




	
	
	
		
 

			




	
	
	
		
 
    @parameterized.expand([

			




	
	
	
		
 
      ("",

			




	
	
	
		
 
       "",

			




	
	
	
		
 
       ""),

			




	
	
	
		
 
      ("https://svn.apache.org/repos",

			




	
	
	
		
 
       "url[https://svn.apache.org/repos]",

			




	
	
	
		
 
       "https://svn.apache.org/repos"),

			




	
	
	
		
 
      ("http://svn.apache.org/repos",

			




	
	
	
		
 
       "url[http://svn.apache.org/repos]",

			




	
	
	
		
 
       "http://svn.apache.org/repos"),

			




	
	
	
		
 
      ("from rev a also rev http://google.com",

			




	
	
	
		
 
       "from rev a also rev url[http://google.com]",

			




	
	
	
		
 
       "http://google.com"),

			




	
	
	
		
 
       ("""Multi line

			




	
	
	
		
 
       https://foo.bar.com

			




	
	
	
		
 
       https://foo.bar.example.com

			




	
	
	
		
 
       some text lalala""",

			




	
	
	
		
 
       """Multi line

			




	
	
	
		
 
       url[https://foo.bar.com]

			




	
	
	
		
 
       url[https://foo.bar.example.com]

			




	
	
	
		
 
       some text lalala""",

			




	
	
	
		
 
       "https://foo.bar.com")

			




	
	
	
		
 
       "https://foo.bar.example.com")

			




	
	
	
		
 
    ])

			




	
	
	
		
 
    def test_urlify_test(self, sample, expected, url_):

			




	
	
	
		
 
        from kallithea.lib.helpers import urlify_text

			




	
	
	
		
 
        expected = self._quick_url(expected,

			




	
	
	
		
 
                                   tmpl="""<a href="%s">%s</a>""", url_=url_)

			




	
	
	
		
 
        self.assertEqual(urlify_text(sample), expected)

			




	
	
	
		
 

			




	
	
	
		
 
    @parameterized.expand([

			




	
	
	
		
 
      ("", None),

			




	
	
	
		
 
      ("/_2", '2'),

			




	
	
	
		
 
      ("_2", '2'),

			




	
	
	
		
 
      ("/_2/", '2'),

			




	
	
	
		
 
      ("_2/", '2'),

			




	
	
	
		
 

			




	
	
	
		
 
      ("/_21", '21'),

			




	
	
	
		
 
      ("_21", '21'),

			




	
	
	
		
 
      ("/_21/", '21'),

			




	
	
	
		
 
      ("_21/", '21'),

			




	
	
	
		
 

			




	
	
	
		
 
      ("/_21/foobar", '21'),

			




	
	
	
		
 
      ("_21/121", '21'),

			




	
	
	
		
 
      ("/_21/_12", '21'),

			




	
	
	
		
 
      ("_21/prefix/foo", '21'),

			




	
	
	
		
 
    ])

			




	
	
	
		
 
    def test_get_repo_by_id(self, test, expected):

			




	
	
	
		
 
        from kallithea.lib.utils import _extract_id_from_repo_name

			




	
	
	
		
 
        _test = _extract_id_from_repo_name(test)

			




	
	
	
		
 
        self.assertEqual(_test, expected, msg='url:%s, got:`%s` expected: `%s`'

			




	
	
	
		
 
                                              % (test, _test, expected))

			




        

    


    
    

    

        

                

                    kallithea/tests/scripts/manual_test_concurrency.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.tests.scripts.manual_test_concurrency

			




	
	
	
		
 
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

			




	
	
	
		
 

			




	
	
	
		
 
Test suite for making push/pull operations

			




	
	
	
		
 

			




	
	
	
		
 
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: Dec 30, 2010

			




	
	
	
		
 
:author: marcink

			




	
	
	
		
 
:copyright: (c) 2013 RhodeCode GmbH, and others.

			




	
	
	
		
 
:license: GPLv3, see LICENSE.md for more details.

			




	
	
	
		
 

			




	
	
	
		
 
"""

			




	
	
	
		
 

			




	
	
	
		
 
import os

			




	
	
	
		
 
import sys

			




	
	
	
		
 
import shutil

			




	
	
	
		
 
import logging

			




	
	
	
		
 
from os.path import join as jn

			




	
	
	
		
 
from os.path import dirname as dn

			




	
	
	
		
 

			




	
	
	
		
 
from tempfile import _RandomNameSequence

			




	
	
	
		
 
from subprocess import Popen, PIPE

			




	
	
	
		
 

			




	
	
	
		
 
from paste.deploy import appconfig

			




	
	
	
		
 
from sqlalchemy import engine_from_config

			




	
	
	
		
 

			




	
	
	
		
 
from kallithea.lib.utils import add_cache

			




	
	
	
		
 
from kallithea.model import init_model

			




	
	
	
		
 
from kallithea.model import meta

			




	
	
	
		
 
from kallithea.model.db import User, Repository

			




	
	
	
		
 
from kallithea.lib.auth import get_crypt_password

			




	
	
	
		
 

			




	
	
	
		
 
from kallithea.tests import TESTS_TMP_PATH, HG_REPO

			




	
	
	
		
 
from kallithea.config.environment import load_environment

			




	
	
	
		
 

			




	
	
	
		
 
rel_path = dn(dn(dn(dn(os.path.abspath(__file__)))))

			




	
	
	
		
 
conf = appconfig('config:development.ini', relative_to=rel_path)

			




	
	
	
		
 
load_environment(conf.global_conf, conf.local_conf)

			




	
	
	
		
 

			




	
	
	
		
 
add_cache(conf)

			




	
	
	
		
 

			




	
	
	
		
 
USER = TEST_USER_ADMIN_LOGIN

			




	
	
	
		
 
PASS = TEST_USER_ADMIN_PASS

			




	
	
	
		
 
HOST = 'server.local'

			




	
	
	
		
 
METHOD = 'pull'

			




	
	
	
		
 
DEBUG = True

			




	
	
	
		
 
log = logging.getLogger(__name__)

			




	
	
	
		
 

			




	
	
	
		
 

			




	
	
	
		
 
class Command(object):

			




	
	
	
		
 

			




	
	
	
		
 
    def __init__(self, cwd):

			




	
	
	
		
 
        self.cwd = cwd

			




	
	
	
		
 

			




	
	
	
		
 
    def execute(self, cmd, *args):

			




	
	
	
		
 
        """Runs command on the system with given ``args``.

			




	
	
	
		
 
        """

			




	
	
	
		
 

			




	
	
	
		
 
        command = cmd + ' ' + ' '.join(args)

			




	
	
	
		
 
        log.debug('Executing %s', command)

			




	
	
	
		
 
        if DEBUG:

			




	
	
	
		
 
            print command

			




	
	
	
		
 
        p = Popen(command, shell=True, stdout=PIPE, stderr=PIPE, cwd=self.cwd)

			




	
	
	
		
 
        stdout, stderr = p.communicate()

			




	
	
	
		
 
        if DEBUG:

			




	
	
	
		
 
            print stdout, stderr

			




	
	
	
		
 
        return stdout, stderr

			




	
	
	
		
 

			




	
	
	
		
 

			




	
	
	
		
 
def get_session():

			




	
	
	
		
 
    engine = engine_from_config(conf, 'sqlalchemy.db1.')

			




	
	
	
		
 
    init_model(engine)

			




	
	
	
		
 
    sa = meta.Session

			




	
	
	
		
 
    return sa

			




	
	
	
		
 

			




	
	
	
		
 

			




	
	
	
		
 
def create_test_user(force=True):

			




	
	
	
		
 
    print 'creating test user'

			




	
	
	
		
 
    sa = get_session()

			




	
	
	
		
 

			




	
	
	
		
 
    user = sa.query(User).filter(User.username == USER).scalar()

			




	
	
	
		
 

			




	
	
	
		
 
    if force and user is not None:

			




	
	
	
		
 
        print 'removing current user'

			




	
	
	
		
 
        for repo in sa.query(Repository).filter(Repository.user == user).all():

			




	
	
	
		
 
            sa.delete(repo)

			




	
	
	
		
 
        sa.delete(user)

			




	
	
	
		
 
        sa.commit()

			




	
	
	
		
 

			




	
	
	
		
 
    if user is None or force:

			




	
	
	
		
 
        print 'creating new one'

			




	
	
	
		
 
        new_usr = User()

			




	
	
	
		
 
        new_usr.username = USER

			




	
	
	
		
 
        new_usr.password = get_crypt_password(PASS)

			




	
	
	
		
 
        new_usr.email = 'mail@mail.com'

			




	
	
	
		
 
        new_usr.email = 'mail@example.com'

			




	
	
	
		
 
        new_usr.name = 'test'

			




	
	
	
		
 
        new_usr.lastname = 'lasttestname'

			




	
	
	
		
 
        new_usr.active = True

			




	
	
	
		
 
        new_usr.admin = True

			




	
	
	
		
 
        sa.add(new_usr)

			




	
	
	
		
 
        sa.commit()

			




	
	
	
		
 

			




	
	
	
		
 
    print 'done'

			




	
	
	
		
 

			




	
	
	
		
 

			




	
	
	
		
 
def create_test_repo(force=True):

			




	
	
	
		
 
    print 'creating test repo'

			




	
	
	
		
 
    from kallithea.model.repo import RepoModel

			




	
	
	
		
 
    sa = get_session()

			




	
	
	
		
 

			




	
	
	
		
 
    user = sa.query(User).filter(User.username == USER).scalar()

			




	
	
	
		
 
    if user is None:

			




	
	
	
		
 
        raise Exception('user not found')

			




	
	
	
		
 

			




	
	
	
		
 
    repo = sa.query(Repository).filter(Repository.repo_name == HG_REPO).scalar()

			




	
	
	
		
 

			




	
	
	
		
 
    if repo is None:

			




	
	
	
		
 
        print 'repo not found creating'

			




	
	
	
		
 

			




	
	
	
		
 
        form_data = {'repo_name': HG_REPO,

			




	
	
	
		
 
                     'repo_type': 'hg',

			




	
	
	
		
 
                     'private':False,

			




	
	
	
		
 
                     'clone_uri': '' }

			




	
	
	
		
 
        rm = RepoModel(sa)

			




	
	
	
		
 
        rm.base_path = '/home/hg'

			




	
	
	
		
 
        rm.create(form_data, user)

			




	
	
	
		
 

			




	
	
	
		
 
    print 'done'

			




	
	
	
		
 

			




	
	
	
		
 

			




	
	
	
		
 
def set_anonymous_access(enable=True):

			




	
	
	
		
 
    sa = get_session()

			




	
	
	
		
 
    user = sa.query(User).filter(User.username == 'default').one()

			




	
	
	
		
 
    user.active = enable

			




	
	
	
		
 
    sa.add(user)

			




	
	
	
		
 
    sa.commit()

			




	
	
	
		
 

			




	
	
	
		
 

			




	
	
	
		
 
def get_anonymous_access():

			




	
	
	
		
 
    sa = get_session()

			




	
	
	
		
 
    return sa.query(User).filter(User.username == 'default').one().active

			




	
	
	
		
 

			




	
	
	
		
 

			




	
	
	
		
 
#==============================================================================

			




	
	
	
		
 
# TESTS

			




	
	
	
		
 
#==============================================================================

			




	
	
	
		
 
def test_clone_with_credentials(no_errors=False, repo=HG_REPO, method=METHOD,

			




	
	
	
		
 
                                seq=None, backend='hg'):

			




	
	
	
		
 
    cwd = path = jn(TESTS_TMP_PATH, repo)

			




	
	
	
		
 

			




	
	
	
		
 
    if seq is None:

			




	
	
	
		
 
        seq = _RandomNameSequence().next()

			




	
	
	
		
 

			




	
	
	
		
 
    try:

			




	
	
	
		
 
        shutil.rmtree(path, ignore_errors=True)

			




	
	
	
		
 
        os.makedirs(path)

			




	
	
	
		
 
        #print 'made dirs %s' % jn(path)

			




	
	
	
		
 
    except OSError:

			




	
	
	
		
 
        raise

			




	
	
	
		
 

			




	
	
	
		
 
    clone_url = 'http://%(user)s:%(pass)s@%(host)s/%(cloned_repo)s' % \

			




	
	
	
		
 
                  {'user': USER,

			




	
	
	
		
 
                   'pass': PASS,

			




	
	
	
		
 
                   'host': HOST,

			




	
	
	
		
 
                   'cloned_repo': repo, }

			




	
	
	
		
 

			




	
	
	
		
 
    dest = path + seq

			




	
	
	
		
 
    if method == 'pull':

			




	
	
	
		
 
        stdout, stderr = Command(cwd).execute(backend, method, '--cwd', dest, clone_url)

			




	
	
	
		
 
    else:

			




	
	
	
		
 
        stdout, stderr = Command(cwd).execute(backend, method, clone_url, dest)

			




	
	
	
		
 
        print stdout,'sdasdsadsa'

			




	
	
	
		
 
        if not no_errors:

			




	
	
	
		
 
            if backend == 'hg':

			




	
	
	
		
 
                assert """adding file changes""" in stdout, 'no messages about cloning'

			




	
	
	
		
 
                assert """abort""" not in stderr , 'got error from clone'

			




	
	
	
		
 
            elif backend == 'git':

			




	
	
	
		
 
                assert """Cloning into""" in stdout, 'no messages about cloning'

			




	
	
	
		
 

			




	
	
	
		
 
if __name__ == '__main__':

			




	
	
	
		
 
    try:

			




	
	
	
		
 
        create_test_user(force=False)

			




	
	
	
		
 
        seq = None

			




	
	
	
		
 
        import time

			




	
	
	
		
 

			




	
	
	
		
 
        try:

			




	
	
	
		
 
            METHOD = sys.argv[3]

			




	
	
	
		
 
        except IndexError:

			




	
	
	
		
 
            pass

			




	
	
	
		
 

			




	
	
	
		
 
        try:

			




	
	
	
		
 
            backend = sys.argv[4]

			




	
	
	
		
 
        except IndexError:

			




	
	
	
		
 
            backend = 'hg'

			




	
	
	
		
 

			




	
	
	
		
 
        if METHOD == 'pull':

			




	
	
	
		
 
            seq = _RandomNameSequence().next()

			




	
	
	
		
 
            test_clone_with_credentials(repo=sys.argv[1], method='clone',

			




	
	
	
		
 
                                        seq=seq, backend=backend)

			




	
	
	
		
 
        s = time.time()

			




	
	
	
		
 
        for i in range(1, int(sys.argv[2]) + 1):

			




	
	
	
		
 
            print 'take', i

			




	
	
	
		
 
            test_clone_with_credentials(repo=sys.argv[1], method=METHOD,

			




	
	
	
		
 
                                        seq=seq, backend=backend)

			




	
	
	
		
 
        print 'time taken %.3f' % (time.time() - s)

			




	
	
	
		
 
    except Exception as e:

			




	
	
	
		
 
        sys.exit('stop on %s' % e)

			




        

    


    
    

    

        

                

                    kallithea/tests/test.ini
                

                

                  
                      
                        

                      ➞

                      
                        
                  

                  
                      
                  
                      
                  
                      
                  
                      
                  
                  
                

                

                    Show inline comments
                    
                

        

        

            



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

			




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

			




	
	
	
		
 
# Kallithea - config for tests:                                                #

			




	
	
	
		
 
# initial_repo_scan = true                                                     #

			




	
	
	
		
 
# vcs_full_cache = false                                                       #

			




	
	
	
		
 
# sqlalchemy and kallithea_test.sqlite                                         #

			




	
	
	
		
 
# custom logging                                                               #

			




	
	
	
		
 
#                                                                              #

			




	
	
	
		
 
# The %(here)s variable will be replaced with the parent directory of this file#

			




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

			




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

			




	
	
	
		
 

			




	
	
	
		
 
[DEFAULT]

			




	
	
	
		
 
debug = true

			




	
	
	
		
 
pdebug = false

			




	
	
	
		
 

			




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

			




	
	
	
		
 
## Email settings                                                             ##

			




	
	
	
		
 
##                                                                            ##

			




	
	
	
		
 
## Refer to the documentation ("Email settings") for more details.            ##

			




	
	
	
		
 
##                                                                            ##

			




	
	
	
		
 
## It is recommended to use a valid sender address that passes access         ##

			




	
	
	
		
 
## validation and spam filtering in mail servers.                             ##

			




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

			




	
	
	
		
 

			




	
	
	
		
 
## 'From' header for application emails. You can optionally add a name.

			




	
	
	
		
 
## Default:

			




	
	
	
		
 
#app_email_from = Kallithea

			




	
	
	
		
 
## Examples:

			




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

			




	
	
	
		
 
#app_email_from = kallithea-noreply@example.com

			




	
	
	
		
 

			




	
	
	
		
 
## Subject prefix for application emails.

			




	
	
	
		
 
## A space between this prefix and the real subject is automatically added.

			




	
	
	
		
 
## Default:

			




	
	
	
		
 
#email_prefix =

			




	
	
	
		
 
## Example:

			




	
	
	
		
 
#email_prefix = [Kallithea]

			




	
	
	
		
 

			




	
	
	
		
 
## Recipients for error emails and fallback recipients of application mails.

			




	
	
	
		
 
## Multiple addresses can be specified, space-separated.

			




	
	
	
		
 
## Only addresses are allowed, do not add any name part.

			




	
	
	
		
 
## Default:

			




	
	
	
		
 
#email_to =

			




	
	
	
		
 
## Examples:

			




	
	
	
		
 
#email_to = admin@example.com

			




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

			




	
	
	
		
 

			




	
	
	
		
 
## 'From' header for error emails. You can optionally add a name.

			




	
	
	
		
 
## Default:

			




	
	
	
		
 
#error_email_from = pylons@yourapp.com

			




	
	
	
		
 
## Examples:

			




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

			




	
	
	
		
 
#error_email_from = paste_error@example.com

			




	
	
	
		
 

			




	
	
	
		
 
## SMTP server settings

			




	
	
	
		
 
## Only smtp_server is mandatory. All other settings take the specified default

			




	
	
	
		
 
## values.

			




	
	
	
		
 
#smtp_server = mail.server.com

			




	
	
	
		
 
#smtp_server = smtp.example.com

			




	
	
	
		
 
#smtp_username =

			




	
	
	
		
 
#smtp_password =

			




	
	
	
		
 
#smtp_port = 25

			




	
	
	
		
 
#smtp_use_tls = false

			




	
	
	
		
 
#smtp_use_ssl = false

			




	
	
	
		
 
## SMTP authentication parameters to use (e.g. LOGIN PLAIN CRAM-MD5, etc.).

			




	
	
	
		
 
## If empty, use any of the authentication parameters supported by the server.

			




	
	
	
		
 
#smtp_auth =

			




	
	
	
		
 

			




	
	
	
		
 
[server:main]

			




	
	
	
		
 
## PASTE ##

			




	
	
	
		
 
#use = egg:Paste#http

			




	
	
	
		
 
## nr of worker threads to spawn

			




	
	
	
		
 
#threadpool_workers = 5

			




	
	
	
		
 
## max request before thread respawn

			




	
	
	
		
 
#threadpool_max_requests = 10

			




	
	
	
		
 
## option to use threads of process

			




	
	
	
		
 
#use_threadpool = true

			




	
	
	
		
 

			




	
	
	
		
 
## WAITRESS ##

			




	
	
	
		
 
use = egg:waitress#main

			




	
	
	
		
 
## number of worker threads

			




	
	
	
		
 
threads = 5

			




	
	
	
		
 
## MAX BODY SIZE 100GB

			




	
	
	
		
 
max_request_body_size = 107374182400

			




	
	
	
		
 
## use poll instead of select, fixes fd limits, may not work on old

			




	
	
	
		
 
## windows systems.

			




	
	
	
		
 
#asyncore_use_poll = True

			




	
	
	
		
 

			




	
	
	
		
 
## GUNICORN ##

			




	
	
	
		
 
#use = egg:gunicorn#main

			




	
	
	
		
 
## number of process workers. You must set `instance_id = *` when this option

			




	
	
	
		
 
## is set to more than one worker

			




	
	
	
		
 
#workers = 1

			




	
	
	
		
 
## process name

			




	
	
	
		
 
#proc_name = kallithea

			




	
	
	
		
 
## type of worker class, one of sync, eventlet, gevent, tornado

			




	
	
	
		
 
## recommended for bigger setup is using of of other than sync one

			




	
	
	
		
 
#worker_class = sync

			




	
	
	
		
 
#max_requests = 1000

			




	
	
	
		
 
## ammount of time a worker can handle request before it gets killed and

			




	
	
	
		
 
## restarted

			




	
	
	
		
 
#timeout = 3600

			




	
	
	
		
 

			




	
	
	
		
 
## UWSGI ##

			




	
	
	
		
 
## run with uwsgi --ini-paste-logged <inifile.ini>

			




	
	
	
		
 
#[uwsgi]

			




	
	
	
		
 
#socket = /tmp/uwsgi.sock

			




	
	
	
		
 
#master = true

			




	
	
	
		
 
#http = 127.0.0.1:5000

			




	
	
	
		
 

			




	
	
	
		
 
## set as deamon and redirect all output to file

			




	
	
	
		
 
#daemonize = ./uwsgi_kallithea.log

			




	
	
	
		
 

			




	
	
	
		
 
## master process PID

			




	
	
	
		
 
#pidfile = ./uwsgi_kallithea.pid

			




	
	
	
		
 

			




	
	
	
		
 
## stats server with workers statistics, use uwsgitop

			




	
	
	
		
 
## for monitoring, `uwsgitop 127.0.0.1:1717`

			




	
	
	
		
 
#stats = 127.0.0.1:1717

			




	
	
	
		
 
#memory-report = true

			




	
	
	
		
 

			




	
	
	
		
 
## log 5XX errors

			




	
	
	
		
 
#log-5xx = true

			




	
	
	
		
 

			




	
	
	
		
 
## Set the socket listen queue size.

			




	
	
	
		
 
#listen = 256

			




	
	
	
		
 

			




	
	
	
		
 
## Gracefully Reload workers after the specified amount of managed requests

			




	
	
	
		
 
## (avoid memory leaks).

			




	
	
	
		
 
#max-requests = 1000

			




	
	
	
		
 

			




	
	
	
		
 
## enable large buffers

			




	
	
	
		
 
#buffer-size = 65535

			




	
	
	
		
 

			




	
	
	
		
 
## socket and http timeouts ##

			




	
	
	
		
 
#http-timeout = 3600

			




	
	
	
		
 
#socket-timeout = 3600

			




	
	
	
		
 

			




	
	
	
		
 
## Log requests slower than the specified number of milliseconds.

			




	
	
	
		
 
#log-slow = 10

			




	
	
	
		
 

			




	
	
	
		
 
## Exit if no app can be loaded.

			




	
	
	
		
 
#need-app = true

			




	
	
	
		
 

			




	
	
	
		
 
## Set lazy mode (load apps in workers instead of master).

			




	
	
	
		
 
#lazy = true

			




	
	
	
		
 

			




	
	
	
		
 
## scaling ##

			




	
	
	
		
 
## set cheaper algorithm to use, if not set default will be used

			




	
	
	
		
 
#cheaper-algo = spare

			




	
	
	
		
 

			




	
	
	
		
 
## minimum number of workers to keep at all times

			




	
	
	
		
 
#cheaper = 1

			




	
	
	
		
 

			




	
	
	
		
 
## number of workers to spawn at startup

			




	
	
	
		
 
#cheaper-initial = 1

			




	
	
	
		
 

			




	
	
	
		
 
## maximum number of workers that can be spawned

			




	
	
	
		
 
#workers = 4

			




	
	
	
		
 

			




	
	
	
		
 
## how many workers should be spawned at a time

			




	
	
	
		
 
#cheaper-step = 1

			




	
	
	
		
 

			




	
	
	
		
 
## COMMON ##

			




	
	
	
		
 
host = 127.0.0.1

			




	
	
	
		
 
port = 4999

			




	
	
	
		
 

			




	
	
	
		
 
## middleware for hosting the WSGI application under a URL prefix

			




	
	
	
		
 
#[filter:proxy-prefix]

			




	
	
	
		
 
#use = egg:PasteDeploy#prefix

			




	
	
	
		
 
#prefix = /<your-prefix>

			




	
	
	
		
 

			




	
	
	
		
 
[app:main]

			




	
	
	
		
 
use = egg:kallithea

			




	
	
	
		
 
## enable proxy prefix middleware

			




	
	
	
		
 
#filter-with = proxy-prefix

			




	
	
	
		
 

			




	
	
	
		
 
full_stack = true

			




	
	
	
		
 
static_files = true

			




	
	
	
		
 
## Available Languages:

			




	
	
	
		
 
## cs de fr hu ja nl_BE pl pt_BR ru sk zh_CN zh_TW

			




	
	
	
		
 
lang =

			




	
	
	
		
 
cache_dir = %(here)s/data

			




	
	
	
		
 
index_dir = %(here)s/data/index

			




	
	
	
		
 

			




	
	
	
		
 
## perform a full repository scan on each server start, this should be

			




	
	
	
		
 
## set to false after first startup, to allow faster server restarts.

			




	
	
	
		
 
#initial_repo_scan = false

			




	
	
	
		
 
initial_repo_scan = true

			




	
	
	
		
 

			




	
	
	
		
 
## uncomment and set this path to use archive download cache

			




	
	
	
		
 
archive_cache_dir = %(here)s/tarballcache

			




	
	
	
		
 

			




	
	
	
		
 
## change this to unique ID for security

			




	
	
	
		
 
app_instance_uuid = test

			




	
	
	
		
 

			




	
	
	
		
 
## cut off limit for large diffs (size in bytes)

			




	
	
	
		
 
cut_off_limit = 256000

			




	
	
	
		
 

			




	
	
	
		
 
## use cache version of scm repo everywhere

			




	
	
	
		
 
#vcs_full_cache = true

			




	
	
	
		
 
vcs_full_cache = false

			




	
	
	
		
 

			




	
	
	
		
 
## force https in Kallithea, fixes https redirects, assumes it's always https

			




	
	
	
		
 
force_https = false

			




	
	
	
		
 

			




	
	
	
		
 
## use Strict-Transport-Security headers

			




	
	
	
		
 
use_htsts = false

			




	
	
	
		
 

			




	
	
	
		
 
## number of commits stats will parse on each iteration

			




	
	
	
		
 
commit_parse_limit = 25

			




	
	
	
		
 

			




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

			




	
	
	
		
 

			




	
	
	
		
 
## options for showing and identifying changesets

			




	
	
	
		
 
show_sha_length = 12

			




	
	
	
		
 
show_revision_number = true

			




	
	
	
		
 

			




	
	
	
		
 
## gist URL alias, used to create nicer urls for gist. This should be an

			




	
	
	
		
 
## url that does rewrites to _admin/gists/<gistid>.

			




	
	
	
		
 
## example: http://gist.kallithea.server/{gistid}. Empty means use the internal

			




	
	
	
		
 
## Kallithea url, ie. http[s]://your.kallithea.server/_admin/gists/<gistid>

			




	
	
	
		
 
## example: http://gist.example.com/{gistid}. Empty means use the internal

			




	
	
	
		
 
## Kallithea url, ie. http[s]://kallithea.example.com/_admin/gists/<gistid>

			




	
	
	
		
 
gist_alias_url =

			




	
	
	
		
 

			




	
	
	
		
 
## white list of API enabled controllers. This allows to add list of

			




	
	
	
		
 
## controllers to which access will be enabled by api_key. eg: to enable

			




	
	
	
		
 
## api access to raw_files put `FilesController:raw`, to enable access to patches

			




	
	
	
		
 
## add `ChangesetController:changeset_patch`. This list should be "," separated

			




	
	
	
		
 
## Syntax is <ControllerClass>:<function>. Check debug logs for generated names

			




	
	
	
		
 
## Recommended settings below are commented out:

			




	
	
	
		
 
api_access_controllers_whitelist =

			




	
	
	
		
 
#    ChangesetController:changeset_patch,

			




	
	
	
		
 
#    ChangesetController:changeset_raw,

			




	
	
	
		
 
#    FilesController:raw,

			




	
	
	
		
 
#    FilesController:archivefile

			




	
	
	
		
 

			




	
	
	
		
 
## default encoding used to convert from and to unicode

			




	
	
	
		
 
## can be also a comma seperated list of encoding in case of mixed encodings

			




	
	
	
		
 
default_encoding = utf8

			




	
	
	
		
 

			




	
	
	
		
 
## issue tracker for Kallithea (leave blank to disable, absent for default)

			




	
	
	
		
 
#bugtracker = https://bitbucket.org/conservancy/kallithea/issues

			




	
	
	
		
 

			




	
	
	
		
 
## issue tracking mapping for commits messages

			




	
	
	
		
 
## comment out issue_pat, issue_server, issue_prefix to enable

			




	
	
	
		
 

			




	
	
	
		
 
## pattern to get the issues from commit messages

			




	
	
	
		
 
## default one used here is #<numbers> with a regex passive group for `#`

			




	
	
	
		
 
## {id} will be all groups matched from this pattern

			




	
	
	
		
 

			




	
	
	
		
 
issue_pat = (?:\s*#)(\d+)

			




	
	
	
		
 

			




	
	
	
		
 
## server url to the issue, each {id} will be replaced with match

			




	
	
	
		
 
## fetched from the regex and {repo} is replaced with full repository name

			




	
	
	
		
 
## including groups {repo_name} is replaced with just name of repo

			




	
	
	
		
 

			




	
	
	
		
 
issue_server_link = https://myissueserver.com/{repo}/issue/{id}

			




	
	
	
		
 
issue_server_link = https://issues.example.com/{repo}/issue/{id}

			




	
	
	
		
 

			




	
	
	
		
 
## prefix to add to link to indicate it's an url

			




	
	
	
		
 
## #314 will be replaced by <issue_prefix><id>

			




	
	
	
		
 

			




	
	
	
		
 
issue_prefix = #

			




	
	
	
		
 

			




	
	
	
		
 
## issue_pat, issue_server_link, issue_prefix can have suffixes to specify

			




	
	
	
		
 
## multiple patterns, to other issues server, wiki or others

			




	
	
	
		
 
## below an example how to create a wiki pattern

			




	
	
	
		
 
# wiki-some-id -> https://mywiki.com/some-id

			




	
	
	
		
 
# wiki-some-id -> https://wiki.example.com/some-id

			




	
	
	
		
 

			




	
	
	
		
 
#issue_pat_wiki = (?:wiki-)(.+)

			




	
	
	
		
 
#issue_server_link_wiki = https://mywiki.com/{id}

			




	
	
	
		
 
#issue_server_link_wiki = https://wiki.example.com/{id}

			




	
	
	
		
 
#issue_prefix_wiki = WIKI-

			




	
	
	
		
 

			




	
	
	
		
 
## instance-id prefix

			




	
	
	
		
 
## a prefix key for this instance used for cache invalidation when running

			




	
	
	
		
 
## multiple instances of kallithea, make sure it's globally unique for

			




	
	
	
		
 
## all running kallithea instances. Leave empty if you don't use it

			




	
	
	
		
 
instance_id =

			




	
	
	
		
 

			




	
	
	
		
 
## alternative return HTTP header for failed authentication. Default HTTP

			




	
	
	
		
 
## response is 401 HTTPUnauthorized. Currently Mercurial clients have trouble with

			




	
	
	
		
 
## handling that. Set this variable to 403 to return HTTPForbidden

			




	
	
	
		
 
auth_ret_code =

			




	
	
	
		
 

			




	
	
	
		
 
## locking return code. When repository is locked return this HTTP code. 2XX

			




	
	
	
		
 
## codes don't break the transactions while 4XX codes do

			




	
	
	
		
 
lock_ret_code = 423

			




	
	
	
		
 

			




	
	
	
		
 
## allows to change the repository location in settings page

			




	
	
	
		
 
allow_repo_location_change = True

			




	
	
	
		
 

			




	
	
	
		
 
## allows to setup custom hooks in settings page

			




	
	
	
		
 
allow_custom_hooks_settings = True

			




	
	
	
		
 

			




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

			




	
	
	
		
 
###        CELERY CONFIG        ####

			




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

			




	
	
	
		
 

			




	
	
	
		
 
use_celery = false

			




	
	
	
		
 
broker.host = localhost

			




	
	
	
		
 
broker.vhost = rabbitmqhost

			




	
	
	
		
 
broker.port = 5672

			




	
	
	
		
 
broker.user = rabbitmq

			




	
	
	
		
 
broker.password = qweqwe

			




	
	
	
		
 

			




	
	
	
		
 
celery.imports = kallithea.lib.celerylib.tasks

			




	
	
	
		
 

			




	
	
	
		
 
celery.result.backend = amqp

			




	
	
	
		
 
celery.result.dburi = amqp://

			




	
	
	
		
 
celery.result.serialier = json

			




	
	
	
		
 

			




	
	
	
		
 
#celery.send.task.error.emails = true

			




	
	
	
		
 
#celery.amqp.task.result.expires = 18000

			




	
	
	
		
 

			




	
	
	
		
 
celeryd.concurrency = 2

			




	
	
	
		
 
#celeryd.log.file = celeryd.log

			




	
	
	
		
 
celeryd.log.level = DEBUG

			




	
	
	
		
 
celeryd.max.tasks.per.child = 1

			




	
	
	
		
 

			




	
	
	
		
 
## tasks will never be sent to the queue, but executed locally instead.

			




	
	
	
		
 
celery.always.eager = false

			




	
	
	
		
 

			




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

			




	
	
	
		
 
###         BEAKER CACHE        ####

			




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

			




	
	
	
		
 

			




	
	
	
		
 
beaker.cache.data_dir = %(here)s/data/cache/data

			




	
	
	
		
 
beaker.cache.lock_dir = %(here)s/data/cache/lock

			




	
	
	
		
 

			




	
	
	
		
 
beaker.cache.regions = short_term,long_term,sql_cache_short

			




	
	
	
		
 

			




	
	
	
		
 
beaker.cache.short_term.type = memory

			




	
	
	
		
 
beaker.cache.short_term.expire = 60

			




	
	
	
		
 
beaker.cache.short_term.key_length = 256

			




	
	
	
		
 

			




	
	
	
		
 
beaker.cache.long_term.type = memory

			




	
	
	
		
 
beaker.cache.long_term.expire = 36000

			




	
	
	
		
 
beaker.cache.long_term.key_length = 256

			




	
	
	
		
 

			




	
	
	
		
 
beaker.cache.sql_cache_short.type = memory

			




	
	
	
		
 
beaker.cache.sql_cache_short.expire = 1

			




	
	
	
		
 
beaker.cache.sql_cache_short.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.

			




	
	
	
		
 
beaker.session.key = kallithea

			




	
	
	
		
 
## Sessions should always only be accessible by the browser, not directly by JavaScript.

			




	
	
	
		
 
beaker.session.httponly = true

			




	
	
	
		
 
## Session lifetime. 2592000 seconds is 30 days.

			




	
	
	
		
 
beaker.session.timeout = 2592000

			




	
	
	
		
 

			




	
	
	
		
 
## Server secret used with HMAC to ensure integrity of cookies.

			




	
	
	
		
 
beaker.session.secret = {74e0cd75-b339-478b-b129-07dd221def1f}

			




	
	
	
		
 
## Further, encrypt the data with AES.

			




	
	
	
		
 
#beaker.session.encrypt_key = <key_for_encryption>

			




	
	
	
		
 
#beaker.session.validate_key = <validation_key>

			




	
	
	
		
 

			




	
	
	
		
 
## Type of storage used for the session, current types are

			




	
	
	
		
 
## dbm, file, memcached, database, and memory.

			




	
	
	
		
 

			




	
	
	
		
 
## File system storage of session data. (default)

			




	
	
	
		
 
#beaker.session.type = file

			




	
	
	
		
 

			




	
	
	
		
 
## Cookie only, store all session data inside the cookie. Requires secure secrets.

			




	
	
	
		
 
#beaker.session.type = cookie

			




	
	
	
		
 

			




	
	
	
		
 
## Database storage of session data.

			




	
	
	
		
 
#beaker.session.type = ext:database

			




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

			




	
	
	
		
 
#beaker.session.table_name = db_session

			




	
	
	
		
 

			




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

			




	
	
	
		
 
## ERROR HANDLING SYSTEMS ##

			




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

			




	
	
	
		
 

			




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

			




	
	
	
		
 
### [errormator] ###

			




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

			




	
	
	
		
 

			




	
	
	
		
 
## Errormator is tailored to work with Kallithea, see

			




	
	
	
		
 
## http://errormator.com for details how to obtain an account

			




	
	
	
		
 
## you must install python package `errormator_client` to make it work

			




	
	
	
		
 

			




	
	
	
		
 
## errormator enabled

			




	
	
	
		
 
errormator = false

			




	
	
	
		
 

			




	
	
	
		
 
errormator.server_url = https://api.errormator.com

			




	
	
	
		
 
errormator.api_key = YOUR_API_KEY

			




	
	
	
		
 

			




	
	
	
		
 
## TWEAK AMOUNT OF INFO SENT HERE

			




	
	
	
		
 

			




	
	
	
		
 
## enables 404 error logging (default False)

			




	
	
	
		
 
errormator.report_404 = false

			




	
	
	
		
 

			




	
	
	
		
 
## time in seconds after request is considered being slow (default 1)

			




	
	
	
		
 
errormator.slow_request_time = 1

			




	
	
	
		
 

			




	
	
	
		
 
## record slow requests in application

			




	
	
	
		
 
## (needs to be enabled for slow datastore recording and time tracking)

			




	
	
	
		
 
errormator.slow_requests = true

			




	
	
	
		
 

			




	
	
	
		
 
## enable hooking to application loggers

			




	
	
	
		
 
#errormator.logging = true

			




	
	
	
		
 

			




	
	
	
		
 
## minimum log level for log capture

			




	
	
	
		
 
#errormator.logging.level = WARNING

			




	
	
	
		
 

			




	
	
	
		
 
## send logs only from erroneous/slow requests

			




	
	
	
		
 
## (saves API quota for intensive logging)

			




	
	
	
		
 
errormator.logging_on_error = false

			




	
	
	
		
 

			




	
	
	
		
 
## list of additonal keywords that should be grabbed from environ object

			




	
	
	
		
 
## can be string with comma separated list of words in lowercase

			




	
	
	
		
 
## (by default client will always send following info:

			




	
	
	
		
 
## 'REMOTE_USER', 'REMOTE_ADDR', 'SERVER_NAME', 'CONTENT_TYPE' + all keys that

			




	
	
	
		
 
## start with HTTP* this list be extended with additional keywords here

			




	
	
	
		
 
errormator.environ_keys_whitelist =

			




	
	
	
		
 

			




	
	
	
		
 
## list of keywords that should be blanked from request object

			




	
	
	
		
 
## can be string with comma separated list of words in lowercase

			




	
	
	
		
 
## (by default client will always blank keys that contain following words

			




	
	
	
		
 
## 'password', 'passwd', 'pwd', 'auth_tkt', 'secret', 'csrf'

			




	
	
	
		
 
## this list be extended with additional keywords set here

			




	
	
	
		
 
errormator.request_keys_blacklist =

			




	
	
	
		
 

			




	
	
	
		
 
## list of namespaces that should be ignores when gathering log entries

			




	
	
	
		
 
## can be string with comma separated list of namespaces

			




	
	
	
		
 
## (by default the client ignores own entries: errormator_client.client)

			




	
	
	
		
 
errormator.log_namespace_blacklist =

			




	
	
	
		
 

			




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

			




	
	
	
		
 
### [sentry] ###

			




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

			




	
	
	
		
 

			




	
	
	
		
 
## sentry is a alternative open source error aggregator

			




	
	
	
		
 
## you must install python packages `sentry` and `raven` to enable

			




	
	
	
		
 

			




	
	
	
		
 
sentry.dsn = YOUR_DNS

			




	
	
	
		
 
sentry.servers =

			




	
	
	
		
 
sentry.name =

			




	
	
	
		
 
sentry.key =

			




	
	
	
		
 
sentry.public_key =

			




	
	
	
		
 
sentry.secret_key =

			




	
	
	
		
 
sentry.project =

			




	
	
	
		
 
sentry.site =

			




	
	
	
		
 
sentry.include_paths =

			




	
	
	
		
 
sentry.exclude_paths =

			




	
	
	
		
 

			




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

			




	
	
	
		
 
## WARNING: *THE LINE BELOW MUST BE UNCOMMENTED ON A PRODUCTION ENVIRONMENT*  ##

			




	
	
	
		
 
## Debug mode will enable the interactive debugging tool, allowing ANYONE to  ##

			




	
	
	
		
 
## execute malicious code after an exception is raised.                       ##

			




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

			




	
	
	
		
 
set debug = false

			




	
	
	
		
 

			




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

			




	
	
	
		
 
###       LOGVIEW CONFIG       ###

			




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

			




	
	
	
		
 

			




        

    


    
    

    

        

                

                    kallithea/tests/vcs/test_utils.py
                

                

                  
                      
                        

                      ➞

                      
                        
                  

                  
                      
                  
                      
                  
                      
                  
                      
                  
                  
                

                

                    Show inline comments
                    
                

        

        

            



	
	
	
		
 

			




	
	
	
		
 
import os

			




	
	
	
		
 
import mock

			




	
	
	
		
 
import time

			




	
	
	
		
 
import shutil

			




	
	
	
		
 
import tempfile

			




	
	
	
		
 
import datetime

			




	
	
	
		
 
from kallithea.lib.vcs.utils.compat import unittest

			




	
	
	
		
 
from kallithea.lib.vcs.utils.paths import get_dirs_for_path

			




	
	
	
		
 
from kallithea.lib.vcs.utils.helpers import get_dict_for_attrs

			




	
	
	
		
 
from kallithea.lib.vcs.utils.helpers import get_scm

			




	
	
	
		
 
from kallithea.lib.vcs.utils.helpers import get_scms_for_path

			




	
	
	
		
 
from kallithea.lib.vcs.utils.helpers import get_total_seconds

			




	
	
	
		
 
from kallithea.lib.vcs.utils.helpers import parse_changesets

			




	
	
	
		
 
from kallithea.lib.vcs.utils.helpers import parse_datetime

			




	
	
	
		
 
from kallithea.lib.vcs.utils import author_email, author_name

			




	
	
	
		
 
from kallithea.lib.vcs.utils.paths import get_user_home

			




	
	
	
		
 
from kallithea.lib.vcs.exceptions import VCSError

			




	
	
	
		
 

			




	
	
	
		
 
from kallithea.tests.vcs.conf import TEST_HG_REPO, TEST_GIT_REPO, TEST_TMP_PATH

			




	
	
	
		
 

			




	
	
	
		
 

			




	
	
	
		
 
class PathsTest(unittest.TestCase):

			




	
	
	
		
 

			




	
	
	
		
 
    def _test_get_dirs_for_path(self, path, expected):

			




	
	
	
		
 
        """

			




	
	
	
		
 
        Tests if get_dirs_for_path returns same as expected.

			




	
	
	
		
 
        """

			




	
	
	
		
 
        expected = sorted(expected)

			




	
	
	
		
 
        result = sorted(get_dirs_for_path(path))

			




	
	
	
		
 
        self.assertEqual(result, expected,

			




	
	
	
		
 
            msg="%s != %s which was expected result for path %s"

			




	
	
	
		
 
            % (result, expected, path))

			




	
	
	
		
 

			




	
	
	
		
 
    def test_get_dirs_for_path(self):

			




	
	
	
		
 
        path = 'foo/bar/baz/file'

			




	
	
	
		
 
        paths_and_results = (

			




	
	
	
		
 
            ('foo/bar/baz/file', ['foo', 'foo/bar', 'foo/bar/baz']),

			




	
	
	
		
 
            ('foo/bar/', ['foo', 'foo/bar']),

			




	
	
	
		
 
            ('foo/bar', ['foo']),

			




	
	
	
		
 
        )

			




	
	
	
		
 
        for path, expected in paths_and_results:

			




	
	
	
		
 
            self._test_get_dirs_for_path(path, expected)

			




	
	
	
		
 

			




	
	
	
		
 

			




	
	
	
		
 
    def test_get_scm(self):

			




	
	
	
		
 
        self.assertEqual(('hg', TEST_HG_REPO), get_scm(TEST_HG_REPO))

			




	
	
	
		
 
        self.assertEqual(('git', TEST_GIT_REPO), get_scm(TEST_GIT_REPO))

			




	
	
	
		
 

			




	
	
	
		
 
    def test_get_two_scms_for_path(self):

			




	
	
	
		
 
        multialias_repo_path = os.path.join(TEST_TMP_PATH, 'hg-git-repo-2')

			




	
	
	
		
 
        if os.path.isdir(multialias_repo_path):

			




	
	
	
		
 
            shutil.rmtree(multialias_repo_path)

			




	
	
	
		
 

			




	
	
	
		
 
        os.mkdir(multialias_repo_path)

			




	
	
	
		
 

			




	
	
	
		
 
        self.assertRaises(VCSError, get_scm, multialias_repo_path)

			




	
	
	
		
 

			




	
	
	
		
 
    def test_get_scm_error_path(self):

			




	
	
	
		
 
        self.assertRaises(VCSError, get_scm, 'err')

			




	
	
	
		
 

			




	
	
	
		
 
    def test_get_scms_for_path(self):

			




	
	
	
		
 
        dirpath = tempfile.gettempdir()

			




	
	
	
		
 
        new = os.path.join(dirpath, 'vcs-scms-for-path-%s' % time.time())

			




	
	
	
		
 
        os.mkdir(new)

			




	
	
	
		
 
        self.assertEqual(get_scms_for_path(new), [])

			




	
	
	
		
 

			




	
	
	
		
 
        os.mkdir(os.path.join(new, '.tux'))

			




	
	
	
		
 
        self.assertEqual(get_scms_for_path(new), [])

			




	
	
	
		
 

			




	
	
	
		
 
        os.mkdir(os.path.join(new, '.git'))

			




	
	
	
		
 
        self.assertEqual(set(get_scms_for_path(new)), set(['git']))

			




	
	
	
		
 

			




	
	
	
		
 
        os.mkdir(os.path.join(new, '.hg'))

			




	
	
	
		
 
        self.assertEqual(set(get_scms_for_path(new)), set(['git', 'hg']))

			




	
	
	
		
 

			




	
	
	
		
 

			




	
	
	
		
 
class TestParseChangesets(unittest.TestCase):

			




	
	
	
		
 

			




	
	
	
		
 
    def test_main_is_returned_correctly(self):

			




	
	
	
		
 
        self.assertEqual(parse_changesets('123456'), {

			




	
	
	
		
 
            'start': None,

			




	
	
	
		
 
            'main': '123456',

			




	
	
	
		
 
            'end': None,

			




	
	
	
		
 
        })

			




	
	
	
		
 

			




	
	
	
		
 
    def test_start_is_returned_correctly(self):

			




	
	
	
		
 
        self.assertEqual(parse_changesets('aaabbb..'), {

			




	
	
	
		
 
            'start': 'aaabbb',

			




	
	
	
		
 
            'main': None,

			




	
	
	
		
 
            'end': None,

			




	
	
	
		
 
        })

			




	
	
	
		
 

			




	
	
	
		
 
    def test_end_is_returned_correctly(self):

			




	
	
	
		
 
        self.assertEqual(parse_changesets('..cccddd'), {

			




	
	
	
		
 
            'start': None,

			




	
	
	
		
 
            'main': None,

			




	
	
	
		
 
            'end': 'cccddd',

			




	
	
	
		
 
        })

			




	
	
	
		
 

			




	
	
	
		
 
    def test_that_two_or_three_dots_are_allowed(self):

			




	
	
	
		
 
        text1 = 'a..b'

			




	
	
	
		
 
        text2 = 'a...b'

			




	
	
	
		
 
        self.assertEqual(parse_changesets(text1), parse_changesets(text2))

			




	
	
	
		
 

			




	
	
	
		
 
    def test_that_input_is_stripped_first(self):

			




	
	
	
		
 
        text1 = 'a..bb'

			




	
	
	
		
 
        text2 = '  a..bb\t\n\t '

			




	
	
	
		
 
        self.assertEqual(parse_changesets(text1), parse_changesets(text2))

			




	
	
	
		
 

			




	
	
	
		
 
    def test_that_exception_is_raised(self):

			




	
	
	
		
 
        text = '123456.789012' # single dot is not recognized

			




	
	
	
		
 
        with self.assertRaises(ValueError):

			




	
	
	
		
 
            parse_changesets(text)

			




	
	
	
		
 

			




	
	
	
		
 
    def test_non_alphanumeric_raises_exception(self):

			




	
	
	
		
 
        with self.assertRaises(ValueError):

			




	
	
	
		
 
            parse_changesets('aaa@bbb')

			




	
	
	
		
 

			




	
	
	
		
 

			




	
	
	
		
 
class TestParseDatetime(unittest.TestCase):

			




	
	
	
		
 

			




	
	
	
		
 
    def test_datetime_text(self):

			




	
	
	
		
 
        self.assertEqual(parse_datetime('2010-04-07 21:29:41'),

			




	
	
	
		
 
            datetime.datetime(2010, 4, 7, 21, 29, 41))

			




	
	
	
		
 

			




	
	
	
		
 
    def test_no_seconds(self):

			




	
	
	
		
 
        self.assertEqual(parse_datetime('2010-04-07 21:29'),

			




	
	
	
		
 
            datetime.datetime(2010, 4, 7, 21, 29))

			




	
	
	
		
 

			




	
	
	
		
 
    def test_date_only(self):

			




	
	
	
		
 
        self.assertEqual(parse_datetime('2010-04-07'),

			




	
	
	
		
 
            datetime.datetime(2010, 4, 7))

			




	
	
	
		
 

			




	
	
	
		
 
    def test_another_format(self):

			




	
	
	
		
 
        self.assertEqual(parse_datetime('04/07/10 21:29:41'),

			




	
	
	
		
 
            datetime.datetime(2010, 4, 7, 21, 29, 41))

			




	
	
	
		
 

			




	
	
	
		
 
    def test_now(self):

			




	
	
	
		
 
        self.assertTrue(parse_datetime('now') - datetime.datetime.now() <

			




	
	
	
		
 
            datetime.timedelta(seconds=1))

			




	
	
	
		
 

			




	
	
	
		
 
    def test_today(self):

			




	
	
	
		
 
        today = datetime.date.today()

			




	
	
	
		
 
        self.assertEqual(parse_datetime('today'),

			




	
	
	
		
 
            datetime.datetime(*today.timetuple()[:3]))

			




	
	
	
		
 

			




	
	
	
		
 
    def test_yesterday(self):

			




	
	
	
		
 
        yesterday = datetime.date.today() - datetime.timedelta(days=1)

			




	
	
	
		
 
        self.assertEqual(parse_datetime('yesterday'),

			




	
	
	
		
 
            datetime.datetime(*yesterday.timetuple()[:3]))

			




	
	
	
		
 

			




	
	
	
		
 
    def test_tomorrow(self):

			




	
	
	
		
 
        tomorrow = datetime.date.today() + datetime.timedelta(days=1)

			




	
	
	
		
 
        args = tomorrow.timetuple()[:3] + (23, 59, 59)

			




	
	
	
		
 
        self.assertEqual(parse_datetime('tomorrow'), datetime.datetime(*args))

			




	
	
	
		
 

			




	
	
	
		
 
    def test_days(self):

			




	
	
	
		
 
        timestamp = datetime.datetime.today() - datetime.timedelta(days=3)

			




	
	
	
		
 
        args = timestamp.timetuple()[:3] + (0, 0, 0, 0)

			




	
	
	
		
 
        expected = datetime.datetime(*args)

			




	
	
	
		
 
        self.assertEqual(parse_datetime('3d'), expected)

			




	
	
	
		
 
        self.assertEqual(parse_datetime('3 d'), expected)

			




	
	
	
		
 
        self.assertEqual(parse_datetime('3 day'), expected)

			




	
	
	
		
 
        self.assertEqual(parse_datetime('3 days'), expected)

			




	
	
	
		
 

			




	
	
	
		
 
    def test_weeks(self):

			




	
	
	
		
 
        timestamp = datetime.datetime.today() - datetime.timedelta(days=3 * 7)

			




	
	
	
		
 
        args = timestamp.timetuple()[:3] + (0, 0, 0, 0)

			




	
	
	
		
 
        expected = datetime.datetime(*args)

			




	
	
	
		
 
        self.assertEqual(parse_datetime('3w'), expected)

			




	
	
	
		
 
        self.assertEqual(parse_datetime('3 w'), expected)

			




	
	
	
		
 
        self.assertEqual(parse_datetime('3 week'), expected)

			




	
	
	
		
 
        self.assertEqual(parse_datetime('3 weeks'), expected)

			




	
	
	
		
 

			




	
	
	
		
 
    def test_mixed(self):

			




	
	
	
		
 
        timestamp = datetime.datetime.today() - datetime.timedelta(days=2 * 7 + 3)

			




	
	
	
		
 
        args = timestamp.timetuple()[:3] + (0, 0, 0, 0)

			




	
	
	
		
 
        expected = datetime.datetime(*args)

			




	
	
	
		
 
        self.assertEqual(parse_datetime('2w3d'), expected)

			




	
	
	
		
 
        self.assertEqual(parse_datetime('2w 3d'), expected)

			




	
	
	
		
 
        self.assertEqual(parse_datetime('2w 3 days'), expected)

			




	
	
	
		
 
        self.assertEqual(parse_datetime('2 weeks 3 days'), expected)

			




	
	
	
		
 

			




	
	
	
		
 

			




	
	
	
		
 
class TestAuthorExtractors(unittest.TestCase):

			




	
	
	
		
 
    TEST_AUTHORS = [("Username Last'o'Name <username@python-works.com>",

			




	
	
	
		
 
                    ("Username Last'o'Name", "username@python-works.com")),

			




	
	
	
		
 
                  ("Username Last'o'Name Spaces < username@python-works.com >",

			




	
	
	
		
 
                    ("Username Last'o'Name Spaces", "username@python-works.com")),

			




	
	
	
		
 
                  ("Username Last'o'Name <username.lastname@python-works.com>",

			




	
	
	
		
 
                    ("Username Last'o'Name", "username.lastname@python-works.com")),

			




	
	
	
		
 
                  ('mrf RFC_SPEC <username+lastname@python-works.com>',

			




	
	
	
		
 
                    ('mrf RFC_SPEC', 'username+lastname@python-works.com')),

			




	
	
	
		
 
                  ('username <user@email.com>',

			




	
	
	
		
 
                    ('username', 'user@email.com')),

			




	
	
	
		
 
                  ('username <user@email.com',

			




	
	
	
		
 
                   ('username', 'user@email.com')),

			




	
	
	
		
 
                  ('broken missing@email.com',

			




	
	
	
		
 
                   ('broken', 'missing@email.com')),

			




	
	
	
		
 
                  ('<justemail@mail.com>',

			




	
	
	
		
 
                   ('', 'justemail@mail.com')),

			




	
	
	
		
 
    TEST_AUTHORS = [("Username Last'o'Name <username@example.com>",

			




	
	
	
		
 
                    ("Username Last'o'Name", "username@example.com")),

			




	
	
	
		
 
                  ("Username Last'o'Name Spaces < username@example.com >",

			




	
	
	
		
 
                    ("Username Last'o'Name Spaces", "username@example.com")),

			




	
	
	
		
 
                  ("Username Last'o'Name <username.lastname@example.com>",

			




	
	
	
		
 
                    ("Username Last'o'Name", "username.lastname@example.com")),

			




	
	
	
		
 
                  ('mrf RFC_SPEC <username+lastname@example.com>',

			




	
	
	
		
 
                    ('mrf RFC_SPEC', 'username+lastname@example.com')),

			




	
	
	
		
 
                  ('username <user@example.com>',

			




	
	
	
		
 
                    ('username', 'user@example.com')),

			




	
	
	
		
 
                  ('username <user@example.com',

			




	
	
	
		
 
                   ('username', 'user@example.com')),

			




	
	
	
		
 
                  ('broken missing@example.com',

			




	
	
	
		
 
                   ('broken', 'missing@example.com')),

			




	
	
	
		
 
                  ('<justemail@example.com>',

			




	
	
	
		
 
                   ('', 'justemail@example.com')),

			




	
	
	
		
 
                  ('justname',

			




	
	
	
		
 
                   ('justname', '')),

			




	
	
	
		
 
                  ('Mr Double Name withemail@email.com ',

			




	
	
	
		
 
                   ('Mr Double Name', 'withemail@email.com')),

			




	
	
	
		
 
                  ('Mr Double Name withemail@example.com ',

			




	
	
	
		
 
                   ('Mr Double Name', 'withemail@example.com')),

			




	
	
	
		
 
                  ]

			




	
	
	
		
 

			




	
	
	
		
 
    def test_author_email(self):

			




	
	
	
		
 

			




	
	
	
		
 
        for test_str, result in self.TEST_AUTHORS:

			




	
	
	
		
 
            self.assertEqual(result[1], author_email(test_str))

			




	
	
	
		
 

			




	
	
	
		
 

			




	
	
	
		
 
    def test_author_name(self):

			




	
	
	
		
 

			




	
	
	
		
 
        for test_str, result in self.TEST_AUTHORS:

			




	
	
	
		
 
            self.assertEqual(result[0], author_name(test_str))

			




	
	
	
		
 

			




	
	
	
		
 

			




	
	
	
		
 
class TestGetDictForAttrs(unittest.TestCase):

			




	
	
	
		
 

			




	
	
	
		
 
    def test_returned_dict_has_expected_attrs(self):

			




	
	
	
		
 
        obj = mock.Mock()

			




	
	
	
		
 
        obj.NOT_INCLUDED = 'this key/value should not be included'

			




	
	
	
		
 
        obj.CONST = True

			




	
	
	
		
 
        obj.foo = 'aaa'

			




	
	
	
		
 
        obj.attrs = {'foo': 'bar'}

			




	
	
	
		
 
        obj.date = datetime.datetime(2010, 12, 31)

			




	
	
	
		
 
        obj.count = 1001

			




	
	
	
		
 

			




	
	
	
		
 
        self.assertEqual(get_dict_for_attrs(obj, ['CONST', 'foo', 'attrs',

			




	
	
	
		
 
            'date', 'count']), {

			




	
	
	
		
 
            'CONST': True,

			




	
	
	
		
 
            'foo': 'aaa',

			




	
	
	
		
 
            'attrs': {'foo': 'bar'},

			




	
	
	
		
 
            'date': datetime.datetime(2010, 12, 31),

			




	
	
	
		
 
            'count': 1001,

			




	
	
	
		
 
        })

			




	
	
	
		
 

			




	
	
	
		
 

			




	
	
	
		
 
class TestGetTotalSeconds(unittest.TestCase):

			




	
	
	
		
 

			




	
	
	
		
 
    def assertTotalSecondsEqual(self, timedelta, expected_seconds):

			




	
	
	
		
 
        result = get_total_seconds(timedelta)

			




	
	
	
		
 
        self.assertEqual(result, expected_seconds,

			




	
	
	
		
 
            "We computed %s seconds for %s but expected %s"

			




	
	
	
		
 
            % (result, timedelta, expected_seconds))

			




	
	
	
		
 

			




	
	
	
		
 
    def test_get_total_seconds_returns_proper_value(self):

			




	
	
	
		
 
        self.assertTotalSecondsEqual(datetime.timedelta(seconds=1001), 1001)

			




	
	
	
		
 

			




	
	
	
		
 
    def test_get_total_seconds_returns_proper_value_for_partial_seconds(self):

			




	
	
	
		
 
        self.assertTotalSecondsEqual(datetime.timedelta(seconds=50.65), 50.65)

			




	
	
	
		
 

			




	
	
	
		
 

			




	
	
	
		
 
class TestGetUserHome(unittest.TestCase):

			




	
	
	
		
 

			




	
	
	
		
 
    @mock.patch.object(os, 'environ', {})

			




	
	
	
		
 
    def test_defaults_to_none(self):

			




	
	
	
		
 
        self.assertEqual(get_user_home(), '')

			




	
	
	
		
 

			




	
	
	
		
 
    @mock.patch.object(os, 'environ', {'HOME': '/home/foobar'})

			




	
	
	
		
 
    def test_unix_like(self):

			




	
	
	
		
 
        self.assertEqual(get_user_home(), '/home/foobar')

			




	
	
	
		
 

			




	
	
	
		
 
    @mock.patch.object(os, 'environ', {'USERPROFILE': '/Users/foobar'})

			




	
	
	
		
 
    def test_windows_like(self):

			




	
	
	
		
 
        self.assertEqual(get_user_home(), '/Users/foobar')

			




	
	
	
		
 

			




	
	
	
		
 
    @mock.patch.object(os, 'environ', {'HOME': '/home/foobar',

			




	
	
	
		
 
        'USERPROFILE': '/Users/foobar'})

			




	
	
	
		
 
    def test_prefers_home_over_userprofile(self):

			




	
	
	
		
 
        self.assertEqual(get_user_home(), '/home/foobar')

			




	
	
	
		
 

			




	
	
	
		
 

			




	
	
	
		
 
if __name__ == '__main__':

			




	
	
	
		
 
    unittest.main()

			




        

    



    


    



    



      

      





    
    0 comments (0 inline, 0 general)
    





    


  

  







  


    




    








    
        
    
    
        This site is powered by
            Kallithea 0.7.0,
        which is
        © 2010–2025 by various authors & licensed under GPLv3.