puma 5.0.2-java → 5.0.3-java

data/lib/puma/app/status.rb

@@ -7,11 +7,16 @@ module Puma
     class Status
       OK_STATUS = '{ "status": "ok" }'.freeze
 
-      def initialize(cli, token = nil)
-        @cli = cli
+      # @param launcher [::Puma::Launcher]
+      # @param token [String, nil] the token used for authentication
+      #
+      def initialize(launcher, token = nil)
+        @launcher = launcher
         @auth_token = token
       end
 
+      # most commands call methods in `::Puma::Launcher` based on command in
+      # `env['PATH_INFO']`
       def call(env)
         unless authenticate(env)
           return rack_response(403, 'Invalid auth token', 'text/plain')
@@ -21,57 +26,53 @@ module Puma
           require 'json'
         end
 
-        case env['PATH_INFO']
-        when /\/stop$/
-          @cli.stop
-          rack_response(200, OK_STATUS)
+        # resp_type is processed by following case statement, return
+        # is a number (status) or a string used as the body of a 200 response
+        resp_type =
+          case env['PATH_INFO'][/\/([^\/]+)$/, 1]
+          when 'stop'
+            @launcher.stop ; 200
 
-        when /\/halt$/
-          @cli.halt
-          rack_response(200, OK_STATUS)
+          when 'halt'
+            @launcher.halt ; 200
 
-        when /\/restart$/
-          @cli.restart
-          rack_response(200, OK_STATUS)
+          when 'restart'
+            @launcher.restart ; 200
 
-        when /\/phased-restart$/
-          if !@cli.phased_restart
-            rack_response(404, '{ "error": "phased restart not available" }')
-          else
-            rack_response(200, OK_STATUS)
-          end
-
-        when /\/reload-worker-directory$/
-          if !@cli.send(:reload_worker_directory)
-            rack_response(404, '{ "error": "reload_worker_directory not available" }')
-          else
-            rack_response(200, OK_STATUS)
-          end
+          when 'phased-restart'
+            @launcher.phased_restart ? 200 : 404
 
-        when /\/gc$/
-          GC.start
-          rack_response(200, OK_STATUS)
+          when 'reload-worker-directory'
+            @launcher.send(:reload_worker_directory) ? 200 : 404
 
-        when /\/gc-stats$/
-          rack_response(200, GC.stat.to_json)
+          when 'gc'
+            GC.start ; 200
 
-        when /\/stats$/
-          rack_response(200, @cli.stats.to_json)
+          when 'gc-stats'
+            GC.stat.to_json
 
-        when /\/thread-backtraces$/
-          backtraces = []
-          @cli.thread_status do |name, backtrace|
-            backtraces << { name: name, backtrace: backtrace }
-          end
+          when 'stats'
+            @launcher.stats.to_json
 
-          rack_response(200, backtraces.to_json)
+          when 'thread-backtraces'
+            backtraces = []
+            @launcher.thread_status do |name, backtrace|
+              backtraces << { name: name, backtrace: backtrace }
+            end
+            backtraces.to_json
 
-        when /\/refork$/
-          Process.kill "SIGURG", $$
-          rack_response(200, OK_STATUS)
+          else
+            return rack_response(404, "Unsupported action", 'text/plain')
+          end
 
-        else
-          rack_response 404, "Unsupported action", 'text/plain'
+        case resp_type
+        when String
+          rack_response 200, resp_type
+        when 200
+          rack_response 200, OK_STATUS
+        when 404
+          str = env['PATH_INFO'][/\/(\S+)/, 1].tr '-', '_'
+          rack_response 404, "{ \"error\": \"#{str} not available\" }"
         end
       end
 

data/lib/puma/binder.rb

@@ -12,7 +12,15 @@ module Puma
   if HAS_SSL
     require 'puma/minissl'
     require 'puma/minissl/context_builder'
-    require 'puma/accept_nonblock'
+
+    # Odd bug in 'pure Ruby' nio4r verion 2.5.2, which installs with Ruby 2.3.
+    # NIO doesn't create any OpenSSL objects, but it rescues an OpenSSL error.
+    # The bug was that it did not require openssl.
+    # @todo remove when Ruby 2.3 support is dropped
+    #
+    if windows? && RbConfig::CONFIG['ruby_version'] == '2.3.0'
+      require 'openssl'
+    end
   end
 
   class Binder

data/lib/puma/client.rb

@@ -85,6 +85,12 @@ module Puma
 
     def_delegators :@io, :closed?
 
+    # Test to see if io meets a bare minimum of functioning, @to_io needs to be
+    # used for MiniSSL::Socket
+    def io_ok?
+      @to_io.is_a?(::BasicSocket) && !closed?
+    end
+
     # @!attribute [r] inspect
     def inspect
       "#<Puma::Client:0x#{object_id.to_s(16)} @ready=#{@ready.inspect}>"
@@ -103,7 +109,12 @@ module Puma
     end
 
     def set_timeout(val)
-      @timeout_at = Time.now + val
+      @timeout_at = Process.clock_gettime(Process::CLOCK_MONOTONIC) + val
+    end
+
+    # Number of seconds until the timeout elapses.
+    def timeout
+      [@timeout_at - Process.clock_gettime(Process::CLOCK_MONOTONIC), 0].max
     end
 
     def reset(fast_check=true)
@@ -188,79 +199,20 @@ module Puma
       false
     end
 
-    if IS_JRUBY
-      def jruby_start_try_to_finish
-        return read_body unless @read_header
-
-        begin
-          data = @io.sysread_nonblock(CHUNK_SIZE)
-        rescue OpenSSL::SSL::SSLError => e
-          return false if e.kind_of? IO::WaitReadable
-          raise e
-        end
-
-        # No data means a closed socket
-        unless data
-          @buffer = nil
-          set_ready
-          raise EOFError
-        end
-
-        if @buffer
-          @buffer << data
-        else
-          @buffer = data
-        end
-
-        @parsed_bytes = @parser.execute(@env, @buffer, @parsed_bytes)
-
-        if @parser.finished?
-          return setup_body
-        elsif @parsed_bytes >= MAX_HEADER
-          raise HttpParserError,
-            "HEADER is longer than allowed, aborting client early."
-        end
-
-        false
-      end
-
-      def eagerly_finish
-        return true if @ready
-
-        if @io.kind_of? OpenSSL::SSL::SSLSocket
-          return true if jruby_start_try_to_finish
-        end
-
-        return false unless IO.select([@to_io], nil, nil, 0)
-        try_to_finish
-      end
-
-    else
-
-      def eagerly_finish
-        return true if @ready
-        return false unless IO.select([@to_io], nil, nil, 0)
-        try_to_finish
-      end
-
-      # For documentation, see https://github.com/puma/puma/issues/1754
-      send(:alias_method, :jruby_eagerly_finish, :eagerly_finish)
-    end # IS_JRUBY
+    def eagerly_finish
+      return true if @ready
+      return false unless IO.select([@to_io], nil, nil, 0)
+      try_to_finish
+    end
 
     def finish(timeout)
-      return true if @ready
-      until try_to_finish
-        can_read = begin
-          IO.select([@to_io], nil, nil, timeout)
-        rescue ThreadPool::ForceShutdown
-          nil
-        end
-        unless can_read
-          write_error(408) if in_data_phase
-          raise ConnectionError
-        end
-      end
-      true
+      return if @ready
+      IO.select([@to_io], nil, nil, timeout) || timeout! until try_to_finish
+    end
+
+    def timeout!
+      write_error(408) if in_data_phase
+      raise ConnectionError
     end
 
     def write_error(status_code)

data/lib/puma/cluster.rb

@@ -3,6 +3,8 @@
 require 'puma/runner'
 require 'puma/util'
 require 'puma/plugin'
+require 'puma/cluster/worker_handle'
+require 'puma/cluster/worker'
 
 require 'time'
 
@@ -11,10 +13,6 @@ module Puma
   # to boot and serve a Ruby application when puma "workers" are needed
   # i.e. when using multi-processes. For example `$ puma -w 5`
   #
-  # At the core of this class is running an instance of `Puma::Server` which
-  # gets created via the `start_server` method from the `Puma::Runner` class
-  # that this inherits from.
-  #
   # An instance of this class will spawn the number of processes passed in
   # via the `spawn_workers` method call. Each worker will have it's own
   # instance of a `Puma::Server`.
@@ -61,79 +59,6 @@ module Puma
       @workers.each { |x| x.hup }
     end
 
-    class Worker
-      def initialize(idx, pid, phase, options)
-        @index = idx
-        @pid = pid
-        @phase = phase
-        @stage = :started
-        @signal = "TERM"
-        @options = options
-        @first_term_sent = nil
-        @started_at = Time.now
-        @last_checkin = Time.now
-        @last_status = {}
-        @term = false
-      end
-
-      attr_reader :index, :pid, :phase, :signal, :last_checkin, :last_status, :started_at
-
-      # @version 5.0.0
-      attr_writer :pid, :phase
-
-      def booted?
-        @stage == :booted
-      end
-
-      def boot!
-        @last_checkin = Time.now
-        @stage = :booted
-      end
-
-      def term?
-        @term
-      end
-
-      def ping!(status)
-        @last_checkin = Time.now
-        require 'json'
-        @last_status = JSON.parse(status, symbolize_names: true)
-      end
-
-      # @see Puma::Cluster#check_workers
-      # @version 5.0.0
-      def ping_timeout
-        @last_checkin +
-          (booted? ?
-            @options[:worker_timeout] :
-            @options[:worker_boot_timeout]
-          )
-      end
-
-      def term
-        begin
-          if @first_term_sent && (Time.now - @first_term_sent) > @options[:worker_shutdown_timeout]
-            @signal = "KILL"
-          else
-            @term ||= true
-            @first_term_sent ||= Time.now
-          end
-          Process.kill @signal, @pid if @pid
-        rescue Errno::ESRCH
-        end
-      end
-
-      def kill
-        @signal = 'KILL'
-        term
-      end
-
-      def hup
-        Process.kill "HUP", @pid
-      rescue Errno::ESRCH
-      end
-    end
-
     def spawn_workers
       diff = @options[:workers] - @workers.size
       return if diff < 1
@@ -154,7 +79,7 @@ module Puma
         end
 
         debug "Spawned worker: #{pid}"
-        @workers << Worker.new(idx, pid, @phase, @options)
+        @workers << WorkerHandle.new(idx, pid, @phase, @options)
       end
 
       if @options[:fork_worker] &&
@@ -249,113 +174,23 @@ module Puma
     end
 
     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"
-      Signal.trap "SIGCHLD", "DEFAULT"
-
-      fork_worker = @options[:fork_worker] && index == 0
-
       @workers = []
-      if !@options[:fork_worker] || fork_worker
-        @master_read.close
-        @suicide_pipe.close
-        @fork_writer.close
-      end
-
-      Thread.new do
-        Puma.set_thread_name "worker check pipe"
-        IO.select [@check_pipe]
-        log "! Detected parent died, dying"
-        exit! 1
-      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']
-        if File.exist?("Gemfile")
-          log "+ Gemfile in context: #{File.expand_path("Gemfile")}"
-        elsif File.exist?("gems.rb")
-          log "+ Gemfile in context: #{File.expand_path("gems.rb")}"
-        end
-      end
-
-      # Invoke any worker boot hooks so they can get
-      # things in shape before booting the app.
-      @launcher.config.run_hooks :before_worker_boot, index, @launcher.events
-
-      server = @server ||= start_server
-      restart_server = Queue.new << true << false
-
-      if fork_worker
-        restart_server.clear
-        worker_pids = []
-        Signal.trap "SIGCHLD" do
-          wakeup! if worker_pids.reject! do |p|
-            Process.wait(p, Process::WNOHANG) rescue true
-          end
-        end
-
-        Thread.new do
-          Puma.set_thread_name "worker fork pipe"
-          while (idx = @fork_pipe.gets)
-            idx = idx.to_i
-            if idx == -1 # stop server
-              if restart_server.length > 0
-                restart_server.clear
-                server.begin_restart(true)
-                @launcher.config.run_hooks :before_refork, nil, @launcher.events
-                nakayoshi_gc
-              end
-            elsif idx == 0 # restart server
-              restart_server << true << false
-            else # fork worker
-              worker_pids << pid = spawn_worker(idx, master)
-              @worker_write << "f#{pid}:#{idx}\n" rescue nil
-            end
-          end
-        end
-      end
-
-      Signal.trap "SIGTERM" do
-        @worker_write << "e#{Process.pid}\n" rescue nil
-        server.stop
-        restart_server << false
-      end
-
-      begin
-        @worker_write << "b#{Process.pid}:#{index}\n"
-      rescue SystemCallError, IOError
-        Thread.current.purge_interrupt_queue if Thread.current.respond_to? :purge_interrupt_queue
-        STDERR.puts "Master seems to have exited, exiting."
-        return
-      end
-
-      Thread.new(@worker_write) do |io|
-        Puma.set_thread_name "stat payload"
+      @master_read.close
+      @suicide_pipe.close
+      @fork_writer.close
 
-        while true
-          sleep Const::WORKER_CHECK_INTERVAL
-          begin
-            require 'json'
-            io << "p#{Process.pid}#{server.stats.to_json}\n"
-          rescue IOError
-            Thread.current.purge_interrupt_queue if Thread.current.respond_to? :purge_interrupt_queue
-            break
-          end
-        end
+      pipes = { check_pipe: @check_pipe, worker_write: @worker_write }
+      if @options[:fork_worker]
+        pipes[:fork_pipe] = @fork_pipe
+        pipes[:wakeup] = @wakeup
       end
 
-      server.run.join while restart_server.pop
-
-      # 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, @launcher.events
-    ensure
-      @worker_write << "t#{Process.pid}\n" rescue nil
-      @worker_write.close
+      new_worker = Worker.new index: index,
+                              master: master,
+                              launcher: @launcher,
+                              pipes: pipes
+      new_worker.run
     end
 
     def restart
@@ -552,7 +387,7 @@ module Puma
       @master_read, @worker_write = read, @wakeup
 
       @launcher.config.run_hooks :before_fork, nil, @launcher.events
-      nakayoshi_gc
+      Puma::Util.nakayoshi_gc @events if @options[:nakayoshi_fork]
 
       spawn_workers
 
@@ -560,9 +395,9 @@ module Puma
         stop
       end
 
-      @launcher.events.fire_on_booted!
-
       begin
+        booted = false
+
         while @status == :run
           begin
             if @phased_restart
@@ -603,6 +438,10 @@ module Puma
                 when "p"
                   w.ping!(result.sub(/^\d+/,'').chomp)
                   @launcher.events.fire(:ping!, w)
+                  if !booted && @workers.none? {|worker| worker.last_status.empty?}
+                    @launcher.events.fire_on_booted!
+                    booted = true
+                  end
                 end
               else
                 log "! Out-of-sync worker list, no #{pid} worker"
@@ -640,7 +479,9 @@ module Puma
         rescue Errno::ECHILD
           begin
             Process.kill(0, w.pid)
-            false # child still alive, but has another parent
+            # child still alive but has another parent (e.g., using fork_worker)
+            w.term if w.term?
+            false
           rescue Errno::ESRCH, Errno::EPERM
             true # child is already terminated
           end
@@ -657,17 +498,5 @@ module Puma
         end
       end
     end
-
-    # @version 5.0.0
-    def nakayoshi_gc
-      return unless @options[:nakayoshi_fork]
-      log "! Promoting existing objects to old generation..."
-      4.times { GC.start(full_mark: false) }
-      if GC.respond_to?(:compact)
-        log "! Compacting..."
-        GC.compact
-      end
-      log "! Friendly fork preparation complete."
-    end
   end
 end