hotswap 0.1.5 → 0.2.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: cfc6ba1c55a44bc480160c4688fd4dbd32c0d389c8c532738e04d3031d14b538
-  data.tar.gz: 6de63bb11a1ab974a55cc8900e8dc063d6f25f3e4f478f098139b1af82fe327a
+  metadata.gz: e2313b39ed36d4fd0d236192de9c34f9ac7546984f8a076d474f035abddef947
+  data.tar.gz: a7458d108f6d2051a08c89aa3a8357c3cb72ccb892c7669b69d3deeaf1f5abe3
 SHA512:
-  metadata.gz: 96fc1c62b5518aef27b08e6cf0fd6a9fafabda30b5be3b199e1a2ecd86d15c177d83c35641b357161e8bec431e53d7db80f859db54971db20088c0e3449da349
-  data.tar.gz: 6bd93a4ab5c061c6d97b77eab76af68ae93675b584648742ce74c950177f76623c6e0691e07310692f22e40d09592bff78d40eead14a7ba5ce103d190f8e94a6
+  metadata.gz: 53ea80ca58d9f342fc04bc51385674ee5b5f8d3dd64a63a18869b5d4fdc81f8ac74c80a6901991d8709d65aeb565d19a5ca3cbeaa19e1a0408ab4ca9ce0dd154
+  data.tar.gz: dfbb24c4a439443db7e43d19f65b9964c86505eda6479fa6ec4ca75cba93b25cc619a6d845aa6ca16a822bc187c2f53f8cabdbf66d4ffae98dc9e93682324fbb

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,111 @@
+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)
+      source_label = source.is_a?(String) ? source : "stdin"
+      logger.info "push started: #{source_label} → #{@path}"
+
+      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
+        logger.info "received #{File.size(temp.path)} bytes, running integrity check"
+
+        db = SQLite3::Database.new(temp.path)
+        result = db.execute("PRAGMA integrity_check")
+        db.close
+        unless result == [["ok"]]
+          logger.error "integrity check failed for #{source_label}"
+          stderr.write("ERROR: integrity check failed\n")
+          return false
+        end
+
+        logger.info "integrity check passed, acquiring swap lock"
+        stderr.write("Swapping database...\n")
+
+        Middleware::SWAP_LOCK.synchronize do
+          if defined?(ActiveRecord::Base)
+            ActiveRecord::Base.connection_handler.clear_all_connections!
+            logger.info "disconnected ActiveRecord"
+          end
+          File.rename(temp.path, @path)
+          logger.info "renamed #{temp.path} → #{@path}"
+        end
+
+        if defined?(ActiveRecord::Base)
+          ActiveRecord::Base.establish_connection
+          logger.info "reconnected ActiveRecord"
+        end
+
+        logger.info "push complete: #{@path}"
+        stdout.write("OK\n")
+        true
+      rescue => e
+        logger.error "push failed: #{e.message}"
+        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)
+      dest_label = destination.is_a?(String) ? destination : "stdout"
+      logger.info "pull started: #{@path} → #{dest_label}"
+
+      unless File.exist?(@path)
+        logger.error "database file not found at #{@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
+        logger.info "backup complete: #{File.size(temp.path)} bytes"
+
+        if destination.is_a?(String)
+          FileUtils.cp(temp.path, destination)
+          logger.info "pull complete: #{@path} → #{destination}"
+          stderr.write("OK\n")
+        else
+          File.open(temp.path, "rb") { |f| IO.copy_stream(f, destination) }
+          logger.info "pull complete: #{@path} → stdout"
+        end
+        true
+      rescue => e
+        logger.error "pull failed: #{e.message}"
+        stderr.write("ERROR: #{e.message}\n")
+        false
+      ensure
+        temp.unlink if temp && File.exist?(temp.path)
+      end
+    end
+
+    private
+
+    def logger = Hotswap.logger
+  end
+end

data/lib/hotswap/railtie.rb

@@ -2,18 +2,26 @@ module Hotswap
   class Railtie < Rails::Railtie
     config.hotswap = ActiveSupport::OrderedOptions.new
 
+    initializer "hotswap.logger" do
+      Hotswap.logger = Rails.logger
+    end
+
     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/socket_server.rb

@@ -27,10 +27,15 @@ module Hotswap
 
       @thread = Thread.new { accept_loop }
       @thread.report_on_exception = false
+
+      logger.info "listening on #{@socket_path}"
+      logger.info "stderr socket on #{@stderr_socket_path}"
+      logger.info "managing #{Hotswap.databases.size} database(s): #{Hotswap.databases.map(&:path).join(', ')}"
       self
     end
 
     def stop
+      logger.info "shutting down"
       @server&.close
       @stderr_server&.close
       @thread&.kill
@@ -45,6 +50,8 @@ module Hotswap
 
     private
 
+    def logger = Hotswap.logger
+
     def accept_loop
       ios = [@server, @stderr_server]
       loop do
@@ -75,6 +82,7 @@ module Hotswap
 
     def handle_connection(socket)
       unless IO.select([socket], nil, nil, CONNECTION_TIMEOUT)
+        logger.warn "connection timed out"
         socket.write("ERROR: connection timeout\n") rescue nil
         return
       end
@@ -83,6 +91,7 @@ module Hotswap
       return unless line
 
       parts = Shellwords.split(line.strip)
+      logger.info "command: #{parts.join(' ')}" unless parts.empty?
 
       # Grab the stderr socket if one is waiting
       stderr_io = take_stderr_client
@@ -94,6 +103,7 @@ module Hotswap
         stderr: stderr_io || $stderr
       )
     rescue => e
+      logger.error "connection error: #{e.message}"
       socket.write("ERROR: #{e.message}\n") rescue nil
     ensure
       stderr_io&.close rescue nil

data/lib/hotswap/version.rb

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

data/lib/hotswap.rb

@@ -1,5 +1,7 @@
+require "logger"
 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 +10,43 @@ module Hotswap
   class Error < StandardError; end
 
   class << self
-    attr_accessor :database_path, :socket_path, :stderr_socket_path
+    attr_accessor :socket_path, :stderr_socket_path
+    attr_writer :logger
+
+    def logger
+      @logger ||= Logger.new($stdout, progname: "hotswap")
+    end
 
     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.1
 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