README.md update

Signed-off-by: Ralf Zerres <ralf.zerres@networkx.de>

src/main.rs

@@ -1,7 +1,7 @@
 /* advotracker infrastructure.
  *
  * Copyright 2019 Ralf Zerres <ralf.zerres@networkx.de>
- * SPDX-License-Identifier: 0BSD
+ * SPDX-License-Identifier: (0BSD or MIT)
  */
 
 // Rust nightly supports procedural macros!
@@ -10,11 +10,18 @@
 
 //use clap::{ArgMatches, Arg, App, SubCommand};
 use clap::ArgMatches;
+
 use serde::Deserialize;
 use std::{env, process};
 use dotenv::dotenv;
 use locales::t;
-use tracing::{debug, info, instrument, span, Level};
+//use tracing::{debug, info, instrument, span, Level};
+//use tracing::{debug, info, instrument, Level, Metadata, span::{Id, Attributes, Record}, trace};
+//use tracing::{debug, instrument, span::*, trace, Level};
+use tracing::{debug, instrument, trace, Level};
+
+//use diesel::prelude::*;
+//use diesel::sqlite::SqliteConnection;
 
 #[derive(Deserialize, Debug)]
 struct Environment {
@@ -26,11 +33,27 @@ struct Args {
     my_conifg: String,
     verbose: String,
 }
+
+pub struct AdvoTrackerSubscriber;
+
+impl tracing::Subscriber for AdvoTrackerSubscriber{
+  fn new_span(&self, _: &Attributes) -> Id { Id::from_u64(0) }
+  fn record(&self, _: &Id, _: &Record) {}
+  fn event(&self, _: &tracing::Event) {}
+  fn record_follows_from(&self, _: &Id, _: &Id) {}
+  fn enabled(&self, _: &Metadata) -> bool { false }
+  fn enter(&self, _: &Id) {}
+  fn exit(&self, _: &Id) {}
+}
+
+impl AdvoTrackerSubscriber {
+  fn new() -> Self { AdvoTrackerSubscriber }
+}
  */
 
 #[instrument]
 fn run_subcommand(matches: &ArgMatches) -> Result<(), String> {
-    info!("inside run_subcommand");
+    //info!("inside run_subcommand");
     match matches.subcommand() {
         ("config", Some(cmd)) => run_config(cmd),
         ("test", Some(cmd)) => run_test(cmd),
@@ -39,14 +62,14 @@ fn run_subcommand(matches: &ArgMatches) -> Result<(), String> {
 }
 
 fn run_config(matches: &ArgMatches) -> Result<(), String> {
-    info!("inside run_config");
+    //info!("inside run_config");
     let _input = matches.value_of("FILE").unwrap();
     Ok(())
 }
 
 
 fn run_test(matches: &ArgMatches)  -> Result<(), String> {
-    info!("inside run_test");
+    //info!("inside run_test");
 
     if let Some(matches) = matches.subcommand_matches("test") {
         if matches.is_present("debug") {
@@ -63,38 +86,72 @@ fn run_test(matches: &ArgMatches)  -> Result<(), String> {
 //[context_attribute::context]
 //#[throw]
 //fn main(args: Args) throw {
-fn main() {
+fn main() -> std::io::Result<()> {
     //initialize tracing eco-system
     use tracing_subscriber::fmt;
 
-    let span = span!(Level::TRACE, "advotracker_main");
+    //let advotracker_subscriber = AdvoTrackerSubscriber::new();
+    //tracing::subscriber::set_global_default(advotracker_subscriber)
+    //    .expect("setting tracing default failed");
+
+    let span = tracing::span!(Level::TRACE, "advotracker_main");
     let _enter = span.enter();
     let subscriber = fmt::Subscriber::builder()
         .with_env_filter("advotracker=trace")
         .finish();
 
     tracing::subscriber::with_default(subscriber, || {
-        // get testing environment (.env)
+        // get system environment
+        let mut lang = env::var("LANG").unwrap_or("en".to_string());
+        let mut res = t!("parse.environment", lang);
+        let mut state = t!("state.started", lang);
         debug!(
-            message = "Reading Environment ...",
-            finished = "no!"
+            message = ?res,
+            state = ?state
+        );
+        trace!(
+            target: "advotracker",
+            environment = "system",
+            lang = ?lang
         );
 
+        // get testing environment (.env)
         dotenv().ok();
-        let mut lang = env::var("LANG").unwrap_or("en".to_string());
         match envy::from_env::<Environment>() {
             Ok(environment) => {
                 if environment.test_lang != lang { lang = environment.test_lang; }
             },
-            Err(e) => println!("Couldn't read LANG ({:#?})", e),
-        };
-        let res = t!("parse.environment", lang);
-        info!(target: "advotracker_event", "{}", res);
-        info!(target: "advotracker_event", "{}", lang);
+            //Err(e) => { debug!( message = "No Lang", "{}", e); }
+            Err(e) => { debug!(target: "advotracker", "{}", e); }
+            //error = "{:#?}", e"
+        }
+        res = t!("parse.environment", lang);
+        trace!(
+            target: "advotracker",
+            environment = "envy",
+            lang = ?lang
+        );
+        //info!(target: "advotracker", "{}", res);
+        //info!(target: "advotracker", "{}", lang);
+        state = t!("state.finished", lang);
+        debug!(
+            message = ?res,
+            state = ?state
+        );
 
         // handle commandline arguments with clap (relative path to cli.yml)
-        let res = t!("parse.arguments", lang);
-        info!(target: "advotracker_event", "{}", res);
+        res = t!("parse.arguments", lang);
+        state = t!("state.started", lang);
+        //info!(target: "advotracker", "{}", res);
+        debug!(
+            message = ?res,
+            state = ?state,
+        );
+        trace!(
+            target: "advotracker",
+            process = ?res,
+            state = ?state
+        );
 
         let yaml = clap::load_yaml!("cli.yml");
         let matches = clap::App::from_yaml(yaml)
@@ -110,11 +167,11 @@ fn main() {
         let verbose = matches.occurrences_of("verbose");
 
         if verbose > 0 {
-            let res_name = t!("config.name.configfile", lang);
+            let mut res_name = t!("config.name.configfile", lang);
             println!("{}: {}", res_name, config);
-            let res_name = t!("config.name.dbdriver", lang);
+            res_name = t!("config.name.dbdriver", lang);
             println!("{}: {}", res_name, dbdriver);
-            let res_name = t!("config.name.verbositylevel", lang);
+            res_name = t!("config.name.verbositylevel", lang);
             println!("{}: {}", res_name, matches.occurrences_of("verbose"));
         }
 
@@ -122,8 +179,17 @@ fn main() {
             for (key, value) in env::vars() {
                 println!("{}={}", key, value);
             }
-            println!("\n");
         }
+        state = t!("state.finished", lang);
+        trace!(
+            target: "advotracker",
+            process = ?res,
+            state = ?state
+        );
+        debug!(
+            message = ?res,
+            state = ?state
+        );
 
         // handle subcommands
         if let Err(e) = run_subcommand(&matches) {
@@ -132,7 +198,60 @@ fn main() {
         }
 
         // Starting the program logic
-        let res = t!("main.start", lang);
-        println!("{}", &res);
+        res = t!("main.started", lang);
+        //info!(target: "advotracker", "{}", res);
+        trace!(
+            target: "advotracker",
+            process = ?res,
+            state = ?state
+        );
+
+        //use advotracker_backend::*;
+        //use advotracker_backend::schema::users::dsl::*;
+
+        /* 
+        let connection = establish_connection();
+
+        trace!(
+            target: "advotracker",
+            process = "Sqlite3",
+            status = "connected",
+        );
+         */
+        
+        /*
+        //User::table.load(&connection);
+        //user::belonging_to(users).load(&connection);
+        use advotracker_backend::models::*;
+
+
+        let results = users
+            //.filter(published.eq(true))
+            .limit(5)
+            .load::<User>(&connection)
+            .expect("Error loading users");
+
+        println!("Displaying {} users", results.len());
+        for user in results {
+            println!("{}", user.user_id);
+            println!("----------\n");
+            println!("{}", user.first_name);
+            println!("{}", user.last_name);
+            println!("{}", user.alias);
+            println!("{}", user.email);
+        }
+
+        state = t!("state.finished", lang);
+        res = t!("main.finished", lang);
+        //info!(target: "advotracker", "{}", res);
+        trace!(
+            target: "advotracker",
+            process = ?res,
+            state = ?state
+        );
+         */
+        
     });
+
+    Ok(())
 }