capistrano-ops 0.2.2 → 0.2.4

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

@@ -1,24 +1,23 @@
+# frozen_string_literal: true
+
 namespace :invoke do
+  # Defalut to :app roles
+  rake_roles = fetch(:rake_roles, :app)
 
-    # 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
+  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
-  
-      else
-        puts "\n\nFailed! You need to specify the 'TASK' parameter!",
-             "Usage: cap <stage> invoke:rake TASK=your:task"
       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.rb

@@ -8,6 +8,8 @@ if defined?(Capistrano::VERSION) && Gem::Version.new(Capistrano::VERSION).releas
   load File.expand_path('capistrano/v3/tasks/figaro_yml.rake', __dir__)
   load File.expand_path('capistrano/v3/tasks/logs.rake', __dir__)
   load File.expand_path('capistrano/v3/tasks/invoke.rake', __dir__)
+  path = File.expand_path(__dir__)
+  Dir.glob("#{path}/capistrano/v3/tasks/backup/**/*.rake").each { |f| load f }
 else
   puts 'Capistrano 3 is required to use this gem'
 end

data/lib/capistrano/ops/notification/api.rb

@@ -1,30 +1,34 @@
+# frozen_string_literal: true
+
 module Notification
-    class Api
-        attr_accessor :notification_type, :notification_level
+  class Api
+    attr_accessor :notification_type, :notification_level
+
+    def initialize(notification_type: ENV['NOTIFICATION_TYPE'], notification_level: ENV['NOTIFICATION_LEVEL'])
+      self.notification_type = notification_type
+      self.notification_level = notification_level || 'error'
+    end
 
-        def initialize(notification_type: ENV['NOTIFICATION_TYPE'], notification_level: ENV['NOTIFICATION_LEVEL'])
-            self.notification_type = notification_type
-            self.notification_level = notification_level || 'error'
-        end
+    def send_backup_notification(result, title, content, webhook_data = nil)
+      return if notification_type.nil?
+
+      case notification_type
+      when 'slack'
+        Slack.new.backup_notification(result, title, content, notification_level)
+      when 'webhook'
+        Webhook.new.backup_notification(result, webhook_data, notification_level)
+      end
+    end
 
-        def send_backup_notification(result, date, database, backup_path)
-            return if notification_type.nil?
-            case notification_type
-            when 'slack'
-                Slack.new.backup_notification(result, date, database, backup_path, notification_level)
-            when 'webhook'
-                Webhook.new.backup_notification(result, date, database, backup_path, notification_level)
-            end
-        end
+    def send_notification(message)
+      return if notification_type.nil?
 
-        def send_notification(message)
-            return if notification_type.nil?
-            case notification_type
-            when 'slack'
-                Slack.new.notify(message)
-            when 'webhook'
-                p 'webhook'
-            end
-        end
+      case notification_type
+      when 'slack'
+        Slack.new.notify(message)
+      when 'webhook'
+        p 'webhook'
+      end
     end
-end
+  end
+end

data/lib/capistrano/ops/notification/slack.rb

@@ -1,67 +1,72 @@
+# frozen_string_literal: true
+
+require 'faraday'
+require 'json'
+
 module Notification
-    class Slack
-        require 'uri'
-        require 'net/http'
-        require 'net/https'
-        def initialize
-            @slack_secret = ENV['SLACK_SECRET']
-            @slack_channel = ENV['SLACK_CHANNEL']
-            @slack_base_url ='https://slack.com/api/'
-        end
+  class Slack
+    def initialize
+      @slack_secret = ENV['SLACK_SECRET']
+      @slack_channel = ENV['SLACK_CHANNEL']
+      @conn = Faraday.new(url: 'https://slack.com/api/') do |faraday|
+        faraday.headers['Content-Type'] = 'application/json'
+        faraday.headers['Authorization'] = "Bearer #{@slack_secret}"
+      end
+    end
+
+    def notify(message)
+      return if @slack_secret.nil? || @slack_channel.nil?
 
-        def notify(message)
-            return if @slack_secret.nil? || @slack_channel.nil?
-            uri = URI.parse("#{@slack_base_url}chat.postMessage")
-            http = Net::HTTP.new(uri.host, uri.port)
-            http.use_ssl = true
-            request = Net::HTTP::Post.new(uri.request_uri, initHeader = {'Content-Type' =>'application/json', 'Authorization' => 'Bearer ' + @slack_secret})
-            request.body = {
-                channel: @slack_channel,
-                text: message
-            }.to_json
-            response = http.request(request)
-            puts response.body
+      begin
+        res = @conn.post('chat.postMessage') do |req|
+          req.body = {
+            "channel": @slack_channel,
+            "text": message
+          }.to_json
         end
+        response = JSON.parse(res.body)
+        raise Notification::Error, response['error'] if response['ok'] == false
 
-        def backup_notification(result, date, database, backup_path, notification_level)
-            return if @slack_secret.nil? || @slack_channel.nil?
-            return if notification_level == 'error' && result
-            uri = URI.parse("#{@slack_base_url}chat.postMessage")
-            http = Net::HTTP.new(uri.host, uri.port)
-            http.use_ssl = true
-            request = Net::HTTP::Post.new(uri.request_uri, initHeader = {'Content-Type' =>'application/json', 'Authorization' => 'Bearer ' + @slack_secret})
-            message_one = "Backup of #{database} successfully finished at #{Time.now}"
-            message_two = "Backup path:\`#{backup_path}/#{database}_#{date}.dump\`"
-            data = {
-                channel: @slack_channel,
-                blocks: [
-                    {
-                        type: 'header',
-                        text: {
-                            type: 'plain_text',
-                            text: ENV['DEFAULT_URL'] || "#{database} Backup",
-                            emoji: true
-                        }
-                    },
-                    {
-                        type: 'section',
-                        text: {
-                            type: 'mrkdwn',
-                            text: result ? "#{message_one}\n#{message_two}" : "Backup of #{database} failed at #{Time.now}"
-                        }
-                    }
-                ]
-            }
-            request.body = data.to_json
-            begin
-             response = JSON.parse(http.request(request).body)
-             if response['ok'] == false
-                raise Notification::Error, response['error']
-             end
-             response
-            rescue => e
-                puts "Slack error: \n\t#{e.message}"
-            end
+        response
+      rescue Notification::Error => e
+        puts "Slack error: \n\t#{e.message}"
+      end
+    end
+
+    def backup_notification(result, title, content, notification_level)
+      return if @slack_secret.nil? || @slack_channel.nil?
+      return if notification_level == 'error' && result
+
+      begin
+        res = @conn.post('chat.postMessage') do |req|
+          req.body = {
+            channel: @slack_channel,
+            blocks: [
+              {
+                type: 'header',
+                text: {
+                  type: 'plain_text',
+                  text: title || "#{Rails.env} Message",
+                  emoji: true
+                }
+              },
+              {
+                type: 'section',
+                text: {
+                  type: 'mrkdwn',
+                  text: content || 'No content'
+                }
+              }
+            ]
+          }.to_json
         end
+        response = JSON.parse(res.body)
+        raise Notification::Error, response['error'] if response['ok'] == false
+
+        response
+      rescue Notification::Error => e
+        puts "Slack error: \n\t#{e.message}"
+      end
     end
+  end
 end

data/lib/capistrano/ops/notification/webhook.rb

@@ -1,40 +1,47 @@
+# frozen_string_literal: true
+
 module Notification
-    class Webhook
-        require 'uri'
-        require 'net/http'
-        require 'net/https'
-        require 'openssl'
-        require 'json'
-
-        def initialize
-            @webhook_url = ENV['WEBHOOK_URL']
-            @secret = ENV['WEBHOOK_SECRET']
-        end
-        
-        def generate_signature(payload_body)
-            "md5=#{OpenSSL::HMAC.hexdigest('md5', ENV['WEBHOOK_SECRET'], payload_body)}"
-        end
+  class Webhook
+    require 'faraday'
+    require 'openssl'
+    require 'json'
 
-        def backup_notification(result, date, database, backup_path, notification_level)
-            return if @webhook_url.nil? || @secret.nil?
-            return if result && ENV['NOTIFICATION_LEVEL'] == 'error'
-            data = {
-                domain: ENV['DEFAULT_URL'] || "#{database} Backup",
-                backupPath: result ? backup_path : nil,
-                backupDate: date,
-            }.to_json
-            
-            uri = URI.parse(@webhook_url)
-            https = Net::HTTP.new(uri.host, uri.port)
-            https.use_ssl = uri.scheme == "https"
-            request = Net::HTTP::Post.new(uri.path.empty? ? "/" : uri.path, initHeader = {'Content-Type' =>'application/json', 'x-hub-signature' => generate_signature("#{data}")})
-            request.body = "#{data}"
-            begin
-                response = https.request(request)
-                response.to_hash
-            rescue => e
-                puts "Webhook error: \n\t#{e.message}"
-            end
+    def initialize
+      @webhook_url = ENV['WEBHOOK_URL']
+      @secret = ENV['WEBHOOK_SECRET']
+      @conn = Faraday.new(url: @webhook_url) do |faraday|
+        faraday.headers['Content-Type'] = 'application/json'
+      end
+    end
+
+    def generate_signature(payload_body)
+      "md5=#{OpenSSL::HMAC.hexdigest('md5', ENV['WEBHOOK_SECRET'], payload_body)}"
+    end
+
+    def backup_notification(result, webhook_data, _notification_level)
+      return if @webhook_url.nil? || @secret.nil?
+      return if result && notification_level == 'error'
+
+      @date = webhook_data[:date]
+      @database = webhook_data[:database]
+      @backup_path = webhook_data[:backup_path]
+
+      @data = {
+        domain: ENV['DEFAULT_URL'] || "#{@database} Backup",
+        backupPath: result ? @backup_path : nil,
+        backupDate: @date
+      }.to_json
+
+      begin
+        @response = @conn.post do |req|
+          req.headers['x-hub-signature'] = generate_signature(@data.to_s)
+          req.body = @data
         end
+
+        @response.to_hash
+      rescue StandardError => e
+        puts "Webhook error: \n\t#{e.message}"
+      end
     end
-end
+  end
+end

data/lib/capistrano/ops/notification.rb

@@ -1,7 +1,9 @@
+# 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
+  class Error < StandardError; end
+end

data/lib/capistrano/ops/railtie.rb

@@ -12,4 +12,4 @@ module Capistrano
       end
     end
   end
-end
+end

data/lib/capistrano/ops/tasks/pg/dump.rake

@@ -2,38 +2,71 @@
 
 # rubocop:disable Metrics/BlockLength
 namespace :pg do
-  default_backup_path = Rails.env.development? ? 'tmp/backups' : '../../shared/backups'
-  database = Rails.configuration.database_configuration[Rails.env]['database']
-  username = Rails.configuration.database_configuration[Rails.env]['username']
-  password = Rails.configuration.database_configuration[Rails.env]['password']
-  hostname = Rails.configuration.database_configuration[Rails.env]['host']
-  portnumber = Rails.configuration.database_configuration[Rails.env]['port']
-  backup_path = Rails.root.join(default_backup_path).to_s
+  @database = Rails.configuration.database_configuration[Rails.env]['database']
+  @username = Rails.configuration.database_configuration[Rails.env]['username']
+  @password = Rails.configuration.database_configuration[Rails.env]['password']
+  @hostname = Rails.configuration.database_configuration[Rails.env]['host']
+  @portnumber = Rails.configuration.database_configuration[Rails.env]['port']
+  @backup_path = Rails.root.join(Rails.env.development? ? 'tmp/backups' : '../../shared/backups').to_s
   backups_enabled = Rails.env.production? || ENV['BACKUPS_ENABLED'] == 'true'
-  
+  external_backup = Rails.env.production? || ENV['EXTERNAL_BACKUP_ENABLED'] == 'true'
   task :dump do
-    api = Notification::Api.new
-    date = Time.now.to_i
-    user = username.present? ? " -U #{username}" : ''
-    host = hostname.present? ? " -h #{hostname}" : ''
-    port = portnumber.present? ? " -p #{portnumber}" : ''
-    # rubocop:disable Layout/LineLength
-    dump_cmd = "export PGPASSWORD='#{password}' && cd #{backup_path} && pg_dump -Fc -d #{database}#{user}#{host}#{port} > #{database}_#{date}.dump"
-    # rubocop:enable Layout/LineLength
-    if backups_enabled
-      system "mkdir -p #{backup_path}" unless Dir.exist?(backup_path)
-      result = system(dump_cmd)
-      api.send_backup_notification(result, date, database, backup_path)
-      # Notification::Slack.new.backup_notification(result, date, database, backup_path)
+    unless backups_enabled
+      puts 'dump: Backups are disabled'
+      exit(0)
     end
-    if backups_enabled
-      # rubocop:disable Layout/LineLength
-      p result ? "Backup created: #{backup_path}/#{database}_#{date}.dump" : "Backup failed, created empty file at #{backup_path}/#{database}_#{date}.dump"
-      system "rm #{backup_path}/#{database}_#{date}.dump" unless result
-    # rubocop:enable Layout/LineLength
+
+    notification = Notification::Api.new
+    commandlist = dump_cmd
+
+    system "mkdir -p #{@backup_path}" unless Dir.exist?(@backup_path)
+
+    result = system(commandlist.join(' && '))
+
+    if ENV['BACKUP_PROVIDER'].present? && external_backup && result
+      puts "Uploading #{@filename} to #{ENV['BACKUP_PROVIDER']}..."
+      provider = Backup::Api.new
+      begin
+        provider.upload("#{@backup_path}/#{@filename}", @filename.to_s)
+        puts "#{@filename} uploaded to #{ENV['BACKUP_PROVIDER']}"
+      rescue StandardError => e
+        puts "#{@filename} upload failed: #{e.message}"
+      end
+    end
+    notification.send_backup_notification(result, title, content(result), { date: @date, database: @database, backup_path: @backup_path })
+    puts result ? "Backup created: #{@backup_path}/#{@filename}" : 'Backup failed removing dump file'
+    system "rm #{@backup_path}/#{@filename}" unless result
+  end
+
+  def title
+    ENV['DEFAULT_URL'] || "#{Rails.env} Backup"
+  end
+
+  def content(result)
+    messages = []
+    if result
+      messages << "Backup of #{@database} successfully finished at #{Time.now}"
+      messages << "Backup path:\`#{@backup_path}/#{@filename}\`"
     else
-      p 'dump: Backups are disabled'
+      messages << "Backup of #{@database} failed at #{Time.now}"
     end
+    messages.join("\n")
+  end
+
+  def dump_cmd
+    @date = Time.now.to_i
+    options = []
+    options << " -d #{@database}" if @database.present?
+    options << " -U #{@username}" if @username.present?
+    options << " -h #{@hostname}" if @hostname.present?
+    options << " -p #{@portnumber}" if @portnumber.present?
+
+    @filename = "#{@database}_#{@date}.dump"
+
+    commandlist = []
+    commandlist << "export PGPASSWORD='#{@password}'"
+    commandlist << "cd #{@backup_path}"
+    commandlist << "pg_dump -Fc #{options.join('')} > #{@filename}"
   end
 end
 # rubocop:enable Metrics/BlockLength

data/lib/capistrano/ops/tasks/pg/remove_old_dumps.rake

@@ -1,19 +1,58 @@
 # frozen_string_literal: true
 
+require 'rake'
 namespace :pg do
-  default_backup_path = Rails.env.development? ? 'tmp/backups' : '../../shared/backups'
-  database = Rails.configuration.database_configuration[Rails.env]['database']
-
-  backup_path = Rails.root.join(default_backup_path).to_s
+  @backup_path = Rails.root.join(Rails.env.development? ? 'tmp/backups' : '../../shared/backups').to_s
+  @database = Rails.configuration.database_configuration[Rails.env]['database']
+  @env_local_no = ENV['NUMBER_OF_LOCAL_BACKUPS']
+  @env_external_no = ENV['NUMBER_OF_EXTERNAL_BACKUPS']
+  @total_local_backups_no = (@env_local_no || ENV['NUMBER_OF_BACKUPS'] || 7).to_i
+  @total_external_backups_no = (@env_external_no || ENV['NUMBER_OF_BACKUPS'] || 7).to_i
   backups_enabled = Rails.env.production? || ENV['BACKUPS_ENABLED'] == 'true'
+  external_backup = Rails.env.production? || ENV['EXTERNAL_BACKUP_ENABLED'] == 'true'
 
   task :remove_old_dumps do
-    bash_regex = "'#{database}.{0,}\.dump'"
-    total_backups_no = ENV['NUMBER_OF_BACKUPS'] || 1
-    # rubocop:disable Layout/LineLength
-    cmd = "cd #{backup_path} && ls -lt | grep -E -i #{bash_regex} | tail -n +#{total_backups_no.to_i + 1} | awk '{print $9}'|xargs rm -rf"
-    # rubocop:enable Layout/LineLength
-    system(cmd) if backups_enabled
-    p backups_enabled ? 'Old backups removed' : 'remove_old_dumps: Backups are disabled'
+    bash_regex = "'#{@database}.{0,}\.dump'"
+
+    unless backups_enabled
+      puts 'remove_old_dumps: Backups are disabled'
+      exit(0)
+    end
+    unless @total_local_backups_no.positive?
+      puts "remove_old_dumps: No local cleanup because option '#{if @env_local_no
+                                                                   'NUMBER_OF_LOCAL_BACKUPS='
+                                                                 else
+                                                                   'NUMBER_OF_BACKUPS='
+                                                                 end}#{@total_local_backups_no}' sets unlimited backups"
+
+    end
+
+    commandlist = [
+      "cd #{@backup_path} && ls -lt ",
+      "grep -E -i #{bash_regex} ",
+      "tail -n +#{@total_local_backups_no + 1} ",
+      "awk '{print $9}' ",
+      'xargs rm -rf'
+    ]
+
+    system(commandlist.join(' | '))
+
+    if ENV['BACKUP_PROVIDER'].present? && external_backup
+      unless @total_external_backups_no.positive?
+        puts "remove_old_dumps: No external cleanup because option '#{if @env_external_no
+                                                                        'NUMBER_OF_EXTERNAL_BACKUPS='
+                                                                      else
+                                                                        'NUMBER_OF_BACKUPS='
+                                                                      end}#{@total_external_backups_no}' sets unlimited backups"
+        exit(0)
+      end
+      provider = Backup::Api.new
+      begin
+        result = provider.remove_old_backups(@database, @total_external_backups_no)
+      rescue StandardError => e
+        puts "remove_old_dumps failed: #{e.message}"
+      end
+      puts 'remove_old_dumps finished' if result
+    end
   end
 end

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

@@ -0,0 +1,66 @@
+# frozen_string_literal: true
+
+# rubocop:disable Metrics/BlockLength
+namespace :storage do
+  @backup_path = Rails.root.join(Rails.env.development? ? 'tmp/backups' : '../../shared/backups').to_s
+  @storage_path = Rails.root.join(Rails.env.development? ? 'storage' : '../../shared/storage').to_s
+  backups_enabled = Rails.env.production? || ENV['BACKUPS_ENABLED'] == 'true'
+  external_backup = Rails.env.production? || ENV['EXTERNAL_BACKUP_ENABLED'] == 'true'
+
+  desc 'backup storage'
+  task :backup do
+    unless backups_enabled
+      puts 'storage: Backups are disabled'
+      exit(0)
+    end
+    notification = Notification::Api.new
+
+    date = Time.now.to_i
+    @filename = "storage_#{date}.tar.gz"
+    FileUtils.mkdir_p(@backup_path) unless Dir.exist?(@backup_path)
+    result = system "tar -zcf #{@backup_path}/#{@filename} -C #{@storage_path} ."
+    FileUtils.rm_rf("#{@backup_path}/#{filename}") unless result
+    puts result ? "Backup created: #{@backup_path}/#{@filename} (#{size_str(File.size("#{@backup_path}/#{@filename}"))})" : 'Backup failed removing dump file'
+
+    if ENV['BACKUP_PROVIDER'].present? && external_backup && result
+      puts "Uploading #{@filename} to #{ENV['BACKUP_PROVIDER']}..."
+      provider = Backup::Api.new
+      begin
+        provider.upload("#{@backup_path}/#{@filename}", @filename.to_s)
+        puts "#{@filename} uploaded to #{ENV['BACKUP_PROVIDER']}"
+      rescue StandardError => e
+        puts "#{@filename} upload failed: #{e.message}"
+      end
+    end
+    notification.send_backup_notification(result, title, message(result), { date: date, backup_path: @backup_path, database: 'storage' })
+  end
+
+  def title
+    ENV['DEFAULT_URL'] || "#{Rails.env} Backup"
+  end
+
+  def message(result)
+    messages = []
+    if result
+      messages << "Backup of storage folder successfully finished at #{Time.now}"
+      messages << "Backup path:\`#{@backup_path}/#{@filename}\`"
+    else
+      messages << "Backup of storage folder failed at #{Time.now}"
+    end
+    messages.join("\n")
+  end
+
+  def size_str(size)
+    case size
+    when 0..1024
+      "#{size} B"
+    when 1024..1024 * 1024
+      "#{size / 1024} KB"
+    when 1024 * 1024..1024 * 1024 * 1024
+      "#{size / 1024 / 1024} MB"
+    when 1024 * 1024 * 1024..1024 * 1024 * 1024 * 1024
+      "#{size / 1024 / 1024 / 1024} GB"
+    end
+  end
+end
+# rubocop:enable Metrics/BlockLength

data/lib/capistrano/ops/tasks/storage/remove_old_backups.rake

@@ -0,0 +1,58 @@
+# frozen_string_literal: true
+
+require 'rake'
+namespace :storage do
+  backup_path = Rails.root.join(Rails.env.development? ? 'tmp/backups' : '../../shared/backups').to_s
+  backups_enabled = Rails.env.production? || ENV['BACKUPS_ENABLED'] == 'true'
+  external_backup = Rails.env.production? || ENV['EXTERNAL_BACKUP_ENABLED'] == 'true'
+
+  @env_local_no = ENV['NUMBER_OF_LOCAL_BACKUPS']
+  @env_external_no = ENV['NUMBER_OF_EXTERNAL_BACKUPS']
+  @total_local_backups_no = (@env_local_no || ENV['NUMBER_OF_BACKUPS'] || 7).to_i
+  @total_external_backups_no = (@env_external_no || ENV['NUMBER_OF_BACKUPS'] || 7).to_i
+  desc 'remove old storage backups'
+  task :remove_old_backups do
+    bash_regex = "'storage_.{0,}\.tar.gz'"
+
+    unless backups_enabled
+      puts 'remove_old_backups: Backups are disabled'
+      exit(0)
+    end
+
+    unless @total_local_backups_no.positive?
+      puts "remove_old_backups: No local cleanup because option '#{if @env_local_no
+                                                                     'NUMBER_OF_LOCAL_BACKUPS='
+                                                                   else
+                                                                     'NUMBER_OF_BACKUPS='
+                                                                   end}#{@total_local_backups_no}' sets unlimited backups"
+    end
+
+    commandlist = [
+      "cd #{backup_path} && ls -lt ",
+      "grep -E -i #{bash_regex} ",
+      "tail -n +#{@total_local_backups_no + 1} ",
+      "awk '{print $9}' ",
+      'xargs rm -rf'
+    ]
+
+    system(commandlist.join(' | '))
+
+    if ENV['BACKUP_PROVIDER'].present? && external_backup
+      unless @total_external_backups_no.positive?
+        puts "remove_old_backups: No external cleanup because option '#{if @env_external_no
+                                                                          'NUMBER_OF_EXTERNAL_BACKUPS='
+                                                                        else
+                                                                          'NUMBER_OF_BACKUPS='
+                                                                        end}#{@total_external_backups_no}' sets unlimited backups"
+        exit(0)
+      end
+      provider = Backup::Api.new
+      begin
+        result = provider.remove_old_backups('storage_', @total_external_backups_no)
+      rescue StandardError => e
+        puts "remove_old_backups failed: #{e.message}"
+      end
+      puts 'remove_old_backups finished' if result
+    end
+  end
+end

data/lib/capistrano/ops/version.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
+
 module Capistrano
   module Ops
-    VERSION = '0.2.2'
+    VERSION = '0.2.4'
   end
 end