cleanup

Author: nitsky

Cargo.lock

@@ -15,7 +15,6 @@ tracing-test = "0.2"
 
 [dependencies]
 anyhow = { version = "1", features = ["backtrace"] }
-async-trait = "0.1"
 bytes = "1"
 chrono = { version = "0.4", features = ["serde"] }
 chrono-tz = { version = "0.6", features = ["serde"] }
@@ -31,7 +30,7 @@ memmap = "0.7"
 ndarray = { version = "0.15", features = ["rayon"] }
 num = "0.4"
 rand = "0.8"
-rust-s3 = { version = "0.28", default-features = false, features = ["tokio-rustls-tls"] }
+rust-s3 = { version = "0.30", default-features = false, features = ["tokio-rustls-tls"] }
 serde = { version = "1", features = ["derive"] }
 serde_json = "1"
 sqlx = { version = "0.5", default-features = false, features = ["any", "chrono", "postgres", "runtime-tokio-rustls", "sqlite"] }

crates/app/core/Cargo.toml

@@ -4,10 +4,10 @@ use crate::{
 	App, AppState,
 };
 use anyhow::Result;
+use modelfox_id::Id;
 use serde::{Deserialize, Serialize};
 use sqlx::prelude::*;
 use std::{borrow::BorrowMut, fmt, io, str::FromStr};
-use modelfox_id::Id;
 use time::{macros::format_description, OffsetDateTime};
 use url::Url;
 
@@ -252,17 +252,17 @@ impl App {
 	) -> Result<Vec<Alert>> {
 		let rows = sqlx::query(
 			"
-			select
-				alerts.data
-			from
-				monitors
-			join
-				alerts
-			on
-				monitors.id = alerts.monitor_id
-			where
-				monitors.model_id = $1
-		",
+				select
+					alerts.data
+				from
+					monitors
+				join
+					alerts
+				on
+					monitors.id = alerts.monitor_id
+				where
+					monitors.model_id = $1
+			",
 		)
 		.bind(model_id.to_string())
 		.fetch_all(txn.borrow_mut())

crates/app/core/alert.rs

@@ -10,10 +10,7 @@ use lettre::AsyncTransport;
 use lettre::Transport;
 use serde::Serialize;
 use sqlx::postgres::PgPoolOptions;
-use std::{
-	path::PathBuf,
-	sync::{Arc, RwLock},
-};
+use std::sync::{Arc, RwLock};
 use storage::InMemoryStorage;
 use tokio::sync::{mpsc, oneshot};
 use url::Url;
@@ -177,44 +174,6 @@ pub async fn migrate_inner(database_url: Url) -> Result<()> {
 	Ok(())
 }
 
-/// Retrieve the user cache directory using the `dirs` crate.
-pub fn cache_path() -> Result<PathBuf> {
-	let cache_dir =
-		dirs::cache_dir().ok_or_else(|| anyhow!("failed to find user cache directory"))?;
-	let modelfox_cache_dir = cache_dir.join("modelfox");
-	std::fs::create_dir_all(&modelfox_cache_dir).map_err(|_| {
-		anyhow!(
-			"failed to create modelfox cache directory in {}",
-			modelfox_cache_dir.display()
-		)
-	})?;
-	Ok(modelfox_cache_dir)
-}
-
-/// Retrieve the user data directory using the `dirs` crate.
-pub fn data_path() -> Result<PathBuf> {
-	let data_dir = dirs::data_dir().ok_or_else(|| anyhow!("failed to find user data directory"))?;
-	let modelfox_data_dir = data_dir.join("modelfox");
-	std::fs::create_dir_all(&modelfox_data_dir).map_err(|_| {
-		anyhow!(
-			"failed to create modelfox data directory in {}",
-			modelfox_data_dir.display()
-		)
-	})?;
-	Ok(modelfox_data_dir)
-}
-
-/// Retrieve the default database url, which is a sqlite database in the user data directory.
-pub fn default_database_url() -> Url {
-	let modelfox_database_path = data_path().unwrap().join("db").join("modelfox.db");
-	std::fs::create_dir_all(modelfox_database_path.parent().unwrap()).unwrap();
-	let url = format!(
-		"sqlite:{}",
-		modelfox_database_path.to_str().unwrap().to_owned()
-	);
-	Url::parse(&url).unwrap()
-}
-
 impl App {
 	pub async fn new(options: Options) -> Result<Self> {
 		// Create the database pool.
@@ -314,6 +273,10 @@ impl App {
 		self.state.smtp_transport.clone()
 	}
 
+	pub fn options(&self) -> &Options {
+		&self.state.options
+	}
+
 	/// Send a message to the monitor checker and wait for it to reply back indicating it has run.
 	#[tracing::instrument(level = "info", skip_all)]
 	pub async fn sync_tasks(&self) -> Result<()> {
@@ -392,13 +355,6 @@ pub async fn reset_database(database_url: &Option<Url>) -> Result<()> {
 	Ok(())
 }
 
-/// Remove all contents of the data dir, including the database
-pub async fn reset_data(database_url: &Option<Url>) -> Result<()> {
-	reset_database(database_url).await?;
-	std::fs::remove_dir_all(data_path()?)?;
-	Ok(())
-}
-
 pub fn path_components(request: &http::Request<hyper::Body>) -> Vec<&str> {
 	request.uri().path().split('/').skip(1).collect::<Vec<_>>()
 }

crates/app/core/lib.rs

@@ -1,4 +1,3 @@
-use crate::{data_path, default_database_url, App};
 use std::net::IpAddr;
 use std::path::PathBuf;
 use url::Url;
@@ -58,45 +57,3 @@ impl Options {
 		self.auth.is_some()
 	}
 }
-
-impl Default for Options {
-	fn default() -> Self {
-		let host: IpAddr = if let Ok(host) = std::env::var("HOST") {
-			host.parse()
-				.expect("Could not parse HOST environment variable")
-		} else {
-			"0.0.0.0".parse().unwrap()
-		};
-		let port = if let Ok(port) = std::env::var("PORT") {
-			port.parse()
-				.expect("Could not parse PORT environment variable")
-		} else {
-			8080u16
-		};
-		let database = DatabaseOptions {
-			max_connections: None,
-			url: default_database_url(),
-		};
-		let storage = StorageOptions::Local(LocalStorageOptions {
-			path: data_path()
-				.expect("Could not read or create modelfox data directory")
-				.join("data"),
-		});
-		Options {
-			auth: None,
-			cookie_domain: None,
-			database,
-			host,
-			port,
-			smtp: None,
-			storage,
-			url: None,
-		}
-	}
-}
-
-impl App {
-	pub fn options(&self) -> &Options {
-		&self.state.options
-	}
-}

crates/app/core/options.rs

@@ -1,14 +1,12 @@
 use crate::App;
 use anyhow::{anyhow, Result};
-use async_trait::async_trait;
 use bytes::Bytes;
 use modelfox_id::Id;
 use std::{
 	collections::HashMap,
 	path::PathBuf,
 	sync::{Arc, RwLock},
 };
-use tokio::fs;
 
 #[derive(Debug)]
 #[allow(clippy::large_enum_variant)]
@@ -75,17 +73,6 @@ impl TryFrom<BytesOrFilePath> for PathBuf {
 	}
 }
 
-/// This trait represents types which can serve as storage buckets for the ModelFox app.
-#[async_trait]
-trait StorageTrait {
-	/// Retrieve an entity from storage.
-	async fn get(&self, entity: StorageEntity, id: Id) -> Result<BytesOrFilePath>;
-	/// Add the provided bytes to the storage.
-	async fn set(&self, entity: StorageEntity, id: Id, data: &[u8]) -> Result<()>;
-	/// Delete an item from storage.
-	async fn remove(&self, entity: StorageEntity, id: Id) -> Result<()>;
-}
-
 impl Storage {
 	pub async fn get(&self, entity: StorageEntity, id: Id) -> Result<BytesOrFilePath> {
 		match self {
@@ -126,8 +113,7 @@ impl Default for InMemoryStorage {
 	}
 }
 
-#[async_trait]
-impl StorageTrait for InMemoryStorage {
+impl InMemoryStorage {
 	async fn get(&self, _entity: StorageEntity, id: Id) -> Result<BytesOrFilePath> {
 		let storage = Arc::clone(&self.storage);
 		let ret = if let Ok(read_guard) = storage.read() {
@@ -159,8 +145,7 @@ impl StorageTrait for InMemoryStorage {
 	}
 }
 
-#[async_trait]
-impl StorageTrait for LocalStorage {
+impl LocalStorage {
 	async fn get(&self, entity: StorageEntity, id: Id) -> Result<BytesOrFilePath> {
 		let entity_path = self.path.join(entity.dir_name());
 		let path = entity_path.join(id.to_string());
@@ -169,16 +154,16 @@ impl StorageTrait for LocalStorage {
 
 	async fn set(&self, entity: StorageEntity, id: Id, data: &[u8]) -> Result<()> {
 		let entity_path = self.path.join(entity.dir_name());
-		fs::create_dir_all(&entity_path).await?;
+		tokio::fs::create_dir_all(&entity_path).await?;
 		let item_path = entity_path.join(id.to_string());
-		fs::write(item_path, data).await?;
+		tokio::fs::write(item_path, data).await?;
 		Ok(())
 	}
 
 	async fn remove(&self, entity: StorageEntity, id: Id) -> Result<()> {
 		let entity_path = self.path.join(entity.dir_name());
 		let item_path = entity_path.join(id.to_string());
-		fs::remove_file(item_path).await?;
+		tokio::fs::remove_file(item_path).await?;
 		Ok(())
 	}
 }
@@ -193,65 +178,54 @@ impl S3Storage {
 		cache_path: PathBuf,
 	) -> Result<S3Storage> {
 		let credentials =
-			s3::creds::Credentials::new(Some(&access_key), Some(&secret_key), None, None, None)
-				.map_err(|e| anyhow!(e.to_string()))?;
+			s3::creds::Credentials::new(Some(&access_key), Some(&secret_key), None, None, None)?;
 		let bucket = s3::Bucket::new(
 			&bucket,
 			s3::Region::Custom { region, endpoint },
 			credentials,
-		)
-		.map_err(|e| anyhow!(e.to_string()))?;
+		)?;
 		Ok(S3Storage { bucket, cache_path })
 	}
 }
 
-#[async_trait]
-impl StorageTrait for S3Storage {
+impl S3Storage {
 	async fn get(&self, entity: StorageEntity, id: Id) -> Result<BytesOrFilePath> {
 		// Attempt to retrieve the item from the cache.
 		let entity_cache_path = self.cache_path.join(entity.dir_name());
 		let item_cache_path = entity_cache_path.join(id.to_string());
-		if fs::metadata(&item_cache_path).await.is_ok() {
+		if tokio::fs::metadata(&item_cache_path).await.is_ok() {
 			return Ok(BytesOrFilePath::from(item_cache_path));
 		}
 		// Retrieve the item from s3 and cache it.
-		let (data, _) = self
-			.bucket
-			.get_object(&key_for_item(entity, id))
-			.await
-			.map_err(|e| anyhow!(e.to_string()))?;
+		let (data, _) = self.bucket.get_object(&key_for_item(entity, id)).await?;
 		// Add the item to the cache.
-		fs::create_dir_all(&entity_cache_path).await?;
-		fs::write(&item_cache_path, data).await?;
+		tokio::fs::create_dir_all(&entity_cache_path).await?;
+		tokio::fs::write(&item_cache_path, data).await?;
 		Ok(BytesOrFilePath::from(item_cache_path))
 	}
 
 	async fn set(&self, entity: StorageEntity, id: Id, data: &[u8]) -> Result<()> {
 		let entity_cache_path = self.cache_path.join(entity.dir_name());
-		fs::create_dir_all(&entity_cache_path).await?;
+		tokio::fs::create_dir_all(&entity_cache_path).await?;
 		let item_cache_path = entity_cache_path.join(id.to_string());
 		// Upload the item to s3.
 		self.bucket
 			.put_object(&key_for_item(entity, id), data)
-			.await
-			.map_err(|e| anyhow!(e.to_string()))?;
+			.await?;
 		// Add the item to the cache.
-		fs::write(item_cache_path, data).await?;
+		tokio::fs::write(item_cache_path, data).await?;
 		Ok(())
 	}
 
 	async fn remove(&self, entity: StorageEntity, id: Id) -> Result<()> {
 		// Remove the item from the cache if it exists.
 		let entity_cache_path = self.cache_path.join(entity.dir_name());
 		let item_cache_path = entity_cache_path.join(id.to_string());
-		if fs::metadata(&item_cache_path).await.is_ok() {
-			fs::remove_file(item_cache_path).await?;
+		if tokio::fs::metadata(&item_cache_path).await.is_ok() {
+			tokio::fs::remove_file(item_cache_path).await?;
 		}
 		// Remove the item from s3.
-		self.bucket
-			.delete_object(&key_for_item(entity, id))
-			.await
-			.map_err(|e| anyhow!(e.to_string()))?;
+		self.bucket.delete_object(&key_for_item(entity, id)).await?;
 		Ok(())
 	}
 }