phlow-runtime 0.4.2

Phlow is a fast, modular runtime for building backends with YAML flows, Rust modules, and native OpenTelemetry observability.
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
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147

use cli::{Cli, Error};
use envs::Envs;

pub mod cli;
pub mod envs;
pub use cli::PrintOutput;

#[derive(Debug, Clone)]
pub struct Settings {
    pub script_main_absolute_path: String,
    pub only_download_modules: bool,
    pub package_path: Option<String>,
    pub package_target: String,
    pub create_tar: bool,
    pub no_run: bool,
    pub download: bool,
    pub print_yaml: bool,
    pub print_output: PrintOutput,
    pub test: bool,
    pub test_filter: Option<String>,
    pub var_main: Option<String>,
    pub var_payload: Option<String>,
    pub start_step: Option<String>,
    // analyzer
    pub analyzer: bool,
    pub analyzer_files: bool,
    pub analyzer_modules: bool,
    pub analyzer_total_steps: bool,
    pub analyzer_total_pipelines: bool,
    pub analyzer_json: bool,
    pub analyzer_inner: bool,
    pub analyzer_all: bool,

    // envs
    pub package_consumer_count: i32,
    #[cfg(target_env = "gnu")]
    pub min_allocated_memory: usize,
    #[cfg(target_env = "gnu")]
    pub garbage_collection: bool,
    #[cfg(target_env = "gnu")]
    pub garbage_collection_interval: u64,
    pub default_package_repository_url: String,
}

impl Settings {
    pub fn try_load() -> Result<Self, Error> {
        let cli = Cli::load()?;
        let envs = Envs::load();

        let main_target = cli.main_target.unwrap_or(envs.main.clone());

        let current_path = std::env::current_dir()
            .unwrap_or_else(|_| "./".into())
            .to_string_lossy()
            .to_string();

        let script_main_absolute_path = if main_target.starts_with(".") {
            format!("{}/{}", current_path, main_target)
        } else {
            main_target.clone()
        };

        let settings = Self {
            script_main_absolute_path,
            only_download_modules: cli.only_download_modules,
            package_path: cli.package_path,
            package_target: cli.package_target,
            create_tar: cli.create_tar,
            no_run: cli.no_run,
            analyzer: cli.analyzer,
            analyzer_files: cli.analyzer_files,
            analyzer_modules: cli.analyzer_modules,
            analyzer_total_steps: cli.analyzer_total_steps,
            analyzer_total_pipelines: cli.analyzer_total_pipelines,
            analyzer_json: cli.analyzer_json,
            analyzer_inner: cli.analyzer_inner,
            analyzer_all: cli.analyzer_all,
            package_consumer_count: envs.package_consumer_count,
            #[cfg(target_env = "gnu")]
            min_allocated_memory: envs.min_allocated_memory,
            #[cfg(target_env = "gnu")]
            garbage_collection: envs.garbage_collection,
            #[cfg(target_env = "gnu")]
            garbage_collection_interval: envs.garbage_collection_interval,
            default_package_repository_url: envs.default_package_repository_url,
            download: cli.download,
            print_yaml: cli.print_yaml,
            print_output: cli.print_output,
            test: cli.test,
            test_filter: cli.test_filter,
            var_main: cli.var_main,
            var_payload: cli.var_payload,
            start_step: cli.start_step,
        };

        Ok(settings)
    }

    pub fn for_runtime() -> Self {
        let envs = Envs::load();

        let current_path = std::env::current_dir()
            .unwrap_or_else(|_| "./".into())
            .to_string_lossy()
            .to_string();

        let main_target = envs.main.clone();
        let script_main_absolute_path = if main_target.starts_with(".") {
            format!("{}/{}", current_path, main_target)
        } else {
            main_target.clone()
        };

        Self {
            script_main_absolute_path,
            only_download_modules: false,
            package_path: None,
            package_target: "./phlow_packages".to_string(),
            create_tar: false,
            no_run: false,
            download: true,
            print_yaml: false,
            print_output: PrintOutput::Yaml,
            test: false,
            test_filter: None,
            var_main: None,
            var_payload: None,
            start_step: None,
            analyzer: false,
            analyzer_files: false,
            analyzer_modules: false,
            analyzer_total_steps: false,
            analyzer_total_pipelines: false,
            analyzer_json: false,
            analyzer_inner: false,
            analyzer_all: false,
            package_consumer_count: envs.package_consumer_count,
            #[cfg(target_env = "gnu")]
            min_allocated_memory: envs.min_allocated_memory,
            #[cfg(target_env = "gnu")]
            garbage_collection: envs.garbage_collection,
            #[cfg(target_env = "gnu")]
            garbage_collection_interval: envs.garbage_collection_interval,
            default_package_repository_url: envs.default_package_repository_url,
        }
    }
}