Avii/webserver
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Split some shit to files to satisfy Veldmuizie

Browse Source
This commit is contained in:
Avii
2025-01-28 13:24:27 +01:00
parent d765dd9404
commit 1b27506149
4 changed files with 346 additions and 349 deletions
Download Patch File Download Diff File Expand all files Collapse all files

163
src/index.rs Normal file
View File

@@ -0,0 +1,163 @@
mod filters;
use std::{path::PathBuf, str::FromStr, sync::LazyLock};
use filters::*;
use tera::{Context, Tera};
use time::OffsetDateTime;
use tokio::time::Instant;
use tokio_stream::{wrappers::ReadDirStream, StreamExt};
use crate::{icon::extract_icon, AResult, FileInfo, BASE_DIR};
pub static TERA: LazyLock<Tera> = LazyLock::new(|| {
let mut tera = Tera::default();
tera.add_raw_template(
"index.html.jinja",
include_str!("../templates/index.html.jinja"),
)
.unwrap();
tera.register_filter("iconize", iconize);
tera.register_filter("from_ico", from_ico);
tera.register_filter("size", size);
tera.register_filter("time", time);
tera.register_filter("md", md);
tera
});
pub async fn render_index(path: &PathBuf, time: Instant) -> AResult<String> {
let time2 = Instant::now();
let base = BASE_DIR.display().to_string();
let dirname = path
.display()
.to_string()
.replace(&base, "")
.replace('\\', "/");
let filename = path.file_name().unwrap().to_string_lossy().to_string();
let description = PathBuf::from_str(&format!(
"{}/.{}.info",
path.parent().unwrap().to_string_lossy(),
filename
))?;
let description = if description.exists() {
Some(std::fs::read_to_string(description)?)
} else {
None
};
let directories = get_directories(path).await?;
let files = get_files(path).await?;
let tera = &*TERA;
let mut context = Context::new();
context.insert("description", &description);
context.insert("dirname", &dirname);
context.insert("directories", &directories);
context.insert("files", &files);
let loading = time2.elapsed() + time.elapsed();
context.insert("loading", &loading.as_millis());
Ok(tera.render("index.html.jinja", &context)?)
}
async fn get_directories(path: &PathBuf) -> AResult<Vec<FileInfo>> {
let mut contents = ReadDirStream::new(tokio::fs::read_dir(&path).await?);
let mut files = vec![];
while let Some(file) = contents.next().await {
let file = file?;
let metadata = file.metadata().await?;
if !metadata.is_dir() {
continue;
}
let filename = file.file_name().to_string_lossy().to_string();
if filename.starts_with('.') {
continue;
}
// let created: OffsetDateTime = metadata.created()?.into();
let modified: OffsetDateTime = metadata.modified()?.into();
let description = PathBuf::from_str(&format!(
"{}/.{}.info",
file.path().parent().unwrap().to_string_lossy(),
filename
))?;
let description = if description.exists() {
Some(std::fs::read_to_string(description)?)
} else {
None
};
files.push(FileInfo {
filename,
format: "DIR".to_string(),
size: 0,
icon: None,
// created,
modified,
description,
});
}
Ok(files)
}
async fn get_files(path: &PathBuf) -> AResult<Vec<FileInfo>> {
let mut contents = ReadDirStream::new(tokio::fs::read_dir(&path).await?);
let mut files = vec![];
while let Some(file) = contents.next().await {
let file = file?;
let metadata = file.metadata().await?;
if metadata.is_dir() {
continue;
}
let filename = file.file_name().to_string_lossy().to_string();
if filename.starts_with('.') {
continue;
}
let format = file_format::FileFormat::from_file(file.path())?;
let format = format.media_type();
let icon = if format == "application/x-dosexec" {
// ..
extract_icon(&file.path()).ok().flatten()
} else {
None
};
// let created: OffsetDateTime = metadata.created()?.into();
let modified: OffsetDateTime = metadata.modified()?.into();
let description = PathBuf::from_str(&format!(
"{}/.{}.info",
file.path().parent().unwrap().to_string_lossy(),
filename
))?;
let description = if description.exists() {
Some(std::fs::read_to_string(description)?)
} else {
None
};
files.push(FileInfo {
filename,
format: format.to_string(),
size: metadata.len() as usize,
icon,
// created,
modified,
description,
});
}
Ok(files)
}

119
src/index/filters.rs Normal file
View File

@@ -0,0 +1,119 @@
use std::{collections::HashMap, sync::LazyLock};
use base64::{prelude::BASE64_STANDARD, Engine};
use tera::{to_value, Result as TeraResult, Value};
use time::OffsetDateTime;
pub static ICONS: LazyLock<HashMap<&str, String>> = LazyLock::new(|| {
let mut map = HashMap::new();
map.insert(
"unknown",
BASE64_STANDARD.encode(include_bytes!("../../icons/unknown.png")),
);
map.insert(
"back",
BASE64_STANDARD.encode(include_bytes!("../../icons/back.png")),
);
map.insert(
"dir",
BASE64_STANDARD.encode(include_bytes!("../../icons/dir.png")),
);
map.insert(
"binary",
BASE64_STANDARD.encode(include_bytes!("../../icons/binary.png")),
);
map.insert(
"image",
BASE64_STANDARD.encode(include_bytes!("../../icons/image2.png")),
);
map.insert(
"compressed",
BASE64_STANDARD.encode(include_bytes!("../../icons/compressed.png")),
);
map
});
pub fn iconize(value: &Value, _args: &HashMap<String, Value>) -> TeraResult<Value> {
let icon = value.as_str().unwrap_or("unknown");
let icon = match icon {
"DIR" | "BACK" => "dir",
"image/png" | "image/jpg" | "image/webp" => "image",
"application/zip" => "compressed",
"application/octet-stream" => "binary",
_ => "unknown",
};
let icons = &*ICONS;
let icon = if icons.contains_key(icon) {
&icons[icon]
} else {
println!("Unknown filetype: {}", icon);
&icons["unknown"]
};
let str = format!("<img src=\"data:image/png;base64,{}\" alt=\"\" />", icon);
Ok(to_value(str).unwrap())
}
pub fn from_ico(value: &Value, _args: &HashMap<String, Value>) -> TeraResult<Value> {
let Some(icon) = value.as_array() else {
return iconize(
&Value::String(String::from("")),
&std::default::Default::default(),
);
};
let icon = icon
.iter()
.map(|n| n.as_u64().unwrap() as u8)
.collect::<Vec<_>>();
let data = BASE64_STANDARD.encode(icon);
let str = format!("<img src=\"data:image/png;base64,{}\" alt=\"\"/>", data);
Ok(to_value(str).unwrap())
}
pub fn size(value: &Value, _args: &HashMap<String, Value>) -> TeraResult<Value> {
let Some(value) = value.as_f64() else {
return Ok(value.clone());
};
Ok(to_value(human_bytes::human_bytes(value)).unwrap())
}
pub fn time(value: &Value, _args: &HashMap<String, Value>) -> TeraResult<Value> {
let time_format: std::vec::Vec<time::format_description::FormatItem<'_>> =
time::format_description::parse("[day]-[month]-[year] [hour]:[minute]:[second]").unwrap();
let Some(time) = value.as_array() else {
return Ok(value.clone());
};
let time: Vec<i64> = time.iter().map(|v| v.as_i64().unwrap()).collect();
let new_time: OffsetDateTime = OffsetDateTime::now_utc();
let new_time = new_time.replace_year(time[0] as i32).unwrap();
let new_time = new_time.replace_ordinal(time[1] as u16).unwrap();
let new_time = new_time.replace_hour(time[2] as u8).unwrap();
let new_time = new_time.replace_minute(time[3] as u8).unwrap();
let new_time = new_time.replace_second(time[4] as u8).unwrap();
let new_time = new_time.replace_nanosecond(time[5] as u32).unwrap();
Ok(to_value(new_time.format(&time_format).unwrap()).unwrap())
}
pub fn md(value: &Value, _args: &HashMap<String, Value>) -> TeraResult<Value> {
// parse value as markdown and return html
if let Some(value) = value.as_str() {
if let Ok(md) = markdown::to_html_with_options(value, &markdown::Options::gfm()) {
return Ok(to_value(md).unwrap());
}
}
Ok(to_value(value).unwrap())
}

59
src/lua.rs Normal file
View File

@@ -0,0 +1,59 @@
use std::sync::LazyLock;
use mlua::Lua;
use crate::AResult;
pub static LUA_CPATH: LazyLock<String> = LazyLock::new(|| {
String::from_utf8_lossy(
&std::process::Command::new("luarocks")
.arg("path")
.arg("--lr-cpath")
.arg("--full")
.output()
.map_err::<std::vec::Vec<u8>, _>(|_| vec![])
.map(|r| r.stdout)
.unwrap_or_default(),
)
.trim()
.to_string()
});
pub static LUA_PATH: LazyLock<String> = LazyLock::new(|| {
String::from_utf8_lossy(
&std::process::Command::new("luarocks")
.arg("path")
.arg("--lr-path")
.arg("--full")
.output()
.map_err::<std::vec::Vec<u8>, _>(|_| vec![])
.map(|r| r.stdout)
.unwrap_or_default(),
)
.trim()
.to_string()
});
pub struct LuaHandler {
lua: Lua,
}
impl LuaHandler {
pub fn new() -> AResult<Self> {
let lua = unsafe { Lua::unsafe_new() };
let this = Self { lua };
this.exec(&format!(
"package.path = \"{}\"\npackage.cpath = \"{}\"",
&*LUA_PATH, &*LUA_CPATH
))?;
Ok(this)
}
pub fn exec(&self, blob: &str) -> AResult<()> {
self.lua.load(blob).exec()?;
Ok(())
}
}

354
src/main.rs
View File

@@ -1,8 +1,9 @@
mod icon;
mod index;
// mod lua;
use std::{collections::HashMap, fs, io::ErrorKind, path::PathBuf, str::FromStr, sync::LazyLock};
use icon::extract_icon;
use mlua::{
Lua, Number, Table,
Value::{self as LuaValue},
@@ -15,12 +16,9 @@ use axum::{
response::{Html, IntoResponse},
routing::get,
};
use base64::prelude::*;
use serde::Serialize;
use tera::{to_value, Context, Result as TeraResult, Tera, Value};
use time::OffsetDateTime;
use tokio::time::Instant;
use tokio_stream::{wrappers::ReadDirStream, StreamExt};
use tower_http::services::ServeDir;
pub type AError = Box<dyn std::error::Error>;
@@ -28,165 +26,6 @@ pub type AResult<T> = Result<T, AError>;
pub static CWD: LazyLock<PathBuf> = LazyLock::new(|| std::env::current_dir().unwrap());
// use reqwest::Method;
// #[derive(Debug, Clone)]
// struct ArrayBuffer(Vec<u8>);
// impl mlua::FromLua for ArrayBuffer {
// fn from_lua(value: LuaValue, _: &Lua) -> mlua::Result<Self> {
// if let Some(data) = value.as_str() {
// return Ok(Self(data.as_bytes().to_owned()));
// }
// if let Some(data) = value.as_table() {
// let mut out = vec![];
// for pair in data.pairs::<mlua::Value, mlua::Value>() {
// let (_, v) = pair?;
// if let Some(value) = v.as_integer() {
// out.push(value as u8);
// }
// }
// return Ok(Self(out));
// }
// Err(mlua::Error::FromLuaConversionError {
// from: value.type_name(),
// to: "ArrayBuffer".to_string(),
// message: None,
// })
// }
// }
pub static TERA: LazyLock<Tera> = LazyLock::new(|| {
let mut tera = Tera::default();
tera.add_raw_template(
"index.html.jinja",
include_str!("../templates/index.html.jinja"),
)
.unwrap();
tera.register_filter("iconize", iconize);
tera.register_filter("from_ico", from_ico);
tera.register_filter("size", size);
tera.register_filter("time", time);
tera.register_filter("md", md);
tera
});
pub static ICONS: LazyLock<HashMap<&str, String>> = LazyLock::new(|| {
let mut map = HashMap::new();
map.insert(
"unknown",
BASE64_STANDARD.encode(include_bytes!("../icons/unknown.png")),
);
map.insert(
"back",
BASE64_STANDARD.encode(include_bytes!("../icons/back.png")),
);
map.insert(
"dir",
BASE64_STANDARD.encode(include_bytes!("../icons/dir.png")),
);
map.insert(
"binary",
BASE64_STANDARD.encode(include_bytes!("../icons/binary.png")),
);
map.insert(
"image",
BASE64_STANDARD.encode(include_bytes!("../icons/image2.png")),
);
map.insert(
"compressed",
BASE64_STANDARD.encode(include_bytes!("../icons/compressed.png")),
);
map
});
fn from_ico(value: &Value, _args: &HashMap<String, Value>) -> TeraResult<Value> {
let Some(icon) = value.as_array() else {
return iconize(
&Value::String(String::from("")),
&std::default::Default::default(),
);
};
let icon = icon
.iter()
.map(|n| n.as_u64().unwrap() as u8)
.collect::<Vec<_>>();
let data = BASE64_STANDARD.encode(icon);
let str = format!("<img src=\"data:image/png;base64,{}\" alt=\"\"/>", data);
Ok(to_value(str).unwrap())
}
fn iconize(value: &Value, _args: &HashMap<String, Value>) -> TeraResult<Value> {
let icon = value.as_str().unwrap_or("unknown");
let icon = match icon {
"DIR" | "BACK" => "dir",
"image/png" | "image/jpg" | "image/webp" => "image",
"application/zip" => "compressed",
"application/octet-stream" => "binary",
_ => "unknown",
};
let icons = &*ICONS;
let icon = if icons.contains_key(icon) {
&icons[icon]
} else {
println!("Unknown filetype: {}", icon);
&icons["unknown"]
};
let str = format!("<img src=\"data:image/png;base64,{}\" alt=\"\" />", icon);
Ok(to_value(str).unwrap())
}
fn size(value: &Value, _args: &HashMap<String, Value>) -> TeraResult<Value> {
let Some(value) = value.as_f64() else {
return Ok(value.clone());
};
Ok(to_value(human_bytes::human_bytes(value)).unwrap())
}
fn time(value: &Value, _args: &HashMap<String, Value>) -> TeraResult<Value> {
let time_format: std::vec::Vec<time::format_description::FormatItem<'_>> =
time::format_description::parse("[day]-[month]-[year] [hour]:[minute]:[second]").unwrap();
let Some(time) = value.as_array() else {
return Ok(value.clone());
};
let time: Vec<i64> = time.iter().map(|v| v.as_i64().unwrap()).collect();
let new_time: OffsetDateTime = OffsetDateTime::now_utc();
let new_time = new_time.replace_year(time[0] as i32).unwrap();
let new_time = new_time.replace_ordinal(time[1] as u16).unwrap();
let new_time = new_time.replace_hour(time[2] as u8).unwrap();
let new_time = new_time.replace_minute(time[3] as u8).unwrap();
let new_time = new_time.replace_second(time[4] as u8).unwrap();
let new_time = new_time.replace_nanosecond(time[5] as u32).unwrap();
Ok(to_value(new_time.format(&time_format).unwrap()).unwrap())
}
fn md(value: &Value, _args: &HashMap<String, Value>) -> TeraResult<Value> {
// parse value as markdown and return html
if let Some(value) = value.as_str() {
if let Ok(md) = markdown::to_html_with_options(value, &markdown::Options::gfm()) {
return Ok(to_value(md).unwrap());
}
}
Ok(to_value(value).unwrap())
}
pub static LUA_CPATH: LazyLock<String> = LazyLock::new(|| {
String::from_utf8_lossy(
&std::process::Command::new("luarocks")
@@ -227,53 +66,10 @@ struct FileInfo {
size: usize,
format: String,
icon: Option<Vec<u8>>,
// created: OffsetDateTime,
modified: OffsetDateTime,
description: Option<String>,
}
// #[derive(Debug, Clone)]
// struct FetchOptions {
// method: String,
// headers: HashMap<String, String>,
// body: Option<ArrayBuffer>,
// }
// impl Default for FetchOptions {
// fn default() -> Self {
// Self {
// method: "GET".to_string(),
// headers: HashMap::new(),
// body: None,
// }
// }
// }
// impl mlua::FromLua for FetchOptions {
// fn from_lua(value: LuaValue, _lua: &Lua) -> mlua::Result<Self> {
// let Some(options) = value.as_table() else {
// return Err(mlua::Error::FromLuaConversionError {
// from: value.type_name(),
// to: "FetchOptions".to_string(),
// message: Some("options must be a table".to_string()),
// });
// };
// let mut result = FetchOptions::default();
// if let Ok(method) = options.get::<String>("method") {
// result.method = method;
// }
// if let Ok(headers) = options.get::<HashMap<String, String>>("headers") {
// result.headers = headers;
// }
// if let Ok(body) = options.get::<Option<ArrayBuffer>>("body") {
// result.body = body;
// }
// Ok(result)
// }
// }
#[tokio::main]
async fn main() -> AResult<()> {
let listener = tokio::net::TcpListener::bind("[::]:3000").await.unwrap();
@@ -283,12 +79,9 @@ async fn main() -> AResult<()> {
async fn file_handler(request: Request) -> impl IntoResponse {
std::env::set_current_dir(&*CWD).unwrap();
// let base_dir: &PathBuf = BASE_DIR.get_or_init(|| {
// PathBuf::from_str(&std::env::var("BASE_DIR").unwrap_or(String::from("./public"))).unwrap()
// });
let base_dir = BASE_DIR.canonicalize().map_err(|e| {
dbg!(e);
eprintln!("{:#?}", e);
(StatusCode::NOT_FOUND, "404: Not Found".to_string())
})?;
@@ -296,8 +89,7 @@ async fn file_handler(request: Request) -> impl IntoResponse {
if request_uri_path.ends_with("/") {
let mut a = base_dir.clone();
a.push(".".to_owned() + &request_uri_path);
a.push("init.lua");
a.push(format!(".{}/{}", &request_uri_path, "init.lua"));
if let Ok(b) = a.canonicalize() {
if b.exists() {
request_uri_path += "init.lua";
@@ -639,7 +431,7 @@ async fn handler(request: Request) -> Result<Html<String>, (StatusCode, String)>
return Err((StatusCode::BAD_REQUEST, "400: Bad Request".to_string()));
}
let body = match render_dir(&path, start).await {
let body = match crate::index::render_index(&path, start).await {
Ok(body) => Ok(body),
Err(e) => {
let ioerror: Option<&std::io::Error> = e.downcast_ref();
@@ -659,139 +451,3 @@ async fn handler(request: Request) -> Result<Html<String>, (StatusCode, String)>
Ok(Html(body?))
}
async fn render_dir(path: &PathBuf, time: Instant) -> AResult<String> {
let time2 = Instant::now();
let base = BASE_DIR.display().to_string();
let dirname = path
.display()
.to_string()
.replace(&base, "")
.replace('\\', "/");
let filename = path.file_name().unwrap().to_string_lossy().to_string();
let description = PathBuf::from_str(&format!(
"{}/.{}.info",
path.parent().unwrap().to_string_lossy(),
filename
))?;
let description = if description.exists() {
Some(fs::read_to_string(description)?)
} else {
None
};
let directories = get_directories(path).await?;
let files = get_files(path).await?;
let tera = &*TERA;
let mut context = Context::new();
context.insert("description", &description);
context.insert("dirname", &dirname);
context.insert("directories", &directories);
context.insert("files", &files);
let loading = time2.elapsed() + time.elapsed();
context.insert("loading", &loading.as_millis());
Ok(tera.render("index.html.jinja", &context)?)
}
async fn get_directories(path: &PathBuf) -> AResult<Vec<FileInfo>> {
let mut contents = ReadDirStream::new(tokio::fs::read_dir(&path).await?);
let mut files = vec![];
while let Some(file) = contents.next().await {
let file = file?;
let metadata = file.metadata().await?;
if !metadata.is_dir() {
continue;
}
let filename = file.file_name().to_string_lossy().to_string();
if filename.starts_with('.') {
continue;
}
// let created: OffsetDateTime = metadata.created()?.into();
let modified: OffsetDateTime = metadata.modified()?.into();
let description = PathBuf::from_str(&format!(
"{}/.{}.info",
file.path().parent().unwrap().to_string_lossy(),
filename
))?;
let description = if description.exists() {
Some(fs::read_to_string(description)?)
} else {
None
};
files.push(FileInfo {
filename,
format: "DIR".to_string(),
size: 0,
icon: None,
// created,
modified,
description,
});
}
Ok(files)
}
async fn get_files(path: &PathBuf) -> AResult<Vec<FileInfo>> {
let mut contents = ReadDirStream::new(tokio::fs::read_dir(&path).await?);
let mut files = vec![];
while let Some(file) = contents.next().await {
let file = file?;
let metadata = file.metadata().await?;
if metadata.is_dir() {
continue;
}
let filename = file.file_name().to_string_lossy().to_string();
if filename.starts_with('.') {
continue;
}
let format = file_format::FileFormat::from_file(file.path())?;
let format = format.media_type();
let icon = if format == "application/x-dosexec" {
// ..
extract_icon(&file.path()).ok().flatten()
} else {
None
};
// let created: OffsetDateTime = metadata.created()?.into();
let modified: OffsetDateTime = metadata.modified()?.into();
let description = PathBuf::from_str(&format!(
"{}/.{}.info",
file.path().parent().unwrap().to_string_lossy(),
filename
))?;
let description = if description.exists() {
Some(fs::read_to_string(description)?)
} else {
None
};
files.push(FileInfo {
filename,
format: format.to_string(),
size: metadata.len() as usize,
icon,
// created,
modified,
description,
});
}
Ok(files)
}