Changeset - 1bafb2d07709
Parent rev.
Child rev.
[Not reviewed]
stable
0 3 0
Thomas De Schampheleire - 7 years ago 2019-04-08 21:32:57
thomas.de_schampheleire@nokia.com
hooks: make the Python interpreter for Git hooks configurable as 'git_hook_interpreter' (Issue #333)

Commit 5e501b6ee639 introduced the use of 'sys.executable' as interpreter
for git hooks instead of 'python2' with the following argument:

"Windows doesn't necessarily have "python2" available in $PATH, but we
still want to make sure we don't end up invoking a python3. Using the
absolute path seems more safe."

But, sys.executable does not necessarily point to Python. When Kallithea is
started under uWSGI, sys.executable points to the uwsgi executable. As a
result, the interpreter encoded in the git hooks on the server repositories
would be:

#!/path/to/uwsgi

And pushing to such repo would result in following client errors:

$ git push
Password for 'http://user@localhost:5050':
Enumerating objects: 3, done.
Counting objects: 100% (3/3), done.
Writing objects: 100% (3/3), 241 bytes | 241.00 KiB/s, done.
Total 3 (delta 0), reused 0 (delta 0)
remote: unable to load configuration from hooks/pre-receive
To http://localhost:5050/gitrepo-new
! [remote rejected] master -> master (pre-receive hook declined)
error: failed to push some refs to 'http://user@localhost:5050/gitrepo-new'

Fix this problem by introducing a configuration setting 'git_hook_interpreter'
that allow administrators to specify which Python interpreter to use.

A subsequent commit will cause its value to be filled in automatically when
generating a new ini file, but an administrator can always override it.
3 files changed with 25 insertions and 1 deletions:
development.ini
9
kallithea/lib/paster_commands/template.ini.mako
12
kallithea/model/scm.py
4
1
0 comments (0 inline, 0 general)
development.ini
➞
Show inline comments
 
@@ -24,192 +24,201 @@
 
#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, comma-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

			




	
	
	
		
 
email_to =

			




	
	
	
		
 

			




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

			




	
	
	
		
 
## Default: (none)

			




	
	
	
		
 
## Examples:

			




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

			




	
	
	
		
 
#error_email_from = kallithea_errors@example.com

			




	
	
	
		
 
error_email_from =

			




	
	
	
		
 

			




	
	
	
		
 
## SMTP server settings

			




	
	
	
		
 
## If specifying credentials, make sure to use secure connections.

			




	
	
	
		
 
## Default: Send unencrypted unauthenticated mails to the specified smtp_server.

			




	
	
	
		
 
## For "SSL", use smtp_use_ssl = true and smtp_port = 465.

			




	
	
	
		
 
## For "STARTTLS", use smtp_use_tls = true and smtp_port = 587.

			




	
	
	
		
 
smtp_server =

			




	
	
	
		
 
#smtp_username =

			




	
	
	
		
 
#smtp_password =

			




	
	
	
		
 
smtp_port =

			




	
	
	
		
 
#smtp_use_ssl = false

			




	
	
	
		
 
#smtp_use_tls = false

			




	
	
	
		
 

			




	
	
	
		
 
## Entry point for 'gearbox serve'

			




	
	
	
		
 
[server:main]

			




	
	
	
		
 
#host = 127.0.0.1

			




	
	
	
		
 
host = 0.0.0.0

			




	
	
	
		
 
port = 5000

			




	
	
	
		
 

			




	
	
	
		
 
## WAITRESS ##

			




	
	
	
		
 
use = egg:waitress#main

			




	
	
	
		
 
## number of worker threads

			




	
	
	
		
 
threads = 1

			




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

			




	
	
	
		
 

			




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

			




	
	
	
		
 

			




	
	
	
		
 
## Internationalization (see setup documentation for details)

			




	
	
	
		
 
## By default, the language requested by the browser is used if available.

			




	
	
	
		
 
#i18n.enabled = false

			




	
	
	
		
 
## Fallback language, empty for English (valid values are the names of subdirectories in kallithea/i18n):

			




	
	
	
		
 
i18n.lang =

			




	
	
	
		
 

			




	
	
	
		
 
cache_dir = %(here)s/data

			




	
	
	
		
 
index_dir = %(here)s/data/index

			




	
	
	
		
 

			




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

			




	
	
	
		
 
archive_cache_dir = %(here)s/tarballcache

			




	
	
	
		
 

			




	
	
	
		
 
## change this to unique ID for security

			




	
	
	
		
 
#app_instance_uuid = VERY-SECRET

			




	
	
	
		
 
app_instance_uuid = development-not-secret

			




	
	
	
		
 

			




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

			




	
	
	
		
 
cut_off_limit = 256000

			




	
	
	
		
 

			




	
	
	
		
 
## 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 Python executable to be used for git hooks.

			




	
	
	
		
 
## This value will be written inside the git hook scripts as the text

			




	
	
	
		
 
## after '#!' (shebang). When empty or not defined, the value of

			




	
	
	
		
 
## 'sys.executable' at the time of installation of the git hooks is

			




	
	
	
		
 
## used, which is correct in many cases but for example not when using uwsgi.

			




	
	
	
		
 
## If you change this setting, you should reinstall the Git hooks via

			




	
	
	
		
 
## Admin > Settings > Remap and Rescan.

			




	
	
	
		
 
# git_hook_interpreter = /srv/kallithea/venv/bin/python2

			




	
	
	
		
 

			




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

			




	
	
	
		
 

			




	
	
	
		
 
## Canonical URL to use when creating full URLs in UI and texts.

			




	
	
	
		
 
## Useful when the site is available under different names or protocols.

			




	
	
	
		
 
## Defaults to what is provided in the WSGI environment.

			




	
	
	
		
 
#canonical_url = https://kallithea.example.com/repos

			




	
	
	
		
 

			




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

			




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

			




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

			




	
	
	
		
 
## 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 separated list of encoding in case of mixed encodings

			




	
	
	
		
 
default_encoding = utf-8

			




	
	
	
		
 

			




	
	
	
		
 
## Set Mercurial encoding, similar to setting HGENCODING before launching Kallithea

			




	
	
	
		
 
hgencoding = utf-8

			




	
	
	
		
 

			




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

			




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

			




	
	
	
		
 

			




	
	
	
		
 
## issue tracking mapping for commit messages, comments, PR descriptions, ...

			




	
	
	
		
 
## Refer to the documentation ("Integration with issue trackers") for more details.

			




	
	
	
		
 

			




	
	
	
		
 
## regular expression to match issue references

			




	
	
	
		
 
## This pattern may/should contain parenthesized groups, that can

			




	
	
	
		
 
## be referred to in issue_server_link or issue_sub using Python backreferences

			




	
	
	
		
 
## (e.g. \1, \2, ...). You can also create named groups with '(?P<groupname>)'.

			




	
	
	
		
 
## To require mandatory whitespace before the issue pattern, use:

			




	
	
	
		
 
## (?:^|(?<=\s)) before the actual pattern, and for mandatory whitespace

			




	
	
	
		
 
## behind the issue pattern, use (?:$|(?=\s)) after the actual pattern.

			




	
	
	
		
 

			




	
	
	
		
 
issue_pat = #(\d+)

			




	
	
	
		
 

			




	
	
	
		
 
## server url to the issue

			




	
	
	
		
 
## This pattern may/should contain backreferences to parenthesized groups in issue_pat.

			




	
	
	
		
 
## A backreference can be \1, \2, ... or \g<groupname> if you specified a named group

			




	
	
	
		
 
## called 'groupname' in issue_pat.

			




	
	
	
		
 
## The special token {repo} is replaced with the full repository name

			




	
	
	
		
 
## including repository groups, while {repo_name} is replaced with just

			




	
	
	
		
 
## the name of the repository.

			




	
	
	
		
 

			




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

			




	
	
	
		
 

			




	
	
	
		
 
## substitution pattern to use as the link text

			




	
	
	
		
 
## If issue_sub is empty, the text matched by issue_pat is retained verbatim

			




	
	
	
		
 
## for the link text. Otherwise, the link text is that of issue_sub, with any

			




	
	
	
		
 
## backreferences to groups in issue_pat replaced.

			




	
	
	
		
 

			




	
	
	
		
 
issue_sub =

			




	
	
	
		
 

			




	
	
	
		
 
## issue_pat, issue_server_link and issue_sub can have suffixes to specify

			




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

			




	
	
	
		
 
## below an example how to create a wiki pattern

			




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

			




	
	
	
		
 

			




	
	
	
		
 
#issue_pat_wiki = wiki-(\S+)

			




	
	
	
		
 
#issue_server_link_wiki = https://wiki.example.com/\1

			




	
	
	
		
 
#issue_sub_wiki = WIKI-\1

			




	
	
	
		
 

			




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

			




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

			




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

			




        

    


    
    

    

        

                

                    kallithea/lib/paster_commands/template.ini.mako
                

                

                  
                      
                        

                      ➞

                      
                        
                  

                  
                      
                  
                      
                  
                      
                  
                      
                  
                  
                

                

                    Show inline comments
                    
                

        

        

            



	
	
		
 
@@ -118,192 +118,204 @@ master = true

			




	
	
	
		
 
http = ${host}:${port}

			




	
	
	
		
 

			




	
	
	
		
 
<%text>## set as daemon 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 = 128

			




	
	
	
		
 

			




	
	
	
		
 
<%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>## 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>## Internationalization (see setup documentation for details)</%text>

			




	
	
	
		
 
<%text>## By default, the language requested by the browser is used if available.</%text>

			




	
	
	
		
 
#i18n.enabled = false

			




	
	
	
		
 
<%text>## Fallback language, empty for English (valid values are the names of subdirectories in kallithea/i18n):</%text>

			




	
	
	
		
 
i18n.lang =

			




	
	
	
		
 

			




	
	
	
		
 
cache_dir = %(here)s/data

			




	
	
	
		
 
index_dir = %(here)s/data/index

			




	
	
	
		
 

			




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

			




	
	
	
		
 
archive_cache_dir = %(here)s/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>## 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 Python executable to be used for git hooks.</%text>

			




	
	
	
		
 
<%text>## This value will be written inside the git hook scripts as the text</%text>

			




	
	
	
		
 
<%text>## after '#!' (shebang). When empty or not defined, the value of</%text>

			




	
	
	
		
 
<%text>## 'sys.executable' at the time of installation of the git hooks is</%text>

			




	
	
	
		
 
<%text>## used, which is correct in many cases but for example not when using uwsgi.</%text>

			




	
	
	
		
 
<%text>## If you change this setting, you should reinstall the Git hooks via</%text>

			




	
	
	
		
 
<%text>## Admin > Settings > Remap and Rescan.</%text>

			




	
	
	
		
 
# git_hook_interpreter = /srv/kallithea/venv/bin/python2

			




	
	
	
		
 
%if git_hook_interpreter:

			




	
	
	
		
 
git_hook_interpreter = ${git_hook_interpreter}

			




	
	
	
		
 
%endif

			




	
	
	
		
 

			




	
	
	
		
 
<%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>## Canonical URL to use when creating full URLs in UI and texts.</%text>

			




	
	
	
		
 
<%text>## Useful when the site is available under different names or protocols.</%text>

			




	
	
	
		
 
<%text>## Defaults to what is provided in the WSGI environment.</%text>

			




	
	
	
		
 
#canonical_url = https://kallithea.example.com/repos

			




	
	
	
		
 

			




	
	
	
		
 
<%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.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 separated list of encoding in case of mixed encodings</%text>

			




	
	
	
		
 
default_encoding = utf-8

			




	
	
	
		
 

			




	
	
	
		
 
<%text>## Set Mercurial encoding, similar to setting HGENCODING before launching Kallithea</%text>

			




	
	
	
		
 
hgencoding = utf-8

			




	
	
	
		
 

			




	
	
	
		
 
<%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 commit messages, comments, PR descriptions, ...</%text>

			




	
	
	
		
 
<%text>## Refer to the documentation ("Integration with issue trackers") for more details.</%text>

			




	
	
	
		
 

			




	
	
	
		
 
<%text>## regular expression to match issue references</%text>

			




	
	
	
		
 
<%text>## This pattern may/should contain parenthesized groups, that can</%text>

			




	
	
	
		
 
<%text>## be referred to in issue_server_link or issue_sub using Python backreferences</%text>

			




	
	
	
		
 
<%text>## (e.g. \1, \2, ...). You can also create named groups with '(?P<groupname>)'.</%text>

			




	
	
	
		
 
<%text>## To require mandatory whitespace before the issue pattern, use:</%text>

			




	
	
	
		
 
<%text>## (?:^|(?<=\s)) before the actual pattern, and for mandatory whitespace</%text>

			




	
	
	
		
 
<%text>## behind the issue pattern, use (?:$|(?=\s)) after the actual pattern.</%text>

			




	
	
	
		
 

			




	
	
	
		
 
issue_pat = #(\d+)

			




	
	
	
		
 

			




	
	
	
		
 
<%text>## server url to the issue</%text>

			




	
	
	
		
 
<%text>## This pattern may/should contain backreferences to parenthesized groups in issue_pat.</%text>

			




	
	
	
		
 
<%text>## A backreference can be \1, \2, ... or \g<groupname> if you specified a named group</%text>

			




	
	
	
		
 
<%text>## called 'groupname' in issue_pat.</%text>

			




	
	
	
		
 
<%text>## The special token {repo} is replaced with the full repository name</%text>

			




	
	
	
		
 
<%text>## including repository groups, while {repo_name} is replaced with just</%text>

			




	
	
	
		
 
<%text>## the name of the repository.</%text>

			




	
	
	
		
 

			




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

			




	
	
	
		
 

			




	
	
	
		
 
<%text>## substitution pattern to use as the link text</%text>

			




	
	
	
		
 
<%text>## If issue_sub is empty, the text matched by issue_pat is retained verbatim</%text>

			




	
	
	
		
 
<%text>## for the link text. Otherwise, the link text is that of issue_sub, with any</%text>

			




	
	
	
		
 
<%text>## backreferences to groups in issue_pat replaced.</%text>

			




	
	
	
		
 

			




	
	
	
		
 
issue_sub =

			




	
	
	
		
 

			




	
	
	
		
 
<%text>## issue_pat, issue_server_link and issue_sub 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://wiki.example.com/some-id

			




	
	
	
		
 

			




	
	
	
		
 
#issue_pat_wiki = wiki-(\S+)

			




	
	
	
		
 
#issue_server_link_wiki = https://wiki.example.com/\1

			




	
	
	
		
 
#issue_sub_wiki = WIKI-\1

			




	
	
	
		
 

			




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

			




        

    


    
    

    

        

                

                    kallithea/model/scm.py
                

                

                  
                      
                        

                      ➞

                      
                        
                  

                  
                      
                  
                      
                  
                      
                  
                      
                  
                  
                

                

                    Show inline comments
                    
                

        

        

            



	
	
		
 
@@ -634,175 +634,178 @@ class ScmModel(object):

			




	
	
	
		
 
        :param author: author of commit, cna be different that committer only for git

			




	
	
	
		
 
        :param trigger_push_hook: trigger push hooks

			




	
	
	
		
 

			




	
	
	
		
 
        :returns: new committed changeset after deletion

			




	
	
	
		
 
        """

			




	
	
	
		
 

			




	
	
	
		
 
        user = User.guess_instance(user)

			




	
	
	
		
 
        scm_instance = repo.scm_instance_no_cache()

			




	
	
	
		
 

			




	
	
	
		
 
        processed_nodes = []

			




	
	
	
		
 
        for f_path in nodes:

			




	
	
	
		
 
            f_path = self._sanitize_path(f_path)

			




	
	
	
		
 
            # content can be empty but for compatibility it allows same dicts

			




	
	
	
		
 
            # structure as add_nodes

			




	
	
	
		
 
            content = nodes[f_path].get('content')

			




	
	
	
		
 
            processed_nodes.append((f_path, content))

			




	
	
	
		
 

			




	
	
	
		
 
        message = safe_unicode(message)

			




	
	
	
		
 
        committer = user.full_contact

			




	
	
	
		
 
        author = safe_unicode(author) if author else committer

			




	
	
	
		
 

			




	
	
	
		
 
        IMC = self._get_IMC_module(scm_instance.alias)

			




	
	
	
		
 
        imc = IMC(scm_instance)

			




	
	
	
		
 

			




	
	
	
		
 
        if not parent_cs:

			




	
	
	
		
 
            parent_cs = EmptyChangeset(alias=scm_instance.alias)

			




	
	
	
		
 

			




	
	
	
		
 
        if isinstance(parent_cs, EmptyChangeset):

			




	
	
	
		
 
            # EmptyChangeset means we we're editing empty repository

			




	
	
	
		
 
            parents = None

			




	
	
	
		
 
        else:

			




	
	
	
		
 
            parents = [parent_cs]

			




	
	
	
		
 
        # add multiple nodes

			




	
	
	
		
 
        for path, content in processed_nodes:

			




	
	
	
		
 
            imc.remove(FileNode(path, content=content))

			




	
	
	
		
 

			




	
	
	
		
 
        tip = imc.commit(message=message,

			




	
	
	
		
 
                         author=author,

			




	
	
	
		
 
                         parents=parents,

			




	
	
	
		
 
                         branch=parent_cs.branch)

			




	
	
	
		
 

			




	
	
	
		
 
        self.mark_for_invalidation(repo.repo_name)

			




	
	
	
		
 
        if trigger_push_hook:

			




	
	
	
		
 
            self._handle_push(scm_instance,

			




	
	
	
		
 
                              username=user.username,

			




	
	
	
		
 
                              action='push_local',

			




	
	
	
		
 
                              repo_name=repo.repo_name,

			




	
	
	
		
 
                              revisions=[tip.raw_id])

			




	
	
	
		
 
        return tip

			




	
	
	
		
 

			




	
	
	
		
 
    def get_unread_journal(self):

			




	
	
	
		
 
        return UserLog.query().count()

			




	
	
	
		
 

			




	
	
	
		
 
    def get_repo_landing_revs(self, repo=None):

			




	
	
	
		
 
        """

			




	
	
	
		
 
        Generates select option with tags branches and bookmarks (for hg only)

			




	
	
	
		
 
        grouped by type

			




	
	
	
		
 

			




	
	
	
		
 
        :param repo:

			




	
	
	
		
 
        """

			




	
	
	
		
 

			




	
	
	
		
 
        hist_l = []

			




	
	
	
		
 
        choices = []

			




	
	
	
		
 
        repo = self.__get_repo(repo)

			




	
	
	
		
 
        hist_l.append(['rev:tip', _('latest tip')])

			




	
	
	
		
 
        choices.append('rev:tip')

			




	
	
	
		
 
        if repo is None:

			




	
	
	
		
 
            return choices, hist_l

			




	
	
	
		
 

			




	
	
	
		
 
        repo = repo.scm_instance

			




	
	
	
		
 

			




	
	
	
		
 
        branches_group = ([(u'branch:%s' % k, k) for k, v in

			




	
	
	
		
 
                           repo.branches.iteritems()], _("Branches"))

			




	
	
	
		
 
        hist_l.append(branches_group)

			




	
	
	
		
 
        choices.extend([x[0] for x in branches_group[0]])

			




	
	
	
		
 

			




	
	
	
		
 
        if repo.alias == 'hg':

			




	
	
	
		
 
            bookmarks_group = ([(u'book:%s' % k, k) for k, v in

			




	
	
	
		
 
                                repo.bookmarks.iteritems()], _("Bookmarks"))

			




	
	
	
		
 
            hist_l.append(bookmarks_group)

			




	
	
	
		
 
            choices.extend([x[0] for x in bookmarks_group[0]])

			




	
	
	
		
 

			




	
	
	
		
 
        tags_group = ([(u'tag:%s' % k, k) for k, v in

			




	
	
	
		
 
                       repo.tags.iteritems()], _("Tags"))

			




	
	
	
		
 
        hist_l.append(tags_group)

			




	
	
	
		
 
        choices.extend([x[0] for x in tags_group[0]])

			




	
	
	
		
 

			




	
	
	
		
 
        return choices, hist_l

			




	
	
	
		
 

			




	
	
	
		
 
    def _get_git_hook_interpreter(self):

			




	
	
	
		
 
        """Return a suitable interpreter for Git hooks.

			




	
	
	
		
 

			




	
	
	
		
 
        Return a suitable string to be written in the POSIX #! shebang line for

			




	
	
	
		
 
        Git hook scripts so they invoke Kallithea code with the right Python

			




	
	
	
		
 
        interpreter and in the right environment.

			




	
	
	
		
 
        """

			




	
	
	
		
 
        # Note: sys.executable might not point at a usable Python interpreter. For

			




	
	
	
		
 
        # example, when using uwsgi, it will point at the uwsgi program itself.

			




	
	
	
		
 
        # FIXME This may not work on Windows and may need a shell wrapper script.

			




	
	
	
		
 
        return (sys.executable

			




	
	
	
		
 
        return (kallithea.CONFIG.get('git_hook_interpreter')

			




	
	
	
		
 
                or sys.executable

			




	
	
	
		
 
                or '/usr/bin/env python2')

			




	
	
	
		
 

			




	
	
	
		
 
    def install_git_hooks(self, repo, force_create=False):

			




	
	
	
		
 
        """

			




	
	
	
		
 
        Creates a kallithea hook inside a git repository

			




	
	
	
		
 

			




	
	
	
		
 
        :param repo: Instance of VCS repo

			




	
	
	
		
 
        :param force_create: Create even if same name hook exists

			




	
	
	
		
 
        """

			




	
	
	
		
 

			




	
	
	
		
 
        loc = os.path.join(repo.path, 'hooks')

			




	
	
	
		
 
        if not repo.bare:

			




	
	
	
		
 
            loc = os.path.join(repo.path, '.git', 'hooks')

			




	
	
	
		
 
        if not os.path.isdir(loc):

			




	
	
	
		
 
            os.makedirs(loc)

			




	
	
	
		
 

			




	
	
	
		
 
        tmpl_post = "#!%s\n" % self._get_git_hook_interpreter()

			




	
	
	
		
 
        tmpl_post += pkg_resources.resource_string(

			




	
	
	
		
 
            'kallithea', os.path.join('config', 'post_receive_tmpl.py')

			




	
	
	
		
 
        )

			




	
	
	
		
 
        tmpl_pre = "#!%s\n" % self._get_git_hook_interpreter()

			




	
	
	
		
 
        tmpl_pre += pkg_resources.resource_string(

			




	
	
	
		
 
            'kallithea', os.path.join('config', 'pre_receive_tmpl.py')

			




	
	
	
		
 
        )

			




	
	
	
		
 

			




	
	
	
		
 
        for h_type, tmpl in [('pre', tmpl_pre), ('post', tmpl_post)]:

			




	
	
	
		
 
            _hook_file = os.path.join(loc, '%s-receive' % h_type)

			




	
	
	
		
 
            has_hook = False

			




	
	
	
		
 
            log.debug('Installing git hook in repo %s', repo)

			




	
	
	
		
 
            if os.path.exists(_hook_file):

			




	
	
	
		
 
                # let's take a look at this hook, maybe it's kallithea ?

			




	
	
	
		
 
                log.debug('hook exists, checking if it is from kallithea')

			




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

			




	
	
	
		
 
                    data = f.read()

			




	
	
	
		
 
                    matches = re.compile(r'(?:%s)\s*=\s*(.*)'

			




	
	
	
		
 
                                         % 'KALLITHEA_HOOK_VER').search(data)

			




	
	
	
		
 
                    if matches:

			




	
	
	
		
 
                        try:

			




	
	
	
		
 
                            ver = matches.groups()[0]

			




	
	
	
		
 
                            log.debug('got %s it is kallithea', ver)

			




	
	
	
		
 
                            has_hook = True

			




	
	
	
		
 
                        except Exception:

			




	
	
	
		
 
                            log.error(traceback.format_exc())

			




	
	
	
		
 
            else:

			




	
	
	
		
 
                # there is no hook in this dir, so we want to create one

			




	
	
	
		
 
                has_hook = True

			




	
	
	
		
 

			




	
	
	
		
 
            if has_hook or force_create:

			




	
	
	
		
 
                log.debug('writing %s hook file !', h_type)

			




	
	
	
		
 
                try:

			




	
	
	
		
 
                    with open(_hook_file, 'wb') as f:

			




	
	
	
		
 
                        tmpl = tmpl.replace('_TMPL_', kallithea.__version__)

			




	
	
	
		
 
                        f.write(tmpl)

			




	
	
	
		
 
                    os.chmod(_hook_file, 0755)

			




	
	
	
		
 
                except IOError as e:

			




	
	
	
		
 
                    log.error('error writing %s: %s', _hook_file, e)

			




	
	
	
		
 
            else:

			




	
	
	
		
 
                log.debug('skipping writing hook file')

			




	
	
	
		
 

			




	
	
	
		
 

			




	
	
	
		
 
def AvailableRepoGroupChoices(top_perms, repo_group_perm_level, extras=()):

			




	
	
	
		
 
    """Return group_id,string tuples with choices for all the repo groups where

			




	
	
	
		
 
    the user has the necessary permissions.

			




	
	
	
		
 

			




	
	
	
		
 
    Top level is -1.

			




	
	
	
		
 
    """

			




	
	
	
		
 
    groups = RepoGroup.query().all()

			




	
	
	
		
 
    if HasPermissionAny('hg.admin')('available repo groups'):

			




	
	
	
		
 
        groups.append(None)

			




	
	
	
		
 
    else:

			




	
	
	
		
 
        groups = list(RepoGroupList(groups, perm_level=repo_group_perm_level))

			




	
	
	
		
 
        if top_perms and HasPermissionAny(*top_perms)('available repo groups'):

			




	
	
	
		
 
            groups.append(None)

			




	
	
	
		
 
        for extra in extras:

			




	
	
	
		
 
            if not any(rg == extra for rg in groups):

			




	
	
	
		
 
                groups.append(extra)

			




	
	
	
		
 
    return RepoGroup.groups_choices(groups=groups)

			




        

    



    


    



    



      

      





    
    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.