feox-server 0.1.0

High-performance Redis-compatible server for Feox DB
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

use clap::Parser;
use feox_server::{Config, Server};
use std::sync::Arc;
use tracing::{error, info};

#[derive(Parser, Debug)]
#[command(author, version, about, long_about = None)]
struct Args {
    /// Port to listen on
    #[arg(short, long, default_value_t = 6379)]
    port: u16,

    /// Bind address
    #[arg(short, long, default_value = "127.0.0.1")]
    bind: String,

    /// Number of worker threads (0 = number of CPUs)
    #[arg(short = 't', long, default_value_t = 0)]
    threads: usize,

    /// Path to FeOx data file (memory-only if not specified)
    #[arg(short = 'd', long)]
    data_path: Option<String>,

    /// Enable verbose logging
    #[arg(short, long)]
    verbose: bool,

    /// Config file path
    #[arg(short, long)]
    config: Option<String>,

    /// Log level (trace, debug, info, warn, error)
    #[arg(long, default_value = "info")]
    log_level: String,
}

fn main() -> anyhow::Result<()> {
    let args = Args::parse();

    // Initialize tracing
    let log_level = if args.verbose {
        "debug"
    } else {
        &args.log_level
    };
    tracing_subscriber::fmt()
        .with_env_filter(format!("feox_server={},feoxdb=info", log_level))
        .init();

    info!(
        "Starting FeOx Server v{} on {}:{}",
        env!("CARGO_PKG_VERSION"),
        args.bind,
        args.port
    );

    // Detect CPU configuration
    let num_cpus = num_cpus::get();
    let threads = if args.threads == 0 {
        num_cpus
    } else {
        args.threads
    };

    info!(
        "Detected {} CPUs, using {} worker threads",
        num_cpus, threads
    );

    // Create configuration
    let config = if let Some(config_path) = args.config {
        Config::from_file(&config_path)?
    } else {
        Config {
            bind_addr: args.bind,
            port: args.port,
            threads,
            data_path: args.data_path,
            ..Default::default()
        }
    };

    // Create and run server
    let server = Arc::new(Server::new(config)?);

    // Setup signal handlers for graceful shutdown
    let server_clone = Arc::clone(&server);
    ctrlc::set_handler(move || {
        info!("Received shutdown signal, shutting down gracefully...");
        server_clone.shutdown();
    })?;

    // Run the server
    if let Err(e) = server.run() {
        error!("Server error: {}", e);
        return Err(e.into());
    }

    info!("Server shutdown complete");
    Ok(())
}