litestream 0.11.2 → 0.13.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 59bbfcde749c016674729dc5b9b677e56cc5b31ec46727d490a19d481b928d61
-  data.tar.gz: 87812cd947c281c8212dd4bc414d7aad7e0e70d8d3ff2ffe3c4f07ec31c063fb
+  metadata.gz: 1e4638f801b8e05319b2390a63422edd6778944bb053324aefdbd43f98a2f15c
+  data.tar.gz: ced2aa3f3648042bf7f2211c02b17db670d0cb8a0c86902067ab08688954cb37
 SHA512:
-  metadata.gz: 13543423827364cbdb44b83674047549ce88df604017d2fca338a739e9453c097c6fec04aba2bf3621d3f725ced03fa62c20e132671d4e5f47616a1b1bc384b0
-  data.tar.gz: 52300ad4aa5f5b46026c9dbab2425461b3d68684a3e9cde5a462684366a90714971b3bd53afaa331eaf6fb8a754d78d0c4d6451d9769459cc621fc636de352a2
+  metadata.gz: be394032aadcf1ae817248ea8e83c1d23433f007f133aa6a0680813d5dd360895695654295bc8f3c91bcd6e8608a973d85f64cea9bae85f64ab6597b2e541f40
+  data.tar.gz: f6e3e6681736fc683bc855ca85c8124cc003c94096406d0127932fc38815541c244a6c1a59ac88ba57d2f0a4816dac30ce25fb4deca4db5563484d99e3a20d6e

data/README.md

@@ -1,5 +1,29 @@
 # litestream-ruby
 
+<p>
+  <a href="https://rubygems.org/gems/litestream">
+  <img alt="GEM Version" src="https://img.shields.io/gem/v/litestream?color=168AFE&include_prereleases&logo=ruby&logoColor=FE1616">
+  </a>
+  <a href="https://rubygems.org/gems/litestream">
+    <img alt="GEM Downloads" src="https://img.shields.io/gem/dt/litestream?color=168AFE&logo=ruby&logoColor=FE1616">
+  </a>
+  <a href="https://github.com/testdouble/standard">
+    <img alt="Ruby Style" src="https://img.shields.io/badge/style-standard-168AFE?logo=ruby&logoColor=FE1616" />
+  </a>
+  <a href="https://github.com/fractaledmind/litestream-ruby/actions/workflows/main.yml">
+    <img alt="Tests" src="https://github.com/fractaledmind/litestream-ruby/actions/workflows/main.yml/badge.svg" />
+  </a>
+  <a href="https://github.com/sponsors/fractaledmind">
+    <img alt="Sponsors" src="https://img.shields.io/github/sponsors/fractaledmind?color=eb4aaa&logo=GitHub%20Sponsors" />
+  </a>
+  <a href="https://ruby.social/@fractaledmind">
+    <img alt="Ruby.Social Follow" src="https://img.shields.io/mastodon/follow/109291299520066427?domain=https%3A%2F%2Fruby.social&label=%40fractaledmind&style=social">
+  </a>
+  <a href="https://twitter.com/fractaledmind">
+    <img alt="Twitter Follow" src="https://img.shields.io/twitter/url?label=%40fractaledmind&style=social&url=https%3A%2F%2Ftwitter.com%2Ffractaledmind">
+  </a>
+</p>
+
 [Litestream](https://litestream.io/) is a standalone streaming replication tool for SQLite. This gem provides a Ruby interface to Litestream.
 
 ## Installation
@@ -28,10 +52,11 @@ This gem wraps the standalone executable version of the [Litestream](https://lit
 
 Supported platforms are:
 
-* arm64-darwin (macos-arm64)
-* x86_64-darwin (macos-x64)
-* arm64-linux (linux-arm64)
-* x86_64-linux (linux-x64)
+- arm64-darwin (macos-arm64)
+- x86_64-darwin (macos-x64)
+- aarch64-linux (linux-aarch64)
+- arm64-linux (linux-arm64)
+- x86_64-linux (linux-x64)
 
 ### Using a local installation of `litestream`
 
@@ -39,13 +64,13 @@ If you are not able to use the vendored standalone executables (for example, if
 
 For example, if you've installed `litestream` so that the executable is found at `/usr/local/bin/litestream`, then you should set your environment variable like so:
 
-``` sh
+```sh
 LITESTREAM_INSTALL_DIR=/usr/local/bin
 ```
 
 This also works with relative paths. If you've installed into your app's directory at `./.bin/litestream`:
 
-``` sh
+```sh
 LITESTREAM_INSTALL_DIR=.bin
 ```
 
@@ -68,31 +93,33 @@ dbs:
         secret-access-key: $LITESTREAM_SECRET_ACCESS_KEY
 ```
 
-The gem also provides a default initializer file at `config/initializers/litestream.rb` that allows you to configure these four environment variables referenced in the configuration file in Ruby. By providing a Ruby interface to these environment variables, you can use any method of storing secrets that you prefer. For example, the default generated file uses Rails' encrypted credentials to store your secrets:
+This is the default for Amazon S3. The full range of possible replica types (e.g. other S3-compatible object storage servers) are covered in Litestream's [replica guides](https://litestream.io/guides/#replica-guides).
+
+The gem also provides a default initializer file at `config/initializers/litestream.rb` that allows you to configure these three environment variables referenced in the configuration file in Ruby. By providing a Ruby interface to these environment variables, you can use any method of storing secrets that you prefer. For example, the default generated file uses Rails' encrypted credentials to store your secrets:
 
 ```ruby
-litestream_credentials = Rails.application.credentials.litestream
-Litestream.configure do |config|
-  config.replica_bucket = litestream_credentials.replica_bucket
-  config.replica_key_id = litestream_credentials.replica_key_id
-  config.replica_access_key = litestream_credentials.replica_access_key
+Rails.application.configure do
+  litestream_credentials = Rails.application.credentials.litestream
+
+  config.litestream.replica_bucket = litestream_credentials&.replica_bucket
+  config.litestream.replica_key_id = litestream_credentials&.replica_key_id
+  config.litestream.replica_access_key = litestream_credentials&.replica_access_key
 end
 ```
 
-However, if you need manual control over the Litestream configuration, you can manually edit the `config/litestream.yml` file. The full range of possible configurations are covered in Litestream's [configuration reference](https://litestream.io/reference/config/).
+However, if you need manual control over the Litestream configuration, you can manually edit the `config/litestream.yml` file. The full range of possible configurations are covered in Litestream's [configuration reference](https://litestream.io/reference/config/).  NB: If you configure a longer `sync-interval`, you may need to adjust `replication_sleep` when calling `Litestream.verify!`.
 
 ### Replication
 
 In order to stream changes to your configured replicas, you need to start the Litestream replication process.
 
-The simplest way to run the Litestream replication process is use the Puma plugin provided by the gem. This allows you to run the Litestream replication process together with Puma and have Puma monitor and manage it. You just need to add
+The simplest way to run the Litestream replication process is use the Puma plugin provided by the gem. This allows you to run the Litestream replication process together with Puma and have Puma monitor and manage it. You just need to add the following to your `puma.rb` configuration:
 
 ```ruby
-plugin :litestream
+# Run litestream only in production.
+plugin :litestream if ENV.fetch("RAILS_ENV", "production") == "production"
 ```
 
-to your `puma.rb` configuration.
-
 If you would prefer to run the Litestream replication process separately from Puma, you can use the provided `litestream:replicate` rake task. This rake task will automatically load the configuration file and set the environment variables before starting the Litestream process.
 
 The simplest way to spin up a Litestream process separately from your Rails application is to use a `Procfile`:
@@ -130,20 +157,32 @@ The Litestream `replicate` command supports the following options, which can be
 
 ### Restoration
 
-You can restore any replicated database at any point using the gem's provided `litestream:restore` rake task. This rake task requires that you specify which specific database you want to restore. As with the `litestream:replicate` task, you pass arguments to the rake task via argument forwarding. For example, to restore the production database, you would run:
+You can restore any replicated database at any point using the gem's provided `litestream:restore` rake task. This rake task requires that you specify which specific database you want to restore. As with the `litestream:replicate` task, you pass arguments to the rake task via argument forwarding. For example, to restore the production database, you would do the following:
 
-```shell
-bin/rails litestream:restore -- --database=storage/production.sqlite3
-# or
-bundle exec rake litestream:restore -- --database=storage/production.sqlite3
-```
+> [!NOTE]  
+> During the restoration process, you need to prevent any interaction with ActiveRecord/SQLite, such as from a running `rails server` or `rails console` instance. If there is any interaction, Rails might regenerate the production database and prevent restoration via litestream. If this happens, you might get a "cannot restore, output path already exists" error.
+
+1. Rename the production (`production.sqlite3`, `production.sqlite3-shm`, and `production.sqlite3-wal`) databases (**recommended**) or alternatively delete. To delete the production databases locally, you can run the following at your own risk:
+   ```shell
+   # DANGEROUS OPERATION, consider renaming database files instead
+   bin/rails db:drop DISABLE_DATABASE_ENVIRONMENT_CHECK=1
+   ```
+
+2. Run restore command:
+   ```shell
+   bin/rails litestream:restore -- --database=storage/production.sqlite3
+   # or
+   bundle exec rake litestream:restore -- --database=storage/production.sqlite3
+   ```
+
+3. Restart your Rails application or Docker container if applicable.
 
 You can restore any of the databases specified in your `config/litestream.yml` file. The `--database` argument should be the path to the database file you want to restore and must match the value for the `path` key of one of your configured databases. The `litestream:restore` rake task will automatically load the configuration file and set the environment variables before calling the Litestream executable.
 
 If you need to pass arguments through the rake task to the underlying `litestream` command, that can be done with additional forwarded arguments:
 
 ```shell
-bin/rails litestream:replicate -- --database=storage/production.sqlite3 --if-db-not-exists
+bin/rails litestream:restore -- --database=storage/production.sqlite3 --if-db-not-exists
 ```
 
 You can forward arguments in whatever order you like, you simply need to ensure that the `--database` argument is present. You can also use either a single-dash `-database` or double-dash `--database` argument format. The Litestream `restore` command supports the following options, which can be passed through the rake task:
@@ -195,7 +234,7 @@ You can verify the integrity of your backed-up databases using the gem's provide
 Litestream.verify! "storage/production.sqlite3"
 ```
 
-In order to verify that the backup for that database is both restorable and fresh, the method will add a new row to that database under the `_litestream_verification` table, which it will create if needed. It will then wait 10 seconds to give the Litestream utility time to replicate that change to whatever storage providers you have configured. After that, it will download the latest backup from that storage provider and ensure that this verification row is present in the backup. If the verification row is _not_ present, the method will raise a `Litestream::VerificationFailure` exception. This check ensures that the restored database file
+In order to verify that the backup for that database is both restorable and fresh, the method will add a new row to that database under the `_litestream_verification` table, which it will create if needed. It will then wait `replication_sleep` seconds (defaults to 10) to give the Litestream utility time to replicate that change to whatever storage providers you have configured. After that, it will download the latest backup from that storage provider and ensure that this verification row is present in the backup. If the verification row is _not_ present, the method will raise a `Litestream::VerificationFailure` exception. This check ensures that the restored database file:
 
 1. exists,
 2. can be opened by SQLite, and
@@ -203,6 +242,119 @@ In order to verify that the backup for that database is both restorable and fres
 
 After restoring the backup, the `Litestream.verify!` method will delete the restored database file. If you need the restored database file, use the `litestream:restore` rake task or `Litestream::Commands.restore` method instead.
 
+### Dashboard
+
+The gem provides a web dashboard for monitoring the status of your Litestream replication. To mount the dashboard in your Rails application, add the following to your `config/routes.rb` file:
+
+```ruby
+authenticate :user, -> (user) { user.admin? } do
+  mount Litestream::Engine, at: "/litestream"
+end
+```
+
+> [!NOTE]
+> Be sure to [secure the dashboard](#authentication) in production.
+
+#### Authentication
+
+Litestream Rails does not restrict access out of the box. You must secure the dashboard yourself. However, it does provide basic HTTP authentication that can be used with basic authentication or Devise. All you need to do is setup a username and password.
+
+There are two ways to setup a username and password. First, you can use the `LITESTREAM_USERNAME` and `LITESTREAM_PASSWORD` environment variables:
+
+```ruby
+ENV["LITESTREAM_USERNAME"] = "frodo"
+ENV["LITESTREAM_PASSWORD"] = "ikeptmysecrets"
+```
+
+Second, you can configure the access credentials via the Rails configuration object, under the `litestream` key, in an initializer:
+
+```ruby
+# Set authentication credentials for Litestream
+config.litestream.username = Rails.application.credentials.dig(:litestream, :username)
+config.litestream.password = Rails.application.credentials.dig(:litestream, :password)
+```
+
+Either way, if you have set a username and password, Litestream will use basic HTTP authentication.
+
+> [!IMPORTANT]
+> If you have not set a username and password, Litestream will not require any authentication to view the dashboard.
+
+If you use Devise for authentication in your app, you can also restrict access to the dashboard by using their `authenticate` constraint in your routes file:
+
+```ruby
+authenticate :user, -> (user) { user.admin? } do
+  mount Litestream::Engine, at: "/litestream"
+end
+```
+
+### Examples
+
+There is only one screen in the dashboard.
+
+- the show view of the Litestream replication process:
+
+![screenshot of the single page in the web dashboard, showing details of the Litestream replication process](images/show-screenshot.png)
+
+### Usage with API-only Applications
+
+If your Rails application is an API-only application (generated with the `rails new --api` command), you will need to add the following middleware to your `config/application.rb` file in order to use the dashboard UI provided by Litestream:
+
+```ruby
+# /config/application.rb
+config.middleware.use ActionDispatch::Cookies
+config.middleware.use ActionDispatch::Session::CookieStore
+config.middleware.use ActionDispatch::Flash
+```
+
+### Overwriting the views
+
+You can find the views in [`app/views`](https://github.com/fractaledmind/litestream-ruby/tree/main/app/views).
+
+```bash
+app/views/
+├── layouts
+│   └── litestream
+│       ├── _style.html
+│       └── application.html.erb
+└── litestream
+    └── processes
+        └── show.html.erb
+```
+
+You can always take control of the views by creating your own views and/or partials at these paths in your application. For example, if you wanted to overwrite the application layout, you could create a file at `app/views/layouts/litestream/application.html.erb`. If you wanted to remove the footer and the automatically disappearing flash messages, as one concrete example, you could define that file as:
+
+```erb
+<!DOCTYPE html>
+<html>
+  <head>
+    <title>Litestream</title>
+    <%= csrf_meta_tags %>
+    <%= csp_meta_tag %>
+
+    <%= render "layouts/litestream/style" %>
+  </head>
+  <body class="h-full flex flex-col">
+    <main class="container mx-auto max-w-4xl mt-4 px-2 grow">
+      <%= content_for?(:content) ? yield(:content) : yield %>
+    </main>
+
+    <div class="fixed top-0 left-0 right-0 text-center py-2">
+      <% if notice.present? %>
+        <p class="py-2 px-3 bg-green-50 text-green-500 font-medium rounded-lg inline-block">
+          <%= notice %>
+        </p>
+      <% end %>
+
+      <% if alert.present? %>
+        <p class="py-2 px-3 bg-red-50 text-red-500 font-medium rounded-lg inline-block">
+          <%= alert %>
+        </p>
+      <% end %>
+    </div>
+  </body>
+</html>
+```
+
 ### 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:
@@ -224,14 +376,14 @@ You can also list the generations of a specific database:
 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.
+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:
+You can list the snapshots available for a database:
 
 ```shell
 bin/rails litestream:snapshots -- --database=storage/production.sqlite3
@@ -244,6 +396,19 @@ replica  generation        index  size     created
 s3       a295b16a796689f3  1      4645465  2024-04-17T00:01:19Z
 ```
 
+Finally, you can list the wal files available for a database:
+
+```shell
+bin/rails litestream:wal -- --database=storage/production.sqlite3
+```
+
+This command lists wal files available for that specified database:
+
+```
+replica  generation        index  offset    size     created
+s3       a295b16a796689f3  1      0         2036     2024-04-17T00:01:19Z
+```
+
 ### Running commands from Ruby
 
 In addition to the provided rake tasks, you can also run Litestream commands directly from Ruby. The gem provides a `Litestream::Commands` module that wraps the Litestream CLI commands. This is particularly useful for the introspection commands, as you can use the output in your Ruby code.
@@ -269,18 +434,18 @@ Litestream::Commands.snapshots('storage/production.sqlite3')
 # => [{"replica"=>"s3", "generation"=>"5f4341bc3d22d615", "index"=>"0", "size"=>"4645465", "created"=>"2024-04-17T19:48:09Z"}]
 ```
 
-You can also restore a database programatically using the `Litestream::Commands.restore` method, which returns the path to the restored database:
+The `Litestream::Commands.wal` method returns an array of hashes with the "replica", "generation", "index", "offset","size", and "created" keys for each wal:
 
 ```ruby
-Litestream::Commands.restore('storage/production.sqlite3')
-# => "storage/production-20240418090048.sqlite3"
+Litestream::Commands.wal('storage/production.sqlite3')
+# => [{"replica"=>"s3", "generation"=>"5f4341bc3d22d615", "index"=>"0",  "offset"=>"0", "size"=>"2036", "created"=>"2024-04-17T19:48:09Z"}]
 ```
 
-Finally, you can verify the integrity of a restored database using the `Litestream::Commands.verify` method, which returns a hash with the "size" and "tables" keys for the original and restored databases:
+You can also restore a database programmatically using the `Litestream::Commands.restore` method, which returns the path to the restored database:
 
 ```ruby
-Litestream::Commands.verify('storage/production.sqlite3')
-# => {"size"=>{"original"=>21688320, "restored"=>21688320}, "tables"=>{"original"=>9, "restored"=>9}}
+Litestream::Commands.restore('storage/production.sqlite3')
+# => "storage/production-20240418090048.sqlite3"
 ```
 
 You _can_ start the replication process using the `Litestream::Commands.replicate` method, but this is not recommended. The replication process should be managed by Litestream itself, and you should not need to manually start it.
@@ -303,7 +468,13 @@ litestream wal [arguments] DB_PATH|REPLICA_URL
 
 ### Using in development
 
-By default, installing the gem does not update your `Procfile.dev` file, and so Litestream will not be started in development. If you would like to test that your configuration is properly setup, you can manually add the `litestream:replicate` rake task to your `Procfile.dev` file. Just copy the `litestream` definition from the production `Procfile`. Then, in order to have a replication bucket for Litestream to point to, you can use a Docker instance of [MinIO](https://min.io/). MinIO is an S3-compatible object storage server that can be run locally. You can run a MinIO server with the following command:
+By default, if you install the gem and configure via `puma.rb` or `Procfile`, Litestream will not start in development.
+
+If you setup via `puma.rb`, then remove the conditional statement.
+
+If you setup via `Procfile`, you will need to update your `Procfile.dev` file. If you would like to test that your configuration is properly setup, you can manually add the `litestream:replicate` rake task to your `Procfile.dev` file. Just copy the `litestream` definition from the production `Procfile`.
+
+In order to have a replication bucket for Litestream to point to, you can use a Docker instance of [MinIO](https://min.io/). MinIO is an S3-compatible object storage server that can be run locally. You can run a MinIO server with the following command:
 
 ```sh
 docker run -p 9000:9000 -p 9001:9001 minio/minio server /data --console-address ":9001"

data/app/controllers/litestream/application_controller.rb

@@ -1,7 +1,6 @@
 module Litestream
-  class ApplicationController < ActionController::Base
+  class ApplicationController < Litestream.base_controller_class.constantize
     protect_from_forgery with: :exception
-    around_action :force_english_locale!
 
     if Litestream.password
       http_basic_authenticate_with(
@@ -9,11 +8,5 @@ module Litestream
         password: Litestream.password
       )
     end
-
-    private
-
-    def force_english_locale!(&action)
-      I18n.with_locale(:en, &action)
-    end
   end
 end

data/app/views/layouts/litestream/_style.html

@@ -801,4 +801,42 @@
   .hover\:underline:hover {
     text-decoration-line: underline;
   }
+  @media (prefers-color-scheme: dark) {
+    .dark\:border-gray-800 {
+      --tw-border-opacity: 1;
+      border-color: rgb(31 41 55 / var(--tw-border-opacity));
+    }
+    .dark\:bg-gray-900 {
+      --tw-bg-opacity: 1;
+      background-color: rgb(17 24 39 / var(--tw-bg-opacity));
+    }
+    .dark\:bg-green-900 {
+      --tw-bg-opacity: 1;
+      background-color: rgb(20 83 45 / var(--tw-bg-opacity));
+    }
+    .dark\:bg-red-900 {
+      --tw-bg-opacity: 1;
+      background-color: rgb(127 29 29 / var(--tw-bg-opacity));
+    }
+    .dark\:text-gray-100 {
+      --tw-text-opacity: 1;
+      color: rgb(243 244 246 / var(--tw-text-opacity));
+    }
+    .dark\:text-white {
+      --tw-text-opacity: 1;
+      color: rgb(255 255 255 / var(--tw-text-opacity));
+    }
+    .dark\:even\:bg-gray-800:nth-child(even) {
+      --tw-bg-opacity: 1;
+      background-color: rgb(31 41 55 / var(--tw-bg-opacity));
+    }
+    .dark\:hover\:bg-gray-900:hover {
+      --tw-bg-opacity: 1;
+      background-color: rgb(17 24 39 / var(--tw-bg-opacity));
+    }
+    .dark\:hover\:bg-gray-800:hover {
+      --tw-bg-opacity: 1;
+      background-color: rgb(31 41 55 / var(--tw-bg-opacity));
+    }
+  }
 </style>

data/app/views/layouts/litestream/application.html.erb

@@ -7,22 +7,22 @@
 
     <%= render "layouts/litestream/style" %>
   </head>
-  <body class="h-full flex flex-col">
+  <body class="h-full flex flex-col dark:bg-gray-900 dark:text-white">
     <main class="container mx-auto max-w-4xl mt-4 px-2 grow">
       <%= content_for?(:content) ? yield(:content) : yield %>
     </main>
 
-    <footer class="container mx-auto mt-24 flex items-center justify-between border-t px-2 py-4 text-base">
+    <footer class="container mx-auto mt-24 flex items-center justify-between border-t dark:border-gray-800 px-2 py-4 text-base">
       <p>
         <code><strong>Litestream</strong></code>&nbsp;&nbsp;|&nbsp;
-        Made by <a href="https://twitter.com/fractaledmind" class="text-blue-500 hover:underline decoration-blue-500">@fractaledmind</a> and <a href="https://github.com/fractaledmind/litestream/graphs/contributors" class="text-blue-500 hover:underline decoration-blue-500">friends</a>! Want to help? It's <a href="https://github.com/fractaledmind/litestream" class="text-blue-500 hover:underline decoration-blue-500">open source</a>!
+        Made by <a href="https://twitter.com/fractaledmind" class="text-blue-500 hover:underline decoration-blue-500">@fractaledmind</a> and <a href="https://github.com/fractaledmind/litestream-ruby/graphs/contributors" class="text-blue-500 hover:underline decoration-blue-500">friends</a>! Want to help? It's <a href="https://github.com/fractaledmind/litestream-ruby" class="text-blue-500 hover:underline decoration-blue-500">open source</a>!
       </p>
     </footer>
 
     <div class="fixed top-0 left-0 right-0 text-center py-2">
       <% if notice.present? %>
         <p id="notice"
-           class="py-2 px-3 bg-green-50 text-green-500 font-medium rounded-lg inline-block"
+           class="py-2 px-3 bg-green-50 dark:bg-green-900 text-green-500 font-medium rounded-lg inline-block"
            data-controller="fade">
           <%= notice.html_safe %>
         </p>
@@ -30,7 +30,7 @@
 
       <% if alert.present? %>
         <p id="alert"
-           class="py-2 px-3 bg-red-50 text-red-500 font-medium rounded-lg inline-block"
+           class="py-2 px-3 bg-red-50 dark:bg-red-900 text-red-500 font-medium rounded-lg inline-block"
            data-controller="fade">
           <%= alert.html_safe %>
         </p>

data/app/views/litestream/processes/show.html.erb

@@ -40,7 +40,7 @@
 <br>
 
 <section id="databases" class="">
-  <div class="mb-3 flex items-center justify-between border-b">
+  <div class="mb-3 flex items-center justify-between border-b dark:border-gray-800">
     <h2 class="text-2xl font-bold">Databases</h2>
     <p class="text-right">Total: <strong><%= @databases.size %></strong></p>
   </div>
@@ -59,7 +59,7 @@
         <section id="generations" class="ml-6">
           <% database['generations'].each do |generation| %>
             <details id="<%= generation['generation'] %>" open="open">
-              <summary class="cursor-pointer rounded p-2 hover:bg-gray-50">
+              <summary class="cursor-pointer rounded p-2 hover:bg-gray-50 dark:hover:bg-gray-800">
                 <code><%= generation['generation'] %></code>
                 (<em><%= generation['lag'] %> lag</em>)
               </summary>
@@ -85,24 +85,24 @@
                     <table class="min-w-full divide-y divide-gray-300">
                       <thead>
                         <tr>
-                          <th scope="col" class="whitespace-nowrap px-2 py-2 text-left text-sm font-semibold text-gray-900">Created at</th>
-                          <th scope="col" class="whitespace-nowrap px-2 py-2 text-right text-sm font-semibold text-gray-900">Index</th>
-                          <th scope="col" class="whitespace-nowrap px-2 py-2 text-right text-sm font-semibold text-gray-900">Size</th>
+                          <th scope="col" class="whitespace-nowrap px-2 py-2 text-left text-sm font-semibold text-gray-900 dark:text-gray-100">Created at</th>
+                          <th scope="col" class="whitespace-nowrap px-2 py-2 text-right text-sm font-semibold text-gray-900 dark:text-gray-100">Index</th>
+                          <th scope="col" class="whitespace-nowrap px-2 py-2 text-right text-sm font-semibold text-gray-900 dark:text-gray-100">Size</th>
                         </tr>
                       </thead>
 
-                      <tbody class="bg-white">
+                      <tbody class="bg-white dark:bg-gray-900">
                         <% generation['snapshots'].each do |snapshot| %>
-                          <tr class="align-top even:bg-gray-50">
-                            <td scope="col" class="whitespace-nowrap px-2 py-2 text-sm text-gray-900">
+                          <tr class="align-top even:bg-gray-50 dark:even:bg-gray-800">
+                            <td scope="col" class="whitespace-nowrap px-2 py-2 text-sm text-gray-900 dark:text-gray-100">
                               <abbr title="<%= snapshot['created'] %>" class="underline decoration-dashed decoration-gray-500 cursor-help">
                                 <time datetime="<%= snapshot['created'] %>"><%= DateTime.parse(snapshot['created']).to_formatted_s(:db) %></time>
                               </abbr>
                             </td>
-                            <td scope="col" class="whitespace-nowrap px-2 py-2 text-sm text-gray-900 text-right">
+                            <td scope="col" class="whitespace-nowrap px-2 py-2 text-sm text-gray-900 dark:text-gray-100 text-right">
                               <%= snapshot['index'] %>
                             </td>
-                            <td scope="col" class="whitespace-nowrap px-2 py-2 text-sm text-gray-900 text-right">
+                            <td scope="col" class="whitespace-nowrap px-2 py-2 text-sm text-gray-900 dark:text-gray-100 text-right">
                               <%= number_to_human_size snapshot['size'] %>
                             </td>
                           </tr>

data/lib/litestream/commands.rb

@@ -104,6 +104,12 @@ module Litestream
         execute("snapshots", argv, database, async: async, tabled_output: true)
       end
 
+      def wal(database, async: false, **argv)
+        raise DatabaseRequiredException, "database argument is required for wal command, e.g. litestream:wal -- --database=path/to/database.sqlite" if database.nil?
+
+        execute("wal", argv, database, async: async, tabled_output: true)
+      end
+
       private
 
       def execute(command, argv = {}, database = nil, async: false, tabled_output: false)
@@ -119,11 +125,13 @@ module Litestream
 
       def prepare(command, argv = {}, database = nil)
         ENV["LITESTREAM_REPLICA_BUCKET"] ||= Litestream.replica_bucket
+        ENV["LITESTREAM_REPLICA_REGION"] ||= Litestream.replica_region
+        ENV["LITESTREAM_REPLICA_ENDPOINT"] ||= Litestream.replica_endpoint
         ENV["LITESTREAM_ACCESS_KEY_ID"] ||= Litestream.replica_key_id
         ENV["LITESTREAM_SECRET_ACCESS_KEY"] ||= Litestream.replica_access_key
 
         args = {
-          "--config" => Rails.root.join("config", "litestream.yml").to_s
+          "--config" => Litestream.config_path.to_s
         }.merge(argv.stringify_keys).to_a.flatten.compact
         cmd = [executable, command, *args, database].compact
         puts cmd.inspect if ENV["DEBUG"]

data/lib/litestream/generators/litestream/templates/initializer.rb

@@ -2,7 +2,7 @@
 # All configuration options will be available as environment variables, e.g.
 # config.replica_bucket becomes LITESTREAM_REPLICA_BUCKET
 # This allows you to configure Litestream using Rails encrypted credentials,
-# or some other mechanism where the values are only avaialble at runtime.
+# or some other mechanism where the values are only available at runtime.
 
 Rails.application.configure do
   # An example of using Rails encrypted credentials to configure Litestream.

data/lib/litestream/upstream.rb

@@ -4,6 +4,7 @@ module Litestream
 
     # rubygems platform name => upstream release filename
     NATIVE_PLATFORMS = {
+      "aarch64-linux" => "litestream-#{VERSION}-linux-arm64.tar.gz",
       "arm64-darwin" => "litestream-#{VERSION}-darwin-arm64.zip",
       "arm64-linux" => "litestream-#{VERSION}-linux-arm64.tar.gz",
       "x86_64-darwin" => "litestream-#{VERSION}-darwin-amd64.zip",

data/lib/litestream/version.rb

@@ -1,3 +1,3 @@
 module Litestream
-  VERSION = "0.11.2"
+  VERSION = "0.13.0"
 end

data/lib/litestream.rb

@@ -19,7 +19,7 @@ module Litestream
 
   def self.configure
     deprecator.warn(
-      'Configuring Litestream via Litestream.configure is deprecated. Use Rails.application.configure { config.litestream.* = ... } instead.',
+      "Configuring Litestream via Litestream.configure is deprecated. Use Rails.application.configure { config.litestream.* = ... } instead.",
       caller
     )
     self.configuration ||= Configuration.new
@@ -33,16 +33,18 @@ module Litestream
     end
   end
 
-  mattr_writer :username, :password, :queue, :replica_bucket, :replica_key_id, :replica_access_key
+  mattr_writer :username, :password, :queue, :replica_bucket, :replica_region, :replica_endpoint, :replica_key_id, :replica_access_key, :systemctl_command,
+    :config_path
+  mattr_accessor :base_controller_class, default: "::ApplicationController"
 
   class << self
-    def verify!(database_path)
+    def verify!(database_path, replication_sleep: 10)
       database = SQLite3::Database.new(database_path)
       database.execute("CREATE TABLE IF NOT EXISTS _litestream_verification (id INTEGER PRIMARY KEY, uuid BLOB)")
       sentinel = SecureRandom.uuid
       database.execute("INSERT INTO _litestream_verification (uuid) VALUES (?)", [sentinel])
       # give the Litestream replication process time to replicate the sentinel value
-      sleep 10
+      sleep replication_sleep
 
       backup_path = "tmp/#{Time.now.utc.strftime("%Y%m%d%H%M%S")}_#{sentinel}.sqlite3"
       Litestream::Commands.restore(database_path, **{"-o" => backup_path})
@@ -77,6 +79,14 @@ module Litestream
       @@replica_bucket || configuration.replica_bucket
     end
 
+    def replica_region
+      @@replica_region
+    end
+
+    def replica_endpoint
+      @@replica_endpoint
+    end
+
     def replica_key_id
       @@replica_key_id || configuration.replica_key_id
     end
@@ -85,55 +95,16 @@ module Litestream
       @@replica_access_key || configuration.replica_access_key
     end
 
+    def systemctl_command
+      @@systemctl_command || "systemctl status litestream"
+    end
+
+    def config_path
+      @@config_path || Rails.root.join("config", "litestream.yml")
+    end
+
     def replicate_process
-      info = {}
-      if !`which systemctl`.empty?
-        systemctl_status = `systemctl status litestream`.chomp
-        # ["● litestream.service - Litestream",
-        #  "     Loaded: loaded (/lib/systemd/system/litestream.service; enabled; vendor preset: enabled)",
-        #  "     Active: active (running) since Tue 2023-07-25 13:49:43 UTC; 8 months 24 days ago",
-        #  "   Main PID: 1179656 (litestream)",
-        #  "      Tasks: 9 (limit: 1115)",
-        #  "     Memory: 22.9M",
-        #  "        CPU: 10h 49.843s",
-        #  "     CGroup: /system.slice/litestream.service",
-        #  "             └─1179656 /usr/bin/litestream replicate",
-        #  "",
-        #  "Warning: some journal files were not opened due to insufficient permissions."]
-        systemctl_status.split("\n").each do |line|
-          line.strip!
-          if line.start_with?("Main PID:")
-            _key, value = line.split(":")
-            pid, _name = value.strip.split(" ")
-            info[:pid] = pid
-          elsif line.start_with?("Active:")
-            value, _ago = line.split(";")
-            status, timestamp = value.split(" since ")
-            info[:started] = DateTime.strptime(timestamp.strip, "%a %Y-%m-%d %H:%M:%S %Z")
-            status_match = status.match(%r{\((?<status>.*)\)})
-            info[:status] = status_match ? status_match[:status] : nil
-          end
-        end
-      else
-        litestream_replicate_ps = `ps -a | grep litestream | grep replicate`.chomp
-        litestream_replicate_ps.split("\n").each do |line|
-          next unless line.include?("litestream replicate")
-          pid, * = line.split(" ")
-          info[:pid] = pid
-          state, _, lstart = `ps -o "state,lstart" #{pid}`.chomp.split("\n").last.partition(/\s+/)
-
-          info[:status] = case state[0]
-          when "I" then "idle"
-          when "R" then "running"
-          when "S" then "sleeping"
-          when "T" then "stopped"
-          when "U" then "uninterruptible"
-          when "Z" then "zombie"
-          end
-          info[:started] = DateTime.strptime(lstart.strip, "%a %b %d %H:%M:%S %Y")
-        end
-      end
-      info
+      systemctl_info || process_info || {}
     end
 
     def databases
@@ -153,6 +124,71 @@ module Litestream
         end
       end
     end
+
+    private
+
+    def systemctl_info
+      return if `which systemctl`.empty?
+
+      systemctl_output = `#{Litestream.systemctl_command}`
+      systemctl_exit_code = $?.exitstatus
+      return unless systemctl_exit_code.zero?
+
+      # ["● litestream.service - Litestream",
+      #  "     Loaded: loaded (/lib/systemd/system/litestream.service; enabled; vendor preset: enabled)",
+      #  "     Active: active (running) since Tue 2023-07-25 13:49:43 UTC; 8 months 24 days ago",
+      #  "   Main PID: 1179656 (litestream)",
+      #  "      Tasks: 9 (limit: 1115)",
+      #  "     Memory: 22.9M",
+      #  "        CPU: 10h 49.843s",
+      #  "     CGroup: /system.slice/litestream.service",
+      #  "             └─1179656 /usr/bin/litestream replicate",
+      #  "",
+      #  "Warning: some journal files were not opened due to insufficient permissions."]
+
+      info = {}
+      systemctl_output.chomp.split("\n").each do |line|
+        line.strip!
+        if line.start_with?("Main PID:")
+          _key, value = line.split(":")
+          pid, _name = value.strip.split(" ")
+          info[:pid] = pid
+        elsif line.start_with?("Active:")
+          value, _ago = line.split(";")
+          status, timestamp = value.split(" since ")
+          info[:started] = DateTime.strptime(timestamp.strip, "%a %Y-%m-%d %H:%M:%S %Z")
+          status_match = status.match(%r{\((?<status>.*)\)})
+          info[:status] = status_match ? status_match[:status] : nil
+        end
+      end
+      info
+    end
+
+    def process_info
+      litestream_replicate_ps = `ps -ax | grep litestream | grep replicate`
+      exit_code = $?.exitstatus
+      return unless exit_code.zero?
+
+      info = {}
+      litestream_replicate_ps.chomp.split("\n").each do |line|
+        next unless line.include?("litestream replicate")
+
+        pid, * = line.split(" ")
+        info[:pid] = pid
+        state, _, lstart = `ps -o "state,lstart" #{pid}`.chomp.split("\n").last.partition(/\s+/)
+
+        info[:status] = case state[0]
+        when "I" then "idle"
+        when "R" then "running"
+        when "S" then "sleeping"
+        when "T" then "stopped"
+        when "U" then "uninterruptible"
+        when "Z" then "zombie"
+        end
+        info[:started] = DateTime.strptime(lstart.strip, "%a %b %d %H:%M:%S %Y")
+      end
+      info
+    end
   end
 end
 

data/lib/tasks/litestream_tasks.rake

@@ -2,6 +2,8 @@ namespace :litestream do
   desc "Print the ENV variables needed for the Litestream config file"
   task env: :environment do
     puts "LITESTREAM_REPLICA_BUCKET=#{Litestream.replica_bucket}"
+    puts "LITESTREAM_REPLICA_REGION=#{Litestream.replica_region}"
+    puts "LITESTREAM_REPLICA_ENDPOINT=#{Litestream.replica_endpoint}"
     puts "LITESTREAM_ACCESS_KEY_ID=#{Litestream.replica_key_id}"
     puts "LITESTREAM_SECRET_ACCESS_KEY=#{Litestream.replica_access_key}"
 
@@ -75,4 +77,18 @@ namespace :litestream do
 
     Litestream::Commands.snapshots(database, async: true, **options)
   end
+
+  desc "List all wal files for a database or replica, for example `rake litestream:wal -- -database=storage/production.sqlite3`"
+  task wal: :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
+    database = options.delete("--database") || options.delete("-database")
+    options.symbolize_keys!
+
+    Litestream::Commands.wal(database, async: true, **options)
+  end
 end

metadata

@@ -1,14 +1,13 @@
 --- !ruby/object:Gem::Specification
 name: litestream
 version: !ruby/object:Gem::Version
-  version: 0.11.2
+  version: 0.13.0
 platform: ruby
 authors:
 - Stephen Margheim
-autorequire:
 bindir: exe
 cert_chain: []
-date: 2024-09-06 00:00:00.000000000 Z
+date: 2025-06-03 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: logfmt
@@ -150,7 +149,6 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
-description:
 email:
 - stephen.margheim@gmail.com
 executables:
@@ -188,7 +186,6 @@ metadata:
   rubygems_mfa_required: 'true'
   source_code_uri: https://github.com/fractaledmind/litestream-ruby
   changelog_uri: https://github.com/fractaledmind/litestream-ruby/CHANGELOG.md
-post_install_message:
 rdoc_options: []
 require_paths:
 - lib
@@ -203,8 +200,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.5.11
-signing_key:
+rubygems_version: 3.6.3
 specification_version: 4
 summary: Integrate Litestream with the RubyGems infrastructure.
 test_files: []