capistrano-ops 0.2.13 → 1.0.0

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

@@ -1,48 +0,0 @@
-# frozen_string_literal: true
-
-namespace :wkhtmltopdf do
-  after 'deploy:symlink:release', 'wkhtmltopdf:setup'
-
-  desc 'unzip wkhtmltopdf if necessary'
-  task :setup do
-    on roles(:app) do
-      within release_path do
-        binary_path, version = binary_path_and_version
-        info("setup wkhtmltopdf version #{version}")
-        check_file_and_permissions(binary_path, version)
-      end
-    end
-  end
-end
-def binary_path_and_version
-  # get the binary path of wkhtmltopdf-binary
-  gem_path = capture(:bundle, 'show', 'wkhtmltopdf-binary').strip
-  binary_path = "#{gem_path}/bin"
-
-  # get the use wkhtmltopdf_ubuntu version from the wicked_pdf initializer
-  version = capture(:cat, 'config/initializers/wicked_pdf.rb').scan(/wkhtmltopdf_ubuntu_(\d+\.\d+)_amd64/).flatten.first
-
-  [binary_path, version]
-end
-
-def check_file_and_permissions(binary_path, version)
-  binary_file = "#{binary_path}/wkhtmltopdf_ubuntu_#{version}_amd64"
-
-  if test("[ -f #{binary_file} ]")
-    info('wkhtmltopdf binary already extracted')
-
-    if test("[ $(stat -c '%a' #{binary_file}) = '777' ]")
-      info('wkhtmltopdf binary has already the right permissions')
-    else
-      info('adding right permissions to wkhtmltopdf binary')
-      execute("chmod 777 #{binary_file}")
-    end
-  else
-    info('extracting wkhtmltopdf binary')
-    # extract the binary but keep the gzip file
-    execute("cd #{binary_path} && gzip -dk  wkhtmltopdf_ubuntu_#{version}_amd64.gz")
-    # add execute permission to the binary
-    execute("chmod 777 #{binary_file}")
-  end
-  info('wkhtmltopdf setup finished')
-end

data/lib/capistrano/ops/capistrano/v3/tasks/backup/backup_helper.rb

@@ -1,50 +0,0 @@
-# frozen_string_literal: true
-
-module BackupHelper
-  def backup_file_name(type)
-    regex = type == 'storage' ? "'.{0,}\.tar.gz'" : "'.{0,}\.dump'"
-    @backup_file_name ||= capture "cd #{shared_path}/backups && ls -lt | grep -E -i #{regex} | head -n 1 | awk '{print $9}'"
-  end
-
-  def backup_file_size
-    @backup_file_size ||= capture "cd #{shared_path}/backups && wc -c #{@backup_file_name} | awk '{print $1}'"
-  end
-
-  def download_backup(backup_file, type)
-    puts "Downloading #{type} backup"
-    download! "#{shared_path}/backups/#{backup_file}", backup_file
-    puts "Download finished\nDeleting temporary backup..."
-    cleanup_backup(backup_file, "Download finished\nDeleting temporary backup...")
-  end
-
-  def cleanup_backup(backup_file, message)
-    puts message
-    execute "cd #{shared_path}/backups && rm #{backup_file}"
-    puts 'Temporary backup deleted'
-  end
-
-  def question(question, default = 'n', &block)
-    print "#{question} #{default.downcase == 'n' ? '(y/N)' : '(Y/n)'}: "
-    input = $stdin.gets.strip.downcase
-    answer = (input.empty? ? default : input).downcase.to_s
-
-    if %w[y n].include?(answer)
-      block.call(answer == 'y')
-    else
-      question(question, default, &block)
-    end
-  end
-
-  def prepare_env
-    @env = "RAILS_ENV=#{fetch(:stage)}"
-    @path_cmd = "PATH=$HOME/.rbenv/versions/#{RUBY_VERSION}/bin:$PATH"
-    @test_command = "cd #{release_path} && #{@path_cmd} && #{@env}"
-  end
-
-  def size_str(size)
-    units = %w[B KB MB GB TB]
-    e = (Math.log(size) / Math.log(1024)).floor
-    s = format('%.2f', size.to_f / 1024**e)
-    s.sub(/\.?0*$/, units[e])
-  end
-end

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

@@ -1,139 +0,0 @@
-# frozen_string_literal: true
-
-# rubocop:disable Metrics/BlockLength
-namespace :figaro_yml do
-  # Defaults to :app role
-  rake_roles = fetch(:rake_roles, :app)
-
-  desc 'get the `application.yml` file from server and create local if it does not exist'
-  task :get do
-    env = fetch(:stage)
-    if !File.exist?('config/application.yml')
-      puts 'config/application.yml does not exist, creating it from all stages'
-      run_locally do
-        yamls = {}
-        stages = Dir.glob('config/deploy/*.rb')
-        puts "found #{stages.count} stages"
-        stages.map do |f|
-          stage = File.basename(f, '.rb')
-          puts "download #{stage} application.yml"
-          begin
-            res = capture "cap #{stage} figaro_yml:get_stage"
-            yamls = yamls.merge(YAML.safe_load(res))
-          rescue StandardError
-            puts "could not get #{stage} application.yml"
-          end
-          yamls
-        end
-        # write to new file
-        puts 'writing to config/application.yml'
-        write_to_file('config/application.yml', yamls.to_yaml)
-      end
-    else
-      local_yml = YAML.safe_load(File.read('config/application.yml'))
-      on roles(rake_roles) do
-        remote = capture("cat #{shared_path}/config/application.yml")
-        remote_yml = YAML.safe_load(remote)
-        remote_stage = remote_yml[env.to_s]
-        puts "remote application.yml stage '#{env}':\n\n"
-        puts "#{remote}\r\n"
-        puts "\r\n"
-        loop do
-          print "Overwrite local application.yml stage '#{env}'? (y/N): "
-          input = $stdin.gets.strip.downcase
-          answer = (input.empty? ? 'N' : input).downcase.to_s
-
-          next unless %w[y n].include?(answer)
-
-          if answer == 'y'
-            puts 'Updating local application.yml'
-            local_yml[env.to_s] = remote_stage
-            write_to_file('config/application.yml', local_yml.to_yaml)
-            exit
-          end
-          break
-        end
-        puts 'Nothing written to local application.yml'
-        exit
-      end
-    end
-  end
-
-  task :get_stage do
-    on roles(rake_roles) do
-      puts capture "cat #{shared_path}/config/application.yml"
-    end
-  end
-
-  desc 'compare and set the figaro_yml file on the server'
-  task :compare do
-    env = fetch(:stage)
-    # read local application.yml
-    local = File.read('config/application.yml')
-
-    # convert to hash
-    local_global_env = YAML.safe_load(local)
-
-    # split into stage and global
-    local_stage_env = local_global_env[env.to_s]
-    local_global_env.delete('staging')
-    local_global_env.delete('production')
-
-    on roles(rake_roles) do
-      # read remote application.yml
-      remote = capture("cat #{shared_path}/config/application.yml")
-
-      remote_global_env = YAML.safe_load(remote)
-      remote_stage_env = remote_global_env[env.to_s]
-      remote_global_env.delete(env.to_s)
-
-      puts "with command 'cap #{env} figaro_yml:setup', following variables will be overwritten:"
-      puts '--------------------------------------------------------------------------------'
-      result1 = compare_hashes(local_global_env, remote_global_env)
-      result2 = compare_hashes(local_stage_env, remote_stage_env)
-      if !result1.empty? || !result2.empty?
-        loop do
-          print 'Update remote application.yml? (y/N): '
-          input = $stdin.gets.strip.downcase
-          answer = (input.empty? ? 'N' : input).downcase.to_s
-
-          next unless %w[y n].include?(answer)
-
-          if answer == 'y'
-            puts 'Updating remote application.yml'
-            invoke 'figaro_yml:setup'
-            exit
-          end
-          break
-        end
-        puts 'remote application.yml not updated'
-        exit
-      end
-      puts 'remote application.yml is up to date'
-    end
-  end
-  def compare_hashes(hash1, hash2)
-    changes = false
-    local_server = hash1.to_a - hash2.to_a
-    server_local = hash2.to_a - hash1.to_a
-
-    [local_server + server_local].flatten(1).to_h.each_key do |k|
-      new_value = hash1[k].to_s
-      new_value = new_value.empty? ? 'nil' : new_value
-      old_value = hash2[k].to_s
-      old_value = old_value.empty? ? 'nil' : old_value
-
-      if old_value != new_value
-        puts "#{k}: #{old_value} => #{new_value} \r\n"
-        changes = true
-      end
-    end
-  end
-
-  def write_to_file(file, content)
-    File.open(file, 'w') do |f|
-      f.write(content)
-    end
-  end
-end
-# rubocop:enable Metrics/BlockLength

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

@@ -1,23 +0,0 @@
-# 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
-    if ENV['TASK']
-      on roles(rake_roles) do
-        within current_path do
-          with rails_env: fetch(:rails_env) do
-            execute :rake, ENV['TASK']
-          end
-        end
-      end
-
-    else
-      puts "\n\nFailed! You need to specify the 'TASK' parameter!",
-           'Usage: cap <stage> invoke:rake TASK=your:task'
-    end
-  end
-end

data/lib/capistrano/ops/capistrano/v3/tasks/logrotate/enable.rake

@@ -1,24 +0,0 @@
-# frozen_string_literal: true
-
-require_relative 'logrotate_helper'
-
-namespace :logrotate do
-  include LogrotateHelper
-  desc 'Enable logrotate for the application'
-  task :enable do
-    on roles(:app) do
-      within release_path do
-        set_config
-        if logrotate_enabled
-          puts "logrotate already enabled:\n========================="
-          puts capture "cat #{@config_file_path}"
-        else
-          make_basepath
-          upload! StringIO.new(@config_template), @config_file_path
-          upload! StringIO.new(@schedule_template), @schedule_file_path
-          whenever 'update' if logrotate_enabled
-        end
-      end
-    end
-  end
-end

data/lib/capistrano/ops/capistrano/v3/tasks/logrotate/logrotate_helper.rb

@@ -1,68 +0,0 @@
-# frozen_string_literal: true
-
-module LogrotateHelper
-  # rubocop:disable Naming/MemoizedInstanceVariableName
-  def set_config
-    info ''
-    @shared_path ||= shared_path
-    @log_file_path ||= fetch(:log_file_path) || "#{@shared_path}/log"
-    @template_config_filename ||= fetch(:logrotate_template_config_file) || 'templates/logrotate.conf.erb'
-    @template_schedule_filename ||= fetch(:logrotate_template_schedule_file) || 'templates/schedule.rb.erb'
-    @basepath ||= fetch(:logrotate_basepath) || "#{shared_path}/logrotate"
-    @config_filename ||= File.basename(@template_config_filename, '.erb')
-    @schedule_filename ||= File.basename(@template_schedule_filename, '.erb')
-    @config_file_path ||= "#{@basepath}/#{@config_filename}"
-    @schedule_file_path ||= "#{@basepath}/#{@schedule_filename}"
-    @config_template ||= config_template
-    @schedule_template ||= schedule_template
-  end
-  # rubocop:enable Naming/MemoizedInstanceVariableName
-
-  def config
-    {
-      template_config_file: fetch(:logrotate_template_config_file) || 'templates/logrotate.conf.erb',
-      template_schedule_file: fetch(:logrotate_template_schedule_file) || 'templates/schedule.rb.erb'
-    }
-  end
-
-  def make_basepath
-    puts capture "mkdir -pv #{@basepath}"
-  end
-
-  def delete_files
-    puts capture "rm -rfv #{@basepath}"
-  end
-
-  def config_template
-    return nil unless @template_config_filename && File.exist?(File.expand_path(@template_config_filename, __dir__))
-
-    ERB.new(File.read(File.expand_path(@template_config_filename, __dir__))).result(binding)
-  end
-
-  def schedule_template
-    return nil unless @template_schedule_filename && File.exist?(File.expand_path(@template_schedule_filename, __dir__))
-
-    ERB.new(File.read(File.expand_path(@template_schedule_filename, __dir__))).result(binding)
-  end
-
-  def logrotate_enabled
-    test("[ -f #{@config_file_path} ]") && test("[ -f #{@schedule_file_path} ]")
-  end
-
-  def logrotate_disabled
-    !(test("[ -f #{@config_file_path} ]") && test("[ -f #{@schedule_file_path} ]"))
-  end
-
-  def whenever(type)
-    case type
-    when 'clear'
-      puts capture :bundle, :exec, :whenever, '--clear-crontab',
-                   "-f #{@schedule_file_path} #{fetch(:whenever_identifier)}_logrotate"
-    when 'update'
-      puts capture :bundle, :exec, :whenever, '--update-crontab', "-f #{@schedule_file_path}",
-                   "-i #{fetch(:whenever_identifier)}_logrotate"
-    else
-      puts 'type not found'
-    end
-  end
-end

data/lib/capistrano/ops/capistrano/v3/tasks/logs/rails.rake

@@ -1,16 +0,0 @@
-# frozen_string_literal: true
-
-namespace :logs do
-  # Default to :app role
-  rake_roles = fetch(:rake_roles, :app)
-  desc 'tail rails logs'
-  task :rails do
-    on roles(rake_roles) do
-      trap('SIGINT') do
-        puts "\nDisconnecting..."
-        exit
-      end
-      execute "tail -f #{shared_path}/log/#{fetch(:rails_env)}.log"
-    end
-  end
-end

data/lib/capistrano/ops/notification.rb

@@ -1,9 +0,0 @@
-# frozen_string_literal: true
-
-require 'capistrano/ops/notification/api'
-require 'capistrano/ops/notification/slack'
-require 'capistrano/ops/notification/webhook'
-
-module Notification
-  class Error < StandardError; end
-end

data/lib/capistrano/ops/railtie.rb

@@ -1,15 +0,0 @@
-# frozen_string_literal: true
-
-require 'rails'
-# require 'capistrano/ops'
-module Capistrano
-  module Ops
-    class Railtie < ::Rails::Railtie
-      railtie_name :ops
-      rake_tasks do
-        path = File.expand_path(__dir__)
-        Dir.glob("#{path}/tasks/**/*.rake").each { |f| load f }
-      end
-    end
-  end
-end