hotswap 0.1.5 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: cfc6ba1c55a44bc480160c4688fd4dbd32c0d389c8c532738e04d3031d14b538
-  data.tar.gz: 6de63bb11a1ab974a55cc8900e8dc063d6f25f3e4f478f098139b1af82fe327a
+  metadata.gz: eb39bbe01190402e38969b9721794ab4845fd46907a4bfd8d5e21f3cd2cc30dc
+  data.tar.gz: c948687920739f879999caf87ab23d8baacefbeb8bcd8a008e37976dc0016d39
 SHA512:
-  metadata.gz: 96fc1c62b5518aef27b08e6cf0fd6a9fafabda30b5be3b199e1a2ecd86d15c177d83c35641b357161e8bec431e53d7db80f859db54971db20088c0e3449da349
-  data.tar.gz: 6bd93a4ab5c061c6d97b77eab76af68ae93675b584648742ce74c950177f76623c6e0691e07310692f22e40d09592bff78d40eead14a7ba5ce103d190f8e94a6
+  metadata.gz: f549bb47a1e79ee364b68cb8e96160f877190d41f8bdf785ea16659d1f7b5aad3bacd052085c588b9b089906d152bc0428098729d5a44b61c7e1cec866680b29
+  data.tar.gz: daaaf30d063d08ced91ff9249f625a6424d50247e1748f2b75506ce21bf6279fce63a9001adf72649397bcd3d45d375aafa498d4f94d45e2449d05797daba2b7

data/lib/hotswap/cli.rb

@@ -1,7 +1,4 @@
 require "thor"
-require "tempfile"
-require "fileutils"
-require "sqlite3"
 
 module Hotswap
   class CLI < Thor
@@ -20,8 +17,6 @@ module Hotswap
       def stderr = @_stderr
     end
 
-    # Thread-safe IO: each connection gets its own IO via thread-local storage
-    # instead of swapping global $stdin/$stdout/$stderr.
     def self.run(args, stdin: $stdin, stdout: $stdout, stderr: $stderr)
       Thread.current[:hotswap_stdin] = stdin
       Thread.current[:hotswap_stdout] = stdout
@@ -37,52 +32,42 @@ module Hotswap
       Thread.current[:hotswap_stderr] = nil
     end
 
-    desc "cp SRC DST", "Copy a database to/from the running server. Use 'database' to refer to the running database."
+    desc "cp SRC DST", "Copy a database to/from the running server"
     long_desc <<~DESC
       Copy a SQLite database to or from the running server.
 
-      Use 'database' as a placeholder for the running server's database.
-      Use '-' for stdin/stdout.
+      If SRC or DST matches a managed database path, hotswap treats it as
+      the live database. Use '-' for stdin/stdout.
 
       Examples:
 
-        hotswap cp ./new.sqlite3 database     # replace the running database
-        hotswap cp database ./backup.sqlite3   # snapshot the running database
-        hotswap cp - database                  # read from stdin
-        hotswap cp database -                  # write to stdout
+        hotswap cp ./new.sqlite3 db/production.sqlite3   # push
+        hotswap cp db/production.sqlite3 ./backup.sqlite3 # pull
+        hotswap cp - db/production.sqlite3                # push from stdin
+        hotswap cp db/production.sqlite3 -                # pull to stdout
     DESC
     def cp(src, dst)
-      db_path = Hotswap.database_path
-      unless db_path
-        io_err.write("ERROR: database_path not configured\n")
-        return
-      end
+      src_db = resolve_database(src)
+      dst_db = resolve_database(dst)
 
-      if src == "database" && dst == "database"
-        io_err.write("ERROR: source and destination can't both be 'database'\n")
+      if src_db && dst_db
+        io_err.write("ERROR: source and destination can't both be managed databases\n")
         return
       end
 
-      if dst == "database"
-        push_database(src, db_path)
-      elsif src == "database"
-        pull_database(dst, db_path)
+      if dst_db
+        source = (src == "-") ? io_in : src
+        dst_db.push(source, stdout: io_out, stderr: io_err)
+      elsif src_db
+        destination = (dst == "-") ? io_out : dst
+        src_db.pull(destination, stderr: io_err)
       else
-        io_err.write("ERROR: one of src/dst must be 'database'\n")
+        paths = Hotswap.databases.map(&:path).join(", ")
+        io_err.write("ERROR: neither path matches a managed database (#{paths})\n")
       end
     end
 
-    desc "push", "Replace the running database from stdin"
-    def push
-      cp("-", "database")
-    end
-
-    desc "pull", "Snapshot the running database to stdout"
-    def pull
-      cp("database", "-")
-    end
-
-    desc "version", "Print the hotswap version"
+desc "version", "Print the hotswap version"
     def version
       io_out.write("hotswap #{Hotswap::VERSION}\n")
     end
@@ -93,73 +78,9 @@ module Hotswap
     def io_out = Thread.current[:hotswap_stdout] || $stdout
     def io_err = Thread.current[:hotswap_stderr] || $stderr
 
-    def push_database(src, db_path)
-      input = (src == "-") ? io_in : File.open(src, "rb")
-
-      dir = File.dirname(db_path)
-      temp = Tempfile.new(["hotswap", ".sqlite3"], dir)
-      begin
-        IO.copy_stream(input, temp)
-        temp.close
-
-        db = SQLite3::Database.new(temp.path)
-        result = db.execute("PRAGMA integrity_check")
-        db.close
-        unless result == [["ok"]]
-          io_err.write("ERROR: integrity check failed\n")
-          return
-        end
-
-        io_err.write("Swapping database...\n")
-
-        Middleware::SWAP_LOCK.synchronize do
-          if defined?(ActiveRecord::Base)
-            ActiveRecord::Base.connection_handler.clear_all_connections!
-          end
-          File.rename(temp.path, db_path)
-        end
-
-        if defined?(ActiveRecord::Base)
-          ActiveRecord::Base.establish_connection
-        end
-
-        io_out.write("OK\n")
-      rescue => e
-        io_err.write("ERROR: #{e.message}\n")
-      ensure
-        input.close if input.is_a?(File)
-        temp.unlink if temp && File.exist?(temp.path)
-      end
-    end
-
-    def pull_database(dst, db_path)
-      unless File.exist?(db_path)
-        io_err.write("ERROR: database file not found\n")
-        return
-      end
-
-      dir = File.dirname(db_path)
-      temp = Tempfile.new(["hotswap-pull", ".sqlite3"], dir)
-      begin
-        src_db = SQLite3::Database.new(db_path)
-        dst_db = SQLite3::Database.new(temp.path)
-        b = SQLite3::Backup.new(dst_db, "main", src_db, "main")
-        b.step(-1)
-        b.finish
-        dst_db.close
-        src_db.close
-
-        if dst == "-"
-          File.open(temp.path, "rb") { |f| IO.copy_stream(f, io_out) }
-        else
-          FileUtils.cp(temp.path, dst)
-          io_err.write("OK\n")
-        end
-      rescue => e
-        io_err.write("ERROR: #{e.message}\n")
-      ensure
-        temp.unlink if temp && File.exist?(temp.path)
-      end
+    def resolve_database(path)
+      return nil if path == "-"
+      Hotswap.find_database(path) || (path == "database" && Hotswap.databases.first)
     end
   end
 end

data/lib/hotswap/database.rb

@@ -0,0 +1,88 @@
+require "tempfile"
+require "fileutils"
+require "sqlite3"
+
+module Hotswap
+  class Database
+    attr_reader :path
+
+    def initialize(path)
+      @path = File.expand_path(path)
+    end
+
+    # Push a new database from an IO stream or file path
+    def push(source, stdout: $stdout, stderr: $stderr)
+      input = source.is_a?(String) ? File.open(source, "rb") : source
+
+      dir = File.dirname(@path)
+      temp = Tempfile.new(["hotswap", ".sqlite3"], dir)
+      begin
+        IO.copy_stream(input, temp)
+        temp.close
+
+        db = SQLite3::Database.new(temp.path)
+        result = db.execute("PRAGMA integrity_check")
+        db.close
+        unless result == [["ok"]]
+          stderr.write("ERROR: integrity check failed\n")
+          return false
+        end
+
+        stderr.write("Swapping database...\n")
+
+        Middleware::SWAP_LOCK.synchronize do
+          if defined?(ActiveRecord::Base)
+            ActiveRecord::Base.connection_handler.clear_all_connections!
+          end
+          File.rename(temp.path, @path)
+        end
+
+        if defined?(ActiveRecord::Base)
+          ActiveRecord::Base.establish_connection
+        end
+
+        stdout.write("OK\n")
+        true
+      rescue => e
+        stderr.write("ERROR: #{e.message}\n")
+        false
+      ensure
+        input.close if source.is_a?(String) && input.is_a?(File)
+        temp.unlink if temp && File.exist?(temp.path)
+      end
+    end
+
+    # Pull the database to an IO stream or file path
+    def pull(destination, stderr: $stderr)
+      unless File.exist?(@path)
+        stderr.write("ERROR: database file not found at #{@path}\n")
+        return false
+      end
+
+      dir = File.dirname(@path)
+      temp = Tempfile.new(["hotswap-pull", ".sqlite3"], dir)
+      begin
+        src_db = SQLite3::Database.new(@path)
+        dst_db = SQLite3::Database.new(temp.path)
+        b = SQLite3::Backup.new(dst_db, "main", src_db, "main")
+        b.step(-1)
+        b.finish
+        dst_db.close
+        src_db.close
+
+        if destination.is_a?(String)
+          FileUtils.cp(temp.path, destination)
+          stderr.write("OK\n")
+        else
+          File.open(temp.path, "rb") { |f| IO.copy_stream(f, destination) }
+        end
+        true
+      rescue => e
+        stderr.write("ERROR: #{e.message}\n")
+        false
+      ensure
+        temp.unlink if temp && File.exist?(temp.path)
+      end
+    end
+  end
+end

data/lib/hotswap/railtie.rb

@@ -3,17 +3,21 @@ module Hotswap
     config.hotswap = ActiveSupport::OrderedOptions.new
 
     initializer "hotswap.configure" do |app|
-      # Default database path from Rails config
-      if app.config.hotswap.database_path
-        Hotswap.database_path = app.config.hotswap.database_path
+      # Discover all SQLite databases from Rails config
+      if app.config.hotswap.database_paths
+        Array(app.config.hotswap.database_paths).each { |p| Hotswap.register(p) }
+      elsif app.config.hotswap.database_path
+        Hotswap.register(app.config.hotswap.database_path)
       else
-        db_config = app.config.database_configuration[Rails.env]
-        if db_config && db_config["adapter"]&.include?("sqlite")
-          Hotswap.database_path = db_config["database"]
+        db_configs = ActiveRecord::Base.configurations.configs_for(env_name: Rails.env)
+        db_configs.each do |db_config|
+          if db_config.adapter.include?("sqlite")
+            Hotswap.register(db_config.database)
+          end
         end
       end
 
-      # Default socket paths
+      # Socket paths
       if app.config.hotswap.socket_path
         Hotswap.socket_path = app.config.hotswap.socket_path
       else

data/lib/hotswap/version.rb

@@ -1,3 +1,3 @@
 module Hotswap
-  VERSION = "0.1.5"
+  VERSION = "0.2.0"
 end

data/lib/hotswap.rb

@@ -1,5 +1,6 @@
 require_relative "hotswap/version"
 require_relative "hotswap/middleware"
+require_relative "hotswap/database"
 require_relative "hotswap/cli"
 require_relative "hotswap/socket_server"
 require_relative "hotswap/railtie" if defined?(Rails::Railtie)
@@ -8,11 +9,38 @@ module Hotswap
   class Error < StandardError; end
 
   class << self
-    attr_accessor :database_path, :socket_path, :stderr_socket_path
+    attr_accessor :socket_path, :stderr_socket_path
 
     def configure
       yield self
     end
+
+    # Registry of managed databases
+    def databases
+      @databases ||= []
+    end
+
+    def register(path)
+      db = Database.new(path)
+      databases << db unless databases.any? { |d| d.path == db.path }
+      db
+    end
+
+    def find_database(path)
+      return nil if path == "-"
+      resolved = File.expand_path(path)
+      databases.find { |db| db.path == resolved }
+    end
+
+    # Backward compat: single database_path getter/setter
+    def database_path=(path)
+      @databases = []
+      register(path) if path
+    end
+
+    def database_path
+      databases.first&.path
+    end
   end
 
   self.socket_path = "tmp/sockets/hotswap.sock"

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: hotswap
 version: !ruby/object:Gem::Version
-  version: 0.1.5
+  version: 0.2.0
 platform: ruby
 authors:
 - Brad Gessler
@@ -160,6 +160,7 @@ files:
 - exe/hotswap
 - lib/hotswap.rb
 - lib/hotswap/cli.rb
+- lib/hotswap/database.rb
 - lib/hotswap/middleware.rb
 - lib/hotswap/railtie.rb
 - lib/hotswap/socket_server.rb