rubydb 0.1.0

data/lib/rubydb/recovery/redo.rb

@@ -0,0 +1,237 @@
+# frozen_string_literal: true
+
+module RubyDB
+  module Recovery
+    # Redo - Handles REDO operations during recovery
+    class Redo
+      attr_reader :stats
+
+      def initialize(engine, wal, config = {})
+        @engine = engine
+        @wal = wal
+        @config = config
+        @stats = {
+          redo_count: 0,
+          redo_failures: 0,
+          total_redo_time_ms: 0,
+          avg_redo_time_ms: 0,
+          last_redo_lsn: nil,
+          last_redo_time: nil
+        }
+        @lock = Mutex.new
+        @batch_size = config[:batch_size] || 1000
+      end
+
+      def redo_records(records, from_lsn = nil)
+        @lock.synchronize do
+          start_time = Time.now
+
+          # Filter records to redo
+          redo_records = records
+          if from_lsn
+            redo_records = redo_records.select { |r| r.lsn && r.lsn >= from_lsn }
+          end
+
+          # Group by transaction
+          grouped = group_by_transaction(redo_records)
+
+          # Process each transaction
+          count = 0
+          grouped.each do |transaction_id, transaction_records|
+            begin
+              count += redo_transaction(transaction_records)
+            rescue => e
+              @stats[:redo_failures] += 1
+              raise if @config[:stop_on_error]
+            end
+          end
+
+          elapsed_ms = (Time.now - start_time) * 1000
+          @stats[:redo_count] += count
+          @stats[:total_redo_time_ms] += elapsed_ms
+          @stats[:avg_redo_time_ms] = @stats[:total_redo_time_ms] / @stats[:redo_count] if @stats[:redo_count] > 0
+
+          if redo_records.any?
+            @stats[:last_redo_lsn] = redo_records.last.lsn
+            @stats[:last_redo_time] = Time.now
+          end
+
+          count
+        end
+      end
+
+      def redo_transaction(records)
+        count = 0
+
+        records.each do |record|
+          # Skip if already applied
+          next if already_applied?(record)
+
+          case record.type
+          when :insert
+            redo_insert(record)
+            count += 1
+          when :update
+            redo_update(record)
+            count += 1
+          when :delete
+            redo_delete(record)
+            count += 1
+          when :create_table
+            redo_create_table(record)
+            count += 1
+          when :drop_table
+            redo_drop_table(record)
+            count += 1
+          when :schema_change
+            redo_schema_change(record)
+            count += 1
+          end
+        end
+
+        count
+      end
+
+      def redo_insert(record)
+        data = record.data
+        return unless data
+
+        # Re-insert the row
+        table = data[:table]
+        columns = data[:columns] || []
+        values = data[:values] || {}
+
+        # Check if row already exists
+        existing = @engine.select_row(table, data[:row_id], columns) if data[:row_id]
+        if existing
+          # Update instead of insert
+          @engine.update_row(table, data[:row_id], values)
+        else
+          @engine.insert_row(table, columns, values)
+        end
+      end
+
+      def redo_update(record)
+        data = record.data
+        return unless data
+
+        # Re-apply the update
+        table = data[:table]
+        row_id = data[:row_id]
+        values = data[:values] || {}
+
+        @engine.update_row(table, row_id, values)
+      end
+
+      def redo_delete(record)
+        data = record.data
+        return unless data
+
+        # Re-delete the row
+        table = data[:table]
+        row_id = data[:row_id]
+
+        @engine.delete_row(table, row_id)
+      end
+
+      def redo_create_table(record)
+        data = record.data
+        return unless data
+
+        # Re-create the table
+        table_name = data[:table_name]
+        columns = data[:columns] || []
+
+        unless @engine.table_exists?(table_name)
+          @engine.create_table(table_name, columns)
+        end
+      end
+
+      def redo_drop_table(record)
+        data = record.data
+        return unless data
+
+        # Re-drop the table
+        table_name = data[:table_name]
+
+        if @engine.table_exists?(table_name)
+          @engine.drop_table(table_name)
+        end
+      end
+
+      def redo_schema_change(record)
+        data = record.data
+        return unless data
+
+        case data[:operation]
+        when :add_column
+          table = @engine.find_table(data[:table_name])
+          table.add_column(data[:column_name], data[:column_type]) if table
+        when :drop_column
+          table = @engine.find_table(data[:table_name])
+          table.drop_column(data[:column_name]) if table
+        when :rename_table
+          @engine.rename_table(data[:old_name], data[:new_name])
+        end
+      end
+
+      def already_applied?(record)
+        data = record.data || {}
+        case record.type
+        when :insert
+          return false unless data[:row_id]
+          !@engine.select_row(data[:table], data[:row_id], data[:columns] || []).nil?
+        when :update
+          row = data[:row_id] && @engine.select_row(data[:table], data[:row_id], data[:columns] || [])
+          row && data.fetch(:values, {}).all? { |key, value| row[key] == value || row[key.to_s] == value }
+        when :delete
+          data[:row_id] && @engine.select_row(data[:table], data[:row_id], data[:columns] || []).nil?
+        when :create_table
+          @engine.table_exists?(data[:table_name])
+        when :drop_table
+          !@engine.table_exists?(data[:table_name])
+        when :schema_change
+          schema_change_applied?(data)
+        else
+          false
+        end
+      rescue StandardError
+        false
+      end
+
+      def schema_change_applied?(data)
+        case data[:operation]
+        when :add_column
+          table = @engine.find_table(data[:table_name])
+          table && table.columns.any? { |column| column.name.to_s == data[:column_name].to_s }
+        when :drop_column
+          table = @engine.find_table(data[:table_name])
+          table && !table.columns.any? { |column| column.name.to_s == data[:column_name].to_s }
+        when :rename_table
+          @engine.table_exists?(data[:new_name]) && !@engine.table_exists?(data[:old_name])
+        else
+          false
+        end
+      end
+
+      def group_by_transaction(records)
+        groups = {}
+        records.each do |record|
+          tx_id = record.transaction_id
+          groups[tx_id] ||= []
+          groups[tx_id] << record
+        end
+        groups
+      end
+
+      def stats
+        @lock.synchronize do
+          @stats.merge({
+            batch_size: @batch_size,
+            last_redo_lsn: @stats[:last_redo_lsn]&.to_s
+          })
+        end
+      end
+    end
+  end
+end

data/lib/rubydb/recovery/undo.rb

@@ -0,0 +1,206 @@
+# frozen_string_literal: true
+
+module RubyDB
+  module Recovery
+    # Undo - Handles UNDO operations during recovery
+    class Undo
+      attr_reader :stats
+
+      def initialize(engine, wal, config = {})
+        @engine = engine
+        @wal = wal
+        @config = config
+        @stats = {
+          undo_count: 0,
+          undo_failures: 0,
+          total_undo_time_ms: 0,
+          avg_undo_time_ms: 0,
+          last_undo_lsn: nil,
+          last_undo_time: nil
+        }
+        @lock = Mutex.new
+        @batch_size = config[:batch_size] || 1000
+      end
+
+      def undo_records(records)
+        @lock.synchronize do
+          start_time = Time.now
+
+          # Group by transaction (undo in reverse order within transaction)
+          grouped = group_by_transaction(records)
+
+          # Process each transaction in reverse (LIFO)
+          count = 0
+          grouped.each do |transaction_id, transaction_records|
+            begin
+              # Undo in reverse order within transaction
+              count += undo_transaction(transaction_records.reverse)
+            rescue => e
+              @stats[:undo_failures] += 1
+              raise if @config[:stop_on_error]
+            end
+          end
+
+          elapsed_ms = (Time.now - start_time) * 1000
+          @stats[:undo_count] += count
+          @stats[:total_undo_time_ms] += elapsed_ms
+          @stats[:avg_undo_time_ms] = @stats[:total_undo_time_ms] / @stats[:undo_count] if @stats[:undo_count] > 0
+
+          if records.any?
+            @stats[:last_undo_lsn] = records.last.lsn
+            @stats[:last_undo_time] = Time.now
+          end
+
+          count
+        end
+      end
+
+      def undo_transaction(records)
+        count = 0
+
+        records.each do |record|
+          case record.type
+          when :insert
+            undo_insert(record)
+            count += 1
+          when :update
+            undo_update(record)
+            count += 1
+          when :delete
+            undo_delete(record)
+            count += 1
+          when :create_table
+            undo_create_table(record)
+            count += 1
+          when :drop_table
+            undo_drop_table(record)
+            count += 1
+          when :schema_change
+            undo_schema_change(record)
+            count += 1
+          end
+        end
+
+        count
+      end
+
+      def undo_insert(record)
+        data = record.data
+        return unless data
+
+        # Undo insert: delete the row
+        table = data[:table]
+        row_id = data[:row_id]
+
+        if row_id
+          # Get the row to verify it exists
+          columns = @engine.table_columns(table)
+          row = @engine.select_row(table, row_id, columns)
+          if row
+            @engine.delete_row(table, row_id)
+          end
+        end
+      end
+
+      def undo_update(record)
+        data = record.data
+        return unless data
+
+        # Undo update: restore old values
+        table = data[:table]
+        row_id = data[:row_id]
+        old_values = data[:old_values]
+
+        if row_id && old_values
+          # Verify the row still exists with the expected values
+          columns = @engine.table_columns(table)
+          current_row = @engine.select_row(table, row_id, columns)
+          if current_row
+            @engine.update_row(table, row_id, old_values)
+          end
+        end
+      end
+
+      def undo_delete(record)
+        data = record.data
+        return unless data
+
+        # Undo delete: reinsert the row
+        table = data[:table]
+        columns = data[:columns] || []
+        row_data = data[:row_data] || {}
+
+        if table && row_data.any?
+          # Check if row still exists
+          existing = @engine.select_row(table, data[:row_id], columns) if data[:row_id]
+          unless existing
+            @engine.insert_row(table, columns, row_data)
+          end
+        end
+      end
+
+      def undo_create_table(record)
+        data = record.data
+        return unless data
+
+        # Undo create table: drop the table
+        table_name = data[:table_name]
+
+        if @engine.table_exists?(table_name)
+          @engine.drop_table(table_name)
+        end
+      end
+
+      def undo_drop_table(record)
+        data = record.data
+        return unless data
+
+        # Undo drop table: re-create the table
+        table_name = data[:table_name]
+        columns = data[:columns] || []
+
+        unless @engine.table_exists?(table_name)
+          @engine.create_table(table_name, columns)
+        end
+      end
+
+      def undo_schema_change(record)
+        data = record.data
+        return unless data
+
+        case data[:operation]
+        when :add_column
+          # Undo add column: drop the column
+          table = @engine.find_table(data[:table_name])
+          table.drop_column(data[:column_name]) if table
+        when :drop_column
+          # Undo drop column: add the column back
+          table = @engine.find_table(data[:table_name])
+          table.add_column(data[:column_name], data[:column_type]) if table
+        when :rename_table
+          # Undo rename table: rename back
+          @engine.rename_table(data[:new_name], data[:old_name])
+        end
+      end
+
+      def group_by_transaction(records)
+        groups = {}
+        records.each do |record|
+          tx_id = record.transaction_id
+          groups[tx_id] ||= []
+          groups[tx_id] << record
+        end
+        groups
+      end
+
+      def stats
+        @lock.synchronize do
+          @stats.merge({
+            batch_size: @batch_size,
+            last_undo_lsn: @stats[:last_undo_lsn]&.to_s
+          })
+        end
+      end
+    end
+  end
+end

data/lib/rubydb/replication/failover.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+# Failover is defined alongside the replication-slot catalog. This public
+# require target keeps direct consumers independent of load order.
+require_relative "replication_slot"

data/lib/rubydb/replication/fencing.rb

@@ -0,0 +1,63 @@
+# frozen_string_literal: true
+
+require "json"
+require "fileutils"
+
+module RubyDB
+  module Replication
+    # File-backed fencing lease. The fence path must live on storage shared by
+    # all nodes that can write the same database. Epoch changes are atomic and
+    # stale writers fail closed when their lease no longer matches.
+    class FencingLease
+      attr_reader :path, :node_id, :epoch
+
+      def initialize(path, node_id)
+        @path = path
+        @node_id = node_id.to_s
+        @epoch = nil
+      end
+
+      def acquire!
+        FileUtils.mkdir_p(File.dirname(@path))
+        File.open("#{@path}.lock", "a+") do |lock|
+          lock.flock(File::LOCK_EX)
+          current = read_record
+          @epoch = current ? current.fetch("epoch").to_i + 1 : 1
+          temporary = "#{@path}.tmp-#{Process.pid}-#{Thread.current.object_id}"
+          File.open(temporary, "wb") do |file|
+            file.write(JSON.generate(node_id: @node_id, epoch: @epoch, updated_at: Time.now.utc.iso8601))
+            file.flush
+            file.fsync
+          end
+          File.rename(temporary, @path)
+        ensure
+          File.delete(temporary) if defined?(temporary) && File.file?(temporary)
+          lock.flock(File::LOCK_UN)
+        end
+        self
+      rescue KeyError, JSON::ParserError, SystemCallError => e
+        raise RubyDB::ReplicationError, "Unable to acquire fencing lease: #{e.message}"
+      end
+
+      def valid?
+        return false unless @epoch
+        record = read_record
+        record && record["node_id"].to_s == @node_id && record["epoch"].to_i == @epoch
+      rescue JSON::ParserError, SystemCallError
+        false
+      end
+
+      def assert_valid!
+        raise RubyDB::ReplicationError, "Fencing lease is missing or stale" unless valid?
+        true
+      end
+
+      private
+
+      def read_record
+        return nil unless File.file?(@path)
+        JSON.parse(File.read(@path))
+      end
+    end
+  end
+end