chagall 0.0.1.beta1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 547bc828747060b2453d9d7fd12211ee7d0f0ffae43af892738f14b9e755f142
+  data.tar.gz: a144cb486c2a31e5a42c8000cf8194eac6d61754b8be185ad2993c3d26a954a6
+SHA512:
+  metadata.gz: 204ca192df6ffe1e3af30dba6d11af3bee58378183926c0926583ccc0bf3a8fc0f09b6c295507c4b96df9d9a9432d1104b26268b2b92953917e971e0cdf1243b
+  data.tar.gz: 4fb4a59f77a8178917df4fefd5d5392e69a9e272f2e8c955e70e554899b9154a914e3e1c7d64576a8c384d8f4f38dd53b3b6cbb28a931d04cd23886d08211766

data/MIT-LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2025 Roman Klevtsov @r3cha
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/Readme.md

@@ -0,0 +1,54 @@
+# Chagall Deploy
+
+## Project under active development
+
+**Chagall Deploy** is a deployment tool for applications for staging and production single-server setups. 
+
+- [ ] Generates Docker and docker compose configurations based on your application’s dependencies
+  - Only for rails apps
+- Don't require Container Registry like Docker Hub or ECR
+- Detect dependecies and include services like
+  - Redis
+  - Sidekiq
+  - Mariadb, MySQL
+  - PostgreSQL
+  - MongoDB
+  - Elasticsearch
+- Generate development and production environments with a single `compose.yaml`
+- For production TLS/SSL using [reproxy](https://github.com/umputun/reproxy)
+
+## Features
+
+- **Dynamic Service Configuration**: Detects and includes services based on your application’s `Gemfile`, `package.json`,`.ruby-version` or `.node-version`.
+- **Multi-Stage Docker Builds**: Uses a single Dockerfile for both development and production environments.
+- **Unified `compose.yaml`**: Configures development and production profiles in one Compose file.
+- **Quick Installation**: Installs with a single `curl` command, generating the necessary `Dockerfile`, `compose.yaml` and `bin/chagall` file.
+
+## Installation
+
+To install Chagall Deploy, run this command in your project root:
+
+```bash
+curl -sSL https://github.com/frontandstart/chagall-deploy/install.sh | bash
+```
+
+## Usage
+
+Generate compose and compose.prod.yaml
+```bash
+bin/chagall install
+```
+
+Setup server for deploy:
+  - install docker
+  - install reproxy(optional can be part of compose.prod.yaml) for signe compose per server deployments
+```bash
+bin/chagall setup
+```
+
+Deploy application
+  - Build image
+  - Trigger compose project update
+```bash
+bin/chagall deploy
+```

data/bin/chagall

@@ -0,0 +1,12 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+require 'chagall'
+
+begin
+  Chagall::Cli.run
+rescue StandardError => e
+  puts "  \e[31mERROR (#{e.class}): #{e.message}\e[0m"
+  puts e.backtrace if ENV['VERBOSE'] || ENV['DEBUG']
+  exit 1
+end

data/lib/chagall/base.rb

@@ -0,0 +1,29 @@
+require "logger"
+
+module Chagall
+  class Base
+    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"
+        end
+      end
+
+      @logger.level = LOG_LEVELS[ENV.fetch("LOG_LEVEL", "info")]
+
+      @ssh = SSH.new
+    end
+  end
+end

data/lib/chagall/cli.rb

@@ -0,0 +1,130 @@
+# frozen_string_literal: true
+
+require "clamp"
+require_relative "settings"
+require_relative "deploy/main"
+require_relative "compose/main"
+
+Clamp.allow_options_after_parameters = true
+
+module Chagall
+  class Cli < Clamp::Command
+    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")
+        return {} unless File.exist?(config_path)
+
+        config = YAML.load_file(config_path)
+        config.transform_keys(&:to_sym)
+      rescue StandardError => e
+        puts "Warning: Error loading chagall.yml: #{e.message}"
+        {}
+      end
+    end
+
+    Settings::OPTIONS.each do |opt|
+      if opt[:type] == :boolean
+        option opt[:flags], :flag, opt[:description],
+               default: options_from_config_file[opt[:key]] || opt[:default],
+               environment_variable: opt[:environment_variable]
+      elsif opt[:proc].is_a?(Proc)
+        option opt[:flags],
+               opt[:environment_variable].gsub("CHAGALL_"),
+               opt[:description],
+               default: options_from_config_file[opt[:key]] || opt[:default],
+               environment_variable: opt[:environment_variable] do |value|
+          opt[:proc].call(value)
+        end
+      else
+        option opt[:flags],
+               opt[:environment_variable].gsub("CHAGALL_"),
+               opt[:description],
+               default: options_from_config_file[opt[:key]] || opt[:default],
+               environment_variable: opt[:environment_variable]
+      end
+    end
+
+    option "--version", :flag, "Show version" do
+      puts Chagall::VERSION
+      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
+
+    private
+
+    def collect_options_hash
+      result = {}
+
+      self.class.recognised_options.each do |option|
+        name = option.attribute_name.to_sym
+
+        next if !respond_to?(name) && !respond_to?("#{name}?")
+
+        binding.irb if option.attribute_name == "context"
+
+        value = if option.type == :flag
+                  send("#{name}?")
+        else
+                  send(name)
+        end
+
+        result[name] = value unless value.nil?
+      end
+
+      result
+    end
+  end
+end

data/lib/chagall/compose/main.rb

@@ -0,0 +1,45 @@
+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
+
+      def initialize(command, args)
+        super()
+        @command = command
+        @arguments = args.join(" ") if args.is_a?(Array)
+        @arguments ||= args.to_s
+
+        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?
+
+        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
+end

data/lib/chagall/deploy/main.rb

@@ -0,0 +1,261 @@
+# 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