prefork_engine 0.0.1 → 0.0.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 227fa879a618645e19ba65f3abfc259f69f5dc79
-  data.tar.gz: 416e99bead194dec4626ce28a7bcb0db3a5f9b01
+  metadata.gz: 28b3d832f86df0ffd4cc4f50995409fdf6e5fa03
+  data.tar.gz: 7cccd2f8bf896a14e5695616cf745b86c0905c10
 SHA512:
-  metadata.gz: 9c7b50e3ebe7fed72b1c390c77ec102fb19aa36ad5350361a92f36b9fbeaa242d51c799f0674e93811b500f598fc2e16e04b557f45b78b3af8c7d9b6641f5041
-  data.tar.gz: adf4233d2a8d8b164d1dafdb160e994855edb56721096bda279dd423cf461b87c97ffe2ba9f597c808724d62f2fb10aecb7b62834a019542c0b3fa83af08ed92
+  metadata.gz: 0ca812d9907a61cfe97d6199d3c3f72c56b4e92ef82a34b1748933cb10affecac50081d1cf0e1235e9a173323f3bebae218e6c7150661bfd9cd1b08bfa2ca1a9
+  data.tar.gz: 772d6caa397e481338a53018fe948f83172cffbf52bcc057190e4d963acf427a9a3498d040e54daff91c9b7a8b1cb4858bca24cedae3c3e40027f58586e89b4a

data/Changes

@@ -0,0 +1,4 @@
+0.0.2 2014-12-11T13:22:49Z
+
+    - remove unnecessary gems from requires 
+    - add example rack handler

data/example/config.ru

@@ -0,0 +1,13 @@
+class HelloApp
+  def call(env)
+    # p env
+    [
+      200,
+      { 'Content-Type' => 'text/html' },
+      ['hello world ']
+    ]
+  end
+end
+
+run HelloApp.new
+

data/example/starlet.rb

@@ -0,0 +1,306 @@
+# -*- coding: utf-8 -*-
+
+# sample Rack handler using PreforkEngine
+# This is ruby port of Starlet (https://metacpan.org/pod/Starlet)
+#
+# ## How to use
+# $ gem install pico_http_parser
+# $ gem isntall prefork_engine
+# $ cat config.ru
+# class HelloApp
+#   def call(env)
+#     [
+#       200,
+#       { 'Content-Type' => 'text/html' },
+#       ['hello world ']
+#     ]
+#   end
+# end
+#
+# run HelloApp.new
+#
+# $ rackup -r ./starlet.rb -E production -s Starlet \
+#    -O MaxWorkers=5 -O MaxRequestPerChild=1000 -O MinRequestPerChild=800 config.ru
+#
+# ## LICENSE
+# This program is free software; you can redistribute it and/or modify it under the same terms as Perl itself.
+# See http://www.perl.com/perl/misc/Artistic.html
+
+$LOAD_PATH.unshift File.expand_path('../../lib', __FILE__)
+require 'rubygems'
+require 'rack'
+require 'stringio'
+require 'socket'
+require 'rack/utils'
+require 'io/nonblock'
+require 'prefork_engine'
+require 'pico_http_parser'
+
+module Rack
+  module Handler
+    class Starlet
+      DEFAULT_OPTIONS = {
+        :Host => '0.0.0.0',
+        :Port => 9292,
+        :MaxWorkers => 10,
+        :Timeout => 300,
+        :MaxRequestPerChild => 100,
+        :MinRequestPerChild => nil,
+        :SpawnInterval => nil,
+        :ErrRespawnInterval => nil
+      }
+      NULLIO  = StringIO.new("").set_encoding('BINARY')
+
+      def self.run(app, options={})
+        slf = new(options)
+        slf.setup_listener()
+        slf.run_worker(app)
+      end
+
+      def self.valid_options
+        {
+          "Host=HOST" => "Hostname to listen on (default: 0.0.0.0)",
+          "Port=PORT" => "Port to listen on (default: 9292)",
+        }
+      end
+
+      def initialize(options={})
+        @options = DEFAULT_OPTIONS.merge(options)
+        @server = nil
+        @_is_tcp = false
+        @_using_defer_accept = false
+
+      end
+
+      def setup_listener()
+        if ENV["SERVER_STARTER_PORT"] then
+          hostport, fd = ENV["SERVER_STARTER_PORT"].split("=",2)
+          if m = hostport.match(/(.*):(\d+)/) then
+            @options[:Host] = m[0]
+            @options[:Port] = m[1].to_i
+          else
+            @options[:Port] = hostport
+          end
+          @server = TCPServer.for_fd(fd.to_i)
+          @_is_tcp = true if !@server.local_address.unix?
+        end
+
+        if @server == nil
+          @server = TCPServer.new(@options[:Host], @options[:Port])
+          @server.setsockopt(:SOCKET, :REUSEADDR, 1)
+          @_is_tcp = true
+        end
+
+        if RUBY_PLATFORM.match(/linux/) && @_is_tcp == true then
+          begin
+            @server.setsockopt(Socket::IPPROTO_TCP, 9, 1)
+            @_using_defer_accept = true
+          end
+        end
+      end
+
+      def run_worker(app)
+        pm_args = {
+          "max_workers" => @options[:MaxWorkers].to_i,
+          "trap_signals" => {
+            "TERM" => 'TERM',
+            "HUP"  => 'TERM',
+          },
+        }
+        if @options[:SpawnInterval] then
+          pm_args["trap_signals"]["USR1"] = ["TERM", @options[:SpawnInterval].to_i]
+          pm_args["spawn_interval"] = @options[:SpawnInterval].to_i
+        end
+        if @options[:ErrRespawnInterval] then
+          pm_args["err_respawn_interval"] = @options[:ErrRespawnInterval].to_i
+        end
+        pe = PreforkEngine.new(pm_args)
+        while !pe.signal_received.match(/^(TERM|USR1)$/)
+          pe.start {
+            srand
+            self.accept_loop(app)
+          }
+        end
+        pe.wait_all_children
+      end
+
+      def _calc_reqs_per_child
+        max = @options[:MaxRequestPerChild].to_i
+        if min = @options[:MinRequestPerChild] then
+          return (max - (max - min.to_i + 1) * rand).to_i
+        end
+        return max.to_i
+      end
+
+      def accept_loop(app)
+        @can_exit = true
+        @term_received = 0
+        proc_req_count = 0
+
+        Signal.trap('TERM') {
+          if @can_exit then
+            exit!(true)
+          end
+          @term_received += 1
+          if @can_exit || @term_received > 1 then
+            exit!(true)
+          end
+        }
+        Signal.trap('PIPE', 'IGNORE')
+        max_reqs = self._calc_reqs_per_child()
+        while proc_req_count < max_reqs
+          @can_exit = true
+          connection = @server.accept
+          begin
+            connection.nonblock(true) {
+              peeraddr = nil
+              peerport = 0
+              if @_is_tcp then
+                connection.setsockopt(Socket::IPPROTO_TCP, Socket::TCP_NODELAY, 1)
+                peer = connection.peeraddr
+                peeraddr = peer[2],
+                peerport = peer[1].to_s
+              end
+              proc_req_count += 1
+              @_is_deferred_accept = @_using_defer_accept
+              env = {
+                'SERVER_NAME' => @options[:Host],
+                'SERVER_PORT' => @options[:Port].to_s,
+                'REMOTE_ADDR' => peeraddr,
+                'REMOTE_PORT' => peerport,
+                'rack.version' => [0,1],
+                'rack.errors' => STDERR,
+                'rack.multithread' => false,
+                'rack.multiprocess' => false,
+                'rack.run_once' => false,
+                'rack.url_scheme' => 'http'
+              }
+              self.handle_connection(env, connection, app)
+            }
+          ensure
+            connection.close
+          end
+        end
+      end
+
+      def handle_connection(env, connection, app)
+        buf = ""
+        while true
+          readed = self.read_timeout(connection)
+          if readed == nil then
+            next
+          end
+          @can_exit = false
+          buf += readed
+          reqlen = PicoHTTPParser.parse_http_request(buf,env)
+          if reqlen >= 0 then
+            # force donwgrade to 1.0
+            env["SERVER_PROTOCOL"] = "HTTP/1.0"
+            # handle request
+            if (cl = env["CONTENT_LENGTH"].to_i) > 0 then
+              buf = buf.unpack('C*').slice(reqlen..-1).pack('C*')
+              buffer = StringIO.new("").set_encoding('BINARY')
+              while cl > 0
+                chunk = ""
+                if buf.bytesize > 0 then
+                  chunk = buf
+                  buf = ""
+                else
+                  readed = self.read_timeout(connection)
+                  if readed == nil then
+                    return
+                  end
+                  chunk += readed
+                end
+                buffer << chunk
+                cl -= chunk.bytesize
+              end
+              buffer.rewind
+              env["rack.input"] = buffer
+            else
+              env["rack.input"] = NULLIO
+            end
+            status, header, body = app.call(env)
+            res_header = "HTTP/1.0 "+status.to_s+" "+Rack::Utils::HTTP_STATUS_CODES[status]+"\r\nConnection: close\r\n"
+            header.each do |k,vs|
+              if k.downcase == "connection" then
+                next
+              end
+              res_header += k + ": " + vs + "\r\n"
+            end
+            res_header += "\r\n"
+            if body.length == 1 && body[0].bytesize < 40960 then
+              ret = self.write_all(connection,res_header+body[0])
+            else
+              ret = self.write_all(connection,res_header)
+              body.each do |part|
+                self.write_all(connection,part)
+              end
+            end
+            return true
+          elsif reqlen == -2 then
+            # request is incomplete, do nothing
+          else
+            # error
+            return nil
+          end
+        end
+      end
+
+      def read_timeout(connection)
+        if @_is_deferred_accept then
+          @_is_deferred_accept = false
+        else
+          if !IO.select([connection],nil,nil,300) then
+            return nil
+          end
+        end
+        while true
+          begin
+            buf = connection.sysread(4096)
+            return buf
+          rescue IO::WaitReadable
+            # retry
+            break
+          rescue EOFError
+            # closed
+            return nil
+          end
+        end
+      end
+
+      def write_timeout(connection, buf)
+        while true
+          begin
+            len = connection.syswrite(buf)
+            return len
+          rescue IO::WaitReadable
+            # retry
+            break
+          rescue EOFError
+            # closed
+            return nil
+          end
+        end
+        if !IO.select(nil,[connection],nil,300) then
+          return nil
+        end
+      end
+
+      def write_all(connection, buf)
+        off = 0
+        while buf.bytesize - off > 0
+          ret = self.write_timeout(connection,buf.unpack('C*').slice(off..-1).pack('C*'))
+          if ret == nil then
+            return nil
+          end
+          off += ret
+        end
+        return buf.bytesize
+      end
+
+    end
+  end
+end
+
+

data/lib/prefork_engine/version.rb

@@ -1,3 +1,3 @@
 class PreforkEngine
-  VERSION = "0.0.1"
+  VERSION = "0.0.2"
 end

data/prefork_engine.gemspec

@@ -22,6 +22,5 @@ Gem::Specification.new do |spec|
   spec.add_development_dependency "rake", "~> 10.0"
   spec.add_development_dependency "rspec"
 
-  spec.add_dependency "pico_http_parser", "~> 0.0.3"
   spec.add_dependency "proc-wait3", "~> 1.7.2"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: prefork_engine
 version: !ruby/object:Gem::Version
-  version: 0.0.1
+  version: 0.0.2
 platform: ruby
 authors:
 - Masahiro Nagano
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-12-10 00:00:00.000000000 Z
+date: 2014-12-11 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -52,20 +52,6 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
-- !ruby/object:Gem::Dependency
-  name: pico_http_parser
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: 0.0.3
-  type: :runtime
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: 0.0.3
 - !ruby/object:Gem::Dependency
   name: proc-wait3
   requirement: !ruby/object:Gem::Requirement
@@ -90,10 +76,13 @@ files:
 - ".gitignore"
 - ".rspec"
 - ".travis.yml"
+- Changes
 - Gemfile
 - LICENSE.txt
 - README.md
 - Rakefile
+- example/config.ru
+- example/starlet.rb
 - lib/prefork_engine.rb
 - lib/prefork_engine/version.rb
 - prefork_engine.gemspec