From ead59361389dbb4ca94c6cc174ec619cbd725d97 Mon Sep 17 00:00:00 2001 From: Titouan Rigoudy Date: Sun, 29 Aug 2021 18:09:51 +0200 Subject: [PATCH] Introduce Config struct. --- client/src/client.rs | 29 ++++++++++++-------- client/src/config.rs | 48 ++++++++++++++++++++++++--------- client/src/main.rs | 42 +++++++++++++---------------- proto/src/server/credentials.rs | 2 +- 4 files changed, 74 insertions(+), 47 deletions(-) diff --git a/client/src/client.rs b/client/src/client.rs index 70f3337..579de08 100644 --- a/client/src/client.rs +++ b/client/src/client.rs @@ -6,7 +6,7 @@ use solstice_proto; use solstice_proto::peer; use solstice_proto::server; -use crate::config; +use crate::config::Config; use crate::control; use crate::login::LoginStatus; use crate::room; @@ -42,6 +42,8 @@ pub struct Client { proto_tx: crossbeam_channel::Sender, proto_rx: crossbeam_channel::Receiver, + config: Config, + login_status: LoginStatus, rooms: room::RoomMap, @@ -58,17 +60,21 @@ impl Client { pub fn new( proto_tx: crossbeam_channel::Sender, proto_rx: crossbeam_channel::Receiver, + config: Config, ) -> Self { + let max_peers = config.max_peers; Client { proto_tx: proto_tx, proto_rx: proto_rx, + config, + login_status: LoginStatus::Todo, rooms: room::RoomMap::new(), users: user::UserMap::new(), - peers: slab::Slab::new(config::MAX_PEERS), + peers: slab::Slab::new(max_peers), } } @@ -76,21 +82,22 @@ impl Client { pub fn run(&mut self) { info!("Logging in..."); - let credentials = server::Credentials::new( - config::USERNAME.to_string(), - config::PASSWORD.to_string(), - ) - .unwrap(); - let version = server::Version::default(); - self.send_to_server(credentials.into_login_request(version).into()); + self.send_to_server( + self + .config + .credentials + .clone() + .into_login_request(version) + .into(), + ); self.login_status = LoginStatus::AwaitingResponse; self.send_to_server( server::SetListenPortRequest { - port: config::LISTEN_PORT, + port: self.config.peer_listen_port, } .into(), ); @@ -367,7 +374,7 @@ impl Client { peer.state = PeerState::Open; // Send a PeerInit. peer::Message::PeerInit(peer::PeerInit { - user_name: config::USERNAME.to_string(), + user_name: self.config.credentials.user_name().to_string(), connection_type: peer.connection_type.clone(), token: peer.token, }) diff --git a/client/src/config.rs b/client/src/config.rs index c97265f..81175e3 100644 --- a/client/src/config.rs +++ b/client/src/config.rs @@ -1,17 +1,41 @@ -pub const USERNAME: &'static str = "solstice"; -// The password is not used for much, and sent unencrypted over the wire, so -// why not even check it in to git -pub const PASSWORD: &'static str = "topsekrit"; +use solstice_proto::server::Credentials; -pub const SERVER_HOST: &'static str = "server.slsknet.org"; -pub const SERVER_PORT: u16 = 2242; +// TODO: Implement reading this from .toml files. +pub struct Config { + /// Credentials to present to the server. + pub credentials: Credentials, -#[allow(dead_code)] -pub const LISTEN_HOST: &'static str = "0.0.0.0"; + /// The address of the server to connect to. + pub server_address: String, -pub const LISTEN_PORT: u16 = 2243; + /// The address on which to listen for incoming peer connections. + #[allow(dead_code)] + pub peer_listen_address: String, -pub const CONTROL_HOST: &'static str = "localhost"; -pub const CONTROL_PORT: u16 = 2244; + // TODO: Remove this in favor of using `peer_listen_address` and the port of + // the bound listener. + /// The port on which to listen for incoming peer connections. + pub peer_listen_port: u16, -pub const MAX_PEERS: usize = 1000; + /// The address on which to listen for incoming control connections. + pub control_listen_address: String, + + /// The maximum number of peer connections allowed at once. + pub max_peers: usize, +} + +impl Default for Config { + fn default() -> Self { + let credentials = + Credentials::new("solstice".to_string(), "topsekrit".to_string()) + .expect("building default credentials"); + Self { + credentials, + server_address: "server.slsknet.org:2242".to_string(), + peer_listen_address: "0.0.0.0:2243".to_string(), + peer_listen_port: 2243, + control_listen_address: "localhost:2244".to_string(), + max_peers: 1000, + } + } +} diff --git a/client/src/main.rs b/client/src/main.rs index b0c2727..b767a65 100644 --- a/client/src/main.rs +++ b/client/src/main.rs @@ -22,6 +22,7 @@ mod message_handler; mod room; mod user; +use config::Config; use context::ContextBundle; use dispatcher::Dispatcher; use executor::Executor; @@ -30,35 +31,26 @@ fn old_main() { let (request_tx, _request_rx) = crossbeam_channel::bounded(100); let (_response_tx, response_rx) = crossbeam_channel::bounded(100); - let mut client = client::Client::new(request_tx, response_rx); + let mut client = + client::Client::new(request_tx, response_rx, Config::default()); client.run(); } async fn run_client( + config: Config, request_rx: mpsc::Receiver, dispatcher_tx: mpsc::Sender, ) -> anyhow::Result<()> { - let address = format!( - "{}:{}", - config::SERVER_HOST, - config::SERVER_PORT - ); - info!("Connecting to server at {}.", address); - let stream = TcpStream::connect(address) + info!("Connecting to server at {}.", config.server_address); + let stream = TcpStream::connect(&config.server_address) .await .context("connecting to server")?; info!("Connection successful."); - let credentials = solstice_proto::server::Credentials::new( - config::USERNAME.to_string(), - config::PASSWORD.to_string(), - ) - .context("validating credentials")?; - info!("Logging in to server."); let (_info, mut worker) = solstice_proto::server::Client::new(stream) - .login(credentials) + .login(config.credentials) .await .context("logging in")?; info!("Login successful."); @@ -94,17 +86,21 @@ async fn async_main() -> anyhow::Result<()> { // TODO: Define a constant for this, or something. let (dispatcher_tx, mut dispatcher_rx) = mpsc::channel(100); - let client_task = - tokio::spawn(run_client(bundle.server_request_rx, dispatcher_tx.clone())); + let config = Config::default(); + + let mut control_listener = + control::Listener::bind(&config.control_listen_address) + .await + .context("binding control listener")?; + + let client_task = tokio::spawn(run_client( + config, + bundle.server_request_rx, + dispatcher_tx.clone(), + )); let dispatcher = Dispatcher::new(); let executor = Executor::new(bundle.context); - - let control_address = - format!("{}:{}", config::CONTROL_HOST, config::CONTROL_PORT); - let mut control_listener = control::Listener::bind(&control_address) - .await - .context("binding control listener")?; let control_task = control_listener.run(dispatcher_tx, bundle.control_response_rx); diff --git a/proto/src/server/credentials.rs b/proto/src/server/credentials.rs index 15a723d..15c3e5e 100644 --- a/proto/src/server/credentials.rs +++ b/proto/src/server/credentials.rs @@ -6,7 +6,7 @@ use crypto::md5::Md5; use crate::server::{LoginRequest, Version}; /// Credentials for logging in a client to a server. -#[derive(Debug, Eq, PartialEq)] +#[derive(Clone, Debug, Eq, PartialEq)] pub struct Credentials { user_name: String, password: String,