cdao-pjet/config/deploy.rb

# config valid only for current version of Capistrano
lock "3.6.1"

set :application, "cdao-pjet"
set :repo_url, "[email protected]:CDAsia/cdao-pjet.git"
set :branch, "master"
set :deploy_to, -> { "/var/www/#{fetch(:application)}" }

# Default value for :linked_files is []
set :docker_copy_data, fetch(:linked_files, []).push(".env",
                                                     "config/application.yml")

# Default value for keep_releases is 5
set :keep_releases, 5

set :log_level, :info

set :bundle_flags, "--deployment --quiet"

set :docker_role, :web
set :docker_compose, true
set :docker_compose_up_services, "--remove-orphans --scale web=3 load_balancer"
set :docker_compose_project_name, -> { fetch(:application) }
set :docker_assets_precompile_command, -> {
  ["bundle exec rake assets:precompile",
   "bundle exec rake assets:non_digested",
   "bundle exec rake assets:clean"].join(" && ")
}
set :docker_migrate_command, -> { "bundle exec rake db:migrate" }
set :docker_compose_path, -> { release_path.join(fetch(:docker_compose_file)) }

namespace :deploy do
  desc "Fix repo"
  task :set_origin_url do
    on roles(:all) do
      if File.directory?(deploy_path.join("repo"))
        execute "cd #{fetch(:deploy_to)}/repo && git remote set-url origin #{fetch(:repo_url)}"
      end
    end
  end

  desc "Load ENV on figaro"
  before :starting, :set_figaro_env do
    run_locally do
      opts = {
          environment: fetch(:rack_env, fetch(:rails_env, "production")),
          path: "config/application.yml"
      }
      Figaro.application = Figaro::Application.new(opts)
      Figaro.load
    end
  end
end

namespace :docker do
  namespace :rails do
    def docker_compose_execute(exec)
      cmd = ["run --rm"] # --rm, Remove container after run
      cmd.unshift("-p #{fetch(:docker_compose_project_name)}") unless fetch(:docker_compose_project_name).nil?
      cmd.unshift("-f #{fetch(:docker_compose_path)}")
      cmd << "web bash -c '#{exec}'"

      cmd.join(" ")
    end

    task :bundle do
      on release_roles(fetch(:docker_role)) do
        within release_path do
          options = []
          # options << "--gemfile #{fetch(:bundle_gemfile)}" if fetch(:bundle_gemfile)
          # options << "--path #{fetch(:bundle_path)}" if fetch(:bundle_path)
          unless test(:'docker-compose', docker_compose_execute("bundle check #{options.join(' ')}"))
            # options << "--binstubs #{fetch(:bundle_binstubs)}" if fetch(:bundle_binstubs)
            # options << "--jobs #{fetch(:bundle_jobs)}" if fetch(:bundle_jobs)
            # options << "--without #{fetch(:bundle_without)}" if fetch(:bundle_without)
            # options << fetch(:bundle_flags).to_s if fetch(:bundle_flags)
            execute :'docker-compose', docker_compose_execute("bundle install #{options.join(' ')}")
          end
        end
      end
    end

    namespace :assets do
      task :precompile do
        on release_roles(fetch(:docker_role)) do
          within release_path do
            execute :'docker-compose', docker_compose_execute(fetch(:docker_assets_precompile_command))
          end
        end
      end
    end

    namespace :db do
      task :migrate do
        on release_roles(fetch(:docker_role)) do
          within release_path do
            execute :'docker-compose', docker_compose_execute(fetch(:docker_migrate_command))
          end
        end
      end
    end

    def _compose_option_up_services
      opt = fetch(:docker_compose_up_services)
      opt.nil? ? "" : opt
    end

    def compose_start_command
      cmd = %w[up -d --remove-orphans]
      cmd << _compose_option_up_services
      cmd.unshift _compose_option_project_name
      cmd.unshift _compose_option_compose_path

      cmd.join(" ")
    end
  end
end

# Sentry deployment notificationt
set :sentry_api_token, ENV["SENTRY_API_TOKEN"]
set :sentry_organization, ENV["SENTRY_ORGANIZATION"]
set :sentry_project, ENV["SENTRY_PROJECT"]

before "deploy:starting", "sentry:validate_config"
after "deploy:published", "sentry:notice_deployment"

after "deploy:check:directories", "deploy:set_origin_url"
after "docker:deploy:compose:build", "docker:rails:bundle"
after "docker:rails:bundle", "docker:rails:db:migrate"
after "docker:rails:bundle", "docker:rails:assets:precompile"