fix(bootstrap): fixed issues that lead to leaving rhodecode.local as a default setting which is now explicitly read from .ini config

rhodecode/config/utils.py

@@ -1,104 +1,107 b''
 # Copyright (C) 2010-2023 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 platform
 
+DEFAULT_USER = 'default'
+
 
 def configure_vcs(config):
     """
     Patch VCS config with some RhodeCode specific stuff
     """
     from rhodecode.lib.vcs import conf
     import rhodecode.lib.vcs.conf.settings
 
     conf.settings.BACKENDS = {
         'hg': 'rhodecode.lib.vcs.backends.hg.MercurialRepository',
         'git': 'rhodecode.lib.vcs.backends.git.GitRepository',
         'svn': 'rhodecode.lib.vcs.backends.svn.SubversionRepository',
     }
 
     conf.settings.HOOKS_PROTOCOL = config['vcs.hooks.protocol']
     conf.settings.HOOKS_HOST = config['vcs.hooks.host']
     conf.settings.DEFAULT_ENCODINGS = config['default_encoding']
     conf.settings.ALIASES[:] = config['vcs.backends']
     conf.settings.SVN_COMPATIBLE_VERSION = config['vcs.svn.compatible_version']
 
 
 def initialize_database(config):
     from rhodecode.lib.utils2 import engine_from_config, get_encryption_key
     from rhodecode.model import init_model
     engine = engine_from_config(config, 'sqlalchemy.db1.')
     init_model(engine, encryption_key=get_encryption_key(config))
 
 
 def initialize_test_environment(settings, test_env=None):
     if test_env is None:
         test_env = not int(os.environ.get('RC_NO_TMP_PATH', 0))
 
     from rhodecode.lib.utils import (
         create_test_directory, create_test_database, create_test_repositories,
         create_test_index)
     from rhodecode.tests import TESTS_TMP_PATH
     from rhodecode.lib.vcs.backends.hg import largefiles_store
     from rhodecode.lib.vcs.backends.git import lfs_store
 
     # test repos
     if test_env:
         create_test_directory(TESTS_TMP_PATH)
         # large object stores
         create_test_directory(largefiles_store(TESTS_TMP_PATH))
         create_test_directory(lfs_store(TESTS_TMP_PATH))
 
         create_test_database(TESTS_TMP_PATH, settings)
         create_test_repositories(TESTS_TMP_PATH, settings)
         create_test_index(TESTS_TMP_PATH, settings)
 
 
 def get_vcs_server_protocol(config):
     return config['vcs.server.protocol']
 
 
 def set_instance_id(config):
     """
     Sets a dynamic generated config['instance_id'] if missing or '*'
     E.g instance_id = *cluster-1 or instance_id = *
     """
 
     config['instance_id'] = config.get('instance_id') or ''
     instance_id = config['instance_id']
     if instance_id.startswith('*') or not instance_id:
         prefix = instance_id.lstrip('*')
         _platform_id = platform.uname()[1] or 'instance'
         config['instance_id'] = '{prefix}uname:{platform}-pid:{pid}'.format(
             prefix=prefix,
             platform=_platform_id,
             pid=os.getpid())
 
 
 def get_default_user_id():
-    DEFAULT_USER = 'default'
     from sqlalchemy import text
     from rhodecode.model import meta
 
     engine = meta.get_engine()
     with meta.SA_Session(engine) as session:
-        result = session.execute(text("SELECT user_id from users where username = :uname"), {'uname': DEFAULT_USER})
+        result = session.execute(text(
+            "SELECT user_id from users where username = :uname"
+        ), {'uname': DEFAULT_USER})
         user_id = result.first()[0]
 
     return user_id

rhodecode/lib/pyramid_utils.py

@@ -1,57 +1,53 b''
 
 
 # Copyright (C) 2016-2023 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 configparser
 
-from rhodecode.lib.config_utils import get_config
 from pyramid.paster import bootstrap as pyramid_bootstrap, setup_logging  # pragma: no cover
 from pyramid.threadlocal import get_current_request as pyramid_current_request
 
 
 def bootstrap(config_uri, options=None, env=None):
+    from rhodecode.config.utils import DEFAULT_USER
+    from rhodecode.lib.config_utils import get_app_config_lightweight
     from rhodecode.lib.utils2 import AttributeDict
     from rhodecode.lib.request import Request
 
     if env:
         os.environ.update(env)
 
-    config = get_config(config_uri)
-    base_url = 'http://rhodecode.local'
-    try:
-        base_url = config.get('app:main', 'app.base_url')
-    except (configparser.NoSectionError, configparser.NoOptionError):
-        pass
+    config = get_app_config_lightweight(config_uri)
+    base_url = config['app.base_url']
 
     request = Request.blank('/', base_url=base_url)
     # fake inject a running user for bootstrap request !
-    request.user = AttributeDict({'username': 'bootstrap-user',
+    request.user = AttributeDict({'username': DEFAULT_USER,
                                   'user_id': 1,
                                   'ip_addr': '127.0.0.1'})
     return pyramid_bootstrap(config_uri, request=request, options=options)
 
 
 def get_current_request():
     pyramid_req = pyramid_current_request()
     if not pyramid_req:
         # maybe we're in celery context and need to get the PYRAMID_REQUEST
         from rhodecode.lib.celerylib.loader import celery_app
         pyramid_req = celery_app.conf['PYRAMID_REQUEST']
     return pyramid_req