pfp 0.3.1

Prefect CLI - a fast Rust CLI for managing Prefect deployments and flow runs
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

use crate::models::{Deployment, FlowRun, LogEntry};
use colored::Colorize;

pub fn state_color(state: &str) -> colored::ColoredString {
    match state.to_uppercase().as_str() {
        "COMPLETED" | "ACTIVE" => state.green(),
        "FAILED" | "CRASHED" => state.red(),
        "RUNNING" => state.blue(),
        "PENDING" | "SCHEDULED" => state.yellow(),
        "CANCELLED" | "PAUSED" => state.magenta(),
        _ => state.normal(),
    }
}

pub fn print_deployments_table(deployments: &[Deployment]) {
    println!("{:<50} {:<8} WORK POOL", "DEPLOYMENT", "STATUS");
    for d in deployments {
        let status = state_color(d.status_str().to_uppercase().as_str());
        println!(
            "{:<50} {:<8} {}",
            d.full_name(),
            status,
            d.work_pool_name.as_deref().unwrap_or("-"),
        );
    }
}

pub fn print_flow_runs_table(runs: &[FlowRun]) {
    println!(
        "{:<26} {:<12} {:<20} {:<10} ID",
        "FLOW RUN", "STATE", "STARTED", "DURATION"
    );
    for r in runs {
        let state = state_color(&r.state_type);
        println!(
            "{:<26} {:<12} {:<20} {:<10} {}",
            truncate(&r.name, 26),
            state,
            r.start_time_short(),
            r.duration_str(),
            r.short_id(),
        );
    }
}

pub fn print_logs(logs: &[LogEntry]) {
    for log in logs {
        let ts = if log.timestamp.len() >= 19 {
            &log.timestamp[..19]
        } else {
            &log.timestamp
        };
        let name = log.level_name();
        let level = match name {
            "ERROR" | "CRITICAL" => name.red(),
            "WARNING" => name.yellow(),
            "INFO" => name.blue(),
            _ => name.dimmed(),
        };
        println!("{} | {:<8} | {}", ts, level, log.message);
    }
}

pub fn print_watch_state(state_name: &str, timestamp: &str) {
    let ts = if timestamp.len() >= 19 {
        &timestamp[11..19]
    } else {
        timestamp
    };
    let state = state_color(state_name);
    println!("{} | {}", ts, state);
}

pub fn print_json<T: serde::Serialize>(value: &T) {
    println!("{}", serde_json::to_string_pretty(value).unwrap());
}

fn truncate(s: &str, max_len: usize) -> String {
    if s.len() <= max_len {
        s.to_string()
    } else {
        format!("{}...", &s[..max_len - 3])
    }
}

#[cfg(test)]
mod tests {
    use super::*;
    use std::ops::Deref;

    #[test]
    fn state_color_completed() {
        assert_eq!(state_color("COMPLETED").deref(), "COMPLETED");
    }

    #[test]
    fn state_color_case_insensitive() {
        assert_eq!(state_color("completed").deref(), "completed");
    }

    #[test]
    fn truncate_short_unchanged() {
        assert_eq!(truncate("hello", 10), "hello");
    }

    #[test]
    fn truncate_long_adds_ellipsis() {
        assert_eq!(truncate("hello world!", 8), "hello...");
    }

    #[test]
    fn truncate_exact_length() {
        assert_eq!(truncate("hello", 5), "hello");
    }
}