alex-db-server 0.1.0

AlexDB server.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105

use clap::Parser;
use std::{error::Error, net::SocketAddr};
use tokio::{
    task,
    time::{sleep, Duration},
};
use tracing::{error, info};
use tracing_subscriber::{layer::SubscriberExt, util::SubscriberInitExt};

type Result<T> = std::result::Result<T, Box<dyn Error + Send + Sync>>;

mod access;
mod api;
mod app;
mod config;
mod error;

#[derive(Parser, Debug)]
#[command(author, version, about, long_about = None)]
pub struct Args {
    /// Data directory
    #[arg(short, long)]
    pub data_dir: Option<String>,

    /// Enable API Key endpoint protection
    #[arg(short, long)]
    pub enable_security_api_keys: Option<bool>,

    /// Port
    #[arg(short, long)]
    pub port: Option<u16>,

    /// Database save triggered after write operations threshold
    #[arg(long)]
    pub save_triggered_by_threshold: Option<u16>,

    /// Database save triggered after time in ms
    #[arg(long)]
    pub save_triggered_after_ms: Option<i64>,

    /// Sleep time between database gc in ms
    #[arg(long)]
    pub sleep_time_between_gc_ms: Option<u64>,

    /// Sleep time between database saves in ms
    #[arg(long)]
    pub sleep_time_between_saves_ms: Option<u64>,
}

pub async fn run() -> Result<()> {
    tracing_subscriber::registry()
        .with(
            tracing_subscriber::EnvFilter::try_from_default_env().unwrap_or_else(|_| {
                "alex_db_server=error,runtime=error,tokio=error,tower_http=error".into()
            }),
        )
        .with(tracing_subscriber::fmt::layer())
        .init();

    let args = Args::parse();
    let config = config::load(args)?;

    let app = app::get_app(config.clone()).await?;

    let db_for_deleting = app.db.clone();
    task::spawn(async move {
        loop {
            let res = db_for_deleting.gc();

            if let Err(e) = res {
                error!("Error: {:?}", e);
            }

            sleep(Duration::from_millis(
                config.db_config.sleep_time_between_gc_ms,
            ))
            .await;
        }
    });

    let db_for_saving = app.db;
    task::spawn(async move {
        loop {
            let res = db_for_saving.save();

            if let Err(e) = res {
                error!("Error: {:?}", e);
            }

            sleep(Duration::from_millis(
                config.db_config.sleep_time_between_saves_ms,
            ))
            .await;
        }
    });

    let addr = SocketAddr::from(([0, 0, 0, 0], config.port));
    info!("listening on {}", addr);
    axum::Server::bind(&addr)
        .serve(app.router.into_make_service())
        .await
        .unwrap();

    Ok(())
}