rubydb 0.1.0

data/lib/rubydb/replication/replication_manager.rb

@@ -0,0 +1,308 @@
+# frozen_string_literal: true
+
+require "thread"
+require "time"
+require "monitor"
+
+module RubyDB
+  module Replication
+    # ReplicationManager - Manages replication setup and coordination
+    class ReplicationManager
+      attr_reader :config, :primary, :replica, :stats, :mode
+
+      # Replication modes
+      MODE_OFF = :off
+      MODE_PRIMARY = :primary
+      MODE_REPLICA = :replica
+      MODE_STANDBY = :standby
+
+      def initialize(engine, config = {})
+        @engine = engine
+        @config = config
+        @mode = config[:mode] || MODE_OFF
+        @cluster_name = config[:cluster_name] || "rubydb_cluster"
+        @node_id = config[:node_id] || generate_node_id
+        @primary_host = config[:primary_host]
+        @primary_port = config[:primary_port] || 7433
+        @replication_port = config[:replication_port] || 7434
+
+        @primary = nil
+        @replica = nil
+        @replication_slots = {}
+        @health_checks = []
+        @stats = {
+          mode: @mode,
+          node_id: @node_id,
+          cluster_name: @cluster_name,
+          healthy: true,
+          last_health_check: nil,
+          failovers: 0,
+          switches: 0,
+          errors: 0
+        }
+        @lock = Monitor.new
+        @running = false
+        @health_thread = nil
+        @health_check_interval = config[:health_check_interval] || 10
+
+        # Initialize based on mode
+        initialize_mode
+      end
+
+      def start
+        @lock.synchronize do
+          return if @running
+
+          @running = true
+
+          case @mode
+          when MODE_PRIMARY
+            @primary&.start
+          when MODE_REPLICA
+            @replica&.start
+          end
+
+          # Start health check
+          start_health_check
+
+          puts "Replication manager started in #{@mode} mode"
+          true
+        end
+      end
+
+      def stop
+        @lock.synchronize do
+          return unless @running
+
+          @running = false
+
+          @health_thread&.kill
+          @health_thread = nil
+
+          @primary&.stop
+          @replica&.stop
+
+          puts "Replication manager stopped"
+          true
+        end
+      end
+
+      def switch_mode(new_mode, config = {})
+        @lock.synchronize do
+          old_mode = @mode
+
+          # Stop current mode
+          stop
+
+          # Update config
+          @mode = new_mode
+          @config = @config.merge(config)
+
+          # Initialize new mode
+          initialize_mode
+
+          # Start new mode
+          start
+
+          @stats[:switches] += 1
+
+          { old_mode: old_mode, new_mode: new_mode }
+        end
+      end
+
+      def promote_to_primary(recovery_point: nil)
+        @lock.synchronize do
+          if @mode != MODE_REPLICA
+            return { success: false, error: "Not in replica mode" }
+          end
+
+          status = @replica&.replication_status
+          promotable_state = status && [
+            Replica::STATE_STREAMING,
+            Replica::STATE_SYNCED,
+            Replica::STATE_DISCONNECTED,
+            Replica::STATE_CONNECTING
+          ].include?(status[:state])
+          caught_up_after_disconnect = status &&
+                                       status[:last_replayed_lsn] &&
+                                       status[:last_received_lsn] == status[:last_replayed_lsn]
+          unless promotable_state && (status[:state] == Replica::STATE_STREAMING ||
+                                      status[:state] == Replica::STATE_SYNCED ||
+                                      caught_up_after_disconnect)
+            return { success: false, error: "Replica is not synchronized enough for manual promotion" }
+          end
+
+          if status[:last_received_lsn] != status[:last_replayed_lsn]
+            return {
+              success: false,
+              error: "Replica has unapplied replication data; promotion requires a caught-up recovery point"
+            }
+          end
+
+          if recovery_point && status[:last_replayed_lsn].to_i < recovery_point.to_i
+            return { success: false, error: "Replica has not reached recovery point #{recovery_point}" }
+          end
+
+          # Promote replica to primary. Automatic promotion is intentionally
+          # not attempted; callers must explicitly invoke this operation.
+          begin
+            @replica&.promote_to_primary(recovery_point: recovery_point)
+          rescue ReplicationError => e
+            return { success: false, error: e.message }
+          end
+
+          # Switch mode
+          @mode = MODE_PRIMARY
+
+          # Create new primary
+          @primary = Primary.new(@engine, @config)
+          @primary.start
+
+          @replica = nil
+          @stats[:failovers] += 1
+
+          { success: true, message: "Promoted to primary" }
+        end
+      end
+
+      def demote_to_replica(primary_host, primary_port = nil)
+        @lock.synchronize do
+          if @mode != MODE_PRIMARY
+            return { success: false, error: "Not in primary mode" }
+          end
+
+          # Stop primary
+          @primary&.stop
+
+          # Update config
+          @config[:primary_host] = primary_host
+          @config[:primary_port] = primary_port if primary_port
+          @mode = MODE_REPLICA
+
+          # Create new replica
+          @replica = Replica.new(@engine, @config)
+          @replica.start
+
+          @primary = nil
+          @stats[:switches] += 1
+
+          { success: true, message: "Demoted to replica" }
+        end
+      end
+
+      def health_check
+        @lock.synchronize do
+          @stats[:last_health_check] = Time.now
+
+          result = case @mode
+          when MODE_PRIMARY
+            check_primary_health
+          when MODE_REPLICA
+            check_replica_health
+          else
+            { healthy: true, message: "Not in active replication mode" }
+          end
+
+          @stats[:healthy] = result[:healthy]
+          @health_checks << result
+
+          # Trim health checks
+          if @health_checks.size > 100
+            @health_checks.shift
+          end
+
+          result
+        end
+      end
+
+      def get_replication_status
+        @lock.synchronize do
+          status = {
+            mode: @mode,
+            node_id: @node_id,
+            cluster_name: @cluster_name,
+            running: @running,
+            healthy: @stats[:healthy],
+            last_health_check: @stats[:last_health_check]&.iso8601
+          }
+
+          case @mode
+          when MODE_PRIMARY
+            status[:primary] = @primary&.get_replication_status
+          when MODE_REPLICA
+            status[:replica] = @replica&.replication_status
+          end
+
+          status
+        end
+      end
+
+      def stats
+        @lock.synchronize do
+          @stats.merge({
+            running: @running,
+            health_checks: @health_checks.size,
+            mode: @mode,
+            node_id: @node_id
+          })
+        end
+      end
+
+      private
+
+      def generate_node_id
+        "node_#{Time.now.to_i}_#{rand(10000)}"
+      end
+
+      def initialize_mode
+        case @mode
+        when MODE_PRIMARY
+          @primary = Primary.new(@engine, @config)
+        when MODE_REPLICA
+          unless @config[:primary_host]
+            raise ConfigError, "Primary host required for replica mode"
+          end
+          @replica = Replica.new(@engine, @config)
+        when MODE_OFF, MODE_STANDBY
+          # No replication
+        else
+          @mode = MODE_OFF
+        end
+      end
+
+      def start_health_check
+        @health_thread = Thread.new do
+          while @running
+            sleep(@health_check_interval)
+            begin
+              health_check
+            rescue => e
+              @stats[:errors] += 1
+            end
+          end
+        end
+      end
+
+      def check_primary_health
+        if @primary&.running?
+          { healthy: true, message: "Primary is running" }
+        else
+          { healthy: false, message: "Primary is not running" }
+        end
+      end
+
+      def check_replica_health
+        if @replica&.running?
+          status = @replica.replication_status
+          if status[:state] == :failed
+            { healthy: false, message: "Replica in failed state" }
+          else
+            { healthy: true, message: "Replica is running" }
+          end
+        else
+          { healthy: false, message: "Replica is not running" }
+        end
+      end
+    end
+  end
+end

data/lib/rubydb/replication/replication_slot.rb

@@ -0,0 +1,295 @@
+# frozen_string_literal: true
+
+require "time"
+require "set"
+
+module RubyDB
+  module Replication
+    # Durable slot state is represented by the primary while the replication
+    # catalog is still file-backed. A slot retains the last acknowledged LSN
+    # and prevents accidental reuse of a replica identity.
+    class ReplicationSlot
+      attr_reader :name, :primary
+      attr_accessor :confirmed_lsn
+
+      def initialize(name, primary)
+        @name = name.to_s
+        @primary = primary
+        @confirmed_lsn = 0
+      end
+
+      def advance(lsn)
+        @confirmed_lsn = [@confirmed_lsn, lsn.to_i].max
+      end
+    end
+
+    # Failover - Handles automatic failover
+    class Failover
+      attr_reader :stats
+
+      # Failover states
+      STATE_NORMAL = :normal
+      STATE_HEALTH_CHECK = :health_check
+      STATE_DETECTED = :detected
+      STATE_FAILING_OVER = :failing_over
+      STATE_PROMOTING = :promoting
+      STATE_VERIFYING = :verifying
+      STATE_COMPLETE = :complete
+      STATE_FAILED = :failed
+
+      def initialize(replication_manager, config = {})
+        @replication_manager = replication_manager
+        @config = config
+        @state = STATE_NORMAL
+        @failover_triggered = false
+        @failover_start_time = nil
+        @candidate_replicas = []
+        @chosen_candidate = nil
+        @health_check_history = []
+        @stats = {
+          failovers: 0,
+          successful_failovers: 0,
+          failed_failovers: 0,
+          total_failover_time_ms: 0,
+          avg_failover_time_ms: 0,
+          last_failover_time: nil,
+          last_failover_result: nil,
+          health_check_failures: 0,
+          consecutive_failures: 0
+        }
+        @lock = Mutex.new
+        @running = false
+        @failover_thread = nil
+        @failover_timeout = config[:timeout] || 30
+        @check_interval = config[:check_interval] || 5
+        @max_consecutive_failures = config[:max_consecutive_failures] || 3
+        @failover_trigger = config[:trigger] || :auto
+      end
+
+      def start
+        @lock.synchronize do
+          return if @running
+
+          @running = true
+          @state = STATE_NORMAL
+          @failover_thread = Thread.new { failover_loop }
+
+          puts "Failover handler started"
+          true
+        end
+      end
+
+      def stop
+        @lock.synchronize do
+          return unless @running
+
+          @running = false
+
+          @failover_thread&.kill
+          @failover_thread = nil
+
+          puts "Failover handler stopped"
+          true
+        end
+      end
+
+      def trigger_failover(reason = "manual trigger")
+        @lock.synchronize do
+          return false if @failover_triggered
+
+          @failover_triggered = true
+          @failover_start_time = Time.now
+          @stats[:failovers] += 1
+
+          Thread.new do
+            execute_failover(reason)
+          end
+
+          true
+        end
+      end
+
+      def health_check
+        trigger_reason = nil
+        result = @lock.synchronize do
+          result = @replication_manager.health_check
+
+          @health_check_history << {
+            timestamp: Time.now,
+            result: result
+          }
+
+          if @health_check_history.size > 100
+            @health_check_history.shift
+          end
+
+          if result[:healthy] == false
+            @stats[:health_check_failures] += 1
+            @stats[:consecutive_failures] += 1
+
+            if @stats[:consecutive_failures] >= @max_consecutive_failures &&
+               @failover_trigger == :auto &&
+               !@failover_triggered
+              trigger_reason = "health check failures"
+            end
+          else
+            @stats[:consecutive_failures] = 0
+          end
+
+          result
+        end
+        trigger_failover(trigger_reason) if trigger_reason
+        result
+      end
+
+      def stats
+        @lock.synchronize do
+          @stats.merge({
+            state: @state,
+            running: @running,
+            failover_triggered: @failover_triggered,
+            consecutive_failures: @stats[:consecutive_failures],
+            health_check_history_size: @health_check_history.size
+          })
+        end
+      end
+
+      private
+
+      def failover_loop
+        while @running
+          sleep(@check_interval)
+          begin
+            health_check
+          rescue => e
+            # Log error but continue
+          end
+        end
+      end
+
+      def execute_failover(reason)
+        @lock.synchronize do
+          @state = STATE_DETECTED
+          start_time = Time.now
+
+          begin
+            # Step 1: Find candidate replicas
+            @state = STATE_HEALTH_CHECK
+            candidates = find_candidate_replicas
+
+            if candidates.empty?
+              @state = STATE_FAILED
+              @stats[:failed_failovers] += 1
+              return failover_result(false, "No candidate replicas found")
+            end
+
+            # Step 2: Choose best candidate
+            @state = STATE_PROMOTING
+            @chosen_candidate = choose_best_candidate(candidates)
+
+            unless @chosen_candidate
+              @state = STATE_FAILED
+              @stats[:failed_failovers] += 1
+              return failover_result(false, "No suitable candidate found")
+            end
+
+            # Step 3: Promote candidate
+            @state = STATE_FAILING_OVER
+            promote_result = promote_candidate(@chosen_candidate)
+
+            unless promote_result[:success]
+              @state = STATE_FAILED
+              @stats[:failed_failovers] += 1
+              return failover_result(false, "Promotion failed: #{promote_result[:error]}")
+            end
+
+            # Step 4: Verify promotion
+            @state = STATE_VERIFYING
+            verify_result = verify_promotion(@chosen_candidate)
+
+            unless verify_result[:success]
+              @state = STATE_FAILED
+              @stats[:failed_failovers] += 1
+              return failover_result(false, "Verification failed: #{verify_result[:error]}")
+            end
+
+            # Step 5: Complete failover
+            @state = STATE_COMPLETE
+            @stats[:successful_failovers] += 1
+
+            elapsed_ms = (Time.now - start_time) * 1000
+            @stats[:total_failover_time_ms] += elapsed_ms
+            @stats[:avg_failover_time_ms] = @stats[:total_failover_time_ms] / @stats[:successful_failovers]
+            @stats[:last_failover_time] = Time.now
+
+            failover_result(true, "Failover completed successfully", {
+              candidate: @chosen_candidate[:node_id],
+              elapsed_ms: elapsed_ms,
+              reason: reason
+            })
+
+          rescue => e
+            @state = STATE_FAILED
+            @stats[:failed_failovers] += 1
+            failover_result(false, "Failover failed: #{e.message}")
+          ensure
+            @failover_triggered = false
+            @chosen_candidate = nil
+          end
+        end
+      end
+
+      def find_candidate_replicas
+        candidates = []
+
+        replica = @replication_manager.replica
+        status = replica&.replication_status
+        if replica&.running? && status && status[:state] == Replica::STATE_SYNCED
+          candidates << {
+            node_id: @replication_manager.replica.config[:node_id] || "replica_1",
+            host: replica.primary_host,
+            port: replica.primary_port,
+            status: status[:state].to_s,
+            lag_ms: status[:lag_ms].to_i,
+            replayed_lsn: status[:last_replayed_lsn].to_i
+          }
+        end
+
+        candidates
+      end
+
+      def choose_best_candidate(candidates)
+        candidates.min_by { |c| [c[:lag_ms] || 0, -(c[:replayed_lsn] || 0)] }
+      end
+
+      def promote_candidate(candidate)
+        result = @replication_manager.promote_to_primary
+        return { success: false, error: "Promotion manager returned no result" } unless result.is_a?(Hash)
+
+        result[:success] ? result : { success: false, error: result[:error] || "Promotion failed" }
+      end
+
+      def verify_promotion(candidate)
+        mode = @replication_manager.respond_to?(:mode) ? @replication_manager.mode : nil
+        return { success: false, error: "Promotion did not enter primary mode" } unless mode == ReplicationManager::MODE_PRIMARY
+
+        health = @replication_manager.health_check
+        health[:healthy] ? { success: true, health: health } : { success: false, error: "Promoted node is unhealthy" }
+      end
+
+      def failover_result(success, message, extra = {})
+        started_at = @failover_start_time || Time.now
+        result = {
+          success: success,
+          message: message,
+          timestamp: Time.now.iso8601,
+          elapsed_ms: (Time.now - started_at) * 1000,
+          state: @state
+        }.merge(extra)
+
+        @stats[:last_failover_result] = result
+        result
+      end
+    end
+  end
+end