activerecord-beagle-turso 0.1.8 → 0.1.9

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: cd2ebde88afce8658ba27c6a8ae41ffb3228e6ec7bb6c65be6ff0a5a1c56d6ec
-  data.tar.gz: 2c6ac050108dd08d75808fb5aa28854164f91835c6529ff400ff97351d81c449
+  metadata.gz: f368e18d7818a9897c2a59309e2850bb44ad977d97513ae210996d2762f138f7
+  data.tar.gz: ffe739174f2998da3bb0bba9de535687dc6143914c123db6df718e9fe2c361df
 SHA512:
-  metadata.gz: 0cc05e0873fd0a0d143c2bae7758320768b06bdca6f6cd676de504cc09bc61360877aa81fa7d4b88ca7836758103135d3056d15cc5587721481b826fd9d0855c
-  data.tar.gz: d0be294e7c35be6e5275cbbbcb54e80546ddb1b4c30a6f6ea32b72ec88c8554eded57b6537e128581ce599c3d1c173e49c443f7ca4e88ba7366641d351b9916d
+  metadata.gz: '07097b798e8ef32bfad3d84318c9b1101284631a7e8171006c1a1be788e12d89e4dc292a7ef2155fdcc3468a1730046f4629c2c7fb16cb5bbc69b7d27965ed50'
+  data.tar.gz: 61880c51d328741a0cbf7641bb2e9eb12b946db91f4472265870b5e03b22cd4bc2ae07023381185bea42afc5329777ab83d31f0e4bab553267ee783df070d188

data/README.md

@@ -68,7 +68,10 @@ does not cover them automatically. Source them from encrypted credentials or
 transaction to finish before raising `Beagle::Turso::BusyError`. Transactions
 begin with `BEGIN IMMEDIATE`, so a writer waits at `BEGIN`, never part-way
 through. The wait sleeps in Ruby, so other threads and fibers keep running.
-Without `timeout:` (or with 0), a busy write raises at once.
+Opening a new connection waits the same way when a synced replica is busy
+with a sync (the engine reports "database tape error: database is busy" as an
+`OpenError` or `ConnectError`), so a pool growing during a `SyncJob` no
+longer fails. Without `timeout:` (or with 0), both raise at once.
 
 An optional `bootstrap_if_empty:` (default `true`) controls whether a brand
 new/empty local file is populated from the remote on first open — see

data/lib/active_record/connection_adapters/beagle_turso_adapter.rb

@@ -74,12 +74,87 @@ module ActiveRecord
       INSERT_STATEMENT_REGEX = /\A\s*(?:(?:INSERT|REPLACE)\b|WITH\b[\s\S]*\)\s*(?:INSERT|REPLACE)\b)/i
       private_constant :INSERT_STATEMENT_REGEX
 
+      # A statement that lost the single-writer race. A stale snapshot is
+      # never retried: the transaction that read it has to start again.
+      STATEMENT_BUSY = lambda do |error|
+        error.is_a?(::Beagle::Turso::BusyError) && !error.message.include?("snapshot is stale")
+      end
+      private_constant :STATEMENT_BUSY
+
+      # Opening or connecting to a synced replica while another connection
+      # syncs it. The sync engine reports that as "database tape error:
+      # database is busy" inside an OpenError or ConnectError (the driver only
+      # classifies the engine's own "Database is busy" as BusyError).
+      OPEN_BUSY = lambda do |error|
+        STATEMENT_BUSY.call(error) ||
+          ((error.is_a?(::Beagle::Turso::OpenError) || error.is_a?(::Beagle::Turso::ConnectError)) &&
+            error.message.match?(/database is busy/i))
+      end
+      private_constant :OPEN_BUSY
+
       class << self
         # Open a beagle-turso Database (synced remote when +remote_url+ is
         # present, otherwise local/in-memory) and wrap it so the SQLite3Adapter
-        # can drive it as a raw connection.
+        # can drive it as a raw connection. A busy open is retried for
+        # database.yml's `timeout:`, like a busy statement.
         def new_client(config)
-          database =
+          busy = ->(error) { OPEN_BUSY.call(error) || torn_meta_read?(error, config) }
+          retry_busy(busy_timeout(config[:timeout]), busy: busy) do
+            database = open_database(config)
+            begin
+              Client.new(database)
+            rescue Exception
+              database.close
+              raise
+            end
+          end
+        end
+
+        # `timeout:` (ms, as in database.yml) as seconds; nil means no waiting.
+        def busy_timeout(milliseconds)
+          milliseconds.to_i.positive? ? milliseconds.to_i / 1000.0 : nil
+        end
+
+        # Retries the block while it raises an error +busy+ accepts, with
+        # capped exponential backoff, for up to +timeout+ seconds. The engine
+        # never waits for a lock itself (from beagle-turso 0.4.0 it raises at
+        # once), so this is where the wait happens. sleep releases the GVL and
+        # yields to a fiber scheduler, so whoever holds the lock can finish.
+        def retry_busy(timeout, busy:)
+          deadline = nil
+          delay = 0.002
+          begin
+            yield
+          rescue ::Beagle::Turso::Error => e
+            raise if timeout.nil? || !busy.call(e)
+
+            now = Process.clock_gettime(Process::CLOCK_MONOTONIC)
+            deadline ||= now + timeout
+            raise if now + delay > deadline
+
+            sleep delay
+            delay = [delay * 2, 0.1].min
+            retry
+          end
+        end
+
+        def synced_config?(config)
+          !config[:remote_url].to_s.empty? && !config[:auth_token].to_s.empty?
+        end
+
+        private
+          # The sync engine (turso 0.8.3) rewrites a replica's metadata file
+          # (`<database>-info`) in place, truncating it first, so an open that
+          # reads it mid-sync can find it empty and fail with "meta must be
+          # initialized before open". Retried only when the file is there: a
+          # replica that was never initialised fails at once.
+          def torn_meta_read?(error, config)
+            error.is_a?(::Beagle::Turso::OpenError) &&
+              error.message.include?("meta must be initialized before open") &&
+              File.exist?("#{config[:database]}-info")
+          end
+
+          def open_database(config)
             if config[:remote_url]
               Beagle::Turso::Database.open(
                 local_path: config[:database].to_s,
@@ -90,12 +165,7 @@ module ActiveRecord
             else
               Beagle::Turso::Database.open_local(config[:database].to_s)
             end
-          Client.new(database)
-        end
-
-        def synced_config?(config)
-          !config[:remote_url].to_s.empty? && !config[:auth_token].to_s.empty?
-        end
+          end
       end
 
       # Adapts a Beagle::Turso::Database + its connected Connection to the subset
@@ -187,31 +257,14 @@ module ActiveRecord
         # does to the sqlite3 gem's busy handler. Unset or 0 means no waiting:
         # a BusyError surfaces at once, as with the sqlite3 gem.
         def busy_handler_timeout=(milliseconds)
-          @busy_timeout = milliseconds.to_i.positive? ? milliseconds.to_i / 1000.0 : nil
+          @busy_timeout = BeagleTursoAdapter.busy_timeout(milliseconds)
         end
 
-        # Retries a statement that lost the single-writer race, with capped
-        # exponential backoff, for up to the busy timeout. The engine never
-        # waits for a lock itself (from beagle-turso 0.4.0 it raises at once),
-        # so this is where the wait happens. sleep releases the GVL and yields
-        # to a fiber scheduler, so the writer holding the lock can finish. The
-        # caller decides what is safe to retry (see BeagleTursoAdapter#perform_query).
-        def retry_busy
-          deadline = nil
-          delay = 0.002
-          begin
-            yield
-          rescue ::Beagle::Turso::BusyError => e
-            raise if @busy_timeout.nil? || e.message.include?("snapshot is stale")
-
-            now = Process.clock_gettime(Process::CLOCK_MONOTONIC)
-            deadline ||= now + @busy_timeout
-            raise if now + delay > deadline
-
-            sleep delay
-            delay = [delay * 2, 0.1].min
-            retry
-          end
+        # Retries a statement that lost the single-writer race for up to the
+        # busy timeout (see BeagleTursoAdapter.retry_busy). The caller decides
+        # what is safe to retry (see BeagleTursoAdapter#perform_query).
+        def retry_busy(&)
+          BeagleTursoAdapter.retry_busy(@busy_timeout, busy: STATEMENT_BUSY, &)
         end
 
         # --- sqlite3-gem lifecycle shims the SQLite3Adapter drives ---

data/lib/activerecord/beagle_turso/version.rb

@@ -2,6 +2,6 @@
 
 module ActiveRecord
   module BeagleTurso
-    VERSION = "0.1.8"
+    VERSION = "0.1.9"
   end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: activerecord-beagle-turso
 version: !ruby/object:Gem::Version
-  version: 0.1.8
+  version: 0.1.9
 platform: ruby
 authors:
 - BeagleSoftwareUK