parallel_server 0.1.5.1 → 0.1.6

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 955a693a92fa37abfe15c9c4c42ab28498a7786b
-  data.tar.gz: 3c951d81ff0e66d70ceb1a65984b3c0b2b32fd8d
+  metadata.gz: 2e68bf1d6ac3906be2d5cc6fd0a4cf06fd2f6a77
+  data.tar.gz: d6b0f09154ec046e08353bdf7660941e7395a308
 SHA512:
-  metadata.gz: c1409e37acbcc93c652d4845c67dfbe6b485545c7ce96ac4130b2439980ca38e9e57966b05ab1593b6775819043ff00891dac8b6ec3198be523ff15f03da26c1
-  data.tar.gz: cadb59c70931be89fc63b82e093614125e1f962412b48278177f0d534557e856b8ed5a84d9f952faa9525add269117c546f653d51b7e6f3054891adc2bd54ae2
+  metadata.gz: 97eb5ecec4518b6c0f20e0c3d13f93610ae475f53731d63d5397aa5d36bacd973009980c69614036409b6a2efadbf455fbf2b88658fef75fb23670dd5a6fc509
+  data.tar.gz: a83190db61bfad2f2cac203851fb5022ec0c83dced8d50798eeb368dfb24c36fa37bb39c96fb808d68519cabb6d96c5a88f0b97ac182d7c9b41ccdf12f666429

data/README.md

@@ -68,6 +68,13 @@ max_idle 経過後でもクライアントと接続中であればプロセス
 クライアントがこの回数の接続を受け付けるとプロセスを終了します(デフォルト: 1000)。
 max_use 経過後でもクライアントと接続中であればプロセスは終了しません。ただし `:min_processes`, `:max_processes` のカウント対象外です。
 
+`:watchdog_timer` :
+子プロセスからのハートビートがこの秒数以上途切れると該当子プロセスに SIGTERM を送ります(デフォルト: 600)。
+その後も子プロセスが死なない場合は60秒後に SIGKILL を送ります。
+
+`:watchdog_signal` :
+`:watchdog_timer` が切れた時に子プロセスに送るシグナルを文字列で指定します(デフォルト: `TERM`)。
+
 `:on_start` :
 子プロセス起動時に*子プロセス側*で実行される処理を Proc で指定します。Proc 実行時の引数はありません。
 
@@ -107,3 +114,9 @@ start を終了します。クライアントと接続中の子プロセスは
 * `stop!`
 
 start を終了します。子プロセスがクライアントと接続中でも SIGTERM で終了させます。
+
+### #detach_children
+
+* `detach_children`
+
+子プロセスを切り離します。子プロセスは待ち受けポートを閉じ、接続中のクライアントがいなくなると終了します。

data/lib/parallel_server/prefork.rb

@@ -9,6 +9,8 @@ module ParallelServer
     DEFAULT_STANDBY_THREADS = 5
     DEFAULT_MAX_IDLE = 10
     DEFAULT_MAX_USE = 1000
+    DEFAULT_WATCHDOG_TIMER = 600
+    DEFAULT_WATCHDOG_SIGNAL = 'TERM'
 
     attr_reader :child_status
 
@@ -21,6 +23,8 @@ module ParallelServer
     #   @option opts [Integer] :max_threads (1) maximum threads per process
     #   @option opts [Integer] :standby_threads (5) keep free processes or threads
     #   @option opts [Integer] :listen_backlog (nil) listen backlog
+    #   @option opts [Integer] :watchdog_timer (600) watchdog timer
+    #   @option opts [Integer] :watchdog_signal ('TERM') this signal is sent when watchdog timer expired.
     #   @option opts [#call] :on_start (nil) object#call() is invoked when child process start. This is called in child process.
     #   @option opts [#call] :on_reload (nil) object#call(hash) is invoked when reload. This is called in child process.
     #   @option opts [#call] :on_child_start (nil) object#call(pid) is invoked when child process exit. This is call in parent process.
@@ -56,8 +60,7 @@ module ParallelServer
       raise 'block required' unless block
       @block = block
       unless @sockets
-        @sockets = Socket.tcp_server_sockets(@host, @port)
-        @sockets.each{|s| s.listen(@listen_backlog)} if @listen_backlog
+        @sockets = create_server_socket(@host, @port, @listen_backlog)
         @sockets_created = true
       end
       @reload_args = nil
@@ -99,6 +102,15 @@ module ParallelServer
       @loop = false
     end
 
+    # @return [void]
+    def detach_children
+      t = Time.now + 5
+      talk_to_children(detach: true)
+      while Time.now < t && @child_status.values.any?{|s| s[:status] == :run}
+        watch_children
+      end
+    end
+
     private
 
     # @return [void]
@@ -108,30 +120,43 @@ module ParallelServer
       old_listen_backlog = @listen_backlog
       set_variables_from_opts
 
-      address_changed = false
       if @sockets_created ? (@host != host || @port != port) : @sockets != sockets
         @sockets.each{|s| s.close rescue nil} if @sockets_created
+        detach_children
         @sockets, @host, @port = sockets, host, port
         if @sockets
           @sockets_created = false
         else
-          @sockets = Socket.tcp_server_sockets(@host, @port)
-          @sockets.each{|s| s.listen(@listen_backlog)} if @listen_backlog
+          @sockets = create_server_socket(@host, @port, @listen_backlog)
           @sockets_created = true
         end
-        address_changed = true
       elsif @listen_backlog != old_listen_backlog
         @sockets.each{|s| s.listen(@listen_backlog)} if @listen_backlog && @sockets_created
       end
 
-      reload_children(address_changed)
+      reload_children
+    end
+
+    # @param host [String] hostname or IP address
+    # @param port [Integer / String] port number / service name
+    # @param backlog [Integer / nil] listen backlog
+    # @return [Array<Socket>] listening sockets
+    def create_server_socket(host, port, backlog)
+      t = Time.now + 5
+      begin
+        sockets = Socket.tcp_server_sockets(host, port)
+      rescue Errno::EADDRINUSE
+        raise if Time.now > t
+        sleep 0.1
+        retry
+      end
+      sockets.each{|s| s.listen(backlog)} if backlog
+      sockets
     end
 
-    # @param address_changed [true/false]
     # @return [void]
-    def reload_children(address_changed=false)
+    def reload_children
       data = {}
-      data[:address_changed] = address_changed
       data[:options] = @opts.select{|_, value| Marshal.dump(value) rescue nil}
       talk_to_children data
     end
@@ -204,6 +229,7 @@ module ParallelServer
       if readable
         readable.each do |from_child|
           if st = Conversation.recv(from_child)
+            st[:time] = Time.now
             @child_status[from_child].update st
             if st[:status] == :stop
               @to_child[from_child].close rescue nil
@@ -218,6 +244,7 @@ module ParallelServer
           end
         end
       end
+      kill_frozen_children
       if @children.size != @child_status.size
         wait_children
       end
@@ -250,6 +277,19 @@ module ParallelServer
       @child_status.values.count{|st| st[:status] == :run}
     end
 
+    # @return [void]
+    def kill_frozen_children
+      now = Time.now
+      @child_status.each do |r, st|
+        if now > st[:time] + @watchdog_timer + 60
+          Process.kill 'KILL', @from_child[r]
+        elsif now > st[:time] + @watchdog_timer && ! st[:signal_sent]
+          Process.kill @watchdog_signal, @from_child[r]
+          st[:signal_sent] = true
+        end
+      end
+    end
+
     # @return [void]
     def wait_children
       @children.delete_if do |pid|
@@ -284,7 +324,7 @@ module ParallelServer
       r, w = from_child[0], to_child[1]
       @from_child[r] = pid
       @to_child[r] = w
-      @child_status[r] = {status: :run, connections: {}}
+      @child_status[r] = {status: :run, connections: {}, time: Time.now}
       @children.push pid
       @on_child_start.call(pid) if @on_child_start
     end
@@ -295,6 +335,8 @@ module ParallelServer
       @max_threads = @opts[:max_threads] || DEFAULT_MAX_THREADS
       @standby_threads = @opts[:standby_threads] || DEFAULT_STANDBY_THREADS
       @listen_backlog = @opts[:listen_backlog]
+      @watchdog_timer = @opts[:watchdog_timer] || DEFAULT_WATCHDOG_TIMER
+      @watchdog_signal = @opts[:watchdog_signal] || DEFAULT_WATCHDOG_SIGNAL
       @on_start = @opts[:on_start]
       @on_child_start = @opts[:on_child_start]
       @on_child_exit = @opts[:on_child_exit]
@@ -373,6 +415,9 @@ module ParallelServer
           count += 1
           break if max_use > 0 && count >= max_use
         end
+      rescue => e
+        STDERR.puts e.inspect, e.backtrace.inspect
+        raise e
       ensure
         @status = :stop
         queue.push true
@@ -389,16 +434,29 @@ module ParallelServer
       # @param queue [Queue]
       # @return [void]
       def reload_loop(queue)
+        heartbeat_interval = 5
         while true
-          data = Conversation.recv(@from_parent)
-          break unless data
-          break if data[:address_changed]
-          @options.update data[:options]
-          @options[:on_reload].call @options if @options[:on_reload]
-          @threads_cv.signal
+          time = Time.now
+          if IO.select([@from_parent], nil, nil, heartbeat_interval)
+            heartbeat_interval -= Time.now - time
+            heartbeat_interval = 0 if heartbeat_interval < 0
+            data = Conversation.recv(@from_parent)
+            break if data.nil? or data[:detach]
+            @options.update data[:options] if data[:options]
+            @options[:on_reload].call @options if @options[:on_reload]
+            @threads_cv.signal
+          else
+            heartbeat_interval = 5
+            @threads_mutex.synchronize do
+              Conversation.send(@to_parent, {})
+            end
+          end
         end
         @from_parent.close
         @from_parent = nil
+      rescue => e
+        STDERR.puts e.inspect, e.backtrace.inspect
+        raise e
       ensure
         @status = :stop
         queue.push true

data/test/parallel_server/test_prefork.rb

@@ -0,0 +1,392 @@
+require 'test/unit'
+require 'test/unit/notify'
+require 'socket'
+require 'timeout'
+require 'tempfile'
+
+require 'parallel_server/prefork'
+
+class TestParallelServerPrefork < Test::Unit::TestCase
+  def setup
+    @tmpf = Tempfile.new('test_prefork')
+    @prefork = ParallelServer::Prefork.new(*args, opts)
+    @thr = Thread.new do
+      begin
+        @prefork.start do |sock|
+          begin
+            sock.puts $$.to_s
+            sock.gets
+          rescue Errno::EPIPE
+          end
+        end
+      rescue
+        p $!, $@
+        raise
+      end
+    end
+    sleep 1
+    @clients = []
+  end
+
+  def teardown
+    @clients.each do |c|
+      c.close rescue nil
+    end
+    @prefork.stop!
+    @thr.join rescue nil
+    @tmpf.close true
+  end
+
+  def args
+    [port]
+  end
+
+  def port
+    ENV['TEST_PORT'] || 12345
+  end
+
+  def connect
+    s = TCPSocket.new('localhost', port)
+    @clients.push s
+    s.gets
+    s
+  end
+
+  def opts
+    {}
+  end
+
+  sub_test_case 'max_process: 1, max_threads: 1' do
+    def opts
+      {
+        min_processes: 1,
+        max_processes: 1,
+        max_threads: 1,
+      }
+    end
+
+    test '2nd wait for connection' do
+      connect
+      assert_raise Timeout::Error do
+        Timeout.timeout(0.5){ connect }
+      end
+    end
+
+    test '2nd connect after 1st connection is closed' do
+      connect
+      Thread.new{ sleep 0.3; @clients.first.puts }
+      Timeout.timeout(1){ connect }
+    end
+  end
+
+  sub_test_case 'max_process: 1, max_threads: 3' do
+    def opts
+      {
+        min_processes: 1,
+        max_processes: 1,
+        max_threads: 3,
+      }
+    end
+
+    test '4th request wait for connection' do
+      3.times{ connect }
+      assert_raise Timeout::Error do
+        Timeout.timeout(0.5){ connect }
+      end
+    end
+
+    test '4th connect after 1st connection is closed' do
+      3.times{ connect }
+      Thread.new{ sleep 0.3; @clients.first.puts }
+      Timeout.timeout(1){ connect }
+    end
+  end
+
+  sub_test_case 'max_process: 3, max_threads: 1' do
+    def opts
+      {
+        min_processes: 1,
+        max_processes: 3,
+        max_threads: 1,
+      }
+    end
+
+    test '4th request wait for connection' do
+      3.times{ connect }
+      assert_raise Timeout::Error do
+        Timeout.timeout(0.5){ connect }
+      end
+    end
+
+    test '4th connect after 1st connection is closed' do
+      3.times{ connect }
+      Thread.new{ sleep 0.3; @clients.first.puts }
+      Timeout.timeout(1){ connect }
+    end
+  end
+
+  sub_test_case 'min_processes: 3' do
+    def opts
+      {
+        min_processes: 3,
+        standby_threads: 1,
+      }
+    end
+
+    test '3 child processes exist' do
+      c = Dir.glob('/proc/*/status').count do |stat|
+        File.read(stat) =~ /^PPid:\t#{$$}$/
+      end
+      assert_equal 3, c
+    end
+  end
+
+  sub_test_case 'max_idle' do
+    def opts
+      @children = []
+      {
+        min_processes: 1,
+        max_processes: 1,
+        max_idle: 0.1,
+        on_child_start: ->(pid){ @children.push pid },
+      }
+    end
+
+    test 'unconnected process exists even if max_idle expired' do
+      sleep 0.5
+      assert File.exist?("/proc/#{@children[0]}")
+      assert_equal 1, @children.size
+    end
+
+    test 'first child process exited if it is connected' do
+      Process.waitpid fork{ connect.close }
+      sleep 0.5
+      assert ! File.exist?("/proc/#{@children[0]}")
+      assert_equal 2, @children.size
+    end
+  end
+
+  sub_test_case 'max_use' do
+    def opts
+      @children = []
+      {
+        min_processes: 1,
+        max_processes: 1,
+        max_use: 2,
+        on_child_start: ->(pid){ @children.push pid },
+      }
+    end
+
+    test 'child process exited if it is connected max_use times' do
+      Process.waitpid fork{ connect.close }
+      sleep 0.5
+      assert File.exist?("/proc/#{@children[0]}")
+      Process.waitpid fork{ connect.close }
+      sleep 0.5
+      assert ! File.exist?("/proc/#{@children[0]}")
+    end
+  end
+
+  sub_test_case 'standby_threads' do
+    def opts
+      @children = []
+      {
+        min_processes: 1,
+        max_processes: 20,
+        max_threads: 2,
+        on_child_start: ->(pid){ @children.push pid }
+      }
+    end
+
+    sub_test_case 'standby_threads=1' do
+      def opts
+        {
+          standby_threads: 1
+        }.merge super
+      end
+
+      test '1 child start' do
+        assert_equal 1, @children.size
+      end
+    end
+
+    sub_test_case '1 < standby_threads <= max_processes/max_threads' do
+      def opts
+        {
+          standby_threads: 10
+        }.merge super
+      end
+
+      test 'n children start' do
+        assert_equal 5, @children.size
+      end
+    end
+
+    sub_test_case 'standby_threads > max_processes/max_threads' do
+      def opts
+        {
+          standby_threads: 100
+        }.merge super
+      end
+
+      test 'max_processes children start' do
+        assert_equal 20, @children.size
+      end
+    end
+  end
+
+  sub_test_case 'on_start' do
+    def opts
+      {
+        min_processes: 1,
+        max_processes: 2,
+        max_threads: 1,
+        standby_threads: 1,
+        on_start: ->(){ File.open(@tmpf.path, 'a'){|f| f.puts $$} },
+      }
+    end
+
+    test 'execute block in child process when child start' do
+      assert_equal 1, File.read(@tmpf.path).lines.count
+      connect.close
+      sleep 0.5
+      assert_equal 2, File.read(@tmpf.path).lines.count
+    end
+  end
+
+  sub_test_case 'on_reload' do
+    def opts
+      {
+        min_processes: 5,
+        max_processes: 5,
+        on_reload: ->(_opts){ File.open(@tmpf.path, 'a'){|f| f.puts $$} },
+      }
+    end
+
+    test 'execute block when reload' do
+      assert_equal 0, File.read(@tmpf.path).lines.count
+      @prefork.reload(12345, opts)
+      sleep 0.5
+      assert_equal 5, File.read(@tmpf.path).lines.count
+    end
+  end
+
+  sub_test_case 'on_child_start' do
+    def opts
+      @childs = []
+      {
+        min_processes: 1,
+        max_processes: 2,
+        max_threads: 1,
+        standby_threads: 1,
+        on_child_start: ->(pid){ @childs.push pid },
+      }
+    end
+
+    test 'execute block when child start' do
+      assert_equal 1, @childs.count
+      connect.close
+      sleep 0.5
+      assert_equal 2, @childs.count
+    end
+  end
+
+  sub_test_case 'on_child_exit' do
+    def opts
+      @childs = []
+      {
+        min_processes: 1,
+        max_processes: 1,
+        max_idle: 0.001,
+        on_child_exit: ->(pid, st){ @childs.push pid; @st = st },
+      }
+    end
+
+    test 'execute block when child exit' do
+      assert_equal [], @childs
+      s = TCPSocket.new('localhost', port)
+      pid = s.gets.chomp.to_i
+      s.close
+      sleep 0.5
+      assert_equal [pid], @childs
+      assert_equal 0, @st.exitstatus
+    end
+  end
+
+  sub_test_case 'each_nonblock' do
+    test 'run in single thread unless timeout occur' do
+      @prefork.singleton_class.class_eval{public :each_nonblock}
+      values = Array.new(100, true)
+      result = []
+      @prefork.each_nonblock(values, 1) do |x|
+        result.push Thread.current
+      end
+      assert_equal result.size, values.size
+      assert_equal result.uniq.size, 1
+    end
+
+    test 'run in multiple thread if timeout occur' do
+      @prefork.singleton_class.class_eval{public :each_nonblock}
+      values = Array.new(10, true)
+      result = []
+      @prefork.each_nonblock(values, 0.1) do |x|
+        result.push Thread.current
+        sleep 0.3
+      end
+      assert_equal result.size, values.size
+      assert result.uniq.size == 10
+    end
+  end
+
+  sub_test_case 'new(port)' do
+    def args
+      [port]
+    end
+
+    test 'connection' do
+      Timeout.timeout(1){ connect }
+    end
+  end
+
+  sub_test_case 'new(host, port)' do
+    def args
+      ['localhost', port]
+    end
+
+    test 'connection' do
+      Timeout.timeout(1){ connect }
+    end
+  end
+
+  sub_test_case 'new(socket)' do
+    def args
+      @sock = TCPServer.new(port)
+      [@sock]
+    end
+
+    def teardown
+      @sock.close
+      super
+    end
+
+    test 'connection' do
+      Timeout.timeout(1){ connect }
+    end
+  end
+
+  sub_test_case 'new(sockets)' do
+    def args
+      @socks = [TCPServer.new(port), TCPServer.new(port+1)]
+      [@socks]
+    end
+
+    def teardown
+      @socks.each(&:close)
+      super
+    end
+
+    test 'connection' do
+      Timeout.timeout(1){ connect }
+    end
+  end
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: parallel_server
 version: !ruby/object:Gem::Version
-  version: 0.1.5.1
+  version: 0.1.6
 platform: ruby
 authors:
 - Tomita Masahiro
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-05-19 00:00:00.000000000 Z
+date: 2015-05-31 00:00:00.000000000 Z
 dependencies: []
 description: Parallel TCP Server library. This is easy to make Multi-Process / Multi-Thread
   server
@@ -20,6 +20,7 @@ extra_rdoc_files:
 files:
 - README.md
 - lib/parallel_server/prefork.rb
+- test/parallel_server/test_prefork.rb
 homepage: http://github.com/tmtm/parallel_server
 licenses:
 - Ruby's
@@ -40,8 +41,10 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.2.2
+rubygems_version: 2.4.5
 signing_key: 
 specification_version: 4
 summary: Parallel TCP Server library
-test_files: []
+test_files:
+- test/parallel_server/test_prefork.rb
+has_rdoc: true