waitup 1.0.1

Wait for TCP ports and HTTP endpoints to be available. Essential for Docker, K8s, and CI/CD pipelines to ensure services are ready before proceeding.
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

#![allow(
    clippy::print_stdout,
    clippy::print_stderr,
    clippy::uninlined_format_args,
    reason = "example code that demonstrates library usage"
)]

//! Kubernetes init container example.
//!
//! This example demonstrates using waitup as a Kubernetes init container
//! to ensure dependencies are ready before the main application starts.
//! Run with: cargo run --example `kubernetes_init`

use std::time::Duration;
use waitup::{wait_for_connection, Target, WaitConfig};

#[tokio::main]
async fn main() -> Result<(), waitup::WaitForError> {
    println!("☸️  Kubernetes Init Container: Checking dependencies...");

    // Environment variables typically set in Kubernetes
    let db_host = std::env::var("DATABASE_HOST").unwrap_or_else(|_| "postgres-service".to_string());
    let db_port = std::env::var("DATABASE_PORT")
        .unwrap_or_else(|_| "5432".to_string())
        .parse::<u16>()
        .unwrap_or(5432);

    let cache_host = std::env::var("REDIS_HOST").unwrap_or_else(|_| "redis-service".to_string());
    let cache_port = std::env::var("REDIS_PORT")
        .unwrap_or_else(|_| "6379".to_string())
        .parse::<u16>()
        .unwrap_or(6379);

    // External API dependency
    let api_url = std::env::var("EXTERNAL_API_URL")
        .unwrap_or_else(|_| "https://api.external-service.com/health".to_string());

    let targets = vec![
        Target::tcp(&db_host, db_port)?,
        Target::tcp(&cache_host, cache_port)?,
        Target::parse(&api_url, 200)?,
    ];

    // Kubernetes-appropriate configuration
    let config = WaitConfig::builder()
        .timeout(Duration::from_secs(300)) // 5 minutes max
        .interval(Duration::from_secs(5)) // Check every 5 seconds
        .max_interval(Duration::from_secs(30))
        .max_retries(Some(60)) // Limit retries
        .wait_for_any(false) // All dependencies must be ready
        .build();

    println!("🔍 Checking dependencies:");
    for target in &targets {
        println!("  ⏳ {}", target.display());
    }

    match wait_for_connection(&targets, &config).await {
        Ok(result) => {
            println!("✅ All dependencies are ready!");
            println!(
                "📊 Completed in {:?} with {} total attempts",
                result.elapsed, result.attempts
            );

            // Log detailed results for troubleshooting
            for target_result in &result.target_results {
                println!(
                    "  ✅ {}: Ready in {:?} ({} attempts)",
                    target_result.target.display(),
                    target_result.elapsed,
                    target_result.attempts
                );
            }

            println!("🎯 Init container completed successfully. Main container can now start.");
        }
        Err(e) => {
            eprintln!("❌ Dependencies not ready: {e}");
            eprintln!("🔧 Check your service configurations and try again.");
            std::process::exit(1);
        }
    }

    Ok(())
}