clean up (#72)

Author: andrewgazelka

Cargo.lock

@@ -14,7 +14,7 @@ homepage = "https://github.com/andrewgazelka/SwarmBot"
 [dependencies]
 
 # parsing arguments
-clap = { version = "3.0.0-rc.5", features = ["derive"] }
+clap = { version = "4.0.32", features = ["derive"] }
 
 # reading from csv
 csv = "1.1"
@@ -34,15 +34,11 @@ tokio = { version = "1.24", features = [
     "parking_lot",
 ] }
 
-# async trait
-async-trait = "0.1"
-
 # dns
-trust-dns-resolver = "0.21.0-alpha.4"
+trust-dns-resolver = "0.22"
 
 # encryption
-aes = "0.7"
-cfb8 = "0.7"
+aes = "0.7.5"
 
 # zlib
 #flate2 = {version = "1.0"}
@@ -61,7 +57,7 @@ reqwest = { version = "0.11", features = ["json", "socks"] }
 
 # for minecraft auth RSA response
 rsa-der = "0.3"
-rsa = "0.6"
+rsa = "0.7"
 
 # used for RSA and random generation
 rand = "0.8"
@@ -70,7 +66,7 @@ rand = "0.8"
 num-bigint = "0.4"
 
 # mojang hash
-sha1 = "0.6"
+sha1 = "0.10"
 
 # json parsing (particularly for mojang api)
 serde_json = "1.0"
@@ -79,7 +75,6 @@ serde_json = "1.0"
 itertools = "0.10"
 
 # for data storage
-bincode = "2.0.0-alpha.2"
 
 # chat parsing
 regex = "1.5"
@@ -108,17 +103,17 @@ swarm-bot-packets = { path = "packets", version = "0.2.0" }
 # so we don't have to use v-tables
 enum_dispatch = "0.3"
 
-# for errors
-thiserror = "1.0"
-
 # websockets
-tokio-tungstenite = "0.17"
+tokio-tungstenite = "0.18"
 
 futures = "0.3"
-#futures-util = "0.3"
 
 interfaces = { path = "interfaces" }
-
+anyhow = "1.0.68"
+bincode = "2.0.0-alpha.2"
+hex-literal = "0.3.4"
+cfb8 = "0.7"
+tokio-stream = "0.1.11"
 
 [dev-dependencies]
 assert_matches = "1.5"
@@ -134,6 +129,6 @@ opt-level = 1
 
 
 [profile.release]
-debug = true
-#lto = "fat"
-#codegen-units = 1
+# debug = true
+lto = "fat"
+codegen-units = 1

Cargo.toml

@@ -1,11 +1,12 @@
 #![feature(once_cell)]
 
-use crate::types::{BlockLocation, Selection2D};
 use futures::{SinkExt, StreamExt};
 use serde::{Deserialize, Serialize};
 use tokio::net::{TcpListener, TcpStream, ToSocketAddrs};
 use tungstenite::Message;
 
+use crate::types::{BlockLocation, Selection2D};
+
 pub mod types;
 
 type Id = u64;
@@ -98,6 +99,7 @@ impl Comm {
         let (send_tx, mut send_rx) = tokio::sync::mpsc::unbounded_channel();
         let mut ws = tokio_tungstenite::accept_async(stream).await?;
         tokio::spawn(async move {
+            let mut msg_to_send = None;
             tokio::select! {
                 val = ws.next() => {
                     if let Some(Ok(msg)) = val {
@@ -109,11 +111,15 @@ impl Comm {
                 val = send_rx.recv() => {
                     if let Some(cmd) = val {
                         if let Ok(msg) = outgoing(cmd) {
-                            let _ = ws.send(msg);
+                            msg_to_send = Some(msg);
                         }
                     }
                 }
             }
+
+            if let Some(msg) = msg_to_send {
+                let _ = ws.send(msg).await;
+            }
         });
 
         Ok(Self {
@@ -133,6 +139,7 @@ impl Comm {
                     let (stream, _) = server.accept().await?;
                     let mut ws = tokio_tungstenite::accept_async(stream).await?;
 
+                    let mut msg_to_send = None;
                     tokio::select! {
                         val = ws.next() => {
                             if let Some(Ok(msg)) = val {
@@ -144,12 +151,16 @@ impl Comm {
                         val = send_rx.recv() => {
                             if let Some(cmd) = val {
                                 if let Ok(msg) = outgoing(cmd) {
-                                    let _ = ws.send(msg);
+                                    msg_to_send = Some(msg)
                                 }
                             }
                         }
                     }
 
+                    if let Some(msg) = msg_to_send {
+                        let _ = ws.send(msg).await;
+                    }
+
                     Ok(())
                 }
                 .await;
@@ -176,7 +187,6 @@ mod tests {
             }),
         };
 
-        let res = serde_json::to_string(&command).unwrap();
-        println!("res {:?}", res);
+        serde_json::to_string(&command).unwrap();
     }
 }

interfaces/src/lib.rs

@@ -1,15 +1,14 @@
-use colored::Colorize;
 use std::{
     f32::consts::PI,
     fmt::{Debug, Display, Formatter},
     ops::{Add, AddAssign, Index, Mul, MulAssign, Neg, Sub},
 };
 
+use colored::Colorize;
 use itertools::Itertools;
 use lazy_static::lazy_static;
 use regex::{Captures, Regex};
 use serde::{Deserialize, Serialize};
-
 use swarm_bot_packets::{
     read::{ByteReadable, ByteReader},
     write::{ByteWritable, ByteWriter},

interfaces/src/types.rs

@@ -1,5 +1,4 @@
 use proc_macro::TokenStream;
-
 use quote::quote;
 use syn::{
     parse::{Parse, ParseStream},

packets/packets_macro/src/lib.rs

@@ -1,10 +1,11 @@
 # https://rust-lang.github.io/rustfmt/?version=v1.4.36
-unstable_features = true
-reorder_imports = true
+format_code_in_doc_comments = true
+format_macro_bodies = true
+format_macro_matchers = true
+group_imports = "StdExternalCrate"
+imports_granularity = "Crate"
 normalize_comments = true
 normalize_doc_attributes = true
-imports_granularity = "Crate"
-format_macro_matchers = true
-format_macro_bodies = true
+reorder_imports = true
+unstable_features = true
 wrap_comments = true
-format_code_in_doc_comments = true

rustfmt.toml

@@ -1,13 +1,13 @@
+//! module for modifying CSVs
+
 use std::fs::File;
 
 use serde::de::DeserializeOwned;
 
-use crate::{
-    bootstrap::{CSVUser, Proxy},
-    error::Res,
-};
+use crate::bootstrap::{CSVUser, Proxy};
 
-fn read_csv<T: DeserializeOwned>(file: File) -> Res<Vec<T>> {
+/// read CSV file into `Vec` of the desired type
+fn read_csv<T: DeserializeOwned>(file: File) -> anyhow::Result<Vec<T>> {
     csv::ReaderBuilder::new()
         .delimiter(b':')
         .has_headers(false)
@@ -20,10 +20,12 @@ fn read_csv<T: DeserializeOwned>(file: File) -> Res<Vec<T>> {
         .collect()
 }
 
-pub fn read_users(file: File) -> Res<Vec<CSVUser>> {
+/// reade users from a CSV file
+pub fn read_users(file: File) -> anyhow::Result<Vec<CSVUser>> {
     read_csv(file)
 }
 
-pub fn read_proxies(file: File) -> Res<Vec<Proxy>> {
+/// read proxies from a CSV file
+pub fn read_proxies(file: File) -> anyhow::Result<Vec<Proxy>> {
     read_csv(file)
 }

src/bootstrap/csv.rs

@@ -1,27 +1,31 @@
+//! Module for interacting with DNS
+use anyhow::Context;
 use trust_dns_resolver::{
     config::{ResolverConfig, ResolverOpts},
-    error::ResolveError,
     AsyncResolver,
 };
 
 use crate::bootstrap::Address;
 
 /// performs a DNS lookup on host
-async fn dns_lookup(host: &str) -> Result<Address, ResolveError> {
-    let resolver =
-        AsyncResolver::tokio(ResolverConfig::default(), ResolverOpts::default()).unwrap();
+async fn dns_lookup(host: &str) -> anyhow::Result<Address> {
+    let resolver = AsyncResolver::tokio(ResolverConfig::default(), ResolverOpts::default())
+        .context("could not create async lookup")?;
 
-    println!("performing srv lookup");
-    resolver
+    let res = resolver
         .srv_lookup(format!("_minecraft._tcp.{host}"))
         .await
-        .map(|res| {
-            let srv = res.iter().next().unwrap();
-            Address {
-                host: srv.target().to_utf8(),
-                port: srv.port(),
-            }
-        })
+        .context("could not perform SRV lookup")?;
+
+    let srv = res
+        .iter()
+        .next()
+        .context("there are no elements in SRV lookup")?;
+
+    Ok(Address {
+        host: srv.target().to_utf8(),
+        port: srv.port(),
+    })
 }
 
 /// Normalizes the address. Some servers like 2b2t have a separate address for

src/bootstrap/dns.rs

@@ -1,3 +1,5 @@
+//! used for boostrapping the code
+use anyhow::Context;
 use serde::Deserialize;
 use tokio::{
     net::{
@@ -22,7 +24,9 @@ pub mod storage;
 /// A server address
 #[derive(Clone, Debug)]
 pub struct Address {
+    /// the hostname
     pub host: String,
+    /// the port
     pub port: u16,
 }
 
@@ -51,51 +55,55 @@ pub struct BotConnection {
     pub write: OwnedWriteHalf,
 }
 
+async fn obtain_connection(user: BotDataLoader, address: Address) -> anyhow::Result<BotConnection> {
+    let BotDataLoader {
+        proxy,
+        user,
+        mojang,
+    } = user;
+
+    let target = String::from(&address);
+
+    let conn = if let Some(proxy) = proxy {
+        let address = proxy.address();
+        let conn = Socks5Stream::connect_with_password(
+            proxy.address().as_str(),
+            target.as_str(),
+            &proxy.user,
+            &proxy.pass,
+        )
+        .await
+        .with_context(|| format!("could not create to socks {address}"))?;
+
+        conn.into_inner()
+    } else {
+        TcpStream::connect(target.as_str()).await.unwrap()
+    };
+
+    let (read, write) = conn.into_split();
+    Ok(BotConnection {
+        user,
+        server_address: address,
+        mojang,
+        read,
+        write,
+    })
+}
+
 impl BotConnection {
-    /// Generates connections given BotData and an address
+    /// Generates connections given [`BotData`] and an address
     pub fn stream(
         server_address: Address,
-        mut users: tokio::sync::mpsc::Receiver<BotDataLoader>,
-    ) -> Receiver<BotConnection> {
+        mut users: Receiver<BotDataLoader>,
+    ) -> Receiver<anyhow::Result<Self>> {
         let (tx, rx) = tokio::sync::mpsc::channel(1);
         tokio::task::spawn_local(async move {
             while let Some(user) = users.recv().await {
                 let tx = tx.clone();
                 let address = server_address.clone();
                 tokio::task::spawn_local(async move {
-                    let BotDataLoader {
-                        proxy,
-                        user,
-                        mojang,
-                    } = user;
-
-                    let target = String::from(&address);
-
-                    let conn = match proxy {
-                        Some(proxy) => {
-                            let conn = Socks5Stream::connect_with_password(
-                                proxy.address().as_str(),
-                                target.as_str(),
-                                &proxy.user,
-                                &proxy.pass,
-                            )
-                            .await
-                            .unwrap();
-                            conn.into_inner()
-                        }
-                        None => TcpStream::connect(target.as_str()).await.unwrap(),
-                    };
-
-                    let (read, write) = conn.into_split();
-                    tx.send(BotConnection {
-                        user,
-                        server_address: address,
-                        mojang,
-                        read,
-                        write,
-                    })
-                    .await
-                    .unwrap();
+                    let connection = obtain_connection(user, address).await;
+                    tx.send(connection).await.unwrap();
                 });
             }
         });