BCards-Scripts-Server/scripts/test-connectivity.sh

#!/bin/bash

# BCards Connectivity Test Script
# Testa conectividade e saúde dos serviços

set -e

# Configurações
SERVER_IPS=("141.148.162.114" "129.146.116.218")
SSH_USER="ubuntu"
DOMAIN="bcards.site"
SERVICE_NAME="bcards-app"

# Cores para output
RED='\033[0;31m'
GREEN='\033[0;32m'
YELLOW='\033[1;33m'
BLUE='\033[0;34m'
NC='\033[0m'

log() {
    echo -e "${GREEN}[$(date +'%Y-%m-%d %H:%M:%S')] $1${NC}"
}

error() {
    echo -e "${RED}[ERROR] $1${NC}"
}

warn() {
    echo -e "${YELLOW}[WARNING] $1${NC}"
}

info() {
    echo -e "${BLUE}[INFO] $1${NC}"
}

success() {
    echo -e "${GREEN}[SUCCESS] $1${NC}"
}

# Função para executar comando em servidor remoto
run_remote() {
    local server_ip=$1
    local command=$2
    ssh -o ConnectTimeout=10 -o StrictHostKeyChecking=no ${SSH_USER}@${server_ip} "$command" 2>/dev/null
}

# Teste de conectividade SSH
test_ssh_connectivity() {
    log "Testando conectividade SSH..."
    
    local passed=0
    local total=${#SERVER_IPS[@]}
    
    for server_ip in "${SERVER_IPS[@]}"; do
        if run_remote $server_ip "echo 'SSH OK'" >/dev/null 2>&1; then
            success "✓ SSH conectado: $server_ip"
            ((passed++))
        else
            error "✗ SSH falhou: $server_ip"
        fi
    done
    
    echo ""
    info "SSH Connectivity: $passed/$total servidores"
}

# Teste de status do Docker
test_docker_status() {
    log "Testando status do Docker..."
    
    local passed=0
    local total=${#SERVER_IPS[@]}
    
    for server_ip in "${SERVER_IPS[@]}"; do
        if run_remote $server_ip "sudo docker info" >/dev/null 2>&1; then
            success "✓ Docker ativo: $server_ip"
            ((passed++))
        else
            error "✗ Docker inativo: $server_ip"
        fi
    done
    
    echo ""
    info "Docker Status: $passed/$total servidores"
}

# Teste de status do Docker Swarm
test_swarm_status() {
    log "Testando status do Docker Swarm..."
    
    local manager_ip=${SERVER_IPS[0]}
    
    if run_remote $manager_ip "sudo docker node ls" >/dev/null 2>&1; then
        success "✓ Docker Swarm ativo"
        
        # Mostrar status dos nodes
        info "Status dos nodes:"
        run_remote $manager_ip "sudo docker node ls" || true
    else
        error "✗ Docker Swarm inativo"
    fi
    
    echo ""
}

# Teste de serviços Docker
test_docker_services() {
    log "Testando serviços Docker..."
    
    local manager_ip=${SERVER_IPS[0]}
    
    if run_remote $manager_ip "sudo docker service ls" >/dev/null 2>&1; then
        info "Serviços ativos:"
        run_remote $manager_ip "sudo docker service ls" || true
        
        # Verificar serviços específicos do BCards
        if run_remote $manager_ip "sudo docker service ls --filter name=${SERVICE_NAME}" | grep -q "${SERVICE_NAME}"; then
            success "✓ Serviços BCards encontrados"
            
            # Status detalhado dos serviços BCards
            info "Status detalhado dos serviços BCards:"
            run_remote $manager_ip "sudo docker service ps ${SERVICE_NAME}_app-server1 --no-trunc" || true
            run_remote $manager_ip "sudo docker service ps ${SERVICE_NAME}_app-server2 --no-trunc" || true
        else
            warn "Serviços BCards não encontrados"
        fi
    else
        error "✗ Falha ao listar serviços Docker"
    fi
    
    echo ""
}

# Teste de health checks internos
test_internal_health() {
    log "Testando health checks internos..."
    
    for server_ip in "${SERVER_IPS[@]}"; do
        info "Testando servidor $server_ip..."
        
        # Verificar se há containers rodando
        local containers=$(run_remote $server_ip "sudo docker ps --filter status=running --format '{{.Names}}'" | wc -l)
        info "  Containers rodando: $containers"
        
        # Teste de conectividade de rede interna
        if run_remote $server_ip "sudo docker network ls | grep bcards" >/dev/null 2>&1; then
            success "  ✓ Rede bcards-network existe"
        else
            warn "  ✗ Rede bcards-network não encontrada"
        fi
    done
    
    echo ""
}

# Teste de conectividade externa HTTP/HTTPS
test_external_connectivity() {
    log "Testando conectividade externa..."
    
    # Teste HTTP
    info "Testando HTTP..."
    if curl -f -s --max-time 10 "http://$DOMAIN/nginx-health" >/dev/null 2>&1; then
        success "✓ HTTP funcionando (http://$DOMAIN)"
    else
        error "✗ HTTP falhou (http://$DOMAIN)"
    fi
    
    # Teste HTTPS
    info "Testando HTTPS..."
    if curl -f -s --max-time 10 "https://$DOMAIN/nginx-health" >/dev/null 2>&1; then
        success "✓ HTTPS funcionando (https://$DOMAIN)"
    else
        warn "✗ HTTPS falhou (https://$DOMAIN)"
    fi
    
    # Teste health check da aplicação
    info "Testando health check da aplicação..."
    if curl -f -s --max-time 10 "http://$DOMAIN/health" >/dev/null 2>&1; then
        success "✓ Health check da aplicação passou"
    else
        error "✗ Health check da aplicação falhou"
    fi
    
    echo ""
}

# Teste de load balancing
test_load_balancing() {
    log "Testando load balancing..."
    
    local servers_found=()
    
    for i in {1..10}; do
        local response=$(curl -s --max-time 5 "http://$DOMAIN/server-info" 2>/dev/null | jq -r '.ServerName' 2>/dev/null || echo "Error")
        
        if [[ "$response" != "Error" && "$response" != "null" ]]; then
            servers_found+=("$response")
        fi
        
        sleep 0.5
    done
    
    if [ ${#servers_found[@]} -gt 0 ]; then
        local unique_servers=$(printf '%s\n' "${servers_found[@]}" | sort -u | wc -l)
        
        info "Servidores detectados em 10 requests:"
        printf '%s\n' "${servers_found[@]}" | sort | uniq -c
        
        if [ $unique_servers -gt 1 ]; then
            success "✓ Load balancing funcionando ($unique_servers servidores diferentes)"
        else
            warn "Load balancing pode não estar funcionando (apenas 1 servidor detectado)"
        fi
    else
        error "✗ Falha ao testar load balancing"
    fi
    
    echo ""
}

# Teste de DNS
test_dns_resolution() {
    log "Testando resolução DNS..."
    
    if nslookup $DOMAIN >/dev/null 2>&1; then
        local ip=$(nslookup $DOMAIN | grep -A1 "Name:" | tail -1 | awk '{print $2}')
        success "✓ DNS funcionando: $DOMAIN -> $ip"
    else
        error "✗ Falha na resolução DNS para $DOMAIN"
    fi
    
    echo ""
}

# Teste de certificado SSL
test_ssl_certificate() {
    log "Testando certificado SSL..."
    
    if command -v openssl >/dev/null 2>&1; then
        local ssl_info=$(echo | timeout 10 openssl s_client -servername $DOMAIN -connect $DOMAIN:443 2>/dev/null | openssl x509 -noout -dates 2>/dev/null)
        
        if [ $? -eq 0 ]; then
            success "✓ Certificado SSL válido"
            info "Informações do certificado:"
            echo "$ssl_info" | sed 's/^/  /'
        else
            warn "Certificado SSL não encontrado ou inválido"
        fi
    else
        warn "OpenSSL não disponível para teste de certificado"
    fi
    
    echo ""
}

# Mostrar métricas de performance
show_performance_metrics() {
    log "Coletando métricas de performance..."
    
    for server_ip in "${SERVER_IPS[@]}"; do
        info "Métricas do servidor $server_ip:"
        
        # CPU e Memória
        local cpu_mem=$(run_remote $server_ip "top -bn1 | grep 'Cpu(s)' | awk '{print \$2}' | awk -F'%' '{print \$1}'; free -m | awk 'NR==2{printf \"%.1f%%\", \$3*100/\$2}'")
        info "  CPU/Memória: $cpu_mem"
        
        # Disk usage
        local disk=$(run_remote $server_ip "df -h / | awk 'NR==2 {print \$5}'")
        info "  Uso do disco: $disk"
        
        # Docker stats
        local docker_containers=$(run_remote $server_ip "sudo docker ps --format 'table {{.Names}}\t{{.Status}}' | tail -n +2 | wc -l")
        info "  Containers Docker ativos: $docker_containers"
    done
    
    echo ""
}

# Gerar relatório detalhado
generate_report() {
    local timestamp=$(date +'%Y-%m-%d %H:%M:%S')
    local report_file="connectivity-report-$(date +'%Y%m%d_%H%M%S').txt"
    
    log "Gerando relatório detalhado..."
    
    {
        echo "BCards Infrastructure Connectivity Report"
        echo "Generated: $timestamp"
        echo "========================================"
        echo ""
        
        echo "Infrastructure Overview:"
        echo "- Domain: $DOMAIN"
        echo "- Servers: ${SERVER_IPS[*]}"
        echo "- Service: $SERVICE_NAME"
        echo ""
        
        echo "Test Results Summary:"
        echo "- SSH Connectivity: $(test_ssh_connectivity 2>&1 | grep -c "SSH OK")/${#SERVER_IPS[@]} servers"
        echo "- Docker Status: $(test_docker_status 2>&1 | grep -c "Docker ativo")/${#SERVER_IPS[@]} servers"
        echo "- External HTTP: $(curl -f -s "http://$DOMAIN/nginx-health" >/dev/null 2>&1 && echo "PASS" || echo "FAIL")"
        echo "- External HTTPS: $(curl -f -s "https://$DOMAIN/nginx-health" >/dev/null 2>&1 && echo "PASS" || echo "FAIL")"
        echo "- App Health Check: $(curl -f -s "http://$DOMAIN/health" >/dev/null 2>&1 && echo "PASS" || echo "FAIL")"
        
    } > $report_file
    
    info "Relatório salvo em: $report_file"
}

# Função principal
main() {
    log "Iniciando testes de conectividade BCards..."
    echo ""
    
    test_ssh_connectivity
    test_docker_status
    test_swarm_status
    test_docker_services
    test_internal_health
    test_dns_resolution
    test_external_connectivity
    test_load_balancing
    test_ssl_certificate
    show_performance_metrics
    
    if [[ "$1" == "--report" ]]; then
        generate_report
    fi
    
    log "Testes de conectividade concluídos!"
}

# Função de ajuda
show_help() {
    echo "BCards Connectivity Test Script"
    echo ""
    echo "Usage: $0 [OPTIONS]"
    echo ""
    echo "OPTIONS:"
    echo "  --report    Gera relatório detalhado em arquivo"
    echo "  --help      Mostra esta ajuda"
    echo ""
    echo "Este script testa:"
    echo "- Conectividade SSH com os servidores"
    echo "- Status do Docker e Docker Swarm"
    echo "- Saúde dos serviços em execução"
    echo "- Conectividade HTTP/HTTPS externa"
    echo "- Funcionamento do load balancing"
    echo "- Resolução DNS e certificados SSL"
    echo "- Métricas de performance dos servidores"
    echo ""
    echo "Servers: ${SERVER_IPS[*]}"
    echo "Domain: $DOMAIN"
}

# Parse argumentos
if [[ "$1" == "--help" || "$1" == "-h" ]]; then
    show_help
    exit 0
fi

# Verificar dependências
if ! command -v curl >/dev/null 2>&1; then
    error "curl não está instalado"
    exit 1
fi

if ! command -v jq >/dev/null 2>&1; then
    warn "jq não está instalado - alguns testes serão limitados"
fi

# Executar função principal
main "$@"