automatic cargo CI changes

.gitea/workflows/cargo.yaml

@@ -16,9 +16,11 @@ jobs:
       - name: get repo
         uses: actions/checkout@v4
       - name: install rust
-        uses: dtolnay/rust-toolchain@stable
+        uses: https://github.com/dtolnay/rust-toolchain@stable
       - name: install additional rust things
-        run: rustup component add rustfmt
+        run: |
+          rustup component add rustfmt
+          rustup component add clippy
       - name: config custom registry
         run: |
           mkdir -p ~/.cargo/
@@ -28,16 +30,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 check
-        run: cargo check --all-features --all-targets
-      - name: cargo fix
-        run: cargo fix --all-features --all-targets
+      - name: cargo clippy check
+        run: cargo clippy --all-features --all-targets
+      - name: cargo clippy fix
+        run: cargo clippy --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: stefanzweifel/git-auto-commit-action@v5
+        uses: https://github.com/stefanzweifel/git-auto-commit-action@v5
         with:
           # Optional. Commit message for the created commit.
           # Defaults to "Apply automatic changes"

Cargo.toml

@@ -1,7 +1,6 @@
-workspace = { members = ["spammer"] }
 [package]
 name = "netpong"
-version = "0.2.1"
+version = "0.2.2"
 edition = "2021"
 publish = true
 authors = ["Christoph J. Scherr <software@cscherr.de>"]
@@ -18,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", "macros"] }
+tokio = { version = "1.35.1", features = ["net", "rt-multi-thread", "macros", "time", "io-util"] }
 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"]

README.md

@@ -1,3 +1,3 @@
-# rs-base
+# netpong
 
-Base repository for rust projects
+Let your hosts play Pingpong over a tls connection.

scripts/make_cert.sh

@@ -1,5 +0,0 @@
-#!/bin/bash
-mkdir data
-echo create ca
-# non-interactive and 10 years expiration
-openssl req -x509 -nodes -newkey rsa:4096 -keyout data/key.pem -out data/cert.pem -sha256 -days 3650 -subj '/CN=localhost'

scripts/publish.sh

@@ -0,0 +1,11 @@
+#!/bin/bash
+set -e
+cargo check --all-features
+echo ">>>>>>>> PUBLISHING RELEASE FOR REPO"
+bash scripts/release.sh
+echo ">>>>>>>> PUBLISHING TO CRATES.IO NEXT"
+sleep 2
+cargo publish
+echo ">>>>>>>> PUBLISHING TO CSCHERR.DE NEXT"
+sleep 2
+cargo publish --registry cscherr

scripts/release.sh

@@ -0,0 +1,24 @@
+#!/bin/bash
+TOKEN=$(cat ~/.git-credentials | grep 'git.cscherr.de' | grep -P '(?:)[^:]*(?=@)' -o)
+NEW_VERSION=$(cat Cargo.toml | rg '^\s*version\s*=\s*"([^"]*)"\s*$' -or '$1')
+GIT_COMMIT_SHA=$(git rev-parse HEAD)
+REPO=${PWD##*/} # name of cwd
+BODY="
+$(git log $(git describe --tags --abbrev=0)..HEAD --pretty="- %s" --oneline --decorate)
+"
+USER=PlexSheep
+git tag "v$NEW_VERSION-test" || echo "could not tag"
+curl -X 'POST' \
+	'https://git.cscherr.de/api/v1/repos/PlexSheep/'$REPO'/releases' \
+	-H 'accept: application/json' \
+	-H "Authorization: token $TOKEN" \
+	-H 'Content-Type: application/json' \
+	-d '{
+  "body": "'"$BODY"'",
+  "draft": false,
+  "name": "v'$NEW_VERSION'",
+  "prerelease": true,
+  "tag_name": "v'$NEW_VERSION'",
+  "target_commitish": "'$GIT_COMMIT_SHA'"
+}' | python -m json.tool
+git push || echo "could not push"

spammer/Cargo.toml

@@ -1,9 +0,0 @@
-[package]
-name = "spammer"
-version = "0.1.0"
-edition = "2021"
-
-# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
-
-[dependencies]
-threadpool = "1.8.1"

spammer/src/main.rs

@@ -1,18 +0,0 @@
-use threadpool::ThreadPool;
-const MAX: usize = 20;
-use std::process::Command;
-
-fn main() {
-    let pool = ThreadPool::new(MAX);
-
-    loop {
-        if pool.queued_count() < MAX {
-            pool.execute(|| {
-                let mut cmd = Command::new("/usr/bin/python3");
-                cmd.args(["../scripts/client.py"]);
-                let _ = cmd.output().unwrap();
-            });
-        }
-        std::thread::sleep(std::time::Duration::from_millis(100));
-    }
-}

src/client/mod.rs

@@ -3,24 +3,20 @@ 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},
-    net::TcpStream,
-};
+use tokio::io::{AsyncReadExt, AsyncWriteExt};
+use tokio::net::TcpStream;
 use tokio_rustls::{
     rustls::{self, pki_types},
-    TlsConnector,
+    TlsConnector, TlsStream,
 };
-use webpki_roots;
 
 const BUF_SIZE: usize = 512;
 
 pub struct Client {
     cfg: Config,
-    stream: TcpStream,
+    stream: TlsStream<TcpStream>,
     connector: TlsConnector,
     domain: pki_types::ServerName<'static>,
 }
@@ -41,7 +37,6 @@ 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) => {
@@ -49,27 +44,29 @@ impl Client {
                 return Err(err.into());
             }
         };
+        let stream = connector
+            .connect(domain.clone(), TcpStream::connect(&cfg.addr).await?)
+            .await?;
 
         Ok(Client {
             cfg: cfg.clone(),
-            stream,
+            stream: tokio_rustls::TlsStream::Client(stream),
             connector,
             domain,
         })
     }
 
-    pub async fn run(self) -> anyhow::Result<()> {
-        let mut stream = self.connector.connect(self.domain, self.stream).await?;
+    pub async fn run(mut self) -> anyhow::Result<()> {
         let mut buf = [0; BUF_SIZE];
-        stream.write_all(b"ping").await?;
+        self.stream.write_all(b"ping").await?;
         info!("> ({}) ping", self.cfg.hostname);
-        while stream.read(&mut buf).await? > 0 {
+        while self.stream.read(&mut buf).await? > 0 {
             let response = decode(&buf)?;
             info!("< ({}) {}", self.cfg.hostname, response);
             if response == "You win!" {
                 break;
             }
-            stream.write_all(b"ping").await?;
+            self.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: &'static str = r##"
+const ABOUT_ROOT: &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: &'static str = r##"
+static LONG_ABOUT_ROOT: &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,11 +74,18 @@ impl Cli {
             }
         };
         if cli.meta {
-            Logger::init(None, Some(ll), true).expect("could not initialize Logger");
+            let _ = Logger::builder()
+                .set_level(ll)
+                .display_filename(true)
+                .build()
+                .expect("could not initialize Logger");
         } else {
             // less verbose version
-            Logger::init_mini(Some(ll)).expect("could not initialize Logger");
+            let _ = Logger::builder()
+                .set_level(ll)
+                .build()
+                .expect("could not initialize Logger");
         }
-        return cli;
+        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.into()),
+        Err(err) => return Err(err),
     }
     .trim_matches(char::from(0))
     .to_string())

src/main.rs

@@ -5,7 +5,6 @@
 
 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::{self},
+    time,
 };
 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);
-                return Err(std::io::ErrorKind::InvalidInput.into());
+                Err(std::io::ErrorKind::InvalidInput.into())
             }
             Err(err) => {
                 error!("could not load certs: {err:?}");
-                return Err(err);
+                Err(err)
             }
         }
     }