puma 3.0.0.rc1 → 5.0.0.beta1

data/lib/puma/minissl.rb

@@ -1,3 +1,10 @@
+# frozen_string_literal: true
+
+begin
+  require 'io/wait'
+rescue LoadError
+end
+
 module Puma
   module MiniSSL
     class Socket
@@ -11,6 +18,10 @@ module Puma
         @socket
       end
 
+      def closed?
+        @socket.closed?
+      end
+
       def readpartial(size)
         while true
           output = @engine.read
@@ -36,12 +47,28 @@ module Puma
         output
       end
 
-      def read_nonblock(size)
+      def read_nonblock(size, *_)
+        # *_ is to deal with keyword args that were added
+        # at some point (and being used in the wild)
         while true
           output = engine_read_all
           return output if output
 
-          data = @socket.read_nonblock(size)
+          data = @socket.read_nonblock(size, exception: false)
+          if data == :wait_readable || data == :wait_writable
+            # It would make more sense to let @socket.read_nonblock raise
+            # EAGAIN if necessary but it seems like it'll misbehave on Windows.
+            # I don't have a Windows machine to debug this so I can't explain
+            # exactly whats happening in that OS. Please let me know if you
+            # find out!
+            #
+            # In the meantime, we can emulate the correct behavior by
+            # capturing :wait_readable & :wait_writable and raising EAGAIN
+            # ourselves.
+            raise IO::EAGAINWaitReadable
+          elsif data.nil?
+            return nil
+          end
 
           @engine.inject(data)
           output = engine_read_all
@@ -55,6 +82,8 @@ module Puma
       end
 
       def write(data)
+        return 0 if data.empty?
+
         need = data.bytesize
 
         while true
@@ -75,13 +104,53 @@ module Puma
       end
 
       alias_method :syswrite, :write
+      alias_method :<<, :write
+
+      # This is a temporary fix to deal with websockets code using
+      # write_nonblock. The problem with implementing it properly
+      # is that it means we'd have to have the ability to rewind
+      # an engine because after we write+extract, the socket
+      # write_nonblock call might raise an exception and later
+      # code would pass the same data in, but the engine would think
+      # it had already written the data in. So for the time being
+      # (and since write blocking is quite rare), go ahead and actually
+      # block in write_nonblock.
+      def write_nonblock(data, *_)
+        write data
+      end
 
       def flush
         @socket.flush
       end
 
+      def read_and_drop(timeout = 1)
+        return :timeout unless IO.select([@socket], nil, nil, timeout)
+        case @socket.read_nonblock(1024, exception: false)
+        when nil
+          :eof
+        when :wait_readable
+          :eagain
+        else
+          :drop
+        end
+      end
+
+      def should_drop_bytes?
+        @engine.init? || !@engine.shutdown
+      end
+
       def close
-        @socket.close
+        begin
+          # Read any drop any partially initialized sockets and any received bytes during shutdown.
+          # Don't let this socket hold this loop forever.
+          # If it can't send more packets within 1s, then give up.
+          return if [:timeout, :eof].include?(read_and_drop(1)) while should_drop_bytes?
+        rescue IOError, SystemCallError
+          Thread.current.purge_interrupt_queue if Thread.current.respond_to? :purge_interrupt_queue
+          # nothing
+        ensure
+          @socket.close
+        end
       end
 
       def peeraddr
@@ -108,21 +177,34 @@ module Puma
 
     class Context
       attr_accessor :verify_mode
+      attr_reader :no_tlsv1, :no_tlsv1_1
+
+      def initialize
+        @no_tlsv1   = false
+        @no_tlsv1_1 = false
+      end
 
       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 :ssl_cipher_list
 
         def keystore=(keystore)
           raise ArgumentError, "No such keystore file '#{keystore}'" unless File.exist? keystore
           @keystore = keystore
         end
+
+        def check
+          raise "Keystore not configured" unless @keystore
+        end
+
       else
         # non-jruby Context properties
         attr_reader :key
         attr_reader :cert
         attr_reader :ca
+        attr_accessor :ssl_cipher_filter
 
         def key=(key)
           raise ArgumentError, "No such key file '#{key}'" unless File.exist? key
@@ -138,7 +220,25 @@ module Puma
           raise ArgumentError, "No such ca file '#{ca}'" unless File.exist? ca
           @ca = ca
         end
+
+        def check
+          raise "Key not configured" unless @key
+          raise "Cert not configured" unless @cert
+        end
       end
+
+      # disables TLSv1
+      def no_tlsv1=(tlsv1)
+        raise ArgumentError, "Invalid value of no_tlsv1" unless ['true', 'false', true, false].include?(tlsv1)
+        @no_tlsv1 = tlsv1
+      end
+
+      # disables TLSv1 and TLSv1.1.  Overrides `#no_tlsv1=`
+      def no_tlsv1_1=(tlsv1_1)
+        raise ArgumentError, "Invalid value of no_tlsv1" unless ['true', 'false', true, false].include?(tlsv1_1)
+        @no_tlsv1_1 = tlsv1_1
+      end
+
     end
 
     VERIFY_NONE = 0
@@ -156,6 +256,7 @@ module Puma
       end
 
       def accept
+        @ctx.check
         io = @socket.accept
         engine = Engine.server @ctx
 
@@ -163,14 +264,19 @@ module Puma
       end
 
       def accept_nonblock
+        @ctx.check
         io = @socket.accept_nonblock
         engine = Engine.server @ctx
 
         Socket.new io, engine
       end
 
+      def addr
+        @socket.addr
+      end
+
       def close
-        @socket.close
+        @socket.close unless @socket.closed?       # closed? call is for Windows
       end
     end
   end

data/lib/puma/minissl/context_builder.rb

@@ -0,0 +1,76 @@
+module Puma
+  module MiniSSL
+    class ContextBuilder
+      def initialize(params, events)
+        require 'puma/minissl'
+        MiniSSL.check
+
+        @params = params
+        @events = events
+      end
+
+      def context
+        ctx = MiniSSL::Context.new
+
+        if defined?(JRUBY_VERSION)
+          unless params['keystore']
+            events.error "Please specify the Java keystore via 'keystore='"
+          end
+
+          ctx.keystore = params['keystore']
+
+          unless params['keystore-pass']
+            events.error "Please specify the Java keystore password  via 'keystore-pass='"
+          end
+
+          ctx.keystore_pass = params['keystore-pass']
+          ctx.ssl_cipher_list = params['ssl_cipher_list'] if params['ssl_cipher_list']
+        else
+          unless params['key']
+            events.error "Please specify the SSL key via 'key='"
+          end
+
+          ctx.key = params['key']
+
+          unless params['cert']
+            events.error "Please specify the SSL cert via 'cert='"
+          end
+
+          ctx.cert = params['cert']
+
+          if ['peer', 'force_peer'].include?(params['verify_mode'])
+            unless params['ca']
+              events.error "Please specify the SSL ca via 'ca='"
+            end
+          end
+
+          ctx.ca = params['ca'] if params['ca']
+          ctx.ssl_cipher_filter = params['ssl_cipher_filter'] if params['ssl_cipher_filter']
+        end
+
+        ctx.no_tlsv1 = true if params['no_tlsv1'] == 'true'
+        ctx.no_tlsv1_1 = true if params['no_tlsv1_1'] == 'true'
+
+        if params['verify_mode']
+          ctx.verify_mode = case params['verify_mode']
+                            when "peer"
+                              MiniSSL::VERIFY_PEER
+                            when "force_peer"
+                              MiniSSL::VERIFY_PEER | MiniSSL::VERIFY_FAIL_IF_NO_PEER_CERT
+                            when "none"
+                              MiniSSL::VERIFY_NONE
+                            else
+                              events.error "Please specify a valid verify_mode="
+                              MiniSSL::VERIFY_NONE
+                            end
+        end
+
+        ctx
+      end
+
+      private
+
+      attr_reader :params, :events
+    end
+  end
+end

data/lib/puma/null_io.rb

@@ -1,42 +1,37 @@
-module Puma
+# frozen_string_literal: true
 
+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
+    # Mimics IO#read with no data.
     #
-    def read(count=nil,buffer=nil)
-      (count && count > 0) ? nil : ""
+    def read(count = nil, _buffer = nil)
+      count && count > 0 ? nil : ""
     end
 
-    # Does nothing
-    #
     def rewind
     end
 
-    # Does nothing
-    #
     def close
     end
 
-    # Always zero
-    #
     def size
       0
     end
 
+    def eof?
+      true
+    end
+
     def sync=(v)
     end
 

data/lib/puma/plugin.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Puma
   class UnknownPlugin < RuntimeError; end
 
@@ -8,7 +10,7 @@ module Puma
 
     def create(name)
       if cls = Plugins.find(name)
-        plugin = cls.new(Plugin)
+        plugin = cls.new
         @instances << plugin
         return plugin
       end
@@ -28,6 +30,7 @@ module Puma
   class PluginRegistry
     def initialize
       @plugins = {}
+      @background = []
     end
 
     def register(name, cls)
@@ -53,13 +56,39 @@ module Puma
 
       raise UnknownPlugin, "file failed to register a plugin"
     end
+
+    def add_background(blk)
+      @background << blk
+    end
+
+    def fire_background
+      @background.each_with_index do |b, i|
+        Thread.new do
+          Puma.set_thread_name "plugin background #{i}"
+          b.call
+        end
+      end
+    end
   end
 
   Plugins = PluginRegistry.new
 
   class Plugin
+    # Matches
+    #  "C:/Ruby22/lib/ruby/gems/2.2.0/gems/puma-3.0.1/lib/puma/plugin/tmp_restart.rb:3:in `<top (required)>'"
+    #  AS
+    #  C:/Ruby22/lib/ruby/gems/2.2.0/gems/puma-3.0.1/lib/puma/plugin/tmp_restart.rb
+    CALLER_FILE = /
+      \A       # start of string
+      .+       # file path (one or more characters)
+      (?=      # stop previous match when
+        :\d+     # a colon is followed by one or more digits
+        :in      # followed by a colon followed by in
+      )
+    /x
+
     def self.extract_name(ary)
-      path = ary.first.split(":").first
+      path = ary.first[CALLER_FILE]
 
       m = %r!puma/plugin/([^/]*)\.rb$!.match(path)
       return m[1]
@@ -75,17 +104,8 @@ module Puma
       Plugins.register name, cls
     end
 
-    def initialize(loader)
-      @loader = loader
-    end
-
     def in_background(&blk)
-      Thread.new(&blk)
-    end
-
-    def workers_supported?
-      return false if Puma.jruby? || Puma.windows?
-      true
+      Plugins.add_background blk
     end
   end
 end

data/lib/puma/plugin/tmp_restart.rb

@@ -1,23 +1,36 @@
+# frozen_string_literal: true
+
 require 'puma/plugin'
 
 Puma::Plugin.create do
   def start(launcher)
     path = File.join("tmp", "restart.txt")
 
-    File.write path, ""
+    orig = nil
 
-    orig = File.stat(path).mtime
+    # If we can't write to the path, then just don't bother with this plugin
+    begin
+      File.write(path, "") unless File.exist?(path)
+      orig = File.stat(path).mtime
+    rescue SystemCallError
+      return
+    end
 
     in_background do
       while true
         sleep 2
 
-        if File.stat(path).mtime > orig
-          launcher.restart
-          break
+        begin
+          mtime = File.stat(path).mtime
+        rescue SystemCallError
+          # If the file has disappeared, assume that means don't restart
+        else
+          if mtime > orig
+            launcher.restart
+            break
+          end
         end
       end
     end
   end
 end
-