puma 3.12.1 → 5.3.2

data/lib/puma/single.rb

@@ -13,12 +13,11 @@ module Puma
   # gets created via the `start_server` method from the `Puma::Runner` class
   # that this inherits from.
   class Single < Runner
+    # @!attribute [r] stats
     def stats
-      b = @server.backlog || 0
-      r = @server.running || 0
-      t = @server.pool_capacity || 0
-      m = @server.max_threads || 0
-      %Q!{ "backlog": #{b}, "running": #{r}, "pool_capacity": #{t}, "max_threads": #{m} }!
+      {
+        started_at: @started_at.utc.iso8601
+      }.merge(@server.stats)
     end
 
     def restart
@@ -26,7 +25,7 @@ module Puma
     end
 
     def stop
-      @server.stop false
+      @server.stop(false) if @server
     end
 
     def halt
@@ -36,67 +35,13 @@ module Puma
     def stop_blocked
       log "- Gracefully stopping, waiting for requests to finish"
       @control.stop(true) if @control
-      @server.stop(true)
-    end
-
-    def jruby_daemon?
-      daemon? and Puma.jruby?
-    end
-
-    def jruby_daemon_start
-      require 'puma/jruby_restart'
-      JRubyRestart.daemon_start(@restart_dir, @launcher.restart_args)
+      @server.stop(true) if @server
     end
 
     def run
-      already_daemon = false
-
-      if jruby_daemon?
-        require 'puma/jruby_restart'
-
-        if JRubyRestart.daemon?
-          # load and bind before redirecting IO so errors show up on stdout/stderr
-          load_and_bind
-          redirect_io
-        end
-
-        already_daemon = JRubyRestart.daemon_init
-      end
-
       output_header "single"
 
-      if jruby_daemon?
-        if already_daemon
-          JRubyRestart.perm_daemonize
-        else
-          pid = nil
-
-          Signal.trap "SIGUSR2" do
-            log "* Started new process #{pid} as daemon..."
-
-            # Must use exit! so we don't unwind and run the ensures
-            # that will be run by the new child (such as deleting the
-            # pidfile)
-            exit!(true)
-          end
-
-          Signal.trap "SIGCHLD" do
-            log "! Error starting new process as daemon, exiting"
-            exit 1
-          end
-
-          jruby_daemon_start
-          sleep
-        end
-      else
-        if daemon?
-          log "* Daemonizing..."
-          Process.daemon(true)
-          redirect_io
-        end
-
-        load_and_bind
-      end
+      load_and_bind
 
       Plugins.fire_background
 
@@ -105,16 +50,15 @@ module Puma
       start_control
 
       @server = server = start_server
+      server_thread = server.run
 
-      unless daemon?
-        log "Use Ctrl-C to stop"
-        redirect_io
-      end
+      log "Use Ctrl-C to stop"
+      redirect_io
 
       @launcher.events.fire_on_booted!
 
       begin
-        server.run.join
+        server_thread.join
       rescue Interrupt
         # Swallow it
       end

data/lib/puma/state_file.rb

@@ -8,15 +8,20 @@ module Puma
       @options = {}
     end
 
-    def save(path)
-      File.write path, YAML.dump(@options)
+    def save(path, permission = nil)
+      contents =YAML.dump @options
+      if permission
+        File.write path, contents, mode: 'wb:UTF-8'
+      else
+        File.write path, contents, mode: 'wb:UTF-8', perm: permission
+      end
     end
 
     def load(path)
       @options = YAML.load File.read(path)
     end
 
-    FIELDS = %w!control_url control_auth_token pid!
+    FIELDS = %w!control_url control_auth_token pid running_from!
 
     FIELDS.each do |f|
       define_method f do

data/lib/puma/systemd.rb

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+require 'sd_notify'
+
+module Puma
+  class Systemd
+    def initialize(events)
+      @events = events
+    end
+
+    def hook_events
+      @events.on_booted { SdNotify.ready }
+      @events.on_stopped { SdNotify.stopping }
+      @events.on_restart { SdNotify.reloading }
+    end
+
+    def start_watchdog
+      return unless SdNotify.watchdog?
+
+      ping_f = watchdog_sleep_time
+
+      log "Pinging systemd watchdog every #{ping_f.round(1)} sec"
+      Thread.new do
+        loop do
+          sleep ping_f
+          SdNotify.watchdog
+        end
+      end
+    end
+
+    private
+
+    def watchdog_sleep_time
+      usec = Integer(ENV["WATCHDOG_USEC"])
+
+      sec_f = usec / 1_000_000.0
+      # "It is recommended that a daemon sends a keep-alive notification message
+      # to the service manager every half of the time returned here."
+      sec_f / 2
+    end
+
+    def log(str)
+      @events.log str
+    end
+  end
+end

data/lib/puma/thread_pool.rb

@@ -13,7 +13,7 @@ module Puma
   # a thread pool via the `Puma::ThreadPool#<<` operator where it is stored in a `@todo` array.
   #
   # Each thread in the pool has an internal loop where it pulls a request from the `@todo` array
-  # and proceses it.
+  # and processes it.
   class ThreadPool
     class ForceShutdown < RuntimeError
     end
@@ -47,6 +47,7 @@ module Puma
       @shutdown = false
 
       @trim_requested = 0
+      @out_of_band_pending = false
 
       @workers = []
 
@@ -54,14 +55,20 @@ module Puma
       @reaper = nil
 
       @mutex.synchronize do
-        @min.times { spawn_thread }
+        @min.times do
+          spawn_thread
+          @not_full.wait(@mutex)
+        end
       end
 
       @clean_thread_locals = false
+      @force_shutdown = false
+      @shutdown_mutex = Mutex.new
     end
 
     attr_reader :spawned, :trim_requested, :waiting
     attr_accessor :clean_thread_locals
+    attr_accessor :out_of_band_hook # @version 5.0.0
 
     def self.clean_thread_locals
       Thread.current.keys.each do |key| # rubocop: disable Performance/HashEachMethods
@@ -72,13 +79,20 @@ module Puma
     # How many objects have yet to be processed by the pool?
     #
     def backlog
-      @mutex.synchronize { @todo.size }
+      with_mutex { @todo.size }
     end
 
+    # @!attribute [r] pool_capacity
     def pool_capacity
       waiting + (@max - spawned)
     end
 
+    # @!attribute [r] busy_threads
+    # @version 5.0.0
+    def busy_threads
+      with_mutex { @spawned - @waiting + @todo.size }
+    end
+
     # :nodoc:
     #
     # Must be called with @mutex held!
@@ -87,8 +101,7 @@ module Puma
       @spawned += 1
 
       th = Thread.new(@spawned) do |spawned|
-        # Thread name is new in Ruby 2.3
-        Thread.current.name = 'puma %03i' % spawned if Thread.current.respond_to?(:name=)
+        Puma.set_thread_name 'threadpool %03i' % spawned
         todo  = @todo
         block = @block
         mutex = @mutex
@@ -100,48 +113,40 @@ module Puma
         while true
           work = nil
 
-          continue = true
-
           mutex.synchronize do
             while todo.empty?
               if @trim_requested > 0
                 @trim_requested -= 1
-                continue = false
-                not_full.signal
-                break
-              end
-
-              if @shutdown
-                continue = false
-                break
+                @spawned -= 1
+                @workers.delete th
+                Thread.exit
               end
 
               @waiting += 1
+              if @out_of_band_pending && trigger_out_of_band_hook
+                @out_of_band_pending = false
+              end
               not_full.signal
-              not_empty.wait mutex
-              @waiting -= 1
+              begin
+                not_empty.wait mutex
+              ensure
+                @waiting -= 1
+              end
             end
 
-            work = todo.shift if continue
+            work = todo.shift
           end
 
-          break unless continue
-
           if @clean_thread_locals
             ThreadPool.clean_thread_locals
           end
 
           begin
-            block.call(work, *extra)
+            @out_of_band_pending = true if block.call(work, *extra)
           rescue Exception => e
             STDERR.puts "Error reached top of thread-pool: #{e.message} (#{e.class})"
           end
         end
-
-        mutex.synchronize do
-          @spawned -= 1
-          @workers.delete th
-        end
       end
 
       @workers << th
@@ -151,9 +156,32 @@ module Puma
 
     private :spawn_thread
 
+    # @version 5.0.0
+    def trigger_out_of_band_hook
+      return false unless out_of_band_hook && out_of_band_hook.any?
+
+      # we execute on idle hook when all threads are free
+      return false unless @spawned == @waiting
+
+      out_of_band_hook.each(&:call)
+      true
+    rescue Exception => e
+      STDERR.puts "Exception calling out_of_band_hook: #{e.message} (#{e.class})"
+      true
+    end
+
+    private :trigger_out_of_band_hook
+
+    # @version 5.0.0
+    def with_mutex(&block)
+      @mutex.owned? ?
+        yield :
+        @mutex.synchronize(&block)
+    end
+
     # Add +work+ to the todo list for a Thread to pickup and process.
     def <<(work)
-      @mutex.synchronize do
+      with_mutex do
         if @shutdown
           raise "Unable to add work while shutting down"
         end
@@ -190,12 +218,12 @@ module Puma
     # request, it might not be added to the `@todo` array right away.
     # For example if a slow client has only sent a header, but not a body
     # then the `@todo` array would stay the same size as the reactor works
-    # to try to buffer the request. In tha scenario the next call to this
+    # to try to buffer the request. In that scenario the next call to this
     # method would not block and another request would be added into the reactor
-    # by the server. This would continue until a fully bufferend request
+    # by the server. This would continue until a fully buffered request
     # makes it through the reactor and can then be processed by the thread pool.
     def wait_until_not_full
-      @mutex.synchronize do
+      with_mutex do
         while true
           return if @shutdown
 
@@ -203,20 +231,42 @@ module Puma
           # is work queued that cannot be handled by waiting
           # threads, then accept more work until we would
           # spin up the max number of threads.
-          return if @todo.size - @waiting < @max - @spawned
+          return if busy_threads < @max
 
           @not_full.wait @mutex
         end
       end
     end
 
-    # If too many threads are in the pool, tell one to finish go ahead
+    # @version 5.0.0
+    def wait_for_less_busy_worker(delay_s)
+      return unless delay_s && delay_s > 0
+
+      # Ruby MRI does GVL, this can result
+      # in processing contention when multiple threads
+      # (requests) are running concurrently
+      return unless Puma.mri?
+
+      with_mutex do
+        return if @shutdown
+
+        # do not delay, if we are not busy
+        return unless busy_threads > 0
+
+        # this will be signaled once a request finishes,
+        # which can happen earlier than delay
+        @not_full.wait @mutex, delay_s
+      end
+    end
+
+    # If there are any free threads in the pool, tell one to go ahead
     # and exit. If +force+ is true, then a trim request is requested
     # even if all threads are being utilized.
     #
     def trim(force=false)
-      @mutex.synchronize do
-        if (force or @waiting > 0) and @spawned - @trim_requested > @min
+      with_mutex do
+        free = @waiting - @todo.size
+        if (force or free > 0) and @spawned - @trim_requested > @min
           @trim_requested += 1
           @not_empty.signal
         end
@@ -226,7 +276,7 @@ module Puma
     # 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
+      with_mutex do
         dead_workers = @workers.reject(&:alive?)
 
         dead_workers.each do |worker|
@@ -240,10 +290,12 @@ module Puma
       end
     end
 
-    class AutoTrim
-      def initialize(pool, timeout)
+    class Automaton
+      def initialize(pool, timeout, thread_name, message)
         @pool = pool
         @timeout = timeout
+        @thread_name = thread_name
+        @message = message
         @running = false
       end
 
@@ -251,8 +303,9 @@ module Puma
         @running = true
 
         @thread = Thread.new do
+          Puma.set_thread_name @thread_name
           while @running
-            @pool.trim
+            @pool.public_send(@message)
             sleep @timeout
           end
         end
@@ -265,44 +318,37 @@ module Puma
     end
 
     def auto_trim!(timeout=30)
-      @auto_trim = AutoTrim.new(self, timeout)
+      @auto_trim = Automaton.new(self, timeout, "threadpool trimmer", :trim)
       @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 = Automaton.new(self, timeout, "threadpool reaper", :reap)
       @reaper.start!
     end
 
+    # Allows ThreadPool::ForceShutdown to be raised within the
+    # provided block if the thread is forced to shutdown during execution.
+    def with_force_shutdown
+      t = Thread.current
+      @shutdown_mutex.synchronize do
+        raise ForceShutdown if @force_shutdown
+        t[:with_force_shutdown] = true
+      end
+      yield
+    ensure
+      t[:with_force_shutdown] = false
+    end
+
     # Tell all threads in the pool to exit and wait for them to finish.
+    # Wait +timeout+ seconds then raise +ForceShutdown+ in remaining threads.
+    # Next, wait an extra +grace+ seconds then force-kill remaining threads.
+    # Finally, wait +kill_grace+ seconds for remaining threads to exit.
     #
     def shutdown(timeout=-1)
-      threads = @mutex.synchronize do
+      threads = with_mutex do
         @shutdown = true
+        @trim_requested = @spawned
         @not_empty.broadcast
         @not_full.broadcast
 
@@ -316,27 +362,29 @@ module Puma
         # Wait for threads to finish without force shutdown.
         threads.each(&:join)
       else
-        # Wait for threads to finish after n attempts (+timeout+).
-        # If threads are still running, it will forcefully kill them.
-        timeout.times do
-          threads.delete_if do |t|
-            t.join 1
-          end
-
-          if threads.empty?
-            break
-          else
-            sleep 1
+        join = ->(inner_timeout) do
+          start = Process.clock_gettime(Process::CLOCK_MONOTONIC)
+          threads.reject! do |t|
+            elapsed = Process.clock_gettime(Process::CLOCK_MONOTONIC) - start
+            t.join inner_timeout - elapsed
           end
         end
 
-        threads.each do |t|
-          t.raise ForceShutdown
-        end
+        # Wait +timeout+ seconds for threads to finish.
+        join.call(timeout)
 
-        threads.each do |t|
-          t.join SHUTDOWN_GRACE_TIME
+        # If threads are still running, raise ForceShutdown and wait to finish.
+        @shutdown_mutex.synchronize do
+          @force_shutdown = true
+          threads.each do |t|
+            t.raise ForceShutdown if t[:with_force_shutdown]
+          end
         end
+        join.call(SHUTDOWN_GRACE_TIME)
+
+        # If threads are _still_ running, forcefully kill them and wait to finish.
+        threads.each(&:kill)
+        join.call(1)
       end
 
       @spawned = 0