kitsune-kit 0.2.1 → 0.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: dd66d70ec00aa522857e3ac981a13ada8e49aa5723e1a1fc577bc05b7642e250
-  data.tar.gz: 81121119b1abe6a5b70d9fb59efc96994af2ac144b899e96bb5a0098743ee995
+  metadata.gz: 508f86259061cf1c767fc1a1678aeb8195aaf174214c2c7f9be5557aa1b73c2a
+  data.tar.gz: 38f6179c02ad9a59608bb3e3d3f62bd7b23648bb0bb24a6cdbd9fba179af3255
 SHA512:
-  metadata.gz: 2a49fd2827e0edc77b9a40a8a7b42fef05cb9ba4c6a78655de2419022ec9ad98b703073620643dca76024184557d146e5c67a8fc6536c7596a52a2b13379d5a5
-  data.tar.gz: 8f2d905fd886ba016229e13762e63b9c1997d9289619bf9d3a3793bd222e8a330231884c64d9dba9571a1ebe32fe7f421c84da29e3c064ebce2eb24faa639931
+  metadata.gz: 65b84489d96cc8228afe78113dcd08065d3297957b77fcece8dfb9fe1d5722695086f18cc6387c400a9888342ac82ce56feaa7d2f9d67c780bf6abedb4c7da3e
+  data.tar.gz: 59a28feaca900d703eb9ebe9943993cb1709b66784d7160425dc50f682bf7e93296408f8cdaedac04f3b2583a7757e74e69f7538515cc83abf3bf0f7088a1411

data/README.md

@@ -19,7 +19,8 @@
 - 💾 Configures swap space for better performance
 - 📊 Installs [DigitalOcean monitoring agent](https://docs.digitalocean.com/products/monitoring/how-to/install-agent/)
 - 🐳 Installs and configures Docker Engine and private networking
-- 🐘 Deploys PostgreSQL via Docker Compose with healthcheck and `.env`
+- 🐘 Deploys PostgreSQL via Docker Compose with healthcheck
+- 🗄️ Deploys Redis via Docker Compose with healthcheck
 - 🔄 All steps can be rolled back (`--rollback`)
 - ⚡ Fast, reproducible and without relying on YAML or complex external tools
 

data/lib/kitsune/blueprints/.env.template

@@ -17,6 +17,10 @@ SWAP_SIZE_GB=2
 DISABLE_SWAP=false
 
 # PostgreSQL Docker
-POSTGRES_DB=
-POSTGRES_USER=
-POSTGRES_PASSWORD=
+POSTGRES_DB=myapp_db
+POSTGRES_USER=postgres
+POSTGRES_PASSWORD=secret
+
+# Redis Docker
+REDIS_PORT=6379
+REDIS_PASSWORD=secret

data/lib/kitsune/blueprints/docker/redis.yml

@@ -0,0 +1,23 @@
+services:
+  redis:
+    image: redis:7.2
+    restart: always
+    ports:
+      - "${REDIS_PORT:-6379}:6379"
+    command: redis-server --requirepass ${REDIS_PASSWORD}
+    networks:
+      - private
+    volumes:
+      - redisdata:/data
+    healthcheck:
+      test: ["CMD", "redis-cli", "-a", "${REDIS_PASSWORD}", "ping"]
+      interval: 30s
+      timeout: 10s
+      retries: 5
+
+volumes:
+  redisdata:
+
+networks:
+  private:
+    driver: bridge

data/lib/kitsune/kit/cli.rb

@@ -15,18 +15,29 @@ require_relative "commands/install_docker_engine"
 require_relative "commands/postinstall_docker"
 require_relative "commands/bootstrap_docker"
 require_relative "commands/setup_postgres_docker"
+require_relative "commands/setup_redis_docker"
 
 module Kitsune
   module Kit
     class CLI < Thor
       def self.dispatch(m, args, options, config)
-        unless ["init", "switch_env", "help", nil].include?(args.first)
+        if args.include?("-v") || args.include?("--version")
+          puts "Kitsune Kit v#{Kitsune::Kit::VERSION}"
+          exit(0)
+        end
+      
+        unless ["version", "init", "switch_env", "help", nil].include?(args.first)
           Kitsune::Kit::EnvLoader.load!
         end
 
         super
       end
 
+      desc "version", "Show Kitsune Kit version"
+      def version
+        say "Kitsune Kit v#{Kitsune::Kit::VERSION}", :green
+      end
+
       desc "init", "Initialize Kitsune Kit project structure"
       subcommand "init", Kitsune::Kit::Commands::Init
 
@@ -68,6 +79,9 @@ module Kitsune
 
       desc "setup_postgres_docker SUBCOMMAND", "Setup PostgreSQL via Docker Compose on remote server"
       subcommand "setup_postgres_docker", Kitsune::Kit::Commands::SetupPostgresDocker
+
+      desc "setup_redis_docker SUBCOMMAND", "Setup Redis via Docker Compose on remote server"
+      subcommand "setup_redis_docker", Kitsune::Kit::Commands::SetupRedisDocker
     end
   end
 end

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

@@ -124,8 +124,8 @@ module Kitsune
           end
 
           def copy_docker_templates
-            dest_path = ".kitsune/docker/postgres.yml"
-            copy_with_prompt(blueprint_path("docker/postgres.yml"), dest_path)
+            copy_with_prompt(blueprint_path("docker/postgres.yml"), ".kitsune/docker/postgres.yml")
+            copy_with_prompt(blueprint_path("docker/redis.yml"), ".kitsune/docker/redis.yml")
           end
 
           def copy_with_prompt(source, destination)

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

@@ -26,7 +26,7 @@ module Kitsune
             defaults: Kitsune::Kit::Defaults.ssh
           )
 
-          with_ssh(filled_options) do |ssh|
+          with_ssh_connection(filled_options) do |ssh|
             install_agent(ssh)
           end
         end
@@ -39,13 +39,13 @@ module Kitsune
             defaults: Kitsune::Kit::Defaults.ssh
           )
 
-          with_ssh(filled_options) do |ssh|
+          with_ssh_connection(filled_options) do |ssh|
             uninstall_agent(ssh)
           end
         end
 
         no_commands do
-          def with_ssh(filled_options)
+          def with_ssh_connection(filled_options)
             Net::SSH.start(
               filled_options[:server_ip],
               "deploy",

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

@@ -36,11 +36,7 @@ module Kitsune
           )
 
           with_ssh_connection(filled_options) do |ssh|
-            perform_setup(ssh, postgres_defaults)
-
-            database_url = build_database_url(filled_options, postgres_defaults)
-            say "🔗 Your DATABASE_URL is:\t", :cyan
-            say database_url, :green
+            perform_setup(ssh, postgres_defaults, filled_options)
           end
         end
 
@@ -71,26 +67,21 @@ module Kitsune
             end
           end
 
-          def perform_setup(ssh, postgres_defaults)
-            docker_compose_local = ".kitsune/docker/postgres.yml"
-            unless File.exist?(docker_compose_local)
-              say "❌ Docker compose file not found at #{docker_compose_local}.", :red
-              exit(1)
-            end
+          def perform_setup(ssh, postgres_defaults, filled_options)
+            local_compose = ".kitsune/docker/postgres.yml"
+            remote_dir = "$HOME/docker/postgres"
+            compose_remote = "#{remote_dir}/docker-compose.yml"
+            env_remote = "#{remote_dir}/.env"
+            marker = "/usr/local/backups/setup_postgres_docker.after"
 
-            docker_dir_remote = "$HOME/docker/postgres"
-            docker_compose_remote = "#{docker_dir_remote}/docker-compose.yml"
-            docker_env_remote = "#{docker_dir_remote}/.env"
-            backup_marker = "/usr/local/backups/setup_postgres_docker.after"
+            abort "❌ Missing #{local_compose}" unless File.exist?(local_compose)
 
             # 1. Create base directory securely
-            ssh.exec!("mkdir -p #{docker_dir_remote}")
-            ssh.exec!("chmod 700 #{docker_dir_remote}")
+            ssh.exec!("mkdir -p #{remote_dir} && chmod 700 #{remote_dir}")
 
             # 2. Upload docker-compose.yml
-            say "📦 Uploading docker-compose.yml to remote server...", :cyan
-            content_compose = File.read(docker_compose_local)
-            upload_file(ssh, content_compose, docker_compose_remote)
+            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 postgres_defaults
             say "📦 Creating .env file for Docker Compose...", :cyan
@@ -101,17 +92,17 @@ module Kitsune
               POSTGRES_PORT=#{postgres_defaults[:postgres_port]}
               POSTGRES_IMAGE=#{postgres_defaults[:postgres_image]}
             ENVFILE
-            upload_file(ssh, env_content, docker_env_remote)
+            upload_file(ssh, env_content, env_remote)
 
             # 4. Secure file permissions
-            ssh.exec!("chmod 600 #{docker_compose_remote} #{docker_env_remote}")
+            ssh.exec!("chmod 600 #{compose_remote} #{env_remote}")
 
             # 5. Create backup marker
-            ssh.exec!("sudo mkdir -p /usr/local/backups && sudo touch #{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 #{docker_dir_remote} && docker compose config")
+            validation_output = ssh.exec!("cd #{remote_dir} && docker compose config")
             say validation_output, :cyan
 
             # 7. Check if container is running
@@ -119,19 +110,20 @@ module Kitsune
 
             if container_status.empty?
               say "▶️ No running container. Running docker compose up...", :cyan
-              ssh.exec!("cd #{docker_dir_remote} && docker compose up -d")
+              ssh.exec!("cd #{remote_dir} && docker compose up -d")
             else
               say "⚠️ PostgreSQL container is already running.", :yellow
               if yes?("🔁 Recreate the container with updated configuration? [y/N]", :yellow)
                 say "🔄 Recreating container...", :cyan
-                ssh.exec!("cd #{docker_dir_remote} && docker compose down -v && docker compose up -d")
+                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 #{docker_dir_remote} && docker compose ps --format json")
+            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
@@ -168,9 +160,13 @@ module Kitsune
               if healthcheck.include?("accepting connections")
                 say "✅ PostgreSQL is up and accepting connections! (attempt #{attempt})", :green
                 success = true
+
+                database_url = build_database_url(filled_options, postgres_defaults)
+                say "🔗 Your DATABASE_URL is:\t", :cyan
+                say database_url, :green
                 break
               else
-                say "⏳ PostgreSQL not ready yet, retrying in 5 seconds... (#{attempt + 1}/#{max_attempts})", :yellow
+                say "⏳ PostgreSQL not ready yet, retrying in 5 seconds... (#{attempt}/#{max_attempts})", :yellow
                 sleep 5
               end
             end
@@ -181,7 +177,7 @@ module Kitsune
 
             # 10. Allow PostgreSQL port through firewall (ufw)
             say "🛡️ Configuring firewall to allow PostgreSQL (port #{postgres_defaults[:postgres_port]})...", :cyan
-            firewall = <<~EOH
+            output = ssh.exec! <<~EOH
               if command -v ufw >/dev/null; then
                 if ! sudo ufw status | grep -q "#{postgres_defaults[:postgres_port]}"; then
                   sudo ufw allow #{postgres_defaults[:postgres_port]}
@@ -192,7 +188,9 @@ module Kitsune
                 echo "⚠️ ufw not found. Skipping firewall configuration."
               fi
             EOH
-            ssh.exec!(firewall)
+            say output
+
+            say "✅ PostgreSQL setup completed successfully!", :green
           end
 
           def perform_rollback(ssh, postgres_defaults)
@@ -227,9 +225,9 @@ module Kitsune
           end
 
           def upload_file(ssh, content, remote_path)
-            escaped_content = Shellwords.escape(content)
+            escaped = Shellwords.escape(content)
             ssh.exec!("mkdir -p #{File.dirname(remote_path)}")
-            ssh.exec!("echo #{escaped_content} > #{remote_path}")
+            ssh.exec!("echo #{escaped} > #{remote_path}")
           end
 
           def build_database_url(filled_options, postgres_defaults)

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

@@ -0,0 +1,241 @@
+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/defaults.rb

@@ -19,7 +19,7 @@ module Kitsune
         user: "postgres",
         password: "secret",
         port: "5432",
-        image: "postgres:15"
+        image: "postgres:17"
       }.freeze
 
       SYSTEM = {
@@ -32,6 +32,11 @@ module Kitsune
         enable_do_metrics: true
       }.freeze
 
+      REDIS = {
+        port: "6379",
+        password: "redis:7.2"
+      }.freeze
+
       def self.infra
         {
           droplet_name: ENV.fetch('DROPLET_NAME', DROPLET[:droplet_name]),
@@ -62,6 +67,13 @@ module Kitsune
         }
       end
 
+      def self.redis
+        {
+          redis_port: ENV.fetch("REDIS_PORT", REDIS[:port]),
+          redis_password: ENV.fetch("REDIS_PASSWORD", REDIS[:password])
+        }
+      end
+
       def self.system
         {
           swap_size_gb: ENV.fetch("SWAP_SIZE_GB", SYSTEM[:swap_size_gb]).to_i,

data/lib/kitsune/kit/version.rb

@@ -2,6 +2,6 @@
 
 module Kitsune
   module Kit
-    VERSION = "0.2.1"
+    VERSION = "0.3.0"
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: kitsune-kit
 version: !ruby/object:Gem::Version
-  version: 0.2.1
+  version: 0.3.0
 platform: ruby
 authors:
 - Omar Herrera
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2025-05-02 00:00:00.000000000 Z
+date: 2025-05-04 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: net-ssh
@@ -184,6 +184,7 @@ files:
 - kitsune-kit-logo.jpg
 - lib/kitsune/blueprints/.env.template
 - lib/kitsune/blueprints/docker/postgres.yml
+- lib/kitsune/blueprints/docker/redis.yml
 - lib/kitsune/blueprints/kit.env.template
 - lib/kitsune/kit.rb
 - lib/kitsune/kit/cli.rb
@@ -197,6 +198,7 @@ files:
 - lib/kitsune/kit/commands/setup_docker_prereqs.rb
 - lib/kitsune/kit/commands/setup_firewall.rb
 - lib/kitsune/kit/commands/setup_postgres_docker.rb
+- lib/kitsune/kit/commands/setup_redis_docker.rb
 - lib/kitsune/kit/commands/setup_swap.rb
 - lib/kitsune/kit/commands/setup_unattended.rb
 - lib/kitsune/kit/commands/setup_user.rb