parallel_server 0.1 → 0.1.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 3d780167579eef4a691c12ab19a0ace61393a41e
-  data.tar.gz: f6a61cfbe9f26dfb093eef85347a5d64ba706449
+  metadata.gz: 45b4976310bb10eafcde6ffd88c58109b37e8484
+  data.tar.gz: f82ca0d3995fd5ea389696d3cbf8f4db793ca6cc
 SHA512:
-  metadata.gz: 98a37012be40e65058989a402d01058c4d6af1505d095187881dcddc94d1cceed50d5ea66b594e7131837e75dd182d8fa333c51dde2ff3edab240e10c7439768
-  data.tar.gz: c41df8dbfdac04e5923eb110e8b10231d878c1b97a80b97925480abe95558d23e90a9c63e03b6627967432563fc976838792d46544e6f2dd7367d7de096dcda5
+  metadata.gz: e109c329657a2318947e0225c81f7ffcf2eced73cda705fa2dff5996c7e5f65fead30dad4c8e0023bb0d5ef71d31edce2f70a36aab3b638d556808ed66c7e928
+  data.tar.gz: 6db5efc1e016e5de43645123db4a3f4b2e47ef538c05fa116ce01c66a539d65bfda0000b1e7c16e6a05ef28bf06a39bcf560b9b6b0bece8f4d6584eddbe01a88

data/README.md

@@ -50,26 +50,30 @@ ParallelServer::Prefork の動作を設定するパラメータ。
 空きスレッド数を指定します(デフォルト: 5)。
 少なくともこの数だけの接続を受け付けられるようにプロセス数を調整します。
 
-`:back_log` :
-待ち受けポートの listen back log を指定します(デフォルト: standby_threads と同じ)。
+`:listen_backlog` :
+待ち受けポートの listen backlog を指定します(デフォルト: nil)。
+未指定時は何も設定しないので backlog の値はシステム依存です。
 
 `:max_idle` :
 指定秒数の間、クライアントからの新たな接続がないとプロセスを終了します(デフォルト: 10)。
 生成後一度も接続されていないプロセスはこのパラメータの影響を受けません。
 max_idle 経過後でもクライアントと接続中であればプロセスは終了しません。ただし `:min_processes`, `:max_processes` のカウント対象外です。
 
-`:on_child_start` :
+`:on_start` :
 子プロセス起動時に*子プロセス側*で実行される処理を Proc で指定します。Proc 実行時の引数はありません。
 
+`:on_child_start` :
+子プロセス起動時に*親プロセス側*で実行される処理を Proc で指定します。Proc 実行時の引数はプロセスID(Integer)です。
+
 `:on_child_exit` :
 子プロセス終了時に*親プロセス側*で実行される処理を Proc で指定します。Proc 実行時の引数はプロセスID(Integer)と終了ステータス(Process::Status)です。
 
 ### #start
 
-* `start{|sock, addr| ...}`
+* `start{|sock, addr, child| ...}`
 
 待ち受けを開始します。クライアントから接続する毎にスレッドを生成して、ブロックを実行します。
-ブロックパラメータは Socket と Addrinfo です。
+ブロックパラメータは Socket と Addrinfo と ParallelServer::Prefork::Child です。
 
 ### #reload
 

data/lib/parallel_server/prefork.rb

@@ -9,6 +9,8 @@ module ParallelServer
     DEFAULT_STANDBY_THREADS = 5
     DEFAULT_MAX_IDLE = 10
 
+    attr_reader :child_status
+
     # @!macro [new] args
     #   @param host [String] hostname or IP address
     #   @param port [Integer / String] port number / service name
@@ -17,39 +19,43 @@ module ParallelServer
     #   @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_threads (1) maximum threads per process
-    #   @option opts [#call] :on_child_start (nil) object#call() is invoked when child process start. This is called in child process.
-    #   @option opts [#call] :on_child_exit (nil) object#call(pid, status) is invoked when child process stop. This is call in parent process.
     #   @option opts [Integer] :standby_threads (5) keep free processes or threads
-    #   @option opts [Integer] :back_log (same as standby_threads) listen back log
+    #   @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_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.
 
     # @overload initialize(host=nil, port, opts={})
     #   @!macro args
     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
-      @on_child_start = opts[:on_child_start]
-      @on_child_exit = opts[:on_child_exit]
-      @standby_threads = opts[:standby_threads] || DEFAULT_STANDBY_THREADS
-      @back_log = opts[:back_log] || @standby_threads
+      @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]
       @from_child = {}             # IO => pid
       @to_child = {}               # pid => IO
       @child_status = {}           # pid => Hash
       @children = []               # pid
+      @thread_to_child = {}        # pid => Thread
     end
 
     # @return [void]
-    # @yield [sock, addr]
+    # @yield [sock, addr, child]
     # @yieldparam sock [Socket]
     # @yieldparam addr [Addrinfo]
+    # @yieldparam child [ParallelServer::Prefork::Child]
     def start(&block)
       raise 'block required' unless block
       @block = block
       @loop = true
       @sockets = Socket.tcp_server_sockets(@host, @port)
-      @sockets.each{|s| s.listen(@back_log)}
+      @sockets.each{|s| s.listen(@listen_backlog)} if @listen_backlog
       @reload_args = nil
       while @loop
         do_reload if @reload_args
@@ -59,6 +65,8 @@ module ParallelServer
       @sockets.each(&:close)
       @to_child.values.each(&:close)
       @to_child.clear
+      @thread_to_child.values.each(&:exit)
+      @thread_to_child.clear
       Thread.new{wait_all_children}
     end
 
@@ -77,34 +85,56 @@ module ParallelServer
       @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]
-      @standby_threads = @opts[:standby_threads] || DEFAULT_STANDBY_THREADS
-      @back_log = @opts[:back_log] || @standby_threads
 
-      data = {}
+      address_changed = false
       if @host != host || @port != port
         @host, @port = host, port
         @sockets.each(&:close)
         @sockets = Socket.tcp_server_sockets(@host, @port)
-        @sockets.each{|s| s.listen(@back_log)}
-        data[:address_changed] = true
+        @sockets.each{|s| s.listen(@listen_backlog)} if @listen_backlog
+        address_changed = true
       end
-      data[:opts] = @opts.select{|_, value| Marshal.dump(value) rescue nil}
+
+      reload_children(address_changed)
+    end
+
+    # @param address_changed [true/false]
+    # @return [void]
+    def reload_children(address_changed=false)
+      data = {}
+      data[:address_changed] = address_changed
+      data[:options] = @opts.select{|_, value| Marshal.dump(value) rescue nil}
       data = Marshal.dump(data)
-      @to_child.values.each do |pipe|
-        talk_to_child pipe, data
+      talk_to_children data
+    end
+
+    # @param data [String]
+    # @return [void]
+    def talk_to_children(data)
+      @data_to_child = data
+      @thread_to_child.values.each do |thr|
+        begin
+          thr.run
+        rescue ThreadError
+          # try to run dead thread. ignore it.
+        end
       end
     end
 
     # @param io [IO]
-    # @param data [String]
     # @return [void]
-    def talk_to_child(io, data)
-      io.puts data.length
-      io.write data
-    rescue Errno::EPIPE
-      # ignore
+    def talk_to_child_loop(io)
+      while true
+        Thread.stop
+        data = @data_to_child
+        io.puts data.length
+        io.write data
+      end
     end
 
     # @return [void]
@@ -145,10 +175,19 @@ module ParallelServer
         readable.each do |from_child|
           pid = @from_child[from_child]
           if st = read_child_status(from_child)
-            @child_status[pid] = st
+            @child_status[pid].update st
+            if st[:status] == :stop
+              @to_child[pid].close rescue nil
+              @to_child.delete pid
+              @thread_to_child[pid].exit rescue nil
+              @thread_to_child.delete pid
+            end
           else
             @from_child.delete from_child
+            @to_child[pid].close rescue nil
             @to_child.delete pid
+            @thread_to_child[pid].exit rescue nil
+            @thread_to_child.delete pid
             @child_status.delete pid
             from_child.close
           end
@@ -187,14 +226,14 @@ module ParallelServer
     # @return [Array<Integer, Integer>]
     def current_capacity_and_connections
       values = @child_status.values
-      capa = values.map{|st| st[:capacity]}.reduce(&:+).to_i
-      conn = values.map{|st| st[:running]}.reduce(&:+).to_i
+      capa = values.count{|st| st[:status] == :run} * @max_threads
+      conn = values.map{|st| st[:connections].count}.reduce(&:+).to_i
       return [capa, conn]
     end
 
     # @return [Integer]
     def available_children
-      @child_status.values.select{|st| st[:capacity] > 0}.size
+      @child_status.values.count{|st| st[:status] == :run}
     end
 
     # @return [void]
@@ -222,41 +261,47 @@ module ParallelServer
         @to_child.values.each(&:close)
         from_child[0].close
         to_child[1].close
-        @on_child_start.call if @on_child_start
+        @on_start.call if @on_start
         Child.new(@sockets, @opts, from_child[1], to_child[0]).start(@block)
       end
       from_child[1].close
       to_child[0].close
       @from_child[from_child[0]] = pid
       @to_child[pid] = to_child[1]
+      @thread_to_child[pid] = Thread.new(to_child[1]){|io| talk_to_child_loop(io)}
       @children.push pid
-      @child_status[pid] = {capacity: @max_threads, running: 0}
+      @child_status[pid] = {status: :run, connections: {}}
+      @on_child_start.call(pid) if @on_child_start
     end
 
     class Child
+
+      attr_reader :options
+
       # @param sockets [Array<Socket>]
       # @param opts [Hash]
       # @param to_parent [IO]
       # @param from_parent [IO]
       def initialize(sockets, opts, to_parent, from_parent)
         @sockets = sockets
-        @opts = opts
+        @options = opts
         @to_parent = to_parent
         @from_parent = from_parent
         @threads = {}
         @threads_mutex = Mutex.new
         @threads_cv = ConditionVariable.new
+        @parent_mutex = Mutex.new
         @status = :run
       end
 
       # @return [Integer]
       def max_threads
-        @opts[:max_threads] || DEFAULT_MAX_THREADS
+        @options[:max_threads] || DEFAULT_MAX_THREADS
       end
 
       # @return [Integer]
       def max_idle
-        @opts[:max_idle] || DEFAULT_MAX_IDLE
+        @options[:max_idle] || DEFAULT_MAX_IDLE
       end
 
       # @param block [#call]
@@ -268,12 +313,12 @@ module ParallelServer
           sock, addr = accept(first)
           break unless sock
           first = false
-          thr = Thread.new(sock, addr){|s, a| run(s, a, block)}
-          connected(thr)
+          Thread.new(sock, addr){|s, a| run(s, a, block)}
         end
+        @status = :stop
         @sockets.each(&:close)
         @threads_mutex.synchronize do
-          notice_status
+          notify_status
         end
         wait_all_connections
       end
@@ -294,7 +339,7 @@ module ParallelServer
         raise unless data.size == len
         data = Marshal.load(data)
         raise if data[:address_changed]
-        @opts.update data[:opts]
+        @options.update data[:options]
       rescue
         @status = :stop
       end
@@ -308,12 +353,12 @@ module ParallelServer
         end
       end
 
-      # @param thread [Thread]
+      # @param addr [Addrinfo]
       # @return [void]
-      def connected(thread)
+      def connected(addr)
         @threads_mutex.synchronize do
-          @threads[thread] = true
-          notice_status
+          @threads[Thread.current] = addr
+          notify_status
         end
       end
 
@@ -321,16 +366,17 @@ module ParallelServer
       def disconnect
         @threads_mutex.synchronize do
           @threads.delete Thread.current
-          notice_status
+          notify_status
           @threads_cv.signal
         end
       end
 
       # @return [void]
-      def notice_status
+      def notify_status
+        connections = Hash[@threads.map{|thr, adr| [thr.object_id, adr]}]
         status = {
-          running: @threads.size,
-          capacity: @status == :run ? max_threads : 0,
+          status: @status,
+          connections: connections,
         }
         data = Marshal.dump(status)
         @to_parent.puts data.length
@@ -344,7 +390,8 @@ module ParallelServer
       # @param block [#call]
       # @return [void]
       def run(sock, addr, block)
-        block.call(sock, addr)
+        connected(addr)
+        block.call(sock, addr, self)
       rescue Exception => e
         STDERR.puts e.inspect, e.backtrace.inspect
       ensure

metadata

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