parallel_server 0.1.1 → 0.1.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 45b4976310bb10eafcde6ffd88c58109b37e8484
-  data.tar.gz: f82ca0d3995fd5ea389696d3cbf8f4db793ca6cc
+  metadata.gz: c5d5502b45b7905a8987e8ca85d33718086a57bc
+  data.tar.gz: 9cba1d1da00b7b52d335b615ff0c54d52a56eb45
 SHA512:
-  metadata.gz: e109c329657a2318947e0225c81f7ffcf2eced73cda705fa2dff5996c7e5f65fead30dad4c8e0023bb0d5ef71d31edce2f70a36aab3b638d556808ed66c7e928
-  data.tar.gz: 6db5efc1e016e5de43645123db4a3f4b2e47ef538c05fa116ce01c66a539d65bfda0000b1e7c16e6a05ef28bf06a39bcf560b9b6b0bece8f4d6584eddbe01a88
+  metadata.gz: 01383431223dc5812e135947fbb7d98ad5cfefa88009c408e9e51d20a82bb8a7db48cfc81e458918ee65be98b8fa921f65291ef9848d82ec7165d7c553961807
+  data.tar.gz: 42202bdc861f0cc9e95b0acf9d01e38ea81540385d1a39bee34ec657333dd3bada3dcd82f7582d26eff1d4c518a7c6dcb07b3c05146bd29464a11aaad25e7d64

data/README.md

@@ -59,9 +59,16 @@ ParallelServer::Prefork の動作を設定するパラメータ。
 生成後一度も接続されていないプロセスはこのパラメータの影響を受けません。
 max_idle 経過後でもクライアントと接続中であればプロセスは終了しません。ただし `:min_processes`, `:max_processes` のカウント対象外です。
 
+`:max_use` :
+クライアントがこの回数の接続を受け付けるとプロセスを終了します(デフォルト: 1000)。
+max_use 経過後でもクライアントと接続中であればプロセスは終了しません。ただし `:min_processes`, `:max_processes` のカウント対象外です。
+
 `:on_start` :
 子プロセス起動時に*子プロセス側*で実行される処理を Proc で指定します。Proc 実行時の引数はありません。
 
+`:on_reload` :
+reload 時に*子プロセス側*で実行される処理を Proc で指定します。Proc 実行時の引数は親プロセスから渡されたオプション(Hash)です。
+
 `:on_child_start` :
 子プロセス起動時に*親プロセス側*で実行される処理を Proc で指定します。Proc 実行時の引数はプロセスID(Integer)です。
 

data/lib/parallel_server/prefork.rb

@@ -8,6 +8,7 @@ module ParallelServer
     DEFAULT_MAX_THREADS = 1
     DEFAULT_STANDBY_THREADS = 5
     DEFAULT_MAX_IDLE = 10
+    DEFAULT_MAX_USE = 1000
 
     attr_reader :child_status
 
@@ -18,10 +19,12 @@ module ParallelServer
     #   @option opts [Integer] :min_processes (5) minimum processes
     #   @option opts [Integer] :max_processes (20) maximum processes
     #   @option opts [Integer] :max_idle (10) cihld process exits if max_idle seconds is expired
+    #   @option opts [Integer] :max_use (1000) child process exits if it is connected max_use times.
     #   @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 [#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.
     #   @option opts [#call] :on_child_exit (nil) object#call(pid, status) is invoked when child process exit. This is call in parent process.
 
@@ -30,19 +33,13 @@ module ParallelServer
     def initialize(*args)
       host, port, opts = parse_args(*args)
       @host, @port, @opts = host, port, opts
-      @min_processes = @opts[:min_processes] || DEFAULT_MIN_PROCESSES
-      @max_processes = @opts[:max_processes] || DEFAULT_MAX_PROCESSES
-      @max_threads = @opts[:max_threads] || DEFAULT_MAX_THREADS
-      @standby_threads = @opts[:standby_threads] || DEFAULT_STANDBY_THREADS
-      @listen_backlog = @opts[:listen_backlog]
-      @on_start = @opts[:on_start]
-      @on_child_start = @opts[:on_child_start]
-      @on_child_exit = @opts[:on_child_exit]
+      set_variables_from_opts
       @from_child = {}             # IO => pid
       @to_child = {}               # pid => IO
       @child_status = {}           # pid => Hash
       @children = []               # pid
       @thread_to_child = {}        # pid => Thread
+      @loop = true
     end
 
     # @return [void]
@@ -53,7 +50,6 @@ module ParallelServer
     def start(&block)
       raise 'block required' unless block
       @block = block
-      @loop = true
       @sockets = Socket.tcp_server_sockets(@host, @port)
       @sockets.each{|s| s.listen(@listen_backlog)} if @listen_backlog
       @reload_args = nil
@@ -62,12 +58,13 @@ module ParallelServer
         watch_children
         adjust_children
       end
-      @sockets.each(&:close)
-      @to_child.values.each(&:close)
+    ensure
+      @sockets.each{|s| s.close rescue nil} if @sockets
+      @to_child.values.each{|s| s.close rescue nil}
       @to_child.clear
       @thread_to_child.values.each(&:exit)
       @thread_to_child.clear
-      Thread.new{wait_all_children}
+      Timeout.timeout(1){wait_all_children} rescue Thread.new{wait_all_children}
     end
 
     # @overload reload(host=nil, port, opts={})
@@ -77,19 +74,25 @@ module ParallelServer
       @reload_args = parse_args(*args)
     end
 
+    # @return [void]
+    def stop
+      @loop = false
+    end
+
+    # @return [void]
+    def stop!
+      Process.kill 'TERM', *@children rescue nil
+      @loop = false
+    end
+
+    private
+
     # @return [void]
     def do_reload
       host, port, @opts = @reload_args
       @reload_args = nil
-
-      @min_processes = @opts[:min_processes] || DEFAULT_MIN_PROCESSES
-      @max_processes = @opts[:max_processes] || DEFAULT_MAX_PROCESSES
-      @max_threads = @opts[:max_threads] || DEFAULT_MAX_THREADS
-      @standby_threads = @opts[:standby_threads] || DEFAULT_STANDBY_THREADS
-      @listen_backlog = @opts[:listen_backlog]
-      @on_start = @opts[:on_start]
-      @on_child_start = @opts[:on_child_start]
-      @on_child_exit = @opts[:on_child_exit]
+      old_listen_backlog = @listen_backlog
+      set_variables_from_opts
 
       address_changed = false
       if @host != host || @port != port
@@ -98,6 +101,8 @@ module ParallelServer
         @sockets = Socket.tcp_server_sockets(@host, @port)
         @sockets.each{|s| s.listen(@listen_backlog)} if @listen_backlog
         address_changed = true
+      elsif @listen_backlog != old_listen_backlog
+        @sockets.each{|s| s.listen(@listen_backlog)} if @listen_backlog
       end
 
       reload_children(address_changed)
@@ -109,14 +114,13 @@ module ParallelServer
       data = {}
       data[:address_changed] = address_changed
       data[:options] = @opts.select{|_, value| Marshal.dump(value) rescue nil}
-      data = Marshal.dump(data)
       talk_to_children data
     end
 
     # @param data [String]
     # @return [void]
     def talk_to_children(data)
-      @data_to_child = data
+      @data_to_child = Marshal.dump(data)
       @thread_to_child.values.each do |thr|
         begin
           thr.run
@@ -129,25 +133,14 @@ module ParallelServer
     # @param io [IO]
     # @return [void]
     def talk_to_child_loop(io)
+      data = nil
       while true
-        Thread.stop
+        Thread.stop if data.nil? || data == @data_to_child
         data = @data_to_child
-        io.puts data.length
-        io.write data
+        Conversation._send(io, data)
       end
     end
 
-    # @return [void]
-    def stop
-      @loop = false
-    end
-
-    # @return [void]
-    def stop!
-      Process.kill 'TERM', *@children rescue nil
-      @loop = false
-    end
-
     # @overload parse_args(host=nil, port, opts={})
     #   @macro args
     # @return [Array<String, String, Hash>] hostname, port, option
@@ -174,7 +167,7 @@ module ParallelServer
       if readable
         readable.each do |from_child|
           pid = @from_child[from_child]
-          if st = read_child_status(from_child)
+          if st = Conversation.recv(from_child)
             @child_status[pid].update st
             if st[:status] == :stop
               @to_child[pid].close rescue nil
@@ -198,17 +191,6 @@ module ParallelServer
       end
     end
 
-    # @param io [IO]
-    # @return [Hash]
-    def read_child_status(io)
-      len = io.gets
-      return unless len && len =~ /\A\d+\n/
-      len = len.to_i
-      data = io.read(len)
-      return unless data.size == len
-      Marshal.load(data)
-    end
-
     # @return [void]
     def adjust_children
       (@min_processes - available_children).times do
@@ -274,6 +256,17 @@ module ParallelServer
       @on_child_start.call(pid) if @on_child_start
     end
 
+    def set_variables_from_opts
+      @min_processes = @opts[:min_processes] || DEFAULT_MIN_PROCESSES
+      @max_processes = @opts[:max_processes] || DEFAULT_MAX_PROCESSES
+      @max_threads = @opts[:max_threads] || DEFAULT_MAX_THREADS
+      @standby_threads = @opts[:standby_threads] || DEFAULT_STANDBY_THREADS
+      @listen_backlog = @opts[:listen_backlog]
+      @on_start = @opts[:on_start]
+      @on_child_start = @opts[:on_child_start]
+      @on_child_exit = @opts[:on_child_exit]
+    end
+
     class Child
 
       attr_reader :options
@@ -304,23 +297,52 @@ module ParallelServer
         @options[:max_idle] || DEFAULT_MAX_IDLE
       end
 
+      # @return [Integer]
+      def max_use
+        @options[:max_use] || DEFAULT_MAX_USE
+      end
+
       # @param block [#call]
       # @return [void]
       def start(block)
-        first = true
-        while @status == :run
-          wait_thread
-          sock, addr = accept(first)
-          break unless sock
-          first = false
-          Thread.new(sock, addr){|s, a| run(s, a, block)}
-        end
-        @status = :stop
+        main_thread = Thread.current
+        accept_thread = Thread.new{ accept_loop(block, main_thread) }
+        reload_thread = Thread.new{ reload_loop(main_thread) }
+
+        # wait that accept_loop or reload_loop end
+        Thread.stop while @status == :run
+
+        accept_thread.exit
         @sockets.each(&:close)
         @threads_mutex.synchronize do
           notify_status
         end
         wait_all_connections
+        reload_thread.exit
+      end
+
+      private
+
+      # @param block [#call]
+      # @param main_thread [Thread]
+      # @return [void]
+      def accept_loop(block, main_thread)
+        count = 0
+        while @status == :run
+          wait_thread
+          sock, addr = accept
+          next if sock.nil? && count == 0
+          break unless sock
+          thr = Thread.new(sock, addr){|s, a| run(s, a, block)}
+          @threads_mutex.synchronize do
+            @threads[thr] = addr
+          end
+          count += 1
+          break if count >= max_use
+        end
+      ensure
+        @status = :stop
+        main_thread.run
       end
 
       # @return [void]
@@ -328,20 +350,25 @@ module ParallelServer
         @threads.keys.each do |thr|
           thr.join rescue nil
         end
+        @status = :exit
       end
 
+      # @param main_thread [Thread]
       # @return [void]
-      def reload
-        len = @from_parent.gets
-        raise unless len && len =~ /\A\d+\n/
-        len = len.to_i
-        data = @from_parent.read(len)
-        raise unless data.size == len
-        data = Marshal.load(data)
-        raise if data[:address_changed]
-        @options.update data[:options]
-      rescue
+      def reload_loop(main_thread)
+        while true
+          data = Conversation.recv(@from_parent)
+          break unless data
+          @options.update data[:options]
+          @options[:on_reload].call @options if @options[:on_reload]
+          @status = :stop if data[:address_changed]
+          @threads_cv.signal
+        end
+        @from_parent.close
+        @from_parent = nil
+      ensure
         @status = :stop
+        main_thread.run
       end
 
       # @return [void]
@@ -378,9 +405,7 @@ module ParallelServer
           status: @status,
           connections: connections,
         }
-        data = Marshal.dump(status)
-        @to_parent.puts data.length
-        @to_parent.write data
+        Conversation.send(@to_parent, status)
       rescue Errno::EPIPE
         # ignore
       end
@@ -399,20 +424,13 @@ module ParallelServer
         disconnect
       end
 
-      # @param first [Boolean]
       # @return [Array<Socket, AddrInfo>]
       # @return [nil]
-      def accept(first=nil)
+      def accept
         while true
-          timer = first ? nil : max_idle
-          readable, = IO.select(@sockets+[@from_parent], nil, nil, timer)
+          readable, = IO.select(@sockets, nil, nil, max_idle)
           return nil unless readable
           r, = readable
-          if r == @from_parent
-            reload
-            next if @status == :run
-            return nil
-          end
           begin
             sock, addr = r.accept_nonblock
             return [sock, addr]
@@ -422,5 +440,33 @@ module ParallelServer
         end
       end
     end
+
+    class Conversation
+      # @param io [IO]
+      # @param msg [Object]
+      # @return [void]
+      def self.send(io, msg)
+        _send(io, Marshal.dump(msg))
+      end
+
+      # @param io [IO]
+      # @param data [String] marshaled data
+      # @return [void]
+      def self._send(io, data)
+        io.puts data.length
+        io.write data
+      end
+
+      # @param io [IO]
+      # @return [Object]
+      def self.recv(io)
+        len = io.gets
+        return unless len && len =~ /\A\d+\n/
+        len = len.to_i
+        data = io.read(len)
+        return unless data && data.size == len
+        Marshal.load(data)
+      end
+    end
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: parallel_server
 version: !ruby/object:Gem::Version
-  version: 0.1.1
+  version: 0.1.2
 platform: ruby
 authors:
 - Tomita Masahiro
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-08-19 00:00:00.000000000 Z
+date: 2014-10-06 00:00:00.000000000 Z
 dependencies: []
 description: Parallel TCP Server library. This is easy to make Multi-Process / Multi-Thread
   server