fix(API): proxy name missing in proxy chain for group outbounds (#817)

* API fix

* clippy

* clippy

* add tests

* up

Author: ibigbug

clash_lib/src/app/outbound/manager.rs

@@ -26,7 +26,7 @@ use crate::{
     },
     print_and_exit,
     proxy::{
-        OutboundType, fallback,
+        fallback,
         group::smart,
         loadbalance, selector, socks, trojan,
         utils::{DirectConnector, ProxyConnector},
@@ -139,29 +139,23 @@ impl OutboundManager {
         }
 
         for (k, v) in self.handlers.iter().chain(provider_handlers.iter()) {
-            let mut m = v.as_map().await;
+            let mut m = if let Some(g) = v.try_as_group_handler() {
+                g.as_map().await
+            } else {
+                let mut m = HashMap::new();
+                m.insert("type".to_string(), Box::new(v.proto()) as _);
+                m
+            };
 
             let alive = proxy_manager.alive(k).await;
             let history = proxy_manager.delay_history(k).await;
             let support_udp = v.support_udp().await;
-            let icon = v.icon();
 
             m.insert("history".to_string(), Box::new(history));
             m.insert("alive".to_string(), Box::new(alive));
             m.insert("name".to_string(), Box::new(k.to_owned()));
             m.insert("udp".to_string(), Box::new(support_udp));
 
-            if matches!(
-                v.proto(),
-                OutboundType::UrlTest
-                    | OutboundType::Relay
-                    | OutboundType::Selector
-                    | OutboundType::Fallback
-                    | OutboundType::LoadBalance
-            ) {
-                m.insert("icon".to_string(), Box::new(icon));
-            }
-
             r.insert(k.clone(), Box::new(m) as _);
         }
 
@@ -172,7 +166,13 @@ impl OutboundManager {
         &self,
         proxy: &AnyOutboundHandler,
     ) -> HashMap<String, Box<dyn Serialize + Send>> {
-        let mut r = proxy.as_map().await;
+        let mut r = if let Some(g) = proxy.try_as_group_handler() {
+            g.as_map().await
+        } else {
+            let mut m = HashMap::new();
+            m.insert("type".to_string(), Box::new(proxy.proto()) as _);
+            m
+        };
 
         let proxy_manager = self.proxy_manager.clone();
 

clash_lib/src/proxy/group/fallback/mod.rs

@@ -1,6 +1,6 @@
-use std::{collections::HashMap, fmt::Debug, io};
+use async_trait::async_trait;
 
-use erased_serde::Serialize;
+use std::{fmt::Debug, io};
 use tracing::debug;
 
 use crate::{
@@ -14,6 +14,7 @@ use crate::{
     proxy::{
         AnyOutboundHandler, ConnectorType, DialWithConnector, HandlerCommonOptions,
         OutboundHandler, OutboundType,
+        group::GroupProxyAPIResponse,
         utils::{RemoteConnector, provider_helper::get_proxies_from_providers},
     },
     session::Session,
@@ -71,7 +72,7 @@ impl Handler {
 
 impl DialWithConnector for Handler {}
 
-#[async_trait::async_trait]
+#[async_trait]
 impl OutboundHandler for Handler {
     /// The name of the outbound handler
     fn name(&self) -> &str {
@@ -96,13 +97,11 @@ impl OutboundHandler for Handler {
         resolver: ThreadSafeDNSResolver,
     ) -> io::Result<BoxedChainedStream> {
         let proxy = self.find_alive_proxy(true).await;
-        match proxy.connect_stream(sess, resolver).await {
-            Ok(s) => {
-                s.append_to_chain(self.name()).await;
-                Ok(s)
-            }
-            Err(e) => Err(e),
-        }
+        let s = proxy.connect_stream(sess, resolver).await?;
+
+        s.append_to_chain(self.name()).await;
+
+        Ok(s)
     }
 
     /// connect to remote target via UDP
@@ -112,7 +111,11 @@ impl OutboundHandler for Handler {
         resolver: ThreadSafeDNSResolver,
     ) -> io::Result<BoxedChainedDatagram> {
         let proxy = self.find_alive_proxy(true).await;
-        proxy.connect_datagram(sess, resolver).await
+        let s = proxy.connect_datagram(sess, resolver).await?;
+
+        s.append_to_chain(self.name()).await;
+
+        Ok(s)
     }
 
     async fn support_connector(&self) -> ConnectorType {
@@ -131,21 +134,19 @@ impl OutboundHandler for Handler {
             .await
     }
 
-    async fn as_map(&self) -> HashMap<String, Box<dyn Serialize + Send>> {
-        let all = get_proxies_from_providers(&self.providers, false).await;
-
-        let mut m = HashMap::new();
-        m.insert("type".to_string(), Box::new(self.proto()) as _);
-        m.insert(
-            "now".to_string(),
-            Box::new(self.find_alive_proxy(false).await.name().to_owned()) as _,
-        );
-        m.insert(
-            "all".to_string(),
-            Box::new(all.iter().map(|x| x.name().to_owned()).collect::<Vec<_>>())
-                as _,
-        );
-        m
+    fn try_as_group_handler(&self) -> Option<&dyn GroupProxyAPIResponse> {
+        Some(self as _)
+    }
+}
+
+#[async_trait]
+impl GroupProxyAPIResponse for Handler {
+    async fn get_proxies(&self) -> Vec<AnyOutboundHandler> {
+        Handler::get_proxies(self, false).await
+    }
+
+    async fn get_active_proxy(&self) -> Option<AnyOutboundHandler> {
+        Some(Handler::find_alive_proxy(self, false).await)
     }
 
     fn icon(&self) -> Option<String> {

clash_lib/src/proxy/group/loadbalance/mod.rs

@@ -1,12 +1,12 @@
 mod helpers;
 
-use std::{collections::HashMap, io, sync::Arc};
-
-use erased_serde::Serialize;
+use async_trait::async_trait;
 use helpers::strategy_sticky_session;
+use std::{io, sync::Arc};
 use tokio::sync::Mutex;
 use tracing::debug;
 
+use self::helpers::{StrategyFn, strategy_consistent_hashring, strategy_rr};
 use crate::{
     app::{
         dispatcher::{BoxedChainedDatagram, BoxedChainedStream},
@@ -19,13 +19,12 @@ use crate::{
     proxy::{
         AnyOutboundHandler, ConnectorType, DialWithConnector, HandlerCommonOptions,
         OutboundHandler, OutboundType,
+        group::GroupProxyAPIResponse,
         utils::{RemoteConnector, provider_helper::get_proxies_from_providers},
     },
     session::Session,
 };
 
-use self::helpers::{StrategyFn, strategy_consistent_hashring, strategy_rr};
-
 #[derive(Default, Clone)]
 pub struct HandlerOptions {
     pub common_opts: HandlerCommonOptions,
@@ -82,7 +81,7 @@ impl Handler {
 
 impl DialWithConnector for Handler {}
 
-#[async_trait::async_trait]
+#[async_trait]
 impl OutboundHandler for Handler {
     /// The name of the outbound handler
     fn name(&self) -> &str {
@@ -109,13 +108,12 @@ impl OutboundHandler for Handler {
         let proxies = self.get_proxies(false).await;
         let proxy = (self.inner.lock().await.strategy_fn)(proxies, sess).await?;
         debug!("{} use proxy {}", self.name(), proxy.name());
-        match proxy.connect_stream(sess, resolver).await {
-            Ok(s) => {
-                s.append_to_chain(self.name()).await;
-                Ok(s)
-            }
-            Err(e) => Err(e),
-        }
+
+        let s = proxy.connect_stream(sess, resolver).await?;
+
+        s.append_to_chain(self.name()).await;
+
+        Ok(s)
     }
 
     /// connect to remote target via UDP
@@ -127,7 +125,12 @@ impl OutboundHandler for Handler {
         let proxies = self.get_proxies(false).await;
         let proxy = (self.inner.lock().await.strategy_fn)(proxies, sess).await?;
         debug!("{} use proxy {}", self.name(), proxy.name());
-        proxy.connect_datagram(sess, resolver).await
+
+        let s = proxy.connect_datagram(sess, resolver).await?;
+
+        s.append_to_chain(self.name()).await;
+
+        Ok(s)
     }
 
     async fn support_connector(&self) -> ConnectorType {
@@ -148,18 +151,19 @@ impl OutboundHandler for Handler {
             .await
     }
 
-    async fn as_map(&self) -> HashMap<String, Box<dyn Serialize + Send>> {
-        let all = get_proxies_from_providers(&self.providers, false).await;
+    fn try_as_group_handler(&self) -> Option<&dyn GroupProxyAPIResponse> {
+        Some(self as _)
+    }
+}
 
-        let mut m = HashMap::new();
-        m.insert("type".to_string(), Box::new(self.proto()) as _);
+#[async_trait]
+impl GroupProxyAPIResponse for Handler {
+    async fn get_proxies(&self) -> Vec<AnyOutboundHandler> {
+        Handler::get_proxies(self, false).await
+    }
 
-        m.insert(
-            "all".to_string(),
-            Box::new(all.iter().map(|x| x.name().to_owned()).collect::<Vec<_>>())
-                as _,
-        );
-        m
+    async fn get_active_proxy(&self) -> Option<AnyOutboundHandler> {
+        None
     }
 
     fn icon(&self) -> Option<String> {

clash_lib/src/proxy/group/mod.rs

@@ -1,6 +1,51 @@
+use crate::proxy::{AnyOutboundHandler, OutboundHandler};
+use async_trait::async_trait;
+use erased_serde::Serialize;
+use std::collections::HashMap;
+
 pub mod fallback;
 pub mod loadbalance;
 pub mod relay;
 pub mod selector;
 pub mod smart;
 pub mod urltest;
+
+/// Convenience trait for group proxy serializing API responses.
+#[async_trait]
+pub trait GroupProxyAPIResponse: OutboundHandler {
+    /// Returns all proxies in the group, which are usually stored in a list of
+    /// ProxyProviders.
+    async fn get_proxies(&self) -> Vec<AnyOutboundHandler>;
+    /// Returns the current effective proxy for the group.
+    /// e.g. for a selector, it returns the currently selected proxy, and for
+    /// urltest, it returns the fastest proxy, etc.
+    async fn get_active_proxy(&self) -> Option<AnyOutboundHandler>;
+
+    /// used in the API responses.
+    async fn as_map(&self) -> HashMap<String, Box<dyn Serialize + Send>> {
+        let all = self.get_proxies().await;
+
+        let mut m = HashMap::new();
+        m.insert("type".to_string(), Box::new(self.proto()) as _);
+
+        if let Some(active) = self.get_active_proxy().await {
+            m.insert("now".to_string(), Box::new(active.name().to_owned()) as _);
+        }
+
+        let icon = self.icon();
+        if let Some(icon) = icon {
+            m.insert("icon".to_string(), Box::new(icon) as _);
+        }
+
+        m.insert(
+            "all".to_string(),
+            Box::new(all.iter().map(|x| x.name().to_owned()).collect::<Vec<_>>())
+                as _,
+        );
+        m
+    }
+
+    fn icon(&self) -> Option<String> {
+        None
+    }
+}

clash_lib/src/proxy/group/relay/mod.rs

@@ -1,7 +1,6 @@
-use std::{collections::HashMap, io, sync::Arc};
+use std::{io, sync::Arc};
 
 use async_trait::async_trait;
-use erased_serde::Serialize;
 use futures::stream::{self, StreamExt};
 use tracing::debug;
 
@@ -18,6 +17,7 @@ use crate::{
     proxy::{
         AnyOutboundHandler, ConnectorType, DialWithConnector, HandlerCommonOptions,
         OutboundHandler, OutboundType,
+        group::GroupProxyAPIResponse,
         utils::{
             DirectConnector, ProxyConnector, RemoteConnector,
             provider_helper::get_proxies_from_providers,
@@ -178,18 +178,19 @@ impl OutboundHandler for Handler {
         ConnectorType::None
     }
 
-    async fn as_map(&self) -> HashMap<String, Box<dyn Serialize + Send>> {
-        let all = get_proxies_from_providers(&self.providers, false).await;
+    fn try_as_group_handler(&self) -> Option<&dyn GroupProxyAPIResponse> {
+        Some(self as _)
+    }
+}
 
-        let mut m = HashMap::new();
-        m.insert("type".to_string(), Box::new(self.proto()) as _);
-        m.insert(
-            "all".to_string(),
-            Box::new(all.iter().map(|x| x.name().to_owned()).collect::<Vec<_>>())
-                as _,
-        );
+#[async_trait]
+impl GroupProxyAPIResponse for Handler {
+    async fn get_proxies(&self) -> Vec<AnyOutboundHandler> {
+        Handler::get_proxies(self, false).await
+    }
 
-        m
+    async fn get_active_proxy(&self) -> Option<AnyOutboundHandler> {
+        None
     }
 
     fn icon(&self) -> Option<String> {