feat: owner cookie

Author: ModProg

Cargo.lock

@@ -24,10 +24,12 @@ thiserror = "1.0.31"
 tokio = { version = "1.18.1", features = ["full"] }
 url = { version = "2.2.2", features = ["serde"] }
 mime_guess = "2.0.4"
-serde_with = "1.13.0"
+serde_with = { version = "1.13.0", features = ["chrono"] }
 syntect = "5.0.0"
 askama = { version = "0.11.1", features = ["with-actix-web"] }
 askama_actix = "0.13.0"
+chrono = { version = "0.4.19", features = ["serde"] }
+actix-utils = "3.0.0"
 
 [dependencies.figment]
  version = "0.10.6"

Cargo.toml

@@ -1,16 +1,21 @@
 use std::path::Path;
 
 use anyhow::{Context, Result};
+use chrono::Duration;
 use figment::{
     providers::{Env, Format, Toml},
     Figment,
 };
 use serde::Deserialize;
+use serde_with::{serde_as, DurationSeconds};
 
+#[serde_as]
 #[derive(Deserialize)]
 pub struct Config {
-    pub max_age: f64,
-    pub time_to_delete: f64,
+    #[serde_as(as = "DurationSeconds<i64>")]
+    pub max_age: Duration,
+    #[serde_as(as = "DurationSeconds<i64>")]
+    pub time_to_delete: Duration,
 }
 
 impl Config {

src/config.rs

@@ -1,22 +1,48 @@
-use crate::{util::ReadableAlphanumeric, StorageConfiguration, RESERVED_URLS};
 use bonsaidb::{
-    core::schema,
+    core::schema::{self, Qualified},
     local::{config::Builder, AsyncDatabase},
 };
 use bonsaidb_files::{
-    direct::{Async, File},
-    BonsaiFiles, FileConfig, FilesSchema, Truncate,
+    direct::{self, Async},
+    FileConfig, FilesSchema, Truncate,
 };
+use chrono::{Duration, Utc};
 use rand::distributions::DistString;
+use serde::{Deserialize, Serialize};
+
+use crate::{util::ReadableAlphanumeric, StorageConfiguration, RESERVED_URLS};
+
+type Result<T = ()> = std::result::Result<T, bonsaidb::core::Error>;
+pub type DateTime = chrono::DateTime<Utc>;
+
+#[derive(Serialize, Deserialize, Debug, Clone)]
+pub struct Metadata {
+    pub delete_at: Option<DateTime>,
+    pub owner: String,
+}
 
-type Result<T> = std::result::Result<T, bonsaidb::core::Error>;
-type FileResult<T> = std::result::Result<T, bonsaidb_files::Error>;
+pub struct Files;
+impl FileConfig for Files {
+    type Metadata = Metadata;
+
+    const BLOCK_SIZE: usize = 65_536;
+
+    fn files_name() -> schema::CollectionName {
+        Qualified::private("files")
+    }
+
+    fn blocks_name() -> schema::CollectionName {
+        Qualified::private("blocks")
+    }
+}
+
+type File = direct::File<Async<AsyncDatabase>, Files>;
 
 #[derive(Debug, schema::Schema)]
-#[schema(name = "paste", include=[FilesSchema<BonsaiFiles>])]
+#[schema(name = "paste", include=[FilesSchema<Files>])]
 struct Schema;
 
-pub struct DB(pub AsyncDatabase);
+pub struct DB(AsyncDatabase);
 
 impl DB {
     pub async fn new() -> Result<Self> {
@@ -25,37 +51,72 @@ impl DB {
         ))
     }
 
-    pub async fn load_file(&self, name: &str) -> FileResult<Option<File<Async<AsyncDatabase>>>> {
-        // TODO delete file if marked for deletion
-        BonsaiFiles::load_async(name, &self.0).await
+    pub async fn delete_at(&self, name: &str, delete_at: DateTime) -> Result {
+        if let Some(mut file) = Files::load_async(name, &self.0).await? {
+            let metadata = file.metadata().expect("all files have metadata").clone();
+            file.update_metadata(Metadata {
+                delete_at: Some(delete_at),
+                ..metadata
+            })
+            .await?;
+        }
+        Ok(())
+    }
+
+    pub async fn file_owner(&self, name: &str) -> Result<Option<String>> {
+        Ok(Files::load_async(name, &self.0)
+            .await?
+            .map(|m| m.metadata().expect("all files have metadata").owner.clone()))
+    }
+
+    pub async fn load_file(&self, name: &str) -> Result<Option<File>> {
+        if let Some(file) = Files::load_async(name, &self.0).await? {
+            if let Some(delete_at) = file.metadata().and_then(|m| m.delete_at) {
+                if Utc::now() > delete_at {
+                    file.delete().await?;
+                    return Ok(None);
+                }
+            }
+            Ok(Some(file))
+        } else {
+            Ok(None)
+        }
     }
 
-    pub async fn new_file(&self) -> FileResult<File<Async<AsyncDatabase>>> {
+    pub async fn new_file(&self, owner: String, ttl: Option<Duration>) -> Result<File> {
         let mut tries = 0;
         // TODO auto increase
         let length = 4;
-        Ok(loop {
+        let mut file = loop {
             let name = loop {
                 let id = ReadableAlphanumeric.sample_string(&mut rand::thread_rng(), length);
                 if !RESERVED_URLS.contains(&id.as_str()) {
                     break id;
                 }
             };
             tries += 1;
-            match BonsaiFiles::build(&name).create_async(&self.0).await {
+            match Files::build(&name).create_async(&self.0).await {
                 Ok(file) => break file,
                 Err(bonsaidb_files::Error::Database(
                     bonsaidb::core::Error::UniqueKeyViolation { .. },
                 )) if tries > 5 => {
-                    let file = BonsaiFiles::load_or_create_async(&name, true, &self.0).await?;
+                    let file = Files::load_or_create_async(&name, true, &self.0).await?;
                     file.truncate(0, Truncate::RemovingStart).await?;
                     break file;
                 }
                 Err(bonsaidb_files::Error::Database(
                     bonsaidb::core::Error::UniqueKeyViolation { .. },
                 )) => continue,
-                Err(err) => return Err(err),
+                Err(err) => return Err(err.into()),
             }
-        })
+        };
+
+        file.update_metadata(Some(Metadata {
+            delete_at: ttl.map(|ttl| Utc::now() + ttl),
+            owner,
+        }))
+        .await?;
+
+        Ok(file)
     }
 }

src/db.rs

@@ -26,7 +26,7 @@ async fn main() -> Result<()> {
         .unwrap_or_else(|| PathBuf::from("config.toml"));
 
     info!(
-        "Loading config from `{}`, this can be changed by the env variable `FRONTEND_CONFIG`",
+        "Loading config from `{}`, this can be changed by the env variable `PASTEMP_CONFIG`",
         config_path.display()
     );
     if !config_path.is_file() {