Method execute_command

src-tauri/extensions/src/ext_runner.rs:634–690

(
        &mut self,
        command: &ExtensionCommand,
        tx: MainCommandReplySender,
    )

    #[tracing::instrument(level = "debug", skip(self))]
    async fn execute_command(
        &mut self,
        command: &ExtensionCommand,
        tx: MainCommandReplySender,
    ) -> MoosyncResult<()> {
        let (package_name, fn_name, args) = command.to_plugin_call();
        let plugins = self.get_extensions(package_name.clone()).await;

        let plugins_len = plugins.len();

        for extension in plugins {
            let command = command.clone();
            let args = args.clone();
            let extension = extension.clone();
            let package_name = package_name.clone();
            let tx = tx.clone();
            thread::spawn(move || {
                let mut plugin = block_on(extension.plugin.lock());
                let res = plugin.call::<_, Value>(fn_name, args.clone());
                match res {
                    Ok(res) => match command.parse_response(res) {
                        Ok(mut parsed_response) => {
                            Self::sanitize_response(&mut parsed_response, package_name.clone());
                            if plugins_len == 1 {
                                let _ = tx.send(parsed_response);
                            }
                        }
                        Err(e) => {
                            if plugins_len == 1 {
                                let _ = tx.send(ExtensionCommandResponse::Empty);
                                tracing::error!(
                                    "Failed to parse response from extension {} {:?}",
                                    package_name,
                                    e
                                );
                            }
                        }
                    },
                    Err(e) => {
                        if plugins_len == 1 {
                            let _ = tx.send(ExtensionCommandResponse::Empty);
                            tracing::error!(
                                "Extension {} responsed with error: {:?}",
                                extension.package_name,
                                e
                            );
                        }
                    }
                }
            });
        }

        if plugins_len > 1 {
            let _ = tx.send(ExtensionCommandResponse::Empty);
        }
        Ok(())
    }