chagall 0.0.1.beta5 → 0.0.1.beta6

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 2e44d1b04e208c82e52cd34be55fb7ba94206e2bbe9687fbb44f791d621b61b8
-  data.tar.gz: ea94a54224c1b67996838581db58f7dad6a3d37dc5c688d81d5de07618a093fa
+  metadata.gz: f3cbd29143d65c6c6713ea03e0e26a29d7bb520139638cec49467fa932a1915d
+  data.tar.gz: 3c758792a4a406ff7981de63eae1512602b2b41184ce1c68ea00c1aa369dfcd3
 SHA512:
-  metadata.gz: 0c57f123057e3fc37bf4c5171d092d2185767b8bd3b1b3573608d93419b5cce755d0f8c556be22b7ff40102c44203a71859c559bbeb2ff1dad3366bba4fdaf68
-  data.tar.gz: 51407745069e3836aee5cdaa4212cc8864f4b0e892ba4bdf9df85669afdea75cc221bc9bb1f993a8a1e67cc7c30ad68cdc5b63d83626225ea6c7909c05c32a01
+  metadata.gz: 53637eb5f31edfd125b9a14c844e888f316e8914a5bfd817eea97e60ae9e5cd5d5b3619f7f1cee2af1421b6ccf4c2e903845bb95cd70a7eaf9d7537312ef0447
+  data.tar.gz: 51b246cc1a5e21171552f56bae8e1b9b4f179468369613de76d7c0e45cf37e8a67b048f63d61248f0deaeb0cc9316ace2d46ad506ff2f516dfd5206ad777b227

data/lib/chagall/base.rb

@@ -1,29 +1,33 @@
 require "logger"
+require_relative "ssh"
 
 module Chagall
-  class Base
+  class Base < Clamp::Command
     attr_reader :logger, :ssh
 
     LOG_LEVELS = {
       "info" => Logger::INFO,
       "debug" => Logger::DEBUG,
       "warn" => Logger::WARN,
-      "error" => Logger::ERROR
-    }.freeze
-
-    def initialize
-      @logger = Logger.new($stdout)
-      @logger.formatter = proc do |severity, _, _, msg|
-        if severity == "DEBUG"
-          "[#{severity}] #{msg}\n"
-        else
-          "#{msg}\n"
+      "error" => Logger::ERROR,
+    }
+ 
+    def logger
+      @logger ||= Logger.new($stdout).tap do |l|
+        l.formatter = proc do |severity, _, _, msg|
+          if severity == "DEBUG"
+            "[#{severity}] #{msg}\n"
+          else
+            "#{msg}\n"
+          end
         end
-      end
 
-      @logger.level = LOG_LEVELS[ENV.fetch("LOG_LEVEL", "info")]
+        l.level = LOG_LEVELS[ENV.fetch("LOG_LEVEL", "info")]
+      end
+    end
 
-      @ssh = SSH.new
+    def ssh
+      @ssh ||= SSH.new(logger: logger)
     end
   end
 end

data/lib/chagall/cli.rb

@@ -2,13 +2,21 @@
 
 require "clamp"
 require_relative "settings"
-require_relative "deploy/main"
-require_relative "compose/main"
+require_relative "deploy"
+require_relative "compose"
+require_relative "rollback"
 
 Clamp.allow_options_after_parameters = true
 
 module Chagall
   class Cli < Clamp::Command
+
+    def run(arguments)
+      parse(arguments)
+      Chagall::Settings.configure(collect_options_hash)
+      execute
+    end
+ 
     def self.options_from_config_file
       @options_from_config_file ||= begin
         config_path = File.join(Dir.pwd, "chagall.yml") || File.join(Dir.pwd, "chagall.yaml")
@@ -49,59 +57,10 @@ module Chagall
       exit(0)
     end
 
-    subcommand "deploy", "Deploy the application to the server" do
-      def execute
-        Chagall::Settings.configure(collect_options_hash)
-        Chagall::Deploy::Main.new
-      end
-    end
-
-    subcommand "setup", "Setup the server for deployment" do
-      def execute
-        Chagall::Settings.configure(collect_options_hash)
-        Chagall::Setup::Main.new
-      end
-    end
-
-    subcommand "compose", "Run Docker Compose commands with arguments passed through" do
-      # Override parse method to handle all arguments after the subcommand
-      def parse(arguments)
-        if arguments.empty?
-          puts "ERROR: Missing required arguments"
-          puts "Usage: chagall compose COMMAND [OPTIONS]"
-          exit(1)
-        end
-
-        # Extract the first argument as command
-        @command = arguments.shift
-
-        # Store the rest as raw args
-        @raw_args = arguments
-
-        # Validate required arguments
-        if @command.nil? || @command.empty?
-          puts "ERROR: Command is required"
-          puts "Usage: chagall compose COMMAND [OPTIONS]"
-          exit(1)
-        end
-      end
-
-      def execute
-        Chagall::Settings.configure(collect_options_hash)
-        Chagall::Compose::Main.new(@command, @raw_args)
-      end
-    end
-
-    subcommand "rollback", "Rollback to previous deployment" do
-      option [ "--steps" ], "STEPS", "Number of steps to rollback", default: "1" do |s|
-        Integer(s)
-      end
-
-      def execute
-        Chagall::Settings.configure(collect_options_hash)
-        puts "Rollback functionality not implemented yet"
-      end
-    end
+    subcommand "deploy", "Deploy the application to the server", Chagall::Deploy
+    subcommand "setup", "Setup the server for deployment", Chagall::Setup
+    subcommand "compose", "Run Docker Compose commands with arguments passed through", Chagall::Compose
+    subcommand "rollback", "Rollback to previous deployment", Chagall::Rollback
 
     private
 

data/lib/chagall/compose/main.rb

@@ -1,32 +1,39 @@
-require_relative "../settings"
 require_relative "../base"
 
 module Chagall
   module Compose
-    # Build and execute command usign docker compose on server
     class Main < Base
-      attr_reader :command, :arguments
+      attr_reader :command, :service, :args
 
-      def initialize(command, args)
-        super()
+      def initialize(command, *args)
         @command = command
-        @arguments = args.join(" ") if args.is_a?(Array)
-        @arguments ||= args.to_s
+        @service = args.first if args.first && !args.first.start_with?('-')
+        @args = @service ? args[1..-1] : args
 
         raise Chagall::Error, "Command is required" if @command.nil? || @command.empty?
 
         run_command
       end
 
-      def run_command
-        cmd = "cd #{Settings.instance.project_folder_path} && #{build_docker_compose_command} #{@command}"
-        cmd << " #{arguments}" unless arguments.empty?
+      private
 
+      def run_command
+        cmd = build_command
         logger.debug "Executing: #{cmd}"
-        ssh.execute(cmd, tty: true)
+        
+        result = ssh.execute(cmd, tty: true)
+        raise Chagall::Error, "Command failed: #{cmd}" unless result
       end
 
-      private
+      def build_command
+        cmd = [ "cd #{Settings.instance.project_folder_path}" ]
+        cmd << build_docker_compose_command
+        cmd << @command
+        cmd << @service if @service
+        cmd << @args.join(" ") if @args && @args.any?
+
+        cmd.join(" && ")
+      end
 
       def build_docker_compose_command
         compose_files = Settings[:compose_files]
@@ -42,4 +49,4 @@ module Chagall
       end
     end
   end
-end
+end 

data/lib/chagall/compose.rb

@@ -0,0 +1,54 @@
+require_relative "base"
+
+module Chagall
+  # Build and execute command usign docker compose on server
+  class Compose < Base
+    attr_reader :command, :arguments
+
+
+    # Override parse method to handle all arguments after the subcommand
+    def parse(arguments)
+      if arguments.empty?
+        puts "ERROR: Missing required arguments"
+        puts "Usage: chagall compose COMMAND [OPTIONS]"
+        exit(1)
+      end
+
+      # Extract the first argument as command
+      @command = arguments.shift
+
+      # Store the rest as raw args
+      @raw_args = arguments
+
+      # Validate required arguments
+      if @command.nil? || @command.empty?
+        puts "ERROR: Command is required"
+        puts "Usage: chagall compose COMMAND [OPTIONS]"
+        exit(1)
+      end
+    end
+
+    def execute
+      cmd = "cd #{Settings.instance.project_folder_path} && #{build_docker_compose_command} #{@command}"
+      cmd << " #{@raw_args.join(" ")}" unless @raw_args.empty?
+
+      logger.debug "Executing: #{cmd}"
+      ssh.execute(cmd, tty: true)
+    end
+
+    private
+
+    def build_docker_compose_command
+      compose_files = Settings[:compose_files]
+      compose_cmd = [ "docker compose" ]
+
+      if compose_files && !compose_files.empty?
+        compose_files.each do |file|
+          compose_cmd << "-f #{File.basename(file)}"
+        end
+      end
+
+      compose_cmd.join(" ")
+    end
+  end
+end

data/lib/chagall/deploy.rb

@@ -0,0 +1,258 @@
+# frozen_string_literal: true
+
+require_relative "base"
+require "digest"
+require "benchmark"
+require "yaml"
+
+module Chagall
+  class Deploy < Base
+
+    attr_reader :total_time
+
+    def execute
+      @interrupted = false
+      @total_time = 0.0
+      setup_signal_handlers
+      Time.now
+
+      t("Checking uncommitted changes") { check_uncommit_changes } unless Settings[:skip_uncommit]
+      t("Check image or build") { check_image_or_build }
+      t("tag as production") { tag_as_production }
+      t("update compose files") { update_compose_files }
+      t("deploy compose files") { deploy_compose_files }
+      t("rotate release") { rotate_releases }
+
+      print_total_time
+    rescue Interrupt
+      logger.info "\nDeployment interrupted by user"
+      print_total_time
+      cleanup_and_exit
+    rescue StandardError => e
+      logger.error "Deployment failed: #{e.message}"
+      logger.debug e.backtrace.join("\n") if ENV["DEBUG"]
+      print_total_time
+      exit 1
+    end
+
+    def check_image_or_build
+      image_exists = verify_image(check_only: true)
+
+      if image_exists
+        logger.info "Image #{@image_tag} exists and compose files are up to date"
+        return
+      end
+
+      t("Building image") { build }
+      t("Rotating cache") { rotate_cache }
+      t("Verifying image") { verify_image }
+    end
+
+    def setup_signal_handlers
+      # Handle CTRL+C (SIGINT)
+      Signal.trap("INT") do
+        @interrupted = true
+        puts "\nReceived interrupt signal. Cleaning up..."
+        cleanup_and_exit
+      end
+
+      # Handle SIGTERM
+      Signal.trap("TERM") do
+        @interrupted = true
+        puts "\nReceived termination signal. Cleaning up..."
+        cleanup_and_exit
+      end
+    end
+
+    def cleanup_and_exit
+      puts "Cleaning up..."
+      # Add any cleanup tasks here
+      exit 1
+    end
+
+    def check_interrupted
+      return unless @interrupted
+
+      puts "Operation interrupted by user"
+      cleanup_and_exit
+    end
+
+    private
+
+    def print_total_time
+      logger.info "Total execution time: #{format('%.2f', @total_time)}s"
+    end
+
+    def t(title)
+      logger.info "[#{title.upcase}]..."
+      start_time = Time.now
+      result = yield
+      duration = Time.now - start_time
+      @total_time += duration
+      logger.info " done #{'%.2f' % duration}s"
+      check_interrupted
+      result
+    rescue StandardError
+      duration = Time.now - start_time
+      @total_time += duration
+      logger.error " failed #{format('%.2f', duration)}s"
+      raise
+    end
+
+    def check_uncommit_changes
+      status = `git status --porcelain`.strip
+      raise "Uncommitted changes found. Commit first" unless status.empty?
+    end
+
+    def build
+      logger.debug "Building #{Settings.instance.image_tag} image and load to server"
+      system(build_cmd)
+    end
+
+    def rotate_cache
+      system("rm -rf #{Settings[:cache_from]}")
+      system("mv #{Settings[:cache_to]} #{Settings[:cache_from]}")
+    end
+
+    def verify_image(check_only: false)
+      logger.debug "Verifying image on server..."
+
+      check_cmd = "docker images --filter=reference=#{Settings.instance.image_tag} --format '{{.ID}}' | grep ."
+
+      # Use backticks to capture output instead of system
+      output = `#{ssh.command(check_cmd)} 2>/dev/null`.strip
+      exists = !output.empty?
+
+      if check_only
+        logger.debug "Image #{exists ? 'found' : 'not found'}: #{Settings.instance.image_tag}"
+        return exists
+      end
+
+      raise "Docker image #{Settings.instance.image_tag} not found on #{Settings[:server]}" unless exists
+
+      true
+    end
+
+    def verify_compose_files
+      puts "Verifying compose files on server..."
+
+      Settings[:compose_files].all? do |file|
+        remote_file = "#{Settings[:projects_folder]}/#{File.basename(file)}"
+        local_md5 = ::Digest::MD5.file(file).hexdigest
+
+        check_cmd = "md5sum #{remote_file} 2>/dev/null | cut -d' ' -f1"
+        remote_md5 = `#{ssh.command(check_cmd)}`.strip
+        local_md5 == remote_md5
+      end
+    end
+
+    def tag_as_production
+      logger.debug "Tagging Docker #{Settings.instance.image_tag} image as production..."
+
+      command = "docker tag #{Settings.instance.image_tag} #{Settings[:name]}:production"
+      ssh.execute(command) or raise "Failed to tag Docker image"
+    end
+
+    def build_cmd
+      args = [
+        "--cache-from type=local,src=#{Settings[:cache_from]}",
+        "--cache-to type=local,dest=#{Settings[:cache_to]},mode=max",
+        "--platform #{Settings[:platform]}",
+        "--tag #{Settings.instance.image_tag}",
+        "--target #{Settings[:target]}",
+        "--file #{Settings[:dockerfile]}"
+      ]
+
+      if Settings[:remote]
+        args.push("--load")
+      else
+        args.push("--output type=docker,dest=-")
+      end
+
+      args.push(Settings[:docker_context])
+
+      args = args.map { |arg| "    #{arg}" }
+                  .join(" \\\n")
+
+      cmd =  "docker build \\\n#{args}"
+      if Settings[:remote]
+        ssh.command(cmd)
+      else
+        "#{cmd} | #{ssh.command('docker load')}"
+      end
+    end
+
+    def update_compose_files
+      logger.debug "Updating compose configuration files on remote server..."
+
+      Settings[:compose_files].each do |file|
+        remote_destination = "#{Settings.instance.project_folder_path}/#{File.basename(file)}"
+        copy_file(file, remote_destination)
+      end
+    end
+
+    def deploy_compose_files
+      logger.debug "Updating compose services..."
+      deploy_command = [ "docker compose" ]
+
+      # Use the remote file paths for docker compose command
+      Settings[:compose_files].each do |file|
+        deploy_command << "-f #{File.basename(file)}"
+      end
+      deploy_command << "up -d"
+
+      ssh.execute(deploy_command.join(" "),
+                  directory: Settings.instance.project_folder_path) or raise "Failed to update compose services"
+    end
+
+    def copy_file(local_file, remote_destination)
+      logger.debug "Copying #{local_file} to #{Settings[:server]}:#{remote_destination}..."
+      command = "scp #{local_file} #{Settings[:server]}:#{remote_destination}"
+
+      system(command) or raise "Failed to copy #{local_file} to server"
+    end
+
+    def rotate_releases
+      logger.debug "Rotating releases..."
+      release_folder = "#{Settings.instance.project_folder_path}/releases"
+      release_file = "#{release_folder}/#{Settings[:release]}"
+
+      # Create releases directory if it doesn't exist
+      ssh.execute("mkdir -p #{release_folder}")
+
+      # Save current release
+      ssh.execute("touch #{release_file}")
+
+      # Get list of releases sorted by modification time (newest first)
+      list_cmd = "ls -t #{release_folder}"
+      releases = `#{ssh.command(list_cmd)}`.strip.split("\n")
+
+      # Keep only the last N releases
+      logger.info "releases #{releases.length}"
+      return unless releases.length > Settings[:keep_releases]
+
+      releases_to_remove = releases[Settings[:keep_releases]..]
+
+      # Remove old release files
+      releases_to_remove.each do |release|
+        ssh.execute("rm #{release_folder}/#{release}")
+
+        # Remove corresponding Docker image
+        image = "#{Settings[:name]}:#{release}"
+        logger.info "Removing old Docker image: #{image}"
+        ssh.execute("docker rmi #{image} || true") # Use || true to prevent failure if image is already removed
+      end
+    end
+
+    def system(*args)
+      result = super
+      raise "Command failed with exit code #{$CHILD_STATUS.exitstatus}: #{args.join(' ')}" unless result
+
+      result
+    end
+
+    def ssh
+      @ssh ||= SSH.new
+    end  
+  end
+end

data/lib/chagall/rollback.rb

@@ -0,0 +1,11 @@
+module Chagall
+  class Rollback < Base
+    option [ "--steps" ], "STEPS", "Number of steps to rollback", default: "1" do |s|
+      Integer(s)
+    end
+
+    def execute
+      puts "Rollback functionality not implemented yet"
+    end
+  end
+end

data/lib/chagall/setup.rb

@@ -0,0 +1,115 @@
+# frozen_string_literal: true
+
+require "yaml"
+require "io/console"
+require_relative "base"
+
+module Chagall
+  # Handles server provisioning and Docker environment setup for deployment
+  class Setup < Base
+    class DockerSetupError < StandardError; end
+
+    def execute
+      install_docker unless docker_installed?
+      setup_non_root_docker_deamon_access if unable_to_access_docker_deamon?
+      create_project_folder unless project_folder_exists?
+      create_env_files
+
+      logger.info "Docker environment setup complete"
+    end
+
+    private
+
+    def create_env_files
+      logger.debug "Create env files described at services..."
+
+      Settings[:compose_files].each do |file|
+        yaml = YAML.load_file(file, aliases: true)
+        yaml["services"].each do |service|
+          service[1]["env_file"]&.each do |env_file|
+            ssh.execute("touch #{env_file}", directory: Settings.instance.project_folder_path)
+          end
+        end
+      end
+    end
+
+    def unable_to_access_docker_deamon?
+      return true
+      docker_result = ssh.command("docker ps")
+      docker_output = `#{docker_result} 2>&1`.strip
+      logger.debug "Docker output: #{docker_output}"
+      docker_output.downcase.include?("permission denied") ||
+        docker_output.downcase.include?("connect: permission denied")
+    end
+
+    def setup_non_root_docker_deamon_access
+      logger.info "Add user to docker group..."
+
+      username = `#{ssh.command("whoami")} 2>&1`.strip
+      return true if username == "root"
+
+      groups = `#{ssh.command("groups")} 2>&1`.strip
+      return if groups.include?("docker")
+
+      logger.debug "Adding #{username} user to docker group"
+      ssh.execute("sudo usermod -aG docker #{username}", tty: true)
+      ssh.execute("groups #{username} | grep -q docker")
+
+      logger.debug "Successfully added user to docker group"
+      true
+    rescue StandardError => e
+      logger.error "Error setting up Docker daemon access: #{e.message}"
+      logger.debug e.backtrace.join("\n")
+      false
+    end
+
+    def docker_installed?
+      logger.debug "Checking Docker installation..."
+
+      docker_output = `#{ssh.command("docker --version")} 2>&1`.strip
+      logger.debug "Docker version output: '#{docker_output}'"
+
+      compose_output = `#{ssh.command("docker compose version")} 2>&1`.strip
+      logger.debug "Docker Compose output: '#{compose_output}'"
+
+      return true if docker_output.include?("Docker version") &&
+                      compose_output.include?("Docker Compose version")
+
+      logger.warn "Docker check failed:"
+      logger.warn "Docker output: #{docker_output}"
+      logger.warn "Docker Compose output: #{compose_output}"
+      false
+    rescue StandardError => e
+      logger.error "Error checking Docker installation: #{e.message}"
+      logger.debug e.backtrace.join("\n")
+      false
+    end
+
+    def project_folder_exists?
+      ssh.execute("test -d #{Settings.instance.project_folder_path}")
+    rescue StandardError => e
+      logger.error "Error checking project folder: #{e.message}"
+      false
+    end
+
+    def create_project_folder
+      logger.debug "Creating project folder #{Settings.instance.project_folder_path}"
+      ssh.execute("mkdir -p #{Settings.instance.project_folder_path}")
+    end
+
+    def install_docker
+      logger.debug "Installing Docker..."
+
+      command = '(curl -fsSL https://get.docker.com || wget -O - https://get.docker.com || echo "exit 1") | sh'
+      # Clear any existing sudo session
+      ssh.execute("sudo -k")
+
+      logger.debug "Executing: #{command}"
+      result = ssh.execute(command, tty: true)
+      raise DockerSetupError, "Failed to execute: #{command}" unless result
+    rescue StandardError => e
+      logger.error "Docker installation failed: #{e.message}"
+      raise DockerSetupError, "Failed to install Docker: #{e.message}"
+    end
+  end
+end

data/lib/chagall/ssh.rb

@@ -1,14 +1,15 @@
-
 require "English"
+
 module Chagall
   class SSH
-    attr_reader :server, :ssh_args
+    attr_reader :server, :ssh_args, :logger
 
     DEFAULT_SSH_ARGS = "-o StrictHostKeyChecking=no -o ServerAliveInterval=60".freeze
 
-    def initialize(server: Settings.instance.options[:server], ssh_args: DEFAULT_SSH_ARGS)
+    def initialize(server: Settings.instance.options[:server], ssh_args: DEFAULT_SSH_ARGS, logger: Logger.new($stdout))
       @server = server
       @ssh_args = ssh_args
+      @logger = logger
     end
 
     def execute(command, directory: nil, tty: false)
@@ -38,18 +39,5 @@ module Chagall
 
       "#{ssh_cmd.join(' ')} '#{cmd}'"
     end
-
-    def logger
-      @logger ||= Logger.new($stdout).tap do |l|
-        l.formatter = proc do |severity, _, _, msg|
-          if severity == "DEBUG"
-            "[#{severity}] #{msg}\n"
-          else
-            "#{msg}\n"
-          end
-        end
-        l.level = ENV.fetch("LOG_LEVEL") { "debug" }.downcase == "debug" ? Logger::DEBUG : Logger::INFO
-      end
-    end
   end
 end

data/lib/chagall/version.rb

@@ -1,3 +1,3 @@
 module Chagall
-  VERSION = "0.0.1.beta5"
+  VERSION = "0.0.1.beta6"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: chagall
 version: !ruby/object:Gem::Version
-  version: 0.0.1.beta5
+  version: 0.0.1.beta6
 platform: ruby
 authors:
 - Roman Klevtsov
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2025-04-09 00:00:00.000000000 Z
+date: 2025-04-10 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: clamp
@@ -93,13 +93,15 @@ files:
 - lib/chagall.rb
 - lib/chagall/base.rb
 - lib/chagall/cli.rb
+- lib/chagall/compose.rb
 - lib/chagall/compose/main.rb
-- lib/chagall/deploy/main.rb
+- lib/chagall/deploy.rb
 - lib/chagall/install/main.rb
 - lib/chagall/install/templates/template.Dockerfile
 - lib/chagall/install/templates/template.compose.yaml
+- lib/chagall/rollback.rb
 - lib/chagall/settings.rb
-- lib/chagall/setup/main.rb
+- lib/chagall/setup.rb
 - lib/chagall/ssh.rb
 - lib/chagall/version.rb
 homepage: https://github.com/frontandstart/chagall

data/lib/chagall/deploy/main.rb

@@ -1,261 +0,0 @@
-# frozen_string_literal: true
-
-require_relative "../settings"
-require_relative "../ssh"
-require "digest"
-require "benchmark"
-require "yaml"
-
-module Chagall
-  module Deploy
-    class Main < Base
-      attr_reader :total_time
-
-      def initialize
-        super()
-        @interrupted = false
-        @total_time = 0.0
-        setup_signal_handlers
-        Time.now
-
-        t("Checking uncommitted changes") { check_uncommit_changes } unless Settings[:skip_uncommit]
-        t("Check image or build") { check_image_or_build }
-        t("tag as production") { tag_as_production }
-        t("update compose files") { update_compose_files }
-        t("deploy compose files") { deploy_compose_files }
-        t("rotate release") { rotate_releases }
-
-        print_total_time
-      rescue Interrupt
-        logger.info "\nDeployment interrupted by user"
-        print_total_time
-        cleanup_and_exit
-      rescue StandardError => e
-        logger.error "Deployment failed: #{e.message}"
-        logger.debug e.backtrace.join("\n") if ENV["DEBUG"]
-        print_total_time
-        exit 1
-      end
-
-      def check_image_or_build
-        image_exists = verify_image(check_only: true)
-
-        if image_exists
-          logger.info "Image #{Settings.instance.image_tag} exists and compose files are up to date"
-          return
-        end
-
-        t("Building image") { build }
-        t("Rotating cache") { rotate_cache }
-        t("Verifying image") { verify_image }
-      end
-
-      def setup_signal_handlers
-        # Handle CTRL+C (SIGINT)
-        Signal.trap("INT") do
-          @interrupted = true
-          puts "\nReceived interrupt signal. Cleaning up..."
-          cleanup_and_exit
-        end
-
-        # Handle SIGTERM
-        Signal.trap("TERM") do
-          @interrupted = true
-          puts "\nReceived termination signal. Cleaning up..."
-          cleanup_and_exit
-        end
-      end
-
-      def cleanup_and_exit
-        puts "Cleaning up..."
-        # Add any cleanup tasks here
-        exit 1
-      end
-
-      def check_interrupted
-        return unless @interrupted
-
-        puts "Operation interrupted by user"
-        cleanup_and_exit
-      end
-
-      private
-
-      def print_total_time
-        logger.info "Total execution time: #{format('%.2f', @total_time)}s"
-      end
-
-      def t(title)
-        logger.info "[#{title.upcase}]..."
-        start_time = Time.now
-        result = yield
-        duration = Time.now - start_time
-        @total_time += duration
-        logger.info " done #{'%.2f' % duration}s"
-        check_interrupted
-        result
-      rescue StandardError
-        duration = Time.now - start_time
-        @total_time += duration
-        logger.error " failed #{format('%.2f', duration)}s"
-        raise
-      end
-
-      def check_uncommit_changes
-        status = `git status --porcelain`.strip
-        raise "Uncommitted changes found. Commit first" unless status.empty?
-      end
-
-      def setup_server
-        SetupServer.new(ssh, logger).setup
-      end
-
-      def build
-        logger.debug "Building #{Settings.instance.image_tag} image and load to server"
-        system(build_cmd)
-      end
-
-      def rotate_cache
-        system("rm -rf #{Settings[:cache_from]}")
-        system("mv #{Settings[:cache_to]} #{Settings[:cache_from]}")
-      end
-
-      def verify_image(check_only: false)
-        logger.debug "Verifying image on server..."
-
-        check_cmd = "docker images --filter=reference=#{Settings.instance.image_tag} --format '{{.ID}}' | grep ."
-
-        # Use backticks to capture output instead of system
-        output = `#{ssh.command(check_cmd)} 2>/dev/null`.strip
-        exists = !output.empty?
-
-        if check_only
-          logger.debug "Image #{exists ? 'found' : 'not found'}: #{Settings.instance.image_tag}"
-          return exists
-        end
-
-        raise "Docker image #{Settings.instance.image_tag} not found on #{Settings[:server]}" unless exists
-
-        true
-      end
-
-      def verify_compose_files
-        puts "Verifying compose files on server..."
-
-        Settings[:compose_files].all? do |file|
-          remote_file = "#{Settings[:projects_folder]}/#{File.basename(file)}"
-          local_md5 = ::Digest::MD5.file(file).hexdigest
-
-          check_cmd = "md5sum #{remote_file} 2>/dev/null | cut -d' ' -f1"
-          remote_md5 = `#{ssh.command(check_cmd)}`.strip
-          local_md5 == remote_md5
-        end
-      end
-
-      def tag_as_production
-        logger.debug "Tagging Docker #{Settings.instance.image_tag} image as production..."
-
-        command = "docker tag #{Settings.instance.image_tag} #{Settings[:name]}:production"
-        ssh.execute(command) or raise "Failed to tag Docker image"
-      end
-
-      def build_cmd
-        args = [
-          "--cache-from type=local,src=#{Settings[:cache_from]}",
-          "--cache-to type=local,dest=#{Settings[:cache_to]},mode=max",
-          "--platform #{Settings[:platform]}",
-          "--tag #{Settings.instance.image_tag}",
-          "--target #{Settings[:target]}",
-          "--file #{Settings[:dockerfile]}"
-        ]
-
-        if Settings[:remote]
-          args.push("--load")
-        else
-          args.push("--output type=docker,dest=-")
-        end
-
-        args.push(Settings[:docker_context])
-
-        args = args.map { |arg| "    #{arg}" }
-                   .join(" \\\n")
-
-        cmd =  "docker build \\\n#{args}"
-        if Settings[:remote]
-          ssh.command(cmd)
-        else
-          "#{cmd} | #{ssh.command('docker load')}"
-        end
-      end
-
-      def update_compose_files
-        logger.debug "Updating compose configuration files on remote server..."
-
-        Settings[:compose_files].each do |file|
-          remote_destination = "#{Settings.instance.project_folder_path}/#{File.basename(file)}"
-          copy_file(file, remote_destination)
-        end
-      end
-
-      def deploy_compose_files
-        logger.debug "Updating compose services..."
-        deploy_command = [ "docker compose" ]
-
-        # Use the remote file paths for docker compose command
-        Settings[:compose_files].each do |file|
-          deploy_command << "-f #{File.basename(file)}"
-        end
-        deploy_command << "up -d"
-
-        ssh.execute(deploy_command.join(" "),
-                    directory: Settings.instance.project_folder_path) or raise "Failed to update compose services"
-      end
-
-      def copy_file(local_file, remote_destination)
-        logger.debug "Copying #{local_file} to #{Settings[:server]}:#{remote_destination}..."
-        command = "scp #{local_file} #{Settings[:server]}:#{remote_destination}"
-
-        system(command) or raise "Failed to copy #{local_file} to server"
-      end
-
-      def rotate_releases
-        logger.debug "Rotating releases..."
-        release_folder = "#{Settings.instance.project_folder_path}/releases"
-        release_file = "#{release_folder}/#{Settings[:release]}"
-
-        # Create releases directory if it doesn't exist
-        ssh.execute("mkdir -p #{release_folder}")
-
-        # Save current release
-        ssh.execute("touch #{release_file}")
-
-        # Get list of releases sorted by modification time (newest first)
-        list_cmd = "ls -t #{release_folder}"
-        releases = `#{ssh.command(list_cmd)}`.strip.split("\n")
-
-        # Keep only the last N releases
-        logger.info "releases #{releases.length}"
-        return unless releases.length > Settings[:keep_releases]
-
-        releases_to_remove = releases[Settings[:keep_releases]..]
-
-        # Remove old release files
-        releases_to_remove.each do |release|
-          ssh.execute("rm #{release_folder}/#{release}")
-
-          # Remove corresponding Docker image
-          image = "#{Settings[:name]}:#{release}"
-          logger.info "Removing old Docker image: #{image}"
-          ssh.execute("docker rmi #{image} || true") # Use || true to prevent failure if image is already removed
-        end
-      end
-
-      def system(*args)
-        result = super
-        raise "Command failed with exit code #{$CHILD_STATUS.exitstatus}: #{args.join(' ')}" unless result
-
-        result
-      end
-    end
-  end
-end

data/lib/chagall/setup/main.rb

@@ -1,121 +0,0 @@
-# frozen_string_literal: true
-
-require "yaml"
-require "io/console"
-
-module Chagall
-  module Setup
-    # Handles server provisioning and Docker environment setup for deployment
-    class Main < Base
-      class DockerSetupError < StandardError; end
-
-      def initialize
-        super()
-        setup
-      end
-
-      def setup
-        install_docker unless docker_installed?
-        setup_non_root_docker_deamon_access if unable_to_access_docker_deamon?
-        create_project_folder unless project_folder_exists?
-        create_env_files
-
-        logger.info "Docker environment setup complete"
-      end
-
-      private
-
-      def create_env_files
-        logger.debug "Create env files described at services..."
-
-        Settings[:compose_files].each do |file|
-          yaml = YAML.load_file(file, aliases: true)
-          yaml["services"].each do |service|
-            service[1]["env_file"]&.each do |env_file|
-              ssh.execute("touch #{env_file}", directory: Settings.instance.project_folder_path)
-            end
-          end
-        end
-      end
-
-      def unable_to_access_docker_deamon?
-        return true
-        docker_result = ssh.command("docker ps")
-        docker_output = `#{docker_result} 2>&1`.strip
-        logger.debug "Docker output: #{docker_output}"
-        docker_output.downcase.include?("permission denied") ||
-          docker_output.downcase.include?("connect: permission denied")
-      end
-
-      def setup_non_root_docker_deamon_access
-        logger.info "Add user to docker group..."
-
-        username = `#{ssh.command("whoami")} 2>&1`.strip
-        return true if username == "root"
-
-        groups = `#{ssh.command("groups")} 2>&1`.strip
-        return if groups.include?("docker")
-
-        logger.debug "Adding #{username} user to docker group"
-        ssh.execute("sudo usermod -aG docker #{username}", tty: true)
-        ssh.execute("groups #{username} | grep -q docker")
-
-        logger.debug "Successfully added user to docker group"
-        true
-      rescue StandardError => e
-        logger.error "Error setting up Docker daemon access: #{e.message}"
-        logger.debug e.backtrace.join("\n")
-        false
-      end
-
-      def docker_installed?
-        logger.debug "Checking Docker installation..."
-
-        docker_output = `#{ssh.command("docker --version")} 2>&1`.strip
-        logger.debug "Docker version output: '#{docker_output}'"
-
-        compose_output = `#{ssh.command("docker compose version")} 2>&1`.strip
-        logger.debug "Docker Compose output: '#{compose_output}'"
-
-        return true if docker_output.include?("Docker version") &&
-                       compose_output.include?("Docker Compose version")
-
-        logger.warn "Docker check failed:"
-        logger.warn "Docker output: #{docker_output}"
-        logger.warn "Docker Compose output: #{compose_output}"
-        false
-      rescue StandardError => e
-        logger.error "Error checking Docker installation: #{e.message}"
-        logger.debug e.backtrace.join("\n")
-        false
-      end
-
-      def project_folder_exists?
-        ssh.execute("test -d #{Settings.instance.project_folder_path}")
-      rescue StandardError => e
-        logger.error "Error checking project folder: #{e.message}"
-        false
-      end
-
-      def create_project_folder
-        logger.debug "Creating project folder #{Settings.instance.project_folder_path}"
-        ssh.execute("mkdir -p #{Settings.instance.project_folder_path}")
-      end
-
-      def install_docker
-        logger.debug "Installing Docker..."
-
-        command = '(curl -fsSL https://get.docker.com || wget -O - https://get.docker.com || echo "exit 1") | sh'
-        # Clear any existing sudo session
-        ssh.execute("sudo -k")
-
-        logger.debug "Executing: #{command}"
-        result = ssh.execute(command, tty: true)
-        raise DockerSetupError, "Failed to execute: #{command}" unless result
-      rescue StandardError => e
-        logger.error "Docker installation failed: #{e.message}"
-        raise DockerSetupError, "Failed to install Docker: #{e.message}"
-      end
-    end
-  end
-end