rubydb 0.1.4 → 0.1.5

data/lib/rubydb/migrations/migration_lock.rb

@@ -1,146 +1,146 @@
-# frozen_string_literal: true
-
-require "time"
-require "fileutils"
-require "monitor"
-
-module RubyDB
-  module Migrations
-    # MigrationLock - Prevents concurrent migrations
-    class MigrationLock
-      attr_reader :stats
-
-      def initialize(engine, config = {})
-        @engine = engine
-        @config = config
-        @lock_table = config[:lock_table] || "migration_lock"
-        @lock_path = config[:lock_path] || "#{engine.path}.migration.lock"
-        @lock_timeout = config[:lock_timeout] || 300 # 5 minutes
-        @lock_acquired = false
-        @lock_id = nil
-        @lock_holder = nil
-        @lock_acquired_at = nil
-        @stats = {
-          locks_acquired: 0,
-          locks_released: 0,
-          locks_failed: 0,
-          lock_contention: 0,
-          lock_timeouts: 0
-        }
-        @lock = Monitor.new
-        @lock_file = nil
-      end
-
-      def acquire_lock
-        @lock.synchronize do
-          return true if @lock_acquired
-
-          @stats[:locks_acquired] += 1
-
-          # Check if lock exists
-          if lock_exists?
-            owner, acquired_at = get_lock_info
-
-            # Check if lock is stale
-            if Time.now - acquired_at > @lock_timeout
-              # Force release stale lock
-              release_lock_force
-              @stats[:lock_timeouts] += 1
-            else
-              @stats[:lock_contention] += 1
-              @stats[:locks_failed] += 1
-              return false
-            end
-          end
-
-          # Acquire lock
-          begin
-            acquire_lock_force
-          rescue Errno::EACCES, Errno::EAGAIN, Errno::EWOULDBLOCK
-            @stats[:lock_contention] += 1
-            @stats[:locks_failed] += 1
-            return false
-          end
-          @lock_acquired = true
-          @lock_acquired_at = Time.now
-          @lock_id = generate_lock_id
-
-          true
-        end
-      end
-
-      def release_lock
-        @lock.synchronize do
-          return false unless @lock_acquired
-
-          release_lock_force
-          @lock_acquired = false
-          @lock_id = nil
-          @lock_acquired_at = nil
-          @stats[:locks_released] += 1
-
-          true
-        end
-      end
-
-      def lock_acquired?
-        @lock_acquired
-      end
-
-      def lock_holder
-        @lock.synchronize do
-          return nil unless lock_exists?
-          get_lock_info
-        end
-      end
-
-      def lock_age
-        @lock.synchronize do
-          return nil unless @lock_acquired
-          Time.now - @lock_acquired_at
-        end
-      end
-
-      def stats
-        @lock.synchronize do
-          @stats.merge({
-            lock_acquired: @lock_acquired,
-            lock_id: @lock_id,
-            lock_age: lock_age
-          })
-        end
-      end
-
-      private
-
-      def lock_exists?
-        !@lock_file.nil?
-      end
-
-      def get_lock_info
-        [@lock_id || "external", @lock_acquired_at || Time.now]
-      end
-
-      def acquire_lock_force
-        FileUtils.mkdir_p(File.dirname(@lock_path))
-        file = File.open(@lock_path, "a+")
-        unless file.flock(File::LOCK_EX | File::LOCK_NB)
-          file.close
-          raise Errno::EWOULDBLOCK
-        end
-        @lock_file = file
-      end
-
-      def release_lock_force
-        return unless @lock_file
-        @lock_file.flock(File::LOCK_UN)
-        @lock_file.close
-        @lock_file = nil
-      end
-
-      def generate_lock_id
-        "lock_#{Time.now.to_i}_#{rand(10000)}"
-      end
-    end
-  end
-end
+# frozen_string_literal: true
+
+require "time"
+require "fileutils"
+require "monitor"
+
+module RubyDB
+  module Migrations
+    # MigrationLock - Prevents concurrent migrations
+    class MigrationLock
+      attr_reader :stats
+
+      def initialize(engine, config = {})
+        @engine = engine
+        @config = config
+        @lock_table = config[:lock_table] || "migration_lock"
+        @lock_path = config[:lock_path] || "#{engine.path}.migration.lock"
+        @lock_timeout = config[:lock_timeout] || 300 # 5 minutes
+        @lock_acquired = false
+        @lock_id = nil
+        @lock_holder = nil
+        @lock_acquired_at = nil
+        @stats = {
+          locks_acquired: 0,
+          locks_released: 0,
+          locks_failed: 0,
+          lock_contention: 0,
+          lock_timeouts: 0
+        }
+        @lock = Monitor.new
+        @lock_file = nil
+      end
+
+      def acquire_lock
+        @lock.synchronize do
+          return true if @lock_acquired
+
+          @stats[:locks_acquired] += 1
+
+          # Check if lock exists
+          if lock_exists?
+            _, acquired_at = get_lock_info
+
+            # Check if lock is stale
+            if Time.now - acquired_at > @lock_timeout
+              # Force release stale lock
+              release_lock_force
+              @stats[:lock_timeouts] += 1
+            else
+              @stats[:lock_contention] += 1
+              @stats[:locks_failed] += 1
+              return false
+            end
+          end
+
+          # Acquire lock
+          begin
+            acquire_lock_force
+          rescue Errno::EACCES, Errno::EAGAIN, Errno::EWOULDBLOCK
+            @stats[:lock_contention] += 1
+            @stats[:locks_failed] += 1
+            return false
+          end
+          @lock_acquired = true
+          @lock_acquired_at = Time.now
+          @lock_id = generate_lock_id
+
+          true
+        end
+      end
+
+      def release_lock
+        @lock.synchronize do
+          return false unless @lock_acquired
+
+          release_lock_force
+          @lock_acquired = false
+          @lock_id = nil
+          @lock_acquired_at = nil
+          @stats[:locks_released] += 1
+
+          true
+        end
+      end
+
+      def lock_acquired?
+        @lock_acquired
+      end
+
+      def lock_holder
+        @lock.synchronize do
+          return nil unless lock_exists?
+          get_lock_info
+        end
+      end
+
+      def lock_age
+        @lock.synchronize do
+          return nil unless @lock_acquired
+          Time.now - @lock_acquired_at
+        end
+      end
+
+      def stats
+        @lock.synchronize do
+          @stats.merge({
+            lock_acquired: @lock_acquired,
+            lock_id: @lock_id,
+            lock_age: lock_age
+          })
+        end
+      end
+
+      private
+
+      def lock_exists?
+        !@lock_file.nil?
+      end
+
+      def get_lock_info
+        [@lock_id || "external", @lock_acquired_at || Time.now]
+      end
+
+      def acquire_lock_force
+        FileUtils.mkdir_p(File.dirname(@lock_path))
+        file = File.open(@lock_path, "a+")
+        unless file.flock(File::LOCK_EX | File::LOCK_NB)
+          file.close
+          raise Errno::EWOULDBLOCK
+        end
+        @lock_file = file
+      end
+
+      def release_lock_force
+        return unless @lock_file
+        @lock_file.flock(File::LOCK_UN)
+        @lock_file.close
+        @lock_file = nil
+      end
+
+      def generate_lock_id
+        "lock_#{Time.now.to_i}_#{rand(10000)}"
+      end
+    end
+  end
+end

data/lib/rubydb/migrations/migration_manager.rb

@@ -1,176 +1,187 @@
-# frozen_string_literal: true
-
-require "fileutils"
-require "time"
-
-module RubyDB
-  module Migrations
-    class MigrationError < StandardError; end unless const_defined?(:MigrationError)
-
-    # Loads and applies migrations with durable version tracking and a
-    # cross-process lock. Migration files must evaluate to a Migration.
-    class MigrationManager
-      attr_reader :database, :engine, :migrations, :stats
-
-      def initialize(database, options = {})
-        @database = database
-        @engine = database.respond_to?(:engine) ? database.engine : database
-        @options = options
-        @migration_path = options[:path] || options[:migrations_path] || "db/migrate"
-        @migrations = options[:migrations] || load_migrations
-        @lock = MigrationLock.new(@engine, options)
-        @stats = { applied: 0, rolled_back: 0, failed: 0 }
-      end
-
-      def migrate
-        with_lock do
-          ensure_schema
-          applied = applied_versions
-          validate_applied_migrations(applied)
-          target = target_version
-          pending = ordered_migrations.reject { |migration| applied.key?(migration.version.to_s) }
-          pending = pending.select { |migration| migration_key(migration.version) <= migration_key(target) } if target
-          apply_migrations(pending)
-        end
-      end
-
-      def rollback(steps = 1)
-        raise ArgumentError, "steps must be a positive integer" unless steps.is_a?(Integer) && steps.positive?
-
-        with_lock do
-          ensure_schema
-          applied = applied_versions
-          validate_applied_migrations(applied)
-          to_rollback = ordered_migrations.select { |m| applied.key?(m.version.to_s) }
-                                      .sort_by { |m| migration_key(m.version) }
-                                      .reverse
-                                      .first(steps)
-          to_rollback.each { |migration| rollback_migration(migration) }
-          to_rollback
-        end
-      end
-
-      def status
-        ensure_schema
-        applied = applied_versions
-        ordered_migrations.map do |migration|
-          record = applied[migration.version.to_s]
-          { version: migration.version.to_s, name: migration.name,
-            state: record ? :applied : :pending, checksum: record && record[:checksum] }
-        end
-      end
-
-      private
-
-      def with_lock
-        raise MigrationError, "could not acquire migration lock" unless @lock.acquire_lock
-        yield
-      ensure
-        @lock.release_lock if @lock&.lock_acquired?
-      end
-
-      def ensure_schema
-        @database.execute("CREATE TABLE IF NOT EXISTS schema_migrations (version TEXT PRIMARY KEY, migration_name TEXT, applied_at TIMESTAMP, checksum TEXT)")
-        ensure_column("migration_name", "TEXT")
-        ensure_column("checksum", "TEXT")
-      end
-
-      def ensure_column(name, type)
-        @database.execute("ALTER TABLE schema_migrations ADD COLUMN #{name} #{type}")
-      rescue StandardError => error
-        raise unless error.message =~ /already exists|duplicate|exists/i
-      end
-
-      def applied_versions
-        rows = @database.query("SELECT version, migration_name, checksum FROM schema_migrations")
-        Array(rows).each_with_object({}) do |row, result|
-          version = row[:version] || row["version"]
-          result[version.to_s] = { name: row[:migration_name] || row["migration_name"], checksum: row[:checksum] || row["checksum"] }
-        end
-      end
-
-      def apply_migrations(migrations)
-        migrations.each do |migration|
-          existing = applied_versions[migration.version.to_s]
-          if existing && existing[:checksum] && existing[:checksum] != migration_checksum(migration)
-            raise MigrationError, "migration checksum mismatch for #{migration.version}"
-          end
-
-          begin
-            @database.transaction do
-              migration.apply_up(@engine)
-              insert_version(migration)
-            end
-            @stats[:applied] += 1
-          rescue StandardError
-            migration.mark_failed
-            @stats[:failed] += 1
-            raise
-          end
-        end
-      end
-
-      def rollback_migration(migration)
-        @database.transaction do
-          migration.apply_down(@engine)
-          @database.execute("DELETE FROM schema_migrations WHERE version = #{quote(migration.version.to_s)}")
-        end
-        @stats[:rolled_back] += 1
-      end
-
-      def insert_version(migration)
-        values = [migration.version.to_s, migration.name.to_s, Time.now.iso8601, migration_checksum(migration)].map { |v| quote(v) }
-        @database.execute("INSERT INTO schema_migrations (version, migration_name, applied_at, checksum) VALUES (#{values.join(', ')})")
-      end
-
-      def quote(value)
-        "'#{value.to_s.gsub("'", "''")}'"
-      end
-
-      def ordered_migrations
-        @migrations.sort_by { |migration| migration_key(migration.version) }
-      end
-
-      def migration_key(version)
-        version.to_s =~ /\A\d+\z/ ? version.to_i : version.to_s
-      end
-
-      def target_version
-        @options[:version]
-      end
-
-      def migration_checksum(migration)
-        migration.checksum
-      end
-
-      def validate_applied_migrations(applied)
-        migrations_by_version = @migrations.each_with_object({}) do |migration, result|
-          result[migration.version.to_s] = migration
-        end
-
-        applied.each do |version, record|
-          migration = migrations_by_version[version]
-          raise MigrationError, "applied migration #{version} is missing from the migration path" unless migration
-
-          expected = migration_checksum(migration)
-          recorded = record[:checksum].to_s
-          unless recorded.empty? || recorded == expected
-            raise MigrationError, "migration checksum mismatch for #{version}"
-          end
-        end
-      end
-
-      def load_migrations
-        return [] unless Dir.exist?(@migration_path)
-
-        Dir.glob(File.join(@migration_path, "*.rb")).sort.map do |path|
-          migration = eval(File.read(path), TOPLEVEL_BINDING, path, 1)
-          unless migration.is_a?(Migration)
-            raise MigrationError, "#{path} must evaluate to a Migration"
-          end
-          migration
-        end
-      end
-    end
-  end
-end
+# frozen_string_literal: true
+
+require "fileutils"
+require "time"
+
+module RubyDB
+  module Migrations
+    class MigrationError < StandardError; end unless const_defined?(:MigrationError)
+
+    # Loads and applies migrations with durable version tracking and a
+    # cross-process lock. Migration files must evaluate to a Migration.
+    class MigrationManager
+      attr_reader :database, :engine, :migrations, :stats
+
+      def initialize(database, options = {})
+        @database = database
+        @engine = database.respond_to?(:engine) ? database.engine : database
+        @options = options
+        @migration_path = File.expand_path(options[:path] || options[:migrations_path] || "db/migrate")
+        @migrations = options[:migrations] || load_migrations
+        @lock = MigrationLock.new(@engine, options)
+        @stats = {applied: 0, rolled_back: 0, failed: 0}
+      end
+
+      def migrate
+        with_lock do
+          ensure_schema
+          applied = applied_versions
+          validate_applied_migrations(applied)
+          target = target_version
+          pending = ordered_migrations.reject { |migration| applied.key?(migration.version.to_s) }
+          pending = pending.select { |migration| migration_key(migration.version) <= migration_key(target) } if target
+          apply_migrations(pending)
+        end
+      end
+
+      def rollback(steps = 1)
+        raise ArgumentError, "steps must be a positive integer" unless steps.is_a?(Integer) && steps.positive?
+
+        with_lock do
+          ensure_schema
+          applied = applied_versions
+          validate_applied_migrations(applied)
+          to_rollback = ordered_migrations.select { |m| applied.key?(m.version.to_s) }
+            .sort_by { |m| migration_key(m.version) }
+            .reverse
+            .first(steps)
+          to_rollback.each { |migration| rollback_migration(migration) }
+          to_rollback
+        end
+      end
+
+      def status
+        ensure_schema
+        applied = applied_versions
+        ordered_migrations.map do |migration|
+          record = applied[migration.version.to_s]
+          {version: migration.version.to_s, name: migration.name,
+           state: record ? :applied : :pending, checksum: record && record[:checksum]}
+        end
+      end
+
+      private
+
+      def with_lock
+        raise MigrationError, "could not acquire migration lock" unless @lock.acquire_lock
+        yield
+      ensure
+        @lock.release_lock if @lock&.lock_acquired?
+      end
+
+      def ensure_schema
+        @database.execute("CREATE TABLE IF NOT EXISTS schema_migrations (version TEXT PRIMARY KEY, migration_name TEXT, applied_at TIMESTAMP, checksum TEXT)")
+        ensure_column("migration_name", "TEXT")
+        ensure_column("checksum", "TEXT")
+      end
+
+      def ensure_column(name, type)
+        @database.execute("ALTER TABLE schema_migrations ADD COLUMN #{name} #{type}")
+      rescue => error
+        raise unless error.message =~ /already exists|duplicate|exists/i
+      end
+
+      def applied_versions
+        rows = @database.query("SELECT version, migration_name, checksum FROM schema_migrations")
+        Array(rows).each_with_object({}) do |row, result|
+          version = row[:version] || row["version"]
+          result[version.to_s] = {name: row[:migration_name] || row["migration_name"], checksum: row[:checksum] || row["checksum"]}
+        end
+      end
+
+      def apply_migrations(migrations)
+        migrations.each do |migration|
+          existing = applied_versions[migration.version.to_s]
+          if existing && existing[:checksum] && existing[:checksum] != migration_checksum(migration)
+            raise MigrationError, "migration checksum mismatch for #{migration.version}"
+          end
+
+          begin
+            @database.transaction do
+              migration.apply_up(@engine)
+              insert_version(migration)
+            end
+            @stats[:applied] += 1
+          rescue
+            migration.mark_failed
+            @stats[:failed] += 1
+            raise
+          end
+        end
+      end
+
+      def rollback_migration(migration)
+        @database.transaction do
+          migration.apply_down(@engine)
+          @database.execute("DELETE FROM schema_migrations WHERE version = #{quote(migration.version.to_s)}")
+        end
+        @stats[:rolled_back] += 1
+      end
+
+      def insert_version(migration)
+        values = [migration.version.to_s, migration.name.to_s, Time.now.iso8601, migration_checksum(migration)].map { |v| quote(v) }
+        @database.execute("INSERT INTO schema_migrations (version, migration_name, applied_at, checksum) VALUES (#{values.join(", ")})")
+      end
+
+      def quote(value)
+        "'#{value.to_s.gsub("'", "''")}'"
+      end
+
+      def ordered_migrations
+        @migrations.sort_by { |migration| migration_key(migration.version) }
+      end
+
+      def migration_key(version)
+        (version.to_s =~ /\A\d+\z/) ? version.to_i : version.to_s
+      end
+
+      def target_version
+        @options[:version]
+      end
+
+      def migration_checksum(migration)
+        migration.checksum
+      end
+
+      def validate_applied_migrations(applied)
+        migrations_by_version = @migrations.each_with_object({}) do |migration, result|
+          result[migration.version.to_s] = migration
+        end
+
+        applied.each do |version, record|
+          migration = migrations_by_version[version]
+          raise MigrationError, "applied migration #{version} is missing from the migration path" unless migration
+
+          expected = migration_checksum(migration)
+          recorded = record[:checksum].to_s
+          unless recorded.empty? || recorded == expected
+            raise MigrationError, "migration checksum mismatch for #{version}"
+          end
+        end
+      end
+
+      def load_migrations
+        return [] unless Dir.exist?(@migration_path)
+
+        migration_root = File.realpath(@migration_path)
+        Dir.glob(File.join(migration_root, "*.rb")).sort.map do |path|
+          path = File.realpath(path)
+          unless File.dirname(path) == migration_root
+            raise MigrationError, "migration path escapes #{@migration_path}: #{path}"
+          end
+
+          # Migration files are trusted deployment code, like Rails migrations.
+          # The root and every file are resolved above so a symlink cannot make
+          # the loader execute Ruby from outside the configured migration tree.
+          # rubocop:disable Security/Eval
+          migration = eval(File.binread(path), TOPLEVEL_BINDING, path, 1)
+          # rubocop:enable Security/Eval
+          unless migration.is_a?(Migration)
+            raise MigrationError, "#{path} must evaluate to a Migration"
+          end
+          migration
+        end
+      end
+    end
+  end
+end