thepipelinetool 0.2.2

readers used for thepipelinetool
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
110
111
112
113
114
115
116
117
118
119
120

use std::{
    cmp::max,
    env,
    path::{Path, PathBuf},
    process,
};

use circular_dependencies::check_circular_dependencies;
use clap::ArgMatches;
use graph::{display_graphite_graph, display_mermaid_graph};
use hash::display_hash;
use thepipelinetool_core::dev::*;
use thepipelinetool_runner::{in_memory::run_in_memory, options::DagOptions};
use tree::display_tree;

pub mod binary;
pub mod circular_dependencies;
pub mod commands;
pub mod graph;
pub mod hash;
pub mod template;
pub mod tree;
pub mod yaml;

fn display_options(options: &DagOptions) {
    print!("{}", serde_json::to_string_pretty(options).unwrap());
}

#[derive(PartialEq)]
pub enum DagType {
    Binary,
    YAML,
}

pub fn get_dag_type_by_path(path: PathBuf) -> DagType {
    if let Some(ext) = path.extension() {
        match ext.to_str().unwrap() {
            "yaml" => {
                return DagType::YAML;
            }
            _ => {}
        }
    }
    DagType::Binary
}

pub fn process_subcommands(
    dag_path: &Path,
    dag_name: &str,
    subcommand_name: &str,
    options: &DagOptions,
    matches: &ArgMatches,
) {
    let tasks = &get_tasks().read().unwrap();
    let edges = &get_edges().read().unwrap();

    match subcommand_name {
        "describe" => match matches
            .subcommand_matches("describe")
            .unwrap()
            .subcommand_name()
            .unwrap()
        {
            "tasks" => display_tasks(),
            "edges" => display_edges(),
            "hash" => display_hash(tasks, edges),
            "options" => display_options(options),
            _ => {}
        },
        "graph" => match matches
            .subcommand_matches("graph")
            .unwrap()
            .get_one::<String>("graph_type")
            .unwrap()
            .as_str()
        {
            "mermaid" => display_mermaid_graph(tasks, edges),
            "graphite" => display_graphite_graph(tasks, edges),
            _ => {}
        },

        "tree" => display_tree(tasks, edges, dag_path),
        "check" => check_circular_dependencies(tasks, edges),
        "run" => {
            let matches = matches.subcommand_matches("run").unwrap();
            match matches.subcommand_name().unwrap() {
                "in_memory" => {
                    let num_threads = match matches
                        .subcommand_matches("in_memory")
                        .unwrap()
                        .get_one::<String>("num_threads")
                        .unwrap()
                        .as_str()
                    {
                        "max" => max(
                            usize::from(std::thread::available_parallelism().unwrap()) - 1,
                            1,
                        ),
                        any => any.parse::<usize>().unwrap(),
                    };

                    check_circular_dependencies(tasks, edges);
                    let exit_code = run_in_memory(
                        tasks,
                        edges,
                        dag_name.to_string(),
                        env::args().next().unwrap(),
                        num_threads,
                    );

                    process::exit(exit_code);
                }
                "function" => run_function(matches),

                _ => {}
            }
        }
        _ => {}
    }
}