updated to new storage schema

Cargo.lock

@@ -1182,6 +1182,7 @@ dependencies = [
 name = "middleman"
 version = "0.1.0"
 dependencies = [
+ "base64",
  "minio",
  "rocket",
  "tokio",

Cargo.toml

@@ -7,5 +7,6 @@ edition = "2021"
 rocket = {path = "../Rocket/core/lib"}
 tokio = { version = "1.40.0", features = ["full"] }
 tracing = "0.1.40"
-tracing-subscriber = "0.3.18"
+tracing-subscriber = { version = "0.3.18", features = ["env-filter"] } 
 minio = {git="https://github.com/minio/minio-rs.git", rev = "c28f576"}
+base64 = "0.22.1"

browser/background.js

@@ -1,13 +1,44 @@
-function handle(requestDetails) {
+function handle_header(req) {
-    let b64 = btoa(requestDetails.url)
+    // Headers
-    // let original = atob(b64);
+    // let x = req.requestHeaders;
-    // console.log(`Loading: ${requestDetails.url} || ${b64}`);
+    // if (!x) {
+    x = new Headers()
+    // }
+    x.append("og", old)
 
+    console.log(x)
+
+    // appending header of the original url so that relative urls can be built into
+    // absolute urls
+    // TODO This doesn't work yet
     return {
-        redirectUrl: `http://localhost:4433/s3/${b64}`
+        requestHeaders: x,
     }
 }
 
-browser.webRequest.onBeforeRequest.addListener(
+let old = ""
-    handle, { urls: ["<all_urls>"] }, ["blocking"]
+
+function url_redirect (req)  {
+    
+    let url = new URL(req.url);
+    let path = url.pathname;
+    let domain = url.hostname;
+
+    let b64 = btoa(path)
+    if (!req.url.startsWith("http://localhost")) {
+        old = req.url
+        // console.debug(`Loading: ${req.url} || ${b64}`);
+        return {
+            redirectUrl: `http://localhost:4433/s3/${domain}/${b64}`
+        }
+    }
+}
+
+browser.webRequest.onBeforeSendHeaders.addListener(
+    handle_header, { urls: ["<all_urls>"] }, ["blocking", "requestHeaders"]
 );
+
+browser.webRequest.onBeforeRequest.addListener(
+    url_redirect, { urls: ["<all_urls>"] }, ["blocking"]
+)
+

src/main.rs

@@ -1,6 +1,7 @@
-use rocket::{fairing::{Fairing, Info, Kind}, fs::FileServer, get, http::Header, routes, Request, Response, State};
+use rocket::{fairing::{Fairing, Info, Kind}, fs::FileServer, futures::io::Cursor, get, http::{ContentType, CookieJar, Header, HeaderMap, Status}, outcome::Outcome, request::{self, FromRequest}, response::content, routes, Error, Request, Response, State};
 use s3::S3;
-use tracing::{info, Level};
+use tracing::{debug, info, trace, Level};
+use tracing_subscriber::EnvFilter;
 
 mod s3;
 
@@ -16,57 +17,92 @@ async fn main() {
     tracing_subscriber::fmt()
         .with_line_number(false)
         .without_time()
-        .with_max_level(Level::INFO)
+        .with_env_filter(EnvFilter::from_default_env())
         .init();
 
     let config = Config {
-        s3_bucket: "b64v1",
+        s3_bucket: "b64v2",
         s3_url: "http://localhost:9000",
-        s3_access_key: "8UO76z8wCs9DnpxSbQUY",
+        s3_access_key: "Eyp21VVclXP8xx49bJ6D",
-        s3_secret_key: "xwKVMpf2jzgprsdo85Dvo74UmO84y0aRrAUorYY5",
+        s3_secret_key: "VxqU9hQ2gl7TvHIFzCM74Og6rQUZcpgYpHNUBnVm",
     };
 
     let s3 = S3::connect(&config).await.expect("Failed to connect to minio, aborting.");
-    let cors = CORS;
+    // let cors = CORS;
 
     let _ = rocket::build()
         .mount("/", FileServer::new("www/"))
         .mount("/", routes![get_s3_content])
         .manage(s3)
-        .attach(cors)
+        // .attach(cors)
         .launch()
         .await;
 
     info!("Bye");
 }
 
-#[get("/s3/<path>")]
+struct Og {
-async fn get_s3_content(path: &str, db: &State<S3>) -> Option<String> {
+    og: Option<String>
-    if let Some(resp) = db.get(&path).await {
+}
-        return Some(resp)
+#[rocket::async_trait]
+impl<'r> FromRequest<'r> for Og{
+    type Error = Error;
+
+    async fn from_request(req: &'r Request<'_>) -> request::Outcome<Self, Self::Error> {
+        if let Some(h) = req.headers().get("og-domain").next() {
+            debug!(h);
+            return Outcome::Success(Og { og: Some(h.to_string()) });
+        }
+        Outcome::Success(Og { og: None })
+    }
+}
+
+
+#[get("/s3/<domain>/<file>")]
+async fn get_s3_content(domain: &str, file: &str, db: &State<S3>, og: Og) -> (Status, (ContentType, String)) {
+    use base64::prelude::*;
+    let filename = domain.to_owned() + "/" + file; 
+
+    info!("{:?}", og.og);
+    
+    if let Some(resp) = db.get(&filename).await {
+        let content_type = if let Ok(url) = BASE64_URL_SAFE.decode(file) {
+            let url = url.into_iter().map(|f| f as char).collect::<String>();
+            if let Some(filetype) = url.split('.').collect::<Vec<&str>>().last() {
+                ContentType::from_extension(&filetype).unwrap_or(ContentType::HTML)
+            } else {
+                ContentType::HTML
+            }
+        } else {
+            ContentType::Any
+        };
+        trace!("{:?}", content_type);
+
+        return (Status::Ok, (content_type, resp))
     }
     // instead of some/none I would rather this be 200/404
-    None
+    // TODO should tell surreal to get this url next.
+    (Status::NotFound, (ContentType::Text, "Resource not found in offline cache".to_string()))
 }
 
 // CORS, to allow other sites to request this from their front-end
-pub struct CORS;
+// pub struct CORS;
 
-#[rocket::async_trait]
+// #[rocket::async_trait]
-impl Fairing for CORS {
+// impl Fairing for CORS {
-    fn info(&self) -> Info {
+//     fn info(&self) -> Info {
-        Info {
+//         Info {
-            name: "Add CORS headers to responses",
+//             name: "Add CORS headers to responses",
-            kind: Kind::Response
+//             kind: Kind::Response
-        }
+//         }
-    }
+//     }
 
-    async fn on_response<'r>(&self, _request: &'r Request<'_>, response: &mut Response<'r>) {
+//     async fn on_response<'r>(&self, _request: &'r Request<'_>, response: &mut Response<'r>) {
-        response.set_header(Header::new("Access-Control-Allow-Origin", "*"));
+//         response.set_header(Header::new("Access-Control-Allow-Origin", "*"));
-        response.set_header(Header::new("Access-Control-Allow-Methods", "POST, GET, PATCH, OPTIONS"));
+//         response.set_header(Header::new("Access-Control-Allow-Methods", "POST, GET, PATCH, OPTIONS"));
-        response.set_header(Header::new("Access-Control-Allow-Headers", "*"));
+//         response.set_header(Header::new("Access-Control-Allow-Headers", "*"));
-        response.set_header(Header::new("Access-Control-Allow-Credentials", "true"));
+//         response.set_header(Header::new("Access-Control-Allow-Credentials", "true"));
-        // TODO set this automatically like how Rocket/core/lib/src/fs/server.rs does (bottom of file)
+//         // TODO set this automatically like how Rocket/core/lib/src/fs/server.rs does (bottom of file)
-        response.set_header(Header::new("Content-Type", "text/html"));
+//         response.set_header(Header::new("Content-Type", "text/html"));
-    }
+//     }
-}
+// }

src/s3.rs

@@ -1,7 +1,13 @@
 use minio::s3::{
-    args::{BucketExistsArgs, MakeBucketArgs}, client::ClientBuilder, creds::StaticProvider, error::Error, http::BaseUrl, types::S3Api, Client
+    args::{BucketExistsArgs, MakeBucketArgs},
+    client::ClientBuilder,
+    creds::StaticProvider,
+    error::Error,
+    http::BaseUrl,
+    types::S3Api,
+    Client,
 };
-use tracing::{instrument, trace};
+use tracing::{error, instrument, trace, warn};
 
 use crate::Config;
 
@@ -41,17 +47,38 @@ impl S3 {
             client: client,
         })
     }
-    
+
     pub async fn get(&self, filename: &str) -> Option<String> {
-        let data = self
+        match self
             .client
             .get_object(&self.bucket_name, &filename)
             .send()
             .await
-            .unwrap();
+        {
-             
+            Ok(data) => {
-        if let Ok(segments )= data.content.to_segmented_bytes().await {
+                if let Ok(segments) = data.content.to_segmented_bytes().await {
-            return Some(segments.to_bytes().iter().map(|c| *c as char).collect::<String>())
+                    return Some(
+                        segments
+                            .to_bytes()
+                            .iter()
+                            .map(|c| *c as char)
+                            .collect::<String>(),
+                    );
+                }
+            }
+            Err(e) => {
+                match e {
+                    Error::S3Error(error_response) => {
+                        if error_response.code == "NoSuchKey" {
+                            warn!("Resource not found")
+                        }
+                    },
+                    _ => {
+                        let error = e.to_string();
+                        error!("S3 Error: {error}");
+                    }
+                }
+            },
         }
         None
     }