nomilo/src/main.rs

//#![feature(proc_macro_hygiene, decl_macro)]

/*
#[macro_use] extern crate rocket;
#[macro_use] extern crate diesel;
#[macro_use] extern crate diesel_migrations;
*/

//mod routes;
//mod cli;
//mod config;
//mod models;
//mod schema;
//mod template;
//mod controllers;

//use std::process::exit;

//use clap::Parser;
//use figment::{Figment, Profile, providers::{Format, Toml, Env}};
//use rocket_sync_db_pools::database;
//use diesel::prelude::*;

mod errors;
mod dns;
mod routes;
mod ressouces;
mod database;
mod validation;
mod macros;

use std::sync::Arc;

use axum::Router;
use axum::routing;
use database::sqlite::SqliteDB;
use database::Db;
use dns::dns_driver::DnsDriverConfig;
use dns::dns_driver::TsigConfig;
use dns::{ZoneDriver, RecordDriver};


#[derive(Clone)]
pub struct AppState {
    zone: Arc<dyn ZoneDriver>,
    records: Arc<dyn RecordDriver>,
    db: Arc<dyn Db>,
}



#[tokio::main]
async fn main() {
    let dns_driver = dns::dns_driver::DnsDriver::from_config(DnsDriverConfig {
        address: "127.0.0.1:5353".parse().unwrap(),
        tsig: Some(TsigConfig {
            key_name: "dev".parse().unwrap(),
            secret: domain::utils::base64::decode::<Vec<u8>>("mbmz4J3Efm1BUjqe12M1RHsOnPjYhKQe+2iKO4tL+a4=").unwrap(),
            algorithm: domain::tsig::Algorithm::Sha256,
        })
    });

    let dns_driver = Arc::new(dns_driver);

    let app_state = AppState {
        zone: dns_driver.clone(),
        records: dns_driver.clone(),
        db: Arc::new(SqliteDB::new("db.sqlite".into()).await),
    };

    let app = Router::new()
        .route("/admin/zones", routing::post(routes::api::zones::create_zone))
        .route("/zones/{zone_name}/records", routing::get(routes::api::zones::get_zone_records))
        .route("/zones/{zone_name}/records", routing::post(routes::api::zones::create_zone_records))
        .with_state(app_state);

    let listener = tokio::net::TcpListener::bind("127.0.0.1:8000").await.unwrap();
    axum::serve(listener, app).await.unwrap();
}



/*
use crate::cli::{NomiloCli, NomiloCommand};

#[database("sqlite")]
pub struct DbConn(diesel::SqliteConnection);


pub fn get_db_conn(figment: &Figment) -> diesel::SqliteConnection {
    let url = match figment.focus("databases.sqlite").extract_inner::<String>("url") {
        Ok(url) => url,
        Err(e) => {
            eprintln!("Error loading configuration: {}", e);
            exit(1);
        }
    };

    match diesel::SqliteConnection::establish(&url) {
        Ok(c) => c,
        Err(e) => {
            eprintln!("Error connecting to database at \"{}\": {}", url, e);
            exit(1);
        }
    }
}


fn main() {
    let figment = Figment::from(rocket::Config::default())
        .merge(Toml::file(Env::var_or("NOMILO_CONFIG", "nomilo.toml")).nested())
        .merge(Env::prefixed("NOMILO_").ignore(&["PROFILE"]).global())
        .select(Profile::from_env_or("NOMILO_PROFILE", "release"));

    let app_config = match figment.extract::<config::Config>() {
        Ok(c) => c,
        Err(e) => {
            eprintln!("Error loading configuration: {}",  e);
            exit(1);
        }
    };

    let nomilo = NomiloCli::parse();
    nomilo.run(figment, app_config);
}
*/