capistrano-ops 0.2.13 → 1.0.0

data/lib/capistrano/ops/figaro_yml/helpers.rb

@@ -0,0 +1,184 @@
+# frozen_string_literal: true
+
+require 'yaml'
+
+# rubocop:disable Metrics/ModuleLength
+module Capistrano
+  module Ops
+    module FigaroYml
+      module Helpers
+        def remote_file_exists?
+          test("[ -f #{figaro_yml_remote_path} ]")
+        end
+
+        def remote_backup_exists?
+          count_remote_files.positive?
+        end
+
+        def rollback_remote_backup
+          latest_backup = latest_remote_backup
+          puts "mv #{figaro_yml_remote_path.parent.join(latest_backup)} #{figaro_yml_remote_path}"
+          execute :mv, figaro_yml_remote_path.parent.join(latest_backup), figaro_yml_remote_path
+          execute :ls, '-l', figaro_yml_remote_path.parent
+        end
+
+        def latest_remote_backup
+          command = "ls -1t #{figaro_yml_remote_path.parent} | grep -E '#{backup_regex}' | head -n 1"
+          capture(command).strip
+        end
+
+        def backup_regex
+          # filename we are looking for "#{figaro_yml_remote_path.basename}-yyyy-mm-dd-HH-MM-SS.bak"
+          "#{figaro_yml_remote_path.basename}-[0-9]{4}-[0-9]{2}-[0-9]{2}-[0-9]{2}-[0-9]{2}-[0-9]{2}.bak"
+        end
+
+        def count_remote_files
+          command = "ls -1 #{figaro_yml_remote_path.parent} | grep -E '#{backup_regex}' | wc -l"
+          capture(command).to_i
+        end
+
+        def create_remote_backup
+          backup_file = "#{figaro_yml_remote_path.basename}-#{Time.now.strftime('%Y-%m-%d-%H-%M-%S')}.bak"
+          # puts "cp #{figaro_yml_remote_path} #{figaro_yml_remote_path.parent.join(backup_file)}"
+          execute :cp, figaro_yml_remote_path, figaro_yml_remote_path.parent.join(backup_file)
+        end
+
+        def cleanup_remote_backups
+          number_of_backups = count_remote_files
+          return unless number_of_backups > 5
+
+          diff = number_of_backups - 5
+          # remove older backups and keep the latest 5
+          command = "ls -1t #{figaro_yml_remote_path.parent} | grep -E '#{backup_regex}' | tail -n #{diff}"
+
+          capture(command).split("\n").each do |file|
+            execute "rm #{figaro_yml_remote_path.parent.join(file)}"
+          end
+        end
+
+        def local_figaro_yml(env)
+          @local_figaro_yml ||= YAML.load(ERB.new(File.read(figaro_yml_local_path)).result)
+          local_figaro = {}
+          deployment_env = fetch(:rails_env, env).to_s
+
+          @local_figaro_yml.each do |key, value|
+            if key == env
+              local_figaro[deployment_env] = @local_figaro_yml[key]
+            elsif !value.is_a?(Hash)
+              local_figaro[key] = @local_figaro_yml[key]
+            end
+          end
+
+          local_figaro
+        end
+
+        def local_yaml
+          YAML.safe_load(File.read(figaro_yml_local_path)) || {}
+        end
+
+        def figaro_yml_env
+          fetch(:figaro_yml_env).to_s
+        end
+
+        def figaro_yml_content
+          local_figaro_yml(figaro_yml_env).to_yaml
+        end
+
+        def configs(yaml, env)
+          stage_yml = yaml[env.to_s]&.sort.to_h
+          global_yml = remove_nested(yaml)&.sort.to_h
+          [global_yml, stage_yml]
+        end
+
+        def remove_nested(hash)
+          hash.each_with_object({}) do |(key, value), new_hash|
+            new_hash[key] = value unless value.is_a?(Hash)
+          end
+        end
+
+        def sort_with_nested(hash)
+          hash.each_with_object({}) do |(key, value), new_hash|
+            new_hash[key] = value.is_a?(Hash) ? sort_with_nested(value) : value
+          end.sort.to_h
+        end
+
+        def compare_hashes(hash1, hash2)
+          all_keys = hash1.keys | hash2.keys # Union of all keys from both hashes
+          all_keys.each_with_object({}) do |key, changes_hash|
+            old_value = hash2[key].nil? ? 'nil' : hash2[key].to_s
+            new_value = hash1[key].nil? ? 'nil' : hash1[key].to_s
+
+            changes_hash[key] = { old: old_value, new: new_value } if old_value != new_value
+          end.tap { |changes| return changes.empty? ? nil : changes }
+        end
+
+        # selection helpers
+        def ask_to_overwrite(question)
+          answer = ''
+          until %w[y n].include?(answer)
+            print "#{question}? (y/N): "
+            answer = $stdin.gets.strip.downcase
+          end
+          answer == 'y'
+        end
+
+        # info helpers
+
+        def print_changes(changes, message)
+          return unless changes
+
+          puts "#{message}:\n\n"
+          changes.each do |key, diff|
+            puts "#{key}: #{diff[:old]} => #{diff[:new]}"
+          end
+          puts "\n"
+        end
+
+        # error helpers
+
+        def check_git_tracking_error
+          puts
+          puts "Error - please remove '#{fetch(:figaro_yml_local_path)}' from git:"
+          puts
+          puts "    $ git rm --cached #{fetch(:figaro_yml_local_path)}"
+          puts
+          puts 'and gitignore it:'
+          puts
+          puts "    $ echo '#{fetch(:figaro_yml_local_path)}' >> .gitignore"
+          puts
+        end
+
+        def check_config_present_error
+          puts
+          puts "Error - '#{figaro_yml_env}' config not present in '#{fetch(:figaro_yml_local_path)}'."
+          puts 'Please populate it.'
+          puts
+        end
+
+        def check_figaro_file_exists_error
+          puts
+          puts "Error - '#{fetch(:figaro_yml_local_path)}' file does not exists, and it's required."
+          puts
+        end
+
+        # file helpers
+        def write_to_file(file, content)
+          File.open(file, 'w') do |f|
+            f.write(content)
+          end
+        end
+
+        def write_combined_yaml(yamls_combined)
+          if yamls_combined.empty?
+            info 'No data to write.'
+          else
+            # write to new file
+            info 'writing to config/application.yml'
+            write_to_file(figaro_yml_local_path, yamls_combined.to_yaml)
+          end
+        end
+      end
+    end
+  end
+end
+# rubocop:enable Metrics/ModuleLength

data/lib/capistrano/ops/figaro_yml/paths.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+require 'pathname'
+
+module Capistrano
+  module Ops
+    module FigaroYml
+      module Paths
+        def figaro_yml_local_path
+          Pathname.new fetch(:figaro_yml_local_path)
+        end
+
+        def figaro_yml_remote_path
+          shared_path.join fetch(:figaro_yml_remote_path)
+        end
+      end
+    end
+  end
+end

data/lib/capistrano/ops/figaro_yml/tasks/backup.rake

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+namespace :figaro_yml do
+  include Capistrano::Ops::FigaroYml::Helpers
+
+  task :backup do
+    on release_roles :all do
+      unless remote_file_exists?
+        puts 'No remote application.yml to backup.'
+        next
+      end
+
+      begin
+        puts 'Creating backup of remote application.yml...'
+        create_remote_backup
+        puts 'Backup created successfully.'
+
+        puts 'Cleaning up remote backups...'
+        cleanup_remote_backups
+        puts 'Remote backups cleaned up successfully.'
+      rescue StandardError => e
+        puts "Error during backup process: #{e.message}"
+      end
+    end
+  end
+end

data/lib/capistrano/ops/figaro_yml/tasks/check.rake

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+namespace :figaro_yml do
+  include Capistrano::Ops::FigaroYml::Paths
+  include Capistrano::Ops::FigaroYml::Helpers
+  desc 'figaro `application.yml` file checks'
+  task :check do
+    invoke 'figaro_yml:check_figaro_file_exists'
+    invoke 'figaro_yml:check_git_tracking'
+    invoke 'figaro_yml:check_config_present'
+  end
+end

data/lib/capistrano/ops/figaro_yml/tasks/check_config_present.rake

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+namespace :figaro_yml do
+  include Capistrano::Ops::FigaroYml::Paths
+  include Capistrano::Ops::FigaroYml::Helpers
+  task :check_config_present do
+    next unless local_figaro_yml(figaro_yml_env).nil?
+
+    check_config_present_error
+    exit 1
+  end
+end

data/lib/capistrano/ops/figaro_yml/tasks/check_figaro_file_exists.rake

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+namespace :figaro_yml do
+  include Capistrano::Ops::FigaroYml::Paths
+  include Capistrano::Ops::FigaroYml::Helpers
+  task :check_figaro_file_exists do
+    next if File.exist?(figaro_yml_local_path)
+
+    check_figaro_file_exists_error
+    exit 1
+  end
+end

data/lib/capistrano/ops/figaro_yml/tasks/check_git_tracking.rake

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+namespace :figaro_yml do
+  include Capistrano::Ops::FigaroYml::Paths
+  include Capistrano::Ops::FigaroYml::Helpers
+  task :check_git_tracking do
+    next unless system("git ls-files #{fetch(:figaro_yml_local_path)} --error-unmatch >/dev/null 2>&1")
+
+    check_git_tracking_error
+    exit 1
+  end
+end

data/lib/capistrano/ops/figaro_yml/tasks/compare.rake

@@ -0,0 +1,53 @@
+# frozen_string_literal: true
+
+namespace :figaro_yml do
+  include Capistrano::Ops::FigaroYml::Paths
+  include Capistrano::Ops::FigaroYml::Helpers
+
+  desc 'compare and set the figaro_yml file on the server'
+  task :compare do
+    # Read and parse local application.yml
+    local = local_figaro_yml(figaro_yml_env)
+
+    # Split into stage-specific and global configurations
+    local_global_env, local_stage_env = configs(local, figaro_yml_env)
+
+    on release_roles :all do
+      # Read and parse remote application.yml
+      remote = YAML.safe_load(capture("cat #{figaro_yml_remote_path}"))
+      remote_global_env, remote_stage_env = configs(remote, figaro_yml_env)
+
+      # Compare hashes and handle nil results with empty hashes
+      differences_global = compare_hashes(local_global_env, remote_global_env)
+      differences_stage = compare_hashes(local_stage_env, remote_stage_env)
+
+      print_changes(differences_global, 'Local application.yml has extra/different global entries compared to remote.')
+      if differences_stage
+        print_changes(differences_stage, "Local application.yml has extra/different entries in #{figaro_yml_env} section compared to remote.")
+      end
+
+      puts 'No Differences found between remote and local application.yml' unless differences_global || differences_stage
+
+      # ask to overwrite remote yml if differences found
+      overwrite_remote = ask_to_overwrite('Overwrite remote application.yml') if differences_global || differences_stage
+      puts 'Nothing written to remote application.yml' unless overwrite_remote
+
+      exit unless overwrite_remote
+      # sort local yml before updating remote
+      puts 'Preparing local application.yml before updating remote...'
+      invoke 'figaro_yml:sort_local'
+      puts 'Local application.yml is ready to be updated.'
+
+      # update remote yml
+      invoke 'figaro_yml:setup'
+      ##
+      # TODO: restart server after updating remote yml
+      # let user choose to restart server after updating remote yml
+      # let user choose to restart server now or later if they choose to restart now
+      # ask for time to restart server if he chooses to restart later
+      # restart server after the time given
+      ##
+      puts 'Remote application.yml has been updated.'
+    end
+  end
+end

data/lib/capistrano/ops/figaro_yml/tasks/create_local.rake

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+namespace :figaro_yml do
+  include Capistrano::Ops::FigaroYml::Paths
+  include Capistrano::Ops::FigaroYml::Helpers
+  task :create_local do
+    run_locally do
+      puts "found #{stages.count} stages"
+      yamls_combined = {}
+
+      stages.each do |f|
+        stage = File.basename(f, '.rb')
+        puts "download #{stage} application.yml"
+        begin
+          res = capture "cap #{stage} figaro_yml:get_stage"
+          stage_yaml = YAML.safe_load(res)
+          stage_yaml[stage.to_s] = stage_yaml[stage.to_s].sort.to_h
+          yamls_combined.merge!(stage_yaml) if stage_yaml
+        rescue StandardError
+          puts "could not get #{stage} application.yml"
+        end
+      end
+
+      write_combined_yaml(yamls_combined.sort.to_h)
+    end
+  end
+end

data/lib/capistrano/ops/figaro_yml/tasks/figaro_yml_symlink.rake

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+namespace :figaro_yml do
+  include Capistrano::Ops::FigaroYml::Paths
+  include Capistrano::Ops::FigaroYml::Helpers
+  task :figaro_yml_symlink do
+    set :linked_files, fetch(:linked_files, []).push(fetch(:figaro_yml_remote_path))
+  end
+  after 'deploy:started', 'figaro_yml:figaro_yml_symlink'
+end

data/lib/capistrano/ops/figaro_yml/tasks/get.rake

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+namespace :figaro_yml do
+  include Capistrano::Ops::FigaroYml::Paths
+  include Capistrano::Ops::FigaroYml::Helpers
+  task :get do
+    if !File.exist?(figaro_yml_local_path)
+      invoke 'figaro_yml:create_local'
+    else
+      local_yml = local_figaro_yml(figaro_yml_env)
+      local_global, local_stage = configs(local_yml, figaro_yml_env)
+      on release_roles :all do
+        remote = capture "cat #{figaro_yml_remote_path}"
+        remote_yml = YAML.safe_load(remote).sort.to_h
+        remote_global, remote_stage = configs(remote_yml, figaro_yml_env)
+        differences_global = compare_hashes(remote_global, local_global || {})
+        differences_stage = compare_hashes(remote_stage, local_stage || {})
+
+        print_changes(differences_global,
+                      'Remote application.yml has extra/different global entries compared to local.')
+        if differences_stage
+          print_changes(differences_stage, "Remote application.yml has extra/different entries in #{figaro_yml_env} section compared to local.")
+        end
+
+        puts 'No Differences found between remote and local application.yml' unless differences_global || differences_stage
+
+        # ask to overwrite local yml if differences found
+        stage_overwrite = ask_to_overwrite("Overwrite local application.yml #{figaro_yml_env} section") if differences_stage
+        global_overwrite = ask_to_overwrite('Overwrite local application.yml globals') if differences_global
+        puts 'Nothing written to local application.yml' unless stage_overwrite || global_overwrite
+        exit unless stage_overwrite || global_overwrite
+
+        # compose new yml
+        composed_yml = {}
+        composed_yml.merge!(local_yml) # local yml is always included to avoid losing any data
+        composed_yml.merge!(local_global) unless global_overwrite
+        composed_yml.merge!(remote_global) if global_overwrite
+        composed_yml[figaro_yml_env.to_s] = stage_overwrite ? remote_stage : local_stage
+
+        # write to new file
+        write_combined_yaml(composed_yml.sort.to_h)
+      end
+    end
+  end
+end

data/lib/capistrano/ops/figaro_yml/tasks/get_stage.rake

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+namespace :figaro_yml do
+  include Capistrano::Ops::FigaroYml::Paths
+  include Capistrano::Ops::FigaroYml::Helpers
+  rake_roles = fetch(:rake_roles, :app)
+
+  task :get_stage do
+    on roles(rake_roles) do
+      raise 'The file does not exist.' unless test "[ -f #{figaro_yml_remote_path} ]"
+
+      puts capture "cat #{figaro_yml_remote_path}"
+    end
+  end
+end

data/lib/capistrano/ops/figaro_yml/tasks/load.rake

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+namespace :load do
+  task :defaults do
+    set :figaro_yml_local_path, 'config/application.yml'
+    set :figaro_yml_remote_path, 'config/application.yml'
+    set :figaro_yml_env, -> { fetch(:rails_env) || fetch(:stage) }
+    set :figaro_yml_remote_backup, false
+  end
+end

data/lib/capistrano/ops/figaro_yml/tasks/rollback.rake

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+namespace :figaro_yml do
+  include Capistrano::Ops::FigaroYml::Helpers
+
+  task :rollback do
+    on release_roles :all do
+      unless remote_backup_exists?
+        puts 'No backup of remote application.yml to rollback.'
+        next
+      end
+
+      begin
+        puts 'Rolling back remote application.yml...'
+        rollback_remote_backup
+        puts 'Rollback completed successfully.'
+      rescue StandardError => e
+        puts "Error during rollback process: #{e.message}"
+      end
+    end
+  end
+end

data/lib/capistrano/ops/figaro_yml/tasks/setup.rake

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+namespace :figaro_yml do
+  include Capistrano::Ops::FigaroYml::Paths
+  include Capistrano::Ops::FigaroYml::Helpers
+
+  desc 'Setup figaro `application.yml` file on the server(s)'
+  task setup: [:check] do
+    content = figaro_yml_content
+    on release_roles :all do
+      execute :mkdir, '-pv', File.dirname(figaro_yml_remote_path)
+      upload! StringIO.new(content), figaro_yml_remote_path
+    end
+  end
+  before 'figaro_yml:setup', 'figaro_yml:backup'
+end

data/lib/capistrano/ops/figaro_yml/tasks/sort_local.rake

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+namespace :figaro_yml do
+  include Capistrano::Ops::FigaroYml::Paths
+  include Capistrano::Ops::FigaroYml::Helpers
+  task :sort_local do
+    run_locally do
+      info 'Sorting local application.yml...'
+      local = local_yaml
+      sorted_local = sort_with_nested(local)
+      write_combined_yaml(sorted_local)
+    end
+  end
+
+  task :sort do
+    invoke 'figaro_yml:sort_local'
+  end
+end

data/lib/capistrano/ops/figaro_yml.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+require 'capistrano/ops/helper'
+require 'capistrano/ops/figaro_yml/paths'
+require 'capistrano/ops/figaro_yml/helpers'
+
+module TaskLoader
+  extend Capistrano::Ops::Helper
+
+  def self.load_tasks_if_gem_present(gem_name, task_path, warning_message)
+    if gem_in_gemfile?(gem_name)
+      Dir.glob("#{File.expand_path(__dir__)}/#{task_path}/**/*.rake").each { |f| load f }
+    else
+      puts warning_message
+    end
+  end
+end
+
+TaskLoader.load_tasks_if_gem_present('figaro', 'figaro_yml/tasks', 'WARNING: Gemfile does not include figaro gem which is required for figaro_yml tasks')
+# include Capistrano::Ops::Helper
+
+# Dir.glob("#{File.expand_path(__dir__)}/figaro_yml/tasks/*.rake").each { |f| load f }
+
+# # gem 'figaro' is required for figaro_yml tasks
+
+# figaro_gem = gem_in_gemfile?('figaro')
+
+# # check if Gemfile environment includes figaro gem and warn user if not found
+# puts 'WARNING: Gemfile does not include figaro gem which is required for figaro_yml tasks' unless figaro_gem

data/lib/capistrano/ops/helper.rb

@@ -0,0 +1,14 @@
+module Capistrano
+  module Ops
+    module Helper
+      def gem_in_gemfile?(gem_name)
+        if File.exist?('Gemfile')
+          File.foreach('Gemfile') do |line|
+            return true if line.include?('gem') && line.include?("'#{gem_name}'") && !line.include?('#')
+          end
+        end
+        false
+      end
+    end
+  end
+end

data/lib/capistrano/ops/invoke/tasks/invoke.rake

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+namespace :invoke do
+  # Defalut to :app roles
+  rake_roles = fetch(:rake_roles, :app)
+
+  desc 'Execute a rake task on a remote server (cap invoke:rake TASK=db:migrate)'
+  task :rake do
+    task_name = ENV['TASK']
+    unless task_name
+      puts "\n\nFailed! You need to specify the 'TASK' parameter!",
+           'Usage: cap <stage> invoke:rake TASK=your:task',
+           'Example: cap production invoke:rake TASK=db:migrate'
+      exit 1
+    end
+
+    on roles(rake_roles) do
+      within current_path do
+        with rails_env: fetch(:rails_env) do
+          execute :rake, task_name
+        end
+      end
+    end
+  end
+end

data/lib/capistrano/ops/invoke.rb

@@ -0,0 +1,3 @@
+# frozen_string_literal: true
+
+Dir.glob("#{File.expand_path(__dir__)}/invoke/tasks/**/*.rake").each { |f| load f }

data/lib/capistrano/ops/logrotate/helpers.rb

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+module Capistrano
+  module Ops
+    module Logrotate
+      module Helpers
+        def config_template
+          return nil unless File.exist?(File.expand_path(logrotate_config_file_template, __dir__))
+
+          ERB.new(File.read(File.expand_path(logrotate_config_file_template, __dir__))).result(binding)
+        end
+
+        def schedule_template
+          return nil unless File.exist?(File.expand_path(logrotate_schedule_file_template, __dir__))
+
+          ERB.new(File.read(File.expand_path(logrotate_schedule_file_template, __dir__))).result(binding)
+        end
+
+        def logrotate_enabled
+          test("[ -f #{logrotate_config_file_path} ]") && test("[ -f #{logrotate_schedule_file_path} ]")
+        end
+
+        def logrotate_disabled
+          !(test("[ -f #{logrotate_config_file_path} ]") && test("[ -f #{logrotate_schedule_file_path} ]"))
+        end
+
+        def make_basepath
+          puts capture "mkdir -pv #{logrotate_basepath}"
+        end
+
+        def delete_files
+          puts capture "rm -rfv #{logrotate_basepath}"
+        end
+
+        def whenever(type)
+          case type
+          when 'clear'
+            puts capture :bundle, :exec, :whenever, '--clear-crontab',
+                         "-f #{logrotate_schedule_file_path} #{fetch(:whenever_identifier)}_logrotate"
+          when 'update'
+            puts capture :bundle, :exec, :whenever, '--update-crontab', "-f #{logrotate_schedule_file_path}",
+                         "-i #{fetch(:whenever_identifier)}_logrotate"
+          else
+            puts 'type not found'
+          end
+        end
+      end
+    end
+  end
+end