puma 2.16.0-java → 3.0.0-java

data/lib/puma/plugin/tmp_restart.rb

@@ -0,0 +1,23 @@
+require 'puma/plugin'
+
+Puma::Plugin.create do
+  def start(launcher)
+    path = File.join("tmp", "restart.txt")
+
+    File.write path, ""
+
+    orig = File.stat(path).mtime
+
+    in_background do
+      while true
+        sleep 2
+
+        if File.stat(path).mtime > orig
+          launcher.restart
+          break
+        end
+      end
+    end
+  end
+end
+

data/lib/puma/runner.rb

@@ -1,7 +1,8 @@
 module Puma
   class Runner
-    def initialize(cli)
-      @cli = cli
+    def initialize(cli, events)
+      @launcher = cli
+      @events = events
       @options = cli.options
       @app = nil
       @control = nil
@@ -16,15 +17,19 @@ module Puma
     end
 
     def log(str)
-      @cli.log str
+      @events.log str
+    end
+
+    def before_restart
+      @control.stop(true) if @control
     end
 
     def error(str)
-      @cli.error str
+      @events.error str
     end
 
-    def before_restart
-      @control.stop(true) if @control
+    def debug(str)
+      @events.log "- #{str}" if @options[:debug]
     end
 
     def start_control
@@ -35,13 +40,13 @@ module Puma
 
       uri = URI.parse str
 
-      app = Puma::App::Status.new @cli
+      app = Puma::App::Status.new @launcher
 
       if token = @options[:control_auth_token]
         app.auth_token = token unless token.empty? or token == :none
       end
 
-      control = Puma::Server.new app, @cli.events
+      control = Puma::Server.new app, @launcher.events
       control.min_threads = 0
       control.max_threads = 1
 
@@ -104,34 +109,34 @@ module Puma
     end
 
     def load_and_bind
-      unless @cli.config.app_configured?
+      unless @launcher.config.app_configured?
         error "No application configured, nothing to run"
         exit 1
       end
 
       # Load the app before we daemonize.
       begin
-        @app = @cli.config.app
+        @app = @launcher.config.app
       rescue Exception => e
         log "! Unable to load application: #{e.class}: #{e.message}"
         raise e
       end
 
-      @cli.binder.parse @options[:binds], self
+      @launcher.binder.parse @options[:binds], self
     end
 
     def app
-      @app ||= @cli.config.app
+      @app ||= @launcher.config.app
     end
 
     def start_server
       min_t = @options[:min_threads]
       max_t = @options[:max_threads]
 
-      server = Puma::Server.new app, @cli.events, @options
+      server = Puma::Server.new app, @launcher.events, @options
       server.min_threads = min_t
       server.max_threads = max_t
-      server.inherit_binder @cli.binder
+      server.inherit_binder @launcher.binder
 
       if @options[:mode] == :tcp
         server.tcp_mode!

data/lib/puma/server.rb

@@ -85,6 +85,7 @@ module Puma
     forward :add_tcp_listener,  :@binder
     forward :add_ssl_listener,  :@binder
     forward :add_unix_listener, :@binder
+    forward :connected_port,    :@binder
 
     def inherit_binder(bind)
       @binder = bind
@@ -398,6 +399,7 @@ module Puma
     #
     def process_client(client, buffer)
       begin
+        clean_thread_locals = @options[:clean_thread_locals]
         close_socket = true
 
         while true
@@ -411,6 +413,8 @@ module Puma
             return unless @queue_requests
             buffer.reset
 
+            ThreadPool.clean_thread_locals if clean_thread_locals
+
             unless client.reset(@status == :run)
               close_socket = false
               client.set_timeout @persistent_timeout
@@ -516,63 +520,20 @@ module Puma
       env['HTTP_X_FORWARDED_PROTO'] == 'https' ? PORT_443 : PORT_80
     end
 
-    # Given the request +env+ from +client+ and a partial request body
-    # in +body+, finish reading the body if there is one and invoke
-    # the rack app. Then construct the response and write it back to
-    # +client+
-    #
-    # +cl+ is the previously fetched Content-Length header if there
-    # was one. This is an optimization to keep from having to look
-    # it up again.
-    #
-    def handle_request(req, lines)
-      env = req.env
+    def handle_app_response(req, lines, env, status, headers, res_body)
       client = req.io
 
-      normalize_env env, req
-
-      env[PUMA_SOCKET] = client
-
-      if env[HTTPS_KEY] && client.peercert
-        env[PUMA_PEERCERT] = client.peercert
-      end
-
-      env[HIJACK_P] = true
-      env[HIJACK] = req
-
       body = req.body
 
       head = env[REQUEST_METHOD] == HEAD
 
-      env[RACK_INPUT] = body
-      env[RACK_URL_SCHEME] =  env[HTTPS_KEY] ? HTTPS : HTTP
-
       # A rack extension. If the app writes #call'ables to this
       # array, we will invoke them when the request is done.
       #
-      after_reply = env[RACK_AFTER_REPLY] = []
+      # (This is already initialized in `handle_request`, just getting here)
+      after_reply = env[RACK_AFTER_REPLY]
 
       begin
-        begin
-          status, headers, res_body = @app.call(env)
-
-          return :async if req.hijacked
-
-          status = status.to_i
-
-          if status == -1
-            unless headers.empty? and res_body == []
-              raise "async response must have empty headers and body"
-            end
-
-            return :async
-          end
-        rescue StandardError => e
-          @events.unknown_error self, e, "Rack app"
-
-          status, headers, res_body = lowlevel_error(e)
-        end
-
         content_length = nil
         no_body = head
 
@@ -714,6 +675,75 @@ module Puma
       return keep_alive
     end
 
+    # Given the request +env+ from +client+ and a partial request body
+    # in +body+, finish reading the body if there is one and invoke
+    # the rack app. Then construct the response and write it back to
+    # +client+
+    #
+    # +cl+ is the previously fetched Content-Length header if there
+    # was one. This is an optimization to keep from having to look
+    # it up again.
+    #
+    def handle_request(req, lines)
+      env = req.env
+      client = req.io
+
+      normalize_env env, req
+
+      env[PUMA_SOCKET] = client
+
+      if env[HTTPS_KEY] && client.peercert
+        env[PUMA_PEERCERT] = client.peercert
+      end
+
+      env[HIJACK_P] = true
+      env[HIJACK] = req
+
+      env['async.callback'] = lambda { |__response|
+        _status, _headers, _res_body = __response
+        # Faye websocket gem also calls this (when available)
+        # with status=101, and res_body being a stream
+        # but calling here just finishes the response
+        # that's why we only response if the request is not
+        # hijacked. not sure if this is a correct solution
+        # but working. for now.
+        unless req.hijacked
+          handle_app_response(req, lines, env, _status, _headers, _res_body)
+        end
+      }
+
+      body = req.body
+
+      env[RACK_INPUT] = body
+      env[RACK_URL_SCHEME] =  env[HTTPS_KEY] ? HTTPS : HTTP
+
+      env[RACK_AFTER_REPLY] = []
+
+      begin
+        status, headers, res_body = @app.call(env)
+
+        return :async if req.hijacked
+
+        status = status.to_i
+
+        if status == -1
+          # unless headers.empty? and res_body == []
+          #   puts "HEADERS: ".white.on_green + headers.inspect
+          #   puts "BODY: ".white.on_green + res_body.inspect
+          #   raise "async response must have empty headers and body"
+          # end
+
+          return :async
+        end
+      rescue StandardError => e
+        @events.unknown_error self, e, "Rack app"
+
+        status, headers, res_body = lowlevel_error(e, env)
+      end
+
+      return handle_app_response(req, lines, env, status, headers, res_body)
+    end
+
     def fetch_status_code(status)
       HTTP_STATUS_CODES.fetch(status) { 'CUSTOM' }
     end
@@ -775,9 +805,13 @@ module Puma
 
     # A fallback rack response if +@app+ raises as exception.
     #
-    def lowlevel_error(e)
+    def lowlevel_error(e, env)
       if handler = @options[:lowlevel_error_handler]
-        return handler.call(e)
+        if handler.arity == 1
+          return handler.call(e)
+        else
+          return handler.call(e, env)
+        end
       end
 
       if @leak_stack_on_error

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, restart_args)
     end
 
     def run
@@ -66,7 +71,7 @@ module Puma
             exit 1
           end
 
-          pid = @cli.jruby_daemon_start
+          pid = jruby_daemon_start
           sleep
         end
       else
@@ -79,7 +84,7 @@ module Puma
         load_and_bind
       end
 
-      @cli.write_state
+      @launcher.write_state
 
       start_control
 
@@ -90,7 +95,7 @@ module Puma
         redirect_io
       end
 
-      @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

@@ -45,6 +45,12 @@ module Puma
     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?
     #
     def backlog
@@ -77,6 +83,7 @@ module Puma
               if @trim_requested > 0
                 @trim_requested -= 1
                 continue = false
+                not_full.signal
                 break
               end
 
@@ -97,9 +104,7 @@ module Puma
           break unless continue
 
           if @clean_thread_locals
-            Thread.current.keys.each do |key|
-              Thread.current[key] = nil unless key == :__recursive_key__
-            end
+            ThreadPool.clean_thread_locals
           end
 
           begin

data/lib/rack/handler/puma.rb

@@ -5,48 +5,55 @@ module Rack
   module Handler
     module Puma
       DEFAULT_OPTIONS = {
-        :Host => '0.0.0.0',
-        :Port => 8080,
-        :Threads => '0:16',
         :Verbose => false,
-        :Silent => 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
+
+          if options[:Threads]
+            min, max = options.delete(:Threads).split(':', 2)
+            c.threads min, max
+          end
 
-        events_hander = options[:Silent] ? ::Puma::Events.strings : ::Puma::Events.stdio
-        server   = ::Puma::Server.new(app, events_hander)
-        min, max = options[:Threads].split(':', 2)
+          host = options[:Host]
 
-        log = events_hander.stdout
+          if host && (host[0,1] == '.' || host[0,1] == '/')
+            c.bind "unix://#{host}"
+          else
+            host ||= ::Puma::Configuration::DefaultTCPHost
+            port = options[:Port] || ::Puma::Configuration::DefaultTCPPort
 
-        log.puts "Puma #{::Puma::Const::PUMA_VERSION} starting..."
-        log.puts "* Min threads: #{min}, max threads: #{max}"
-        log.puts "* Environment: #{ENV['RACK_ENV']}"
-        log.puts "* Listening on tcp://#{options[:Host]}:#{options[:Port]}"
+            c.port port, host
+          end
 
-        server.add_tcp_listener options[:Host], options[:Port]
-        server.min_threads = min
-        server.max_threads = max
-        yield server if block_given?
+          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
-          log.puts "* Gracefully stopping, waiting for requests to finish"
-          server.stop(true)
-          log.puts "* Goodbye!"
+          puts "* Gracefully stopping, waiting for requests to finish"
+          launcher.stop
+          puts "* Goodbye!"
         end
-
       end
 
       def self.valid_options