From 985b35cdaba27835d6bdd90f296a1348ba9fa83c Mon Sep 17 00:00:00 2001
From: Fabio Erculiani <lxnay@sabayon.org>
Date: Mon, 31 Jan 2011 23:20:58 +0100
Subject: [PATCH] [entropy.server] first chunk of refactoring and cleanup work
 (making repo=None argument die)

---
 libraries/entropy/server/interfaces/db.py     | 146 +++---
 libraries/entropy/server/interfaces/main.py   | 471 +++++++-----------
 .../entropy/server/interfaces/mirrors.py      | 122 ++---
 libraries/entropy/server/transceivers.py      |   4 +-
 .../entropy/services/system/executors.py      |   4 +-
 .../interfaces/portage_plugin/__init__.py     |   7 +-
 server/server_reagent.py                      |  26 +-
 7 files changed, 349 insertions(+), 431 deletions(-)

diff --git a/libraries/entropy/server/interfaces/db.py b/libraries/entropy/server/interfaces/db.py
index 2fc693b3e..0c0b4f3f7 100644
--- a/libraries/entropy/server/interfaces/db.py
+++ b/libraries/entropy/server/interfaces/db.py
@@ -307,7 +307,7 @@ class ServerPackagesRepositoryUpdater(object):
     def __write_gpg_pubkey(self, repo_sec):
         pubkey = repo_sec.get_pubkey(self._repository_id)
         # write pubkey to file and add to data upload
-        gpg_path = self._entropy._get_local_database_gpg_signature_file(
+        gpg_path = self._entropy._get_local_repository_gpg_signature_file(
             self._repository_id)
         with open(gpg_path, "w") as gpg_f:
             gpg_f.write(pubkey)
@@ -325,7 +325,7 @@ class ServerPackagesRepositoryUpdater(object):
         """
         Return whether repository is locally locked (already).
         """
-        lock_file = self._entropy._get_database_lockfile(self._repository_id)
+        lock_file = self._entropy._get_repository_lockfile(self._repository_id)
         return os.path.isfile(lock_file)
 
     def _calculate_sync_queues(self):
@@ -368,8 +368,8 @@ class ServerPackagesRepositoryUpdater(object):
         extra_text_files = []
         gpg_signed_files = []
         data = {}
-        db_rev_file = self._entropy._get_local_database_revision_file(
-            repo = self._repository_id)
+        db_rev_file = self._entropy._get_local_repository_revision_file(
+            self._repository_id)
         # adding ~ at the beginning makes this file to be appended at the end
         # of the upload queue
         data['~database_revision_file'] = db_rev_file
@@ -378,14 +378,14 @@ class ServerPackagesRepositoryUpdater(object):
 
         # branch migration support scripts
         post_branch_mig_file = self._entropy._get_local_post_branch_mig_script(
-            repo = self._repository_id)
+            self._repository_id)
         if os.path.isfile(post_branch_mig_file) or download:
             if download:
                 data['database_post_branch_hop_script'] = post_branch_mig_file
             extra_text_files.append(post_branch_mig_file)
 
         post_branch_upg_file = self._entropy._get_local_post_branch_upg_script(
-            repo = self._repository_id)
+            self._repository_id)
         if os.path.isfile(post_branch_upg_file) or download:
             if download:
                 data['database_post_branch_upgrade_script'] = \
@@ -394,30 +394,29 @@ class ServerPackagesRepositoryUpdater(object):
 
         post_repo_update_file = \
             self._entropy._get_local_post_repo_update_script(
-                repo = self._repository_id)
+                self._repository_id)
         if os.path.isfile(post_repo_update_file) or download:
             if download:
                 data['database_post_repo_update_script'] = post_repo_update_file
             extra_text_files.append(post_repo_update_file)
 
-        database_ts_file = self._entropy._get_local_database_timestamp_file(
-            repo = self._repository_id)
+        database_ts_file = self._entropy._get_local_repository_timestamp_file(
+            self._repository_id)
         if os.path.isfile(database_ts_file) or download:
             data['database_timestamp_file'] = database_ts_file
             if not download:
                 critical.append(database_ts_file)
 
         database_package_mask_file = \
-            self._entropy._get_local_database_mask_file(
-                repo = self._repository_id)
+            self._entropy._get_local_repository_mask_file(self._repository_id)
         if os.path.isfile(database_package_mask_file) or download:
             if download:
                 data['database_package_mask_file'] = database_package_mask_file
             extra_text_files.append(database_package_mask_file)
 
         database_package_system_mask_file = \
-            self._entropy._get_local_database_system_mask_file(
-                repo = self._repository_id)
+            self._entropy._get_local_repository_system_mask_file(
+                self._repository_id)
         if os.path.isfile(database_package_system_mask_file) or download:
             if download:
                 data['database_package_system_mask_file'] = \
@@ -425,8 +424,8 @@ class ServerPackagesRepositoryUpdater(object):
             extra_text_files.append(database_package_system_mask_file)
 
         database_package_confl_tagged_file = \
-            self._entropy._get_local_database_confl_tagged_file(
-                repo = self._repository_id)
+            self._entropy._get_local_repository_confl_tagged_file(
+                self._repository_id)
         if os.path.isfile(database_package_confl_tagged_file) or download:
             if download:
                 data['database_package_confl_tagged_file'] = \
@@ -434,8 +433,8 @@ class ServerPackagesRepositoryUpdater(object):
             extra_text_files.append(database_package_confl_tagged_file)
 
         database_license_whitelist_file = \
-            self._entropy._get_local_database_licensewhitelist_file(
-                repo = self._repository_id)
+            self._entropy._get_local_repository_licensewhitelist_file(
+                self._repository_id)
         if os.path.isfile(database_license_whitelist_file) or download:
             if download:
                 data['database_license_whitelist_file'] = \
@@ -443,8 +442,8 @@ class ServerPackagesRepositoryUpdater(object):
             extra_text_files.append(database_license_whitelist_file)
 
         database_mirrors_file = \
-            self._entropy._get_local_database_mirrors_file(
-                repo = self._repository_id)
+            self._entropy._get_local_repository_mirrors_file(
+                self._repository_id)
         if os.path.isfile(database_mirrors_file) or download:
             if download:
                 data['database_mirrors_file'] = \
@@ -452,8 +451,8 @@ class ServerPackagesRepositoryUpdater(object):
             extra_text_files.append(database_mirrors_file)
 
         database_fallback_mirrors_file = \
-            self._entropy._get_local_database_fallback_mirrors_file(
-                repo = self._repository_id)
+            self._entropy._get_local_repository_fallback_mirrors_file(
+                self._repository_id)
         if os.path.isfile(database_fallback_mirrors_file) or download:
             if download:
                 data['database_fallback_mirrors_file'] = \
@@ -462,22 +461,22 @@ class ServerPackagesRepositoryUpdater(object):
 
         exp_based_pkgs_removal_file = \
             self._entropy._get_local_exp_based_pkgs_rm_whitelist_file(
-                repo = self._repository_id)
+                self._repository_id)
         if os.path.isfile(exp_based_pkgs_removal_file) or download:
             if download:
                 data['exp_based_pkgs_removal_file'] = \
                     exp_based_pkgs_removal_file
             extra_text_files.append(exp_based_pkgs_removal_file)
 
-        database_rss_file = self._entropy._get_local_database_rss_file(
-            repo = self._repository_id)
+        database_rss_file = self._entropy._get_local_repository_rss_file(
+            self._repository_id)
         if os.path.isfile(database_rss_file) or download:
             data['database_rss_file'] = database_rss_file
             if not download:
                 critical.append(data['database_rss_file'])
         database_rss_light_file = \
-            self._entropy._get_local_database_rsslight_file(
-                repo = self._repository_id)
+            self._entropy._get_local_repository_rsslight_file(
+                self._repository_id)
 
         if os.path.isfile(database_rss_light_file) or download:
             data['database_rss_light_file'] = database_rss_light_file
@@ -485,34 +484,34 @@ class ServerPackagesRepositoryUpdater(object):
                 critical.append(data['database_rss_light_file'])
 
         pkglist_file = self._entropy._get_local_pkglist_file(
-            repo = self._repository_id)
+            self._repository_id)
         data['pkglist_file'] = pkglist_file
         if not download:
             critical.append(data['pkglist_file'])
 
         critical_updates_file = self._entropy._get_local_critical_updates_file(
-            repo = self._repository_id)
+            self._repository_id)
         if os.path.isfile(critical_updates_file) or download:
             if download:
                 data['critical_updates_file'] = critical_updates_file
             extra_text_files.append(critical_updates_file)
 
         restricted_file = self._entropy._get_local_restricted_file(
-            repo = self._repository_id)
+            self._repository_id)
         if os.path.isfile(restricted_file) or download:
             if download:
                 data['restricted_file'] = restricted_file
             extra_text_files.append(restricted_file)
 
-        keywords_file = self._entropy._get_local_database_keywords_file(
-            repo = self._repository_id)
+        keywords_file = self._entropy._get_local_repository_keywords_file(
+            self._repository_id)
         if os.path.isfile(keywords_file) or download:
             if download:
                 data['keywords_file'] = keywords_file
             extra_text_files.append(keywords_file)
 
-        gpg_file = self._entropy._get_local_database_gpg_signature_file(
-            repo = self._repository_id)
+        gpg_file = self._entropy._get_local_repository_gpg_signature_file(
+            self._repository_id)
         if os.path.isfile(gpg_file) or download:
             data['gpg_file'] = gpg_file
             # no need to add to extra_text_files, it will be added
@@ -524,8 +523,7 @@ class ServerPackagesRepositoryUpdater(object):
 
             # upload eapi3 signal file
             something_new = os.path.join(
-                self._entropy._get_local_database_dir(
-                    repo = self._repository_id),
+                self._entropy._get_local_repository_dir(self._repository_id),
                 etpConst['etpdatabaseeapi3updates'])
             with open(something_new, "w") as sn_f:
                 sn_f.flush()
@@ -534,24 +532,22 @@ class ServerPackagesRepositoryUpdater(object):
 
             # always push metafiles file, it's cheap
             data['metafiles_path'] = \
-                self._entropy._get_local_database_compressed_metafiles_file(
-                    repo = self._repository_id)
+                self._entropy._get_local_repository_compressed_metafiles_file(
+                    self._repository_id)
             critical.append(data['metafiles_path'])
             gpg_signed_files.append(data['metafiles_path'])
 
             if 2 not in disabled_eapis:
 
                 data['dump_path_light'] = os.path.join(
-                    self._entropy._get_local_database_dir(
-                        repo = self._repository_id),
-                    etpConst[cmethod[5]])
+                    self._entropy._get_local_repository_dir(
+                        self._repository_id), etpConst[cmethod[5]])
                 critical.append(data['dump_path_light'])
                 gpg_signed_files.append(data['dump_path_light'])
 
                 data['dump_path_digest_light'] = os.path.join(
-                    self._entropy._get_local_database_dir(
-                        repo = self._repository_id),
-                    etpConst[cmethod[6]])
+                    self._entropy._get_local_repository_dir(
+                        self._repository_id), etpConst[cmethod[6]])
                 critical.append(data['dump_path_digest_light'])
                 gpg_signed_files.append(data['dump_path_digest_light'])
 
@@ -559,38 +555,33 @@ class ServerPackagesRepositoryUpdater(object):
         if 1 not in disabled_eapis:
 
             data['compressed_database_path'] = os.path.join(
-                self._entropy._get_local_database_dir(
-                    repo = self._repository_id),
+                self._entropy._get_local_repository_dir(self._repository_id),
                 etpConst[cmethod[2]])
             critical.append(data['compressed_database_path'])
             gpg_signed_files.append(data['compressed_database_path'])
 
             data['compressed_database_path_light'] = os.path.join(
-                self._entropy._get_local_database_dir(
-                    repo = self._repository_id),
+                self._entropy._get_local_repository_dir(self._repository_id),
                 etpConst[cmethod[7]])
             critical.append(data['compressed_database_path_light'])
             gpg_signed_files.append(data['compressed_database_path_light'])
 
             data['database_path_digest'] = os.path.join(
-                self._entropy._get_local_database_dir(
-                    repo = self._repository_id),
+                self._entropy._get_local_repository_dir(self._repository_id),
                 etpConst['etpdatabasehashfile']
             )
             critical.append(data['database_path_digest'])
             gpg_signed_files.append(data['database_path_digest'])
 
             data['compressed_database_path_digest'] = os.path.join(
-                self._entropy._get_local_database_dir(
-                    repo = self._repository_id),
+                self._entropy._get_local_repository_dir(self._repository_id),
                 etpConst[cmethod[2]] + etpConst['packagesmd5fileext']
             )
             critical.append(data['compressed_database_path_digest'])
             gpg_signed_files.append(data['compressed_database_path_digest'])
 
             data['compressed_database_path_digest_light'] = os.path.join(
-                self._entropy._get_local_database_dir(
-                    repo = self._repository_id),
+                self._entropy._get_local_repository_dir(self._repository_id),
                 etpConst[cmethod[8]]
             )
             critical.append(data['compressed_database_path_digest_light'])
@@ -599,15 +590,15 @@ class ServerPackagesRepositoryUpdater(object):
 
 
         # SSL cert file, just for reference
-        ssl_ca_cert = self._entropy._get_local_database_ca_cert_file(
-            repo = self._repository_id)
+        ssl_ca_cert = self._entropy._get_local_repository_ca_cert_file(
+            self._repository_id)
         if os.path.isfile(ssl_ca_cert):
             if download:
                 data['ssl_ca_cert_file'] = ssl_ca_cert
             extra_text_files.append(ssl_ca_cert)
 
-        ssl_server_cert = self._entropy._get_local_database_server_cert_file(
-            repo = self._repository_id)
+        ssl_server_cert = self._entropy._get_local_repository_server_cert_file(
+            self._repository_id)
         if os.path.isfile(ssl_server_cert):
             if download:
                 data['ssl_server_cert_file'] = ssl_server_cert
@@ -665,11 +656,10 @@ class ServerPackagesRepositoryUpdater(object):
             raise AttributeError("wrong repository compression method")
 
         crippled_uri = EntropyTransceiver.get_uri_name(uri)
-        database_path = self._entropy._get_local_database_file(
-            repo = self._repository_id)
+        database_path = self._entropy._get_local_repository_file(
+            self._repository_id)
         database_dir_path = os.path.dirname(
-            self._entropy._get_local_database_file(
-                repo = self._repository_id))
+            self._entropy._get_local_repository_file(self._repository_id))
 
         download_data, critical, text_files, tmp_dirs, \
             gpg_to_verify_files = self._get_files_to_sync(cmethod,
@@ -783,13 +773,13 @@ class ServerPackagesRepositoryUpdater(object):
     def _update_rss_feed(self):
 
         product = self._settings['repositories']['product']
-        rss_path = self._entropy._get_local_database_rss_file(
-            repo = self._repository_id)
-        rss_light_path = self._entropy._get_local_database_rsslight_file(
-            repo = self._repository_id)
+        rss_path = self._entropy._get_local_repository_rss_file(
+            self._repository_id)
+        rss_light_path = self._entropy._get_local_repository_rsslight_file(
+            self._repository_id)
         rss_dump_name = self._repository_id + etpConst['rss-dump-name']
-        db_revision_path = self._entropy._get_local_database_revision_file(
-            repo = self._repository_id)
+        db_revision_path = self._entropy._get_local_repository_revision_file(
+            self._repository_id)
 
         rss_title = "%s Online Repository Status" % (
             self._settings['system']['name'],)
@@ -866,7 +856,7 @@ class ServerPackagesRepositoryUpdater(object):
         Update the repository timestamp file.
         """
         from datetime import datetime
-        ts_file = self._entropy._get_local_database_timestamp_file(
+        ts_file = self._entropy._get_local_repository_timestamp_file(
             self._repository_id)
         current_ts = "%s" % (datetime.fromtimestamp(time.time()),)
         with open(ts_file, "w") as ts_f:
@@ -878,7 +868,7 @@ class ServerPackagesRepositoryUpdater(object):
         Create the repository packages list file.
         """
         pkglist_file = self._entropy._get_local_pkglist_file(
-            repo = self._repository_id)
+            self._repository_id)
 
         tmp_pkglist_file = pkglist_file + ".tmp"
         dbconn = self._entropy.open_server_repository(
@@ -1172,12 +1162,12 @@ class ServerPackagesRepositoryUpdater(object):
                 found_file_list.append(gpg_path)
             else:
                 gpg_path = \
-                    self._entropy._get_local_database_gpg_signature_file(
+                    self._entropy._get_local_repository_gpg_signature_file(
                         self._repository_id)
                 not_found_file_list.append(gpg_path) # not found
 
         metafile_not_found_file = \
-            self._entropy._get_local_database_metafiles_not_found_file(
+            self._entropy._get_local_repository_metafiles_not_found_file(
                 self._repository_id)
         with open(metafile_not_found_file, "w") as f_meta:
             f_meta.writelines(not_found_file_list)
@@ -1208,7 +1198,7 @@ class ServerPackagesRepositoryUpdater(object):
         cmethod = etpConst['etpdatabasecompressclasses'].get(db_format)
         if cmethod is None:
             raise AttributeError("wrong repository compression method passed")
-        database_path = self._entropy._get_local_database_file(
+        database_path = self._entropy._get_local_repository_file(
             self._repository_id)
 
         if disabled_eapis:
@@ -1255,7 +1245,7 @@ class ServerPackagesRepositoryUpdater(object):
         # now we can safely copy it
 
         # backup current database to avoid re-indexing
-        old_dbpath = self._entropy._get_local_database_file(self._repository_id)
+        old_dbpath = self._entropy._get_local_repository_file(self._repository_id)
         backup_dbpath = old_dbpath + ".up_backup"
         try:
             if os.access(backup_dbpath, os.R_OK) and \
@@ -1274,7 +1264,7 @@ class ServerPackagesRepositoryUpdater(object):
                 upload_data, cmethod)
 
             # create compressed dump + checksum
-            eapi2_dbfile = self._entropy._get_local_database_file(
+            eapi2_dbfile = self._entropy._get_local_repository_file(
                 self._repository_id)
             temp_eapi2_dbfile = eapi2_dbfile+".light_eapi2.tmp"
             shutil.copy2(eapi2_dbfile, temp_eapi2_dbfile)
@@ -1317,7 +1307,7 @@ class ServerPackagesRepositoryUpdater(object):
                 upload_data['compressed_database_path_digest'])
 
             # create light version of the compressed db
-            eapi1_dbfile = self._entropy._get_local_database_file(
+            eapi1_dbfile = self._entropy._get_local_repository_file(
                 self._repository_id)
             temp_eapi1_dbfile = eapi1_dbfile+".light"
             shutil.copy2(eapi1_dbfile, temp_eapi1_dbfile)
@@ -1422,8 +1412,8 @@ class ServerPackagesRepositoryUpdater(object):
 
             if not mirrors_locked and db_locked:
                 # mirrors not locked remotely but only locally
-                mylock_file = self._entropy._get_database_lockfile(
-                    repo = self._repository_id)
+                mylock_file = self._entropy._get_repository_lockfile(
+                    self._repository_id)
 
                 if os.access(mylock_file, os.W_OK) and \
                     os.path.isfile(mylock_file):
@@ -1453,7 +1443,7 @@ class ServerPackagesRepositoryUpdater(object):
         if download_latest:
             # close all the currently open repos
             self._entropy.close_repositories()
-            download_uri = download_latest.pop(0)
+            download_uri = download_latest[0]
             error = self._download(download_uri)
             if error:
                 self._entropy.output(
diff --git a/libraries/entropy/server/interfaces/main.py b/libraries/entropy/server/interfaces/main.py
index b047315e8..6aac84d41 100644
--- a/libraries/entropy/server/interfaces/main.py
+++ b/libraries/entropy/server/interfaces/main.py
@@ -93,7 +93,7 @@ class ServerEntropyRepositoryPlugin(EntropyRepositoryPlugin):
 
         repo = entropy_repository_instance.name
         local_dbfile = self._metadata['local_dbfile']
-        taint_file = self._server._get_local_database_taint_file(repo)
+        taint_file = self._server._get_local_repository_taint_file(repo)
         if os.path.isfile(taint_file):
             dbs = ServerRepositoryStatus()
             dbs.set_tainted(local_dbfile)
@@ -168,7 +168,7 @@ class ServerEntropyRepositoryPlugin(EntropyRepositoryPlugin):
             return 0
 
         # taint the database status
-        taint_file = self._server._get_local_database_taint_file(repo = repo)
+        taint_file = self._server._get_local_repository_taint_file(repo)
         f = open(taint_file, "w")
         f.write(etpConst['currentarch']+" repository tainted\n")
         f.flush()
@@ -184,8 +184,8 @@ class ServerEntropyRepositoryPlugin(EntropyRepositoryPlugin):
             Entropy repository revision bumping function. Every time it's called,
             revision is incremented by 1.
             """
-            revision_file = self._server._get_local_database_revision_file(
-                repo = repo)
+            revision_file = self._server._get_local_repository_revision_file(
+                repo)
             if not os.path.isfile(revision_file):
                 revision = 1
             else:
@@ -868,7 +868,7 @@ class ServerFatscopeSystemSettingsPlugin(SystemSettingsPlugin):
 
             idpackages = set()
             exp_fp = self._helper._get_local_exp_based_pkgs_rm_whitelist_file(
-                repo = repoid)
+                repoid)
             dbconn = self._helper.open_server_repository(
                 just_reading = True, repo = repoid)
 
@@ -912,8 +912,7 @@ class ServerFakeClientSystemSettingsPlugin(SystemSettingsPlugin):
                 "repository = %s|%s|http://--fake--|http://--fake--" % (
                     repoid, repo_data['description'],))
             my_data['repoid'] = repoid
-            my_data['dbpath'] = self._helper._get_local_database_dir(
-                repo = repoid)
+            my_data['dbpath'] = self._helper._get_local_repository_dir(repoid)
             my_data['dbrevision'] = self._helper.local_repository_revision(
                 repoid)
             cli_repodata['available'][repoid] = my_data
@@ -1005,7 +1004,7 @@ class ServerSettingsMixin:
         return db_download_uri.replace("/%s/" % (cur_branch,),
             "/%s/" % (new_branch,))
 
-    def _get_basedir_pkg_listing(self, base_dir, repo = None, branch = None):
+    def _get_basedir_pkg_listing(self, base_dir, branch = None):
 
         pkgs_dir_types = self._get_pkg_dir_names()
         basedir_raw_content = []
@@ -1029,302 +1028,215 @@ class ServerSettingsMixin:
             etpConst['packagesrelativepath_basedir_nonfree'],
             etpConst['packagesrelativepath_basedir_restricted']]
 
-    def _get_remote_database_relative_path(self, repo = None):
+    def _get_remote_repository_relative_path(self, repository_id):
         srv_set = self._settings[Server.SYSTEM_SETTINGS_PLG_ID]['server']
-        if repo is None:
-            repo = self.default_repository
-        return srv_set['repositories'][repo]['database_relative_path']
+        return srv_set['repositories'][repository_id]['database_relative_path']
 
-    def _get_local_database_file(self, repo = None, branch = None):
-        if repo is None:
-            repo = self.default_repository
-        return os.path.join(self._get_local_database_dir(repo, branch),
-            etpConst['etpdatabasefile'])
+    def _get_local_repository_file(self, repository_id, branch = None):
+        return os.path.join(self._get_local_repository_dir(repository_id,
+            branch = branch), etpConst['etpdatabasefile'])
 
-    def _get_local_store_directory(self, repo = None):
+    def _get_local_store_directory(self, repository_id):
         srv_set = self._settings[Server.SYSTEM_SETTINGS_PLG_ID]['server']
-        if repo is None:
-            repo = self.default_repository
-        return srv_set['repositories'][repo]['store_dir']
+        return srv_set['repositories'][repository_id]['store_dir']
 
-    def _get_local_upload_directory(self, repo = None):
+    def _get_local_upload_directory(self, repository_id):
         srv_set = self._settings[Server.SYSTEM_SETTINGS_PLG_ID]['server']
-        if repo is None:
-            repo = self.default_repository
-        return srv_set['repositories'][repo]['upload_basedir']
+        return srv_set['repositories'][repository_id]['upload_basedir']
 
-    def _get_local_repository_base_directory(self, repo = None):
+    def _get_local_repository_base_directory(self, repository_id):
         srv_set = self._settings[Server.SYSTEM_SETTINGS_PLG_ID]['server']
-        if repo is None:
-            repo = self.default_repository
-        return srv_set['repositories'][repo]['repo_basedir']
+        return srv_set['repositories'][repository_id]['repo_basedir']
 
-    def _get_local_database_taint_file(self, repo = None, branch = None):
-        if repo is None:
-            repo = self.default_repository
-        return os.path.join(self._get_local_database_dir(repo, branch),
-            etpConst['etpdatabasetaintfile'])
+    def _get_local_repository_taint_file(self, repository_id, branch = None):
+        return os.path.join(self._get_local_repository_dir(repository_id,
+            branch = branch), etpConst['etpdatabasetaintfile'])
 
-    def _get_local_database_revision_file(self, repo = None, branch = None):
-        if repo is None:
-            repo = self.default_repository
-        return os.path.join(self._get_local_database_dir(repo, branch),
-            etpConst['etpdatabaserevisionfile'])
+    def _get_local_repository_revision_file(self, repository_id, branch = None):
+        return os.path.join(
+            self._get_local_repository_dir(repository_id, branch = branch),
+                etpConst['etpdatabaserevisionfile'])
 
-    def _get_local_database_timestamp_file(self, repo = None, branch = None):
-        if repo is None:
-            repo = self.default_repository
-        return os.path.join(self._get_local_database_dir(repo, branch),
-            etpConst['etpdatabasetimestampfile'])
-
-    def _get_local_database_ca_cert_file(self, repo = None, branch = None):
-        if repo is None:
-            repo = self.default_repository
-        return os.path.join(self._get_local_database_dir(repo, branch),
-            etpConst['etpdatabasecacertfile'])
-
-    def _get_local_database_server_cert_file(self, repo = None, branch = None):
-        if repo is None:
-            repo = self.default_repository
-        return os.path.join(self._get_local_database_dir(repo, branch),
-            etpConst['etpdatabaseservercertfile'])
-
-    def _get_local_database_mask_file(self, repo = None, branch = None):
-        if repo is None:
-            repo = self.default_repository
-        return os.path.join(self._get_local_database_dir(repo, branch),
-            etpConst['etpdatabasemaskfile'])
-
-    def _get_local_database_system_mask_file(self, repo = None, branch = None):
-        if repo is None:
-            repo = self.default_repository
-        return os.path.join(self._get_local_database_dir(repo, branch),
-            etpConst['etpdatabasesytemmaskfile'])
-
-    def _get_local_database_confl_tagged_file(self, repo = None, branch = None):
-        if repo is None:
-            repo = self.default_repository
-        return os.path.join(self._get_local_database_dir(repo, branch),
-            etpConst['etpdatabaseconflictingtaggedfile'])
-
-    def _get_local_database_licensewhitelist_file(self, repo = None,
+    def _get_local_repository_timestamp_file(self, repository_id,
         branch = None):
-        if repo is None:
-            repo = self.default_repository
-        return os.path.join(self._get_local_database_dir(repo, branch),
-            etpConst['etpdatabaselicwhitelistfile'])
+        return os.path.join(self._get_local_repository_dir(repository_id,
+            branch = branch), etpConst['etpdatabasetimestampfile'])
 
-    def _get_local_database_mirrors_file(self, repo = None,
+    def _get_local_repository_ca_cert_file(self, repository_id, branch = None):
+        return os.path.join(self._get_local_repository_dir(repository_id,
+            branch = branch), etpConst['etpdatabasecacertfile'])
+
+    def _get_local_repository_server_cert_file(self, repository_id,
         branch = None):
-        if repo is None:
-            repo = self.default_repository
-        return os.path.join(self._get_local_database_dir(repo, branch),
-            etpConst['etpdatabasemirrorsfile'])
+        return os.path.join(self._get_local_repository_dir(repository_id,
+            branch = branch), etpConst['etpdatabaseservercertfile'])
 
-    def _get_local_database_fallback_mirrors_file(self, repo = None,
+    def _get_local_repository_mask_file(self, repository_id, branch = None):
+        return os.path.join(self._get_local_repository_dir(repository_id,
+            branch = branch), etpConst['etpdatabasemaskfile'])
+
+    def _get_local_repository_system_mask_file(self, repository_id,
         branch = None):
-        if repo is None:
-            repo = self.default_repository
-        return os.path.join(self._get_local_database_dir(repo, branch),
-            etpConst['etpdatabasefallbackmirrorsfile'])
+        return os.path.join(self._get_local_repository_dir(repository_id,
+            branch = branch), etpConst['etpdatabasesytemmaskfile'])
 
-    def _get_local_database_dep_rewrite_file(self, repo = None, branch = None):
-        if repo is None:
-            repo = self.default_repository
-        return os.path.join(self._get_local_database_dir(repo, branch),
-            etpConst['etpdatabasedeprewritefile'])
+    def _get_local_repository_confl_tagged_file(self, repository_id,
+        branch = None):
+        return os.path.join(self._get_local_repository_dir(repository_id,
+            branch = branch), etpConst['etpdatabaseconflictingtaggedfile'])
 
-    def _get_local_database_dep_blacklist_file(self, repo = None, branch = None):
-        if repo is None:
-            repo = self.default_repository
-        return os.path.join(self._get_local_database_dir(repo, branch),
-            etpConst['etpdatabasedepblacklistfile'])
+    def _get_local_repository_licensewhitelist_file(self, repository_id,
+        branch = None):
+        return os.path.join(self._get_local_repository_dir(repository_id,
+            branch = branch), etpConst['etpdatabaselicwhitelistfile'])
 
-    def _get_local_database_rss_file(self, repo = None, branch = None):
+    def _get_local_repository_mirrors_file(self, repository_id, branch = None):
+        return os.path.join(self._get_local_repository_dir(repository_id,
+            branch = branch), etpConst['etpdatabasemirrorsfile'])
+
+    def _get_local_repository_fallback_mirrors_file(self, repository_id,
+        branch = None):
+        return os.path.join(self._get_local_repository_dir(repository_id,
+            branch = branch), etpConst['etpdatabasefallbackmirrorsfile'])
+
+    def _get_local_repository_rss_file(self, repository_id, branch = None):
         srv_set = self._settings[Server.SYSTEM_SETTINGS_PLG_ID]['server']
-        if repo is None:
-            repo = self.default_repository
-        return os.path.join(self._get_local_database_dir(repo, branch),
-            srv_set['rss']['name'])
+        return os.path.join(self._get_local_repository_dir(repository_id,
+            branch = branch), srv_set['rss']['name'])
 
-    def _get_local_database_rsslight_file(self, repo = None, branch = None):
-        if repo is None:
-            repo = self.default_repository
-        return os.path.join(self._get_local_database_dir(repo, branch),
-            etpConst['rss-light-name'])
+    def _get_local_repository_rsslight_file(self, repository_id, branch = None):
+        return os.path.join(self._get_local_repository_dir(repository_id,
+            branch = branch), etpConst['rss-light-name'])
 
-    def _get_local_database_notice_board_file(self, repo = None, branch = None):
-        if repo is None:
-            repo = self.default_repository
-        return os.path.join(self._get_local_database_dir(repo, branch),
-            etpConst['rss-notice-board'])
-
-    def _get_local_database_treeupdates_file(self, repo = None, branch = None):
-        if repo is None:
-            repo = self.default_repository
-        return os.path.join(self._get_local_database_dir(repo, branch),
-            etpConst['etpdatabaseupdatefile'])
-
-    def _get_local_database_compressed_metafiles_file(self, repo = None,
+    def _get_local_repository_notice_board_file(self, repository_id,
         branch = None):
+        return os.path.join(self._get_local_repository_dir(repository_id,
+            branch = branch), etpConst['rss-notice-board'])
 
-        if repo is None:
-            repo = self.default_repository
-        return os.path.join(self._get_local_database_dir(repo, branch),
-            etpConst['etpdatabasemetafilesfile'])
-
-    def _get_local_database_metafiles_not_found_file(self, repo = None,
+    def _get_local_repository_treeupdates_file(self, repository_id,
         branch = None):
+        return os.path.join(self._get_local_repository_dir(repository_id,
+            branch = branch), etpConst['etpdatabaseupdatefile'])
 
-        if repo is None:
-            repo = self.default_repository
-        return os.path.join(self._get_local_database_dir(repo, branch),
-            etpConst['etpdatabasemetafilesnotfound'])
-
-    def _get_local_database_gpg_signature_file(self, repo = None, branch = None):
-        if repo is None:
-            repo = self.default_repository
-        return os.path.join(self._get_local_database_dir(repo, branch),
-            etpConst['etpdatabasegpgfile'])
-
-    def _get_local_exp_based_pkgs_rm_whitelist_file(self, repo = None,
+    def _get_local_repository_compressed_metafiles_file(self, repository_id,
         branch = None):
-        if repo is None:
-            repo = self.default_repository
-        return os.path.join(self._get_local_database_dir(repo, branch),
-            etpConst['etpdatabaseexpbasedpkgsrm'])
+        return os.path.join(self._get_local_repository_dir(repository_id,
+            branch = branch), etpConst['etpdatabasemetafilesfile'])
 
-    def _get_local_pkglist_file(self, repo = None, branch = None):
-        if repo is None:
-            repo = self.default_repository
-        return os.path.join(self._get_local_database_dir(repo, branch),
-            etpConst['etpdatabasepkglist'])
+    def _get_local_repository_metafiles_not_found_file(self, repository_id,
+        branch = None):
+        return os.path.join(self._get_local_repository_dir(repository_id,
+            branch = branch), etpConst['etpdatabasemetafilesnotfound'])
 
-    def _get_local_database_sets_dir(self, repo = None, branch = None):
-        if repo is None:
-            repo = self.default_repository
-        return os.path.join(self._get_local_database_dir(repo, branch),
-            etpConst['confsetsdirname'])
+    def _get_local_repository_gpg_signature_file(self, repository_id,
+        branch = None):
+        return os.path.join(self._get_local_repository_dir(repository_id,
+            branch = branch), etpConst['etpdatabasegpgfile'])
 
-    def _get_local_post_branch_mig_script(self, repo = None, branch = None):
-        if repo is None:
-            repo = self.default_repository
-        return os.path.join(self._get_local_database_dir(repo, branch),
-            etpConst['etp_post_branch_hop_script'])
+    def _get_local_exp_based_pkgs_rm_whitelist_file(self, repository_id,
+        branch = None):
+        return os.path.join(self._get_local_repository_dir(repository_id,
+            branch = branch), etpConst['etpdatabaseexpbasedpkgsrm'])
 
-    def _get_local_post_branch_upg_script(self, repo = None, branch = None):
-        if repo is None:
-            repo = self.default_repository
-        return os.path.join(self._get_local_database_dir(repo, branch),
-            etpConst['etp_post_branch_upgrade_script'])
+    def _get_local_pkglist_file(self, repository_id, branch = None):
+        return os.path.join(self._get_local_repository_dir(repository_id,
+            branch = branch), etpConst['etpdatabasepkglist'])
 
-    def _get_local_post_repo_update_script(self, repo = None, branch = None):
-        if repo is None:
-            repo = self.default_repository
-        return os.path.join(self._get_local_database_dir(repo, branch),
-            etpConst['etp_post_repo_update_script'])
+    def _get_local_database_sets_dir(self, repository_id, branch = None):
+        return os.path.join(self._get_local_repository_dir(repository_id,
+            branch = branch), etpConst['confsetsdirname'])
 
-    def _get_local_critical_updates_file(self, repo = None, branch = None):
-        if repo is None:
-            repo = self.default_repository
-        return os.path.join(self._get_local_database_dir(repo, branch),
-            etpConst['etpdatabasecriticalfile'])
+    def _get_local_post_branch_mig_script(self, repository_id, branch = None):
+        return os.path.join(self._get_local_repository_dir(repository_id,
+            branch = branch), etpConst['etp_post_branch_hop_script'])
 
-    def _get_local_restricted_file(self, repo = None, branch = None):
-        if repo is None:
-            repo = self.default_repository
-        return os.path.join(self._get_local_database_dir(repo, branch),
-            etpConst['etpdatabaserestrictedfile'])
+    def _get_local_post_branch_upg_script(self, repository_id, branch = None):
+        return os.path.join(self._get_local_repository_dir(repository_id,
+            branch = branch), etpConst['etp_post_branch_upgrade_script'])
 
-    def _get_local_database_keywords_file(self, repo = None, branch = None):
-        if repo is None:
-            repo = self.default_repository
-        return os.path.join(self._get_local_database_dir(repo, branch),
-            etpConst['etpdatabasekeywordsfile'])
+    def _get_local_post_repo_update_script(self, repository_id, branch = None):
+        return os.path.join(self._get_local_repository_dir(repository_id,
+            branch = branch), etpConst['etp_post_repo_update_script'])
 
-    def _get_local_database_dir(self, repo = None, branch = None):
+    def _get_local_critical_updates_file(self, repository_id, branch = None):
+        return os.path.join(self._get_local_repository_dir(repository_id,
+            branch = branch), etpConst['etpdatabasecriticalfile'])
+
+    def _get_local_restricted_file(self, repository_id, branch = None):
+        return os.path.join(self._get_local_repository_dir(repository_id,
+            branch = branch), etpConst['etpdatabaserestrictedfile'])
+
+    def _get_local_repository_keywords_file(self, repository_id, branch = None):
+        return os.path.join(self._get_local_repository_dir(repository_id,
+            branch = branch), etpConst['etpdatabasekeywordsfile'])
+
+    def _get_local_repository_dir(self, repository_id, branch = None):
         srv_set = self._settings[Server.SYSTEM_SETTINGS_PLG_ID]['server']
-        if repo is None:
-            repo = self.default_repository
         if branch is None:
             branch = self._settings['repositories']['branch']
-        return os.path.join(srv_set['repositories'][repo]['database_dir'],
-            branch)
+        return os.path.join(
+            srv_set['repositories'][repository_id]['database_dir'], branch)
 
-    def _get_missing_dependencies_blacklist_file(self, repo = None,
+    def _get_missing_dependencies_blacklist_file(self, repository_id,
         branch = None):
         srv_set = self._settings[Server.SYSTEM_SETTINGS_PLG_ID]['server']
-        if repo is None:
-            repo = self.default_repository
         if branch is None:
             branch = self._settings['repositories']['branch']
-        return os.path.join(srv_set['repositories'][repo]['database_dir'],
-            branch, etpConst['etpdatabasemissingdepsblfile'])
+        return os.path.join(
+            srv_set['repositories'][repository_id]['database_dir'],
+                branch, etpConst['etpdatabasemissingdepsblfile'])
 
-    def _get_database_lockfile(self, repo = None):
-        if repo is None:
-            repo = self.default_repository
-        return os.path.join(self._get_local_database_dir(repo),
+    def _get_repository_lockfile(self, repository_id):
+        return os.path.join(self._get_local_repository_dir(repository_id),
             etpConst['etpdatabaselockfile'])
 
-    def _get_database_download_lockfile(self, repo = None):
-        if repo is None:
-            repo = self.default_repository
-        return os.path.join(self._get_local_database_dir(repo),
+    def _get_repository_download_lockfile(self, repository_id):
+        return os.path.join(self._get_local_repository_dir(repository_id),
             etpConst['etpdatabasedownloadlockfile'])
 
-    def _create_local_database_download_lockfile(self, repo = None):
-        if repo is None:
-            repo = self.default_repository
-        lock_file = self._get_database_download_lockfile(repo)
-        f_lock = open(lock_file, "w")
-        f_lock.write("download locked")
-        f_lock.flush()
-        f_lock.close()
+    def _create_local_repository_download_lockfile(self, repository_id):
+        lock_file = self._get_repository_download_lockfile(repository_id)
+        with open(lock_file, "w") as f_lock:
+            f_lock.write("download locked")
+            f_lock.flush()
 
-    def _create_local_database_lockfile(self, repo = None):
-        if repo is None:
-            repo = self.default_repository
-        lock_file = self._get_database_lockfile(repo)
-        f_lock = open(lock_file, "w")
-        f_lock.write("database locked")
-        f_lock.flush()
-        f_lock.close()
+    def _create_local_repository_lockfile(self, repository_id):
+        lock_file = self._get_repository_lockfile(repository_id)
+        with open(lock_file, "w") as f_lock:
+            f_lock.write("database locked")
+            f_lock.flush()
 
-    def _remove_local_database_lockfile(self, repo = None):
-        if repo is None:
-            repo = self.default_repository
-        lock_file = self._get_database_lockfile(repo)
-        if os.path.isfile(lock_file):
+    def _remove_local_repository_lockfile(self, repository_id):
+        lock_file = self._get_repository_lockfile(repository_id)
+        try:
             os.remove(lock_file)
+        except OSError:
+            pass
 
-    def _remove_local_database_download_lockfile(self, repo = None):
-        if repo is None:
-            repo = self.default_repository
-        lock_file = self._get_database_download_lockfile(repo)
-        if os.path.isfile(lock_file):
+    def _remove_local_repository_download_lockfile(self, repository_id):
+        lock_file = self._get_repository_download_lockfile(repository_id)
+        try:
             os.remove(lock_file)
+        except OSError:
+            pass
 
-    def complete_remote_package_relative_path(self, pkg_rel_url, repo = None):
+    def complete_remote_package_relative_path(self, pkg_rel_url, repository_id):
         srv_set = self._settings[Server.SYSTEM_SETTINGS_PLG_ID]['server']
-        if repo is None:
-            repo = self.default_repository
         return os.path.join(
-            srv_set['repositories'][repo]['remote_repo_basedir'], pkg_rel_url)
+            srv_set['repositories'][repository_id]['remote_repo_basedir'],
+                pkg_rel_url)
 
-    def complete_local_upload_package_path(self, pkg_rel_url, repo = None):
+    def complete_local_upload_package_path(self, pkg_rel_url, repository_id):
         srv_set = self._settings[Server.SYSTEM_SETTINGS_PLG_ID]['server']
-        if repo is None:
-            repo = self.default_repository
-        return os.path.join(srv_set['repositories'][repo]['upload_basedir'],
-            pkg_rel_url)
+        return os.path.join(
+            srv_set['repositories'][repository_id]['upload_basedir'],
+                pkg_rel_url)
 
-    def complete_local_package_path(self, pkg_rel_url, repo = None):
+    def complete_local_package_path(self, pkg_rel_url, repository_id):
         srv_set = self._settings[Server.SYSTEM_SETTINGS_PLG_ID]['server']
-        if repo is None:
-            repo = self.default_repository
-        return os.path.join(srv_set['repositories'][repo]['repo_basedir'],
-            pkg_rel_url)
+        return os.path.join(
+            srv_set['repositories'][repository_id]['repo_basedir'],
+                pkg_rel_url)
 
     def remote_repository_mirrors(self, repository_id):
         """
@@ -1363,7 +1275,7 @@ class ServerSettingsMixin:
         @return: the actual repository revision
         @rtype: int
         """
-        dbrev_file = self._get_local_database_revision_file(repository_id)
+        dbrev_file = self._get_local_repository_revision_file(repository_id)
         if not os.path.isfile(dbrev_file):
             return 0
 
@@ -1513,7 +1425,7 @@ class ServerPackageDepsMixin:
         @return: mask status, True if ok, False if not
         @rtype: bool
         """
-        mask_file = self._get_local_database_mask_file(repo = repo)
+        mask_file = self._get_local_repository_mask_file(repo)
         current_packages = []
 
         if os.path.isfile(mask_file) and os.access(mask_file, os.R_OK):
@@ -1544,7 +1456,7 @@ class ServerPackageDepsMixin:
         @return: mask status, True if ok, False if not
         @rtype: bool
         """
-        mask_file = self._get_local_database_mask_file(repo = repo)
+        mask_file = self._get_local_repository_mask_file(repo)
         current_packages = []
 
         if os.path.isfile(mask_file) and os.access(mask_file, os.R_OK):
@@ -1593,7 +1505,7 @@ class ServerPackagesHandlingMixin:
             back = True
         )
 
-        if os.path.isfile(self._get_local_database_file(repo)):
+        if os.path.isfile(self._get_local_repository_file(repo)):
 
             # test out
             if show_warnings:
@@ -1604,7 +1516,7 @@ class ServerPackagesHandlingMixin:
                 mytxt = "%s: %s: %s" % (
                     bold(_("WARNING")),
                     red(_("repository already exists")),
-                    self._get_local_database_file(repo),
+                    self._get_local_repository_file(repo),
                 )
                 self.output(
                     mytxt,
@@ -1617,7 +1529,7 @@ class ServerPackagesHandlingMixin:
                 if rc_question == _("No"):
                     return
 
-            os.remove(self._get_local_database_file(repo))
+            os.remove(self._get_local_repository_file(repo))
 
         # initialize
         dbconn = self.open_server_repository(read_only = False,
@@ -1805,7 +1717,7 @@ class ServerPackagesHandlingMixin:
                 for pkg_fp, idpackage in download_queue[from_branch]:
                     down_url = dbconn.retrieveDownloadURL(idpackage)
                     down_rel = self.complete_remote_package_relative_path(
-                        down_url, repo = repo)
+                        down_url, repo)
                     down_rel_dir = os.path.dirname(down_rel)
                     obj = queue_map.setdefault(down_rel_dir, [])
                     obj.append(pkg_fp)
@@ -1963,7 +1875,7 @@ class ServerPackagesHandlingMixin:
 
                 # move files to upload
                 new_package_path = self.complete_local_upload_package_path(
-                    download_url, repo = repo)
+                    download_url, repo)
                 self._ensure_dir_path(os.path.dirname(new_package_path))
 
                 try:
@@ -2179,10 +2091,10 @@ class ServerPackagesHandlingMixin:
             )
             # move binary file
             from_file = self.complete_local_package_path(package_rel_path,
-                repo = repo)
+                repo)
             if not os.path.isfile(from_file):
                 from_file = self.complete_local_upload_package_path(
-                    package_rel_path, repo = repo)
+                    package_rel_path, repo)
             if not os.path.isfile(from_file):
                 self.output(
                     "[%s=>%s|%s] %s: %s -> %s" % (
@@ -2229,7 +2141,7 @@ class ServerPackagesHandlingMixin:
             del tmp_data
 
             to_file = self.complete_local_upload_package_path(
-                updated_package_rel_path, repo = to_repo)
+                updated_package_rel_path, to_repo)
 
             if new_tag != None:
 
@@ -2241,7 +2153,7 @@ class ServerPackagesHandlingMixin:
                         match_category, match_name, match_version, new_tag)
 
                 to_file = self.complete_local_upload_package_path(
-                    updated_package_rel_path, repo = to_repo)
+                    updated_package_rel_path, to_repo)
                 # directly move to correct place, tag changed, so file name
                 to_file = os.path.join(os.path.dirname(to_file),
                     tagged_package_filename)
@@ -2588,7 +2500,7 @@ class ServerPackagesHandlingMixin:
                     currentcounter += 1
                     pkgfile = dbconn.retrieveDownloadURL(idpackage)
                     pkgfile = self.complete_remote_package_relative_path(
-                        pkgfile, repo = repo)
+                        pkgfile, repo)
                     pkghash = dbconn.retrieveDigest(idpackage)
 
                     self.output(
@@ -3212,15 +3124,16 @@ class ServerPackagesHandlingMixin:
             level = "info",
             header = darkgreen(" @@ ")
         )
-        branch_dbdir = self._get_local_database_dir(repo)
-        old_branch_dbdir = self._get_local_database_dir(repo, from_branch)
+        branch_dbdir = self._get_local_repository_dir(repo)
+        old_branch_dbdir = self._get_local_repository_dir(repo,
+            branch = from_branch)
 
         # close all our databases
         self.close_repositories()
 
         # if database file did not exist got created as an empty file
         # we can just rm -rf it
-        branch_dbfile = self._get_local_database_file(repo)
+        branch_dbfile = self._get_local_repository_file(repo)
         if os.path.isfile(branch_dbfile):
             if entropy.tools.get_file_size(branch_dbfile) == 0:
                 shutil.rmtree(branch_dbdir, True)
@@ -3727,7 +3640,7 @@ class ServerRepositoryMixin:
             )
         else:
             # move empty database for security sake
-            dbfile = self._get_local_database_file(repoid)
+            dbfile = self._get_local_repository_file(repoid)
             if os.path.isfile(dbfile):
                 shutil.move(dbfile, dbfile+".backup")
             self.initialize_server_repository(repo = repoid,
@@ -3829,7 +3742,7 @@ class ServerRepositoryMixin:
             repo = self.default_repository
 
         # check if the database is locked locally
-        lock_file = self._get_database_lockfile(repo)
+        lock_file = self._get_repository_lockfile(repo)
         if os.path.isfile(lock_file):
             self.output(
                 red(_("Entropy repository is already locked by you :-)")),
@@ -4018,7 +3931,7 @@ class ServerRepositoryMixin:
             read_only = True
             no_upload = True
 
-        local_dbfile = self._get_local_database_file(repo, use_branch)
+        local_dbfile = self._get_local_repository_file(repo, branch = use_branch)
         if do_cache:
             cached = self._server_dbcache.get(
                 (repo, etpConst['systemroot'], local_dbfile, read_only,
@@ -4119,7 +4032,7 @@ class ServerRepositoryMixin:
     def setup_empty_repository(self, dbpath = None, repo = None):
 
         if dbpath is None:
-            dbpath = self._get_local_database_file(repo)
+            dbpath = self._get_local_repository_file(repo)
 
         dbdir = os.path.dirname(dbpath)
         if not os.path.isdir(dbdir):
@@ -4154,7 +4067,7 @@ class ServerRepositoryMixin:
         if repo is None:
             repo = self.default_repository
 
-        wl_file = self._get_local_database_licensewhitelist_file(repo = repo)
+        wl_file = self._get_local_repository_licensewhitelist_file(repo)
         if not os.path.isfile(wl_file):
             return []
         return entropy.tools.generic_file_content_parser(wl_file)
@@ -4164,7 +4077,7 @@ class ServerRepositoryMixin:
         if repo is None:
             repo = self.default_repository
 
-        rl_file = self._get_local_restricted_file(repo = repo)
+        rl_file = self._get_local_restricted_file(repo)
         if not os.path.isfile(rl_file):
             return []
         return entropy.tools.generic_file_content_parser(rl_file,
@@ -4349,7 +4262,7 @@ class ServerRepositoryMixin:
         download_url = self._setup_repository_package_filename(dbconn,
             idpackage)
         destination_path = self.complete_local_upload_package_path(
-            download_url, repo = repo)
+            download_url, repo)
         destination_dir = os.path.dirname(destination_path)
         self._ensure_dir_path(destination_dir)
 
@@ -4550,8 +4463,8 @@ class ServerRepositoryMixin:
             repo = self.default_repository
 
         # taint the database status
-        db_file = self._get_local_database_file(repo = repo)
-        taint_file = self._get_local_database_taint_file(repo = repo)
+        db_file = self._get_local_repository_file(repo)
+        taint_file = self._get_local_repository_taint_file(repo)
         f = open(taint_file, "w")
         f.write("repository tainted\n")
         f.flush()
@@ -4570,7 +4483,7 @@ class ServerMiscMixin:
 
     def _ensure_paths(self, repo):
         upload_dir = self._get_local_upload_directory(repo)
-        db_dir = self._get_local_database_dir(repo)
+        db_dir = self._get_local_repository_dir(repo)
         for mydir in [upload_dir, db_dir]:
             if (not os.path.isdir(mydir)) and (not os.path.lexists(mydir)):
                 os.makedirs(mydir, 0o755)
@@ -4584,11 +4497,11 @@ class ServerMiscMixin:
                 recursion = False, uid = etpConst['uid'])
 
     def _setup_services(self):
-        self._setup_entropy_settings()
+        self._setup_entropy_settings(self.default_repository)
         self._backup_entropy_settings()
         self.Mirrors = MirrorsServer(self, self.default_repository)
 
-    def _setup_entropy_settings(self, repo = None):
+    def _setup_entropy_settings(self, repository_id):
         srv_set = self._settings[Server.SYSTEM_SETTINGS_PLG_ID]['server']
         backup_list = [
             'etpdatabaseclientfilepath',
@@ -4601,7 +4514,7 @@ class ServerMiscMixin:
         # setup client database
         if not self.community_repo:
             etpConst['etpdatabaseclientfilepath'] = \
-                self._get_local_database_file(repo = repo)
+                self._get_local_repository_file(repository_id)
             etpConst['clientdbid'] = etpConst['serverdbid']
         const_create_working_dirs()
 
@@ -4724,7 +4637,8 @@ class ServerMiscMixin:
             repo = self.default_repository
         if branch is None:
             branch = self._settings['repositories']['branch']
-        wl_file = self._get_missing_dependencies_blacklist_file(repo, branch)
+        wl_file = self._get_missing_dependencies_blacklist_file(repo,
+            branch = branch)
         wl_data = []
         if os.path.isfile(wl_file) and os.access(wl_file, os.R_OK):
             f_wl = open(wl_file, "r")
@@ -4740,7 +4654,8 @@ class ServerMiscMixin:
             repo = self.default_repository
         if branch is None:
             branch = self._settings['repositories']['branch']
-        wl_file = self._get_missing_dependencies_blacklist_file(repo, branch)
+        wl_file = self._get_missing_dependencies_blacklist_file(repo,
+            branch = branch)
         wl_dir = os.path.dirname(wl_file)
         if not (os.path.isdir(wl_dir) and os.access(wl_dir, os.W_OK)):
             return
@@ -4757,8 +4672,7 @@ class ServerMiscMixin:
         path of package. This method does not check for path validity though.
         """
         pkg_rel_url = dbconn.retrieveDownloadURL(idpackage)
-        complete_path = self.complete_local_package_path(pkg_rel_url,
-            repo = repo)
+        complete_path = self.complete_local_package_path(pkg_rel_url, repo)
         return complete_path
 
     def _get_upload_package_path(self, repo, dbconn, idpackage):
@@ -4768,8 +4682,7 @@ class ServerMiscMixin:
         This method does not check for path validity though.
         """
         pkg_path = dbconn.retrieveDownloadURL(idpackage)
-        return os.path.join(self._get_local_upload_directory(repo = repo),
-            pkg_path)
+        return os.path.join(self._get_local_upload_directory(repo), pkg_path)
 
     def scan_package_changes(self):
 
@@ -5150,7 +5063,7 @@ class ServerMiscMixin:
         if repo is None:
             repo = self.default_repository
 
-        sets_dir = self._get_local_database_sets_dir(repo, branch)
+        sets_dir = self._get_local_database_sets_dir(repo, branch = branch)
         if not (os.path.isdir(sets_dir) and os.access(sets_dir, os.R_OK)):
             return {}
 
diff --git a/libraries/entropy/server/interfaces/mirrors.py b/libraries/entropy/server/interfaces/mirrors.py
index a2cea8c40..36eeae469 100644
--- a/libraries/entropy/server/interfaces/mirrors.py
+++ b/libraries/entropy/server/interfaces/mirrors.py
@@ -35,7 +35,7 @@ class ServerNoticeBoardMixin:
         if repo is None:
             repo = self._entropy.default_repository
         mirrors = self._entropy.remote_repository_mirrors(repo)
-        rss_path = self._entropy._get_local_database_notice_board_file(repo)
+        rss_path = self._entropy._get_local_repository_notice_board_file(repo)
         mytmpdir = tempfile.mkdtemp(prefix = "entropy.server")
 
         self._entropy.output(
@@ -84,7 +84,7 @@ class ServerNoticeBoardMixin:
         if repo is None:
             repo = self._entropy.default_repository
         mirrors = self._entropy.remote_repository_mirrors(repo)
-        rss_path = self._entropy._get_local_database_notice_board_file(repo)
+        rss_path = self._entropy._get_local_repository_notice_board_file(repo)
         rss_file = os.path.basename(rss_path)
 
         self._entropy.output(
@@ -139,7 +139,7 @@ class ServerNoticeBoardMixin:
         if repo is None:
             repo = self._entropy.default_repository
         mirrors = self._entropy.remote_repository_mirrors(repo)
-        rss_path = self._entropy._get_local_database_notice_board_file(repo)
+        rss_path = self._entropy._get_local_repository_notice_board_file(repo)
 
         self._entropy.output(
             "[repo:%s] %s %s" % (
@@ -191,7 +191,7 @@ class ServerNoticeBoardMixin:
 
         rss_title = "%s Notice Board" % (self._settings['system']['name'],)
         rss_description = "Inform about important distribution activities."
-        rss_path = self._entropy._get_local_database_notice_board_file(repo)
+        rss_path = self._entropy._get_local_repository_notice_board_file(repo)
         srv_set = self._settings[Server.SYSTEM_SETTINGS_PLG_ID]['server']
         if not link:
             link = srv_set['rss']['website_url']
@@ -210,7 +210,7 @@ class ServerNoticeBoardMixin:
 
     def read_notice_board(self, do_download = True, repo = None):
 
-        rss_path = self._entropy._get_local_database_notice_board_file(repo)
+        rss_path = self._entropy._get_local_repository_notice_board_file(repo)
         if do_download:
             self.download_notice_board(repo)
         if not (os.path.isfile(rss_path) and os.access(rss_path, os.R_OK)):
@@ -220,7 +220,7 @@ class ServerNoticeBoardMixin:
 
     def remove_from_notice_board(self, identifier, repo = None):
 
-        rss_path = self._entropy._get_local_database_notice_board_file(repo)
+        rss_path = self._entropy._get_local_repository_notice_board_file(repo)
         rss_title = "%s Notice Board" % (self._settings['system']['name'],)
         rss_description = "Inform about important distribution activities."
         if not (os.path.isfile(rss_path) and os.access(rss_path, os.R_OK)):
@@ -314,7 +314,7 @@ class Server(ServerNoticeBoardMixin):
                 header = brown(" @@ ")
             )
 
-            branches_path = self._entropy._get_remote_database_relative_path(
+            branches_path = self._entropy._get_remote_repository_relative_path(
                 repo)
             txc = self._entropy.Transceiver(uri)
             txc.set_verbosity(False)
@@ -389,7 +389,7 @@ class Server(ServerNoticeBoardMixin):
             )
 
             base_path = os.path.join(
-                self._entropy._get_remote_database_relative_path(repo),
+                self._entropy._get_remote_repository_relative_path(repo),
                 self._settings['repositories']['branch'])
             lock_file = os.path.join(base_path,
                 etpConst['etpdatabaselockfile'])
@@ -434,7 +434,7 @@ class Server(ServerNoticeBoardMixin):
                 issues = True
 
         if not issues:
-            db_taint_file = self._entropy._get_local_database_taint_file(repo)
+            db_taint_file = self._entropy._get_local_repository_taint_file(repo)
             if os.path.isfile(db_taint_file):
                 os.remove(db_taint_file)
 
@@ -481,7 +481,7 @@ class Server(ServerNoticeBoardMixin):
 
             lock_file = etpConst['etpdatabasedownloadlockfile']
             my_path = os.path.join(
-                self._entropy._get_remote_database_relative_path(repo),
+                self._entropy._get_remote_repository_relative_path(repo),
                 self._settings['repositories']['branch'])
             lock_file = os.path.join(my_path, lock_file)
 
@@ -533,7 +533,7 @@ class Server(ServerNoticeBoardMixin):
             repo = self._entropy.default_repository
 
         my_path = os.path.join(
-            self._entropy._get_remote_database_relative_path(repo),
+            self._entropy._get_remote_repository_relative_path(repo),
             self._settings['repositories']['branch'])
 
         # create path to lock file if it doesn't exist
@@ -544,13 +544,13 @@ class Server(ServerNoticeBoardMixin):
         lock_string = ''
 
         if dblock:
-            self._entropy._create_local_database_lockfile(repo)
-            lock_file = self._entropy._get_database_lockfile(repo)
+            self._entropy._create_local_repository_lockfile(repo)
+            lock_file = self._entropy._get_repository_lockfile(repo)
         else:
             # locking/unlocking mirror1 for download
             lock_string = _('for download')
-            self._entropy._create_local_database_download_lockfile(repo)
-            lock_file = self._entropy._get_database_download_lockfile(repo)
+            self._entropy._create_local_repository_download_lockfile(repo)
+            lock_file = self._entropy._get_repository_download_lockfile(repo)
 
         remote_path = os.path.join(my_path, os.path.basename(lock_file))
 
@@ -581,7 +581,7 @@ class Server(ServerNoticeBoardMixin):
                 level = "error",
                 header = darkred(" * ")
             )
-            self._entropy._remove_local_database_lockfile(repo)
+            self._entropy._remove_local_repository_lockfile(repo)
 
         return rc_upload
 
@@ -592,7 +592,7 @@ class Server(ServerNoticeBoardMixin):
             repo = self._entropy.default_repository
 
         my_path = os.path.join(
-            self._entropy._get_remote_database_relative_path(repo),
+            self._entropy._get_remote_repository_relative_path(repo),
             self._settings['repositories']['branch'])
 
         crippled_uri = EntropyTransceiver.get_uri_name(uri)
@@ -618,9 +618,9 @@ class Server(ServerNoticeBoardMixin):
                 header = darkgreen(" * ")
             )
             if dblock:
-                self._entropy._remove_local_database_lockfile(repo)
+                self._entropy._remove_local_repository_lockfile(repo)
             else:
-                self._entropy._remove_local_database_download_lockfile(repo)
+                self._entropy._remove_local_repository_download_lockfile(repo)
         else:
             self._entropy.output(
                 "[repo:%s|%s] %s: %s - %s" % (
@@ -667,9 +667,9 @@ class Server(ServerNoticeBoardMixin):
 
                 remote_path = \
                     self._entropy.complete_remote_package_relative_path(
-                        pkg_relative_path, repo = repo)
+                        pkg_relative_path, repo)
                 download_path = self._entropy.complete_local_package_path(
-                    pkg_relative_path, repo = repo)
+                    pkg_relative_path, repo)
 
                 download_dir = os.path.dirname(download_path)
 
@@ -798,7 +798,7 @@ class Server(ServerNoticeBoardMixin):
         if cmethod is None:
             raise AttributeError("Wrong repository compression method passed")
         remote_dir = os.path.join(
-            self._entropy._get_remote_database_relative_path(repo),
+            self._entropy._get_remote_repository_relative_path(repo),
             self._settings['repositories']['branch'])
 
         # let raise exception if connection is impossible
@@ -808,7 +808,7 @@ class Server(ServerNoticeBoardMixin):
             compressedfile = etpConst[cmethod[2]]
             rc1 = handler.is_file(os.path.join(remote_dir, compressedfile))
 
-            rev_file = self._entropy._get_local_database_revision_file(repo)
+            rev_file = self._entropy._get_local_repository_revision_file(repo)
             revfilename = os.path.basename(rev_file)
             rc2 = handler.is_file(os.path.join(remote_dir, revfilename))
 
@@ -911,7 +911,7 @@ class Server(ServerNoticeBoardMixin):
         """
         dbstatus = []
         remote_dir = os.path.join(
-            self._entropy._get_remote_database_relative_path(repository_id),
+            self._entropy._get_remote_repository_relative_path(repository_id),
             self._settings['repositories']['branch'])
         lock_file = os.path.join(remote_dir, etpConst['etpdatabaselockfile'])
         down_lock_file = os.path.join(remote_dir,
@@ -955,12 +955,11 @@ class Server(ServerNoticeBoardMixin):
         """
         gave_up = False
 
-        lock_file = self._entropy._get_database_lockfile(repo = repository_id)
+        lock_file = self._entropy._get_repository_lockfile(repository_id)
         lock_filename = os.path.basename(lock_file)
 
         remote_dir = os.path.join(
-            self._entropy._get_remote_database_relative_path(
-                repo = repository_id),
+            self._entropy._get_remote_repository_relative_path(repository_id),
             self._settings['repositories']['branch'])
         remote_lock_file = os.path.join(remote_dir, lock_filename)
 
@@ -1014,7 +1013,10 @@ class Server(ServerNoticeBoardMixin):
     def _calculate_local_upload_files(self, repo = None):
         upload_files = 0
         upload_packages = set()
-        upload_dir = self._entropy._get_local_upload_directory(repo = repo)
+        if repo is None:
+            repo = self._entropy.default_repository
+
+        upload_dir = self._entropy._get_local_upload_directory(repo)
 
         # check if it exists
         if not os.path.isdir(upload_dir):
@@ -1022,7 +1024,7 @@ class Server(ServerNoticeBoardMixin):
 
         branch = self._settings['repositories']['branch']
         upload_pkgs = self._entropy._get_basedir_pkg_listing(upload_dir,
-            repo = repo, branch = branch)
+            branch = branch)
 
         pkg_ext = etpConst['packagesext']
         pkg_md5_ext = etpConst['packagesmd5fileext']
@@ -1037,8 +1039,9 @@ class Server(ServerNoticeBoardMixin):
     def _calculate_local_package_files(self, repo = None):
         local_files = 0
         local_packages = set()
-        base_dir = self._entropy._get_local_repository_base_directory(
-            repo = repo)
+        if repo is None:
+            repo = self._entropy.default_repository
+        base_dir = self._entropy._get_local_repository_base_directory(repo)
 
         # check if it exists
         if not os.path.isdir(base_dir):
@@ -1046,7 +1049,7 @@ class Server(ServerNoticeBoardMixin):
 
         branch = self._settings['repositories']['branch']
         pkg_files = self._entropy._get_basedir_pkg_listing(base_dir,
-            repo = repo, branch = branch)
+            branch = branch)
 
         pkg_ext = etpConst['packagesext']
         pkg_md5_ext = etpConst['packagesmd5fileext']
@@ -1225,11 +1228,11 @@ class Server(ServerNoticeBoardMixin):
         for pkg_dir_type in pkgs_dir_types:
 
             remote_dir = self._entropy.complete_remote_package_relative_path(
-                pkg_dir_type, repo = repo)
+                pkg_dir_type, repo)
             remote_dir = os.path.join(remote_dir, etpConst['currentarch'],
                 branch)
             only_dir = self._entropy.complete_remote_package_relative_path("",
-                repo = repo)
+                repo)
             db_url_dir = remote_dir[len(only_dir):]
 
             # create path to lock file if it doesn't exist
@@ -1317,7 +1320,7 @@ class Server(ServerNoticeBoardMixin):
 
                 local_filepath = \
                     self._entropy.complete_local_upload_package_path(
-                        local_package, repo = repo)
+                        local_package, repo)
 
                 local_size = entropy.tools.get_file_size(local_filepath)
                 remote_size = remote_packages_data.get(local_package)
@@ -1343,7 +1346,7 @@ class Server(ServerNoticeBoardMixin):
 
             if local_package in remote_packages:
                 local_filepath = self._entropy.complete_local_package_path(
-                    local_package, repo = repo)
+                    local_package, repo)
                 local_size = entropy.tools.get_file_size(local_filepath)
                 remote_size = remote_packages_data.get(local_package)
                 if remote_size is None:
@@ -1365,7 +1368,7 @@ class Server(ServerNoticeBoardMixin):
 
             if remote_package in local_packages:
                 local_filepath = self._entropy.complete_local_package_path(
-                    remote_package, repo = repo)
+                    remote_package, repo)
                 local_size = entropy.tools.get_file_size(local_filepath)
                 remote_size = remote_packages_data.get(remote_package)
                 if remote_size is None:
@@ -1434,7 +1437,7 @@ class Server(ServerNoticeBoardMixin):
 
         for item in removal_queue:
             local_filepath = self._entropy.complete_local_package_path(
-                item, repo = repo)
+                item, repo)
             size = entropy.tools.get_file_size(local_filepath)
             metainfo['removal'] += size
             removal.append((local_filepath, item, size))
@@ -1442,7 +1445,7 @@ class Server(ServerNoticeBoardMixin):
         for item in download_queue:
 
             local_filepath = self._entropy.complete_local_upload_package_path(
-                item, repo = repo)
+                item, repo)
             if not os.path.isfile(local_filepath):
                 size = remote_packages_data.get(item)
                 if size is None:
@@ -1457,10 +1460,10 @@ class Server(ServerNoticeBoardMixin):
         for item in upload_queue:
 
             local_filepath = self._entropy.complete_local_upload_package_path(
-                item, repo = repo)
+                item, repo)
 
             local_filepath_pkgs = self._entropy.complete_local_package_path(
-                item, repo = repo)
+                item, repo)
             if os.path.isfile(local_filepath):
                 size = entropy.tools.get_file_size(local_filepath)
                 upload.append((local_filepath, item, size))
@@ -1528,7 +1531,8 @@ class Server(ServerNoticeBoardMixin):
         for from_file, rel_file, size in copy_queue:
             from_file_hash = from_file + etpConst['packagesmd5fileext']
 
-            to_file = self._entropy.complete_local_package_path(rel_file)
+            to_file = self._entropy.complete_local_package_path(rel_file,
+                repo)
             to_file_hash = to_file+etpConst['packagesmd5fileext']
             expiration_file = to_file+etpConst['packagesexpirationfileext']
 
@@ -1581,7 +1585,7 @@ class Server(ServerNoticeBoardMixin):
         for rel_path, myqueue in queue_map.items():
 
             remote_dir = self._entropy.complete_remote_package_relative_path(
-                rel_path, repo = repo)
+                rel_path, repo)
 
             uploader = self.TransceiverServerHandler(self._entropy, [uri],
                 myqueue, critical_files = myqueue,
@@ -1650,10 +1654,10 @@ class Server(ServerNoticeBoardMixin):
         for rel_path, myqueue in queue_map.items():
 
             remote_dir = self._entropy.complete_remote_package_relative_path(
-                rel_path, repo = repo)
+                rel_path, repo)
 
             local_basedir = self._entropy.complete_local_package_path(rel_path,
-                repo = repo)
+                repo)
             if not os.path.isdir(local_basedir):
                 self._entropy._ensure_dir_path(local_basedir)
 
@@ -2030,16 +2034,15 @@ class Server(ServerNoticeBoardMixin):
         if repo is None:
             repo = self._entropy.default_repository
 
-        upload_dir = self._entropy._get_local_upload_directory(repo = repo)
-        basedir_list = self._entropy._get_basedir_pkg_listing(upload_dir,
-            repo = repo)
+        upload_dir = self._entropy._get_local_upload_directory(repo)
+        basedir_list = self._entropy._get_basedir_pkg_listing(upload_dir)
 
         for pkg_rel in basedir_list:
 
             source_pkg = self._entropy.complete_local_upload_package_path(
-                pkg_rel, repo = repo)
+                pkg_rel, repo)
             dest_pkg = self._entropy.complete_local_package_path(pkg_rel,
-                repo = repo)
+                repo)
             dest_pkg_dir = os.path.dirname(dest_pkg)
             self._entropy._ensure_dir_path(dest_pkg_dir)
 
@@ -2067,7 +2070,7 @@ class Server(ServerNoticeBoardMixin):
     def _is_package_expired(self, package_rel, repo = None):
 
         pkg_path = self._entropy.complete_local_package_path(package_rel,
-            repo = repo)
+            repo)
         pkg_path += etpConst['packagesexpirationfileext']
         if not os.path.isfile(pkg_path):
             return False
@@ -2085,8 +2088,11 @@ class Server(ServerNoticeBoardMixin):
 
     def _create_expiration_file(self, package_rel, repo = None, gentle = False):
 
+        if repo is None:
+            repo = self._entropy.default_repository
+
         pkg_path = self._entropy.complete_local_package_path(package_rel,
-            repo = repo)
+            repo)
         pkg_path += etpConst['packagesexpirationfileext']
         if gentle and os.path.isfile(pkg_path):
             return
@@ -2096,17 +2102,19 @@ class Server(ServerNoticeBoardMixin):
 
     def _collect_expiring_packages(self, branch, repo = None):
 
+        if repo is None:
+            repo = self._entropy.default_repository
+
         dbconn = self._entropy.open_server_repository(just_reading = True,
             repo = repo)
 
         database_bins = set(dbconn.listAllDownloads(do_sort = False,
             full_path = True))
 
-        repo_basedir = self._entropy._get_local_repository_base_directory(
-            repo = repo)
+        repo_basedir = self._entropy._get_local_repository_base_directory(repo)
 
         repo_bins = self._entropy._get_basedir_pkg_listing(repo_basedir,
-            repo = repo, branch = branch)
+            branch = branch)
 
         # convert to set, so that we can do fast thingszzsd
         repo_bins = set(repo_bins)
@@ -2223,7 +2231,7 @@ class Server(ServerNoticeBoardMixin):
         removal_map = {}
         for package_rel in removal:
             rel_path = self._entropy.complete_remote_package_relative_path(
-                package_rel, repo = repo)
+                package_rel, repo)
             rel_dir = os.path.dirname(rel_path)
             obj = removal_map.setdefault(rel_dir, [])
             base_pkg = os.path.basename(package_rel)
@@ -2306,7 +2314,7 @@ class Server(ServerNoticeBoardMixin):
             for package_rel in removal:
 
                 package_path = self._entropy.complete_local_package_path(
-                    package_rel, repo = repo)
+                    package_rel, repo)
 
                 package_path_hash = package_path + \
                     etpConst['packagesmd5fileext']
diff --git a/libraries/entropy/server/transceivers.py b/libraries/entropy/server/transceivers.py
index 138d4398d..4fdba4c61 100644
--- a/libraries/entropy/server/transceivers.py
+++ b/libraries/entropy/server/transceivers.py
@@ -62,7 +62,7 @@ class TransceiverServerHandler:
             # default to database directory
             branch = self._settings['repositories']['branch']
             my_path = os.path.join(
-                self.Entropy._get_remote_database_relative_path(repo), branch)
+                self.Entropy._get_remote_repository_relative_path(repo), branch)
             self.txc_basedir = my_path
         else:
             self.txc_basedir = txc_basedir
@@ -70,7 +70,7 @@ class TransceiverServerHandler:
         if not local_basedir:
             # default to database directory
             self.local_basedir = os.path.dirname(
-                self.Entropy._get_local_database_file(self.repo))
+                self.Entropy._get_local_repository_file(self.repo))
         else:
             self.local_basedir = local_basedir
 
diff --git a/libraries/entropy/services/system/executors.py b/libraries/entropy/services/system/executors.py
index cb2fbcdd6..2131b06ec 100644
--- a/libraries/entropy/services/system/executors.py
+++ b/libraries/entropy/services/system/executors.py
@@ -579,7 +579,7 @@ class Base:
 
                 # run quickpkg
                 for repoid in to_add:
-                    store_dir = Entropy._get_local_store_directory(repo = repoid)
+                    store_dir = Entropy._get_local_store_directory(repoid)
                     for atom in to_add[repoid]:
                         Entropy.Spm().generate_package(atom, store_dir)
 
@@ -589,7 +589,7 @@ class Base:
                     avail_repos.pop(etpConst['clientserverrepoid'])
                 matches_added = set()
                 for repoid in avail_repos:
-                    store_dir = Entropy._get_local_store_directory(repo = repoid)
+                    store_dir = Entropy._get_local_store_directory(repoid)
                     package_files = os.listdir(store_dir)
                     if not package_files:
                         continue
diff --git a/libraries/entropy/spm/plugins/interfaces/portage_plugin/__init__.py b/libraries/entropy/spm/plugins/interfaces/portage_plugin/__init__.py
index 24a9828e3..d586e777e 100644
--- a/libraries/entropy/spm/plugins/interfaces/portage_plugin/__init__.py
+++ b/libraries/entropy/spm/plugins/interfaces/portage_plugin/__init__.py
@@ -2374,7 +2374,7 @@ class PortagePlugin(SpmPlugin):
                     header = blue("  # ")
                 )
 
-            mydest = entropy_server._get_local_store_directory(repo = repo)
+            mydest = entropy_server._get_local_store_directory(repo)
             try:
                 mypath = self.generate_package(myatom, mydest)
             except Exception:
@@ -2493,8 +2493,9 @@ class PortagePlugin(SpmPlugin):
     def package_names_update(self, entropy_repository, entropy_repository_id,
         entropy_server, entropy_branch):
 
-        repo_updates_file = entropy_server._get_local_database_treeupdates_file(
-            entropy_repository_id)
+        repo_updates_file = \
+            entropy_server._get_local_repository_treeupdates_file(
+                entropy_repository_id)
         do_rescan = False
 
         stored_digest = entropy_repository.retrieveRepositoryUpdatesDigest(
diff --git a/server/server_reagent.py b/server/server_reagent.py
index d35114b8a..a516617c6 100644
--- a/server/server_reagent.py
+++ b/server/server_reagent.py
@@ -558,7 +558,8 @@ def _switch_branch(entropy_server, args):
 
 def _restore_repository(entropy_server):
 
-    db_file = entropy_server._get_local_database_file()
+    db_file = entropy_server._get_local_repository_file(
+        entropy_server.default_repository)
     db_dir = os.path.dirname(db_file)
     dblist = entropy_server.installed_repository_backups(
         client_dbdir = db_dir)
@@ -767,11 +768,12 @@ def _repositories(entropy_server, options):
 
     elif cmd == "backup":
 
-        db_path = entropy_server._get_local_database_file()
+        db_path = entropy_server._get_local_repository_file(
+            entropy_server.default_repository)
         # make sure to close all repos before backing-up
         entropy_server.close_repositories()
-        rc, err_msg = entropy_server.backup_repository(entropy_server.default_repository,
-            os.path.dirname(db_path))
+        rc, err_msg = entropy_server.backup_repository(
+            entropy_server.default_repository, os.path.dirname(db_path))
         if not rc:
             print_info(darkred(" ** ")+red("%s: %s" % (
                 _("Error"), err_msg,) ))
@@ -1029,7 +1031,8 @@ def _update(entropy_server, options):
 
         # package them
         print_info(brown(" @@ ")+blue("%s..." % (_("Compressing packages"),) ))
-        store_dir = entropy_server._get_local_store_directory()
+        store_dir = entropy_server._get_local_store_directory(
+            entropy_server.default_repository)
         for x in to_be_added:
             print_info(brown("    # ")+red(x[0]+"..."))
             try:
@@ -1039,7 +1042,8 @@ def _update(entropy_server, options):
                 print_info(brown("    !!! ")+bold("%s..." % (
                     _("Ignoring broken Spm entry, please recompile it"),) ))
 
-    store_dir = entropy_server._get_local_store_directory()
+    store_dir = entropy_server._get_local_store_directory(
+        entropy_server.default_repository)
     etp_pkg_files = []
     if os.path.isdir(store_dir):
         etp_pkg_files = os.listdir(store_dir)
@@ -1048,7 +1052,10 @@ def _update(entropy_server, options):
         # then exit gracefully
         return 0
 
-    etp_pkg_files = [(os.path.join(entropy_server._get_local_store_directory(), x), False,) for x in etp_pkg_files]
+    local_store_dir = entropy_server._get_local_store_directory(
+        entropy_server.default_repository)
+    etp_pkg_files = [(os.path.join(local_store_dir, x), False) \
+        for x in etp_pkg_files]
     idpackages = entropy_server.add_packages_to_repository(etp_pkg_files)
 
     if idpackages:
@@ -1083,9 +1090,8 @@ def _status(entropy_server):
     for repo_id in sorted(repos_data):
         repo_data = repos_data[repo_id]
         repo_rev = entropy_server.local_repository_revision(repo_id)
-        store_dir = entropy_server._get_local_store_directory(repo = repo_id)
-        upload_basedir = entropy_server._get_local_upload_directory(
-            repo = repo_id)
+        store_dir = entropy_server._get_local_store_directory(repo_id)
+        upload_basedir = entropy_server._get_local_upload_directory(repo_id)
         upload_files, upload_packages = \
             entropy_server.Mirrors._calculate_local_upload_files(
                 repo = repo_id)