use 'sitesync' over 'sync_server'

client/ayon_core/host/dirmap.py

@@ -36,23 +36,23 @@ class HostDirmap(object):
         host_name,
         project_name,
         project_settings=None,
-        sync_module=None
+        sitesync_addon=None
     ):
         self.host_name = host_name
         self.project_name = project_name
         self._project_settings = project_settings
-        self._sync_module = sync_module
+        self._sitesync_addon = sitesync_addon
         # to limit reinit of Modules
-        self._sync_module_discovered = sync_module is not None
+        self._sitesync_addon_discovered = sitesync_addon is not None
         self._log = None
 
     @property
-    def sync_module(self):
+    def sitesync_addon(self):
-        if not self._sync_module_discovered:
+        if not self._sitesync_addon_discovered:
-            self._sync_module_discovered = True
+            self._sitesync_addon_discovered = True
             manager = AddonsManager()
-            self._sync_module = manager.get("sync_server")
+            self._sitesync_addon = manager.get("sitesync")
-        return self._sync_module
+        return self._sitesync_addon
 
     @property
     def project_settings(self):
@@ -158,25 +158,25 @@ class HostDirmap(object):
         """
         project_name = self.project_name
 
-        sync_module = self.sync_module
+        sitesync_addon = self.sitesync_addon
         mapping = {}
         if (
-            sync_module is None
+            sitesync_addon is None
-            or not sync_module.enabled
+            or not sitesync_addon.enabled
-            or project_name not in sync_module.get_enabled_projects()
+            or project_name not in sitesync_addon.get_enabled_projects()
         ):
             return mapping
 
-        active_site = sync_module.get_local_normalized_site(
+        active_site = sitesync_addon.get_local_normalized_site(
-            sync_module.get_active_site(project_name))
+            sitesync_addon.get_active_site(project_name))
-        remote_site = sync_module.get_local_normalized_site(
+        remote_site = sitesync_addon.get_local_normalized_site(
-            sync_module.get_remote_site(project_name))
+            sitesync_addon.get_remote_site(project_name))
         self.log.debug(
             "active {} - remote {}".format(active_site, remote_site)
         )
 
         if active_site == "local" and active_site != remote_site:
-            sync_settings = sync_module.get_sync_project_setting(
+            sync_settings = sitesync_addon.get_sync_project_setting(
                 project_name,
                 exclude_locals=False,
                 cached=False)
@@ -194,7 +194,7 @@ class HostDirmap(object):
             self.log.debug("remote overrides {}".format(remote_overrides))
 
             current_platform = platform.system().lower()
-            remote_provider = sync_module.get_provider_for_site(
+            remote_provider = sitesync_addon.get_provider_for_site(
                 project_name, remote_site
             )
             # dirmap has sense only with regular disk provider, in the workfile

client/ayon_core/hosts/nuke/api/lib.py

@@ -2627,11 +2627,11 @@ class NukeDirmap(HostDirmap):
 
 
 class DirmapCache:
-    """Caching class to get settings and sync_module easily and only once."""
+    """Caching class to get settings and sitesync easily and only once."""
     _project_name = None
     _project_settings = None
-    _sync_module_discovered = False
+    _sitesync_addon_discovered = False
-    _sync_module = None
+    _sitesync_addon = None
     _mapping = None
 
     @classmethod
@@ -2647,11 +2647,11 @@ class DirmapCache:
         return cls._project_settings
 
     @classmethod
-    def sync_module(cls):
+    def sitesync_addon(cls):
-        if not cls._sync_module_discovered:
+        if not cls._sitesync_addon_discovered:
-            cls._sync_module_discovered = True
+            cls._sitesync_addon_discovered = True
-            cls._sync_module = AddonsManager().get("sync_server")
+            cls._sitesync_addon = AddonsManager().get("sitesync")
-        return cls._sync_module
+        return cls._sitesync_addon
 
     @classmethod
     def mapping(cls):
@@ -2673,7 +2673,7 @@ def dirmap_file_name_filter(file_name):
         "nuke",
         DirmapCache.project_name(),
         DirmapCache.project_settings(),
-        DirmapCache.sync_module(),
+        DirmapCache.sitesync_addon(),
     )
     if not DirmapCache.mapping():
         DirmapCache.set_mapping(dirmap_processor.get_mappings())

client/ayon_core/pipeline/anatomy/anatomy.py

@@ -447,7 +447,7 @@ class CacheItem:
 
 
 class Anatomy(BaseAnatomy):
-    _sync_server_addon_cache = CacheItem()
+    _sitesync_addon_cache = CacheItem()
     _project_cache = collections.defaultdict(CacheItem)
     _default_site_id_cache = collections.defaultdict(CacheItem)
     _root_overrides_cache = collections.defaultdict(
@@ -482,13 +482,13 @@ class Anatomy(BaseAnatomy):
         return copy.deepcopy(project_cache.data)
 
     @classmethod
-    def get_sync_server_addon(cls):
+    def get_sitesync_addon(cls):
-        if cls._sync_server_addon_cache.is_outdated:
+        if cls._sitesync_addon_cache.is_outdated:
             manager = AddonsManager()
-            cls._sync_server_addon_cache.update_data(
+            cls._sitesync_addon_cache.update_data(
-                manager.get_enabled_addon("sync_server")
+                manager.get_enabled_addon("sitesync")
             )
-        return cls._sync_server_addon_cache.data
+        return cls._sitesync_addon_cache.data
 
     @classmethod
     def _get_studio_roots_overrides(cls, project_name):
@@ -525,8 +525,8 @@ class Anatomy(BaseAnatomy):
         """
 
         # First check if sync server is available and enabled
-        sync_server = cls.get_sync_server_addon()
+        sitesync_addon = cls.get_sitesync_addon()
-        if sync_server is None or not sync_server.enabled:
+        if sitesync_addon is None or not sitesync_addon.enabled:
             # QUESTION is ok to force 'studio' when site sync is not enabled?
             site_name = "studio"
 
@@ -535,7 +535,7 @@ class Anatomy(BaseAnatomy):
             project_cache = cls._default_site_id_cache[project_name]
             if project_cache.is_outdated:
                 project_cache.update_data(
-                    sync_server.get_active_site_type(project_name)
+                    sitesync_addon.get_active_site_type(project_name)
                 )
             site_name = project_cache.data
 
@@ -549,7 +549,7 @@ class Anatomy(BaseAnatomy):
                 )
             else:
                 # Ask sync server to get roots overrides
-                roots_overrides = sync_server.get_site_root_overrides(
+                roots_overrides = sitesync.get_site_root_overrides(
                     project_name, site_name
                 )
             site_cache.update_data(roots_overrides)

client/ayon_core/tools/loader/models/site_sync.py

@@ -57,7 +57,7 @@ class SiteSyncModel:
         )
 
         manager = AddonsManager()
-        self._site_sync_addon = manager.get("sync_server")
+        self._site_sync_addon = manager.get("sitesync")
 
     def reset(self):
         self._site_icons = None

client/ayon_core/tools/sceneinventory/control.py

@@ -89,8 +89,8 @@ class SceneInventoryController:
         return []
 
     # Site Sync methods
-    def is_sync_server_enabled(self):
+    def is_sitesync_enabled(self):
-        return self._site_sync_model.is_sync_server_enabled()
+        return self._site_sync_model.is_sitesync_enabled()
 
     def get_sites_information(self):
         return self._site_sync_model.get_sites_information()

client/ayon_core/tools/sceneinventory/models/site_sync.py

@@ -9,30 +9,30 @@ class SiteSyncModel:
     def __init__(self, controller):
         self._controller = controller
 
-        self._sync_server_module = NOT_SET
+        self._sitesync_addon = NOT_SET
-        self._sync_server_enabled = None
+        self._sitesync_enabled = None
         self._active_site = NOT_SET
         self._remote_site = NOT_SET
         self._active_site_provider = NOT_SET
         self._remote_site_provider = NOT_SET
 
     def reset(self):
-        self._sync_server_module = NOT_SET
+        self._sitesync_addon = NOT_SET
-        self._sync_server_enabled = None
+        self._sitesync_enabled = None
         self._active_site = NOT_SET
         self._remote_site = NOT_SET
         self._active_site_provider = NOT_SET
         self._remote_site_provider = NOT_SET
 
-    def is_sync_server_enabled(self):
+    def is_sitesync_enabled(self):
         """Site sync is enabled.
 
         Returns:
             bool: Is enabled or not.
         """
 
-        self._cache_sync_server_module()
+        self._cache_sitesync_addon()
-        return self._sync_server_enabled
+        return self._sitesync_enabled
 
     def get_site_provider_icons(self):
         """Icon paths per provider.
@@ -41,9 +41,9 @@ class SiteSyncModel:
             dict[str, str]: Path by provider name.
         """
 
-        if not self.is_sync_server_enabled():
+        if not self.is_sitesync_enabled():
             return {}
-        site_sync_addon = self._get_sync_server_module()
+        site_sync_addon = self._get_sitesync_addon()
         return site_sync_addon.get_site_icons()
 
     def get_sites_information(self):
@@ -65,11 +65,11 @@ class SiteSyncModel:
             }
             for repre_id in representation_ids
         }
-        if not self.is_sync_server_enabled():
+        if not self.is_sitesync_enabled():
             return output
 
         project_name = self._controller.get_current_project_name()
-        site_sync = self._get_sync_server_module()
+        site_sync = self._get_sitesync_addon()
         repre_entities = ayon_api.get_representations(
             project_name, representation_ids
         )
@@ -95,7 +95,7 @@ class SiteSyncModel:
         """
 
         project_name = self._controller.get_current_project_name()
-        site_sync = self._get_sync_server_module()
+        site_sync = self._get_sitesync_addon()
         active_site = self._get_active_site()
         remote_site = self._get_remote_site()
         progress = self.get_representations_site_progress(
@@ -119,18 +119,18 @@ class SiteSyncModel:
                     project_name, repre_id, site, force=True
                 )
 
-    def _get_sync_server_module(self):
+    def _get_sitesync_addon(self):
-        self._cache_sync_server_module()
+        self._cache_sitesync_addon()
-        return self._sync_server_module
+        return self._sitesync_addon
 
-    def _cache_sync_server_module(self):
+    def _cache_sitesync_addon(self):
-        if self._sync_server_module is not NOT_SET:
+        if self._sitesync_addon is not NOT_SET:
-            return self._sync_server_module
+            return self._sitesync_addon
         manager = AddonsManager()
-        site_sync = manager.get("sync_server")
+        site_sync = manager.get("sitesync")
         sync_enabled = site_sync is not None and site_sync.enabled
-        self._sync_server_module = site_sync
+        self._sitesync_addon = site_sync
-        self._sync_server_enabled = sync_enabled
+        self._sitesync_enabled = sync_enabled
 
     def _get_active_site(self):
         if self._active_site is NOT_SET:
@@ -157,8 +157,8 @@ class SiteSyncModel:
         remote_site = None
         active_site_provider = None
         remote_site_provider = None
-        if self.is_sync_server_enabled():
+        if self.is_sitesync_enabled():
-            site_sync = self._get_sync_server_module()
+            site_sync = self._get_sitesync_addon()
             project_name = self._controller.get_current_project_name()
             active_site = site_sync.get_active_site(project_name)
             remote_site = site_sync.get_remote_site(project_name)

client/ayon_core/tools/sceneinventory/view.py

@@ -311,9 +311,9 @@ class SceneInventoryView(QtWidgets.QTreeView):
 
         menu.addAction(remove_action)
 
-        self._handle_sync_server(menu, repre_ids)
+        self._handle_sitesync(menu, repre_ids)
 
-    def _handle_sync_server(self, menu, repre_ids):
+    def _handle_sitesync(self, menu, repre_ids):
         """Adds actions for download/upload when SyncServer is enabled
 
         Args:
@@ -324,7 +324,7 @@ class SceneInventoryView(QtWidgets.QTreeView):
             (OptionMenu)
         """
 
-        if not self._controller.is_sync_server_enabled():
+        if not self._controller.is_sitesync_enabled():
             return
 
         menu.addSeparator()

client/ayon_core/tools/sceneinventory/window.py

@@ -70,7 +70,7 @@ class SceneInventoryWindow(QtWidgets.QDialog):
         view = SceneInventoryView(controller, self)
         view.setModel(proxy)
 
-        sync_enabled = controller.is_sync_server_enabled()
+        sync_enabled = controller.is_sitesync_enabled()
         view.setColumnHidden(model.active_site_col, not sync_enabled)
         view.setColumnHidden(model.remote_site_col, not sync_enabled)