wendell-puma 2.9.2

data/lib/puma/single.rb

@@ -0,0 +1,102 @@
+require 'puma/runner'
+
+module Puma
+  class Single < Runner
+    def stats
+      b = @server.backlog
+      r = @server.running
+      %Q!{ "backlog": #{b}, "running": #{r} }!
+    end
+
+    def restart
+      @server.begin_restart
+    end
+
+    def stop
+      @server.stop false
+    end
+
+    def halt
+      @server.halt
+    end
+
+    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 @cli.jruby?
+    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
+        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, exitting"
+            exit 1
+          end
+
+          pid = @cli.jruby_daemon_start
+          sleep
+        end
+      else
+        load_and_bind
+
+        if daemon?
+          log "* Daemonizing..."
+          Process.daemon(true)
+        end
+      end
+
+      @cli.write_state
+
+      start_control
+
+      @server = server = start_server
+
+      unless @options[:daemon]
+        log "Use Ctrl-C to stop"
+      end
+
+      redirect_io
+
+      @cli.events.fire_on_booted!
+
+      begin
+        server.run.join
+      rescue Interrupt
+        # Swallow it
+      end
+    end
+  end
+end

data/lib/puma/tcp_logger.rb

@@ -0,0 +1,32 @@
+module Puma
+  class TCPLogger
+    def initialize(logger, app, quiet=false)
+      @logger = logger
+      @app = app
+      @quiet = quiet
+    end
+
+    FORMAT = "%s - %s"
+
+    def log(who, str)
+      now = Time.now.strftime("%d/%b/%Y %H:%M:%S")
+
+      @logger.puts "#{now} - #{who} - #{str}"
+    end
+
+    def call(env, socket)
+      who = env[Const::REMOTE_ADDR]
+      log who, "connected" unless @quiet
+
+      env['log'] = lambda { |str| log(who, str) }
+
+      begin
+        @app.call env, socket
+      rescue Object => e
+        log who, "exception: #{e.message} (#{e.class})"
+      else
+        log who, "disconnected" unless @quiet
+      end
+    end
+  end
+end

data/lib/puma/thread_pool.rb

@@ -0,0 +1,185 @@
+require 'thread'
+
+module Puma
+  # A simple thread pool management object.
+  #
+  class ThreadPool
+
+    # Maintain a minimum of +min+ and maximum of +max+ threads
+    # in the pool.
+    #
+    # The block passed is the work that will be performed in each
+    # thread.
+    #
+    def initialize(min, max, *extra, &block)
+      @cond = ConditionVariable.new
+      @mutex = Mutex.new
+
+      @todo = []
+
+      @spawned = 0
+      @waiting = 0
+
+      @min = Integer(min)
+      @max = Integer(max)
+      @block = block
+      @extra = extra
+
+      @shutdown = false
+
+      @trim_requested = 0
+
+      @workers = []
+
+      @auto_trim = nil
+
+      @mutex.synchronize do
+        @min.times { spawn_thread }
+      end
+    end
+
+    attr_reader :spawned, :trim_requested
+
+    # How many objects have yet to be processed by the pool?
+    #
+    def backlog
+      @mutex.synchronize { @todo.size }
+    end
+
+    # :nodoc:
+    #
+    # Must be called with @mutex held!
+    #
+    def spawn_thread
+      @spawned += 1
+
+      th = Thread.new do
+        todo  = @todo
+        block = @block
+        mutex = @mutex
+        cond  = @cond
+
+        extra = @extra.map { |i| i.new }
+
+        while true
+          work = nil
+
+          continue = true
+
+          mutex.synchronize do
+            while todo.empty?
+              if @trim_requested > 0
+                @trim_requested -= 1
+                continue = false
+                break
+              end
+
+              if @shutdown
+                continue = false
+                break
+              end
+
+              @waiting += 1
+              cond.wait mutex
+              @waiting -= 1
+            end
+
+            work = todo.shift if continue
+          end
+
+          break unless continue
+
+          block.call(work, *extra)
+        end
+
+        mutex.synchronize do
+          @spawned -= 1
+          @workers.delete th
+        end
+      end
+
+      @workers << th
+
+      th
+    end
+
+    private :spawn_thread
+
+    # Add +work+ to the todo list for a Thread to pickup and process.
+    def <<(work)
+      @mutex.synchronize do
+        if @shutdown
+          raise "Unable to add work while shutting down"
+        end
+
+        @todo << work
+
+        if @waiting < @todo.size and @spawned < @max
+          spawn_thread
+        end
+
+        @cond.signal
+      end
+    end
+
+    # If too many threads are in the pool, tell one to finish 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
+          @trim_requested += 1
+          @cond.signal
+        end
+      end
+    end
+
+    class AutoTrim
+      def initialize(pool, timeout)
+        @pool = pool
+        @timeout = timeout
+        @running = false
+      end
+
+      def start!
+        @running = true
+
+        @thread = Thread.new do
+          while @running
+            @pool.trim
+            sleep @timeout
+          end
+        end
+      end
+
+      def stop
+        @running = false
+        @thread.wakeup
+      end
+    end
+
+    def auto_trim!(timeout=5)
+      @auto_trim = AutoTrim.new(self, timeout)
+      @auto_trim.start!
+    end
+
+    # Tell all threads in the pool to exit and wait for them to finish.
+    #
+    def shutdown
+      @mutex.synchronize do
+        @shutdown = true
+        @cond.broadcast
+
+        @auto_trim.stop if @auto_trim
+      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?
+
+      @spawned = 0
+      @workers = []
+    end
+  end
+end

data/lib/puma/util.rb

@@ -0,0 +1,9 @@
+module Puma
+  module Util
+    module_function
+
+    def pipe
+      IO.pipe
+    end
+  end
+end

data/lib/rack/handler/puma.rb

@@ -0,0 +1,66 @@
+require 'rack/handler'
+require 'puma'
+
+module Rack
+  module Handler
+    module Puma
+      DEFAULT_OPTIONS = {
+        :Host => '0.0.0.0',
+        :Port => 8080,
+        :Threads => '0:16',
+        :Verbose => false
+      }
+
+      def self.run(app, options = {})
+        options  = DEFAULT_OPTIONS.merge(options)
+
+        if options[:Verbose]
+          app = Rack::CommonLogger.new(app, STDOUT)
+        end
+
+        if options[:environment]
+          ENV['RACK_ENV'] = options[:environment].to_s
+        end
+
+        server   = ::Puma::Server.new(app)
+        min, max = options[:Threads].split(':', 2)
+
+        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]}"
+
+        server.add_tcp_listener options[:Host], options[:Port]
+        server.min_threads = min
+        server.max_threads = max
+        yield server if block_given?
+
+        begin
+          server.run.join
+        rescue Interrupt
+          puts "* Gracefully stopping, waiting for requests to finish"
+          server.stop(true)
+          puts "* Goodbye!"
+        end
+
+      end
+
+      def self.valid_options
+        {
+          "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"
+        }
+      end
+    end
+
+    register :puma, Puma
+  end
+end
+
+# This is to trick newrelic into enabling the agent automatically.
+module Mongrel
+  class HttpServer
+  end
+end

data/test/test_app_status.rb

@@ -0,0 +1,92 @@
+require 'test/unit'
+require 'rack'
+require 'puma/app/status'
+
+class TestAppStatus < Test::Unit::TestCase
+  class FakeServer
+    def initialize
+      @status = :running
+      @backlog = 0
+      @running = 0
+    end
+
+    attr_reader :status
+    attr_accessor :backlog, :running
+
+    def stop
+      @status = :stop
+    end
+
+    def halt
+      @status = :halt
+    end
+
+    def stats
+      "{}"
+    end
+  end
+
+  def setup
+    @server = FakeServer.new
+    @app = Puma::App::Status.new(@server)
+    @app.auth_token = nil
+  end
+
+  def lint(uri)
+    app = Rack::Lint.new @app
+    mock_env = Rack::MockRequest.env_for uri
+    app.call mock_env
+  end
+
+  def test_bad_token
+    @app.auth_token = "abcdef"
+
+    status, _, _ = lint('/whatever')
+
+    assert_equal 403, status
+  end
+
+  def test_good_token
+    @app.auth_token = "abcdef"
+
+    status, _, _ = lint('/whatever?token=abcdef')
+
+    assert_equal 404, status
+  end
+
+  def test_unsupported
+    status, _, _ = lint('/not-real')
+
+    assert_equal 404, status
+  end
+
+  def test_stop
+    status, _ , app = lint('/stop')
+
+    assert_equal :stop, @server.status
+    assert_equal 200, status
+    assert_equal ['{ "status": "ok" }'], app.enum_for.to_a
+  end
+
+  def test_halt
+    status, _ , app = lint('/halt')
+
+    assert_equal :halt, @server.status
+    assert_equal 200, status
+    assert_equal ['{ "status": "ok" }'], app.enum_for.to_a
+  end
+
+  def test_stats
+    @server.backlog = 1
+    @server.running = 9
+    status, _ , app = lint('/stats')
+
+    assert_equal 200, status
+    assert_equal ['{}'], app.enum_for.to_a
+  end
+
+  def test_alternate_location
+    status, _ , _ = lint('__alternatE_location_/stats')
+    assert_equal 200, status
+  end
+end