tayo 0.1.13 → 0.2.0

data/lib/tayo/commands/sqlite.rb

@@ -1,413 +0,0 @@
-# frozen_string_literal: true
-
-require 'tayo/commands/base'
-require 'git'
-require 'colorize'
-require 'tty-prompt'
-
-module Tayo
-  module Commands
-    class Sqlite < Base
-      def execute
-        puts "\n🗄️  SQLite 프로덕션 최적화 설정을 시작합니다...".colorize(:yellow)
-        puts "Tayo #{Tayo::VERSION}".colorize(:light_black)
-        
-        unless in_rails_project?
-          puts "❌ Rails 프로젝트가 아닙니다. Rails 프로젝트 루트에서 실행해주세요.".colorize(:red)
-          exit 1
-        end
-        
-        puts "\n이 명령은 다음 작업을 수행합니다:".colorize(:light_black)
-        puts "  • database.yml에 SQLite 프로덕션 최적화 설정 추가"
-        puts "  • SQLite pragma 초기화 파일 생성"
-        puts "  • SQLite 설정 검증 rake task 생성"
-        puts "  • SQLite 프로덕션 가이드 문서 생성"
-        
-        prompt = TTY::Prompt.new
-        continue = prompt.yes?("\n계속하시겠습니까?")
-        
-        unless continue
-          puts "취소되었습니다.".colorize(:yellow)
-          exit 0
-        end
-        
-        # Git 상태 체크
-        git = Git.open('.')
-        unless git.status.changed.empty? && git.status.added.empty? && git.status.deleted.empty?
-          puts "\n⚠️  커밋되지 않은 변경사항이 있습니다.".colorize(:yellow)
-          puts "SQLite 설정을 적용하기 전에 현재 상태를 커밋하는 것을 권장합니다.".colorize(:light_black)
-          
-          commit_now = prompt.yes?("\n지금 커밋하시겠습니까?")
-          if commit_now
-            git.add(all: true)
-            git.commit("현재 상태 저장 (tayo sqlite 실행 전)")
-            puts "✓ 현재 상태를 커밋했습니다.".colorize(:green)
-          end
-        end
-        
-        # database.yml 업데이트
-        update_database_yml
-        
-        # SQLite pragma 초기화 파일 생성
-        create_sqlite_pragma_initializer
-        
-        # SQLite 검증 rake task 생성
-        create_sqlite_check_rake_task
-        
-        # SQLite 가이드 문서 생성
-        create_sqlite_guide
-        
-        # Git 커밋
-        begin
-          git.add('config/database.yml')
-          git.add('config/initializers/sqlite3_pragmas.rb')
-          git.add('lib/tasks/sqlite_check.rake')
-          git.add('sqlite_guide.md')
-          
-          commit_message = <<~MSG
-            SQLite 프로덕션 최적화 설정 추가
-            
-            - WAL 모드와 IMMEDIATE 트랜잭션으로 동시성 문제 해결
-            - busy_timeout 5초 설정으로 SQLITE_BUSY 에러 방지
-            - 캐시 및 메모리 최적화로 성능 향상
-            - 설정 검증을 위한 rake task 추가
-            - 상세 가이드 문서 포함
-          MSG
-          
-          git.commit(commit_message)
-          puts "\n✓ 변경사항을 Git에 커밋했습니다.".colorize(:green)
-        rescue => e
-          puts "\n⚠️  Git 커밋 실패: #{e.message}".colorize(:yellow)
-          puts "수동으로 커밋해주세요.".colorize(:light_black)
-        end
-        
-        puts "\n✅ SQLite 프로덕션 최적화 설정이 완료되었습니다!".colorize(:green)
-        puts "\n다음 명령으로 설정을 검증할 수 있습니다:".colorize(:light_black)
-        puts "  rails db:sqlite_check".colorize(:cyan)
-        puts "  rails db:sqlite_stats".colorize(:cyan)
-        puts "\n자세한 내용은 sqlite_guide.md 파일을 참고하세요.".colorize(:light_black)
-      end
-      
-      private
-      
-      def update_database_yml
-        puts "\n📝 database.yml 업데이트 중...".colorize(:blue)
-        
-        database_yml_path = 'config/database.yml'
-        unless File.exist?(database_yml_path)
-          puts "❌ config/database.yml 파일을 찾을 수 없습니다.".colorize(:red)
-          exit 1
-        end
-        
-        # 백업 생성
-        backup_path = "#{database_yml_path}.backup"
-        FileUtils.cp(database_yml_path, backup_path)
-        puts "  백업 생성: #{backup_path}".colorize(:light_black)
-        
-        content = File.read(database_yml_path)
-        
-        # SQLite 최적화 설정 추가
-        optimized_content = add_sqlite_optimizations(content)
-        
-        File.write(database_yml_path, optimized_content)
-        puts "✓ database.yml이 업데이트되었습니다.".colorize(:green)
-      end
-      
-      def add_sqlite_optimizations(content)
-        # 이미 최적화 설정이 있는지 확인
-        if content.include?('transaction_mode: IMMEDIATE')
-          puts "  이미 SQLite 최적화 설정이 적용되어 있습니다.".colorize(:yellow)
-          return content
-        end
-        
-        # production 섹션 찾기
-        if content =~ /^production:\s*$/
-          # 기존 production 설정이 단순한 경우
-          if content =~ /^production:\s*\n\s+<<:\s*\*default/
-            # 새로운 production 설정으로 교체
-            new_production = <<~YAML
-            production:
-              primary:
-                <<: *default
-                database: storage/production.sqlite3
-                transaction_mode: IMMEDIATE
-                pragmas:
-                  journal_mode: WAL
-                  synchronous: NORMAL
-                  cache_size: 2000
-                  journal_size_limit: 27103364
-                  foreign_keys: ON
-                  mmap_size: 134217728
-                  busy_timeout: 5000
-              cache:
-                <<: *default
-                database: storage/production_cache.sqlite3
-                migrations_paths: db/cache_migrate
-                transaction_mode: IMMEDIATE
-                pragmas:
-                  journal_mode: WAL
-                  synchronous: NORMAL
-                  cache_size: 2000
-                  journal_size_limit: 27103364
-                  foreign_keys: ON
-                  mmap_size: 134217728
-                  busy_timeout: 5000
-              queue:
-                <<: *default
-                database: storage/production_queue.sqlite3
-                migrations_paths: db/queue_migrate
-                transaction_mode: IMMEDIATE
-                pragmas:
-                  journal_mode: WAL
-                  synchronous: NORMAL
-                  cache_size: 2000
-                  journal_size_limit: 27103364
-                  foreign_keys: ON
-                  mmap_size: 134217728
-                  busy_timeout: 5000
-              cable:
-                <<: *default
-                database: storage/production_cable.sqlite3
-                migrations_paths: db/cable_migrate
-                transaction_mode: IMMEDIATE
-                pragmas:
-                  journal_mode: WAL
-                  synchronous: NORMAL
-                  cache_size: 2000
-                  journal_size_limit: 27103364
-                  foreign_keys: ON
-                  mmap_size: 134217728
-                  busy_timeout: 5000
-            YAML
-            
-            content.sub!(/^production:\s*\n\s+<<:\s*\*default\s*\n\s+database:\s+storage\/production\.sqlite3/, new_production.chomp)
-          end
-        end
-        
-        # default 섹션에 busy_timeout 추가
-        unless content.include?('pragmas:')
-          content.sub!(/^(\s+timeout:\s+5000)/, "\\1\n  pragmas:\n    busy_timeout: 5000")
-        end
-        
-        content
-      end
-      
-      def create_sqlite_pragma_initializer
-        puts "\n📝 SQLite pragma 초기화 파일 생성 중...".colorize(:blue)
-        
-        initializer_path = 'config/initializers/sqlite3_pragmas.rb'
-        
-        # consulteam의 sqlite3_pragmas.rb 내용
-        initializer_content = <<~RUBY
-        # SQLite3 프로덕션 최적화 설정
-        # database.yml의 pragma 설정을 보완하는 추가 설정
-        
-        # ActiveRecord가 연결을 설정할 때마다 실행되도록 설정
-        ActiveSupport.on_load(:active_record) do
-          if defined?(ActiveRecord::ConnectionAdapters::SQLite3Adapter)
-            # SQLite3Adapter의 configure_connection 메서드 오버라이드
-            module SQLite3BusyTimeoutPatch
-              def configure_connection
-                super
-                # busy_timeout을 확실하게 설정 (밀리초 단위)
-                if @raw_connection.respond_to?(:busy_timeout)
-                  @raw_connection.busy_timeout(5000)
-                end
-                raw_execute("PRAGMA busy_timeout = 5000", "SCHEMA")
-                raw_execute("PRAGMA journal_size_limit = 27103364", "SCHEMA")
-              end
-            end
-            
-            ActiveRecord::ConnectionAdapters::SQLite3Adapter.prepend(SQLite3BusyTimeoutPatch)
-          end
-        end
-        
-        Rails.application.config.after_initialize do
-          ActiveRecord::Base.connection_pool.with_connection do |connection|
-            if connection.adapter_name == 'SQLite'
-              # 개발 환경에서도 중요한 설정은 적용
-              # SQLite3 gem의 busy_timeout 메서드를 직접 호출
-              if connection.raw_connection.respond_to?(:busy_timeout)
-                connection.raw_connection.busy_timeout(5000)
-              else
-                connection.execute("PRAGMA busy_timeout = 5000")
-              end
-              connection.execute("PRAGMA journal_size_limit = 27103364")
-              
-              if Rails.env.production?
-                # WAL 모드 확인 (database.yml에서 이미 설정되어 있어야 함)
-                result = connection.execute("PRAGMA journal_mode")
-                journal_mode = result.first["journal_mode"] rescue result.first.values.first
-                
-                unless journal_mode.upcase == "WAL"
-                  Rails.logger.warn "WARNING: SQLite is not in WAL mode. Production performance may be severely impacted."
-                end
-                
-                # busy_timeout 확인
-                result = connection.execute("PRAGMA busy_timeout")
-                busy_timeout = result.first["busy_timeout"] rescue result.first.values.first
-                
-                if busy_timeout.to_i < 5000
-                  Rails.logger.warn "WARNING: SQLite busy_timeout is less than 5000ms. This may cause SQLITE_BUSY errors under load."
-                end
-                
-                # 추가 최적화 설정
-                connection.execute("PRAGMA temp_store = MEMORY")
-                connection.execute("PRAGMA optimize")
-                
-                Rails.logger.info "SQLite production optimizations applied successfully"
-                Rails.logger.info "Journal mode: \#{journal_mode}, Busy timeout: \#{busy_timeout}ms"
-              end
-            end
-          end
-        end
-        
-        # 주기적인 최적화 실행 (선택사항)
-        if Rails.env.production? && defined?(ActiveRecord::Base)
-          Thread.new do
-            loop do
-              sleep(4.hours)
-              begin
-                ActiveRecord::Base.connection_pool.with_connection do |connection|
-                  if connection.adapter_name == 'SQLite'
-                    connection.execute("PRAGMA optimize")
-                    Rails.logger.info "SQLite PRAGMA optimize executed"
-                  end
-                end
-              rescue => e
-                Rails.logger.error "Failed to run SQLite optimization: \#{e.message}"
-              end
-            end
-          end
-        end
-        RUBY
-        
-        File.write(initializer_path, initializer_content)
-        puts "✓ #{initializer_path} 파일이 생성되었습니다.".colorize(:green)
-      end
-      
-      def create_sqlite_check_rake_task
-        puts "\n📝 SQLite 검증 rake task 생성 중...".colorize(:blue)
-        
-        # lib/tasks 디렉토리 생성
-        FileUtils.mkdir_p('lib/tasks')
-        
-        rake_task_path = 'lib/tasks/sqlite_check.rake'
-        
-        # consulteam의 sqlite_check.rake 내용
-        rake_task_content = <<~RUBY
-        namespace :db do
-          desc "SQLite 프로덕션 설정 검증"
-          task sqlite_check: :environment do
-            if ActiveRecord::Base.connection.adapter_name == 'SQLite'
-              puts "\\n=== SQLite 프로덕션 설정 검증 ==="
-              
-              connection = ActiveRecord::Base.connection
-              
-              # 각 pragma 설정 확인
-              pragmas = {
-                'journal_mode' => 'WAL',
-                'synchronous' => 'NORMAL',
-                'cache_size' => '2000',
-                'journal_size_limit' => '27103364',
-                'foreign_keys' => '1',
-                'mmap_size' => '134217728',
-                'busy_timeout' => '5000'
-              }
-              
-              all_good = true
-              
-              pragmas.each do |pragma, expected|
-                result = connection.execute("PRAGMA \#{pragma}")
-                actual = result.first[pragma] rescue result.first.values.first
-                
-                if pragma == 'foreign_keys'
-                  status = actual.to_s == expected ? "✓" : "✗"
-                elsif pragma == 'journal_mode'
-                  status = actual.to_s.upcase == expected ? "✓" : "✗"
-                elsif pragma == 'synchronous'
-                  # NORMAL = 1 in SQLite
-                  status = (actual.to_s == '1' || actual.to_s.upcase == expected) ? "✓" : "✗"
-                else
-                  status = actual.to_s == expected ? "✓" : "✗"
-                end
-                
-                puts "\#{status} \#{pragma.ljust(20)}: \#{actual} \#{status == '✗' ? "(예상값: \#{expected})" : ""}"
-                all_good = false if status == "✗"
-              end
-              
-              # transaction_mode 확인 (Rails 로그에서만 확인 가능)
-              puts "\\n참고: transaction_mode=IMMEDIATE 설정은 런타임에서만 확인 가능합니다."
-              
-              if all_good
-                puts "\\n✅ 모든 SQLite 프로덕션 설정이 올바르게 구성되었습니다!"
-              else
-                puts "\\n⚠️  일부 설정이 권장값과 다릅니다. database.yml을 확인하세요."
-              end
-            else
-              puts "이 태스크는 SQLite 데이터베이스에서만 사용 가능합니다."
-            end
-          end
-          
-          desc "SQLite 성능 통계 확인"
-          task sqlite_stats: :environment do
-            if ActiveRecord::Base.connection.adapter_name == 'SQLite'
-              puts "\\n=== SQLite 성능 통계 ==="
-              
-              connection = ActiveRecord::Base.connection
-              
-              # 데이터베이스 파일 크기
-              db_path = connection.instance_variable_get(:@config)[:database]
-              if File.exist?(db_path)
-                size_mb = File.size(db_path) / 1024.0 / 1024.0
-                puts "데이터베이스 크기: \#{'%.2f' % size_mb} MB"
-                
-                # WAL 파일 크기 확인
-                wal_path = "\#{db_path}-wal"
-                if File.exist?(wal_path)
-                  wal_size_mb = File.size(wal_path) / 1024.0 / 1024.0
-                  puts "WAL 파일 크기: \#{'%.2f' % wal_size_mb} MB"
-                end
-              end
-              
-              # 페이지 정보
-              result = connection.execute("PRAGMA page_count")
-              page_count = result.first.values.first
-              
-              result = connection.execute("PRAGMA page_size")
-              page_size = result.first.values.first
-              
-              puts "페이지 수: \#{page_count}"
-              puts "페이지 크기: \#{page_size} bytes"
-              
-              # 캐시 히트율 (대략적인 추정)
-              result = connection.execute("PRAGMA cache_size")
-              cache_size = result.first.values.first
-              puts "캐시 크기: \#{cache_size} pages"
-              
-              puts "\\n실시간 성능 모니터링을 위해서는 애플리케이션 로그를 확인하세요."
-            else
-              puts "이 태스크는 SQLite 데이터베이스에서만 사용 가능합니다."
-            end
-          end
-        end
-        RUBY
-        
-        File.write(rake_task_path, rake_task_content)
-        puts "✓ #{rake_task_path} 파일이 생성되었습니다.".colorize(:green)
-      end
-      
-      def create_sqlite_guide
-        puts "\n📝 SQLite 가이드 문서 생성 중...".colorize(:blue)
-        
-        guide_path = 'sqlite_guide.md'
-        
-        # consulteam의 sqlite_guide.md 내용
-        guide_content = File.read('/Users/alfonso/projects/consulteam/sqlite_guide.md')
-        
-        File.write(guide_path, guide_content)
-        puts "✓ #{guide_path} 파일이 생성되었습니다.".colorize(:green)
-      end
-    end
-  end
-end

data/scripts/setup_rubygems_key.sh

@@ -1,60 +0,0 @@
-#!/bin/bash
-
-# RubyGems API 키 설정 스크립트
-
-echo "🔑 RubyGems API 키 설정 도우미"
-echo "================================"
-echo ""
-echo "이 스크립트는 RubyGems API 키를 안전하게 저장합니다."
-echo ""
-
-# 옵션 선택
-echo "저장 방법을 선택하세요:"
-echo "1) ~/.gem/credentials (표준 방법)"
-echo "2) macOS Keychain (가장 안전)"
-echo "3) 둘 다"
-echo ""
-read -p "선택 (1-3): " choice
-
-# API 키 입력
-echo ""
-read -s -p "RubyGems API 키를 입력하세요: " api_key
-echo ""
-
-case $choice in
-  1)
-    # credentials 파일에 저장
-    mkdir -p ~/.gem
-    echo "---" > ~/.gem/credentials
-    echo ":rubygems_api_key: $api_key" >> ~/.gem/credentials
-    chmod 0600 ~/.gem/credentials
-    echo "✅ ~/.gem/credentials에 저장되었습니다."
-    ;;
-  2)
-    # Keychain에 저장
-    security add-generic-password -a "$USER" -s "rubygems-api-key" -w "$api_key" -U
-    echo "✅ macOS Keychain에 저장되었습니다."
-    ;;
-  3)
-    # 둘 다
-    mkdir -p ~/.gem
-    echo "---" > ~/.gem/credentials
-    echo ":rubygems_api_key: $api_key" >> ~/.gem/credentials
-    chmod 0600 ~/.gem/credentials
-    security add-generic-password -a "$USER" -s "rubygems-api-key" -w "$api_key" -U
-    echo "✅ 두 곳 모두에 저장되었습니다."
-    ;;
-  *)
-    echo "❌ 잘못된 선택입니다."
-    exit 1
-    ;;
-esac
-
-echo ""
-echo "🎉 설정이 완료되었습니다!"
-echo ""
-echo "이제 다음 명령으로 gem을 배포할 수 있습니다:"
-echo "  rake release"
-echo ""
-echo "또는 Keychain에서 키를 사용하려면:"
-echo "  GEM_HOST_API_KEY=\$(security find-generic-password -a \"$USER\" -s \"rubygems-api-key\" -w) rake release"