feat: seperate into lib and cli packages

soulseek-rs-lib/src/peer/mod.rs

@@ -0,0 +1,199 @@
+mod download_peer;
+pub mod listen;
+
+// Export actor types
+pub use crate::actor::peer_actor::{PeerActor, PeerMessage};
+pub use crate::actor::peer_registry::PeerRegistry;
+
+pub use download_peer::DownloadPeer;
+
+use crate::message::Message;
+use core::fmt;
+use std::{net::TcpStream, str::FromStr};
+
+#[derive(Debug)]
+#[allow(dead_code)]
+pub struct NewPeer {
+    pub username: String,
+    pub connection_type: ConnectionType,
+    pub token: u32,
+    pub tcp_stream: TcpStream,
+}
+impl NewPeer {
+    pub fn new_from_message(
+        message: &mut Message,
+        tcp_stream: TcpStream,
+    ) -> Self {
+        let username = message.read_string();
+        let connection_type = message.read_string().parse().unwrap();
+        let token = message.read_int32();
+
+        Self {
+            username,
+            connection_type,
+            token,
+            tcp_stream,
+        }
+    }
+}
+
+#[derive(Debug, Clone)]
+pub enum ConnectionType {
+    P,
+    F,
+    D,
+}
+
+#[derive(Debug, Clone)]
+pub struct ParseConnectionTypeError;
+
+impl fmt::Display for ParseConnectionTypeError {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        write!(f, "invalid connection type")
+    }
+}
+
+impl std::error::Error for ParseConnectionTypeError {}
+
+impl FromStr for ConnectionType {
+    type Err = ParseConnectionTypeError;
+
+    fn from_str(s: &str) -> Result<Self, Self::Err> {
+        match s {
+            "P" => Ok(ConnectionType::P),
+            "F" => Ok(ConnectionType::F),
+            "D" => Ok(ConnectionType::D),
+            _ => Err(ParseConnectionTypeError),
+        }
+    }
+}
+
+impl fmt::Display for ConnectionType {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        let s = match self {
+            ConnectionType::P => "P",
+            ConnectionType::F => "F",
+            ConnectionType::D => "D",
+        };
+        write!(f, "{}", s)
+    }
+}
+
+#[derive(Debug, Clone)]
+#[allow(dead_code)]
+pub struct Peer {
+    pub username: String,
+    pub connection_type: ConnectionType,
+    pub host: String,
+    pub port: u32,
+    pub token: Option<u32>,
+    pub privileged: Option<u8>,
+    pub unknown: Option<u8>,
+    pub obfuscated_port: Option<u8>,
+}
+impl Peer {
+    #[allow(clippy::too_many_arguments, dead_code)]
+    pub fn new(
+        username: String,
+        connection_type: ConnectionType,
+        host: String,
+        port: u32,
+        token: Option<u32>,
+        privileged: u8,
+        unknown: u8,
+        obfuscated_port: u8,
+    ) -> Self {
+        Self {
+            username,
+            connection_type,
+            host,
+            port,
+            token,
+            privileged: Some(privileged),
+            unknown: Some(unknown),
+            obfuscated_port: Some(obfuscated_port),
+        }
+    }
+    #[allow(dead_code)]
+    pub fn new_from_message(message: &mut Message) -> Self {
+        let username = message.read_string();
+        let connection_type = message.read_string().parse().unwrap();
+
+        let mut ip: Vec<i32> = vec![];
+        for _ in 0..4 {
+            ip.push(message.read_int8().into());
+        }
+        let host: String = format!(
+            "{}.{}.{}.{}",
+            ip[3].abs(),
+            ip[2].abs(),
+            ip[1].abs(),
+            ip[0].abs()
+        );
+
+        let (port, token, privileged, unknown, obfuscated_port) = (
+            message.read_int32(),
+            message.read_int32(),
+            message.read_int8(),
+            message.read_int8(),
+            message.read_int8(),
+        );
+
+        Self {
+            username,
+            connection_type,
+            host,
+            port,
+            token: Some(token),
+            privileged: Some(privileged),
+            unknown: Some(unknown),
+            obfuscated_port: Some(obfuscated_port),
+        }
+    }
+}
+#[test]
+fn test_new_from_message() {
+    let data: Vec<u8> = [
+        36, 0, 0, 0, 18, 0, 0, 0, 2, 0, 0, 0, 100, 112, 1, 0, 0, 0, 80, 27,
+        231, 37, 45, 186, 8, 0, 0, 178, 78, 25, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+    ]
+    .to_vec();
+    let mut message = Message::new_with_data(data);
+    message.set_pointer(8);
+
+    let peer = Peer::new_from_message(&mut message);
+
+    assert_eq!(peer.username, "dp");
+    assert!(matches!(peer.connection_type, ConnectionType::P));
+    assert_eq!(peer.host, "45.37.231.27");
+    assert_eq!(peer.port, 2234);
+    assert_eq!(peer.token, Some(1658546));
+    assert_eq!(peer.privileged, Some(0));
+    assert_eq!(peer.unknown, Some(0));
+    assert_eq!(peer.obfuscated_port, Some(0));
+}
+
+#[test]
+fn test_new_from_message2() {
+    let data: Vec<u8> = [
+        42, 0, 0, 0, 18, 0, 0, 0, 8, 0, 0, 0, 103, 114, 97, 110, 100, 112, 97,
+        103, 1, 0, 0, 0, 80, 137, 128, 193, 68, 187, 8, 0, 0, 58, 16, 0, 0, 0,
+        1, 0, 0, 0, 188, 8, 0, 0,
+    ]
+    .to_vec();
+    let mut message = Message::new_with_data(data);
+    message.set_pointer(8);
+
+    println!("code: {}", message.get_message_code_u32());
+
+    let peer = Peer::new_from_message(&mut message);
+
+    assert_eq!(peer.username, "grandpag");
+    assert!(matches!(peer.connection_type, ConnectionType::P));
+    assert_eq!(peer.host, "68.193.128.137");
+    assert_eq!(peer.port, 2235);
+    assert_eq!(peer.token, Some(4154));
+    assert_eq!(peer.privileged, Some(0));
+    assert_eq!(peer.unknown, Some(1));
+    assert_eq!(peer.obfuscated_port, Some(0));
+}