svn: enable hooks and integration framework execution.

- This change will allow SVN to execute rhodecode integration framework
via executing the builting hooks.
- uses txn_id for svn to provide metadata required via Apache
- Interception of SVN transaction is required to use temporary stores for metadata
- hooks are now part of vcsserver where the install/control logic is stored

MANIFEST.in

@@ -1,54 +1,51 b''
 # top level files
 
 include MANIFEST.in
 include README.rst
 include CHANGES.rst
 include LICENSE.txt
 
 include rhodecode/VERSION
 
 # docs
 recursive-include docs *
 
 # all config files
 recursive-include configs *
 
 # translations
 recursive-include rhodecode/i18n *
 
-# hook templates
-recursive-include rhodecode/config/hook_templates *
-
 # non-python core stuff
 recursive-include rhodecode *.cfg
 recursive-include rhodecode *.json
 recursive-include rhodecode *.ini_tmpl
 recursive-include rhodecode *.sh
 recursive-include rhodecode *.mako
 
 # 502 page
 include rhodecode/public/502.html
 
 
 # images, css
 include rhodecode/public/css/*.css
 include rhodecode/public/images/*.*
 include rhodecode/public/images/ee_features/*.*
 
 # sound files
 include rhodecode/public/sounds/*.mp3
 include rhodecode/public/sounds/*.wav
 
 # fonts
 recursive-include rhodecode/public/fonts/ProximaNova *
 recursive-include rhodecode/public/fonts/RCIcons *
 
 # js
 recursive-include rhodecode/public/js *
 
 # templates
 recursive-include rhodecode/templates *
 
 # skip any tests files
 recursive-exclude rhodecode/tests *
 

rhodecode/api/tests/test_get_repo_changeset.py

@@ -1,140 +1,141 b''
 # -*- coding: utf-8 -*-
 
 # Copyright (C) 2010-2018 RhodeCode GmbH
 #
 # This program is free software: you can redistribute it and/or modify
 # it under the terms of the GNU Affero General Public License, version 3
 # (only), as published by the Free Software Foundation.
 #
 # 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 Affero General Public License
 # along with this program.  If not, see <http://www.gnu.org/licenses/>.
 #
 # This program is dual-licensed. If you wish to learn more about the
 # RhodeCode Enterprise Edition, including its added features, Support services,
 # and proprietary license terms, please see https://rhodecode.com/licenses/
 
 
 import pytest
 
 from rhodecode.api.tests.utils import build_data, api_call, assert_error
 
 
 @pytest.mark.usefixtures("testuser_api", "app")
 class TestGetRepoChangeset(object):
     @pytest.mark.parametrize("details", ['basic', 'extended', 'full'])
     def test_get_repo_changeset(self, details, backend):
         commit = backend.repo.get_commit(commit_idx=0)
         __, params = build_data(
             self.apikey, 'get_repo_changeset',
             repoid=backend.repo_name, revision=commit.raw_id,
             details=details,
         )
         response = api_call(self.app, params)
         result = response.json['result']
         assert result['revision'] == 0
         assert result['raw_id'] == commit.raw_id
 
         if details == 'full':
             assert result['refs']['bookmarks'] == getattr(
                 commit, 'bookmarks', [])
-            assert result['refs']['branches'] == [commit.branch]
+            branches = [commit.branch] if commit.branch else []
+            assert result['refs']['branches'] == branches
             assert result['refs']['tags'] == commit.tags
 
     @pytest.mark.parametrize("details", ['basic', 'extended', 'full'])
     def test_get_repo_changeset_bad_type(self, details, backend):
         id_, params = build_data(
             self.apikey, 'get_repo_changeset',
             repoid=backend.repo_name, revision=0,
             details=details,
         )
         response = api_call(self.app, params)
         expected = 'commit_id must be a string value'
         assert_error(id_, expected, given=response.body)
 
     @pytest.mark.parametrize("details", ['basic', 'extended', 'full'])
     def test_get_repo_changesets(self, details, backend):
         limit = 2
         commit = backend.repo.get_commit(commit_idx=0)
         __, params = build_data(
             self.apikey, 'get_repo_changesets',
             repoid=backend.repo_name, start_rev=commit.raw_id, limit=limit,
             details=details,
         )
         response = api_call(self.app, params)
         result = response.json['result']
         assert result
         assert len(result) == limit
         for x in xrange(limit):
             assert result[x]['revision'] == x
 
         if details == 'full':
             for x in xrange(limit):
                 assert 'bookmarks' in result[x]['refs']
                 assert 'branches' in result[x]['refs']
                 assert 'tags' in result[x]['refs']
 
     @pytest.mark.parametrize("details", ['basic', 'extended', 'full'])
     @pytest.mark.parametrize("start_rev, expected_revision", [
         ("0", 0),
         ("10", 10),
         ("20", 20),
         ])
     @pytest.mark.backends("hg", "git")
     def test_get_repo_changesets_commit_range(
             self, details, backend, start_rev, expected_revision):
         limit = 10
         __, params = build_data(
             self.apikey, 'get_repo_changesets',
             repoid=backend.repo_name, start_rev=start_rev, limit=limit,
             details=details,
         )
         response = api_call(self.app, params)
         result = response.json['result']
         assert result
         assert len(result) == limit
         for i in xrange(limit):
             assert result[i]['revision'] == int(expected_revision) + i
 
     @pytest.mark.parametrize("details", ['basic', 'extended', 'full'])
     @pytest.mark.parametrize("start_rev, expected_revision", [
         ("0", 0),
         ("10", 9),
         ("20", 19),
         ])
     def test_get_repo_changesets_commit_range_svn(
             self, details, backend_svn, start_rev, expected_revision):
 
         # TODO: johbo: SVN showed a problem here: The parameter "start_rev"
         # in our API allows to pass in a "Commit ID" as well as a
         # "Commit Index". In the case of Subversion it is not possible to
         # distinguish these cases. As a workaround we implemented this
         # behavior which gives a preference to see it as a "Commit ID".
 
         limit = 10
         __, params = build_data(
             self.apikey, 'get_repo_changesets',
             repoid=backend_svn.repo_name, start_rev=start_rev, limit=limit,
             details=details,
         )
         response = api_call(self.app, params)
         result = response.json['result']
         assert result
         assert len(result) == limit
         for i in xrange(limit):
             assert result[i]['revision'] == int(expected_revision) + i
 
     @pytest.mark.parametrize("details", ['basic', 'extended', 'full'])
     def test_get_repo_changesets_bad_type(self, details, backend):
         id_, params = build_data(
             self.apikey, 'get_repo_changesets',
             repoid=backend.repo_name, start_rev=0, limit=2,
             details=details,
         )
         response = api_call(self.app, params)
         expected = 'commit_id must be a string value'
         assert_error(id_, expected, given=response.body)

rhodecode/lib/hooks_daemon.py

@@ -1,251 +1,313 b''
 # -*- coding: utf-8 -*-
 
 # Copyright (C) 2010-2018 RhodeCode GmbH
 #
 # This program is free software: you can redistribute it and/or modify
 # it under the terms of the GNU Affero General Public License, version 3
 # (only), as published by the Free Software Foundation.
 #
 # 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 Affero General Public License
 # along with this program.  If not, see <http://www.gnu.org/licenses/>.
 #
 # This program is dual-licensed. If you wish to learn more about the
 # RhodeCode Enterprise Edition, including its added features, Support services,
 # and proprietary license terms, please see https://rhodecode.com/licenses/
 
-import json
+import os
+import time
 import logging
+import tempfile
 import traceback
 import threading
+
 from BaseHTTPServer import BaseHTTPRequestHandler
 from SocketServer import TCPServer
 
 import rhodecode
 from rhodecode.model import meta
 from rhodecode.lib.base import bootstrap_request, bootstrap_config
 from rhodecode.lib import hooks_base
 from rhodecode.lib.utils2 import AttributeDict
+from rhodecode.lib.ext_json import json
 
 
 log = logging.getLogger(__name__)
 
 
 class HooksHttpHandler(BaseHTTPRequestHandler):
+
     def do_POST(self):
         method, extras = self._read_request()
+        txn_id = getattr(self.server, 'txn_id', None)
+        if txn_id:
+            from rhodecode.lib.caches import compute_key_from_params
+            log.debug('Computing TXN_ID based on `%s`:`%s`',
+                      extras['repository'], extras['txn_id'])
+            computed_txn_id = compute_key_from_params(
+                extras['repository'], extras['txn_id'])
+            if txn_id != computed_txn_id:
+                raise Exception(
+                    'TXN ID fail: expected {} got {} instead'.format(
+                        txn_id, computed_txn_id))
+
         try:
             result = self._call_hook(method, extras)
         except Exception as e:
             exc_tb = traceback.format_exc()
             result = {
                 'exception': e.__class__.__name__,
                 'exception_traceback': exc_tb,
                 'exception_args': e.args
             }
         self._write_response(result)
 
     def _read_request(self):
         length = int(self.headers['Content-Length'])
         body = self.rfile.read(length).decode('utf-8')
         data = json.loads(body)
         return data['method'], data['extras']
 
     def _write_response(self, result):
         self.send_response(200)
         self.send_header("Content-type", "text/json")
         self.end_headers()
         self.wfile.write(json.dumps(result))
 
     def _call_hook(self, method, extras):
         hooks = Hooks()
         try:
             result = getattr(hooks, method)(extras)
         finally:
             meta.Session.remove()
         return result
 
     def log_message(self, format, *args):
         """
         This is an overridden method of BaseHTTPRequestHandler which logs using
         logging library instead of writing directly to stderr.
         """
 
         message = format % args
 
-        # TODO: mikhail: add different log levels support
         log.debug(
             "%s - - [%s] %s", self.client_address[0],
             self.log_date_time_string(), message)
 
 
 class DummyHooksCallbackDaemon(object):
+    hooks_uri = ''
+
     def __init__(self):
         self.hooks_module = Hooks.__module__
 
     def __enter__(self):
         log.debug('Running dummy hooks callback daemon')
         return self
 
     def __exit__(self, exc_type, exc_val, exc_tb):
         log.debug('Exiting dummy hooks callback daemon')
 
 
 class ThreadedHookCallbackDaemon(object):
 
     _callback_thread = None
     _daemon = None
     _done = False
 
-    def __init__(self):
-        self._prepare()
+    def __init__(self, txn_id=None, port=None):
+        self._prepare(txn_id=txn_id, port=port)
 
     def __enter__(self):
         self._run()
         return self
 
     def __exit__(self, exc_type, exc_val, exc_tb):
         log.debug('Callback daemon exiting now...')
         self._stop()
 
-    def _prepare(self):
+    def _prepare(self, txn_id=None, port=None):
         raise NotImplementedError()
 
     def _run(self):
         raise NotImplementedError()
 
     def _stop(self):
         raise NotImplementedError()
 
 
 class HttpHooksCallbackDaemon(ThreadedHookCallbackDaemon):
     """
     Context manager which will run a callback daemon in a background thread.
     """
 
     hooks_uri = None
 
     IP_ADDRESS = '127.0.0.1'
 
     # From Python docs: Polling reduces our responsiveness to a shutdown
     # request and wastes cpu at all other times.
     POLL_INTERVAL = 0.01
 
-    def _prepare(self):
-        log.debug("Preparing HTTP callback daemon and registering hook object")
-
+    def _prepare(self, txn_id=None, port=None):
         self._done = False
-        self._daemon = TCPServer((self.IP_ADDRESS, 0), HooksHttpHandler)
+        self._daemon = TCPServer((self.IP_ADDRESS, port or 0), HooksHttpHandler)
         _, port = self._daemon.server_address
         self.hooks_uri = '{}:{}'.format(self.IP_ADDRESS, port)
+        self.txn_id = txn_id
+        # inject transaction_id for later verification
+        self._daemon.txn_id = self.txn_id
 
-        log.debug("Hooks uri is: %s", self.hooks_uri)
+        log.debug(
+            "Preparing HTTP callback daemon at `%s` and registering hook object",
+            self.hooks_uri)
 
     def _run(self):
         log.debug("Running event loop of callback daemon in background thread")
         callback_thread = threading.Thread(
             target=self._daemon.serve_forever,
             kwargs={'poll_interval': self.POLL_INTERVAL})
         callback_thread.daemon = True
         callback_thread.start()
         self._callback_thread = callback_thread
 
     def _stop(self):
         log.debug("Waiting for background thread to finish.")
         self._daemon.shutdown()
         self._callback_thread.join()
         self._daemon = None
         self._callback_thread = None
+        if self.txn_id:
+            txn_id_file = get_txn_id_data_path(self.txn_id)
+            log.debug('Cleaning up TXN ID %s', txn_id_file)
+            if os.path.isfile(txn_id_file):
+                os.remove(txn_id_file)
+
         log.debug("Background thread done.")
 
 
-def prepare_callback_daemon(extras, protocol, use_direct_calls):
-    callback_daemon = None
+def get_txn_id_data_path(txn_id):
+    root = tempfile.gettempdir()
+    return os.path.join(root, 'rc_txn_id_{}'.format(txn_id))
+
+
+def store_txn_id_data(txn_id, data_dict):
+    if not txn_id:
+        log.warning('Cannot store txn_id because it is empty')
+        return
+
+    path = get_txn_id_data_path(txn_id)
+    try:
+        with open(path, 'wb') as f:
+            f.write(json.dumps(data_dict))
+    except Exception:
+        log.exception('Failed to write txn_id metadata')
 
+
+def get_txn_id_from_store(txn_id):
+    """
+    Reads txn_id from store and if present returns the data for callback manager
+    """
+    path = get_txn_id_data_path(txn_id)
+    try:
+        with open(path, 'rb') as f:
+            return json.loads(f.read())
+    except Exception:
+        return {}
+
+
+def prepare_callback_daemon(extras, protocol, use_direct_calls, txn_id=None):
+    txn_details = get_txn_id_from_store(txn_id)
+    port = txn_details.get('port', 0)
     if use_direct_calls:
         callback_daemon = DummyHooksCallbackDaemon()
         extras['hooks_module'] = callback_daemon.hooks_module
     else:
         if protocol == 'http':
-            callback_daemon = HttpHooksCallbackDaemon()
+            callback_daemon = HttpHooksCallbackDaemon(txn_id=txn_id, port=port)
         else:
             log.error('Unsupported callback daemon protocol "%s"', protocol)
             raise Exception('Unsupported callback daemon protocol.')
 
         extras['hooks_uri'] = callback_daemon.hooks_uri
         extras['hooks_protocol'] = protocol
+    extras['time'] = time.time()
 
-    log.debug('Prepared a callback daemon: %s', callback_daemon)
+    # register txn_id
+    extras['txn_id'] = txn_id
+
+    log.debug('Prepared a callback daemon: %s at url `%s`',
+              callback_daemon.__class__.__name__, callback_daemon.hooks_uri)
     return callback_daemon, extras
 
 
 class Hooks(object):
     """
     Exposes the hooks for remote call backs
     """
 
     def repo_size(self, extras):
         log.debug("Called repo_size of %s object", self)
         return self._call_hook(hooks_base.repo_size, extras)
 
     def pre_pull(self, extras):
         log.debug("Called pre_pull of %s object", self)
         return self._call_hook(hooks_base.pre_pull, extras)
 
     def post_pull(self, extras):
         log.debug("Called post_pull of %s object", self)
         return self._call_hook(hooks_base.post_pull, extras)
 
     def pre_push(self, extras):
         log.debug("Called pre_push of %s object", self)
         return self._call_hook(hooks_base.pre_push, extras)
 
     def post_push(self, extras):
         log.debug("Called post_push of %s object", self)
         return self._call_hook(hooks_base.post_push, extras)
 
     def _call_hook(self, hook, extras):
         extras = AttributeDict(extras)
         server_url = extras['server_url']
         request = bootstrap_request(application_url=server_url)
 
         bootstrap_config(request)  # inject routes and other interfaces
 
         # inject the user for usage in hooks
         request.user = AttributeDict({'username': extras.username,
                                       'ip_addr': extras.ip,
                                       'user_id': extras.user_id})
 
         extras.request = request
 
         try:
             result = hook(extras)
         except Exception as error:
             exc_tb = traceback.format_exc()
             log.exception('Exception when handling hook %s', hook)
             error_args = error.args
             return {
                 'status': 128,
                 'output': '',
                 'exception': type(error).__name__,
                 'exception_traceback': exc_tb,
                 'exception_args': error_args,
             }
         finally:
             meta.Session.remove()
 
         log.debug('Got hook call response %s', result)
         return {
             'status': result.status,
             'output': result.output,
         }
 
     def __enter__(self):
         return self
 
     def __exit__(self, exc_type, exc_val, exc_tb):
         pass

rhodecode/lib/middleware/simplesvn.py

@@ -1,175 +1,204 b''
 # -*- coding: utf-8 -*-
 
 # Copyright (C) 2010-2018 RhodeCode GmbH
 #
 # This program is free software: you can redistribute it and/or modify
 # it under the terms of the GNU Affero General Public License, version 3
 # (only), as published by the Free Software Foundation.
 #
 # 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 Affero General Public License
 # along with this program.  If not, see <http://www.gnu.org/licenses/>.
 #
 # This program is dual-licensed. If you wish to learn more about the
 # RhodeCode Enterprise Edition, including its added features, Support services,
 # and proprietary license terms, please see https://rhodecode.com/licenses/
 
+import base64
 import logging
 import urllib
 from urlparse import urljoin
 
-
 import requests
 from webob.exc import HTTPNotAcceptable
 
+from rhodecode.lib import caches
 from rhodecode.lib.middleware import simplevcs
 from rhodecode.lib.utils import is_valid_repo
-from rhodecode.lib.utils2 import str2bool
+from rhodecode.lib.utils2 import str2bool, safe_int
+from rhodecode.lib.ext_json import json
+from rhodecode.lib.hooks_daemon import store_txn_id_data
+
 
 log = logging.getLogger(__name__)
 
 
 class SimpleSvnApp(object):
     IGNORED_HEADERS = [
         'connection', 'keep-alive', 'content-encoding',
         'transfer-encoding', 'content-length']
     rc_extras = {}
 
-
     def __init__(self, config):
         self.config = config
 
     def __call__(self, environ, start_response):
         request_headers = self._get_request_headers(environ)
 
         data = environ['wsgi.input']
         # johbo: Avoid that we end up with sending the request in chunked
         # transfer encoding (mainly on Gunicorn). If we know the content
         # length, then we should transfer the payload in one request.
         if environ['REQUEST_METHOD'] == 'MKCOL' or 'CONTENT_LENGTH' in environ:
             data = data.read()
+            if data.startswith('(create-txn-with-props'):
+                # store on-the-fly our rc_extra using svn revision properties
+                # those can be read later on in hooks executed so we have a way
+                # to pass in the data into svn hooks
+                rc_data = base64.urlsafe_b64encode(json.dumps(self.rc_extras))
+                rc_data_len = len(rc_data)
+                # header defines data lenght, and serialized data
+                skel = ' rc-scm-extras {} {}'.format(rc_data_len, rc_data)
+                data = data[:-2] + skel + '))'
 
         log.debug('Calling: %s method via `%s`', environ['REQUEST_METHOD'],
                   self._get_url(environ['PATH_INFO']))
+
         response = requests.request(
             environ['REQUEST_METHOD'], self._get_url(environ['PATH_INFO']),
             data=data, headers=request_headers)
 
         if response.status_code not in [200, 401]:
             if response.status_code >= 500:
                 log.error('Got SVN response:%s with text:`%s`',
                           response, response.text)
             else:
                 log.debug('Got SVN response:%s with text:`%s`',
                           response, response.text)
         else:
             log.debug('got response code: %s', response.status_code)
 
         response_headers = self._get_response_headers(response.headers)
+
+        if response.headers.get('SVN-Txn-name'):
+            svn_tx_id = response.headers.get('SVN-Txn-name')
+            txn_id = caches.compute_key_from_params(
+                self.config['repository'], svn_tx_id)
+            port = safe_int(self.rc_extras['hooks_uri'].split(':')[-1])
+            store_txn_id_data(txn_id, {'port': port})
+
         start_response(
             '{} {}'.format(response.status_code, response.reason),
             response_headers)
         return response.iter_content(chunk_size=1024)
 
     def _get_url(self, path):
         url_path = urljoin(
             self.config.get('subversion_http_server_url', ''), path)
         url_path = urllib.quote(url_path, safe="/:=~+!$,;'")
         return url_path
 
     def _get_request_headers(self, environ):
         headers = {}
 
         for key in environ:
             if not key.startswith('HTTP_'):
                 continue
             new_key = key.split('_')
             new_key = [k.capitalize() for k in new_key[1:]]
             new_key = '-'.join(new_key)
             headers[new_key] = environ[key]
 
         if 'CONTENT_TYPE' in environ:
             headers['Content-Type'] = environ['CONTENT_TYPE']
 
         if 'CONTENT_LENGTH' in environ:
             headers['Content-Length'] = environ['CONTENT_LENGTH']
 
         return headers
 
     def _get_response_headers(self, headers):
         headers = [
             (h, headers[h])
             for h in headers
             if h.lower() not in self.IGNORED_HEADERS
         ]
 
         return headers
 
 
 class DisabledSimpleSvnApp(object):
     def __init__(self, config):
         self.config = config
 
     def __call__(self, environ, start_response):
         reason = 'Cannot handle SVN call because: SVN HTTP Proxy is not enabled'
         log.warning(reason)
         return HTTPNotAcceptable(reason)(environ, start_response)
 
 
 class SimpleSvn(simplevcs.SimpleVCS):
 
     SCM = 'svn'
     READ_ONLY_COMMANDS = ('OPTIONS', 'PROPFIND', 'GET', 'REPORT')
     DEFAULT_HTTP_SERVER = 'http://localhost:8090'
 
     def _get_repository_name(self, environ):
         """
         Gets repository name out of PATH_INFO header
 
         :param environ: environ where PATH_INFO is stored
         """
         path = environ['PATH_INFO'].split('!')
         repo_name = path[0].strip('/')
 
         # SVN includes the whole path in it's requests, including
         # subdirectories inside the repo. Therefore we have to search for
         # the repo root directory.
         if not is_valid_repo(
                 repo_name, self.base_path, explicit_scm=self.SCM):
             current_path = ''
             for component in repo_name.split('/'):
                 current_path += component
                 if is_valid_repo(
                         current_path, self.base_path, explicit_scm=self.SCM):
                     return current_path
                 current_path += '/'
 
         return repo_name
 
     def _get_action(self, environ):
         return (
             'pull'
             if environ['REQUEST_METHOD'] in self.READ_ONLY_COMMANDS
             else 'push')
 
+    def _should_use_callback_daemon(self, extras, environ, action):
+        # only MERGE command triggers hooks, so we don't want to start
+        # hooks server too many times. POST however starts the svn transaction
+        # so we also need to run the init of callback daemon of POST
+        if environ['REQUEST_METHOD'] in ['MERGE', 'POST']:
+            return True
+        return False
+
     def _create_wsgi_app(self, repo_path, repo_name, config):
         if self._is_svn_enabled():
             return SimpleSvnApp(config)
         # we don't have http proxy enabled return dummy request handler
         return DisabledSimpleSvnApp(config)
 
     def _is_svn_enabled(self):
         conf = self.repo_vcs_config
         return str2bool(conf.get('vcs_svn_proxy', 'http_requests_enabled'))
 
     def _create_config(self, extras, repo_name):
         conf = self.repo_vcs_config
         server_url = conf.get('vcs_svn_proxy', 'http_server_url')
         server_url = server_url or self.DEFAULT_HTTP_SERVER
 
         extras['subversion_http_server_url'] = server_url
         return extras

rhodecode/lib/middleware/simplevcs.py

@@ -1,648 +1,673 b''
 # -*- coding: utf-8 -*-
 
 # Copyright (C) 2014-2018 RhodeCode GmbH
 #
 # This program is free software: you can redistribute it and/or modify
 # it under the terms of the GNU Affero General Public License, version 3
 # (only), as published by the Free Software Foundation.
 #
 # 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 Affero General Public License
 # along with this program.  If not, see <http://www.gnu.org/licenses/>.
 #
 # This program is dual-licensed. If you wish to learn more about the
 # RhodeCode Enterprise Edition, including its added features, Support services,
 # and proprietary license terms, please see https://rhodecode.com/licenses/
 
 """
 SimpleVCS middleware for handling protocol request (push/clone etc.)
 It's implemented with basic auth function
 """
 
 import os
 import re
 import logging
 import importlib
 from functools import wraps
+from StringIO import StringIO
+from lxml import etree
 
 import time
 from paste.httpheaders import REMOTE_USER, AUTH_TYPE
-# TODO(marcink): check if we should use webob.exc here ?
+
 from pyramid.httpexceptions import (
     HTTPNotFound, HTTPForbidden, HTTPNotAcceptable, HTTPInternalServerError)
 from zope.cachedescriptors.property import Lazy as LazyProperty
 
 import rhodecode
 from rhodecode.authentication.base import (
     authenticate, get_perms_cache_manager, VCS_TYPE, loadplugin)
 from rhodecode.lib import caches
 from rhodecode.lib.auth import AuthUser, HasPermissionAnyMiddleware
 from rhodecode.lib.base import (
     BasicAuth, get_ip_addr, get_user_agent, vcs_operation_context)
-from rhodecode.lib.exceptions import (
-    HTTPLockedRC, HTTPRequirementError, UserCreationError,
-    NotAllowedToCreateUserError)
+from rhodecode.lib.exceptions import (UserCreationError, NotAllowedToCreateUserError)
 from rhodecode.lib.hooks_daemon import prepare_callback_daemon
 from rhodecode.lib.middleware import appenlight
 from rhodecode.lib.middleware.utils import scm_app_http
 from rhodecode.lib.utils import is_valid_repo, SLUG_RE
 from rhodecode.lib.utils2 import safe_str, fix_PATH, str2bool, safe_unicode
 from rhodecode.lib.vcs.conf import settings as vcs_settings
 from rhodecode.lib.vcs.backends import base
+
 from rhodecode.model import meta
 from rhodecode.model.db import User, Repository, PullRequest
 from rhodecode.model.scm import ScmModel
 from rhodecode.model.pull_request import PullRequestModel
 from rhodecode.model.settings import SettingsModel, VcsSettingsModel
 
 log = logging.getLogger(__name__)
 
 
+def extract_svn_txn_id(acl_repo_name, data):
+    """
+    Helper method for extraction of svn txn_id from submited XML data during
+    POST operations
+    """
+    try:
+        root = etree.fromstring(data)
+        pat = re.compile(r'/txn/(?P<txn_id>.*)')
+        for el in root:
+            if el.tag == '{DAV:}source':
+                for sub_el in el:
+                    if sub_el.tag == '{DAV:}href':
+                        match = pat.search(sub_el.text)
+                        if match:
+                            svn_tx_id = match.groupdict()['txn_id']
+                            txn_id = caches.compute_key_from_params(
+                                acl_repo_name, svn_tx_id)
+                            return txn_id
+    except Exception:
+        log.exception('Failed to extract txn_id')
+
+
 def initialize_generator(factory):
     """
     Initializes the returned generator by draining its first element.
 
     This can be used to give a generator an initializer, which is the code
     up to the first yield statement. This decorator enforces that the first
     produced element has the value ``"__init__"`` to make its special
     purpose very explicit in the using code.
     """
 
     @wraps(factory)
     def wrapper(*args, **kwargs):
         gen = factory(*args, **kwargs)
         try:
             init = gen.next()
         except StopIteration:
             raise ValueError('Generator must yield at least one element.')
         if init != "__init__":
             raise ValueError('First yielded element must be "__init__".')
         return gen
     return wrapper
 
 
 class SimpleVCS(object):
     """Common functionality for SCM HTTP handlers."""
 
     SCM = 'unknown'
 
     acl_repo_name = None
     url_repo_name = None
     vcs_repo_name = None
     rc_extras = {}
 
     # We have to handle requests to shadow repositories different than requests
     # to normal repositories. Therefore we have to distinguish them. To do this
     # we use this regex which will match only on URLs pointing to shadow
     # repositories.
     shadow_repo_re = re.compile(
         '(?P<groups>(?:{slug_pat}/)*)'  # repo groups
         '(?P<target>{slug_pat})/'       # target repo
         'pull-request/(?P<pr_id>\d+)/'  # pull request
         'repository$'                   # shadow repo
         .format(slug_pat=SLUG_RE.pattern))
 
     def __init__(self, config, registry):
         self.registry = registry
         self.config = config
         # re-populated by specialized middleware
         self.repo_vcs_config = base.Config()
         self.rhodecode_settings = SettingsModel().get_all_settings(cache=True)
 
         registry.rhodecode_settings = self.rhodecode_settings
         # authenticate this VCS request using authfunc
         auth_ret_code_detection = \
             str2bool(self.config.get('auth_ret_code_detection', False))
         self.authenticate = BasicAuth(
             '', authenticate, registry, config.get('auth_ret_code'),
             auth_ret_code_detection)
         self.ip_addr = '0.0.0.0'
 
     @LazyProperty
     def global_vcs_config(self):
         try:
             return VcsSettingsModel().get_ui_settings_as_config_obj()
         except Exception:
             return base.Config()
 
     @property
     def base_path(self):
         settings_path = self.repo_vcs_config.get(
             *VcsSettingsModel.PATH_SETTING)
 
         if not settings_path:
             settings_path = self.global_vcs_config.get(
             *VcsSettingsModel.PATH_SETTING)
 
         if not settings_path:
             # try, maybe we passed in explicitly as config option
             settings_path = self.config.get('base_path')
 
         if not settings_path:
             raise ValueError('FATAL: base_path is empty')
         return settings_path
 
     def set_repo_names(self, environ):
         """
         This will populate the attributes acl_repo_name, url_repo_name,
         vcs_repo_name and is_shadow_repo. In case of requests to normal (non
         shadow) repositories all names are equal. In case of requests to a
         shadow repository the acl-name points to the target repo of the pull
         request and the vcs-name points to the shadow repo file system path.
         The url-name is always the URL used by the vcs client program.
 
         Example in case of a shadow repo:
             acl_repo_name = RepoGroup/MyRepo
             url_repo_name = RepoGroup/MyRepo/pull-request/3/repository
             vcs_repo_name = /repo/base/path/RepoGroup/.__shadow_MyRepo_pr-3'
         """
         # First we set the repo name from URL for all attributes. This is the
         # default if handling normal (non shadow) repo requests.
         self.url_repo_name = self._get_repository_name(environ)
         self.acl_repo_name = self.vcs_repo_name = self.url_repo_name
         self.is_shadow_repo = False
 
         # Check if this is a request to a shadow repository.
         match = self.shadow_repo_re.match(self.url_repo_name)
         if match:
             match_dict = match.groupdict()
 
             # Build acl repo name from regex match.
             acl_repo_name = safe_unicode('{groups}{target}'.format(
                 groups=match_dict['groups'] or '',
                 target=match_dict['target']))
 
             # Retrieve pull request instance by ID from regex match.
             pull_request = PullRequest.get(match_dict['pr_id'])
 
             # Only proceed if we got a pull request and if acl repo name from
             # URL equals the target repo name of the pull request.
             if pull_request and (acl_repo_name ==
                                  pull_request.target_repo.repo_name):
                 # Get file system path to shadow repository.
                 workspace_id = PullRequestModel()._workspace_id(pull_request)
                 target_vcs = pull_request.target_repo.scm_instance()
                 vcs_repo_name = target_vcs._get_shadow_repository_path(
                     workspace_id)
 
                 # Store names for later usage.
                 self.vcs_repo_name = vcs_repo_name
                 self.acl_repo_name = acl_repo_name
                 self.is_shadow_repo = True
 
         log.debug('Setting all VCS repository names: %s', {
             'acl_repo_name': self.acl_repo_name,
             'url_repo_name': self.url_repo_name,
             'vcs_repo_name': self.vcs_repo_name,
         })
 
     @property
     def scm_app(self):
         custom_implementation = self.config['vcs.scm_app_implementation']
         if custom_implementation == 'http':
             log.info('Using HTTP implementation of scm app.')
             scm_app_impl = scm_app_http
         else:
             log.info('Using custom implementation of scm_app: "{}"'.format(
                 custom_implementation))
             scm_app_impl = importlib.import_module(custom_implementation)
         return scm_app_impl
 
     def _get_by_id(self, repo_name):
         """
         Gets a special pattern _<ID> from clone url and tries to replace it
         with a repository_name for support of _<ID> non changeable urls
         """
 
         data = repo_name.split('/')
         if len(data) >= 2:
             from rhodecode.model.repo import RepoModel
             by_id_match = RepoModel().get_repo_by_id(repo_name)
             if by_id_match:
                 data[1] = by_id_match.repo_name
 
         return safe_str('/'.join(data))
 
     def _invalidate_cache(self, repo_name):
         """
         Set's cache for this repository for invalidation on next access
 
         :param repo_name: full repo name, also a cache key
         """
         ScmModel().mark_for_invalidation(repo_name)
 
     def is_valid_and_existing_repo(self, repo_name, base_path, scm_type):
         db_repo = Repository.get_by_repo_name(repo_name)
         if not db_repo:
             log.debug('Repository `%s` not found inside the database.',
                       repo_name)
             return False
 
         if db_repo.repo_type != scm_type:
             log.warning(
                 'Repository `%s` have incorrect scm_type, expected %s got %s',
                 repo_name, db_repo.repo_type, scm_type)
             return False
 
         config = db_repo._config
         config.set('extensions', 'largefiles', '')
         return is_valid_repo(
             repo_name, base_path,
             explicit_scm=scm_type, expect_scm=scm_type, config=config)
 
     def valid_and_active_user(self, user):
         """
         Checks if that user is not empty, and if it's actually object it checks
         if he's active.
 
         :param user: user object or None
         :return: boolean
         """
         if user is None:
             return False
 
         elif user.active:
             return True
 
         return False
 
     @property
     def is_shadow_repo_dir(self):
         return os.path.isdir(self.vcs_repo_name)
 
     def _check_permission(self, action, user, repo_name, ip_addr=None,
                           plugin_id='', plugin_cache_active=False, cache_ttl=0):
         """
         Checks permissions using action (push/pull) user and repository
         name. If plugin_cache and ttl is set it will use the plugin which
         authenticated the user to store the cached permissions result for N
         amount of seconds as in cache_ttl
 
         :param action: push or pull action
         :param user: user instance
         :param repo_name: repository name
         """
 
         # get instance of cache manager configured for a namespace
         cache_manager = get_perms_cache_manager(
             custom_ttl=cache_ttl, suffix=user.user_id)
         log.debug('AUTH_CACHE_TTL for permissions `%s` active: %s (TTL: %s)',
                   plugin_id, plugin_cache_active, cache_ttl)
 
         # for environ based password can be empty, but then the validation is
         # on the server that fills in the env data needed for authentication
         _perm_calc_hash = caches.compute_key_from_params(
             plugin_id, action, user.user_id, repo_name, ip_addr)
 
         # _authenticate is a wrapper for .auth() method of plugin.
         # it checks if .auth() sends proper data.
         # For RhodeCodeExternalAuthPlugin it also maps users to
         # Database and maps the attributes returned from .auth()
         # to RhodeCode database. If this function returns data
         # then auth is correct.
         start = time.time()
         log.debug('Running plugin `%s` permissions check', plugin_id)
 
         def perm_func():
             """
             This function is used internally in Cache of Beaker to calculate
             Results
             """
             log.debug('auth: calculating permission access now...')
             # check IP
             inherit = user.inherit_default_permissions
             ip_allowed = AuthUser.check_ip_allowed(
                 user.user_id, ip_addr, inherit_from_default=inherit)
             if ip_allowed:
                 log.info('Access for IP:%s allowed', ip_addr)
             else:
                 return False
 
             if action == 'push':
                 perms = ('repository.write', 'repository.admin')
                 if not HasPermissionAnyMiddleware(*perms)(user, repo_name):
                     return False
 
             else:
                 # any other action need at least read permission
                 perms = (
                     'repository.read', 'repository.write', 'repository.admin')
                 if not HasPermissionAnyMiddleware(*perms)(user, repo_name):
                     return False
 
             return True
 
         if plugin_cache_active:
             log.debug('Trying to fetch cached perms by %s', _perm_calc_hash[:6])
             perm_result = cache_manager.get(
                 _perm_calc_hash, createfunc=perm_func)
         else:
             perm_result = perm_func()
 
         auth_time = time.time() - start
         log.debug('Permissions for plugin `%s` completed in %.3fs, '
                   'expiration time of fetched cache %.1fs.',
                   plugin_id, auth_time, cache_ttl)
 
         return perm_result
 
     def _check_ssl(self, environ, start_response):
         """
         Checks the SSL check flag and returns False if SSL is not present
         and required True otherwise
         """
         org_proto = environ['wsgi._org_proto']
         # check if we have SSL required  ! if not it's a bad request !
         require_ssl = str2bool(self.repo_vcs_config.get('web', 'push_ssl'))
         if require_ssl and org_proto == 'http':
             log.debug(
                 'Bad request: detected protocol is `%s` and '
                 'SSL/HTTPS is required.', org_proto)
             return False
         return True
 
     def _get_default_cache_ttl(self):
         # take AUTH_CACHE_TTL from the `rhodecode` auth plugin
         plugin = loadplugin('egg:rhodecode-enterprise-ce#rhodecode')
         plugin_settings = plugin.get_settings()
         plugin_cache_active, cache_ttl = plugin.get_ttl_cache(
             plugin_settings) or (False, 0)
         return plugin_cache_active, cache_ttl
 
     def __call__(self, environ, start_response):
         try:
             return self._handle_request(environ, start_response)
         except Exception:
             log.exception("Exception while handling request")
             appenlight.track_exception(environ)
             return HTTPInternalServerError()(environ, start_response)
         finally:
             meta.Session.remove()
 
     def _handle_request(self, environ, start_response):
 
         if not self._check_ssl(environ, start_response):
             reason = ('SSL required, while RhodeCode was unable '
                       'to detect this as SSL request')
             log.debug('User not allowed to proceed, %s', reason)
             return HTTPNotAcceptable(reason)(environ, start_response)
 
         if not self.url_repo_name:
             log.warning('Repository name is empty: %s', self.url_repo_name)
             # failed to get repo name, we fail now
             return HTTPNotFound()(environ, start_response)
         log.debug('Extracted repo name is %s', self.url_repo_name)
 
         ip_addr = get_ip_addr(environ)
         user_agent = get_user_agent(environ)
         username = None
 
         # skip passing error to error controller
         environ['pylons.status_code_redirect'] = True
 
         # ======================================================================
         # GET ACTION PULL or PUSH
         # ======================================================================
         action = self._get_action(environ)
 
         # ======================================================================
         # Check if this is a request to a shadow repository of a pull request.
         # In this case only pull action is allowed.
         # ======================================================================
         if self.is_shadow_repo and action != 'pull':
             reason = 'Only pull action is allowed for shadow repositories.'
             log.debug('User not allowed to proceed, %s', reason)
             return HTTPNotAcceptable(reason)(environ, start_response)
 
         # Check if the shadow repo actually exists, in case someone refers
         # to it, and it has been deleted because of successful merge.
         if self.is_shadow_repo and not self.is_shadow_repo_dir:
             log.debug(
                 'Shadow repo detected, and shadow repo dir `%s` is missing',
                 self.is_shadow_repo_dir)
             return HTTPNotFound()(environ, start_response)
 
         # ======================================================================
         # CHECK ANONYMOUS PERMISSION
         # ======================================================================
         if action in ['pull', 'push']:
             anonymous_user = User.get_default_user()
             username = anonymous_user.username
             if anonymous_user.active:
                 plugin_cache_active, cache_ttl = self._get_default_cache_ttl()
                 # ONLY check permissions if the user is activated
                 anonymous_perm = self._check_permission(
                     action, anonymous_user, self.acl_repo_name, ip_addr,
                     plugin_id='anonymous_access',
                     plugin_cache_active=plugin_cache_active,
                     cache_ttl=cache_ttl,
                 )
             else:
                 anonymous_perm = False
 
             if not anonymous_user.active or not anonymous_perm:
                 if not anonymous_user.active:
                     log.debug('Anonymous access is disabled, running '
                               'authentication')
 
                 if not anonymous_perm:
                     log.debug('Not enough credentials to access this '
                               'repository as anonymous user')
 
                 username = None
                 # ==============================================================
                 # DEFAULT PERM FAILED OR ANONYMOUS ACCESS IS DISABLED SO WE
                 # NEED TO AUTHENTICATE AND ASK FOR AUTH USER PERMISSIONS
                 # ==============================================================
 
                 # try to auth based on environ, container auth methods
                 log.debug('Running PRE-AUTH for container based authentication')
                 pre_auth = authenticate(
                     '', '', environ, VCS_TYPE, registry=self.registry,
                     acl_repo_name=self.acl_repo_name)
                 if pre_auth and pre_auth.get('username'):
                     username = pre_auth['username']
                 log.debug('PRE-AUTH got %s as username', username)
                 if pre_auth:
                     log.debug('PRE-AUTH successful from %s',
                               pre_auth.get('auth_data', {}).get('_plugin'))
 
                 # If not authenticated by the container, running basic auth
                 # before inject the calling repo_name for special scope checks
                 self.authenticate.acl_repo_name = self.acl_repo_name
 
                 plugin_cache_active, cache_ttl = False, 0
                 plugin = None
                 if not username:
                     self.authenticate.realm = self.authenticate.get_rc_realm()
 
                     try:
                         auth_result = self.authenticate(environ)
                     except (UserCreationError, NotAllowedToCreateUserError) as e:
                         log.error(e)
                         reason = safe_str(e)
                         return HTTPNotAcceptable(reason)(environ, start_response)
 
                     if isinstance(auth_result, dict):
                         AUTH_TYPE.update(environ, 'basic')
                         REMOTE_USER.update(environ, auth_result['username'])
                         username = auth_result['username']
                         plugin = auth_result.get('auth_data', {}).get('_plugin')
                         log.info(
                             'MAIN-AUTH successful for user `%s` from %s plugin',
                             username, plugin)
 
                         plugin_cache_active, cache_ttl = auth_result.get(
                             'auth_data', {}).get('_ttl_cache') or (False, 0)
                     else:
                         return auth_result.wsgi_application(
                             environ, start_response)
 
 
                 # ==============================================================
                 # CHECK PERMISSIONS FOR THIS REQUEST USING GIVEN USERNAME
                 # ==============================================================
                 user = User.get_by_username(username)
                 if not self.valid_and_active_user(user):
                     return HTTPForbidden()(environ, start_response)
                 username = user.username
                 user.update_lastactivity()
                 meta.Session().commit()
 
                 # check user attributes for password change flag
                 user_obj = user
                 if user_obj and user_obj.username != User.DEFAULT_USER and \
                         user_obj.user_data.get('force_password_change'):
                     reason = 'password change required'
                     log.debug('User not allowed to authenticate, %s', reason)
                     return HTTPNotAcceptable(reason)(environ, start_response)
 
                 # check permissions for this repository
                 perm = self._check_permission(
                     action, user, self.acl_repo_name, ip_addr,
                     plugin, plugin_cache_active, cache_ttl)
                 if not perm:
                     return HTTPForbidden()(environ, start_response)
 
         # extras are injected into UI object and later available
         # in hooks executed by RhodeCode
         check_locking = _should_check_locking(environ.get('QUERY_STRING'))
         extras = vcs_operation_context(
             environ, repo_name=self.acl_repo_name, username=username,
             action=action, scm=self.SCM, check_locking=check_locking,
             is_shadow_repo=self.is_shadow_repo
         )
 
         # ======================================================================
         # REQUEST HANDLING
         # ======================================================================
         repo_path = os.path.join(
             safe_str(self.base_path), safe_str(self.vcs_repo_name))
         log.debug('Repository path is %s', repo_path)
 
         fix_PATH()
 
         log.info(
             '%s action on %s repo "%s" by "%s" from %s %s',
             action, self.SCM, safe_str(self.url_repo_name),
             safe_str(username), ip_addr, user_agent)
 
         return self._generate_vcs_response(
             environ, start_response, repo_path, extras, action)
 
     @initialize_generator
     def _generate_vcs_response(
             self, environ, start_response, repo_path, extras, action):
         """
         Returns a generator for the response content.
 
         This method is implemented as a generator, so that it can trigger
         the cache validation after all content sent back to the client. It
         also handles the locking exceptions which will be triggered when
         the first chunk is produced by the underlying WSGI application.
         """
-        callback_daemon, extras = self._prepare_callback_daemon(extras)
+        txn_id = ''
+        if 'CONTENT_LENGTH' in environ and environ['REQUEST_METHOD'] == 'MERGE':
+            # case for SVN, we want to re-use the callback daemon port
+            # so we use the txn_id, for this we peek the body, and still save
+            # it as wsgi.input
+            data = environ['wsgi.input'].read()
+            environ['wsgi.input'] = StringIO(data)
+            txn_id = extract_svn_txn_id(self.acl_repo_name, data)
+
+        callback_daemon, extras = self._prepare_callback_daemon(
+            extras, environ, action, txn_id=txn_id)
+        log.debug('HOOKS extras is %s', extras)
+
         config = self._create_config(extras, self.acl_repo_name)
-        log.debug('HOOKS extras is %s', extras)
         app = self._create_wsgi_app(repo_path, self.url_repo_name, config)
+        with callback_daemon:
         app.rc_extras = extras
 
         try:
-            with callback_daemon:
-                try:
                     response = app(environ, start_response)
                 finally:
                     # This statement works together with the decorator
                     # "initialize_generator" above. The decorator ensures that
                     # we hit the first yield statement before the generator is
                     # returned back to the WSGI server. This is needed to
                     # ensure that the call to "app" above triggers the
                     # needed callback to "start_response" before the
                     # generator is actually used.
                     yield "__init__"
 
+            # iter content
                 for chunk in response:
                     yield chunk
-        except Exception as exc:
-            # TODO: martinb: Exceptions are only raised in case of the Pyro4
-            # backend. Refactor this except block after dropping Pyro4 support.
-            # TODO: johbo: Improve "translating" back the exception.
-            if getattr(exc, '_vcs_kind', None) == 'repo_locked':
-                exc = HTTPLockedRC(*exc.args)
-                _code = rhodecode.CONFIG.get('lock_ret_code')
-                log.debug('Repository LOCKED ret code %s!', (_code,))
-            elif getattr(exc, '_vcs_kind', None) == 'requirement':
-                log.debug(
-                    'Repository requires features unknown to this Mercurial')
-                exc = HTTPRequirementError(*exc.args)
-            else:
-                raise
 
-            for chunk in exc(environ, start_response):
-                yield chunk
-        finally:
+            try:
             # invalidate cache on push
-            try:
                 if action == 'push':
                     self._invalidate_cache(self.url_repo_name)
             finally:
                 meta.Session.remove()
 
     def _get_repository_name(self, environ):
         """Get repository name out of the environmnent
 
         :param environ: WSGI environment
         """
         raise NotImplementedError()
 
     def _get_action(self, environ):
         """Map request commands into a pull or push command.
 
         :param environ: WSGI environment
         """
         raise NotImplementedError()
 
     def _create_wsgi_app(self, repo_path, repo_name, config):
         """Return the WSGI app that will finally handle the request."""
         raise NotImplementedError()
 
     def _create_config(self, extras, repo_name):
         """Create a safe config representation."""
         raise NotImplementedError()
 
-    def _prepare_callback_daemon(self, extras):
+    def _should_use_callback_daemon(self, extras, environ, action):
+        return True
+
+    def _prepare_callback_daemon(self, extras, environ, action, txn_id=None):
+        direct_calls = vcs_settings.HOOKS_DIRECT_CALLS
+        if not self._should_use_callback_daemon(extras, environ, action):
+            # disable callback daemon for actions that don't require it
+            direct_calls = True
+
         return prepare_callback_daemon(
             extras, protocol=vcs_settings.HOOKS_PROTOCOL,
-            use_direct_calls=vcs_settings.HOOKS_DIRECT_CALLS)
+            use_direct_calls=direct_calls, txn_id=txn_id)
 
 
 def _should_check_locking(query_string):
     # this is kind of hacky, but due to how mercurial handles client-server
     # server see all operation on commit; bookmarks, phases and
     # obsolescence marker in different transaction, we don't want to check
     # locking on those
     return query_string not in ['cmd=listkeys']

rhodecode/lib/utils.py

@@ -1,781 +1,779 b''
 # -*- coding: utf-8 -*-
 
 # Copyright (C) 2010-2018 RhodeCode GmbH
 #
 # This program is free software: you can redistribute it and/or modify
 # it under the terms of the GNU Affero General Public License, version 3
 # (only), as published by the Free Software Foundation.
 #
 # 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 Affero General Public License
 # along with this program.  If not, see <http://www.gnu.org/licenses/>.
 #
 # This program is dual-licensed. If you wish to learn more about the
 # RhodeCode Enterprise Edition, including its added features, Support services,
 # and proprietary license terms, please see https://rhodecode.com/licenses/
 
 """
 Utilities library for RhodeCode
 """
 
 import datetime
 import decorator
 import json
 import logging
 import os
 import re
 import shutil
 import tempfile
 import traceback
 import tarfile
 import warnings
 import hashlib
 from os.path import join as jn
 
 import paste
 import pkg_resources
 from webhelpers.text import collapse, remove_formatting, strip_tags
 from mako import exceptions
 from pyramid.threadlocal import get_current_registry
 from pyramid.request import Request
 
 from rhodecode.lib.fakemod import create_module
 from rhodecode.lib.vcs.backends.base import Config
 from rhodecode.lib.vcs.exceptions import VCSError
 from rhodecode.lib.vcs.utils.helpers import get_scm, get_scm_backend
 from rhodecode.lib.utils2 import (
     safe_str, safe_unicode, get_current_rhodecode_user, md5)
 from rhodecode.model import meta
 from rhodecode.model.db import (
     Repository, User, RhodeCodeUi, UserLog, RepoGroup, UserGroup)
 from rhodecode.model.meta import Session
 
 
 log = logging.getLogger(__name__)
 
 REMOVED_REPO_PAT = re.compile(r'rm__\d{8}_\d{6}_\d{6}__.*')
 
 # String which contains characters that are not allowed in slug names for
 # repositories or repository groups. It is properly escaped to use it in
 # regular expressions.
 SLUG_BAD_CHARS = re.escape('`?=[]\;\'"<>,/~!@#$%^&*()+{}|:')
 
 # Regex that matches forbidden characters in repo/group slugs.
 SLUG_BAD_CHAR_RE = re.compile('[{}]'.format(SLUG_BAD_CHARS))
 
 # Regex that matches allowed characters in repo/group slugs.
 SLUG_GOOD_CHAR_RE = re.compile('[^{}]'.format(SLUG_BAD_CHARS))
 
 # Regex that matches whole repo/group slugs.
 SLUG_RE = re.compile('[^{}]+'.format(SLUG_BAD_CHARS))
 
 _license_cache = None
 
 
 def repo_name_slug(value):
     """
     Return slug of name of repository
     This function is called on each creation/modification
     of repository to prevent bad names in repo
     """
     replacement_char = '-'
 
     slug = remove_formatting(value)
     slug = SLUG_BAD_CHAR_RE.sub('', slug)
     slug = re.sub('[\s]+', '-', slug)
     slug = collapse(slug, replacement_char)
     return slug
 
 
 #==============================================================================
 # PERM DECORATOR HELPERS FOR EXTRACTING NAMES FOR PERM CHECKS
 #==============================================================================
 def get_repo_slug(request):
     _repo = ''
 
     if hasattr(request, 'db_repo'):
         # if our requests has set db reference use it for name, this
         # translates the example.com/_<id> into proper repo names
         _repo = request.db_repo.repo_name
     elif getattr(request, 'matchdict', None):
         # pyramid
         _repo = request.matchdict.get('repo_name')
 
     if _repo:
         _repo = _repo.rstrip('/')
     return _repo
 
 
 def get_repo_group_slug(request):
     _group = ''
     if hasattr(request, 'db_repo_group'):
         # if our requests has set db reference use it for name, this
         # translates the example.com/_<id> into proper repo group names
         _group = request.db_repo_group.group_name
     elif getattr(request, 'matchdict', None):
         # pyramid
         _group = request.matchdict.get('repo_group_name')
 
 
     if _group:
         _group = _group.rstrip('/')
     return _group
 
 
 def get_user_group_slug(request):
     _user_group = ''
 
     if hasattr(request, 'db_user_group'):
         _user_group = request.db_user_group.users_group_name
     elif getattr(request, 'matchdict', None):
         # pyramid
         _user_group = request.matchdict.get('user_group_id')
         _user_group_name = request.matchdict.get('user_group_name')
         try:
             if _user_group:
                 _user_group = UserGroup.get(_user_group)
             elif _user_group_name:
                 _user_group = UserGroup.get_by_group_name(_user_group_name)
 
             if _user_group:
                 _user_group = _user_group.users_group_name
         except Exception:
             log.exception('Failed to get user group by id and name')
             # catch all failures here
             return None
 
     return _user_group
 
 
 def get_filesystem_repos(path, recursive=False, skip_removed_repos=True):
     """
     Scans given path for repos and return (name,(type,path)) tuple
 
     :param path: path to scan for repositories
     :param recursive: recursive search and return names with subdirs in front
     """
 
     # remove ending slash for better results
     path = path.rstrip(os.sep)
     log.debug('now scanning in %s location recursive:%s...', path, recursive)
 
     def _get_repos(p):
         dirpaths = _get_dirpaths(p)
         if not _is_dir_writable(p):
             log.warning('repo path without write access: %s', p)
 
         for dirpath in dirpaths:
             if os.path.isfile(os.path.join(p, dirpath)):
                 continue
             cur_path = os.path.join(p, dirpath)
 
             # skip removed repos
             if skip_removed_repos and REMOVED_REPO_PAT.match(dirpath):
                 continue
 
             #skip .<somethin> dirs
             if dirpath.startswith('.'):
                 continue
 
             try:
                 scm_info = get_scm(cur_path)
                 yield scm_info[1].split(path, 1)[-1].lstrip(os.sep), scm_info
             except VCSError:
                 if not recursive:
                     continue
                 #check if this dir containts other repos for recursive scan
                 rec_path = os.path.join(p, dirpath)
                 if os.path.isdir(rec_path):
                     for inner_scm in _get_repos(rec_path):
                         yield inner_scm
 
     return _get_repos(path)
 
 
 def _get_dirpaths(p):
     try:
         # OS-independable way of checking if we have at least read-only
         # access or not.
         dirpaths = os.listdir(p)
     except OSError:
         log.warning('ignoring repo path without read access: %s', p)
         return []
 
     # os.listpath has a tweak: If a unicode is passed into it, then it tries to
     # decode paths and suddenly returns unicode objects itself. The items it
     # cannot decode are returned as strings and cause issues.
     #
     # Those paths are ignored here until a solid solution for path handling has
     # been built.
     expected_type = type(p)
 
     def _has_correct_type(item):
         if type(item) is not expected_type:
             log.error(
                 u"Ignoring path %s since it cannot be decoded into unicode.",
                 # Using "repr" to make sure that we see the byte value in case
                 # of support.
                 repr(item))
             return False
         return True
 
     dirpaths = [item for item in dirpaths if _has_correct_type(item)]
 
     return dirpaths
 
 
 def _is_dir_writable(path):
     """
     Probe if `path` is writable.
 
     Due to trouble on Cygwin / Windows, this is actually probing if it is
     possible to create a file inside of `path`, stat does not produce reliable
     results in this case.
     """
     try:
         with tempfile.TemporaryFile(dir=path):
             pass
     except OSError:
         return False
     return True
 
 
 def is_valid_repo(repo_name, base_path, expect_scm=None, explicit_scm=None, config=None):
     """
     Returns True if given path is a valid repository False otherwise.
     If expect_scm param is given also, compare if given scm is the same
     as expected from scm parameter. If explicit_scm is given don't try to
     detect the scm, just use the given one to check if repo is valid
 
     :param repo_name:
     :param base_path:
     :param expect_scm:
     :param explicit_scm:
     :param config:
 
     :return True: if given path is a valid repository
     """
     full_path = os.path.join(safe_str(base_path), safe_str(repo_name))
     log.debug('Checking if `%s` is a valid path for repository. '
               'Explicit type: %s', repo_name, explicit_scm)
 
     try:
         if explicit_scm:
             detected_scms = [get_scm_backend(explicit_scm)(
                 full_path, config=config).alias]
         else:
             detected_scms = get_scm(full_path)
 
         if expect_scm:
             return detected_scms[0] == expect_scm
         log.debug('path: %s is an vcs object:%s', full_path, detected_scms)
         return True
     except VCSError:
         log.debug('path: %s is not a valid repo !', full_path)
         return False
 
 
 def is_valid_repo_group(repo_group_name, base_path, skip_path_check=False):
     """
     Returns True if given path is a repository group, False otherwise
 
     :param repo_name:
     :param base_path:
     """
     full_path = os.path.join(safe_str(base_path), safe_str(repo_group_name))
     log.debug('Checking if `%s` is a valid path for repository group',
               repo_group_name)
 
     # check if it's not a repo
     if is_valid_repo(repo_group_name, base_path):
         log.debug('Repo called %s exist, it is not a valid '
                   'repo group' % repo_group_name)
         return False
 
     try:
         # we need to check bare git repos at higher level
         # since we might match branches/hooks/info/objects or possible
         # other things inside bare git repo
         scm_ = get_scm(os.path.dirname(full_path))
         log.debug('path: %s is a vcs object:%s, not valid '
                   'repo group' % (full_path, scm_))
         return False
     except VCSError:
         pass
 
     # check if it's a valid path
     if skip_path_check or os.path.isdir(full_path):
         log.debug('path: %s is a valid repo group !', full_path)
         return True
 
     log.debug('path: %s is not a valid repo group !', full_path)
     return False
 
 
 def ask_ok(prompt, retries=4, complaint='[y]es or [n]o please!'):
     while True:
         ok = raw_input(prompt)
         if ok.lower() in ('y', 'ye', 'yes'):
             return True
         if ok.lower() in ('n', 'no', 'nop', 'nope'):
             return False
         retries = retries - 1
         if retries < 0:
             raise IOError
         print(complaint)
 
 # propagated from mercurial documentation
 ui_sections = [
     'alias', 'auth',
     'decode/encode', 'defaults',
     'diff', 'email',
     'extensions', 'format',
     'merge-patterns', 'merge-tools',
     'hooks', 'http_proxy',
     'smtp', 'patch',
     'paths', 'profiling',
     'server', 'trusted',
     'ui', 'web', ]
 
 
 def config_data_from_db(clear_session=True, repo=None):
     """
     Read the configuration data from the database and return configuration
     tuples.
     """
     from rhodecode.model.settings import VcsSettingsModel
 
     config = []
 
     sa = meta.Session()
     settings_model = VcsSettingsModel(repo=repo, sa=sa)
 
     ui_settings = settings_model.get_ui_settings()
 
     ui_data = []
     for setting in ui_settings:
         if setting.active:
             ui_data.append((setting.section, setting.key, setting.value))
             config.append((
                 safe_str(setting.section), safe_str(setting.key),
                 safe_str(setting.value)))
         if setting.key == 'push_ssl':
             # force set push_ssl requirement to False, rhodecode
             # handles that
             config.append((
                 safe_str(setting.section), safe_str(setting.key), False))
     log.debug(
         'settings ui from db: %s',
         ','.join(map(lambda s: '[{}] {}={}'.format(*s), ui_data)))
     if clear_session:
         meta.Session.remove()
 
     # TODO: mikhail: probably it makes no sense to re-read hooks information.
     # It's already there and activated/deactivated
     skip_entries = []
     enabled_hook_classes = get_enabled_hook_classes(ui_settings)
     if 'pull' not in enabled_hook_classes:
         skip_entries.append(('hooks', RhodeCodeUi.HOOK_PRE_PULL))
     if 'push' not in enabled_hook_classes:
         skip_entries.append(('hooks', RhodeCodeUi.HOOK_PRE_PUSH))
         skip_entries.append(('hooks', RhodeCodeUi.HOOK_PRETX_PUSH))
         skip_entries.append(('hooks', RhodeCodeUi.HOOK_PUSH_KEY))
 
     config = [entry for entry in config if entry[:2] not in skip_entries]
 
     return config
 
 
 def make_db_config(clear_session=True, repo=None):
     """
     Create a :class:`Config` instance based on the values in the database.
     """
     config = Config()
     config_data = config_data_from_db(clear_session=clear_session, repo=repo)
     for section, option, value in config_data:
         config.set(section, option, value)
     return config
 
 
 def get_enabled_hook_classes(ui_settings):
     """
     Return the enabled hook classes.
 
     :param ui_settings: List of ui_settings as returned
         by :meth:`VcsSettingsModel.get_ui_settings`
 
     :return: a list with the enabled hook classes. The order is not guaranteed.
     :rtype: list
     """
     enabled_hooks = []
     active_hook_keys = [
         key for section, key, value, active in ui_settings
         if section == 'hooks' and active]
 
     hook_names = {
         RhodeCodeUi.HOOK_PUSH: 'push',
         RhodeCodeUi.HOOK_PULL: 'pull',
         RhodeCodeUi.HOOK_REPO_SIZE: 'repo_size'
     }
 
     for key in active_hook_keys:
         hook = hook_names.get(key)
         if hook:
             enabled_hooks.append(hook)
 
     return enabled_hooks
 
 
 def set_rhodecode_config(config):
     """
     Updates pyramid config with new settings from database
 
     :param config:
     """
     from rhodecode.model.settings import SettingsModel
     app_settings = SettingsModel().get_all_settings()
 
     for k, v in app_settings.items():
         config[k] = v
 
 
 def get_rhodecode_realm():
     """
     Return the rhodecode realm from database.
     """
     from rhodecode.model.settings import SettingsModel
     realm = SettingsModel().get_setting_by_name('realm')
     return safe_str(realm.app_settings_value)
 
 
 def get_rhodecode_base_path():
     """
     Returns the base path. The base path is the filesystem path which points
     to the repository store.
     """
     from rhodecode.model.settings import SettingsModel
     paths_ui = SettingsModel().get_ui_by_section_and_key('paths', '/')
     return safe_str(paths_ui.ui_value)
 
 
 def map_groups(path):
     """
     Given a full path to a repository, create all nested groups that this
     repo is inside. This function creates parent-child relationships between
     groups and creates default perms for all new groups.
 
     :param paths: full path to repository
     """
     from rhodecode.model.repo_group import RepoGroupModel
     sa = meta.Session()
     groups = path.split(Repository.NAME_SEP)
     parent = None
     group = None
 
     # last element is repo in nested groups structure
     groups = groups[:-1]
     rgm = RepoGroupModel(sa)
     owner = User.get_first_super_admin()
     for lvl, group_name in enumerate(groups):
         group_name = '/'.join(groups[:lvl] + [group_name])
         group = RepoGroup.get_by_group_name(group_name)
         desc = '%s group' % group_name
 
         # skip folders that are now removed repos
         if REMOVED_REPO_PAT.match(group_name):
             break
 
         if group is None:
             log.debug('creating group level: %s group_name: %s',
                        lvl, group_name)
             group = RepoGroup(group_name, parent)
             group.group_description = desc
             group.user = owner
             sa.add(group)
             perm_obj = rgm._create_default_perms(group)
             sa.add(perm_obj)
             sa.flush()
 
         parent = group
     return group
 
 
 def repo2db_mapper(initial_repo_list, remove_obsolete=False):
     """
     maps all repos given in initial_repo_list, non existing repositories
     are created, if remove_obsolete is True it also checks for db entries
     that are not in initial_repo_list and removes them.
 
     :param initial_repo_list: list of repositories found by scanning methods
     :param remove_obsolete: check for obsolete entries in database
     """
     from rhodecode.model.repo import RepoModel
-    from rhodecode.model.scm import ScmModel
     from rhodecode.model.repo_group import RepoGroupModel
     from rhodecode.model.settings import SettingsModel
 
     sa = meta.Session()
     repo_model = RepoModel()
     user = User.get_first_super_admin()
     added = []
 
     # creation defaults
     defs = SettingsModel().get_default_repo_settings(strip_prefix=True)
     enable_statistics = defs.get('repo_enable_statistics')
     enable_locking = defs.get('repo_enable_locking')
     enable_downloads = defs.get('repo_enable_downloads')
     private = defs.get('repo_private')
 
     for name, repo in initial_repo_list.items():
         group = map_groups(name)
         unicode_name = safe_unicode(name)
         db_repo = repo_model.get_by_repo_name(unicode_name)
         # found repo that is on filesystem not in RhodeCode database
         if not db_repo:
             log.info('repository %s not found, creating now', name)
             added.append(name)
             desc = (repo.description
                     if repo.description != 'unknown'
                     else '%s repository' % name)
 
             db_repo = repo_model._create_repo(
                 repo_name=name,
                 repo_type=repo.alias,
                 description=desc,
                 repo_group=getattr(group, 'group_id', None),
                 owner=user,
                 enable_locking=enable_locking,
                 enable_downloads=enable_downloads,
                 enable_statistics=enable_statistics,
                 private=private,
                 state=Repository.STATE_CREATED
             )
             sa.commit()
             # we added that repo just now, and make sure we updated server info
             if db_repo.repo_type == 'git':
                 git_repo = db_repo.scm_instance()
                 # update repository server-info
                 log.debug('Running update server info')
                 git_repo._update_server_info()
 
             db_repo.update_commit_cache()
 
         config = db_repo._config
         config.set('extensions', 'largefiles', '')
-        ScmModel().install_hooks(
-            db_repo.scm_instance(config=config),
-            repo_type=db_repo.repo_type)
+        repo = db_repo.scm_instance(config=config)
+        repo.install_hooks()
 
     removed = []
     if remove_obsolete:
         # remove from database those repositories that are not in the filesystem
         for repo in sa.query(Repository).all():
             if repo.repo_name not in initial_repo_list.keys():
                 log.debug("Removing non-existing repository found in db `%s`",
                           repo.repo_name)
                 try:
                     RepoModel(sa).delete(repo, forks='detach', fs_remove=False)
                     sa.commit()
                     removed.append(repo.repo_name)
                 except Exception:
                     # don't hold further removals on error
                     log.error(traceback.format_exc())
                     sa.rollback()
 
         def splitter(full_repo_name):
             _parts = full_repo_name.rsplit(RepoGroup.url_sep(), 1)
             gr_name = None
             if len(_parts) == 2:
                 gr_name = _parts[0]
             return gr_name
 
         initial_repo_group_list = [splitter(x) for x in
                                    initial_repo_list.keys() if splitter(x)]
 
         # remove from database those repository groups that are not in the
         # filesystem due to parent child relationships we need to delete them
         # in a specific order of most nested first
         all_groups = [x.group_name for x in sa.query(RepoGroup).all()]
         nested_sort = lambda gr: len(gr.split('/'))
         for group_name in sorted(all_groups, key=nested_sort, reverse=True):
             if group_name not in initial_repo_group_list:
                 repo_group = RepoGroup.get_by_group_name(group_name)
                 if (repo_group.children.all() or
                     not RepoGroupModel().check_exist_filesystem(
                         group_name=group_name, exc_on_failure=False)):
                     continue
 
                 log.info(
                     'Removing non-existing repository group found in db `%s`',
                     group_name)
                 try:
                     RepoGroupModel(sa).delete(group_name, fs_remove=False)
                     sa.commit()
                     removed.append(group_name)
                 except Exception:
                     # don't hold further removals on error
                     log.exception(
                         'Unable to remove repository group `%s`',
                         group_name)
                     sa.rollback()
                     raise
 
     return added, removed
 
 
 def load_rcextensions(root_path):
     import rhodecode
     from rhodecode.config import conf
 
     path = os.path.join(root_path, 'rcextensions', '__init__.py')
     if os.path.isfile(path):
         rcext = create_module('rc', path)
         EXT = rhodecode.EXTENSIONS = rcext
         log.debug('Found rcextensions now loading %s...', rcext)
 
         # Additional mappings that are not present in the pygments lexers
         conf.LANGUAGES_EXTENSIONS_MAP.update(getattr(EXT, 'EXTRA_MAPPINGS', {}))
 
         # auto check if the module is not missing any data, set to default if is
         # this will help autoupdate new feature of rcext module
         #from rhodecode.config import rcextensions
         #for k in dir(rcextensions):
         #    if not k.startswith('_') and not hasattr(EXT, k):
         #        setattr(EXT, k, getattr(rcextensions, k))
 
 
 def get_custom_lexer(extension):
     """
     returns a custom lexer if it is defined in rcextensions module, or None
     if there's no custom lexer defined
     """
     import rhodecode
     from pygments import lexers
 
     # custom override made by RhodeCode
     if extension in ['mako']:
         return lexers.get_lexer_by_name('html+mako')
 
     # check if we didn't define this extension as other lexer
     extensions = rhodecode.EXTENSIONS and getattr(rhodecode.EXTENSIONS, 'EXTRA_LEXERS', None)
     if extensions and extension in rhodecode.EXTENSIONS.EXTRA_LEXERS:
         _lexer_name = rhodecode.EXTENSIONS.EXTRA_LEXERS[extension]
         return lexers.get_lexer_by_name(_lexer_name)
 
 
 #==============================================================================
 # TEST FUNCTIONS AND CREATORS
 #==============================================================================
 def create_test_index(repo_location, config):
     """
     Makes default test index.
     """
     import rc_testdata
 
     rc_testdata.extract_search_index(
         'vcs_search_index', os.path.dirname(config['search.location']))
 
 
 def create_test_directory(test_path):
     """
     Create test directory if it doesn't exist.
     """
     if not os.path.isdir(test_path):
         log.debug('Creating testdir %s', test_path)
         os.makedirs(test_path)
 
 
 def create_test_database(test_path, config):
     """
     Makes a fresh database.
     """
     from rhodecode.lib.db_manage import DbManage
 
     # PART ONE create db
     dbconf = config['sqlalchemy.db1.url']
     log.debug('making test db %s', dbconf)
 
     dbmanage = DbManage(log_sql=False, dbconf=dbconf, root=config['here'],
                         tests=True, cli_args={'force_ask': True})
     dbmanage.create_tables(override=True)
     dbmanage.set_db_version()
     # for tests dynamically set new root paths based on generated content
     dbmanage.create_settings(dbmanage.config_prompt(test_path))
     dbmanage.create_default_user()
     dbmanage.create_test_admin_and_users()
     dbmanage.create_permissions()
     dbmanage.populate_default_permissions()
     Session().commit()
 
 
 def create_test_repositories(test_path, config):
     """
     Creates test repositories in the temporary directory. Repositories are
     extracted from archives within the rc_testdata package.
     """
     import rc_testdata
     from rhodecode.tests import HG_REPO, GIT_REPO, SVN_REPO
 
     log.debug('making test vcs repositories')
 
     idx_path = config['search.location']
     data_path = config['cache_dir']
 
     # clean index and data
     if idx_path and os.path.exists(idx_path):
         log.debug('remove %s', idx_path)
         shutil.rmtree(idx_path)
 
     if data_path and os.path.exists(data_path):
         log.debug('remove %s', data_path)
         shutil.rmtree(data_path)
 
     rc_testdata.extract_hg_dump('vcs_test_hg', jn(test_path, HG_REPO))
     rc_testdata.extract_git_dump('vcs_test_git', jn(test_path, GIT_REPO))
 
     # Note: Subversion is in the process of being integrated with the system,
     # until we have a properly packed version of the test svn repository, this
     # tries to copy over the repo from a package "rc_testdata"
     svn_repo_path = rc_testdata.get_svn_repo_archive()
     with tarfile.open(svn_repo_path) as tar:
         tar.extractall(jn(test_path, SVN_REPO))
 
 
 def password_changed(auth_user, session):
     # Never report password change in case of default user or anonymous user.
     if auth_user.username == User.DEFAULT_USER or auth_user.user_id is None:
         return False
 
     password_hash = md5(auth_user.password) if auth_user.password else None
     rhodecode_user = session.get('rhodecode_user', {})
     session_password_hash = rhodecode_user.get('password', '')
     return password_hash != session_password_hash
 
 
 def read_opensource_licenses():
     global _license_cache
 
     if not _license_cache:
         licenses = pkg_resources.resource_string(
             'rhodecode', 'config/licenses.json')
         _license_cache = json.loads(licenses)
 
     return _license_cache
 
 
 def generate_platform_uuid():
     """
     Generates platform UUID based on it's name
     """
     import platform
 
     try:
         uuid_list = [platform.platform()]
         return hashlib.sha256(':'.join(uuid_list)).hexdigest()
     except Exception as e:
         log.error('Failed to generate host uuid: %s' % e)
         return 'UNDEFINED'

rhodecode/lib/vcs/backends/base.py

@@ -1,1694 +1,1698 b''
 # -*- coding: utf-8 -*-
 
 # Copyright (C) 2014-2018 RhodeCode GmbH
 #
 # This program is free software: you can redistribute it and/or modify
 # it under the terms of the GNU Affero General Public License, version 3
 # (only), as published by the Free Software Foundation.
 #
 # 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 Affero General Public License
 # along with this program.  If not, see <http://www.gnu.org/licenses/>.
 #
 # This program is dual-licensed. If you wish to learn more about the
 # RhodeCode Enterprise Edition, including its added features, Support services,
 # and proprietary license terms, please see https://rhodecode.com/licenses/
 
 """
 Base module for all VCS systems
 """
 
 import collections
 import datetime
 import fnmatch
 import itertools
 import logging
 import os
 import re
 import time
 import warnings
 
 from zope.cachedescriptors.property import Lazy as LazyProperty
 
 from rhodecode.lib.utils2 import safe_str, safe_unicode
 from rhodecode.lib.vcs import connection
 from rhodecode.lib.vcs.utils import author_name, author_email
 from rhodecode.lib.vcs.conf import settings
 from rhodecode.lib.vcs.exceptions import (
     CommitError, EmptyRepositoryError, NodeAlreadyAddedError,
     NodeAlreadyChangedError, NodeAlreadyExistsError, NodeAlreadyRemovedError,
     NodeDoesNotExistError, NodeNotChangedError, VCSError,
     ImproperArchiveTypeError, BranchDoesNotExistError, CommitDoesNotExistError,
     RepositoryError)
 
 
 log = logging.getLogger(__name__)
 
 
 FILEMODE_DEFAULT = 0100644
 FILEMODE_EXECUTABLE = 0100755
 
 Reference = collections.namedtuple('Reference', ('type', 'name', 'commit_id'))
 MergeResponse = collections.namedtuple(
     'MergeResponse',
     ('possible', 'executed', 'merge_ref', 'failure_reason'))
 
 
 class MergeFailureReason(object):
     """
     Enumeration with all the reasons why the server side merge could fail.
 
     DO NOT change the number of the reasons, as they may be stored in the
     database.
 
     Changing the name of a reason is acceptable and encouraged to deprecate old
     reasons.
     """
 
     # Everything went well.
     NONE = 0
 
     # An unexpected exception was raised. Check the logs for more details.
     UNKNOWN = 1
 
     # The merge was not successful, there are conflicts.
     MERGE_FAILED = 2
 
     # The merge succeeded but we could not push it to the target repository.
     PUSH_FAILED = 3
 
     # The specified target is not a head in the target repository.
     TARGET_IS_NOT_HEAD = 4
 
     # The source repository contains more branches than the target. Pushing
     # the merge will create additional branches in the target.
     HG_SOURCE_HAS_MORE_BRANCHES = 5
 
     # The target reference has multiple heads. That does not allow to correctly
     # identify the target location. This could only happen for mercurial
     # branches.
     HG_TARGET_HAS_MULTIPLE_HEADS = 6
 
     # The target repository is locked
     TARGET_IS_LOCKED = 7
 
     # Deprecated, use MISSING_TARGET_REF or MISSING_SOURCE_REF instead.
     # A involved commit could not be found.
     _DEPRECATED_MISSING_COMMIT = 8
 
     # The target repo reference is missing.
     MISSING_TARGET_REF = 9
 
     # The source repo reference is missing.
     MISSING_SOURCE_REF = 10
 
     # The merge was not successful, there are conflicts related to sub
     # repositories.
     SUBREPO_MERGE_FAILED = 11
 
 
 class UpdateFailureReason(object):
     """
     Enumeration with all the reasons why the pull request update could fail.
 
     DO NOT change the number of the reasons, as they may be stored in the
     database.
 
     Changing the name of a reason is acceptable and encouraged to deprecate old
     reasons.
     """
 
     # Everything went well.
     NONE = 0
 
     # An unexpected exception was raised. Check the logs for more details.
     UNKNOWN = 1
 
     # The pull request is up to date.
     NO_CHANGE = 2
 
     # The pull request has a reference type that is not supported for update.
     WRONG_REF_TYPE = 3
 
     # Update failed because the target reference is missing.
     MISSING_TARGET_REF = 4
 
     # Update failed because the source reference is missing.
     MISSING_SOURCE_REF = 5
 
 
 class BaseRepository(object):
     """
     Base Repository for final backends
 
     .. attribute:: DEFAULT_BRANCH_NAME
 
        name of default branch (i.e. "trunk" for svn, "master" for git etc.
 
     .. attribute:: commit_ids
 
        list of all available commit ids, in ascending order
 
     .. attribute:: path
 
        absolute path to the repository
 
     .. attribute:: bookmarks
 
        Mapping from name to :term:`Commit ID` of the bookmark. Empty in case
        there are no bookmarks or the backend implementation does not support
        bookmarks.
 
     .. attribute:: tags
 
        Mapping from name to :term:`Commit ID` of the tag.
 
     """
 
     DEFAULT_BRANCH_NAME = None
     DEFAULT_CONTACT = u"Unknown"
     DEFAULT_DESCRIPTION = u"unknown"
     EMPTY_COMMIT_ID = '0' * 40
 
     path = None
+    _remote = None
 
     def __init__(self, repo_path, config=None, create=False, **kwargs):
         """
         Initializes repository. Raises RepositoryError if repository could
         not be find at the given ``repo_path`` or directory at ``repo_path``
         exists and ``create`` is set to True.
 
         :param repo_path: local path of the repository
         :param config: repository configuration
         :param create=False: if set to True, would try to create repository.
         :param src_url=None: if set, should be proper url from which repository
           would be cloned; requires ``create`` parameter to be set to True -
           raises RepositoryError if src_url is set and create evaluates to
           False
         """
         raise NotImplementedError
 
     def __repr__(self):
         return '<%s at %s>' % (self.__class__.__name__, self.path)
 
     def __len__(self):
         return self.count()
 
     def __eq__(self, other):
         same_instance = isinstance(other, self.__class__)
         return same_instance and other.path == self.path
 
     def __ne__(self, other):
         return not self.__eq__(other)
 
     @classmethod
     def get_default_config(cls, default=None):
         config = Config()
         if default and isinstance(default, list):
             for section, key, val in default:
                 config.set(section, key, val)
         return config
 
     @LazyProperty
     def EMPTY_COMMIT(self):
         return EmptyCommit(self.EMPTY_COMMIT_ID)
 
     @LazyProperty
     def alias(self):
         for k, v in settings.BACKENDS.items():
             if v.split('.')[-1] == str(self.__class__.__name__):
                 return k
 
     @LazyProperty
     def name(self):
         return safe_unicode(os.path.basename(self.path))
 
     @LazyProperty
     def description(self):
         raise NotImplementedError
 
     def refs(self):
         """
         returns a `dict` with branches, bookmarks, tags, and closed_branches
         for this repository
         """
         return dict(
             branches=self.branches,
             branches_closed=self.branches_closed,
             tags=self.tags,
             bookmarks=self.bookmarks
         )
 
     @LazyProperty
     def branches(self):
         """
         A `dict` which maps branch names to commit ids.
         """
         raise NotImplementedError
 
     @LazyProperty
     def branches_closed(self):
         """
         A `dict` which maps tags names to commit ids.
         """
         raise NotImplementedError
 
     @LazyProperty
     def bookmarks(self):
         """
         A `dict` which maps tags names to commit ids.
         """
         raise NotImplementedError
 
     @LazyProperty
     def tags(self):
         """
         A `dict` which maps tags names to commit ids.
         """
         raise NotImplementedError
 
     @LazyProperty
     def size(self):
         """
         Returns combined size in bytes for all repository files
         """
         tip = self.get_commit()
         return tip.size
 
     def size_at_commit(self, commit_id):
         commit = self.get_commit(commit_id)
         return commit.size
 
     def is_empty(self):
         return not bool(self.commit_ids)
 
     @staticmethod
     def check_url(url, config):
         """
         Function will check given url and try to verify if it's a valid
         link.
         """
         raise NotImplementedError
 
     @staticmethod
     def is_valid_repository(path):
         """
         Check if given `path` contains a valid repository of this backend
         """
         raise NotImplementedError
 
     # ==========================================================================
     # COMMITS
     # ==========================================================================
 
     def get_commit(self, commit_id=None, commit_idx=None, pre_load=None):
         """
         Returns instance of `BaseCommit` class. If `commit_id` and `commit_idx`
         are both None, most recent commit is returned.
 
         :param pre_load: Optional. List of commit attributes to load.
 
         :raises ``EmptyRepositoryError``: if there are no commits
         """
         raise NotImplementedError
 
     def __iter__(self):
         for commit_id in self.commit_ids:
             yield self.get_commit(commit_id=commit_id)
 
     def get_commits(
             self, start_id=None, end_id=None, start_date=None, end_date=None,
             branch_name=None, show_hidden=False, pre_load=None):
         """
         Returns iterator of `BaseCommit` objects from start to end
         not inclusive. This should behave just like a list, ie. end is not
         inclusive.
 
         :param start_id: None or str, must be a valid commit id
         :param end_id: None or str, must be a valid commit id
         :param start_date:
         :param end_date:
         :param branch_name:
         :param show_hidden:
         :param pre_load:
         """
         raise NotImplementedError
 
     def __getitem__(self, key):
         """
         Allows index based access to the commit objects of this repository.
         """
         pre_load = ["author", "branch", "date", "message", "parents"]
         if isinstance(key, slice):
             return self._get_range(key, pre_load)
         return self.get_commit(commit_idx=key, pre_load=pre_load)
 
     def _get_range(self, slice_obj, pre_load):
         for commit_id in self.commit_ids.__getitem__(slice_obj):
             yield self.get_commit(commit_id=commit_id, pre_load=pre_load)
 
     def count(self):
         return len(self.commit_ids)
 
     def tag(self, name, user, commit_id=None, message=None, date=None, **opts):
         """
         Creates and returns a tag for the given ``commit_id``.
 
         :param name: name for new tag
         :param user: full username, i.e.: "Joe Doe <[e-mail]>"
         :param commit_id: commit id for which new tag would be created
         :param message: message of the tag's commit
         :param date: date of tag's commit
 
         :raises TagAlreadyExistError: if tag with same name already exists
         """
         raise NotImplementedError
 
     def remove_tag(self, name, user, message=None, date=None):
         """
         Removes tag with the given ``name``.
 
         :param name: name of the tag to be removed
         :param user: full username, i.e.: "Joe Doe <[e-mail]>"
         :param message: message of the tag's removal commit
         :param date: date of tag's removal commit
 
         :raises TagDoesNotExistError: if tag with given name does not exists
         """
         raise NotImplementedError
 
     def get_diff(
             self, commit1, commit2, path=None, ignore_whitespace=False,
             context=3, path1=None):
         """
         Returns (git like) *diff*, as plain text. Shows changes introduced by
         `commit2` since `commit1`.
 
         :param commit1: Entry point from which diff is shown. Can be
           ``self.EMPTY_COMMIT`` - in this case, patch showing all
           the changes since empty state of the repository until `commit2`
         :param commit2: Until which commit changes should be shown.
         :param path: Can be set to a path of a file to create a diff of that
           file. If `path1` is also set, this value is only associated to
           `commit2`.
         :param ignore_whitespace: If set to ``True``, would not show whitespace
           changes. Defaults to ``False``.
         :param context: How many lines before/after changed lines should be
           shown. Defaults to ``3``.
         :param path1: Can be set to a path to associate with `commit1`. This
           parameter works only for backends which support diff generation for
           different paths. Other backends will raise a `ValueError` if `path1`
           is set and has a different value than `path`.
         :param file_path: filter this diff by given path pattern
         """
         raise NotImplementedError
 
     def strip(self, commit_id, branch=None):
         """
         Strip given commit_id from the repository
         """
         raise NotImplementedError
 
     def get_common_ancestor(self, commit_id1, commit_id2, repo2):
         """
         Return a latest common ancestor commit if one exists for this repo
         `commit_id1` vs `commit_id2` from `repo2`.
 
         :param commit_id1: Commit it from this repository to use as a
            target for the comparison.
         :param commit_id2: Source commit id to use for comparison.
         :param repo2: Source repository to use for comparison.
         """
         raise NotImplementedError
 
     def compare(self, commit_id1, commit_id2, repo2, merge, pre_load=None):
         """
         Compare this repository's revision `commit_id1` with `commit_id2`.
 
         Returns a tuple(commits, ancestor) that would be merged from
         `commit_id2`. Doing a normal compare (``merge=False``), ``None``
         will be returned as ancestor.
 
         :param commit_id1: Commit it from this repository to use as a
            target for the comparison.
         :param commit_id2: Source commit id to use for comparison.
         :param repo2: Source repository to use for comparison.
         :param merge: If set to ``True`` will do a merge compare which also
            returns the common ancestor.
         :param pre_load: Optional. List of commit attributes to load.
         """
         raise NotImplementedError
 
     def merge(self, target_ref, source_repo, source_ref, workspace_id,
               user_name='', user_email='', message='', dry_run=False,
               use_rebase=False, close_branch=False):
         """
         Merge the revisions specified in `source_ref` from `source_repo`
         onto the `target_ref` of this repository.
 
         `source_ref` and `target_ref` are named tupls with the following
         fields `type`, `name` and `commit_id`.
 
         Returns a MergeResponse named tuple with the following fields
         'possible', 'executed', 'source_commit', 'target_commit',
         'merge_commit'.
 
         :param target_ref: `target_ref` points to the commit on top of which
             the `source_ref` should be merged.
         :param source_repo: The repository that contains the commits to be
             merged.
         :param source_ref: `source_ref` points to the topmost commit from
             the `source_repo` which should be merged.
         :param workspace_id: `workspace_id` unique identifier.
         :param user_name: Merge commit `user_name`.
         :param user_email: Merge commit `user_email`.
         :param message: Merge commit `message`.
         :param dry_run: If `True` the merge will not take place.
         :param use_rebase: If `True` commits from the source will be rebased
             on top of the target instead of being merged.
         :param close_branch: If `True` branch will be close before merging it
         """
         if dry_run:
             message = message or 'dry_run_merge_message'
             user_email = user_email or '[e-mail]'
             user_name = user_name or 'Dry-Run User'
         else:
             if not user_name:
                 raise ValueError('user_name cannot be empty')
             if not user_email:
                 raise ValueError('user_email cannot be empty')
             if not message:
                 raise ValueError('message cannot be empty')
 
         shadow_repository_path = self._maybe_prepare_merge_workspace(
             workspace_id, target_ref, source_ref)
 
         try:
             return self._merge_repo(
                 shadow_repository_path, target_ref, source_repo,
                 source_ref, message, user_name, user_email, dry_run=dry_run,
                 use_rebase=use_rebase, close_branch=close_branch)
         except RepositoryError:
             log.exception(
                 'Unexpected failure when running merge, dry-run=%s',
                 dry_run)
             return MergeResponse(
                 False, False, None, MergeFailureReason.UNKNOWN)
 
     def _merge_repo(self, shadow_repository_path, target_ref,
                     source_repo, source_ref, merge_message,
                     merger_name, merger_email, dry_run=False,
                     use_rebase=False, close_branch=False):
         """Internal implementation of merge."""
         raise NotImplementedError
 
     def _maybe_prepare_merge_workspace(self, workspace_id, target_ref, source_ref):
         """
         Create the merge workspace.
 
         :param workspace_id: `workspace_id` unique identifier.
         """
         raise NotImplementedError
 
     def cleanup_merge_workspace(self, workspace_id):
         """
         Remove merge workspace.
 
         This function MUST not fail in case there is no workspace associated to
         the given `workspace_id`.
 
         :param workspace_id: `workspace_id` unique identifier.
         """
         raise NotImplementedError
 
     # ========== #
     # COMMIT API #
     # ========== #
 
     @LazyProperty
     def in_memory_commit(self):
         """
         Returns :class:`InMemoryCommit` object for this repository.
         """
         raise NotImplementedError
 
     # ======================== #
     # UTILITIES FOR SUBCLASSES #
     # ======================== #
 
     def _validate_diff_commits(self, commit1, commit2):
         """
         Validates that the given commits are related to this repository.
 
         Intended as a utility for sub classes to have a consistent validation
         of input parameters in methods like :meth:`get_diff`.
         """
         self._validate_commit(commit1)
         self._validate_commit(commit2)
         if (isinstance(commit1, EmptyCommit) and
                 isinstance(commit2, EmptyCommit)):
             raise ValueError("Cannot compare two empty commits")
 
     def _validate_commit(self, commit):
         if not isinstance(commit, BaseCommit):
             raise TypeError(
                 "%s is not of type BaseCommit" % repr(commit))
         if commit.repository != self and not isinstance(commit, EmptyCommit):
             raise ValueError(
                 "Commit %s must be a valid commit from this repository %s, "
                 "related to this repository instead %s." %
                 (commit, self, commit.repository))
 
     def _validate_commit_id(self, commit_id):
         if not isinstance(commit_id, basestring):
             raise TypeError("commit_id must be a string value")
 
     def _validate_commit_idx(self, commit_idx):
         if not isinstance(commit_idx, (int, long)):
             raise TypeError("commit_idx must be a numeric value")
 
     def _validate_branch_name(self, branch_name):
         if branch_name and branch_name not in self.branches_all:
             msg = ("Branch %s not found in %s" % (branch_name, self))
             raise BranchDoesNotExistError(msg)
 
     #
     # Supporting deprecated API parts
     # TODO: johbo: consider to move this into a mixin
     #
 
     @property
     def EMPTY_CHANGESET(self):
         warnings.warn(
             "Use EMPTY_COMMIT or EMPTY_COMMIT_ID instead", DeprecationWarning)
         return self.EMPTY_COMMIT_ID
 
     @property
     def revisions(self):
         warnings.warn("Use commits attribute instead", DeprecationWarning)
         return self.commit_ids
 
     @revisions.setter
     def revisions(self, value):
         warnings.warn("Use commits attribute instead", DeprecationWarning)
         self.commit_ids = value
 
     def get_changeset(self, revision=None, pre_load=None):
         warnings.warn("Use get_commit instead", DeprecationWarning)
         commit_id = None
         commit_idx = None
         if isinstance(revision, basestring):
             commit_id = revision
         else:
             commit_idx = revision
         return self.get_commit(
             commit_id=commit_id, commit_idx=commit_idx, pre_load=pre_load)
 
     def get_changesets(
             self, start=None, end=None, start_date=None, end_date=None,
             branch_name=None, pre_load=None):
         warnings.warn("Use get_commits instead", DeprecationWarning)
         start_id = self._revision_to_commit(start)
         end_id = self._revision_to_commit(end)
         return self.get_commits(
             start_id=start_id, end_id=end_id, start_date=start_date,
             end_date=end_date, branch_name=branch_name, pre_load=pre_load)
 
     def _revision_to_commit(self, revision):
         """
         Translates a revision to a commit_id
 
         Helps to support the old changeset based API which allows to use
         commit ids and commit indices interchangeable.
         """
         if revision is None:
             return revision
 
         if isinstance(revision, basestring):
             commit_id = revision
         else:
             commit_id = self.commit_ids[revision]
         return commit_id
 
     @property
     def in_memory_changeset(self):
         warnings.warn("Use in_memory_commit instead", DeprecationWarning)
         return self.in_memory_commit
 
     def get_path_permissions(self, username):
         """
         Returns a path permission checker or None if not supported
 
         :param username: session user name
         :return: an instance of BasePathPermissionChecker or None
         """
         return None
 
+    def install_hooks(self, force=False):
+        return self._remote.install_hooks(force)
+
 
 class BaseCommit(object):
     """
     Each backend should implement it's commit representation.
 
     **Attributes**
 
         ``repository``
             repository object within which commit exists
 
         ``id``
             The commit id, may be ``raw_id`` or i.e. for mercurial's tip
             just ``tip``.
 
         ``raw_id``
             raw commit representation (i.e. full 40 length sha for git
             backend)
 
         ``short_id``
             shortened (if apply) version of ``raw_id``; it would be simple
             shortcut for ``raw_id[:12]`` for git/mercurial backends or same
             as ``raw_id`` for subversion
 
         ``idx``
             commit index
 
         ``files``
             list of ``FileNode`` (``Node`` with NodeKind.FILE) objects
 
         ``dirs``
             list of ``DirNode`` (``Node`` with NodeKind.DIR) objects
 
         ``nodes``
             combined list of ``Node`` objects
 
         ``author``
             author of the commit, as unicode
 
         ``message``
             message of the commit, as unicode
 
         ``parents``
             list of parent commits
 
     """
 
     branch = None
     """
     Depending on the backend this should be set to the branch name of the
     commit. Backends not supporting branches on commits should leave this
     value as ``None``.
     """
 
     _ARCHIVE_PREFIX_TEMPLATE = b'{repo_name}-{short_id}'
     """
     This template is used to generate a default prefix for repository archives
     if no prefix has been specified.
     """
 
     def __str__(self):
         return '<%s at %s:%s>' % (
             self.__class__.__name__, self.idx, self.short_id)
 
     def __repr__(self):
         return self.__str__()
 
     def __unicode__(self):
         return u'%s:%s' % (self.idx, self.short_id)
 
     def __eq__(self, other):
         same_instance = isinstance(other, self.__class__)
         return same_instance and self.raw_id == other.raw_id
 
     def __json__(self):
         parents = []
         try:
             for parent in self.parents:
                 parents.append({'raw_id': parent.raw_id})
         except NotImplementedError:
             # empty commit doesn't have parents implemented
             pass
 
         return {
             'short_id': self.short_id,
             'raw_id': self.raw_id,
             'revision': self.idx,
             'message': self.message,
             'date': self.date,
             'author': self.author,
             'parents': parents,
             'branch': self.branch
         }
 
     def _get_refs(self):
         return {
-            'branches': [self.branch],
+            'branches': [self.branch] if self.branch else [],
             'bookmarks': getattr(self, 'bookmarks', []),
             'tags': self.tags
         }
 
     @LazyProperty
     def last(self):
         """
         ``True`` if this is last commit in repository, ``False``
         otherwise; trying to access this attribute while there is no
         commits would raise `EmptyRepositoryError`
         """
         if self.repository is None:
             raise CommitError("Cannot check if it's most recent commit")
         return self.raw_id == self.repository.commit_ids[-1]
 
     @LazyProperty
     def parents(self):
         """
         Returns list of parent commits.
         """
         raise NotImplementedError
 
     @property
     def merge(self):
         """
         Returns boolean if commit is a merge.
         """
         return len(self.parents) > 1
 
     @LazyProperty
     def children(self):
         """
         Returns list of child commits.
         """
         raise NotImplementedError
 
     @LazyProperty
     def id(self):
         """
         Returns string identifying this commit.
         """
         raise NotImplementedError
 
     @LazyProperty
     def raw_id(self):
         """
         Returns raw string identifying this commit.
         """
         raise NotImplementedError
 
     @LazyProperty
     def short_id(self):
         """
         Returns shortened version of ``raw_id`` attribute, as string,
         identifying this commit, useful for presentation to users.
         """
         raise NotImplementedError
 
     @LazyProperty
     def idx(self):
         """
         Returns integer identifying this commit.
         """
         raise NotImplementedError
 
     @LazyProperty
     def committer(self):
         """
         Returns committer for this commit
         """
         raise NotImplementedError
 
     @LazyProperty
     def committer_name(self):
         """
         Returns committer name for this commit
         """
 
         return author_name(self.committer)
 
     @LazyProperty
     def committer_email(self):
         """
         Returns committer email address for this commit
         """
 
         return author_email(self.committer)
 
     @LazyProperty
     def author(self):
         """
         Returns author for this commit
         """
 
         raise NotImplementedError
 
     @LazyProperty
     def author_name(self):
         """
         Returns author name for this commit
         """
 
         return author_name(self.author)
 
     @LazyProperty
     def author_email(self):
         """
         Returns author email address for this commit
         """
 
         return author_email(self.author)
 
     def get_file_mode(self, path):
         """
         Returns stat mode of the file at `path`.
         """
         raise NotImplementedError
 
     def is_link(self, path):
         """
         Returns ``True`` if given `path` is a symlink
         """
         raise NotImplementedError
 
     def get_file_content(self, path):
         """
         Returns content of the file at the given `path`.
         """
         raise NotImplementedError
 
     def get_file_size(self, path):
         """
         Returns size of the file at the given `path`.
         """
         raise NotImplementedError
 
     def get_file_commit(self, path, pre_load=None):
         """
         Returns last commit of the file at the given `path`.
 
         :param pre_load: Optional. List of commit attributes to load.
         """
         commits = self.get_file_history(path, limit=1, pre_load=pre_load)
         if not commits:
             raise RepositoryError(
                 'Failed to fetch history for path {}. '
                 'Please check if such path exists in your repository'.format(
                     path))
         return commits[0]
 
     def get_file_history(self, path, limit=None, pre_load=None):
         """
         Returns history of file as reversed list of :class:`BaseCommit`
         objects for which file at given `path` has been modified.
 
         :param limit: Optional. Allows to limit the size of the returned
            history. This is intended as a hint to the underlying backend, so
            that it can apply optimizations depending on the limit.
         :param pre_load: Optional. List of commit attributes to load.
         """
         raise NotImplementedError
 
     def get_file_annotate(self, path, pre_load=None):
         """
         Returns a generator of four element tuples with
         lineno, sha, commit lazy loader and line
 
         :param pre_load: Optional. List of commit attributes to load.
         """
         raise NotImplementedError
 
     def get_nodes(self, path):
         """
         Returns combined ``DirNode`` and ``FileNode`` objects list representing
         state of commit at the given ``path``.
 
         :raises ``CommitError``: if node at the given ``path`` is not
           instance of ``DirNode``
         """
         raise NotImplementedError
 
     def get_node(self, path):
         """
         Returns ``Node`` object from the given ``path``.
 
         :raises ``NodeDoesNotExistError``: if there is no node at the given
           ``path``
         """
         raise NotImplementedError
 
     def get_largefile_node(self, path):
         """
         Returns the path to largefile from Mercurial/Git-lfs storage.
         or None if it's not a largefile node
         """
         return None
 
     def archive_repo(self, file_path, kind='tgz', subrepos=None,
                      prefix=None, write_metadata=False, mtime=None):
         """
         Creates an archive containing the contents of the repository.
 
         :param file_path: path to the file which to create the archive.
         :param kind: one of following: ``"tbz2"``, ``"tgz"``, ``"zip"``.
         :param prefix: name of root directory in archive.
             Default is repository name and commit's short_id joined with dash:
             ``"{repo_name}-{short_id}"``.
         :param write_metadata: write a metadata file into archive.
         :param mtime: custom modification time for archive creation, defaults
             to time.time() if not given.
 
         :raise VCSError: If prefix has a problem.
         """
         allowed_kinds = settings.ARCHIVE_SPECS.keys()
         if kind not in allowed_kinds:
             raise ImproperArchiveTypeError(
                 'Archive kind (%s) not supported use one of %s' %
                 (kind, allowed_kinds))
 
         prefix = self._validate_archive_prefix(prefix)
 
         mtime = mtime or time.mktime(self.date.timetuple())
 
         file_info = []
         cur_rev = self.repository.get_commit(commit_id=self.raw_id)
         for _r, _d, files in cur_rev.walk('/'):
             for f in files:
                 f_path = os.path.join(prefix, f.path)
                 file_info.append(
                     (f_path, f.mode, f.is_link(), f.raw_bytes))
 
         if write_metadata:
             metadata = [
                 ('repo_name', self.repository.name),
                 ('rev', self.raw_id),
                 ('create_time', mtime),
                 ('branch', self.branch),
                 ('tags', ','.join(self.tags)),
             ]
             meta = ["%s:%s" % (f_name, value) for f_name, value in metadata]
             file_info.append(('.archival.txt', 0644, False, '\n'.join(meta)))
 
         connection.Hg.archive_repo(file_path, mtime, file_info, kind)
 
     def _validate_archive_prefix(self, prefix):
         if prefix is None:
             prefix = self._ARCHIVE_PREFIX_TEMPLATE.format(
                 repo_name=safe_str(self.repository.name),
                 short_id=self.short_id)
         elif not isinstance(prefix, str):
             raise ValueError("prefix not a bytes object: %s" % repr(prefix))
         elif prefix.startswith('/'):
             raise VCSError("Prefix cannot start with leading slash")
         elif prefix.strip() == '':
             raise VCSError("Prefix cannot be empty")
         return prefix
 
     @LazyProperty
     def root(self):
         """
         Returns ``RootNode`` object for this commit.
         """
         return self.get_node('')
 
     def next(self, branch=None):
         """
         Returns next commit from current, if branch is gives it will return
         next commit belonging to this branch
 
         :param branch: show commits within the given named branch
         """
         indexes = xrange(self.idx + 1, self.repository.count())
         return self._find_next(indexes, branch)
 
     def prev(self, branch=None):
         """
         Returns previous commit from current, if branch is gives it will
         return previous commit belonging to this branch
 
         :param branch: show commit within the given named branch
         """
         indexes = xrange(self.idx - 1, -1, -1)
         return self._find_next(indexes, branch)
 
     def _find_next(self, indexes, branch=None):
         if branch and self.branch != branch:
             raise VCSError('Branch option used on commit not belonging '
                            'to that branch')
 
         for next_idx in indexes:
             commit = self.repository.get_commit(commit_idx=next_idx)
             if branch and branch != commit.branch:
                 continue
             return commit
         raise CommitDoesNotExistError
 
     def diff(self, ignore_whitespace=True, context=3):
         """
         Returns a `Diff` object representing the change made by this commit.
         """
         parent = (
             self.parents[0] if self.parents else self.repository.EMPTY_COMMIT)
         diff = self.repository.get_diff(
             parent, self,
             ignore_whitespace=ignore_whitespace,
             context=context)
         return diff
 
     @LazyProperty
     def added(self):
         """
         Returns list of added ``FileNode`` objects.
         """
         raise NotImplementedError
 
     @LazyProperty
     def changed(self):
         """
         Returns list of modified ``FileNode`` objects.
         """
         raise NotImplementedError
 
     @LazyProperty
     def removed(self):
         """
         Returns list of removed ``FileNode`` objects.
         """
         raise NotImplementedError
 
     @LazyProperty
     def size(self):
         """
         Returns total number of bytes from contents of all filenodes.
         """
         return sum((node.size for node in self.get_filenodes_generator()))
 
     def walk(self, topurl=''):
         """
         Similar to os.walk method. Insted of filesystem it walks through
         commit starting at given ``topurl``.  Returns generator of tuples
         (topnode, dirnodes, filenodes).
         """
         topnode = self.get_node(topurl)
         if not topnode.is_dir():
             return
         yield (topnode, topnode.dirs, topnode.files)
         for dirnode in topnode.dirs:
             for tup in self.walk(dirnode.path):
                 yield tup
 
     def get_filenodes_generator(self):
         """
         Returns generator that yields *all* file nodes.
         """
         for topnode, dirs, files in self.walk():
             for node in files:
                 yield node
 
     #
     # Utilities for sub classes to support consistent behavior
     #
 
     def no_node_at_path(self, path):
         return NodeDoesNotExistError(
             u"There is no file nor directory at the given path: "
             u"`%s` at commit %s" % (safe_unicode(path), self.short_id))
 
     def _fix_path(self, path):
         """
         Paths are stored without trailing slash so we need to get rid off it if
         needed.
         """
         return path.rstrip('/')
 
     #
     # Deprecated API based on changesets
     #
 
     @property
     def revision(self):
         warnings.warn("Use idx instead", DeprecationWarning)
         return self.idx
 
     @revision.setter
     def revision(self, value):
         warnings.warn("Use idx instead", DeprecationWarning)
         self.idx = value
 
     def get_file_changeset(self, path):
         warnings.warn("Use get_file_commit instead", DeprecationWarning)
         return self.get_file_commit(path)
 
 
 class BaseChangesetClass(type):
 
     def __instancecheck__(self, instance):
         return isinstance(instance, BaseCommit)
 
 
 class BaseChangeset(BaseCommit):
 
     __metaclass__ = BaseChangesetClass
 
     def __new__(cls, *args, **kwargs):
         warnings.warn(
             "Use BaseCommit instead of BaseChangeset", DeprecationWarning)
         return super(BaseChangeset, cls).__new__(cls, *args, **kwargs)
 
 
 class BaseInMemoryCommit(object):
     """
     Represents differences between repository's state (most recent head) and
     changes made *in place*.
 
     **Attributes**
 
         ``repository``
             repository object for this in-memory-commit
 
         ``added``
             list of ``FileNode`` objects marked as *added*
 
         ``changed``
             list of ``FileNode`` objects marked as *changed*
 
         ``removed``
             list of ``FileNode`` or ``RemovedFileNode`` objects marked to be
             *removed*
 
         ``parents``
             list of :class:`BaseCommit` instances representing parents of
             in-memory commit. Should always be 2-element sequence.
 
     """
 
     def __init__(self, repository):
         self.repository = repository
         self.added = []
         self.changed = []
         self.removed = []
         self.parents = []
 
     def add(self, *filenodes):
         """
         Marks given ``FileNode`` objects as *to be committed*.
 
         :raises ``NodeAlreadyExistsError``: if node with same path exists at
            latest commit
         :raises ``NodeAlreadyAddedError``: if node with same path is already
            marked as *added*
         """
         # Check if not already marked as *added* first
         for node in filenodes:
             if node.path in (n.path for n in self.added):
                 raise NodeAlreadyAddedError(
                     "Such FileNode %s is already marked for addition"
                     % node.path)
         for node in filenodes:
             self.added.append(node)
 
     def change(self, *filenodes):
         """
         Marks given ``FileNode`` objects to be *changed* in next commit.
 
         :raises ``EmptyRepositoryError``: if there are no commits yet
         :raises ``NodeAlreadyExistsError``: if node with same path is already
            marked to be *changed*
         :raises ``NodeAlreadyRemovedError``: if node with same path is already
            marked to be *removed*
         :raises ``NodeDoesNotExistError``: if node doesn't exist in latest
            commit
         :raises ``NodeNotChangedError``: if node hasn't really be changed
         """
         for node in filenodes:
             if node.path in (n.path for n in self.removed):
                 raise NodeAlreadyRemovedError(
                     "Node at %s is already marked as removed" % node.path)
         try:
             self.repository.get_commit()
         except EmptyRepositoryError:
             raise EmptyRepositoryError(
                 "Nothing to change - try to *add* new nodes rather than "
                 "changing them")
         for node in filenodes:
             if node.path in (n.path for n in self.changed):
                 raise NodeAlreadyChangedError(
                     "Node at '%s' is already marked as changed" % node.path)
             self.changed.append(node)
 
     def remove(self, *filenodes):
         """
         Marks given ``FileNode`` (or ``RemovedFileNode``) objects to be
         *removed* in next commit.
 
         :raises ``NodeAlreadyRemovedError``: if node has been already marked to
            be *removed*
         :raises ``NodeAlreadyChangedError``: if node has been already marked to
            be *changed*
         """
         for node in filenodes:
             if node.path in (n.path for n in self.removed):
                 raise NodeAlreadyRemovedError(
                     "Node is already marked to for removal at %s" % node.path)
             if node.path in (n.path for n in self.changed):
                 raise NodeAlreadyChangedError(
                     "Node is already marked to be changed at %s" % node.path)
             # We only mark node as *removed* - real removal is done by
             # commit method
             self.removed.append(node)
 
     def reset(self):
         """
         Resets this instance to initial state (cleans ``added``, ``changed``
         and ``removed`` lists).
         """
         self.added = []
         self.changed = []
         self.removed = []
         self.parents = []
 
     def get_ipaths(self):
         """
         Returns generator of paths from nodes marked as added, changed or
         removed.
         """
         for node in itertools.chain(self.added, self.changed, self.removed):
             yield node.path
 
     def get_paths(self):
         """
         Returns list of paths from nodes marked as added, changed or removed.
         """
         return list(self.get_ipaths())
 
     def check_integrity(self, parents=None):
         """
         Checks in-memory commit's integrity. Also, sets parents if not
         already set.
 
         :raises CommitError: if any error occurs (i.e.
           ``NodeDoesNotExistError``).
         """
         if not self.parents:
             parents = parents or []
             if len(parents) == 0:
                 try:
                     parents = [self.repository.get_commit(), None]
                 except EmptyRepositoryError:
                     parents = [None, None]
             elif len(parents) == 1:
                 parents += [None]
             self.parents = parents
 
         # Local parents, only if not None
         parents = [p for p in self.parents if p]
 
         # Check nodes marked as added
         for p in parents:
             for node in self.added:
                 try:
                     p.get_node(node.path)
                 except NodeDoesNotExistError:
                     pass
                 else:
                     raise NodeAlreadyExistsError(
                         "Node `%s` already exists at %s" % (node.path, p))
 
         # Check nodes marked as changed
         missing = set(self.changed)
         not_changed = set(self.changed)
         if self.changed and not parents:
             raise NodeDoesNotExistError(str(self.changed[0].path))
         for p in parents:
             for node in self.changed:
                 try:
                     old = p.get_node(node.path)
                     missing.remove(node)
                     # if content actually changed, remove node from not_changed
                     if old.content != node.content:
                         not_changed.remove(node)
                 except NodeDoesNotExistError:
                     pass
         if self.changed and missing:
             raise NodeDoesNotExistError(
                 "Node `%s` marked as modified but missing in parents: %s"
                 % (node.path, parents))
 
         if self.changed and not_changed:
             raise NodeNotChangedError(
                 "Node `%s` wasn't actually changed (parents: %s)"
                 % (not_changed.pop().path, parents))
 
         # Check nodes marked as removed
         if self.removed and not parents:
             raise NodeDoesNotExistError(
                 "Cannot remove node at %s as there "
                 "were no parents specified" % self.removed[0].path)
         really_removed = set()
         for p in parents:
             for node in self.removed:
                 try:
                     p.get_node(node.path)
                     really_removed.add(node)
                 except CommitError:
                     pass
         not_removed = set(self.removed) - really_removed
         if not_removed:
             # TODO: johbo: This code branch does not seem to be covered
             raise NodeDoesNotExistError(
                 "Cannot remove node at %s from "
                 "following parents: %s" % (not_removed, parents))
 
     def commit(
             self, message, author, parents=None, branch=None, date=None,
             **kwargs):
         """
         Performs in-memory commit (doesn't check workdir in any way) and
         returns newly created :class:`BaseCommit`. Updates repository's
         attribute `commits`.
 
         .. note::
 
            While overriding this method each backend's should call
            ``self.check_integrity(parents)`` in the first place.
 
         :param message: message of the commit
         :param author: full username, i.e. "Joe Doe <[e-mail]>"
         :param parents: single parent or sequence of parents from which commit
            would be derived
         :param date: ``datetime.datetime`` instance. Defaults to
            ``datetime.datetime.now()``.
         :param branch: branch name, as string. If none given, default backend's
            branch would be used.
 
         :raises ``CommitError``: if any error occurs while committing
         """
         raise NotImplementedError
 
 
 class BaseInMemoryChangesetClass(type):
 
     def __instancecheck__(self, instance):
         return isinstance(instance, BaseInMemoryCommit)
 
 
 class BaseInMemoryChangeset(BaseInMemoryCommit):
 
     __metaclass__ = BaseInMemoryChangesetClass
 
     def __new__(cls, *args, **kwargs):
         warnings.warn(
             "Use BaseCommit instead of BaseInMemoryCommit", DeprecationWarning)
         return super(BaseInMemoryChangeset, cls).__new__(cls, *args, **kwargs)
 
 
 class EmptyCommit(BaseCommit):
     """
     An dummy empty commit. It's possible to pass hash when creating
     an EmptyCommit
     """
 
     def __init__(
             self, commit_id='0' * 40, repo=None, alias=None, idx=-1,
             message='', author='', date=None):
         self._empty_commit_id = commit_id
         # TODO: johbo: Solve idx parameter, default value does not make
         # too much sense
         self.idx = idx
         self.message = message
         self.author = author
         self.date = date or datetime.datetime.fromtimestamp(0)
         self.repository = repo
         self.alias = alias
 
     @LazyProperty
     def raw_id(self):
         """
         Returns raw string identifying this commit, useful for web
         representation.
         """
 
         return self._empty_commit_id
 
     @LazyProperty
     def branch(self):
         if self.alias:
             from rhodecode.lib.vcs.backends import get_backend
             return get_backend(self.alias).DEFAULT_BRANCH_NAME
 
     @LazyProperty
     def short_id(self):
         return self.raw_id[:12]
 
     @LazyProperty
     def id(self):
         return self.raw_id
 
     def get_file_commit(self, path):
         return self
 
     def get_file_content(self, path):
         return u''
 
     def get_file_size(self, path):
         return 0
 
 
 class EmptyChangesetClass(type):
 
     def __instancecheck__(self, instance):
         return isinstance(instance, EmptyCommit)
 
 
 class EmptyChangeset(EmptyCommit):
 
     __metaclass__ = EmptyChangesetClass
 
     def __new__(cls, *args, **kwargs):
         warnings.warn(
             "Use EmptyCommit instead of EmptyChangeset", DeprecationWarning)
         return super(EmptyCommit, cls).__new__(cls, *args, **kwargs)
 
     def __init__(self, cs='0' * 40, repo=None, requested_revision=None,
                  alias=None, revision=-1, message='', author='', date=None):
         if requested_revision is not None:
             warnings.warn(
                 "Parameter requested_revision not supported anymore",
                 DeprecationWarning)
         super(EmptyChangeset, self).__init__(
             commit_id=cs, repo=repo, alias=alias, idx=revision,
             message=message, author=author, date=date)
 
         @property
         def revision(self):
             warnings.warn("Use idx instead", DeprecationWarning)
             return self.idx
 
         @revision.setter
         def revision(self, value):
             warnings.warn("Use idx instead", DeprecationWarning)
             self.idx = value
 
 
 class EmptyRepository(BaseRepository):
     def __init__(self, repo_path=None, config=None, create=False, **kwargs):
         pass
 
     def get_diff(self, *args, **kwargs):
         from rhodecode.lib.vcs.backends.git.diff import GitDiff
         return GitDiff('')
 
 
 class CollectionGenerator(object):
 
     def __init__(self, repo, commit_ids, collection_size=None, pre_load=None):
         self.repo = repo
         self.commit_ids = commit_ids
         # TODO: (oliver) this isn't currently hooked up
         self.collection_size = None
         self.pre_load = pre_load
 
     def __len__(self):
         if self.collection_size is not None:
             return self.collection_size
         return self.commit_ids.__len__()
 
     def __iter__(self):
         for commit_id in self.commit_ids:
             # TODO: johbo: Mercurial passes in commit indices or commit ids
             yield self._commit_factory(commit_id)
 
     def _commit_factory(self, commit_id):
         """
         Allows backends to override the way commits are generated.
         """
         return self.repo.get_commit(commit_id=commit_id,
                                     pre_load=self.pre_load)
 
     def __getslice__(self, i, j):
         """
         Returns an iterator of sliced repository
         """
         commit_ids = self.commit_ids[i:j]
         return self.__class__(
             self.repo, commit_ids, pre_load=self.pre_load)
 
     def __repr__(self):
         return '<CollectionGenerator[len:%s]>' % (self.__len__())
 
 
 class Config(object):
     """
     Represents the configuration for a repository.
 
     The API is inspired by :class:`ConfigParser.ConfigParser` from the
     standard library. It implements only the needed subset.
     """
 
     def __init__(self):
         self._values = {}
 
     def copy(self):
         clone = Config()
         for section, values in self._values.items():
             clone._values[section] = values.copy()
         return clone
 
     def __repr__(self):
         return '<Config(%s sections) at %s>' % (
             len(self._values), hex(id(self)))
 
     def items(self, section):
         return self._values.get(section, {}).iteritems()
 
     def get(self, section, option):
         return self._values.get(section, {}).get(option)
 
     def set(self, section, option, value):
         section_values = self._values.setdefault(section, {})
         section_values[option] = value
 
     def clear_section(self, section):
         self._values[section] = {}
 
     def serialize(self):
         """
         Creates a list of three tuples (section, key, value) representing
         this config object.
         """
         items = []
         for section in self._values:
             for option, value in self._values[section].items():
                 items.append(
                     (safe_str(section), safe_str(option), safe_str(value)))
         return items
 
 
 class Diff(object):
     """
     Represents a diff result from a repository backend.
 
     Subclasses have to provide a backend specific value for
     :attr:`_header_re` and :attr:`_meta_re`.
     """
     _meta_re = None
     _header_re = None
 
     def __init__(self, raw_diff):
         self.raw = raw_diff
 
     def chunks(self):
         """
         split the diff in chunks of separate --git a/file b/file chunks
         to make diffs consistent we must prepend with \n, and make sure
         we can detect last chunk as this was also has special rule
         """
 
         diff_parts = ('\n' + self.raw).split('\ndiff --git')
         header = diff_parts[0]
 
         if self._meta_re:
             match = self._meta_re.match(header)
 
         chunks = diff_parts[1:]
         total_chunks = len(chunks)
 
         return (
             DiffChunk(chunk, self, cur_chunk == total_chunks)
             for cur_chunk, chunk in enumerate(chunks, start=1))
 
 
 class DiffChunk(object):
 
     def __init__(self, chunk, diff, last_chunk):
         self._diff = diff
 
         # since we split by \ndiff --git that part is lost from original diff
         # we need to re-apply it at the end, EXCEPT ! if it's last chunk
         if not last_chunk:
             chunk += '\n'
 
         match = self._diff._header_re.match(chunk)
         self.header = match.groupdict()
         self.diff = chunk[match.end():]
         self.raw = chunk
 
 
 class BasePathPermissionChecker(object):
 
     @staticmethod
     def create_from_patterns(includes, excludes):
         if includes and '*' in includes and not excludes:
             return AllPathPermissionChecker()
         elif excludes and '*' in excludes:
             return NonePathPermissionChecker()
         else:
             return PatternPathPermissionChecker(includes, excludes)
 
     @property
     def has_full_access(self):
         raise NotImplemented()
 
     def has_access(self, path):
         raise NotImplemented()
 
 
 class AllPathPermissionChecker(BasePathPermissionChecker):
 
     @property
     def has_full_access(self):
         return True
 
     def has_access(self, path):
         return True
 
 
 class NonePathPermissionChecker(BasePathPermissionChecker):
 
     @property
     def has_full_access(self):
         return False
 
     def has_access(self, path):
         return False
 
 
 class PatternPathPermissionChecker(BasePathPermissionChecker):
 
     def __init__(self, includes, excludes):
         self.includes = includes
         self.excludes = excludes
         self.includes_re = [] if not includes else [
             re.compile(fnmatch.translate(pattern)) for pattern in includes]
         self.excludes_re = [] if not excludes else [
             re.compile(fnmatch.translate(pattern)) for pattern in excludes]
 
     @property
     def has_full_access(self):
         return '*' in self.includes and not self.excludes
 
     def has_access(self, path):
         for regex in self.excludes_re:
             if regex.match(path):
                 return False
         for regex in self.includes_re:
             if regex.match(path):
                 return True
         return False

rhodecode/model/repo.py

@@ -1,1036 +1,1036 b''
 # -*- coding: utf-8 -*-
 
 # Copyright (C) 2010-2018 RhodeCode GmbH
 #
 # This program is free software: you can redistribute it and/or modify
 # it under the terms of the GNU Affero General Public License, version 3
 # (only), as published by the Free Software Foundation.
 #
 # 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 Affero General Public License
 # along with this program.  If not, see <http://www.gnu.org/licenses/>.
 #
 # This program is dual-licensed. If you wish to learn more about the
 # RhodeCode Enterprise Edition, including its added features, Support services,
 # and proprietary license terms, please see https://rhodecode.com/licenses/
 
 import os
 import re
 import shutil
 import time
 import logging
 import traceback
 import datetime
 
 from pyramid.threadlocal import get_current_request
 from zope.cachedescriptors.property import Lazy as LazyProperty
 
 from rhodecode import events
 from rhodecode.lib.auth import HasUserGroupPermissionAny
 from rhodecode.lib.caching_query import FromCache
 from rhodecode.lib.exceptions import AttachedForksError
 from rhodecode.lib.hooks_base import log_delete_repository
 from rhodecode.lib.user_log_filter import user_log_filter
 from rhodecode.lib.utils import make_db_config
 from rhodecode.lib.utils2 import (
     safe_str, safe_unicode, remove_prefix, obfuscate_url_pw,
     get_current_rhodecode_user, safe_int, datetime_to_time,
     action_logger_generic)
 from rhodecode.lib.vcs.backends import get_backend
 from rhodecode.model import BaseModel
 from rhodecode.model.db import (
     _hash_key, joinedload, or_, Repository, UserRepoToPerm, UserGroupRepoToPerm,
     UserRepoGroupToPerm, UserGroupRepoGroupToPerm, User, Permission,
     Statistics, UserGroup, RepoGroup, RepositoryField, UserLog)
 
 from rhodecode.model.settings import VcsSettingsModel
 
 
 log = logging.getLogger(__name__)
 
 
 class RepoModel(BaseModel):
 
     cls = Repository
 
     def _get_user_group(self, users_group):
         return self._get_instance(UserGroup, users_group,
                                   callback=UserGroup.get_by_group_name)
 
     def _get_repo_group(self, repo_group):
         return self._get_instance(RepoGroup, repo_group,
                                   callback=RepoGroup.get_by_group_name)
 
     def _create_default_perms(self, repository, private):
         # create default permission
         default = 'repository.read'
         def_user = User.get_default_user()
         for p in def_user.user_perms:
             if p.permission.permission_name.startswith('repository.'):
                 default = p.permission.permission_name
                 break
 
         default_perm = 'repository.none' if private else default
 
         repo_to_perm = UserRepoToPerm()
         repo_to_perm.permission = Permission.get_by_key(default_perm)
 
         repo_to_perm.repository = repository
         repo_to_perm.user_id = def_user.user_id
 
         return repo_to_perm
 
     @LazyProperty
     def repos_path(self):
         """
         Gets the repositories root path from database
         """
         settings_model = VcsSettingsModel(sa=self.sa)
         return settings_model.get_repos_location()
 
     def get(self, repo_id, cache=False):
         repo = self.sa.query(Repository) \
             .filter(Repository.repo_id == repo_id)
 
         if cache:
             repo = repo.options(
                 FromCache("sql_cache_short", "get_repo_%s" % repo_id))
         return repo.scalar()
 
     def get_repo(self, repository):
         return self._get_repo(repository)
 
     def get_by_repo_name(self, repo_name, cache=False):
         repo = self.sa.query(Repository) \
             .filter(Repository.repo_name == repo_name)
 
         if cache:
             name_key = _hash_key(repo_name)
             repo = repo.options(
                 FromCache("sql_cache_short", "get_repo_%s" % name_key))
         return repo.scalar()
 
     def _extract_id_from_repo_name(self, repo_name):
         if repo_name.startswith('/'):
             repo_name = repo_name.lstrip('/')
         by_id_match = re.match(r'^_(\d{1,})', repo_name)
         if by_id_match:
             return by_id_match.groups()[0]
 
     def get_repo_by_id(self, repo_name):
         """
         Extracts repo_name by id from special urls.
         Example url is _11/repo_name
 
         :param repo_name:
         :return: repo object if matched else None
         """
 
         try:
             _repo_id = self._extract_id_from_repo_name(repo_name)
             if _repo_id:
                 return self.get(_repo_id)
         except Exception:
             log.exception('Failed to extract repo_name from URL')
 
         return None
 
     def get_repos_for_root(self, root, traverse=False):
         if traverse:
             like_expression = u'{}%'.format(safe_unicode(root))
             repos = Repository.query().filter(
                 Repository.repo_name.like(like_expression)).all()
         else:
             if root and not isinstance(root, RepoGroup):
                 raise ValueError(
                     'Root must be an instance '
                     'of RepoGroup, got:{} instead'.format(type(root)))
             repos = Repository.query().filter(Repository.group == root).all()
         return repos
 
     def get_url(self, repo, request=None, permalink=False):
         if not request:
             request = get_current_request()
 
         if not request:
             return
 
         if permalink:
             return request.route_url(
                 'repo_summary', repo_name='_{}'.format(safe_str(repo.repo_id)))
         else:
             return request.route_url(
                 'repo_summary', repo_name=safe_str(repo.repo_name))
 
     def get_commit_url(self, repo, commit_id, request=None, permalink=False):
         if not request:
             request = get_current_request()
 
         if not request:
             return
 
         if permalink:
             return request.route_url(
                 'repo_commit', repo_name=safe_str(repo.repo_id),
                 commit_id=commit_id)
 
         else:
             return request.route_url(
                 'repo_commit', repo_name=safe_str(repo.repo_name),
                 commit_id=commit_id)
 
     def get_repo_log(self, repo, filter_term):
         repo_log = UserLog.query()\
             .filter(or_(UserLog.repository_id == repo.repo_id,
                         UserLog.repository_name == repo.repo_name))\
             .options(joinedload(UserLog.user))\
             .options(joinedload(UserLog.repository))\
             .order_by(UserLog.action_date.desc())
 
         repo_log = user_log_filter(repo_log, filter_term)
         return repo_log
 
     @classmethod
     def update_repoinfo(cls, repositories=None):
         if not repositories:
             repositories = Repository.getAll()
         for repo in repositories:
             repo.update_commit_cache()
 
     def get_repos_as_dict(self, repo_list=None, admin=False,
                           super_user_actions=False):
         _render = get_current_request().get_partial_renderer(
             'rhodecode:templates/data_table/_dt_elements.mako')
         c = _render.get_call_context()
 
         def quick_menu(repo_name):
             return _render('quick_menu', repo_name)
 
         def repo_lnk(name, rtype, rstate, private, fork_of):
             return _render('repo_name', name, rtype, rstate, private, fork_of,
                            short_name=not admin, admin=False)
 
         def last_change(last_change):
             if admin and isinstance(last_change, datetime.datetime) and not last_change.tzinfo:
                 last_change = last_change + datetime.timedelta(seconds=
                     (datetime.datetime.now() - datetime.datetime.utcnow()).seconds)
             return _render("last_change", last_change)
 
         def rss_lnk(repo_name):
             return _render("rss", repo_name)
 
         def atom_lnk(repo_name):
             return _render("atom", repo_name)
 
         def last_rev(repo_name, cs_cache):
             return _render('revision', repo_name, cs_cache.get('revision'),
                            cs_cache.get('raw_id'), cs_cache.get('author'),
                            cs_cache.get('message'), cs_cache.get('date'))
 
         def desc(desc):
             return _render('repo_desc', desc, c.visual.stylify_metatags)
 
         def state(repo_state):
             return _render("repo_state", repo_state)
 
         def repo_actions(repo_name):
             return _render('repo_actions', repo_name, super_user_actions)
 
         def user_profile(username):
             return _render('user_profile', username)
 
         repos_data = []
         for repo in repo_list:
             cs_cache = repo.changeset_cache
             row = {
                 "menu": quick_menu(repo.repo_name),
 
                 "name": repo_lnk(repo.repo_name, repo.repo_type,
                                  repo.repo_state, repo.private, repo.fork),
                 "name_raw": repo.repo_name.lower(),
 
                 "last_change": last_change(repo.last_db_change),
                 "last_change_raw": datetime_to_time(repo.last_db_change),
 
                 "last_changeset": last_rev(repo.repo_name, cs_cache),
                 "last_changeset_raw": cs_cache.get('revision'),
 
                 "desc": desc(repo.description_safe),
                 "owner": user_profile(repo.user.username),
 
                 "state": state(repo.repo_state),
                 "rss": rss_lnk(repo.repo_name),
 
                 "atom": atom_lnk(repo.repo_name),
             }
             if admin:
                 row.update({
                     "action": repo_actions(repo.repo_name),
                 })
             repos_data.append(row)
 
         return repos_data
 
     def _get_defaults(self, repo_name):
         """
         Gets information about repository, and returns a dict for
         usage in forms
 
         :param repo_name:
         """
 
         repo_info = Repository.get_by_repo_name(repo_name)
 
         if repo_info is None:
             return None
 
         defaults = repo_info.get_dict()
         defaults['repo_name'] = repo_info.just_name
 
         groups = repo_info.groups_with_parents
         parent_group = groups[-1] if groups else None
 
         # we use -1 as this is how in HTML, we mark an empty group
         defaults['repo_group'] = getattr(parent_group, 'group_id', -1)
 
         keys_to_process = (
             {'k': 'repo_type', 'strip': False},
             {'k': 'repo_enable_downloads', 'strip': True},
             {'k': 'repo_description', 'strip': True},
             {'k': 'repo_enable_locking', 'strip': True},
             {'k': 'repo_landing_rev', 'strip': True},
             {'k': 'clone_uri', 'strip': False},
             {'k': 'push_uri', 'strip': False},
             {'k': 'repo_private', 'strip': True},
             {'k': 'repo_enable_statistics', 'strip': True}
         )
 
         for item in keys_to_process:
             attr = item['k']
             if item['strip']:
                 attr = remove_prefix(item['k'], 'repo_')
 
             val = defaults[attr]
             if item['k'] == 'repo_landing_rev':
                 val = ':'.join(defaults[attr])
             defaults[item['k']] = val
             if item['k'] == 'clone_uri':
                 defaults['clone_uri_hidden'] = repo_info.clone_uri_hidden
             if item['k'] == 'push_uri':
                 defaults['push_uri_hidden'] = repo_info.push_uri_hidden
 
         # fill owner
         if repo_info.user:
             defaults.update({'user': repo_info.user.username})
         else:
             replacement_user = User.get_first_super_admin().username
             defaults.update({'user': replacement_user})
 
         return defaults
 
     def update(self, repo, **kwargs):
         try:
             cur_repo = self._get_repo(repo)
             source_repo_name = cur_repo.repo_name
             if 'user' in kwargs:
                 cur_repo.user = User.get_by_username(kwargs['user'])
 
             if 'repo_group' in kwargs:
                 cur_repo.group = RepoGroup.get(kwargs['repo_group'])
             log.debug('Updating repo %s with params:%s', cur_repo, kwargs)
 
             update_keys = [
                 (1, 'repo_description'),
                 (1, 'repo_landing_rev'),
                 (1, 'repo_private'),
                 (1, 'repo_enable_downloads'),
                 (1, 'repo_enable_locking'),
                 (1, 'repo_enable_statistics'),
                 (0, 'clone_uri'),
                 (0, 'push_uri'),
                 (0, 'fork_id')
             ]
             for strip, k in update_keys:
                 if k in kwargs:
                     val = kwargs[k]
                     if strip:
                         k = remove_prefix(k, 'repo_')
 
                     setattr(cur_repo, k, val)
 
             new_name = cur_repo.get_new_name(kwargs['repo_name'])
             cur_repo.repo_name = new_name
 
             # if private flag is set, reset default permission to NONE
             if kwargs.get('repo_private'):
                 EMPTY_PERM = 'repository.none'
                 RepoModel().grant_user_permission(
                     repo=cur_repo, user=User.DEFAULT_USER, perm=EMPTY_PERM
                 )
 
             # handle extra fields
             for field in filter(lambda k: k.startswith(RepositoryField.PREFIX),
                                 kwargs):
                 k = RepositoryField.un_prefix_key(field)
                 ex_field = RepositoryField.get_by_key_name(
                     key=k, repo=cur_repo)
                 if ex_field:
                     ex_field.field_value = kwargs[field]
                     self.sa.add(ex_field)
             cur_repo.updated_on = datetime.datetime.now()
             self.sa.add(cur_repo)
 
             if source_repo_name != new_name:
                 # rename repository
                 self._rename_filesystem_repo(
                     old=source_repo_name, new=new_name)
 
             return cur_repo
         except Exception:
             log.error(traceback.format_exc())
             raise
 
     def _create_repo(self, repo_name, repo_type, description, owner,
                      private=False, clone_uri=None, repo_group=None,
                      landing_rev='rev:tip', fork_of=None,
                      copy_fork_permissions=False, enable_statistics=False,
                      enable_locking=False, enable_downloads=False,
                      copy_group_permissions=False,
                      state=Repository.STATE_PENDING):
         """
         Create repository inside database with PENDING state, this should be
         only executed by create() repo. With exception of importing existing
         repos
         """
         from rhodecode.model.scm import ScmModel
 
         owner = self._get_user(owner)
         fork_of = self._get_repo(fork_of)
         repo_group = self._get_repo_group(safe_int(repo_group))
 
         try:
             repo_name = safe_unicode(repo_name)
             description = safe_unicode(description)
             # repo name is just a name of repository
             # while repo_name_full is a full qualified name that is combined
             # with name and path of group
             repo_name_full = repo_name
             repo_name = repo_name.split(Repository.NAME_SEP)[-1]
 
             new_repo = Repository()
             new_repo.repo_state = state
             new_repo.enable_statistics = False
             new_repo.repo_name = repo_name_full
             new_repo.repo_type = repo_type
             new_repo.user = owner
             new_repo.group = repo_group
             new_repo.description = description or repo_name
             new_repo.private = private
             new_repo.clone_uri = clone_uri
             new_repo.landing_rev = landing_rev
 
             new_repo.enable_statistics = enable_statistics
             new_repo.enable_locking = enable_locking
             new_repo.enable_downloads = enable_downloads
 
             if repo_group:
                 new_repo.enable_locking = repo_group.enable_locking
 
             if fork_of:
                 parent_repo = fork_of
                 new_repo.fork = parent_repo
 
             events.trigger(events.RepoPreCreateEvent(new_repo))
 
             self.sa.add(new_repo)
 
             EMPTY_PERM = 'repository.none'
             if fork_of and copy_fork_permissions:
                 repo = fork_of
                 user_perms = UserRepoToPerm.query() \
                     .filter(UserRepoToPerm.repository == repo).all()
                 group_perms = UserGroupRepoToPerm.query() \
                     .filter(UserGroupRepoToPerm.repository == repo).all()
 
                 for perm in user_perms:
                     UserRepoToPerm.create(
                         perm.user, new_repo, perm.permission)
 
                 for perm in group_perms:
                     UserGroupRepoToPerm.create(
                         perm.users_group, new_repo, perm.permission)
                 # in case we copy permissions and also set this repo to private
                 # override the default user permission to make it a private
                 # repo
                 if private:
                     RepoModel(self.sa).grant_user_permission(
                         repo=new_repo, user=User.DEFAULT_USER, perm=EMPTY_PERM)
 
             elif repo_group and copy_group_permissions:
                 user_perms = UserRepoGroupToPerm.query() \
                     .filter(UserRepoGroupToPerm.group == repo_group).all()
 
                 group_perms = UserGroupRepoGroupToPerm.query() \
                     .filter(UserGroupRepoGroupToPerm.group == repo_group).all()
 
                 for perm in user_perms:
                     perm_name = perm.permission.permission_name.replace(
                         'group.', 'repository.')
                     perm_obj = Permission.get_by_key(perm_name)
                     UserRepoToPerm.create(perm.user, new_repo, perm_obj)
 
                 for perm in group_perms:
                     perm_name = perm.permission.permission_name.replace(
                         'group.', 'repository.')
                     perm_obj = Permission.get_by_key(perm_name)
                     UserGroupRepoToPerm.create(
                         perm.users_group, new_repo, perm_obj)
 
                 if private:
                     RepoModel(self.sa).grant_user_permission(
                         repo=new_repo, user=User.DEFAULT_USER, perm=EMPTY_PERM)
 
             else:
                 perm_obj = self._create_default_perms(new_repo, private)
                 self.sa.add(perm_obj)
 
             # now automatically start following this repository as owner
             ScmModel(self.sa).toggle_following_repo(new_repo.repo_id,
                                                     owner.user_id)
 
             # we need to flush here, in order to check if database won't
             # throw any exceptions, create filesystem dirs at the very end
             self.sa.flush()
             events.trigger(events.RepoCreateEvent(new_repo))
             return new_repo
 
         except Exception:
             log.error(traceback.format_exc())
             raise
 
     def create(self, form_data, cur_user):
         """
         Create repository using celery tasks
 
         :param form_data:
         :param cur_user:
         """
         from rhodecode.lib.celerylib import tasks, run_task
         return run_task(tasks.create_repo, form_data, cur_user)
 
     def update_permissions(self, repo, perm_additions=None, perm_updates=None,
                            perm_deletions=None, check_perms=True,
                            cur_user=None):
         if not perm_additions:
             perm_additions = []
         if not perm_updates:
             perm_updates = []
         if not perm_deletions:
             perm_deletions = []
 
         req_perms = ('usergroup.read', 'usergroup.write', 'usergroup.admin')
 
         changes = {
             'added': [],
             'updated': [],
             'deleted': []
         }
         # update permissions
         for member_id, perm, member_type in perm_updates:
             member_id = int(member_id)
             if member_type == 'user':
                 member_name = User.get(member_id).username
                 # this updates also current one if found
                 self.grant_user_permission(
                     repo=repo, user=member_id, perm=perm)
             else:  # set for user group
                 # check if we have permissions to alter this usergroup
                 member_name = UserGroup.get(member_id).users_group_name
                 if not check_perms or HasUserGroupPermissionAny(
                         *req_perms)(member_name, user=cur_user):
                     self.grant_user_group_permission(
                         repo=repo, group_name=member_id, perm=perm)
 
             changes['updated'].append({'type': member_type, 'id': member_id,
                                        'name': member_name, 'new_perm': perm})
 
         # set new permissions
         for member_id, perm, member_type in perm_additions:
             member_id = int(member_id)
             if member_type == 'user':
                 member_name = User.get(member_id).username
                 self.grant_user_permission(
                     repo=repo, user=member_id, perm=perm)
             else:  # set for user group
                 # check if we have permissions to alter this usergroup
                 member_name = UserGroup.get(member_id).users_group_name
                 if not check_perms or HasUserGroupPermissionAny(
                         *req_perms)(member_name, user=cur_user):
                     self.grant_user_group_permission(
                         repo=repo, group_name=member_id, perm=perm)
             changes['added'].append({'type': member_type, 'id': member_id,
                                      'name': member_name, 'new_perm': perm})
         # delete permissions
         for member_id, perm, member_type in perm_deletions:
             member_id = int(member_id)
             if member_type == 'user':
                 member_name = User.get(member_id).username
                 self.revoke_user_permission(repo=repo, user=member_id)
             else:  # set for user group
                 # check if we have permissions to alter this usergroup
                 member_name = UserGroup.get(member_id).users_group_name
                 if not check_perms or HasUserGroupPermissionAny(
                         *req_perms)(member_name, user=cur_user):
                     self.revoke_user_group_permission(
                         repo=repo, group_name=member_id)
 
             changes['deleted'].append({'type': member_type, 'id': member_id,
                                        'name': member_name, 'new_perm': perm})
         return changes
 
     def create_fork(self, form_data, cur_user):
         """
         Simple wrapper into executing celery task for fork creation
 
         :param form_data:
         :param cur_user:
         """
         from rhodecode.lib.celerylib import tasks, run_task
         return run_task(tasks.create_repo_fork, form_data, cur_user)
 
     def delete(self, repo, forks=None, fs_remove=True, cur_user=None):
         """
         Delete given repository, forks parameter defines what do do with
         attached forks. Throws AttachedForksError if deleted repo has attached
         forks
 
         :param repo:
         :param forks: str 'delete' or 'detach'
         :param fs_remove: remove(archive) repo from filesystem
         """
         if not cur_user:
             cur_user = getattr(get_current_rhodecode_user(), 'username', None)
         repo = self._get_repo(repo)
         if repo:
             if forks == 'detach':
                 for r in repo.forks:
                     r.fork = None
                     self.sa.add(r)
             elif forks == 'delete':
                 for r in repo.forks:
                     self.delete(r, forks='delete')
             elif [f for f in repo.forks]:
                 raise AttachedForksError()
 
             old_repo_dict = repo.get_dict()
             events.trigger(events.RepoPreDeleteEvent(repo))
             try:
                 self.sa.delete(repo)
                 if fs_remove:
                     self._delete_filesystem_repo(repo)
                 else:
                     log.debug('skipping removal from filesystem')
                 old_repo_dict.update({
                     'deleted_by': cur_user,
                     'deleted_on': time.time(),
                 })
                 log_delete_repository(**old_repo_dict)
                 events.trigger(events.RepoDeleteEvent(repo))
             except Exception:
                 log.error(traceback.format_exc())
                 raise
 
     def grant_user_permission(self, repo, user, perm):
         """
         Grant permission for user on given repository, or update existing one
         if found
 
         :param repo: Instance of Repository, repository_id, or repository name
         :param user: Instance of User, user_id or username
         :param perm: Instance of Permission, or permission_name
         """
         user = self._get_user(user)
         repo = self._get_repo(repo)
         permission = self._get_perm(perm)
 
         # check if we have that permission already
         obj = self.sa.query(UserRepoToPerm) \
             .filter(UserRepoToPerm.user == user) \
             .filter(UserRepoToPerm.repository == repo) \
             .scalar()
         if obj is None:
             # create new !
             obj = UserRepoToPerm()
         obj.repository = repo
         obj.user = user
         obj.permission = permission
         self.sa.add(obj)
         log.debug('Granted perm %s to %s on %s', perm, user, repo)
         action_logger_generic(
             'granted permission: {} to user: {} on repo: {}'.format(
                 perm, user, repo), namespace='security.repo')
         return obj
 
     def revoke_user_permission(self, repo, user):
         """
         Revoke permission for user on given repository
 
         :param repo: Instance of Repository, repository_id, or repository name
         :param user: Instance of User, user_id or username
         """
 
         user = self._get_user(user)
         repo = self._get_repo(repo)
 
         obj = self.sa.query(UserRepoToPerm) \
             .filter(UserRepoToPerm.repository == repo) \
             .filter(UserRepoToPerm.user == user) \
             .scalar()
         if obj:
             self.sa.delete(obj)
             log.debug('Revoked perm on %s on %s', repo, user)
             action_logger_generic(
                 'revoked permission from user: {} on repo: {}'.format(
                     user, repo), namespace='security.repo')
 
     def grant_user_group_permission(self, repo, group_name, perm):
         """
         Grant permission for user group on given repository, or update
         existing one if found
 
         :param repo: Instance of Repository, repository_id, or repository name
         :param group_name: Instance of UserGroup, users_group_id,
             or user group name
         :param perm: Instance of Permission, or permission_name
         """
         repo = self._get_repo(repo)
         group_name = self._get_user_group(group_name)
         permission = self._get_perm(perm)
 
         # check if we have that permission already
         obj = self.sa.query(UserGroupRepoToPerm) \
             .filter(UserGroupRepoToPerm.users_group == group_name) \
             .filter(UserGroupRepoToPerm.repository == repo) \
             .scalar()
 
         if obj is None:
             # create new
             obj = UserGroupRepoToPerm()
 
         obj.repository = repo
         obj.users_group = group_name
         obj.permission = permission
         self.sa.add(obj)
         log.debug('Granted perm %s to %s on %s', perm, group_name, repo)
         action_logger_generic(
             'granted permission: {} to usergroup: {} on repo: {}'.format(
                 perm, group_name, repo), namespace='security.repo')
 
         return obj
 
     def revoke_user_group_permission(self, repo, group_name):
         """
         Revoke permission for user group on given repository
 
         :param repo: Instance of Repository, repository_id, or repository name
         :param group_name: Instance of UserGroup, users_group_id,
             or user group name
         """
         repo = self._get_repo(repo)
         group_name = self._get_user_group(group_name)
 
         obj = self.sa.query(UserGroupRepoToPerm) \
             .filter(UserGroupRepoToPerm.repository == repo) \
             .filter(UserGroupRepoToPerm.users_group == group_name) \
             .scalar()
         if obj:
             self.sa.delete(obj)
             log.debug('Revoked perm to %s on %s', repo, group_name)
             action_logger_generic(
                 'revoked permission from usergroup: {} on repo: {}'.format(
                     group_name, repo), namespace='security.repo')
 
     def delete_stats(self, repo_name):
         """
         removes stats for given repo
 
         :param repo_name:
         """
         repo = self._get_repo(repo_name)
         try:
             obj = self.sa.query(Statistics) \
                 .filter(Statistics.repository == repo).scalar()
             if obj:
                 self.sa.delete(obj)
         except Exception:
             log.error(traceback.format_exc())
             raise
 
     def add_repo_field(self, repo_name, field_key, field_label, field_value='',
                        field_type='str', field_desc=''):
 
         repo = self._get_repo(repo_name)
 
         new_field = RepositoryField()
         new_field.repository = repo
         new_field.field_key = field_key
         new_field.field_type = field_type  # python type
         new_field.field_value = field_value
         new_field.field_desc = field_desc
         new_field.field_label = field_label
         self.sa.add(new_field)
         return new_field
 
     def delete_repo_field(self, repo_name, field_key):
         repo = self._get_repo(repo_name)
         field = RepositoryField.get_by_key_name(field_key, repo)
         if field:
             self.sa.delete(field)
 
     def _create_filesystem_repo(self, repo_name, repo_type, repo_group,
                                 clone_uri=None, repo_store_location=None,
                                 use_global_config=False):
         """
         makes repository on filesystem. It's group aware means it'll create
         a repository within a group, and alter the paths accordingly of
         group location
 
         :param repo_name:
         :param alias:
         :param parent:
         :param clone_uri:
         :param repo_store_location:
         """
         from rhodecode.lib.utils import is_valid_repo, is_valid_repo_group
         from rhodecode.model.scm import ScmModel
 
         if Repository.NAME_SEP in repo_name:
             raise ValueError(
                 'repo_name must not contain groups got `%s`' % repo_name)
 
         if isinstance(repo_group, RepoGroup):
             new_parent_path = os.sep.join(repo_group.full_path_splitted)
         else:
             new_parent_path = repo_group or ''
 
         if repo_store_location:
             _paths = [repo_store_location]
         else:
             _paths = [self.repos_path, new_parent_path, repo_name]
             # we need to make it str for mercurial
         repo_path = os.path.join(*map(lambda x: safe_str(x), _paths))
 
         # check if this path is not a repository
         if is_valid_repo(repo_path, self.repos_path):
             raise Exception('This path %s is a valid repository' % repo_path)
 
         # check if this path is a group
         if is_valid_repo_group(repo_path, self.repos_path):
             raise Exception('This path %s is a valid group' % repo_path)
 
         log.info('creating repo %s in %s from url: `%s`',
                  repo_name, safe_unicode(repo_path),
                  obfuscate_url_pw(clone_uri))
 
         backend = get_backend(repo_type)
 
         config_repo = None if use_global_config else repo_name
         if config_repo and new_parent_path:
             config_repo = Repository.NAME_SEP.join(
                 (new_parent_path, config_repo))
         config = make_db_config(clear_session=False, repo=config_repo)
         config.set('extensions', 'largefiles', '')
 
         # patch and reset hooks section of UI config to not run any
         # hooks on creating remote repo
         config.clear_section('hooks')
 
         # TODO: johbo: Unify this, hardcoded "bare=True" does not look nice
         if repo_type == 'git':
             repo = backend(
                 repo_path, config=config, create=True, src_url=clone_uri,
                 bare=True)
         else:
             repo = backend(
                 repo_path, config=config, create=True, src_url=clone_uri)
 
-        ScmModel().install_hooks(repo, repo_type=repo_type)
+        repo.install_hooks()
 
         log.debug('Created repo %s with %s backend',
                   safe_unicode(repo_name), safe_unicode(repo_type))
         return repo
 
     def _rename_filesystem_repo(self, old, new):
         """
         renames repository on filesystem
 
         :param old: old name
         :param new: new name
         """
         log.info('renaming repo from %s to %s', old, new)
 
         old_path = os.path.join(self.repos_path, old)
         new_path = os.path.join(self.repos_path, new)
         if os.path.isdir(new_path):
             raise Exception(
                 'Was trying to rename to already existing dir %s' % new_path
             )
         shutil.move(old_path, new_path)
 
     def _delete_filesystem_repo(self, repo):
         """
         removes repo from filesystem, the removal is acctually made by
         added rm__ prefix into dir, and rename internat .hg/.git dirs so this
         repository is no longer valid for rhodecode, can be undeleted later on
         by reverting the renames on this repository
 
         :param repo: repo object
         """
         rm_path = os.path.join(self.repos_path, repo.repo_name)
         repo_group = repo.group
         log.info("Removing repository %s", rm_path)
         # disable hg/git internal that it doesn't get detected as repo
         alias = repo.repo_type
 
         config = make_db_config(clear_session=False)
         config.set('extensions', 'largefiles', '')
         bare = getattr(repo.scm_instance(config=config), 'bare', False)
 
         # skip this for bare git repos
         if not bare:
             # disable VCS repo
             vcs_path = os.path.join(rm_path, '.%s' % alias)
             if os.path.exists(vcs_path):
                 shutil.move(vcs_path, os.path.join(rm_path, 'rm__.%s' % alias))
 
         _now = datetime.datetime.now()
         _ms = str(_now.microsecond).rjust(6, '0')
         _d = 'rm__%s__%s' % (_now.strftime('%Y%m%d_%H%M%S_' + _ms),
                              repo.just_name)
         if repo_group:
             # if repository is in group, prefix the removal path with the group
             args = repo_group.full_path_splitted + [_d]
             _d = os.path.join(*args)
 
         if os.path.isdir(rm_path):
             shutil.move(rm_path, os.path.join(self.repos_path, _d))
 
 
 class ReadmeFinder:
     """
     Utility which knows how to find a readme for a specific commit.
 
     The main idea is that this is a configurable algorithm. When creating an
     instance you can define parameters, currently only the `default_renderer`.
     Based on this configuration the method :meth:`search` behaves slightly
     different.
     """
 
     readme_re = re.compile(r'^readme(\.[^\.]+)?$', re.IGNORECASE)
     path_re = re.compile(r'^docs?', re.IGNORECASE)
 
     default_priorities = {
         None: 0,
         '.text': 2,
         '.txt': 3,
         '.rst': 1,
         '.rest': 2,
         '.md': 1,
         '.mkdn': 2,
         '.mdown': 3,
         '.markdown': 4,
     }
 
     path_priority = {
         'doc': 0,
         'docs': 1,
     }
 
     FALLBACK_PRIORITY = 99
 
     RENDERER_TO_EXTENSION = {
         'rst': ['.rst', '.rest'],
         'markdown': ['.md', 'mkdn', '.mdown', '.markdown'],
     }
 
     def __init__(self, default_renderer=None):
         self._default_renderer = default_renderer
         self._renderer_extensions = self.RENDERER_TO_EXTENSION.get(
             default_renderer, [])
 
     def search(self, commit, path='/'):
         """
         Find a readme in the given `commit`.
         """
         nodes = commit.get_nodes(path)
         matches = self._match_readmes(nodes)
         matches = self._sort_according_to_priority(matches)
         if matches:
             return matches[0].node
 
         paths = self._match_paths(nodes)
         paths = self._sort_paths_according_to_priority(paths)
         for path in paths:
             match = self.search(commit, path=path)
             if match:
                 return match
 
         return None
 
     def _match_readmes(self, nodes):
         for node in nodes:
             if not node.is_file():
                 continue
             path = node.path.rsplit('/', 1)[-1]
             match = self.readme_re.match(path)
             if match:
                 extension = match.group(1)
                 yield ReadmeMatch(node, match, self._priority(extension))
 
     def _match_paths(self, nodes):
         for node in nodes:
             if not node.is_dir():
                 continue
             match = self.path_re.match(node.path)
             if match:
                 yield node.path
 
     def _priority(self, extension):
         renderer_priority = (
             0 if extension in self._renderer_extensions else 1)
         extension_priority = self.default_priorities.get(
             extension, self.FALLBACK_PRIORITY)
         return (renderer_priority, extension_priority)
 
     def _sort_according_to_priority(self, matches):
 
         def priority_and_path(match):
             return (match.priority, match.path)
 
         return sorted(matches, key=priority_and_path)
 
     def _sort_paths_according_to_priority(self, paths):
 
         def priority_and_path(path):
             return (self.path_priority.get(path, self.FALLBACK_PRIORITY), path)
 
         return sorted(paths, key=priority_and_path)
 
 
 class ReadmeMatch:
 
     def __init__(self, node, match, priority):
         self.node = node
         self._match = match
         self.priority = priority
 
     @property
     def path(self):
         return self.node.path
 
     def __repr__(self):
         return '<ReadmeMatch {} priority={}'.format(self.path, self.priority)

rhodecode/model/scm.py

@@ -1,922 +1,812 b''
 # -*- coding: utf-8 -*-
 
 # Copyright (C) 2010-2018 RhodeCode GmbH
 #
 # This program is free software: you can redistribute it and/or modify
 # it under the terms of the GNU Affero General Public License, version 3
 # (only), as published by the Free Software Foundation.
 #
 # 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 Affero General Public License
 # along with this program.  If not, see <http://www.gnu.org/licenses/>.
 #
 # This program is dual-licensed. If you wish to learn more about the
 # RhodeCode Enterprise Edition, including its added features, Support services,
 # and proprietary license terms, please see https://rhodecode.com/licenses/
 
 """
 Scm model for RhodeCode
 """
 
 import os.path
 import re
 import sys
 import traceback
 import logging
 import cStringIO
 import pkg_resources
 
 from sqlalchemy import func
 from zope.cachedescriptors.property import Lazy as LazyProperty
 
 import rhodecode
 from rhodecode.lib.vcs import get_backend
 from rhodecode.lib.vcs.exceptions import RepositoryError, NodeNotChangedError
 from rhodecode.lib.vcs.nodes import FileNode
 from rhodecode.lib.vcs.backends.base import EmptyCommit
 from rhodecode.lib import helpers as h
 from rhodecode.lib.auth import (
     HasRepoPermissionAny, HasRepoGroupPermissionAny,
     HasUserGroupPermissionAny)
 from rhodecode.lib.exceptions import NonRelativePathError, IMCCommitError
 from rhodecode.lib import hooks_utils, caches
 from rhodecode.lib.utils import (
     get_filesystem_repos, make_db_config)
 from rhodecode.lib.utils2 import (safe_str, safe_unicode)
 from rhodecode.lib.system_info import get_system_info
 from rhodecode.model import BaseModel
 from rhodecode.model.db import (
     Repository, CacheKey, UserFollowing, UserLog, User, RepoGroup,
     PullRequest)
 from rhodecode.model.settings import VcsSettingsModel
 
 log = logging.getLogger(__name__)
 
 
 class UserTemp(object):
     def __init__(self, user_id):
         self.user_id = user_id
 
     def __repr__(self):
         return "<%s('id:%s')>" % (self.__class__.__name__, self.user_id)
 
 
 class RepoTemp(object):
     def __init__(self, repo_id):
         self.repo_id = repo_id
 
     def __repr__(self):
         return "<%s('id:%s')>" % (self.__class__.__name__, self.repo_id)
 
 
 class SimpleCachedRepoList(object):
     """
     Lighter version of of iteration of repos without the scm initialisation,
     and with cache usage
     """
     def __init__(self, db_repo_list, repos_path, order_by=None, perm_set=None):
         self.db_repo_list = db_repo_list
         self.repos_path = repos_path
         self.order_by = order_by
         self.reversed = (order_by or '').startswith('-')
         if not perm_set:
             perm_set = ['repository.read', 'repository.write',
                         'repository.admin']
         self.perm_set = perm_set
 
     def __len__(self):
         return len(self.db_repo_list)
 
     def __repr__(self):
         return '<%s (%s)>' % (self.__class__.__name__, self.__len__())
 
     def __iter__(self):
         for dbr in self.db_repo_list:
             # check permission at this level
             has_perm = HasRepoPermissionAny(*self.perm_set)(
                 dbr.repo_name, 'SimpleCachedRepoList check')
             if not has_perm:
                 continue
 
             tmp_d = {
                 'name': dbr.repo_name,
                 'dbrepo': dbr.get_dict(),
                 'dbrepo_fork': dbr.fork.get_dict() if dbr.fork else {}
             }
             yield tmp_d
 
 
 class _PermCheckIterator(object):
 
     def __init__(
             self, obj_list, obj_attr, perm_set, perm_checker,
             extra_kwargs=None):
         """
         Creates iterator from given list of objects, additionally
         checking permission for them from perm_set var
 
         :param obj_list: list of db objects
         :param obj_attr: attribute of object to pass into perm_checker
         :param perm_set: list of permissions to check
         :param perm_checker: callable to check permissions against
         """
         self.obj_list = obj_list
         self.obj_attr = obj_attr
         self.perm_set = perm_set
         self.perm_checker = perm_checker
         self.extra_kwargs = extra_kwargs or {}
 
     def __len__(self):
         return len(self.obj_list)
 
     def __repr__(self):
         return '<%s (%s)>' % (self.__class__.__name__, self.__len__())
 
     def __iter__(self):
         checker = self.perm_checker(*self.perm_set)
         for db_obj in self.obj_list:
             # check permission at this level
             name = getattr(db_obj, self.obj_attr, None)
             if not checker(name, self.__class__.__name__, **self.extra_kwargs):
                 continue
 
             yield db_obj
 
 
 class RepoList(_PermCheckIterator):
 
     def __init__(self, db_repo_list, perm_set=None, extra_kwargs=None):
         if not perm_set:
             perm_set = [
                 'repository.read', 'repository.write', 'repository.admin']
 
         super(RepoList, self).__init__(
             obj_list=db_repo_list,
             obj_attr='repo_name', perm_set=perm_set,
             perm_checker=HasRepoPermissionAny,
             extra_kwargs=extra_kwargs)
 
 
 class RepoGroupList(_PermCheckIterator):
 
     def __init__(self, db_repo_group_list, perm_set=None, extra_kwargs=None):
         if not perm_set:
             perm_set = ['group.read', 'group.write', 'group.admin']
 
         super(RepoGroupList, self).__init__(
             obj_list=db_repo_group_list,
             obj_attr='group_name', perm_set=perm_set,
             perm_checker=HasRepoGroupPermissionAny,
             extra_kwargs=extra_kwargs)
 
 
 class UserGroupList(_PermCheckIterator):
 
     def __init__(self, db_user_group_list, perm_set=None, extra_kwargs=None):
         if not perm_set:
             perm_set = ['usergroup.read', 'usergroup.write', 'usergroup.admin']
 
         super(UserGroupList, self).__init__(
             obj_list=db_user_group_list,
             obj_attr='users_group_name', perm_set=perm_set,
             perm_checker=HasUserGroupPermissionAny,
             extra_kwargs=extra_kwargs)
 
 
 class ScmModel(BaseModel):
     """
     Generic Scm Model
     """
 
     @LazyProperty
     def repos_path(self):
         """
         Gets the repositories root path from database
         """
 
         settings_model = VcsSettingsModel(sa=self.sa)
         return settings_model.get_repos_location()
 
     def repo_scan(self, repos_path=None):
         """
         Listing of repositories in given path. This path should not be a
         repository itself. Return a dictionary of repository objects
 
         :param repos_path: path to directory containing repositories
         """
 
         if repos_path is None:
             repos_path = self.repos_path
 
         log.info('scanning for repositories in %s', repos_path)
 
         config = make_db_config()
         config.set('extensions', 'largefiles', '')
         repos = {}
 
         for name, path in get_filesystem_repos(repos_path, recursive=True):
             # name need to be decomposed and put back together using the /
             # since this is internal storage separator for rhodecode
             name = Repository.normalize_repo_name(name)
 
             try:
                 if name in repos:
                     raise RepositoryError('Duplicate repository name %s '
                                           'found in %s' % (name, path))
                 elif path[0] in rhodecode.BACKENDS:
                     klass = get_backend(path[0])
                     repos[name] = klass(path[1], config=config)
             except OSError:
                 continue
         log.debug('found %s paths with repositories', len(repos))
         return repos
 
     def get_repos(self, all_repos=None, sort_key=None):
         """
         Get all repositories from db and for each repo create it's
         backend instance and fill that backed with information from database
 
         :param all_repos: list of repository names as strings
             give specific repositories list, good for filtering
 
         :param sort_key: initial sorting of repositories
         """
         if all_repos is None:
             all_repos = self.sa.query(Repository)\
                 .filter(Repository.group_id == None)\
                 .order_by(func.lower(Repository.repo_name)).all()
         repo_iter = SimpleCachedRepoList(
             all_repos, repos_path=self.repos_path, order_by=sort_key)
         return repo_iter
 
     def get_repo_groups(self, all_groups=None):
         if all_groups is None:
             all_groups = RepoGroup.query()\
                 .filter(RepoGroup.group_parent_id == None).all()
         return [x for x in RepoGroupList(all_groups)]
 
     def mark_for_invalidation(self, repo_name, delete=False):
         """
         Mark caches of this repo invalid in the database. `delete` flag
         removes the cache entries
 
         :param repo_name: the repo_name for which caches should be marked
             invalid, or deleted
         :param delete: delete the entry keys instead of setting bool
             flag on them
         """
         CacheKey.set_invalidate(repo_name, delete=delete)
         repo = Repository.get_by_repo_name(repo_name)
 
         if repo:
             config = repo._config
             config.set('extensions', 'largefiles', '')
             repo.update_commit_cache(config=config, cs_cache=None)
             caches.clear_repo_caches(repo_name)
 
     def toggle_following_repo(self, follow_repo_id, user_id):
 
         f = self.sa.query(UserFollowing)\
             .filter(UserFollowing.follows_repo_id == follow_repo_id)\
             .filter(UserFollowing.user_id == user_id).scalar()
 
         if f is not None:
             try:
                 self.sa.delete(f)
                 return
             except Exception:
                 log.error(traceback.format_exc())
                 raise
 
         try:
             f = UserFollowing()
             f.user_id = user_id
             f.follows_repo_id = follow_repo_id
             self.sa.add(f)
         except Exception:
             log.error(traceback.format_exc())
             raise
 
     def toggle_following_user(self, follow_user_id, user_id):
         f = self.sa.query(UserFollowing)\
             .filter(UserFollowing.follows_user_id == follow_user_id)\
             .filter(UserFollowing.user_id == user_id).scalar()
 
         if f is not None:
             try:
                 self.sa.delete(f)
                 return
             except Exception:
                 log.error(traceback.format_exc())
                 raise
 
         try:
             f = UserFollowing()
             f.user_id = user_id
             f.follows_user_id = follow_user_id
             self.sa.add(f)
         except Exception:
             log.error(traceback.format_exc())
             raise
 
     def is_following_repo(self, repo_name, user_id, cache=False):
         r = self.sa.query(Repository)\
             .filter(Repository.repo_name == repo_name).scalar()
 
         f = self.sa.query(UserFollowing)\
             .filter(UserFollowing.follows_repository == r)\
             .filter(UserFollowing.user_id == user_id).scalar()
 
         return f is not None
 
     def is_following_user(self, username, user_id, cache=False):
         u = User.get_by_username(username)
 
         f = self.sa.query(UserFollowing)\
             .filter(UserFollowing.follows_user == u)\
             .filter(UserFollowing.user_id == user_id).scalar()
 
         return f is not None
 
     def get_followers(self, repo):
         repo = self._get_repo(repo)
 
         return self.sa.query(UserFollowing)\
             .filter(UserFollowing.follows_repository == repo).count()
 
     def get_forks(self, repo):
         repo = self._get_repo(repo)
         return self.sa.query(Repository)\
             .filter(Repository.fork == repo).count()
 
     def get_pull_requests(self, repo):
         repo = self._get_repo(repo)
         return self.sa.query(PullRequest)\
             .filter(PullRequest.target_repo == repo)\
             .filter(PullRequest.status != PullRequest.STATUS_CLOSED).count()
 
     def mark_as_fork(self, repo, fork, user):
         repo = self._get_repo(repo)
         fork = self._get_repo(fork)
         if fork and repo.repo_id == fork.repo_id:
             raise Exception("Cannot set repository as fork of itself")
 
         if fork and repo.repo_type != fork.repo_type:
             raise RepositoryError(
                 "Cannot set repository as fork of repository with other type")
 
         repo.fork = fork
         self.sa.add(repo)
         return repo
 
     def pull_changes(self, repo, username, remote_uri=None):
         dbrepo = self._get_repo(repo)
         remote_uri = remote_uri or dbrepo.clone_uri
         if not remote_uri:
             raise Exception("This repository doesn't have a clone uri")
 
         repo = dbrepo.scm_instance(cache=False)
         # TODO: marcink fix this an re-enable since we need common logic
         # for hg/git remove hooks so we don't trigger them on fetching
         # commits from remote
         repo.config.clear_section('hooks')
 
         repo_name = dbrepo.repo_name
         try:
             # TODO: we need to make sure those operations call proper hooks !
             repo.pull(remote_uri)
 
             self.mark_for_invalidation(repo_name)
         except Exception:
             log.error(traceback.format_exc())
             raise
 
     def push_changes(self, repo, username, remote_uri=None):
         dbrepo = self._get_repo(repo)
         remote_uri = remote_uri or dbrepo.push_uri
         if not remote_uri:
             raise Exception("This repository doesn't have a clone uri")
 
         repo = dbrepo.scm_instance(cache=False)
         repo.config.clear_section('hooks')
 
         try:
             repo.push(remote_uri)
         except Exception:
             log.error(traceback.format_exc())
             raise
 
     def commit_change(self, repo, repo_name, commit, user, author, message,
                       content, f_path):
         """
         Commits changes
 
         :param repo: SCM instance
 
         """
         user = self._get_user(user)
 
         # decoding here will force that we have proper encoded values
         # in any other case this will throw exceptions and deny commit
         content = safe_str(content)
         path = safe_str(f_path)
         # message and author needs to be unicode
         # proper backend should then translate that into required type
         message = safe_unicode(message)
         author = safe_unicode(author)
         imc = repo.in_memory_commit
         imc.change(FileNode(path, content, mode=commit.get_file_mode(f_path)))
         try:
             # TODO: handle pre-push action !
             tip = imc.commit(
                 message=message, author=author, parents=[commit],
                 branch=commit.branch)
         except Exception as e:
             log.error(traceback.format_exc())
             raise IMCCommitError(str(e))
         finally:
             # always clear caches, if commit fails we want fresh object also
             self.mark_for_invalidation(repo_name)
 
         # We trigger the post-push action
         hooks_utils.trigger_post_push_hook(
             username=user.username, action='push_local', repo_name=repo_name,
             repo_alias=repo.alias, commit_ids=[tip.raw_id])
         return tip
 
     def _sanitize_path(self, f_path):
         if f_path.startswith('/') or f_path.startswith('./') or '../' in f_path:
             raise NonRelativePathError('%s is not an relative path' % f_path)
         if f_path:
             f_path = os.path.normpath(f_path)
         return f_path
 
     def get_dirnode_metadata(self, request, commit, dir_node):
         if not dir_node.is_dir():
             return []
 
         data = []
         for node in dir_node:
             if not node.is_file():
                 # we skip file-nodes
                 continue
 
             last_commit = node.last_commit
             last_commit_date = last_commit.date
             data.append({
                 'name': node.name,
                 'size': h.format_byte_size_binary(node.size),
                 'modified_at': h.format_date(last_commit_date),
                 'modified_ts': last_commit_date.isoformat(),
                 'revision': last_commit.revision,
                 'short_id': last_commit.short_id,
                 'message': h.escape(last_commit.message),
                 'author': h.escape(last_commit.author),
                 'user_profile': h.gravatar_with_user(
                     request, last_commit.author),
             })
 
         return data
 
     def get_nodes(self, repo_name, commit_id, root_path='/', flat=True,
                   extended_info=False, content=False, max_file_bytes=None):
         """
         recursive walk in root dir and return a set of all path in that dir
         based on repository walk function
 
         :param repo_name: name of repository
         :param commit_id: commit id for which to list nodes
         :param root_path: root path to list
         :param flat: return as a list, if False returns a dict with description
         :param max_file_bytes: will not return file contents over this limit
 
         """
         _files = list()
         _dirs = list()
         try:
             _repo = self._get_repo(repo_name)
             commit = _repo.scm_instance().get_commit(commit_id=commit_id)
             root_path = root_path.lstrip('/')
             for __, dirs, files in commit.walk(root_path):
                 for f in files:
                     _content = None
                     _data = f.unicode_path
                     over_size_limit = (max_file_bytes is not None
                                        and f.size > max_file_bytes)
 
                     if not flat:
                         _data = {
                             "name": h.escape(f.unicode_path),
                             "type": "file",
                             }
                         if extended_info:
                             _data.update({
                                 "md5": f.md5,
                                 "binary": f.is_binary,
                                 "size": f.size,
                                 "extension": f.extension,
                                 "mimetype": f.mimetype,
                                 "lines": f.lines()[0]
                             })
 
                         if content:
                             full_content = None
                             if not f.is_binary and not over_size_limit:
                                 full_content = safe_str(f.content)
 
                             _data.update({
                                 "content": full_content,
                             })
                     _files.append(_data)
                 for d in dirs:
                     _data = d.unicode_path
                     if not flat:
                         _data = {
                             "name": h.escape(d.unicode_path),
                             "type": "dir",
                             }
                     if extended_info:
                         _data.update({
                             "md5": None,
                             "binary": None,
                             "size": None,
                             "extension": None,
                         })
                     if content:
                         _data.update({
                             "content": None
                         })
                     _dirs.append(_data)
         except RepositoryError:
             log.debug("Exception in get_nodes", exc_info=True)
             raise
 
         return _dirs, _files
 
     def create_nodes(self, user, repo, message, nodes, parent_commit=None,
                      author=None, trigger_push_hook=True):
         """
         Commits given multiple nodes into repo
 
         :param user: RhodeCode User object or user_id, the commiter
         :param repo: RhodeCode Repository object
         :param message: commit message
         :param nodes: mapping {filename:{'content':content},...}
         :param parent_commit: parent commit, can be empty than it's
            initial commit
         :param author: author of commit, cna be different that commiter
            only for git
         :param trigger_push_hook: trigger push hooks
 
         :returns: new commited commit
         """
 
         user = self._get_user(user)
         scm_instance = repo.scm_instance(cache=False)
 
         processed_nodes = []
         for f_path in nodes:
             f_path = self._sanitize_path(f_path)
             content = nodes[f_path]['content']
             f_path = safe_str(f_path)
             # decoding here will force that we have proper encoded values
             # in any other case this will throw exceptions and deny commit
             if isinstance(content, (basestring,)):
                 content = safe_str(content)
             elif isinstance(content, (file, cStringIO.OutputType,)):
                 content = content.read()
             else:
                 raise Exception('Content is of unrecognized type %s' % (
                     type(content)
                 ))
             processed_nodes.append((f_path, content))
 
         message = safe_unicode(message)
         commiter = user.full_contact
         author = safe_unicode(author) if author else commiter
 
         imc = scm_instance.in_memory_commit
 
         if not parent_commit:
             parent_commit = EmptyCommit(alias=scm_instance.alias)
 
         if isinstance(parent_commit, EmptyCommit):
             # EmptyCommit means we we're editing empty repository
             parents = None
         else:
             parents = [parent_commit]
         # add multiple nodes
         for path, content in processed_nodes:
             imc.add(FileNode(path, content=content))
         # TODO: handle pre push scenario
         tip = imc.commit(message=message,
                          author=author,
                          parents=parents,
                          branch=parent_commit.branch)
 
         self.mark_for_invalidation(repo.repo_name)
         if trigger_push_hook:
             hooks_utils.trigger_post_push_hook(
                 username=user.username, action='push_local',
                 repo_name=repo.repo_name, repo_alias=scm_instance.alias,
                 commit_ids=[tip.raw_id])
         return tip
 
     def update_nodes(self, user, repo, message, nodes, parent_commit=None,
                      author=None, trigger_push_hook=True):
         user = self._get_user(user)
         scm_instance = repo.scm_instance(cache=False)
 
         message = safe_unicode(message)
         commiter = user.full_contact
         author = safe_unicode(author) if author else commiter
 
         imc = scm_instance.in_memory_commit
 
         if not parent_commit:
             parent_commit = EmptyCommit(alias=scm_instance.alias)
 
         if isinstance(parent_commit, EmptyCommit):
             # EmptyCommit means we we're editing empty repository
             parents = None
         else:
             parents = [parent_commit]
 
         # add multiple nodes
         for _filename, data in nodes.items():
             # new filename, can be renamed from the old one, also sanitaze
             # the path for any hack around relative paths like ../../ etc.
             filename = self._sanitize_path(data['filename'])
             old_filename = self._sanitize_path(_filename)
             content = data['content']
 
             filenode = FileNode(old_filename, content=content)
             op = data['op']
             if op == 'add':
                 imc.add(filenode)
             elif op == 'del':
                 imc.remove(filenode)
             elif op == 'mod':
                 if filename != old_filename:
                     # TODO: handle renames more efficient, needs vcs lib
                     # changes
                     imc.remove(filenode)
                     imc.add(FileNode(filename, content=content))
                 else:
                     imc.change(filenode)
 
         try:
             # TODO: handle pre push scenario
             # commit changes
             tip = imc.commit(message=message,
                              author=author,
                              parents=parents,
                              branch=parent_commit.branch)
         except NodeNotChangedError:
             raise
         except Exception as e:
             log.exception("Unexpected exception during call to imc.commit")
             raise IMCCommitError(str(e))
         finally:
             # always clear caches, if commit fails we want fresh object also
             self.mark_for_invalidation(repo.repo_name)
 
         if trigger_push_hook:
             hooks_utils.trigger_post_push_hook(
                 username=user.username, action='push_local',
                 repo_name=repo.repo_name, repo_alias=scm_instance.alias,
                 commit_ids=[tip.raw_id])
 
     def delete_nodes(self, user, repo, message, nodes, parent_commit=None,
                      author=None, trigger_push_hook=True):
         """
         Deletes given multiple nodes into `repo`
 
         :param user: RhodeCode User object or user_id, the committer
         :param repo: RhodeCode Repository object
         :param message: commit message
         :param nodes: mapping {filename:{'content':content},...}
         :param parent_commit: parent commit, can be empty than it's initial
            commit
         :param author: author of commit, cna be different that commiter only
            for git
         :param trigger_push_hook: trigger push hooks
 
         :returns: new commit after deletion
         """
 
         user = self._get_user(user)
         scm_instance = repo.scm_instance(cache=False)
 
         processed_nodes = []
         for f_path in nodes:
             f_path = self._sanitize_path(f_path)
             # content can be empty but for compatabilty it allows same dicts
             # structure as add_nodes
             content = nodes[f_path].get('content')
             processed_nodes.append((f_path, content))
 
         message = safe_unicode(message)
         commiter = user.full_contact
         author = safe_unicode(author) if author else commiter
 
         imc = scm_instance.in_memory_commit
 
         if not parent_commit:
             parent_commit = EmptyCommit(alias=scm_instance.alias)
 
         if isinstance(parent_commit, EmptyCommit):
             # EmptyCommit means we we're editing empty repository
             parents = None
         else:
             parents = [parent_commit]
         # add multiple nodes
         for path, content in processed_nodes:
             imc.remove(FileNode(path, content=content))
 
         # TODO: handle pre push scenario
         tip = imc.commit(message=message,
                          author=author,
                          parents=parents,
                          branch=parent_commit.branch)
 
         self.mark_for_invalidation(repo.repo_name)
         if trigger_push_hook:
             hooks_utils.trigger_post_push_hook(
                 username=user.username, action='push_local',
                 repo_name=repo.repo_name, repo_alias=scm_instance.alias,
                 commit_ids=[tip.raw_id])
         return tip
 
     def strip(self, repo, commit_id, branch):
         scm_instance = repo.scm_instance(cache=False)
         scm_instance.config.clear_section('hooks')
         scm_instance.strip(commit_id, branch)
         self.mark_for_invalidation(repo.repo_name)
 
     def get_unread_journal(self):
         return self.sa.query(UserLog).count()
 
     def get_repo_landing_revs(self, translator, repo=None):
         """
         Generates select option with tags branches and bookmarks (for hg only)
         grouped by type
 
         :param repo:
         """
         _ = translator
         repo = self._get_repo(repo)
 
         hist_l = [
             ['rev:tip', _('latest tip')]
         ]
         choices = [
             'rev:tip'
         ]
 
         if not repo:
             return choices, hist_l
 
         repo = repo.scm_instance()
 
         branches_group = (
             [(u'branch:%s' % safe_unicode(b), safe_unicode(b))
                 for b in repo.branches],
             _("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' % safe_unicode(b), safe_unicode(b))
                     for b in repo.bookmarks],
                 _("Bookmarks"))
             hist_l.append(bookmarks_group)
             choices.extend([x[0] for x in bookmarks_group[0]])
 
         tags_group = (
             [(u'tag:%s' % safe_unicode(t), safe_unicode(t))
                 for t in repo.tags],
             _("Tags"))
         hist_l.append(tags_group)
         choices.extend([x[0] for x in tags_group[0]])
 
         return choices, hist_l
 
-    def install_git_hook(self, repo, force_create=False):
-        """
-        Creates a rhodecode 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, mode=0777)
-
-        tmpl_post = pkg_resources.resource_string(
-            'rhodecode', '/'.join(
-                ('config', 'hook_templates', 'git_post_receive.py.tmpl')))
-        tmpl_pre = pkg_resources.resource_string(
-            'rhodecode', '/'.join(
-                ('config', 'hook_templates', 'git_pre_receive.py.tmpl')))
-
-        for h_type, tmpl in [('pre', tmpl_pre), ('post', tmpl_post)]:
-            _hook_file = os.path.join(loc, '%s-receive' % h_type)
-            log.debug('Installing git hook in repo %s', repo)
-            _rhodecode_hook = _check_rhodecode_hook(_hook_file)
-
-            if _rhodecode_hook or force_create:
-                log.debug('writing %s hook file !', h_type)
-                try:
-                    with open(_hook_file, 'wb') as f:
-                        tmpl = tmpl.replace('_TMPL_', rhodecode.__version__)
-                        tmpl = tmpl.replace('_ENV_', sys.executable)
-                        f.write(tmpl)
-                    os.chmod(_hook_file, 0755)
-                except IOError:
-                    log.exception('error writing hook file %s', _hook_file)
-            else:
-                log.debug('skipping writing hook file')
-
-    def install_svn_hooks(self, repo, force_create=False):
-        """
-        Creates rhodecode hooks inside a svn repository
-
-        :param repo: Instance of VCS repo
-        :param force_create: Create even if same name hook exists
-        """
-        hooks_path = os.path.join(repo.path, 'hooks')
-        if not os.path.isdir(hooks_path):
-            os.makedirs(hooks_path)
-        post_commit_tmpl = pkg_resources.resource_string(
-            'rhodecode', '/'.join(
-                ('config', 'hook_templates', 'svn_post_commit_hook.py.tmpl')))
-        pre_commit_template = pkg_resources.resource_string(
-            'rhodecode', '/'.join(
-                ('config', 'hook_templates', 'svn_pre_commit_hook.py.tmpl')))
-        templates = {
-            'post-commit': post_commit_tmpl,
-            'pre-commit': pre_commit_template
-        }
-        for filename in templates:
-            _hook_file = os.path.join(hooks_path, filename)
-            _rhodecode_hook = _check_rhodecode_hook(_hook_file)
-            if _rhodecode_hook or force_create:
-                log.debug('writing %s hook file !', filename)
-                template = templates[filename]
-                try:
-                    with open(_hook_file, 'wb') as f:
-                        template = template.replace(
-                            '_TMPL_', rhodecode.__version__)
-                        template = template.replace('_ENV_', sys.executable)
-                        f.write(template)
-                    os.chmod(_hook_file, 0755)
-                except IOError:
-                    log.exception('error writing hook file %s', filename)
-            else:
-                log.debug('skipping writing hook file')
-
-    def install_hooks(self, repo, repo_type):
-        if repo_type == 'git':
-            self.install_git_hook(repo)
-        elif repo_type == 'svn':
-            self.install_svn_hooks(repo)
-
     def get_server_info(self, environ=None):
         server_info = get_system_info(environ)
         return server_info
-
-
-def _check_rhodecode_hook(hook_path):
-    """
-    Check if the hook was created by RhodeCode
-    """
-    if not os.path.exists(hook_path):
-        return True
-
-    log.debug('hook exists, checking if it is from rhodecode')
-    hook_content = _read_hook(hook_path)
-    matches = re.search(r'(?:RC_HOOK_VER)\s*=\s*(.*)', hook_content)
-    if matches:
-        try:
-            version = matches.groups()[0]
-            log.debug('got %s, it is rhodecode', version)
-            return True
-        except Exception:
-            log.exception("Exception while reading the hook version.")
-
-    return False
-
-
-def _read_hook(hook_path):
-    with open(hook_path, 'rb') as f:
-        content = f.read()
-    return content

rhodecode/tests/lib/middleware/test_simplevcs.py

@@ -1,499 +1,472 b''
 # -*- coding: utf-8 -*-
 
 # Copyright (C) 2010-2018 RhodeCode GmbH
 #
 # This program is free software: you can redistribute it and/or modify
 # it under the terms of the GNU Affero General Public License, version 3
 # (only), as published by the Free Software Foundation.
 #
 # 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 Affero General Public License
 # along with this program.  If not, see <http://www.gnu.org/licenses/>.
 #
 # This program is dual-licensed. If you wish to learn more about the
 # RhodeCode Enterprise Edition, including its added features, Support services,
 # and proprietary license terms, please see https://rhodecode.com/licenses/
 
 import base64
 
 import mock
 import pytest
 
 from rhodecode.lib.utils2 import AttributeDict
 from rhodecode.tests.utils import CustomTestApp
 
 from rhodecode.lib.caching_query import FromCache
 from rhodecode.lib.hooks_daemon import DummyHooksCallbackDaemon
 from rhodecode.lib.middleware import simplevcs
 from rhodecode.lib.middleware.https_fixup import HttpsFixup
 from rhodecode.lib.middleware.utils import scm_app_http
 from rhodecode.model.db import User, _hash_key
 from rhodecode.model.meta import Session
 from rhodecode.tests import (
     HG_REPO, TEST_USER_ADMIN_LOGIN, TEST_USER_ADMIN_PASS)
 from rhodecode.tests.lib.middleware import mock_scm_app
 
 
 class StubVCSController(simplevcs.SimpleVCS):
 
     SCM = 'hg'
     stub_response_body = tuple()
 
     def __init__(self, *args, **kwargs):
         super(StubVCSController, self).__init__(*args, **kwargs)
         self._action = 'pull'
         self._is_shadow_repo_dir = True
         self._name = HG_REPO
         self.set_repo_names(None)
 
     @property
     def is_shadow_repo_dir(self):
         return self._is_shadow_repo_dir
 
     def _get_repository_name(self, environ):
         return self._name
 
     def _get_action(self, environ):
         return self._action
 
     def _create_wsgi_app(self, repo_path, repo_name, config):
         def fake_app(environ, start_response):
             headers = [
                 ('Http-Accept', 'application/mercurial')
             ]
             start_response('200 OK', headers)
             return self.stub_response_body
         return fake_app
 
     def _create_config(self, extras, repo_name):
         return None
 
 
 @pytest.fixture
 def vcscontroller(baseapp, config_stub, request_stub):
     config_stub.testing_securitypolicy()
     config_stub.include('rhodecode.authentication')
 
     controller = StubVCSController(
         baseapp.config.get_settings(), request_stub.registry)
     app = HttpsFixup(controller, baseapp.config.get_settings())
     app = CustomTestApp(app)
 
     _remove_default_user_from_query_cache()
 
     # Sanity checks that things are set up correctly
     app.get('/' + HG_REPO, status=200)
 
     app.controller = controller
     return app
 
 
 def _remove_default_user_from_query_cache():
     user = User.get_default_user(cache=True)
     query = Session().query(User).filter(User.username == user.username)
     query = query.options(
         FromCache("sql_cache_short", "get_user_%s" % _hash_key(user.username)))
     query.invalidate()
     Session().expire(user)
 
 
 def test_handles_exceptions_during_permissions_checks(
         vcscontroller, disable_anonymous_user):
     user_and_pass = '%s:%s' % (TEST_USER_ADMIN_LOGIN, TEST_USER_ADMIN_PASS)
     auth_password = base64.encodestring(user_and_pass).strip()
     extra_environ = {
         'AUTH_TYPE': 'Basic',
         'HTTP_AUTHORIZATION': 'Basic %s' % auth_password,
         'REMOTE_USER': TEST_USER_ADMIN_LOGIN,
     }
 
     # Verify that things are hooked up correctly
     vcscontroller.get('/', status=200, extra_environ=extra_environ)
 
     # Simulate trouble during permission checks
     with mock.patch('rhodecode.model.db.User.get_by_username',
                     side_effect=Exception) as get_user:
         # Verify that a correct 500 is returned and check that the expected
         # code path was hit.
         vcscontroller.get('/', status=500, extra_environ=extra_environ)
         assert get_user.called
 
 
 def test_returns_forbidden_if_no_anonymous_access(
         vcscontroller, disable_anonymous_user):
     vcscontroller.get('/', status=401)
 
 
 class StubFailVCSController(simplevcs.SimpleVCS):
     def _handle_request(self, environ, start_response):
         raise Exception("BOOM")
 
 
 @pytest.fixture(scope='module')
 def fail_controller(baseapp):
     controller = StubFailVCSController(
         baseapp.config.get_settings(), baseapp.config)
     controller = HttpsFixup(controller, baseapp.config.get_settings())
     controller = CustomTestApp(controller)
     return controller
 
 
 def test_handles_exceptions_as_internal_server_error(fail_controller):
     fail_controller.get('/', status=500)
 
 
 def test_provides_traceback_for_appenlight(fail_controller):
     response = fail_controller.get(
         '/', status=500, extra_environ={'appenlight.client': 'fake'})
     assert 'appenlight.__traceback' in response.request.environ
 
 
 def test_provides_utils_scm_app_as_scm_app_by_default(baseapp, request_stub):
     controller = StubVCSController(baseapp.config.get_settings(), request_stub.registry)
     assert controller.scm_app is scm_app_http
 
 
 def test_allows_to_override_scm_app_via_config(baseapp, request_stub):
     config = baseapp.config.get_settings().copy()
     config['vcs.scm_app_implementation'] = (
         'rhodecode.tests.lib.middleware.mock_scm_app')
     controller = StubVCSController(config, request_stub.registry)
     assert controller.scm_app is mock_scm_app
 
 
 @pytest.mark.parametrize('query_string, expected', [
     ('cmd=stub_command', True),
     ('cmd=listkeys', False),
 ])
 def test_should_check_locking(query_string, expected):
     result = simplevcs._should_check_locking(query_string)
     assert result == expected
 
 
 class TestShadowRepoRegularExpression(object):
     pr_segment = 'pull-request'
     shadow_segment = 'repository'
 
     @pytest.mark.parametrize('url, expected', [
         # repo with/without groups
         ('My-Repo/{pr_segment}/1/{shadow_segment}', True),
         ('Group/My-Repo/{pr_segment}/2/{shadow_segment}', True),
         ('Group/Sub-Group/My-Repo/{pr_segment}/3/{shadow_segment}', True),
         ('Group/Sub-Group1/Sub-Group2/My-Repo/{pr_segment}/3/{shadow_segment}', True),
 
         # pull request ID
         ('MyRepo/{pr_segment}/1/{shadow_segment}', True),
         ('MyRepo/{pr_segment}/1234567890/{shadow_segment}', True),
         ('MyRepo/{pr_segment}/-1/{shadow_segment}', False),
         ('MyRepo/{pr_segment}/invalid/{shadow_segment}', False),
 
         # unicode
         (u'Sp€çîál-Repö/{pr_segment}/1/{shadow_segment}', True),
         (u'Sp€çîál-Gröüp/Sp€çîál-Repö/{pr_segment}/1/{shadow_segment}', True),
 
         # trailing/leading slash
         ('/My-Repo/{pr_segment}/1/{shadow_segment}', False),
         ('My-Repo/{pr_segment}/1/{shadow_segment}/', False),
         ('/My-Repo/{pr_segment}/1/{shadow_segment}/', False),
 
         # misc
         ('My-Repo/{pr_segment}/1/{shadow_segment}/extra', False),
         ('My-Repo/{pr_segment}/1/{shadow_segment}extra', False),
     ])
     def test_shadow_repo_regular_expression(self, url, expected):
         from rhodecode.lib.middleware.simplevcs import SimpleVCS
         url = url.format(
             pr_segment=self.pr_segment,
             shadow_segment=self.shadow_segment)
         match_obj = SimpleVCS.shadow_repo_re.match(url)
         assert (match_obj is not None) == expected
 
 
 @pytest.mark.backends('git', 'hg')
 class TestShadowRepoExposure(object):
 
     def test_pull_on_shadow_repo_propagates_to_wsgi_app(
             self, baseapp, request_stub):
         """
         Check that a pull action to a shadow repo is propagated to the
         underlying wsgi app.
         """
         controller = StubVCSController(
             baseapp.config.get_settings(), request_stub.registry)
         controller._check_ssl = mock.Mock()
         controller.is_shadow_repo = True
         controller._action = 'pull'
         controller._is_shadow_repo_dir = True
         controller.stub_response_body = 'dummy body value'
         controller._get_default_cache_ttl = mock.Mock(
             return_value=(False, 0))
 
         environ_stub = {
             'HTTP_HOST': 'test.example.com',
             'HTTP_ACCEPT': 'application/mercurial',
             'REQUEST_METHOD': 'GET',
             'wsgi.url_scheme': 'http',
         }
 
         response = controller(environ_stub, mock.Mock())
         response_body = ''.join(response)
 
         # Assert that we got the response from the wsgi app.
         assert response_body == controller.stub_response_body
 
     def test_pull_on_shadow_repo_that_is_missing(self, baseapp, request_stub):
         """
         Check that a pull action to a shadow repo is propagated to the
         underlying wsgi app.
         """
         controller = StubVCSController(
             baseapp.config.get_settings(), request_stub.registry)
         controller._check_ssl = mock.Mock()
         controller.is_shadow_repo = True
         controller._action = 'pull'
         controller._is_shadow_repo_dir = False
         controller.stub_response_body = 'dummy body value'
         environ_stub = {
             'HTTP_HOST': 'test.example.com',
             'HTTP_ACCEPT': 'application/mercurial',
             'REQUEST_METHOD': 'GET',
             'wsgi.url_scheme': 'http',
         }
 
         response = controller(environ_stub, mock.Mock())
         response_body = ''.join(response)
 
         # Assert that we got the response from the wsgi app.
         assert '404 Not Found' in response_body
 
     def test_push_on_shadow_repo_raises(self, baseapp, request_stub):
         """
         Check that a push action to a shadow repo is aborted.
         """
         controller = StubVCSController(
             baseapp.config.get_settings(), request_stub.registry)
         controller._check_ssl = mock.Mock()
         controller.is_shadow_repo = True
         controller._action = 'push'
         controller.stub_response_body = 'dummy body value'
         environ_stub = {
             'HTTP_HOST': 'test.example.com',
             'HTTP_ACCEPT': 'application/mercurial',
             'REQUEST_METHOD': 'GET',
             'wsgi.url_scheme': 'http',
         }
 
         response = controller(environ_stub, mock.Mock())
         response_body = ''.join(response)
 
         assert response_body != controller.stub_response_body
         # Assert that a 406 error is returned.
         assert '406 Not Acceptable' in response_body
 
     def test_set_repo_names_no_shadow(self, baseapp, request_stub):
         """
         Check that the set_repo_names method sets all names to the one returned
         by the _get_repository_name method on a request to a non shadow repo.
         """
         environ_stub = {}
         controller = StubVCSController(
             baseapp.config.get_settings(), request_stub.registry)
         controller._name = 'RepoGroup/MyRepo'
         controller.set_repo_names(environ_stub)
         assert not controller.is_shadow_repo
         assert (controller.url_repo_name ==
                 controller.acl_repo_name ==
                 controller.vcs_repo_name ==
                 controller._get_repository_name(environ_stub))
 
     def test_set_repo_names_with_shadow(
             self, baseapp, pr_util, config_stub, request_stub):
         """
         Check that the set_repo_names method sets correct names on a request
         to a shadow repo.
         """
         from rhodecode.model.pull_request import PullRequestModel
 
         pull_request = pr_util.create_pull_request()
         shadow_url = '{target}/{pr_segment}/{pr_id}/{shadow_segment}'.format(
             target=pull_request.target_repo.repo_name,
             pr_id=pull_request.pull_request_id,
             pr_segment=TestShadowRepoRegularExpression.pr_segment,
             shadow_segment=TestShadowRepoRegularExpression.shadow_segment)
         controller = StubVCSController(
             baseapp.config.get_settings(), request_stub.registry)
         controller._name = shadow_url
         controller.set_repo_names({})
 
         # Get file system path to shadow repo for assertions.
         workspace_id = PullRequestModel()._workspace_id(pull_request)
         target_vcs = pull_request.target_repo.scm_instance()
         vcs_repo_name = target_vcs._get_shadow_repository_path(
             workspace_id)
 
         assert controller.vcs_repo_name == vcs_repo_name
         assert controller.url_repo_name == shadow_url
         assert controller.acl_repo_name == pull_request.target_repo.repo_name
         assert controller.is_shadow_repo
 
     def test_set_repo_names_with_shadow_but_missing_pr(
             self, baseapp, pr_util, config_stub, request_stub):
         """
         Checks that the set_repo_names method enforces matching target repos
         and pull request IDs.
         """
         pull_request = pr_util.create_pull_request()
         shadow_url = '{target}/{pr_segment}/{pr_id}/{shadow_segment}'.format(
             target=pull_request.target_repo.repo_name,
             pr_id=999999999,
             pr_segment=TestShadowRepoRegularExpression.pr_segment,
             shadow_segment=TestShadowRepoRegularExpression.shadow_segment)
         controller = StubVCSController(
             baseapp.config.get_settings(), request_stub.registry)
         controller._name = shadow_url
         controller.set_repo_names({})
 
         assert not controller.is_shadow_repo
         assert (controller.url_repo_name ==
                 controller.acl_repo_name ==
                 controller.vcs_repo_name)
 
 
 @pytest.mark.usefixtures('baseapp')
 class TestGenerateVcsResponse(object):
 
     def test_ensures_that_start_response_is_called_early_enough(self):
         self.call_controller_with_response_body(iter(['a', 'b']))
         assert self.start_response.called
 
     def test_invalidates_cache_after_body_is_consumed(self):
         result = self.call_controller_with_response_body(iter(['a', 'b']))
         assert not self.was_cache_invalidated()
         # Consume the result
         list(result)
         assert self.was_cache_invalidated()
 
-    @mock.patch('rhodecode.lib.middleware.simplevcs.HTTPLockedRC')
-    def test_handles_locking_exception(self, http_locked_rc):
-        result = self.call_controller_with_response_body(
-            self.raise_result_iter(vcs_kind='repo_locked'))
-        assert not http_locked_rc.called
-        # Consume the result
-        list(result)
-        assert http_locked_rc.called
-
-    @mock.patch('rhodecode.lib.middleware.simplevcs.HTTPRequirementError')
-    def test_handles_requirement_exception(self, http_requirement):
-        result = self.call_controller_with_response_body(
-            self.raise_result_iter(vcs_kind='requirement'))
-        assert not http_requirement.called
-        # Consume the result
-        list(result)
-        assert http_requirement.called
-
-    @mock.patch('rhodecode.lib.middleware.simplevcs.HTTPLockedRC')
-    def test_handles_locking_exception_in_app_call(self, http_locked_rc):
-        app_factory_patcher = mock.patch.object(
-            StubVCSController, '_create_wsgi_app')
-        with app_factory_patcher as app_factory:
-            app_factory().side_effect = self.vcs_exception()
-            result = self.call_controller_with_response_body(['a'])
-            list(result)
-        assert http_locked_rc.called
-
     def test_raises_unknown_exceptions(self):
         result = self.call_controller_with_response_body(
             self.raise_result_iter(vcs_kind='unknown'))
         with pytest.raises(Exception):
             list(result)
 
     def test_prepare_callback_daemon_is_called(self):
-        def side_effect(extras):
+        def side_effect(extras, environ, action, txn_id=None):
             return DummyHooksCallbackDaemon(), extras
 
         prepare_patcher = mock.patch.object(
             StubVCSController, '_prepare_callback_daemon')
         with prepare_patcher as prepare_mock:
             prepare_mock.side_effect = side_effect
             self.call_controller_with_response_body(iter(['a', 'b']))
         assert prepare_mock.called
         assert prepare_mock.call_count == 1
 
     def call_controller_with_response_body(self, response_body):
         settings = {
             'base_path': 'fake_base_path',
             'vcs.hooks.protocol': 'http',
             'vcs.hooks.direct_calls': False,
         }
         registry = AttributeDict()
         controller = StubVCSController(settings, registry)
         controller._invalidate_cache = mock.Mock()
         controller.stub_response_body = response_body
         self.start_response = mock.Mock()
         result = controller._generate_vcs_response(
             environ={}, start_response=self.start_response,
             repo_path='fake_repo_path',
             extras={}, action='push')
         self.controller = controller
         return result
 
     def raise_result_iter(self, vcs_kind='repo_locked'):
         """
         Simulates an exception due to a vcs raised exception if kind vcs_kind
         """
         raise self.vcs_exception(vcs_kind=vcs_kind)
         yield "never_reached"
 
     def vcs_exception(self, vcs_kind='repo_locked'):
         locked_exception = Exception('TEST_MESSAGE')
         locked_exception._vcs_kind = vcs_kind
         return locked_exception
 
     def was_cache_invalidated(self):
         return self.controller._invalidate_cache.called
 
 
 class TestInitializeGenerator(object):
 
     def test_drains_first_element(self):
         gen = self.factory(['__init__', 1, 2])
         result = list(gen)
         assert result == [1, 2]
 
     @pytest.mark.parametrize('values', [
         [],
         [1, 2],
     ])
     def test_raises_value_error(self, values):
         with pytest.raises(ValueError):
             self.factory(values)
 
     @simplevcs.initialize_generator
     def factory(self, iterable):
         for elem in iterable:
             yield elem
 
 
 class TestPrepareHooksDaemon(object):
     def test_calls_imported_prepare_callback_daemon(self, app_settings, request_stub):
         expected_extras = {'extra1': 'value1'}
         daemon = DummyHooksCallbackDaemon()
 
         controller = StubVCSController(app_settings, request_stub.registry)
         prepare_patcher = mock.patch.object(
             simplevcs, 'prepare_callback_daemon',
             return_value=(daemon, expected_extras))
         with prepare_patcher as prepare_mock:
             callback_daemon, extras = controller._prepare_callback_daemon(
-                expected_extras.copy())
+                expected_extras.copy(), {}, 'push')
         prepare_mock.assert_called_once_with(
             expected_extras,
             protocol=app_settings['vcs.hooks.protocol'],
+            txn_id=None,
             use_direct_calls=app_settings['vcs.hooks.direct_calls'])
 
         assert callback_daemon == daemon
         assert extras == extras

rhodecode/tests/lib/test_hooks_daemon.py

@@ -1,321 +1,329 b''
 # -*- coding: utf-8 -*-
 
 # Copyright (C) 2010-2018 RhodeCode GmbH
 #
 # This program is free software: you can redistribute it and/or modify
 # it under the terms of the GNU Affero General Public License, version 3
 # (only), as published by the Free Software Foundation.
 #
 # 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 Affero General Public License
 # along with this program.  If not, see <http://www.gnu.org/licenses/>.
 #
 # This program is dual-licensed. If you wish to learn more about the
 # RhodeCode Enterprise Edition, including its added features, Support services,
 # and proprietary license terms, please see https://rhodecode.com/licenses/
 
 import json
 import logging
 from StringIO import StringIO
 
 import mock
 import pytest
 
 from rhodecode.lib import hooks_daemon
 from rhodecode.tests.utils import assert_message_in_log
 
 
 class TestDummyHooksCallbackDaemon(object):
     def test_hooks_module_path_set_properly(self):
         daemon = hooks_daemon.DummyHooksCallbackDaemon()
         assert daemon.hooks_module == 'rhodecode.lib.hooks_daemon'
 
     def test_logs_entering_the_hook(self):
         daemon = hooks_daemon.DummyHooksCallbackDaemon()
         with mock.patch.object(hooks_daemon.log, 'debug') as log_mock:
             with daemon as return_value:
                 log_mock.assert_called_once_with(
                     'Running dummy hooks callback daemon')
         assert return_value == daemon
 
     def test_logs_exiting_the_hook(self):
         daemon = hooks_daemon.DummyHooksCallbackDaemon()
         with mock.patch.object(hooks_daemon.log, 'debug') as log_mock:
             with daemon:
                 pass
         log_mock.assert_called_with('Exiting dummy hooks callback daemon')
 
 
 class TestHooks(object):
     def test_hooks_can_be_used_as_a_context_processor(self):
         hooks = hooks_daemon.Hooks()
         with hooks as return_value:
             pass
         assert hooks == return_value
 
 
 class TestHooksHttpHandler(object):
     def test_read_request_parses_method_name_and_arguments(self):
         data = {
             'method': 'test',
             'extras': {
                 'param1': 1,
                 'param2': 'a'
             }
         }
         request = self._generate_post_request(data)
         hooks_patcher = mock.patch.object(
             hooks_daemon.Hooks, data['method'], create=True, return_value=1)
 
         with hooks_patcher as hooks_mock:
             MockServer(hooks_daemon.HooksHttpHandler, request)
 
         hooks_mock.assert_called_once_with(data['extras'])
 
     def test_hooks_serialized_result_is_returned(self):
         request = self._generate_post_request({})
         rpc_method = 'test'
         hook_result = {
             'first': 'one',
             'second': 2
         }
         read_patcher = mock.patch.object(
             hooks_daemon.HooksHttpHandler, '_read_request',
             return_value=(rpc_method, {}))
         hooks_patcher = mock.patch.object(
             hooks_daemon.Hooks, rpc_method, create=True,
             return_value=hook_result)
 
         with read_patcher, hooks_patcher:
             server = MockServer(hooks_daemon.HooksHttpHandler, request)
 
         expected_result = json.dumps(hook_result)
         assert server.request.output_stream.buflist[-1] == expected_result
 
     def test_exception_is_returned_in_response(self):
         request = self._generate_post_request({})
         rpc_method = 'test'
         read_patcher = mock.patch.object(
             hooks_daemon.HooksHttpHandler, '_read_request',
             return_value=(rpc_method, {}))
         hooks_patcher = mock.patch.object(
             hooks_daemon.Hooks, rpc_method, create=True,
             side_effect=Exception('Test exception'))
 
         with read_patcher, hooks_patcher:
             server = MockServer(hooks_daemon.HooksHttpHandler, request)
 
         org_exc = json.loads(server.request.output_stream.buflist[-1])
         expected_result = {
             'exception': 'Exception',
             'exception_traceback': org_exc['exception_traceback'],
             'exception_args': ['Test exception']
         }
         assert org_exc == expected_result
 
     def test_log_message_writes_to_debug_log(self, caplog):
         ip_port = ('0.0.0.0', 8888)
         handler = hooks_daemon.HooksHttpHandler(
             MockRequest('POST /'), ip_port, mock.Mock())
         fake_date = '1/Nov/2015 00:00:00'
         date_patcher = mock.patch.object(
             handler, 'log_date_time_string', return_value=fake_date)
         with date_patcher, caplog.at_level(logging.DEBUG):
             handler.log_message('Some message %d, %s', 123, 'string')
 
         expected_message = '{} - - [{}] Some message 123, string'.format(
             ip_port[0], fake_date)
         assert_message_in_log(
             caplog.records, expected_message,
             levelno=logging.DEBUG, module='hooks_daemon')
 
     def _generate_post_request(self, data):
         payload = json.dumps(data)
         return 'POST / HTTP/1.0\nContent-Length: {}\n\n{}'.format(
             len(payload), payload)
 
 
 class ThreadedHookCallbackDaemon(object):
     def test_constructor_calls_prepare(self):
         prepare_daemon_patcher = mock.patch.object(
             hooks_daemon.ThreadedHookCallbackDaemon, '_prepare')
         with prepare_daemon_patcher as prepare_daemon_mock:
             hooks_daemon.ThreadedHookCallbackDaemon()
         prepare_daemon_mock.assert_called_once_with()
 
     def test_run_is_called_on_context_start(self):
         patchers = mock.patch.multiple(
             hooks_daemon.ThreadedHookCallbackDaemon,
             _run=mock.DEFAULT, _prepare=mock.DEFAULT, __exit__=mock.DEFAULT)
 
         with patchers as mocks:
             daemon = hooks_daemon.ThreadedHookCallbackDaemon()
             with daemon as daemon_context:
                 pass
             mocks['_run'].assert_called_once_with()
         assert daemon_context == daemon
 
     def test_stop_is_called_on_context_exit(self):
         patchers = mock.patch.multiple(
             hooks_daemon.ThreadedHookCallbackDaemon,
             _run=mock.DEFAULT, _prepare=mock.DEFAULT, _stop=mock.DEFAULT)
 
         with patchers as mocks:
             daemon = hooks_daemon.ThreadedHookCallbackDaemon()
             with daemon as daemon_context:
                 assert mocks['_stop'].call_count == 0
 
             mocks['_stop'].assert_called_once_with()
         assert daemon_context == daemon
 
 
 class TestHttpHooksCallbackDaemon(object):
     def test_prepare_inits_daemon_variable(self, tcp_server, caplog):
         with self._tcp_patcher(tcp_server), caplog.at_level(logging.DEBUG):
             daemon = hooks_daemon.HttpHooksCallbackDaemon()
         assert daemon._daemon == tcp_server
 
+        _, port = tcp_server.server_address
+        expected_uri = '{}:{}'.format(daemon.IP_ADDRESS, port)
+        msg = 'Preparing HTTP callback daemon at `{}` and ' \
+              'registering hook object'.format(expected_uri)
         assert_message_in_log(
-            caplog.records,
-            'Preparing HTTP callback daemon and registering hook object',
-            levelno=logging.DEBUG, module='hooks_daemon')
+            caplog.records, msg, levelno=logging.DEBUG, module='hooks_daemon')
 
     def test_prepare_inits_hooks_uri_and_logs_it(
             self, tcp_server, caplog):
         with self._tcp_patcher(tcp_server), caplog.at_level(logging.DEBUG):
             daemon = hooks_daemon.HttpHooksCallbackDaemon()
 
         _, port = tcp_server.server_address
         expected_uri = '{}:{}'.format(daemon.IP_ADDRESS, port)
         assert daemon.hooks_uri == expected_uri
 
+        msg = 'Preparing HTTP callback daemon at `{}` and ' \
+              'registering hook object'.format(expected_uri)
         assert_message_in_log(
-            caplog.records, 'Hooks uri is: {}'.format(expected_uri),
+            caplog.records, msg,
             levelno=logging.DEBUG, module='hooks_daemon')
 
     def test_run_creates_a_thread(self, tcp_server):
         thread = mock.Mock()
 
         with self._tcp_patcher(tcp_server):
             daemon = hooks_daemon.HttpHooksCallbackDaemon()
 
         with self._thread_patcher(thread) as thread_mock:
             daemon._run()
 
         thread_mock.assert_called_once_with(
             target=tcp_server.serve_forever,
             kwargs={'poll_interval': daemon.POLL_INTERVAL})
         assert thread.daemon is True
         thread.start.assert_called_once_with()
 
     def test_run_logs(self, tcp_server, caplog):
 
         with self._tcp_patcher(tcp_server):
             daemon = hooks_daemon.HttpHooksCallbackDaemon()
 
         with self._thread_patcher(mock.Mock()), caplog.at_level(logging.DEBUG):
             daemon._run()
 
         assert_message_in_log(
             caplog.records,
             'Running event loop of callback daemon in background thread',
             levelno=logging.DEBUG, module='hooks_daemon')
 
     def test_stop_cleans_up_the_connection(self, tcp_server, caplog):
         thread = mock.Mock()
 
         with self._tcp_patcher(tcp_server):
             daemon = hooks_daemon.HttpHooksCallbackDaemon()
 
         with self._thread_patcher(thread), caplog.at_level(logging.DEBUG):
             with daemon:
                 assert daemon._daemon == tcp_server
                 assert daemon._callback_thread == thread
 
         assert daemon._daemon is None
         assert daemon._callback_thread is None
         tcp_server.shutdown.assert_called_with()
         thread.join.assert_called_once_with()
 
         assert_message_in_log(
             caplog.records, 'Waiting for background thread to finish.',
             levelno=logging.DEBUG, module='hooks_daemon')
 
     def _tcp_patcher(self, tcp_server):
         return mock.patch.object(
             hooks_daemon, 'TCPServer', return_value=tcp_server)
 
     def _thread_patcher(self, thread):
         return mock.patch.object(
             hooks_daemon.threading, 'Thread', return_value=thread)
 
 
 class TestPrepareHooksDaemon(object):
     @pytest.mark.parametrize('protocol', ('http',))
     def test_returns_dummy_hooks_callback_daemon_when_using_direct_calls(
             self, protocol):
         expected_extras = {'extra1': 'value1'}
         callback, extras = hooks_daemon.prepare_callback_daemon(
             expected_extras.copy(), protocol=protocol, use_direct_calls=True)
         assert isinstance(callback, hooks_daemon.DummyHooksCallbackDaemon)
         expected_extras['hooks_module'] = 'rhodecode.lib.hooks_daemon'
-        assert extras == expected_extras
+        expected_extras['time'] = extras['time']
+        assert 'extra1' in extras
 
     @pytest.mark.parametrize('protocol, expected_class', (
         ('http', hooks_daemon.HttpHooksCallbackDaemon),
     ))
     def test_returns_real_hooks_callback_daemon_when_protocol_is_specified(
             self, protocol, expected_class):
         expected_extras = {
             'extra1': 'value1',
+            'txn_id': 'txnid2',
             'hooks_protocol': protocol.lower()
         }
         callback, extras = hooks_daemon.prepare_callback_daemon(
-            expected_extras.copy(), protocol=protocol, use_direct_calls=False)
+            expected_extras.copy(), protocol=protocol, use_direct_calls=False,
+            txn_id='txnid2')
         assert isinstance(callback, expected_class)
-        hooks_uri = extras.pop('hooks_uri')
+        extras.pop('hooks_uri')
+        expected_extras['time'] = extras['time']
         assert extras == expected_extras
 
     @pytest.mark.parametrize('protocol', (
         'invalid',
         'Http',
         'HTTP',
     ))
     def test_raises_on_invalid_protocol(self, protocol):
         expected_extras = {
             'extra1': 'value1',
             'hooks_protocol': protocol.lower()
         }
         with pytest.raises(Exception):
             callback, extras = hooks_daemon.prepare_callback_daemon(
                 expected_extras.copy(),
                 protocol=protocol,
                 use_direct_calls=False)
 
 
 class MockRequest(object):
     def __init__(self, request):
         self.request = request
         self.input_stream = StringIO(b'{}'.format(self.request))
         self.output_stream = StringIO()
 
     def makefile(self, mode, *args, **kwargs):
         return self.output_stream if mode == 'wb' else self.input_stream
 
 
 class MockServer(object):
     def __init__(self, Handler, request):
         ip_port = ('0.0.0.0', 8888)
         self.request = MockRequest(request)
         self.handler = Handler(self.request, ip_port, self)
 
 
 @pytest.fixture
 def tcp_server():
     server = mock.Mock()
     server.server_address = ('127.0.0.1', 8881)
     return server

rhodecode/tests/lib/test_utils.py

@@ -1,456 +1,446 b''
 # -*- coding: utf-8 -*-
 
 # Copyright (C) 2010-2018 RhodeCode GmbH
 #
 # This program is free software: you can redistribute it and/or modify
 # it under the terms of the GNU Affero General Public License, version 3
 # (only), as published by the Free Software Foundation.
 #
 # 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 Affero General Public License
 # along with this program.  If not, see <http://www.gnu.org/licenses/>.
 #
 # This program is dual-licensed. If you wish to learn more about the
 # RhodeCode Enterprise Edition, including its added features, Support services,
 # and proprietary license terms, please see https://rhodecode.com/licenses/
 
 import json
 import multiprocessing
 import os
 
 import mock
 import py
 import pytest
 
 from rhodecode.lib import caching_query
 from rhodecode.lib import utils
 from rhodecode.lib.utils2 import md5
 from rhodecode.model import settings
 from rhodecode.model import db
 from rhodecode.model import meta
 from rhodecode.model.repo import RepoModel
 from rhodecode.model.repo_group import RepoGroupModel
 from rhodecode.model.scm import ScmModel
 from rhodecode.model.settings import UiSetting, SettingsModel
 from rhodecode.tests.fixture import Fixture
 
 
 fixture = Fixture()
 
 
 def extract_hooks(config):
     """Return a dictionary with the hook entries of the given config."""
     hooks = {}
     config_items = config.serialize()
     for section, name, value in config_items:
         if section != 'hooks':
             continue
         hooks[name] = value
 
     return hooks
 
 
 def disable_hooks(request, hooks):
     """Disables the given hooks from the UI settings."""
     session = meta.Session()
 
     model = SettingsModel()
     for hook_key in hooks:
         sett = model.get_ui_by_key(hook_key)
         sett.ui_active = False
         session.add(sett)
 
     # Invalidate cache
     ui_settings = session.query(db.RhodeCodeUi).options(
         caching_query.FromCache('sql_cache_short', 'get_hg_ui_settings'))
     ui_settings.invalidate()
 
     ui_settings = session.query(db.RhodeCodeUi).options(
         caching_query.FromCache(
             'sql_cache_short', 'get_hook_settings', 'get_hook_settings'))
     ui_settings.invalidate()
 
     @request.addfinalizer
     def rollback():
         session.rollback()
 
 
 HOOK_PRE_PUSH = db.RhodeCodeUi.HOOK_PRE_PUSH
 HOOK_PRETX_PUSH = db.RhodeCodeUi.HOOK_PRETX_PUSH
 HOOK_PUSH = db.RhodeCodeUi.HOOK_PUSH
 HOOK_PRE_PULL = db.RhodeCodeUi.HOOK_PRE_PULL
 HOOK_PULL = db.RhodeCodeUi.HOOK_PULL
 HOOK_REPO_SIZE = db.RhodeCodeUi.HOOK_REPO_SIZE
 HOOK_PUSH_KEY = db.RhodeCodeUi.HOOK_PUSH_KEY
 
 HG_HOOKS = frozenset(
     (HOOK_PRE_PULL, HOOK_PULL, HOOK_PRE_PUSH, HOOK_PRETX_PUSH, HOOK_PUSH,
      HOOK_REPO_SIZE, HOOK_PUSH_KEY))
 
 
 @pytest.mark.parametrize('disabled_hooks,expected_hooks', [
     ([], HG_HOOKS),
     (HG_HOOKS, []),
 
     ([HOOK_PRE_PUSH, HOOK_PRETX_PUSH, HOOK_REPO_SIZE, HOOK_PUSH_KEY], [HOOK_PRE_PULL, HOOK_PULL, HOOK_PUSH]),
 
     # When a pull/push hook is disabled, its pre-pull/push counterpart should
     # be disabled too.
     ([HOOK_PUSH], [HOOK_PRE_PULL, HOOK_PULL, HOOK_REPO_SIZE]),
     ([HOOK_PULL], [HOOK_PRE_PUSH, HOOK_PRETX_PUSH, HOOK_PUSH, HOOK_REPO_SIZE,
                    HOOK_PUSH_KEY]),
 ])
 def test_make_db_config_hg_hooks(baseapp, request, disabled_hooks,
                                  expected_hooks):
     disable_hooks(request, disabled_hooks)
 
     config = utils.make_db_config()
     hooks = extract_hooks(config)
 
     assert set(hooks.iterkeys()).intersection(HG_HOOKS) == set(expected_hooks)
 
 
 @pytest.mark.parametrize('disabled_hooks,expected_hooks', [
     ([], ['pull', 'push']),
     ([HOOK_PUSH], ['pull']),
     ([HOOK_PULL], ['push']),
     ([HOOK_PULL, HOOK_PUSH], []),
 ])
 def test_get_enabled_hook_classes(disabled_hooks, expected_hooks):
     hook_keys = (HOOK_PUSH, HOOK_PULL)
     ui_settings = [
         ('hooks', key, 'some value', key not in disabled_hooks)
         for key in hook_keys]
 
     result = utils.get_enabled_hook_classes(ui_settings)
     assert sorted(result) == expected_hooks
 
 
 def test_get_filesystem_repos_finds_repos(tmpdir, baseapp):
     _stub_git_repo(tmpdir.ensure('repo', dir=True))
     repos = list(utils.get_filesystem_repos(str(tmpdir)))
     assert repos == [('repo', ('git', tmpdir.join('repo')))]
 
 
 def test_get_filesystem_repos_skips_directories(tmpdir, baseapp):
     tmpdir.ensure('not-a-repo', dir=True)
     repos = list(utils.get_filesystem_repos(str(tmpdir)))
     assert repos == []
 
 
 def test_get_filesystem_repos_skips_directories_with_repos(tmpdir, baseapp):
     _stub_git_repo(tmpdir.ensure('subdir/repo', dir=True))
     repos = list(utils.get_filesystem_repos(str(tmpdir)))
     assert repos == []
 
 
 def test_get_filesystem_repos_finds_repos_in_subdirectories(tmpdir, baseapp):
     _stub_git_repo(tmpdir.ensure('subdir/repo', dir=True))
     repos = list(utils.get_filesystem_repos(str(tmpdir), recursive=True))
     assert repos == [('subdir/repo', ('git', tmpdir.join('subdir', 'repo')))]
 
 
 def test_get_filesystem_repos_skips_names_starting_with_dot(tmpdir):
     _stub_git_repo(tmpdir.ensure('.repo', dir=True))
     repos = list(utils.get_filesystem_repos(str(tmpdir)))
     assert repos == []
 
 
 def test_get_filesystem_repos_skips_files(tmpdir):
     tmpdir.ensure('test-file')
     repos = list(utils.get_filesystem_repos(str(tmpdir)))
     assert repos == []
 
 
 def test_get_filesystem_repos_skips_removed_repositories(tmpdir):
     removed_repo_name = 'rm__00000000_000000_000000__.stub'
     assert utils.REMOVED_REPO_PAT.match(removed_repo_name)
     _stub_git_repo(tmpdir.ensure(removed_repo_name, dir=True))
     repos = list(utils.get_filesystem_repos(str(tmpdir)))
     assert repos == []
 
 
 def _stub_git_repo(repo_path):
     """
     Make `repo_path` look like a Git repository.
     """
     repo_path.ensure('.git', dir=True)
 
 
 @pytest.mark.parametrize('str_class', [str, unicode], ids=['str', 'unicode'])
 def test_get_dirpaths_returns_all_paths(tmpdir, str_class):
     tmpdir.ensure('test-file')
     dirpaths = utils._get_dirpaths(str_class(tmpdir))
     assert dirpaths == ['test-file']
 
 
 def test_get_dirpaths_returns_all_paths_bytes(
         tmpdir, platform_encodes_filenames):
     if platform_encodes_filenames:
         pytest.skip("This platform seems to encode filenames.")
     tmpdir.ensure('repo-a-umlaut-\xe4')
     dirpaths = utils._get_dirpaths(str(tmpdir))
     assert dirpaths == ['repo-a-umlaut-\xe4']
 
 
 def test_get_dirpaths_skips_paths_it_cannot_decode(
         tmpdir, platform_encodes_filenames):
     if platform_encodes_filenames:
         pytest.skip("This platform seems to encode filenames.")
     path_with_latin1 = 'repo-a-umlaut-\xe4'
     tmpdir.ensure(path_with_latin1)
     dirpaths = utils._get_dirpaths(unicode(tmpdir))
     assert dirpaths == []
 
 
 @pytest.fixture(scope='session')
 def platform_encodes_filenames():
     """
     Boolean indicator if the current platform changes filename encodings.
     """
     path_with_latin1 = 'repo-a-umlaut-\xe4'
     tmpdir = py.path.local.mkdtemp()
     tmpdir.ensure(path_with_latin1)
     read_path = tmpdir.listdir()[0].basename
     tmpdir.remove()
     return path_with_latin1 != read_path
 
 
 
 
 def test_repo2db_mapper_groups(repo_groups):
     session = meta.Session()
     zombie_group, parent_group, child_group = repo_groups
     zombie_path = os.path.join(
         RepoGroupModel().repos_path, zombie_group.full_path)
     os.rmdir(zombie_path)
 
     # Avoid removing test repos when calling repo2db_mapper
     repo_list = {
         repo.repo_name: 'test' for repo in session.query(db.Repository).all()
     }
     utils.repo2db_mapper(repo_list, remove_obsolete=True)
 
     groups_in_db = session.query(db.RepoGroup).all()
     assert child_group in groups_in_db
     assert parent_group in groups_in_db
     assert zombie_path not in groups_in_db
 
 
 def test_repo2db_mapper_enables_largefiles(backend):
     repo = backend.create_repo()
     repo_list = {repo.repo_name: 'test'}
     with mock.patch('rhodecode.model.db.Repository.scm_instance') as scm_mock:
-        with mock.patch.multiple('rhodecode.model.scm.ScmModel',
-                                 install_git_hook=mock.DEFAULT,
-                                 install_svn_hooks=mock.DEFAULT):
             utils.repo2db_mapper(repo_list, remove_obsolete=False)
             _, kwargs = scm_mock.call_args
             assert kwargs['config'].get('extensions', 'largefiles') == ''
 
 
 @pytest.mark.backends("git", "svn")
 def test_repo2db_mapper_installs_hooks_for_repos_in_db(backend):
     repo = backend.create_repo()
     repo_list = {repo.repo_name: 'test'}
-    with mock.patch.object(ScmModel, 'install_hooks') as install_hooks_mock:
         utils.repo2db_mapper(repo_list, remove_obsolete=False)
-    install_hooks_mock.assert_called_once_with(
-        repo.scm_instance(), repo_type=backend.alias)
 
 
 @pytest.mark.backends("git", "svn")
 def test_repo2db_mapper_installs_hooks_for_newly_added_repos(backend):
     repo = backend.create_repo()
     RepoModel().delete(repo, fs_remove=False)
     meta.Session().commit()
     repo_list = {repo.repo_name: repo.scm_instance()}
-    with mock.patch.object(ScmModel, 'install_hooks') as install_hooks_mock:
         utils.repo2db_mapper(repo_list, remove_obsolete=False)
-    assert install_hooks_mock.call_count == 1
-    install_hooks_args, _ = install_hooks_mock.call_args
-    assert install_hooks_args[0].name == repo.repo_name
 
 
 class TestPasswordChanged(object):
     def setup(self):
         self.session = {
             'rhodecode_user': {
                 'password': '0cc175b9c0f1b6a831c399e269772661'
             }
         }
         self.auth_user = mock.Mock()
         self.auth_user.userame = 'test'
         self.auth_user.password = 'abc123'
 
     def test_returns_false_for_default_user(self):
         self.auth_user.username = db.User.DEFAULT_USER
         result = utils.password_changed(self.auth_user, self.session)
         assert result is False
 
     def test_returns_false_if_password_was_not_changed(self):
         self.session['rhodecode_user']['password'] = md5(
             self.auth_user.password)
         result = utils.password_changed(self.auth_user, self.session)
         assert result is False
 
     def test_returns_true_if_password_was_changed(self):
         result = utils.password_changed(self.auth_user, self.session)
         assert result is True
 
     def test_returns_true_if_auth_user_password_is_empty(self):
         self.auth_user.password = None
         result = utils.password_changed(self.auth_user, self.session)
         assert result is True
 
     def test_returns_true_if_session_password_is_empty(self):
         self.session['rhodecode_user'].pop('password')
         result = utils.password_changed(self.auth_user, self.session)
         assert result is True
 
 
 class TestReadOpensourceLicenses(object):
     def test_success(self):
         utils._license_cache = None
         json_data = '''
         {
             "python2.7-pytest-2.7.1": {"UNKNOWN": null},
             "python2.7-Markdown-2.6.2": {
                 "BSD-3-Clause": "http://spdx.org/licenses/BSD-3-Clause"
             }
         }
         '''
         resource_string_patch = mock.patch.object(
             utils.pkg_resources, 'resource_string', return_value=json_data)
         with resource_string_patch:
             result = utils.read_opensource_licenses()
         assert result == json.loads(json_data)
 
     def test_caching(self):
         utils._license_cache = {
             "python2.7-pytest-2.7.1": {
                 "UNKNOWN": None
             },
             "python2.7-Markdown-2.6.2": {
                 "BSD-3-Clause": "http://spdx.org/licenses/BSD-3-Clause"
             }
         }
         resource_patch = mock.patch.object(
             utils.pkg_resources, 'resource_string', side_effect=Exception)
         json_patch = mock.patch.object(
             utils.json, 'loads', side_effect=Exception)
 
         with resource_patch as resource_mock, json_patch as json_mock:
             result = utils.read_opensource_licenses()
 
         assert resource_mock.call_count == 0
         assert json_mock.call_count == 0
         assert result == utils._license_cache
 
     def test_licenses_file_contains_no_unknown_licenses(self):
         utils._license_cache = None
         result = utils.read_opensource_licenses()
         license_names = []
         for licenses in result.values():
             license_names.extend(licenses.keys())
         assert 'UNKNOWN' not in license_names
 
 
 class TestMakeDbConfig(object):
     def test_data_from_config_data_from_db_returned(self):
         test_data = [
             ('section1', 'option1', 'value1'),
             ('section2', 'option2', 'value2'),
             ('section3', 'option3', 'value3'),
         ]
         with mock.patch.object(utils, 'config_data_from_db') as config_mock:
             config_mock.return_value = test_data
             kwargs = {'clear_session': False, 'repo': 'test_repo'}
             result = utils.make_db_config(**kwargs)
         config_mock.assert_called_once_with(**kwargs)
         for section, option, expected_value in test_data:
             value = result.get(section, option)
             assert value == expected_value
 
 
 class TestConfigDataFromDb(object):
     def test_config_data_from_db_returns_active_settings(self):
         test_data = [
             UiSetting('section1', 'option1', 'value1', True),
             UiSetting('section2', 'option2', 'value2', True),
             UiSetting('section3', 'option3', 'value3', False),
         ]
         repo_name = 'test_repo'
 
         model_patch = mock.patch.object(settings, 'VcsSettingsModel')
         hooks_patch = mock.patch.object(
             utils, 'get_enabled_hook_classes',
             return_value=['pull', 'push', 'repo_size'])
         with model_patch as model_mock, hooks_patch:
             instance_mock = mock.Mock()
             model_mock.return_value = instance_mock
             instance_mock.get_ui_settings.return_value = test_data
             result = utils.config_data_from_db(
                 clear_session=False, repo=repo_name)
 
         self._assert_repo_name_passed(model_mock, repo_name)
 
         expected_result = [
             ('section1', 'option1', 'value1'),
             ('section2', 'option2', 'value2'),
         ]
         assert result == expected_result
 
     def _assert_repo_name_passed(self, model_mock, repo_name):
         assert model_mock.call_count == 1
         call_args, call_kwargs = model_mock.call_args
         assert call_kwargs['repo'] == repo_name
 
 
 class TestIsDirWritable(object):
     def test_returns_false_when_not_writable(self):
         with mock.patch('__builtin__.open', side_effect=OSError):
             assert not utils._is_dir_writable('/stub-path')
 
     def test_returns_true_when_writable(self, tmpdir):
         assert utils._is_dir_writable(str(tmpdir))
 
     def test_is_safe_against_race_conditions(self, tmpdir):
         workers = multiprocessing.Pool()
         directories = [str(tmpdir)] * 10
         workers.map(utils._is_dir_writable, directories)
 
 
 class TestGetEnabledHooks(object):
     def test_only_active_hooks_are_enabled(self):
         ui_settings = [
             UiSetting('hooks', db.RhodeCodeUi.HOOK_PUSH, 'value', True),
             UiSetting('hooks', db.RhodeCodeUi.HOOK_REPO_SIZE, 'value', True),
             UiSetting('hooks', db.RhodeCodeUi.HOOK_PULL, 'value', False)
         ]
         result = utils.get_enabled_hook_classes(ui_settings)
         assert result == ['push', 'repo_size']
 
     def test_all_hooks_are_enabled(self):
         ui_settings = [
             UiSetting('hooks', db.RhodeCodeUi.HOOK_PUSH, 'value', True),
             UiSetting('hooks', db.RhodeCodeUi.HOOK_REPO_SIZE, 'value', True),
             UiSetting('hooks', db.RhodeCodeUi.HOOK_PULL, 'value', True)
         ]
         result = utils.get_enabled_hook_classes(ui_settings)
         assert result == ['push', 'repo_size', 'pull']
 
     def test_no_enabled_hooks_when_no_hook_settings_are_found(self):
         ui_settings = []
         result = utils.get_enabled_hook_classes(ui_settings)
         assert result == []
 
 
 def test_obfuscate_url_pw():
     from rhodecode.lib.utils2 import obfuscate_url_pw
     engine = u'/home/repos/malmö'
     assert obfuscate_url_pw(engine)
  No newline at end of file

rhodecode/tests/models/test_repos.py

@@ -1,171 +1,172 b''
 # -*- coding: utf-8 -*-
 
 # Copyright (C) 2010-2018 RhodeCode GmbH
 #
 # This program is free software: you can redistribute it and/or modify
 # it under the terms of the GNU Affero General Public License, version 3
 # (only), as published by the Free Software Foundation.
 #
 # 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 Affero General Public License
 # along with this program.  If not, see <http://www.gnu.org/licenses/>.
 #
 # This program is dual-licensed. If you wish to learn more about the
 # RhodeCode Enterprise Edition, including its added features, Support services,
 # and proprietary license terms, please see https://rhodecode.com/licenses/
 
+import os
+import mock
+import pytest
 import tempfile
 
-import mock
-import pytest
 
 from rhodecode.lib.exceptions import AttachedForksError
 from rhodecode.lib.utils import make_db_config
 from rhodecode.model.db import Repository
 from rhodecode.model.meta import Session
 from rhodecode.model.repo import RepoModel
 from rhodecode.model.scm import ScmModel
 
 
 class TestRepoModel(object):
 
     def test_remove_repo(self, backend):
         repo = backend.create_repo()
         Session().commit()
         RepoModel().delete(repo=repo)
         Session().commit()
 
         repos = ScmModel().repo_scan()
 
         assert Repository.get_by_repo_name(repo_name=backend.repo_name) is None
         assert repo.repo_name not in repos
 
     def test_remove_repo_raises_exc_when_attached_forks(self, backend):
         repo = backend.create_repo()
         Session().commit()
         backend.create_fork()
         Session().commit()
 
         with pytest.raises(AttachedForksError):
             RepoModel().delete(repo=repo)
 
     def test_remove_repo_delete_forks(self, backend):
         repo = backend.create_repo()
         Session().commit()
 
         fork = backend.create_fork()
         Session().commit()
 
         fork_of_fork = backend.create_fork()
         Session().commit()
 
         RepoModel().delete(repo=repo, forks='delete')
         Session().commit()
 
         assert Repository.get_by_repo_name(repo_name=repo.repo_name) is None
         assert Repository.get_by_repo_name(repo_name=fork.repo_name) is None
         assert (
             Repository.get_by_repo_name(repo_name=fork_of_fork.repo_name)
             is None)
 
     def test_remove_repo_detach_forks(self, backend):
         repo = backend.create_repo()
         Session().commit()
 
         fork = backend.create_fork()
         Session().commit()
 
         fork_of_fork = backend.create_fork()
         Session().commit()
 
         RepoModel().delete(repo=repo, forks='detach')
         Session().commit()
 
         assert Repository.get_by_repo_name(repo_name=repo.repo_name) is None
         assert (
             Repository.get_by_repo_name(repo_name=fork.repo_name) is not None)
         assert (
             Repository.get_by_repo_name(repo_name=fork_of_fork.repo_name)
             is not None)
 
     @pytest.mark.parametrize("filename, expected", [
         ("README", True),
         ("README.rst", False),
     ])
     def test_filenode_is_link(self, vcsbackend, filename, expected):
         repo = vcsbackend.repo
         assert repo.get_commit().is_link(filename) is expected
 
     def test_get_commit(self, backend):
         backend.repo.get_commit()
 
     def test_get_changeset_is_deprecated(self, backend):
         repo = backend.repo
         pytest.deprecated_call(repo.get_changeset)
 
     def test_clone_url_encrypted_value(self, backend):
         repo = backend.create_repo()
         Session().commit()
 
         repo.clone_url = 'https://marcink:[e-mail]'
         Session().add(repo)
         Session().commit()
 
         assert repo.clone_url == 'https://marcink:[e-mail]'
 
     @pytest.mark.backends("git", "svn")
     def test_create_filesystem_repo_installs_hooks(self, tmpdir, backend):
-        hook_methods = {
-            'git': 'install_git_hook',
-            'svn': 'install_svn_hooks'
-        }
         repo = backend.create_repo()
         repo_name = repo.repo_name
         model = RepoModel()
         repo_location = tempfile.mkdtemp()
         model.repos_path = repo_location
-        method = hook_methods[backend.alias]
-        with mock.patch.object(ScmModel, method) as hooks_mock:
-            model._create_filesystem_repo(
+        repo = model._create_filesystem_repo(
                 repo_name, backend.alias, repo_group='', clone_uri=None)
-        assert hooks_mock.call_count == 1
-        hook_args, hook_kwargs = hooks_mock.call_args
-        assert hook_args[0].name == repo_name
+
+        hooks = {
+            'svn': ('pre-commit', 'post-commit'),
+            'git': ('pre-receive', 'post-receive'),
+        }
+        for hook in hooks[backend.alias]:
+            with open(os.path.join(repo.path, 'hooks', hook)) as f:
+                data = f.read()
+                assert 'RC_HOOK_VER' in data
 
     @pytest.mark.parametrize("use_global_config, repo_name_passed", [
         (True, False),
         (False, True)
     ])
     def test_per_repo_config_is_generated_during_filesystem_repo_creation(
             self, tmpdir, backend, use_global_config, repo_name_passed):
         repo_name = 'test-{}-repo-{}'.format(backend.alias, use_global_config)
         config = make_db_config()
         model = RepoModel()
         with mock.patch('rhodecode.model.repo.make_db_config') as config_mock:
             config_mock.return_value = config
             model._create_filesystem_repo(
                 repo_name, backend.alias, repo_group='', clone_uri=None,
                 use_global_config=use_global_config)
         expected_repo_name = repo_name if repo_name_passed else None
         expected_call = mock.call(clear_session=False, repo=expected_repo_name)
         assert expected_call in config_mock.call_args_list
 
     def test_update_commit_cache_with_config(serf, backend):
         repo = backend.create_repo()
         with mock.patch('rhodecode.model.db.Repository.scm_instance') as scm:
             scm_instance = mock.Mock()
             scm_instance.get_commit.return_value = {
                 'raw_id': 40*'0',
                 'revision': 1
             }
             scm.return_value = scm_instance
             repo.update_commit_cache()
             scm.assert_called_with(cache=False, config=None)
             config = {'test': 'config'}
             repo.update_commit_cache(config=config)
             scm.assert_called_with(
                 cache=False, config=config)

rhodecode/tests/models/test_scm.py

@@ -1,336 +1,196 b''
 # -*- coding: utf-8 -*-
 
 # Copyright (C) 2010-2018 RhodeCode GmbH
 #
 # This program is free software: you can redistribute it and/or modify
 # it under the terms of the GNU Affero General Public License, version 3
 # (only), as published by the Free Software Foundation.
 #
 # 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 Affero General Public License
 # along with this program.  If not, see <http://www.gnu.org/licenses/>.
 #
 # This program is dual-licensed. If you wish to learn more about the
 # RhodeCode Enterprise Edition, including its added features, Support services,
 # and proprietary license terms, please see https://rhodecode.com/licenses/
 
 import os
 import stat
 import sys
 
 import pytest
 from mock import Mock, patch, DEFAULT
 
 import rhodecode
 from rhodecode.model import db, scm
 from rhodecode.tests import no_newline_id_generator
 
 
 def test_scm_instance_config(backend):
     repo = backend.create_repo()
     with patch.multiple('rhodecode.model.db.Repository',
                         _get_instance=DEFAULT,
                         _get_instance_cached=DEFAULT) as mocks:
         repo.scm_instance()
         mocks['_get_instance'].assert_called_with(
             config=None, cache=False)
 
         config = {'some': 'value'}
         repo.scm_instance(config=config)
         mocks['_get_instance'].assert_called_with(
             config=config, cache=False)
 
         with patch.dict(rhodecode.CONFIG, {'vcs_full_cache': 'true'}):
             repo.scm_instance(config=config)
             mocks['_get_instance_cached'].assert_called()
 
 
 def test__get_instance_config(backend):
     repo = backend.create_repo()
     vcs_class = Mock()
     with patch.multiple('rhodecode.lib.vcs.backends',
                         get_scm=DEFAULT,
                         get_backend=DEFAULT) as mocks:
         mocks['get_scm'].return_value = backend.alias
         mocks['get_backend'].return_value = vcs_class
         with patch('rhodecode.model.db.Repository._config') as config_mock:
             repo._get_instance()
             vcs_class.assert_called_with(
                 repo_path=repo.repo_full_path, config=config_mock,
                 create=False, with_wire={'cache': True})
 
         new_config = {'override': 'old_config'}
         repo._get_instance(config=new_config)
         vcs_class.assert_called_with(
             repo_path=repo.repo_full_path, config=new_config, create=False,
             with_wire={'cache': True})
 
 
 def test_mark_for_invalidation_config(backend):
     repo = backend.create_repo()
     with patch('rhodecode.model.db.Repository.update_commit_cache') as _mock:
         scm.ScmModel().mark_for_invalidation(repo.repo_name)
         _, kwargs = _mock.call_args
         assert kwargs['config'].__dict__ == repo._config.__dict__
 
 
 def test_mark_for_invalidation_with_delete_updates_last_commit(backend):
     commits = [{'message': 'A'}, {'message': 'B'}]
     repo = backend.create_repo(commits=commits)
     scm.ScmModel().mark_for_invalidation(repo.repo_name, delete=True)
     assert repo.changeset_cache['revision'] == 1
 
 
 def test_mark_for_invalidation_with_delete_updates_last_commit_empty(backend):
     repo = backend.create_repo()
     scm.ScmModel().mark_for_invalidation(repo.repo_name, delete=True)
     assert repo.changeset_cache['revision'] == -1
 
 
 def test_strip_with_multiple_heads(backend_hg):
     commits = [
         {'message': 'A'},
         {'message': 'a'},
         {'message': 'b'},
         {'message': 'B', 'parents': ['A']},
         {'message': 'a1'},
     ]
     repo = backend_hg.create_repo(commits=commits)
     commit_ids = backend_hg.commit_ids
 
     model = scm.ScmModel()
     model.strip(repo, commit_ids['b'], branch=None)
 
     vcs_repo = repo.scm_instance()
     rest_commit_ids = [c.raw_id for c in vcs_repo.get_changesets()]
     assert len(rest_commit_ids) == 4
     assert commit_ids['b'] not in rest_commit_ids
 
 
 def test_strip_with_single_heads(backend_hg):
     commits = [
         {'message': 'A'},
         {'message': 'a'},
         {'message': 'b'},
     ]
     repo = backend_hg.create_repo(commits=commits)
     commit_ids = backend_hg.commit_ids
 
     model = scm.ScmModel()
     model.strip(repo, commit_ids['b'], branch=None)
 
     vcs_repo = repo.scm_instance()
     rest_commit_ids = [c.raw_id for c in vcs_repo.get_changesets()]
     assert len(rest_commit_ids) == 2
     assert commit_ids['b'] not in rest_commit_ids
 
 
 def test_get_nodes_returns_unicode_flat(backend_random):
     repo = backend_random.repo
     directories, files = scm.ScmModel().get_nodes(
         repo.repo_name, repo.get_commit(commit_idx=0).raw_id,
         flat=True)
     assert_contains_only_unicode(directories)
     assert_contains_only_unicode(files)
 
 
 def test_get_nodes_returns_unicode_non_flat(backend_random):
     repo = backend_random.repo
     directories, files = scm.ScmModel().get_nodes(
         repo.repo_name, repo.get_commit(commit_idx=0).raw_id,
         flat=False)
     # johbo: Checking only the names for now, since that is the critical
     # part.
     assert_contains_only_unicode([d['name'] for d in directories])
     assert_contains_only_unicode([f['name'] for f in files])
 
 
 def test_get_nodes_max_file_bytes(backend_random):
     repo = backend_random.repo
     max_file_bytes = 10
     directories, files = scm.ScmModel().get_nodes(
         repo.repo_name, repo.get_commit(commit_idx=0).raw_id, content=True,
         extended_info=True, flat=False)
     assert any(file['content'] and len(file['content']) > max_file_bytes
                for file in files)
 
     directories, files = scm.ScmModel().get_nodes(
         repo.repo_name, repo.get_commit(commit_idx=0).raw_id, content=True,
         extended_info=True, flat=False, max_file_bytes=max_file_bytes)
     assert all(
         file['content'] is None if file['size'] > max_file_bytes else True
         for file in files)
 
 
 def assert_contains_only_unicode(structure):
     assert structure
     for value in structure:
         assert isinstance(value, unicode)
 
 
 @pytest.mark.backends("hg", "git")
 def test_get_non_unicode_reference(backend):
     model = scm.ScmModel()
     non_unicode_list = ["Adını".decode("cp1254")]
 
     def scm_instance():
         return Mock(
             branches=non_unicode_list, bookmarks=non_unicode_list,
             tags=non_unicode_list, alias=backend.alias)
 
     repo = Mock(__class__=db.Repository, scm_instance=scm_instance)
     choices, __ = model.get_repo_landing_revs(translator=lambda s: s, repo=repo)
     if backend.alias == 'hg':
         valid_choices = [
             'rev:tip', u'branch:Ad\xc4\xb1n\xc4\xb1',
             u'book:Ad\xc4\xb1n\xc4\xb1', u'tag:Ad\xc4\xb1n\xc4\xb1']
     else:
         valid_choices = [
             'rev:tip', u'branch:Ad\xc4\xb1n\xc4\xb1',
             u'tag:Ad\xc4\xb1n\xc4\xb1']
 
     assert choices == valid_choices
-
-
-class TestInstallSvnHooks(object):
-    HOOK_FILES = ('pre-commit', 'post-commit')
-
-    def test_new_hooks_are_created(self, backend_svn):
-        model = scm.ScmModel()
-        repo = backend_svn.create_repo()
-        vcs_repo = repo.scm_instance()
-        model.install_svn_hooks(vcs_repo)
-
-        hooks_path = os.path.join(vcs_repo.path, 'hooks')
-        assert os.path.isdir(hooks_path)
-        for file_name in self.HOOK_FILES:
-            file_path = os.path.join(hooks_path, file_name)
-            self._check_hook_file_mode(file_path)
-            self._check_hook_file_content(file_path)
-
-    def test_rc_hooks_are_replaced(self, backend_svn):
-        model = scm.ScmModel()
-        repo = backend_svn.create_repo()
-        vcs_repo = repo.scm_instance()
-        hooks_path = os.path.join(vcs_repo.path, 'hooks')
-        file_paths = [os.path.join(hooks_path, f) for f in self.HOOK_FILES]
-
-        for file_path in file_paths:
-            self._create_fake_hook(
-                file_path, content="RC_HOOK_VER = 'abcde'\n")
-
-        model.install_svn_hooks(vcs_repo)
-
-        for file_path in file_paths:
-            self._check_hook_file_content(file_path)
-
-    def test_non_rc_hooks_are_not_replaced_without_force_create(
-            self, backend_svn):
-        model = scm.ScmModel()
-        repo = backend_svn.create_repo()
-        vcs_repo = repo.scm_instance()
-        hooks_path = os.path.join(vcs_repo.path, 'hooks')
-        file_paths = [os.path.join(hooks_path, f) for f in self.HOOK_FILES]
-        non_rc_content = "exit 0\n"
-
-        for file_path in file_paths:
-            self._create_fake_hook(file_path, content=non_rc_content)
-
-        model.install_svn_hooks(vcs_repo)
-
-        for file_path in file_paths:
-            with open(file_path, 'rt') as hook_file:
-                content = hook_file.read()
-            assert content == non_rc_content
-
-    def test_non_rc_hooks_are_replaced_with_force_create(self, backend_svn):
-        model = scm.ScmModel()
-        repo = backend_svn.create_repo()
-        vcs_repo = repo.scm_instance()
-        hooks_path = os.path.join(vcs_repo.path, 'hooks')
-        file_paths = [os.path.join(hooks_path, f) for f in self.HOOK_FILES]
-        non_rc_content = "exit 0\n"
-
-        for file_path in file_paths:
-            self._create_fake_hook(file_path, content=non_rc_content)
-
-        model.install_svn_hooks(vcs_repo, force_create=True)
-
-        for file_path in file_paths:
-            self._check_hook_file_content(file_path)
-
-    def _check_hook_file_mode(self, file_path):
-        assert os.path.exists(file_path)
-        stat_info = os.stat(file_path)
-
-        file_mode = stat.S_IMODE(stat_info.st_mode)
-        expected_mode = int('755', 8)
-        assert expected_mode == file_mode
-
-    def _check_hook_file_content(self, file_path):
-        with open(file_path, 'rt') as hook_file:
-            content = hook_file.read()
-
-        expected_env = '#!{}'.format(sys.executable)
-        expected_rc_version = "\nRC_HOOK_VER = '{}'\n".format(
-            rhodecode.__version__)
-        assert content.strip().startswith(expected_env)
-        assert expected_rc_version in content
-
-    def _create_fake_hook(self, file_path, content):
-        with open(file_path, 'w') as hook_file:
-            hook_file.write(content)
-
-
-class TestCheckRhodecodeHook(object):
-
-    @patch('os.path.exists', Mock(return_value=False))
-    def test_returns_true_when_no_hook_found(self):
-        result = scm._check_rhodecode_hook('/tmp/fake_hook_file.py')
-        assert result
-
-    @pytest.mark.parametrize("file_content, expected_result", [
-        ("RC_HOOK_VER = '3.3.3'\n", True),
-        ("RC_HOOK = '3.3.3'\n", False),
-    ], ids=no_newline_id_generator)
-    @patch('os.path.exists', Mock(return_value=True))
-    def test_signatures(self, file_content, expected_result):
-        hook_content_patcher = patch.object(
-            scm, '_read_hook', return_value=file_content)
-        with hook_content_patcher:
-            result = scm._check_rhodecode_hook('/tmp/fake_hook_file.py')
-
-        assert result is expected_result
-
-
-class TestInstallHooks(object):
-    def test_hooks_are_installed_for_git_repo(self, backend_git):
-        repo = backend_git.create_repo()
-        model = scm.ScmModel()
-        scm_repo = repo.scm_instance()
-        with patch.object(model, 'install_git_hook') as hooks_mock:
-            model.install_hooks(scm_repo, repo_type='git')
-        hooks_mock.assert_called_once_with(scm_repo)
-
-    def test_hooks_are_installed_for_svn_repo(self, backend_svn):
-        repo = backend_svn.create_repo()
-        scm_repo = repo.scm_instance()
-        model = scm.ScmModel()
-        with patch.object(scm.ScmModel, 'install_svn_hooks') as hooks_mock:
-            model.install_hooks(scm_repo, repo_type='svn')
-        hooks_mock.assert_called_once_with(scm_repo)
-
-    @pytest.mark.parametrize('hook_method', [
-        'install_svn_hooks',
-        'install_git_hook'])
-    def test_mercurial_doesnt_trigger_hooks(self, backend_hg, hook_method):
-        repo = backend_hg.create_repo()
-        scm_repo = repo.scm_instance()
-        model = scm.ScmModel()
-        with patch.object(scm.ScmModel, hook_method) as hooks_mock:
-            model.install_hooks(scm_repo, repo_type='hg')
-        assert hooks_mock.call_count == 0