ready for release

.gitea/workflows/cargo.yaml

@@ -16,11 +16,9 @@ jobs:
       - name: get repo
         uses: actions/checkout@v4
       - name: install rust
-        uses: https://github.com/dtolnay/rust-toolchain@stable
+        uses: dtolnay/rust-toolchain@stable
       - name: install additional rust things
-        run: |
+        run: rustup component add rustfmt
-          rustup component add rustfmt
-          rustup component add clippy
       - name: config custom registry
         run: |
           mkdir -p ~/.cargo/
@@ -30,16 +28,16 @@ jobs:
           echo '[registries.cscherr]' >> ~/.cargo/config.toml
           echo 'index = "https://git.cscherr.de/PlexSheep/_cargo-index.git"' >> ~/.cargo/config.toml
           cat ~/.cargo/config.toml
-      - name: cargo clippy check
+      - name: cargo check
-        run: cargo clippy --all-features --all-targets
+        run: cargo check --all-features --all-targets
-      - name: cargo clippy fix
+      - name: cargo fix
-        run: cargo clippy --fix --all-features --all-targets
+        run: cargo fix --all-features --all-targets
       - name: cargo fmt
         run: cargo fmt --all
       - name: cargo test
         run: cargo test --all-features --all-targets
       - name: commit back to repository
-        uses: https://github.com/stefanzweifel/git-auto-commit-action@v5
+        uses: stefanzweifel/git-auto-commit-action@v5
         with:
           # Optional. Commit message for the created commit.
           # Defaults to "Apply automatic changes"

Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "netpong"
-version = "0.2.2"
+version = "0.2.1"
 edition = "2021"
 publish = true
 authors = ["Christoph J. Scherr <software@cscherr.de>"]
@@ -17,12 +17,12 @@ anyhow = "1.0.79"
 clap = "4.4.18"
 clap-num = "1.0.2"
 clap-verbosity-flag = "2.1.2"
+libpt = { version = "0.3.11", features = ["net"] }
 thiserror = "1.0.56"
-tokio = { version = "1.35.1", features = ["net", "rt-multi-thread", "macros", "time", "io-util"] }
+tokio = { version = "1.35.1", features = ["net", "rt", "macros"] }
 rustls-pemfile = "2.0.0"
 tokio-rustls = "0.25.0"
 webpki-roots = "0.26.0"
-libpt = { version = "0.6.0", features = ["log"] }
 
 [features]
 default = ["server"]

src/client/mod.rs

@@ -3,20 +3,24 @@ use std::{fs::File, io::BufReader, sync::Arc};
 
 use crate::{common::decode, Config};
 
+use anyhow;
 use libpt::log::{error, info, trace};
 use rustls_pemfile::certs;
-use tokio::io::{AsyncReadExt, AsyncWriteExt};
+use tokio::{
-use tokio::net::TcpStream;
+    io::{AsyncReadExt, AsyncWriteExt},
+    net::TcpStream,
+};
 use tokio_rustls::{
     rustls::{self, pki_types},
-    TlsConnector, TlsStream,
+    TlsConnector,
 };
+use webpki_roots;
 
 const BUF_SIZE: usize = 512;
 
 pub struct Client {
     cfg: Config,
-    stream: TlsStream<TcpStream>,
+    stream: TcpStream,
     connector: TlsConnector,
     domain: pki_types::ServerName<'static>,
 }
@@ -37,6 +41,7 @@ impl Client {
             .with_root_certificates(root_cert_store)
             .with_no_client_auth();
         let connector = TlsConnector::from(Arc::new(tls_config));
+        let stream = TcpStream::connect(&cfg.addr).await?;
         let domain = match pki_types::ServerName::try_from(cfg.hostname.clone()) {
             Ok(domain) => domain,
             Err(err) => {
@@ -44,29 +49,27 @@ impl Client {
                 return Err(err.into());
             }
         };
-        let stream = connector
-            .connect(domain.clone(), TcpStream::connect(&cfg.addr).await?)
-            .await?;
 
         Ok(Client {
             cfg: cfg.clone(),
-            stream: tokio_rustls::TlsStream::Client(stream),
+            stream,
             connector,
             domain,
         })
     }
 
-    pub async fn run(mut self) -> anyhow::Result<()> {
+    pub async fn run(self) -> anyhow::Result<()> {
+        let mut stream = self.connector.connect(self.domain, self.stream).await?;
         let mut buf = [0; BUF_SIZE];
-        self.stream.write_all(b"ping").await?;
+        stream.write_all(b"ping").await?;
         info!("> ({}) ping", self.cfg.hostname);
-        while self.stream.read(&mut buf).await? > 0 {
+        while stream.read(&mut buf).await? > 0 {
             let response = decode(&buf)?;
             info!("< ({}) {}", self.cfg.hostname, response);
             if response == "You win!" {
                 break;
             }
-            self.stream.write_all(b"ping").await?;
+            stream.write_all(b"ping").await?;
             info!("> ({}) ping", self.cfg.hostname);
             // we should wait, so that we don't spam the client
             std::thread::sleep(self.cfg.delay);

src/common/args.rs

@@ -6,11 +6,11 @@ use clap::Parser;
 use clap_verbosity_flag::{InfoLevel, Verbosity};
 
 /// short about section displayed in help
-const ABOUT_ROOT: &str = r##"
+const ABOUT_ROOT: &'static str = r##"
 Let your hosts play ping pong over the network
 "##;
 /// longer about section displayed in help, is combined with [the short help](ABOUT_ROOT)
-static LONG_ABOUT_ROOT: &str = r##"
+static LONG_ABOUT_ROOT: &'static str = r##"
 
     Connect to a ping pong server and periodically send a ping. The server will reply with a pong.
     That's it really. You can also host your own netpong server (server feature).
@@ -74,18 +74,11 @@ impl Cli {
             }
         };
         if cli.meta {
-            let _ = Logger::builder()
+            Logger::init(None, Some(ll), true).expect("could not initialize Logger");
-                .set_level(ll)
-                .display_filename(true)
-                .build()
-                .expect("could not initialize Logger");
         } else {
             // less verbose version
-            let _ = Logger::builder()
+            Logger::init_mini(Some(ll)).expect("could not initialize Logger");
-                .set_level(ll)
-                .build()
-                .expect("could not initialize Logger");
         }
-        cli
+        return cli;
     }
 }

src/common/mod.rs

@@ -7,7 +7,7 @@ pub mod conf;
 pub fn decode(buf: &[u8]) -> Result<String, Utf8Error> {
     Ok(match std::str::from_utf8(buf) {
         Ok(s) => s.to_string(),
-        Err(err) => return Err(err),
+        Err(err) => return Err(err.into()),
     }
     .trim_matches(char::from(0))
     .to_string())

src/main.rs

@@ -5,6 +5,7 @@
 
 use anyhow::Result;
 use libpt::log::*;
+use tokio;
 
 mod client;
 mod common;

src/server/mod.rs

@@ -13,7 +13,7 @@ use rustls_pemfile::{certs, private_key};
 use tokio::{
     io::{AsyncReadExt, AsyncWriteExt},
     net::{TcpListener, TcpStream},
-    time,
+    time::{self},
 };
 use tokio_rustls::{rustls, TlsAcceptor};
 
@@ -109,10 +109,10 @@ impl Server {
             error!("the server needs a key!");
             return Err(std::io::ErrorKind::InvalidInput.into());
         }
-
+        let key = private_key(&mut std::io::BufReader::new(File::open(
-        private_key(&mut std::io::BufReader::new(File::open(
             cfg.key.clone().unwrap(),
-        )?))
+        )?));
+        return key;
     }
 
     fn load_certs(cfg: Config) -> std::io::Result<Vec<CertificateDer<'static>>> {
@@ -121,18 +121,18 @@ impl Server {
             return Err(std::io::ErrorKind::InvalidInput.into());
         }
         match certs(&mut std::io::BufReader::new(File::open(
-            cfg.certs.clone().unwrap(),
+            &cfg.certs.clone().unwrap(),
         )?))
         .collect::<std::io::Result<Vec<CertificateDer<'static>>>>()
         {
             Ok(v) if !v.is_empty() => Ok(v),
             Ok(_) => {
                 error!("no certs found in provided file {:?}", cfg.certs);
-                Err(std::io::ErrorKind::InvalidInput.into())
+                return Err(std::io::ErrorKind::InvalidInput.into());
             }
             Err(err) => {
                 error!("could not load certs: {err:?}");
-                Err(err)
+                return Err(err);
             }
         }
     }