gitlab-puma 4.3.1.gitlab.2

data/lib/puma/cli.rb

@@ -0,0 +1,239 @@
+# frozen_string_literal: true
+
+require 'optparse'
+require 'uri'
+
+require 'puma'
+require 'puma/configuration'
+require 'puma/launcher'
+require 'puma/const'
+require 'puma/events'
+
+module Puma
+  class << self
+    # The CLI exports its Puma::Configuration object here to allow
+    # apps to pick it up. An app needs to use it conditionally though
+    # since it is not set if the app is launched via another
+    # mechanism than the CLI class.
+    attr_accessor :cli_config
+  end
+
+  # Handles invoke a Puma::Server in a command line style.
+  #
+  class CLI
+    KEYS_NOT_TO_PERSIST_IN_STATE = Launcher::KEYS_NOT_TO_PERSIST_IN_STATE
+
+    # Create a new CLI object using +argv+ as the command line
+    # arguments.
+    #
+    # +stdout+ and +stderr+ can be set to IO-like objects which
+    # this object will report status on.
+    #
+    def initialize(argv, events=Events.stdio)
+      @debug = false
+      @argv = argv.dup
+
+      @events = events
+
+      @conf = nil
+
+      @stdout = nil
+      @stderr = nil
+      @append = false
+
+      @control_url = nil
+      @control_options = {}
+
+      setup_options
+
+      begin
+        @parser.parse! @argv
+
+        if file = @argv.shift
+          @conf.configure do |user_config, file_config|
+            file_config.rackup file
+          end
+        end
+      rescue UnsupportedOption
+        exit 1
+      end
+
+      @conf.configure do |user_config, file_config|
+        if @stdout || @stderr
+          user_config.stdout_redirect @stdout, @stderr, @append
+        end
+
+        if @control_url
+          user_config.activate_control_app @control_url, @control_options
+        end
+      end
+
+      @launcher = Puma::Launcher.new(@conf, :events => @events, :argv => argv)
+    end
+
+    attr_reader :launcher
+
+    # Parse the options, load the rackup, start the server and wait
+    # for it to finish.
+    #
+    def run
+      @launcher.run
+    end
+
+  private
+    def unsupported(str)
+      @events.error(str)
+      raise UnsupportedOption
+    end
+
+    def configure_control_url(command_line_arg)
+      if command_line_arg
+        @control_url = command_line_arg
+      elsif Puma.jruby?
+        unsupported "No default url available on JRuby"
+      end
+    end
+
+    # Build the OptionParser object to handle the available options.
+    #
+
+    def setup_options
+      @conf = Configuration.new do |user_config, file_config|
+        @parser = OptionParser.new do |o|
+          o.on "-b", "--bind URI", "URI to bind to (tcp://, unix://, ssl://)" do |arg|
+            user_config.bind arg
+          end
+
+          o.on "-C", "--config PATH", "Load PATH as a config file" do |arg|
+            file_config.load arg
+          end
+
+          o.on "--control-url URL", "The bind url to use for the control server. Use 'auto' to use temp unix server" do |arg|
+            configure_control_url(arg)
+          end
+
+          # alias --control-url for backwards-compatibility
+          o.on "--control URL", "DEPRECATED alias for --control-url" do |arg|
+            configure_control_url(arg)
+          end
+
+          o.on "--control-token TOKEN",
+            "The token to use as authentication for the control server" do |arg|
+            @control_options[:auth_token] = arg
+          end
+
+          o.on "-d", "--daemon", "Daemonize the server into the background" do
+            user_config.daemonize
+            user_config.quiet
+          end
+
+          o.on "--debug", "Log lowlevel debugging information" do
+            user_config.debug
+          end
+
+          o.on "--dir DIR", "Change to DIR before starting" do |d|
+            user_config.directory d
+          end
+
+          o.on "-e", "--environment ENVIRONMENT",
+            "The environment to run the Rack app on (default development)" do |arg|
+            user_config.environment arg
+          end
+
+          o.on "-I", "--include PATH", "Specify $LOAD_PATH directories" do |arg|
+            $LOAD_PATH.unshift(*arg.split(':'))
+          end
+
+          o.on "-p", "--port PORT", "Define the TCP port to bind to",
+            "Use -b for more advanced options" do |arg|
+            user_config.bind "tcp://#{Configuration::DefaultTCPHost}:#{arg}"
+          end
+
+          o.on "--pidfile PATH", "Use PATH as a pidfile" do |arg|
+            user_config.pidfile arg
+          end
+
+          o.on "--preload", "Preload the app. Cluster mode only" do
+            user_config.preload_app!
+          end
+
+          o.on "--prune-bundler", "Prune out the bundler env if possible" do
+            user_config.prune_bundler
+          end
+
+          o.on "--extra-runtime-dependencies GEM1,GEM2", "Defines any extra needed gems when using --prune-bundler" do |arg|
+            user_config.extra_runtime_dependencies arg.split(',')
+          end
+
+          o.on "-q", "--quiet", "Do not log requests internally (default true)" do
+            user_config.quiet
+          end
+
+          o.on "-v", "--log-requests", "Log requests as they occur" do
+            user_config.log_requests
+          end
+
+          o.on "-R", "--restart-cmd CMD",
+            "The puma command to run during a hot restart",
+            "Default: inferred" do |cmd|
+            user_config.restart_command cmd
+          end
+
+          o.on "-S", "--state PATH", "Where to store the state details" do |arg|
+            user_config.state_path arg
+          end
+
+          o.on '-t', '--threads INT', "min:max threads to use (default 0:16)" do |arg|
+            min, max = arg.split(":")
+            if max
+              user_config.threads min, max
+            else
+              user_config.threads min, min
+            end
+          end
+
+          o.on "--tcp-mode", "Run the app in raw TCP mode instead of HTTP mode" do
+            user_config.tcp_mode!
+          end
+
+          o.on "--early-hints", "Enable early hints support" do
+            user_config.early_hints
+          end
+
+          o.on "-V", "--version", "Print the version information" do
+            puts "puma version #{Puma::Const::VERSION}"
+            exit 0
+          end
+
+          o.on "-w", "--workers COUNT",
+            "Activate cluster mode: How many worker processes to create" do |arg|
+            user_config.workers arg
+          end
+
+          o.on "--tag NAME", "Additional text to display in process listing" do |arg|
+            user_config.tag arg
+          end
+
+          o.on "--redirect-stdout FILE", "Redirect STDOUT to a specific file" do |arg|
+            @stdout = arg.to_s
+          end
+
+          o.on "--redirect-stderr FILE", "Redirect STDERR to a specific file" do |arg|
+            @stderr = arg.to_s
+          end
+
+          o.on "--[no-]redirect-append", "Append to redirected files" do |val|
+            @append = val
+          end
+
+          o.banner = "puma <options> <rackup file>"
+
+          o.on_tail "-h", "--help", "Show help" do
+            $stdout.puts o
+            exit 0
+          end
+        end
+      end
+    end
+  end
+end

data/lib/puma/client.rb

@@ -0,0 +1,494 @@
+# frozen_string_literal: true
+
+class IO
+  # We need to use this for a jruby work around on both 1.8 and 1.9.
+  # So this either creates the constant (on 1.8), or harmlessly
+  # reopens it (on 1.9).
+  module WaitReadable
+  end
+end
+
+require 'puma/detect'
+require 'tempfile'
+require 'forwardable'
+
+if Puma::IS_JRUBY
+  # We have to work around some OpenSSL buffer/io-readiness bugs
+  # so we pull it in regardless of if the user is binding
+  # to an SSL socket
+  require 'openssl'
+end
+
+module Puma
+
+  class ConnectionError < RuntimeError; end
+
+  # An instance of this class represents a unique request from a client.
+  # For example, this could be a web request from a browser or from CURL.
+  #
+  # An instance of `Puma::Client` can be used as if it were an IO object
+  # by the reactor. The reactor is expected to call `#to_io`
+  # on any non-IO objects it polls. For example, nio4r internally calls
+  # `IO::try_convert` (which may call `#to_io`) when a new socket is
+  # registered.
+  #
+  # Instances of this class are responsible for knowing if
+  # the header and body are fully buffered via the `try_to_finish` method.
+  # They can be used to "time out" a response via the `timeout_at` reader.
+  class Client
+    # The object used for a request with no body. All requests with
+    # no body share this one object since it has no state.
+    EmptyBody = NullIO.new
+
+    include Puma::Const
+    extend Forwardable
+
+    def initialize(io, env=nil)
+      @io = io
+      @to_io = io.to_io
+      @proto_env = env
+      if !env
+        @env = nil
+      else
+        @env = env.dup
+      end
+
+      @parser = HttpParser.new
+      @parsed_bytes = 0
+      @read_header = true
+      @ready = false
+
+      @body = nil
+      @body_read_start = nil
+      @buffer = nil
+      @tempfile = nil
+
+      @timeout_at = nil
+
+      @requests_served = 0
+      @hijacked = false
+
+      @peerip = nil
+      @remote_addr_header = nil
+
+      @body_remain = 0
+
+      @in_last_chunk = false
+    end
+
+    attr_reader :env, :to_io, :body, :io, :timeout_at, :ready, :hijacked,
+                :tempfile
+
+    attr_writer :peerip
+
+    attr_accessor :remote_addr_header
+
+    def_delegators :@io, :closed?
+
+    def inspect
+      "#<Puma::Client:0x#{object_id.to_s(16)} @ready=#{@ready.inspect}>"
+    end
+
+    # For the hijack protocol (allows us to just put the Client object
+    # into the env)
+    def call
+      @hijacked = true
+      env[HIJACK_IO] ||= @io
+    end
+
+    def in_data_phase
+      !@read_header
+    end
+
+    def set_timeout(val)
+      @timeout_at = Time.now + val
+    end
+
+    def reset(fast_check=true)
+      @parser.reset
+      @read_header = true
+      @env = @proto_env.dup
+      @body = nil
+      @tempfile = nil
+      @parsed_bytes = 0
+      @ready = false
+      @body_remain = 0
+      @peerip = nil
+      @in_last_chunk = false
+
+      if @buffer
+        @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
+
+        return false
+      else
+        begin
+          if fast_check &&
+              IO.select([@to_io], nil, nil, FAST_TRACK_KA_TIMEOUT)
+            return try_to_finish
+          end
+        rescue IOError
+          # swallow it
+        end
+
+      end
+    end
+
+    def close
+      begin
+        @io.close
+      rescue IOError
+        Thread.current.purge_interrupt_queue if Thread.current.respond_to? :purge_interrupt_queue
+      end
+    end
+
+    def try_to_finish
+      return read_body unless @read_header
+
+      begin
+        data = @io.read_nonblock(CHUNK_SIZE)
+      rescue Errno::EAGAIN
+        return false
+      rescue SystemCallError, IOError, EOFError
+        raise ConnectionError, "Connection error detected during read"
+      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
+
+    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
+    end # IS_JRUBY
+
+    def finish
+      return true if @ready
+      until try_to_finish
+        IO.select([@to_io], nil, nil)
+      end
+      true
+    end
+
+    def write_error(status_code)
+      begin
+        @io << ERROR_RESPONSE[status_code]
+      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
+
+    private
+
+    def setup_body
+      @body_read_start = Process.clock_gettime(Process::CLOCK_MONOTONIC, :millisecond)
+
+      if @env[HTTP_EXPECT] == CONTINUE
+        # TODO allow a hook here to check the headers before
+        # going forward
+        @io << HTTP_11_100
+        @io.flush
+      end
+
+      @read_header = false
+
+      body = @parser.body
+
+      te = @env[TRANSFER_ENCODING2]
+
+      if te && CHUNKED.casecmp(te) == 0
+        return setup_chunked_body(body)
+      end
+
+      @chunked_body = false
+
+      cl = @env[CONTENT_LENGTH]
+
+      unless cl
+        @buffer = body.empty? ? nil : body
+        @body = EmptyBody
+        set_ready
+        return true
+      end
+
+      remain = cl.to_i - body.bytesize
+
+      if remain <= 0
+        @body = StringIO.new(body)
+        @buffer = nil
+        set_ready
+        return true
+      end
+
+      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.
+        @body = StringIO.new body[0,0]
+      end
+
+      @body.write body
+
+      @body_remain = remain
+
+      return false
+    end
+
+    def read_body
+      if @chunked_body
+        return read_chunked_body
+      end
+
+      # Read an odd sized chunk so we can read even sized ones
+      # after this
+      remain = @body_remain
+
+      if remain > CHUNK_SIZE
+        want = CHUNK_SIZE
+      else
+        want = remain
+      end
+
+      begin
+        chunk = @io.read_nonblock(want)
+      rescue Errno::EAGAIN
+        return false
+      rescue SystemCallError, IOError
+        raise ConnectionError, "Connection error detected during read"
+      end
+
+      # No chunk means a closed socket
+      unless chunk
+        @body.close
+        @buffer = nil
+        set_ready
+        raise EOFError
+      end
+
+      remain -= @body.write(chunk)
+
+      if remain <= 0
+        @body.rewind
+        @buffer = nil
+        set_ready
+        return true
+      end
+
+      @body_remain = remain
+
+      false
+    end
+
+    def read_chunked_body
+      while true
+        begin
+          chunk = @io.read_nonblock(4096)
+        rescue IO::WaitReadable
+          return false
+        rescue SystemCallError, IOError
+          raise ConnectionError, "Connection error detected during read"
+        end
+
+        # No chunk means a closed socket
+        unless chunk
+          @body.close
+          @buffer = nil
+          set_ready
+          raise EOFError
+        end
+
+        return true if decode_chunk(chunk)
+      end
+    end
+
+    def setup_chunked_body(body)
+      @chunked_body = true
+      @partial_part_left = 0
+      @prev_chunk = ""
+
+      @body = Tempfile.new(Const::PUMA_TMP_BASE)
+      @body.binmode
+      @tempfile = @body
+
+      return decode_chunk(body)
+    end
+
+    def decode_chunk(chunk)
+      if @partial_part_left > 0
+        if @partial_part_left <= chunk.size
+          if @partial_part_left > 2
+            @body << chunk[0..(@partial_part_left-3)] # skip the \r\n
+          end
+          chunk = chunk[@partial_part_left..-1]
+          @partial_part_left = 0
+        else
+          @body << chunk if @partial_part_left > 2 # don't include the last \r\n
+          @partial_part_left -= chunk.size
+          return false
+        end
+      end
+
+      if @prev_chunk.empty?
+        io = StringIO.new(chunk)
+      else
+        io = StringIO.new(@prev_chunk+chunk)
+        @prev_chunk = ""
+      end
+
+      while !io.eof?
+        line = io.gets
+        if line.end_with?("\r\n")
+          len = line.strip.to_i(16)
+          if len == 0
+            @in_last_chunk = true
+            @body.rewind
+            rest = io.read
+            last_crlf_size = "\r\n".bytesize
+            if rest.bytesize < last_crlf_size
+              @buffer = nil
+              @partial_part_left = last_crlf_size - rest.bytesize
+              return false
+            else
+              @buffer = rest[last_crlf_size..-1]
+              @buffer = nil if @buffer.empty?
+              set_ready
+              return true
+            end
+          end
+
+          len += 2
+
+          part = io.read(len)
+
+          unless part
+            @partial_part_left = len
+            next
+          end
+
+          got = part.size
+
+          case
+          when got == len
+            @body << part[0..-3] # to skip the ending \r\n
+          when got <= len - 2
+            @body << part
+            @partial_part_left = len - part.size
+          when got == len - 1 # edge where we get just \r but not \n
+            @body << part[0..-2]
+            @partial_part_left = len - part.size
+          end
+        else
+          @prev_chunk = line
+          return false
+        end
+      end
+
+      if @in_last_chunk
+        set_ready
+        true
+      else
+        false
+      end
+    end
+
+    def set_ready
+      if @body_read_start
+        @env['puma.request_body_wait'] = Process.clock_gettime(Process::CLOCK_MONOTONIC, :millisecond) - @body_read_start
+      end
+      @requests_served += 1
+      @ready = true
+    end
+  end
+end