twinleaf-tools 2.0.0

Tools for the Twinleaf I/O protocol for reading data from Twinleaf quantum sensors.
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

use std::process::ExitCode;
use twinleaf_tools::{Commands, DumpSubcommands, LogSubcommands, RPCSubcommands, TioCli};
use clap::Parser;
use twinleaf_tools::tools::{
    tio_proxy::run_proxy,
    tio_text_proxy::run_text_proxy,
    tio_monitor::run_monitor, 
    tio_health::run_health,  
    tio_tool::{
        list_rpcs, 
        rpc, 
        rpc_dump, 
        dump, 
        data_dump_all_deprecated, 
        data_dump_deprecated, 
        meta_dump_deprecated,
        log, 
        log_dump, 
        log_data_dump_deprecated,
        log_metadata,
        meta_reroute,
        log_csv, 
        log_hdf, 
        firmware_upgrade, 
    }
};

fn main() -> ExitCode {
    let cli = TioCli::parse();

    //TODO: Work on exit code logic  
    let result = match cli.command {
        Commands::Proxy(proxy_cli) => run_proxy(proxy_cli), 
        Commands::Monitor{
            tio, 
            all, 
            fps, 
            colors
        } => run_monitor(tio, all, fps, colors), 
        Commands::Health(health_cli) => run_health(health_cli), 
        Commands::NmeaProxy{tio, tcp_port} => run_text_proxy(tio, tcp_port),
        Commands::Rpc {
            tio, 
            subcommands,
            rpc_name,
            rpc_arg,
            req_type,
            rep_type,
            debug
        } => {
            let _= match subcommands{
                Some(RPCSubcommands::List { tio }) => list_rpcs(&tio), 
                Some(RPCSubcommands::Dump { tio, rpc_name, capture }) 
                => rpc_dump(&tio, rpc_name, capture),
                None => rpc(&tio, rpc_name.unwrap_or("".to_string()), rpc_arg, req_type, rep_type, debug),
            };
            Ok(())
        }
        Commands::Dump {
            tio,
            subcommands,
            data, 
            meta, 
            depth,
        } => {
            let _ = match subcommands { 
                Some(DumpSubcommands::Data { tio }) => data_dump_deprecated(&tio), 
                Some(DumpSubcommands::DataAll { tio }) => data_dump_all_deprecated(&tio),
                Some(DumpSubcommands::Meta { tio }) => meta_dump_deprecated(&tio), 
                None => dump(&tio, data, meta, depth),
            }; 
            Ok(())
        } 
        Commands::Log {
            tio,
            subcommands,
            file,
            unbuffered,
            raw,
            depth,
        } => {
            let _= match subcommands{
                Some(LogSubcommands::Metadata { tio, file })
                => log_metadata(&tio, file),
                Some(LogSubcommands::Dump { files, data, meta, sensor, depth })
                => log_dump(files, data, meta, sensor, depth), 
                Some(LogSubcommands::DataDump { files}) => log_data_dump_deprecated(files), 
                Some(LogSubcommands::Csv { args, sensor, output})                
                => log_csv( args, sensor, output), 
                Some(LogSubcommands::Hdf { files, output, filter, compress, debug, split_level, split_policy })
                => log_hdf(files, output, filter, compress, debug, split_level, split_policy),
                None => log(&tio, file, unbuffered, raw, depth),
            }; 
            Ok(())
        }
        Commands::MetaReroute { input, route, output } 
        => meta_reroute(input, route, output),
        Commands::FirmwareUpgrade { tio, firmware_path } => firmware_upgrade(&tio, firmware_path),
    };

    if result.is_ok() {
        ExitCode::SUCCESS
    } else {
        eprintln!("FAILED");
        ExitCode::FAILURE
    }
}