Method discover_provider_extensions

src-tauri/src/providers/handler.rs:169–221

(&self)

    #[tracing::instrument(level = "debug", skip(self))]
    pub async fn discover_provider_extensions(&self) -> Result<()> {
        let ext_handler = get_extension_handler(&self.app_handle);
        let extensions_res = ext_handler.get_installed_extensions().await?;
        for extension in extensions_res {
            let provides = ext_handler
                .get_provider_scopes(extension.package_name.clone().into())
                .await;
            tracing::info!(
                "Got provider scopes from {} {:?}",
                extension.package_name,
                provides
            );
            if let Ok(provides) = provides {
                tracing::info!(
                    "Inserting extension provider {:?} {:?}",
                    extension,
                    provides,
                );

                let provider = Box::new(ExtensionProvider::new(
                    extension.clone(),
                    provides,
                    self.app_handle.clone(),
                    self.status_tx.clone(),
                ));
                let key = {
                    let mut provider_store = self.provider_store.write().await;
                    let key = provider.key();
                    provider_store.insert(key.clone(), provider);
                    tracing::info!("provider_store: {:?}", provider_store.keys());
                    key
                };

                let provider_store = self.provider_store.clone();
                async_runtime::spawn(async move {
                    let provider_store = provider_store.read().await;
                    if let Some(provider) = provider_store.get(&key) {
                        let res = provider.initialize().await;
                        if let Err(err) = res {
                            tracing::error!(
                                "Error initializing extension provider {}: {:?}",
                                key,
                                err
                            );
                        }
                    }
                });
            }

            self.app_handle.emit("providers-updated", Value::Null)?;
        }
        Ok(())
    }

    #[tracing::instrument(level = "debug", skip(self, key))]
    pub async fn initialize_provider(&self, key: String) {