capistrano-ops 1.0.4 → 1.0.8

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 6028f991e964a7ce6f029c3878b1c36b322802df80013019de85c1f9f9220f9f
-  data.tar.gz: 1664aea997e5db3daa236ea04758cb68bd3b34262e29faa90fa41564b2e88aeb
+  metadata.gz: cb9a8459b0906318eb8149333da576558e4f232c35ca3bd453756a1ba4031036
+  data.tar.gz: e6e1342c6a847e029583db4824b1f69e63b687db53f42ce3f6e4e933d5d7aa27
 SHA512:
-  metadata.gz: 99aba98f09eee78b13851eec6ad35dd142fe1252903af6f3c5faf36260c02c693ef6245eddef8dfdefaac9965c9836b08de2620bf449716e47ad096380e26d3b
-  data.tar.gz: 69d303c90aad93e679ac797d90bf759f615e82431ef9a39008fad8c430aa66938cf1fd2b14dfb4249bc9c17bd8fbdf76786c00d0a1b226b3c588fe650024b1e8
+  metadata.gz: b8e3b49f6fc1fbc179713f06ec82a06b3e6bc953b256ad1f5e6b564ff47a28c9d3705e4e4b8add425de28aea1e0d5830fa055b42c9a6bc46d2244f5e645d3fb3
+  data.tar.gz: 19516277d0a171017ad63b526f602a47056ab469defe6d6b3e5292ffe9a1a0221ed8dedd5e2012d49ea4dca5c233eb283d11fd05df6111a723a9bf13e48d5867

data/capistrano-ops.gemspec

@@ -20,12 +20,12 @@ Gem::Specification.new do |s|
   s.require_paths = ['lib']
 
   s.required_ruby_version = '>= 2.7.0', '< 3.3.0'
-  s.add_dependency 'aws-sdk-s3', '~> 1.128'
+  s.add_dependency 'aws-sdk-s3', '~> 1.175'
   s.add_dependency 'faraday'
   s.add_dependency 'nokogiri'
   s.add_dependency 'rails'
   s.add_development_dependency 'bundler', '~> 2.4.12'
-  s.add_development_dependency 'rake', '~> 10.0'
+  s.add_development_dependency 'rake', '~> 12.3'
   s.add_development_dependency 'rubocop', '~> 1.56.2' # rubocop ruby
   s.add_development_dependency 'rubocop-performance', '~> 1.19.0' # speed up rubocop
 end

data/lib/capistrano/ops/rails/lib/backup/api.rb

@@ -9,11 +9,11 @@ module Backup
       self.provider_config = provider_config
     end
 
-    def upload(backup_file, filename)
+    def upload(backup_file, filename, type = 'file')
       case backup_provider
       when 's3'
         s3 = Backup::S3.new(**provider_config)
-        s3.upload(backup_file, filename)
+        s3.upload_stream(backup_file, filename, type)
       when 'scp'
         p 'SCP backup not implemented yet'
       when 'rsync'

data/lib/capistrano/ops/rails/lib/backup/s3.rb

@@ -2,10 +2,15 @@
 
 module Backup
   require 'aws-sdk-s3'
+  require 'rubygems/package'
+  require 'zlib'
+  require 'find'
   require 'capistrano/ops/rails/lib/backup/s3_helper'
+
   class S3
     include Backup::S3Helper
-    attr_accessor :endpoint, :region, :access_key_id, :secret_access_key, :s3_resource
+
+    attr_accessor :endpoint, :region, :access_key_id, :secret_access_key, :s3_resource, :s3_client
 
     def initialize(endpoint: ENV['S3_BACKUP_ENDPOINT'], region: ENV['S3_BACKUP_REGION'], access_key_id: ENV['S3_BACKUP_KEY'],
                    secret_access_key: ENV['S3_BACKUP_SECRET'])
@@ -18,10 +23,10 @@ module Backup
         access_key_id: access_key_id,
         secret_access_key: secret_access_key,
         force_path_style: true
-
       }
       configuration[:endpoint] = endpoint unless endpoint.nil?
       self.s3_resource = Aws::S3::Resource.new(configuration)
+      self.s3_client = Aws::S3::Client.new(configuration)
     end
 
     def upload(backup_file, key)
@@ -34,6 +39,226 @@ module Backup
       'File uploaded to S3'
     end
 
+    def upload_stream(backup_file, key, type)
+      if type == 'folder'
+        upload_folder_as_tar_gz_stream(backup_file, key)
+      else
+        upload_file_as_stream(backup_file, key)
+      end
+    end
+
+    # rubocop:disable Metrics/MethodLength
+    def upload_file_as_stream(file_path, key)
+      bucket = ENV['S3_BACKUP_BUCKET']
+      # Calculate total size of the file to be uploaded
+      total_size = File.size(file_path)
+      chunk_size = calculate_chunk_size(total_size)
+
+      uploaded_size = 0
+
+      # Initiate multipart upload
+
+      # Upload the tar.gz data from the file in parts
+      part_number = 1
+      parts = []
+      last_logged_progress = 0
+      max_retry_time = 300 # 5 minutes in seconds
+      total_wait_time = 0
+
+      begin
+        File.open(file_path, 'rb') do |file|
+          while (part = file.read(chunk_size)) # Read calculated chunk size
+            retry_count = 0
+            begin
+              # Initiate multipart upload
+              multipart_upload ||= s3_client.create_multipart_upload(bucket: bucket, key: key)
+              part_upload = s3_client.upload_part(
+                bucket: bucket,
+                key: key,
+                upload_id: multipart_upload.upload_id,
+                part_number: part_number,
+                body: part
+              )
+              parts << { part_number: part_number, etag: part_upload.etag }
+              uploaded_size += part.size
+              part_number += 1
+
+              progress = (uploaded_size.to_f / total_size * 100).round
+              if progress >= last_logged_progress + 10
+                puts "Upload progress: #{progress}% complete"
+                last_logged_progress = progress
+              end
+            rescue StandardError => e
+              retry_count += 1
+              wait_time = 2**retry_count
+              total_wait_time += wait_time
+
+              if total_wait_time > max_retry_time
+                puts "Exceeded maximum retry time of #{max_retry_time / 60} minutes. Aborting upload."
+                raise e
+              end
+              puts "Error uploading part #{part_number}: #{e.message.split("\n").first} (Attempt #{retry_count})"
+              puts "Retry in #{wait_time} seconds"
+              sleep(wait_time) # Exponential backoff
+              puts 'Retrying upload part...'
+              retry
+            end
+          end
+        end
+
+        # Complete multipart upload
+        s3_client.complete_multipart_upload(
+          bucket: bucket,
+          key: key,
+          upload_id: multipart_upload.upload_id,
+          multipart_upload: { parts: parts }
+        )
+        puts 'Completed multipart upload'
+      rescue StandardError => e
+        # Abort multipart upload in case of error
+        s3_client.abort_multipart_upload(
+          bucket: bucket,
+          key: key,
+          upload_id: multipart_upload.upload_id
+        )
+        puts "Aborted multipart upload due to error: #{e.message}"
+        raise e
+      end
+
+      'File uploaded to S3 as tar.gz'
+    rescue StandardError => e
+      puts "Upload failed: #{e.message}"
+      raise e
+    end
+
+    def upload_folder_as_tar_gz_stream(folder_path, key)
+      bucket = ENV['S3_BACKUP_BUCKET']
+
+      # Calculate total size of the files to be uploaded
+      total_size = calculate_total_size(folder_path)
+      chunk_size = calculate_chunk_size(total_size)
+
+      # Create a pipe to stream data
+      read_io, write_io = IO.pipe
+      read_io.binmode
+      write_io.binmode
+
+      uploaded_size = 0
+
+      # Start a thread to write the tar.gz data to the pipe
+      writer_thread = start_writer_thread(folder_path, write_io)
+
+      # Upload the tar.gz data from the pipe in parts
+      part_number = 1
+      parts = []
+      last_logged_progress = 0
+      max_retry_time = 300 # 5 minutes in seconds
+      total_wait_time = 0
+
+      begin
+        while (part = read_io.read(chunk_size)) # Read calculated chunk size
+          retry_count = 0
+          begin
+            # Initiate multipart upload
+            multipart_upload ||= s3_client.create_multipart_upload(bucket: bucket, key: key)
+            part_upload = s3_client.upload_part(
+              bucket: bucket,
+              key: key,
+              upload_id: multipart_upload.upload_id,
+              part_number: part_number,
+              body: part
+            )
+            parts << { part_number: part_number, etag: part_upload.etag }
+            uploaded_size += part.size
+            part_number += 1
+
+            progress = (uploaded_size.to_f / total_size * 100).round
+            if progress >= last_logged_progress + 10
+              puts "Upload progress: #{progress}% complete"
+              last_logged_progress = progress
+            end
+          rescue StandardError => e
+            retry_count += 1
+            wait_time = 2**retry_count
+            total_wait_time += wait_time
+
+            if total_wait_time > max_retry_time
+              puts "Exceeded maximum retry time of #{max_retry_time / 60} minutes. Aborting upload."
+              raise e
+            end
+            puts "Error uploading part #{part_number}: #{e.message.split("\n").first} (Attempt #{retry_count})"
+            puts "Retry in #{wait_time} seconds"
+            sleep(wait_time) # Exponential backoff
+            puts 'Retrying upload part...'
+            retry
+          end
+        end
+
+        # Complete multipart upload
+        s3_client.complete_multipart_upload(
+          bucket: bucket,
+          key: key,
+          upload_id: multipart_upload.upload_id,
+          multipart_upload: { parts: parts }
+        )
+        puts 'Completed multipart upload'
+      rescue StandardError => e
+        # Abort multipart upload in case of error
+        if multipart_upload
+          s3_client.abort_multipart_upload(
+            bucket: bucket,
+            key: key,
+            upload_id: multipart_upload.upload_id
+          )
+        end
+        puts "Aborted multipart upload due to error: #{e.message}"
+        raise e
+      ensure
+        read_io.close unless read_io.closed?
+        writer_thread.join
+      end
+
+      'Folder uploaded to S3 as tar.gz'
+    rescue StandardError => e
+      puts "Upload failed: #{e.message}"
+      raise e
+    end
+    # rubocop:enable Metrics/MethodLength
+
+    private
+
+    def start_writer_thread(folder_path, write_io)
+      Thread.new do
+        parent_folder = File.dirname(folder_path)
+        folder_name = File.basename(folder_path)
+
+        Zlib::GzipWriter.wrap(write_io) do |gz|
+          Gem::Package::TarWriter.new(gz) do |tar|
+            Dir.chdir(parent_folder) do
+              Find.find(folder_name) do |file_path|
+                if File.directory?(file_path)
+                  tar.mkdir(file_path, File.stat(file_path).mode)
+                else
+                  mode = File.stat(file_path).mode
+                  tar.add_file_simple(file_path, mode, File.size(file_path)) do |tar_file|
+                    File.open(file_path, 'rb') do |f|
+                      while (chunk = f.read(1024 * 1024)) # Read in 1MB chunks
+                        tar_file.write(chunk)
+                      end
+                    end
+                  end
+                end
+              end
+            end
+          end
+        end
+      rescue StandardError => e
+        puts "Error writing tar.gz data: #{e.message}"
+      ensure
+        write_io.close unless write_io.closed?
+      end
+    end
+
     def remove_old_backups(basename, keep: 5)
       all_items = s3_resource.bucket(ENV['S3_BACKUP_BUCKET']).objects(prefix: basename).map do |item|
         { key: item.key, last_modified: item.last_modified }

data/lib/capistrano/ops/rails/lib/backup/s3_helper.rb

@@ -21,5 +21,21 @@ module Backup
     def get_items_by_month(all_items, month)
       all_items.select { |item| item[:last_modified].strftime('%Y-%m') == month }
     end
+
+    def calculate_total_size(folder_path)
+      total_size = 0
+      Find.find(folder_path) do |file_path|
+        total_size += File.size(file_path) unless File.directory?(file_path)
+      end
+      total_size
+    end
+
+    def calculate_chunk_size(total_size)
+      max_chunks = 10_000
+      min_chunk_size = 20 * 1024 * 1024 # 20MB
+      max_chunk_size = 105 * 1024 * 1024 # 105MB
+      chunk_size = [total_size / max_chunks, min_chunk_size].max
+      [chunk_size, max_chunk_size].min
+    end
   end
 end

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

@@ -5,9 +5,12 @@ namespace :pg do
   include PostgresHelper
 
   task :dump do
-    backup_path = configuration[:backup_path]
-    backups_enabled = configuration[:backups_enabled]
-    external_backup = configuration[:external_backup]
+    backup_path = configs[:backup_path]
+    backups_enabled = configs[:backups_enabled]
+    external_backup = configs[:external_backup]
+    database = configs[:database]
+    date = Time.now.to_i
+    filename = "#{database}_#{date}.dump"
 
     unless backups_enabled
       puts 'dump: Backups are disabled'
@@ -15,26 +18,26 @@ namespace :pg do
     end
 
     notification = Notification::Api.new
-    commandlist = dump_cmd(configuration)
+    commandlist = dump_cmd(configs)
 
     system "mkdir -p #{backup_path}" unless Dir.exist?(backup_path)
 
     result = system(commandlist)
 
     if ENV['BACKUP_PROVIDER'].present? && external_backup && result
-      puts "Uploading #{@filename} to #{ENV['BACKUP_PROVIDER']}..."
+      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']}"
+        provider.upload("#{backup_path}/#{filename}", filename.to_s, 'file')
+        puts "#{filename} uploaded to #{ENV['BACKUP_PROVIDER']}"
       rescue StandardError => e
-        puts "#{@filename} upload failed: #{e.message}"
+        puts "#{filename} upload failed: #{e.message}"
       end
     end
-    notification.send_backup_notification(result, title, content(result, { database: @database, backup_path: @backup_path, filename: @filename }),
-                                          { date: @date, backup_path: @backup_path, database: @database })
-    puts result ? "Backup created: #{@backup_path}/#{@filename} (#{size_str(File.size("#{@backup_path}/#{@filename}"))})" : 'Backup failed removing dump file'
+    notification.send_backup_notification(result, title, content(result, { database: database, backup_path: backup_path, filename: filename }),
+                                          { date: date, backup_path: backup_path, database: database })
+    puts result ? "Backup created: #{backup_path}/#{filename} (#{size_str(File.size("#{backup_path}/#{filename}"))})" : 'Backup failed removing dump file'
 
-    system "rm #{@backup_path}/#{@filename}" unless result
+    system "rm #{backup_path}/#{filename}" unless result
   end
 end

data/lib/capistrano/ops/rails/lib/tasks/pg/postgres_helper.rb

@@ -1,18 +1,18 @@
 # frozen_string_literal: true
 
 module PostgresHelper
-  def configuration
-    @configuration ||=
-      {
-        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'
-      }
+  def configs
+    @configs ||= {
+      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',
+      filename: "#{Rails.configuration.database_configuration[Rails.env]['database']}_#{Time.now.to_i}.dump"
+    }
   end
 
   def title
@@ -20,41 +20,41 @@ module PostgresHelper
   end
 
   def content(result, settings = {})
-    @database = settings[:database]
-    @backup_path = settings[:backup_path]
-    @filename = settings[:filename]
+    database = settings[:database]
+    backup_path = settings[:backup_path]
+    filename = settings[:filename]
 
     messages = []
     if result
-      messages << "Backup of #{@database} successfully finished at #{Time.now}"
-      messages << "Backup path:\`#{@backup_path}/#{@filename}\`"
+      messages << "Backup of #{database} successfully finished at #{Time.now}"
+      messages << "Backup path:\`#{backup_path}/#{filename}\`"
     else
-      messages << "Backup of #{@database} failed at #{Time.now}"
+      messages << "Backup of #{database} failed at #{Time.now}"
     end
     messages.join("\n")
   end
 
   def dump_cmd(settings = {})
-    @hostname = settings[:hostname]
-    @database = settings[:database]
-    @username = settings[:username]
-    @password = settings[:password]
-    @portnumber = settings[:portnumber]
-    @backup_path = settings[:backup_path]
+    hostname = settings[:hostname]
+    database = settings[:database]
+    username = settings[:username]
+    password = settings[:password]
+    portnumber = settings[:portnumber]
+    backup_path = settings[:backup_path]
 
-    @date = Time.now.to_i
+    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?
+    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"
+    filename = "#{database}_#{date}.dump"
 
     commandlist = []
-    commandlist << "export PGPASSWORD='#{@password}'"
-    commandlist << "cd #{@backup_path}"
-    commandlist << "pg_dump --no-acl --no-owner #{options.join('')} > #{@filename}"
+    commandlist << "export PGPASSWORD='#{password}'"
+    commandlist << "cd #{backup_path}"
+    commandlist << "pg_dump --no-acl --no-owner #{options.join('')} > #{filename}"
     commandlist.join(' && ')
   end
 

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

@@ -1,58 +1,48 @@
 # frozen_string_literal: true
 
+require_relative './storage_helper'
 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'
+  include StorageHelper
 
   desc 'backup storage'
   task :backup do
+    backup_path = configuration[:backup_path]
+    storage_path = configuration[:storage_path]
+    backups_enabled = configuration[:backups_enabled]
+    external_backup = configuration[:external_backup]
+    keep_local_backups = configuration[:keep_local_backups]
+    backup_provider = configuration[:backup_provider]
     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)
-    response = system "tar -zcf #{@backup_path}/#{@filename} -C #{@storage_path} ."
-    FileUtils.rm_rf("#{@backup_path}/#{filename}") unless response
-    puts response ? "Backup created: #{@backup_path}/#{@filename} (#{size_str(File.size("#{@backup_path}/#{@filename}"))})" : 'Backup failed removing dump file'
-
-    if ENV['BACKUP_PROVIDER'].present? && external_backup && response
-      puts "Uploading #{@filename} to #{ENV['BACKUP_PROVIDER']}..."
+    response = false
+    if keep_local_backups
+      puts "Creating backup of storage folder at #{Time.now}"
+      response = create_local_backup(@filename, storage_path, backup_path)
+    end
+    if backup_provider.present? && external_backup
+      @date = Time.now.to_i
+      @filename = "storage_#{@date}.tar.gz"
+      puts "Uploading #{@filename} to #{backup_provider}..."
       provider = Backup::Api.new
       begin
-        provider.upload("#{@backup_path}/#{@filename}", @filename.to_s)
-        puts "#{@filename} uploaded to #{ENV['BACKUP_PROVIDER']}"
+        if keep_local_backups
+          provider.upload("#{backup_path}/#{@filename}", @filename.to_s, 'file')
+        else
+          provider.upload(storage_path, @filename.to_s, 'folder')
+          response = true
+        end
+        puts "#{@filename} uploaded to #{backup_provider}" if response
       rescue StandardError => e
         puts "#{@filename} upload failed: #{e.message}"
+        response = false
       end
     end
-    notification.send_backup_notification(response, title, message(response), { date: date, backup_path: @backup_path, database: 'storage' })
-  end
-
-  def title
-    ENV['DEFAULT_URL'] || "#{Rails.env} Backup"
-  end
-
-  def message(result=false)
-    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)
-    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])
+    notification.send_backup_notification(response, title, message(response, { backup_path: backup_path, filename: @filename }),
+                                          { date: @date, backup_path: @backup_path, database: 'storage' })
   end
 end

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

@@ -8,8 +8,8 @@ namespace :storage do
   local_backup = Rails.env.production?
   local_backup = ENV['KEEP_LOCAL_STORAGE_BACKUPS'] == 'true' if ENV['KEEP_LOCAL_STORAGE_BACKUPS'].present?
 
-  @env_local_no = ENV['NUMBER_OF_LOCAL_BACKUPS'].present? ? ENV['NUMBER_OF_LOCAL_BACKUPS'] : nil
-  @env_external_no = ENV['NUMBER_OF_EXTERNAL_BACKUPS'].present? ? ENV['NUMBER_OF_EXTERNAL_BACKUPS'] : nil
+  @env_local_no = ENV['NUMBER_OF_LOCAL_BACKUPS'].presence
+  @env_external_no = ENV['NUMBER_OF_EXTERNAL_BACKUPS'].presence
   @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'

data/lib/capistrano/ops/rails/lib/tasks/storage/storage_helper.rb

@@ -0,0 +1,69 @@
+# frozen_string_literal: true
+
+module StorageHelper
+  def configuration
+    @configuration ||=
+      {
+        backup_path: path_resolver('backups'),
+        storage_path: path_resolver('storage'),
+        backups_enabled: env_or_production('BACKUPS_ENABLED'),
+        external_backup: env_or_production('EXTERNAL_BACKUP_ENABLED'),
+        keep_local_backups: env_or_production('KEEP_LOCAL_STORAGE_BACKUPS'),
+        backup_provider: ENV['BACKUP_PROVIDER']
+      }
+  end
+
+  def title
+    ENV['DEFAULT_URL'] || "#{Rails.env} Backup"
+  end
+
+  def message(result = false, settings = {})
+    @backup_path = settings[:backup_path]
+    @filename = settings[:filename]
+    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 backup_cmd(settings = {})
+    @backup_path = settings[:backup_path]
+    @date = Time.now.to_i
+    @filename = "storage_#{@date}.tar.gz"
+    FileUtils.mkdir_p(@backup_path) unless Dir.exist?(@backup_path)
+    "tar -zcf #{@backup_path}/#{@filename} -C #{settings[:storage_path]} ."
+  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
+
+  def create_local_backup(filename, storage_path, backup_path)
+    FileUtils.mkdir_p(backup_path) unless Dir.exist?(backup_path)
+    response = system(backup_cmd(backup_path: backup_path, storage_path: storage_path))
+    FileUtils.rm_rf("#{@backup_path}/#{filename}") unless response
+    puts response ? "Backup created: #{backup_path}/#{@filename} (#{size_str(File.size("#{@backup_path}/#{@filename}"))})" : 'Backup failed removing dump file'
+    response
+  end
+
+  private
+
+  def env_or_production(env_var, default: Rails.env.production?)
+    if ENV.key?(env_var)
+      ENV[env_var] == 'true'
+    else
+      default
+    end
+  end
+
+  def path_resolver(folder)
+    Rails.root.join(Rails.env.development? ? 'tmp' : '../../shared', folder).to_s
+  end
+end

data/lib/capistrano/ops/version.rb

@@ -2,6 +2,6 @@
 
 module Capistrano
   module Ops
-    VERSION = '1.0.4'
+    VERSION = '1.0.8'
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: capistrano-ops
 version: !ruby/object:Gem::Version
-  version: 1.0.4
+  version: 1.0.8
 platform: ruby
 authors:
 - Florian Crusius
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2024-08-13 00:00:00.000000000 Z
+date: 2024-12-16 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: aws-sdk-s3
@@ -16,14 +16,14 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '1.128'
+        version: '1.175'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '1.128'
+        version: '1.175'
 - !ruby/object:Gem::Dependency
   name: faraday
   requirement: !ruby/object:Gem::Requirement
@@ -86,14 +86,14 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '10.0'
+        version: '12.3'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '10.0'
+        version: '12.3'
 - !ruby/object:Gem::Dependency
   name: rubocop
   requirement: !ruby/object:Gem::Requirement
@@ -200,6 +200,7 @@ files:
 - lib/capistrano/ops/rails/lib/tasks/pg/remove_old_dumps.rake
 - lib/capistrano/ops/rails/lib/tasks/storage/backup.rake
 - lib/capistrano/ops/rails/lib/tasks/storage/remove_old_backups.rake
+- lib/capistrano/ops/rails/lib/tasks/storage/storage_helper.rb
 - lib/capistrano/ops/task_loader.rb
 - lib/capistrano/ops/version.rb
 - lib/capistrano/ops/whenever.rb