polyphony-http 0.24

data/lib/polyphony/http/client/agent.rb

@@ -0,0 +1,131 @@
+# frozen_string_literal: true
+
+export_default :Agent
+
+require 'uri'
+
+ResourcePool = import '../../core/resource_pool'
+SiteConnectionManager = import './site_connection_manager'
+
+# Implements an HTTP agent
+class Agent
+  def self.get(*args, &block)
+    default.get(*args, &block)
+  end
+
+  def self.post(*args, &block)
+    default.post(*args, &block)
+  end
+
+  def self.default
+    @default ||= new
+  end
+
+  def initialize
+    @pools = Hash.new do |h, k|
+      h[k] = SiteConnectionManager.new(k)
+    end
+  end
+
+  OPTS_DEFAULT = {}.freeze
+
+  def get(url, opts = OPTS_DEFAULT, &block)
+    request(url, opts.merge(method: :GET), &block)
+  end
+
+  def post(url, opts = OPTS_DEFAULT, &block)
+    request(url, opts.merge(method: :POST), &block)
+  end
+
+  def request(url, opts = OPTS_DEFAULT, &block)
+    ctx = request_ctx(url, opts)
+
+    response = do_request(ctx, &block)
+    case response.status_code
+    when 301, 302
+      redirect(response.headers['Location'], ctx, opts, &block)
+    when 200, 204
+      response
+    else
+      raise "Error received from server: #{response.status_code}"
+    end
+  end
+
+  def redirect(url, ctx, opts, &block)
+    url = redirect_url(url, ctx)
+    request(url, opts, &block)
+  end
+
+  def redirect_url(url, ctx)
+    case url
+    when /^http(?:s)?\:\/\//
+      url
+    when /^\/\/(.+)$/
+      ctx[:uri].scheme + url
+    when /^\//
+      format_uri(url, ctx)
+    else
+      ctx[:uri] + url
+    end
+  end
+
+  def format_uri(url, ctx)
+    format(
+      '%<scheme>s://%<host>s%<url>s',
+      scheme: ctx[:uri].scheme,
+      host:   ctx[:uri].host,
+      url:    url
+    )
+  end
+
+  def request_ctx(url, opts)
+    {
+      method: opts[:method] || :GET,
+      uri:    url_to_uri(url, opts),
+      opts:   opts,
+      retry:  0
+    }
+  end
+
+  def url_to_uri(url, opts)
+    uri = URI(url)
+    if opts[:query]
+      query = opts[:query].map { |k, v| "#{k}=#{v}" }.join('&')
+      if uri.query
+        v.query = "#{uri.query}&#{query}"
+      else
+        uri.query = query
+      end
+    end
+    uri
+  end
+
+  def do_request(ctx, &block)
+    key = uri_key(ctx[:uri])
+
+    @pools[key].acquire do |adapter|
+      send_request_and_check_response(adapter, ctx, &block)
+    end
+  rescue Exception => e
+    p e
+    puts e.backtrace.join("\n")
+  end
+
+  def send_request_and_check_response(adapter, ctx, &block)
+    response = adapter.request(ctx)
+    case response.status_code
+    when 200, 204
+      if block
+        block.(response)
+      else
+        # read body
+        response.body
+      end
+    end
+    response
+  end
+
+  def uri_key(uri)
+    { scheme: uri.scheme, host: uri.host, port: uri.port }
+  end
+end

data/lib/polyphony/http/client/http1.rb

@@ -0,0 +1,129 @@
+# frozen_string_literal: true
+
+export_default :HTTP1Adapter
+
+require 'http/parser'
+
+Response = import './response'
+
+# HTTP 1 adapter
+class HTTP1Adapter
+  def initialize(socket)
+    @socket = socket
+    @parser = HTTP::Parser.new(self)
+  end
+
+  def on_headers_complete(headers)
+    @headers = headers
+  end
+
+  def on_body(chunk)
+    if @waiting_for_chunk
+      @buffered_chunks ||= []
+      @buffered_chunks << chunk
+    elsif @buffered_body
+      @buffered_body << chunk
+    else
+      @buffered_body = +chunk
+    end
+  end
+
+  def on_message_complete
+    @done = true
+  end
+
+  def request(ctx)
+    # consume previous response if not finished
+    consume_response if @done == false
+
+    @socket << format_http1_request(ctx)
+
+    @buffered_body = nil
+    @done = false
+
+    read_headers
+    Response.new(self, @parser.status_code, @headers)
+  end
+
+  def read_headers
+    @headers = nil
+    while !@headers && (data = @socket.readpartial(8192))
+      @parser << data
+    end
+
+    raise 'Socket closed by host' unless @headers
+  end
+
+  def body
+    @waiting_for_chunk = nil
+    consume_response
+    @buffered_body
+  end
+
+  def each_chunk(&block)
+    if (body = @buffered_body)
+      @buffered_body = nil
+      @waiting_for_chunk = true
+      block.(body)
+    end
+    while !@done && (data = @socket.readpartial(8192))
+      @parser << data
+    end
+    raise 'Socket closed by host' unless @done
+
+    @buffered_chunks.each(&block)
+  end
+
+  def next_body_chunk
+    return nil if @done
+    if @buffered_chunks && !@buffered_chunks.empty?
+      return @buffered_chunks.shift
+    end
+
+    read_next_body_chunk
+  end
+
+  def read_next_body_chunk
+    @waiting_for_chunk = true
+    while !@done && (data = @socket.readpartial(8192))
+      @parser << data
+      break unless @buffered_chunks.empty?
+    end
+    @buffered_chunks.shift
+  end
+
+  def consume_response
+    while !@done && (data = @socket.readpartial(8192))
+      @parser << data
+    end
+
+    raise 'Socket closed by host' unless @done
+  end
+
+  HTTP1_REQUEST = <<~HTTP.gsub("\n", "\r\n")
+    %<method>s %<request>s HTTP/1.1
+    Host: %<host>s
+    %<headers>s
+
+  HTTP
+
+  def format_http1_request(ctx)
+    headers = format_headers(ctx)
+
+    format(
+      HTTP1_REQUEST,
+      method:  ctx[:method],
+      request: ctx[:uri].request_uri,
+      host:    ctx[:uri].host,
+      headers: headers
+    )
+  end
+
+  def format_headers(headers)
+    headers.map { |k, v| "#{k}: #{v}\r\n" }.join
+  end
+
+  def protocol
+    :http1
+  end
+end

data/lib/polyphony/http/client/http2.rb

@@ -0,0 +1,180 @@
+# frozen_string_literal: true
+
+export_default :HTTP2Adapter
+
+require 'http/2'
+
+Response = import './response'
+
+# HTTP 2 adapter
+class HTTP2Adapter
+  def initialize(socket)
+    @socket = socket
+    @client = HTTP2::Client.new
+    @client.on(:frame) { |bytes| socket << bytes }
+    # @client.on(:frame_received) do |frame|
+    #   puts "Received frame: #{frame.inspect}"
+    # end
+    # @client.on(:frame_sent) do |frame|
+    #   puts "Sent frame: #{frame.inspect}"
+    # end
+
+    @reader = spin do
+      while (data = socket.readpartial(8192))
+        @client << data
+        snooze
+      end
+    end
+  end
+
+  def allocate_stream_adapter
+    StreamAdapter.new(self)
+  end
+
+  def allocate_stream
+    @client.new_stream
+  end
+
+  def protocol
+    :http2
+  end
+
+  # Virtualizes adapter over HTTP2 stream
+  class StreamAdapter
+    def initialize(connection)
+      @connection = connection
+    end
+
+    def request(ctx)
+      stream = setup_stream # (ctx, stream)
+      send_request(ctx, stream)
+
+      stream.on(:headers, &method(:on_headers))
+      stream.on(:data, &method(:on_data))
+      stream.on(:close, &method(:on_close))
+
+      # stream.on(:active) { puts "* active" }
+      # stream.on(:half_close) { puts "* half_close" }
+
+      wait_for_response(ctx, stream)
+    rescue Exception => e
+      p e
+      puts e.backtrace.join("\n")
+      # ensure
+      # stream.close
+    end
+
+    def send_request(ctx, stream)
+      headers = prepare_headers(ctx)
+      if ctx[:opts][:payload]
+        stream.headers(headers, end_stream: false)
+        stream.data(ctx[:opts][:payload], end_stream: true)
+      else
+        stream.headers(headers, end_stream: true)
+      end
+    end
+
+    def on_headers(headers)
+      if @waiting_headers_fiber
+        @waiting_headers_fiber.schedule headers.to_h
+      else
+        @headers = headers.to_h
+      end
+    end
+
+    def on_data(chunk)
+      if @waiting_chunk_fiber
+        @waiting_chunk_fiber&.schedule chunk
+      else
+        @buffered_chunks << chunk
+      end
+    end
+
+    def on_close(_stream)
+      @done = true
+      @waiting_done_fiber&.schedule
+    end
+
+    def setup_stream
+      stream = @connection.allocate_stream
+
+      @headers = nil
+      @done = nil
+      @buffered_chunks = []
+
+      @waiting_headers_fiber = nil
+      @waiting_chunk_fiber = nil
+      @waiting_done_fiber = nil
+
+      stream
+    end
+
+    def wait_for_response(_ctx, _stream)
+      headers = wait_for_headers
+      Response.new(self, headers[':status'].to_i, headers)
+    end
+
+    def wait_for_headers
+      return @headers if @headers
+
+      @waiting_headers_fiber = Fiber.current
+      suspend
+    end
+
+    def protocol
+      :http2
+    end
+
+    def prepare_headers(ctx)
+      headers = {
+        ':method'    => ctx[:method].to_s,
+        ':scheme'    => ctx[:uri].scheme,
+        ':authority' => [ctx[:uri].host, ctx[:uri].port].join(':'),
+        ':path'      => ctx[:uri].request_uri,
+        'User-Agent' => 'curl/7.54.0'
+      }
+      headers.merge!(ctx[:opts][:headers]) if ctx[:opts][:headers]
+      headers
+    end
+
+    def body
+      @waiting_done_fiber = Fiber.current
+      suspend
+      @buffered_chunks.join
+      # body = +''
+      # while !@done
+      #   p :body_suspend_pre
+      #   chunk = suspend
+      #   p :body_suspend_post
+      #   body << chunk
+      # end
+      # puts ""
+      # body
+    rescue Exception => e
+      p e
+      puts e.backtrace.join("\n")
+    end
+
+    def each_chunk
+      yield @buffered_chunks.shift until @buffered_chunks.empty?
+
+      @waiting_chunk_fiber = Fiber.current
+      until @done
+        chunk = suspend
+        yield chunk
+      end
+    end
+
+    def next_body_chunk
+      return yield @buffered_chunks.shift unless @buffered_chunks.empty?
+
+      @waiting_chunk_fuber = Fiber.current
+      until @done
+        chunk = suspend
+        return yield chunk
+      end
+
+      nil
+    end
+  end
+end

data/lib/polyphony/http/client/response.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+export_default :Response
+
+require 'json'
+
+# HTTP response
+class Response
+  attr_reader :status_code, :headers
+
+  def initialize(adapter, status_code, headers)
+    @adapter = adapter
+    @status_code = status_code
+    @headers = headers
+  end
+
+  def body
+    @body ||= @adapter.body
+  end
+
+  def each_chunk(&block)
+    @adapter.each_chunk(&block)
+  end
+
+  def next_body_chunk
+    @adapter.next_body_chunk
+  end
+
+  def json
+    @json ||= ::JSON.parse(body)
+  end
+end