SiteSync: host dirmap is not working properly (#4563)

- only editable keys are returned from Site Sync module to Local Settings

Cleaner approach even if LS UI is going away in Ayon.

- use remote_site only if is local_drive provider

- remove unwanted import

- cache mapping, update logging

Mapping was called multiple times for Nuke.
Logging was too verbose.

openpype/host/dirmap.py

@@ -39,7 +39,6 @@ class HostDirmap(object):
         self._project_settings = project_settings
         self._sync_module = sync_module  # to limit reinit of Modules
         self._log = None
-        self._mapping = None  # cache mapping
 
     @property
     def sync_module(self):
@@ -70,29 +69,28 @@ class HostDirmap(object):
         """Run host dependent remapping from source_path to destination_path"""
         pass
 
-    def process_dirmap(self):
+    def process_dirmap(self, mapping=None):
         # type: (dict) -> None
         """Go through all paths in Settings and set them using `dirmap`.
 
             If artists has Site Sync enabled, take dirmap mapping directly from
             Local Settings when artist is syncing workfile locally.
 
-        Args:
-            project_settings (dict): Settings for current project.
         """
 
-        if not self._mapping:
-            self._mapping = self.get_mappings(self.project_settings)
-        if not self._mapping:
+        if not mapping:
+            mapping = self.get_mappings()
+        if not mapping:
             return
 
-        self.log.info("Processing directory mapping ...")
         self.on_enable_dirmap()
-        self.log.info("mapping:: {}".format(self._mapping))
 
-        for k, sp in enumerate(self._mapping["source-path"]):
-            dst = self._mapping["destination-path"][k]
+        for k, sp in enumerate(mapping["source-path"]):
+            dst = mapping["destination-path"][k]
             try:
+                # add trailing slash if missing
+                sp = os.path.join(sp, '')
+                dst = os.path.join(dst, '')
                 print("{} -> {}".format(sp, dst))
                 self.dirmap_routine(sp, dst)
             except IndexError:
@@ -110,28 +108,24 @@ class HostDirmap(object):
                 )
                 continue
 
-    def get_mappings(self, project_settings):
+    def get_mappings(self):
         """Get translation from source-path to destination-path.
 
             It checks if Site Sync is enabled and user chose to use local
             site, in that case configuration in Local Settings takes precedence
         """
 
-        local_mapping = self._get_local_sync_dirmap(project_settings)
         dirmap_label = "{}-dirmap".format(self.host_name)
-        if (
-            not self.project_settings[self.host_name].get(dirmap_label)
-            and not local_mapping
-        ):
-            return {}
-        mapping_settings = self.project_settings[self.host_name][dirmap_label]
-        mapping_enabled = mapping_settings["enabled"] or bool(local_mapping)
+        mapping_sett = self.project_settings[self.host_name].get(dirmap_label,
+                                                                 {})
+        local_mapping = self._get_local_sync_dirmap()
+        mapping_enabled = mapping_sett.get("enabled") or bool(local_mapping)
         if not mapping_enabled:
             return {}
 
         mapping = (
             local_mapping
-            or mapping_settings["paths"]
+            or mapping_sett["paths"]
             or {}
         )
 
@@ -141,28 +135,27 @@ class HostDirmap(object):
             or not mapping.get("source-path")
         ):
             return {}
+        self.log.info("Processing directory mapping ...")
+        self.log.info("mapping:: {}".format(mapping))
         return mapping
 
-    def _get_local_sync_dirmap(self, project_settings):
+    def _get_local_sync_dirmap(self):
         """
             Returns dirmap if synch to local project is enabled.
 
             Only valid mapping is from roots of remote site to local site set
             in Local Settings.
 
-            Args:
-                project_settings (dict)
             Returns:
                 dict : { "source-path": [XXX], "destination-path": [YYYY]}
         """
+        project_name = os.getenv("AVALON_PROJECT")
 
         mapping = {}
-
-        if not project_settings["global"]["sync_server"]["enabled"]:
+        if (not self.sync_module.enabled or
+                project_name not in self.sync_module.get_enabled_projects()):
             return mapping
 
-        project_name = os.getenv("AVALON_PROJECT")
-
         active_site = self.sync_module.get_local_normalized_site(
             self.sync_module.get_active_site(project_name))
         remote_site = self.sync_module.get_local_normalized_site(
@@ -171,11 +164,7 @@ class HostDirmap(object):
             "active {} - remote {}".format(active_site, remote_site)
         )
 
-        if (
-            active_site == "local"
-            and project_name in self.sync_module.get_enabled_projects()
-            and active_site != remote_site
-        ):
+        if active_site == "local" and active_site != remote_site:
             sync_settings = self.sync_module.get_sync_project_setting(
                 project_name,
                 exclude_locals=False,
@@ -188,7 +177,15 @@ class HostDirmap(object):
 
             self.log.debug("local overrides {}".format(active_overrides))
             self.log.debug("remote overrides {}".format(remote_overrides))
+
             current_platform = platform.system().lower()
+            remote_provider = self.sync_module.get_provider_for_site(
+                project_name, remote_site
+            )
+            # dirmap has sense only with regular disk provider, in the workfile
+            # wont be root on cloud or sftp provider
+            if remote_provider != "local_drive":
+                remote_site = "studio"
             for root_name, active_site_dir in active_overrides.items():
                 remote_site_dir = (
                     remote_overrides.get(root_name)

openpype/hosts/nuke/api/lib.py

@@ -2861,10 +2861,10 @@ class NukeDirmap(HostDirmap):
         pass
 
     def dirmap_routine(self, source_path, destination_path):
-        log.debug("{}: {}->{}".format(self.file_name,
-                                      source_path, destination_path))
         source_path = source_path.lower().replace(os.sep, '/')
         destination_path = destination_path.lower().replace(os.sep, '/')
+        log.debug("Map: {} with: {}->{}".format(self.file_name,
+                                                source_path, destination_path))
         if platform.system().lower() == "windows":
             self.file_name = self.file_name.lower().replace(
                 source_path, destination_path)
@@ -2878,6 +2878,7 @@ class DirmapCache:
     _project_name = None
     _project_settings = None
     _sync_module = None
+    _mapping = None
 
     @classmethod
     def project_name(cls):
@@ -2897,6 +2898,36 @@ class DirmapCache:
             cls._sync_module = ModulesManager().modules_by_name["sync_server"]
         return cls._sync_module
 
+    @classmethod
+    def mapping(cls):
+        return cls._mapping
+
+    @classmethod
+    def set_mapping(cls, mapping):
+        cls._mapping = mapping
+
+
+def dirmap_file_name_filter(file_name):
+    """Nuke callback function with single full path argument.
+
+        Checks project settings for potential mapping from source to dest.
+    """
+
+    dirmap_processor = NukeDirmap(
+        file_name,
+        "nuke",
+        DirmapCache.project_name(),
+        DirmapCache.project_settings(),
+        DirmapCache.sync_module(),
+    )
+    if not DirmapCache.mapping():
+        DirmapCache.set_mapping(dirmap_processor.get_mappings())
+
+    dirmap_processor.process_dirmap(DirmapCache.mapping())
+    if os.path.exists(dirmap_processor.file_name):
+        return dirmap_processor.file_name
+    return file_name
+
 
 @contextlib.contextmanager
 def node_tempfile():
@@ -2942,25 +2973,6 @@ def duplicate_node(node):
     return dupli_node
 
 
-def dirmap_file_name_filter(file_name):
-    """Nuke callback function with single full path argument.
-
-        Checks project settings for potential mapping from source to dest.
-    """
-
-    dirmap_processor = NukeDirmap(
-        file_name,
-        "nuke",
-        DirmapCache.project_name(),
-        DirmapCache.project_settings(),
-        DirmapCache.sync_module(),
-    )
-    dirmap_processor.process_dirmap()
-    if os.path.exists(dirmap_processor.file_name):
-        return dirmap_processor.file_name
-    return file_name
-
-
 def get_group_io_nodes(nodes):
     """Get the input and the output of a group of nodes."""
 

openpype/modules/sync_server/sync_server_module.py

@@ -1472,13 +1472,15 @@ class SyncServerModule(OpenPypeModule, ITrayModule):
 
         return sync_settings
 
-    def get_all_site_configs(self, project_name=None):
+    def get_all_site_configs(self, project_name=None,
+                             local_editable_only=False):
         """
             Returns (dict) with all sites configured system wide.
 
             Args:
                 project_name (str)(optional): if present, check if not disabled
-
+                local_editable_only (bool)(opt): if True return only Local
+                    Setting configurable (for LS UI)
             Returns:
                 (dict): {'studio': {'provider':'local_drive'...},
                          'MY_LOCAL': {'provider':....}}
@@ -1499,9 +1501,21 @@ class SyncServerModule(OpenPypeModule, ITrayModule):
                     if site_settings:
                         detail.update(site_settings)
                 system_sites[site] = detail
-
         system_sites.update(self._get_default_site_configs(sync_enabled,
                                                            project_name))
+        if local_editable_only:
+            local_schema = SyncServerModule.get_local_settings_schema()
+            editable_keys = {}
+            for provider_code, editables in local_schema.items():
+                editable_keys[provider_code] = ["enabled", "provider"]
+                for editable_item in editables:
+                    editable_keys[provider_code].append(editable_item["key"])
+
+            for _, site in system_sites.items():
+                provider = site["provider"]
+                for site_config_key in list(site.keys()):
+                    if site_config_key not in editable_keys[provider]:
+                        site.pop(site_config_key, None)
 
         return system_sites
 

openpype/tools/settings/local_settings/projects_widget.py

@@ -272,7 +272,7 @@ class SitesWidget(QtWidgets.QWidget):
         )
 
         site_configs = sync_server_module.get_all_site_configs(
-            self._project_name)
+            self._project_name, local_editable_only=True)
 
         roots_entity = (
             self.project_settings[PROJECT_ANATOMY_KEY][LOCAL_ROOTS_KEY]