Feature: 在加入房间时展示 p2p 连接难度 (#105)

* Feature: Display connection difficulty based on NAT status in guest-connecting state.

* Fix: typo

Author: burningtnt

src/controller/api.rs

@@ -1,6 +1,6 @@
 use std::sync::mpsc;
 use crate::controller::states::AppState;
-use crate::controller::{experimental, ExceptionType, Room};
+use crate::controller::{experimental, ConnectionDifficulty, ExceptionType, Room};
 use crate::scaffolding::profile::Profile;
 use crate::mc::scanning::MinecraftScanner;
 use crate::MOTD;
@@ -48,8 +48,14 @@ pub fn get_state() -> Value {
         AppState::GuestConnecting { room, .. } => {
             json!({"state": "guest-connecting", "index": index, "room": room.code})
         }
-        AppState::GuestStarting { room, .. } => {
-            json!({"state": "guest-starting", "index": index, "room": room.code})
+        AppState::GuestStarting { room, difficulty, .. } => {
+            json!({"state": "guest-starting", "index": index, "room": room.code, "difficulty": match difficulty {
+                ConnectionDifficulty::Unknown => "UNKNOWN",
+                ConnectionDifficulty::Easiest => "EASIEST",
+                ConnectionDifficulty::Simple => "SIMPLE",
+                ConnectionDifficulty::Medium => "MEDIUM",
+                ConnectionDifficulty::Tough => "TOUGH",
+            }})
         }
         AppState::GuestOk { server, profiles, .. } => {
             let url = if server.port == 25565 {

src/controller/rooms/experimental/room.rs

@@ -1,7 +1,7 @@
 use crate::controller::experimental::{MACHINE_ID, VENDOR};
 use crate::controller::rooms::legacy;
 use crate::controller::states::{AppState, AppStateCapture};
-use crate::controller::{ExceptionType, Room, RoomKind, SCAFFOLDING_PORT};
+use crate::controller::{ConnectionDifficulty, ExceptionType, Room, RoomKind, SCAFFOLDING_PORT};
 use crate::easytier;
 use crate::easytier::argument::{Argument, PortForward, Proto};
 use crate::easytier::publics::{fetch_public_nodes, PublicServers};
@@ -226,7 +226,7 @@ pub fn start_guest(room: Room, player: Option<String>, capture: AppStateCapture)
             return;
         };
 
-        state.set(AppState::GuestStarting { room, easytier })
+        state.set(AppState::GuestStarting { room, easytier, difficulty: ConnectionDifficulty::Unknown })
     };
 
     let (scaffolding_port, host_ip) = 'local_port: {
@@ -237,7 +237,7 @@ pub fn start_guest(room: Room, player: Option<String>, capture: AppStateCapture)
                 return;
             };
             let mut state = state.into_slow();
-            let AppState::GuestStarting { easytier, .. } = state.as_mut_ref() else {
+            let AppState::GuestStarting { easytier, difficulty, .. } = state.as_mut_ref() else {
                 unreachable!();
             };
             if !easytier.is_alive() {
@@ -248,25 +248,46 @@ pub fn start_guest(room: Room, player: Option<String>, capture: AppStateCapture)
             let Some(players) = easytier.get_players() else {
                 continue;
             };
-            for EasyTierMember { hostname, address } in players {
-                if hostname.starts_with("scaffolding-mc-server-") && let Ok(port) = u16::from_str(&hostname["scaffolding-mc-server-".len()..]) {
-                    logging!("RoomExperiment", "Scaffolding Server is at {}:{}", address, port);
-
-                    let local_port = PortRequest::Scaffolding.request();
-
-                    if !easytier.add_port_forward(&[PortForward {
-                        local: SocketAddrV4::new(Ipv4Addr::UNSPECIFIED, local_port).into(),
-                        remote: SocketAddrV4::new(address, port).into(),
-                        proto: Proto::TCP,
-                    }]) {
-                        logging!("RoomExperiment", "Cannot create a port-forward {} -> {} for Scaffolding Connection.", local_port, port);
-                        state.set(AppState::Exception { kind: ExceptionType::GuestEasytierCrash });
-                        return;
-                    };
 
-                    break 'local_port (local_port, address);
+            let Some(local_nat) = players.iter().find_map(|EasyTierMember { is_local, nat, ..}| {
+                if *is_local {
+                    Some(nat)
+                } else {
+                    None
                 }
-            }
+            }) else {
+                continue;
+            };
+
+            let Some((server_address, server_port, server_nat)) = players.iter().find_map(|
+                EasyTierMember { hostname, address, is_local, nat, .. }
+            | {
+                static PREFIX: &str = "scaffolding-mc-server-";
+
+                if let Some(address) = address && !is_local && hostname.starts_with(PREFIX) && let Ok(port) = u16::from_str(&hostname[PREFIX.len()..]) {
+                    Some((address, port, nat))
+                } else {
+                    None
+                }
+            }) else {
+                continue;
+            };
+
+            logging!("RoomExperiment", "Scaffolding Server is at {}:{}", server_address, server_port);
+            let local_port = PortRequest::Scaffolding.request();
+            if !easytier.add_port_forward(&[PortForward {
+                local: SocketAddrV4::new(Ipv4Addr::UNSPECIFIED, local_port).into(),
+                remote: SocketAddrV4::new(*server_address, server_port).into(),
+                proto: Proto::TCP,
+            }]) {
+                logging!("RoomExperiment", "Cannot create a port-forward {} -> {} for Scaffolding Connection.", local_port, server_port);
+                state.set(AppState::Exception { kind: ExceptionType::GuestEasytierCrash });
+                return;
+            };
+
+            *difficulty = easytier::calc_conn_difficulty(local_nat, server_nat);
+            logging!("RoomExperiment", "Current NAT status: {:?} -> {:?}, difficulty = {:?}", local_nat, server_nat, difficulty);
+            break 'local_port (local_port, *server_address);
         }
 
         logging!("RoomExperiment", "Cannot find scaffolding server.");
@@ -401,7 +422,7 @@ pub fn start_guest(room: Room, player: Option<String>, capture: AppStateCapture)
             return;
         };
         state.replace(|state| {
-            let AppState::GuestStarting { room, easytier } = state else {
+            let AppState::GuestStarting { room, easytier, .. } = state else {
                 unreachable!();
             };
 

src/controller/rooms/legacy.rs

@@ -1,5 +1,5 @@
 use crate::controller::states::{AppState, AppStateCapture};
-use crate::controller::{ExceptionType, Room, RoomKind};
+use crate::controller::{ConnectionDifficulty, ExceptionType, Room, RoomKind};
 use crate::easytier;
 use crate::easytier::argument::{Argument, PortForward, Proto};
 use crate::mc::fakeserver::FakeServer;
@@ -217,7 +217,7 @@ pub fn start_guest(room: Room, capture: AppStateCapture) {
         let Some(state) = capture.try_capture() else {
             return;
         };
-        state.set(AppState::GuestStarting { room, easytier })
+        state.set(AppState::GuestStarting { room, easytier, difficulty: ConnectionDifficulty::Unknown })
     };
 
     'init_conn: {
@@ -248,7 +248,7 @@ pub fn start_guest(room: Room, capture: AppStateCapture) {
         };
 
         state.replace(move |state| match state {
-            AppState::GuestStarting { room, easytier } => AppState::GuestOk {
+            AppState::GuestStarting { room, easytier, .. } => AppState::GuestOk {
                 room,
                 easytier,
                 server,

src/controller/rooms/mod.rs

@@ -20,6 +20,11 @@ pub(crate) enum RoomKind {
     PCL2CE { mc_port: u16 },
 }
 
+#[derive(Debug)]
+pub enum ConnectionDifficulty {
+    Unknown, Easiest, Simple, Medium, Tough
+}
+
 impl Room {
     pub fn create() -> Room {
         experimental::create_room()

src/controller/states.rs

@@ -6,7 +6,7 @@ use std::mem;
 use std::panic::Location;
 use std::time::{Duration, SystemTime};
 use parking_lot::{Mutex, MutexGuard};
-use crate::controller::Room;
+use crate::controller::{ConnectionDifficulty, Room};
 use crate::scaffolding::profile::Profile;
 
 pub enum AppState {
@@ -32,6 +32,7 @@ pub enum AppState {
     GuestStarting {
         room: Room,
         easytier: EasyTier,
+        difficulty: ConnectionDifficulty
     },
     GuestOk {
         room: Room,
@@ -61,8 +62,8 @@ impl Debug for AppState {
             AppState::GuestConnecting { room } => {
                 write!(f, "AppState::GuestConnecting {{ code: {:?} }}", room.code)
             }
-            AppState::GuestStarting { room, .. } => {
-                write!(f, "AppState::GuestStarting {{ code: {:?}, easytier: .. }}", room.code)
+            AppState::GuestStarting { room, difficulty, .. } => {
+                write!(f, "AppState::GuestStarting {{ code: {:?}, difficulty: {:?}, easytier: .. }}", room.code, difficulty)
             }
             AppState::GuestOk { room, server, profiles, .. } => {
                 write!(

src/easytier/argument.rs

@@ -3,14 +3,14 @@ use std::net::{Ipv4Addr, SocketAddr};
 
 type CowString = Cow<'static, str>;
 
-#[derive(Clone)]
+#[derive(Clone, Debug)]
 pub struct PortForward {
     pub(crate) local: SocketAddr,
     pub(crate) remote: SocketAddr,
     pub(crate) proto: Proto,
 }
 
-#[derive(Clone)]
+#[derive(Clone, Debug)]
 pub enum Proto {
     TCP,
     UDP,

src/easytier/executable_impl.rs

@@ -15,7 +15,7 @@ use std::{
     thread,
     time::Duration,
 };
-use crate::easytier::EasyTierMember;
+use crate::easytier::{EasyTierMember, NatType};
 
 static EASYTIER_ARCHIVE: (&str, &str, &[u8]) = (
     include_str!(env!("TERRACOTTA_ET_ENTRY_CONF")),
@@ -230,11 +230,26 @@ impl EasyTier {
         let mut players: Vec<EasyTierMember> = vec![];
         for item in object.as_array()? {
             let hostname = item.as_object()?.get("hostname")?.as_str()?.to_string();
-            let Ok(address) = Ipv4Addr::from_str(item.as_object()?.get("ipv4")?.as_str()?) else {
-                continue;
+            let address = Ipv4Addr::from_str(item.as_object()?.get("ipv4")?.as_str()?).ok();
+            let is_local = item.as_object()?.get("cost")?.as_str()? == "Local";
+            let nat = match item.as_object()?.get("nat_type")?.as_str()? {
+                "Unknown" => NatType::Unknown,
+                "OpenInternet" => NatType::OpenInternet,
+                "NoPat" => NatType::NoPAT ,
+                "FullCone" => NatType::FullCone,
+                "Restricted" => NatType::Restricted,
+                "PortRestricted" => NatType::PortRestricted,
+                "Symmetric" => NatType::Symmetric,
+                "SymUdpFirewall" => NatType::SymmetricUdpWall,
+                "SymmetricEasyInc" => NatType::SymmetricEasyIncrease,
+                "SymmetricEasyDec" => NatType::SymmetricEasyDecrease,
+                #[cfg(debug_assertions)]
+                nat => panic!("Unknown NAT type: {}", nat),
+                #[cfg(not(debug_assertions))]
+                _ => return None,
             };
 
-            players.push(EasyTierMember { hostname, address });
+            players.push(EasyTierMember { hostname, address, is_local, nat });
         }
         Some(players)
     }

src/easytier/mod.rs

@@ -1,6 +1,8 @@
-use std::net::Ipv4Addr;
+use crate::controller::ConnectionDifficulty;
 use crate::easytier::argument::{Argument, PortForward};
 use cfg_if::cfg_if;
+use std::cmp::PartialEq;
+use std::net::Ipv4Addr;
 
 pub mod argument;
 pub mod publics;
@@ -14,9 +16,42 @@ cfg_if! {
 
 pub struct EasyTier(inner::EasyTier);
 
+#[derive(Debug)]
 pub struct EasyTierMember {
     pub hostname: String,
-    pub address: Ipv4Addr
+    pub address: Option<Ipv4Addr>,
+    pub is_local: bool,
+    pub nat: NatType,
+}
+
+#[derive(Clone, Debug, PartialEq)]
+pub enum NatType {
+    Unknown,
+    OpenInternet,
+    NoPAT,
+    FullCone,
+    Restricted,
+    PortRestricted,
+    Symmetric,
+    SymmetricUdpWall,
+    SymmetricEasyIncrease,
+    SymmetricEasyDecrease,
+}
+
+pub fn calc_conn_difficulty(left: &NatType, right: &NatType) -> ConnectionDifficulty {
+    let is = |types: &[NatType]| -> bool {
+        types.contains(left) || types.contains(right)
+    };
+
+    if is(&[NatType::OpenInternet]) {
+        ConnectionDifficulty::Easiest
+    } else if is(&[NatType::NoPAT,NatType::FullCone]) {
+        ConnectionDifficulty::Simple
+    } else if is(&[NatType::Restricted, NatType::PortRestricted]) {
+        ConnectionDifficulty::Medium
+    } else {
+        ConnectionDifficulty::Tough
+    }
 }
 
 pub fn create(args: Vec<Argument>) -> EasyTier {