116 lines
3.3 KiB
Rust
116 lines
3.3 KiB
Rust
use cfg_if::cfg_if;
|
|
|
|
cfg_if! {
|
|
if #[cfg(feature = "ssr")] {
|
|
use leptos::logging::log;
|
|
|
|
use lazy_static::lazy_static;
|
|
use std::env;
|
|
use diesel::{
|
|
pg::PgConnection,
|
|
r2d2::ConnectionManager,
|
|
r2d2::PooledConnection,
|
|
r2d2::Pool,
|
|
};
|
|
|
|
use diesel_migrations::{
|
|
embed_migrations,
|
|
EmbeddedMigrations,
|
|
MigrationHarness,
|
|
};
|
|
|
|
// See https://leward.eu/notes-on-diesel-a-rust-orm/
|
|
|
|
// Define some types to make it easier to work with Diesel
|
|
type PgPool = Pool<ConnectionManager<PgConnection>>;
|
|
pub type PgPooledConn = PooledConnection<ConnectionManager<PgConnection>>;
|
|
|
|
// Keep a global instance of the pool
|
|
lazy_static! {
|
|
static ref DB_POOL: PgPool = init_db_pool();
|
|
}
|
|
|
|
/// Initialize the database pool
|
|
///
|
|
/// Uses DATABASE_URL environment variable to connect to the database if set,
|
|
/// otherwise builds a connection string from other environment variables.
|
|
///
|
|
/// Will panic if either the DATABASE_URL or POSTGRES_HOST environment variables
|
|
/// are not set, or if there is an error creating the pool.
|
|
///
|
|
/// # Returns
|
|
/// A database pool object, which can be used to get pooled connections
|
|
fn init_db_pool() -> PgPool {
|
|
let database_url = env::var("DATABASE_URL").unwrap_or_else(|_| {
|
|
// Build the database URL from environment variables
|
|
// Construct a separate log_url to avoid logging the password
|
|
let mut log_url = "postgres://".to_string();
|
|
let mut url = "postgres://".to_string();
|
|
|
|
if let Ok(user) = env::var("POSTGRES_USER") {
|
|
url.push_str(&user);
|
|
log_url.push_str(&user);
|
|
|
|
if let Ok(password) = env::var("POSTGRES_PASSWORD") {
|
|
url.push_str(":");
|
|
log_url.push_str(":");
|
|
url.push_str(&password);
|
|
log_url.push_str("********");
|
|
}
|
|
|
|
url.push_str("@");
|
|
log_url.push_str("@");
|
|
}
|
|
|
|
let host = env::var("POSTGRES_HOST").expect("DATABASE_URL or POSTGRES_HOST must be set");
|
|
|
|
url.push_str(&host);
|
|
log_url.push_str(&host);
|
|
|
|
if let Ok(port) = env::var("POSTGRES_PORT") {
|
|
url.push_str(":");
|
|
url.push_str(&port);
|
|
log_url.push_str(":");
|
|
log_url.push_str(&port);
|
|
}
|
|
|
|
if let Ok(dbname) = env::var("POSTGRES_DB") {
|
|
url.push_str("/");
|
|
url.push_str(&dbname);
|
|
log_url.push_str("/");
|
|
log_url.push_str(&dbname);
|
|
}
|
|
|
|
log!("Connecting to database: {}", log_url);
|
|
url
|
|
});
|
|
|
|
let manager = ConnectionManager::<PgConnection>::new(database_url);
|
|
PgPool::builder()
|
|
.build(manager)
|
|
.expect("Failed to create pool.")
|
|
}
|
|
|
|
/// Get a pooled connection to the database
|
|
///
|
|
/// Will panic if there is an error getting a connection from the pool.
|
|
///
|
|
/// # Returns
|
|
/// A pooled connection to the database
|
|
pub fn get_db_conn() -> PgPooledConn {
|
|
DB_POOL.get().expect("Failed to get a database connection from the pool.")
|
|
}
|
|
|
|
/// Embedded database migrations into the binary
|
|
const DB_MIGRATIONS: EmbeddedMigrations = embed_migrations!();
|
|
|
|
/// Run any pending migrations in the database
|
|
/// Always safe to call, as it will only run migrations that have not already been run
|
|
pub fn migrate() {
|
|
let db_con = &mut get_db_conn();
|
|
db_con.run_pending_migrations(DB_MIGRATIONS).expect("Could not run database migrations");
|
|
}
|
|
|
|
}
|
|
}
|