Merge pull request #3 from malandrakisgeo/static

Support for static websites in general

Author: malandrakisgeo

README

@@ -0,0 +1,14 @@
+A web server written in Rust. Suitable for static content.
+
+Add your website under /static either as a subdirectory or by replacing all contents, and voila.
+The server expects an index.html.
+
+
+Features:
+    Caching
+
+
+TODOs:
+    Range requests
+    Security
+    Logging

src/cache/mod.rs

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

src/server_cache.rs renamed to src/cache/server_cache.rs

@@ -24,12 +24,12 @@ impl Config {
     pub fn default_config() -> Config {
 
         return  Config{
-            address: "127.0.0.1".to_string(), //127.0.0.1, 0.0.0.0   127.0.0.1:7151
+            address: "127.0.0.1".to_string(), //127.0.0.1:7151
             port: "7151".to_string(),
             auth: Default::default(),
             file_dir: ".".to_string(),
             tls: None,
-            max_cache_files: 5,
+            max_cache_files: 10,
             largest_cacheable_file_size: 1000000000 //100MB in bytes
         }
     }

src/config.rs

@@ -0,0 +1,100 @@
+use std::{fs};
+use std::time::SystemTime;
+use urlencoding::decode;
+use crate::content_manager::song_site::songs_page;
+use crate::response::refera_error::ReferaError;
+use crate::server_cache::FileCacheTuple;
+
+
+pub fn get_file(name: &str) -> FileCacheTuple {
+    //TODO: Add support for range requests
+
+    let f: FileCacheTuple;
+    let mut ve: Vec<u8>;
+    if name.eq("") || name.eq(" ") || name.eq("/") {
+        ve = default_page();
+    } else {
+        ve = match parse_file(name) {
+            Ok(data) => data,
+            Err(err) => Vec::new()
+        };
+    }
+
+    f = FileCacheTuple(ve, SystemTime::now(), 0);
+
+    return f;
+}
+
+
+fn default_page() -> Vec<u8> {
+    let contents = fs::read_to_string("./static/index.html").unwrap_or("Page not found!".parse().unwrap());
+
+    Vec::from(contents)
+}
+
+
+pub fn error_page() -> Vec<u8> {
+    let error_page = fs::read_to_string("./static/not_found.html").unwrap();
+
+    Vec::from(error_page)
+}
+
+
+fn parse_file(path: &str) -> Result<Vec<u8>, ReferaError> {
+     let mut proper_path = path.replace("%20", " ");
+
+
+    let mut file: Vec<u8> = Vec::new();
+    let decoded = decode(path).expect("UTF-8");
+
+    if fs::read_dir("./static".to_owned() + proper_path.as_mut_str()).is_err() { //if not a subdirectory
+        file = fs::read("./static".to_owned() + decoded.as_ref()).map_err(|e| ReferaError::from(e))?;
+    } else { //if the url corresponds to a directory under /static
+        file = fs::read("./static".to_owned() + decoded.as_ref() + "/index.html").map_err(|e| ReferaError::from(e))?; //retrieve the index.html
+    }
+
+    if (proper_path.contains("malandrakisgeo-songs-site-example") && !proper_path.contains(".mp3")) {
+        file = songs_page(file);
+    }
+
+    Ok(file)
+}
+
+
+/*fn parse_song_evolved(path: &str)-> Result<Vec<u8>, ReferaError>{
+    let decoded = decode(path).expect("UTF-8");
+
+    const BUFFER_LEN: usize = 51200;
+    let mut buffer = [0u8; BUFFER_LEN];
+    let mut file = File::open("./static/songs".to_owned()+decoded.as_ref())?;
+    file.read(&mut buffer).unwrap();
+
+    Ok(Vec::from(buffer))
+
+}
+
+pub fn generate_tds(files: ReadDir) -> String {
+    let mut tds_vec = Vec::new();
+
+    for file in files {
+        let data = &file.unwrap();
+        let path = &data.path();
+        let _name = data.file_name();
+        let file_name = _name.to_str().unwrap();
+
+        let date_modified = data.metadata().unwrap().modified().unwrap(); //TODO: fix
+        let dt: DateTime<Utc> = date_modified.clone().into();
+        let showable_datetime = dt.format("%d/%m/%Y"); //%d/%m/%Y %T to show even time
+
+        let file_type = std::path::Path::new(path.as_path()).extension().unwrap_or("unknown_type".as_ref()).to_str().unwrap();
+        let size = &data.metadata().unwrap().size();
+
+        let td = format!("<tr>\n<td><a href=\"songs/{file_name}\">{file_name}</a> </td>\n<td>{showable_datetime}</td>\n<td>{file_type}</td>\n<td>{size}</td>\n</tr>\n");
+        //  let td = format!("<tr>\n<td><a href=\"malandrakisgeo-songs-site-example/songs/{file_name}\">{file_name}</a> </td>\n<td>{showable_datetime}</td>\n<td>{file_type}</td>\n<td>{size}</td>\n</tr>\n");
+
+        tds_vec.append(&mut Vec::from(td));
+    }
+
+    String::from_utf8(tds_vec).unwrap()
+}*/
+

src/content_manager/content_parser.rs

@@ -0,0 +1,2 @@
+pub mod content_parser;
+pub mod song_site;

src/content_manager/mod.rs

@@ -0,0 +1,45 @@
+use std::fs;
+use std::fs::ReadDir;
+use std::os::unix::fs::MetadataExt;
+use chrono::{DateTime, Utc};
+
+/*
+    The reason this project exists. I wanted to improve my Rust skills by writing a server that renders an HTML file with a list of songs,
+    and serves them in demand. But I chose to make it a general purpose web server instead.
+    TODO: Create a separate branch with the song_site
+ */
+
+pub fn songs_page(mut contents: Vec<u8>) -> Vec<u8> {
+    let paths = fs::read_dir("./static/malandrakisgeo-songs-site-example/songs/").unwrap_or(fs::read_dir(".").unwrap());
+    let tds = generate_tds(paths);
+
+    let str = String::from_utf8(contents).unwrap();
+    let content_to_serve = str.replace("{replace_me!}", &tds);
+
+    Vec::from(content_to_serve)
+}
+fn generate_tds(files: ReadDir) -> String {
+    let mut tds_vec = Vec::new();
+
+    for file in files {
+        let data = &file.unwrap();
+        let path = &data.path();
+        let _name = data.file_name();
+        let file_name = _name.to_str().unwrap();
+
+        let date_modified = data.metadata().unwrap().modified().unwrap(); //TODO: fix
+        let dt: DateTime<Utc> = date_modified.clone().into();
+        let showable_datetime = dt.format("%d/%m/%Y"); //%d/%m/%Y %T to show even time
+
+        let file_type = std::path::Path::new(path.as_path()).extension().unwrap_or("unknown_type".as_ref()).to_str().unwrap();
+        let size = &data.metadata().unwrap().size();
+
+        let td = format!("<tr>\n<td><a href=\"songs/{file_name}\">{file_name}</a> </td>\n<td>{showable_datetime}</td>\n<td>{file_type}</td>\n<td>{size}</td>\n</tr>\n");
+        //  let td = format!("<tr>\n<td><a href=\"malandrakisgeo-songs-site-example/songs/{file_name}\">{file_name}</a> </td>\n<td>{showable_datetime}</td>\n<td>{file_type}</td>\n<td>{size}</td>\n</tr>\n");
+
+        tds_vec.append(&mut Vec::from(td));
+    }
+
+    String::from_utf8(tds_vec).unwrap()
+}
+

src/content_manager/song_site.rs

@@ -3,15 +3,17 @@ use std::collections::HashMap;
 use std::io::{BufRead, BufReader, Read, Write};
 use std::net::{TcpListener, TcpStream};
 use std::ops::Add;
+use crate::cache::server_cache;
 use crate::config::Config;
+use crate::content_manager::content_parser;
 use crate::http::http_status::StatusCode;
 use crate::response::refera_response::ReferaResponse;
 
 mod config;
-mod content_parser;
-mod server_cache;
 mod response;
 mod http;
+mod cache;
+mod content_manager;
 
 fn main() {
     let conf = Config::default_config();
@@ -52,8 +54,6 @@ fn handle_http_req(request: &mut TcpStream) {
 
     if method_url.get(0).unwrap().contains("GET") {
         resp = get_reply(method_url.get(1).unwrap(), http_headers.0);
-    } else if method_url.get(0).unwrap().contains("POST") {
-        resp = post_reply(&mut buf_reader, http_headers.0);
     } else {
         resp = ReferaResponse::new(StatusCode::BadRequest, None, Vec::new())
     }
@@ -64,28 +64,18 @@ fn get_reply(url: &str, headers: HashMap<String, String>) -> ReferaResponse {
     let cached_file = server_cache::file_lookup(url);
     if cached_file.is_none(){
         let file = content_parser::get_file(url);
-        if!file.0.is_empty(){
+        return if !file.0.is_empty() {
             server_cache::insert_file(url, &file);
-            return ReferaResponse::new(StatusCode::Ok, None, file.0.clone());
-        }else{
-            return ReferaResponse::new(StatusCode::NotFound, None, content_parser::error_page());
+            ReferaResponse::new(StatusCode::Ok, None, file.0.clone())
+        } else {
+            ReferaResponse::new(StatusCode::NotFound, None, content_parser::error_page())
         }
     }
 
     ReferaResponse::new(StatusCode::Ok, None, cached_file.unwrap().0.clone())
 }
 
 
-fn post_reply(buf_reader: &mut BufReader<TcpStream>, headers: HashMap<String, String>) -> ReferaResponse {  //WIP - TODO
-    let content_length_str = headers.get_key_value("Content-Length").unwrap().1;
-    let mut buffer: Vec<u8> = vec![0; content_length_str.trim().parse::<usize>().unwrap()];
-    buf_reader.read_exact(&mut buffer).unwrap();
-
-    //let result = content_parser::post_content(buffer.clone(), "aa");
-
-    ReferaResponse::new(StatusCode::Ok, None, Vec::new())
-}
-
 fn determine_headers(vector: &Vec<String>) -> (HashMap<String, String>, String) {
     let mut header_map = HashMap::new();
 
@@ -104,16 +94,7 @@ fn determine_headers(vector: &Vec<String>) -> (HashMap<String, String>, String)
 
 
 
-/*fn read(stream: &mut TcpStream) {
-    let mut buf = vec![0; 1024];
-    println!("Received {} bytes", stream.read(&mut buf).unwrap());
-    let resp = ReferaResponse::new(StatusCode::Ok, None, Vec::new());
-    stream.write_all(resp.as_u8().as_slice()).unwrap();
-}
-
-
-
-
+/*
 
     This causes the request to stack. Why?
     According to stackoverflow, "read_to_string reads into String until EOF which will not happen until you close the stream from the writer side."

src/content_parser.rs

@@ -0,0 +1,13 @@
+<!DOCTYPE html>
+<html lang="en">
+<head>
+    <meta charset="UTF-8">
+    <title>default</title>
+</head>
+<body>
+
+    <p>Serve your static website by adding it ./static. It can be a subfolder or a replacement of all contents. The server looks up for an index.html </p>
+    <p><a href="malandrakisgeo-songs-site-example/index.html"><< Sample website</a></p>
+
+</body>
+</html>