puma 2.7.0 → 3.1.1

data/lib/puma/single.rb

@@ -27,7 +27,12 @@ module Puma
     end
 
     def jruby_daemon?
-      daemon? and @cli.jruby?
+      daemon? and Puma.jruby?
+    end
+
+    def jruby_daemon_start
+      require 'puma/jruby_restart'
+      JRubyRestart.daemon_start(@restart_dir, @launcher.restart_args)
     end
 
     def run
@@ -62,35 +67,35 @@ module Puma
           end
 
           Signal.trap "SIGCHLD" do
-            log "! Error starting new process as daemon, exitting"
+            log "! Error starting new process as daemon, exiting"
             exit 1
           end
 
-          pid = @cli.jruby_daemon_start
+          pid = jruby_daemon_start
           sleep
         end
       else
-        load_and_bind
-
         if daemon?
           log "* Daemonizing..."
           Process.daemon(true)
+          redirect_io
         end
+
+        load_and_bind
       end
 
-      @cli.write_state
+      @launcher.write_state
 
       start_control
 
       @server = server = start_server
 
-      unless @options[:daemon]
+      unless daemon?
         log "Use Ctrl-C to stop"
+        redirect_io
       end
 
-      redirect_io
-
-      @cli.events.fire_on_booted!
+      @launcher.events.fire_on_booted!
 
       begin
         server.run.join

data/lib/puma/state_file.rb

@@ -0,0 +1,29 @@
+require 'yaml'
+
+module Puma
+  class StateFile
+    def initialize
+      @options = {}
+    end
+
+    def save(path)
+      File.write path, YAML.dump(@options)
+    end
+
+    def load(path)
+      @options = YAML.load File.read(path)
+    end
+
+    FIELDS = %w!control_url control_auth_token pid!
+
+    FIELDS.each do |f|
+      define_method f do
+        @options[f]
+      end
+
+      define_method "#{f}=" do |v|
+        @options[f] = v
+      end
+    end
+  end
+end

data/lib/puma/thread_pool.rb

@@ -12,7 +12,8 @@ module Puma
     # thread.
     #
     def initialize(min, max, *extra, &block)
-      @cond = ConditionVariable.new
+      @not_empty = ConditionVariable.new
+      @not_full = ConditionVariable.new
       @mutex = Mutex.new
 
       @todo = []
@@ -32,13 +33,23 @@ module Puma
       @workers = []
 
       @auto_trim = nil
+      @reaper = nil
 
       @mutex.synchronize do
         @min.times { spawn_thread }
       end
+
+      @clean_thread_locals = false
     end
 
     attr_reader :spawned, :trim_requested
+    attr_accessor :clean_thread_locals
+
+    def self.clean_thread_locals
+      Thread.current.keys.each do |key|
+        Thread.current[key] = nil unless key == :__recursive_key__
+      end
+    end
 
     # How many objects have yet to be processed by the pool?
     #
@@ -57,7 +68,8 @@ module Puma
         todo  = @todo
         block = @block
         mutex = @mutex
-        cond  = @cond
+        not_empty = @not_empty
+        not_full = @not_full
 
         extra = @extra.map { |i| i.new }
 
@@ -71,6 +83,7 @@ module Puma
               if @trim_requested > 0
                 @trim_requested -= 1
                 continue = false
+                not_full.signal
                 break
               end
 
@@ -80,16 +93,24 @@ module Puma
               end
 
               @waiting += 1
-              cond.wait mutex
+              not_full.signal
+              not_empty.wait mutex
               @waiting -= 1
             end
 
-            work = todo.pop if continue
+            work = todo.shift if continue
           end
 
           break unless continue
 
-          block.call(work, *extra)
+          if @clean_thread_locals
+            ThreadPool.clean_thread_locals
+          end
+
+          begin
+            block.call(work, *extra)
+          rescue Exception
+          end
         end
 
         mutex.synchronize do
@@ -114,11 +135,19 @@ module Puma
 
         @todo << work
 
-        if @waiting == 0 and @spawned < @max
+        if @waiting < @todo.size and @spawned < @max
           spawn_thread
         end
 
-        @cond.signal
+        @not_empty.signal
+      end
+    end
+
+    def wait_until_not_full
+      @mutex.synchronize do
+        until @todo.size - @waiting < @max - @spawned or @shutdown
+          @not_full.wait @mutex
+        end
       end
     end
 
@@ -130,11 +159,26 @@ module Puma
       @mutex.synchronize do
         if (force or @waiting > 0) and @spawned - @trim_requested > @min
           @trim_requested += 1
-          @cond.signal
+          @not_empty.signal
         end
       end
     end
 
+    # If there are dead threads in the pool make them go away while decreasing
+    # spawned counter so that new healthy threads could be created again.
+    def reap
+      @mutex.synchronize do
+        dead_workers = @workers.reject(&:alive?)
+
+        dead_workers.each do |worker|
+          worker.kill
+          @spawned -= 1
+        end
+
+        @workers -= dead_workers
+      end
+    end
+
     class AutoTrim
       def initialize(pool, timeout)
         @pool = pool
@@ -164,19 +208,50 @@ module Puma
       @auto_trim.start!
     end
 
+    class Reaper
+      def initialize(pool, timeout)
+        @pool = pool
+        @timeout = timeout
+        @running = false
+      end
+
+      def start!
+        @running = true
+
+        @thread = Thread.new do
+          while @running
+            @pool.reap
+            sleep @timeout
+          end
+        end
+      end
+
+      def stop
+        @running = false
+        @thread.wakeup
+      end
+    end
+
+    def auto_reap!(timeout=5)
+      @reaper = Reaper.new(self, timeout)
+      @reaper.start!
+    end
+
     # Tell all threads in the pool to exit and wait for them to finish.
     #
     def shutdown
-      @mutex.synchronize do
+      threads = @mutex.synchronize do
         @shutdown = true
-        @cond.broadcast
+        @not_empty.broadcast
+        @not_full.broadcast
 
         @auto_trim.stop if @auto_trim
+        @reaper.stop if @reaper
+        # dup workers so that we join them all safely
+        @workers.dup
       end
 
-      # Use this instead of #each so that we don't stop in the middle
-      # of each and see a mutated object mid #each
-      @workers.first.join until @workers.empty?
+      threads.each(&:join)
 
       @spawned = 0
       @workers = []

data/lib/puma/util.rb

@@ -1,3 +1,15 @@
+major, minor, patch = RUBY_VERSION.split('.').map { |v| v.to_i }
+
+if major == 1 && minor < 9
+  require 'puma/rack/backports/uri/common_18'
+elsif major == 1 && minor == 9 && patch == 2 && RUBY_PATCHLEVEL <= 328 && RUBY_ENGINE != 'jruby'
+  require 'puma/rack/backports/uri/common_192'
+elsif major == 1 && minor == 9 && patch == 3 && RUBY_PATCHLEVEL < 125
+  require 'puma/rack/backports/uri/common_193'
+else
+  require 'uri/common'
+end
+
 module Puma
   module Util
     module_function
@@ -5,5 +17,116 @@ module Puma
     def pipe
       IO.pipe
     end
+
+    # Unescapes a URI escaped string with +encoding+. +encoding+ will be the
+    # target encoding of the string returned, and it defaults to UTF-8
+    if defined?(::Encoding)
+      def unescape(s, encoding = Encoding::UTF_8)
+        URI.decode_www_form_component(s, encoding)
+      end
+    else
+      def unescape(s, encoding = nil)
+        URI.decode_www_form_component(s, encoding)
+      end
+    end
+    module_function :unescape
+
+    DEFAULT_SEP = /[&;] */n
+
+    # Stolen from Mongrel, with some small modifications:
+    # Parses a query string by breaking it up at the '&'
+    # and ';' characters.  You can also use this to parse
+    # cookies by changing the characters used in the second
+    # parameter (which defaults to '&;').
+    def parse_query(qs, d = nil, &unescaper)
+      unescaper ||= method(:unescape)
+
+      params = {}
+
+      (qs || '').split(d ? /[#{d}] */n : DEFAULT_SEP).each do |p|
+        next if p.empty?
+        k, v = p.split('=', 2).map(&unescaper)
+
+        if cur = params[k]
+          if cur.class == Array
+            params[k] << v
+          else
+            params[k] = [cur, v]
+          end
+        else
+          params[k] = v
+        end
+      end
+
+      return params
+    end
+
+    # A case-insensitive Hash that preserves the original case of a
+    # header when set.
+    class HeaderHash < Hash
+      def self.new(hash={})
+        HeaderHash === hash ? hash : super(hash)
+      end
+
+      def initialize(hash={})
+        super()
+        @names = {}
+        hash.each { |k, v| self[k] = v }
+      end
+
+      def each
+        super do |k, v|
+          yield(k, v.respond_to?(:to_ary) ? v.to_ary.join("\n") : v)
+        end
+      end
+
+      def to_hash
+        hash = {}
+        each { |k,v| hash[k] = v }
+        hash
+      end
+
+      def [](k)
+        super(k) || super(@names[k.downcase])
+      end
+
+      def []=(k, v)
+        canonical = k.downcase
+        delete k if @names[canonical] && @names[canonical] != k # .delete is expensive, don't invoke it unless necessary
+        @names[k] = @names[canonical] = k
+        super k, v
+      end
+
+      def delete(k)
+        canonical = k.downcase
+        result = super @names.delete(canonical)
+        @names.delete_if { |name,| name.downcase == canonical }
+        result
+      end
+
+      def include?(k)
+        @names.include?(k) || @names.include?(k.downcase)
+      end
+
+      alias_method :has_key?, :include?
+      alias_method :member?, :include?
+      alias_method :key?, :include?
+
+      def merge!(other)
+        other.each { |k, v| self[k] = v }
+        self
+      end
+
+      def merge(other)
+        hash = dup
+        hash.merge! other
+      end
+
+      def replace(other)
+        clear
+        other.each { |k, v| self[k] = v }
+        self
+      end
+    end
   end
 end

data/lib/rack/handler/puma.rb

@@ -5,44 +5,55 @@ module Rack
   module Handler
     module Puma
       DEFAULT_OPTIONS = {
-        :Host => '0.0.0.0',
-        :Port => 8080,
-        :Threads => '0:16',
-        :Verbose => false
+        :Verbose => false,
+        :Silent  => false
       }
 
       def self.run(app, options = {})
         options  = DEFAULT_OPTIONS.merge(options)
 
-        if options[:Verbose]
-          app = Rack::CommonLogger.new(app, STDOUT)
-        end
+        conf = ::Puma::Configuration.new do |c|
+          c.quiet
 
-        if options[:environment]
-          ENV['RACK_ENV'] = options[:environment].to_s
-        end
+          if options.delete(:Verbose)
+            app = Rack::CommonLogger.new(app, STDOUT)
+          end
+
+          if options[:environment]
+            c.environment options[:environment]
+          end
 
-        server   = ::Puma::Server.new(app)
-        min, max = options[:Threads].split(':', 2)
+          if options[:Threads]
+            min, max = options.delete(:Threads).split(':', 2)
+            c.threads min, max
+          end
 
-        puts "Puma #{::Puma::Const::PUMA_VERSION} starting..."
-        puts "* Min threads: #{min}, max threads: #{max}"
-        puts "* Environment: #{ENV['RACK_ENV']}"
-        puts "* Listening on tcp://#{options[:Host]}:#{options[:Port]}"
+          host = options[:Host]
 
-        server.add_tcp_listener options[:Host], options[:Port]
-        server.min_threads = min
-        server.max_threads = max
-        yield server if block_given?
+          if host && (host[0,1] == '.' || host[0,1] == '/')
+            c.bind "unix://#{host}"
+          else
+            host ||= ::Puma::Configuration::DefaultTCPHost
+            port = options[:Port] || ::Puma::Configuration::DefaultTCPPort
+
+            c.port port, host
+          end
+
+          c.app app
+        end
 
+        events = options.delete(:Silent) ? ::Puma::Events.strings : ::Puma::Events.stdio
+
+        launcher = ::Puma::Launcher.new(conf, :events => events)
+
+        yield launcher if block_given?
         begin
-          server.run.join
+          launcher.run
         rescue Interrupt
           puts "* Gracefully stopping, waiting for requests to finish"
-          server.stop(true)
+          launcher.stop
           puts "* Goodbye!"
         end
-
       end
 
       def self.valid_options
@@ -50,7 +61,7 @@ module Rack
           "Host=HOST"       => "Hostname to listen on (default: localhost)",
           "Port=PORT"       => "Port to listen on (default: 8080)",
           "Threads=MIN:MAX" => "min:max threads to use (default 0:16)",
-          "Quiet"           => "Don't report each request"
+          "Verbose"         => "Don't report each request (default: false)"
         }
       end
     end
@@ -59,8 +70,3 @@ module Rack
   end
 end
 
-# This is to trick newrelic into enabling the agent automatically.
-module Mongrel
-  class HttpServer
-  end
-end