script.sh

#!/bin/bash

# Configuration
TEMPLATE_DIR="templates"
OUTPUT_DIR="output"
CONFIG_FILE="vars.conf"

# Ensure output directory exists
mkdir -p "$OUTPUT_DIR"

# Function to base64 encode a value
b64encode() {
    echo -n "$1" | base64 -w 0
}

# Function to load variables from config file
load_config() {
    if [[ -f "$CONFIG_FILE" ]]; then
        source "$CONFIG_FILE"
    fi
}

# Function to evaluate and export all variables
setup_variables() {
    export CLUSTER_ENDPOINT="${CLUSTER_ENDPOINT:-172.20.0.1:6443}"
    export IMAGE_REGISTRY="${IMAGE_REGISTRY:-harbor.s.dev.clu.io.solutions}"
    export ENVIRONMENT="${ENVIRONMENT:-dev}"
    export TALOS_VERSION="${TALOS_VERSION:-v1.10.3}"
    export KUBERNETES_VERSION="${KUBERNETES_VERSION:-1.33.0}"
    export FLUXCD_BOOTSTRAP_PATH="${FLUXCD_BOOTSTRAP_PATH:-clusters/talos/management}"
    
    # Generate CLUSTER_NAME with random hash appended
    base_cluster_name="${CLUSTER_NAME:-io-test-cluster}"
    random_hash=$(openssl rand -hex 6)
    export CLUSTER_NAME="${base_cluster_name}-${random_hash}"
    
    # Evaluate base64 encoded variables
    if [[ -n "$GITHUB_DEPLOY_KEY_PRIV_B64" ]]; then
        export GITHUB_DEPLOY_KEY_PRIV_B64=$(eval echo "$GITHUB_DEPLOY_KEY_PRIV_B64")
    fi
    
    if [[ -n "$GITHUB_DEPLOY_KEY_PUB_B64" ]]; then
        export GITHUB_DEPLOY_KEY_PUB_B64=$(eval echo "$GITHUB_DEPLOY_KEY_PUB_B64")
    fi
    
    if [[ -n "$GITHUB_KNOWN_HOSTS_B64" ]]; then
        export GITHUB_KNOWN_HOSTS_B64=$(eval echo "$GITHUB_KNOWN_HOSTS_B64")
    fi
}

# Function to process a single template
process_template() {
    local template_file="$1"
    local output_file="$2"
    
    envsubst < "$template_file" > "$output_file"
    
    echo "Processed: $template_file -> $output_file"
}

# Function to generate talosctl secrets
generate_talos_secrets() {
    echo "Generating Talos secrets..."
    
    if ! command -v talosctl &> /dev/null; then
        echo "Error: talosctl command not found. Please install talosctl first."
        return 1
    fi
    
    talosctl gen secrets -f
    
    if [[ $? -eq 0 ]]; then
        echo "Talos secrets generated successfully: secrets.yaml"
    else
        echo "Error: Failed to generate Talos secrets"
        return 1
    fi
}

# Function to generate talosctl config
generate_talos_config() {
    echo "Generating Talos cluster configuration..."
    
    if ! command -v talosctl &> /dev/null; then
        echo "Error: talosctl command not found. Please install talosctl first."
        return 1
    fi
    
    # Check if required patch files exist
    local controlplane_patch="$OUTPUT_DIR/talos-controlplane.yaml"
    local worker_cpu_patch="$OUTPUT_DIR/talos-worker-mc-cpu.yaml"
    local worker_gpu_patch="$OUTPUT_DIR/talos-worker-mc-gpu.yaml"
    local flux="$OUTPUT_DIR/flux.yaml"

    if [[ ! -f "$controlplane_patch" ]]; then
        echo "Warning: Control plane patch file not found: $controlplane_patch"
        echo "Make sure you have a controlplane.tpl template file"
    fi
    
    if [[ ! -f "$worker_cpu_patch" ]]; then
        echo "Warning: Worker CPU patch file not found: $worker_cpu_patch"
        echo "Make sure you have a talos-worker-mc-cpu.tpl template file"
    fi
    
    if [[ ! -f "$worker_gpu_patch" ]]; then
        echo "Warning: Worker GPU patch file not found: $worker_gpu_patch"
        echo "Make sure you have a talos-worker-mc-gpu.tpl template file"
    fi
    
    # Check if secrets file exists
    if [[ ! -f "secrets.yaml" ]]; then
        echo "Warning: secrets.yaml not found. Run generate_talos_secrets first or ensure secrets.yaml exists"
    fi
    
    # Generate 3 control plane configurations
    echo "Generating control plane configurations..."
    for i in {1..3}; do
        local hostname_patch="[{\"op\": \"add\", \"path\": \"/machine/network/hostname\", \"value\": \"io-control-plane-$i\"}]"
        local output_file="controlplane-$i.yaml"
        
        local talosctl_cmd="talosctl gen config $CLUSTER_NAME https://$CLUSTER_ENDPOINT"
        

        # Add patch files: cp mc and flux to 1, only cp mc for -2 and -3
        if [[ -f "$controlplane_patch" ]]; then
            if [[ $i -eq 1 ]]; then
                talosctl_cmd="$talosctl_cmd --config-patch-control-plane @$controlplane_patch --config-patch-control-plane @$flux"
            else
                talosctl_cmd="$talosctl_cmd --config-patch-control-plane @$controlplane_patch"
            fi
        fi
        
        # Add hostname patch
        talosctl_cmd="$talosctl_cmd --config-patch '$hostname_patch'"
        
        # Add other parameters
        talosctl_cmd="$talosctl_cmd --with-secrets secrets.yaml --with-docs=false --with-examples=false --kubernetes-version \"$KUBERNETES_VERSION\" --talos-version \"$TALOS_VERSION\" -t controlplane -o $output_file -f"
        
        echo "Generating control plane $i: $output_file"
        echo "Running: $talosctl_cmd"
        
        # Execute the command
        eval "$talosctl_cmd"
        
        if [[ $? -eq 0 ]]; then
            echo "Control plane $i configuration generated: $output_file"
        else
            echo "Error: Failed to generate control plane $i configuration"
            return 1
        fi
    done
    
    # Generate worker CPU configuration
    echo "Generating worker CPU configuration..."
    if [[ -f "$worker_cpu_patch" ]]; then
        local worker_cpu_cmd="talosctl gen config $CLUSTER_NAME https://$CLUSTER_ENDPOINT --config-patch-worker @$worker_cpu_patch --with-secrets secrets.yaml --with-docs=false --with-examples=false --kubernetes-version \"$KUBERNETES_VERSION\" --talos-version \"$TALOS_VERSION\" -t worker -o worker-cpu.yaml -f"
        
        echo "Running: $worker_cpu_cmd"
        eval "$worker_cpu_cmd"
        
        if [[ $? -eq 0 ]]; then
            echo "Worker CPU configuration generated: worker-cpu.yaml"
        else
            echo "Error: Failed to generate worker CPU configuration"
            return 1
        fi
    else
        echo "Skipping worker CPU configuration - patch file not found"
    fi
    
    # Generate worker GPU configuration
    echo "Generating worker GPU configuration..."
    if [[ -f "$worker_gpu_patch" ]]; then
        local worker_gpu_cmd="talosctl gen config $CLUSTER_NAME https://$CLUSTER_ENDPOINT --config-patch-worker @$worker_gpu_patch --with-secrets secrets.yaml --with-docs=false --with-examples=false --kubernetes-version \"$KUBERNETES_VERSION\" --talos-version \"$TALOS_VERSION\" -t worker -o worker-gpu.yaml -f"
        
        echo "Running: $worker_gpu_cmd"
        eval "$worker_gpu_cmd"
        
        if [[ $? -eq 0 ]]; then
            echo "Worker GPU configuration generated: worker-gpu.yaml"
        else
            echo "Error: Failed to generate worker GPU configuration"
            return 1
        fi
    else
        echo "Skipping worker GPU configuration - patch file not found"
    fi
    
    # Generate talosconfig
    echo "Generating talosconfig..."
    local talosconfig_cmd="talosctl gen config $CLUSTER_NAME https://$CLUSTER_ENDPOINT --with-secrets secrets.yaml --with-docs=false --with-examples=false --kubernetes-version \"$KUBERNETES_VERSION\" --talos-version \"$TALOS_VERSION\" -t talosconfig -o talosconfig -f"
    
    echo "Running: $talosconfig_cmd"
    eval "$talosconfig_cmd"
    
    if [[ $? -eq 0 ]]; then
        echo "Talosconfig generated: talosconfig"
        echo ""
        echo "=========================================="
        echo "All Talos configurations generated successfully:"
        echo "  Control Planes:"
        echo "    - controlplane-1.yaml"
        echo "    - controlplane-2.yaml" 
        echo "    - controlplane-3.yaml"
        echo "  Workers:"
        echo "    - worker-cpu.yaml"
        echo "    - worker-gpu.yaml"
        echo "  Config:"
        echo "    - talosconfig"
        echo "=========================================="
    else
        echo "Error: Failed to generate talosconfig"
        return 1
    fi
}

# Function to process all .tpl files
process_all_templates() {
    echo "Processing template files..."
    for template in "$TEMPLATE_DIR"/*.tpl; do
        if [[ -f "$template" ]]; then
            filename=$(basename "$template" .tpl)
            output_file="$OUTPUT_DIR/${filename}.yaml"
            process_template "$template" "$output_file"
        fi
    done
    
    if [[ $(ls "$TEMPLATE_DIR"/*.tpl 2>/dev/null | wc -l) -eq 0 ]]; then
        echo "Warning: No .tpl files found in $TEMPLATE_DIR directory"
    fi
}

# Function to validate generated Talos configs
validate_talos_configs() {
    echo "\nValidating generated Talos configuration files..."
    local configs=(controlplane-1.yaml controlplane-2.yaml controlplane-3.yaml worker-cpu.yaml worker-gpu.yaml)
    local all_valid=1
    for config in "${configs[@]}"; do
        if [[ -f "$config" ]]; then
            echo "Validating $config..."
            if talosctl validate -c "$config" -m metal; then
                : # Success, no extra echo to avoid duplicate output
            else
                echo "Validation failed for $config"
                all_valid=0
            fi
        else
            echo "Warning: $config not found, skipping validation."
        fi
    done
    if [[ $all_valid -eq 1 ]]; then
        echo "All configuration files validated successfully."
    else
        echo "Some configuration files failed validation."
    fi
}

# Main execution
main() {
    echo "=== Talos Cluster Configuration Generator ==="
    echo "Cluster: $CLUSTER_NAME"
    echo "=========================================="
    
    load_config
    setup_variables
    
    # Process templates first
    process_all_templates
    
    # Generate Talos secrets
    generate_talos_secrets
    
    # Generate Talos cluster configuration
    generate_talos_config
    
    # Validate generated configs
    validate_talos_configs
    
    echo "=========================================="
    echo "Configuration generation completed!"
    echo "Cluster Name: $CLUSTER_NAME"
    echo "Cluster Endpoint: https://$CLUSTER_ENDPOINT"
    echo "=========================================="
}

# Run main function
main "$@"