familia 1.2.0 → 2.0.0.pre.pre

data/try/pooling/connection_pool_test_try.rb

@@ -0,0 +1,273 @@
+# try/pooling/connection_pool_test_try.rb
+
+# USAGE: FAMILIA_TRACE=1 FAMILIA_DEBUG=1 bundle exec tryouts try/pooling/connection_pool_test_try.rb
+
+require 'bundler/setup'
+require 'securerandom'
+require 'thread'
+require_relative '../helpers/test_helpers'
+
+# Configure connection pooling via connection_provider
+require 'connection_pool'
+
+# Create pools for each logical database
+@pools = {}
+
+Familia.connection_provider = lambda do |uri|
+  @pools[uri] ||= ConnectionPool.new(size: 5, timeout: 2) do
+    parsed = URI.parse(uri)
+    Redis.new(
+      host: parsed.host,
+      port: parsed.port,
+      db: parsed.db || 0
+    )
+  end
+  
+  @pools[uri].with { |conn| conn }
+end
+
+# Test model for connection pool testing
+class PoolTestAccount < Familia::Horreum
+  identifier_field :account_id
+  field :account_id
+  field :balance
+  field :holder_name
+
+  def init
+    @account_id ||= SecureRandom.hex(6)
+    @balance = @balance.to_f if @balance
+  end
+
+  def balance
+    @balance&.to_f
+  end
+end
+
+class PoolTestSession < Familia::Horreum
+  identifier_field :session_id
+  field :session_id
+  field :user_id
+  field :created_at
+
+  def init
+    @session_id ||= SecureRandom.hex(8)
+    @created_at ||= Time.now.to_i
+  end
+end
+
+## Clean up before tests
+PoolTestAccount.dbclient.flushdb
+#=> "OK"
+
+## Test 1: Connection provider configuration
+Familia.connection_provider.is_a?(Proc)
+#=> true
+
+## Test 2: Connection pool created automatically
+@account1 = PoolTestAccount.new(balance: 1000, holder_name: "Alice")
+@account1.save
+#=> true
+
+## Test 3: Basic pool functionality
+@account1.balance
+#=> 1000.0
+
+## Test 4: Multiple logical databases with separate pools
+# Account in DB 0 (default)
+@account_db0 = PoolTestAccount.new(balance: 500, holder_name: "Bob")
+@account_db0.save
+#=> true
+
+## Test 5: Account in DB 1 via class configuration
+class PoolTestAccountDB1 < Familia::Horreum
+  self.logical_database = 1
+  identifier_field :account_id
+  field :account_id
+  field :balance
+  field :holder_name
+
+  def init
+    @account_id ||= SecureRandom.hex(6)
+    @balance = @balance.to_f if @balance
+  end
+
+  def balance
+    @balance&.to_f
+  end
+end
+
+@account_db1 = PoolTestAccountDB1.new(balance: 750, holder_name: "Charlie")
+@account_db1.save
+#=> true
+
+## Test 6: Verify accounts are in different databases
+@account_db0.balance
+#=> 500.0
+
+## Test 7: Verify DB1 account works independently
+@account_db1.balance
+#=> 750.0
+
+## Test 8: Connection pool thread safety
+@results = []
+@mutex = Mutex.new
+
+# Create multiple threads performing concurrent operations
+threads = 5.times.map do |i|
+  Thread.new do
+    account = PoolTestAccount.new(balance: 1000, holder_name: "Thread#{i}")
+    result = account.save
+    @mutex.synchronize { @results << result }
+  end
+end
+
+threads.each(&:join)
+@results.all?
+#=> true
+
+## Test 9: Thread safety verification
+@results.size
+#=> 5
+
+## Test 10: Transaction support with connection pools
+@account_a = PoolTestAccount.new(balance: 1000, holder_name: "AccountA")
+@account_b = PoolTestAccount.new(balance: 500, holder_name: "AccountB")
+[@account_a.save, @account_b.save]
+#=> [true, true]
+
+## Test 11: Multi/EXEC transaction operations
+@transfer_result = Familia.transaction do |conn|
+  # Test that transaction connection is available
+  conn.ping
+end
+# Transaction returns array with results
+@transfer_result.first
+#=> "PONG"
+
+## Test 12: Transaction block executes properly
+# Simple verification that accounts maintain their values
+[@account_a.balance, @account_b.balance]
+#=> [1000.0, 500.0]
+
+## Test 13: with_connection method
+@connection_test_result = Familia.with_connection do |conn|
+  conn.set("test_key_#{SecureRandom.hex(4)}", "test_value")
+end
+@connection_test_result
+#=> "OK"
+
+## Test 14: Pipeline operations with connection pool
+@pipeline_results = Familia.pipeline do |conn|
+  conn.ping
+end
+# Pipeline executes successfully
+@pipeline_results.first
+#=> "PONG"
+
+## Test 15: Multi/EXEC operations with connection pool
+@multi_results = Familia.multi do |conn|
+  conn.ping
+end
+# Multi/EXEC executes successfully
+@multi_results.first
+#=> "PONG"
+
+## Test 16: Error handling in transactions
+@error_account = PoolTestAccount.new(balance: 100, holder_name: "ErrorTest")
+@error_account.save
+#=> true
+
+## Test 17: Transaction error handling
+begin
+  Familia.transaction do |conn|
+    conn.ping
+    raise "Simulated error"
+  end
+  false
+rescue => e
+  # Error propagates correctly from transaction block
+  true
+end
+#=> true
+
+## Test 18: Verify account state after transaction error
+@error_account.refresh!
+@error_account.balance
+#=> 100.0
+
+## Test 19: Multiple pools created for different databases
+@pools.size >= 1
+#=> true
+
+## Test 20: Connection pool timeout handling
+timeout_threads = []
+timeout_results = []
+timeout_mutex = Mutex.new
+
+# Start threads that hold connections briefly
+3.times do |i|
+  timeout_threads << Thread.new do
+    begin
+      result = Familia.with_connection do |conn|
+        sleep(0.1)  # Brief hold
+        conn.ping
+      end
+      timeout_mutex.synchronize { timeout_results << result }
+    rescue => e
+      timeout_mutex.synchronize { timeout_results << e.class.name }
+    end
+  end
+end
+
+timeout_threads.each(&:join)
+timeout_results.all? { |r| r == "PONG" }
+#=> true
+
+## Test 21: Debug mode validation (if enabled)
+# This test only runs if FAMILIA_DEBUG=1 is set
+if ENV['FAMILIA_DEBUG']
+  Familia.debug = true
+  # Test that debug mode doesn't break normal operation
+  debug_account = PoolTestAccount.new(balance: 123, holder_name: "Debug")
+  debug_account.save
+else
+  true  # Skip debug test if not in debug mode
+end
+#=> true
+
+## Test 22: Backward compatibility - existing code works unchanged
+@compat_result = PoolTestAccount.dbclient.ping
+@compat_result
+#=> "PONG"
+
+## Test 23: Field operations work unchanged
+@compat_account = PoolTestAccount.new(balance: 9999, holder_name: "Compat")
+@compat_account.save
+#=> true
+
+## Test 24: Direct field access works
+@compat_account.hget("balance").to_f
+#=> 9999.0
+
+## Test 25: Connection provider receives correct URIs
+@captured_uris = []
+original_provider = Familia.connection_provider
+
+# Temporarily wrap provider to capture URIs
+Familia.connection_provider = lambda do |uri|
+  @captured_uris << uri
+  original_provider.call(uri)
+end
+
+# Trigger some operations to capture URIs
+test_account = PoolTestAccount.new(balance: 555, holder_name: "URITest")
+test_account.save
+
+# Restore original provider
+Familia.connection_provider = original_provider
+
+# Verify URIs contain database information
+@captured_uris.any? { |uri| uri.include?('redis://') }
+#=> true
+
+puts "Connection pool tests completed successfully!"

data/try/pooling/lib/atomic_saves_v3_connection_pool_helpers.rb

@@ -0,0 +1,192 @@
+# try/pooling/lib/atomic_saves_v3_connection_pool_helpers.rb
+
+##
+# Atomic Save V3 Proof of Concept - Connection Pool Integration
+#
+# This implementation explores atomic saves with Database connection pooling
+# for thread safety in multi-threaded environments (like Puma).
+#
+# Key Goals:
+# 1. **Connection Pool Integration**: Use ConnectionPool gem for thread safety
+# 2. **Dual Approach Testing**: Compare proxy vs explicit connection passing
+# 3. **Thread Safety Validation**: Prove pool handles concurrent operations
+# 4. **Separate Transaction Boundaries**: Each atomic block gets own transaction
+#
+# Approaches Tested:
+# - Proxy Approach: Familia.atomic { ... } (transparent, V2 style)
+# - Explicit Approach: Familia.atomic { |conn| ... } (clear boundaries)
+
+require 'connection_pool'
+require 'json'
+
+# Test models
+class BankAccount < Familia::Horreum
+  identifier_field :account_number
+  field :account_number
+  field :balance
+  field :holder_name
+  field :metadata  # Variable-sized JSON field for workload simulation
+
+  def init
+    @account_number ||= SecureRandom.hex(8)
+    @balance = @balance.to_f if @balance
+    @metadata = @metadata.is_a?(String) ? JSON.parse(@metadata) : @metadata rescue @metadata
+  end
+
+  def balance
+    @balance&.to_f
+  end
+
+  def withdraw(amount)
+    raise "Insufficient funds" if balance < amount
+    self.balance -= amount
+  end
+
+  def deposit(amount)
+    self.balance += amount
+  end
+
+  def metadata=(value)
+    @metadata = value.is_a?(Hash) || value.is_a?(Array) ? JSON.generate(value) : value
+  end
+
+  # Add method that accepts explicit connection
+  def save(using: nil)
+    if using
+      # Use provided connection explicitly
+      original_instance = @dbclient
+      @dbclient = using
+      begin
+        super()
+      ensure
+        @dbclient = original_instance
+      end
+    else
+      # Use normal save behavior
+      super()
+    end
+  end
+end
+
+class TransactionRecord < Familia::Horreum
+  identifier_field :transaction_id
+  field :transaction_id
+  field :from_account
+  field :to_account
+  field :amount
+  field :status
+  field :created_at
+
+  def initialize(from: nil, to: nil, amount: 0)
+    @transaction_id = SecureRandom.hex(8)
+    @from_account = from
+    @to_account = to
+    @amount = amount.to_f
+    @status = "pending"
+    @created_at = Time.now.to_i
+  end
+
+  def amount
+    @amount&.to_f
+  end
+
+  def created_at
+    @created_at&.to_i
+  end
+
+  def save(using: nil)
+    if using
+      original_instance = @dbclient
+      @dbclient = using
+      begin
+        super()
+      ensure
+        @dbclient = original_instance
+      end
+    else
+      super()
+    end
+  end
+end
+
+module Familia
+  # Connection pool for Database connections
+  @@connection_pool = ConnectionPool.new(size: 10, timeout: 5) do
+    Redis.new(url: Familia.uri.to_s)
+  end
+
+  class << self
+    def connection_pool
+      @@connection_pool
+    end
+
+    def current_transaction
+      Thread.current[:familia_current_transaction_v3]
+    end
+
+    def current_transaction=(transaction)
+      Thread.current[:familia_current_transaction_v3] = transaction
+    end
+
+    # Proxy approach - transparent like V2
+    def atomic(&block)
+      if current_transaction
+        # Nested atomic - create separate transaction
+        atomic_separate(&block)
+      else
+        # Use connection pool to get connection
+        # For this prototype, we'll use a simple approach that works with Redis
+        connection_pool.with do |conn|
+          begin
+            # Store the connection for use within the block
+            self.current_transaction = conn
+            result = yield
+            result
+          ensure
+            self.current_transaction = nil
+          end
+        end
+      end
+    end
+
+    # Explicit approach - connection passed to block
+    def atomic_explicit(&block)
+      connection_pool.with do |conn|
+        # For this prototype, pass the connection directly
+        yield(conn)
+      end
+    end
+
+    # Helper for separate nested transactions
+    def atomic_separate(&block)
+      connection_pool.with do |conn|
+        begin
+          old_transaction = current_transaction
+          # Use a separate connection for nested transactions
+          self.current_transaction = conn
+          result = yield
+          result
+        ensure
+          self.current_transaction = old_transaction
+        end
+      end
+    end
+  end
+
+  # Override dbclient method for proxy approach
+  module ConnectionPoolRedis
+    def dbclient
+      Familia.current_transaction || super
+    end
+  end
+
+  # Inject into Horreum for proxy approach
+  class Horreum
+    prepend ConnectionPoolRedis
+  end
+
+  # Inject into DataType for proxy approach
+  class DataType
+    prepend ConnectionPoolRedis
+  end
+end