fips 1.0.1

A powerful mock server supported by a plugin system
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

use std::alloc::System;

#[global_allocator]
static ALLOCATOR: System = System;

use clap::Parser;
use configuration::configuration::Config;
use std::fs::File;
use std::sync::Arc;
use tokio::runtime::Runtime;

mod backend;
mod configuration;
mod fips;
mod plugin_registry;
mod terminal_ui;
mod utility;

use crate::configuration::ruleset::RuleSet;
use crate::utility::log::Loggable;
use crate::utility::options::CliOptions;

use tokio::sync::Mutex as AsyncMutex;

#[cfg(feature = "logging")]
mod logging;

#[cfg(feature = "ui")]
mod frontend;

type LogFunction = Box<dyn Fn(&Loggable) + Send + Sync>;

pub struct PaintLogsCallbacks(LogFunction);

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let cli_options = CliOptions::parse();

    #[cfg(feature = "logging")]
    {
        logging::init()?;
        log::info!("Starting FIPS on port {} with config paths: {:?}", cli_options.port, cli_options.config);
        std::panic::set_hook({
            Box::new(|e| {
                log::error!("Panic: {}", e);
            })
        });
    }

    if cli_options.write_schema {
        let schema = schemars::schema_for!(Vec<RuleSet>);
        serde_json::to_writer(&File::create("fips-schema.json")?, &schema)?;
        //exit early
        return Ok(());
    };

    //TODO: get rid of duplication caused by introduction of async mutex
    let async_configuration = Arc::new(AsyncMutex::new(
        Config::load(&cli_options.config).unwrap_or_default(),
    ));

    let (_state, _app, logging) = {
        #[cfg(feature = "ui")]
        let (state, app, logging) = {
            frontend::setup(
                Arc::clone(&async_configuration),
                cli_options.clone(),
            )
            .await
        };
        #[cfg(not(feature = "ui"))]
        let (state, app, logging) = { backend::setup() };
        (state, app, logging)
    };

    let addr = ([127, 0, 0, 1], cli_options.port).into();
    let runtime = Runtime::new().unwrap();
    let _guard = runtime.enter();

    let _rt_handle =
        backend::spawn_backend(&async_configuration, &addr, &logging);

    #[cfg(feature = "ui")]
    {
        frontend::spawn_frontend(_app, runtime).await?;
    }

    #[cfg(not(feature = "ui"))]
    {
        println!("FIPS server running on http://127.0.0.1:{}", cli_options.port);
        println!("Config paths: {:?}", cli_options.config);
        _rt_handle.await?.unwrap();
    }

    Ok(())
}