puma 2.7.0 → 3.1.1

data/lib/puma/client.rb

@@ -7,6 +7,7 @@ class IO
 end
 
 require 'puma/detect'
+require 'puma/delegation'
 
 if Puma::IS_JRUBY
   # We have to work around some OpenSSL buffer/io-readiness bugs
@@ -21,6 +22,7 @@ module Puma
 
   class Client
     include Puma::Const
+    extend  Puma::Delegation
 
     def initialize(io, env=nil)
       @io = io
@@ -39,14 +41,25 @@ module Puma
 
       @body = nil
       @buffer = nil
+      @tempfile = nil
 
       @timeout_at = nil
 
       @requests_served = 0
       @hijacked = false
+
+      @peerip = nil
+      @remote_addr_header = nil
     end
 
-    attr_reader :env, :to_io, :body, :io, :timeout_at, :ready, :hijacked
+    attr_reader :env, :to_io, :body, :io, :timeout_at, :ready, :hijacked,
+                :tempfile
+
+    attr_writer :peerip
+
+    attr_accessor :remote_addr_header
+
+    forward :closed?, :@io
 
     def inspect
       "#<Puma::Client:0x#{object_id.to_s(16)} @ready=#{@ready.inspect}>"
@@ -59,6 +72,10 @@ module Puma
       env[HIJACK_IO] ||= @io
     end
 
+    def in_data_phase
+      !@read_header
+    end
+
     def set_timeout(val)
       @timeout_at = Time.now + val
     end
@@ -68,6 +85,7 @@ module Puma
       @read_header = true
       @env = @proto_env.dup
       @body = nil
+      @tempfile = nil
       @parsed_bytes = 0
       @ready = false
 
@@ -100,6 +118,7 @@ module Puma
     EmptyBody = NullIO.new
 
     def setup_body
+      @in_data_phase = true
       body = @parser.body
       cl = @env[CONTENT_LENGTH]
 
@@ -124,6 +143,7 @@ module Puma
       if remain > MAX_BODY
         @body = Tempfile.new(Const::PUMA_TMP_BASE)
         @body.binmode
+        @tempfile = @body
       else
         # The body[0,0] trick is to get an empty string in the same
         # encoding as body.
@@ -217,6 +237,14 @@ module Puma
       end
     end # IS_JRUBY
 
+    def finish
+      return true if @ready
+      until try_to_finish
+        IO.select([@to_io], nil, nil)
+      end
+      true
+    end
+
     def read_body
       # Read an odd sized chunk so we can read even sized ones
       # after this
@@ -267,11 +295,30 @@ module Puma
       end
     end
 
+    def write_408
+      begin
+        @io << ERROR_408_RESPONSE
+      rescue StandardError
+      end
+    end
+
     def write_500
       begin
         @io << ERROR_500_RESPONSE
       rescue StandardError
       end
     end
+
+    def peerip
+      return @peerip if @peerip
+
+      if @remote_addr_header
+        hdr = (@env[@remote_addr_header] || LOCALHOST_ADDR).split(/[\s,]/).first
+        @peerip = hdr
+        return hdr
+      end
+
+      @peerip ||= @io.peeraddr.last
+    end
   end
 end

data/lib/puma/cluster.rb

@@ -1,12 +1,14 @@
 require 'puma/runner'
+require 'time'
 
 module Puma
   class Cluster < Runner
-    def initialize(cli)
-      super cli
+    def initialize(cli, events)
+      super cli, events
 
       @phase = 0
       @workers = []
+      @next_check = nil
 
       @phased_state = :idle
       @phased_restart = false
@@ -26,51 +28,101 @@ module Puma
     def start_phased_restart
       @phase += 1
       log "- Starting phased worker restart, phase: #{@phase}"
+
+      # Be sure to change the directory again before loading
+      # the app. This way we can pick up new code.
+      if dir = @options[:worker_directory]
+        log "+ Changing to #{dir}"
+        Dir.chdir dir
+      end
+    end
+
+    def redirect_io
+      super
+
+      @workers.each { |x| x.hup }
     end
 
     class Worker
-      def initialize(pid, phase)
+      def initialize(idx, pid, phase, options)
+        @index = idx
         @pid = pid
         @phase = phase
         @stage = :started
         @signal = "TERM"
+        @options = options
+        @first_term_sent = nil
+        @last_checkin = Time.now
+        @last_status = '{}'
+        @dead = false
       end
 
-      attr_reader :pid, :phase, :signal
+      attr_reader :index, :pid, :phase, :signal, :last_checkin, :last_status
 
       def booted?
         @stage == :booted
       end
 
       def boot!
+        @last_checkin = Time.now
         @stage = :booted
       end
 
+      def dead?
+        @dead
+      end
+
+      def dead!
+        @dead = true
+      end
+
+      def ping!(status)
+        @last_checkin = Time.now
+        @last_status = status
+      end
+
+      def ping_timeout?(which)
+        Time.now - @last_checkin > which
+      end
+
       def term
         begin
-          if @first_term_sent && (Time.new - @first_term_sent) > 30
+          if @first_term_sent && (Time.now - @first_term_sent) > @options[:worker_shutdown_timeout]
             @signal = "KILL"
           else
-            @first_term_sent ||= Time.new
+            @first_term_sent ||= Time.now
           end
 
           Process.kill @signal, @pid
         rescue Errno::ESRCH
         end
       end
+
+      def kill
+        Process.kill "KILL", @pid
+      rescue Errno::ESRCH
+      end
+
+      def hup
+        Process.kill "HUP", @pid
+      rescue Errno::ESRCH
+      end
     end
 
     def spawn_workers
       diff = @options[:workers] - @workers.size
 
-      upgrade = (@phased_state == :waiting)
-
       master = Process.pid
 
       diff.times do
-        pid = fork { worker(upgrade, master) }
-        @cli.debug "Spawned worker: #{pid}"
-        @workers << Worker.new(pid, @phase)
+        idx = next_worker_index
+        @launcher.config.run_hooks :before_worker_fork, idx
+
+        pid = fork { worker(idx, master) }
+        debug "Spawned worker: #{pid}"
+        @workers << Worker.new(idx, pid, @phase, @options)
+
+        @launcher.config.run_hooks :after_worker_fork, idx
       end
 
       if diff > 0
@@ -78,11 +130,37 @@ module Puma
       end
     end
 
+    def next_worker_index
+      all_positions =  0...@options[:workers]
+      occupied_positions = @workers.map { |w| w.index }
+      available_positions = all_positions.to_a - occupied_positions
+      available_positions.first
+    end
+
     def all_workers_booted?
       @workers.count { |w| !w.booted? } == 0
     end
 
-    def check_workers
+    def check_workers(force=false)
+      return if !force && @next_check && @next_check >= Time.now
+
+      @next_check = Time.now + 5
+
+      any = false
+
+      @workers.each do |w|
+        next if !w.booted? && !w.ping_timeout?(@options[:worker_boot_timeout])
+        if w.ping_timeout?(@options[:worker_timeout])
+          log "! Terminating timed out worker: #{w.pid}"
+          w.kill
+          any = true
+        end
+      end
+
+      # If we killed any timed out workers, try to catch them
+      # during this loop by giving the kernel time to kill them.
+      sleep 1 if any
+
       while @workers.any?
         pid = Process.waitpid(-1, Process::WNOHANG)
         break unless pid
@@ -90,6 +168,8 @@ module Puma
         @workers.delete_if { |w| w.pid == pid }
       end
 
+      @workers.delete_if(&:dead?)
+
       spawn_workers
 
       if all_workers_booted?
@@ -112,16 +192,22 @@ module Puma
     end
 
     def wakeup!
+      return unless @wakeup
+
       begin
         @wakeup.write "!" unless @wakeup.closed?
       rescue SystemCallError, IOError
       end
     end
 
-    def worker(upgrade, master)
-      $0 = "puma: cluster worker: #{master}"
+    def worker(index, master)
+      title = "puma: cluster worker #{index}: #{master}"
+      title << " [#{@options[:tag]}]" if @options[:tag] && !@options[:tag].empty?
+      $0 = title
+
       Signal.trap "SIGINT", "IGNORE"
 
+      @workers = []
       @master_read.close
       @suicide_pipe.close
 
@@ -131,19 +217,15 @@ module Puma
         exit! 1
       end
 
-      # Be sure to change the directory again before loading
-      # the app. This way we can pick up new code.
-      if upgrade
-        if dir = @options[:worker_directory]
-          log "+ Changing to #{dir}"
-          Dir.chdir dir
-        end
+      # If we're not running under a Bundler context, then
+      # report the info about the context we will be using
+      if !ENV['BUNDLE_GEMFILE'] and File.exist?("Gemfile")
+        log "+ Gemfile in context: #{File.expand_path("Gemfile")}"
       end
 
       # Invoke any worker boot hooks so they can get
       # things in shape before booting the app.
-      hooks = @options[:worker_boot]
-      hooks.each { |h| h.call }
+      @launcher.config.run_hooks :before_worker_boot, index
 
       server = start_server
 
@@ -154,13 +236,33 @@ module Puma
       begin
         @worker_write << "b#{Process.pid}\n"
       rescue SystemCallError, IOError
-        STDERR.puts "Master seems to have exitted, exitting."
+        STDERR.puts "Master seems to have exited, exiting."
         return
       end
 
+      Thread.new(@worker_write) do |io|
+        base_payload = "p#{Process.pid}"
+
+        while true
+          sleep 5
+          begin
+            b = server.backlog
+            r = server.running
+            payload = %Q!#{base_payload}{ "backlog":#{b}, "running":#{r} }\n!
+            io << payload
+          rescue IOError
+            break
+          end
+        end
+      end
+
       server.run.join
 
+      # Invoke any worker shutdown hooks so they can prevent the worker
+      # exiting until any background operations are completed
+      @launcher.config.run_hooks :before_worker_shutdown, index
     ensure
+      @worker_write << "t#{Process.pid}\n" rescue nil
       @worker_write.close
     end
 
@@ -195,37 +297,27 @@ module Puma
       wakeup!
     end
 
+    def reload_worker_directory
+      if dir = @options[:worker_directory]
+        log "+ Changing to #{dir}"
+        Dir.chdir dir
+      end
+    end
+
     def stats
-      %Q!{ "workers": #{@workers.size}, "phase": #{@phase} }!
+      old_worker_count = @workers.count { |w| w.phase != @phase }
+      booted_worker_count = @workers.count { |w| w.booted? }
+      worker_status = '[' + @workers.map{ |w| %Q!{ "pid": #{w.pid}, "index": #{w.index}, "phase": #{w.phase}, "booted": #{w.booted?}, "last_checkin": "#{w.last_checkin.utc.iso8601}", "last_status": #{w.last_status} }!}.join(",") + ']'
+      %Q!{ "workers": #{@workers.size}, "phase": #{@phase}, "booted_workers": #{booted_worker_count}, "old_workers": #{old_worker_count}, "worker_status": #{worker_status} }!
     end
 
     def preload?
       @options[:preload_app]
     end
 
-    def run
-      @status = :run
-
-      output_header "cluster"
-
-      log "* Process workers: #{@options[:workers]}"
-
-      if preload?
-        log "* Preloading application"
-        load_and_bind
-      else
-        log "* Phased restart available"
-
-        unless @cli.config.app_configured?
-          error "No application configured, nothing to run"
-          exit 1
-        end
-
-        @cli.binder.parse @options[:binds], self
-      end
-
-      read, @wakeup = Puma::Util.pipe
-
+    # We do this in a separate method to keep the lambad scope
+    # of the signals handlers as small as possible.
+    def setup_signals
       Signal.trap "SIGCHLD" do
         wakeup!
       end
@@ -254,6 +346,48 @@ module Puma
           stop
         end
       end
+    end
+
+    def run
+      @status = :run
+
+      output_header "cluster"
+
+      log "* Process workers: #{@options[:workers]}"
+
+      before = Thread.list
+
+      if preload?
+        log "* Preloading application"
+        load_and_bind
+
+        after = Thread.list
+
+        if after.size > before.size
+          threads = (after - before)
+          if threads.first.respond_to? :backtrace
+            log "! WARNING: Detected #{after.size-before.size} Thread(s) started in app boot:"
+            threads.each do |t|
+              log "! #{t.inspect} - #{t.backtrace ? t.backtrace.first : ''}"
+            end
+          else
+            log "! WARNING: Detected #{after.size-before.size} Thread(s) started in app boot"
+          end
+        end
+      else
+        log "* Phased restart available"
+
+        unless @launcher.config.app_configured?
+          error "No application configured, nothing to run"
+          exit 1
+        end
+
+        @launcher.binder.parse @options[:binds], self
+      end
+
+      read, @wakeup = Puma::Util.pipe
+
+      setup_signals
 
       # Used by the workers to detect if the master process dies.
       # If select says that @check_pipe is ready, it's because the
@@ -273,34 +407,49 @@ module Puma
 
       start_control
 
-      @cli.write_state
+      @launcher.write_state
 
       @master_read, @worker_write = read, @wakeup
+
+      @launcher.config.run_hooks :before_fork, nil
+
       spawn_workers
 
       Signal.trap "SIGINT" do
         stop
       end
 
-      @cli.events.fire_on_booted!
+      @launcher.events.fire_on_booted!
 
       begin
         while @status == :run
           begin
             res = IO.select([read], nil, nil, 5)
 
+            force_check = false
+
             if res
               req = read.read_nonblock(1)
 
-              if req == "b"
-                pid = read.gets.to_i
-                w = @workers.find { |x| x.pid == pid }
-                if w
+              next if !req || req == "!"
+
+              result = read.gets
+              pid = result.to_i
+
+              if w = @workers.find { |x| x.pid == pid }
+                case req
+                when "b"
                   w.boot!
-                  log "- Worker #{pid} booted, phase: #{w.phase}"
-                else
-                  log "! Out-of-sync worker list, no #{pid} worker"
+                  log "- Worker #{w.index} (pid: #{pid}) booted, phase: #{w.phase}"
+                  force_check = true
+                when "t"
+                  w.dead!
+                  force_check = true
+                when "p"
+                  w.ping!(result.sub(/^\d+/,'').chomp)
                 end
+              else
+                log "! Out-of-sync worker list, no #{pid} worker"
               end
             end
 
@@ -309,7 +458,7 @@ module Puma
               @phased_restart = false
             end
 
-            check_workers
+            check_workers force_check
 
           rescue Interrupt
             @status = :stop