tayo 0.1.13 → 0.2.2

data/lib/tayo/proxy/docker_manager.rb

@@ -0,0 +1,150 @@
+# frozen_string_literal: true
+
+require "colorize"
+require "json"
+
+module Tayo
+  module Proxy
+    class DockerManager
+      def check_containers
+        puts "\n🐳 Docker 컨테이너 상태를 확인합니다...".colorize(:yellow)
+
+        unless docker_installed?
+          puts "❌ Docker가 설치되어 있지 않습니다.".colorize(:red)
+          puts "https://www.docker.com/get-started 에서 Docker를 설치해주세요.".colorize(:cyan)
+          exit 1
+        end
+
+        unless docker_running?
+          puts "❌ Docker가 실행되고 있지 않습니다.".colorize(:red)
+          puts "Docker Desktop을 실행해주세요.".colorize(:cyan)
+          exit 1
+        end
+
+        # Kamal Proxy 상태 확인
+        check_kamal_proxy_status
+
+        # Caddy 상태 확인
+        check_caddy_status
+
+        puts ""
+      end
+
+      def container_exists?(name)
+        output = `docker ps -a --filter "name=^#{name}$" --format "{{.Names}}" 2>/dev/null`.strip
+        !output.empty?
+      end
+
+      def container_running?(name)
+        output = `docker ps --filter "name=^#{name}$" --format "{{.Names}}" 2>/dev/null`.strip
+        !output.empty?
+      end
+
+      def check_port_binding(container, ports)
+        return false unless container_running?(container)
+
+        ports.all? do |port|
+          output = `docker port #{container} #{port} 2>/dev/null`.strip
+          !output.empty?
+        end
+      end
+
+      def port_in_use?(port)
+        # Docker 컨테이너가 포트를 사용 중인지 확인
+        docker_using = `docker ps --format "table {{.Names}}\t{{.Ports}}" | grep -E "0\\.0\\.0\\.0:#{port}->|\\*:#{port}->" 2>/dev/null`.strip
+        return true unless docker_using.empty?
+
+        # 시스템 포트 확인
+        if RUBY_PLATFORM.include?("darwin")
+          # macOS
+          output = `lsof -iTCP:#{port} -sTCP:LISTEN 2>/dev/null`.strip
+        else
+          # Linux
+          output = `netstat -tln 2>/dev/null | grep ":#{port}"`.strip
+          output = `ss -tln 2>/dev/null | grep ":#{port}"`.strip if output.empty?
+        end
+
+        !output.empty?
+      end
+
+      def stop_container(name)
+        return unless container_exists?(name)
+
+        puts "🛑 #{name} 컨테이너를 중지합니다...".colorize(:yellow)
+        system("docker stop #{name} >/dev/null 2>&1")
+        system("docker rm #{name} >/dev/null 2>&1")
+      end
+
+      def get_container_network(name)
+        return nil unless container_running?(name)
+
+        output = `docker inspect #{name} --format '{{range .NetworkSettings.Networks}}{{.NetworkID}}{{end}}' 2>/dev/null`.strip
+        output.empty? ? nil : output
+      end
+
+      def create_network_if_not_exists(network_name = "tayo-proxy")
+        existing = `docker network ls --filter "name=^#{network_name}$" --format "{{.Name}}" 2>/dev/null`.strip
+
+        if existing.empty?
+          puts "📡 Docker 네트워크 '#{network_name}'를 생성합니다...".colorize(:yellow)
+          system("docker network create #{network_name} >/dev/null 2>&1")
+        end
+
+        network_name
+      end
+
+      private
+
+      def docker_installed?
+        system("which docker >/dev/null 2>&1")
+      end
+
+      def docker_running?
+        system("docker info >/dev/null 2>&1")
+      end
+
+      def check_kamal_proxy_status
+        # Traefik으로 교체되어 더 이상 사용하지 않음
+        check_traefik_status
+      end
+
+      def check_traefik_status
+        if container_running?("traefik")
+          if check_port_binding("traefik", [80, 443])
+            puts "✅ Traefik: 실행 중 (80, 443 포트 사용)".colorize(:green)
+          else
+            puts "⚠️  Traefik: 실행 중이지만 포트가 올바르게 바인딩되지 않음".colorize(:yellow)
+            show_port_conflicts
+          end
+        elsif container_exists?("traefik")
+          puts "⚠️  Traefik: 중지됨".colorize(:yellow)
+        else
+          puts "ℹ️  Traefik: 설치되지 않음".colorize(:gray)
+        end
+      end
+
+      def check_caddy_status
+        # Caddy는 더 이상 사용하지 않음
+        # 이 메서드는 하위 호환성을 위해 유지하지만 아무것도 하지 않음
+      end
+
+      def show_port_conflicts
+        [80, 443].each do |port|
+          if port_in_use?(port)
+            # 포트를 사용 중인 프로세스 찾기
+            if RUBY_PLATFORM.include?("darwin")
+              process = `lsof -iTCP:#{port} -sTCP:LISTEN 2>/dev/null | grep LISTEN | head -1`.strip
+            else
+              process = `netstat -tlnp 2>/dev/null | grep ":#{port}" | head -1`.strip
+            end
+
+            unless process.empty?
+              puts "   ⚠️  포트 #{port}가 다른 프로세스에서 사용 중입니다:".colorize(:yellow)
+              puts "      #{process}".colorize(:gray)
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/tayo/proxy/network_config.rb

@@ -0,0 +1,147 @@
+# frozen_string_literal: true
+
+require "colorize"
+require "tty-prompt"
+
+module Tayo
+  module Proxy
+    class NetworkConfig
+      attr_reader :public_ip, :internal_ip, :external_http, :external_https
+
+      def initialize
+        @prompt = TTY::Prompt.new
+        @use_custom_ports = false
+      end
+
+      def detect_ips
+        puts "\n🔍 네트워크 정보를 확인합니다...".colorize(:yellow)
+
+        # 공인 IP 감지
+        print "공인 IP 확인 중... "
+        @public_ip = detect_public_ip
+        puts "#{@public_ip}".colorize(:green)
+
+        # 내부 IP 감지
+        print "내부 IP 확인 중... "
+        @internal_ip = detect_internal_ip
+        puts "#{@internal_ip}".colorize(:green)
+
+        puts ""
+      end
+
+      def configure_ports
+        puts "\n🌐 외부 접속 포트를 설정합니다.".colorize(:yellow)
+        puts "Kamal Proxy는 항상 80, 443 포트를 사용합니다.".colorize(:gray)
+        puts ""
+
+        choices = [
+          { name: "공유기에서 80, 443을 직접 포워딩 (기본)", value: :direct },
+          { name: "다른 포트를 사용하여 포워딩 (예: 8080→80, 8443→443)", value: :custom }
+        ]
+
+        choice = @prompt.select("포트 설정 방식을 선택하세요:", choices)
+
+        if choice == :custom
+          @use_custom_ports = true
+
+          @external_http = @prompt.ask("HTTP 외부 포트 (기본: 8080):", default: "8080")
+          @external_https = @prompt.ask("HTTPS 외부 포트 (기본: 8443):", default: "8443")
+
+          puts "\n✅ 외부 포트가 설정되었습니다:".colorize(:green)
+          puts "   HTTP:  #{@external_http}".colorize(:gray)
+          puts "   HTTPS: #{@external_https}".colorize(:gray)
+        else
+          @external_http = "80"
+          @external_https = "443"
+
+          puts "\n✅ 표준 포트(80, 443)를 사용합니다.".colorize(:green)
+        end
+      end
+
+      def use_custom_ports?
+        @use_custom_ports
+      end
+
+      def show_port_forwarding_guide
+        return unless use_custom_ports?
+
+        puts "\n📡 공유기 포트포워딩 설정 안내:".colorize(:yellow)
+        puts "━" * 50
+        puts "외부 포트 #{@external_http} → #{@internal_ip}:80".colorize(:white)
+        puts "외부 포트 #{@external_https} → #{@internal_ip}:443".colorize(:white)
+        puts "━" * 50
+        puts ""
+        puts "위 설정을 공유기 관리 페이지에서 완료해주세요.".colorize(:cyan)
+        puts "일반적인 접속 주소: http://192.168.1.1".colorize(:gray)
+      end
+
+      private
+
+      def detect_public_ip
+        # curl을 사용한 공인 IP 감지
+        ip = `curl -s ifconfig.me 2>/dev/null`.strip
+
+        # 대체 방법들
+        if ip.empty? || !valid_ip?(ip)
+          ip = `curl -s ipecho.net/plain 2>/dev/null`.strip
+        end
+
+        if ip.empty? || !valid_ip?(ip)
+          ip = `curl -s icanhazip.com 2>/dev/null`.strip
+        end
+
+        if ip.empty? || !valid_ip?(ip)
+          puts "\n⚠️  공인 IP를 자동으로 감지할 수 없습니다.".colorize(:yellow)
+          ip = @prompt.ask("공인 IP를 직접 입력해주세요:") do |q|
+            q.validate(/\A\d{1,3}\.\d{1,3}\.\d{1,3}\.\d{1,3}\z/, "올바른 IP 형식을 입력해주세요")
+          end
+        end
+
+        ip
+      end
+
+      def detect_internal_ip
+        # macOS
+        if RUBY_PLATFORM.include?("darwin")
+          # en0 (Wi-Fi) 또는 en1 (Ethernet) 인터페이스에서 IP 추출
+          ip = `ifconfig en0 2>/dev/null | grep 'inet ' | grep -v 127.0.0.1 | awk '{print $2}'`.strip
+          ip = `ifconfig en1 2>/dev/null | grep 'inet ' | grep -v 127.0.0.1 | awk '{print $2}'`.strip if ip.empty?
+
+          # 다른 인터페이스 검색
+          if ip.empty?
+            ip = `ifconfig | grep 'inet ' | grep -v 127.0.0.1 | grep -v '::1' | head -1 | awk '{print $2}'`.strip
+          end
+        else
+          # Linux
+          ip = `hostname -I 2>/dev/null | awk '{print $1}'`.strip
+
+          if ip.empty?
+            ip = `ip addr show | grep 'inet ' | grep -v 127.0.0.1 | grep -v '::1' | head -1 | awk '{print $2}' | cut -d/ -f1`.strip
+          end
+        end
+
+        # 여전히 비어있다면 수동 입력
+        if ip.empty? || !valid_ip?(ip)
+          puts "\n⚠️  내부 IP를 자동으로 감지할 수 없습니다.".colorize(:yellow)
+          ip = @prompt.ask("내부 IP를 직접 입력해주세요 (예: 192.168.1.100):") do |q|
+            q.validate(/\A\d{1,3}\.\d{1,3}\.\d{1,3}\.\d{1,3}\z/, "올바른 IP 형식을 입력해주세요")
+          end
+        end
+
+        ip
+      end
+
+      def valid_ip?(ip)
+        return false if ip.nil? || ip.empty?
+
+        parts = ip.split('.')
+        return false unless parts.length == 4
+
+        parts.all? do |part|
+          num = part.to_i
+          num >= 0 && num <= 255 && part == num.to_s
+        end
+      end
+    end
+  end
+end

data/lib/tayo/proxy/traefik_config.rb

@@ -0,0 +1,303 @@
+# frozen_string_literal: true
+
+require "colorize"
+require "fileutils"
+require "yaml"
+require "erb"
+
+module Tayo
+  module Proxy
+    class TraefikConfig
+      TRAEFIK_CONFIG_DIR = File.expand_path("~/.tayo/traefik")
+
+      def initialize
+        @docker = DockerManager.new
+      end
+
+      def setup(domains, email = nil)
+        puts "\n⚙️  Traefik을 설정합니다...".colorize(:yellow)
+
+        # 설정 디렉토리 생성
+        setup_directories
+
+        # 이메일 주소 입력 (Let's Encrypt용)
+        email ||= get_email_for_acme
+
+        # 설정 파일 생성
+        create_docker_compose(email)
+        create_traefik_config(email)
+        create_dynamic_config(domains)
+
+        # Traefik 시작
+        ensure_running
+
+        # 라우팅 설정
+        configure_routes(domains)
+
+        puts "✅ Traefik 설정이 완료되었습니다.".colorize(:green)
+      end
+
+      private
+
+      def setup_directories
+        FileUtils.mkdir_p(TRAEFIK_CONFIG_DIR)
+        FileUtils.mkdir_p(File.join(TRAEFIK_CONFIG_DIR, "config"))
+
+        # acme.json 파일 생성 및 권한 설정
+        acme_file = File.join(TRAEFIK_CONFIG_DIR, "acme.json")
+        unless File.exist?(acme_file)
+          File.write(acme_file, "{}")
+          File.chmod(0600, acme_file)
+        end
+      end
+
+      def get_email_for_acme
+        prompt = TTY::Prompt.new
+
+        # 저장된 이메일 확인
+        email_file = File.join(TRAEFIK_CONFIG_DIR, ".email")
+        if File.exist?(email_file)
+          saved_email = File.read(email_file).strip
+          if prompt.yes?("저장된 이메일을 사용하시겠습니까? (#{saved_email})")
+            return saved_email
+          end
+        end
+
+        # 새 이메일 입력
+        email = prompt.ask("Let's Encrypt 인증서용 이메일 주소를 입력하세요:") do |q|
+          q.validate(/\A[\w+\-.]+@[a-z\d\-]+(\.[a-z\d\-]+)*\.[a-z]+\z/i, "올바른 이메일 형식을 입력해주세요")
+        end
+
+        # 이메일 저장
+        File.write(email_file, email)
+        email
+      end
+
+      def create_docker_compose(email)
+        compose_content = <<~YAML
+          version: '3.8'
+
+          services:
+            traefik:
+              image: traefik:v3.0
+              container_name: traefik
+              restart: unless-stopped
+              security_opt:
+                - no-new-privileges:true
+              networks:
+                - traefik-net
+              ports:
+                - "80:80"
+                - "443:443"
+                - "8080:8080"  # 대시보드
+              extra_hosts:
+                - "host.docker.internal:host-gateway"
+              volumes:
+                - /var/run/docker.sock:/var/run/docker.sock:ro
+                - #{TRAEFIK_CONFIG_DIR}/config/traefik.yml:/etc/traefik/traefik.yml:ro
+                - #{TRAEFIK_CONFIG_DIR}/config/dynamic.yml:/etc/traefik/dynamic.yml:ro
+                - #{TRAEFIK_CONFIG_DIR}/acme.json:/acme.json
+              labels:
+                - "traefik.enable=true"
+                - "traefik.http.routers.dashboard.rule=Host(`traefik.localhost`)"
+                - "traefik.http.routers.dashboard.service=api@internal"
+                - "traefik.http.routers.dashboard.middlewares=auth"
+                - "traefik.http.middlewares.auth.basicauth.users=admin:$$2y$$10$$YFPx3EmK6lN5bPG.zPNvp.UYQhkPvNnkZ7J4zYu2GODXJfHZXfYbK"  # admin:admin
+
+          networks:
+            traefik-net:
+              name: traefik-net
+              driver: bridge
+        YAML
+
+        compose_file = File.join(TRAEFIK_CONFIG_DIR, "docker-compose.yml")
+        File.write(compose_file, compose_content)
+        puts "✅ Docker Compose 파일이 생성되었습니다.".colorize(:green)
+      end
+
+      def create_traefik_config(email = nil)
+        # 이메일 주소 확인
+        email_file = File.join(TRAEFIK_CONFIG_DIR, ".email")
+        email ||= File.exist?(email_file) ? File.read(email_file).strip : "admin@example.com"
+
+        config_content = <<~YAML
+          # Traefik 정적 설정
+          api:
+            dashboard: true
+            debug: false
+
+          entryPoints:
+            web:
+              address: ":80"
+              http:
+                redirections:
+                  entryPoint:
+                    to: websecure
+                    scheme: https
+                    permanent: true
+            websecure:
+              address: ":443"
+
+          providers:
+            docker:
+              endpoint: "unix:///var/run/docker.sock"
+              exposedByDefault: false
+              network: traefik-net
+              watch: true
+            file:
+              filename: /etc/traefik/dynamic.yml
+              watch: true
+
+          certificatesResolvers:
+            myresolver:
+              acme:
+                email: #{email}
+                storage: /acme.json
+                tlsChallenge: {}
+                # caServer: https://acme-staging-v02.api.letsencrypt.org/directory  # 테스트용
+
+          log:
+            level: INFO
+            format: json
+
+          accessLog:
+            format: json
+        YAML
+
+        config_file = File.join(TRAEFIK_CONFIG_DIR, "config", "traefik.yml")
+        File.write(config_file, config_content)
+        puts "✅ Traefik 설정 파일이 생성되었습니다.".colorize(:green)
+      end
+
+      def create_dynamic_config(domains)
+        routers = {}
+        services = {}
+
+        domains.each do |domain_info|
+          domain = domain_info[:domain]
+          safe_name = domain.gsub('.', '-').gsub('_', '-')
+
+          # HTTP 라우터 (리다이렉트용)
+          routers["#{safe_name}-http"] = {
+            "rule" => "Host(`#{domain}`)",
+            "entryPoints" => ["web"],
+            "middlewares" => ["redirect-to-https"],
+            "service" => "#{safe_name}-service"
+          }
+
+          # HTTPS 라우터
+          routers["#{safe_name}-https"] = {
+            "rule" => "Host(`#{domain}`)",
+            "entryPoints" => ["websecure"],
+            "service" => "#{safe_name}-service",
+            "tls" => {
+              "certResolver" => "myresolver"
+            }
+          }
+
+          # 서비스 정의 (호스트의 3000 포트로)
+          services["#{safe_name}-service"] = {
+            "loadBalancer" => {
+              "servers" => [
+                { "url" => "http://host.docker.internal:3000" }
+              ]
+            }
+          }
+        end
+
+        # 미들웨어 정의
+        dynamic_config = {
+          "http" => {
+            "middlewares" => {
+              "redirect-to-https" => {
+                "redirectScheme" => {
+                  "scheme" => "https",
+                  "permanent" => true
+                }
+              }
+            },
+            "routers" => routers,
+            "services" => services
+          }
+        }
+
+        dynamic_file = File.join(TRAEFIK_CONFIG_DIR, "config", "dynamic.yml")
+        File.write(dynamic_file, dynamic_config.to_yaml)
+        puts "✅ 동적 라우팅 설정이 생성되었습니다.".colorize(:green)
+      end
+
+      def ensure_running
+        if @docker.container_running?("traefik")
+          puts "🔄 Traefik 컨테이너를 재시작합니다...".colorize(:yellow)
+          reload_traefik
+        else
+          start_container
+        end
+      end
+
+      def start_container
+        puts "🚀 Traefik 컨테이너를 시작합니다...".colorize(:yellow)
+
+        # 기존 컨테이너가 있다면 제거
+        if @docker.container_exists?("traefik")
+          @docker.stop_container("traefik")
+        end
+
+        # Docker Compose로 시작
+        Dir.chdir(TRAEFIK_CONFIG_DIR) do
+          if system("docker compose up -d")
+            puts "✅ Traefik이 시작되었습니다.".colorize(:green)
+
+            # 시작 완료 대기
+            sleep 3
+
+            # 상태 확인
+            check_traefik_status
+          else
+            puts "❌ Traefik 시작에 실패했습니다.".colorize(:red)
+            exit 1
+          end
+        end
+      end
+
+      def reload_traefik
+        puts "🔄 Traefik 설정을 다시 로드합니다...".colorize(:yellow)
+
+        Dir.chdir(TRAEFIK_CONFIG_DIR) do
+          if system("docker compose restart")
+            puts "✅ Traefik이 재시작되었습니다.".colorize(:green)
+          else
+            puts "⚠️  Traefik 재시작에 실패했습니다.".colorize(:yellow)
+          end
+        end
+      end
+
+      def check_traefik_status
+        # 대시보드 접근 확인
+        puts "\n📊 Traefik 대시보드: http://localhost:8080".colorize(:cyan)
+        puts "   (기본 인증: admin / admin)".colorize(:gray)
+
+        # 로그 확인
+        logs = `docker logs traefik --tail 5 2>&1`.strip
+        if logs.include?("error") || logs.include?("Error")
+          puts "\n⚠️  Traefik 로그에 오류가 발견되었습니다:".colorize(:yellow)
+          puts logs.colorize(:gray)
+        end
+      end
+
+      def configure_routes(domains)
+        puts "\n📝 도메인 라우팅 상태:".colorize(:yellow)
+
+        domains.each do |domain_info|
+          domain = domain_info[:domain]
+          puts "   • #{domain} → localhost:3000".colorize(:green)
+          puts "     HTTP:  http://#{domain} (→ HTTPS 리다이렉트)".colorize(:gray)
+          puts "     HTTPS: https://#{domain} (Let's Encrypt 인증서)".colorize(:gray)
+        end
+
+        puts "\n💡 Let's Encrypt 인증서 발급 중...".colorize(:yellow)
+        puts "   첫 발급에는 1-2분이 소요될 수 있습니다.".colorize(:gray)
+      end
+    end
+  end
+end