Module: TestPuma::PumaSocket

# File 'test/helpers/test_puma/puma_socket.rb', line 75

def before_setup
  @ios_to_close ||= []
  @bind_port = nil
  @bind_path = nil
  @control_port = nil
  @control_path = nil
  super
end

# File 'test/helpers/test_puma/puma_socket.rb', line 292

def new_ctx(&blk)
  ctx = OpenSSL::SSL::SSLContext.new
  if blk
    yield ctx
  else
    ctx.verify_mode = OpenSSL::SSL::VERIFY_NONE
  end
  ctx
end

# File 'test/helpers/test_puma/puma_socket.rb', line 306

def new_socket(host: nil, port: nil, path: nil, ctx: nil, session: nil)
  port  ||= @bind_port
  path  ||= @bind_path
  ip ||= (host || HOST.ip).gsub RE_HOST_TO_IP, ''  # in case a URI style IPv6 is passed

  skt =
    if path && !port && !ctx
      UNIXSocket.new path.sub(/\A@/, "\0") # sub is for abstract
    elsif port # && !path
      tcp = TCPSocket.new ip, port.to_i
      tcp.setsockopt(Socket::IPPROTO_TCP, Socket::TCP_NODELAY, 1) if SET_TCP_NODELAY
      if ctx
        ::OpenSSL::SSL::SSLSocket.new tcp, ctx
      else
        tcp
      end
    else
      raise 'port or path must be set!'
    end

  skt.define_singleton_method :read_response, READ_RESPONSE
  skt.define_singleton_method :read_body, READ_BODY
  skt.define_singleton_method :<<, REQ_WRITE
  @ios_to_close << skt
  if ctx
    @ios_to_close << tcp
    skt.session = session if session
    skt.sync_close = true
    skt.connect
  end
  skt
end

# File 'test/helpers/test_puma/puma_socket.rb', line 368

def read_response_array(skts, resp_count: nil, body_only: nil)
  results = Array.new skts.length
  Thread.new do
    until skts.compact.empty?
      skts.each_with_index do |skt, idx|
        next if skt.nil?
        begin
          next unless skt.wait_readable 0.000_5
          if resp_count
            resp = skt.read_response.dup
            cntr = 0
            until resp.split(RESP_SPLIT).length == resp_count + 1 || cntr > 20
              cntr += 1
              Thread.pass
              if skt.wait_readable 0.001
                begin
                  resp << skt.read_response
                rescue EOFError
                  break
                end
              end
            end
            results[idx] = resp
          else
            results[idx] = body_only ? skt.read_body : skt.read_response
          end
        rescue StandardError => e
          results[idx] = e.class.to_s
        end
        begin
          skt.close unless skt.closed? # skt.close may return Errno::EBADF
        rescue StandardError => e
          results[idx] ||= e.class.to_s
        end
        skts[idx] = nil
      end
    end
  end.join 15
  results
end

# File 'test/helpers/test_puma/puma_socket.rb', line 179

def send_http(req = GET_11, host: nil, port: nil, path: nil, ctx: nil, session: nil)
  skt = new_socket host: host, port: port, path: path, ctx: ctx, session: session
  skt.syswrite req
  skt
end

# File 'test/helpers/test_puma/puma_socket.rb', line 344

def send_http_array(req = GET_11, len, dly: 0.000_1, max_retries: 5)
  Array.new(len) {
    retries = 0
    begin
      skt = send_http req
      sleep dly
      skt
    rescue Errno::ECONNREFUSED
      retries += 1
      if retries < max_retries
        retry
      else
        flunk 'Generate requests failed from Errno::ECONNREFUSED'
      end
    end
  }
end

# File 'test/helpers/test_puma/puma_socket.rb', line 141

def send_http_read_all(req = GET_11, host: nil, port: nil, path: nil, ctx: nil,
    session: nil, len: nil, timeout: nil)
  skt = send_http req, host: host, port: port, path: path, ctx: ctx, session: session
  read = String.new # rubocop: disable Performance/UnfreezeString
  counter = 0
  prev_size = 0
  loop do
    raise(Timeout::Error, 'Client Read Timeout') if counter > 5
    if skt.wait_readable 1
      read << skt.sysread(RESP_READ_LEN)
    end
    ttl_read = read.bytesize
    return read if prev_size == ttl_read && !ttl_read.zero?
    prev_size = ttl_read
    counter += 1
  end
rescue EOFError
  return read
rescue => e
  raise e
end

# File 'test/helpers/test_puma/puma_socket.rb', line 130

def send_http_read_resp_body(req = GET_11, host: nil, port: nil, path: nil, ctx: nil,
    session: nil, len: nil, timeout: nil)
  skt = send_http req, host: host, port: port, path: path, ctx: ctx, session: session
  skt.read_body timeout: timeout, len: len
end

# File 'test/helpers/test_puma/puma_socket.rb', line 118

def send_http_read_resp_headers(req = GET_11, host: nil, port: nil, path: nil, ctx: nil,
    session: nil, len: nil, timeout: nil)
  skt = send_http req, host: host, port: port, path: path, ctx: ctx, session: session
  resp = skt.read_response timeout: timeout, len: len
  resp.split(RESP_SPLIT, 2).first.split "\r\n"
end

# File 'test/helpers/test_puma/puma_socket.rb', line 168

def send_http_read_response(req = GET_11, host: nil, port: nil, path: nil, ctx: nil,
    session: nil, len: nil, timeout: nil)
  skt = send_http req, host: host, port: port, path: path, ctx: ctx, session: session
  skt.read_response timeout: timeout, len: len
end

# File 'test/helpers/test_puma/puma_socket.rb', line 191

def skt_closed_by_server(socket)
  skt = socket.to_io
  return false unless skt.kind_of?(TCPSocket)

  begin
    tcp_info = skt.getsockopt(Socket::IPPROTO_TCP, Socket::TCP_INFO)
  rescue IOError, SystemCallError
    false
  else
    state = tcp_info.unpack('C')[0]
    # TIME_WAIT: 6, CLOSE: 7, CLOSE_WAIT: 8, LAST_ACK: 9, CLOSING: 11
    (state >= 6 && state <= 9) || state == 11
  end
end