Add an inherit_socket option to disable fork safety check

When `inherit_socket` is set to true, we disable safety check that prevents
a forked child from sharing a socket with its parent; this is potentially
useful in order to prohibit excessive connection churn on redis when ALL of the following are met:

 - many short-lived forked children of one process need to talk to redis, AND
 - your own code prevents the parent process from using the redis connection
   while a child is alive

Improper use of this option will result in corrupted and/or incorrect responses.

`inherit_socket` is disabled by default.

Author: yaauie

CHANGELOG.md

@@ -5,6 +5,9 @@
   HyperLogLog (Redis 2.8.9, #432)
 * Added support for `bitpos` command (Redis 2.9.11, #412)
 * Added support for automatically reconnecting in forked child (#414)
+* Added support for expert-mode option `inherit_socket`, which disables
+  fork-safety check and enables a socket to be shared with a child
+  process (#409)
 * Added MRI Ruby 2.1.0 to CI
 * Fix truncation of meaningful information in certain timeouts (#430)
 * Fix handling of connection retries that could result in retry loop (#415)

README.md

@@ -158,6 +158,18 @@ end
 # => 1
 ```
 
+## Expert-Mode Options
+
+ - `inherit_socket: true`: disable safety check that prevents a forked child
+   from sharing a socket with its parent; this is potentially useful in order to mitigate connection churn when:
+    - many short-lived forked children of one process need to talk
+      to redis, AND
+    - your own code prevents the parent process from using the redis
+      connection while a child is alive
+   
+   Improper use of `inherit_socket` will result in corrupted and/or incorrect
+   responses.
+
 ## Alternate drivers
 
 By default, redis-rb uses Ruby's socket library to talk with Redis.

lib/redis/client.rb

@@ -16,7 +16,8 @@ class Client
       :db => 0,
       :driver => nil,
       :id => nil,
-      :tcp_keepalive => 0
+      :tcp_keepalive => 0,
+      :inherit_socket => false
     }
 
     def options
@@ -59,6 +60,10 @@ def driver
       @options[:driver]
     end
 
+    def inherit_socket?
+      @options[:inherit_socket]
+    end
+
     attr_accessor :logger
     attr_reader :connection
     attr_reader :command_map
@@ -310,10 +315,11 @@ def ensure_connected
         tries += 1
 
         if connected?
-          if Process.pid != @pid
+          unless inherit_socket? || Process.pid == @pid
             raise InheritedError,
               "Tried to use a connection from a child process without reconnecting. " +
-              "You need to reconnect to Redis after forking."
+              "You need to reconnect to Redis after forking " +
+              "or set :inherit_socket to true."
           end
         else
           connect
@@ -372,7 +378,7 @@ def _parse_options(options)
 
       # Use default when option is not specified or nil
       defaults.keys.each do |key|
-        options[key] ||= defaults[key]
+        options[key] = defaults[key] if options[key].nil?
       end
 
       if options[:path]

test/fork_safety_test.rb

@@ -0,0 +1,64 @@
+# encoding: UTF-8
+
+require File.expand_path("helper", File.dirname(__FILE__))
+
+class TestForkSafety < Test::Unit::TestCase
+
+  include Helper::Client
+
+  driver(:ruby, :hiredis) do
+    def test_fork_safety
+      redis = Redis.new(OPTIONS)
+      redis.set "foo", 1
+
+      child_pid = fork do
+        begin
+          # InheritedError triggers a reconnect,
+          # so we need to disable reconnects to force
+          # the exception bubble up
+          redis.without_reconnect do
+            redis.set "foo", 2
+          end
+        rescue Redis::InheritedError
+          exit 127
+        end
+      end
+
+      _, status = Process.wait2(child_pid)
+
+      assert_equal 127, status.exitstatus
+      assert_equal "1", redis.get("foo")
+
+    rescue NotImplementedError => error
+      raise unless error.message =~ /fork is not available/
+      skip(error.message)
+    end
+
+    def test_fork_safety_with_enabled_inherited_socket
+      redis = Redis.new(OPTIONS.merge(:inherit_socket => true))
+      redis.set "foo", 1
+
+      child_pid = fork do
+        begin
+          # InheritedError triggers a reconnect,
+          # so we need to disable reconnects to force
+          # the exception bubble up
+          redis.without_reconnect do
+            redis.set "foo", 2
+          end
+        rescue Redis::InheritedError
+          exit 127
+        end
+      end
+
+      _, status = Process.wait2(child_pid)
+
+      assert_equal 0, status.exitstatus
+      assert_equal "2", redis.get("foo")
+
+    rescue NotImplementedError => error
+      raise unless error.message =~ /fork is not available/
+      skip(error.message)
+    end
+  end
+end