feat(remap and rescan): added more relient remap and removal option, and also split the logic to either add or cleanup

rhodecode/api/tests/test_cleanup_repos.py

@@ -0,0 +1,44 b''
+# Copyright (C) 2010-2024 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 mock
+import pytest
+
+from rhodecode.model.scm import ScmModel
+from rhodecode.api.tests.utils import (
+    build_data, api_call, assert_ok, assert_error, crash)
+
+
[e-mail]("testuser_api", "app")
+class TestCleanupRepos(object):
+    def test_api_cleanup_repos(self):
+        id_, params = build_data(self.apikey, 'cleanup_repos')
+        response = api_call(self.app, params)
+
+        expected = {'removed': [], 'errors': []}
+        assert_ok(id_, expected, given=response.body)
+
+    def test_api_cleanup_repos_error(self):
+
+        id_, params = build_data(self.apikey, 'cleanup_repos', )
+
+        with mock.patch('rhodecode.lib.utils.repo2db_cleanup', side_effect=crash):
+            response = api_call(self.app, params)
+
+        expected = 'Error occurred during repo storage cleanup action'
+        assert_error(id_, expected, given=response.body)

rhodecode/api/tests/test_rescan_repos.py

@@ -1,42 +1,42 b''
 # Copyright (C) 2010-2024 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 mock
 import pytest
 
-from rhodecode.model.scm import ScmModel
 from rhodecode.api.tests.utils import (
     build_data, api_call, assert_ok, assert_error, crash)
 
 
 @pytest.mark.usefixtures("testuser_api", "app")
 class TestRescanRepos(object):
     def test_api_rescan_repos(self):
         id_, params = build_data(self.apikey, 'rescan_repos')
         response = api_call(self.app, params)
 
-        expected = {'added': [], 'removed': []}
+        expected = {'added': [], 'errors': []}
         assert_ok(id_, expected, given=response.body)
 
-    @mock.patch.object(ScmModel, 'repo_scan', crash)
-    def test_api_rescann_error(self):
+    def test_api_rescan_repos_error(self):
         id_, params = build_data(self.apikey, 'rescan_repos', )
-        response = api_call(self.app, params)
+
+        with mock.patch('rhodecode.lib.utils.repo2db_mapper', side_effect=crash):
+            response = api_call(self.app, params)
 
         expected = 'Error occurred during rescan repositories action'
         assert_error(id_, expected, given=response.body)

rhodecode/api/views/server_api.py

@@ -1,479 +1,463 b''
 # Copyright (C) 2011-2024 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 logging
 import itertools
-import base64
 
 from rhodecode.api import (
     jsonrpc_method, JSONRPCError, JSONRPCForbidden, find_methods)
 
 from rhodecode.api.utils import (
     Optional, OAttr, has_superadmin_permission, get_user_or_error)
-from rhodecode.lib.utils import repo2db_mapper, get_rhodecode_repo_store_path
+from rhodecode.lib.utils import get_rhodecode_repo_store_path
 from rhodecode.lib import system_info
 from rhodecode.lib import user_sessions
 from rhodecode.lib import exc_tracking
 from rhodecode.lib.ext_json import json
 from rhodecode.lib.utils2 import safe_int
 from rhodecode.model.db import UserIpMap
 from rhodecode.model.scm import ScmModel
-from rhodecode.apps.file_store import utils as store_utils
-from rhodecode.apps.file_store.exceptions import FileNotAllowedException, \
-    FileOverSizeException
+
 
 log = logging.getLogger(__name__)
 
 
 @jsonrpc_method()
 def get_server_info(request, apiuser):
     """
     Returns the |RCE| server information.
 
     This includes the running version of |RCE| and all installed
     packages. This command takes the following options:
 
     :param apiuser: This is filled automatically from the |authtoken|.
     :type apiuser: AuthUser
 
     Example output:
 
     .. code-block:: bash
 
       id : <id_given_in_input>
       result : {
         'modules': [<module name>,...]
         'py_version': <python version>,
         'platform': <platform type>,
         'rhodecode_version': <rhodecode version>
       }
       error :  null
     """
 
     if not has_superadmin_permission(apiuser):
         raise JSONRPCForbidden()
 
     server_info = ScmModel().get_server_info(request.environ)
     # rhodecode-index requires those
 
     server_info['index_storage'] = server_info['search']['value']['location']
     server_info['storage'] = server_info['storage']['value']['path']
 
     return server_info
 
 
 @jsonrpc_method()
 def get_repo_store(request, apiuser):
     """
     Returns the |RCE| repository storage information.
 
     :param apiuser: This is filled automatically from the |authtoken|.
     :type apiuser: AuthUser
 
     Example output:
 
     .. code-block:: bash
 
       id : <id_given_in_input>
       result : {
         'modules': [<module name>,...]
         'py_version': <python version>,
         'platform': <platform type>,
         'rhodecode_version': <rhodecode version>
       }
       error :  null
     """
 
     if not has_superadmin_permission(apiuser):
         raise JSONRPCForbidden()
 
     path = get_rhodecode_repo_store_path()
     return {"path": path}
 
 
 @jsonrpc_method()
 def get_ip(request, apiuser, userid=Optional(OAttr('apiuser'))):
     """
     Displays the IP Address as seen from the |RCE| server.
 
     * This command displays the IP Address, as well as all the defined IP
       addresses for the specified user. If the ``userid`` is not set, the
       data returned is for the user calling the method.
 
     This command can only be run using an |authtoken| with admin rights to
     the specified repository.
 
     This command takes the following options:
 
     :param apiuser: This is filled automatically from |authtoken|.
     :type apiuser: AuthUser
     :param userid: Sets the userid for which associated IP Address data
         is returned.
     :type userid: Optional(str or int)
 
     Example output:
 
     .. code-block:: bash
 
         id : <id_given_in_input>
         result : {
                      "server_ip_addr": "<ip_from_clien>",
                      "user_ips": [
                                     {
                                        "ip_addr": "<ip_with_mask>",
                                        "ip_range": ["<start_ip>", "<end_ip>"],
                                     },
                                     ...
                                  ]
         }
 
     """
     if not has_superadmin_permission(apiuser):
         raise JSONRPCForbidden()
 
     userid = Optional.extract(userid, evaluate_locals=locals())
     userid = getattr(userid, 'user_id', userid)
 
     user = get_user_or_error(userid)
     ips = UserIpMap.query().filter(UserIpMap.user == user).all()
     return {
         'server_ip_addr': request.rpc_ip_addr,
         'user_ips': ips
     }
 
 
 @jsonrpc_method()
-def rescan_repos(request, apiuser, remove_obsolete=Optional(False)):
+def rescan_repos(request, apiuser):
     """
     Triggers a rescan of the specified repositories.
-
-    * If the ``remove_obsolete`` option is set, it also deletes repositories
-      that are found in the database but not on the file system, so called
-      "clean zombies".
+    It returns list of added repositories, and errors during scan.
 
     This command can only be run using an |authtoken| with admin rights to
     the specified repository.
 
     This command takes the following options:
 
     :param apiuser: This is filled automatically from the |authtoken|.
     :type apiuser: AuthUser
-    :param remove_obsolete: Deletes repositories from the database that
-        are not found on the filesystem.
-    :type remove_obsolete: Optional(``True`` | ``False``)
 
     Example output:
 
     .. code-block:: bash
 
       id : <id_given_in_input>
       result : {
         'added': [<added repository name>,...]
-        'removed': [<removed repository name>,...]
+        'errors': [<error_list>,...]
       }
       error :  null
 
     Example error output:
 
     .. code-block:: bash
 
       id : <id_given_in_input>
       result : null
       error :  {
         'Error occurred during rescan repositories action'
       }
 
     """
+    from rhodecode.lib.utils import repo2db_mapper # re-import for testing patches
+
     if not has_superadmin_permission(apiuser):
         raise JSONRPCForbidden()
 
     try:
-        rm_obsolete = Optional.extract(remove_obsolete)
-        added, removed = repo2db_mapper(ScmModel().repo_scan(),
-                                        remove_obsolete=rm_obsolete, force_hooks_rebuild=True)
-        return {'added': added, 'removed': removed}
+        added, errors = repo2db_mapper(ScmModel().repo_scan(), force_hooks_rebuild=True)
+        return {'added': added, 'errors': errors}
     except Exception:
-        log.exception('Failed to run repo rescann')
+        log.exception('Failed to run repo rescan')
         raise JSONRPCError(
             'Error occurred during rescan repositories action'
         )
 
 @jsonrpc_method()
-def cleanup_repos(request, apiuser, remove_obsolete=Optional(False)):
+def cleanup_repos(request, apiuser):
     """
-    Triggers a rescan of the specified repositories.
-
-    * If the ``remove_obsolete`` option is set, it also deletes repositories
-      that are found in the database but not on the file system, so called
-      "clean zombies".
+    Triggers a cleanup of non-existing repositories or repository groups in filesystem.
 
     This command can only be run using an |authtoken| with admin rights to
     the specified repository.
 
     This command takes the following options:
 
     :param apiuser: This is filled automatically from the |authtoken|.
     :type apiuser: AuthUser
-    :param remove_obsolete: Deletes repositories from the database that
-        are not found on the filesystem.
-    :type remove_obsolete: Optional(``True`` | ``False``)
 
     Example output:
 
     .. code-block:: bash
 
       id : <id_given_in_input>
       result : {
-        'added': [<added repository name>,...]
-        'removed': [<removed repository name>,...]
+        'removed': [<removed repository name or repository group name>,...]
+        'errors': [<error list of failures to remove>,...]
       }
       error :  null
 
     Example error output:
 
     .. code-block:: bash
 
       id : <id_given_in_input>
       result : null
       error :  {
-        'Error occurred during rescan repositories action'
+        'Error occurred during repo storage cleanup action'
       }
 
     """
+    from rhodecode.lib.utils import repo2db_cleanup  # re-import for testing patches
+
     if not has_superadmin_permission(apiuser):
         raise JSONRPCForbidden()
 
     try:
-        rm_obsolete = Optional.extract(remove_obsolete)
-        added, removed = repo2db_mapper(ScmModel().repo_scan(),
-                                        remove_obsolete=rm_obsolete, force_hooks_rebuild=True)
-        return {'added': added, 'removed': removed}
+        removed, errors = repo2db_cleanup()
+        return {'removed': removed, 'errors': errors}
     except Exception:
-        log.exception('Failed to run repo rescann')
+        log.exception('Failed to run repo storage cleanup')
         raise JSONRPCError(
-            'Error occurred during rescan repositories action'
+            'Error occurred during repo storage cleanup action'
         )
 
 
 @jsonrpc_method()
 def cleanup_sessions(request, apiuser, older_then=Optional(60)):
     """
     Triggers a session cleanup action.
 
     If the ``older_then`` option is set, only sessions that hasn't been
     accessed in the given number of days will be removed.
 
     This command can only be run using an |authtoken| with admin rights to
     the specified repository.
 
     This command takes the following options:
 
     :param apiuser: This is filled automatically from the |authtoken|.
     :type apiuser: AuthUser
     :param older_then: Deletes session that hasn't been accessed
         in given number of days.
     :type older_then: Optional(int)
 
     Example output:
 
     .. code-block:: bash
 
       id : <id_given_in_input>
       result: {
         "backend": "<type of backend>",
         "sessions_removed": <number_of_removed_sessions>
       }
       error :  null
 
     Example error output:
 
     .. code-block:: bash
 
       id : <id_given_in_input>
       result : null
       error :  {
         'Error occurred during session cleanup'
       }
 
     """
     if not has_superadmin_permission(apiuser):
         raise JSONRPCForbidden()
 
     older_then = safe_int(Optional.extract(older_then)) or 60
     older_than_seconds = 60 * 60 * 24 * older_then
 
     config = system_info.rhodecode_config().get_value()['value']['config']
     session_model = user_sessions.get_session_handler(
         config.get('beaker.session.type', 'memory'))(config)
 
     backend = session_model.SESSION_TYPE
     try:
         cleaned = session_model.clean_sessions(
             older_than_seconds=older_than_seconds)
         return {'sessions_removed': cleaned, 'backend': backend}
     except user_sessions.CleanupCommand as msg:
         return {'cleanup_command': str(msg), 'backend': backend}
     except Exception as e:
         log.exception('Failed session cleanup')
         raise JSONRPCError(
             'Error occurred during session cleanup'
         )
 
 
 @jsonrpc_method()
 def get_method(request, apiuser, pattern=Optional('*')):
     """
     Returns list of all available API methods. By default match pattern
     os "*" but any other pattern can be specified. eg *comment* will return
     all methods with comment inside them. If just single method is matched
     returned data will also include method specification
 
     This command can only be run using an |authtoken| with admin rights to
     the specified repository.
 
     This command takes the following options:
 
     :param apiuser: This is filled automatically from the |authtoken|.
     :type apiuser: AuthUser
     :param pattern: pattern to match method names against
     :type pattern: Optional("*")
 
     Example output:
 
     .. code-block:: bash
 
       id : <id_given_in_input>
       "result": [
         "changeset_comment",
         "comment_pull_request",
         "comment_commit"
       ]
       error :  null
 
     .. code-block:: bash
 
       id : <id_given_in_input>
       "result": [
         "comment_commit",
         {
           "apiuser": "<RequiredType>",
           "comment_type": "<Optional:u'note'>",
           "commit_id": "<RequiredType>",
           "message": "<RequiredType>",
           "repoid": "<RequiredType>",
           "request": "<RequiredType>",
           "resolves_comment_id": "<Optional:None>",
           "status": "<Optional:None>",
           "userid": "<Optional:<OptionalAttr:apiuser>>"
         }
       ]
       error :  null
     """
     from rhodecode.config import patches
     inspect = patches.inspect_getargspec()
 
     if not has_superadmin_permission(apiuser):
         raise JSONRPCForbidden()
 
     pattern = Optional.extract(pattern)
 
     matches = find_methods(request.registry.jsonrpc_methods, pattern)
 
     args_desc = []
     matches_keys = list(matches.keys())
     if len(matches_keys) == 1:
         func = matches[matches_keys[0]]
 
         argspec = inspect.getargspec(func)
         arglist = argspec[0]
         defaults = list(map(repr, argspec[3] or []))
 
         default_empty = '<RequiredType>'
 
         # kw arguments required by this method
         func_kwargs = dict(itertools.zip_longest(
             reversed(arglist), reversed(defaults), fillvalue=default_empty))
         args_desc.append(func_kwargs)
 
     return matches_keys + args_desc
 
 
 @jsonrpc_method()
 def store_exception(request, apiuser, exc_data_json, prefix=Optional('rhodecode')):
     """
     Stores sent exception inside the built-in exception tracker in |RCE| server.
 
     This command can only be run using an |authtoken| with admin rights to
     the specified repository.
 
     This command takes the following options:
 
     :param apiuser: This is filled automatically from the |authtoken|.
     :type apiuser: AuthUser
 
     :param exc_data_json: JSON data with exception e.g
         {"exc_traceback": "Value `1` is not allowed", "exc_type_name": "ValueError"}
     :type exc_data_json: JSON data
 
     :param prefix: prefix for error type, e.g 'rhodecode', 'vcsserver', 'rhodecode-tools'
     :type prefix: Optional("rhodecode")
 
     Example output:
 
     .. code-block:: bash
 
       id : <id_given_in_input>
       "result": {
         "exc_id": 139718459226384,
         "exc_url": "http://localhost:8080/_admin/settings/exceptions/139718459226384"
       }
       error :  null
     """
     if not has_superadmin_permission(apiuser):
         raise JSONRPCForbidden()
 
     prefix = Optional.extract(prefix)
     exc_id = exc_tracking.generate_id()
 
     try:
         exc_data = json.loads(exc_data_json)
     except Exception:
         log.error('Failed to parse JSON: %r', exc_data_json)
         raise JSONRPCError('Failed to parse JSON data from exc_data_json field. '
                            'Please make sure it contains a valid JSON.')
 
     try:
         exc_traceback = exc_data['exc_traceback']
         exc_type_name = exc_data['exc_type_name']
         exc_value = ''
     except KeyError as err:
         raise JSONRPCError(
             f'Missing exc_traceback, or exc_type_name '
             f'in exc_data_json field. Missing: {err}')
 
     class ExcType:
         __name__ = exc_type_name
 
     exc_info = (ExcType(), exc_value, exc_traceback)
 
     exc_tracking._store_exception(
         exc_id=exc_id, exc_info=exc_info, prefix=prefix)
 
     exc_url = request.route_url(
         'admin_settings_exception_tracker_show', exception_id=exc_id)
     return {'exc_id': exc_id, 'exc_url': exc_url}

rhodecode/apps/admin/__init__.py

@@ -1,1124 +1,1133 b''
 # Copyright (C) 2016-2024 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/
 
 
 from rhodecode.apps._base import ADMIN_PREFIX
 from rhodecode.apps._base.navigation import includeme as nav_includeme
 from rhodecode.apps.admin.views.main_views import AdminMainView
 
 
 def admin_routes(config):
     """
     Admin prefixed routes
     """
     from rhodecode.apps.admin.views.audit_logs import AdminAuditLogsView
     from rhodecode.apps.admin.views.artifacts import AdminArtifactsView
     from rhodecode.apps.admin.views.automation import AdminAutomationView
     from rhodecode.apps.admin.views.scheduler import AdminSchedulerView
     from rhodecode.apps.admin.views.defaults import AdminDefaultSettingsView
     from rhodecode.apps.admin.views.exception_tracker import ExceptionsTrackerView
     from rhodecode.apps.admin.views.open_source_licenses import OpenSourceLicensesAdminSettingsView
     from rhodecode.apps.admin.views.permissions import AdminPermissionsView
     from rhodecode.apps.admin.views.process_management import AdminProcessManagementView
     from rhodecode.apps.admin.views.repo_groups import AdminRepoGroupsView 
     from rhodecode.apps.admin.views.repositories import AdminReposView
     from rhodecode.apps.admin.views.sessions import AdminSessionSettingsView
     from rhodecode.apps.admin.views.settings import AdminSettingsView
     from rhodecode.apps.admin.views.svn_config import AdminSvnConfigView
     from rhodecode.apps.admin.views.system_info import AdminSystemInfoSettingsView
     from rhodecode.apps.admin.views.user_groups import AdminUserGroupsView
     from rhodecode.apps.admin.views.users import AdminUsersView, UsersView
     from rhodecode.apps.admin.views.security import AdminSecurityView
 
     # Security EE feature
 
     config.add_route(
         'admin_security',
         pattern='/security')
     config.add_view(
         AdminSecurityView,
         attr='security',
         route_name='admin_security', request_method='GET',
         renderer='rhodecode:templates/admin/security/security.mako')
 
     config.add_route(
         name='admin_security_update',
         pattern='/security/update')
     config.add_view(
         AdminSecurityView,
         attr='security_update',
         route_name='admin_security_update', request_method='POST',
         renderer='rhodecode:templates/admin/security/security.mako')
 
     config.add_route(
         name='admin_security_modify_allowed_vcs_client_versions',
         pattern=ADMIN_PREFIX + '/security/modify/allowed_vcs_client_versions')
     config.add_view(
         AdminSecurityView,
         attr='vcs_whitelisted_client_versions_edit',
         route_name='admin_security_modify_allowed_vcs_client_versions', request_method=('GET', 'POST'),
         renderer='rhodecode:templates/admin/security/edit_allowed_vcs_client_versions.mako')
 
 
     config.add_route(
         name='admin_audit_logs',
         pattern='/audit_logs')
     config.add_view(
         AdminAuditLogsView,
         attr='admin_audit_logs',
         route_name='admin_audit_logs', request_method='GET',
         renderer='rhodecode:templates/admin/admin_audit_logs.mako')
 
     config.add_route(
         name='admin_audit_log_entry',
         pattern='/audit_logs/{audit_log_id}')
     config.add_view(
         AdminAuditLogsView,
         attr='admin_audit_log_entry',
         route_name='admin_audit_log_entry', request_method='GET',
         renderer='rhodecode:templates/admin/admin_audit_log_entry.mako')
 
     # Artifacts EE feature
     config.add_route(
         'admin_artifacts',
         pattern=ADMIN_PREFIX + '/artifacts')
     config.add_route(
         'admin_artifacts_show_all',
         pattern=ADMIN_PREFIX + '/artifacts')
     config.add_view(
         AdminArtifactsView,
         attr='artifacts',
         route_name='admin_artifacts', request_method='GET',
         renderer='rhodecode:templates/admin/artifacts/artifacts.mako')
     config.add_view(
         AdminArtifactsView,
         attr='artifacts',
         route_name='admin_artifacts_show_all', request_method='GET',
         renderer='rhodecode:templates/admin/artifacts/artifacts.mako')
 
     # EE views
     config.add_route(
         name='admin_artifacts_show_info',
         pattern=ADMIN_PREFIX + '/artifacts/{uid}')
     config.add_route(
         name='admin_artifacts_delete',
         pattern=ADMIN_PREFIX + '/artifacts/{uid}/delete')
     config.add_route(
         name='admin_artifacts_update',
         pattern=ADMIN_PREFIX + '/artifacts/{uid}/update')
 
     # Automation EE feature
     config.add_route(
         'admin_automation',
         pattern=ADMIN_PREFIX + '/automation')
     config.add_view(
         AdminAutomationView,
         attr='automation',
         route_name='admin_automation', request_method='GET',
         renderer='rhodecode:templates/admin/automation/automation.mako')
 
     # Scheduler EE feature
     config.add_route(
         'admin_scheduler',
         pattern=ADMIN_PREFIX + '/scheduler')
     config.add_view(
         AdminSchedulerView,
         attr='scheduler',
         route_name='admin_scheduler', request_method='GET',
         renderer='rhodecode:templates/admin/scheduler/scheduler.mako')
 
     config.add_route(
         name='admin_settings_open_source',
         pattern='/settings/open_source')
     config.add_view(
         OpenSourceLicensesAdminSettingsView,
         attr='open_source_licenses',
         route_name='admin_settings_open_source', request_method='GET',
         renderer='rhodecode:templates/admin/settings/settings.mako')
 
     config.add_route(
         name='admin_settings_vcs_svn_generate_cfg',
         pattern='/settings/vcs/svn_generate_cfg')
     config.add_view(
         AdminSvnConfigView,
         attr='vcs_svn_generate_config',
         route_name='admin_settings_vcs_svn_generate_cfg',
         request_method='POST', renderer='json')
 
     config.add_route(
         name='admin_settings_system',
         pattern='/settings/system')
     config.add_view(
         AdminSystemInfoSettingsView,
         attr='settings_system_info',
         route_name='admin_settings_system', request_method='GET',
         renderer='rhodecode:templates/admin/settings/settings.mako')
 
     config.add_route(
         name='admin_settings_system_update',
         pattern='/settings/system/updates')
     config.add_view(
         AdminSystemInfoSettingsView,
         attr='settings_system_info_check_update',
         route_name='admin_settings_system_update', request_method='GET',
         renderer='rhodecode:templates/admin/settings/settings_system_update.mako')
 
     config.add_route(
         name='admin_settings_exception_tracker',
         pattern='/settings/exceptions')
     config.add_view(
         ExceptionsTrackerView,
         attr='browse_exceptions',
         route_name='admin_settings_exception_tracker', request_method='GET',
         renderer='rhodecode:templates/admin/settings/settings.mako')
 
     config.add_route(
         name='admin_settings_exception_tracker_delete_all',
         pattern='/settings/exceptions_delete_all')
     config.add_view(
         ExceptionsTrackerView,
         attr='exception_delete_all',
         route_name='admin_settings_exception_tracker_delete_all', request_method='POST',
         renderer='rhodecode:templates/admin/settings/settings.mako')
 
     config.add_route(
         name='admin_settings_exception_tracker_show',
         pattern='/settings/exceptions/{exception_id}')
     config.add_view(
         ExceptionsTrackerView,
         attr='exception_show',
         route_name='admin_settings_exception_tracker_show', request_method='GET',
         renderer='rhodecode:templates/admin/settings/settings.mako')
 
     config.add_route(
         name='admin_settings_exception_tracker_delete',
         pattern='/settings/exceptions/{exception_id}/delete')
     config.add_view(
         ExceptionsTrackerView,
         attr='exception_delete',
         route_name='admin_settings_exception_tracker_delete', request_method='POST',
         renderer='rhodecode:templates/admin/settings/settings.mako')
 
     config.add_route(
         name='admin_settings_sessions',
         pattern='/settings/sessions')
     config.add_view(
         AdminSessionSettingsView,
         attr='settings_sessions',
         route_name='admin_settings_sessions', request_method='GET',
         renderer='rhodecode:templates/admin/settings/settings.mako')
 
     config.add_route(
         name='admin_settings_sessions_cleanup',
         pattern='/settings/sessions/cleanup')
     config.add_view(
         AdminSessionSettingsView,
         attr='settings_sessions_cleanup',
         route_name='admin_settings_sessions_cleanup', request_method='POST')
 
     config.add_route(
         name='admin_settings_process_management',
         pattern='/settings/process_management')
     config.add_view(
         AdminProcessManagementView,
         attr='process_management',
         route_name='admin_settings_process_management', request_method='GET',
         renderer='rhodecode:templates/admin/settings/settings.mako')
 
     config.add_route(
         name='admin_settings_process_management_data',
         pattern='/settings/process_management/data')
     config.add_view(
         AdminProcessManagementView,
         attr='process_management_data',
         route_name='admin_settings_process_management_data', request_method='GET',
         renderer='rhodecode:templates/admin/settings/settings_process_management_data.mako')
 
     config.add_route(
         name='admin_settings_process_management_signal',
         pattern='/settings/process_management/signal')
     config.add_view(
         AdminProcessManagementView,
         attr='process_management_signal',
         route_name='admin_settings_process_management_signal',
         request_method='POST', renderer='json_ext')
 
     config.add_route(
         name='admin_settings_process_management_master_signal',
         pattern='/settings/process_management/master_signal')
     config.add_view(
         AdminProcessManagementView,
         attr='process_management_master_signal',
         route_name='admin_settings_process_management_master_signal',
         request_method='POST', renderer='json_ext')
 
     # default settings
     config.add_route(
         name='admin_defaults_repositories',
         pattern='/defaults/repositories')
     config.add_view(
         AdminDefaultSettingsView,
         attr='defaults_repository_show',
         route_name='admin_defaults_repositories', request_method='GET',
         renderer='rhodecode:templates/admin/defaults/defaults.mako')
 
     config.add_route(
         name='admin_defaults_repositories_update',
         pattern='/defaults/repositories/update')
     config.add_view(
         AdminDefaultSettingsView,
         attr='defaults_repository_update',
         route_name='admin_defaults_repositories_update', request_method='POST',
         renderer='rhodecode:templates/admin/defaults/defaults.mako')
 
     # admin settings
 
     config.add_route(
         name='admin_settings',
         pattern='/settings')
     config.add_view(
         AdminSettingsView,
         attr='settings_global',
         route_name='admin_settings', request_method='GET',
         renderer='rhodecode:templates/admin/settings/settings.mako')
 
     config.add_route(
         name='admin_settings_update',
         pattern='/settings/update')
     config.add_view(
         AdminSettingsView,
         attr='settings_global_update',
         route_name='admin_settings_update', request_method='POST',
         renderer='rhodecode:templates/admin/settings/settings.mako')
 
     config.add_route(
         name='admin_settings_global',
         pattern='/settings/global')
     config.add_view(
         AdminSettingsView,
         attr='settings_global',
         route_name='admin_settings_global', request_method='GET',
         renderer='rhodecode:templates/admin/settings/settings.mako')
 
     config.add_route(
         name='admin_settings_global_update',
         pattern='/settings/global/update')
     config.add_view(
         AdminSettingsView,
         attr='settings_global_update',
         route_name='admin_settings_global_update', request_method='POST',
         renderer='rhodecode:templates/admin/settings/settings.mako')
 
     config.add_route(
         name='admin_settings_vcs',
         pattern='/settings/vcs')
     config.add_view(
         AdminSettingsView,
         attr='settings_vcs',
         route_name='admin_settings_vcs', request_method='GET',
         renderer='rhodecode:templates/admin/settings/settings.mako')
 
     config.add_route(
         name='admin_settings_vcs_update',
         pattern='/settings/vcs/update')
     config.add_view(
         AdminSettingsView,
         attr='settings_vcs_update',
         route_name='admin_settings_vcs_update', request_method='POST',
         renderer='rhodecode:templates/admin/settings/settings.mako')
 
     config.add_route(
         name='admin_settings_vcs_svn_pattern_delete',
         pattern='/settings/vcs/svn_pattern_delete')
     config.add_view(
         AdminSettingsView,
         attr='settings_vcs_delete_svn_pattern',
         route_name='admin_settings_vcs_svn_pattern_delete', request_method='POST',
         renderer='json_ext', xhr=True)
 
     config.add_route(
         name='admin_settings_mapping',
         pattern='/settings/mapping')
     config.add_view(
         AdminSettingsView,
         attr='settings_mapping',
         route_name='admin_settings_mapping', request_method='GET',
         renderer='rhodecode:templates/admin/settings/settings.mako')
 
     config.add_route(
-        name='admin_settings_mapping_update',
-        pattern='/settings/mapping/update')
+        name='admin_settings_mapping_create',
+        pattern='/settings/mapping/create')
     config.add_view(
         AdminSettingsView,
-        attr='settings_mapping_update',
-        route_name='admin_settings_mapping_update', request_method='POST',
+        attr='settings_mapping_create',
+        route_name='admin_settings_mapping_create', request_method='POST',
+        renderer='rhodecode:templates/admin/settings/settings.mako')
+
+    config.add_route(
+        name='admin_settings_mapping_cleanup',
+        pattern='/settings/mapping/cleanup')
+    config.add_view(
+        AdminSettingsView,
+        attr='settings_mapping_cleanup',
+        route_name='admin_settings_mapping_cleanup', request_method='POST',
         renderer='rhodecode:templates/admin/settings/settings.mako')
 
     config.add_route(
         name='admin_settings_visual',
         pattern='/settings/visual')
     config.add_view(
         AdminSettingsView,
         attr='settings_visual',
         route_name='admin_settings_visual', request_method='GET',
         renderer='rhodecode:templates/admin/settings/settings.mako')
 
     config.add_route(
         name='admin_settings_visual_update',
         pattern='/settings/visual/update')
     config.add_view(
         AdminSettingsView,
         attr='settings_visual_update',
         route_name='admin_settings_visual_update', request_method='POST',
         renderer='rhodecode:templates/admin/settings/settings.mako')
 
     config.add_route(
         name='admin_settings_issuetracker',
         pattern='/settings/issue-tracker')
     config.add_view(
         AdminSettingsView,
         attr='settings_issuetracker',
         route_name='admin_settings_issuetracker', request_method='GET',
         renderer='rhodecode:templates/admin/settings/settings.mako')
 
     config.add_route(
         name='admin_settings_issuetracker_update',
         pattern='/settings/issue-tracker/update')
     config.add_view(
         AdminSettingsView,
         attr='settings_issuetracker_update',
         route_name='admin_settings_issuetracker_update', request_method='POST',
         renderer='rhodecode:templates/admin/settings/settings.mako')
 
     config.add_route(
         name='admin_settings_issuetracker_test',
         pattern='/settings/issue-tracker/test')
     config.add_view(
         AdminSettingsView,
         attr='settings_issuetracker_test',
         route_name='admin_settings_issuetracker_test', request_method='POST',
         renderer='string', xhr=True)
 
     config.add_route(
         name='admin_settings_issuetracker_delete',
         pattern='/settings/issue-tracker/delete')
     config.add_view(
         AdminSettingsView,
         attr='settings_issuetracker_delete',
         route_name='admin_settings_issuetracker_delete', request_method='POST',
         renderer='json_ext', xhr=True)
 
     config.add_route(
         name='admin_settings_email',
         pattern='/settings/email')
     config.add_view(
         AdminSettingsView,
         attr='settings_email',
         route_name='admin_settings_email', request_method='GET',
         renderer='rhodecode:templates/admin/settings/settings.mako')
 
     config.add_route(
         name='admin_settings_email_update',
         pattern='/settings/email/update')
     config.add_view(
         AdminSettingsView,
         attr='settings_email_update',
         route_name='admin_settings_email_update', request_method='POST',
         renderer='rhodecode:templates/admin/settings/settings.mako')
 
     config.add_route(
         name='admin_settings_hooks',
         pattern='/settings/hooks')
     config.add_view(
         AdminSettingsView,
         attr='settings_hooks',
         route_name='admin_settings_hooks', request_method='GET',
         renderer='rhodecode:templates/admin/settings/settings.mako')
 
     config.add_route(
         name='admin_settings_hooks_update',
         pattern='/settings/hooks/update')
     config.add_view(
         AdminSettingsView,
         attr='settings_hooks_update',
         route_name='admin_settings_hooks_update', request_method='POST',
         renderer='rhodecode:templates/admin/settings/settings.mako')
 
     config.add_route(
         name='admin_settings_hooks_delete',
         pattern='/settings/hooks/delete')
     config.add_view(
         AdminSettingsView,
         attr='settings_hooks_update',
         route_name='admin_settings_hooks_delete', request_method='POST',
         renderer='rhodecode:templates/admin/settings/settings.mako')
 
     config.add_route(
         name='admin_settings_search',
         pattern='/settings/search')
     config.add_view(
         AdminSettingsView,
         attr='settings_search',
         route_name='admin_settings_search', request_method='GET',
         renderer='rhodecode:templates/admin/settings/settings.mako')
 
     config.add_route(
         name='admin_settings_labs',
         pattern='/settings/labs')
     config.add_view(
         AdminSettingsView,
         attr='settings_labs',
         route_name='admin_settings_labs', request_method='GET',
         renderer='rhodecode:templates/admin/settings/settings.mako')
 
     config.add_route(
         name='admin_settings_labs_update',
         pattern='/settings/labs/update')
     config.add_view(
         AdminSettingsView,
         attr='settings_labs_update',
         route_name='admin_settings_labs_update', request_method='POST',
         renderer='rhodecode:templates/admin/settings/settings.mako')
 
     # global permissions
 
     config.add_route(
         name='admin_permissions_application',
         pattern='/permissions/application')
     config.add_view(
         AdminPermissionsView,
         attr='permissions_application',
         route_name='admin_permissions_application', request_method='GET',
         renderer='rhodecode:templates/admin/permissions/permissions.mako')
 
     config.add_route(
         name='admin_permissions_application_update',
         pattern='/permissions/application/update')
     config.add_view(
         AdminPermissionsView,
         attr='permissions_application_update',
         route_name='admin_permissions_application_update', request_method='POST',
         renderer='rhodecode:templates/admin/permissions/permissions.mako')
 
     config.add_route(
         name='admin_permissions_global',
         pattern='/permissions/global')
     config.add_view(
         AdminPermissionsView,
         attr='permissions_global',
         route_name='admin_permissions_global', request_method='GET',
         renderer='rhodecode:templates/admin/permissions/permissions.mako')
     
     config.add_route(
         name='admin_permissions_global_update',
         pattern='/permissions/global/update')
     config.add_view(
         AdminPermissionsView,
         attr='permissions_global_update',
         route_name='admin_permissions_global_update', request_method='POST',
         renderer='rhodecode:templates/admin/permissions/permissions.mako')
 
     config.add_route(
         name='admin_permissions_object',
         pattern='/permissions/object')
     config.add_view(
         AdminPermissionsView,
         attr='permissions_objects',
         route_name='admin_permissions_object', request_method='GET',
         renderer='rhodecode:templates/admin/permissions/permissions.mako')
 
     config.add_route(
         name='admin_permissions_object_update',
         pattern='/permissions/object/update')
     config.add_view(
         AdminPermissionsView,
         attr='permissions_objects_update',
         route_name='admin_permissions_object_update', request_method='POST',
         renderer='rhodecode:templates/admin/permissions/permissions.mako')
 
     # Branch perms EE feature
     config.add_route(
         name='admin_permissions_branch',
         pattern='/permissions/branch')
     config.add_view(
         AdminPermissionsView,
         attr='permissions_branch',
         route_name='admin_permissions_branch', request_method='GET',
         renderer='rhodecode:templates/admin/permissions/permissions.mako')
 
     config.add_route(
         name='admin_permissions_ips',
         pattern='/permissions/ips')
     config.add_view(
         AdminPermissionsView,
         attr='permissions_ips',
         route_name='admin_permissions_ips', request_method='GET',
         renderer='rhodecode:templates/admin/permissions/permissions.mako')
 
     config.add_route(
         name='admin_permissions_overview',
         pattern='/permissions/overview')
     config.add_view(
         AdminPermissionsView,
         attr='permissions_overview',
         route_name='admin_permissions_overview', request_method='GET',
         renderer='rhodecode:templates/admin/permissions/permissions.mako')
 
     config.add_route(
         name='admin_permissions_auth_token_access',
         pattern='/permissions/auth_token_access')
     config.add_view(
         AdminPermissionsView,
         attr='auth_token_access',
         route_name='admin_permissions_auth_token_access', request_method='GET',
         renderer='rhodecode:templates/admin/permissions/permissions.mako')
 
     config.add_route(
         name='admin_permissions_ssh_keys',
         pattern='/permissions/ssh_keys')
     config.add_view(
         AdminPermissionsView,
         attr='ssh_keys',
         route_name='admin_permissions_ssh_keys', request_method='GET',
         renderer='rhodecode:templates/admin/permissions/permissions.mako')
 
     config.add_route(
         name='admin_permissions_ssh_keys_data',
         pattern='/permissions/ssh_keys/data')
     config.add_view(
         AdminPermissionsView,
         attr='ssh_keys_data',
         route_name='admin_permissions_ssh_keys_data', request_method='GET',
         renderer='json_ext', xhr=True)
 
     config.add_route(
         name='admin_permissions_ssh_keys_update',
         pattern='/permissions/ssh_keys/update')
     config.add_view(
         AdminPermissionsView,
         attr='ssh_keys_update',
         route_name='admin_permissions_ssh_keys_update', request_method='POST',
         renderer='rhodecode:templates/admin/permissions/permissions.mako')
 
     # users admin
     config.add_route(
         name='users',
         pattern='/users')
     config.add_view(
         AdminUsersView,
         attr='users_list',
         route_name='users', request_method='GET',
         renderer='rhodecode:templates/admin/users/users.mako')
 
     config.add_route(
         name='users_data',
         pattern='/users_data')
     config.add_view(
         AdminUsersView,
         attr='users_list_data',
         # renderer defined below
         route_name='users_data', request_method='GET',
         renderer='json_ext', xhr=True)
 
     config.add_route(
         name='users_create',
         pattern='/users/create')
     config.add_view(
         AdminUsersView,
         attr='users_create',
         route_name='users_create', request_method='POST',
         renderer='rhodecode:templates/admin/users/user_add.mako')
 
     config.add_route(
         name='users_new',
         pattern='/users/new')
     config.add_view(
         AdminUsersView,
         attr='users_new',
         route_name='users_new', request_method='GET',
         renderer='rhodecode:templates/admin/users/user_add.mako')
 
     # user management
     config.add_route(
         name='user_edit',
         pattern=r'/users/{user_id:\d+}/edit',
         user_route=True)
     config.add_view(
         UsersView,
         attr='user_edit',
         route_name='user_edit', request_method='GET',
         renderer='rhodecode:templates/admin/users/user_edit.mako')
 
     config.add_route(
         name='user_edit_advanced',
         pattern=r'/users/{user_id:\d+}/edit/advanced',
         user_route=True)
     config.add_view(
         UsersView,
         attr='user_edit_advanced',
         route_name='user_edit_advanced', request_method='GET',
         renderer='rhodecode:templates/admin/users/user_edit.mako')
 
     config.add_route(
         name='user_edit_global_perms',
         pattern=r'/users/{user_id:\d+}/edit/global_permissions',
         user_route=True)
     config.add_view(
         UsersView,
         attr='user_edit_global_perms',
         route_name='user_edit_global_perms', request_method='GET',
         renderer='rhodecode:templates/admin/users/user_edit.mako')
 
     config.add_route(
         name='user_edit_global_perms_update',
         pattern=r'/users/{user_id:\d+}/edit/global_permissions/update',
         user_route=True)
     config.add_view(
         UsersView,
         attr='user_edit_global_perms_update',
         route_name='user_edit_global_perms_update', request_method='POST',
         renderer='rhodecode:templates/admin/users/user_edit.mako')
 
     config.add_route(
         name='user_update',
         pattern=r'/users/{user_id:\d+}/update',
         user_route=True)
     config.add_view(
         UsersView,
         attr='user_update',
         route_name='user_update', request_method='POST',
         renderer='rhodecode:templates/admin/users/user_edit.mako')
 
     config.add_route(
         name='user_delete',
         pattern=r'/users/{user_id:\d+}/delete',
         user_route=True)
     config.add_view(
         UsersView,
         attr='user_delete',
         route_name='user_delete', request_method='POST',
         renderer='rhodecode:templates/admin/users/user_edit.mako')
 
     config.add_route(
         name='user_enable_force_password_reset',
         pattern=r'/users/{user_id:\d+}/password_reset_enable',
         user_route=True)
     config.add_view(
         UsersView,
         attr='user_enable_force_password_reset',
         route_name='user_enable_force_password_reset', request_method='POST',
         renderer='rhodecode:templates/admin/users/user_edit.mako')
 
     config.add_route(
         name='user_disable_force_password_reset',
         pattern=r'/users/{user_id:\d+}/password_reset_disable',
         user_route=True)
     config.add_view(
         UsersView,
         attr='user_disable_force_password_reset',
         route_name='user_disable_force_password_reset', request_method='POST',
         renderer='rhodecode:templates/admin/users/user_edit.mako')
 
     config.add_route(
         name='user_create_personal_repo_group',
         pattern=r'/users/{user_id:\d+}/create_repo_group',
         user_route=True)
     config.add_view(
         UsersView,
         attr='user_create_personal_repo_group',
         route_name='user_create_personal_repo_group', request_method='POST',
         renderer='rhodecode:templates/admin/users/user_edit.mako')
 
     # user notice
     config.add_route(
         name='user_notice_dismiss',
         pattern=r'/users/{user_id:\d+}/notice_dismiss',
         user_route=True)
     config.add_view(
         UsersView,
         attr='user_notice_dismiss',
         route_name='user_notice_dismiss', request_method='POST',
         renderer='json_ext', xhr=True)
 
     # user auth tokens
     config.add_route(
         name='edit_user_auth_tokens',
         pattern=r'/users/{user_id:\d+}/edit/auth_tokens',
         user_route=True)
     config.add_view(
         UsersView,
         attr='auth_tokens',
         route_name='edit_user_auth_tokens', request_method='GET',
         renderer='rhodecode:templates/admin/users/user_edit.mako')
 
     config.add_route(
         name='edit_user_auth_tokens_view',
         pattern=r'/users/{user_id:\d+}/edit/auth_tokens/view',
         user_route=True)
     config.add_view(
         UsersView,
         attr='auth_tokens_view',
         route_name='edit_user_auth_tokens_view', request_method='POST',
         renderer='json_ext', xhr=True)
 
     config.add_route(
         name='edit_user_auth_tokens_add',
         pattern=r'/users/{user_id:\d+}/edit/auth_tokens/new',
         user_route=True)
     config.add_view(
         UsersView,
         attr='auth_tokens_add',
         route_name='edit_user_auth_tokens_add', request_method='POST')
 
     config.add_route(
         name='edit_user_auth_tokens_delete',
         pattern=r'/users/{user_id:\d+}/edit/auth_tokens/delete',
         user_route=True)
     config.add_view(
         UsersView,
         attr='auth_tokens_delete',
         route_name='edit_user_auth_tokens_delete', request_method='POST')
 
     # user ssh keys
     config.add_route(
         name='edit_user_ssh_keys',
         pattern=r'/users/{user_id:\d+}/edit/ssh_keys',
         user_route=True)
     config.add_view(
         UsersView,
         attr='ssh_keys',
         route_name='edit_user_ssh_keys', request_method='GET',
         renderer='rhodecode:templates/admin/users/user_edit.mako')
 
     config.add_route(
         name='edit_user_ssh_keys_generate_keypair',
         pattern=r'/users/{user_id:\d+}/edit/ssh_keys/generate',
         user_route=True)
     config.add_view(
         UsersView,
         attr='ssh_keys_generate_keypair',
         route_name='edit_user_ssh_keys_generate_keypair', request_method='GET',
         renderer='rhodecode:templates/admin/users/user_edit.mako')
 
     config.add_route(
         name='edit_user_ssh_keys_add',
         pattern=r'/users/{user_id:\d+}/edit/ssh_keys/new',
         user_route=True)
     config.add_view(
         UsersView,
         attr='ssh_keys_add',
         route_name='edit_user_ssh_keys_add', request_method='POST')
 
     config.add_route(
         name='edit_user_ssh_keys_delete',
         pattern=r'/users/{user_id:\d+}/edit/ssh_keys/delete',
         user_route=True)
     config.add_view(
         UsersView,
         attr='ssh_keys_delete',
         route_name='edit_user_ssh_keys_delete', request_method='POST')
 
     # user emails
     config.add_route(
         name='edit_user_emails',
         pattern=r'/users/{user_id:\d+}/edit/emails',
         user_route=True)
     config.add_view(
         UsersView,
         attr='emails',
         route_name='edit_user_emails', request_method='GET',
         renderer='rhodecode:templates/admin/users/user_edit.mako')
 
     config.add_route(
         name='edit_user_emails_add',
         pattern=r'/users/{user_id:\d+}/edit/emails/new',
         user_route=True)
     config.add_view(
         UsersView,
         attr='emails_add',
         route_name='edit_user_emails_add', request_method='POST')
 
     config.add_route(
         name='edit_user_emails_delete',
         pattern=r'/users/{user_id:\d+}/edit/emails/delete',
         user_route=True)
     config.add_view(
         UsersView,
         attr='emails_delete',
         route_name='edit_user_emails_delete', request_method='POST')
 
     # user IPs
     config.add_route(
         name='edit_user_ips',
         pattern=r'/users/{user_id:\d+}/edit/ips',
         user_route=True)
     config.add_view(
         UsersView,
         attr='ips',
         route_name='edit_user_ips', request_method='GET',
         renderer='rhodecode:templates/admin/users/user_edit.mako')
 
     config.add_route(
         name='edit_user_ips_add',
         pattern=r'/users/{user_id:\d+}/edit/ips/new',
         user_route_with_default=True)  # enabled for default user too
     config.add_view(
         UsersView,
         attr='ips_add',
         route_name='edit_user_ips_add', request_method='POST')
 
     config.add_route(
         name='edit_user_ips_delete',
         pattern=r'/users/{user_id:\d+}/edit/ips/delete',
         user_route_with_default=True)  # enabled for default user too
     config.add_view(
         UsersView,
         attr='ips_delete',
         route_name='edit_user_ips_delete', request_method='POST')
 
     # user perms
     config.add_route(
         name='edit_user_perms_summary',
         pattern=r'/users/{user_id:\d+}/edit/permissions_summary',
         user_route=True)
     config.add_view(
         UsersView,
         attr='user_perms_summary',
         route_name='edit_user_perms_summary', request_method='GET',
         renderer='rhodecode:templates/admin/users/user_edit.mako')
 
     config.add_route(
         name='edit_user_perms_summary_json',
         pattern=r'/users/{user_id:\d+}/edit/permissions_summary/json',
         user_route=True)
     config.add_view(
         UsersView,
         attr='user_perms_summary_json',
         route_name='edit_user_perms_summary_json', request_method='GET',
         renderer='json_ext')
 
     # user user groups management
     config.add_route(
         name='edit_user_groups_management',
         pattern=r'/users/{user_id:\d+}/edit/groups_management',
         user_route=True)
     config.add_view(
         UsersView,
         attr='groups_management',
         route_name='edit_user_groups_management', request_method='GET',
         renderer='rhodecode:templates/admin/users/user_edit.mako')
 
     config.add_route(
         name='edit_user_groups_management_updates',
         pattern=r'/users/{user_id:\d+}/edit/edit_user_groups_management/updates',
         user_route=True)
     config.add_view(
         UsersView,
         attr='groups_management_updates',
         route_name='edit_user_groups_management_updates', request_method='POST')
 
     # user audit logs
     config.add_route(
         name='edit_user_audit_logs',
         pattern=r'/users/{user_id:\d+}/edit/audit', user_route=True)
     config.add_view(
         UsersView,
         attr='user_audit_logs',
         route_name='edit_user_audit_logs', request_method='GET',
         renderer='rhodecode:templates/admin/users/user_edit.mako')
 
     config.add_route(
         name='edit_user_audit_logs_download',
         pattern=r'/users/{user_id:\d+}/edit/audit/download', user_route=True)
     config.add_view(
         UsersView,
         attr='user_audit_logs_download',
         route_name='edit_user_audit_logs_download', request_method='GET',
         renderer='string')
 
     # user caches
     config.add_route(
         name='edit_user_caches',
         pattern=r'/users/{user_id:\d+}/edit/caches',
         user_route=True)
     config.add_view(
         UsersView,
         attr='user_caches',
         route_name='edit_user_caches', request_method='GET',
         renderer='rhodecode:templates/admin/users/user_edit.mako')
 
     config.add_route(
         name='edit_user_caches_update',
         pattern=r'/users/{user_id:\d+}/edit/caches/update',
         user_route=True)
     config.add_view(
         UsersView,
         attr='user_caches_update',
         route_name='edit_user_caches_update', request_method='POST')
 
     # user-groups admin
     config.add_route(
         name='user_groups',
         pattern='/user_groups')
     config.add_view(
         AdminUserGroupsView,
         attr='user_groups_list',
         route_name='user_groups', request_method='GET',
         renderer='rhodecode:templates/admin/user_groups/user_groups.mako')
 
     config.add_route(
         name='user_groups_data',
         pattern='/user_groups_data')
     config.add_view(
         AdminUserGroupsView,
         attr='user_groups_list_data',
         route_name='user_groups_data', request_method='GET',
         renderer='json_ext', xhr=True)
 
     config.add_route(
         name='user_groups_new',
         pattern='/user_groups/new')
     config.add_view(
         AdminUserGroupsView,
         attr='user_groups_new',
         route_name='user_groups_new', request_method='GET',
         renderer='rhodecode:templates/admin/user_groups/user_group_add.mako')
 
     config.add_route(
         name='user_groups_create',
         pattern='/user_groups/create')
     config.add_view(
         AdminUserGroupsView,
         attr='user_groups_create',
         route_name='user_groups_create', request_method='POST',
         renderer='rhodecode:templates/admin/user_groups/user_group_add.mako')
 
     # repos admin
     config.add_route(
         name='repos',
         pattern='/repos')
     config.add_view(
         AdminReposView,
         attr='repository_list',
         route_name='repos', request_method='GET',
         renderer='rhodecode:templates/admin/repos/repos.mako')
 
     config.add_route(
         name='repos_data',
         pattern='/repos_data')
     config.add_view(
         AdminReposView,
         attr='repository_list_data',
         route_name='repos_data', request_method='GET',
         renderer='json_ext', xhr=True)
 
     config.add_route(
         name='repo_new',
         pattern='/repos/new')
     config.add_view(
         AdminReposView,
         attr='repository_new',
         route_name='repo_new', request_method='GET',
         renderer='rhodecode:templates/admin/repos/repo_add.mako')
 
     config.add_route(
         name='repo_create',
         pattern='/repos/create')
     config.add_view(
         AdminReposView,
         attr='repository_create',
         route_name='repo_create', request_method='POST',
         renderer='rhodecode:templates/admin/repos/repos.mako')
 
     # repo groups admin
     config.add_route(
         name='repo_groups',
         pattern='/repo_groups')
     config.add_view(
         AdminRepoGroupsView,
         attr='repo_group_list',
         route_name='repo_groups', request_method='GET',
         renderer='rhodecode:templates/admin/repo_groups/repo_groups.mako')
 
     config.add_route(
         name='repo_groups_data',
         pattern='/repo_groups_data')
     config.add_view(
         AdminRepoGroupsView,
         attr='repo_group_list_data',
         route_name='repo_groups_data', request_method='GET',
         renderer='json_ext', xhr=True)
 
     config.add_route(
         name='repo_group_new',
         pattern='/repo_group/new')
     config.add_view(
         AdminRepoGroupsView,
         attr='repo_group_new',
         route_name='repo_group_new', request_method='GET',
         renderer='rhodecode:templates/admin/repo_groups/repo_group_add.mako')
 
     config.add_route(
         name='repo_group_create',
         pattern='/repo_group/create')
     config.add_view(
         AdminRepoGroupsView,
         attr='repo_group_create',
         route_name='repo_group_create', request_method='POST',
         renderer='rhodecode:templates/admin/repo_groups/repo_group_add.mako')
 
 
 def includeme(config):
     # Create admin navigation registry and add it to the pyramid registry.
     nav_includeme(config)
 
     # main admin routes
     config.add_route(
         name='admin_home', pattern=ADMIN_PREFIX)
     config.add_view(
         AdminMainView,
         attr='admin_main',
         route_name='admin_home', request_method='GET',
         renderer='rhodecode:templates/admin/main.mako')
 
     # pr global redirect
     config.add_route(
         name='pull_requests_global_0',  # backward compat
         pattern=ADMIN_PREFIX + r'/pull_requests/{pull_request_id:\d+}')
     config.add_view(
         AdminMainView,
         attr='pull_requests',
         route_name='pull_requests_global_0', request_method='GET')
 
     config.add_route(
         name='pull_requests_global_1',  # backward compat
         pattern=ADMIN_PREFIX + r'/pull-requests/{pull_request_id:\d+}')
     config.add_view(
         AdminMainView,
         attr='pull_requests',
         route_name='pull_requests_global_1', request_method='GET')
 
     config.add_route(
         name='pull_requests_global',
         pattern=ADMIN_PREFIX + r'/pull-request/{pull_request_id:\d+}')
     config.add_view(
         AdminMainView,
         attr='pull_requests',
         route_name='pull_requests_global', request_method='GET')
 
     config.include(admin_routes, route_prefix=ADMIN_PREFIX)

rhodecode/apps/admin/tests/test_admin_repos.py

@@ -1,496 +1,498 b''
 # Copyright (C) 2010-2024 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 urllib.request
 import urllib.parse
 import urllib.error
 
 import mock
 import pytest
 
 from rhodecode.apps._base import ADMIN_PREFIX
 from rhodecode.lib import auth
 from rhodecode.lib.utils2 import safe_str
 from rhodecode.lib import helpers as h
 from rhodecode.model.db import (
     Repository, RepoGroup, UserRepoToPerm, User, Permission)
 from rhodecode.model.meta import Session
 from rhodecode.model.repo import RepoModel
 from rhodecode.model.repo_group import RepoGroupModel
 from rhodecode.model.user import UserModel
 from rhodecode.tests import (
     login_user_session, assert_session_flash, TEST_USER_ADMIN_LOGIN,
     TEST_USER_REGULAR_LOGIN, TEST_USER_REGULAR_PASS)
 from rhodecode.tests.fixtures.rc_fixture import Fixture, error_function
 from rhodecode.tests.utils import repo_on_filesystem
 from rhodecode.tests.routes import route_path
 
 fixture = Fixture()
 
 
 def _get_permission_for_user(user, repo):
     perm = UserRepoToPerm.query()\
         .filter(UserRepoToPerm.repository ==
                 Repository.get_by_repo_name(repo))\
         .filter(UserRepoToPerm.user == User.get_by_username(user))\
         .all()
     return perm
 
 
 @pytest.mark.usefixtures("app")
 class TestAdminRepos(object):
 
     def test_repo_list(self, autologin_user, user_util, xhr_header):
         repo = user_util.create_repo()
         repo_name = repo.repo_name
         response = self.app.get(
             route_path('repos_data'), status=200,
             extra_environ=xhr_header)
 
         response.mustcontain(repo_name)
 
     def test_create_page_restricted_to_single_backend(self, autologin_user, backend):
         with mock.patch('rhodecode.BACKENDS', {'git': 'git'}):
             response = self.app.get(route_path('repo_new'), status=200)
         assert_response = response.assert_response()
         element = assert_response.get_element('[name=repo_type]')
         assert element.get('value') == 'git'
 
     def test_create_page_non_restricted_backends(self, autologin_user, backend):
         response = self.app.get(route_path('repo_new'), status=200)
         assert_response = response.assert_response()
         assert ['hg', 'git', 'svn'] == [x.get('value') for x in assert_response.get_elements('[name=repo_type]')]
 
     @pytest.mark.parametrize(
         "suffix", ['', 'xxa'], ids=['', 'non-ascii'])
     def test_create(self, autologin_user, backend, suffix, csrf_token):
         repo_name_unicode = backend.new_repo_name(suffix=suffix)
         repo_name = repo_name_unicode
 
         description_unicode = 'description for newly created repo' + suffix
         description = description_unicode
 
         response = self.app.post(
             route_path('repo_create'),
             fixture._get_repo_create_params(
                 repo_private=False,
                 repo_name=repo_name,
                 repo_type=backend.alias,
                 repo_description=description,
                 csrf_token=csrf_token),
             status=302)
 
         self.assert_repository_is_created_correctly(
             repo_name, description, backend)
 
     def test_create_numeric_name(self, autologin_user, backend, csrf_token):
         numeric_repo = '1234'
         repo_name = numeric_repo
         description = 'description for newly created repo' + numeric_repo
         self.app.post(
             route_path('repo_create'),
             fixture._get_repo_create_params(
                 repo_private=False,
                 repo_name=repo_name,
                 repo_type=backend.alias,
                 repo_description=description,
                 csrf_token=csrf_token))
-
-        self.assert_repository_is_created_correctly(
-            repo_name, description, backend)
+        try:
+            self.assert_repository_is_created_correctly(repo_name, description, backend)
+        finally:
+            RepoModel().delete(numeric_repo)
+            Session().commit()
 
     @pytest.mark.parametrize("suffix", ['', '_ąćę'], ids=['', 'non-ascii'])
     def test_create_in_group(
             self, autologin_user, backend, suffix, csrf_token):
         # create GROUP
         group_name = f'sometest_{backend.alias}'
         gr = RepoGroupModel().create(group_name=group_name,
                                      group_description='test',
                                      owner=TEST_USER_ADMIN_LOGIN)
         Session().commit()
 
         repo_name = f'ingroup{suffix}'
         repo_name_full = RepoGroup.url_sep().join([group_name, repo_name])
         description = 'description for newly created repo'
 
         self.app.post(
             route_path('repo_create'),
             fixture._get_repo_create_params(
                 repo_private=False,
                 repo_name=safe_str(repo_name),
                 repo_type=backend.alias,
                 repo_description=description,
                 repo_group=gr.group_id,
                 csrf_token=csrf_token))
 
         # TODO: johbo: Cleanup work to fixture
         try:
             self.assert_repository_is_created_correctly(
                 repo_name_full, description, backend)
 
             new_repo = RepoModel().get_by_repo_name(repo_name_full)
             inherited_perms = UserRepoToPerm.query().filter(
                 UserRepoToPerm.repository_id == new_repo.repo_id).all()
             assert len(inherited_perms) == 1
         finally:
             RepoModel().delete(repo_name_full)
             RepoGroupModel().delete(group_name)
             Session().commit()
 
     def test_create_in_group_numeric_name(
             self, autologin_user, backend, csrf_token):
         # create GROUP
         group_name = 'sometest_%s' % backend.alias
         gr = RepoGroupModel().create(group_name=group_name,
                                      group_description='test',
                                      owner=TEST_USER_ADMIN_LOGIN)
         Session().commit()
 
         repo_name = '12345'
         repo_name_full = RepoGroup.url_sep().join([group_name, repo_name])
         description = 'description for newly created repo'
         self.app.post(
             route_path('repo_create'),
             fixture._get_repo_create_params(
                 repo_private=False,
                 repo_name=repo_name,
                 repo_type=backend.alias,
                 repo_description=description,
                 repo_group=gr.group_id,
                 csrf_token=csrf_token))
 
         # TODO: johbo: Cleanup work to fixture
         try:
             self.assert_repository_is_created_correctly(
                 repo_name_full, description, backend)
 
             new_repo = RepoModel().get_by_repo_name(repo_name_full)
             inherited_perms = UserRepoToPerm.query()\
                 .filter(UserRepoToPerm.repository_id == new_repo.repo_id).all()
             assert len(inherited_perms) == 1
         finally:
             RepoModel().delete(repo_name_full)
             RepoGroupModel().delete(group_name)
             Session().commit()
 
     def test_create_in_group_without_needed_permissions(self, backend):
         session = login_user_session(
             self.app, TEST_USER_REGULAR_LOGIN, TEST_USER_REGULAR_PASS)
         csrf_token = auth.get_csrf_token(session)
         # revoke
         user_model = UserModel()
         # disable fork and create on default user
         user_model.revoke_perm(User.DEFAULT_USER, 'hg.create.repository')
         user_model.grant_perm(User.DEFAULT_USER, 'hg.create.none')
         user_model.revoke_perm(User.DEFAULT_USER, 'hg.fork.repository')
         user_model.grant_perm(User.DEFAULT_USER, 'hg.fork.none')
 
         # disable on regular user
         user_model.revoke_perm(TEST_USER_REGULAR_LOGIN, 'hg.create.repository')
         user_model.grant_perm(TEST_USER_REGULAR_LOGIN, 'hg.create.none')
         user_model.revoke_perm(TEST_USER_REGULAR_LOGIN, 'hg.fork.repository')
         user_model.grant_perm(TEST_USER_REGULAR_LOGIN, 'hg.fork.none')
         Session().commit()
 
         # create GROUP
         group_name = 'reg_sometest_%s' % backend.alias
         gr = RepoGroupModel().create(group_name=group_name,
                                      group_description='test',
                                      owner=TEST_USER_ADMIN_LOGIN)
         Session().commit()
         repo_group_id = gr.group_id
 
         group_name_allowed = 'reg_sometest_allowed_%s' % backend.alias
         gr_allowed = RepoGroupModel().create(
             group_name=group_name_allowed,
             group_description='test',
             owner=TEST_USER_REGULAR_LOGIN)
         allowed_repo_group_id = gr_allowed.group_id
         Session().commit()
 
         repo_name = 'ingroup'
         description = 'description for newly created repo'
         response = self.app.post(
             route_path('repo_create'),
             fixture._get_repo_create_params(
                 repo_private=False,
                 repo_name=repo_name,
                 repo_type=backend.alias,
                 repo_description=description,
                 repo_group=repo_group_id,
                 csrf_token=csrf_token))
 
         response.mustcontain('Invalid value')
 
         # user is allowed to create in this group
         repo_name = 'ingroup'
         repo_name_full = RepoGroup.url_sep().join(
             [group_name_allowed, repo_name])
         description = 'description for newly created repo'
         response = self.app.post(
             route_path('repo_create'),
             fixture._get_repo_create_params(
                 repo_private=False,
                 repo_name=repo_name,
                 repo_type=backend.alias,
                 repo_description=description,
                 repo_group=allowed_repo_group_id,
                 csrf_token=csrf_token))
 
         # TODO: johbo: Cleanup in pytest fixture
         try:
             self.assert_repository_is_created_correctly(
                 repo_name_full, description, backend)
 
             new_repo = RepoModel().get_by_repo_name(repo_name_full)
             inherited_perms = UserRepoToPerm.query().filter(
                 UserRepoToPerm.repository_id == new_repo.repo_id).all()
             assert len(inherited_perms) == 1
 
             assert repo_on_filesystem(repo_name_full)
         finally:
             RepoModel().delete(repo_name_full)
             RepoGroupModel().delete(group_name)
             RepoGroupModel().delete(group_name_allowed)
             Session().commit()
 
     def test_create_in_group_inherit_permissions(self, autologin_user, backend,
                                                  csrf_token):
         # create GROUP
         group_name = 'sometest_%s' % backend.alias
         gr = RepoGroupModel().create(group_name=group_name,
                                      group_description='test',
                                      owner=TEST_USER_ADMIN_LOGIN)
         perm = Permission.get_by_key('repository.write')
         RepoGroupModel().grant_user_permission(
             gr, TEST_USER_REGULAR_LOGIN, perm)
 
         # add repo permissions
         Session().commit()
         repo_group_id = gr.group_id
         repo_name = 'ingroup_inherited_%s' % backend.alias
         repo_name_full = RepoGroup.url_sep().join([group_name, repo_name])
         description = 'description for newly created repo'
         self.app.post(
             route_path('repo_create'),
             fixture._get_repo_create_params(
                 repo_private=False,
                 repo_name=repo_name,
                 repo_type=backend.alias,
                 repo_description=description,
                 repo_group=repo_group_id,
                 repo_copy_permissions=True,
                 csrf_token=csrf_token))
 
         # TODO: johbo: Cleanup to pytest fixture
         try:
             self.assert_repository_is_created_correctly(
                 repo_name_full, description, backend)
         except Exception:
             RepoGroupModel().delete(group_name)
             Session().commit()
             raise
 
         # check if inherited permissions are applied
         new_repo = RepoModel().get_by_repo_name(repo_name_full)
         inherited_perms = UserRepoToPerm.query().filter(
             UserRepoToPerm.repository_id == new_repo.repo_id).all()
         assert len(inherited_perms) == 2
 
         assert TEST_USER_REGULAR_LOGIN in [
             x.user.username for x in inherited_perms]
         assert 'repository.write' in [
             x.permission.permission_name for x in inherited_perms]
 
         RepoModel().delete(repo_name_full)
         RepoGroupModel().delete(group_name)
         Session().commit()
 
     @pytest.mark.xfail_backends(
         "git", "hg", reason="Missing reposerver support")
     def test_create_with_clone_uri(self, autologin_user, backend, reposerver,
                                    csrf_token):
         source_repo = backend.create_repo(number_of_commits=2)
         source_repo_name = source_repo.repo_name
         reposerver.serve(source_repo.scm_instance())
 
         repo_name = backend.new_repo_name()
         response = self.app.post(
             route_path('repo_create'),
             fixture._get_repo_create_params(
                 repo_private=False,
                 repo_name=repo_name,
                 repo_type=backend.alias,
                 repo_description='',
                 clone_uri=reposerver.url,
                 csrf_token=csrf_token),
             status=302)
 
         # Should be redirected to the creating page
         response.mustcontain('repo_creating')
 
         # Expecting that both repositories have same history
         source_repo = RepoModel().get_by_repo_name(source_repo_name)
         source_vcs = source_repo.scm_instance()
         repo = RepoModel().get_by_repo_name(repo_name)
         repo_vcs = repo.scm_instance()
         assert source_vcs[0].message == repo_vcs[0].message
         assert source_vcs.count() == repo_vcs.count()
         assert source_vcs.commit_ids == repo_vcs.commit_ids
 
     @pytest.mark.xfail_backends("svn", reason="Depends on import support")
     def test_create_remote_repo_wrong_clone_uri(self, autologin_user, backend,
                                                 csrf_token):
         repo_name = backend.new_repo_name()
         description = 'description for newly created repo'
         response = self.app.post(
             route_path('repo_create'),
             fixture._get_repo_create_params(
                 repo_private=False,
                 repo_name=repo_name,
                 repo_type=backend.alias,
                 repo_description=description,
                 clone_uri='http://repo.invalid/repo',
                 csrf_token=csrf_token))
         response.mustcontain('invalid clone url')
 
     @pytest.mark.xfail_backends("svn", reason="Depends on import support")
     def test_create_remote_repo_wrong_clone_uri_hg_svn(
             self, autologin_user, backend, csrf_token):
         repo_name = backend.new_repo_name()
         description = 'description for newly created repo'
         response = self.app.post(
             route_path('repo_create'),
             fixture._get_repo_create_params(
                 repo_private=False,
                 repo_name=repo_name,
                 repo_type=backend.alias,
                 repo_description=description,
                 clone_uri='svn+http://svn.invalid/repo',
                 csrf_token=csrf_token))
         response.mustcontain('invalid clone url')
 
     def test_create_with_git_suffix(
             self, autologin_user, backend, csrf_token):
         repo_name = backend.new_repo_name() + ".git"
         description = 'description for newly created repo'
         response = self.app.post(
             route_path('repo_create'),
             fixture._get_repo_create_params(
                 repo_private=False,
                 repo_name=repo_name,
                 repo_type=backend.alias,
                 repo_description=description,
                 csrf_token=csrf_token))
         response.mustcontain('Repository name cannot end with .git')
 
     def test_default_user_cannot_access_private_repo_in_a_group(
             self, autologin_user, user_util, backend):
 
         group = user_util.create_repo_group()
 
         repo = backend.create_repo(
             repo_private=True, repo_group=group, repo_copy_permissions=True)
 
         permissions = _get_permission_for_user(
             user='default', repo=repo.repo_name)
         assert len(permissions) == 1
         assert permissions[0].permission.permission_name == 'repository.none'
         assert permissions[0].repository.private is True
 
     def test_create_on_top_level_without_permissions(self, backend):
         session = login_user_session(
             self.app, TEST_USER_REGULAR_LOGIN, TEST_USER_REGULAR_PASS)
         csrf_token = auth.get_csrf_token(session)
 
         # revoke
         user_model = UserModel()
         # disable fork and create on default user
         user_model.revoke_perm(User.DEFAULT_USER, 'hg.create.repository')
         user_model.grant_perm(User.DEFAULT_USER, 'hg.create.none')
         user_model.revoke_perm(User.DEFAULT_USER, 'hg.fork.repository')
         user_model.grant_perm(User.DEFAULT_USER, 'hg.fork.none')
 
         # disable on regular user
         user_model.revoke_perm(TEST_USER_REGULAR_LOGIN, 'hg.create.repository')
         user_model.grant_perm(TEST_USER_REGULAR_LOGIN, 'hg.create.none')
         user_model.revoke_perm(TEST_USER_REGULAR_LOGIN, 'hg.fork.repository')
         user_model.grant_perm(TEST_USER_REGULAR_LOGIN, 'hg.fork.none')
         Session().commit()
 
         repo_name = backend.new_repo_name()
         description = 'description for newly created repo'
         response = self.app.post(
             route_path('repo_create'),
             fixture._get_repo_create_params(
                 repo_private=False,
                 repo_name=repo_name,
                 repo_type=backend.alias,
                 repo_description=description,
                 csrf_token=csrf_token))
 
         response.mustcontain(
             "You do not have the permission to store repositories in "
             "the root location.")
 
     @mock.patch.object(RepoModel, '_create_filesystem_repo', error_function)
     def test_create_repo_when_filesystem_op_fails(
             self, autologin_user, backend, csrf_token):
         repo_name = backend.new_repo_name()
         description = 'description for newly created repo'
 
         response = self.app.post(
             route_path('repo_create'),
             fixture._get_repo_create_params(
                 repo_private=False,
                 repo_name=repo_name,
                 repo_type=backend.alias,
                 repo_description=description,
                 csrf_token=csrf_token))
 
         assert_session_flash(
             response, 'Error creating repository %s' % repo_name)
         # repo must not be in db
         assert backend.repo is None
         # repo must not be in filesystem !
         assert not repo_on_filesystem(repo_name)
 
     def assert_repository_is_created_correctly(self, repo_name, description, backend):
         url_quoted_repo_name = urllib.parse.quote(repo_name)
 
         # run the check page that triggers the flash message
         response = self.app.get(
             route_path('repo_creating_check', repo_name=repo_name))
         assert response.json == {'result': True}
 
         flash_msg = 'Created repository <a href="/{}">{}</a>'.format(url_quoted_repo_name, repo_name)
         assert_session_flash(response, flash_msg)
 
         # test if the repo was created in the database
         new_repo = RepoModel().get_by_repo_name(repo_name)
 
         assert new_repo.repo_name == repo_name
         assert new_repo.description == description
 
         # test if the repository is visible in the list ?
         response = self.app.get(
             h.route_path('repo_summary', repo_name=repo_name))
         response.mustcontain(repo_name)
         response.mustcontain(backend.alias)
 
         assert repo_on_filesystem(repo_name)

rhodecode/apps/admin/views/settings.py

@@ -1,716 +1,733 b''
 # Copyright (C) 2010-2024 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 logging
 import collections
 
 import datetime
 import formencode
 import formencode.htmlfill
 
 import rhodecode
 
 from pyramid.httpexceptions import HTTPFound, HTTPNotFound
 from pyramid.renderers import render
 from pyramid.response import Response
 
 from rhodecode.apps._base import BaseAppView
 from rhodecode.apps._base.navigation import navigation_list
 from rhodecode.apps.svn_support import config_keys
 from rhodecode.lib import helpers as h
 from rhodecode.lib.auth import (
     LoginRequired, HasPermissionAllDecorator, CSRFRequired)
 from rhodecode.lib.celerylib import tasks, run_task
 from rhodecode.lib.str_utils import safe_str
-from rhodecode.lib.utils import repo2db_mapper, get_rhodecode_repo_store_path
+from rhodecode.lib.utils import repo2db_mapper, get_rhodecode_repo_store_path, repo2db_cleanup
 from rhodecode.lib.utils2 import str2bool, AttributeDict
 from rhodecode.lib.index import searcher_from_config
 
 from rhodecode.model.db import RhodeCodeUi, Repository
 from rhodecode.model.forms import (ApplicationSettingsForm,
     ApplicationUiSettingsForm, ApplicationVisualisationForm,
     LabsSettingsForm, IssueTrackerPatternsForm)
 from rhodecode.model.permission import PermissionModel
 from rhodecode.model.repo_group import RepoGroupModel
 
 from rhodecode.model.scm import ScmModel
 from rhodecode.model.notification import EmailNotificationModel
 from rhodecode.model.meta import Session
 from rhodecode.model.settings import (
     IssueTrackerSettingsModel, VcsSettingsModel, SettingNotFound,
     SettingsModel)
 
 
 log = logging.getLogger(__name__)
 
 
 class AdminSettingsView(BaseAppView):
 
     def load_default_context(self):
         c = self._get_local_tmpl_context()
         c.labs_active = str2bool(
             rhodecode.CONFIG.get('labs_settings_active', 'true'))
         c.navlist = navigation_list(self.request)
         return c
 
     @classmethod
     def _get_ui_settings(cls):
         ret = RhodeCodeUi.query().all()
 
         if not ret:
             raise Exception('Could not get application ui settings !')
         settings = {
             # legacy param that needs to be kept
             'web_push_ssl': False,
             'extensions_hgsubversion': False
         }
         for each in ret:
             k = each.ui_key
             v = each.ui_value
             section = each.ui_section
 
             # skip some options if they are defined
             if f"{section}_{k}" in ['web_push_ssl', 'extensions_hgsubversion']:
                 continue
 
             if k == '/':
                 k = 'root_path'
 
             if k in ['publish', 'enabled']:
                 v = str2bool(v)
 
             if k.find('.') != -1:
                 k = k.replace('.', '_')
 
             if each.ui_section in ['hooks', 'extensions']:
                 v = each.ui_active
 
             settings[section + '_' + k] = v
 
         return settings
 
     @classmethod
     def _form_defaults(cls):
         defaults = SettingsModel().get_all_settings()
         defaults.update(cls._get_ui_settings())
 
         defaults.update({
             'new_svn_branch': '',
             'new_svn_tag': '',
         })
         return defaults
 
     @LoginRequired()
     @HasPermissionAllDecorator('hg.admin')
     def settings_vcs(self):
         c = self.load_default_context()
         c.active = 'vcs'
         model = VcsSettingsModel()
         c.svn_branch_patterns = model.get_global_svn_branch_patterns()
         c.svn_tag_patterns = model.get_global_svn_tag_patterns()
         c.svn_generate_config = rhodecode.ConfigGet().get_bool(config_keys.generate_config)
         c.svn_config_path = rhodecode.ConfigGet().get_str(config_keys.config_file_path)
         defaults = self._form_defaults()
 
         data = render('rhodecode:templates/admin/settings/settings.mako',
                       self._get_template_context(c), self.request)
         html = formencode.htmlfill.render(
             data,
             defaults=defaults,
             encoding="UTF-8",
             force_defaults=False
         )
         return Response(html)
 
     @LoginRequired()
     @HasPermissionAllDecorator('hg.admin')
     @CSRFRequired()
     def settings_vcs_update(self):
         _ = self.request.translate
         c = self.load_default_context()
         c.active = 'vcs'
 
         model = VcsSettingsModel()
         c.svn_branch_patterns = model.get_global_svn_branch_patterns()
         c.svn_tag_patterns = model.get_global_svn_tag_patterns()
 
         c.svn_generate_config = rhodecode.ConfigGet().get_bool(config_keys.generate_config)
         c.svn_config_path = rhodecode.ConfigGet().get_str(config_keys.config_file_path)
         application_form = ApplicationUiSettingsForm(self.request.translate)()
 
         try:
             form_result = application_form.to_python(dict(self.request.POST))
         except formencode.Invalid as errors:
             h.flash(
                 _("Some form inputs contain invalid data."),
                 category='error')
             data = render('rhodecode:templates/admin/settings/settings.mako',
                           self._get_template_context(c), self.request)
             html = formencode.htmlfill.render(
                 data,
                 defaults=errors.value,
                 errors=errors.unpack_errors() or {},
                 prefix_error=False,
                 encoding="UTF-8",
                 force_defaults=False
             )
             return Response(html)
 
         try:
             model.update_global_hook_settings(form_result)
 
             model.create_or_update_global_svn_settings(form_result)
             model.create_or_update_global_hg_settings(form_result)
             model.create_or_update_global_git_settings(form_result)
             model.create_or_update_global_pr_settings(form_result)
         except Exception:
             log.exception("Exception while updating settings")
             h.flash(_('Error occurred during updating '
                       'application settings'), category='error')
         else:
             Session().commit()
             h.flash(_('Updated VCS settings'), category='success')
             raise HTTPFound(h.route_path('admin_settings_vcs'))
 
         data = render('rhodecode:templates/admin/settings/settings.mako',
                       self._get_template_context(c), self.request)
         html = formencode.htmlfill.render(
             data,
             defaults=self._form_defaults(),
             encoding="UTF-8",
             force_defaults=False
         )
         return Response(html)
 
     @LoginRequired()
     @HasPermissionAllDecorator('hg.admin')
     @CSRFRequired()
     def settings_vcs_delete_svn_pattern(self):
         delete_pattern_id = self.request.POST.get('delete_svn_pattern')
         model = VcsSettingsModel()
         try:
             model.delete_global_svn_pattern(delete_pattern_id)
         except SettingNotFound:
             log.exception(
                 'Failed to delete svn_pattern with id %s', delete_pattern_id)
             raise HTTPNotFound()
 
         Session().commit()
         return True
 
     @LoginRequired()
     @HasPermissionAllDecorator('hg.admin')
     def settings_mapping(self):
         c = self.load_default_context()
         c.active = 'mapping'
         c.storage_path = get_rhodecode_repo_store_path()
         data = render('rhodecode:templates/admin/settings/settings.mako',
                       self._get_template_context(c), self.request)
         html = formencode.htmlfill.render(
             data,
             defaults=self._form_defaults(),
             encoding="UTF-8",
             force_defaults=False
         )
         return Response(html)
 
     @LoginRequired()
     @HasPermissionAllDecorator('hg.admin')
     @CSRFRequired()
-    def settings_mapping_update(self):
+    def settings_mapping_create(self):
         _ = self.request.translate
         c = self.load_default_context()
         c.active = 'mapping'
-        rm_obsolete = self.request.POST.get('destroy', False)
         invalidate_cache = self.request.POST.get('invalidate', False)
-        log.debug('rescanning repo location with destroy obsolete=%s', rm_obsolete)
+        log.debug('rescanning repo location')
 
         if invalidate_cache:
             log.debug('invalidating all repositories cache')
             for repo in Repository.get_all():
                 ScmModel().mark_for_invalidation(repo.repo_name, delete=True)
 
         filesystem_repos = ScmModel().repo_scan()
-        added, removed = repo2db_mapper(filesystem_repos, rm_obsolete, force_hooks_rebuild=True)
+        added, errors = repo2db_mapper(filesystem_repos, force_hooks_rebuild=True)
         PermissionModel().trigger_permission_flush()
 
         def _repr(rm_repo):
             return ', '.join(map(safe_str, rm_repo)) or '-'
 
-        h.flash(_('Repositories successfully '
-                  'rescanned added: %s ; removed: %s') %
-                (_repr(added), _repr(removed)),
-                category='success')
+        if errors:
+            h.flash(_('Errors during scan: {}').format(_repr(errors), ), category='error')
+
+        h.flash(_('Repositories successfully scanned: Added: {}').format(_repr(added)), category='success')
+        raise HTTPFound(h.route_path('admin_settings_mapping'))
+
+    @LoginRequired()
+    @HasPermissionAllDecorator('hg.admin')
+    @CSRFRequired()
+    def settings_mapping_cleanup(self):
+        _ = self.request.translate
+        c = self.load_default_context()
+        c.active = 'mapping'
+        log.debug('rescanning repo location')
+
+        removed, errors = repo2db_cleanup()
+        PermissionModel().trigger_permission_flush()
+
+        def _repr(rm_repo):
+            return ', '.join(map(safe_str, rm_repo)) or '-'
+
+        h.flash(_('Repositories successfully scanned: Errors: {}, Added: {}').format(errors, _repr(removed)), category='success')
         raise HTTPFound(h.route_path('admin_settings_mapping'))
 
     @LoginRequired()
     @HasPermissionAllDecorator('hg.admin')
     def settings_global(self):
         c = self.load_default_context()
         c.active = 'global'
         c.personal_repo_group_default_pattern = RepoGroupModel()\
             .get_personal_group_name_pattern()
 
         data = render('rhodecode:templates/admin/settings/settings.mako',
                       self._get_template_context(c), self.request)
         html = formencode.htmlfill.render(
             data,
             defaults=self._form_defaults(),
             encoding="UTF-8",
             force_defaults=False
         )
         return Response(html)
 
     @LoginRequired()
     @HasPermissionAllDecorator('hg.admin')
     @CSRFRequired()
     def settings_global_update(self):
         _ = self.request.translate
         c = self.load_default_context()
         c.active = 'global'
         c.personal_repo_group_default_pattern = RepoGroupModel()\
             .get_personal_group_name_pattern()
         application_form = ApplicationSettingsForm(self.request.translate)()
         try:
             form_result = application_form.to_python(dict(self.request.POST))
         except formencode.Invalid as errors:
             h.flash(
                 _("Some form inputs contain invalid data."),
                 category='error')
             data = render('rhodecode:templates/admin/settings/settings.mako',
                           self._get_template_context(c), self.request)
             html = formencode.htmlfill.render(
                 data,
                 defaults=errors.value,
                 errors=errors.unpack_errors() or {},
                 prefix_error=False,
                 encoding="UTF-8",
                 force_defaults=False
             )
             return Response(html)
 
         settings = [
             ('title', 'rhodecode_title', 'unicode'),
             ('realm', 'rhodecode_realm', 'unicode'),
             ('pre_code', 'rhodecode_pre_code', 'unicode'),
             ('post_code', 'rhodecode_post_code', 'unicode'),
             ('captcha_public_key', 'rhodecode_captcha_public_key', 'unicode'),
             ('captcha_private_key', 'rhodecode_captcha_private_key', 'unicode'),
             ('create_personal_repo_group', 'rhodecode_create_personal_repo_group', 'bool'),
             ('personal_repo_group_pattern', 'rhodecode_personal_repo_group_pattern', 'unicode'),
         ]
 
         try:
             for setting, form_key, type_ in settings:
                 sett = SettingsModel().create_or_update_setting(
                     setting, form_result[form_key], type_)
                 Session().add(sett)
 
             Session().commit()
             SettingsModel().invalidate_settings_cache()
             h.flash(_('Updated application settings'), category='success')
         except Exception:
             log.exception("Exception while updating application settings")
             h.flash(
                 _('Error occurred during updating application settings'),
                 category='error')
 
         raise HTTPFound(h.route_path('admin_settings_global'))
 
     @LoginRequired()
     @HasPermissionAllDecorator('hg.admin')
     def settings_visual(self):
         c = self.load_default_context()
         c.active = 'visual'
 
         data = render('rhodecode:templates/admin/settings/settings.mako',
                       self._get_template_context(c), self.request)
         html = formencode.htmlfill.render(
             data,
             defaults=self._form_defaults(),
             encoding="UTF-8",
             force_defaults=False
         )
         return Response(html)
 
     @LoginRequired()
     @HasPermissionAllDecorator('hg.admin')
     @CSRFRequired()
     def settings_visual_update(self):
         _ = self.request.translate
         c = self.load_default_context()
         c.active = 'visual'
         application_form = ApplicationVisualisationForm(self.request.translate)()
         try:
             form_result = application_form.to_python(dict(self.request.POST))
         except formencode.Invalid as errors:
             h.flash(
                 _("Some form inputs contain invalid data."),
                 category='error')
             data = render('rhodecode:templates/admin/settings/settings.mako',
                           self._get_template_context(c), self.request)
             html = formencode.htmlfill.render(
                 data,
                 defaults=errors.value,
                 errors=errors.unpack_errors() or {},
                 prefix_error=False,
                 encoding="UTF-8",
                 force_defaults=False
             )
             return Response(html)
 
         try:
             settings = [
                 ('show_public_icon', 'rhodecode_show_public_icon', 'bool'),
                 ('show_private_icon', 'rhodecode_show_private_icon', 'bool'),
                 ('stylify_metatags', 'rhodecode_stylify_metatags', 'bool'),
                 ('repository_fields', 'rhodecode_repository_fields', 'bool'),
                 ('dashboard_items', 'rhodecode_dashboard_items', 'int'),
                 ('admin_grid_items', 'rhodecode_admin_grid_items', 'int'),
                 ('show_version', 'rhodecode_show_version', 'bool'),
                 ('use_gravatar', 'rhodecode_use_gravatar', 'bool'),
                 ('markup_renderer', 'rhodecode_markup_renderer', 'unicode'),
                 ('gravatar_url', 'rhodecode_gravatar_url', 'unicode'),
                 ('clone_uri_tmpl', 'rhodecode_clone_uri_tmpl', 'unicode'),
                 ('clone_uri_id_tmpl', 'rhodecode_clone_uri_id_tmpl', 'unicode'),
                 ('clone_uri_ssh_tmpl', 'rhodecode_clone_uri_ssh_tmpl', 'unicode'),
                 ('support_url', 'rhodecode_support_url', 'unicode'),
                 ('show_revision_number', 'rhodecode_show_revision_number', 'bool'),
                 ('show_sha_length', 'rhodecode_show_sha_length', 'int'),
             ]
             for setting, form_key, type_ in settings:
                 sett = SettingsModel().create_or_update_setting(
                     setting, form_result[form_key], type_)
                 Session().add(sett)
 
             Session().commit()
             SettingsModel().invalidate_settings_cache()
             h.flash(_('Updated visualisation settings'), category='success')
         except Exception:
             log.exception("Exception updating visualization settings")
             h.flash(_('Error occurred during updating '
                       'visualisation settings'),
                     category='error')
 
         raise HTTPFound(h.route_path('admin_settings_visual'))
 
     @LoginRequired()
     @HasPermissionAllDecorator('hg.admin')
     def settings_issuetracker(self):
         c = self.load_default_context()
         c.active = 'issuetracker'
         defaults = c.rc_config
 
         entry_key = 'rhodecode_issuetracker_pat_'
 
         c.issuetracker_entries = {}
         for k, v in defaults.items():
             if k.startswith(entry_key):
                 uid = k[len(entry_key):]
                 c.issuetracker_entries[uid] = None
 
         for uid in c.issuetracker_entries:
             c.issuetracker_entries[uid] = AttributeDict({
                 'pat': defaults.get('rhodecode_issuetracker_pat_' + uid),
                 'url': defaults.get('rhodecode_issuetracker_url_' + uid),
                 'pref': defaults.get('rhodecode_issuetracker_pref_' + uid),
                 'desc': defaults.get('rhodecode_issuetracker_desc_' + uid),
             })
 
         return self._get_template_context(c)
 
     @LoginRequired()
     @HasPermissionAllDecorator('hg.admin')
     @CSRFRequired()
     def settings_issuetracker_test(self):
         error_container = []
 
         urlified_commit = h.urlify_commit_message(
             self.request.POST.get('test_text', ''),
             'repo_group/test_repo1', error_container=error_container)
         if error_container:
             def converter(inp):
                 return h.html_escape(inp)
 
             return 'ERRORS: ' + '\n'.join(map(converter, error_container))
 
         return urlified_commit
 
     @LoginRequired()
     @HasPermissionAllDecorator('hg.admin')
     @CSRFRequired()
     def settings_issuetracker_update(self):
         _ = self.request.translate
         self.load_default_context()
         settings_model = IssueTrackerSettingsModel()
 
         try:
             form = IssueTrackerPatternsForm(self.request.translate)()
             data = form.to_python(self.request.POST)
         except formencode.Invalid as errors:
             log.exception('Failed to add new pattern')
             error = errors
             h.flash(_(f'Invalid issue tracker pattern: {error}'),
                     category='error')
             raise HTTPFound(h.route_path('admin_settings_issuetracker'))
 
         if data:
             for uid in data.get('delete_patterns', []):
                 settings_model.delete_entries(uid)
 
             for pattern in data.get('patterns', []):
                 for setting, value, type_ in pattern:
                     sett = settings_model.create_or_update_setting(
                         setting, value, type_)
                     Session().add(sett)
 
                 Session().commit()
 
             SettingsModel().invalidate_settings_cache()
             h.flash(_('Updated issue tracker entries'), category='success')
         raise HTTPFound(h.route_path('admin_settings_issuetracker'))
 
     @LoginRequired()
     @HasPermissionAllDecorator('hg.admin')
     @CSRFRequired()
     def settings_issuetracker_delete(self):
         _ = self.request.translate
         self.load_default_context()
         uid = self.request.POST.get('uid')
         try:
             IssueTrackerSettingsModel().delete_entries(uid)
         except Exception:
             log.exception('Failed to delete issue tracker setting %s', uid)
             raise HTTPNotFound()
 
         SettingsModel().invalidate_settings_cache()
         h.flash(_('Removed issue tracker entry.'), category='success')
 
         return {'deleted': uid}
 
     @LoginRequired()
     @HasPermissionAllDecorator('hg.admin')
     def settings_email(self):
         c = self.load_default_context()
         c.active = 'email'
         c.rhodecode_ini = rhodecode.CONFIG
 
         data = render('rhodecode:templates/admin/settings/settings.mako',
                       self._get_template_context(c), self.request)
         html = formencode.htmlfill.render(
             data,
             defaults=self._form_defaults(),
             encoding="UTF-8",
             force_defaults=False
         )
         return Response(html)
 
     @LoginRequired()
     @HasPermissionAllDecorator('hg.admin')
     @CSRFRequired()
     def settings_email_update(self):
         _ = self.request.translate
         c = self.load_default_context()
         c.active = 'email'
 
         test_email = self.request.POST.get('test_email')
 
         if not test_email:
             h.flash(_('Please enter email address'), category='error')
             raise HTTPFound(h.route_path('admin_settings_email'))
 
         email_kwargs = {
             'date': datetime.datetime.now(),
             'user': self._rhodecode_db_user
         }
 
         (subject, email_body, email_body_plaintext) = EmailNotificationModel().render_email(
             EmailNotificationModel.TYPE_EMAIL_TEST, **email_kwargs)
 
         recipients = [test_email] if test_email else None
 
         run_task(tasks.send_email, recipients, subject,
                  email_body_plaintext, email_body)
 
         h.flash(_('Send email task created'), category='success')
         raise HTTPFound(h.route_path('admin_settings_email'))
 
     @LoginRequired()
     @HasPermissionAllDecorator('hg.admin')
     def settings_hooks(self):
         c = self.load_default_context()
         c.active = 'hooks'
 
         model = SettingsModel()
         c.hooks = model.get_builtin_hooks()
         c.custom_hooks = model.get_custom_hooks()
 
         data = render('rhodecode:templates/admin/settings/settings.mako',
                       self._get_template_context(c), self.request)
         html = formencode.htmlfill.render(
             data,
             defaults=self._form_defaults(),
             encoding="UTF-8",
             force_defaults=False
         )
         return Response(html)
 
     @LoginRequired()
     @HasPermissionAllDecorator('hg.admin')
     @CSRFRequired()
     def settings_hooks_update(self):
         _ = self.request.translate
         c = self.load_default_context()
         c.active = 'hooks'
         if c.visual.allow_custom_hooks_settings:
             ui_key = self.request.POST.get('new_hook_ui_key')
             ui_value = self.request.POST.get('new_hook_ui_value')
 
             hook_id = self.request.POST.get('hook_id')
             new_hook = False
 
             model = SettingsModel()
             try:
                 if ui_value and ui_key:
                     model.create_or_update_hook(ui_key, ui_value)
                     h.flash(_('Added new hook'), category='success')
                     new_hook = True
                 elif hook_id:
                     RhodeCodeUi.delete(hook_id)
                     Session().commit()
 
                 # check for edits
                 update = False
                 _d = self.request.POST.dict_of_lists()
                 for k, v in zip(_d.get('hook_ui_key', []),
                                 _d.get('hook_ui_value_new', [])):
                     model.create_or_update_hook(k, v)
                     update = True
 
                 if update and not new_hook:
                     h.flash(_('Updated hooks'), category='success')
                 Session().commit()
             except Exception:
                 log.exception("Exception during hook creation")
                 h.flash(_('Error occurred during hook creation'),
                         category='error')
 
         raise HTTPFound(h.route_path('admin_settings_hooks'))
 
     @LoginRequired()
     @HasPermissionAllDecorator('hg.admin')
     def settings_search(self):
         c = self.load_default_context()
         c.active = 'search'
 
         c.searcher = searcher_from_config(self.request.registry.settings)
         c.statistics = c.searcher.statistics(self.request.translate)
 
         return self._get_template_context(c)
 
     @LoginRequired()
     @HasPermissionAllDecorator('hg.admin')
     def settings_labs(self):
         c = self.load_default_context()
         if not c.labs_active:
             raise HTTPFound(h.route_path('admin_settings'))
 
         c.active = 'labs'
         c.lab_settings = _LAB_SETTINGS
 
         data = render('rhodecode:templates/admin/settings/settings.mako',
                       self._get_template_context(c), self.request)
         html = formencode.htmlfill.render(
             data,
             defaults=self._form_defaults(),
             encoding="UTF-8",
             force_defaults=False
         )
         return Response(html)
 
     @LoginRequired()
     @HasPermissionAllDecorator('hg.admin')
     @CSRFRequired()
     def settings_labs_update(self):
         _ = self.request.translate
         c = self.load_default_context()
         c.active = 'labs'
 
         application_form = LabsSettingsForm(self.request.translate)()
         try:
             form_result = application_form.to_python(dict(self.request.POST))
         except formencode.Invalid as errors:
             h.flash(
                 _("Some form inputs contain invalid data."),
                 category='error')
             data = render('rhodecode:templates/admin/settings/settings.mako',
                           self._get_template_context(c), self.request)
             html = formencode.htmlfill.render(
                 data,
                 defaults=errors.value,
                 errors=errors.unpack_errors() or {},
                 prefix_error=False,
                 encoding="UTF-8",
                 force_defaults=False
             )
             return Response(html)
 
         try:
             session = Session()
             for setting in _LAB_SETTINGS:
                 setting_name = setting.key[len('rhodecode_'):]
                 sett = SettingsModel().create_or_update_setting(
                     setting_name, form_result[setting.key], setting.type)
                 session.add(sett)
 
         except Exception:
             log.exception('Exception while updating lab settings')
             h.flash(_('Error occurred during updating labs settings'),
                     category='error')
         else:
             Session().commit()
             SettingsModel().invalidate_settings_cache()
             h.flash(_('Updated Labs settings'), category='success')
             raise HTTPFound(h.route_path('admin_settings_labs'))
 
         data = render('rhodecode:templates/admin/settings/settings.mako',
                       self._get_template_context(c), self.request)
         html = formencode.htmlfill.render(
             data,
             defaults=self._form_defaults(),
             encoding="UTF-8",
             force_defaults=False
         )
         return Response(html)
 
 
 # :param key: name of the setting including the 'rhodecode_' prefix
 # :param type: the RhodeCodeSetting type to use.
 # :param group: the i18ned group in which we should dispaly this setting
 # :param label: the i18ned label we should display for this setting
 # :param help: the i18ned help we should dispaly for this setting
 LabSetting = collections.namedtuple(
     'LabSetting', ('key', 'type', 'group', 'label', 'help'))
 
 
 # This list has to be kept in sync with the form
 # rhodecode.model.forms.LabsSettingsForm.
 _LAB_SETTINGS = [
 
 ]

rhodecode/lib/utils.py

@@ -1,895 +1,928 b''
 # Copyright (C) 2010-2024 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 importlib
 
 import decorator
 import logging
 import os
 import re
 import sys
 import shutil
 import socket
 import tempfile
 import traceback
 import tarfile
 
 from functools import wraps
 from os.path import join as jn
 
 import paste
 import pkg_resources
 from webhelpers2.text import collapse, strip_tags, convert_accented_entities, convert_misc_entities
 
 from mako import exceptions
 
 import rhodecode
 from rhodecode import ConfigGet
 from rhodecode.lib.exceptions import HTTPBranchProtected, HTTPLockedRepo, ClientNotSupported
 from rhodecode.lib.hash_utils import sha256_safe, md5, sha1
 from rhodecode.lib.type_utils import AttributeDict
 from rhodecode.lib.str_utils import safe_bytes, safe_str
 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.ext_json import sjson as json
 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(r'`?=[]\;\'"<>,/~!@#$%^&*()+{}|:')
 
 # Regex that matches forbidden characters in repo/group slugs.
 SLUG_BAD_CHAR_RE = re.compile(r'[{}\x00-\x08\x0b-\x0c\x0e-\x1f]'.format(SLUG_BAD_CHARS))
 
 # Regex that matches allowed characters in repo/group slugs.
 SLUG_GOOD_CHAR_RE = re.compile(r'[^{}]'.format(SLUG_BAD_CHARS))
 
 # Regex that matches whole repo/group slugs.
 SLUG_RE = re.compile(r'[^{}]+'.format(SLUG_BAD_CHARS))
 
 _license_cache = None
 
 
 def adopt_for_celery(func):
     """
     Decorator designed to adopt hooks (from rhodecode.lib.hooks_base)
     for further usage as a celery tasks.
     """
     @wraps(func)
     def wrapper(extras):
         extras = AttributeDict(extras)
 
         try:
             # HooksResponse implements to_json method which must be used there.
             return func(extras).to_json()
         except HTTPBranchProtected as error:
             # Those special cases don't need error reporting. It's a case of
             # locked repo or protected branch
             error_args = error.args
             return {
                 'status': error.code,
                 'output': error.explanation,
                 'exception': type(error).__name__,
                 'exception_args': error_args,
                 'exception_traceback': '',
             }
         except ClientNotSupported as error:
             # Those special cases don't need error reporting. It's a case of
             # locked repo or protected branch
             error_args = error.args
             return {
                 'status': error.code,
                 'output': error.explanation,
                 'exception': type(error).__name__,
                 'exception_args': error_args,
                 'exception_traceback': '',
             }
         except HTTPLockedRepo as error:
             # Those special cases don't need error reporting. It's a case of
             # locked repo or protected branch
             error_args = error.args
             return {
                 'status': error.code,
                 'output': error.explanation,
                 'exception': type(error).__name__,
                 'exception_args': error_args,
                 'exception_traceback': '',
             }
         except Exception as e:
             return {
                 'status': 128,
                 'output': '',
                 'exception': type(e).__name__,
                 'exception_args': e.args,
                 'exception_traceback': traceback.format_exc(),
             }
     return wrapper
 
 
 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 = strip_tags(value)
     slug = convert_accented_entities(slug)
     slug = convert_misc_entities(slug)
 
     slug = SLUG_BAD_CHAR_RE.sub('', slug)
     slug = re.sub(r'[\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_name'):
         # 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_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):
                     yield from _get_repos(rec_path)
 
     return _get_repos(path)
 
 
 def get_dirpaths(p: str) -> list:
     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(
                 "Ignoring path %s since it cannot be decoded into str.",
                 # 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 a given path is a repository group, False otherwise
 
     :param repo_group_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
         maybe_repo = os.path.dirname(full_path)
         if maybe_repo == base_path:
             # skip root level repo check; we know root location CANNOT BE a repo group
             return False
 
         scm_ = get_scm(maybe_repo)
         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 = 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 OSError
         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 prepare_config_data(clear_session=True, repo=None):
     """
     Read the configuration data from the database, *.ini files and return configuration
     tuples.
     """
     from rhodecode.model.settings import VcsSettingsModel
 
     sa = meta.Session()
     settings_model = VcsSettingsModel(repo=repo, sa=sa)
 
     ui_settings = settings_model.get_ui_settings()
 
     ui_data = []
     config = [
         ('web', 'push_ssl', 'false'),
     ]
     for setting in ui_settings:
         # skip certain deprecated keys that might be still in DB
         if f"{setting.section}_{setting.key}" in ['extensions_hgsubversion']:
             continue
 
         # Todo: remove this section once transition to *.ini files will be completed
         if setting.section in ('largefiles', 'vcs_git_lfs'):
             if setting.key != 'enabled':
                 continue
         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 this is deprecated, and we must force it to False
             config.append((
                 safe_str(setting.section), safe_str(setting.key), False))
     config_getter = ConfigGet()
     config.append(('vcs_git_lfs', 'store_location', config_getter.get_str('vcs.git.lfs.storage_location')))
     config.append(('largefiles', 'usercache', config_getter.get_str('vcs.hg.largefiles.storage_location')))
     log.debug(
         'settings ui from db@repo[%s]: %s',
         repo,
         ','.join(['[{}] {}={}'.format(*s) for s in 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 = prepare_config_data(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 list(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_repo_store_path():
     """
     Returns the base path. The base path is the filesystem path which points
     to the repository store.
     """
 
     import rhodecode
     return rhodecode.CONFIG['repo_store.path']
 
 
 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, force_hooks_rebuild=False):
+def repo2db_mapper(initial_repo_list, force_hooks_rebuild=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
+    maps all repos given in initial_repo_list, non-existing repositories
+    are created
     """
     from rhodecode.model.repo import RepoModel
-    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 = []
+    errors = []
 
     # 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 list(initial_repo_list.items()):
         group = map_groups(name)
         str_name = safe_str(name)
         db_repo = repo_model.get_by_repo_name(str_name)
 
         # found repo that is on filesystem not in RhodeCode database
         if not db_repo:
             log.info('repository `%s` not found in the database, creating now', name)
             added.append(name)
-            desc = (repo.description
-                    if repo.description != 'unknown'
-                    else '%s repository' % name)
+            desc = repo.description if repo.description != 'unknown' else f'{name} repository'
 
             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()
+
+        try:
+            config = db_repo._config
+            config.set('extensions', 'largefiles', '')
+            scm_repo = db_repo.scm_instance(config=config)
+        except Exception:
+            log.error(traceback.format_exc())
+            errors.append(f'getting vcs instance for {name} failed')
+            continue
+
+        try:
+            db_repo.update_commit_cache(recursive=False)
+        except Exception:
+            log.error(traceback.format_exc())
+            errors.append(f'update_commit_cache for {name} failed')
+            continue
+
+        try:
+            scm_repo.install_hooks(force=force_hooks_rebuild)
+        except Exception:
+            log.error(traceback.format_exc())
+            errors.append(f'install_hooks for {name} failed')
+            continue
+
+        try:
             # 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(force=True)
-
-            db_repo.update_commit_cache(recursive=False)
+                scm_repo._update_server_info(force=True)
+        except Exception:
+            log.error(traceback.format_exc())
+            errors.append(f'update_server_info for {name} failed')
+            continue
 
-        config = db_repo._config
-        config.set('extensions', 'largefiles', '')
-        repo = db_repo.scm_instance(config=config)
-        repo.install_hooks(force=force_hooks_rebuild)
+    return added, errors
 
+def repo2db_cleanup(skip_repos=None, skip_groups=None):
+    from rhodecode.model.repo import RepoModel
+    from rhodecode.model.repo_group import RepoGroupModel
+
+    sa = meta.Session()
     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 list(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()
+    errors = []
+
+
+    all_repos = Repository.execute(
+        Repository.select(Repository)\
+            .order_by(Repository.repo_name)
+    ).scalars()
 
-        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
+    # remove from database those repositories that are not in the filesystem
+    for db_repo in all_repos:
+        db_repo_name = db_repo.repo_name
+        if skip_repos and db_repo_name in skip_repos:
+            log.debug('Skipping repo `%s`', db_repo_name)
+            continue
+        try:
+            instance = db_repo.scm_instance()
+        except Exception:
+            instance = None
 
-        initial_repo_group_list = [splitter(x) for x in
-                                   list(initial_repo_list.keys()) if splitter(x)]
+        if not instance:
+            log.debug("Removing non-existing repository found in db `%s`", db_repo_name)
+            try:
+                RepoModel(sa).delete(db_repo, forks='detach', fs_remove=False, call_events=False)
+                sa.commit()
+                removed.append(db_repo_name)
+            except Exception:
+                # don't hold further removals on error
+                log.error(traceback.format_exc())
+                sa.rollback()
+                errors.append(db_repo_name)
 
-        # 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()]
-        def nested_sort(gr):
-            return 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
+    # 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 = RepoGroup.execute(
+        RepoGroup.select(RepoGroup.group_name)\
+            .order_by(RepoGroup.group_name)
+    ).scalars().all()
+
+    def nested_sort(gr):
+        return len(gr.split('/'))
 
-                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
+    for group_name in sorted(all_groups, key=nested_sort, reverse=True):
+        if skip_groups and group_name in skip_groups:
+            log.debug('Skipping repo group `%s`', group_name)
+            continue
+
+        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)
 
-    return added, removed
+        try:
+            RepoGroupModel(sa).delete(group_name, fs_remove=False, call_events=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()
+            errors.append(group_name)
+
+    return removed, errors
+
 
 def deep_reload_package(package_name):
     """
     Deeply reload a package by removing it and its submodules from sys.modules,
     then re-importing it.
     """
     # Remove the package and its submodules from sys.modules
     to_reload = [name for name in sys.modules if name == package_name or name.startswith(package_name + ".")]
     for module_name in to_reload:
         del sys.modules[module_name]
         log.debug(f"Removed module from cache: {module_name}")
 
     # Re-import the package
     package = importlib.import_module(package_name)
     log.debug(f"Re-imported package: {package_name}")
 
     return package
 
 def load_rcextensions(root_path):
     import rhodecode
     from rhodecode.config import conf
 
     path = os.path.join(root_path)
     deep_reload = path in sys.path
     sys.path.insert(0, path)
 
     try:
         rcextensions = __import__('rcextensions', fromlist=[''])
     except ImportError:
         if os.path.isdir(os.path.join(path, 'rcextensions')):
             log.warning('Unable to load rcextensions from %s', path)
         rcextensions = None
 
     if rcextensions:
         if deep_reload:
             rcextensions = deep_reload_package('rcextensions')
         log.info('Loaded rcextensions from %s...', rcextensions)
         rhodecode.EXTENSIONS = rcextensions
 
         # Additional mappings that are not present in the pygments lexers
         conf.LANGUAGES_EXTENSIONS_MAP.update(
             getattr(rhodecode.EXTENSIONS, 'EXTRA_MAPPINGS', {}))
 
 
 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.
     """
     try:
         import rc_testdata
     except ImportError:
         raise ImportError('Failed to import rc_testdata, '
                           'please make sure this package is installed from requirements_test.txt')
 
     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
     from rhodecode.lib.utils2 import get_encryption_key
 
     # PART ONE create db
     dbconf = config['sqlalchemy.db1.url']
     enc_key = get_encryption_key(config)
 
     log.debug('making test db %s', dbconf)
 
     dbmanage = DbManage(log_sql=False, dbconf=dbconf, root=config['here'],
                         tests=True, cli_args={'force_ask': True}, enc_key=enc_key)
     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.
     """
     try:
         import rc_testdata
     except ImportError:
         raise ImportError('Failed to import rc_testdata, '
                           'please make sure this package is installed from requirements_test.txt')
 
-    from rhodecode.tests import HG_REPO, GIT_REPO, SVN_REPO
+    from rhodecode.bootstrap import HG_REPO, GIT_REPO, SVN_REPO
 
     log.debug('making test vcs repositories at %s', test_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(safe_bytes(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 sha256_safe(':'.join(uuid_list))
     except Exception as e:
         log.error('Failed to generate host uuid: %s', e)
         return 'UNDEFINED'
 
 
 def send_test_email(recipients, email_body='TEST EMAIL'):
     """
     Simple code for generating test emails.
     Usage::
 
         from rhodecode.lib import utils
         utils.send_test_email()
     """
     from rhodecode.lib.celerylib import tasks, run_task
 
     email_body = email_body_plaintext = email_body
     subject = f'SUBJECT FROM: {socket.gethostname()}'
     tasks.send_email(recipients, subject, email_body_plaintext, email_body)

rhodecode/lib/vcs/backends/__init__.py

@@ -1,93 +1,94 b''
 # Copyright (C) 2014-2024 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/
 
 """
 VCS Backends module
 """
 
 import os
 import logging
 
 from rhodecode import typing
 
 from rhodecode.lib.vcs.conf import settings
 from rhodecode.lib.vcs.exceptions import VCSError
 from rhodecode.lib.vcs.utils.helpers import get_scm
 from rhodecode.lib.vcs.utils.imports import import_class
 
 
 log = logging.getLogger(__name__)
 
 
 def get_vcs_instance(repo_path, *args, **kwargs) -> typing.VCSRepo | None:
     """
     Given a path to a repository an instance of the corresponding vcs backend
     repository class is created and returned. If no repository can be found
     for the path it returns None. Arguments and keyword arguments are passed
     to the vcs backend repository class.
     """
     from rhodecode.lib.utils2 import safe_str
 
     explicit_vcs_alias = kwargs.pop('_vcs_alias', None)
     try:
         vcs_alias = safe_str(explicit_vcs_alias or get_scm(repo_path)[0])
         log.debug(
             'Creating instance of %s repository from %s', vcs_alias,
             safe_str(repo_path))
         backend = get_backend(vcs_alias)
 
         if explicit_vcs_alias:
             # do final verification of existence of the path, this does the
             # same as get_scm() call which we skip in explicit_vcs_alias
             if not os.path.isdir(repo_path):
                 raise VCSError(f"Given path {repo_path} is not a directory")
     except VCSError:
         log.exception(
-            'Perhaps this repository is in db and not in '
-            'filesystem run rescan repositories with '
-            '"destroy old data" option from admin panel')
+            'Perhaps this repository is in db and not in filesystem.'
+            'Run cleanup filesystem option from admin settings under Remap and rescan'
+            )
+
         return None
 
     return backend(repo_path=repo_path, *args, **kwargs)
 
 
 def get_backend(alias) -> typing.VCSRepoClass:
     """
     Returns ``Repository`` class identified by the given alias or raises
     VCSError if alias is not recognized or backend class cannot be imported.
     """
     if alias not in settings.BACKENDS:
         raise VCSError(
             f"Given alias '{alias}' is not recognized! "
             f"Allowed aliases:{settings.BACKENDS.keys()}")
     backend_path = settings.BACKENDS[alias]
     klass = import_class(backend_path)
     return klass
 
 
 def get_supported_backends():
     """
     Returns list of aliases of supported backends.
     """
     return settings.BACKENDS.keys()
 
 
 def get_vcsserver_service_data():
     from rhodecode.lib.vcs import connection
     return connection.Service.get_vcsserver_service_data()
 

rhodecode/model/repo.py

@@ -1,1212 +1,1219 b''
 # Copyright (C) 2010-2024 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 sqlalchemy.orm import aliased
 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, AttachedPullRequestsError, AttachedArtifactsError
 from rhodecode.lib import hooks_base
 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, remove_prefix, obfuscate_url_pw,
     get_current_rhodecode_user, safe_int, action_logger_generic)
 from rhodecode.lib.vcs.backends import get_backend
 from rhodecode.lib.vcs.nodes import NodeKind
 from rhodecode.model import BaseModel
 from rhodecode.model.db import (
     _hash_key, func, case, joinedload, or_, in_filter_generator,
     Session, Repository, UserRepoToPerm, UserGroupRepoToPerm,
     UserRepoGroupToPerm, UserGroupRepoGroupToPerm, User, Permission,
     Statistics, UserGroup, RepoGroup, RepositoryField, UserLog)
 from rhodecode.model.permission import PermissionModel
 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 = def_user
 
         return repo_to_perm
 
     def get(self, repo_id):
         repo = self.sa.query(Repository) \
             .filter(Repository.repo_id == 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", f"get_repo_{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+)', 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
         """
         _repo_id = 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')
             if _repo_id:
                 Session().rollback()
 
         return None
 
     def get_repos_for_root(self, root, traverse=False):
         if traverse:
             like_expression = u'{}%'.format(safe_str(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_commit_cache(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, short_name=None):
 
         _render = get_current_request().get_partial_renderer(
             'rhodecode:templates/data_table/_dt_elements.mako')
         c = _render.get_call_context()
         h = _render.get_helpers()
 
         def quick_menu(repo_name):
             return _render('quick_menu', repo_name)
 
         def repo_lnk(name, rtype, rstate, private, archived, fork_repo_name):
             if short_name is not None:
                 short_name_var = short_name
             else:
                 short_name_var = not admin
             return _render('repo_name', name, rtype, rstate, private, archived, fork_repo_name,
                            short_name=short_name_var, admin=False)
 
         def last_change(last_change):
             if admin and isinstance(last_change, datetime.datetime) and not last_change.tzinfo:
                 ts = time.time()
                 utc_offset = (datetime.datetime.fromtimestamp(ts)
                               - datetime.datetime.utcfromtimestamp(ts)).total_seconds()
                 last_change = last_change + datetime.timedelta(seconds=utc_offset)
 
             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:
             # NOTE(marcink): because we use only raw column we need to load it like that
             changeset_cache = Repository._load_changeset_cache(
                 repo.repo_id, 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.archived, repo.fork_repo_name),
 
                 "desc": desc(h.escape(repo.description)),
 
                 "last_change": last_change(repo.updated_on),
 
                 "last_changeset": last_rev(repo.repo_name, changeset_cache),
                 "last_changeset_raw": changeset_cache.get('revision'),
 
                 "owner": user_profile(repo.owner_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_repos_data_table(
             self, draw, start, limit,
             search_q, order_by, order_dir,
             auth_user, repo_group_id):
         from rhodecode.model.scm import RepoList
 
         _perms = ['repository.read', 'repository.write', 'repository.admin']
 
         repos = Repository.query() \
             .filter(Repository.group_id == repo_group_id) \
             .all()
         auth_repo_list = RepoList(
             repos, perm_set=_perms,
             extra_kwargs=dict(user=auth_user))
 
         allowed_ids = [-1]
         for repo in auth_repo_list:
             allowed_ids.append(repo.repo_id)
 
         repos_data_total_count = Repository.query() \
             .filter(Repository.group_id == repo_group_id) \
             .filter(or_(
                 # generate multiple IN to fix limitation problems
                 *in_filter_generator(Repository.repo_id, allowed_ids))
             ) \
             .count()
 
         RepoFork = aliased(Repository)
         OwnerUser = aliased(User)
         base_q = Session.query(
             Repository.repo_id,
             Repository.repo_name,
             Repository.description,
             Repository.repo_type,
             Repository.repo_state,
             Repository.private,
             Repository.archived,
             Repository.updated_on,
             Repository._changeset_cache,
             RepoFork.repo_name.label('fork_repo_name'),
             OwnerUser.username.label('owner_username'),
             ) \
             .filter(Repository.group_id == repo_group_id) \
             .filter(or_(
                 # generate multiple IN to fix limitation problems
                 *in_filter_generator(Repository.repo_id, allowed_ids))
             ) \
             .outerjoin(RepoFork, Repository.fork_id == RepoFork.repo_id) \
             .join(OwnerUser, Repository.user_id == OwnerUser.user_id)
 
         repos_data_total_filtered_count = base_q.count()
 
         sort_defined = False
         if order_by == 'repo_name':
             sort_col = func.lower(Repository.repo_name)
             sort_defined = True
         elif order_by == 'user_username':
             sort_col = User.username
         else:
             sort_col = getattr(Repository, order_by, None)
 
         if sort_defined or sort_col:
             if order_dir == 'asc':
                 sort_col = sort_col.asc()
             else:
                 sort_col = sort_col.desc()
 
         base_q = base_q.order_by(sort_col)
         base_q = base_q.offset(start).limit(limit)
 
         repos_list = base_q.all()
 
         repos_data = RepoModel().get_repos_as_dict(
             repo_list=repos_list, admin=False)
 
         data = ({
             'draw': draw,
             'data': repos_data,
             'recordsTotal': repos_data_total_count,
             'recordsFiltered': repos_data_total_filtered_count,
         })
         return 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
 
             affected_user_ids = []
             if 'user' in kwargs:
                 old_owner_id = cur_repo.user.user_id
                 new_owner = User.get_by_username(kwargs['user'])
                 cur_repo.user = new_owner
 
                 if old_owner_id != new_owner.user_id:
                     affected_user_ids = [new_owner.user_id, old_owner_id]
 
             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 = source_repo_name
             if 'repo_name' in kwargs:
                 new_name = cur_repo.get_new_name(kwargs['repo_name'])
                 cur_repo.repo_name = new_name
 
             if 'repo_private' in kwargs:
                 # if private flag is set to True, reset default permission to NONE
                 set_private_to = kwargs.get('repo_private')
                 if set_private_to:
                     EMPTY_PERM = 'repository.none'
                     RepoModel().grant_user_permission(
                         repo=cur_repo, user=User.DEFAULT_USER, perm=EMPTY_PERM
                     )
                 if set_private_to != cur_repo.private:
                     # NOTE(dan): we change repo private mode we need to notify all USERS
                     # this is just by having this value set to a different value then it was before
                     affected_user_ids = User.get_all_user_ids()
 
             if kwargs.get('repo_landing_rev'):
                 landing_rev_val = kwargs['repo_landing_rev']
                 RepoModel().set_landing_rev(cur_repo, landing_rev_val)
 
             # 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)
 
             self.sa.add(cur_repo)
 
             if source_repo_name != new_name:
                 # rename repository
                 self._rename_filesystem_repo(
                     old=source_repo_name, new=new_name)
 
             if affected_user_ids:
                 PermissionModel().trigger_permission_flush(affected_user_ids)
 
             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=None, 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))
         default_landing_ref, _lbl = ScmModel.backend_landing_ref(repo_type)
         landing_rev = landing_rev or default_landing_ref
 
         try:
             repo_name = safe_str(repo_name)
             description = safe_str(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.archived = False
             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, actor=owner))
             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': [],
             'default_user_changed': None
         }
 
         repo = self._get_repo(repo)
 
         # 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
                 if member_name == User.DEFAULT_USER:
                     # NOTE(dan): detect if we changed permissions for default user
                     perm_obj = self.sa.query(UserRepoToPerm) \
                         .filter(UserRepoToPerm.user_id == member_id) \
                         .filter(UserRepoToPerm.repository == repo) \
                         .scalar()
                     if perm_obj and perm_obj.permission.permission_name != perm:
                         changes['default_user_changed'] = True
 
                 # this updates also current one if found
                 self.grant_user_permission(
                     repo=repo, user=member_id, perm=perm)
             elif member_type == '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)
             else:
                 raise ValueError("member_type must be 'user' or 'user_group' "
                                  "got {} instead".format(member_type))
             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)
             elif member_type == '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)
             else:
                 raise ValueError("member_type must be 'user' or 'user_group' "
                                  "got {} instead".format(member_type))
 
             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)
             elif member_type == '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)
             else:
                 raise ValueError("member_type must be 'user' or 'user_group' "
                                  "got {} instead".format(member_type))
 
             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 archive(self, repo):
         """
         Archive given repository. Set archive flag.
 
         :param repo:
         """
         repo = self._get_repo(repo)
         if repo:
 
             try:
                 repo.archived = True
                 self.sa.add(repo)
                 self.sa.commit()
             except Exception:
                 log.error(traceback.format_exc())
                 raise
 
-    def delete(self, repo, forks=None, pull_requests=None, artifacts=None, fs_remove=True, cur_user=None):
+    def delete(self, repo, forks=None, pull_requests=None, artifacts=None, fs_remove=True, cur_user=None, call_events=True):
         """
         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 pull_requests: str 'delete' or None
         :param artifacts: str 'delete' or None
         :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()
+        if not repo:
+            return False
 
-            # check for pull requests
-            pr_sources = repo.pull_requests_source
-            pr_targets = repo.pull_requests_target
-            if pull_requests != 'delete' and (pr_sources or pr_targets):
-                raise AttachedPullRequestsError()
+        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()
+
+        # check for pull requests
+        pr_sources = repo.pull_requests_source
+        pr_targets = repo.pull_requests_target
+        if pull_requests != 'delete' and (pr_sources or pr_targets):
+            raise AttachedPullRequestsError()
 
-            artifacts_objs = repo.artifacts
-            if artifacts == 'delete':
-                for a in artifacts_objs:
-                    self.sa.delete(a)
-            elif [a for a in artifacts_objs]:
-                raise AttachedArtifactsError()
+        artifacts_objs = repo.artifacts
+        if artifacts == 'delete':
+            for a in artifacts_objs:
+                self.sa.delete(a)
+        elif [a for a in artifacts_objs]:
+            raise AttachedArtifactsError()
 
-            old_repo_dict = repo.get_dict()
+        old_repo_dict = repo.get_dict()
+        if call_events:
             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(),
-                })
+
+        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(),
+            })
+            if call_events:
                 hooks_base.delete_repository(**old_repo_dict)
                 events.trigger(events.RepoDeleteEvent(repo))
-            except Exception:
-                log.error(traceback.format_exc())
-                raise
+        except Exception:
+            log.error(traceback.format_exc())
+            raise
+
+        return True
 
     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 set_landing_rev(self, repo, landing_rev_name):
         if landing_rev_name.startswith('branch:'):
             landing_rev_name = landing_rev_name.split('branch:')[-1]
         scm_instance = repo.scm_instance()
         if scm_instance:
             return scm_instance._remote.set_head_ref(landing_rev_name)
 
     def _create_filesystem_repo(self, repo_name, repo_type, repo_group,
                                 clone_uri=None, repo_store_location=None,
                                 use_global_config=False, install_hooks=True):
         """
         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(f'This path {repo_path} is a valid repository')
 
         # check if this path is a group
         if is_valid_repo_group(repo_path, self.repos_path):
             raise Exception(f'This path {repo_path} is a valid group')
 
         log.info('creating repo %s in %s from url: `%s`',
                  repo_name, safe_str(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,
                 with_wire={"cache": False})
         else:
             repo = backend(
                 repo_path, config=config, create=True, src_url=clone_uri,
                 with_wire={"cache": False})
 
         if install_hooks:
             repo.install_hooks()
 
         log.debug('Created repo %s with %s backend',
                   safe_str(repo_name), safe_str(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 actually made by
         added rm__ prefix into dir, and rename internal .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("delete_filesystem_repo: 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__{}__{}'.format(_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))
 
         # finally cleanup diff-cache if it exists
         cached_diffs_dir = repo.cached_diffs_dir
         if os.path.isdir(cached_diffs_dir):
             shutil.rmtree(cached_diffs_dir)
 
 
 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,
         '.rst':      1,
         '.md':       1,
         '.rest':     2,
         '.mkdn':     2,
         '.text':     2,
         '.txt':      3,
         '.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`.
         """
         # firstly, check the PATH type if it is actually a DIR
         if commit.get_node(path).kind != NodeKind.DIR:
             return None
 
         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 f'<ReadmeMatch {self.path} priority={self.priority}'

rhodecode/model/repo_group.py

@@ -1,889 +1,892 b''
 # Copyright (C) 2011-2024 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/
 
 
 """
 repo group model for RhodeCode
 """
 
 import os
 import datetime
 import itertools
 import logging
 import shutil
 import time
 import traceback
 import string
 
 
 from rhodecode import events
 from rhodecode.model import BaseModel
 from rhodecode.model.db import (_hash_key, func, or_, in_filter_generator,
     Session, RepoGroup, UserRepoGroupToPerm, User, Permission, UserGroupRepoGroupToPerm,
     UserGroup, Repository)
 from rhodecode.model.permission import PermissionModel
 from rhodecode.model.settings import SettingsModel
 from rhodecode.lib.caching_query import FromCache
 from rhodecode.lib.utils2 import action_logger_generic
 
 log = logging.getLogger(__name__)
 
 
 class RepoGroupModel(BaseModel):
 
     cls = RepoGroup
     PERSONAL_GROUP_DESC = 'personal repo group of user `%(username)s`'
     PERSONAL_GROUP_PATTERN = '${username}'  # default
 
     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 get_repo_group(self, repo_group):
         return self._get_repo_group(repo_group)
 
     def get_by_group_name(self, repo_group_name, cache=None):
         repo = self.sa.query(RepoGroup) \
             .filter(RepoGroup.group_name == repo_group_name)
 
         if cache:
             name_key = _hash_key(repo_group_name)
             repo = repo.options(
                 FromCache("sql_cache_short", f"get_repo_group_{name_key}"))
         return repo.scalar()
 
     def get_default_create_personal_repo_group(self):
         value = SettingsModel().get_setting_by_name(
             'create_personal_repo_group')
         return value.app_settings_value if value else None or False
 
     def get_personal_group_name_pattern(self):
         value = SettingsModel().get_setting_by_name(
             'personal_repo_group_pattern')
         val = value.app_settings_value if value else None
         group_template = val or self.PERSONAL_GROUP_PATTERN
 
         group_template = group_template.lstrip('/')
         return group_template
 
     def get_personal_group_name(self, user):
         template = self.get_personal_group_name_pattern()
         return string.Template(template).safe_substitute(
             username=user.username,
             user_id=user.user_id,
             first_name=user.first_name,
             last_name=user.last_name,
         )
 
     def create_personal_repo_group(self, user, commit_early=True):
         desc = self.PERSONAL_GROUP_DESC % {'username': user.username}
         personal_repo_group_name = self.get_personal_group_name(user)
 
         # create a new one
         RepoGroupModel().create(
             group_name=personal_repo_group_name,
             group_description=desc,
             owner=user.username,
             personal=True,
             commit_early=commit_early)
 
     def _create_default_perms(self, new_group):
         # create default permission
         default_perm = 'group.read'
         def_user = User.get_default_user()
         for p in def_user.user_perms:
             if p.permission.permission_name.startswith('group.'):
                 default_perm = p.permission.permission_name
                 break
 
         repo_group_to_perm = UserRepoGroupToPerm()
         repo_group_to_perm.permission = Permission.get_by_key(default_perm)
 
         repo_group_to_perm.group = new_group
         repo_group_to_perm.user = def_user
         return repo_group_to_perm
 
     def _get_group_name_and_parent(self, group_name_full, repo_in_path=False,
                                    get_object=False):
         """
         Get's the group name and a parent group name from given group name.
         If repo_in_path is set to truth, we asume the full path also includes
         repo name, in such case we clean the last element.
 
         :param group_name_full:
         """
         split_paths = 1
         if repo_in_path:
             split_paths = 2
         _parts = group_name_full.rsplit(RepoGroup.url_sep(), split_paths)
 
         if repo_in_path and len(_parts) > 1:
             # such case last element is the repo_name
             _parts.pop(-1)
         group_name_cleaned = _parts[-1]  # just the group name
         parent_repo_group_name = None
 
         if len(_parts) > 1:
             parent_repo_group_name = _parts[0]
 
         parent_group = None
         if parent_repo_group_name:
             parent_group = RepoGroup.get_by_group_name(parent_repo_group_name)
 
         if get_object:
             return group_name_cleaned, parent_repo_group_name, parent_group
 
         return group_name_cleaned, parent_repo_group_name
 
     def check_exist_filesystem(self, group_name, exc_on_failure=True):
         create_path = os.path.join(self.repos_path, group_name)
-        log.debug('creating new group in %s', create_path)
+        log.debug('checking FS presence for repo group in %s', create_path)
 
         if os.path.isdir(create_path):
             if exc_on_failure:
                 abs_create_path = os.path.abspath(create_path)
                 raise Exception(f'Directory `{abs_create_path}` already exists !')
             return False
         return True
 
     def _create_group(self, group_name):
         """
         makes repository group on filesystem
 
         :param repo_name:
         :param parent_id:
         """
 
         self.check_exist_filesystem(group_name)
         create_path = os.path.join(self.repos_path, group_name)
         log.debug('creating new group in %s', create_path)
         os.makedirs(create_path, mode=0o755)
         log.debug('created group in %s', create_path)
 
     def _rename_group(self, old, new):
         """
         Renames a group on filesystem
 
         :param group_name:
         """
 
         if old == new:
             log.debug('skipping group rename')
             return
 
         log.debug('renaming repository group from %s to %s', old, new)
 
         old_path = os.path.join(self.repos_path, old)
         new_path = os.path.join(self.repos_path, new)
 
         log.debug('renaming repos paths from %s to %s', old_path, new_path)
 
         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_group(self, group, force_delete=False):
         """
         Deletes a group from a filesystem
 
         :param group: instance of group from database
         :param force_delete: use shutil rmtree to remove all objects
         """
         paths = group.full_path.split(RepoGroup.url_sep())
         paths = os.sep.join(paths)
 
         rm_path = os.path.join(self.repos_path, paths)
         log.info("Removing group %s", rm_path)
         # delete only if that path really exists
         if os.path.isdir(rm_path):
             if force_delete:
                 shutil.rmtree(rm_path)
             else:
                 # archive that group`
                 _now = datetime.datetime.now()
                 _ms = str(_now.microsecond).rjust(6, '0')
                 _d = 'rm__{}_GROUP_{}'.format(
                     _now.strftime('%Y%m%d_%H%M%S_' + _ms), group.name)
                 shutil.move(rm_path, os.path.join(self.repos_path, _d))
 
     def create(self, group_name, group_description, owner, just_db=False,
                copy_permissions=False, personal=None, commit_early=True):
 
         (group_name_cleaned,
          parent_group_name) = RepoGroupModel()._get_group_name_and_parent(group_name)
 
         parent_group = None
         if parent_group_name:
             parent_group = self._get_repo_group(parent_group_name)
             if not parent_group:
                 # we tried to create a nested group, but the parent is not
                 # existing
                 raise ValueError(
                     'Parent group `%s` given in `%s` group name '
                     'is not yet existing.' % (parent_group_name, group_name))
 
         # because we are doing a cleanup, we need to check if such directory
         # already exists. If we don't do that we can accidentally delete
         # existing directory via cleanup that can cause data issues, since
         # delete does a folder rename to special syntax later cleanup
         # functions can delete this
         cleanup_group = self.check_exist_filesystem(group_name,
                                                     exc_on_failure=False)
         user = self._get_user(owner)
         if not user:
             raise ValueError('Owner %s not found as rhodecode user', owner)
 
         try:
             new_repo_group = RepoGroup()
             new_repo_group.user = user
             new_repo_group.group_description = group_description or group_name
             new_repo_group.parent_group = parent_group
             new_repo_group.group_name = group_name
             new_repo_group.personal = personal
 
             self.sa.add(new_repo_group)
 
             # create an ADMIN permission for owner except if we're super admin,
             # later owner should go into the owner field of groups
             if not user.is_admin:
                 self.grant_user_permission(repo_group=new_repo_group,
                                            user=owner, perm='group.admin')
 
             if parent_group and copy_permissions:
                 # copy permissions from parent
                 user_perms = UserRepoGroupToPerm.query() \
                     .filter(UserRepoGroupToPerm.group == parent_group).all()
 
                 group_perms = UserGroupRepoGroupToPerm.query() \
                     .filter(UserGroupRepoGroupToPerm.group == parent_group).all()
 
                 for perm in user_perms:
                     # don't copy over the permission for user who is creating
                     # this group, if he is not super admin he get's admin
                     # permission set above
                     if perm.user != user or user.is_admin:
                         UserRepoGroupToPerm.create(
                             perm.user, new_repo_group, perm.permission)
 
                 for perm in group_perms:
                     UserGroupRepoGroupToPerm.create(
                         perm.users_group, new_repo_group, perm.permission)
             else:
                 perm_obj = self._create_default_perms(new_repo_group)
                 self.sa.add(perm_obj)
 
             # now commit the changes, earlier so we are sure everything is in
             # the database.
             if commit_early:
                 self.sa.commit()
             if not just_db:
                 self._create_group(new_repo_group.group_name)
 
             # trigger the post hook
             from rhodecode.lib import hooks_base
             repo_group = RepoGroup.get_by_group_name(group_name)
 
             # update repo group commit caches initially
             repo_group.update_commit_cache()
 
             hooks_base.create_repository_group(
                 created_by=user.username, **repo_group.get_dict())
 
             # Trigger create event.
             events.trigger(events.RepoGroupCreateEvent(repo_group))
 
             return new_repo_group
         except Exception:
             self.sa.rollback()
             log.exception('Exception occurred when creating repository group, '
                           'doing cleanup...')
             # rollback things manually !
             repo_group = RepoGroup.get_by_group_name(group_name)
             if repo_group:
                 RepoGroup.delete(repo_group.group_id)
                 self.sa.commit()
                 if cleanup_group:
                     RepoGroupModel()._delete_filesystem_group(repo_group)
             raise
 
     def update_permissions(
             self, repo_group, perm_additions=None, perm_updates=None,
             perm_deletions=None, recursive=None, check_perms=True,
             cur_user=None):
         from rhodecode.model.repo import RepoModel
         from rhodecode.lib.auth import HasUserGroupPermissionAny
 
         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': [],
             'default_user_changed': None
         }
 
         def _set_perm_user(_obj: RepoGroup | Repository, _user_obj: User, _perm):
 
             if isinstance(_obj, RepoGroup):
                 self.grant_user_permission(repo_group=_obj, user=_user_obj, perm=_perm)
             elif isinstance(_obj, Repository):
                 # private repos will not allow to change the default
                 # permissions using recursive mode
                 if _obj.private and _user_obj.username == User.DEFAULT_USER:
                     log.debug('Skipping private repo %s for user %s', _obj, _user_obj)
                     return
 
                 # we set group permission, we have to switch to repo permission definition
                 new_perm = _perm.replace('group.', 'repository.')
                 RepoModel().grant_user_permission(repo=_obj, user=_user_obj, perm=new_perm)
 
         def _set_perm_group(_obj: RepoGroup | Repository, users_group: UserGroup, _perm):
             if isinstance(_obj, RepoGroup):
                 self.grant_user_group_permission(repo_group=_obj, group_name=users_group, perm=_perm)
             elif isinstance(_obj, Repository):
                 # we set group permission, we have to switch to repo permission definition
                 new_perm = _perm.replace('group.', 'repository.')
                 RepoModel().grant_user_group_permission(repo=_obj, group_name=users_group, perm=new_perm)
 
         def _revoke_perm_user(_obj: RepoGroup | Repository, _user_obj: User):
             if isinstance(_obj, RepoGroup):
                 self.revoke_user_permission(repo_group=_obj, user=_user_obj)
             elif isinstance(_obj, Repository):
                 # private repos will not allow to change the default
                 # permissions using recursive mode, also there's no revocation fo default user, just update
                 if _user_obj.username == User.DEFAULT_USER:
                     log.debug('Skipping private repo %s for user %s', _obj, _user_obj)
                     return
                 RepoModel().revoke_user_permission(repo=_obj, user=_user_obj)
 
         def _revoke_perm_group(_obj: RepoGroup | Repository, user_group: UserGroup):
             if isinstance(_obj, RepoGroup):
                 self.revoke_user_group_permission(repo_group=_obj, group_name=user_group)
             elif isinstance(_obj, Repository):
                 RepoModel().revoke_user_group_permission(repo=_obj, group_name=user_group)
 
         # start updates
         log.debug('Now updating permissions for %s in recursive mode:%s',
                   repo_group, recursive)
 
         # initialize check function, we'll call that multiple times
         has_group_perm = HasUserGroupPermissionAny(*req_perms)
 
         for obj in repo_group.recursive_groups_and_repos():
             # iterated obj is an instance of a repos group or repository in
             # that group, recursive option can be: none, repos, groups, all
             if recursive == 'all':
                 obj = obj
             elif recursive == 'repos':
                 # skip groups, other than this one
                 if isinstance(obj, RepoGroup) and not obj == repo_group:
                     continue
             elif recursive == 'groups':
                 # skip repos
                 if isinstance(obj, Repository):
                     continue
             else:  # recursive == 'none':
                 #  DEFAULT option - don't apply to iterated objects
                 # also we do a break at the end of this loop. if we are not
                 # in recursive mode
                 obj = repo_group
 
             change_obj = obj.get_api_data()
 
             # update permissions
             for member_id, perm, member_type in perm_updates:
                 member_id = int(member_id)
                 if member_type == 'user':
                     member_obj = User.get(member_id)
                     member_name = member_obj.username
                     if isinstance(obj, RepoGroup) and obj == repo_group and member_name == User.DEFAULT_USER:
                         # NOTE(dan): detect if we changed permissions for default user
                         perm_obj = self.sa.query(UserRepoGroupToPerm) \
                             .filter(UserRepoGroupToPerm.user_id == member_id) \
                             .filter(UserRepoGroupToPerm.group == repo_group) \
                             .scalar()
                         if perm_obj and perm_obj.permission.permission_name != perm:
                             changes['default_user_changed'] = True
 
                     # this updates also current one if found
                     _set_perm_user(obj, member_obj, perm)
                 elif member_type == 'user_group':
                     member_obj = UserGroup.get(member_id)
                     member_name = member_obj.users_group_name
                     if not check_perms or has_group_perm(member_name, user=cur_user):
                         _set_perm_group(obj, member_obj, perm)
                 else:
                     raise ValueError(
                         f"member_type must be 'user' or 'user_group' got {member_type} instead"
                     )
 
                 changes['updated'].append(
                     {'change_obj': change_obj, '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_obj = User.get(member_id)
                     member_name = member_obj.username
                     _set_perm_user(obj, member_obj, perm)
                 elif member_type == 'user_group':
                     # check if we have permissions to alter this usergroup
                     member_obj = UserGroup.get(member_id)
                     member_name = member_obj.users_group_name
                     if not check_perms or has_group_perm(member_name, user=cur_user):
                         _set_perm_group(obj, member_obj, perm)
                 else:
                     raise ValueError(
                         f"member_type must be 'user' or 'user_group' got {member_type} instead"
                     )
 
                 changes['added'].append(
                     {'change_obj': change_obj, '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_obj = User.get(member_id)
                     member_name = member_obj.username
                     _revoke_perm_user(obj, member_obj)
                 elif member_type == 'user_group':
                     # check if we have permissions to alter this usergroup
                     member_obj = UserGroup.get(member_id)
                     member_name = member_obj.users_group_name
                     if not check_perms or has_group_perm(member_name, user=cur_user):
                         _revoke_perm_group(obj, member_obj)
                 else:
                     raise ValueError(
                         f"member_type must be 'user' or 'user_group' got {member_type} instead"
                     )
                 changes['deleted'].append(
                     {'change_obj': change_obj, 'type': member_type,
                      'id': member_id, 'name': member_name, 'new_perm': perm})
 
             # if it's not recursive call for all,repos,groups
             # break the loop and don't proceed with other changes
             if recursive not in ['all', 'repos', 'groups']:
                 break
 
         return changes
 
     def update(self, repo_group, form_data):
         try:
             repo_group = self._get_repo_group(repo_group)
             old_path = repo_group.full_path
 
             # change properties
             if 'group_description' in form_data:
                 repo_group.group_description = form_data['group_description']
 
             if 'enable_locking' in form_data:
                 repo_group.enable_locking = form_data['enable_locking']
 
             if 'group_parent_id' in form_data:
                 parent_group = (
                     self._get_repo_group(form_data['group_parent_id']))
                 repo_group.group_parent_id = (
                     parent_group.group_id if parent_group else None)
                 repo_group.parent_group = parent_group
 
             # mikhail: to update the full_path, we have to explicitly
             # update group_name
             group_name = form_data.get('group_name', repo_group.name)
             repo_group.group_name = repo_group.get_new_name(group_name)
 
             new_path = repo_group.full_path
 
             affected_user_ids = []
             if 'user' in form_data:
                 old_owner_id = repo_group.user.user_id
                 new_owner = User.get_by_username(form_data['user'])
                 repo_group.user = new_owner
 
                 if old_owner_id != new_owner.user_id:
                     affected_user_ids = [new_owner.user_id, old_owner_id]
 
             self.sa.add(repo_group)
 
             # iterate over all members of this groups and do fixes
             # set locking if given
             # if obj is a repoGroup also fix the name of the group according
             # to the parent
             # if obj is a Repo fix it's name
             # this can be potentially heavy operation
             for obj in repo_group.recursive_groups_and_repos():
                 # set the value from it's parent
                 obj.enable_locking = repo_group.enable_locking
                 if isinstance(obj, RepoGroup):
                     new_name = obj.get_new_name(obj.name)
                     log.debug('Fixing group %s to new name %s',
                               obj.group_name, new_name)
                     obj.group_name = new_name
 
                 elif isinstance(obj, Repository):
                     # we need to get all repositories from this new group and
                     # rename them accordingly to new group path
                     new_name = obj.get_new_name(obj.just_name)
                     log.debug('Fixing repo %s to new name %s',
                               obj.repo_name, new_name)
                     obj.repo_name = new_name
 
                 self.sa.add(obj)
 
             self._rename_group(old_path, new_path)
 
             # Trigger update event.
             events.trigger(events.RepoGroupUpdateEvent(repo_group))
 
             if affected_user_ids:
                 PermissionModel().trigger_permission_flush(affected_user_ids)
 
             return repo_group
         except Exception:
             log.error(traceback.format_exc())
             raise
 
-    def delete(self, repo_group, force_delete=False, fs_remove=True):
+    def delete(self, repo_group, force_delete=False, fs_remove=True, call_events=True):
         repo_group = self._get_repo_group(repo_group)
         if not repo_group:
             return False
+        repo_group_name = repo_group.group_name
         try:
             self.sa.delete(repo_group)
             if fs_remove:
                 self._delete_filesystem_group(repo_group, force_delete)
             else:
                 log.debug('skipping removal from filesystem')
 
             # Trigger delete event.
-            events.trigger(events.RepoGroupDeleteEvent(repo_group))
-            return True
+            if call_events:
+                events.trigger(events.RepoGroupDeleteEvent(repo_group))
 
         except Exception:
-            log.error('Error removing repo_group %s', repo_group)
+            log.error('Error removing repo_group %s', repo_group_name)
             raise
 
+        return True
+
     def grant_user_permission(self, repo_group, user, perm):
         """
         Grant permission for user on given repository group, or update
         existing one if found
 
         :param repo_group: Instance of RepoGroup, repositories_group_id,
             or repositories_group name
         :param user: Instance of User, user_id or username
         :param perm: Instance of Permission, or permission_name
         """
 
         repo_group = self._get_repo_group(repo_group)
         user = self._get_user(user)
         permission = self._get_perm(perm)
 
         # check if we have that permission already
         obj = self.sa.query(UserRepoGroupToPerm)\
             .filter(UserRepoGroupToPerm.user == user)\
             .filter(UserRepoGroupToPerm.group == repo_group)\
             .scalar()
         if obj is None:
             # create new !
             obj = UserRepoGroupToPerm()
         obj.group = repo_group
         obj.user = user
         obj.permission = permission
         self.sa.add(obj)
         log.debug('Granted perm %s to %s on %s', perm, user, repo_group)
         action_logger_generic(
             'granted permission: {} to user: {} on repogroup: {}'.format(
                 perm, user, repo_group), namespace='security.repogroup')
         return obj
 
     def revoke_user_permission(self, repo_group, user):
         """
         Revoke permission for user on given repository group
 
         :param repo_group: Instance of RepoGroup, repositories_group_id,
             or repositories_group name
         :param user: Instance of User, user_id or username
         """
 
         repo_group = self._get_repo_group(repo_group)
         user = self._get_user(user)
 
         obj = self.sa.query(UserRepoGroupToPerm)\
             .filter(UserRepoGroupToPerm.user == user)\
             .filter(UserRepoGroupToPerm.group == repo_group)\
             .scalar()
         if obj:
             self.sa.delete(obj)
             log.debug('Revoked perm on %s on %s', repo_group, user)
             action_logger_generic(
                 'revoked permission from user: {} on repogroup: {}'.format(
                     user, repo_group), namespace='security.repogroup')
 
     def grant_user_group_permission(self, repo_group, group_name, perm):
         """
         Grant permission for user group on given repository group, or update
         existing one if found
 
         :param repo_group: Instance of RepoGroup, repositories_group_id,
             or repositories_group name
         :param group_name: Instance of UserGroup, users_group_id,
             or user group name
         :param perm: Instance of Permission, or permission_name
         """
         repo_group = self._get_repo_group(repo_group)
         group_name = self._get_user_group(group_name)
         permission = self._get_perm(perm)
 
         # check if we have that permission already
         obj = self.sa.query(UserGroupRepoGroupToPerm)\
             .filter(UserGroupRepoGroupToPerm.group == repo_group)\
             .filter(UserGroupRepoGroupToPerm.users_group == group_name)\
             .scalar()
 
         if obj is None:
             # create new
             obj = UserGroupRepoGroupToPerm()
 
         obj.group = repo_group
         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_group)
         action_logger_generic(
             'granted permission: {} to usergroup: {} on repogroup: {}'.format(
                 perm, group_name, repo_group), namespace='security.repogroup')
         return obj
 
     def revoke_user_group_permission(self, repo_group, group_name):
         """
         Revoke permission for user group on given repository group
 
         :param repo_group: Instance of RepoGroup, repositories_group_id,
             or repositories_group name
         :param group_name: Instance of UserGroup, users_group_id,
             or user group name
         """
         repo_group = self._get_repo_group(repo_group)
         group_name = self._get_user_group(group_name)
 
         obj = self.sa.query(UserGroupRepoGroupToPerm)\
             .filter(UserGroupRepoGroupToPerm.group == repo_group)\
             .filter(UserGroupRepoGroupToPerm.users_group == group_name)\
             .scalar()
         if obj:
             self.sa.delete(obj)
             log.debug('Revoked perm to %s on %s', repo_group, group_name)
             action_logger_generic(
                 'revoked permission from usergroup: {} on repogroup: {}'.format(
                     group_name, repo_group), namespace='security.repogroup')
 
     @classmethod
     def update_commit_cache(cls, repo_groups=None):
         if not repo_groups:
             repo_groups = RepoGroup.getAll()
         for repo_group in repo_groups:
             repo_group.update_commit_cache()
 
     def get_repo_groups_as_dict(self, repo_group_list=None, admin=False,
                                 super_user_actions=False):
 
         from pyramid.threadlocal import get_current_request
         _render = get_current_request().get_partial_renderer(
             'rhodecode:templates/data_table/_dt_elements.mako')
         c = _render.get_call_context()
         h = _render.get_helpers()
 
         def quick_menu(repo_group_name):
             return _render('quick_repo_group_menu', repo_group_name)
 
         def repo_group_lnk(repo_group_name):
             return _render('repo_group_name', repo_group_name)
 
         def last_change(last_change):
             if admin and isinstance(last_change, datetime.datetime) and not last_change.tzinfo:
                 ts = time.time()
                 utc_offset = (datetime.datetime.fromtimestamp(ts)
                               - datetime.datetime.utcfromtimestamp(ts)).total_seconds()
                 last_change = last_change + datetime.timedelta(seconds=utc_offset)
             return _render("last_change", last_change)
 
         def desc(desc, personal):
             return _render(
                 'repo_group_desc', desc, personal, c.visual.stylify_metatags)
 
         def repo_group_actions(repo_group_id, repo_group_name, gr_count):
             return _render(
                 'repo_group_actions', repo_group_id, repo_group_name, gr_count)
 
         def repo_group_name(repo_group_name, children_groups):
             return _render("repo_group_name", repo_group_name, children_groups)
 
         def user_profile(username):
             return _render('user_profile', username)
 
         repo_group_data = []
         for group in repo_group_list:
             # NOTE(marcink): because we use only raw column we need to load it like that
             changeset_cache = RepoGroup._load_changeset_cache(
                 '', group._changeset_cache)
             last_commit_change = RepoGroup._load_commit_change(changeset_cache)
             row = {
                 "menu": quick_menu(group.group_name),
                 "name": repo_group_lnk(group.group_name),
                 "name_raw": group.group_name,
 
                 "last_change": last_change(last_commit_change),
 
                 "last_changeset": "",
                 "last_changeset_raw": "",
 
                 "desc": desc(h.escape(group.group_description), group.personal),
                 "top_level_repos": 0,
                 "owner": user_profile(group.User.username)
             }
             if admin:
                 repo_count = group.repositories.count()
                 children_groups = list(map(
                     h.safe_str,
                     itertools.chain((g.name for g in group.parents),
                                     (x.name for x in [group]))))
                 row.update({
                     "action": repo_group_actions(
                         group.group_id, group.group_name, repo_count),
                     "top_level_repos": repo_count,
                     "name": repo_group_name(group.group_name, children_groups),
 
                 })
             repo_group_data.append(row)
 
         return repo_group_data
 
     def get_repo_groups_data_table(
             self, draw, start, limit,
             search_q, order_by, order_dir,
             auth_user, repo_group_id):
         from rhodecode.model.scm import RepoGroupList
 
         _perms = ['group.read', 'group.write', 'group.admin']
         repo_groups = RepoGroup.query() \
             .filter(RepoGroup.group_parent_id == repo_group_id) \
             .all()
         auth_repo_group_list = RepoGroupList(
             repo_groups, perm_set=_perms,
             extra_kwargs=dict(user=auth_user))
 
         allowed_ids = [-1]
         for repo_group in auth_repo_group_list:
             allowed_ids.append(repo_group.group_id)
 
         repo_groups_data_total_count = RepoGroup.query() \
             .filter(RepoGroup.group_parent_id == repo_group_id) \
             .filter(or_(
                 # generate multiple IN to fix limitation problems
                 *in_filter_generator(RepoGroup.group_id, allowed_ids))
             ) \
             .count()
 
         base_q = Session.query(
             RepoGroup.group_name,
             RepoGroup.group_name_hash,
             RepoGroup.group_description,
             RepoGroup.group_id,
             RepoGroup.personal,
             RepoGroup.updated_on,
             RepoGroup._changeset_cache,
             User,
             ) \
             .filter(RepoGroup.group_parent_id == repo_group_id) \
             .filter(or_(
                 # generate multiple IN to fix limitation problems
                 *in_filter_generator(RepoGroup.group_id, allowed_ids))
             ) \
             .join(User, User.user_id == RepoGroup.user_id) \
             .group_by(RepoGroup, User)
 
         repo_groups_data_total_filtered_count = base_q.count()
 
         sort_defined = False
 
         if order_by == 'group_name':
             sort_col = func.lower(RepoGroup.group_name)
             sort_defined = True
         elif order_by == 'user_username':
             sort_col = User.username
         else:
             sort_col = getattr(RepoGroup, order_by, None)
 
         if sort_defined or sort_col:
             if order_dir == 'asc':
                 sort_col = sort_col.asc()
             else:
                 sort_col = sort_col.desc()
 
         base_q = base_q.order_by(sort_col)
         base_q = base_q.offset(start).limit(limit)
 
         repo_group_list = base_q.all()
 
         repo_groups_data = RepoGroupModel().get_repo_groups_as_dict(
             repo_group_list=repo_group_list, admin=False)
 
         data = ({
             'draw': draw,
             'data': repo_groups_data,
             'recordsTotal': repo_groups_data_total_count,
             'recordsFiltered': repo_groups_data_total_filtered_count,
         })
         return data
 
     def _get_defaults(self, repo_group_name):
         repo_group = RepoGroup.get_by_group_name(repo_group_name)
 
         if repo_group is None:
             return None
 
         defaults = repo_group.get_dict()
         defaults['repo_group_name'] = repo_group.name
         defaults['repo_group_description'] = repo_group.group_description
         defaults['repo_group_enable_locking'] = repo_group.enable_locking
 
         # we use -1 as this is how in HTML, we mark an empty group
         defaults['repo_group'] = defaults['group_parent_id'] or -1
 
         # fill owner
         if repo_group.user:
             defaults.update({'user': repo_group.user.username})
         else:
             replacement_user = User.get_first_super_admin().username
             defaults.update({'user': replacement_user})
 
         return defaults

rhodecode/subscribers.py

@@ -1,422 +1,422 b''
 # Copyright (C) 2010-2024 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 io
 import shlex
 
 import math
 import re
 import os
 import datetime
 import logging
 import queue
 import subprocess
 
 
 from dateutil.parser import parse
 from pyramid.interfaces import IRoutesMapper
 from pyramid.settings import asbool
 from pyramid.path import AssetResolver
 from threading import Thread
 
 from rhodecode.config.jsroutes import generate_jsroutes_content
 from rhodecode.lib.base import get_auth_user
 from rhodecode.lib.celerylib.loader import set_celery_conf
 
 import rhodecode
 
 
 log = logging.getLogger(__name__)
 
 
 def add_renderer_globals(event):
     from rhodecode.lib import helpers
 
     # TODO: When executed in pyramid view context the request is not available
     # in the event. Find a better solution to get the request.
     from pyramid.threadlocal import get_current_request
     request = event['request'] or get_current_request()
 
     # Add Pyramid translation as '_' to context
     event['_'] = request.translate
     event['_ungettext'] = request.plularize
     event['h'] = helpers
 
 
 def set_user_lang(event):
     request = event.request
     cur_user = getattr(request, 'user', None)
 
     if cur_user:
         user_lang = cur_user.get_instance().user_data.get('language')
         if user_lang:
             log.debug('lang: setting current user:%s language to: %s', cur_user, user_lang)
             event.request._LOCALE_ = user_lang
 
 
 def update_celery_conf(event):
     log.debug('Setting celery config from new request')
     set_celery_conf(request=event.request, registry=event.request.registry)
 
 
 def add_request_user_context(event):
     """
     Adds auth user into request context
     """
 
     request = event.request
     # access req_id as soon as possible
     req_id = request.req_id
 
     if hasattr(request, 'vcs_call'):
         # skip vcs calls
         return
 
     if hasattr(request, 'rpc_method'):
         # skip api calls
         return
 
     auth_user, auth_token = get_auth_user(request)
     request.user = auth_user
     request.user_auth_token = auth_token
     request.environ['rc_auth_user'] = auth_user
     request.environ['rc_auth_user_id'] = str(auth_user.user_id)
     request.environ['rc_req_id'] = req_id
 
 
 def reset_log_bucket(event):
     """
     reset the log bucket on new request
     """
     request = event.request
     request.req_id_records_init()
 
 
 def scan_repositories_if_enabled(event):
     """
     This is subscribed to the `pyramid.events.ApplicationCreated` event. It
     does a repository scan if enabled in the settings.
     """
 
     settings = event.app.registry.settings
     vcs_server_enabled = settings['vcs.server.enable']
     import_on_startup = settings['startup.import_repos']
 
     if vcs_server_enabled and import_on_startup:
         from rhodecode.model.scm import ScmModel
         from rhodecode.lib.utils import repo2db_mapper
         scm = ScmModel()
         repositories = scm.repo_scan(scm.repos_path)
-        repo2db_mapper(repositories, remove_obsolete=False)
+        repo2db_mapper(repositories)
 
 
 def write_metadata_if_needed(event):
     """
     Writes upgrade metadata
     """
     import rhodecode
     from rhodecode.lib import system_info
     from rhodecode.lib import ext_json
 
     fname = '.rcmetadata.json'
     ini_loc = os.path.dirname(rhodecode.CONFIG.get('__file__'))
     metadata_destination = os.path.join(ini_loc, fname)
 
     def get_update_age():
         now = datetime.datetime.utcnow()
 
         with open(metadata_destination, 'rb') as f:
             data = ext_json.json.loads(f.read())
             if 'created_on' in data:
                 update_date = parse(data['created_on'])
                 diff = now - update_date
                 return diff.total_seconds() / 60.0
 
         return 0
 
     def write():
         configuration = system_info.SysInfo(
             system_info.rhodecode_config)()['value']
         license_token = configuration['config']['license_token']
 
         setup = dict(
             workers=configuration['config']['server:main'].get(
                 'workers', '?'),
             worker_type=configuration['config']['server:main'].get(
                 'worker_class', 'sync'),
         )
         dbinfo = system_info.SysInfo(system_info.database_info)()['value']
         del dbinfo['url']
 
         metadata = dict(
             desc='upgrade metadata info',
             license_token=license_token,
             created_on=datetime.datetime.utcnow().isoformat(),
             usage=system_info.SysInfo(system_info.usage_info)()['value'],
             platform=system_info.SysInfo(system_info.platform_type)()['value'],
             database=dbinfo,
             cpu=system_info.SysInfo(system_info.cpu)()['value'],
             memory=system_info.SysInfo(system_info.memory)()['value'],
             setup=setup
         )
 
         with open(metadata_destination, 'wb') as f:
             f.write(ext_json.json.dumps(metadata))
 
     settings = event.app.registry.settings
     if settings.get('metadata.skip'):
         return
 
     # only write this every 24h, workers restart caused unwanted delays
     try:
         age_in_min = get_update_age()
     except Exception:
         age_in_min = 0
 
     if age_in_min > 60 * 60 * 24:
         return
 
     try:
         write()
     except Exception:
         pass
 
 
 def write_usage_data(event):
     import rhodecode
     from rhodecode.lib import system_info
     from rhodecode.lib import ext_json
 
     settings = event.app.registry.settings
     instance_tag = settings.get('metadata.write_usage_tag')
     if not settings.get('metadata.write_usage'):
         return
 
     def get_update_age(dest_file):
         now = datetime.datetime.now(datetime.UTC)
 
         with open(dest_file, 'rb') as f:
             data = ext_json.json.loads(f.read())
             if 'created_on' in data:
                 update_date = parse(data['created_on'])
                 diff = now - update_date
                 return math.ceil(diff.total_seconds() / 60.0)
 
         return 0
 
     utc_date = datetime.datetime.now(datetime.UTC)
     hour_quarter = int(math.ceil((utc_date.hour + utc_date.minute/60.0) / 6.))
     fname = f'.rc_usage_{utc_date.year}{utc_date.month:02d}{utc_date.day:02d}_{hour_quarter}.json'
     ini_loc = os.path.dirname(rhodecode.CONFIG.get('__file__'))
 
     usage_dir = os.path.join(ini_loc, '.rcusage')
     if not os.path.isdir(usage_dir):
         os.makedirs(usage_dir)
     usage_metadata_destination = os.path.join(usage_dir, fname)
 
     try:
         age_in_min = get_update_age(usage_metadata_destination)
     except Exception:
         age_in_min = 0
 
     # write every 6th hour
     if age_in_min and age_in_min < 60 * 6:
         log.debug('Usage file created %s minutes ago, skipping (threshold: %s minutes)...',
                   age_in_min, 60 * 6)
         return
 
     def write(dest_file):
         configuration = system_info.SysInfo(system_info.rhodecode_config)()['value']
         license_token = configuration['config']['license_token']
 
         metadata = dict(
             desc='Usage data',
             instance_tag=instance_tag,
             license_token=license_token,
             created_on=datetime.datetime.utcnow().isoformat(),
             usage=system_info.SysInfo(system_info.usage_info)()['value'],
         )
 
         with open(dest_file, 'wb') as f:
             f.write(ext_json.formatted_json(metadata))
 
     try:
         log.debug('Writing usage file at: %s', usage_metadata_destination)
         write(usage_metadata_destination)
     except Exception:
         pass
 
 
 def write_js_routes_if_enabled(event):
     registry = event.app.registry
 
     mapper = registry.queryUtility(IRoutesMapper)
     _argument_prog = re.compile(r'\{(.*?)\}|:\((.*)\)')
 
     def _extract_route_information(route):
         """
         Convert a route into tuple(name, path, args), eg:
             ('show_user', '/profile/%(username)s', ['username'])
         """
 
         route_path = route.pattern
         pattern = route.pattern
 
         def replace(matchobj):
             if matchobj.group(1):
                 return "%%(%s)s" % matchobj.group(1).split(':')[0]
             else:
                 return "%%(%s)s" % matchobj.group(2)
 
         route_path = _argument_prog.sub(replace, route_path)
 
         if not route_path.startswith('/'):
             route_path = f'/{route_path}'
 
         return (
             route.name,
             route_path,
             [(arg[0].split(':')[0] if arg[0] != '' else arg[1])
              for arg in _argument_prog.findall(pattern)]
         )
 
     def get_routes():
         # pyramid routes
         for route in mapper.get_routes():
             if not route.name.startswith('__'):
                 yield _extract_route_information(route)
 
     if asbool(registry.settings.get('generate_js_files', 'false')):
         static_path = AssetResolver().resolve('rhodecode:public').abspath()
         jsroutes = get_routes()
         jsroutes_file_content = generate_jsroutes_content(jsroutes)
         jsroutes_file_path = os.path.join(
             static_path, 'js', 'rhodecode', 'routes.js')
 
         try:
             with open(jsroutes_file_path, 'w', encoding='utf-8') as f:
                 f.write(jsroutes_file_content)
             log.debug('generated JS files in %s', jsroutes_file_path)
         except Exception:
             log.exception('Failed to write routes.js into %s', jsroutes_file_path)
 
 
 def import_license_if_present(event):
     """
     This is subscribed to the `pyramid.events.ApplicationCreated` event. It
     does a import license key based on a presence of the file.
     """
     settings = event.app.registry.settings
 
     rhodecode_edition_id = settings.get('rhodecode.edition_id')
     license_file_path = settings.get('license.import_path')
     force = settings.get('license.import_path_mode') == 'force'
 
     if license_file_path and rhodecode_edition_id == 'EE':
         log.debug('license.import_path= is set importing license from %s', license_file_path)
         from rhodecode.model.meta import Session
         from rhodecode.model.license import apply_license_from_file
         try:
             apply_license_from_file(license_file_path, force=force)
             Session().commit()
         except OSError:
             log.exception('Failed to import license from %s, make sure this file exists', license_file_path)
 
 
 class Subscriber(object):
     """
     Base class for subscribers to the pyramid event system.
     """
     def __call__(self, event):
         self.run(event)
 
     def run(self, event):
         raise NotImplementedError('Subclass has to implement this.')
 
 
 class AsyncSubscriber(Subscriber):
     """
     Subscriber that handles the execution of events in a separate task to not
     block the execution of the code which triggers the event. It puts the
     received events into a queue from which the worker process takes them in
     order.
     """
     def __init__(self):
         self._stop = False
         self._eventq = queue.Queue()
         self._worker = self.create_worker()
         self._worker.start()
 
     def __call__(self, event):
         self._eventq.put(event)
 
     def create_worker(self):
         worker = Thread(target=self.do_work)
         worker.daemon = True
         return worker
 
     def stop_worker(self):
         self._stop = False
         self._eventq.put(None)
         self._worker.join()
 
     def do_work(self):
         while not self._stop:
             event = self._eventq.get()
             if event is not None:
                 self.run(event)
 
 
 class AsyncSubprocessSubscriber(AsyncSubscriber):
     """
     Subscriber that uses the subprocess module to execute a command if an
     event is received. Events are handled asynchronously::
 
         subscriber = AsyncSubprocessSubscriber('ls -la', timeout=10)
         subscriber(dummyEvent) # running __call__(event)
 
     """
 
     def __init__(self, cmd, timeout=None):
         if not isinstance(cmd, (list, tuple)):
             cmd = shlex.split(cmd)
         super().__init__()
         self._cmd = cmd
         self._timeout = timeout
 
     def run(self, event):
         cmd = self._cmd
         timeout = self._timeout
         log.debug('Executing command %s.', cmd)
 
         try:
             output = subprocess.check_output(
                 cmd, timeout=timeout, stderr=subprocess.STDOUT)
             log.debug('Command finished %s', cmd)
             if output:
                 log.debug('Command output: %s', output)
         except subprocess.TimeoutExpired as e:
             log.exception('Timeout while executing command.')
             if e.output:
                 log.error('Command output: %s', e.output)
         except subprocess.CalledProcessError as e:
             log.exception('Error while executing command.')
             if e.output:
                 log.error('Command output: %s', e.output)
         except Exception:
             log.exception(
                 'Exception while executing command %s.', cmd)

rhodecode/templates/admin/settings/settings_mapping.mako

@@ -1,33 +1,45 b''
-${h.secure_form(h.route_path('admin_settings_mapping_update'), request=request)}
+
 
 <div class="panel panel-default">
     <div class="panel-heading">
-        <h3 class="panel-title">${_('Import New Groups or Repositories')}</h3>
+        <h3 class="panel-title">${_('Import new repository groups and repositories')}</h3>
     </div>
     <div class="panel-body">
-
+    ${h.secure_form(h.route_path('admin_settings_mapping_create'), request=request)}
         <p>
-            ${_('This function will scann all data under the current storage path location at')} <code>${c.storage_path}</code>
+            ${_('This function will scan all data under the current storage path location at')} <code>${c.storage_path}</code><br/>
+            ${_('Each folder will be imported as a new repository group, and each repository found will be also imported to root level or corresponding repository group')}
         </p>
 
         <div class="checkbox">
-            ${h.checkbox('destroy',True)}
-            <label for="destroy">${_('Destroy old data')}</label>
-        </div>
-        <span class="help-block">${_('In case a repository or a group was deleted from the filesystem and it still exists in the database, check this option to remove obsolete data from the database.')}</span>
-
-        <div class="checkbox">
             ${h.checkbox('invalidate',True)}
             <label for="invalidate"> ${_('Invalidate cache for all repositories')}</label>
         </div>
         <span class="help-block">${_('Each cache data for repositories will be cleaned with this option selected. Use this to reload data and clear cache keys.')}</span>
 
         <div class="buttons">
-            ${h.submit('rescan',_('Rescan Filesystem'),class_="btn")}
+            ${h.submit('rescan',_('Scan filesystem'),class_="btn")}
         </div>
-
+    ${h.end_form()}
     </div>
 </div>
 
 
-${h.end_form()}
+<div class="panel panel-default">
+    <div class="panel-heading">
+        <h3 class="panel-title">${_('Cleanup removed Repository Groups or Repositories')}</h3>
+    </div>
+    <div class="panel-body">
+    ${h.secure_form(h.route_path('admin_settings_mapping_cleanup'), request=request)}
+        <p>
+            ${_('This function will scan all data under the current storage path location at')} <code>${c.storage_path}</code>
+            ${_('Then it will remove all repository groups and repositories that are no longer present in the filesystem.')}
+        </p>
+
+        <div class="buttons">
+            ${h.submit('rescan',_('Cleanup filesystem'),class_="btn btn-danger")}
+        </div>
+    ${h.end_form()}
+    </div>
+</div>
+

rhodecode/tests/fixtures/fixture_utils.py

@@ -1,1695 +1,1697 b''
 # Copyright (C) 2010-2024 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 collections
 import datetime
 import os
 import re
 import pprint
 import shutil
 import socket
 import subprocess
 import time
 import uuid
 import dateutil.tz
 import logging
 import functools
 import textwrap
 
 import mock
 import pyramid.testing
 import pytest
 import colander
 import requests
 import pyramid.paster
 
 import rhodecode
 import rhodecode.lib
 from rhodecode.model.changeset_status import ChangesetStatusModel
 from rhodecode.model.comment import CommentsModel
 from rhodecode.model.db import (
     PullRequest,
     PullRequestReviewers,
     Repository,
     RhodeCodeSetting,
     ChangesetStatus,
     RepoGroup,
     UserGroup,
     RepoRhodeCodeUi,
     RepoRhodeCodeSetting,
     RhodeCodeUi,
 )
 from rhodecode.model.meta import Session
 from rhodecode.model.pull_request import PullRequestModel
 from rhodecode.model.repo import RepoModel
 from rhodecode.model.repo_group import RepoGroupModel
 from rhodecode.model.user import UserModel
 from rhodecode.model.settings import VcsSettingsModel
 from rhodecode.model.user_group import UserGroupModel
 from rhodecode.model.integration import IntegrationModel
 from rhodecode.integrations import integration_type_registry
 from rhodecode.integrations.types.base import IntegrationTypeBase
 from rhodecode.lib.utils import repo2db_mapper
 from rhodecode.lib.str_utils import safe_bytes
 from rhodecode.lib.hash_utils import sha1_safe
 from rhodecode.lib.vcs.backends import get_backend
 from rhodecode.lib.vcs.nodes import FileNode
 from rhodecode.lib.base import bootstrap_config
 from rhodecode.tests import (
     login_user_session,
     get_new_dir,
     utils,
     TESTS_TMP_PATH,
     TEST_USER_ADMIN_LOGIN,
     TEST_USER_REGULAR_LOGIN,
     TEST_USER_REGULAR2_LOGIN,
     TEST_USER_REGULAR_PASS,
     console_printer,
 )
 from rhodecode.tests.utils import set_anonymous_access
 from rhodecode.tests.fixtures.rc_fixture import Fixture
 from rhodecode.config import utils as config_utils
 
 log = logging.getLogger(__name__)
 
 
 def cmp(a, b):
     # backport cmp from python2 so we can still use it in the custom code in this module
     return (a > b) - (a < b)
 
 
 @pytest.fixture(scope="session")
 def http_environ_session():
     """
     Allow to use "http_environ" in session scope.
     """
     return plain_http_environ()
 
 
 def plain_http_host_stub():
     """
     Value of HTTP_HOST in the test run.
     """
     return "example.com:80"
 
 
 def plain_config_stub(request, request_stub):
     """
     Set up pyramid.testing and return the Configurator.
     """
 
     config = bootstrap_config(request=request_stub)
 
     @request.addfinalizer
     def cleanup():
         pyramid.testing.tearDown()
 
     return config
 
 
 def plain_request_stub():
     """
     Stub request object.
     """
     from rhodecode.lib.base import bootstrap_request
 
     _request = bootstrap_request(scheme="https")
     return _request
 
 
 @pytest.fixture()
 def http_host_stub():
     """
     Value of HTTP_HOST in the test run.
     """
     return plain_http_host_stub()
 
 
 def plain_http_host_only_stub():
     """
     Value of HTTP_HOST in the test run.
     """
     return plain_http_host_stub().split(":")[0]
 
 
 @pytest.fixture()
 def http_host_only_stub():
     """
     Value of HTTP_HOST in the test run.
     """
     return plain_http_host_only_stub()
 
 
 def plain_http_environ():
     """
     HTTP extra environ keys.
 
     Used by the test application and as well for setting up the pylons
     environment. In the case of the fixture "app" it should be possible
     to override this for a specific test case.
     """
     return {
         "SERVER_NAME": plain_http_host_only_stub(),
         "SERVER_PORT": plain_http_host_stub().split(":")[1],
         "HTTP_HOST": plain_http_host_stub(),
         "HTTP_USER_AGENT": "rc-test-agent",
         "REQUEST_METHOD": "GET",
     }
 
 
 @pytest.fixture(scope="session")
 def baseapp(request, ini_config, http_environ_session, available_port_factory, vcsserver_factory, celery_factory):
     from rhodecode.lib.config_utils import get_app_config
     from rhodecode.config.middleware import make_pyramid_app
 
     log.info("Using the RhodeCode configuration:%s", ini_config)
     pyramid.paster.setup_logging(ini_config)
 
     settings = get_app_config(ini_config)
     store_dir = os.path.dirname(ini_config)
 
     # start vcsserver
     _vcsserver_port = available_port_factory()
     vcsserver_instance = vcsserver_factory(
         request,
         store_dir=store_dir,
         port=_vcsserver_port,
         info_prefix="base-app-"
     )
 
     settings["vcs.server"] = vcsserver_instance.bind_addr
 
     # we skip setting store_dir for baseapp, it's internally set via testing rhodecode.ini
     # settings['repo_store.path'] = str(store_dir)
     console_printer(f' :warning: [green]pytest-setup[/green] Starting base pyramid-app: {ini_config}')
     pyramid_baseapp = make_pyramid_app({"__file__": ini_config}, **settings)
 
     # start celery
     celery_factory(
         request,
         store_dir=store_dir,
         port=None,
         info_prefix="base-app-",
         overrides=(
             {'handler_console': {'level': 'DEBUG'}},
             {'app:main': {'vcs.server': vcsserver_instance.bind_addr}},
             {'app:main': {'repo_store.path': store_dir}}
         )
     )
 
     return pyramid_baseapp
 
 
 @pytest.fixture(scope="session")
 def app_settings(baseapp, ini_config):
     """
     Settings dictionary used to create the app.
 
     Parses the ini file and passes the result through the sanitize and apply
     defaults mechanism in `rhodecode.config.middleware`.
     """
     return baseapp.config.get_settings()
 
 
 @pytest.fixture(scope="session")
 def db_connection(ini_settings):
     # Initialize the database connection.
     config_utils.initialize_database(ini_settings)
 
 
 LoginData = collections.namedtuple("LoginData", ("csrf_token", "user"))
 
 
 def _autologin_user(app, *args):
     session = login_user_session(app, *args)
     csrf_token = rhodecode.lib.auth.get_csrf_token(session)
     return LoginData(csrf_token, session["rhodecode_user"])
 
 
 @pytest.fixture()
 def autologin_user(app):
     """
     Utility fixture which makes sure that the admin user is logged in
     """
     return _autologin_user(app)
 
 
 @pytest.fixture()
 def autologin_regular_user(app):
     """
     Utility fixture which makes sure that the regular user is logged in
     """
     return _autologin_user(app, TEST_USER_REGULAR_LOGIN, TEST_USER_REGULAR_PASS)
 
 
 @pytest.fixture(scope="function")
 def csrf_token(request, autologin_user):
     return autologin_user.csrf_token
 
 
 @pytest.fixture(scope="function")
 def xhr_header(request):
     return {"HTTP_X_REQUESTED_WITH": "XMLHttpRequest"}
 
 
 @pytest.fixture()
 def real_crypto_backend(monkeypatch):
     """
     Switch the production crypto backend on for this test.
 
     During the test run the crypto backend is replaced with a faster
     implementation based on the MD5 algorithm.
     """
     monkeypatch.setattr(rhodecode, "is_test", False)
 
 
 @pytest.fixture(scope="class")
 def index_location(request, baseapp):
     index_location = baseapp.config.get_settings()["search.location"]
     if request.cls:
         request.cls.index_location = index_location
     return index_location
 
 
 @pytest.fixture(scope="session", autouse=True)
 def tests_tmp_path(request):
     """
     Create temporary directory to be used during the test session.
     """
     if not os.path.exists(TESTS_TMP_PATH):
         os.makedirs(TESTS_TMP_PATH)
 
     if not request.config.getoption("--keep-tmp-path"):
 
         @request.addfinalizer
         def remove_tmp_path():
             shutil.rmtree(TESTS_TMP_PATH)
 
     return TESTS_TMP_PATH
 
 
 @pytest.fixture()
 def test_repo_group(request):
     """
     Create a temporary repository group, and destroy it after
     usage automatically
     """
     fixture = Fixture()
     repogroupid = "test_repo_group_%s" % str(time.time()).replace(".", "")
     repo_group = fixture.create_repo_group(repogroupid)
 
     def _cleanup():
         fixture.destroy_repo_group(repogroupid)
 
     request.addfinalizer(_cleanup)
     return repo_group
 
 
 @pytest.fixture()
 def test_user_group(request):
     """
     Create a temporary user group, and destroy it after
     usage automatically
     """
     fixture = Fixture()
     usergroupid = "test_user_group_%s" % str(time.time()).replace(".", "")
     user_group = fixture.create_user_group(usergroupid)
 
     def _cleanup():
         fixture.destroy_user_group(user_group)
 
     request.addfinalizer(_cleanup)
     return user_group
 
 
 @pytest.fixture(scope="session")
 def test_repo(request):
     container = TestRepoContainer()
     request.addfinalizer(container._cleanup)
     return container
 
 
 class TestRepoContainer(object):
     """
     Container for test repositories which are used read only.
 
     Repositories will be created on demand and re-used during the lifetime
     of this object.
 
     Usage to get the svn test repository "minimal"::
 
        test_repo = TestContainer()
        repo = test_repo('minimal', 'svn')
 
     """
 
     dump_extractors = {
         "git": utils.extract_git_repo_from_dump,
         "hg": utils.extract_hg_repo_from_dump,
         "svn": utils.extract_svn_repo_from_dump,
     }
 
     def __init__(self):
         self._cleanup_repos = []
         self._fixture = Fixture()
         self._repos = {}
 
     def __call__(self, dump_name, backend_alias, config=None):
         key = (dump_name, backend_alias)
         if key not in self._repos:
             repo = self._create_repo(dump_name, backend_alias, config)
             self._repos[key] = repo.repo_id
         return Repository.get(self._repos[key])
 
     def _create_repo(self, dump_name, backend_alias, config):
         repo_name = f"{backend_alias}-{dump_name}"
         backend = get_backend(backend_alias)
         dump_extractor = self.dump_extractors[backend_alias]
         repo_path = dump_extractor(dump_name, repo_name)
 
         vcs_repo = backend(repo_path, config=config)
         repo2db_mapper({repo_name: vcs_repo})
 
         repo = RepoModel().get_by_repo_name(repo_name)
         self._cleanup_repos.append(repo_name)
         return repo
 
     def _cleanup(self):
         for repo_name in reversed(self._cleanup_repos):
             self._fixture.destroy_repo(repo_name)
 
 
 def backend_base(request, backend_alias, test_repo):
     if backend_alias not in request.config.getoption("--backends"):
         pytest.skip(f"Backend {backend_alias} not selected.")
 
     utils.check_xfail_backends(request.node, backend_alias)
     utils.check_skip_backends(request.node, backend_alias)
 
     repo_name = "vcs_test_%s" % (backend_alias,)
     backend = Backend(
         alias=backend_alias, repo_name=repo_name, test_name=request.node.name, test_repo_container=test_repo
     )
     request.addfinalizer(backend.cleanup)
     return backend
 
 
 @pytest.fixture()
 def backend(request, backend_alias, baseapp, test_repo):
     """
     Parametrized fixture which represents a single backend implementation.
 
     It respects the option `--backends` to focus the test run on specific
     backend implementations.
 
     It also supports `pytest.mark.xfail_backends` to mark tests as failing
     for specific backends. This is intended as a utility for incremental
     development of a new backend implementation.
     """
     return backend_base(request, backend_alias, test_repo)
 
 
 @pytest.fixture()
 def backend_git(request, baseapp, test_repo):
     return backend_base(request, "git", test_repo)
 
 
 @pytest.fixture()
 def backend_hg(request, baseapp, test_repo):
     return backend_base(request, "hg", test_repo)
 
 
 @pytest.fixture()
 def backend_svn(request, baseapp, test_repo):
     return backend_base(request, "svn", test_repo)
 
 
 @pytest.fixture()
 def backend_random(backend_git):
     """
     Use this to express that your tests need "a backend.
 
     A few of our tests need a backend, so that we can run the code. This
     fixture is intended to be used for such cases. It will pick one of the
     backends and run the tests.
 
     The fixture `backend` would run the test multiple times for each
     available backend which is a pure waste of time if the test is
     independent of the backend type.
     """
     # TODO: johbo: Change this to pick a random backend
     return backend_git
 
 
 @pytest.fixture()
 def backend_stub(backend_git):
     """
     Use this to express that your tests need a backend stub
 
     TODO: mikhail: Implement a real stub logic instead of returning
     a git backend
     """
     return backend_git
 
 
 @pytest.fixture()
 def repo_stub(backend_stub):
     """
     Use this to express that your tests need a repository stub
     """
     return backend_stub.create_repo()
 
 
 class Backend(object):
     """
     Represents the test configuration for one supported backend
 
     Provides easy access to different test repositories based on
     `__getitem__`. Such repositories will only be created once per test
     session.
     """
 
     invalid_repo_name = re.compile(r"[^0-9a-zA-Z]+")
     _master_repo = None
     _master_repo_path = ""
     _commit_ids = {}
 
     def __init__(self, alias, repo_name, test_name, test_repo_container):
         self.alias = alias
         self.repo_name = repo_name
         self._cleanup_repos = []
         self._test_name = test_name
         self._test_repo_container = test_repo_container
         # TODO: johbo: Used as a delegate interim. Not yet sure if Backend or
         # Fixture will survive in the end.
         self._fixture = Fixture()
 
     def __getitem__(self, key):
         return self._test_repo_container(key, self.alias)
 
     def create_test_repo(self, key, config=None):
         return self._test_repo_container(key, self.alias, config)
 
     @property
     def repo_id(self):
         # just fake some repo_id
         return self.repo.repo_id
 
     @property
     def repo(self):
         """
         Returns the "current" repository. This is the vcs_test repo or the
         last repo which has been created with `create_repo`.
         """
         from rhodecode.model.db import Repository
 
         return Repository.get_by_repo_name(self.repo_name)
 
     @property
     def default_branch_name(self):
         VcsRepository = get_backend(self.alias)
         return VcsRepository.DEFAULT_BRANCH_NAME
 
     @property
     def default_head_id(self):
         """
         Returns the default head id of the underlying backend.
 
         This will be the default branch name in case the backend does have a
         default branch. In the other cases it will point to a valid head
         which can serve as the base to create a new commit on top of it.
         """
         vcsrepo = self.repo.scm_instance()
         head_id = vcsrepo.DEFAULT_BRANCH_NAME or vcsrepo.commit_ids[-1]
         return head_id
 
     @property
     def commit_ids(self):
         """
         Returns the list of commits for the last created repository
         """
         return self._commit_ids
 
     def create_master_repo(self, commits):
         """
         Create a repository and remember it as a template.
 
         This allows to easily create derived repositories to construct
         more complex scenarios for diff, compare and pull requests.
 
         Returns a commit map which maps from commit message to raw_id.
         """
         self._master_repo = self.create_repo(commits=commits)
         self._master_repo_path = self._master_repo.repo_full_path
 
         return self._commit_ids
 
     def create_repo(self, commits=None, number_of_commits=0, heads=None, name_suffix="", bare=False, **kwargs):
         """
         Create a repository and record it for later cleanup.
 
         :param commits: Optional. A sequence of dict instances.
            Will add a commit per entry to the new repository.
         :param number_of_commits: Optional. If set to a number, this number of
            commits will be added to the new repository.
         :param heads: Optional. Can be set to a sequence of of commit
            names which shall be pulled in from the master repository.
         :param name_suffix: adds special suffix to generated repo name
         :param bare: set a repo as bare (no checkout)
         """
         self.repo_name = self._next_repo_name() + name_suffix
         repo = self._fixture.create_repo(self.repo_name, repo_type=self.alias, bare=bare, **kwargs)
         self._cleanup_repos.append(repo.repo_name)
 
         commits = commits or [{"message": f"Commit {x} of {self.repo_name}"} for x in range(number_of_commits)]
         vcs_repo = repo.scm_instance()
         vcs_repo.count()
         self._add_commits_to_repo(vcs_repo, commits)
         if heads:
             self.pull_heads(repo, heads)
 
         return repo
 
     def pull_heads(self, repo, heads, do_fetch=False):
         """
         Make sure that repo contains all commits mentioned in `heads`
         """
         vcsrepo = repo.scm_instance()
         vcsrepo.config.clear_section("hooks")
         commit_ids = [self._commit_ids[h] for h in heads]
         if do_fetch:
             vcsrepo.fetch(self._master_repo_path, commit_ids=commit_ids)
         vcsrepo.pull(self._master_repo_path, commit_ids=commit_ids)
 
     def create_fork(self):
         repo_to_fork = self.repo_name
         self.repo_name = self._next_repo_name()
         repo = self._fixture.create_fork(repo_to_fork, self.repo_name)
         self._cleanup_repos.append(self.repo_name)
         return repo
 
     def new_repo_name(self, suffix=""):
         self.repo_name = self._next_repo_name() + suffix
         self._cleanup_repos.append(self.repo_name)
         return self.repo_name
 
     def _next_repo_name(self):
         return "%s_%s" % (self.invalid_repo_name.sub("_", self._test_name), len(self._cleanup_repos))
 
     def ensure_file(self, filename, content=b"Test content\n"):
         assert self._cleanup_repos, "Avoid writing into vcs_test repos"
         commits = [
             {
                 "added": [
                     FileNode(filename, content=content),
                 ]
             },
         ]
         self._add_commits_to_repo(self.repo.scm_instance(), commits)
 
     def enable_downloads(self):
         repo = self.repo
         repo.enable_downloads = True
         Session().add(repo)
         Session().commit()
 
     def cleanup(self):
         for repo_name in reversed(self._cleanup_repos):
             self._fixture.destroy_repo(repo_name)
 
     def _add_commits_to_repo(self, repo, commits):
         commit_ids = _add_commits_to_repo(repo, commits)
         if not commit_ids:
             return
         self._commit_ids = commit_ids
 
         # Creating refs for Git to allow fetching them from remote repository
         if self.alias == "git":
             refs = {}
             for message in self._commit_ids:
                 cleanup_message = message.replace(" ", "")
                 ref_name = f"refs/test-refs/{cleanup_message}"
                 refs[ref_name] = self._commit_ids[message]
             self._create_refs(repo, refs)
 
     def _create_refs(self, repo, refs):
         for ref_name, ref_val in refs.items():
             repo.set_refs(ref_name, ref_val)
 
 
 class VcsBackend(object):
     """
     Represents the test configuration for one supported vcs backend.
     """
 
     invalid_repo_name = re.compile(r"[^0-9a-zA-Z]+")
 
     def __init__(self, alias, repo_path, test_name, test_repo_container):
         self.alias = alias
         self._repo_path = repo_path
         self._cleanup_repos = []
         self._test_name = test_name
         self._test_repo_container = test_repo_container
 
     def __getitem__(self, key):
         return self._test_repo_container(key, self.alias).scm_instance()
 
     def __repr__(self):
         return f"{self.__class__.__name__}(alias={self.alias}, repo={self._repo_path})"
 
     @property
     def repo(self):
         """
         Returns the "current" repository. This is the vcs_test repo of the last
         repo which has been created.
         """
         Repository = get_backend(self.alias)
         return Repository(self._repo_path)
 
     @property
     def backend(self):
         """
         Returns the backend implementation class.
         """
         return get_backend(self.alias)
 
     def create_repo(self, commits=None, number_of_commits=0, _clone_repo=None, bare=False):
         repo_name = self._next_repo_name()
         self._repo_path = get_new_dir(repo_name)
         repo_class = get_backend(self.alias)
         src_url = None
         if _clone_repo:
             src_url = _clone_repo.path
         repo = repo_class(self._repo_path, create=True, src_url=src_url, bare=bare)
         self._cleanup_repos.append(repo)
 
         commits = commits or [{"message": "Commit %s of %s" % (x, repo_name)} for x in range(number_of_commits)]
         _add_commits_to_repo(repo, commits)
         return repo
 
     def clone_repo(self, repo):
         return self.create_repo(_clone_repo=repo)
 
     def cleanup(self):
         for repo in self._cleanup_repos:
             shutil.rmtree(repo.path)
 
     def new_repo_path(self):
         repo_name = self._next_repo_name()
         self._repo_path = get_new_dir(repo_name)
         return self._repo_path
 
     def _next_repo_name(self):
         return "{}_{}".format(self.invalid_repo_name.sub("_", self._test_name), len(self._cleanup_repos))
 
     def add_file(self, repo, filename, content="Test content\n"):
         imc = repo.in_memory_commit
         imc.add(FileNode(safe_bytes(filename), content=safe_bytes(content)))
         imc.commit(message="Automatic commit from vcsbackend fixture", author="Automatic <[e-mail]>")
 
     def ensure_file(self, filename, content="Test content\n"):
         assert self._cleanup_repos, "Avoid writing into vcs_test repos"
         self.add_file(self.repo, filename, content)
 
 
 def vcsbackend_base(request, backend_alias, tests_tmp_path, baseapp, test_repo) -> VcsBackend:
     if backend_alias not in request.config.getoption("--backends"):
         pytest.skip("Backend %s not selected." % (backend_alias,))
 
     utils.check_xfail_backends(request.node, backend_alias)
     utils.check_skip_backends(request.node, backend_alias)
 
     repo_name = f"vcs_test_{backend_alias}"
     repo_path = os.path.join(tests_tmp_path, repo_name)
     backend = VcsBackend(
         alias=backend_alias, repo_path=repo_path, test_name=request.node.name, test_repo_container=test_repo
     )
     request.addfinalizer(backend.cleanup)
     return backend
 
 
 @pytest.fixture()
 def vcsbackend(request, backend_alias, tests_tmp_path, baseapp, test_repo):
     """
     Parametrized fixture which represents a single vcs backend implementation.
 
     See the fixture `backend` for more details. This one implements the same
     concept, but on vcs level. So it does not provide model instances etc.
 
     Parameters are generated dynamically, see :func:`pytest_generate_tests`
     for how this works.
     """
     return vcsbackend_base(request, backend_alias, tests_tmp_path, baseapp, test_repo)
 
 
 @pytest.fixture()
 def vcsbackend_git(request, tests_tmp_path, baseapp, test_repo):
     return vcsbackend_base(request, "git", tests_tmp_path, baseapp, test_repo)
 
 
 @pytest.fixture()
 def vcsbackend_hg(request, tests_tmp_path, baseapp, test_repo):
     return vcsbackend_base(request, "hg", tests_tmp_path, baseapp, test_repo)
 
 
 @pytest.fixture()
 def vcsbackend_svn(request, tests_tmp_path, baseapp, test_repo):
     return vcsbackend_base(request, "svn", tests_tmp_path, baseapp, test_repo)
 
 
 @pytest.fixture()
 def vcsbackend_stub(vcsbackend_git):
     """
     Use this to express that your test just needs a stub of a vcsbackend.
 
     Plan is to eventually implement an in-memory stub to speed tests up.
     """
     return vcsbackend_git
 
 
 def _add_commits_to_repo(vcs_repo, commits):
     commit_ids = {}
     if not commits:
         return commit_ids
 
     imc = vcs_repo.in_memory_commit
 
     for idx, commit in enumerate(commits):
         message = str(commit.get("message", f"Commit {idx}"))
 
         for node in commit.get("added", []):
             imc.add(FileNode(safe_bytes(node.path), content=node.content))
         for node in commit.get("changed", []):
             imc.change(FileNode(safe_bytes(node.path), content=node.content))
         for node in commit.get("removed", []):
             imc.remove(FileNode(safe_bytes(node.path)))
 
         parents = [vcs_repo.get_commit(commit_id=commit_ids[p]) for p in commit.get("parents", [])]
 
         operations = ("added", "changed", "removed")
         if not any((commit.get(o) for o in operations)):
             imc.add(FileNode(b"file_%b" % safe_bytes(str(idx)), content=safe_bytes(message)))
 
         commit = imc.commit(
             message=message,
             author=str(commit.get("author", "Automatic <[e-mail]>")),
             date=commit.get("date"),
             branch=commit.get("branch"),
             parents=parents,
         )
 
         commit_ids[commit.message] = commit.raw_id
 
     return commit_ids
 
 
 @pytest.fixture()
 def reposerver(request):
     """
     Allows to serve a backend repository
     """
 
     repo_server = RepoServer()
     request.addfinalizer(repo_server.cleanup)
     return repo_server
 
 
 class RepoServer(object):
     """
     Utility to serve a local repository for the duration of a test case.
 
     Supports only Subversion so far.
     """
 
     url = None
 
     def __init__(self):
         self._cleanup_servers = []
 
     def serve(self, vcsrepo):
         if vcsrepo.alias != "svn":
             raise TypeError("Backend %s not supported" % vcsrepo.alias)
 
         proc = subprocess.Popen(
             ["svnserve", "-d", "--foreground", "--listen-host", "localhost", "--root", vcsrepo.path]
         )
         self._cleanup_servers.append(proc)
         self.url = "svn://localhost"
 
     def cleanup(self):
         for proc in self._cleanup_servers:
             proc.terminate()
 
 
 @pytest.fixture()
 def pr_util(backend, request, config_stub):
     """
     Utility for tests of models and for functional tests around pull requests.
 
     It gives an instance of :class:`PRTestUtility` which provides various
     utility methods around one pull request.
 
     This fixture uses `backend` and inherits its parameterization.
     """
 
     util = PRTestUtility(backend)
     request.addfinalizer(util.cleanup)
 
     return util
 
 
 class PRTestUtility(object):
     pull_request = None
     pull_request_id = None
     mergeable_patcher = None
     mergeable_mock = None
     notification_patcher = None
     commit_ids: dict
 
     def __init__(self, backend):
         self.backend = backend
 
     def create_pull_request(
         self,
         commits=None,
         target_head=None,
         source_head=None,
         revisions=None,
         approved=False,
         author=None,
         mergeable=False,
         enable_notifications=True,
         name_suffix="",
         reviewers=None,
         observers=None,
         title="Test",
         description="Description",
     ):
         self.set_mergeable(mergeable)
         if not enable_notifications:
             # mock notification side effect
             self.notification_patcher = mock.patch("rhodecode.model.notification.NotificationModel.create")
             self.notification_patcher.start()
 
         if not self.pull_request:
             if not commits:
                 commits = [
                     {"message": "c1"},
                     {"message": "c2"},
                     {"message": "c3"},
                 ]
                 target_head = "c1"
                 source_head = "c2"
                 revisions = ["c2"]
 
             self.commit_ids = self.backend.create_master_repo(commits)
             self.target_repository = self.backend.create_repo(heads=[target_head], name_suffix=name_suffix)
             self.source_repository = self.backend.create_repo(heads=[source_head], name_suffix=name_suffix)
             self.author = author or UserModel().get_by_username(TEST_USER_ADMIN_LOGIN)
 
             model = PullRequestModel()
             self.create_parameters = {
                 "created_by": self.author,
                 "source_repo": self.source_repository.repo_name,
                 "source_ref": self._default_branch_reference(source_head),
                 "target_repo": self.target_repository.repo_name,
                 "target_ref": self._default_branch_reference(target_head),
                 "revisions": [self.commit_ids[r] for r in revisions],
                 "reviewers": reviewers or self._get_reviewers(),
                 "observers": observers or self._get_observers(),
                 "title": title,
                 "description": description,
             }
             self.pull_request = model.create(**self.create_parameters)
             assert model.get_versions(self.pull_request) == []
 
             self.pull_request_id = self.pull_request.pull_request_id
 
             if approved:
                 self.approve()
 
             Session().add(self.pull_request)
             Session().commit()
 
         return self.pull_request
 
     def approve(self):
         self.create_status_votes(ChangesetStatus.STATUS_APPROVED, *self.pull_request.reviewers)
 
     def close(self):
         PullRequestModel().close_pull_request(self.pull_request, self.author)
 
     def _default_branch_reference(self, commit_message, branch: str = None) -> str:
         default_branch = branch or self.backend.default_branch_name
         message = self.commit_ids[commit_message]
         reference = f"branch:{default_branch}:{message}"
 
         return reference
 
     def _get_reviewers(self):
         role = PullRequestReviewers.ROLE_REVIEWER
         return [
             (TEST_USER_REGULAR_LOGIN, ["default1"], False, role, []),
             (TEST_USER_REGULAR2_LOGIN, ["default2"], False, role, []),
         ]
 
     def _get_observers(self):
         return []
 
     def update_source_repository(self, head=None, do_fetch=False):
         heads = [head or "c3"]
         self.backend.pull_heads(self.source_repository, heads=heads, do_fetch=do_fetch)
 
     def update_target_repository(self, head=None, do_fetch=False):
         heads = [head or "c3"]
         self.backend.pull_heads(self.target_repository, heads=heads, do_fetch=do_fetch)
 
     def set_pr_target_ref(self, ref_type: str = "branch", ref_name: str = "branch", ref_commit_id: str = "") -> str:
         full_ref = f"{ref_type}:{ref_name}:{ref_commit_id}"
         self.pull_request.target_ref = full_ref
         return full_ref
 
     def set_pr_source_ref(self, ref_type: str = "branch", ref_name: str = "branch", ref_commit_id: str = "") -> str:
         full_ref = f"{ref_type}:{ref_name}:{ref_commit_id}"
         self.pull_request.source_ref = full_ref
         return full_ref
 
     def add_one_commit(self, head=None):
         self.update_source_repository(head=head)
         old_commit_ids = set(self.pull_request.revisions)
         PullRequestModel().update_commits(self.pull_request, self.pull_request.author)
         commit_ids = set(self.pull_request.revisions)
         new_commit_ids = commit_ids - old_commit_ids
         assert len(new_commit_ids) == 1
         return new_commit_ids.pop()
 
     def remove_one_commit(self):
         assert len(self.pull_request.revisions) == 2
         source_vcs = self.source_repository.scm_instance()
         removed_commit_id = source_vcs.commit_ids[-1]
 
         # TODO: johbo: Git and Mercurial have an inconsistent vcs api here,
         # remove the if once that's sorted out.
         if self.backend.alias == "git":
             kwargs = {"branch_name": self.backend.default_branch_name}
         else:
             kwargs = {}
         source_vcs.strip(removed_commit_id, **kwargs)
 
         PullRequestModel().update_commits(self.pull_request, self.pull_request.author)
         assert len(self.pull_request.revisions) == 1
         return removed_commit_id
 
     def create_comment(self, linked_to=None):
         comment = CommentsModel().create(
             text="Test comment", repo=self.target_repository.repo_name, user=self.author, pull_request=self.pull_request
         )
         assert comment.pull_request_version_id is None
 
         if linked_to:
             PullRequestModel()._link_comments_to_version(linked_to)
 
         return comment
 
     def create_inline_comment(self, linked_to=None, line_no="n1", file_path="file_1"):
         comment = CommentsModel().create(
             text="Test comment",
             repo=self.target_repository.repo_name,
             user=self.author,
             line_no=line_no,
             f_path=file_path,
             pull_request=self.pull_request,
         )
         assert comment.pull_request_version_id is None
 
         if linked_to:
             PullRequestModel()._link_comments_to_version(linked_to)
 
         return comment
 
     def create_version_of_pull_request(self):
         pull_request = self.create_pull_request()
         version = PullRequestModel()._create_version_from_snapshot(pull_request)
         return version
 
     def create_status_votes(self, status, *reviewers):
         for reviewer in reviewers:
             ChangesetStatusModel().set_status(
                 repo=self.pull_request.target_repo, status=status, user=reviewer.user_id, pull_request=self.pull_request
             )
 
     def set_mergeable(self, value):
         if not self.mergeable_patcher:
             self.mergeable_patcher = mock.patch.object(VcsSettingsModel, "get_general_settings")
             self.mergeable_mock = self.mergeable_patcher.start()
         self.mergeable_mock.return_value = {"rhodecode_pr_merge_enabled": value}
 
     def cleanup(self):
         # In case the source repository is already cleaned up, the pull
         # request will already be deleted.
         pull_request = PullRequest().get(self.pull_request_id)
         if pull_request:
             PullRequestModel().delete(pull_request, pull_request.author)
             Session().commit()
 
         if self.notification_patcher:
             self.notification_patcher.stop()
 
         if self.mergeable_patcher:
             self.mergeable_patcher.stop()
 
 
 @pytest.fixture()
 def user_admin(baseapp):
     """
     Provides the default admin test user as an instance of `db.User`.
     """
     user = UserModel().get_by_username(TEST_USER_ADMIN_LOGIN)
     return user
 
 
 @pytest.fixture()
 def user_regular(baseapp):
     """
     Provides the default regular test user as an instance of `db.User`.
     """
     user = UserModel().get_by_username(TEST_USER_REGULAR_LOGIN)
     return user
 
 
 @pytest.fixture()
 def user_util(request, db_connection):
     """
     Provides a wired instance of `UserUtility` with integrated cleanup.
     """
     utility = UserUtility(test_name=request.node.name)
     request.addfinalizer(utility.cleanup)
     return utility
 
 
 # TODO: johbo: Split this up into utilities per domain or something similar
 class UserUtility(object):
     def __init__(self, test_name="test"):
         self._test_name = self._sanitize_name(test_name)
         self.fixture = Fixture()
         self.repo_group_ids = []
         self.repos_ids = []
         self.user_ids = []
         self.user_group_ids = []
         self.user_repo_permission_ids = []
         self.user_group_repo_permission_ids = []
         self.user_repo_group_permission_ids = []
         self.user_group_repo_group_permission_ids = []
         self.user_user_group_permission_ids = []
         self.user_group_user_group_permission_ids = []
         self.user_permissions = []
 
     def _sanitize_name(self, name):
         for char in ["[", "]"]:
             name = name.replace(char, "_")
         return name
 
     def create_repo_group(self, owner=TEST_USER_ADMIN_LOGIN, auto_cleanup=True):
         group_name = "{prefix}_repogroup_{count}".format(prefix=self._test_name, count=len(self.repo_group_ids))
         repo_group = self.fixture.create_repo_group(group_name, cur_user=owner)
         if auto_cleanup:
             self.repo_group_ids.append(repo_group.group_id)
         return repo_group
 
     def create_repo(self, owner=TEST_USER_ADMIN_LOGIN, parent=None, auto_cleanup=True, repo_type="hg", bare=False):
         repo_name = "{prefix}_repository_{count}".format(prefix=self._test_name, count=len(self.repos_ids))
 
         repository = self.fixture.create_repo(
             repo_name, cur_user=owner, repo_group=parent, repo_type=repo_type, bare=bare
         )
         if auto_cleanup:
             self.repos_ids.append(repository.repo_id)
         return repository
 
     def create_user(self, auto_cleanup=True, **kwargs):
         user_name = "{prefix}_user_{count}".format(prefix=self._test_name, count=len(self.user_ids))
         user = self.fixture.create_user(user_name, **kwargs)
         if auto_cleanup:
             self.user_ids.append(user.user_id)
         return user
 
     def create_additional_user_email(self, user, email):
         uem = self.fixture.create_additional_user_email(user=user, email=email)
         return uem
 
     def create_user_with_group(self):
         user = self.create_user()
         user_group = self.create_user_group(members=[user])
         return user, user_group
 
     def create_user_group(self, owner=TEST_USER_ADMIN_LOGIN, members=None, auto_cleanup=True, **kwargs):
         group_name = "{prefix}_usergroup_{count}".format(prefix=self._test_name, count=len(self.user_group_ids))
         user_group = self.fixture.create_user_group(group_name, cur_user=owner, **kwargs)
 
         if auto_cleanup:
             self.user_group_ids.append(user_group.users_group_id)
         if members:
             for user in members:
                 UserGroupModel().add_user_to_group(user_group, user)
         return user_group
 
     def grant_user_permission(self, user_name, permission_name):
         self.inherit_default_user_permissions(user_name, False)
         self.user_permissions.append((user_name, permission_name))
 
     def grant_user_permission_to_repo_group(self, repo_group, user, permission_name):
         permission = RepoGroupModel().grant_user_permission(repo_group, user, permission_name)
         self.user_repo_group_permission_ids.append((repo_group.group_id, user.user_id))
         return permission
 
     def grant_user_group_permission_to_repo_group(self, repo_group, user_group, permission_name):
         permission = RepoGroupModel().grant_user_group_permission(repo_group, user_group, permission_name)
         self.user_group_repo_group_permission_ids.append((repo_group.group_id, user_group.users_group_id))
         return permission
 
     def grant_user_permission_to_repo(self, repo, user, permission_name):
         permission = RepoModel().grant_user_permission(repo, user, permission_name)
         self.user_repo_permission_ids.append((repo.repo_id, user.user_id))
         return permission
 
     def grant_user_group_permission_to_repo(self, repo, user_group, permission_name):
         permission = RepoModel().grant_user_group_permission(repo, user_group, permission_name)
         self.user_group_repo_permission_ids.append((repo.repo_id, user_group.users_group_id))
         return permission
 
     def grant_user_permission_to_user_group(self, target_user_group, user, permission_name):
         permission = UserGroupModel().grant_user_permission(target_user_group, user, permission_name)
         self.user_user_group_permission_ids.append((target_user_group.users_group_id, user.user_id))
         return permission
 
     def grant_user_group_permission_to_user_group(self, target_user_group, user_group, permission_name):
         permission = UserGroupModel().grant_user_group_permission(target_user_group, user_group, permission_name)
         self.user_group_user_group_permission_ids.append((target_user_group.users_group_id, user_group.users_group_id))
         return permission
 
     def revoke_user_permission(self, user_name, permission_name):
         self.inherit_default_user_permissions(user_name, True)
         UserModel().revoke_perm(user_name, permission_name)
 
     def inherit_default_user_permissions(self, user_name, value):
         user = UserModel().get_by_username(user_name)
         user.inherit_default_permissions = value
         Session().add(user)
         Session().commit()
 
     def cleanup(self):
         self._cleanup_permissions()
         self._cleanup_repos()
         self._cleanup_repo_groups()
         self._cleanup_user_groups()
         self._cleanup_users()
 
     def _cleanup_permissions(self):
         if self.user_permissions:
             for user_name, permission_name in self.user_permissions:
                 self.revoke_user_permission(user_name, permission_name)
 
         for permission in self.user_repo_permission_ids:
             RepoModel().revoke_user_permission(*permission)
 
         for permission in self.user_group_repo_permission_ids:
             RepoModel().revoke_user_group_permission(*permission)
 
         for permission in self.user_repo_group_permission_ids:
             RepoGroupModel().revoke_user_permission(*permission)
 
         for permission in self.user_group_repo_group_permission_ids:
             RepoGroupModel().revoke_user_group_permission(*permission)
 
         for permission in self.user_user_group_permission_ids:
             UserGroupModel().revoke_user_permission(*permission)
 
         for permission in self.user_group_user_group_permission_ids:
             UserGroupModel().revoke_user_group_permission(*permission)
 
     def _cleanup_repo_groups(self):
         def _repo_group_compare(first_group_id, second_group_id):
             """
             Gives higher priority to the groups with the most complex paths
             """
             first_group = RepoGroup.get(first_group_id)
             second_group = RepoGroup.get(second_group_id)
             first_group_parts = len(first_group.group_name.split("/")) if first_group else 0
             second_group_parts = len(second_group.group_name.split("/")) if second_group else 0
             return cmp(second_group_parts, first_group_parts)
 
         sorted_repo_group_ids = sorted(self.repo_group_ids, key=functools.cmp_to_key(_repo_group_compare))
         for repo_group_id in sorted_repo_group_ids:
             self.fixture.destroy_repo_group(repo_group_id)
 
     def _cleanup_repos(self):
         sorted_repos_ids = sorted(self.repos_ids)
         for repo_id in sorted_repos_ids:
             self.fixture.destroy_repo(repo_id)
 
     def _cleanup_user_groups(self):
         def _user_group_compare(first_group_id, second_group_id):
             """
             Gives higher priority to the groups with the most complex paths
             """
             first_group = UserGroup.get(first_group_id)
             second_group = UserGroup.get(second_group_id)
             first_group_parts = len(first_group.users_group_name.split("/")) if first_group else 0
             second_group_parts = len(second_group.users_group_name.split("/")) if second_group else 0
             return cmp(second_group_parts, first_group_parts)
 
         sorted_user_group_ids = sorted(self.user_group_ids, key=functools.cmp_to_key(_user_group_compare))
         for user_group_id in sorted_user_group_ids:
             self.fixture.destroy_user_group(user_group_id)
 
     def _cleanup_users(self):
         for user_id in self.user_ids:
             self.fixture.destroy_user(user_id)
 
 
 @pytest.fixture(scope="session")
 def testrun():
     return {
         "uuid": uuid.uuid4(),
         "start": datetime.datetime.utcnow().isoformat(),
         "timestamp": int(time.time()),
     }
 
 
 class AppenlightClient(object):
     url_template = "{url}?protocol_version=0.5"
 
     def __init__(self, url, api_key, add_server=True, add_timestamp=True, namespace=None, request=None, testrun=None):
         self.url = self.url_template.format(url=url)
         self.api_key = api_key
         self.add_server = add_server
         self.add_timestamp = add_timestamp
         self.namespace = namespace
         self.request = request
         self.server = socket.getfqdn(socket.gethostname())
         self.tags_before = {}
         self.tags_after = {}
         self.stats = []
         self.testrun = testrun or {}
 
     def tag_before(self, tag, value):
         self.tags_before[tag] = value
 
     def tag_after(self, tag, value):
         self.tags_after[tag] = value
 
     def collect(self, data):
         if self.add_server:
             data.setdefault("server", self.server)
         if self.add_timestamp:
             data.setdefault("date", datetime.datetime.utcnow().isoformat())
         if self.namespace:
             data.setdefault("namespace", self.namespace)
         if self.request:
             data.setdefault("request", self.request)
         self.stats.append(data)
 
     def send_stats(self):
         tags = [
             ("testrun", self.request),
             ("testrun.start", self.testrun["start"]),
             ("testrun.timestamp", self.testrun["timestamp"]),
             ("test", self.namespace),
         ]
         for key, value in self.tags_before.items():
             tags.append((key + ".before", value))
             try:
                 delta = self.tags_after[key] - value
                 tags.append((key + ".delta", delta))
             except Exception:
                 pass
         for key, value in self.tags_after.items():
             tags.append((key + ".after", value))
         self.collect(
             {
                 "message": "Collected tags",
                 "tags": tags,
             }
         )
 
         response = requests.post(
             self.url,
             headers={"X-appenlight-api-key": self.api_key},
             json=self.stats,
         )
 
         if not response.status_code == 200:
             pprint.pprint(self.stats)
             print(response.headers)
             print(response.text)
             raise Exception("Sending to appenlight failed")
 
 
 @pytest.fixture()
 def gist_util(request, db_connection):
     """
     Provides a wired instance of `GistUtility` with integrated cleanup.
     """
     utility = GistUtility()
     request.addfinalizer(utility.cleanup)
     return utility
 
 
 class GistUtility(object):
     def __init__(self):
         self.fixture = Fixture()
         self.gist_ids = []
 
     def create_gist(self, **kwargs):
         gist = self.fixture.create_gist(**kwargs)
         self.gist_ids.append(gist.gist_id)
         return gist
 
     def cleanup(self):
         for id_ in self.gist_ids:
             self.fixture.destroy_gists(str(id_))
 
 
 @pytest.fixture()
 def enabled_backends(request):
     backends = request.config.option.backends
     return backends[:]
 
 
 @pytest.fixture()
 def settings_util(request, db_connection):
     """
     Provides a wired instance of `SettingsUtility` with integrated cleanup.
     """
     utility = SettingsUtility()
     request.addfinalizer(utility.cleanup)
     return utility
 
 
 class SettingsUtility(object):
     def __init__(self):
         self.rhodecode_ui_ids = []
         self.rhodecode_setting_ids = []
         self.repo_rhodecode_ui_ids = []
         self.repo_rhodecode_setting_ids = []
 
     def create_repo_rhodecode_ui(self, repo, section, value, key=None, active=True, cleanup=True):
         key = key or sha1_safe(f"{section}{value}{repo.repo_id}")
 
         setting = RepoRhodeCodeUi()
         setting.repository_id = repo.repo_id
         setting.ui_section = section
         setting.ui_value = value
         setting.ui_key = key
         setting.ui_active = active
         Session().add(setting)
         Session().commit()
 
         if cleanup:
             self.repo_rhodecode_ui_ids.append(setting.ui_id)
         return setting
 
     def create_rhodecode_ui(self, section, value, key=None, active=True, cleanup=True):
         key = key or sha1_safe(f"{section}{value}")
 
         setting = RhodeCodeUi()
         setting.ui_section = section
         setting.ui_value = value
         setting.ui_key = key
         setting.ui_active = active
         Session().add(setting)
         Session().commit()
 
         if cleanup:
             self.rhodecode_ui_ids.append(setting.ui_id)
         return setting
 
     def create_repo_rhodecode_setting(self, repo, name, value, type_, cleanup=True):
         setting = RepoRhodeCodeSetting(repo.repo_id, key=name, val=value, type=type_)
         Session().add(setting)
         Session().commit()
 
         if cleanup:
             self.repo_rhodecode_setting_ids.append(setting.app_settings_id)
         return setting
 
     def create_rhodecode_setting(self, name, value, type_, cleanup=True):
         setting = RhodeCodeSetting(key=name, val=value, type=type_)
         Session().add(setting)
         Session().commit()
 
         if cleanup:
             self.rhodecode_setting_ids.append(setting.app_settings_id)
 
         return setting
 
     def cleanup(self):
         for id_ in self.rhodecode_ui_ids:
             setting = RhodeCodeUi.get(id_)
             Session().delete(setting)
 
         for id_ in self.rhodecode_setting_ids:
             setting = RhodeCodeSetting.get(id_)
             Session().delete(setting)
 
         for id_ in self.repo_rhodecode_ui_ids:
             setting = RepoRhodeCodeUi.get(id_)
             Session().delete(setting)
 
         for id_ in self.repo_rhodecode_setting_ids:
             setting = RepoRhodeCodeSetting.get(id_)
             Session().delete(setting)
 
         Session().commit()
 
 
 @pytest.fixture()
 def no_notifications(request):
     notification_patcher = mock.patch("rhodecode.model.notification.NotificationModel.create")
     notification_patcher.start()
     request.addfinalizer(notification_patcher.stop)
 
 
 @pytest.fixture(scope="session")
 def repeat(request):
     """
     The number of repetitions is based on this fixture.
 
     Slower calls may divide it by 10 or 100. It is chosen in a way so that the
     tests are not too slow in our default test suite.
     """
     return request.config.getoption("--repeat")
 
 
 @pytest.fixture()
 def rhodecode_fixtures():
     return Fixture()
 
 
 @pytest.fixture()
 def context_stub():
     """
     Stub context object.
     """
     context = pyramid.testing.DummyResource()
     return context
 
 
 @pytest.fixture()
 def StubIntegrationType():
     class _StubIntegrationType(IntegrationTypeBase):
         """Test integration type class"""
 
         key = "test"
         display_name = "Test integration type"
         description = "A test integration type for testing"
 
         @classmethod
         def icon(cls):
             return "test_icon_html_image"
 
         def __init__(self, settings):
             super(_StubIntegrationType, self).__init__(settings)
             self.sent_events = []  # for testing
 
         def send_event(self, event):
             self.sent_events.append(event)
 
         def settings_schema(self):
             class SettingsSchema(colander.Schema):
                 test_string_field = colander.SchemaNode(
                     colander.String(),
                     missing=colander.required,
                     title="test string field",
                 )
                 test_int_field = colander.SchemaNode(
                     colander.Int(),
                     title="some integer setting",
                 )
 
             return SettingsSchema()
 
     integration_type_registry.register_integration_type(_StubIntegrationType)
     return _StubIntegrationType
 
 
 @pytest.fixture()
 def stub_integration_settings():
     return {
         "test_string_field": "some data",
         "test_int_field": 100,
     }
 
 
 @pytest.fixture()
 def repo_integration_stub(request, repo_stub, StubIntegrationType, stub_integration_settings):
+    repo_id = repo_stub.repo_id
     integration = IntegrationModel().create(
         StubIntegrationType,
         settings=stub_integration_settings,
         enabled=True,
         name="test repo integration",
         repo=repo_stub,
         repo_group=None,
         child_repos_only=None,
     )
 
     @request.addfinalizer
     def cleanup():
         IntegrationModel().delete(integration)
+        RepoModel().delete(repo_id)
 
     return integration
 
 
 @pytest.fixture()
 def repogroup_integration_stub(request, test_repo_group, StubIntegrationType, stub_integration_settings):
     integration = IntegrationModel().create(
         StubIntegrationType,
         settings=stub_integration_settings,
         enabled=True,
         name="test repogroup integration",
         repo=None,
         repo_group=test_repo_group,
         child_repos_only=True,
     )
 
     @request.addfinalizer
     def cleanup():
         IntegrationModel().delete(integration)
 
     return integration
 
 
 @pytest.fixture()
 def repogroup_recursive_integration_stub(request, test_repo_group, StubIntegrationType, stub_integration_settings):
     integration = IntegrationModel().create(
         StubIntegrationType,
         settings=stub_integration_settings,
         enabled=True,
         name="test recursive repogroup integration",
         repo=None,
         repo_group=test_repo_group,
         child_repos_only=False,
     )
 
     @request.addfinalizer
     def cleanup():
         IntegrationModel().delete(integration)
 
     return integration
 
 
 @pytest.fixture()
 def global_integration_stub(request, StubIntegrationType, stub_integration_settings):
     integration = IntegrationModel().create(
         StubIntegrationType,
         settings=stub_integration_settings,
         enabled=True,
         name="test global integration",
         repo=None,
         repo_group=None,
         child_repos_only=None,
     )
 
     @request.addfinalizer
     def cleanup():
         IntegrationModel().delete(integration)
 
     return integration
 
 
 @pytest.fixture()
 def root_repos_integration_stub(request, StubIntegrationType, stub_integration_settings):
     integration = IntegrationModel().create(
         StubIntegrationType,
         settings=stub_integration_settings,
         enabled=True,
         name="test global integration",
         repo=None,
         repo_group=None,
         child_repos_only=True,
     )
 
     @request.addfinalizer
     def cleanup():
         IntegrationModel().delete(integration)
 
     return integration
 
 
 @pytest.fixture()
 def local_dt_to_utc():
     def _factory(dt):
         return dt.replace(tzinfo=dateutil.tz.tzlocal()).astimezone(dateutil.tz.tzutc()).replace(tzinfo=None)
 
     return _factory
 
 
 @pytest.fixture()
 def disable_anonymous_user(request, baseapp):
     set_anonymous_access(False)
 
     @request.addfinalizer
     def cleanup():
         set_anonymous_access(True)
 
 
 @pytest.fixture(scope="module")
 def rc_fixture(request):
     return Fixture()
 
 
 @pytest.fixture()
 def repo_groups(request):
     fixture = Fixture()
 
     session = Session()
     zombie_group = fixture.create_repo_group("zombie")
     parent_group = fixture.create_repo_group("parent")
     child_group = fixture.create_repo_group("parent/child")
     groups_in_db = session.query(RepoGroup).all()
     assert len(groups_in_db) == 3
     assert child_group.group_parent_id == parent_group.group_id
 
     @request.addfinalizer
     def cleanup():
         fixture.destroy_repo_group(zombie_group)
         fixture.destroy_repo_group(child_group)
         fixture.destroy_repo_group(parent_group)
 
     return zombie_group, parent_group, child_group
 

rhodecode/tests/integrations/test_integration.py

@@ -1,223 +1,221 b''
 # Copyright (C) 2010-2024 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 time
 import pytest
 
 from rhodecode import events
+from rhodecode.model.repo import RepoModel
 from rhodecode.tests.fixtures.rc_fixture import Fixture
 from rhodecode.model.db import Session, Integration
 from rhodecode.model.integration import IntegrationModel
 
 
 class TestDeleteScopesDeletesIntegrations(object):
-    def test_delete_repo_with_integration_deletes_integration(
-            self, repo_integration_stub):
-
-        Session().delete(repo_integration_stub.repo)
+    def test_delete_repo_with_integration_deletes_integration(self, repo_integration_stub):
+        RepoModel().delete(repo_integration_stub.repo)
         Session().commit()
         Session().expire_all()
         integration = Integration.get(repo_integration_stub.integration_id)
         assert integration is None
 
-    def test_delete_repo_group_with_integration_deletes_integration(
-            self, repogroup_integration_stub):
+    def test_delete_repo_group_with_integration_deletes_integration(self, repogroup_integration_stub):
 
         Session().delete(repogroup_integration_stub.repo_group)
         Session().commit()
         Session().expire_all()
         integration = Integration.get(repogroup_integration_stub.integration_id)
         assert integration is None
 
 
 count = 1
 
 
 def counter():
     global count
     val = count
     count += 1
-    return '{}_{}'.format(val, time.time())
+    return f'{val}_{time.time()}'
 
 
 @pytest.fixture()
 def integration_repos(request, StubIntegrationType, stub_integration_settings):
     """
     Create repositories and integrations for testing, and destroy them after
 
     Structure:
         root_repo
         parent_group/
             parent_repo
             child_group/
                 child_repo
         other_group/
             other_repo
     """
     fixture = Fixture()
 
     parent_group_id = 'int_test_parent_group_{}'.format(counter())
     parent_group = fixture.create_repo_group(parent_group_id)
 
     other_group_id = 'int_test_other_group_{}'.format(counter())
     other_group = fixture.create_repo_group(other_group_id)
 
     child_group_id = (
         parent_group_id + '/' + 'int_test_child_group_{}'.format(counter()))
     child_group = fixture.create_repo_group(child_group_id)
 
     parent_repo_id = 'int_test_parent_repo_{}'.format(counter())
     parent_repo = fixture.create_repo(parent_repo_id, repo_group=parent_group)
 
     child_repo_id = 'int_test_child_repo_{}'.format(counter())
     child_repo = fixture.create_repo(child_repo_id, repo_group=child_group)
 
     other_repo_id = 'int_test_other_repo_{}'.format(counter())
     other_repo = fixture.create_repo(other_repo_id, repo_group=other_group)
 
     root_repo_id = 'int_test_repo_root_{}'.format(counter())
     root_repo = fixture.create_repo(root_repo_id)
 
     integrations = {}
     for name, repo, repo_group, child_repos_only in [
             ('global', None, None, None),
             ('root_repos', None, None, True),
             ('parent_repo', parent_repo, None, None),
             ('child_repo', child_repo, None, None),
             ('other_repo', other_repo, None, None),
             ('root_repo', root_repo, None, None),
             ('parent_group', None, parent_group, True),
             ('parent_group_recursive', None, parent_group, False),
             ('child_group', None, child_group, True),
             ('child_group_recursive', None, child_group, False),
             ('other_group', None, other_group, True),
             ('other_group_recursive', None, other_group, False),
         ]:
         integrations[name] = IntegrationModel().create(
             StubIntegrationType, settings=stub_integration_settings,
             enabled=True, name='test %s integration' % name,
             repo=repo, repo_group=repo_group, child_repos_only=child_repos_only)
 
     Session().commit()
 
     def _cleanup():
         for integration in integrations.values():
             Session.delete(integration)
 
         fixture.destroy_repo(root_repo)
         fixture.destroy_repo(child_repo)
         fixture.destroy_repo(parent_repo)
         fixture.destroy_repo(other_repo)
         fixture.destroy_repo_group(child_group)
         fixture.destroy_repo_group(parent_group)
         fixture.destroy_repo_group(other_group)
 
     request.addfinalizer(_cleanup)
 
     return {
         'integrations': integrations,
         'repos': {
             'root_repo': root_repo,
             'other_repo': other_repo,
             'parent_repo': parent_repo,
             'child_repo': child_repo,
         }
     }
 
 
 def test_enabled_integration_repo_scopes(integration_repos):
     integrations = integration_repos['integrations']
     repos = integration_repos['repos']
 
     triggered_integrations = IntegrationModel().get_for_event(
         events.RepoEvent(repos['root_repo']))
 
     assert triggered_integrations == [
         integrations['global'],
         integrations['root_repos'],
         integrations['root_repo'],
     ]
 
     triggered_integrations = IntegrationModel().get_for_event(
         events.RepoEvent(repos['other_repo']))
 
     assert triggered_integrations == [
         integrations['global'],
         integrations['other_group'],
         integrations['other_group_recursive'],
         integrations['other_repo'],
     ]
 
     triggered_integrations = IntegrationModel().get_for_event(
         events.RepoEvent(repos['parent_repo']))
 
     assert triggered_integrations == [
         integrations['global'],
         integrations['parent_group'],
         integrations['parent_group_recursive'],
         integrations['parent_repo'],
     ]
 
     triggered_integrations = IntegrationModel().get_for_event(
         events.RepoEvent(repos['child_repo']))
 
     assert triggered_integrations == [
         integrations['global'],
         integrations['child_group'],
         integrations['parent_group_recursive'],
         integrations['child_group_recursive'],
         integrations['child_repo'],
     ]
 
 
 def test_disabled_integration_repo_scopes(integration_repos):
     integrations = integration_repos['integrations']
     repos = integration_repos['repos']
 
     for integration in integrations.values():
         integration.enabled = False
     Session().commit()
 
     triggered_integrations = IntegrationModel().get_for_event(
         events.RepoEvent(repos['root_repo']))
 
     assert triggered_integrations == []
 
     triggered_integrations = IntegrationModel().get_for_event(
         events.RepoEvent(repos['parent_repo']))
 
     assert triggered_integrations == []
 
     triggered_integrations = IntegrationModel().get_for_event(
         events.RepoEvent(repos['child_repo']))
 
     assert triggered_integrations == []
 
     triggered_integrations = IntegrationModel().get_for_event(
         events.RepoEvent(repos['other_repo']))
 
     assert triggered_integrations == []
 
 
 def test_enabled_non_repo_integrations(integration_repos):
     integrations = integration_repos['integrations']
 
     triggered_integrations = IntegrationModel().get_for_event(
         events.UserPreCreate({}))
 
     assert triggered_integrations == [integrations['global']]

rhodecode/tests/lib/test_utils.py

@@ -1,486 +1,540 b''
 # Copyright (C) 2010-2024 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 multiprocessing
 import os
+import shutil
 
 import mock
 import py
 import pytest
 
+import rhodecode
 from rhodecode.lib import caching_query
 from rhodecode.lib import utils
 from rhodecode.lib.str_utils import safe_bytes
 from rhodecode.model import settings
 from rhodecode.model import db
 from rhodecode.model import meta
+from rhodecode.model.meta import Session
 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.fixtures.fixture_pyramid import rhodecode_factory
 from rhodecode.tests.fixtures.rc_fixture import Fixture
 from rhodecode_tools.lib.hash_utils import md5_safe
 from rhodecode.lib.ext_json import json
 
 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'))
 
     meta.cache.invalidate(
         ui_settings, {},
         caching_query.FromCache('sql_cache_short', 'get_hg_ui_settings'))
 
     ui_settings = session.query(db.RhodeCodeUi).options(
         caching_query.FromCache('sql_cache_short', 'get_hook_settings'))
 
     meta.cache.invalidate(
         ui_settings, {},
         caching_query.FromCache('sql_cache_short', 'get_hook_settings'))
 
     @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.keys()).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)
 
 
 def test_get_dirpaths_returns_all_paths_on_str(tmpdir):
     tmpdir.ensure('test-file')
     tmpdir.ensure('test-file-1')
     tmp_path = str(tmpdir)
     dirpaths = utils.get_dirpaths(tmp_path)
     assert list(sorted(dirpaths)) == ['test-file', 'test-file-1']
 
 
 def test_get_dirpaths_returns_all_paths_on_bytes(tmpdir):
     tmpdir.ensure('test-file-bytes')
     tmp_path = str(tmpdir)
     dirpaths = utils.get_dirpaths(safe_bytes(tmp_path))
     assert list(sorted(dirpaths)) == [b'test-file-bytes']
 
 
 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'
     tmp_path = str(tmpdir.ensure(path_with_latin1))
     dirpaths = utils.get_dirpaths(tmp_path)
     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):
+def test_repo2db_cleaner_removes_zombie_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)
+    repo_list = [repo.repo_name for repo in session.query(db.Repository).all()]
+
+    utils.repo2db_cleanup(skip_repos=repo_list)
 
     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):
+
[e-mail]("hg", "git", "svn")
+def test_repo2db_cleaner_removes_zombie_repos(backend):
     repo = backend.create_repo()
-    repo_list = {repo.repo_name: 'test'}
-    with mock.patch('rhodecode.model.db.Repository.scm_instance') as scm_mock:
-        utils.repo2db_mapper(repo_list, remove_obsolete=False)
-        _, kwargs = scm_mock.call_args
-        assert kwargs['config'].get('extensions', 'largefiles') == ''
+    zombie_path = repo.repo_full_path
+    shutil.rmtree(zombie_path)
+
+    removed, errors = utils.repo2db_cleanup()
+    assert len(removed) == 1
+    assert not errors
 
 
[e-mail]("git", "svn")
+def test_repo2db_mapper_adds_new_repos(request, backend):
+    repo = backend.create_repo()
+    cleanup_repos = []
+    cleanup_groups = []
+    for num in range(5):
+        copy_repo_name = f'{repo.repo_name}-{num}'
+        copy_repo_path = f'{repo.repo_full_path}-{num}'
+
+        shutil.copytree(repo.repo_full_path, copy_repo_path)
+        cleanup_repos.append(copy_repo_name)
+
+    for gr_num in range(5):
+        gr_name = f'my_gr_{gr_num}'
+        dest_gr = os.path.join(os.path.dirname(repo.repo_full_path), gr_name)
+        os.makedirs(dest_gr, exist_ok=True)
+
+        copy_repo_name = f'{gr_name}/{repo.repo_name}-{gr_num}'
+        copy_repo_path = f'{dest_gr}/{repo.repo_name}-{gr_num}'
+
+        shutil.copytree(repo.repo_full_path, copy_repo_path)
+        cleanup_repos.append(copy_repo_name)
+        cleanup_groups.append(gr_name)
+
+    repo_list = ScmModel().repo_scan()
+
+    added, errors = utils.repo2db_mapper(repo_list)
+    Session().commit()
+    assert not errors
+
+    assert len(added) == 10
+
+    @request.addfinalizer
+    def cleanup():
+        for _repo in cleanup_repos:
+            del_result = RepoModel().delete(_repo, call_events=False)
+            Session().commit()
+            assert del_result is True
+
+        for _repo_group in cleanup_groups:
+            del_result = RepoGroupModel().delete(_repo_group, force_delete=True, call_events=False)
+            Session().commit()
+            assert del_result is True
+
+
 def test_repo2db_mapper_installs_hooks_for_repos_in_db(backend):
     repo = backend.create_repo()
     repo_list = {repo.repo_name: 'test'}
-    utils.repo2db_mapper(repo_list, remove_obsolete=False)
+    added, errors = utils.repo2db_mapper(repo_list)
+    assert not errors
+    assert repo.scm_instance().get_hooks_info() == {'pre_version': rhodecode.__version__, 'post_version': rhodecode.__version__}
 
 
 @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()}
-    utils.repo2db_mapper(repo_list, remove_obsolete=False)
+    added, errors = utils.repo2db_mapper(repo_list)
+    assert not errors
+    assert len(added) == 1
 
 
 class TestPasswordChanged(object):
 
     def setup_method(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_safe(
             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()
 
         for license_data in result:
             if isinstance(license_data["license"], list):
                 for lic_data in license_data["license"]:
                     assert 'UNKNOWN' not in lic_data["fullName"]
             else:
                 full_name = license_data.get("fullName") or license_data
                 assert 'UNKNOWN' not in full_name
 
 
 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, 'prepare_config_data') 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 TestPrepareConfigData(object):
     def test_prepare_config_data_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.prepare_config_data(
                 clear_session=False, repo=repo_name)
 
         self._assert_repo_name_passed(model_mock, repo_name)
 
         assert ('section1', 'option1', 'value1') in result
         assert ('section2', 'option2', 'value2') in result
         assert ('section3', 'option3', 'value3') not in 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('builtins.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ö'
+    engine = '/home/repos/malmö'
     assert obfuscate_url_pw(engine)
 
 
 @pytest.mark.parametrize("test_ua, expected", [
     ("", ""),
     ('"quoted"', 'quoted'),
     ('internal-merge', 'internal-merge'),
     ('hg/internal-merge', 'hg/internal-merge'),
     ('git/internal-merge', 'git/internal-merge'),
 
     # git
     ('git/2.10.1 (Apple Git-78)', 'git/2.10.1'),
     ('GiT/2.37.2.windows.2', 'git/2.37.2'),
     ('git/2.35.1 (Microsoft Windows NT 10.0.19044.0; Win32NT x64) CLR/4.0.30319 VS16/16.0.0', 'git/2.35.1'),
     ('ssh-user-agent', 'ssh-user-agent'),
     ('git/ssh-user-agent', 'git/ssh-user-agent'),
 
 
     # hg
     ('mercurial/proto-1.0 (Mercurial 4.2)', 'mercurial/4.2'),
     ('mercurial/proto-1.0', ''),
     ('mercurial/proto-1.0 (Mercurial 3.9.2)', 'mercurial/3.9.2'),
     ('mercurial/ssh-user-agent', 'mercurial/ssh-user-agent'),
     ('mercurial/proto-1.0 (Mercurial 5.8rc0)', 'mercurial/5.8rc0'),
 
 
 ])
 def test_user_agent_normalizer(test_ua, expected):
     from rhodecode.lib.utils2 import user_agent_normalizer
     assert user_agent_normalizer(test_ua, safe=False) == expected

rhodecode/tests/routes.py

@@ -1,323 +1,324 b''
 # Copyright (C) 2010-2024 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/
 
 
 def get_url_defs():
     from rhodecode.apps._base import ADMIN_PREFIX
 
     return {
         "home": "/",
         "main_page_repos_data": "/_home_repos",
         "main_page_repo_groups_data": "/_home_repo_groups",
         "repo_group_home": "/{repo_group_name}",
         "user_autocomplete_data": "/_users",
         "user_group_autocomplete_data": "/_user_groups",
         "repo_list_data": "/_repos",
         "goto_switcher_data": "/_goto_data",
         "admin_home": ADMIN_PREFIX + "",
         "admin_audit_logs": ADMIN_PREFIX + "/audit_logs",
         "admin_defaults_repositories": ADMIN_PREFIX + "/defaults/repositories",
         "admin_defaults_repositories_update": ADMIN_PREFIX
         + "/defaults/repositories/update",
         "search": ADMIN_PREFIX + "/search",
         "search_repo": "/{repo_name}/search",
         "my_account_auth_tokens": ADMIN_PREFIX + "/my_account/auth_tokens",
         "my_account_auth_tokens_add": ADMIN_PREFIX + "/my_account/auth_tokens/new",
         "my_account_auth_tokens_delete": ADMIN_PREFIX
         + "/my_account/auth_tokens/delete",
         "repos": ADMIN_PREFIX + "/repos",
         "repos_data": ADMIN_PREFIX + "/repos_data",
         "repo_groups": ADMIN_PREFIX + "/repo_groups",
         "repo_groups_data": ADMIN_PREFIX + "/repo_groups_data",
         "user_groups": ADMIN_PREFIX + "/user_groups",
         "user_groups_data": ADMIN_PREFIX + "/user_groups_data",
         "user_profile": "/_profiles/{username}",
         "profile_user_group": "/_profile_user_group/{user_group_name}",
         "repo_summary": "/{repo_name}",
         "repo_creating_check": "/{repo_name}/repo_creating_check",
         "edit_repo": "/{repo_name}/settings",
         "edit_repo_vcs": "/{repo_name}/settings/vcs",
         "edit_repo_vcs_update": "/{repo_name}/settings/vcs/update",
         "edit_repo_vcs_svn_pattern_delete": "/{repo_name}/settings/vcs/svn_pattern/delete",
         "repo_archivefile": "/{repo_name}/archive/{fname}",
         "repo_files_diff": "/{repo_name}/diff/{f_path}",
         "repo_files_diff_2way_redirect": "/{repo_name}/diff-2way/{f_path}",
         "repo_files": "/{repo_name}/files/{commit_id}/{f_path}",
         "repo_files:default_path": "/{repo_name}/files/{commit_id}/",
         "repo_files:default_commit": "/{repo_name}/files",
         "repo_files:rendered": "/{repo_name}/render/{commit_id}/{f_path}",
         "repo_files:annotated": "/{repo_name}/annotate/{commit_id}/{f_path}",
         "repo_files:annotated_previous": "/{repo_name}/annotate-previous/{commit_id}/{f_path}",
         "repo_files_nodelist": "/{repo_name}/nodelist/{commit_id}/{f_path}",
         "repo_file_raw": "/{repo_name}/raw/{commit_id}/{f_path}",
         "repo_file_download": "/{repo_name}/download/{commit_id}/{f_path}",
         "repo_file_history": "/{repo_name}/history/{commit_id}/{f_path}",
         "repo_file_authors": "/{repo_name}/authors/{commit_id}/{f_path}",
         "repo_files_remove_file": "/{repo_name}/remove_file/{commit_id}/{f_path}",
         "repo_files_delete_file": "/{repo_name}/delete_file/{commit_id}/{f_path}",
         "repo_files_edit_file": "/{repo_name}/edit_file/{commit_id}/{f_path}",
         "repo_files_update_file": "/{repo_name}/update_file/{commit_id}/{f_path}",
         "repo_files_add_file": "/{repo_name}/add_file/{commit_id}/{f_path}",
         "repo_files_upload_file": "/{repo_name}/upload_file/{commit_id}/{f_path}",
         "repo_files_create_file": "/{repo_name}/create_file/{commit_id}/{f_path}",
         "repo_files_replace_binary": "/{repo_name}/replace_binary/{commit_id}/{f_path}",
         "repo_nodetree_full": "/{repo_name}/nodetree_full/{commit_id}/{f_path}",
         "repo_nodetree_full:default_path": "/{repo_name}/nodetree_full/{commit_id}/",
         "journal": ADMIN_PREFIX + "/journal",
         "journal_rss": ADMIN_PREFIX + "/journal/rss",
         "journal_atom": ADMIN_PREFIX + "/journal/atom",
         "journal_public": ADMIN_PREFIX + "/public_journal",
         "journal_public_atom": ADMIN_PREFIX + "/public_journal/atom",
         "journal_public_atom_old": ADMIN_PREFIX + "/public_journal_atom",
         "journal_public_rss": ADMIN_PREFIX + "/public_journal/rss",
         "journal_public_rss_old": ADMIN_PREFIX + "/public_journal_rss",
         "toggle_following": ADMIN_PREFIX + "/toggle_following",
         "upload_file": "/_file_store/upload",
         "download_file": "/_file_store/download/{fid}",
         "download_file_by_token": "/_file_store/token-download/{_auth_token}/{fid}",
         "gists_show": ADMIN_PREFIX + "/gists",
         "gists_new": ADMIN_PREFIX + "/gists/new",
         "gists_create": ADMIN_PREFIX + "/gists/create",
         "gist_show": ADMIN_PREFIX + "/gists/{gist_id}",
         "gist_delete": ADMIN_PREFIX + "/gists/{gist_id}/delete",
         "gist_edit": ADMIN_PREFIX + "/gists/{gist_id}/edit",
         "gist_edit_check_revision": ADMIN_PREFIX
         + "/gists/{gist_id}/edit/check_revision",
         "gist_update": ADMIN_PREFIX + "/gists/{gist_id}/update",
         "gist_show_rev": ADMIN_PREFIX + "/gists/{gist_id}/rev/{revision}",
         "gist_show_formatted": ADMIN_PREFIX
         + "/gists/{gist_id}/rev/{revision}/{format}",
         "gist_show_formatted_path": ADMIN_PREFIX
         + "/gists/{gist_id}/rev/{revision}/{format}/{f_path}",
         "login": ADMIN_PREFIX + "/login",
         "logout": ADMIN_PREFIX + "/logout",
         "setup_2fa": ADMIN_PREFIX + "/setup_2fa",
         "check_2fa": ADMIN_PREFIX + "/check_2fa",
         "register": ADMIN_PREFIX + "/register",
         "reset_password": ADMIN_PREFIX + "/password_reset",
         "reset_password_confirmation": ADMIN_PREFIX + "/password_reset_confirmation",
         "admin_permissions_application": ADMIN_PREFIX + "/permissions/application",
         "admin_permissions_application_update": ADMIN_PREFIX
         + "/permissions/application/update",
         "repo_commit_raw": "/{repo_name}/changeset-diff/{commit_id}",
         "user_group_members_data": ADMIN_PREFIX
         + "/user_groups/{user_group_id}/members",
         "user_groups_new": ADMIN_PREFIX + "/user_groups/new",
         "user_groups_create": ADMIN_PREFIX + "/user_groups/create",
         "edit_user_group": ADMIN_PREFIX + "/user_groups/{user_group_id}/edit",
         "edit_user_group_advanced_sync": ADMIN_PREFIX
         + "/user_groups/{user_group_id}/edit/advanced/sync",
         "edit_user_group_global_perms_update": ADMIN_PREFIX
         + "/user_groups/{user_group_id}/edit/global_permissions/update",
         "user_groups_update": ADMIN_PREFIX + "/user_groups/{user_group_id}/update",
         "user_groups_delete": ADMIN_PREFIX + "/user_groups/{user_group_id}/delete",
         "edit_user_group_perms": ADMIN_PREFIX
         + "/user_groups/{user_group_id}/edit/permissions",
         "edit_user_group_perms_update": ADMIN_PREFIX
         + "/user_groups/{user_group_id}/edit/permissions/update",
         "edit_repo_group": "/{repo_group_name}/_edit",
         "edit_repo_group_perms": "/{repo_group_name:}/_settings/permissions",
         "edit_repo_group_perms_update": "/{repo_group_name}/_settings/permissions/update",
         "edit_repo_group_advanced": "/{repo_group_name}/_settings/advanced",
         "edit_repo_group_advanced_delete": "/{repo_group_name}/_settings/advanced/delete",
         "edit_user_ssh_keys": ADMIN_PREFIX + "/users/{user_id}/edit/ssh_keys",
         "edit_user_ssh_keys_generate_keypair": ADMIN_PREFIX
         + "/users/{user_id}/edit/ssh_keys/generate",
         "edit_user_ssh_keys_add": ADMIN_PREFIX + "/users/{user_id}/edit/ssh_keys/new",
         "edit_user_ssh_keys_delete": ADMIN_PREFIX
         + "/users/{user_id}/edit/ssh_keys/delete",
         "users": ADMIN_PREFIX + "/users",
         "users_data": ADMIN_PREFIX + "/users_data",
         "users_create": ADMIN_PREFIX + "/users/create",
         "users_new": ADMIN_PREFIX + "/users/new",
         "user_edit": ADMIN_PREFIX + "/users/{user_id}/edit",
         "user_edit_advanced": ADMIN_PREFIX + "/users/{user_id}/edit/advanced",
         "user_edit_global_perms": ADMIN_PREFIX
         + "/users/{user_id}/edit/global_permissions",
         "user_edit_global_perms_update": ADMIN_PREFIX
         + "/users/{user_id}/edit/global_permissions/update",
         "user_update": ADMIN_PREFIX + "/users/{user_id}/update",
         "user_delete": ADMIN_PREFIX + "/users/{user_id}/delete",
         "user_create_personal_repo_group": ADMIN_PREFIX
         + "/users/{user_id}/create_repo_group",
         "edit_user_auth_tokens": ADMIN_PREFIX + "/users/{user_id}/edit/auth_tokens",
         "edit_user_auth_tokens_add": ADMIN_PREFIX
         + "/users/{user_id}/edit/auth_tokens/new",
         "edit_user_auth_tokens_delete": ADMIN_PREFIX
         + "/users/{user_id}/edit/auth_tokens/delete",
         "edit_user_emails": ADMIN_PREFIX + "/users/{user_id}/edit/emails",
         "edit_user_emails_add": ADMIN_PREFIX + "/users/{user_id}/edit/emails/new",
         "edit_user_emails_delete": ADMIN_PREFIX + "/users/{user_id}/edit/emails/delete",
         "edit_user_ips": ADMIN_PREFIX + "/users/{user_id}/edit/ips",
         "edit_user_ips_add": ADMIN_PREFIX + "/users/{user_id}/edit/ips/new",
         "edit_user_ips_delete": ADMIN_PREFIX + "/users/{user_id}/edit/ips/delete",
         "edit_user_perms_summary": ADMIN_PREFIX
         + "/users/{user_id}/edit/permissions_summary",
         "edit_user_perms_summary_json": ADMIN_PREFIX
         + "/users/{user_id}/edit/permissions_summary/json",
         "edit_user_audit_logs": ADMIN_PREFIX + "/users/{user_id}/edit/audit",
         "edit_user_audit_logs_download": ADMIN_PREFIX
         + "/users/{user_id}/edit/audit/download",
         "admin_settings": ADMIN_PREFIX + "/settings",
         "admin_settings_update": ADMIN_PREFIX + "/settings/update",
         "admin_settings_global": ADMIN_PREFIX + "/settings/global",
         "admin_settings_global_update": ADMIN_PREFIX + "/settings/global/update",
         "admin_settings_vcs": ADMIN_PREFIX + "/settings/vcs",
         "admin_settings_vcs_update": ADMIN_PREFIX + "/settings/vcs/update",
         "admin_settings_vcs_svn_pattern_delete": ADMIN_PREFIX
         + "/settings/vcs/svn_pattern_delete",
         "admin_settings_mapping": ADMIN_PREFIX + "/settings/mapping",
-        "admin_settings_mapping_update": ADMIN_PREFIX + "/settings/mapping/update",
+        "admin_settings_mapping_create": ADMIN_PREFIX + "/settings/mapping/create",
+        "admin_settings_mapping_cleanup": ADMIN_PREFIX + "/settings/mapping/cleanup",
         "admin_settings_visual": ADMIN_PREFIX + "/settings/visual",
         "admin_settings_visual_update": ADMIN_PREFIX + "/settings/visual/update",
         "admin_settings_issuetracker": ADMIN_PREFIX + "/settings/issue-tracker",
         "admin_settings_issuetracker_update": ADMIN_PREFIX
         + "/settings/issue-tracker/update",
         "admin_settings_issuetracker_test": ADMIN_PREFIX
         + "/settings/issue-tracker/test",
         "admin_settings_issuetracker_delete": ADMIN_PREFIX
         + "/settings/issue-tracker/delete",
         "admin_settings_email": ADMIN_PREFIX + "/settings/email",
         "admin_settings_email_update": ADMIN_PREFIX + "/settings/email/update",
         "admin_settings_hooks": ADMIN_PREFIX + "/settings/hooks",
         "admin_settings_hooks_update": ADMIN_PREFIX + "/settings/hooks/update",
         "admin_settings_hooks_delete": ADMIN_PREFIX + "/settings/hooks/delete",
         "admin_settings_search": ADMIN_PREFIX + "/settings/search",
         "admin_settings_labs": ADMIN_PREFIX + "/settings/labs",
         "admin_settings_labs_update": ADMIN_PREFIX + "/settings/labs/update",
         "admin_settings_sessions": ADMIN_PREFIX + "/settings/sessions",
         "admin_settings_sessions_cleanup": ADMIN_PREFIX + "/settings/sessions/cleanup",
         "admin_settings_system": ADMIN_PREFIX + "/settings/system",
         "admin_settings_system_update": ADMIN_PREFIX + "/settings/system/updates",
         "admin_settings_open_source": ADMIN_PREFIX + "/settings/open_source",
         "repo_group_new": ADMIN_PREFIX + "/repo_group/new",
         "repo_group_create": ADMIN_PREFIX + "/repo_group/create",
         "repo_new": ADMIN_PREFIX + "/repos/new",
         "repo_create": ADMIN_PREFIX + "/repos/create",
         "admin_permissions_global": ADMIN_PREFIX + "/permissions/global",
         "admin_permissions_global_update": ADMIN_PREFIX + "/permissions/global/update",
         "admin_permissions_object": ADMIN_PREFIX + "/permissions/object",
         "admin_permissions_object_update": ADMIN_PREFIX + "/permissions/object/update",
         "admin_permissions_ips": ADMIN_PREFIX + "/permissions/ips",
         "admin_permissions_overview": ADMIN_PREFIX + "/permissions/overview",
         "admin_permissions_ssh_keys": ADMIN_PREFIX + "/permissions/ssh_keys",
         "admin_permissions_ssh_keys_data": ADMIN_PREFIX + "/permissions/ssh_keys/data",
         "admin_permissions_ssh_keys_update": ADMIN_PREFIX
         + "/permissions/ssh_keys/update",
         "pullrequest_show": "/{repo_name}/pull-request/{pull_request_id}",
         "pull_requests_global": ADMIN_PREFIX + "/pull-request/{pull_request_id}",
         "pull_requests_global_0": ADMIN_PREFIX + "/pull_requests/{pull_request_id}",
         "pull_requests_global_1": ADMIN_PREFIX + "/pull-requests/{pull_request_id}",
         "notifications_show_all": ADMIN_PREFIX + "/notifications",
         "notifications_mark_all_read": ADMIN_PREFIX + "/notifications_mark_all_read",
         "notifications_show": ADMIN_PREFIX + "/notifications/{notification_id}",
         "notifications_update": ADMIN_PREFIX
         + "/notifications/{notification_id}/update",
         "notifications_delete": ADMIN_PREFIX
         + "/notifications/{notification_id}/delete",
         "my_account": ADMIN_PREFIX + "/my_account/profile",
         "my_account_edit": ADMIN_PREFIX + "/my_account/edit",
         "my_account_update": ADMIN_PREFIX + "/my_account/update",
         "my_account_pullrequests": ADMIN_PREFIX + "/my_account/pull_requests",
         "my_account_pullrequests_data": ADMIN_PREFIX + "/my_account/pull_requests/data",
         "my_account_emails": ADMIN_PREFIX + "/my_account/emails",
         "my_account_emails_add": ADMIN_PREFIX + "/my_account/emails/new",
         "my_account_emails_delete": ADMIN_PREFIX + "/my_account/emails/delete",
         "my_account_password": ADMIN_PREFIX + "/my_account/password",
         "my_account_password_update": ADMIN_PREFIX + "/my_account/password/update",
         "my_account_repos": ADMIN_PREFIX + "/my_account/repos",
         "my_account_watched": ADMIN_PREFIX + "/my_account/watched",
         "my_account_perms": ADMIN_PREFIX + "/my_account/perms",
         "my_account_notifications": ADMIN_PREFIX + "/my_account/notifications",
         "my_account_ssh_keys": ADMIN_PREFIX + "/my_account/ssh_keys",
         "my_account_ssh_keys_generate": ADMIN_PREFIX + "/my_account/ssh_keys/generate",
         "my_account_ssh_keys_add": ADMIN_PREFIX + "/my_account/ssh_keys/new",
         "my_account_ssh_keys_delete": ADMIN_PREFIX + "/my_account/ssh_keys/delete",
         "pullrequest_show_all": "/{repo_name}/pull-request",
         "pullrequest_show_all_data": "/{repo_name}/pull-request-data",
         "bookmarks_home": "/{repo_name}/bookmarks",
         "branches_home": "/{repo_name}/branches",
         "branch_remove": "/{repo_name}/branches/{branch_name}/remove",
         "tags_home": "/{repo_name}/tags",
         "repo_changelog": "/{repo_name}/changelog",
         "repo_commits": "/{repo_name}/commits",
         "repo_commits_file": "/{repo_name}/commits/{commit_id}/{f_path}",
         "repo_commits_elements": "/{repo_name}/commits_elements",
         "repo_commit": "/{repo_name}/changeset/{commit_id}",
         "repo_commit_comment_create": "/{repo_name}/changeset/{commit_id}/comment/create",
         "repo_commit_comment_preview": "/{repo_name}/changeset/{commit_id}/comment/preview",
         "repo_commit_comment_delete": "/{repo_name}/changeset/{commit_id}/comment/{comment_id}/delete",
         "repo_commit_comment_edit": "/{repo_name}/changeset/{commit_id}/comment/{comment_id}/edit",
         "repo_commit_children": "/{repo_name}/changeset_children/{commit_id}",
         "repo_commit_parents": "/{repo_name}/changeset_parents/{commit_id}",
         "repo_commit_patch": "/{repo_name}/changeset-patch/{commit_id}",
         "repo_commit_download": "/{repo_name}/changeset-download/{commit_id}",
         "repo_commit_data": "/{repo_name}/changeset-data/{commit_id}",
         "repo_compare": "/{repo_name}/compare/{source_ref_type}@{source_ref}...{target_ref_type}@{target_ref}",
         "repo_compare_select": "/{repo_name}/compare",
         "rss_feed_home": "/{repo_name}/feed-rss",
         "atom_feed_home": "/{repo_name}/feed-atom",
         "rss_feed_home_old": "/{repo_name}/feed/rss",
         "atom_feed_home_old": "/{repo_name}/feed/atom",
         "repo_fork_new": "/{repo_name}/fork",
         "repo_fork_create": "/{repo_name}/fork/create",
         "repo_forks_show_all": "/{repo_name}/forks",
         "repo_forks_data": "/{repo_name}/forks/data",
         "edit_repo_issuetracker": "/{repo_name}/settings/issue_trackers",
         "edit_repo_issuetracker_test": "/{repo_name}/settings/issue_trackers/test",
         "edit_repo_issuetracker_delete": "/{repo_name}/settings/issue_trackers/delete",
         "edit_repo_issuetracker_update": "/{repo_name}/settings/issue_trackers/update",
         "edit_repo_maintenance": "/{repo_name}/settings/maintenance",
         "edit_repo_maintenance_execute": "/{repo_name}/settings/maintenance/execute",
         "repo_changelog_file": "/{repo_name}/changelog/{commit_id}/{f_path}",
         "pullrequest_repo_refs": "/{repo_name}/pull-request/refs/{target_repo_name:.*?[^/]}",
         "pullrequest_repo_targets": "/{repo_name}/pull-request/repo-destinations",
         "pullrequest_new": "/{repo_name}/pull-request/new",
         "pullrequest_create": "/{repo_name}/pull-request/create",
         "pullrequest_update": "/{repo_name}/pull-request/{pull_request_id}/update",
         "pullrequest_merge": "/{repo_name}/pull-request/{pull_request_id}/merge",
         "pullrequest_delete": "/{repo_name}/pull-request/{pull_request_id}/delete",
         "pullrequest_comment_create": "/{repo_name}/pull-request/{pull_request_id}/comment",
         "pullrequest_comment_delete": "/{repo_name}/pull-request/{pull_request_id}/comment/{comment_id}/delete",
         "pullrequest_comment_edit": "/{repo_name}/pull-request/{pull_request_id}/comment/{comment_id}/edit",
         "edit_repo_caches": "/{repo_name}/settings/caches",
         "edit_repo_perms": "/{repo_name}/settings/permissions",
         "edit_repo_fields": "/{repo_name}/settings/fields",
         "edit_repo_remote": "/{repo_name}/settings/remote",
         "edit_repo_statistics": "/{repo_name}/settings/statistics",
         "edit_repo_advanced": "/{repo_name}/settings/advanced",
         "edit_repo_advanced_delete": "/{repo_name}/settings/advanced/delete",
         "edit_repo_advanced_archive": "/{repo_name}/settings/advanced/archive",
         "edit_repo_advanced_fork": "/{repo_name}/settings/advanced/fork",
         "edit_repo_advanced_locking": "/{repo_name}/settings/advanced/locking",
         "edit_repo_advanced_journal": "/{repo_name}/settings/advanced/journal",
         "repo_stats": "/{repo_name}/repo_stats/{commit_id}",
         "repo_refs_data": "/{repo_name}/refs-data",
         "repo_refs_changelog_data": "/{repo_name}/refs-data-changelog",
         "repo_artifacts_stream_store": "/_file_store/stream-upload",
     }
 
 
 def route_path(name, params=None, **kwargs):
     import urllib.parse
 
     base_url = get_url_defs()[name].format(**kwargs)
 
     if params:
         base_url = f"{base_url}?{urllib.parse.urlencode(params)}"
     return base_url