Skip to content

Instantly share code, notes, and snippets.

@diegslva

diegslva/guistorm-manager.sh

Last active September 9, 2025 13:54
Show Gist options

  • Select an option

    Learn more about clone URLs
  • Save diegslva/3250d8da91f65de91c0d2958d971eea7 to your computer and use it in GitHub Desktop.

Select an option

Learn more about clone URLs
Save diegslva/3250d8da91f65de91c0d2958d971eea7 to your computer and use it in GitHub Desktop.
Download ZIP
Raw
guistorm-manager.sh
#!/bin/bash
# ═══════════════════════════════════════════════════════════════════════════════
# guistorm-manager.sh - Gerenciador Automático de Subdomínios
# Author: Diego L.S. - github.com/dieglsva
# Data: 16/01/2025
# Descrição: Adiciona, remove e gerencia subdomínios no Caddy + Go Apps
# ═══════════════════════════════════════════════════════════════════════════════
set -e
# ═══════════════════════════════════════════════════════════════════════════════
# CONFIGURAÇÕES GLOBAIS
# ═══════════════════════════════════════════════════════════════════════════════
readonly CADDY_CONFIG="/etc/caddy/Caddyfile"
readonly CADDY_BACKUP_DIR="/etc/caddy/backups"
readonly APPS_DIR="/opt/apps"
readonly SYSTEMD_DIR="/etc/systemd/system"
readonly LOG_DIR="/var/log/guistorm"
readonly DOMAIN_BASE="guistorm.io"
readonly EMAIL="dieg.slva@gmail.com"
# Cores para output
readonly RED='\033[0;31m'
readonly GREEN='\033[0;32m'
readonly YELLOW='\033[1;33m'
readonly BLUE='\033[0;34m'
readonly CYAN='\033[0;36m'
readonly NC='\033[0m'
# Próxima porta disponível (incrementa automaticamente)
PORT_FILE="/etc/caddy/.next_port"
[[ ! -f "$PORT_FILE" ]] && echo "8090" > "$PORT_FILE"
# ═══════════════════════════════════════════════════════════════════════════════
# FUNÇÕES DE UTILIDADE
# ═══════════════════════════════════════════════════════════════════════════════
log_info() { echo -e "${GREEN}[✓]${NC} $1"; }
log_warn() { echo -e "${YELLOW}[→]${NC} $1"; }
log_error() { echo -e "${RED}[✗]${NC} $1"; }
log_blue() { echo -e "${BLUE}[◆]${NC} $1"; }
log_cyan() { echo -e "${CYAN}[★]${NC} $1"; }
show_header() {
echo -e "${CYAN}═══════════════════════════════════════════════════════════════${NC}"
echo -e "${CYAN} GUISTORM.IO - GERENCIADOR DE SUBDOMÍNIOS${NC}"
echo -e "${CYAN}═══════════════════════════════════════════════════════════════${NC}"
echo ""
}
# Verificar se está rodando como root
check_root() {
if [[ $EUID -ne 0 ]]; then
log_error "Este script precisa ser executado como root!"
exit 1
fi
}
# Backup do Caddyfile
backup_caddy() {
mkdir -p "$CADDY_BACKUP_DIR"
local backup_file="$CADDY_BACKUP_DIR/Caddyfile.$(date +%Y%m%d_%H%M%S).bak"
cp "$CADDY_CONFIG" "$backup_file"
log_info "Backup criado: $backup_file"
}
# Validar nome do subdomínio
validate_subdomain() {
local subdomain=$1
if [[ ! "$subdomain" =~ ^[a-z0-9]([a-z0-9-]{0,61}[a-z0-9])?$ ]]; then
log_error "Nome de subdomínio inválido! Use apenas: a-z, 0-9 e hífens"
return 1
fi
return 0
}
# Obter próxima porta disponível
get_next_port() {
local current_port=$(cat "$PORT_FILE")
echo "$current_port"
echo $((current_port + 1)) > "$PORT_FILE"
}
# ═══════════════════════════════════════════════════════════════════════════════
# INICIALIZAR CADDYFILE COM SNIPPETS (se necessário)
# ═══════════════════════════════════════════════════════════════════════════════
init_caddy_snippets() {
if ! grep -q "(security_headers)" "$CADDY_CONFIG" 2>/dev/null; then
log_warn "Inicializando snippets no Caddyfile..."
# Criar backup do original
backup_caddy
# Adicionar snippets no início do arquivo
cat > "$CADDY_CONFIG.tmp" << 'EOF'
# ═══════════════════════════════════════════════════════════════════════════════
# CONFIGURAÇÃO GLOBAL - GUISTORM.IO
# Gerenciado por: guistorm-manager.sh
# ═══════════════════════════════════════════════════════════════════════════════
{
email dieg.slva@gmail.com
servers {
protocols h1 h2 h3
strict_sni_host on
}
}
# ═══════════════════════════════════════════════════════════════════════════════
# SNIPPETS REUTILIZÁVEIS
# ═══════════════════════════════════════════════════════════════════════════════
# Headers de segurança padrão
(security_headers) {
header {
Strict-Transport-Security "max-age=31536000; includeSubDomains; preload"
X-Content-Type-Options "nosniff"
X-Frame-Options "SAMEORIGIN"
X-XSS-Protection "1; mode=block"
Referrer-Policy "strict-origin-when-cross-origin"
-Server
-X-Powered-By
}
}
# Compressão otimizada
(compression) {
encode {
gzip 9
zstd
match {
header Content-Type text/*
header Content-Type application/json*
header Content-Type application/javascript*
header Content-Type application/xml*
}
}
}
# Rate limiting padrão
(rate_limiting) {
rate_limit {
zone dynamic {
key {remote_host}
events 100
window 60s
}
}
}
# Logging padrão
(logging) {
log {
output file /var/log/caddy/{args.0}.log {
roll_size 50mb
roll_keep 5
roll_keep_for 720h
}
format json
}
}
# Proxy backend padrão
(backend_proxy) {
reverse_proxy localhost:{args.0} {
health_uri /health
health_interval 30s
health_timeout 5s
health_status 200
header_up X-Real-IP {remote_host}
header_up X-Forwarded-For {remote_host}
header_up X-Forwarded-Proto {scheme}
header_up X-Forwarded-Host {host}
transport http {
dial_timeout 30s
read_timeout 90s
write_timeout 90s
}
}
}
# WebSocket support
(websocket) {
@websocket {
header Connection *Upgrade*
header Upgrade websocket
}
handle @websocket {
reverse_proxy localhost:{args.0} {
header_up Upgrade {http.request.header.Upgrade}
header_up Connection "upgrade"
}
}
}
# ═══════════════════════════════════════════════════════════════════════════════
# DOMÍNIOS CONFIGURADOS
# ═══════════════════════════════════════════════════════════════════════════════
EOF
# Adicionar configurações existentes
if [[ -f "$CADDY_CONFIG" ]]; then
# Extrair apenas as configurações de domínio (sem os headers globais)
grep -A 1000 "^[a-z].*\.guistorm\.io {" "$CADDY_CONFIG" >> "$CADDY_CONFIG.tmp" 2>/dev/null || true
fi
mv "$CADDY_CONFIG.tmp" "$CADDY_CONFIG"
log_info "Snippets inicializados com sucesso!"
fi
}
# ═══════════════════════════════════════════════════════════════════════════════
# FUNÇÃO: ADICIONAR SUBDOMÍNIO
# ═══════════════════════════════════════════════════════════════════════════════
add_subdomain() {
local subdomain=$1
local port=${2:-$(get_next_port)}
local type=${3:-"backend"} # backend, websocket, static
# Validar entrada
validate_subdomain "$subdomain" || return 1
# Verificar se já existe
if grep -q "^$subdomain\.$DOMAIN_BASE {" "$CADDY_CONFIG" 2>/dev/null; then
log_error "Subdomínio $subdomain.$DOMAIN_BASE já existe!"
return 1
fi
log_info "Adicionando subdomínio: $subdomain.$DOMAIN_BASE (porta: $port)"
# Backup antes de modificar
backup_caddy
# Adicionar configuração baseada no tipo
case "$type" in
"backend")
cat >> "$CADDY_CONFIG" << EOF
# $subdomain.$DOMAIN_BASE - Backend API
# Adicionado em: $(date '+%Y-%m-%d %H:%M:%S')
$subdomain.$DOMAIN_BASE {
import security_headers
import compression
import rate_limiting
import logging $subdomain
import backend_proxy $port
}
EOF
;;
"websocket")
cat >> "$CADDY_CONFIG" << EOF
# $subdomain.$DOMAIN_BASE - WebSocket Service
# Adicionado em: $(date '+%Y-%m-%d %H:%M:%S')
$subdomain.$DOMAIN_BASE {
import security_headers
import compression
import rate_limiting
import logging $subdomain
import websocket $port
import backend_proxy $port
}
EOF
;;
"static")
# Criar diretório para arquivos estáticos
local static_dir="/var/www/$subdomain"
mkdir -p "$static_dir"
chown -R www-data:www-data "$static_dir"
cat >> "$CADDY_CONFIG" << EOF
# $subdomain.$DOMAIN_BASE - Static Website
# Adicionado em: $(date '+%Y-%m-%d %H:%M:%S')
$subdomain.$DOMAIN_BASE {
import security_headers
import compression
import logging $subdomain
root * /var/www/$subdomain
try_files {path} /index.html
file_server
}
EOF
# Criar index.html de exemplo
cat > "$static_dir/index.html" << EOF
<!DOCTYPE html>
<html>
<head>
<title>$subdomain.$DOMAIN_BASE</title>
<style>
body {
font-family: -apple-system, system-ui, sans-serif;
display: flex;
align-items: center;
justify-content: center;
min-height: 100vh;
background: linear-gradient(135deg, #667eea 0%, #764ba2 100%);
color: white;
margin: 0;
}
.container {
text-align: center;
padding: 40px;
}
h1 { font-size: 3em; margin-bottom: 10px; }
p { font-size: 1.2em; opacity: 0.9; }
</style>
</head>
<body>
<div class="container">
<h1>🚀 $subdomain.$DOMAIN_BASE</h1>
<p>Site configurado com sucesso!</p>
<p><small>Criado em: $(date '+%Y-%m-%d %H:%M:%S')</small></p>
</div>
</body>
</html>
EOF
;;
esac
# Criar aplicação Go se for backend/websocket
if [[ "$type" != "static" ]]; then
create_go_app "$subdomain" "$port" "$type"
fi
# Validar e recarregar Caddy
if caddy validate --config "$CADDY_CONFIG" &>/dev/null; then
systemctl reload caddy
log_info "Caddy recarregado com sucesso!"
echo ""
log_cyan "Subdomínio adicionado com sucesso!"
echo -e "${GREEN}URL:${NC} https://$subdomain.$DOMAIN_BASE"
echo -e "${GREEN}Porta:${NC} $port"
echo -e "${GREEN}Tipo:${NC} $type"
if [[ "$type" != "static" ]]; then
echo -e "${GREEN}Serviço:${NC} $subdomain-app.service"
echo ""
echo -e "${YELLOW}Comandos úteis:${NC}"
echo " • Status: systemctl status $subdomain-app"
echo " • Logs: journalctl -u $subdomain-app -f"
echo " • Editar: nano $APPS_DIR/$subdomain/main.go"
else
echo -e "${GREEN}Diretório:${NC} /var/www/$subdomain"
fi
else
log_error "Erro na configuração do Caddy! Revertendo..."
cp "$CADDY_BACKUP_DIR/$(ls -t $CADDY_BACKUP_DIR | head -1)" "$CADDY_CONFIG"
return 1
fi
}
# ═══════════════════════════════════════════════════════════════════════════════
# FUNÇÃO: CRIAR APLICAÇÃO GO
# ═══════════════════════════════════════════════════════════════════════════════
create_go_app() {
local subdomain=$1
local port=$2
local type=$3
local app_dir="$APPS_DIR/$subdomain"
log_info "Criando aplicação Go para $subdomain..."
mkdir -p "$app_dir"
# Criar aplicação baseada no tipo
if [[ "$type" == "websocket" ]]; then
cat > "$app_dir/main.go" << EOF
package main
import (
"encoding/json"
"fmt"
"log"
"net/http"
"time"
"github.com/gorilla/websocket"
)
var upgrader = websocket.Upgrader{
CheckOrigin: func(r *http.Request) bool {
return true // Ajustar em produção
},
}
type Message struct {
Type string \`json:"type"\`
Content string \`json:"content"\`
Timestamp time.Time \`json:"timestamp"\`
}
func handleWebSocket(w http.ResponseWriter, r *http.Request) {
conn, err := upgrader.Upgrade(w, r, nil)
if err != nil {
log.Printf("Erro no upgrade: %v", err)
return
}
defer conn.Close()
log.Printf("Cliente conectado: %s", r.RemoteAddr)
// Echo server exemplo
for {
var msg Message
err := conn.ReadJSON(&msg)
if err != nil {
log.Printf("Cliente desconectado: %v", err)
break
}
msg.Timestamp = time.Now()
msg.Type = "echo"
if err := conn.WriteJSON(msg); err != nil {
log.Printf("Erro ao enviar: %v", err)
break
}
}
}
func handleHome(w http.ResponseWriter, r *http.Request) {
w.Header().Set("Content-Type", "text/html")
fmt.Fprintf(w, \`
<!DOCTYPE html>
<html>
<head>
<title>$subdomain WebSocket</title>
</head>
<body>
<h1>WebSocket Service: $subdomain.$DOMAIN_BASE</h1>
<p>Conecte via: wss://$subdomain.$DOMAIN_BASE/ws</p>
</body>
</html>
\`)
}
func handleHealth(w http.ResponseWriter, r *http.Request) {
w.Header().Set("Content-Type", "application/json")
json.NewEncoder(w).Encode(map[string]string{
"status": "healthy",
"service": "$subdomain",
"type": "websocket",
})
}
func main() {
http.HandleFunc("/", handleHome)
http.HandleFunc("/ws", handleWebSocket)
http.HandleFunc("/health", handleHealth)
log.Printf("[✓] $subdomain WebSocket rodando na porta $port")
log.Fatal(http.ListenAndServe(":$port", nil))
}
EOF
else
# Backend API padrão
cat > "$app_dir/main.go" << EOF
package main
import (
"encoding/json"
"fmt"
"log"
"net/http"
"runtime"
"time"
)
type Response struct {
Service string \`json:"service"\`
Subdomain string \`json:"subdomain"\`
Status string \`json:"status"\`
Timestamp time.Time \`json:"timestamp"\`
Version string \`json:"version"\`
GoVersion string \`json:"go_version"\`
Uptime string \`json:"uptime"\`
}
var startTime = time.Now()
func handleRoot(w http.ResponseWriter, r *http.Request) {
w.Header().Set("Content-Type", "application/json")
response := Response{
Service: "$subdomain-service",
Subdomain: "$subdomain.$DOMAIN_BASE",
Status: "operational",
Timestamp: time.Now(),
Version: "1.0.0",
GoVersion: runtime.Version(),
Uptime: time.Since(startTime).String(),
}
json.NewEncoder(w).Encode(response)
}
func handleHealth(w http.ResponseWriter, r *http.Request) {
w.Header().Set("Content-Type", "application/json")
json.NewEncoder(w).Encode(map[string]interface{}{
"status": "healthy",
"uptime": time.Since(startTime).Seconds(),
})
}
func handleInfo(w http.ResponseWriter, r *http.Request) {
w.Header().Set("Content-Type", "text/html; charset=utf-8")
fmt.Fprintf(w, \`
<!DOCTYPE html>
<html>
<head>
<title>$subdomain.$DOMAIN_BASE</title>
<style>
body {
font-family: -apple-system, system-ui, sans-serif;
max-width: 800px;
margin: 100px auto;
padding: 20px;
background: linear-gradient(135deg, #667eea 0%, #764ba2 100%);
color: white;
}
h1 { font-size: 2.5em; }
.info {
background: rgba(255,255,255,0.1);
padding: 20px;
border-radius: 10px;
margin-top: 20px;
}
code {
background: rgba(0,0,0,0.3);
padding: 2px 8px;
border-radius: 4px;
}
</style>
</head>
<body>
<h1>🚀 $subdomain Service</h1>
<div class="info">
<p><strong>Domínio:</strong> $subdomain.$DOMAIN_BASE</p>
<p><strong>Status:</strong> ✅ Operacional</p>
<p><strong>API Endpoint:</strong> <code>GET /api</code></p>
<p><strong>Health Check:</strong> <code>GET /health</code></p>
<p><strong>Go Version:</strong> %s</p>
<p><strong>Uptime:</strong> %s</p>
</div>
</body>
</html>
\`, runtime.Version(), time.Since(startTime))
}
func main() {
// Rotas
http.HandleFunc("/", handleRoot)
http.HandleFunc("/api", handleRoot)
http.HandleFunc("/health", handleHealth)
http.HandleFunc("/info", handleInfo)
// Middleware de logging
handler := http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
start := time.Now()
http.DefaultServeMux.ServeHTTP(w, r)
log.Printf("%s %s %s %v", r.Method, r.URL.Path, r.RemoteAddr, time.Since(start))
})
log.Printf("[✓] $subdomain service rodando na porta $port")
log.Printf("[→] URL: https://$subdomain.$DOMAIN_BASE")
log.Fatal(http.ListenAndServe(":$port", handler))
}
EOF
fi
# Compilar aplicação
cd "$app_dir"
go mod init "$subdomain" 2>/dev/null || true
if [[ "$type" == "websocket" ]]; then
go get github.com/gorilla/websocket 2>/dev/null || true
fi
go build -o app main.go
# Criar systemd service
cat > "$SYSTEMD_DIR/$subdomain-app.service" << EOF
[Unit]
Description=$subdomain Service - $type
After=network.target
[Service]
Type=simple
User=www-data
Group=www-data
WorkingDirectory=$app_dir
ExecStart=$app_dir/app
Restart=always
RestartSec=10
# Limites
LimitNOFILE=65536
LimitNPROC=4096
# Variáveis de ambiente
Environment="GO_ENV=production"
Environment="SERVICE_NAME=$subdomain"
Environment="PORT=$port"
[Install]
WantedBy=multi-user.target
EOF
# Iniciar serviço
systemctl daemon-reload
systemctl enable "$subdomain-app.service"
systemctl start "$subdomain-app.service"
log_info "Aplicação Go criada e iniciada!"
}
# ═══════════════════════════════════════════════════════════════════════════════
# FUNÇÃO: REMOVER SUBDOMÍNIO
# ═══════════════════════════════════════════════════════════════════════════════
remove_subdomain() {
local subdomain=$1
if [[ -z "$subdomain" ]]; then
log_error "Por favor, especifique o subdomínio a remover"
return 1
fi
# Verificar se existe
if ! grep -q "^$subdomain\.$DOMAIN_BASE {" "$CADDY_CONFIG"; then
log_error "Subdomínio $subdomain.$DOMAIN_BASE não encontrado!"
return 1
fi
log_warn "Removendo subdomínio: $subdomain.$DOMAIN_BASE"
# Confirmar
echo -e "${YELLOW}⚠️ Esta ação irá:${NC}"
echo " • Remover configuração do Caddy"
echo " • Parar e remover o serviço (se existir)"
echo " • Remover aplicação em $APPS_DIR/$subdomain"
echo " • Remover diretório web em /var/www/$subdomain (se existir)"
echo ""
read -p "Confirmar remoção? (s/N): " confirm
if [[ "$confirm" != "s" ]]; then
log_info "Operação cancelada"
return 0
fi
# Backup antes de remover
backup_caddy
# Remover do Caddyfile (remove o bloco inteiro)
sed -i "/^# $subdomain\.$DOMAIN_BASE/,/^$/d" "$CADDY_CONFIG"
sed -i "/^$subdomain\.$DOMAIN_BASE {/,/^}/d" "$CADDY_CONFIG"
# Parar e remover serviço se existir
if systemctl list-units --all | grep -q "$subdomain-app.service"; then
systemctl stop "$subdomain-app.service" 2>/dev/null || true
systemctl disable "$subdomain-app.service" 2>/dev/null || true
rm -f "$SYSTEMD_DIR/$subdomain-app.service"
systemctl daemon-reload
log_info "Serviço removido"
fi
# Remover aplicação
if [[ -d "$APPS_DIR/$subdomain" ]]; then
rm -rf "$APPS_DIR/$subdomain"
log_info "Aplicação removida"
fi
# Remover diretório web se existir
if [[ -d "/var/www/$subdomain" ]]; then
rm -rf "/var/www/$subdomain"
log_info "Diretório web removido"
fi
# Recarregar Caddy
systemctl reload caddy
log_info "Subdomínio $subdomain.$DOMAIN_BASE removido com sucesso!"
}
# ═══════════════════════════════════════════════════════════════════════════════
# FUNÇÃO: LISTAR SUBDOMÍNIOS
# ═══════════════════════════════════════════════════════════════════════════════
list_subdomains() {
log_cyan "Subdomínios configurados:"
echo ""
# Extrair subdomínios do Caddyfile
local subdomains=$(grep -E "^[a-z0-9-]+\.guistorm\.io {" "$CADDY_CONFIG" | sed 's/ {//' | sort)
if [[ -z "$subdomains" ]]; then
log_warn "Nenhum subdomínio configurado"
return
fi
printf "%-40s %-10s %-15s\n" "DOMÍNIO" "PORTA" "STATUS"
printf "%-40s %-10s %-15s\n" "-------" "-----" "------"
while IFS= read -r domain; do
# Extrair porta do reverse_proxy
local port=$(grep -A 10 "^$domain {" "$CADDY_CONFIG" | grep -oP 'localhost:\K\d+' | head -1)
# Verificar status do serviço
local service_name=$(echo "$domain" | cut -d'.' -f1)
local status="N/A"
if [[ -d "/var/www/$service_name" ]]; then
status="Static"
elif systemctl is-active "$service_name-app" &>/dev/null; then
status="✅ Running"
elif systemctl list-units --all | grep -q "$service_name-app.service"; then
status="❌ Stopped"
else
status="📁 No service"
fi
printf "%-40s %-10s %-15s\n" "$domain" "${port:-static}" "$status"
done <<< "$subdomains"
echo ""
# Mostrar estatísticas
local total=$(echo "$subdomains" | wc -l)
local running=$(systemctl list-units --state=running | grep -c "app.service" || echo 0)
echo -e "${CYAN}──────────────────────────────────────────────────────────${NC}"
echo -e "Total: $total | Rodando: $running | Próxima porta: $(cat $PORT_FILE)"
}
# ═══════════════════════════════════════════════════════════════════════════════
# FUNÇÃO: STATUS DETALHADO
# ═══════════════════════════════════════════════════════════════════════════════
show_status() {
local subdomain=$1
if [[ -z "$subdomain" ]]; then
# Status geral
log_cyan "Status Geral do Sistema"
echo ""
echo -e "${YELLOW}[→] Caddy:${NC}"
systemctl status caddy --no-pager | head -5
echo ""
echo -e "${YELLOW}[→] Certificados SSL:${NC}"
caddy list-certificates 2>/dev/null | grep "guistorm.io" || echo " Nenhum certificado ativo"
echo ""
echo -e "${YELLOW}[→] Recursos:${NC}"
free -h | grep Mem | awk '{print " Memória: " $3 " / " $2}'
df -h / | tail -1 | awk '{print " Disco: " $3 " / " $2}'
echo ""
list_subdomains
else
# Status específico
if ! grep -q "^$subdomain\.$DOMAIN_BASE {" "$CADDY_CONFIG"; then
log_error "Subdomínio $subdomain.$DOMAIN_BASE não encontrado!"
return 1
fi
log_cyan "Status: $subdomain.$DOMAIN_BASE"
echo ""
# Configuração Caddy
echo -e "${YELLOW}[→] Configuração Caddy:${NC}"
grep -A 8 "^$subdomain\.$DOMAIN_BASE {" "$CADDY_CONFIG"
# Serviço
if systemctl list-units --all | grep -q "$subdomain-app.service"; then
echo ""
echo -e "${YELLOW}[→] Serviço:${NC}"
systemctl status "$subdomain-app.service" --no-pager | head -10
echo ""
echo -e "${YELLOW}[→] Últimos logs:${NC}"
journalctl -u "$subdomain-app.service" -n 5 --no-pager
fi
# Teste de conectividade
echo ""
echo -e "${YELLOW}[→] Teste de conectividade:${NC}"
local port=$(grep -A 10 "^$subdomain\.$DOMAIN_BASE {" "$CADDY_CONFIG" | grep -oP 'localhost:\K\d+' | head -1)
if [[ -n "$port" ]]; then
if curl -s "http://localhost:$port/health" > /dev/null 2>&1; then
echo -e " ${GREEN}✅ Health check OK${NC}"
else
echo -e " ${RED}❌ Health check falhou${NC}"
fi
fi
fi
}
# ═══════════════════════════════════════════════════════════════════════════════
# FUNÇÃO: EDITAR APLICAÇÃO
# ═══════════════════════════════════════════════════════════════════════════════
edit_app() {
local subdomain=$1
if [[ -z "$subdomain" ]]; then
log_error "Por favor, especifique o subdomínio"
return 1
fi
local app_file="$APPS_DIR/$subdomain/main.go"
if [[ ! -f "$app_file" ]]; then
log_error "Aplicação não encontrada: $app_file"
return 1
fi
log_info "Editando: $app_file"
nano "$app_file"
echo ""
read -p "Recompilar e reiniciar o serviço? (s/N): " confirm
if [[ "$confirm" == "s" ]]; then
cd "$APPS_DIR/$subdomain"
go build -o app main.go
systemctl restart "$subdomain-app.service"
log_info "Serviço reiniciado!"
fi
}
# ═══════════════════════════════════════════════════════════════════════════════
# FUNÇÃO: MENU INTERATIVO
# ═══════════════════════════════════════════════════════════════════════════════
show_menu() {
clear
show_header
echo -e "${CYAN}Escolha uma opção:${NC}"
echo ""
echo " 1) 📝 Adicionar novo subdomínio"
echo " 2) 🗑️ Remover subdomínio"
echo " 3) 📋 Listar subdomínios"
echo " 4) 📊 Status detalhado"
echo " 5) ✏️ Editar aplicação"
echo " 6) 🔄 Recarregar Caddy"
echo " 7) 📖 Ver logs do Caddy"
echo " 8) 🔧 Validar configuração"
echo " 9) 📦 Backup completo"
echo " 0) 🚪 Sair"
echo ""
echo -e "${CYAN}─────────────────────────────────────────────────${NC}"
read -p "Opção: " choice
case $choice in
1)
read -p "Nome do subdomínio (ex: api): " subdomain
echo "Tipo de serviço:"
echo " 1) Backend API (padrão)"
echo " 2) WebSocket"
echo " 3) Site estático"
read -p "Escolha (1-3): " type_choice
case $type_choice in
2) type="websocket" ;;
3) type="static" ;;
*) type="backend" ;;
esac
add_subdomain "$subdomain" "" "$type"
;;
2)
list_subdomains
echo ""
read -p "Nome do subdomínio para remover: " subdomain
remove_subdomain "$subdomain"
;;
3)
list_subdomains
;;
4)
read -p "Subdomínio específico (ou Enter para geral): " subdomain
show_status "$subdomain"
;;
5)
list_subdomains
echo ""
read -p "Nome do subdomínio para editar: " subdomain
edit_app "$subdomain"
;;
6)
systemctl reload caddy
log_info "Caddy recarregado!"
;;
7)
journalctl -u caddy -f
;;
8)
if caddy validate --config "$CADDY_CONFIG"; then
log_info "Configuração válida!"
else
log_error "Configuração inválida!"
fi
;;
9)
backup_caddy
tar -czf "/root/guistorm-backup-$(date +%Y%m%d_%H%M%S).tar.gz" \
"$CADDY_CONFIG" "$APPS_DIR" "$SYSTEMD_DIR"/*-app.service 2>/dev/null
log_info "Backup completo criado em /root/"
;;
0)
echo ""
log_info "Até logo!"
exit 0
;;
*)
log_error "Opção inválida!"
;;
esac
echo ""
read -p "Pressione Enter para continuar..."
}
# ═══════════════════════════════════════════════════════════════════════════════
# FUNÇÃO: MODO CLI (Linha de Comando)
# ═══════════════════════════════════════════════════════════════════════════════
handle_cli() {
case "$1" in
add)
shift
add_subdomain "$@"
;;
remove|rm)
shift
remove_subdomain "$@"
;;
list|ls)
list_subdomains
;;
status)
shift
show_status "$@"
;;
edit)
shift
edit_app "$@"
;;
reload)
systemctl reload caddy
log_info "Caddy recarregado!"
;;
validate)
caddy validate --config "$CADDY_CONFIG"
;;
help|--help|-h)
show_help
;;
*)
log_error "Comando inválido: $1"
show_help
exit 1
;;
esac
}
# ═══════════════════════════════════════════════════════════════════════════════
# FUNÇÃO: AJUDA
# ═══════════════════════════════════════════════════════════════════════════════
show_help() {
echo "Uso: $0 [comando] [opções]"
echo ""
echo "Comandos:"
echo " add <nome> [porta] [tipo] - Adicionar subdomínio"
echo " remove <nome> - Remover subdomínio"
echo " list - Listar subdomínios"
echo " status [nome] - Mostrar status"
echo " edit <nome> - Editar aplicação"
echo " reload - Recarregar Caddy"
echo " validate - Validar configuração"
echo " help - Mostrar esta ajuda"
echo ""
echo "Tipos de serviço: backend (padrão), websocket, static"
echo ""
echo "Exemplos:"
echo " $0 add api # Adiciona api.guistorm.io"
echo " $0 add chat 8090 websocket # Adiciona chat com WebSocket"
echo " $0 add docs 0 static # Adiciona site estático"
echo " $0 remove api # Remove api.guistorm.io"
echo " $0 list # Lista todos os subdomínios"
}
# ═══════════════════════════════════════════════════════════════════════════════
# MAIN
# ═══════════════════════════════════════════════════════════════════════════════
main() {
# Verificar root
check_root
# Inicializar snippets se necessário
init_caddy_snippets
# Criar diretórios necessários
mkdir -p "$APPS_DIR" "$LOG_DIR" "$CADDY_BACKUP_DIR"
# Modo de execução
if [[ $# -eq 0 ]]; then
# Menu interativo
while true; do
show_menu
done
else
# Modo CLI
handle_cli "$@"
fi
}
# Executar
main "$@"
Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment