wendell-puma 2.9.2

data/lib/puma.rb

@@ -0,0 +1,14 @@
+# Standard libraries
+require 'socket'
+require 'tempfile'
+require 'yaml'
+require 'time'
+require 'etc'
+require 'uri'
+require 'stringio'
+
+require 'thread'
+
+# Ruby Puma
+require 'puma/const'
+require 'puma/server'

data/lib/puma/accept_nonblock.rb

@@ -0,0 +1,23 @@
+require 'openssl'
+
+module OpenSSL
+  module SSL
+    class SSLServer
+      unless public_method_defined? :accept_nonblock
+        def accept_nonblock
+          sock = @svr.accept_nonblock
+
+          begin
+            ssl = OpenSSL::SSL::SSLSocket.new(sock, @ctx)
+            ssl.sync_close = true
+            ssl.accept if @start_immediately
+            ssl
+          rescue SSLError => ex
+            sock.close
+            raise ex
+          end
+        end
+      end
+    end
+  end
+end

data/lib/puma/app/status.rb

@@ -0,0 +1,59 @@
+module Puma
+  module App
+    class Status
+      def initialize(cli)
+        @cli = cli
+        @auth_token = nil
+      end
+      OK_STATUS = '{ "status": "ok" }'.freeze
+
+      attr_accessor :auth_token
+
+      def authenticate(env)
+        return true unless @auth_token
+        env['QUERY_STRING'].to_s.split(/&;/).include?("token=#{@auth_token}")
+      end
+
+      def rack_response(status, body, content_type='application/json')
+        headers = {
+          'Content-Type' => content_type,
+          'Content-Length' => body.bytesize.to_s
+        }
+
+        [status, headers, [body]]
+      end
+
+      def call(env)
+        unless authenticate(env)
+          return rack_response(403, 'Invalid auth token', 'text/plain')
+        end
+
+        case env['PATH_INFO']
+        when /\/stop$/
+          @cli.stop
+          return rack_response(200, OK_STATUS)
+
+        when /\/halt$/
+          @cli.halt
+          return rack_response(200, OK_STATUS)
+
+        when /\/restart$/
+          @cli.restart
+          return rack_response(200, OK_STATUS)
+
+        when /\/phased-restart$/
+          if !@cli.phased_restart
+            return rack_response(404, '{ "error": "phased restart not available" }')
+          else
+            return rack_response(200, OK_STATUS)
+          end
+
+        when /\/stats$/
+          return rack_response(200, @cli.stats)
+        else
+          rack_response 404, "Unsupported action", 'text/plain'
+        end
+      end
+    end
+  end
+end

data/lib/puma/binder.rb

@@ -0,0 +1,298 @@
+require 'puma/const'
+
+module Puma
+  class Binder
+    include Puma::Const
+
+    def initialize(events)
+      @events = events
+      @listeners = []
+      @inherited_fds = {}
+      @unix_paths = []
+
+      @proto_env = {
+        "rack.version".freeze => Rack::VERSION,
+        "rack.errors".freeze => events.stderr,
+        "rack.multithread".freeze => true,
+        "rack.multiprocess".freeze => false,
+        "rack.run_once".freeze => false,
+        "SCRIPT_NAME".freeze => ENV['SCRIPT_NAME'] || "",
+
+        # Rack blows up if this is an empty string, and Rack::Lint
+        # blows up if it's nil. So 'text/plain' seems like the most
+        # sensible default value.
+        "CONTENT_TYPE".freeze => "text/plain",
+
+        "QUERY_STRING".freeze => "",
+        SERVER_PROTOCOL => HTTP_11,
+        SERVER_SOFTWARE => PUMA_VERSION,
+        GATEWAY_INTERFACE => CGI_VER
+      }
+
+      @envs = {}
+      @ios = []
+    end
+
+    attr_reader :listeners, :ios
+
+    def env(sock)
+      @envs.fetch(sock, @proto_env)
+    end
+
+    def close
+      @ios.each { |i| i.close }
+      @unix_paths.each { |i| File.unlink i }
+    end
+
+    def import_from_env
+      remove = []
+
+      ENV.each do |k,v|
+        if k =~ /PUMA_INHERIT_\d+/
+          fd, url = v.split(":", 2)
+          @inherited_fds[url] = fd.to_i
+          remove << k
+        end
+        if k =~ /LISTEN_FDS/ && ENV['LISTEN_PID'].to_i == $$
+          v.to_i.times do |num|
+            fd = num + 3
+            sock = TCPServer.for_fd(fd)
+            begin
+              url = "unix://" + Socket.unpack_sockaddr_un(sock.getsockname)
+            rescue ArgumentError
+              port, addr = Socket.unpack_sockaddr_in(sock.getsockname)
+              if addr =~ /\:/
+                addr = "[#{addr}]"
+              end
+              url = "tcp://#{addr}:#{port}"
+            end
+            @inherited_fds[url] = sock
+          end
+          ENV.delete k
+          ENV.delete 'LISTEN_PID'
+        end
+      end
+
+      remove.each do |k|
+        ENV.delete k
+      end
+    end
+
+    def parse(binds, logger)
+      binds.each do |str|
+        uri = URI.parse str
+        case uri.scheme
+        when "tcp"
+          if fd = @inherited_fds.delete(str)
+            logger.log "* Inherited #{str}"
+            io = inherit_tcp_listener uri.host, uri.port, fd
+          else
+            params = Rack::Utils.parse_query uri.query
+
+            opt = params.key?('low_latency')
+            bak = params.fetch('backlog', 1024).to_i
+
+            logger.log "* Listening on #{str}"
+            io = add_tcp_listener uri.host, uri.port, opt, bak
+          end
+
+          @listeners << [str, io]
+        when "unix"
+          path = "#{uri.host}#{uri.path}"
+
+          if fd = @inherited_fds.delete(str)
+            logger.log "* Inherited #{str}"
+            io = inherit_unix_listener path, fd
+          else
+            logger.log "* Listening on #{str}"
+
+            umask = nil
+
+            if uri.query
+              params = Rack::Utils.parse_query uri.query
+              if u = params['umask']
+                # Use Integer() to respect the 0 prefix as octal
+                umask = Integer(u)
+              end
+            end
+
+            io = add_unix_listener path, umask
+          end
+
+          @listeners << [str, io]
+        when "ssl"
+          params = Rack::Utils.parse_query uri.query
+          require 'puma/minissl'
+
+          ctx = MiniSSL::Context.new
+
+          if defined?(JRUBY_VERSION)
+            unless params['keystore']
+              @events.error "Please specify the Java keystore via 'keystore='"
+            end
+
+            ctx.keystore = params['keystore']
+
+            unless params['keystore-pass']
+              @events.error "Please specify the Java keystore password  via 'keystore-pass='"
+            end
+
+            ctx.keystore_pass = params['keystore-pass']
+          else
+            unless params['key']
+              @events.error "Please specify the SSL key via 'key='"
+            end
+
+            ctx.key = params['key']
+
+            unless params['cert']
+              @events.error "Please specify the SSL cert via 'cert='"
+            end
+
+            ctx.cert = params['cert']
+          end
+
+          ctx.verify_mode = MiniSSL::VERIFY_NONE
+
+          if fd = @inherited_fds.delete(str)
+            logger.log "* Inherited #{str}"
+            io = inherited_ssl_listener fd, ctx
+          else
+            logger.log "* Listening on #{str}"
+            io = add_ssl_listener uri.host, uri.port, ctx
+          end
+
+          @listeners << [str, io]
+        else
+          logger.error "Invalid URI: #{str}"
+        end
+      end
+
+      # If we inherited fds but didn't use them (because of a
+      # configuration change), then be sure to close them.
+      @inherited_fds.each do |str, fd|
+        logger.log "* Closing unused inherited connection: #{str}"
+
+        begin
+          if fd.kind_of? TCPServer
+            fd.close
+          else
+            IO.for_fd(fd).close
+          end
+
+        rescue SystemCallError
+        end
+
+        # We have to unlink a unix socket path that's not being used
+        uri = URI.parse str
+        if uri.scheme == "unix"
+          path = "#{uri.host}#{uri.path}"
+          File.unlink path
+        end
+      end
+
+    end
+
+    # Tell the server to listen on host +host+, port +port+.
+    # If +optimize_for_latency+ is true (the default) then clients connecting
+    # will be optimized for latency over throughput.
+    #
+    # +backlog+ indicates how many unaccepted connections the kernel should
+    # allow to accumulate before returning connection refused.
+    #
+    def add_tcp_listener(host, port, optimize_for_latency=true, backlog=1024)
+      host = host[1..-2] if host[0..0] == '['
+      s = TCPServer.new(host, port)
+      if optimize_for_latency
+        s.setsockopt(Socket::IPPROTO_TCP, Socket::TCP_NODELAY, 1)
+      end
+      s.setsockopt(Socket::SOL_SOCKET,Socket::SO_REUSEADDR, true)
+      s.listen backlog
+      @ios << s
+      s
+    end
+
+    def inherit_tcp_listener(host, port, fd)
+      if fd.kind_of? TCPServer
+        s = fd
+      else
+        s = TCPServer.for_fd(fd)
+      end
+
+      @ios << s
+      s
+    end
+
+    def add_ssl_listener(host, port, ctx,
+                         optimize_for_latency=true, backlog=1024)
+      require 'puma/minissl'
+
+      s = TCPServer.new(host, port)
+      if optimize_for_latency
+        s.setsockopt(Socket::IPPROTO_TCP, Socket::TCP_NODELAY, 1)
+      end
+      s.setsockopt(Socket::SOL_SOCKET,Socket::SO_REUSEADDR, true)
+      s.listen backlog
+
+      ssl = MiniSSL::Server.new s, ctx
+      env = @proto_env.dup
+      env[HTTPS_KEY] = HTTPS
+      @envs[ssl] = env
+
+      @ios << ssl
+      s
+    end
+
+    def inherited_ssl_listener(fd, ctx)
+      require 'puma/minissl'
+      s = TCPServer.for_fd(fd)
+      @ios << MiniSSL::Server.new(s, ctx)
+      s
+    end
+
+    # Tell the server to listen on +path+ as a UNIX domain socket.
+    #
+    def add_unix_listener(path, umask=nil)
+      @unix_paths << path
+
+      # Let anyone connect by default
+      umask ||= 0
+
+      begin
+        old_mask = File.umask(umask)
+
+        if File.exist? path
+          begin
+            old = UNIXSocket.new path
+          rescue SystemCallError, IOError
+            File.unlink path
+          else
+            old.close
+            raise "There is already a server bound to: #{path}"
+          end
+        end
+
+        s = UNIXServer.new(path)
+        @ios << s
+      ensure
+        File.umask old_mask
+      end
+
+      s
+    end
+
+    def inherit_unix_listener(path, fd)
+      @unix_paths << path
+
+      if fd.kind_of? TCPServer
+        s = fd
+      else
+        s = UNIXServer.for_fd fd
+      end
+      @ios << s
+
+      s
+    end
+
+  end
+end

data/lib/puma/capistrano.rb

@@ -0,0 +1,86 @@
+Capistrano::Configuration.instance.load do
+
+  # Ensure the tmp/sockets directory is created by the deploy:setup task and
+  # symlinked in by the deploy:update task. This is not handled by Capistrano
+  # v2 but is fixed in v3.
+  shared_children.push('tmp/sockets')
+
+  _cset(:puma_default_hooks)    { true }
+  _cset(:puma_cmd)    { "#{fetch(:bundle_cmd, 'bundle')} exec puma" }
+  _cset(:pumactl_cmd) { "#{fetch(:bundle_cmd, 'bundle')} exec pumactl" }
+  _cset(:puma_env)    { fetch(:rack_env, fetch(:rails_env, 'production')) }
+  _cset(:puma_state)  { "#{shared_path}/sockets/puma.state" }
+  _cset(:puma_socket) { "unix://#{shared_path}/sockets/puma.sock" }
+  _cset(:puma_role)   { :app }
+
+  if fetch(:puma_default_hooks)
+    after 'deploy:stop', 'puma:stop'
+    after 'deploy:start', 'puma:start'
+    after 'deploy:restart', 'puma:restart'
+  end
+
+  namespace :puma do
+    desc 'Start puma'
+    task :start, :roles => lambda { puma_role }, :on_no_matching_servers => :continue do
+      run "cd #{current_path} && #{puma_cmd} #{start_options}", :pty => false
+    end
+
+    desc 'Stop puma'
+    task :stop, :roles => lambda { puma_role }, :on_no_matching_servers => :continue do
+      run "cd #{current_path} && #{pumactl_cmd} -S #{state_path} stop"
+    end
+
+    desc 'Restart puma'
+    task :restart, :roles => lambda { puma_role }, :on_no_matching_servers => :continue do
+      begin
+        run "cd #{current_path} && #{pumactl_cmd} -S #{state_path} restart"
+      rescue Capistrano::CommandError => ex
+        puts "Failed to restart puma: #{ex}\nAssuming not started."
+        start
+      end
+    end
+
+    desc 'Restart puma (phased restart)'
+    task :phased_restart, :roles => lambda { puma_role }, :on_no_matching_servers => :continue do
+      begin
+        run "cd #{current_path} && #{pumactl_cmd} -S #{state_path} phased-restart"
+      rescue Capistrano::CommandError => ex
+        puts "Failed to restart puma: #{ex}\nAssuming not started."
+        start
+      end
+    end
+
+  end
+
+  def start_options
+    if config_file
+      "-q -d -e #{puma_env} -C #{config_file}"
+    else
+      "-q -d -e #{puma_env} -b '#{puma_socket}' -S #{state_path} --control 'unix://#{shared_path}/sockets/pumactl.sock'"
+    end
+  end
+
+  def config_file
+    @_config_file ||= begin
+      file = fetch(:puma_config_file, nil)
+      file = "./config/puma/#{puma_env}.rb" if !file && File.exists?("./config/puma/#{puma_env}.rb")
+      file
+    end
+  end
+
+  def puma_env
+    fetch(:rack_env, fetch(:rails_env, 'production'))
+  end
+
+  def state_path
+    (config_file ? configuration.options[:state] : nil) || puma_state
+  end
+
+  def configuration
+    require 'puma/configuration'
+
+    config = Puma::Configuration.new(:config_file => config_file)
+    config.load
+    config
+  end
+end