flow-iron 0.3.5

Infrastructure-as-code CLI — deploy Docker Compose apps with Caddy reverse proxy and Cloudflare DNS
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

#![allow(clippy::unwrap_used)]

use iron::compose::{generate, generate_env};
use iron::config::*;

fn simple_app() -> ResolvedApp {
    ResolvedApp {
        name: "site".to_string(),
        image: "ghcr.io/flow-industries/site:latest".to_string(),
        servers: vec!["flow-1".to_string()],
        port: Some(3000),
        deploy_strategy: DeployStrategy::Rolling,
        routing: Some(Routing {
            routes: vec!["flow.industries".to_string()],
            health_path: Some("/health".to_string()),
            health_interval: Some("5s".to_string()),
        }),
        env: std::collections::HashMap::new(),
        services: vec![],
        ports: vec![],
    }
}

#[test]
fn generate_simple_compose() {
    let app = simple_app();
    let output = generate(&app, "flow");
    assert!(output.contains("image: ghcr.io/flow-industries/site:latest"));
    assert!(output.contains("wud.trigger.include=rollout"));
    assert!(output.contains("networks:"));
    assert!(output.contains("flow:"));
    assert!(output.contains("wget"));
    assert!(output.contains("/health"));
}

#[test]
fn generate_recreate_strategy() {
    let mut app = simple_app();
    app.deploy_strategy = DeployStrategy::Recreate;
    let output = generate(&app, "flow");
    assert!(output.contains("wud.trigger.include=gameupdate"));
}

#[test]
fn generate_with_ports() {
    let app = ResolvedApp {
        name: "game-server".to_string(),
        image: "ghcr.io/flow-industries/game-server:latest".to_string(),
        servers: vec!["game-1".to_string()],
        port: None,
        deploy_strategy: DeployStrategy::Recreate,
        routing: None,
        env: [("REGION".into(), "eu".into())].into(),
        services: vec![],
        ports: vec![PortMapping {
            internal: 9999,
            external: 9999,
            protocol: "tcp".to_string(),
        }],
    };
    let output = generate(&app, "flow");
    assert!(output.contains("\"9999:9999\""));
    assert!(!output.contains("networks:"));
}

#[test]
fn generate_with_sidecars() {
    let app = ResolvedApp {
        name: "auth".to_string(),
        image: "ghcr.io/flow-industries/auth:latest".to_string(),
        servers: vec!["flow-1".to_string()],
        port: Some(3000),
        deploy_strategy: DeployStrategy::Rolling,
        routing: Some(Routing {
            routes: vec!["id.flow.industries".to_string()],
            health_path: Some("/health".to_string()),
            health_interval: None,
        }),
        env: [("NODE_ENV".into(), "production".into())].into(),
        services: vec![
            ResolvedSidecar {
                name: "postgres".to_string(),
                image: "postgres:17".to_string(),
                volumes: vec!["pgdata:/var/lib/postgresql/data".to_string()],
                env: [("POSTGRES_USER".into(), "flow".into())].into(),
                healthcheck: Some("pg_isready -U flow -d flow_auth".to_string()),
                depends_on: None,
            },
            ResolvedSidecar {
                name: "backup".to_string(),
                image: "prodrigestivill/postgres-backup-local".to_string(),
                volumes: vec!["./backups:/backups".to_string()],
                env: [("POSTGRES_HOST".into(), "postgres".into())].into(),
                healthcheck: None,
                depends_on: Some("postgres".to_string()),
            },
        ],
        ports: vec![],
    };
    let output = generate(&app, "flow");
    assert!(output.contains("postgres:"));
    assert!(output.contains("pg_isready"));
    assert!(output.contains("wud.watch=false"));
    assert!(output.contains("pgdata:"));
    assert!(output.contains("depends_on:"));
}

#[test]
fn generate_custom_network_name() {
    let app = simple_app();
    let output = generate(&app, "mynet");
    assert!(output.contains("- mynet"));
    assert!(output.contains("mynet:"));
    assert!(output.contains("external: true"));
}

#[test]
fn generate_env_file() {
    let app = ResolvedApp {
        name: "auth".to_string(),
        image: "test".to_string(),
        servers: vec![],
        port: Some(3000),
        deploy_strategy: DeployStrategy::Rolling,
        routing: None,
        env: [
            ("DB_PASSWORD".into(), "secret123".into()),
            ("NODE_ENV".into(), "production".into()),
        ]
        .into(),
        services: vec![ResolvedSidecar {
            name: "postgres".to_string(),
            image: "postgres:17".to_string(),
            volumes: vec![],
            env: [("POSTGRES_USER".into(), "flow".into())].into(),
            healthcheck: None,
            depends_on: None,
        }],
        ports: vec![],
    };
    let env = generate_env(&app);
    assert!(env.contains("DB_PASSWORD=secret123"));
    assert!(env.contains("NODE_ENV=production"));
    assert!(env.contains("POSTGRES_USER=flow"));
}