Class: Puma::Client

Relationships & Source Files
Super Chains via Extension / Inclusion / Inheritance
Class Chain: self, Forwardable
Instance Chain: self, `Const`
Inherits:	Object
Defined in:	lib/puma/client.rb

Overview

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 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.

Constant Summary

ALLOWED_TRANSFER_ENCODING =

this tests all values but the last, which must be chunked

# File 'lib/puma/client.rb', line 44
```
%w[compress deflate gzip].freeze
```
CHUNK_SIZE_INVALID =

chunked body validation

# File 'lib/puma/client.rb', line 47
```
/[^\h]/.freeze
```
CHUNK_VALID_ENDING =
# File 'lib/puma/client.rb', line 48
```
"\r\n".freeze
```
CONTENT_LENGTH_VALUE_INVALID =

Content-Length header value validation

# File 'lib/puma/client.rb', line 51
```
/[^\d]/.freeze
```
EmptyBody =

The object used for a request with no body. All requests with no body share this one object since it has no state.

# File 'lib/puma/client.rb', line 57
```
NullIO.new
```
TE_ERR_MSG =
# File 'lib/puma/client.rb', line 53
```
'Invalid Transfer-Encoding'
```

`Const` - Included

CGI_VER, CHUNKED, CHUNK_SIZE, CLOSE, CLOSE_CHUNKED, CODE_NAME, COLON, CONNECTION_CLOSE, CONNECTION_KEEP_ALIVE, CONTENT_LENGTH, CONTENT_LENGTH2, CONTENT_LENGTH_S, CONTINUE, EARLY_HINTS, ERROR_RESPONSE, FAST_TRACK_KA_TIMEOUT, FIRST_DATA_TIMEOUT, GATEWAY_INTERFACE, HALT_COMMAND, HEAD, HIJACK, HIJACK_IO, HIJACK_P, HTTP, HTTPS, HTTPS_KEY, HTTP_10_200, HTTP_11, HTTP_11_100, HTTP_11_200, HTTP_CONNECTION, HTTP_EXPECT, HTTP_HOST, HTTP_INJECTION_REGEX, HTTP_VERSION, HTTP_X_FORWARDED_FOR, HTTP_X_FORWARDED_PROTO, HTTP_X_FORWARDED_SCHEME, HTTP_X_FORWARDED_SSL, KEEP_ALIVE, LINE_END, LOCALHOST, LOCALHOST_ADDR, LOCALHOST_IP, MAX_BODY, MAX_FAST_INLINE, MAX_HEADER, NEWLINE, PATH_INFO, PERSISTENT_TIMEOUT, PORT_443, PORT_80, PUMA_CONFIG, PUMA_PEERCERT, PUMA_SERVER_STRING, PUMA_SOCKET, PUMA_TMP_BASE, PUMA_VERSION, QUERY_STRING, RACK_AFTER_REPLY, RACK_INPUT, RACK_URL_SCHEME, REMOTE_ADDR, REQUEST_METHOD, REQUEST_PATH, REQUEST_URI, RESTART_COMMAND, SERVER_NAME, SERVER_PORT, SERVER_PROTOCOL, SERVER_SOFTWARE, STOP_COMMAND, TRANSFER_ENCODING, TRANSFER_ENCODING2, TRANSFER_ENCODING_CHUNKED, WORKER_CHECK_INTERVAL, WRITE_TIMEOUT

Class Method Summary

.new(io, env = nil) ⇒ Client constructor

Instance Attribute Summary

#body readonly
#env readonly
#hijacked readonly
#io readonly
#peerip rw
#peerip=(value) rw
#ready readonly
#remote_addr_header rw
#tempfile readonly
#timeout_at readonly
#to_io readonly

Instance Method Summary

#call

For the hijack protocol (allows us to just put the Client object into the env).
#close
#eagerly_finish

See additional method definition at line 239.
#finish

IS_JRUBY.
#in_data_phase
#inspect
#jruby_start_try_to_finish
#reset(fast_check = true)
#set_timeout(val)
#try_to_finish
#write_error(status_code)
#decode_chunk(chunk) private
#read_body private
#read_chunked_body private
#set_ready private
#setup_body private
#setup_chunked_body(body) private
#write_chunk(str) private

Constructor Details

.new(io, env = nil) ⇒ `Client`

[ GitHub ]

# File 'lib/puma/client.rb', line 62


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

Instance Attribute Details

#body (readonly)

[ GitHub ]

# File 'lib/puma/client.rb', line 95


attr_reader :env, :to_io, :body, :io, :timeout_at, :ready, :hijacked,
            :tempfile

#env (readonly)

[ GitHub ]

# File 'lib/puma/client.rb', line 95


attr_reader :env, :to_io, :body, :io, :timeout_at, :ready, :hijacked,
            :tempfile

#hijacked (readonly)

[ GitHub ]

# File 'lib/puma/client.rb', line 95


attr_reader :env, :to_io, :body, :io, :timeout_at, :ready, :hijacked,
            :tempfile

#io (readonly)

[ GitHub ]

# File 'lib/puma/client.rb', line 95


attr_reader :env, :to_io, :body, :io, :timeout_at, :ready, :hijacked,
            :tempfile

#peerip (rw)

[ GitHub ]

# File 'lib/puma/client.rb', line 274


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

#peerip=(value) (rw)

[ GitHub ]

# File 'lib/puma/client.rb', line 98


attr_writer :peerip

#ready (readonly)

[ GitHub ]

# File 'lib/puma/client.rb', line 95


attr_reader :env, :to_io, :body, :io, :timeout_at, :ready, :hijacked,
            :tempfile

#remote_addr_header (rw)

[ GitHub ]

# File 'lib/puma/client.rb', line 100


attr_accessor :remote_addr_header

#tempfile (readonly)

[ GitHub ]

# File 'lib/puma/client.rb', line 95


attr_reader :env, :to_io, :body, :io, :timeout_at, :ready, :hijacked,
            :tempfile

#timeout_at (readonly)

[ GitHub ]

# File 'lib/puma/client.rb', line 95


attr_reader :env, :to_io, :body, :io, :timeout_at, :ready, :hijacked,
            :tempfile

#to_io (readonly)

[ GitHub ]

# File 'lib/puma/client.rb', line 95


attr_reader :env, :to_io, :body, :io, :timeout_at, :ready, :hijacked,
            :tempfile

Instance Method Details

#call

For the hijack protocol (allows us to just put the Client object into the env)

[ GitHub ]

# File 'lib/puma/client.rb', line 110


def call
  @hijacked = true
  env[HIJACK_IO] ||= @io
end

#close

[ GitHub ]

# File 'lib/puma/client.rb', line 159


def close
  begin
    @io.close
  rescue IOError
    Thread.current.purge_interrupt_queue if Thread.current.respond_to? :purge_interrupt_queue
  end
end

#decode_chunk(chunk) (private)

[ GitHub ]

# File 'lib/puma/client.rb', line 460


def decode_chunk(chunk)
  if @partial_part_left > 0
    if @partial_part_left <= chunk.size
      if @partial_part_left > 2
        write_chunk(chunk[0..(@partial_part_left-3)]) # skip the \r\n
      end
      chunk = chunk[@partial_part_left..-1]
      @partial_part_left = 0
    else
      write_chunk(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")
      # Puma doesn't process chunk extensions, but should parse if they're
      # present, which is the reason for the semicolon regex
      chunk_hex = line.strip[/\A[^;]+/]
      if chunk_hex =~ CHUNK_SIZE_INVALID
        raise HttpParserError, "Invalid chunk size: '#{chunk_hex}'"
      end
      len = chunk_hex.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
        # proper chunked segment must end with "\r\n"
        if part.end_with? CHUNK_VALID_ENDING
          write_chunk(part[0..-3]) # to skip the ending \r\n
        else
          raise HttpParserError, "Chunk size mismatch"
        end
      when got <= len - 2
        write_chunk(part)
        @partial_part_left = len - part.size
      when got == len - 1 # edge where we get just \r but not \n
        write_chunk(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

#eagerly_finish

See additional method definition at line 239.

[ GitHub ]

# File 'lib/puma/client.rb', line 252


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

#finish

IS_JRUBY

[ GitHub ]

# File 'lib/puma/client.rb', line 259


def finish
  return true if @ready
  until try_to_finish
    IO.select([@to_io], nil, nil)
  end
  true
end

#in_data_phase

[ GitHub ]

# File 'lib/puma/client.rb', line 115


def in_data_phase
  !@read_header
end

#inspect

[ GitHub ]

# File 'lib/puma/client.rb', line 104


def inspect
  "#<Puma::Client:0x#{object_id.to_s(16)} @ready=#{@ready.inspect}>"
end

#jruby_start_try_to_finish

[ GitHub ]

# File 'lib/puma/client.rb', line 204


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

#read_body (private)

[ GitHub ]

# File 'lib/puma/client.rb', line 369


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 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

  remain -= @body.write(chunk)

  if remain <= 0
    @body.rewind
    @buffer = nil
    set_ready
    return true
  end

  @body_remain = remain

  false
end

#read_chunked_body (private)

[ GitHub ]

# File 'lib/puma/client.rb', line 414


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

    if decode_chunk(chunk)
      @env[CONTENT_LENGTH] = @chunked_content_length
      return true
    end
  end
end

#reset(fast_check = true)

[ GitHub ]

# File 'lib/puma/client.rb', line 123


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

#set_ready (private)

[ GitHub ]

# File 'lib/puma/client.rb', line 549


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

#set_timeout(val)

[ GitHub ]

# File 'lib/puma/client.rb', line 119


def set_timeout(val)
  @timeout_at = Time.now + val
end

#setup_body (private)

[ GitHub ]

# File 'lib/puma/client.rb', line 288


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
    te_lwr = te.downcase
    if te.include? ','
      te_ary = te_lwr.split ','
      te_count = te_ary.count CHUNKED
      te_valid = te_ary[0..-2].all? { |e| ALLOWED_TRANSFER_ENCODING.include? e }
      if te_ary.last == CHUNKED && te_count == 1 && te_valid
        @env.delete TRANSFER_ENCODING2
        return setup_chunked_body body
      elsif te_count >= 1
        raise HttpParserError   , "#{TE_ERR_MSG}, multiple chunked: '#{te}'"
      elsif !te_valid
        raise HttpParserError501, "#{TE_ERR_MSG}, unknown value: '#{te}'"
      end
    elsif te_lwr == CHUNKED
      @env.delete TRANSFER_ENCODING2
      return setup_chunked_body body
    elsif ALLOWED_TRANSFER_ENCODING.include? te_lwr
      raise HttpParserError     , "#{TE_ERR_MSG}, single value must be chunked: '#{te}'"
    else
      raise HttpParserError501  , "#{TE_ERR_MSG}, unknown value: '#{te}'"
    end
  end

  @chunked_body = false

  cl = @env[CONTENT_LENGTH]

  if cl
    # cannot contain characters that are not \d
    if cl =~ CONTENT_LENGTH_VALUE_INVALID
      raise HttpParserError, "Invalid Content-Length: #{cl.inspect}"
    end
  else
    @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

#setup_chunked_body(body) (private)

[ GitHub ]

# File 'lib/puma/client.rb', line 439


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

  @chunked_content_length = 0

  if decode_chunk(body)
    @env[CONTENT_LENGTH] = @chunked_content_length
    return true
  end
end

#try_to_finish

[ GitHub ]

# File 'lib/puma/client.rb', line 167


def try_to_finish
  return read_body unless @read_header

  begin
    data = @io.read_nonblock(CHUNK_SIZE)
  rescue IO::WaitReadable
    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

#write_chunk(str) (private)

[ GitHub ]

# File 'lib/puma/client.rb', line 456


def write_chunk(str)
  @chunked_content_length += @body.write(str)
end

#write_error(status_code)

[ GitHub ]

# File 'lib/puma/client.rb', line 267


def write_error(status_code)
  begin
    @io << ERROR_RESPONSE[status_code]
  rescue StandardError
  end
end

Class: Puma::Client

Overview

Constant Summary

Const - Included

Class Method Summary

Instance Attribute Summary

Instance Method Summary

Constructor Details

.new(io, env = nil) ⇒ Client

Instance Attribute Details

#body (readonly)

#env (readonly)

#hijacked (readonly)

#io (readonly)

#peerip (rw)

#peerip=(value) (rw)

#ready (readonly)

#remote_addr_header (rw)

#tempfile (readonly)

#timeout_at (readonly)

#to_io (readonly)

Instance Method Details

#call

#close

#decode_chunk(chunk) (private)

#eagerly_finish

#finish

#in_data_phase

#inspect

#jruby_start_try_to_finish

#read_body (private)

#read_chunked_body (private)

#reset(fast_check = true)

#set_ready (private)

#set_timeout(val)

#setup_body (private)

#setup_chunked_body(body) (private)

#try_to_finish

#write_chunk(str) (private)

#write_error(status_code)

`Const` - Included

.new(io, env = nil) ⇒ `Client`