Merge branch 'main' into backlog/harmony-windows

Author: henriknorin-ftrack

libs/framework-core/source/ftrack_framework_core/client/__init__.py

@@ -5,18 +5,24 @@
 import logging
 import uuid
 from collections import defaultdict
+from functools import partial
+import atexit
 
 from six import string_types
 
+import ftrack_api
+
 from ftrack_framework_core.widget.dialog import FrameworkDialog
 import ftrack_constants.framework as constants
 
 from ftrack_framework_core.client.host_connection import HostConnection
 
-from ftrack_utils.decorators import track_framework_usage
+from ftrack_utils.decorators import track_framework_usage, run_in_main_thread
 
 from ftrack_utils.framework.config.tool import get_tool_config_by_name
 
+from ftrack_framework_core.event import EventManager
+
 
 class Client(object):
     '''
@@ -179,10 +185,22 @@ def registry(self):
     def tool_config_options(self):
         return self._tool_config_options
 
+    @property
+    def remote_event_manager(self):
+        # TODO: this is a temporal solution, 1 session should be able to act as local and remote at the same time
+        if self._remote_event_manager:
+            return self._remote_event_manager
+        else:
+            _remote_session = ftrack_api.Session(auto_connect_event_hub=False)
+            self._remote_event_manager = EventManager(
+                session=_remote_session, mode=constants.event.REMOTE_EVENT_MODE
+            )
+        # Make sure it is shutdown
+        atexit.register(self.close)
+        return self._remote_event_manager
+
     def __init__(
-        self,
-        event_manager,
-        registry,
+        self, event_manager, registry, run_in_main_thread_wrapper=None
     ):
         '''
         Initialise Client with instance of
@@ -206,6 +224,10 @@ def __init__(
         self.__instanced_dialogs = {}
         self._dialog = None
         self._tool_config_options = defaultdict(defaultdict)
+        self._remote_event_manager = None
+
+        # Set up the run_in_main_thread decorator
+        self.run_in_main_thread_wrapper = run_in_main_thread_wrapper
 
         self.logger.debug('Initialising Client {}'.format(self))
 
@@ -267,6 +289,7 @@ def on_host_changed(self, host_connection):
         self.event_manager.publish.client_signal_host_changed(self.id)
 
     # Context
+    @run_in_main_thread
     def _host_context_changed_callback(self, event):
         '''Set the new context ID based on data provided in *event*'''
         # Feed the new context to the client
@@ -302,6 +325,7 @@ def run_tool_config(self, tool_config_reference):
         )
 
     # Plugin
+    @run_in_main_thread
     def on_log_item_added_callback(self, event):
         '''
         Called when a log item has added in the host.
@@ -321,6 +345,7 @@ def on_log_item_added_callback(self, event):
             self.id, event['data']['log_item']
         )
 
+    @run_in_main_thread
     def on_ui_hook_callback(self, event):
         '''
         Called ui_hook has been executed on host and needs to notify UI with
@@ -339,24 +364,111 @@ def reset_all_tool_configs(self):
         '''
         self.host_connection.reset_all_tool_configs()
 
+    @run_in_main_thread
+    def _on_discover_action_callback(
+        self, name, label, dialog_name, options, session_identifier_func, event
+    ):
+        '''Discover *event*.'''
+        if session_identifier_func:
+            session_id = session_identifier_func()
+            label = label + " @" + session_id
+        selection = event['data'].get('selection', [])
+        if len(selection) == 1 and selection[0]['entityType'] == 'Component':
+            return {
+                'items': [
+                    {
+                        'name': name,
+                        'label': label,
+                        'host_id': self.host_id,
+                        'dialog_name': dialog_name,
+                        'options': options,
+                    }
+                ]
+            }
+
+    @run_in_main_thread
+    def _on_launch_action_callback(self, event):
+        '''Handle *event*.
+
+        event['data'] should contain:
+
+            *applicationIdentifier* to identify which application to start.
+
+        '''
+        selection = event['data']['selection']
+
+        name = event['data']['name']
+        label = event['data']['label']
+        dialog_name = event['data']['dialog_name']
+        options = event['data']['options']
+        options['event_data'] = {'selection': selection}
+
+        self.run_tool(name, dialog_name, options)
+
+    def subscribe_action_tool(
+        self,
+        name,
+        label=None,
+        dialog_name=None,
+        options=None,
+        session_identifier_func=None,
+    ):
+        '''
+        Subscribe the given tool to the ftrack.action.discover and
+        ftrack.action.launch events.
+        '''
+        if not options:
+            options = dict()
+        # TODO: The event should be added to the event manager to be accesible
+        #  through subscribe and publish classes
+        self.remote_event_manager.session.event_hub.subscribe(
+            u'topic=ftrack.action.discover and '
+            u'source.user.username="{0}"'.format(self.session.api_user),
+            partial(
+                self._on_discover_action_callback,
+                name,
+                label,
+                dialog_name,
+                options,
+                session_identifier_func,
+            ),
+        )
+
+        self.remote_event_manager.session.event_hub.subscribe(
+            u'topic=ftrack.action.launch and '
+            u'data.name={0} and '
+            u'source.user.username="{1}" and '
+            u'data.host_id={2}'.format(
+                name, self.session.api_user, self.host_id
+            ),
+            self._on_launch_action_callback,
+        )
+
     @track_framework_usage(
         'FRAMEWORK_RUN_TOOL',
         {'module': 'client'},
         ['name'],
     )
-    def run_tool(self, name, dialog_name=None, options=dict, dock_func=False):
+    def run_tool(
+        self,
+        name,
+        dialog_name=None,
+        options=None,
+        dock_func=False,
+    ):
         '''
         Client runs the tool passed from the DCC config, can run run_dialog
         if the tool has UI or directly run_tool_config if it doesn't.
         '''
+
         self.logger.info(f"Running {name} tool")
+        if not options:
+            options = dict()
+
         if dialog_name:
             self.run_dialog(
                 dialog_name,
-                dialog_options={
-                    'tool_config_names': options.get('tool_configs'),
-                    'docked': options.get('docked', False),
-                },
+                dialog_options=options,
                 dock_func=dock_func,
             )
         else:
@@ -375,6 +487,11 @@ def run_tool(self, name, dialog_name=None, options=dict, dock_func=False):
                         f"Couldn't find any tool config matching the name {tool_config_name}"
                     )
                     continue
+
+                self.set_config_options(
+                    tool_config['reference'], options=options
+                )
+
                 self.run_tool_config(tool_config['reference'])
 
     # UI
@@ -500,16 +617,24 @@ def _connect_getter_property_callback(self, property_name):
         return self.__getattribute__(property_name)
 
     def set_config_options(
-        self, tool_config_reference, plugin_config_reference, plugin_options
+        self, tool_config_reference, plugin_config_reference=None, options=None
     ):
-        if not isinstance(plugin_options, dict):
+        if not options:
+            options = dict()
+        # TODO_ mayabe we should rename this one to make sure this is just for plugins
+        if not isinstance(options, dict):
             raise Exception(
                 "plugin_options should be a dictionary. "
-                "Current given type: {}".format(plugin_options)
+                "Current given type: {}".format(options)
             )
-        self._tool_config_options[tool_config_reference][
-            plugin_config_reference
-        ] = plugin_options
+        if not plugin_config_reference:
+            self._tool_config_options[tool_config_reference][
+                'options'
+            ] = options
+        else:
+            self._tool_config_options[tool_config_reference][
+                plugin_config_reference
+            ] = options
 
     def run_ui_hook(
         self, tool_config_reference, plugin_config_reference, payload
@@ -539,3 +664,11 @@ def verify_plugins(self, plugin_names):
             self.host_id, plugin_names
         )[0]
         return unregistered_plugins
+
+    def close(self):
+        self.logger.debug('Shutting down client')
+
+        if self._remote_event_manager:
+            self.logger.debug('Stopping remote_event_manager')
+            self.remote_event_manager.close()
+            self._remote_event_manager = None

libs/framework-core/source/ftrack_framework_core/engine/__init__.py

@@ -196,14 +196,16 @@ def execute_engine(self, engine, user_options):
 
         store = self.get_store()
         for item in engine:
+            tool_config_options = user_options.get('options') or {}
             # If plugin is just string execute plugin with no options
             if isinstance(item, str):
-                self.run_plugin(item, store, {})
+                self.run_plugin(item, store, tool_config_options)
 
             elif isinstance(item, dict):
                 # If it's a group, execute all plugins from the group
                 if item["type"] == "group":
-                    group_options = item.get("options") or {}
+                    group_options = copy.deepcopy(tool_config_options)
+                    group_options.update(item.get("options") or {})
                     group_reference = item['reference']
                     group_options.update(
                         user_options.get(group_reference) or {}
@@ -232,10 +234,11 @@ def execute_engine(self, engine, user_options):
                         #  group recursively execute plugins inside
 
                 elif item["type"] == "plugin":
-                    # Execute plugin only with its own options if plugin is
-                    # defined outside the group
+                    options = copy.deepcopy(tool_config_options)
+                    options.update(item.get("options") or {})
+                    # Execute plugin only with its own options and tool_config
+                    # options if plugin is defined outside the group
                     plugin_reference = item['reference']
-                    options = item.get("options", {})
                     options.update(user_options.get(plugin_reference) or {})
                     self.run_plugin(
                         item["plugin"], store, options, plugin_reference

libs/framework-core/source/ftrack_framework_core/event/__init__.py

@@ -26,6 +26,7 @@ def __init__(self, session):
         super(_EventHubThread, self).__init__(name=_name)
         self.logger.debug('Name set for the thread: {}'.format(_name))
         self._session = session
+        self._stop = False
 
     def start(self):
         '''Start thread for *_session*.'''
@@ -34,12 +35,19 @@ def start(self):
         )
         super(_EventHubThread, self).start()
 
+    def stop(self):
+        self.logger.debug(
+            'stopping event hub thread for session {}'.format(self._session)
+        )
+        self._stop = True
+
     def run(self):
         '''Listen for events.'''
         self.logger.debug(
             'hub thread started for session {}'.format(self._session)
         )
-        self._session.event_hub.wait()
+        while not self._stop:
+            self._session.event_hub.wait(0.2)
 
 
 class EventManager(object):
@@ -108,6 +116,13 @@ def _wait(self):
             # self.logger.debug('Starting new hub thread for {}'.format(self))
             self._event_hub_thread.start()
 
+    def close(self):
+        if self._event_hub_thread and self._event_hub_thread.is_alive():
+            self.logger.debug('Stopping event hub thread')
+            self._event_hub_thread.stop()
+            self._event_hub_thread = None
+            self.session.close()
+
     def __init__(self, session, mode=constants.event.LOCAL_EVENT_MODE):
         self.logger = logging.getLogger(
             __name__ + '.' + self.__class__.__name__