Reconnect when a fork is detected

This prevents raising unhandled exceptions that the caller needs to
figure out how to handle. It also makes Dalli play nicer in preforking
and reforking server environments.

Author: PatrickTulskie

CHANGELOG.md

@@ -7,6 +7,7 @@ Unreleased
 - Fix cannot read response data included terminator `\r\n` when use meta protocol (matsubara0507)
 - Support SERVER_ERROR response from Memcached as per the [memcached spec](https://github.com/memcached/memcached/blob/e43364402195c8e822bb8f88755a60ab8bbed62a/doc/protocol.txt#L172) (grcooper)
 - Update Socket timeout handling to use Socket#timeout= when available (nickamorim)
+- Reconnect gracefully when a fork is detected instead of crashing (PatrickTulskie)
 
 3.2.8
 ==========

lib/dalli/protocol/connection_manager.rb

@@ -100,13 +100,13 @@ def socket_timeout
 
       def confirm_ready!
         close if request_in_progress?
-        close_on_fork if fork_detected?
+        reconnect_on_fork if fork_detected?
       end
 
       def confirm_in_progress!
         raise '[Dalli] No request in progress. This may be a bug in Dalli.' unless request_in_progress?
 
-        close_on_fork if fork_detected?
+        reconnect_on_fork if fork_detected?
       end
 
       def close
@@ -218,13 +218,12 @@ def log_warn_message(err_or_string)
         end
       end
 
-      def close_on_fork
+      def reconnect_on_fork
         message = 'Fork detected, re-connecting child process...'
         Dalli.logger.info { message }
-        # Close socket on a fork, setting us up for reconnect
-        # on next request.
+        # Close socket on a fork and reconnect immediately
         close
-        raise Dalli::NetworkError, message
+        establish_connection
       end
 
       def fork_detected?

test/integration/test_fork_safety.rb

@@ -0,0 +1,60 @@
+# frozen_string_literal: true
+
+require_relative '../helper'
+
+describe 'Fork safety' do
+  # Skip tests if fork is not supported (e.g., JRuby)
+  next unless Process.respond_to?(:fork)
+
+  MemcachedManager.supported_protocols.each do |protocol|
+    describe "using the #{protocol} protocol" do
+      it 'automatically reconnects after fork' do
+        memcached_persistent(protocol) do |dc, _port|
+          # Set a value before forking
+          dc.set('fork_test_key', 'parent_value')
+
+          assert_equal 'parent_value', dc.get('fork_test_key')
+
+          # Fork a child process
+          read_pipe, write_pipe = IO.pipe
+          pid = fork do
+            read_pipe.close
+
+            # In the child process, we should detect the fork and reconnect
+            begin
+              # Simple test - set a value after fork
+              dc.set('child_key', 'child_value')
+              value = dc.get('child_key')
+
+              # Write success to the pipe
+              write_pipe.write("success:#{value}")
+            rescue StandardError => e
+              # Write error to the pipe if reconnection fails
+              write_pipe.write("error:#{e.class.name}:#{e.message}")
+            ensure
+              write_pipe.close
+              exit!(0)
+            end
+          end
+
+          # In the parent process
+          write_pipe.close
+
+          # Wait for child process to finish
+          Process.wait(pid)
+
+          # Read result from pipe
+          result = read_pipe.read
+          read_pipe.close
+
+          # Verify the child successfully reconnected and performed operations
+          assert_match(/^success:/, result, "Child process encountered an error: #{result}")
+          assert_equal 'success:child_value', result
+
+          # Parent should still be able to work
+          assert_equal 'parent_value', dc.get('fork_test_key')
+        end
+      end
+    end
+  end
+end

test/test_fork_safety.rb

@@ -0,0 +1,53 @@
+# frozen_string_literal: true
+
+require_relative 'helper'
+
+class TestForkSafety < Minitest::Test
+  include Memcached::Helper
+
+  def setup
+    skip('Fork unavailable') unless Process.respond_to?(:fork)
+  end
+
+  MemcachedManager.supported_protocols.each do |protocol|
+    define_method "test_fork_safety_#{protocol}" do
+      memcached_persistent(protocol) do |dc, _port|
+        # Set initial value
+        dc.set('key', 'foo')
+
+        assert_equal 'foo', dc.get('key')
+
+        pid = fork do
+          # Child process should detect fork and reconnect automatically
+          100.times do |i|
+            # Should work without errors due to auto-reconnection
+            dc.set('key', "child_#{i}")
+            sleep(0.01) # Add a small delay to prevent racing too fast
+          end
+          exit!(0)
+        end
+
+        # Parent process should continue to work
+        100.times do |_i|
+          # Basic operation to ensure connection still works
+          begin
+            dc.get('foo')
+          rescue StandardError
+            nil
+          end
+          sleep(0.01) # Add a small delay
+        end
+
+        # Wait for child to finish
+        _, status = Process.wait2(pid)
+
+        assert_predicate(status, :success?)
+
+        # Verify we can still perform operations in parent
+        dc.get('key') # Just ensure this doesn't raise an error
+
+        assert_kind_of String, dc.get('key'), 'Expected a string value from memcached'
+      end
+    end
+  end
+end