chagall 0.0.1.beta1

data/lib/chagall/install/main.rb

@@ -0,0 +1,321 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+require "erb"
+require "yaml"
+require "fileutils"
+require "optparse"
+require "logger"
+require "tmpdir"
+require "securerandom"
+require "net/http"
+require "json"
+require "uri"
+
+# The Installer class is responsible for setting up the environment for a Ruby on Rails application.
+# It detects the required services and versions, generates necessary Docker and Compose files, and logs the process.
+#
+# Constants:
+# - TEMPLATES_DIR: Directory where template files are stored.
+# - DEFAULT_NODE_VERSION: Default Node.js version to use if not specified.
+# - DEFAULT_RUBY_VERSION: Default Ruby version to use if not specified.
+#
+# Attributes:
+# - app_name: Name of the application.
+# - services: List of services to be included in the setup.
+# - versions: Hash containing versions of Ruby, Node.js, PostgreSQL, and Redis.
+# - logger: Logger instance for logging messages.
+# - database_type: Type of database to use (e.g., 'postgres', 'mysql', 'sqlite').
+#
+# Methods:
+# - initialize(options = {}): Initializes the installer with given options.
+# - install: Main method to perform the installation process.
+#
+# Private Methods:
+# - backup_file(file): Creates a backup of the specified file if it exists.
+# - detect_ruby_version: Detects the Ruby version from various files or defaults to a predefined version.
+# - detect_node_version: Detects the Node.js version from various files or defaults to a predefined version.
+# - node_version_from_package_json: Extracts the Node.js version from package.json if available.
+# - node_version_from_file: Extracts the Node.js version from .node-version, .tool-versions, or .nvmrc files if available.
+# - detect_services: Detects required services based on the gems listed in the Gemfile.
+# - generate_compose: Generates the Docker Compose file from a template.
+# - generate_dockerfile: Generates the Dockerfile from a template.
+class Installer # rubocop:disable Metrics/ClassLength
+  TEMPLATES_DIR = File.expand_path("./templates", __dir__)
+  TEMP_DIR = File.join(Dir.tmpdir, "chagall-#{SecureRandom.hex(4)}").freeze
+  DEFAULT_RUBY_VERSION = "3.3.0"
+  DEFAULT_NODE_VERSION = "20.11.0"
+
+  GITHUB_REPO = "frontandstart/chagall"
+  TEMPLATE_FILES = %w[template.compose.yaml
+                      template.Dockerfile].freeze
+
+  DEPENDENCIES = [
+    {
+      adapter: :postgresql,
+      gem_name: "pg",
+      service: :postgres,
+      image: "postgres:16.4-bullseye",
+      docker_env: "DATABASE_URL: postgres://postgres:postgres@postgres:5432"
+    },
+    {
+      adapter: :mysql2,
+      gem_name: "mysql2",
+      service: :mariadb,
+      image: "mariadb:8.0-bullseye",
+      docker_env: "DATABASE_URL: mysql://mysql:mysql@mariadb:3306"
+    },
+    {
+      adapter: :mongoid,
+      gem_name: "mongoid",
+      service: :mongodb,
+      image: "mongo:8.0-noble",
+      docker_env: "DATABASE_URL: mongodb://mongodb:27017"
+    },
+    {
+      gem_name: "redis",
+      service: :redis,
+      image: "redis:7.4-bookworm",
+      docker_env: "REDIS_URL: redis://redis:6379"
+    },
+    {
+      gem_name: "sidekiq",
+      service: :sidekiq,
+      image: -> { app_name }
+    },
+    {
+      gem_name: "elasticsearch",
+      service: :elasticsearch,
+      image: "elasticsearch:8.15.3",
+      docker_env: "ELASTICSEARCH_URL: elasticsearch://elasticsearch:9200"
+    },
+    {
+      gem_name: "solid_queue",
+      service: :solid_queue,
+      image: -> { app_name }
+    }
+  ].freeze
+
+  attr_reader :app_name,
+              :versions,
+              :logger,
+              :database_type,
+              :database_config,
+              :gemfile,
+              :gemfile_lock
+
+  attr_accessor :project_services,
+                :environments
+
+  def initialize(options = {})
+    raise "Gemfile not found" unless File.exist?("Gemfile")
+
+    Chagall::Settings.configure(argv)
+
+    @app_name = options[:app_name] || File.basename(Dir.pwd)
+    @services = []
+    @logger = Logger.new($stdout)
+    @logger.formatter = proc { |_, _, _, msg| "#{msg}\n" }
+    @environments = {}
+    @gemfile = File.read("Gemfile")
+    @gemfile_lock = File.read("Gemfile.lock")
+    @database_adapters = YAML.load_file("config/database.yml")
+                             .map { |_, config| config["adapter"] }.uniq
+    @database_type = @database_adapters
+  end
+
+  def install
+    setup_temp_directory
+    detect_services
+    generate_environment_variables
+    generate_compose_file
+    generate_dockerfile
+    logger.info "Installation completed successfully!"
+  ensure
+    cleanup_temp_directory
+  end
+
+  private
+
+  def setup_temp_directory
+    FileUtils.mkdir_p(TEMP_DIR)
+    download_template_files
+  rescue StandardError => e
+    logger.error "Failed to set up temporary directory: #{e.message}"
+    cleanup_temp_directory
+    raise
+  end
+
+  def detect_services
+    DEPENDENCIES.each do |dependency|
+      @services << dependency if gemfile_has_dependency?(dependency[:gem_name])
+    end
+
+    logger.info "Detected services: #{services.map { |s| s[:service] }.join(', ')}"
+  end
+
+  def gemfile_has_dependency?(gem_name)
+    gemfile_match = gemfile.match?(/^\s*[^#].*gem ['"]#{gem_name}['"]/)
+    gemfile_lock_match = gemfile_lock.match?(/^\s+#{gem_name}\s+\(/) || false
+
+    gemfile_match && gemfile_lock_match
+  end
+
+  def generate_environment_variables
+    services.each do |service|
+      url = generate_service_url_for(service[:adapter])
+      environments[service[:url_name]] = url if url
+    end
+  end
+
+  def cleanup_temp_directory
+    FileUtils.remove_entry_secure(TEMP_DIR) if Dir.exist?(TEMP_DIR)
+  end
+
+  def download_template_files
+    release_info = fetch_latest_release
+    TEMPLATE_FILES.each do |filename|
+      download_template(filename, release_info)
+    end
+  rescue StandardError => e
+    logger.error "Failed to download template files: #{e.message}"
+    raise
+  end
+
+  def fetch_latest_release
+    uri = URI("https://api.github.com/repos/#{GITHUB_REPO}/releases/latest")
+    response = Net::HTTP.get_response(uri)
+
+    raise "Failed to fetch latest release info: #{response.message}" unless response.is_a?(Net::HTTPSuccess)
+
+    JSON.parse(response.body)
+  end
+
+  def download_template(filename, release_info)
+    asset = release_info["assets"].find { |a| a["name"] == filename }
+    raise "Template file #{filename} not found in release" unless asset
+
+    download_url = asset["browser_download_url"]
+    target_path = File.join(TEMP_DIR, filename)
+
+    uri = URI(download_url)
+    response = Net::HTTP.get_response(uri)
+
+    raise "Failed to download #{filename}: #{response.message}" unless response.is_a?(Net::HTTPSuccess)
+
+    File.write(target_path, response.body)
+    logger.info "Downloaded #{filename}"
+  end
+
+  def backup_file(file)
+    return unless File.exist?(file)
+
+    backup = "#{file}.chagall.bak"
+    FileUtils.cp(file, backup)
+    logger.info "Backed up existing #{file} to #{backup}"
+  end
+
+  def generate_database_url(adapter)
+    case adapter
+    when "postgresql"
+      "postgres://postgres:postgres@postgres:5432/db"
+    when "mysql2"
+      "mysql2://mysql:mysql@mysql:3306/db"
+    when "sqlite3"
+      "sqlite3:///data/db.sqlite3"
+    when "redis"
+      "redis://redis:5432/0"
+    else
+      raise "Unsupported adapter: #{adapter}"
+    end
+  end
+
+  def generate_compose_file
+    backup_file("compose.yaml")
+
+    template_path = File.join(TEMP_DIR, "template.compose.yaml")
+    raise "Compose template not found at #{template_path}" unless File.exist?(template_path)
+
+    template = File.read(template_path)
+    result = ERB.new(
+      template,
+      trim_mode: "-",
+      services: services,
+      environments: environments
+    ).result(binding)
+
+    File.write("compose.yaml", result)
+    logger.info "Generated compose.yaml"
+  end
+
+  def generate_dockerfile
+    backup_file("Dockerfile")
+
+    template_path = File.join(TEMP_DIR, "template.Dockerfile")
+    raise "Dockerfile template not found at #{template_path}" unless File.exist?(template_path)
+
+    template = File.read(template_path)
+    result = ERB.new(template, trim_mode: "-").result(binding)
+
+    File.write("Dockerfile", result)
+    logger.info "Generated Dockerfile"
+  end
+
+  def detect_ruby_version
+    from_gemfile = gemfile.match(/ruby ['"](.+?)['"]/)[1]
+    return from_gemfile if from_gemfile
+
+    if File.exist?(".ruby-version")
+      File.read(".ruby-version").strip
+    elsif File.exist?(".tool-versions")
+      File.read(".tool-versions").match(/ruby (.+?)\n/)[1]
+    else
+      DEFAULT_RUBY_VERSION
+    end
+  end
+
+  def detect_node_version
+    node_version_from_package_json || node_version_from_file || DEFAULT_NODE_VERSION
+  end
+
+  def node_version_from_package_json
+    return unless File.exist?("package.json")
+
+    begin
+      JSON.parse(File.read("package.json")).dig("engines", "node")&.delete("^")
+    rescue JSON::ParserError
+      nil
+    end
+  end
+
+  def node_version_from_file
+    if File.exist?(".node-version")
+      File.read(".node-version").strip
+    elsif File.exist?(".tool-versions")
+      File.read(".tool-versions").match(/node (.+?)\n/)[1]
+    elsif File.exist?(".nvmrc")
+      File.read(".nvmrc").strip
+    end
+  end
+
+  def find_dependecy_by(name, value)
+    DEPENDENCIES.find { |d| d[name.to_sym] == value.to_sym }
+  end
+end
+
+if __FILE__ == $PROGRAM_NAME
+  options = {}
+  OptionParser.new do |opts|
+    opts.banner = "Usage: install.rb [options]"
+
+    opts.on("-n", "--non-interactive", "Run in non-interactive mode") do
+      options[:non_interactive] = true
+    end
+
+    opts.on("-a", "--app-name NAME", "Set application name") do |name|
+      options[:app_name] = name
+    end
+  end.parse!
+
+  Installer.new(options).install
+end

data/lib/chagall/install/templates/template.Dockerfile

@@ -0,0 +1,37 @@
+ARG RUBY_VERSION=<%= @versions['ruby'] %>
+ARG NODE_VERSION=<%= @versions['node'] %>
+
+FROM ruby:${RUBY_VERSION}-slim AS development
+
+LABEL app.name="<%= @app_name %>"
+
+ARG NODE_VERSION
+ENV NODE_VERSION=${NODE_VERSION}
+WORKDIR /app
+
+RUN apt-get update -qq && apt-get install -y \
+    build-essential \
+    libvips \
+    libffi-dev \
+    libssl-dev \
+    gnupg2 \
+    curl \
+    git
+
+# Node section
+RUN curl -o- https://raw.githubusercontent.com/nvm-sh/nvm/v0.39.1/install.sh | bash && \
+    export NVM_DIR="/root/.nvm" && \
+    . "$NVM_DIR/nvm.sh" && \
+    nvm install "$NODE_VERSION" && \
+    nvm use "$NODE_VERSION" && \
+    nvm alias default "$NODE_VERSION"
+
+RUN gem install bundler
+
+FROM development AS production
+
+COPY . .
+
+RUN bundle config set production true
+RUN BUNDLE_JOBS=$(nproc) bundle install
+RUN bundle exec rails assets:precompile

data/lib/chagall/install/templates/template.compose.yaml

@@ -0,0 +1,121 @@
+x-docker-environment: &docker-environment
+  <% if services.each do |service| %>
+  <%= service[:docker_env] if service[:docker_env] %>
+  <% end %>
+  HISTFILE: tmp/.docker_shell_history
+  PRY_HISTFILE: tmp/.docker_pry_history
+  RAILS_LOG_TO_STDOUT: true
+
+x-app: &app
+  image: <%= @app_name %>:development
+  environment:
+    <<: *docker-environment
+  build:
+    context: .
+    target: development
+  working_dir: /app
+  env_file:
+    - .env
+  stdin_open: true
+  ports:
+    - ${PORT:-3000}:${PORT:-3000}
+  depends_on:
+    postgres:
+      condition: service_healthy
+    redis:
+      condition: service_healthy
+  tmpfs:
+    - /app/tmp/pids
+  volumes:
+    - .:/app:c
+    - cache:/app/tmp/cache:d
+    - bundle:/usr/local/bundle:d
+    - node_modules:/app/node_modules:d
+
+services:
+  app: &app
+    command: bin/dev
+
+  <%- if @services.include?('postgres') -%>
+  postgres:
+    image: postgres:<%= @versions['postgres'] %>
+    environment:
+      POSTGRES_USER: postgres
+      POSTGRES_PASSWORD: postgres
+      POSTGRES_HOST: 0.0.0.0
+    volumes:
+      - postgres:/var/lib/postgresql/data:c
+    healthcheck:
+      test: ["CMD-SHELL", "pg_isready -h postgres -U postgres"]
+      interval: 5s
+      timeout: 5s
+      retries: 10
+  <%- end -%>
+
+  <%- if services.include?('redis') -%>
+  redis:
+    image: redis:<%= @versions['redis'] %>
+    volumes:
+      - redis:/data:delegated
+    healthcheck:
+      test: ["CMD", "redis-cli", "ping"]
+      interval: 5s
+      timeout: 3s
+      retries: 10
+    entrypoint: redis-server --appendonly yes
+  <%- end -%>
+
+  prod:
+    <<: *app
+    image: <%= @app_name %>:production
+    environment:
+      <<: *docker-environment
+      RAILS_ENV: production
+      RACK_ENV: production
+    profiles:
+      - prod
+    healthcheck:
+      test: ["CMD", "curl", "http://prod:3000/health"]
+      interval: 20s
+      timeout: 5s
+      retries: 3
+      start_period: 20s
+    deploy:
+      mode: replicated
+      replicas: 2
+      endpoint_mode: vip
+      update_config:
+        parallelism: 1
+        order: start-first
+        delay: 5s
+        failure_action: rollback
+      restart_policy:
+        condition: on-failure
+        max_attempts: 3
+        window: 120s
+    volumes:
+      - cache:/app/tmp/cache:d
+
+  reproxy:
+    image: umputun/reproxy
+    profiles:
+      - prod
+    ports:
+      - 80:8080
+      - 443:8443
+    environment:
+      SSL_TYPE: auto
+      SSL_ACME_FQDN: domain.com
+      SSL_ACME_LOCATION: /srv/var/acme
+      SSL_ACME_EMAIL: mail@example.com
+      FILE_ENABLED: true
+    volumes:
+      - ./config/reproxy.conf:/srv/reproxy.yml
+      - certs:/srv/var/acme
+
+volumes:
+  postgres:
+  redis:
+  bundle:
+  node_modules:
+  cache:

data/lib/chagall/settings.rb

@@ -0,0 +1,232 @@
+# frozen_string_literal: true
+
+require "yaml"
+require "singleton"
+
+module Chagall
+  class Settings
+    include Singleton
+
+    attr_accessor :options, :missing_options, :missing_compose_files
+    CHAGALL_PROJECTS_FOLDER = "~/projects"
+    TMP_CACHE_FOLDER = "tmp"
+
+    OPTIONS = [
+      {
+        key: :debug,
+        flags: [ "--debug" ],
+        description: "Debug mode with pry attaching",
+        type: :boolean,
+        default: false,
+        environment_variable: "CHAGALL_DEBUG"
+      },
+      {
+        key: :skip_uncommit,
+        flags: [ "--skip-uncommit" ],
+        description: "Skip uncommitted changes check",
+        type: :boolean,
+        default: false,
+        environment_variable: "CHAGALL_SKIP_UNCOMMIT"
+      },
+      {
+        key: :server,
+        flags: [ "-s", "--server" ],
+        description: "Server to deploy to",
+        type: :string,
+        required: true,
+        environment_variable: "CHAGALL_SERVER"
+      },
+      {
+        key: :name,
+        flags: [ "-n", "--name" ],
+        description: "Project name",
+        type: :string,
+        default: Pathname.new(Dir.pwd).basename.to_s,
+        environment_variable: "CHAGALL_NAME"
+      },
+      {
+        key: :release,
+        flags: [ "--release" ],
+        description: "Release tag",
+        required: true,
+        default: `git rev-parse --short HEAD`.strip,
+        type: :string,
+        environment_variable: "CHAGALL_RELEASE"
+      },
+      {
+        key: :dry_run,
+        type: :boolean,
+        default: false,
+        flags: [ "-d", "--dry-run" ],
+        environment_variable: "CHAGALL_DRY_RUN",
+        description: "Dry run"
+      },
+      {
+        key: :remote,
+        flags: [ "-r", "--remote" ],
+        description: "Deploy remotely (build on remote server)",
+        type: :boolean,
+        default: false,
+        environment_variable: "CHAGALL_REMOTE"
+      },
+      {
+        key: :compose_files,
+        flags: [ "-c", "--compose-files" ],
+        description: "Comma separated list of compose files",
+        type: :array,
+        required: true,
+        environment_variable: "CHAGALL_COMPOSE_FILES",
+        proc: ->(value) { value.split(",") }
+      },
+      {
+        key: :target,
+        type: :string,
+        default: "production",
+        flags: [ "--target" ],
+        environment_variable: "CHAGALL_TARGET",
+        description: "Target"
+      },
+      {
+        key: :dockerfile,
+        type: :string,
+        flags: [ "-f", "--file" ],
+        default: "Dockerfile",
+        environment_variable: "CHAGALL_DOCKERFILE",
+        description: "Dockerfile"
+      },
+      {
+        key: :projects_folder,
+        type: :string,
+        default: CHAGALL_PROJECTS_FOLDER,
+        flags: [ "-p", "--projects-folder" ],
+        environment_variable: "CHAGALL_PROJECTS_FOLDER",
+        description: "Projects folder"
+      },
+      {
+        key: :cache_from,
+        type: :string,
+        default: "#{TMP_CACHE_FOLDER}/.buildx-cache",
+        flags: [ "--cache-from" ],
+        environment_variable: "CHAGALL_CACHE_FROM",
+        description: "Cache from"
+      },
+      {
+        key: :cache_to,
+        type: :string,
+        default: "#{TMP_CACHE_FOLDER}/.buildx-cache-new",
+        flags: [ "--cache-to" ],
+        environment_variable: "CHAGALL_CACHE_TO",
+        description: "Cache to"
+      },
+      {
+        key: :keep_releases,
+        type: :integer,
+        default: 3,
+        flags: [ "-k", "--keep-releases" ],
+        environment_variable: "CHAGALL_KEEP_RELEASES",
+        description: "Keep releases",
+        proc: ->(value) { Integer(value) }
+      },
+      {
+        key: :ssh_args,
+        type: :string,
+        default: "-o StrictHostKeyChecking=no",
+        environment_variable: "CHAGALL_SSH_ARGS",
+        flags: [ "--ssh-args" ],
+        description: "SSH arguments"
+      },
+      {
+        key: :docker_context,
+        type: :string,
+        flags: [ "--docker-context" ],
+        environment_variable: "CHAGALL_DOCKER_CONTEXT",
+        default: ".",
+        description: "Docker context"
+      },
+      {
+        key: :platform,
+        type: :string,
+        flags: [ "--platform" ],
+        environment_variable: "CHAGALL_PLATFORM",
+        default: "linux/x86_64",
+        description: "Platform"
+      }
+    ].freeze
+    class << self
+      def configure(argv)
+        instance.configure(argv)
+      end
+
+      def [](key)
+        instance.options[key]
+      end
+    end
+
+    def configure(parsed_options)
+      @options = parsed_options
+      @missing_options = []
+      @missing_compose_files = []
+
+      # @options.merge!(options_from_config_file)
+      # @options.merge!(parsed_options)
+
+      validate_options
+    end
+
+    def validate_options
+      error_message_string = "\n"
+
+      OPTIONS.each do |option|
+        @missing_options << option if option[:required] && @options[option[:key]].to_s.empty?
+      end
+
+      if @missing_options.any?
+        error_message_string += "  Missing required options: #{@missing_options.map { |o| o[:key] }.join(', ')}\n"
+        error_message_string += "    These can be set via:\n"
+        error_message_string += "      - CLI arguments (#{@missing_options.map { |o| o[:flags] }.join(', ')})\n"
+        error_message_string += "      - Environment variables (#{@missing_options.map do |o|
+          o[:environment_variable] || o[:env_name]
+        end.join(', ')})\n"
+        error_message_string += "      - chagall.yml file\n"
+      end
+
+      if @options[:compose_files]
+        @options[:compose_files].each do |file|
+          unless File.exist?(file)
+            @missing_compose_files << file
+            error_message_string += "  Missing compose file: #{file}\n"
+          end
+        end
+      end
+
+      return unless @missing_options.any? || @missing_compose_files.any?
+
+      raise Chagall::SettingsError, error_message_string unless @options[:dry_run]
+    end
+
+    def 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
+
+    def true?(value)
+      value.to_s.strip.downcase == "true"
+    end
+
+    def image_tag
+      @image_tag ||= "#{options[:name]}:#{options[:release]}"
+    end
+
+    def project_folder_path
+      @project_folder_path ||= "#{options[:projects_folder]}/#{options[:name]}"
+    end
+  end
+end