Add config file option

Author: leirn

Cargo.lock

@@ -1,6 +1,6 @@
 [package]
 name = "nav_data"
-version = "0.1.0"
+version = "0.1.5"
 edition = "2021"
 
 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
@@ -25,11 +25,12 @@ bson = "2.8.1"
 clap = { version = "4.4.18", features = ["derive"] }
 clap_derive = "4.4.7"
 futures = "0.3.30"
+serde_yaml = "0.9.30"
 
 [dependencies.uuid]
 version = "1.7.0"
 features = [
     "v4",                # Lets you generate random UUIDs
     "fast-rng",          # Use a faster (but still sufficiently random) RNG
     "macro-diagnostics", # Enable better diagnostics for compile-time UUIDs
-]
+]

Cargo.toml

@@ -9,7 +9,7 @@ LABEL maintainer="Laurent <laurent@vromman.org>" \
     org.opencontainers.image.vendor="Laurent Vromman" \
     org.opencontainers.image.documentation="https://github.com/leirn/navdata/README.md" \
     org.opencontainers.image.licenses="MIT" \
-    org.opencontainers.image.version="0.1.3" \
+    org.opencontainers.image.version="0.1.5" \
     org.opencontainers.image.url="https://github.com/leirn/navdata/" \
     org.opencontainers.image.source="https://github.com/leirn/navdata/" \
     org.opencontainers.image.revision=$VCS_REF \
@@ -20,21 +20,12 @@ COPY . /app
 RUN apt-get update && apt-get -y install sqlite3
 RUN cargo build --release
 
-FROM gcr.io/distroless/cc-debian12
+FROM gcr.io/distroless/cc-debian12:lastest
 
 ENV DATABASE_FOLDER=/data
 
 VOLUME "/data"
-
-ENV HOST=0.0.0.0
-
-ENV PORT=8080
-
-ARG DATABASE_PATH=":memory:"
-ENV DATABASE_PATH=${DATABASE_PATH}
-
-ARG TOKEN_LIST=""
-ENV TOKEN_LIST=${TOKEN_LIST}
+VOLUME "/config"
 
 ARG RUST_LOG="warn"
 ENV RUST_LOG=${RUST_LOG}
@@ -46,4 +37,4 @@ EXPOSE 8080
 
 COPY --from=build-env /app/target/release/nav_data /
 COPY --from=build-env /usr/lib/x86_64-linux-gnu/libsqlite3.so.0.8.6 /usr/lib/x86_64-linux-gnu/libsqlite3.so.0
-CMD ["./nav_data"]
+CMD ["./nav_data --config /config/config.yaml"]

Dockerfile

@@ -28,4 +28,24 @@ This data MUST NOT be used to plan real life flights.
 - ```GET /airport?search={query}``` : look for an airport based on ```query``` string. Answer first 100 results
 - ```GET /airport/{icao}``` : look for an airport based on its ICAO code
 - ```GET /navaid?search={query}``` : look for a navaid (VOR, DME, ADF...) based on ```query``` string. Answer first 100 results
-- ```GET /navaid/{icao}``` : look for an navaid based on its ICAO code
+- ```GET /navaid/{icao}``` : look for an navaid based on its ICAO code
+
+### Config file
+
+Config files must be given for docker as ```/config/config.yaml```.
+
+Format is:
+
+```yaml
+http:
+  host: 127.0.0.1
+  port: 8080
+security:
+  auth_tokens:
+    - aaaa
+    - bbbb
+    - cccc
+database:
+  backend : MONGODB # can be either SQLITE or MONGODB
+  path : mongodb://localhost:27017 # Mongo URI if mongo (mandatory. Path to sqlite file if sqlite. If sqlite and no path, memory is used
+```

README.md

@@ -0,0 +1,11 @@
+http:
+  host: 127.0.0.1
+  port: 8080
+security:
+  auth_tokens:
+    - aaaa
+    - bbbb
+    - cccc
+database:
+  backend : MONGODB # can be either SQLITE or MONGODB
+  path : mongodb://localhost:27017 # Mongo URI if mongo (mandatory. Path to sqlite file if sqlite. If sqlite and no path, memory is used

navdata_config.yaml

@@ -0,0 +1,27 @@
+use serde::Deserialize;
+
+use super::db::BackendType;
+
+#[derive(Debug, Deserialize, Default)]
+pub struct Config {
+    pub http: HttpConfig,
+    pub security: SecurityConfig,
+    pub database: DatabaseConfig,
+}
+
+#[derive(Debug, Deserialize, Default)]
+pub struct HttpConfig {
+    pub host: String,
+    pub port: u16,
+}
+
+#[derive(Debug, Deserialize, Default)]
+pub struct SecurityConfig {
+    pub auth_tokens: Vec<String>,
+}
+
+#[derive(Debug, Deserialize, Default)]
+pub struct DatabaseConfig {
+    pub backend: BackendType,
+    pub path: Option<String>,
+}

src/app/config/mod.rs

@@ -3,6 +3,7 @@ pub mod mongodb;
 pub mod sqlite;
 use self::mongodb::MongoDbBackend;
 use self::sqlite::SqliteBackend;
+use crate::app::config::Config;
 use log::error;
 use serde::{Deserialize, Serialize};
 use std::error::Error;
@@ -414,15 +415,17 @@ pub struct Navaid {
 
 pub struct AppState {
     pub database: DatabaseBackend,
+    pub config: Config,
 }
 
 pub async fn periodical_update(app_state: web::Data<AppState>) {
     let state = app_state.clone();
     state.database.periodical_update().await
 }
 
-#[derive(Clone, Copy)]
+#[derive(Clone, Copy, Debug, Default, Deserialize)]
 pub enum BackendType {
+    #[default]
     SQLITE,
     MONGODB,
 }

src/app/db/mod.rs

@@ -3,7 +3,6 @@ pub const ERROR_SQLITE_ACCESS: &str = "Error while accessing SQLite connection";
 pub const CSV_FORMAT_ERROR: &str = "CSV file does not have the right format";
 
 // Parameters
-pub const PARAM_TOKEN_LIST: &str = "TOKEN_LIST";
 pub const TOKEN_COOKIE: &str = "navaid_auth_token";
 
 // HTTP

src/app/messages.rs

@@ -1,3 +1,4 @@
+pub mod config;
 pub mod db;
 pub mod messages;
 pub mod navdata;

src/app/mod.rs

@@ -1,9 +1,8 @@
 use super::error::AuthorizationError;
+use crate::app::db::AppState;
+use crate::app::messages::TOKEN_COOKIE;
 use actix_web::dev::{forward_ready, Service, ServiceResponse, Transform};
 use actix_web::{dev::ServiceRequest, Error};
-
-use crate::app::messages::{PARAM_TOKEN_LIST, TOKEN_COOKIE};
-use std::env;
 use std::{
     future::{ready, Future, Ready},
     pin::Pin,
@@ -74,22 +73,20 @@ where
             let conn_info = req.connection_info().clone();
             let real_remote_addr = conn_info.realip_remote_addr().unwrap_or("unknown");
 
-            let tokens = env::var(PARAM_TOKEN_LIST);
-
-            let success = match tokens {
-                Ok(tokens) => {
-                    let tokens: Vec<&str> = tokens.split(",").collect();
+            let app_data = req.app_data::<AppState>().unwrap();
 
+            let success = match app_data.config.security.auth_tokens.len() {
+                // If no token set
+                0 => true,
+                _ => {
                     let token = match req.cookie(TOKEN_COOKIE) {
                         Some(cookie) => cookie.value().to_owned(),
                         None => {
                             return Err(Error::from(AuthorizationError::NoToken).into());
                         }
                     };
-                    tokens.len() == 0 || tokens.contains(&token.as_str())
+                    app_data.config.security.auth_tokens.contains(&token)
                 }
-                // If not set, bypass auth
-                Err(_) => true,
             };
 
             match success {

src/app/security/simple_token.rs

@@ -1,9 +1,11 @@
 mod app;
 use actix_cors::Cors;
 use actix_web::{middleware::Logger, web, App, HttpServer};
+use app::config::Config;
 use app::db::{periodical_update, AppState, BackendType, DatabaseBackend};
 use app::security::simple_token::SimpleToken;
 use clap::Parser;
+use std::path::PathBuf;
 
 #[derive(Parser, Debug)]
 #[command(author, version, about, long_about = None)]
@@ -31,6 +33,10 @@ struct Args {
     /// loglevel. 0 for error, 1 for warn, 2 for info, 3 for debug
     #[arg(short, long, default_value_t = 2)]
     loglevel: u8,
+
+    /// path to YAML config file
+    #[arg(short, long)]
+    config: PathBuf,
 }
 
 #[actix_web::main]
@@ -39,21 +45,40 @@ async fn main() -> std::io::Result<()> {
 
     let args = Args::parse();
 
-    let host = args.address;
-    let port = args.port;
+    let mut config = Config::default();
+    if args.config.exists() {
+        let f = std::fs::File::open(args.config).expect("Could not open file.");
+        config = serde_yaml::from_reader(f).expect("Could not read values.");
+    } else {
+        config.http.host = args.address.clone();
+        config.http.port = args.port;
 
-    let backend_type = {
-        if args.mongodb {
-            BackendType::MONGODB
-        } else {
-            BackendType::SQLITE
-        }
-    };
-    let database_path = args.db_path;
+        config.database.backend = {
+            if args.mongodb {
+                BackendType::MONGODB
+            } else {
+                BackendType::SQLITE
+            }
+        };
+        config.database.path = Some(args.db_path.clone());
+    }
+    let backend = DatabaseBackend::new(
+        config.database.backend,
+        config
+            .database
+            .path
+            .clone()
+            .unwrap_or(":memory:".to_string()),
+    )
+    .await;
 
-    let backend = DatabaseBackend::new(backend_type, database_path).await;
+    let host = config.http.host.clone();
+    let port = config.http.port;
 
-    let app_state = web::Data::new(AppState { database: backend });
+    let app_state: web::Data<AppState> = web::Data::new(AppState {
+        database: backend,
+        config: config,
+    });
 
     actix_rt::spawn(periodical_update(app_state.clone()));