wendell-puma 2.9.2

data/lib/puma/jruby_restart.rb

@@ -0,0 +1,83 @@
+require 'ffi'
+
+module Puma
+  module JRubyRestart
+    extend FFI::Library
+    ffi_lib 'c'
+
+    attach_function :execlp, [:string, :varargs], :int
+    attach_function :chdir, [:string], :int
+    attach_function :fork, [], :int
+    attach_function :exit, [:int], :void
+    attach_function :setsid, [], :int
+
+    def self.chdir_exec(dir, argv)
+      chdir(dir)
+      cmd = argv.first
+      argv = ([:string] * argv.size).zip(argv).flatten
+      argv << :string
+      argv << nil
+      execlp(cmd, *argv)
+      raise SystemCallError.new(FFI.errno)
+    end
+
+    PermKey = 'PUMA_DAEMON_PERM'
+    RestartKey = 'PUMA_DAEMON_RESTART'
+
+    # Called to tell things "Your now always in daemon mode,
+    # don't try to reenter it."
+    #
+    def self.perm_daemonize
+      ENV[PermKey] = "1"
+    end
+
+    def self.daemon?
+      ENV.key?(PermKey) || ENV.key?(RestartKey)
+    end
+
+    def self.daemon_init
+      return true if ENV.key?(PermKey)
+
+      return false unless ENV.key? RestartKey
+
+      master = ENV[RestartKey]
+
+      # In case the master disappears early
+      begin
+        Process.kill "SIGUSR2", master.to_i
+      rescue SystemCallError => e
+      end
+
+      ENV[RestartKey] = ""
+
+      setsid
+
+      null = File.open "/dev/null", "w+"
+      STDIN.reopen null
+      STDOUT.reopen null
+      STDERR.reopen null
+
+      true
+    end
+
+    def self.daemon_start(dir, argv)
+      ENV['PUMA_DAEMON_RESTART'] = Process.pid.to_s
+
+      if k = ENV['PUMA_JRUBY_DAEMON_OPTS']
+        ENV['JRUBY_OPTS'] = k
+      end
+
+      cmd = argv.first
+      argv = ([:string] * argv.size).zip(argv).flatten
+      argv << :string
+      argv << nil
+
+      chdir(dir)
+      ret = fork
+      return ret if ret != 0
+      execlp(cmd, *argv)
+      raise SystemCallError.new(FFI.errno)
+    end
+  end
+end
+

data/lib/puma/minissl.rb

@@ -0,0 +1,187 @@
+if Puma::IS_JRUBY
+  require 'java'
+  java_import 'java.lang.RuntimeException'
+  require 'puma/delegation'
+end
+
+
+module Puma
+  module MiniSSL
+    class EngineWrapper
+      extend Puma::Delegation
+
+      %w(inject extract write).each do |action|
+        forward action, :@engine
+      end
+
+      def initialize(engine)
+        @engine=engine
+      end
+
+      if Puma::IS_JRUBY
+        def read
+          begin
+            @engine.read
+          rescue RuntimeException=>e
+            raise IOError.new("Unable to read from engine, #{e.message}")
+          end
+        end
+      else
+        forward :read, :@engine 
+      end
+    end
+    class Socket
+      def initialize(socket, engine)
+        @socket = socket
+        @engine = EngineWrapper.new(engine)
+      end
+
+      def to_io
+        @socket
+      end
+
+      def readpartial(size)
+        while true
+          output = @engine.read
+          return output if output
+
+          data = @socket.readpartial(size)
+          @engine.inject(data)
+          output = @engine.read
+
+          return output if output
+
+          while neg_data = @engine.extract
+            @socket.write neg_data
+          end
+        end
+      end
+
+      def engine_read_all
+        output = @engine.read
+        while output and additional_output = @engine.read
+          output << additional_output
+        end
+        output
+      end
+
+      def read_nonblock(size)
+        while true
+          output = engine_read_all
+          return output if output
+
+          data = @socket.read_nonblock(size)
+
+          @engine.inject(data)
+          output = engine_read_all
+
+          return output if output
+
+          while neg_data = @engine.extract
+            @socket.write neg_data
+          end
+        end
+      end
+
+      def write(data)
+        need = data.bytesize
+
+        while true
+          wrote = @engine.write data
+          enc = @engine.extract
+
+          while enc
+            @socket.write enc
+            enc = @engine.extract
+          end
+
+          need -= wrote
+
+          return data.bytesize if need == 0
+
+          data = data[wrote..-1]
+        end
+      end
+
+      alias_method :syswrite, :write
+
+      def flush
+        @socket.flush
+      end
+
+      def close
+        @socket.close
+      end
+
+      def peeraddr
+        @socket.peeraddr
+      end
+    end
+
+    class Context
+      attr_accessor :verify_mode
+
+      if defined?(JRUBY_VERSION)
+        # jruby-specific Context properties: java uses a keystore and password pair rather than a cert/key pair
+        attr_reader :keystore
+        attr_accessor :keystore_pass
+        attr_accessor :enable_SSLv3
+
+        def initialize
+          @enable_SSLv3 = false
+        end
+
+        def keystore=(keystore)
+          raise ArgumentError, "No such keystore file '#{keystore}'" unless File.exist? keystore
+          @keystore = keystore
+        end
+      else
+        # non-jruby Context properties
+        attr_reader :key
+        attr_reader :cert
+
+        def key=(key)
+          raise ArgumentError, "No such key file '#{key}'" unless File.exist? key
+          @key = key
+        end
+
+        def cert=(cert)
+          raise ArgumentError, "No such cert file '#{cert}'" unless File.exist? cert
+          @cert = cert
+        end
+      end
+    end
+
+    VERIFY_NONE = 0
+    VERIFY_PEER = 1
+
+    class Server
+      def initialize(socket, ctx)
+        @socket = socket
+        @ctx = ctx
+      end
+
+      def to_io
+        @socket
+      end
+
+      def accept
+        io = @socket.accept
+        engine = Engine.server @ctx
+
+        Socket.new io, engine
+      end
+
+      def accept_nonblock
+        io = @socket.accept_nonblock
+        engine = Engine.server @ctx
+
+        Socket.new io, engine
+      end
+
+      def close
+        @socket.close
+      end
+    end
+  end
+end

data/lib/puma/null_io.rb

@@ -0,0 +1,34 @@
+module Puma
+
+  # Provides an IO-like object that always appears to contain no data.
+  # Used as the value for rack.input when the request has no body.
+  #
+  class NullIO
+    # Always returns nil
+    #
+    def gets
+      nil
+    end
+
+    # Never yields
+    #
+    def each
+    end
+
+    # Mimics IO#read with no data
+    #
+    def read(count=nil,buffer=nil)
+      (count && count > 0) ? nil : ""
+    end
+
+    # Does nothing
+    #
+    def rewind
+    end
+
+    # Does nothing
+    #
+    def close
+    end
+  end
+end

data/lib/puma/rack_default.rb

@@ -0,0 +1,7 @@
+require 'rack/handler/puma'
+
+module Rack::Handler
+  def self.default(options = {})
+    Rack::Handler::Puma
+  end
+end

data/lib/puma/rack_patch.rb

@@ -0,0 +1,45 @@
+require 'rack/commonlogger'
+
+module Rack
+  # Patch CommonLogger to use after_reply.
+  #
+  # Simply request this file and CommonLogger will be a bit more 
+  # efficient.
+  class CommonLogger
+    remove_method :call
+
+    def call(env)
+      began_at = Time.now
+      status, header, body = @app.call(env)
+      header = Utils::HeaderHash.new(header)
+
+      # If we've been hijacked, then output a special line
+      if env['rack.hijack_io']
+        log_hijacking(env, 'HIJACK', header, began_at)
+      elsif ary = env['rack.after_reply']
+        ary << lambda { log(env, status, header, began_at) }
+      else
+        body = BodyProxy.new(body) { log(env, status, header, began_at) }
+      end
+
+      [status, header, body]
+    end
+
+    HIJACK_FORMAT = %{%s - %s [%s] "%s %s%s %s" HIJACKED -1 %0.4f\n}
+
+    def log_hijacking(env, status, header, began_at)
+      now = Time.now
+
+      logger = @logger || env['rack.errors']
+      logger.write HIJACK_FORMAT % [
+        env['HTTP_X_FORWARDED_FOR'] || env["REMOTE_ADDR"] || "-",
+        env["REMOTE_USER"] || "-",
+        now.strftime("%d/%b/%Y %H:%M:%S"),
+        env["REQUEST_METHOD"],
+        env["PATH_INFO"],
+        env["QUERY_STRING"].empty? ? "" : "?"+env["QUERY_STRING"],
+        env["HTTP_VERSION"],
+        now - began_at ]
+    end
+  end
+end

data/lib/puma/reactor.rb

@@ -0,0 +1,183 @@
+require 'puma/util'
+
+module Puma
+  class Reactor
+    DefaultSleepFor = 5
+
+    def initialize(server, app_pool)
+      @server = server
+      @events = server.events
+      @app_pool = app_pool
+
+      @mutex = Mutex.new
+      @ready, @trigger = Puma::Util.pipe
+      @input = []
+      @sleep_for = DefaultSleepFor
+      @timeouts = []
+
+      @sockets = [@ready]
+    end
+
+    private
+
+    def run_internal
+      sockets = @sockets
+
+      while true
+        begin
+          ready = IO.select sockets, nil, nil, @sleep_for
+        rescue IOError => e
+          if sockets.any? { |socket| socket.closed? }
+            STDERR.puts "Error in select: #{e.message} (#{e.class})"
+            STDERR.puts e.backtrace
+            sockets = sockets.reject { |socket| socket.closed? }
+            retry
+          else
+            raise
+          end
+        end
+
+        if ready and reads = ready[0]
+          reads.each do |c|
+            if c == @ready
+              @mutex.synchronize do
+                case @ready.read(1)
+                when "*"
+                  sockets += @input
+                  @input.clear
+                when "c"
+                  sockets.delete_if do |s|
+                    if s == @ready
+                      false
+                    else
+                      s.close
+                      true
+                    end
+                  end
+                when "!"
+                  return
+                end
+              end
+            else
+              # We have to be sure to remove it from the timeout
+              # list or we'll accidentally close the socket when
+              # it's in use!
+              if c.timeout_at
+                @mutex.synchronize do
+                  @timeouts.delete c
+                end
+              end
+
+              begin
+                if c.try_to_finish
+                  @app_pool << c
+                  sockets.delete c
+                end
+
+              # The client doesn't know HTTP well
+              rescue HttpParserError => e
+                c.write_400
+                c.close
+
+                sockets.delete c
+
+                @events.parse_error @server, c.env, e
+              rescue StandardError => e
+                c.write_500
+                c.close
+
+                sockets.delete c
+              end
+            end
+          end
+        end
+
+        unless @timeouts.empty?
+          @mutex.synchronize do
+            now = Time.now
+
+            while @timeouts.first.timeout_at < now
+              c = @timeouts.shift
+              c.write_408 if c.in_data_phase
+              c.close
+              sockets.delete c
+
+              break if @timeouts.empty?
+            end
+
+            calculate_sleep
+          end
+        end
+      end
+    end
+
+    public
+
+    def run
+      run_internal
+    ensure
+      @trigger.close
+      @ready.close
+    end
+
+    def run_in_thread
+      @thread = Thread.new do
+        begin
+          run_internal
+        rescue StandardError => e
+          STDERR.puts "Error in reactor loop escaped: #{e.message} (#{e.class})"
+          STDERR.puts e.backtrace
+          retry
+        ensure
+          @trigger.close
+          @ready.close
+        end
+      end
+    end
+
+    def calculate_sleep
+      if @timeouts.empty?
+        @sleep_for = DefaultSleepFor
+      else
+        diff = @timeouts.first.timeout_at.to_f - Time.now.to_f
+
+        if diff < 0.0
+          @sleep_for = 0
+        else
+          @sleep_for = diff
+        end
+      end
+    end
+
+    def add(c)
+      @mutex.synchronize do
+        @input << c
+        @trigger << "*"
+
+        if c.timeout_at
+          @timeouts << c
+          @timeouts.sort! { |a,b| a.timeout_at <=> b.timeout_at }
+
+          calculate_sleep
+        end
+      end
+    end
+
+    # Close all watched sockets and clear them from being watched
+    def clear!
+      begin
+        @trigger << "c"
+      rescue IOError
+      end
+    end
+
+    def shutdown
+      begin
+        @trigger << "!"
+      rescue IOError
+      end
+
+      @thread.join
+    end
+  end
+end