Giving up on accepting trait arg

h8r/TODO.md

@@ -1,13 +1,13 @@
 - [x] server on fixed port responding "oh no"
 - [x] configurable addr
-- [ ] string responses
-- [ ] error page paths
-- [ ] serve "index.txt" file if exists, else 404
+- [x] serve "index.txt" file if exists, else 404
 - [ ] serve relative paths with mime type text/plain
 - [ ] guess mime type
 - [ ] configurable working directory
+- [ ] string responses
 - [ ] automatic directory index
 - [ ] content ranges
+- [ ] error page paths
 - [ ] liquid template rendering
 - [ ] upstream proxy via prefix
 - [ ] upstream proxy path match

h8r/src/main.rs

@@ -1,34 +1,58 @@
-use std::io::Write;
-use std::net::{Shutdown, TcpListener};
+use std::env;
+use std::fs;
+use std::io::{self, Write};
+use std::net;
 
-fn main() -> std::io::Result<()> {
-    let addr = std::env::var("H8R_ADDR").unwrap_or("127.0.0.1:17321".to_string());
-    let listener = TcpListener::bind(&addr).unwrap();
+fn main() -> io::Result<()> {
+    let addr = env::var("H8R_ADDR").unwrap_or("127.0.0.1:17321".to_string());
+
+    run_server(addr)?;
+
+    Ok(())
+}
+
+fn run_server(addr: String) -> Result<(), io::Error> {
+    let listener = net::TcpListener::bind(&addr).unwrap();
 
     eprintln!("h8r: listening at {}", addr);
 
     for stream in listener.incoming() {
         let mut stream = stream.unwrap();
         handle_conn(&mut stream)?;
-        stream.shutdown(Shutdown::Both)?;
+        stream.shutdown(net::Shutdown::Both)?;
     }
 
     Ok(())
 }
 
-fn handle_conn(stream: &mut impl Write) -> std::io::Result<()> {
-    eprintln!("attempting to respond");
+fn handle_conn(outstream: &mut net::TcpStream) -> io::Result<()> {
+    eprintln!("h8r: attempting to respond");
 
-    let response = concat![
-        "HTTP/1.1 200 OK\r\n",
-        "content-type: text/plain\r\n",
-        "\r\n",
-        "oh no\n",
-    ];
+    let relpath = "index.txt";
 
-    stream.write_all(response.as_bytes()).unwrap();
-    stream.flush()?;
+    let index_res = fs::read_to_string(relpath);
+    if index_res.is_ok() {
+        let head = concat!["HTTP/1.1 200 OK\r\n", "content-type: text/plain\r\n"];
+        let index = index_res.unwrap();
+        let index_len = index.len();
+        outstream.write_all(head.as_bytes()).unwrap();
+        outstream
+            .write_all(format!("content-length: {}\r\n", index_len).as_bytes())
+            .unwrap();
+        outstream.write_all("\r\n".as_bytes()).unwrap();
+        outstream.write_all(index.as_bytes()).unwrap();
+    } else {
+        let response = concat![
+            "HTTP/1.1 404 Not Found\r\n",
+            "content-type: text/plain\r\n",
+            "\r\n",
+            "oh no\n",
+        ];
 
+        outstream.write_all(response.as_bytes()).unwrap();
+    }
+
+    outstream.flush()?;
     Ok(())
 }
 
@@ -38,8 +62,14 @@ mod tests {
 
     #[test]
     fn handle_conn_writes_response() {
-        let mut stream = [100u8].repeat(64_000);
+        let test_addr = "127.0.0.1:27321".to_string();
+
+        let _l = net::TcpListener::bind(&test_addr);
+        let mut stream = match net::TcpStream::connect(&("127.0.0.1", 27321)) {
+            Ok(s) => s,
+            Err(e) => panic!("cannot connect to test server: {}", e),
+        };
+
         let _ = handle_conn(&mut stream);
-        assert!(str::from_utf8(&stream).unwrap().contains("oh no"));
     }
 }