oxidux 0.4.0

Reverse proxy and process manager for web app development.
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

use std::sync::Arc;
use std::time::Instant;

use futures::future::join_all;
use futures::Stream;
use tokio::sync::RwLock;

use crate::config;
use crate::process::Process;

// Follow Heroku convention of "web" as the label for primary process
const DEFAULT_PROCESS: &str = "web";

#[derive(Clone, Debug)]
pub struct App {
    /// App name. This serves as the primary app domain as well as a unique identifer.
    name: String,
    /// Port app server process binds to
    port: u16,
    /// App working directory
    directory: String,
    command_config: config::CommandConfig,
    /// Headers added to proxied request to the app
    headers: hyper::HeaderMap,
    /// List of processes for this app
    pub processes: Vec<Process>,
    /// Domain TLD suffix, defaults to ".test"
    tld: String,
    /// Alternate domain names for app
    aliases: Vec<String>,
    /// Last time app was accessed
    last_hit: Arc<RwLock<Instant>>,
}

impl App {
    pub fn from_config(app_config: &config::App, auto_port: u16, tld: String) -> Self {
        let port = app_config.port.unwrap_or(auto_port);

        let processes = app_config
            .commands()
            .into_iter()
            .map(|(name, command)| Process::from_config(app_config, name, command, port))
            .collect();

        Self {
            name: app_config.name.clone(),
            port,
            command_config: app_config.command_config.clone(),
            directory: app_config.full_path(),
            headers: app_config.parsed_headers(),
            processes,
            tld,
            aliases: app_config.aliases.clone(),
            last_hit: Arc::new(RwLock::new(Instant::now())),
        }
    }

    pub fn directory(&self) -> &str {
        self.directory.as_ref()
    }

    pub fn name(&self) -> &str {
        self.name.as_ref()
    }

    pub fn port(&self) -> u16 {
        self.port
    }

    pub async fn start(&self) {
        for process in &self.processes {
            if let Err(error) = process.start().await {
                eprint!(
                    "Process {} failed to start with error: {}",
                    process.name().await,
                    error
                )
            }
        }
    }

    pub async fn stop(&self) {
        for process in &self.processes {
            process.stop().await
        }
    }

    pub async fn is_running(&self) -> bool {
        for process in &self.processes {
            if process.is_running().await {
                return true;
            }
        }

        false
    }

    pub fn headers(&self) -> &hyper::HeaderMap {
        &self.headers
    }

    pub async fn default_process(&self) -> Option<&Process> {
        self.find_process(DEFAULT_PROCESS)
            .await
            .or_else(|| self.processes.first())
    }

    pub async fn find_process(&self, name: &str) -> Option<&Process> {
        for process in &self.processes {
            if process.process_name().await == name {
                return Some(process);
            }
        }

        None
    }

    pub fn tld(&self) -> &str {
        &self.tld
    }

    pub async fn output_stream(&self) -> impl Stream<Item = (Process, String)> {
        eprintln!("Registering output listener");

        let streams = join_all(self.processes.iter().map(Process::register_output_watcher)).await;

        futures::stream::select_all(streams)
    }

    pub fn domains(&self) -> impl Iterator<Item = &String> + '_ {
        std::iter::once(&self.name).chain(self.aliases.iter())
    }

    /// Last time app was accessed
    pub(crate) async fn last_hit(&self) -> Instant {
        *self.last_hit.read().await
    }

    /// Refresh the last hit time
    pub(crate) async fn touch(&self) {
        *self.last_hit.write().await = Instant::now();
    }
}