solid_backup 0.2.2 → 0.4.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: '09416cd05590f787149f5de85fd0094cb124edeebd4a86a41bc943c1c3ea40bb'
-  data.tar.gz: 31565779742aef8295c71134d01f0f78eaf578950800ca7d4f62f612512eafc6
+  metadata.gz: dd198b0749b8c0ec8bbbf9371c95c95e3bf7967b3c76353b6bc8af310acbd160
+  data.tar.gz: 6c22706156961bcf44051d1023f6e5b2c50e4e02607a8b87f0dc6b774053963c
 SHA512:
-  metadata.gz: 427730d383e49058a091bc569950f8ea857aa3d135d6b5a2815aad687662a09fa7dcf3a4a3031e0ffaa7975f4a3920c09666244fa7a6a55aa8ae52e01d400469
-  data.tar.gz: 94306f1e4b34f84e2fa516d905187c6b74290dd33f7476704cdd6d8040514b91aaa49859c0778b2fd7fbeacd5c7fe4671ab22a3f0d9163ef96b88df87a580709
+  metadata.gz: 2fdd803df8a709d66657b09bec4b49f27a94cc593a95ad27bb82daa1dd812391fb0e71a755124cdb3833c24fd10086b135b66f26665440c4a3d258c39110973d
+  data.tar.gz: 40649b13dfeacc3fc4db7c159ae017b0d2034e7075883ce4ad4bb0f1dc48b51ca4db9b62459898134477dede39c653590f095565aa587f4f3807cd52926aad03

data/CHANGELOG.md

@@ -1,5 +1,18 @@
 # Solid Backup
 
+## 0.4.0
+
+- Add backup compression support via the `compressor:` option; currently
+  `SolidBackup::Compressor::Gzip` is the only supported value.
+
+## 0.3.0
+
+- `destination` is the directory where backup files will be placed, not a
+  %-encoded template.
+- New `expiration:` option can be set to determine backup expiration policy;
+  currently only `SolidBackup::Expiration::Age.new(maximum: ...)` and
+  `SolidBackup::Expiration::None.new` are supported.
+
 ## 0.2.2
 
 - Don't call `SolidBackup` too early to avoid errors caused by Rails not being

data/README.md

@@ -28,11 +28,14 @@ will lack backups due to omission. There are three database backup modes:
 
 Modes other than `SolidBackup::Backup::None` take the following parameters:
 
-- `destination` - a `strftime` template used to generate backup file names; the
-                  directory under which the files are placed must already exist
-                  and be writeable.
+- `destination` - the directory where backup files will be held; it must already
+                  exist and be writeable.
 - `interval_in_minutes` - the number of minutes to the beginning of the next
                           backup after the previous one finished.
+- `expiration` - backup expiration policy; expired backups are automatically
+                 removed.
+- `compressor` - backup compression policy; `nil` be default which turns
+                 compression off, but can be set to SolidBackup::Compressor::Gzip.
 
 Additionally, `SolidBackup::Backup::API` takes the following parameters:
 
@@ -52,10 +55,22 @@ SolidBackup.configure do |config|
     # Back up the primary database using the SQLite backup API.
     production.backup "primary",
                       SolidBackup::Backup::API,
-                      destination: "storage/backups/primary_%Y%m%dT%H%M%S.sqlite3",
-                      interval_in_minutes: 15, # Start the next backup 15 minutes after the previous one.
-                      step: 100,               # Back up in 100-page increments.
-                      wait: 0.1                # Wait 0.1 seconds if a lock interrupts a backup step.
+                      destination: "storage/backups",
+
+                      # Start the next backup 15 minutes after the previous one.
+                      interval_in_minutes: 15,
+
+                      # Back up in 100-page increments.
+                      step: 100,
+
+                      # Wait 0.1 seconds if a lock interrupts a backup step.
+                      wait: 0.1,
+
+                      # Remove backups older than 30 days.
+                      expiration: SolidBackup::Expiration::Age.new(maximum: 30.days),
+
+                      # Compress backups using gzip.
+                      compressor: SolidBackup::Compressor::Gzip
 
     # Don't back up the cache database.
     production.backup "cache", SolidBackup::Backup::None
@@ -63,8 +78,16 @@ SolidBackup.configure do |config|
     # Back up the queue database using VACUUM INTO.
     production.backup "queue",
                       SolidBackup::Backup::VacuumInto,
-                      destination: "storage/backups/queue_%Y%m%dT%H%M%S.sqlite3",
-                      interval_in_minutes: 60 # Start the next backup 60 minutes after the previous one.
+                      destination: "storage/backups",
+
+                      # Start the next backup 60 minutes after the previous one.
+                      interval_in_minutes: 60,
+
+                      # Remove backups older than 12 hours.
+                      expiration: SolidBackup::Expiration::Age.new(maximum: 12.hours),
+
+                      # Don't compress backups. This is the default setting.
+                      compressor: nil
   end
 end
 ```

data/lib/solid_backup/backup/api.rb

@@ -13,9 +13,9 @@ class SolidBackup::Backup::API < SolidBackup::Backup
   def do_perform(backup_path)
     with_connection do |connection|
       source = connection.raw_connection
-      destination = SQLite3::Database.new(backup_path)
+      target = SQLite3::Database.new(backup_path)
 
-      backup = SQLite3::Backup.new(destination, "main", source, "main")
+      backup = SQLite3::Backup.new(target, "main", source, "main")
 
       loop do
         result = backup.step(step)
@@ -32,7 +32,7 @@ class SolidBackup::Backup::API < SolidBackup::Backup
       end
 
       backup.finish
-      destination.close
+      target.close
     end
   end
 end

data/lib/solid_backup/backup/none.rb

@@ -7,19 +7,19 @@
 # - destination and interval_in_minutes - to allow nil values
 class SolidBackup::Backup::None < SolidBackup::Backup
   def initialize(database:)
-    super(database:, destination: nil, interval_in_minutes: 0)
+    super(database:, destination: nil, interval_in_minutes: 0, expiration: nil, compressor: nil)
   end
 
   def tick
   end
 
-  def perform
-  end
-
   private
 
   attr_writer :destination, :interval_in_minutes
 
+  def perform
+  end
+
   def do_perform(backup_path)
   end
 end

data/lib/solid_backup/backup.rb

@@ -4,10 +4,12 @@ module SolidBackup
   class Backup
     attr_reader :database
 
-    def initialize(database:, destination:, interval_in_minutes:)
+    def initialize(database:, destination:, interval_in_minutes:, expiration:, compressor:)
       self.database = database
       self.destination = destination
       self.interval_in_minutes = interval_in_minutes
+      self.expiration = expiration
+      self.compressor = compressor
 
       reset_countdown
     end
@@ -19,23 +21,40 @@ module SolidBackup
 
       if countdown <= 0
         perform
+        remove_expired_backups
         reset_countdown
       end
     end
 
+    private
+
+    attr_accessor :countdown, :expiration, :compressor
+    attr_writer :database
+    attr_reader :destination, :interval_in_minutes
+
     def perform
       ActiveSupport::Notifications.instrument("backup.solid_backup", database:) do
         lock do
-          do_perform(Time.now.utc.strftime(destination.to_s))
+          backup_path = Pathname(Time.now.utc.strftime((destination / file_name_pattern).to_s))
+          do_perform(backup_path)
+
+          next if compressor.nil?
+
+          compressor.compress(backup_path)
+          backup_path.unlink
         end
       end
     end
 
-    private
-
-    attr_accessor :countdown
-    attr_writer :database
-    attr_reader :destination, :interval_in_minutes
+    def remove_expired_backups
+      files = destination.children.select(&:file?)
+      expiration.select_expired(files) do |pathname|
+        Time.strptime(pathname.basename.to_s, file_name_pattern)
+      rescue ArgumentError
+      end.each do |pathname|
+        pathname.unlink
+      end
+    end
 
     def interval_in_minutes=(value)
       if !value.is_a?(Integer) || value <= 0
@@ -49,17 +68,16 @@ module SolidBackup
 
     def destination=(value)
       value = Pathname(value)
-      directory = value.dirname
 
-      if !directory.directory?
-        raise "invalid backup configuration for #{database}: destination directory #{directory} must exist"
+      if !value.directory?
+        raise "invalid backup configuration for #{database}: destination directory #{value} must exist"
       end
 
-      test_path = directory / "solid_backup.txt"
+      test_path = value / "solid_backup.txt"
       begin
         test_path.write("Solid Backup Test")
       rescue Errno::EACCES
-        raise "invalid backup configuration for #{database}: destination directory #{directory} must be writeable"
+        raise "invalid backup configuration for #{database}: destination directory #{value} must be writeable"
       ensure
         test_path.unlink
       end
@@ -79,10 +97,14 @@ module SolidBackup
       ActiveRecord::Base.connection_handler.establish_connection(database.to_sym)
     end
 
+    def file_name_pattern
+      "#{database}_%Y%m%dT%H%M%S%Z.sqlite3"
+    end
+
     delegate :with_connection, to: :connection_pool
 
     def lock
-      path = destination.dirname / ".solid_backup.#{database}.lock"
+      path = destination / ".solid_backup.#{database}.lock"
 
       File.open(path, File::RDWR | File::CREAT) do |f|
         if f.flock(File::LOCK_EX | File::LOCK_NB)

data/lib/solid_backup/compressor.rb

@@ -0,0 +1,14 @@
+module SolidBackup::Compressor
+  module Gzip
+    def self.compress(source_path)
+      target_path = "#{source_path}.gz"
+      source_path = Pathname(source_path)
+
+      Zlib::GzipWriter.open(target_path) do |gzip|
+        gzip.mtime = source_path.mtime
+        gzip.orig_name = source_path.basename.to_s
+        gzip.write(source_path.binread)
+      end
+    end
+  end
+end

data/lib/solid_backup/expiration.rb

@@ -0,0 +1,25 @@
+module SolidBackup::Expiration
+  class None
+    def select_expired(pathnames)
+      []
+    end
+  end
+
+  class Age
+    def initialize(maximum:)
+      self.maximum = maximum
+    end
+
+    def select_expired(pathnames)
+      threshold = maximum.ago.utc
+      pathnames.select do |pathname|
+        timestamp = yield(pathname)
+        timestamp && timestamp < threshold
+      end
+    end
+
+    private
+
+    attr_accessor :maximum
+  end
+end

data/lib/solid_backup/generators/install_generator.rb

@@ -15,8 +15,10 @@ module SolidBackup
             <<~CODE.chomp
               production.backup #{db_config.name.inspect},
                                 SolidBackup::Backup::API,
-                                destination: "storage/backups/#{db_config.name}_%Y%m%dT%H%M%S.sqlite3",
+                                destination: "storage/backups",
                                 interval_in_minutes: 60,
+                                expiration: SolidBackup::Expiration::Age.new(maximum: 24.hours),
+                                compressor: SolidBackup::Compressor::Gzip,
                                 step: 100,
                                 wait: 0.1
             CODE

data/lib/solid_backup/version.rb

@@ -1,3 +1,3 @@
 module SolidBackup
-  VERSION = "0.2.2"
+  VERSION = "0.4.0"
 end

data/lib/solid_backup.rb

@@ -6,6 +6,8 @@ require "solid_backup/backup/api"
 require "solid_backup/backup/vacuum_into"
 require "solid_backup/configuration"
 require "solid_backup/configuration/environment"
+require "solid_backup/expiration"
+require "solid_backup/compressor"
 require "solid_backup/version"
 require "solid_backup/railtie"
 

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: solid_backup
 version: !ruby/object:Gem::Version
-  version: 0.2.2
+  version: 0.4.0
 platform: ruby
 authors:
 - Greg Navis
@@ -108,8 +108,10 @@ files:
 - lib/solid_backup/backup/api.rb
 - lib/solid_backup/backup/none.rb
 - lib/solid_backup/backup/vacuum_into.rb
+- lib/solid_backup/compressor.rb
 - lib/solid_backup/configuration.rb
 - lib/solid_backup/configuration/environment.rb
+- lib/solid_backup/expiration.rb
 - lib/solid_backup/generators/install_generator.rb
 - lib/solid_backup/railtie.rb
 - lib/solid_backup/version.rb
@@ -134,7 +136,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 4.0.10
+rubygems_version: 4.0.20
 specification_version: 4
 summary: Solid Backup provides simple backups for SQLite databases in Ruby on Rails
   apps.