Revert "chore(cleanup): remove stale items"

This reverts commit b991e7d.

Cargo.toml

@@ -0,0 +1,37 @@
+[package]
+name = "chuck"
+version = "0.0.1"
+edition = "2021"
+authors = ["arqu <[email protected]>"]
+license = "Apache-2.0/MIT"
+repository = "https://github.com/n0-computer/chuck"
+description = "iroh test tools"
+rust-version = "1.65"
+
+[dependencies]
+anyhow = { version = "1", features = ["backtrace"] }
+clap = { version = "4.0.9", features = ["derive"] }
+tokio = { version = "1", features = ["full"] }
+serde = { version = "1", features = ["derive"] }
+bincode = "1.3.3"
+tempfile = "3.4.0"
+futures = "0.3.21"
+bytes = "1.1.0"
+rand = "0.8.5"
+
+axum = "0.6.2"
+tower = { version = "0.4", features = ["util"] }
+tower-http = { version = "0.3.0", features = ["fs", "trace"] }
+tracing = "0.1"
+tracing-subscriber = { version = "0.3", features = ["env-filter"] }
+axum-server = { version = "0.3", features = ["tls-rustls"] }
+reqwest = { version = "0.11.10", default-features = false, features = ["rustls-tls"] }
+
+#iroh-api = { git = "https://github.com/n0-computer/iroh", rev = "0e06dd7f70e21955f735ecd54464c7527fbf72c1"}
+#iroh-util = { git = "https://github.com/n0-computer/iroh", rev = "0e06dd7f70e21955f735ecd54464c7527fbf72c1"}
+#iroh-share = { git = "https://github.com/n0-computer/iroh", rev = "0e06dd7f70e21955f735ecd54464c7527fbf72c1"}
+#iroh-one = { git = "https://github.com/n0-computer/iroh", rev = "0e06dd7f70e21955f735ecd54464c7527fbf72c1"}
+#iroh-rpc-types = { git = "https://github.com/n0-computer/iroh", rev = "0e06dd7f70e21955f735ecd54464c7527fbf72c1", default-features = false}
+#iroh-rpc-client = { git = "https://github.com/n0-computer/iroh", rev = "0e06dd7f70e21955f735ecd54464c7527fbf72c1", default-features = false}
+
+iroh = { git = "https://github.com/n0-computer/iroh", rev = "2149bc8c6819b044833f5af0b8fdac567ef93650", default-features = false }

README.md

@@ -1,3 +1,10 @@
 # Chuck
 
 A place to chuck in various integration type tests and benchmarks.
+
+## Samples
+
+```
+cargo run -- memesync-receiver 9991
+cargo run -- memesync-sender localhost:10001 5242872 foo.jpg
+```

src/lib.rs

@@ -0,0 +1 @@
+pub mod service;

src/main.rs

@@ -0,0 +1,99 @@
+use anyhow::{Result};
+use clap::{Parser, Subcommand};
+
+use axum::{
+    http::{StatusCode},
+    response::IntoResponse,
+    routing::{get, get_service},
+    Router,
+};
+use axum_server::tls_rustls::RustlsConfig;
+use iroh::{Keypair, PeerId, provider::Ticket};
+use std::{io, net::SocketAddr, path::PathBuf};
+use tower_http::{
+    services::ServeDir,
+    trace::TraceLayer,
+};
+
+#[derive(Parser, Debug)]
+#[clap(author, version, about, long_about = None)]
+struct Args {
+    #[clap(subcommand)]
+    command: Commands,
+}
+
+#[derive(Debug, Subcommand)]
+enum Commands {
+    #[clap(arg_required_else_help = true)]
+    HttpServer { tls: u8, serve_path: PathBuf, certs: Option<PathBuf> },
+    #[clap(arg_required_else_help = false)]
+    HttpClient { target_host: String },
+    #[clap(arg_required_else_help = true)]
+    PeerID { path: PathBuf },
+    #[clap(arg_required_else_help = true)]
+    Ticket { ticket: Ticket },
+}
+
+#[tokio::main(flavor = "multi_thread")]
+async fn main() -> Result<()> {
+    let args = Args::parse();
+    match args.command {
+        Commands::HttpServer { tls, serve_path, certs } => {
+            let addr = SocketAddr::from(([0, 0, 0, 0], 443));
+            let serve_dir =
+                get_service(ServeDir::new(serve_path)).handle_error(handle_error);
+            let router = Router::new()
+                .route("/foo", get(|| async { "Hi from /foo" }))
+                .nest_service("/assets", serve_dir.clone())
+                .fallback_service(serve_dir);
+            if tls > 0 {
+                let cert_path = certs.unwrap();
+                let config = RustlsConfig::from_pem_file(
+                    cert_path
+                        .join("cert.pem"),
+                    cert_path
+                        .join("key.pem"),
+                )
+                .await
+                .unwrap();
+                println!("listening on {} with tls", addr);
+                axum_server::bind_rustls(addr, config)
+                    .serve(router.layer(TraceLayer::new_for_http()).into_make_service())
+                    .await
+                    .unwrap();
+            } else {
+                println!("listening on {}", addr);
+                axum::Server::bind(&addr)
+                    .serve(router.layer(TraceLayer::new_for_http()).into_make_service())
+                    .await
+                    .unwrap();
+            }
+        }
+        Commands::HttpClient { target_host } => {
+            let body = reqwest::Client::builder()
+                .danger_accept_invalid_certs(true)
+                .build()
+                .unwrap()
+                .get(&target_host)
+                .send()
+                .await?
+                .bytes()
+                .await?;
+            println!("{:?}", body.get(0));
+        }
+        Commands::PeerID { path } => {
+            let keystr = tokio::fs::read(path).await?;
+            let keypair = Keypair::try_from_openssh(keystr)?;
+            let pid = PeerId::from(keypair.public());
+            println!("{}", pid);
+        }
+        Commands::Ticket { ticket } => {
+            println!("{:?}", ticket);
+        }
+    }
+    Ok(())
+}
+
+async fn handle_error(_err: io::Error) -> impl IntoResponse {
+    (StatusCode::INTERNAL_SERVER_ERROR, "Something went wrong...")
+}

src/service.rs

@@ -0,0 +1,105 @@
+use anyhow::Result;
+use serde::{Deserialize, Serialize};
+use tokio::io::{AsyncReadExt, AsyncWriteExt};
+use tokio::net::TcpListener;
+use tokio::sync::mpsc;
+
+pub const DEFAULT_SERVICE_SERVER_PORT: u32 = 10001;
+pub const DEFAULT_SERVICE_BUFFER_SIZE: usize = 64 * 1024;
+
+pub struct Server {
+    listener: TcpListener,
+    handler: mpsc::Sender<Request>,
+}
+
+impl Server {
+    pub async fn new(addr: String, handler: mpsc::Sender<Request>) -> Result<Self, std::io::Error> {
+        let listener = TcpListener::bind(&addr).await?;
+        Ok(Self { listener, handler })
+    }
+
+    pub async fn run(&mut self) -> Result<(), std::io::Error> {
+        loop {
+            let tx = self.handler.clone();
+            let (mut socket, _) = self.listener.accept().await?;
+            tokio::spawn(async move {
+                let mut buf = [0; DEFAULT_SERVICE_BUFFER_SIZE];
+                println!("got connection");
+                loop {
+                    let n = match socket.read(&mut buf).await {
+                        // socket closed
+                        Ok(n) if n == 0 => return,
+                        Ok(n) => n,
+                        Err(e) => {
+                            eprintln!("failed to read from socket; err = {:?}", e);
+                            return;
+                        }
+                    };
+                    if let Ok(request) = Request::from_bytes(&buf[..n]) {
+                        if let Err(e) = tx.send(request).await {
+                            eprintln!("failed to send request; err = {:?}", e);
+                            return;
+                        }
+                        let status_ok = "200 OK";
+                        if let Err(e) = socket.write_all(status_ok.as_bytes()).await {
+                            eprintln!("failed to write to socket; err = {:?}", e);
+                            return;
+                        }
+                    } else {
+                        let status_err = "500 Internal Server Error";
+                        if let Err(e) = socket.write_all(status_err.as_bytes()).await {
+                            eprintln!("failed to write to socket; err = {:?}", e);
+                            return;
+                        }
+                    }
+                }
+            });
+        }
+    }
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
+pub enum RequestTopic {
+    MemesyncTicket,
+    CidRequest,
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
+pub struct Request {
+    pub topic: RequestTopic,
+    pub data: Vec<u8>,
+}
+
+impl Request {
+    pub fn new(topic: RequestTopic, data: Vec<u8>) -> Self {
+        Self { topic, data }
+    }
+
+    pub fn as_bytes(&self) -> Vec<u8> {
+        bincode::serialize(self).expect("failed to serialize")
+    }
+
+    pub fn from_bytes(bytes: &[u8]) -> Result<Self> {
+        let req = bincode::deserialize(bytes)?;
+        Ok(req)
+    }
+}
+
+pub struct Client {
+    host: String,
+}
+
+impl Client {
+    pub async fn new(host: String) -> Self {
+        Self { host }
+    }
+
+    pub async fn send(&mut self, request: Request) -> Result<(), std::io::Error> {
+        let mut socket = tokio::net::TcpStream::connect(&self.host).await?;
+        socket.write_all(&request.as_bytes()).await?;
+        let mut buf = [0; DEFAULT_SERVICE_BUFFER_SIZE];
+        socket.read(&mut buf).await?;
+        println!("Response: {}", String::from_utf8_lossy(&buf));
+        Ok(())
+    }
+}