database.rs

use postgres::{Client, NoTls, Error, Row};
use std::collections::HashMap;
use std::task::Context as TC;
use std::vec::Vec;
use actix::{Actor, Addr, Context, System, MailboxError};
use actix::prelude::Handler;
use actix::prelude::Message;
use core::marker::Sync;
use postgres::types::ToSql;
use crate::global_config;
use crate::logging;
use futures::executor::block_on;


struct Connection { connection: Result<Client, Error> }


impl Actor for Connection {
    type Context = Context<Self>;

    fn started(&mut self, _ctx: &mut Self::Context) {
        logging::info("Database connected");
    }
}


#[derive(Message)]
#[rtype(result = "Result<Vec<Row>, Error>")]
struct SQLQuery {
    query: &'static str,
    parameters: &'static [&'static (dyn ToSql + Sync)]
}


impl Handler<SQLQuery> for Connection {
    type Result = Result<Vec<Row>, Error>;

    fn handle(&mut self, msg: SQLQuery, _ctx: &mut Context<Self>) -> Self::Result {
        self.connection?.query(msg.query, msg.parameters)
    }
}


static connection: Addr<Connection> = {
    let system = System::new();
    let addr = system.block_on(async { Connection::create(|ctx| {
        Connection { connection: connection_instance() }
    }) });
    system.run().unwrap();
    addr
};


pub fn query(query: &'static str, parameters: &'static [&(dyn ToSql + Sync)]) -> Result<Result<Vec<Row>, Error>, MailboxError> {
    block_on(connection.send(SQLQuery{ query, parameters }))
}


fn connection_instance() -> Result<Client, Error> {
    let useless_default = "docile";
    let host = global_config::item("db.host").unwrap_or("127.0.0.1");
    let user = global_config::item("db.user").unwrap_or(useless_default);
    let base = global_config::item("db.database").unwrap_or(useless_default);
    let connection_string = format!("host={host} user={user} database={base}");
    Client::connect(&connection_string[..], NoTls)
}