parallel_server 0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 3d780167579eef4a691c12ab19a0ace61393a41e
+  data.tar.gz: f6a61cfbe9f26dfb093eef85347a5d64ba706449
+SHA512:
+  metadata.gz: 98a37012be40e65058989a402d01058c4d6af1505d095187881dcddc94d1cceed50d5ea66b594e7131837e75dd182d8fa333c51dde2ff3edab240e10c7439768
+  data.tar.gz: c41df8dbfdac04e5923eb110e8b10231d878c1b97a80b97925480abe95558d23e90a9c63e03b6627967432563fc976838792d46544e6f2dd7367d7de096dcda5

data/README.md

@@ -0,0 +1,93 @@
+ParallelServer
+==============
+
+ParallelServer は Ruby の並列 TCP/IP サーバーを簡単に作ることが出来るライブラリです。
+
+ParallelServer::Prefork
+-----------------------
+
+あらかじめ処理用のプロセスを生成しておき、接続毎にスレッドを生成して処理を実行します。
+
+### 例
+
+```ruby
+require 'parallel_server/prefork'
+
+pl = ParallelServer::Prefork.new(12345, max_processes: 100, max_idle: 100)
+pl.start do |sock, addr|
+  sock.puts 'Who are you?'
+  name = sock.gets
+  sock.puts "Hello, #{name}"
+end
+```
+
+### ParallelServer::Prefork.new
+
+* `ParallelServer::Prefork.new(port, opts={})`
+* `ParallelServer::Prefork.new(host, port, opts={})`
+
+#### host
+
+待ち受けるIPアドレス。省略時はすべてのIPアドレスで待ち受けます。
+
+#### port
+待ち受けるTCPポート番号。
+
+#### opts
+
+ParallelServer::Prefork の動作を設定するパラメータ。
+
+`:min_processes` :
+最小プロセス数を指定します(デフォルト: 5)。
+
+`:max_processes` :
+最大プロセス数を指定します(デフォルト: 20)。
+
+`:max_threads` :
+1プロセスあたりの最大スレッド数を指定します(デフォルト: 1)。
+
+`:standby_threads` :
+空きスレッド数を指定します(デフォルト: 5)。
+少なくともこの数だけの接続を受け付けられるようにプロセス数を調整します。
+
+`:back_log` :
+待ち受けポートの listen back log を指定します(デフォルト: standby_threads と同じ)。
+
+`:max_idle` :
+指定秒数の間、クライアントからの新たな接続がないとプロセスを終了します(デフォルト: 10)。
+生成後一度も接続されていないプロセスはこのパラメータの影響を受けません。
+max_idle 経過後でもクライアントと接続中であればプロセスは終了しません。ただし `:min_processes`, `:max_processes` のカウント対象外です。
+
+`:on_child_start` :
+子プロセス起動時に*子プロセス側*で実行される処理を Proc で指定します。Proc 実行時の引数はありません。
+
+`:on_child_exit` :
+子プロセス終了時に*親プロセス側*で実行される処理を Proc で指定します。Proc 実行時の引数はプロセスID(Integer)と終了ステータス(Process::Status)です。
+
+### #start
+
+* `start{|sock, addr| ...}`
+
+待ち受けを開始します。クライアントから接続する毎にスレッドを生成して、ブロックを実行します。
+ブロックパラメータは Socket と Addrinfo です。
+
+### #reload
+
+* `reload(port, opts={})`
+* `reload(host, port, opts={})`
+
+引数の形式は new と同じです。
+
+start 後にパラメータを変更したい場合に使用します。
+
+### #stop
+
+* `stop`
+
+start を終了します。クライアントと接続中の子プロセスは接続が切断されるまで終了しません。
+
+### #stop!
+
+* `stop!`
+
+start を終了します。子プロセスがクライアントと接続中でも SIGTERM で終了させます。

data/lib/parallel_server/prefork.rb

@@ -0,0 +1,379 @@
+require 'socket'
+require 'thread'
+
+module ParallelServer
+  class Prefork
+    DEFAULT_MIN_PROCESSES = 5
+    DEFAULT_MAX_PROCESSES = 20
+    DEFAULT_MAX_THREADS = 1
+    DEFAULT_STANDBY_THREADS = 5
+    DEFAULT_MAX_IDLE = 10
+
+    # @!macro [new] args
+    #   @param host [String] hostname or IP address
+    #   @param port [Integer / String] port number / service name
+    #   @param opts [Hash] options
+    #   @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_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
+
+    # @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
+      @from_child = {}             # IO => pid
+      @to_child = {}               # pid => IO
+      @child_status = {}           # pid => Hash
+      @children = []               # pid
+    end
+
+    # @return [void]
+    # @yield [sock, addr]
+    # @yieldparam sock [Socket]
+    # @yieldparam addr [Addrinfo]
+    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)}
+      @reload_args = nil
+      while @loop
+        do_reload if @reload_args
+        watch_children
+        adjust_children
+      end
+      @sockets.each(&:close)
+      @to_child.values.each(&:close)
+      @to_child.clear
+      Thread.new{wait_all_children}
+    end
+
+    # @overload reload(host=nil, port, opts={})
+    #   @macro args
+    # @return [void]
+    def reload(*args)
+      @reload_args = parse_args(*args)
+    end
+
+    # @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
+      @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 = {}
+      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
+      end
+      data[:opts] = @opts.select{|_, value| Marshal.dump(value) rescue nil}
+      data = Marshal.dump(data)
+      @to_child.values.each do |pipe|
+        talk_to_child pipe, data
+      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
+    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
+    def parse_args(*args)
+      opts = {}
+      arg_count = args.size
+      if args.last.is_a? Hash
+        opts = args.pop
+      end
+      if args.size == 1
+        host, port = nil, args.first
+      elsif args.size == 2
+        host, port = args
+      else
+        raise ArgumentError, "wrong number of arguments (#{arg_count} for 1..3)"
+      end
+      return host, port, opts
+    end
+
+    # @return [Integer]
+    def watch_children
+      rset = @from_child.empty? ? nil : @from_child.keys
+      readable, = IO.select(rset, nil, nil, 0.1)
+      if readable
+        readable.each do |from_child|
+          pid = @from_child[from_child]
+          if st = read_child_status(from_child)
+            @child_status[pid] = st
+          else
+            @from_child.delete from_child
+            @to_child.delete pid
+            @child_status.delete pid
+            from_child.close
+          end
+        end
+      end
+      if @children.size != @child_status.size
+        wait_children
+      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
+        start_child
+      end
+      capa, conn = current_capacity_and_connections
+      required_connections = conn + @standby_threads
+      required_processes = (required_connections - capa + @max_threads - 1) / @max_threads
+      [required_processes, @max_processes - available_children].min.times do
+        start_child
+      end
+    end
+
+    # current capacity and current connections
+    # @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
+      return [capa, conn]
+    end
+
+    # @return [Integer]
+    def available_children
+      @child_status.values.select{|st| st[:capacity] > 0}.size
+    end
+
+    # @return [void]
+    def wait_children
+      @children.delete_if do |pid|
+        _pid, status = Process.waitpid2(pid, Process::WNOHANG)
+        @on_child_exit.call(pid, status) if _pid && @on_child_exit
+        _pid
+      end
+    end
+
+    # @return [void]
+    def wait_all_children
+      until @children.empty?
+        watch_children
+      end
+    end
+
+    # @return [void]
+    def start_child
+      from_child = IO.pipe
+      to_child = IO.pipe
+      pid = fork do
+        @from_child.keys.each(&:close)
+        @to_child.values.each(&:close)
+        from_child[0].close
+        to_child[1].close
+        @on_child_start.call if @on_child_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]
+      @children.push pid
+      @child_status[pid] = {capacity: @max_threads, running: 0}
+    end
+
+    class Child
+      # @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
+        @to_parent = to_parent
+        @from_parent = from_parent
+        @threads = {}
+        @threads_mutex = Mutex.new
+        @threads_cv = ConditionVariable.new
+        @status = :run
+      end
+
+      # @return [Integer]
+      def max_threads
+        @opts[:max_threads] || DEFAULT_MAX_THREADS
+      end
+
+      # @return [Integer]
+      def max_idle
+        @opts[:max_idle] || DEFAULT_MAX_IDLE
+      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
+          thr = Thread.new(sock, addr){|s, a| run(s, a, block)}
+          connected(thr)
+        end
+        @sockets.each(&:close)
+        @threads_mutex.synchronize do
+          notice_status
+        end
+        wait_all_connections
+      end
+
+      # @return [void]
+      def wait_all_connections
+        @threads.keys.each do |thr|
+          thr.join rescue nil
+        end
+      end
+
+      # @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]
+        @opts.update data[:opts]
+      rescue
+        @status = :stop
+      end
+
+      # @return [void]
+      def wait_thread
+        @threads_mutex.synchronize do
+          while @threads.size >= max_threads
+            @threads_cv.wait(@threads_mutex)
+          end
+        end
+      end
+
+      # @param thread [Thread]
+      # @return [void]
+      def connected(thread)
+        @threads_mutex.synchronize do
+          @threads[thread] = true
+          notice_status
+        end
+      end
+
+      # @return [void]
+      def disconnect
+        @threads_mutex.synchronize do
+          @threads.delete Thread.current
+          notice_status
+          @threads_cv.signal
+        end
+      end
+
+      # @return [void]
+      def notice_status
+        status = {
+          running: @threads.size,
+          capacity: @status == :run ? max_threads : 0,
+        }
+        data = Marshal.dump(status)
+        @to_parent.puts data.length
+        @to_parent.write data
+      rescue Errno::EPIPE
+        # ignore
+      end
+
+      # @param sock [Socket]
+      # @param addr [AddrInfo]
+      # @param block [#call]
+      # @return [void]
+      def run(sock, addr, block)
+        block.call(sock, addr)
+      rescue Exception => e
+        STDERR.puts e.inspect, e.backtrace.inspect
+      ensure
+        sock.close rescue nil
+        disconnect
+      end
+
+      # @param first [Boolean]
+      # @return [Array<Socket, AddrInfo>]
+      # @return [nil]
+      def accept(first=nil)
+        while true
+          timer = first ? nil : max_idle
+          readable, = IO.select(@sockets+[@from_parent], nil, nil, timer)
+          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]
+          rescue IO::WaitReadable
+            next
+          end
+        end
+      end
+    end
+  end
+end

metadata

@@ -0,0 +1,48 @@
+--- !ruby/object:Gem::Specification
+name: parallel_server
+version: !ruby/object:Gem::Version
+  version: '0.1'
+platform: ruby
+authors:
+- Tomita Masahiro
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2014-07-30 00:00:00.000000000 Z
+dependencies: []
+description: Parallel TCP Server library. This is easy to make Multi-Process / Multi-Thread
+  server
+email: tommy@tmtm.org
+executables: []
+extensions: []
+extra_rdoc_files:
+- README.md
+files:
+- README.md
+- lib/parallel_server/prefork.rb
+homepage: http://github.com/tmtm/parallel_server
+licenses:
+- Ruby's
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.2.2
+signing_key: 
+specification_version: 4
+summary: Parallel TCP Server library
+test_files: []
+has_rdoc: true