entrypoint 0.2.0

opinionated application framework/wrapper that eliminates main function boilerplate
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

//! dynamic logging reload tui

use entrypoint::prelude::*;
use std::io;
use tokio::signal;

#[derive(entrypoint::clap::Parser, DotEnvDefault, Debug)]
#[command(author, version, about, long_about = None)]
struct Args {}

impl LoggerConfig for Args {
    fn default_log_layer(
        &self,
    ) -> Box<dyn tracing_subscriber::Layer<Registry> + Send + Sync + 'static> {
        let (layer, reload) = reload::Layer::new(
            tracing_subscriber::fmt::Layer::default()
                .event_format(self.default_log_format())
                .with_writer(self.default_log_writer())
                .with_filter(self.default_log_level()),
        );

        let _ = reload.modify(|layer| *layer.filter_mut() = self.default_log_level());
        //#FIXME let _ = reload.modify(|layer| {layer.inner_mut().map_event_format(|e| e);});
        let _ = reload.modify(|layer| *layer.inner_mut().writer_mut() = self.default_log_writer());

        layer.boxed()
    }
}

#[tokio::main]
#[entrypoint::entrypoint]
async fn entrypoint(_args: Args) -> entrypoint::anyhow::Result<()> {
    let logging = tokio::spawn(async {
        loop {
            tokio::time::sleep(std::time::Duration::from_millis(500)).await;
            trace!("this is a trace");
            debug!("this is a debug");
            info!("this is an info");
            warn!("this is a warn");
            error!("this is an error");
        }
    });

    let cli = tokio::spawn(async {
        loop {
            let mut input = String::new();
            if let Ok(bytes) = io::stdin().read_line(&mut input) {
                error!(input);
            }
        }
    });

    let random_changes = tokio::spawn(async {
        loop {
            tokio::time::sleep(std::time::Duration::from_millis(1000)).await;
            //let _ = reload.modify(|layer| *layer.filter_mut() = self.default_log_level());
            //let _ = reload.modify(|layer| *layer.inner_mut().writer_mut() = self.default_log_writer());
            // #FIXME - format
            // #FIXME - thread name
        }
    });

    match signal::ctrl_c().await {
        Ok(()) => {
            info!("recv'd ctrl-c; application shutdown");
        }
        Err(_) => {
            error!("failed to listen for ctrl-c");
        }
    }

    Ok(())
}