litestream 0.5.0-x86_64-linux → 0.5.1-x86_64-linux

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: b76c2f2d900ef4acecee6dda18c2347262dc50b5017228f1f9a74a9f24e7acdf
-  data.tar.gz: 3cce5e25ab5e461c9f1c7f1b721924ea7a60fd9fe7338ef212305fbf535aebf1
+  metadata.gz: 729b379a492cfd9b1105012eda88040a7c5442498c6ee83f3afac5c0d2e9b7d9
+  data.tar.gz: 30d4e5b071868893ff9ad0597b94fe2e0e32abd77fc928c736829e65b38913fa
 SHA512:
-  metadata.gz: 82e4f3a3326df997d56086f5263d64d5be93a6779d1a10f3cbc5769b64637765c58acb87967a0553d7e4ed0738c59f604daa8656b5601825ef5d033eab52b3ea
-  data.tar.gz: 92b1150f4c347fd1ff8bdce01105657e1baf88ae25b55c6badfd455bc2e8db974124a89132213bcbec5ac4c9b0185177a5c16da4cc383eff976789dcd8939326
+  metadata.gz: 8425ee62f03e72f3a4afdfefd2f05971ceb553f9b9e6bd0a97209357a457ea6c6c3b66dbaaa408af5d27f2912f8be66fc41be213dc5efc074d04ec14764d799f
+  data.tar.gz: 47916adf85f2f8ed40a1c10de77c43b800abaa10f8786c511810d30a950f6d96e4951d0251539f649b449102f6f2db476d3991614a6de2f1f84e259904a5a897

data/README.md

@@ -165,6 +165,47 @@ You can forward arguments in whatever order you like, you simply need to ensure
     Disables environment variable expansion in configuration file.
 ```
 
+### Introspection
+
+Litestream offers a handful of commands that allow you to introspect the state of your replication. The gem provides a few rake tasks that wrap these commands for you. For example, you can list the databases that Litestream is configured to replicate:
+
+```shell
+bin/rails litestream:databases
+```
+
+This will return a list of databases and their configured replicas:
+
+```
+path                                                 replicas
+/Users/you/Code/your-app/storage/production.sqlite3  s3
+```
+
+You can also list the generations of a specific database:
+
+```shell
+bin/rails litestream:generations -- --database=storage/production.sqlite3
+```
+
+This will list all generations for the specified database, including stats about their lag behind the primary database and the time range they cover.
+
+```
+name  generation        lag     start                 end
+s3    a295b16a796689f3  -156ms  2024-04-17T00:01:19Z  2024-04-17T00:01:19Z
+```
+
+Finally, you can list the snapshots available for a database:
+
+```shell
+bin/rails litestream:snapshots -- --database=storage/production.sqlite3
+```
+
+This command lists snapshots available for that specified database:
+
+```
+replica  generation        index  size     created
+s3       a295b16a796689f3  1      4645465  2024-04-17T00:01:19Z
+```
+
 ### Additional commands
 
 The rake tasks are the recommended way to interact with the Litestream utility in your Rails application or Ruby project. But, you _can_ work directly with the Litestream CLI. Since the gem installs the native executable via Bundler, the `litestream` command will be available in your `PATH`.

data/lib/litestream/commands.rb

@@ -14,106 +14,120 @@ module Litestream
     # raised when LITESTREAM_INSTALL_DIR does not exist
     DirectoryNotFoundException = Class.new(StandardError)
 
-    def self.platform
-      [:cpu, :os].map { |m| Gem::Platform.local.send(m) }.join("-")
-    end
+    # raised when a litestream command requires a database argument but it isn't provided
+    DatabaseRequiredException = Class.new(StandardError)
+
+    class << self
+      def platform
+        [:cpu, :os].map { |m| Gem::Platform.local.send(m) }.join("-")
+      end
 
-    def self.executable(exe_path: DEFAULT_DIR)
-      litestream_install_dir = ENV["LITESTREAM_INSTALL_DIR"]
-      if litestream_install_dir
-        if File.directory?(litestream_install_dir)
-          warn "NOTE: using LITESTREAM_INSTALL_DIR to find litestream executable: #{litestream_install_dir}"
-          exe_path = litestream_install_dir
-          exe_file = File.expand_path(File.join(litestream_install_dir, "litestream"))
+      def executable(exe_path: DEFAULT_DIR)
+        litestream_install_dir = ENV["LITESTREAM_INSTALL_DIR"]
+        if litestream_install_dir
+          if File.directory?(litestream_install_dir)
+            warn "NOTE: using LITESTREAM_INSTALL_DIR to find litestream executable: #{litestream_install_dir}"
+            exe_path = litestream_install_dir
+            exe_file = File.expand_path(File.join(litestream_install_dir, "litestream"))
+          else
+            raise DirectoryNotFoundException, <<~MESSAGE
+              LITESTREAM_INSTALL_DIR is set to #{litestream_install_dir}, but that directory does not exist.
+            MESSAGE
+          end
         else
-          raise DirectoryNotFoundException, <<~MESSAGE
-            LITESTREAM_INSTALL_DIR is set to #{litestream_install_dir}, but that directory does not exist.
-          MESSAGE
-        end
-      else
-        if Litestream::Upstream::NATIVE_PLATFORMS.keys.none? { |p| Gem::Platform.match_gem?(Gem::Platform.new(p), GEM_NAME) }
-          raise UnsupportedPlatformException, <<~MESSAGE
-            litestream-ruby does not support the #{platform} platform
-            Please install litestream following instructions at https://litestream.io/install
-          MESSAGE
+          if Litestream::Upstream::NATIVE_PLATFORMS.keys.none? { |p| Gem::Platform.match_gem?(Gem::Platform.new(p), GEM_NAME) }
+            raise UnsupportedPlatformException, <<~MESSAGE
+              litestream-ruby does not support the #{platform} platform
+              Please install litestream following instructions at https://litestream.io/install
+            MESSAGE
+          end
+
+          exe_file = Dir.glob(File.expand_path(File.join(exe_path, "*", "litestream"))).find do |f|
+            Gem::Platform.match_gem?(Gem::Platform.new(File.basename(File.dirname(f))), GEM_NAME)
+          end
         end
 
-        exe_file = Dir.glob(File.expand_path(File.join(exe_path, "*", "litestream"))).find do |f|
-          Gem::Platform.match_gem?(Gem::Platform.new(File.basename(File.dirname(f))), GEM_NAME)
-        end
-      end
+        if exe_file.nil? || !File.exist?(exe_file)
+          raise ExecutableNotFoundException, <<~MESSAGE
+            Cannot find the litestream executable for #{platform} in #{exe_path}
 
-      if exe_file.nil? || !File.exist?(exe_file)
-        raise ExecutableNotFoundException, <<~MESSAGE
-          Cannot find the litestream executable for #{platform} in #{exe_path}
+            If you're using bundler, please make sure you're on the latest bundler version:
 
-          If you're using bundler, please make sure you're on the latest bundler version:
+                gem install bundler
+                bundle update --bundler
 
-              gem install bundler
-              bundle update --bundler
+            Then make sure your lock file includes this platform by running:
 
-          Then make sure your lock file includes this platform by running:
+                bundle lock --add-platform #{platform}
+                bundle install
 
-              bundle lock --add-platform #{platform}
-              bundle install
+            See `bundle lock --help` output for details.
+
+            If you're still seeing this message after taking those steps, try running
+            `bundle config` and ensure `force_ruby_platform` isn't set to `true`. See
+            https://github.com/fractaledmind/litestream-ruby#check-bundle_force_ruby_platform
+            for more details.
+          MESSAGE
+        end
 
-          See `bundle lock --help` output for details.
+        exe_file
+      end
 
-          If you're still seeing this message after taking those steps, try running
-          `bundle config` and ensure `force_ruby_platform` isn't set to `true`. See
-          https://github.com/fractaledmind/litestream-ruby#check-bundle_force_ruby_platform
-          for more details.
-        MESSAGE
+      def replicate(argv = {})
+        execute("replicate", argv)
       end
 
-      exe_file
-    end
+      def restore(database, argv = {})
+        raise DatabaseRequiredException, "database argument is required for restore command, e.g. litestream:restore -- --database=path/to/database.sqlite" if database.nil?
+
+        dir, file = File.split(database)
+        ext = File.extname(file)
+        base = File.basename(file, ext)
+        now = Time.now.utc.strftime("%Y%m%d%H%M%S")
+
+        args = {
+          "-o" => File.join(dir, "#{base}-#{now}#{ext}")
+        }.merge(argv)
 
-    def self.replicate(argv = {})
-      if Litestream.configuration
-        ENV["LITESTREAM_REPLICA_BUCKET"] ||= Litestream.configuration.replica_bucket
-        ENV["LITESTREAM_ACCESS_KEY_ID"] ||= Litestream.configuration.replica_key_id
-        ENV["LITESTREAM_SECRET_ACCESS_KEY"] ||= Litestream.configuration.replica_access_key
+        execute("restore", args, database)
       end
 
-      args = {
-        "--config" => Rails.root.join("config", "litestream.yml").to_s
-      }.merge(argv).to_a.flatten.compact
+      def databases(argv = {})
+        execute("databases", argv)
+      end
 
-      command = [executable, "replicate", *args]
-      puts command.inspect
+      def generations(database, argv = {})
+        raise DatabaseRequiredException, "database argument is required for generations command, e.g. litestream:generations -- --database=path/to/database.sqlite" if database.nil?
 
-      # To release the resources of the Ruby process, just fork and exit.
-      # The forked process executes litestream and replaces itself.
-      if fork.nil?
-        exec(*command)
+        execute("generations", argv, database)
       end
-    end
 
-    def self.restore(database, argv = {})
-      if Litestream.configuration
-        ENV["LITESTREAM_REPLICA_BUCKET"] ||= Litestream.configuration.replica_bucket
-        ENV["LITESTREAM_ACCESS_KEY_ID"] ||= Litestream.configuration.replica_key_id
-        ENV["LITESTREAM_SECRET_ACCESS_KEY"] ||= Litestream.configuration.replica_access_key
+      def snapshots(database, argv = {})
+        raise DatabaseRequiredException, "database argument is required for snapshots command, e.g. litestream:snapshots -- --database=path/to/database.sqlite" if database.nil?
+
+        execute("snapshots", argv, database)
       end
 
-      dir, file = File.split(database)
-      ext = File.extname(file)
-      base = File.basename(file, ext)
-      now = Time.now.utc.strftime("%Y%m%d%H%M%S")
+      private
 
-      args = {
-        "--config" => Rails.root.join("config", "litestream.yml").to_s,
-        "-o" => File.join(dir, "#{base}-#{now}#{ext}")
-      }.merge(argv).to_a.flatten.compact
+      def execute(command, argv = {}, database = nil)
+        if Litestream.configuration
+          ENV["LITESTREAM_REPLICA_BUCKET"] ||= Litestream.configuration.replica_bucket
+          ENV["LITESTREAM_ACCESS_KEY_ID"] ||= Litestream.configuration.replica_key_id
+          ENV["LITESTREAM_SECRET_ACCESS_KEY"] ||= Litestream.configuration.replica_access_key
+        end
 
-      command = [executable, "restore", *args, database]
-      puts command.inspect
+        args = {
+          "--config" => Rails.root.join("config", "litestream.yml").to_s
+        }.merge(argv).to_a.flatten.compact
+        cmd = [executable, command, *args, database].compact
 
-      # To release the resources of the Ruby process, just fork and exit.
-      # The forked process executes litestream and replaces itself.
-      if fork.nil?
-        exec(*command)
+        # To release the resources of the Ruby process, just fork and exit.
+        # The forked process executes litestream and replaces itself.
+        if fork.nil?
+          puts cmd.inspect if ENV["DEBUG"]
+          exec(*cmd)
+        end
       end
     end
   end

data/lib/litestream/version.rb

@@ -1,3 +1,3 @@
 module Litestream
-  VERSION = "0.5.0"
+  VERSION = "0.5.1"
 end

data/lib/tasks/litestream_tasks.rake

@@ -36,4 +36,40 @@ namespace :litestream do
 
     Litestream::Commands.restore(options.delete("--database") || options.delete("-database"), options)
   end
+
+  desc "List all databases and associated replicas in the config file, e.g. rake litestream:databases -- -no-expand-env"
+  task databases: :environment do
+    options = {}
+    if (separator_index = ARGV.index("--"))
+      ARGV.slice(separator_index + 1, ARGV.length)
+        .map { |pair| pair.split("=") }
+        .each { |opt| options[opt[0]] = opt[1] || nil }
+    end
+
+    Litestream::Commands.databases(options)
+  end
+
+  desc "List all generations for a database or replica, e.g. rake litestream:generations -- -database=storage/production.sqlite3"
+  task generations: :environment do
+    options = {}
+    if (separator_index = ARGV.index("--"))
+      ARGV.slice(separator_index + 1, ARGV.length)
+        .map { |pair| pair.split("=") }
+        .each { |opt| options[opt[0]] = opt[1] || nil }
+    end
+
+    Litestream::Commands.generations(options.delete("--database") || options.delete("-database"), options)
+  end
+
+  desc "List all snapshots for a database or replica, e.g. rake litestream:snapshots -- -database=storage/production.sqlite3"
+  task snapshots: :environment do
+    options = {}
+    if (separator_index = ARGV.index("--"))
+      ARGV.slice(separator_index + 1, ARGV.length)
+        .map { |pair| pair.split("=") }
+        .each { |opt| options[opt[0]] = opt[1] || nil }
+    end
+
+    Litestream::Commands.snapshots(options.delete("--database") || options.delete("-database"), options)
+  end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: litestream
 version: !ruby/object:Gem::Version
-  version: 0.5.0
+  version: 0.5.1
 platform: x86_64-linux
 authors:
 - Stephen Margheim