108 lines
3.2 KiB
Rust
108 lines
3.2 KiB
Rust
use std::{error::Error, path::PathBuf, sync::Arc};
|
|
|
|
use async_trait::async_trait;
|
|
|
|
use crate::{
|
|
ConfigInfoType,
|
|
containers::db::{DBConfigInfoType, DBInfo, PreExistingDBInfo, UnStartedContainer},
|
|
util::to_absolute_path,
|
|
};
|
|
|
|
#[derive(Clone)]
|
|
pub struct ContainerConfig {
|
|
// Add any SQLite-specific configuration options here if needed
|
|
pub database_name: String,
|
|
pub absolute_dir_path: PathBuf,
|
|
}
|
|
|
|
#[derive(Default)]
|
|
pub struct OptionalContainerConfig {
|
|
// Add any optional configuration fields here
|
|
pub database_name: Option<String>,
|
|
pub absolute_path: Option<PathBuf>,
|
|
}
|
|
|
|
impl OptionalContainerConfig {
|
|
pub fn fill_with(&self, other: &ContainerConfig) -> ContainerConfig {
|
|
ContainerConfig {
|
|
database_name: self
|
|
.database_name
|
|
.clone()
|
|
.unwrap_or_else(|| other.database_name.clone()),
|
|
absolute_dir_path: self
|
|
.absolute_path
|
|
.clone()
|
|
.unwrap_or_else(|| other.absolute_dir_path.clone()),
|
|
}
|
|
}
|
|
}
|
|
|
|
pub fn get_default_config() -> ContainerConfig {
|
|
ContainerConfig {
|
|
database_name: "sqlite".to_string(),
|
|
absolute_dir_path: to_absolute_path("./generated/sqlite"),
|
|
}
|
|
}
|
|
|
|
pub struct SQLiteContainer {
|
|
pub config: ContainerConfig,
|
|
}
|
|
|
|
impl SQLiteContainer {
|
|
fn get_db_absolute_path(&self) -> PathBuf {
|
|
self.config
|
|
.absolute_dir_path
|
|
.join(&self.config.database_name)
|
|
.with_extension("db")
|
|
}
|
|
}
|
|
|
|
#[async_trait]
|
|
impl DBInfo<OptionalContainerConfig> for SQLiteContainer {
|
|
async fn get_db_container_config_info(&self) -> DBConfigInfoType {
|
|
// sqlite filepath url does not include the "sqlite://" prefix
|
|
let sqlite_url = format!("sqlite://{}", self.get_db_absolute_path().to_string_lossy());
|
|
// create the file
|
|
std::fs::create_dir_all(&self.config.absolute_dir_path)
|
|
.expect("Failed to create directories for SQLite database");
|
|
std::fs::File::create(self.get_db_absolute_path())
|
|
.expect("Failed to create SQLite database file");
|
|
//
|
|
ConfigInfoType::PreExisting(PreExistingDBInfo {
|
|
db_type: crate::containers::db::DBType::SQLite,
|
|
url: sqlite_url,
|
|
on_delete: {
|
|
let db_path = self.get_db_absolute_path();
|
|
Arc::new(move || {
|
|
// delete the sqlite database file
|
|
if db_path.exists()
|
|
&& let Err(e) = std::fs::remove_file(&db_path)
|
|
{
|
|
eprintln!("Failed to delete SQLite database file: {}", e);
|
|
}
|
|
})
|
|
},
|
|
})
|
|
}
|
|
|
|
async fn new(user_default_config: Option<OptionalContainerConfig>) -> Self
|
|
where
|
|
Self: Sized,
|
|
{
|
|
let default_config = get_default_config();
|
|
let config = user_default_config
|
|
.unwrap_or_default()
|
|
.fill_with(&default_config);
|
|
|
|
SQLiteContainer {
|
|
config: config.clone(),
|
|
}
|
|
}
|
|
|
|
fn get_unstarted_container(&self) -> Result<UnStartedContainer, Box<dyn Error>> {
|
|
Err(Box::new(std::io::Error::other(
|
|
"SQLite does not use a container",
|
|
)))
|
|
}
|
|
}
|