kvcli 0.0.6

A distributed kv storage CLI
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
97
98
99
100
101
102
103
104
105
106
107
108
109

#![allow(unused)]

use std::fmt::{Display, Formatter};
use std::fs::File;
use std::io::{self, BufWriter, StderrLock, StdoutLock, Write};
use std::io::{BufRead, BufReader};
use std::path::PathBuf;
use std::sync::Arc;
use std::sync::atomic::{AtomicBool, Ordering};
use std::{env, panic, thread};
use std::time::Duration;
use structopt::StructOpt;
use anyhow::{Context, Result};
use signal_hook::{consts::SIGINT, iterator::Signals};
use human_panic::setup_panic;

/// Search for a pattern in a file and display the lines that contain it.
#[derive(StructOpt, Debug)]
struct Cli {
    #[structopt(short = "p", long = "port")]
    port: Option<i32>,
}

impl Display for Cli {
    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
        write!(f, "({})", self.port.as_ref().unwrap())
    }
}

/// signal-hook 可以去处理更多的 Unix 信号。 在 https://vorner.github.io/2018/06/28/signal-hook.html 中描述了它的设计原理， 且它是目前社区里支持最为广泛的库。
///
/// cargo run -- --port 3006
///
fn main() {
    setup_panic_hooks();

    if let Err(e) = run() {
        eprintln!("Error: {}", e);

        for cause in e.chain() {
            eprintln!("Caused by: {}", cause);
        }
        ::std::process::exit(1);
    }
}

fn run() -> Result<()> {
    let args = Cli::from_args();

    println!("Hello, world! {:?}", args);

    let pb = indicatif::ProgressBar::new(100);
    let running = Arc::new(AtomicBool::new(true));
    let r = running.clone();

    // signal_hook::flag::register(signal_hook::consts::SIGTERM, Arc::clone(&running))?;
    let mut signals = Signals::new(&[SIGINT])?;
    thread::spawn(move || {
        for sig in signals.forever() {
            println!("Received signal {:?}", sig);
            r.store(false, Ordering::SeqCst);
        }
    });

    println!("Waiting for Ctrl-C...");
    let mut idx = 0;
    while running.load(Ordering::SeqCst) {
        if idx >= 50 {
            break;
        }

        thread::sleep(Duration::from_secs(1));

        pb.inc(2);
        idx += 1;
    }

    pb.finish_with_message("done");
    if running.load(Ordering::SeqCst) {
        println!("idx is 100, Exiting...");
    } else {
        println!("Got it! Exiting...");
    }

    Ok(())
}

fn setup_panic_hooks() {
    let meta = human_panic::Metadata {
        version: env!("CARGO_PKG_VERSION").into(),
        name: env!("CARGO_PKG_NAME").into(),
        authors: env!("CARGO_PKG_AUTHORS").replace(":", ", ").into(),
        homepage: env!("CARGO_PKG_HOMEPAGE").into(),
    };

    let default_hook = panic::take_hook();

    if let Err(_) = env::var("RUST_BACKTRACE") {
        panic::set_hook(Box::new(move |info: &panic::PanicInfo| {
            // First call the default hook that prints to standard error.
            default_hook(info);

            // Then call human_panic.
            let file_path = human_panic::handle_dump(&meta, info);
            human_panic::print_msg(file_path, &meta)
                .expect("human-panic: printing error message to console failed");
        }));
    }
}