Add direnv

2024-08-28 15:15:03 -07:00
28 changed files with 1036 additions and 1104 deletions
--- a/.envrc
+++ b/.envrc
@ -0,0 +1 @@
+use flake
--- a/.gitignore
+++ b/.gitignore
@ -1,3 +1,4 @@
 /target
 .DS_Store
 /.cache
+.direnv
--- a/.rustfmt.toml
+++ b/.rustfmt.toml
@ -1 +0,0 @@
-edition = "2021"
--- a/Cargo.lock
+++ b/Cargo.lock
--- a/Cargo.toml
+++ b/Cargo.toml
@ -8,42 +8,24 @@ edition = "2021"

 [dependencies]
 async-bincode = { version = "0.7.0", features = ["tokio"] }
-async-trait = "0.1.81"
-async_zip = { version = "0.0.17", features = [
-  "deflate",
-  "tokio",
-  "tokio-fs",
-  "async-compression",
-] }
-http-body-util = "0.1.2"
-axum = { version = "0.7.5", features = [
-  "multipart",
-  "http2",
-  "macros",
-  "original-uri",
-] }
-axum-extra = { version = "0.9.0", features = ["typed-header"] }
+async-trait = "0.1.72"
+async_zip = { version = "0.0.13", features = ["deflate", "tokio", "tokio-fs", "async-compression"] }
+axum = { version = "0.6.12", features = ["multipart", "http2", "headers", "macros", "original-uri"] }
 bincode = "1.3.3"
 chrono = { version = "0.4.24", features = ["serde"] }
 futures = "0.3.28"
-headers = "0.4.0"
-leptos = { version = "0.6.14", features = [
-  "ssr",
-  "nightly",
-  "tracing",
-  "default-tls",
-  "experimental-islands",
-] }
-leptos_meta = { version = "0.6.14", features = ["ssr"] }
-leptos_router = { version = "0.6.14", features = ["ssr"] }
+headers = "0.3.8"
+leptos = { version = "0.4.6", features = ["ssr", "nightly", "tracing", "default-tls"] }
+leptos_meta = { version = "0.4.6", features = ["ssr"] }
+leptos_router = { version = "0.4.6", features = ["ssr"] }
 rand = { version = "0.8.5", features = ["small_rng"] }
-reqwest = { version = "0.12.7", features = ["json", "native-tls", "blocking"] }
+reqwest = { version = "0.11.18", features = ["json", "native-tls", "blocking"] }
 sanitize-filename-reader-friendly = "2.2.1"
 serde = { version = "1.0.160", features = ["serde_derive", "derive"] }
 serde_derive = "1.0.160"
 tokio = { version = "1.27.0", features = ["full"] }
 tokio-util = { version = "0.7.7", features = ["io"] }
-tower = { version = "0.5.0", features = ["util"] }
-tower-http = { version = "0.5.0", features = ["fs", "trace", "limit"] }
+tower = { version = "0.4.13", features = ["util"] }
+tower-http = { version = "0.4.0", features = ["fs", "trace", "limit"] }
 tracing = "0.1.37"
 tracing-subscriber = { version = "0.3.16", features = ["env-filter"] }
--- a/dist/link.html
+++ b/dist/link.html
@ -0,0 +1,45 @@
+<!DOCTYPE html>
+<html lang="en">
+
+<head>
+    <title></title>
+    <meta charset="UTF-8">
+    <meta name="viewport" content="width=device-width, initial-scale=1">
+    <link href="css/link.css" rel="stylesheet">
+
+    <script>
+        document.addEventListener("DOMContentLoaded", () => {
+            const params = new Proxy(new URLSearchParams(window.location.search), {
+                get: (searchParams, prop) => searchParams.get(prop),
+            });
+
+
+            if (params.link !== null) {
+                let link = `${window.location.origin}/download/${params.link}`;
+
+                let link_el = document.getElementById("link");
+
+                link_el.href = link;
+                link_el.innerHTML = link;
+            }
+        });
+
+        function clipboard() {
+            let copyText = document.getElementById("link");
+
+            navigator.clipboard.writeText(copyText.href).then(() => alert("Copied: " + copyText.href));
+        }
+    </script>
+</head>
+
+<body>
+    <div class="link-wrapper">
+        <a id="link" href=""></a>
+    </div>
+
+    <button class="return-button" onclick="clipboard()">Copy to Clipboard</button>
+
+    <a href="/" class="return-button">Return to home</a>
+</body>
+
+</html>
--- a/dist/scripts/cat_fact_fetcher.js
+++ b/dist/scripts/cat_fact_fetcher.js
@ -0,0 +1,5 @@
+fetch("https://catfact.ninja/fact")
+  .then(data => data.json())
+  .then(data => {
+    document.getElementById("cat-fact").innerHTML = data.fact;
+  });
--- a/dist/scripts/link.js
+++ b/dist/scripts/link.js
@ -1,3 +1,19 @@
+document.addEventListener("DOMContentLoaded", () => {
+  const params = new Proxy(new URLSearchParams(window.location.search), {
+    get: (searchParams, prop) => searchParams.get(prop),
+  });
+
+
+  if (params.link !== null) {
+    let link = `${window.location.origin}/download/${params.link}`;
+
+    let link_el = document.getElementById("link");
+
+    link_el.href = link;
+    link_el.innerHTML = link;
+  }
+});
+
 function clipboard() {
  let copyText = document.getElementById("link");

--- a/leptosfmt.toml
+++ b/leptosfmt.toml
@ -1,2 +0,0 @@
-[attr_values]
-class = "Tailwind" # "Tailwind" is the only attribute value formatter available for now
--- a/rust-analyzer.toml
+++ b/rust-analyzer.toml
@ -1,2 +0,0 @@
-[rustfmt]
-overrideCommand = ["leptosfmt", "--stdin", "--rustfmt"]
--- a/src/cache.rs
+++ b/src/cache.rs
@ -1,5 +1,7 @@
 use crate::state::AppState;

+use super::error;
+
 use serde::Serialize;
 use tokio::io::AsyncReadExt;

@ -15,7 +17,7 @@ where
    let mut records_cache = tokio::fs::File::create(".cache/data").await.unwrap();

    let mut buf: Vec<u8> = Vec::with_capacity(200);
-    bincode::serialize_into(&mut buf, records).map_err(io::Error::other)?;
+    bincode::serialize_into(&mut buf, records).map_err(|err| error::io_other(&err.to_string()))?;

    let bytes_written = tokio::io::copy(&mut buf.as_slice(), &mut records_cache).await?;

--- a/src/main.rs
+++ b/src/main.rs
@ -1,83 +1,329 @@
-use axum::{
-    extract::{ConnectInfo, Request},
-    middleware::{self, Next},
-    response::{Html, IntoResponse},
-    routing::get,
-    Router,
-};
-use axum_extra::TypedHeader;
-use tower_http::{services::ServeDir, trace::TraceLayer};
+use async_zip::{tokio::write::ZipFileWriter, Compression, ZipEntryBuilder};

-use std::{io, net::SocketAddr};
+use axum::{
+    body::StreamBody,
+    extract::{ConnectInfo, DefaultBodyLimit, Multipart, State},
+    http::{Request, Response, StatusCode},
+    middleware::{self, Next},
+    response::{Html, IntoResponse, Redirect},
+    routing::{get, post},
+    Json, Router, TypedHeader,
+};
+
+use futures::TryStreamExt;
+
+use headers::HeaderMap;
+use leptos::IntoView;
+use nyazoom_headers::ForwardedFor;
+
+use sanitize_filename_reader_friendly::sanitize;
+
+use std::{io, net::SocketAddr, path::Path, time::Duration};
+
+use tokio_util::{
+    compat::FuturesAsyncWriteCompatExt,
+    io::{ReaderStream, StreamReader},
+};
+
+use tower_http::{limit::RequestBodyLimitLayer, services::ServeDir, trace::TraceLayer};
+
+use tracing_subscriber::{layer::SubscriberExt, util::SubscriberInitExt};

 mod cache;
-mod router;
+mod nyazoom_headers;
 mod state;
 mod util;
 mod views;

-use util::{headers::ForwardedFor, logging, ssr, sweeper};
+use state::{AppState, UploadRecord};

-use router::*;
-use state::*;
-use views::*;
+use crate::state::AsyncRemoveRecord;
+use crate::views::{DownloadLinkPage, HtmxPage, LinkView, Welcome};
+
+pub mod error {
+    use std::io::{Error, ErrorKind};
+
+    pub fn io_other(s: &str) -> Error {
+        Error::new(ErrorKind::Other, s)
+    }
+}

 #[tokio::main]
 async fn main() -> io::Result<()> {
-    logging::init_tracing();
+    // Set up logging
+    tracing_subscriber::registry()
+        .with(
+            tracing_subscriber::EnvFilter::try_from_default_env()
+                .unwrap_or_else(|_| "nyazoom=debug,tower_http=debug".into()),
+        )
+        .with(tracing_subscriber::fmt::layer())
+        .init();

    // uses create_dir_all to create both .cache and serve inside it in one go
    util::make_dir(".cache/serve").await?;

    let state = cache::fetch_cache().await;

-    sweeper::spawn(state.clone());
+    // Spawn a repeating task that will clean files periodically
+    tokio::spawn({
+        let state = state.clone();
+        async move {
+            loop {
+                tokio::time::sleep(Duration::from_secs(15 * 60)).await;
+                tracing::info!("Cleaning Sweep!");
+
+                let mut records = state.records.lock().await;
+
+                for (key, record) in records.clone().into_iter() {
+                    if !record.can_be_downloaded() {
+                        tracing::info!("culling: {:?}", record);
+                        records.remove_record(&key).await.unwrap();
+                    }
+                }
+            }
+        }
+    });

    // Router Setup
    let app = Router::new()
        .route("/", get(welcome))
-        .nest("/download", get_download_router())
-        .nest("/upload", get_upload_router())
-        .nest("/records", get_records_router())
-        .nest("/link", get_link_router())
+        .route("/upload", post(upload_to_zip))
+        .route("/records", get(records))
+        .route("/records/links", get(records_links))
+        .route("/download/:id", get(download))
+        .route("/link/:id", get(link).delete(link_delete))
+        .route("/link/:id/remaining", get(remaining))
+        .layer(DefaultBodyLimit::disable())
+        .layer(RequestBodyLimitLayer::new(
+            10 * 1024 * 1024 * 1024, // 10GiB
+        ))
        .with_state(state)
        .fallback_service(ServeDir::new("dist"))
        .layer(TraceLayer::new_for_http())
        .layer(middleware::from_fn(log_source));

-    serve(app).await;
+    // Server creation
+    let addr = SocketAddr::from(([0, 0, 0, 0], 3000));
+    tracing::debug!("listening on http://{}/", addr);
+    axum::Server::bind(&addr)
+        .serve(app.into_make_service_with_connect_info::<SocketAddr>())
+        .await
+        .unwrap();

    Ok(())
 }

+async fn remaining(
+    State(state): State<AppState>,
+    axum::extract::Path(id): axum::extract::Path<String>,
+) -> impl IntoResponse {
+    let records = state.records.lock().await;
+    if let Some(record) = records.get(&id) {
+        let downloads_remaining = record.downloads_remaining();
+        let plural = if downloads_remaining > 1 { "s" } else { "" };
+        let out = format!(
+            "You have {} download{} remaining!",
+            downloads_remaining, plural
+        );
+        Html(out)
+    } else {
+        Html("?".to_string())
+    }
+}
+
 async fn welcome() -> impl IntoResponse {
-    let fact = views::get_cat_fact().await;
-    Html(ssr::render(move || {
-        leptos::view! { <WelcomePage fact /> }
+    let cat_fact = views::get_cat_fact().await;
+    Html(leptos::ssr::render_to_string(move |cx| {
+        leptos::view! { cx, <Welcome fact=cat_fact /> }
    }))
 }

-async fn log_source(
+async fn records(State(state): State<AppState>) -> impl IntoResponse {
+    Json(state.records.lock().await.clone())
+}
+
+// This function is to remain ugly until that time in which I properly hide
+// this behind some kind of authentication
+async fn records_links(State(state): State<AppState>) -> impl IntoResponse {
+    let records = state.records.lock().await.clone();
+    Html(leptos::ssr::render_to_string(move |cx| {
+        leptos::view! { cx,
+            <HtmxPage>
+                <div class="form-wrapper">
+                    <div class="column-container">
+                        <ul>
+                            {records.keys().map(|key| leptos::view! { cx,
+                                        <li class="link-wrapper">
+                                            <a href="/link/{key}">{key}</a>
+                                            <button style="margin-left: 1em;"
+                                                hx-target="closest .link-wrapper"
+                                                hx-swap="outerHTML"
+                                                hx-delete="/link/{key}">X</button>
+                                        </li>
+                                    })
+                                .collect::<Vec<_>>()}
+                        </ul>
+                    </div>
+                </div>
+            </HtmxPage>
+        }
+    }))
+}
+
+async fn link(
+    axum::extract::Path(id): axum::extract::Path<String>,
+    State(mut state): State<AppState>,
+) -> Result<Html<String>, Redirect> {
+    {
+        let mut records = state.records.lock().await;
+
+        if let Some(record) = records
+            .get_mut(&id)
+            .filter(|record| record.can_be_downloaded())
+        {
+            if record.can_be_downloaded() {
+                return Ok(Html(leptos::ssr::render_to_string({
+                    let record = record.clone();
+                    |cx| {
+                        leptos::view! { cx, <DownloadLinkPage id=id record=record /> }
+                    }
+                })));
+            }
+        }
+    }
+
+    // TODO: This....
+    state.remove_record(&id).await.unwrap();
+
+    Err(Redirect::to(&format!("/404.html")))
+}
+
+async fn link_delete(
+    axum::extract::Path(id): axum::extract::Path<String>,
+    State(mut state): State<AppState>,
+) -> Result<Html<String>, (StatusCode, String)> {
+    state
+        .remove_record(&id)
+        .await
+        .map_err(|err| (StatusCode::INTERNAL_SERVER_ERROR, err.to_string()))?;
+
+    Ok(Html("".to_string()))
+}
+
+async fn log_source<B>(
    ConnectInfo(addr): ConnectInfo<SocketAddr>,
    forwarded_for: Option<TypedHeader<ForwardedFor>>,
-    req: Request,
-    next: Next,
+    req: Request<B>,
+    next: Next<B>,
 ) -> impl IntoResponse {
    tracing::info!("{} : {:?}", addr, forwarded_for);

    next.run(req).await
 }

-async fn serve(app: Router) {
-    // // Server creation
-    let addr = SocketAddr::from(([0, 0, 0, 0], 3000));
-    let listener = tokio::net::TcpListener::bind(&addr).await.unwrap();
-    axum::serve(
-        listener,
-        app.into_make_service_with_connect_info::<SocketAddr>(),
-    )
+async fn upload_to_zip(
+    State(state): State<AppState>,
+    mut body: Multipart,
+) -> Result<Response<String>, (StatusCode, String)> {
+    tracing::debug!("{:?}", *state.records.lock().await);
+
+    let cache_name = util::get_random_name(10);
+
+    let archive_path = Path::new(".cache/serve").join(&format!("{}.zip", &cache_name));
+
+    tracing::debug!("Zipping: {:?}", &archive_path);
+
+    let mut archive = tokio::fs::File::create(&archive_path)
        .await
+        .map_err(|err| (StatusCode::INTERNAL_SERVER_ERROR, err.to_string()))?;
+    let mut writer = ZipFileWriter::new(&mut archive);
+
+    while let Some(field) = body.next_field().await.unwrap() {
+        let file_name = match field.file_name() {
+            Some(file_name) => sanitize(file_name),
+            _ => continue,
+        };
+
+        tracing::debug!("Downloading to Zip: {file_name:?}");
+
+        let stream = field;
+        let body_with_io_error = stream.map_err(|err| io::Error::new(io::ErrorKind::Other, err));
+        let mut body_reader = StreamReader::new(body_with_io_error);
+
+        let builder = ZipEntryBuilder::new(file_name, Compression::Deflate);
+        let mut entry_writer = writer
+            .write_entry_stream(builder)
+            .await
+            .unwrap()
+            .compat_write();
+
+        tokio::io::copy(&mut body_reader, &mut entry_writer)
+            .await
+            .map_err(|err| (StatusCode::INTERNAL_SERVER_ERROR, err.to_string()))?;
+
+        entry_writer
+            .into_inner()
+            .close()
+            .await
+            .map_err(|err| (StatusCode::INTERNAL_SERVER_ERROR, err.to_string()))?;
+    }
+
+    let mut records = state.records.lock().await;
+    let record = UploadRecord::new(archive_path);
+    records.insert(cache_name.clone(), record.clone());
+
+    cache::write_to_cache(&records)
+        .await
+        .map_err(|err| (StatusCode::INTERNAL_SERVER_ERROR, err.to_string()))?;
+
+    writer.close().await.unwrap();
+
+    let id = cache_name;
+    let response = Response::builder()
+        .status(200)
+        .header("Content-Type", "text/html")
+        .header("HX-Push-Url", format!("/link/{}", &id))
+        .body(leptos::ssr::render_to_string(|cx| {
+            leptos::view! { cx, <LinkView id record /> }
+        }))
        .unwrap();

-    tracing::debug!("listening on http://{}/", addr);
+    Ok(response)
+}
+
+async fn download(
+    axum::extract::Path(id): axum::extract::Path<String>,
+    headers: HeaderMap,
+    State(state): State<AppState>,
+) -> Result<axum::response::Response, (StatusCode, String)> {
+    {
+        let mut records = state.records.lock().await;
+        if headers.get("hx-request").is_some() {
+            return Ok(axum::http::Response::builder()
+                .header("HX-Redirect", format!("/download/{id}"))
+                .status(204)
+                .body("".to_owned())
+                .unwrap()
+                .into_response());
+        }
+
+        if let Some(record) = records
+            .get_mut(&id)
+            .filter(|record| record.can_be_downloaded())
+        {
+            record.downloads += 1;
+
+            let file = tokio::fs::File::open(&record.file).await.unwrap();
+
+            return Ok(axum::response::Response::builder()
+                .header("Content-Type", "application/zip")
+                .body(StreamBody::new(ReaderStream::new(file)))
+                .unwrap()
+                .into_response());
+        } else {
+            records.remove_record(&id).await.unwrap()
+        }
+    }
+
+    Ok(Redirect::to("/404.html").into_response())
 }
--- a/src/nyazoom_headers.rs
+++ b/src/nyazoom_headers.rs
--- a/src/router/download.rs
+++ b/src/router/download.rs
@ -1,41 +0,0 @@
-use axum::{
-    body::Body,
-    extract::State,
-    response::{IntoResponse, Redirect},
-    routing::get,
-    Router,
-};
-use reqwest::StatusCode;
-use tokio_util::io::ReaderStream;
-
-use crate::{AppState, AsyncRemoveRecord};
-
-pub fn get_download_router() -> Router<AppState> {
-    Router::new().route("/:id", get(download))
-}
-
-async fn download(
-    axum::extract::Path(id): axum::extract::Path<String>,
-    State(state): State<AppState>,
-) -> Result<axum::response::Response, (StatusCode, String)> {
-    {
-        let mut records = state.records.lock().await;
-        if let Some(record) = records
-            .get_mut(&id)
-            .filter(|record| record.can_be_downloaded())
-        {
-            record.downloads += 1;
-
-            let file = tokio::fs::File::open(&record.file).await.unwrap();
-
-            return Ok(axum::response::Response::builder()
-                .header("Content-Type", "application/zip")
-                .body(Body::from_stream(ReaderStream::new(file)))
-                .unwrap());
-        } else {
-            records.remove_record(&id).await.unwrap()
-        }
-    }
-
-    Ok(Redirect::to("/404.html").into_response())
-}
--- a/src/router/link.rs
+++ b/src/router/link.rs
@ -1,74 +0,0 @@
-use axum::{
-    extract::State,
-    response::{Html, IntoResponse, Redirect},
-    routing::get,
-    Router,
-};
-use reqwest::StatusCode;
-
-use crate::{util::ssr, AppState, AsyncRemoveRecord, DownloadLinkPage};
-
-pub fn get_link_router() -> Router<AppState> {
-    // Link pages
-    Router::new()
-        .route("/:id", get(link).delete(link_delete))
-        .route("/:id/remaining", get(remaining))
-}
-
-async fn link(
-    axum::extract::Path(id): axum::extract::Path<String>,
-    State(mut state): State<AppState>,
-) -> Result<Html<String>, Redirect> {
-    {
-        let mut records = state.records.lock().await;
-
-        if let Some(record) = records
-            .get_mut(&id)
-            .filter(|record| record.can_be_downloaded())
-        {
-            return Ok(Html(ssr::render({
-                let record = record.clone();
-                || leptos::view! { <DownloadLinkPage id record /> }
-            })));
-        }
-    }
-
-    // TODO: This....
-    state.remove_record(&id).await.unwrap();
-
-    Err(Redirect::to("/404.html"))
-}
-
-async fn link_delete(
-    axum::extract::Path(id): axum::extract::Path<String>,
-    State(mut state): State<AppState>,
-) -> Result<Html<String>, (StatusCode, String)> {
-    state
-        .remove_record(&id)
-        .await
-        .map_err(|err| (StatusCode::INTERNAL_SERVER_ERROR, err.to_string()))?;
-
-    Ok(Html("".to_string()))
-}
-
-#[inline]
-pub fn get_remaining_text(downloads_remaining: u8) -> String {
-    let plural = if downloads_remaining > 1 { "s" } else { "" };
-    format!(
-        "You have {} download{} remaining!",
-        downloads_remaining, plural
-    )
-}
-
-async fn remaining(
-    State(state): State<AppState>,
-    axum::extract::Path(id): axum::extract::Path<String>,
-) -> impl IntoResponse {
-    let records = state.records.lock().await;
-    if let Some(record) = records.get(&id) {
-        let downloads_remaining = record.downloads_remaining();
-        Html(get_remaining_text(downloads_remaining))
-    } else {
-        Html("?".to_string())
-    }
-}
--- a/src/router/mod.rs
+++ b/src/router/mod.rs
@ -1,9 +0,0 @@
-pub mod download;
-pub mod link;
-pub mod records;
-pub mod upload;
-
-pub use download::get_download_router;
-pub use link::get_link_router;
-pub use records::get_records_router;
-pub use upload::get_upload_router;
--- a/src/router/records.rs
+++ b/src/router/records.rs
@ -1,57 +0,0 @@
-use axum::{
-    extract::State,
-    response::{Html, IntoResponse},
-    routing::get,
-    Json, Router,
-};
-use leptos::CollectView;
-
-use crate::{util::ssr, AppState, HtmxPage};
-
-pub fn get_records_router() -> Router<AppState> {
-    // Records views
-    Router::new()
-        .route("/", get(records))
-        .route("/links", get(records_links))
-}
-
-pub(crate) async fn records(State(state): State<AppState>) -> impl IntoResponse {
-    Json(state.records.lock().await.clone())
-}
-
-// This function is to remain ugly until that time in which I properly hide
-// this behind some kind of authentication
-pub async fn records_links(State(state): State<AppState>) -> impl IntoResponse {
-    let records = state.records.lock().await.clone();
-
-    let records_list_view = records
-        .keys()
-        .map(|key| {
-            leptos::view! {
-                <li class="link-wrapper">
-                    <a href="/link/{key}">{key}</a>
-                    <button
-                        style="margin-left: 1em;"
-                        hx-target="closest .link-wrapper"
-                        hx-swap="outerHTML"
-                        hx-delete="/link/{key}"
-                    >
-                        "X"
-                    </button>
-                </li>
-            }
-        })
-        .collect_view();
-
-    Html(ssr::render(move || {
-        leptos::view! {
-            <HtmxPage>
-                <div class="form-wrapper">
-                    <div class="column-container">
-                        <ul>{records_list_view}</ul>
-                    </div>
-                </div>
-            </HtmxPage>
-        }
-    }))
-}
--- a/src/router/upload.rs
+++ b/src/router/upload.rs
@ -1,99 +0,0 @@
-use std::path::Path;
-
-use async_zip::{base::write::ZipFileWriter, Compression, ZipEntryBuilder};
-use axum::{
-    extract::{DefaultBodyLimit, Multipart, State},
-    http::Response,
-    routing::post,
-    Router,
-};
-use futures::TryStreamExt;
-use reqwest::StatusCode;
-use sanitize_filename_reader_friendly::sanitize;
-use tokio::io;
-use tokio_util::{compat::FuturesAsyncWriteCompatExt, io::StreamReader};
-use tower_http::limit::RequestBodyLimitLayer;
-
-use crate::{
-    cache,
-    util::{self, ssr},
-    AppState, LinkView, UploadRecord,
-};
-
-pub fn get_upload_router() -> Router<AppState> {
-    // Upload needs a subrouter to increase the body limit
-    Router::new()
-        .route("/", post(upload_to_zip))
-        .layer(DefaultBodyLimit::disable())
-        .layer(RequestBodyLimitLayer::new(
-            10 * 1024 * 1024 * 1024, // 10GiB
-        ))
-}
-
-async fn upload_to_zip(
-    State(state): State<AppState>,
-    mut body: Multipart,
-) -> Result<Response<String>, (StatusCode, String)> {
-    tracing::debug!("{:?}", *state.records.lock().await);
-
-    let cache_name = util::get_random_name(10);
-
-    let archive_path = Path::new(".cache/serve").join(format!("{}.zip", &cache_name));
-
-    tracing::debug!("Zipping: {:?}", &archive_path);
-
-    let mut archive = tokio::fs::File::create(&archive_path)
-        .await
-        .map_err(|err| (StatusCode::INTERNAL_SERVER_ERROR, err.to_string()))?;
-    let mut writer = ZipFileWriter::with_tokio(&mut archive);
-
-    while let Some(field) = body.next_field().await.unwrap() {
-        let file_name = match field.file_name() {
-            Some(file_name) => sanitize(file_name),
-            _ => continue,
-        };
-
-        tracing::debug!("Downloading to Zip: {file_name:?}");
-
-        let stream = field;
-        let body_with_io_error = stream.map_err(io::Error::other);
-        let mut body_reader = StreamReader::new(body_with_io_error);
-
-        let builder = ZipEntryBuilder::new(file_name.into(), Compression::Deflate);
-        let mut entry_writer = writer
-            .write_entry_stream(builder)
-            .await
-            .unwrap()
-            .compat_write();
-
-        tokio::io::copy(&mut body_reader, &mut entry_writer)
-            .await
-            .map_err(|err| (StatusCode::INTERNAL_SERVER_ERROR, err.to_string()))?;
-
-        entry_writer
-            .into_inner()
-            .close()
-            .await
-            .map_err(|err| (StatusCode::INTERNAL_SERVER_ERROR, err.to_string()))?;
-    }
-
-    let mut records = state.records.lock().await;
-    let record = UploadRecord::new(archive_path);
-    records.insert(cache_name.clone(), record.clone());
-
-    cache::write_to_cache(&records)
-        .await
-        .map_err(|err| (StatusCode::INTERNAL_SERVER_ERROR, err.to_string()))?;
-
-    writer.close().await.unwrap();
-
-    let id = cache_name;
-    let response = Response::builder()
-        .status(200)
-        .header("Content-Type", "text/html")
-        .header("HX-Push-Url", format!("/link/{}", &id))
-        .body(ssr::render(|| leptos::view! { <LinkView id record /> }))
-        .unwrap();
-
-    Ok(response)
-}
--- a/src/state.rs
+++ b/src/state.rs
@ -66,12 +66,12 @@ impl AppState {

 #[async_trait]
 pub trait AsyncRemoveRecord {
-    async fn remove_record(&mut self, id: &str) -> Result<(), std::io::Error>;
+    async fn remove_record(&mut self, id: &String) -> Result<(), std::io::Error>;
 }

 #[async_trait]
 impl AsyncRemoveRecord for AppState {
-    async fn remove_record(&mut self, id: &str) -> Result<(), std::io::Error> {
+    async fn remove_record(&mut self, id: &String) -> Result<(), std::io::Error> {
        let mut records = self.records.lock().await;
        records.remove_record(id).await
    }
@ -79,12 +79,12 @@ impl AsyncRemoveRecord for AppState {

 #[async_trait]
 impl AsyncRemoveRecord for HashMap<String, UploadRecord> {
-    async fn remove_record(&mut self, id: &str) -> Result<(), std::io::Error> {
-        match self.entry(id.to_string()) {
+    async fn remove_record(&mut self, id: &String) -> Result<(), std::io::Error> {
+        match self.entry(id.clone()) {
            Entry::Occupied(entry) => {
                tokio::fs::remove_file(&entry.get().file).await?;
                entry.remove_entry();
-                cache::write_to_cache(self).await?;
+                cache::write_to_cache(&self).await?;

                Ok(())
            }
--- a/src/util/mod.rs
+++ b/src/util/mod.rs
@ -1,8 +1,3 @@
-pub mod headers;
-pub mod logging;
-pub mod ssr;
-pub mod sweeper;
-
 use rand::{
    distributions::{Alphanumeric, DistString},
    rngs::SmallRng,
--- a/src/util/logging.rs
+++ b/src/util/logging.rs
@ -1,12 +0,0 @@
-use tracing_subscriber::{layer::SubscriberExt, util::SubscriberInitExt};
-
-pub fn init_tracing() {
-    // Set up logging
-    tracing_subscriber::registry()
-        .with(
-            tracing_subscriber::EnvFilter::try_from_default_env()
-                .unwrap_or_else(|_| "nyazoom=debug,tower_http=debug".into()),
-        )
-        .with(tracing_subscriber::fmt::layer())
-        .init();
-}
--- a/src/util/ssr.rs
+++ b/src/util/ssr.rs
@ -1,7 +0,0 @@
-pub fn render<F, N>(f: F) -> String
-where
-    F: FnOnce() -> N + 'static,
-    N: leptos::IntoView,
-{
-    leptos::ssr::render_to_string(f).to_string()
-}
--- a/src/util/sweeper.rs
+++ b/src/util/sweeper.rs
@ -1,22 +0,0 @@
-use std::time::Duration;
-
-use crate::state::{AppState, AsyncRemoveRecord};
-
-/// Spawn a repeating task that will clean files periodically
-pub fn spawn(state: AppState) {
-    tokio::spawn(async move {
-        loop {
-            tokio::time::sleep(Duration::from_secs(15 * 60)).await;
-            tracing::info!("Cleaning Sweep!");
-
-            let mut records = state.records.lock().await;
-
-            for (key, record) in records.clone().into_iter() {
-                if !record.can_be_downloaded() {
-                    tracing::info!("culling: {:?}", record);
-                    records.remove_record(&key).await.unwrap();
-                }
-            }
-        }
-    });
-}
--- a/src/views.rs
+++ b/src/views.rs
@ -0,0 +1,106 @@
+use futures::TryFutureExt;
+use leptos::{component, view, Children, IntoView, Scope};
+use serde::Deserialize;
+
+use crate::state::UploadRecord;
+
+#[derive(Debug, Deserialize)]
+pub struct CatFact {
+    pub fact: String,
+}
+
+pub async fn get_cat_fact() -> String {
+    reqwest::get("https://catfact.ninja/fact")
+        .and_then(|res| res.json())
+        .map_ok(|cf: CatFact| cf.fact)
+        .await
+        .unwrap_or_else(|_| String::from("The cat fact goddess has failed me :<"))
+}
+
+// {https://api.thecatapi.com/v1/images/search?size=small&format=src}
+// {https://cataas.com/cat?width=250&height=250}
+#[component]
+pub fn Welcome(cx: Scope, fact: String) -> impl IntoView {
+    view! { cx,
+        <HtmxPage>
+            <div class="form-wrapper">
+                <WelcomeView fact />
+            </div>
+        </HtmxPage>
+    }
+}
+
+#[component]
+pub fn WelcomeView(cx: Scope, fact: String) -> impl IntoView {
+    view! {
+        cx,
+        <form id="form" hx-swap="outerHTML" hx-post="/upload" hx-encoding="multipart/form-data" class="column-container">
+            <div class="cat-img-wrapper">
+                <img class="cat-img" src="https://api.thecatapi.com/v1/images/search?size=small&format=src" />
+            </div>
+            <input type="file" id="file" name="file" data-multiple-caption="{{count}} files selected" multiple />
+            <label for="file">Select Files</label>
+
+            <input type="submit" value="Get Link~" />
+            <p id="cat-fact">{fact}</p>
+            <progress id="progress" class="htmx-indicator" value="0" max="100"></progress>
+        </form>
+        <script src="/scripts/loading_progress.js" />
+    }
+}
+
+// <link href="../dist/css/link.css" rel="stylesheet" />
+// #TODO: Handle pushing cleaner
+#[component]
+pub fn DownloadLinkPage(cx: Scope, id: String, record: UploadRecord) -> impl IntoView {
+    view! { cx,
+        <HtmxPage>
+            <div class="form-wrapper">
+                <LinkView id record />
+            </div>
+        </HtmxPage>
+    }
+}
+
+#[component]
+pub fn HtmxPage(cx: Scope, children: Children) -> impl IntoView {
+    view! { cx,
+        <head>
+            <title>Nyazoom</title>
+            <meta charset="UTF-8" />
+            <meta name="viewport" content="width=device-width, initial-scale=1" />
+            <link href="/css/main.css" rel="stylesheet" />
+            <link href="/css/link.css" rel="stylesheet" />
+            <script src="/scripts/file_label.js" />
+            <script src="/scripts/link.js" />
+            <script src="https://unpkg.com/htmx.org@1.9.4" integrity="sha384-zUfuhFKKZCbHTY6aRR46gxiqszMk5tcHjsVFxnUo8VMus4kHGVdIYVbOYYNlKmHV" crossorigin="anonymous"></script>
+        </head>
+
+        <body>
+            <h1>NyaZoom<sup>2</sup></h1>
+            {children(cx)}
+        </body>
+    }
+}
+
+#[component]
+pub fn LinkView(cx: Scope, id: String, record: UploadRecord) -> impl IntoView {
+    let downloads_remaining = record.max_downloads - record.downloads;
+    let plural = if downloads_remaining > 1 { "s" } else { "" };
+    view! {
+        cx,
+        <div class="column-container">
+            <div class="link-wrapper">
+                <a id="link" href="/download/{id}">Download Now!</a>
+            </div>
+
+            <div class="link-wrapper" hx-get="/link/{id}/remaining" hx-trigger="click from:#link delay:0.2s, every 10s" >
+                You have {record.downloads_remaining()} download{plural} remaining!
+            </div>
+            <button class="return-button" onclick="clipboard()">Copy to Clipboard</button>
+
+
+            <a href="/" class="return-button">Return to home</a>
+        </div>
+    }
+}
--- a/src/views/base_page.rs
+++ b/src/views/base_page.rs
@ -1,26 +0,0 @@
-use leptos::{component, view, Children, IntoView};
-
-#[component]
-pub fn HtmxPage(children: Children) -> impl IntoView {
-    view! {
-        <head>
-            <title>Nyazoom</title>
-            <meta charset="UTF-8" />
-            <meta name="viewport" content="width=device-width, initial-scale=1" />
-            <link href="/css/main.css" rel="stylesheet" />
-            <link href="/css/link.css" rel="stylesheet" />
-            <script src="/scripts/file_label.js" />
-            <script src="/scripts/link.js" />
-            <script
-                src="https://unpkg.com/htmx.org@2.0.2"
-                integrity="sha384-Y7hw+L/jvKeWIRRkqWYfPcvVxHzVzn5REgzbawhxAuQGwX1XWe70vji+VSeHOThJ"
-                crossorigin="anonymous"
-            ></script>
-        </head>
-
-        <body>
-            <h1>"NyaZoom"<sup>"2"</sup></h1>
-            {children()}
-        </body>
-    }
-}
--- a/src/views/links.rs
+++ b/src/views/links.rs
@ -1,47 +0,0 @@
-use leptos::{component, view, IntoView};
-
-use crate::link::get_remaining_text;
-use crate::state::UploadRecord;
-use crate::HtmxPage;
-
-// <link href="../dist/css/link.css" rel="stylesheet" />
-// #TODO: Handle pushing cleaner
-#[component]
-pub fn DownloadLinkPage(id: String, record: UploadRecord) -> impl IntoView {
-    view! {
-        <HtmxPage>
-            <div class="form-wrapper">
-                <LinkView id record />
-            </div>
-        </HtmxPage>
-    }
-}
-
-#[component]
-pub fn LinkView(id: String, record: UploadRecord) -> impl IntoView {
-    let downloads_remaining = record.max_downloads - record.downloads;
-    view! {
-        <div class="column-container">
-            <div class="link-wrapper">
-                <a id="link" href="/download/{id}">
-                    "Download Now!"
-                </a>
-            </div>
-
-            <div
-                class="link-wrapper"
-                hx-get="/link/{id}/remaining"
-                hx-trigger="click from:#link delay:0.2s, every 10s"
-            >
-                {get_remaining_text(downloads_remaining)}
-            </div>
-            <button class="return-button" onclick="clipboard()">
-                Copy to Clipboard
-            </button>
-
-            <a href="/" class="return-button">
-                "Return to home"
-            </a>
-        </div>
-    }
-}
--- a/src/views/mod.rs
+++ b/src/views/mod.rs
@ -1,23 +0,0 @@
-use futures::TryFutureExt;
-use serde::Deserialize;
-
-pub mod base_page;
-pub mod links;
-pub mod welcome;
-
-pub use base_page::*;
-pub use links::*;
-pub use welcome::*;
-
-#[derive(Debug, Deserialize)]
-pub struct CatFact {
-    pub fact: String,
-}
-
-pub async fn get_cat_fact() -> String {
-    reqwest::get("https://catfact.ninja/fact")
-        .and_then(|res| res.json())
-        .map_ok(|cf: CatFact| cf.fact)
-        .await
-        .unwrap_or_else(|_| String::from("The cat fact goddess has failed me :<"))
-}
--- a/src/views/welcome.rs
+++ b/src/views/welcome.rs
@ -1,49 +0,0 @@
-use leptos::{component, view, IntoView};
-
-use crate::HtmxPage;
-
-// {https://api.thecatapi.com/v1/images/search?size=small&format=src}
-// {https://cataas.com/cat?width=250&height=250}
-#[component]
-pub fn WelcomePage(fact: String) -> impl IntoView {
-    view! {
-        <HtmxPage>
-            <div class="form-wrapper">
-                <WelcomeView fact />
-            </div>
-        </HtmxPage>
-    }
-}
-
-#[component]
-pub fn WelcomeView(fact: String) -> impl IntoView {
-    view! {
-        <form
-            id="form"
-            hx-swap="outerHTML"
-            hx-post="/upload"
-            hx-encoding="multipart/form-data"
-            class="column-container"
-        >
-            <div class="cat-img-wrapper">
-                <img
-                    class="cat-img"
-                    src="https://api.thecatapi.com/v1/images/search?size=small&format=src"
-                />
-            </div>
-            <input
-                type="file"
-                id="file"
-                name="file"
-                data-multiple-caption="{{count}} files selected"
-                multiple
-            />
-            <label for="file">"Select Files"</label>
-
-            <input type="submit" value="Get Link~" />
-            <p id="cat-fact">{fact}</p>
-            <progress id="progress" class="htmx-indicator" value="0" max="100"></progress>
-        </form>
-        <script src="/scripts/loading_progress.js" />
-    }
-}