kitsune-kit 0.4.1 → 0.6.0

data/lib/kitsune/kit/commands/setup_redis_docker.rb

@@ -1,241 +0,0 @@
-require "thor"
-require "net/ssh"
-require "fileutils"
-require "shellwords"
-require_relative "../defaults"
-require_relative "../options_builder"
-require "pry"
-module Kitsune
-  module Kit
-    module Commands
-      class SetupRedisDocker < Thor
-        namespace "setup_redis_docker"
-
-        class_option :server_ip, aliases: "-s", required: true, desc: "Server IP address or hostname"
-        class_option :ssh_port, aliases: "-p", desc: "SSH port"
-        class_option :ssh_key_path, aliases: "-k", desc: "Path to SSH private key"
-
-        desc "create", "Setup Redis using Docker Compose on remote server"
-        def create
-          redis_defaults = Kitsune::Kit::Defaults.redis
-
-          if redis_defaults[:redis_password] == "secret"
-            say "⚠️ Warning: You are using the default Redis password ('secret').", :yellow
-            if ENV.fetch("KIT_ENV", "development") == "production"
-              abort "❌ Production environment requires a secure Redis password!"
-            else
-              say "🔒 Please change REDIS_PASSWORD in your .env if needed.", :yellow
-            end
-          end
-
-          filled_options = Kitsune::Kit::OptionsBuilder.build(
-            options,
-            required: [:server_ip],
-            defaults: Kitsune::Kit::Defaults.ssh
-          )
-
-          with_ssh_connection(filled_options) do |ssh|
-            perform_setup(ssh, redis_defaults, filled_options)
-          end
-        end
-
-        desc "rollback", "Remove Redis Docker setup from remote server"
-        def rollback
-          redis_defaults = Kitsune::Kit::Defaults.redis
-
-          filled_options = Kitsune::Kit::OptionsBuilder.build(
-            options,
-            required: [:server_ip],
-            defaults: Kitsune::Kit::Defaults.ssh
-          )
-
-          with_ssh_connection(filled_options) do |ssh|
-            perform_rollback(ssh, redis_defaults)
-          end
-        end
-
-        no_commands do
-          def with_ssh_connection(filled_options)
-            server = filled_options[:server_ip]
-            port   = filled_options[:ssh_port]
-            key    = File.expand_path(filled_options[:ssh_key_path])
-
-            say "🔑 Connecting as deploy@#{server}:#{port}", :green
-            Net::SSH.start(server, "deploy", port: port, keys: [key], non_interactive: true, timeout: 5) do |ssh|
-              yield ssh
-            end
-          end
-
-          def perform_setup(ssh, redis_defaults, filled_options)
-            local_compose = ".kitsune/docker/redis.yml"
-            remote_dir = "$HOME/docker/redis"
-            compose_remote = "#{remote_dir}/docker-compose.yml"
-            env_remote = "#{remote_dir}/.env"
-            marker = "/usr/local/backups/setup_redis_docker.after"
-
-            abort "❌ Missing #{local_compose}" unless File.exist?(local_compose)
-
-            # 1. Create base directory securely
-            ssh.exec!("mkdir -p #{remote_dir} && chmod 700 #{remote_dir}")
-
-            # 2. Upload docker-compose.yml
-            say "📦 Uploading docker-compose.yml to #{remote_dir}", :cyan
-            upload_file(ssh, File.read(local_compose), compose_remote)
-
-            # 3. Create .env file for docker-compose based on redis_defaults
-            env_content = <<~ENVFILE
-              REDIS_PORT=#{redis_defaults[:redis_port]}
-              REDIS_PASSWORD=#{redis_defaults[:redis_password]}
-            ENVFILE
-            upload_file(ssh, env_content, env_remote)
-
-            # 4. Secure file permissions
-            ssh.exec!("chmod 600 #{compose_remote} #{env_remote}")
-
-            # 5. Create a backup marker
-            ssh.exec!("sudo mkdir -p /usr/local/backups && sudo touch #{marker}")
-
-            # 6. Validate docker-compose.yml
-            say "🔍 Validating docker-compose.yml...", :cyan
-            validation_output = ssh.exec!("cd #{remote_dir} && docker compose config")
-            say validation_output, :cyan
-
-            # 7. Check if container is running
-            container_status = ssh.exec!("docker ps --filter 'name=redis' --format '{{.Status}}'").strip
-
-            if container_status.empty?
-              say "▶️ No running container. Running docker compose up...", :cyan
-              ssh.exec!("cd #{remote_dir} && docker compose up -d")
-            else
-              say "⚠️ Redis container is already running.", :yellow
-              if yes?("🔁 Recreate the container with updated configuration? [y/N]", :yellow)
-                say "🔄 Recreating container...", :cyan
-                ssh.exec!("cd #{remote_dir} && docker compose down -v && docker compose up -d")
-              else
-                say "⏩ Keeping existing container.", :cyan
-              end
-            end
-
-            # 8. Check container status
-            say "📋 Final container status (docker compose ps):", :cyan
-            docker_ps_output = ssh.exec!("cd #{remote_dir} && docker compose ps --format json")
-
-            if docker_ps_output.nil? || docker_ps_output.strip.empty? || docker_ps_output.include?("no configuration file")
-              say "⚠️ docker compose ps returned no valid output.", :yellow
-            else
-              begin
-                services = JSON.parse(docker_ps_output)
-                services = [services] if services.is_a?(Hash)
-
-                redis = services.find { |svc| svc["Service"] == "redis" }
-                status = redis && redis["State"]
-                health = redis && redis["Health"]
-
-                if (status == "running" && health == "healthy") || (health == "healthy")
-                  say "✅ Redis container is running and healthy.", :green
-                else
-                  say "⚠️ Redis container is not healthy yet.", :yellow
-                end
-              rescue JSON::ParserError => e
-                say "🚨 Failed to parse docker compose ps output as JSON: #{e.message}", :red
-              end
-            end
-
-            # 9. Check Redis readiness with retries
-            say "🔍 Checking Redis health with retries...", :cyan
-
-            max_attempts = 10
-            attempt = 0
-            success = false
-
-            while attempt < max_attempts
-              attempt += 1
-              healthcheck = ssh.exec!("docker exec $(docker ps -qf name=redis) redis-cli --no-auth-warning -a \"#{redis_defaults[:redis_password]}\" PING")
-
-              if healthcheck.strip == "PONG"
-                say "✅ Redis is up and responding to PING! (attempt #{attempt})", :green
-                success = true
-
-                redis_url = build_redis_url(filled_options, redis_defaults)
-                say "🔗 Your REDIS_URL is:\t", :cyan
-                say redis_url, :green
-                break
-              else
-                say "⏳ Redis not ready yet, retrying in 5 seconds... (#{attempt}/#{max_attempts})", :yellow
-                sleep 5
-              end
-            end
-
-            unless success
-              say "❌ Redis did not become ready after #{max_attempts} attempts.", :red
-            end
-
-            # 10. Allow Redis port through firewall (ufw)
-            say "🛡️ Configuring firewall to allow Redis (port #{redis_defaults[:redis_port]})...", :cyan
-            output = ssh.exec! <<~EOH
-              if command -v ufw >/dev/null; then
-                if ! sudo ufw status | grep -q "#{redis_defaults[:redis_port]}"; then
-                  sudo ufw allow #{redis_defaults[:redis_port]}
-                else
-                  echo "💡 Port #{redis_defaults[:redis_port]} is already allowed in ufw."
-                fi
-              else
-                echo "⚠️ ufw not found. Skipping firewall configuration."
-              fi
-            EOH
-            say output
-
-            say "✅ Redis setup completed successfully!", :green
-          end
-
-          def perform_rollback(ssh, defaults)
-            output = ssh.exec! <<~EOH
-              set -e
-          
-              BASE_DIR="$HOME/docker/redis"
-              BACKUP_DIR="/usr/local/backups"
-              SCRIPT_ID="setup_redis_docker"
-              AFTER_FILE="${BACKUP_DIR}/${SCRIPT_ID}.after"
-          
-              if [ -f "$AFTER_FILE" ]; then
-                echo "🔁 Stopping and removing docker containers..."
-                cd "$BASE_DIR"
-                docker compose down -v || true
-          
-                echo "🧹 Cleaning up files..."
-                rm -rf "$BASE_DIR"
-                sudo rm -f "$AFTER_FILE"
-          
-                if command -v ufw >/dev/null; then
-                  echo "🛡️ Removing Redis port from firewall..."
-                  sudo ufw delete allow #{defaults[:redis_port]} || true
-                fi
-              else
-                echo "💡 Nothing to rollback"
-              fi
-          
-              echo "✅ Rollback completed"
-            EOH
-          
-            say output
-          end
-          
-
-          def upload_file(ssh, content, remote_path)
-            escaped = Shellwords.escape(content)
-            ssh.exec!("mkdir -p #{File.dirname(remote_path)}")
-            ssh.exec!("echo #{escaped} > #{remote_path}")
-          end
-
-          def build_redis_url(filled_options, redis_defaults)
-            password = redis_defaults[:redis_password]
-            host     = filled_options[:server_ip]
-            port     = redis_defaults[:redis_port]
-          
-            "redis://:#{password}@#{host}:#{port}/0"
-          end
-        end
-      end
-    end
-  end
-end

data/lib/kitsune/kit/commands/setup_swap.rb

@@ -1,151 +0,0 @@
-require "thor"
-require "net/ssh"
-require_relative "../defaults"
-require_relative "../options_builder"
-
-module Kitsune
-  module Kit
-    module Commands
-      class SetupSwap < Thor
-        namespace "setup_swap"
-
-        class_option :server_ip, aliases: "-s", required: true, desc: "Server IP address"
-        class_option :ssh_port, aliases: "-p", desc: "SSH port"
-        class_option :ssh_key_path, aliases: "-k", desc: "SSH private key path"
-        class_option :size_gb, type: :numeric, desc: "Swap size in GB"
-        class_option :swappiness, type: :numeric, desc: "vm.swappiness value (0-100)"
-
-        desc "create", "Create and activate a swap file on the remote server"
-        def create
-          if Kitsune::Kit::Defaults.system[:disable_swap]
-            say "⚠️ Swap setup is disabled via DISABLE_SWAP=true", :yellow
-            return
-          end
-
-          filled_options = Kitsune::Kit::OptionsBuilder.build(
-            options,
-            required: [:server_ip],
-            defaults: Kitsune::Kit::Defaults.system.merge(Kitsune::Kit::Defaults.ssh)
-          )
-
-          with_ssh_connection(filled_options) do |ssh|
-            perform_setup(ssh, filled_options)
-          end
-        end
-
-        desc "rollback", "Disable and remove swap file from remote server"
-        def rollback
-          filled_options = Kitsune::Kit::OptionsBuilder.build(
-            options,
-            required: [:server_ip],
-            defaults: Kitsune::Kit::Defaults.system.merge(Kitsune::Kit::Defaults.ssh)
-          )
-
-          with_ssh_connection(filled_options) do |ssh|
-            perform_rollback(ssh)
-          end
-        end
-
-        no_commands do
-          def with_ssh_connection(filled)
-            server = filled[:server_ip]
-            port   = filled[:ssh_port]
-            key    = File.expand_path(filled[:ssh_key_path])
-
-            say "🔑 Connecting as deploy@#{server}:#{port}", :green
-            Net::SSH.start(server, "deploy", port: port, keys: [key], non_interactive: true, timeout: 5) do |ssh|
-              yield ssh
-            end
-          end
-
-          def perform_setup(ssh, filled_options)
-            size_gb = filled_options[:swap_size_gb].to_i
-            swappiness = filled_options[:swap_swappiness].to_i
-
-            abort "❌ Invalid swap size" if size_gb <= 0
-
-            script = <<~EOH
-              set -e
-
-              BACKUP_DIR="/usr/local/backups"
-              MARKER_FILE="${BACKUP_DIR}/setup_swap.after"
-              SWAPPINESS_BEFORE_FILE="${BACKUP_DIR}/setup_swap.swappiness.before"
-
-              if [ -f "$MARKER_FILE" ]; then
-                echo "🔁 Swap already set up, skipping."
-                exit 0
-              fi
-
-              SWAPFILE="/swapfile"
-              SIZE_GB=#{size_gb}
-              SIZE_BYTES=$((SIZE_GB * 1024 * 1024 * 1024))
-
-              echo "📝 Creating ${SIZE_GB}GB swap file..."
-              sudo fallocate -l ${SIZE_BYTES} ${SWAPFILE}
-              sudo chmod 600 ${SWAPFILE}
-              sudo mkswap ${SWAPFILE}
-              sudo swapon ${SWAPFILE}
-              echo '/swapfile none swap sw 0 0' | sudo tee -a /etc/fstab
-
-              # Backup swappiness if not already backed up
-              if [ ! -f "$SWAPPINESS_BEFORE_FILE" ]; then
-                CURRENT=$(cat /proc/sys/vm/swappiness)
-                echo "$CURRENT" | sudo tee "$SWAPPINESS_BEFORE_FILE"
-                echo "✍🏻 Backed up vm.swappiness: $CURRENT"
-              fi
-
-              echo "🛠️ Setting vm.swappiness=#{swappiness}"
-              sudo sysctl vm.swappiness=#{swappiness}
-              echo "vm.swappiness=#{swappiness}" | sudo tee -a /etc/sysctl.conf
-
-              sudo mkdir -p "$BACKUP_DIR"
-              sudo touch "$MARKER_FILE"
-
-              echo "✅ Swap file created and swappiness set"
-              free -h
-            EOH
-
-            say ssh.exec!(script)
-          end
-
-          def perform_rollback(ssh)
-            script = <<~EOH
-              set -e
-
-              BACKUP_DIR="/usr/local/backups"
-              MARKER_FILE="${BACKUP_DIR}/setup_swap.after"
-              SWAPPINESS_BEFORE_FILE="${BACKUP_DIR}/setup_swap.swappiness.before"
-
-              if [ ! -f "$MARKER_FILE" ]; then
-                echo "💡 No swap marker found, skipping rollback."
-                exit 0
-              fi
-
-              echo "🧹 Removing swap..."
-              sudo swapoff /swapfile || true
-              sudo rm -f /swapfile
-              sudo sed -i '/\\/swapfile none swap sw 0 0/d' /etc/fstab
-              sudo rm -f "$MARKER_FILE"
-
-              if [ -f "$SWAPPINESS_BEFORE_FILE" ]; then
-                ORIGINAL=$(cat "$SWAPPINESS_BEFORE_FILE")
-                echo "🔁 Restoring vm.swappiness: $ORIGINAL"
-                sudo sysctl vm.swappiness=$ORIGINAL
-                sudo sed -i '/vm.swappiness=/d' /etc/sysctl.conf
-                echo "vm.swappiness=$ORIGINAL" | sudo tee -a /etc/sysctl.conf
-                sudo rm -f "$SWAPPINESS_BEFORE_FILE"
-              else
-                echo "💡 No swappiness backup found, skipping restore."
-              fi
-
-              echo "✅ Swap rollback completed"
-              free -h
-            EOH
-
-            say ssh.exec!(script)
-          end
-        end
-      end
-    end
-  end
-end

data/lib/kitsune/kit/commands/setup_unattended.rb

@@ -1,132 +0,0 @@
-require "thor"
-require "net/ssh"
-require_relative "../defaults"
-require_relative "../options_builder"
-
-module Kitsune
-  module Kit
-    module Commands
-      class SetupUnattended < Thor
-        namespace "setup_unattended"
-
-        class_option :server_ip,    aliases: "-s", required: true, desc: "Server IP address or hostname"
-        class_option :ssh_port,     aliases: "-p", desc: "SSH port"
-        class_option :ssh_key_path, aliases: "-k", desc: "Path to your private SSH key"
-
-        desc "create", "Configure unattended-upgrades on the remote server"
-        def create
-          filled_options = Kitsune::Kit::OptionsBuilder.build(
-            options,
-            required: [:server_ip],
-            defaults: Kitsune::Kit::Defaults.ssh
-          )
-
-          with_ssh_connection(filled_options) do |ssh|
-            perform_setup(ssh)
-          end
-        end
-
-        desc "rollback", "Revert unattended-upgrades configuration on the remote server"
-        def rollback
-          filled_options = Kitsune::Kit::OptionsBuilder.build(
-            options,
-            required: [:server_ip],
-            defaults: Kitsune::Kit::Defaults.ssh
-          )
-
-          with_ssh_connection(filled_options) do |ssh|
-            perform_rollback(ssh)
-          end
-        end
-
-        no_commands do
-          def with_ssh_connection(filled_options)
-            server = filled_options[:server_ip]
-            port   = filled_options[:ssh_port]
-            key    = File.expand_path(filled_options[:ssh_key_path])
-
-            say "🔑 Connecting as deploy@#{server}:#{port}", :green
-            Net::SSH.start(server, "deploy", port: port, keys: [key], non_interactive: true, timeout: 5) do |ssh|
-              yield ssh
-            end
-          end
-
-          def perform_setup(ssh)
-            output = ssh.exec! <<~EOH
-              set -e
-
-              sudo mkdir -p /usr/local/backups
-              sudo chown deploy:deploy /usr/local/backups
-
-              RESOURCE="/etc/apt/apt.conf.d/20auto-upgrades"
-              BACKUP_DIR="/usr/local/backups"
-              SCRIPT_ID="setup_unattended"
-              BACKUP_FILE="${BACKUP_DIR}/${SCRIPT_ID}.before"
-              MARKER_FILE="${BACKUP_DIR}/${SCRIPT_ID}.after"
-
-              echo "✍🏻 Installing required packages…"
-              if ! dpkg -l | grep -q "^ii\\s*unattended-upgrades"; then
-                sudo apt-get update -y
-                sudo apt-get install -y unattended-upgrades apt-listchanges && echo "   - packages installed"
-              else
-                echo "   - unattended-upgrades already installed"
-              fi
-
-              if [ ! -f "$MARKER_FILE" ]; then
-                echo "✍🏻 Backing up existing config…"
-                sudo cp "$RESOURCE" "$BACKUP_FILE" && echo "   - backup saved to $BACKUP_FILE"
-                sudo touch "$MARKER_FILE" && echo "   - marker created at $MARKER_FILE"
-              else
-                echo "   - backup & marker already exist"
-              fi
-
-              echo "✍🏻 Applying new auto-upgrades config…"
-              sudo tee "$RESOURCE" > /dev/null <<UPGR
-APT::Periodic::Update-Package-Lists "1";
-APT::Periodic::Download-Upgradeable-Packages "1";
-APT::Periodic::AutocleanInterval "7";
-APT::Periodic::Unattended-Upgrade "1";
-UPGR
-              echo "   - config applied"
-
-              echo "✍🏻 Enabling & restarting unattended-upgrades…"
-              sudo systemctl --quiet enable unattended-upgrades.service >/dev/null 2>&1 && echo "   - service enabled"
-              sudo systemctl --quiet restart unattended-upgrades.service && echo "   - service restarted"
-            EOH
-            say output
-            say "✅ Unattended-upgrades setup completed", :green
-          end
-
-          def perform_rollback(ssh)
-            output = ssh.exec! <<~EOH
-              set -e
-
-              sudo mkdir -p /usr/local/backups
-              sudo chown deploy:deploy /usr/local/backups
-
-              RESOURCE="/etc/apt/apt.conf.d/20auto-upgrades"
-              BACKUP_DIR="/usr/local/backups"
-              SCRIPT_ID="setup_unattended"
-              BACKUP_FILE="${BACKUP_DIR}/${SCRIPT_ID}.before"
-              MARKER_FILE="${BACKUP_DIR}/${SCRIPT_ID}.after"
-
-              if [ -f "$MARKER_FILE" ]; then
-                echo "🔁 Restoring original auto-upgrades config…"
-                sudo mv "$BACKUP_FILE" "$RESOURCE" && echo "   - config restored from $BACKUP_FILE"
-                sudo rm -f "$MARKER_FILE" && echo "   - marker $MARKER_FILE removed"
-              else
-                echo "   - no marker for $SCRIPT_ID, skipping restore"
-              fi
-
-              echo "✍🏻 Stopping & disabling unattended-upgrades…"
-              sudo systemctl --quiet stop unattended-upgrades.service apt-daily.timer apt-daily-upgrade.timer && echo "   - services stopped"
-              sudo systemctl --quiet disable unattended-upgrades.service && echo "   - service disabled"
-            EOH
-            say output
-            say "✅ Unattended-upgrades rollback completed", :green
-          end
-        end
-      end
-    end
-  end
-end