add config parsing

Author: blobcode

Cargo.lock

@@ -12,4 +12,5 @@ bpaf = "0.4.3"
 toml = "0.5"
 log = "0.4"
 simple_logger = "2.1.0"
+serde = { version = "1.0", features = ["derive"] }
 futures = "0.3"

Cargo.toml

@@ -0,0 +1,15 @@
+# ⚙️ cobalt
+
+cobalt is a simple, minimal reverse proxy in rust using tokio. It's the greatly improved descendant of the earlier [pine](https://github.com/blobcode/pine).
+
+## installation
+
+To install, you'll need `cargo` and `git` installed.
+
+## getting started
+
+## config
+
+---
+
+written with ❤️ by [blobcode](https://blobco.de)

README.md

@@ -1,5 +1,5 @@
-port = 8080
+port = 8000
 
 [[host]]
-from = ["localhost:8080"]
+from = ["localhost:8000"]
 to = "localhost:4000"

cobalt.toml

@@ -0,0 +1,23 @@
+use bpaf::*;
+use std::path::PathBuf;
+#[derive(Clone, Debug)]
+pub struct Opts {
+    pub path: PathBuf,
+}
+
+pub fn parse() -> Opts {
+    let path = short('c')
+        .long("config")
+        .help("path to config file")
+        .argument("PATH")
+        .from_str();
+
+    // combine parsers `speed` and `distance` parsers into a parser for Opts
+    let parser = construct!(Opts { path });
+
+    // define help message, attach it to parser, and run the results
+    Info::default()
+        .descr("a simple reverse proxy")
+        .for_parser(parser)
+        .run()
+}

src/args.rs

@@ -0,0 +1,51 @@
+use serde::Deserialize;
+use std::path::PathBuf;
+use std::{collections::HashMap, fs};
+
+// main config struct
+pub struct Config {
+    pub port: u16,
+    pub hosts: HashMap<String, String>,
+}
+
+// structs that parse toml
+#[derive(Deserialize)]
+pub struct ConfigToml {
+    pub port: u16,
+    pub host: Vec<HostToml>,
+}
+
+#[derive(Deserialize)]
+pub struct HostToml {
+    pub from: Vec<String>,
+    pub to: String,
+}
+
+// parse config file
+fn parsehosts(config: ConfigToml) -> HashMap<String, String> {
+    // parse list
+    let mut hosts = HashMap::new();
+    // add all "to" and "from" fields to the hashmap
+    for host in config.host {
+        for from in host.from {
+            let to = &host.to;
+            hosts.insert(from.to_string(), to.to_string());
+        }
+    }
+    hosts
+}
+
+// main function to get config struct
+pub fn parse(file: PathBuf) -> Config {
+    // load config
+    let buf = fs::read_to_string(file).unwrap();
+
+    // parse file contents
+    let config: ConfigToml = toml::from_str(&buf).unwrap();
+
+    // create main config struct
+    Config {
+        port: config.port,
+        hosts: parsehosts(config),
+    }
+}

src/config.rs

@@ -1,15 +1,23 @@
 use simple_logger::SimpleLogger;
 use std::error::Error;
 
+mod args;
+mod config;
 mod server;
 
 #[tokio::main]
 async fn main() -> Result<(), Box<dyn Error>> {
     // logging setup
     SimpleLogger::new().init().unwrap();
 
+    // get args
+    let opts = args::parse();
+
+    // get config
+    let config = config::parse(opts.path);
+
     // server setup
-    let server = server::Server { port: 80 };
+    let server = server::Server { port: config.port };
     server.run().await?;
     Ok(())
 }

src/main.rs

@@ -6,27 +6,25 @@ use futures::FutureExt;
 use std::error::Error;
 
 pub struct Server {
-    pub port: u32,
+    pub port: u16,
 }
 
 impl Server {
     pub async fn run(&self) -> Result<(), Box<dyn Error>> {
-        let listen_addr = "127.0.0.1:8081".to_string();
-        let server_addr = "127.0.0.1:8080".to_string();
+        let listen_addr = "127.0.0.1:".to_string() + &self.port.to_string();
 
         log::info!("Listening on: {}", listen_addr);
-        log::info!("Proxying to: {}", server_addr);
 
         let listener = TcpListener::bind(listen_addr).await?;
 
         while let Ok((inbound, _)) = listener.accept().await {
-            let transfer = proxy(inbound, server_addr.clone()).map(|r| {
+            let handler = handle(inbound).map(|r| {
                 if let Err(e) = r {
                     log::error!("Failed to proxy; error={}", e);
                 }
             });
 
-            tokio::spawn(transfer);
+            tokio::spawn(handler);
         }
         Ok(())
     }
@@ -52,3 +50,31 @@ async fn proxy(mut inbound: TcpStream, proxy_addr: String) -> Result<(), Box<dyn
 
     Ok(())
 }
+
+async fn handle(inbound: TcpStream) -> Result<(), Box<dyn Error>> {
+    let server_addr = "127.0.0.1:8080".to_string();
+
+    let transfer = proxy(inbound, server_addr.clone()).map(|r| {
+        if let Err(e) = r {
+            log::error!("Failed to proxy; error={}", e);
+        }
+    });
+
+    tokio::spawn(transfer);
+
+    Ok(())
+}
+
+fn gethost() -> Result<(), Box<dyn Error>> {
+    let mut headers = [httparse::EMPTY_HEADER; 64];
+    let mut req = httparse::Request::new(&mut headers);
+
+    let buf = b"GET /index.html HTTP/1.1\r\nHost";
+    assert!(req.parse(buf)?.is_partial());
+
+    // a partial request, so we try again once we have more data
+
+    let buf = b"GET /index.html HTTP/1.1\r\nHost: example.domain\r\n\r\n";
+    assert!(req.parse(buf)?.is_complete());
+    Ok(())
+}