polyphony 0.13

data/lib/polyphony/http/http1.rb

@@ -0,0 +1,124 @@
+# frozen_string_literal: true
+
+export :run
+
+require 'http/parser'
+
+Request = import('./http1_request')
+HTTP2 = import('./http2')
+
+class Http::Parser
+  def async!
+    self.on_message_complete = proc { @request_complete = true }
+    self
+  end
+
+  def parse(data)
+    self << data
+    return nil unless @request_complete
+
+    @request_complete = nil
+    self
+  end
+end
+
+# Sets up parsing and handling of request/response cycle
+# @param socket [Net::Socket] socket
+# @param handler [Proc] request handler
+# @return [void]
+def run(socket, handler)
+  ctx = connection_context(socket, handler)
+  ctx[:parser].on_body = proc { |chunk| handle_body_chunk(ctx, chunk) }
+
+  loop do
+    data = socket.read
+    if ctx[:parser].parse(data)
+      break unless handle_request(ctx)
+      EV.snooze
+    end
+  end
+rescue IOError, SystemCallError => e
+  # do nothing
+ensure
+  socket.close
+end
+
+# Returns a context hash for the given socket. This hash contains references
+# related to the connection and its current state
+# @param socket [Net::Socket] socket
+# @param handler [Proc] request handler
+# @return [Hash]
+def connection_context(socket, handler)
+  {
+    can_upgrade:  true,
+    count:        0,
+    socket:       socket,
+    handler:      handler,
+    parser:       Http::Parser.new.async!,
+    body:         nil,
+    request:      Request.new
+  }
+end
+
+# Adds given chunk to request body
+# @param ctx [Hash] connection context
+# @return [void]
+def handle_body_chunk(context, chunk)
+
+  context[:body] ||= +''
+  context[:body] << chunk
+end
+
+# Handles request, upgrading the connection if possible
+# @param ctx [Hash] connection context
+# @return [boolean] true if HTTP 1 loop should continue handling socket
+def handle_request(ctx)
+  return nil if ctx[:can_upgrade] && upgrade_connection(ctx)
+
+  # allow upgrading the connection only on first request
+  ctx[:can_upgrade] = false
+  ctx[:request].setup(ctx[:socket], ctx[:parser], ctx[:body])
+  ctx[:handler].(ctx[:request])
+  
+  if ctx[:parser].keep_alive?
+    ctx[:body] = nil
+    true
+  else
+    nil
+  end
+end
+
+S_EMPTY           = ''
+S_UPGRADE         = 'Upgrade'
+S_H2C             = 'h2c'
+S_SCHEME          = ':scheme'
+S_METHOD          = ':method'
+S_AUTHORITY       = ':authority'
+S_PATH            = ':path'
+S_HTTP            = 'http'
+S_HOST            = 'Host'
+
+# Upgrades an HTTP 1 connection to HTTP 2 on client request
+# @param ctx [Hash] connection context
+# @return [Boolean] true if connection was upgraded
+def upgrade_connection(ctx)
+  return false unless ctx[:parser].headers[S_UPGRADE] == S_H2C
+
+  request = http2_upgraded_request(ctx)
+  body = ctx[:body] || S_EMPTY
+  HTTP2.upgrade(ctx[:socket], ctx[:handler], request, body)
+  true
+end
+
+# Returns a request hash for handling by upgraded HTTP 2 connection
+# @param ctx [Hash] connection context
+# @return [Hash]
+def http2_upgraded_request(ctx)
+  headers = ctx[:parser].headers
+  headers.merge(
+    S_SCHEME    => S_HTTP,
+    S_METHOD    => ctx[:parser].http_method,
+    S_AUTHORITY => headers[S_HOST],
+    S_PATH      => ctx[:parser].request_url
+  )
+end

data/lib/polyphony/http/http1_request.rb

@@ -0,0 +1,71 @@
+# frozen_string_literal: true
+
+export_default :Request
+
+require 'uri'
+
+class Request
+  def setup(conn, parser, body)
+    @conn         = conn
+    @parser = parser
+    @method       = parser.http_method
+    @request_url  = parser.request_url
+    @body         = body
+  end
+
+  def method
+    @method ||= @parser.http_method
+  end
+
+  S_EMPTY     = ''
+
+  def path
+    @uri ||= URI.parse(@parser.request_url || S_EMPTY)
+    @path ||= @uri.path
+  end
+
+  S_AMPERSAND = '&'
+  S_EQUAL     = '='
+  
+  def query
+    @uri ||= URI.parse(@parser.request_url || S_EMPTY)
+    return @query if @query
+  
+    if (q = u.query)
+      @query = q.split(S_AMPERSAND).each_with_object({}) do |kv, h|
+        k, v = kv.split(S_EQUAL)
+        h[k.to_sym] = URI.decode_www_form_component(v)
+      end
+    else
+      @query = {}
+    end
+  end
+
+  def headers
+    @headers ||= @parser.headers
+  end
+
+  S_CONTENT_LENGTH  = 'Content-Length'
+  S_STATUS          = ':status'
+  EMPTY_LINE = "\r\n"
+
+  def respond(body, headers = {})
+    status = headers.delete(S_STATUS) || 200
+    data = +"HTTP/1.1 #{status}\r\n"
+    headers[S_CONTENT_LENGTH] = body.bytesize if body
+    headers.each do |k, v|
+      if v.is_a?(Array)
+        v.each { |vv| data << "#{k}: #{vv}\r\n" }
+      else
+        data << "#{k}: #{v}\r\n"
+      end
+    end
+    if body
+      data << "\r\n#{body}"
+    else
+      data << EMPTY_LINE
+    end
+
+    @conn << data
+  end
+end

data/lib/polyphony/http/http2.rb

@@ -0,0 +1,66 @@
+# frozen_string_literal: true
+
+export :run, :upgrade
+
+require 'http/2'
+
+Request = import('./http2_request')
+
+S_HTTP2_SETTINGS  = 'HTTP2-Settings'
+
+UPGRADE_MESSAGE = <<~HTTP.gsub("\n", "\r\n")
+  HTTP/1.1 101 Switching Protocols
+  Connection: Upgrade
+  Upgrade: h2c
+
+HTTP
+
+def upgrade(socket, handler, request, body)
+  interface = prepare(socket, handler)
+  settings = request[S_HTTP2_SETTINGS]
+  socket.write(UPGRADE_MESSAGE)
+  interface.upgrade(settings, request, body)
+  client_loop(socket, interface)
+end
+
+def prepare(socket, handler)
+  ::HTTP2::Server.new.tap do |interface|
+    interface.on(:frame) { |bytes| socket << bytes }
+    interface.on(:stream) { |stream| start_stream(stream, handler) }
+  end
+end
+
+def run(socket, handler)
+  interface = prepare(socket, handler)
+  client_loop(socket, interface)
+end
+
+def client_loop(socket, interface)
+  loop do
+    data = socket.read
+    interface << data
+    EV.snooze
+  end
+rescue IOError, SystemCallError => e
+  # do nothing
+rescue StandardError => e
+  puts "error in HTTP2 parse_incoming_data: #{e.inspect}"
+  puts e.backtrace.join("\n")
+ensure
+  socket.close
+end
+
+# Handles HTTP 2 stream
+# @param stream [HTTP2::Stream] HTTP 2 stream
+# @param handler [Proc] request handler
+# @return [void]
+def start_stream(stream, handler)
+  request = Request.new(stream)
+
+  # stream.on(:active) { puts 'client opened new stream' }
+  # stream.on(:close)  { puts 'stream closed' }
+
+  stream.on(:headers) { |h| request.set_headers(h) }
+  stream.on(:data) { |data| request.add_body_chunk(chunk) }
+  stream.on(:half_close) { handler.(request) }
+end

data/lib/polyphony/http/http2_request.rb

@@ -0,0 +1,69 @@
+# frozen_string_literal: true
+
+export_default :Request
+
+require 'uri'
+
+class Request
+  def initialize(stream)
+    @stream = stream
+  end
+
+  def set_headers(headers)
+    @headers = Hash[*headers.flatten]
+  end
+
+  def add_body_chunk(chunk)
+    if @body
+      @body << chunk
+    else
+      @body = +chunk
+    end
+  end
+
+  S_METHOD = ':method'
+
+  def method
+    @method ||= @headers[S_METHOD]
+  end
+
+  def scheme
+    @scheme ||= @headers[':scheme']
+  end
+
+  S_EMPTY     = ''
+
+  def path
+    @uri ||= URI.parse(@headers[':path'] || S_EMPTY)
+    @path ||= @uri.path
+  end
+
+  S_AMPERSAND = '&'
+  S_EQUAL     = '='
+  
+  def query
+    @uri ||= URI.parse(@headers[':path'] || S_EMPTY)
+    return @query if @query
+  
+    if (q = u.query)
+      @query = q.split(S_AMPERSAND).each_with_object({}) do |kv, h|
+        k, v = kv.split(S_EQUAL)
+        h[k.to_sym] = URI.decode_www_form_component(v)
+      end
+    else
+      @query = {}
+    end
+  end
+
+  S_CONTENT_LENGTH = 'Content-Length'
+  S_STATUS = ':status'
+  S_STATUS_200 = '200'
+  EMPTY_LINE = "\r\n"
+
+  def respond(body, headers = {})
+    headers[S_STATUS] ||= S_STATUS_200
+
+    @stream.headers(headers, end_stream: false)
+    @stream.data(body, end_stream: true)
+  end
+end

data/lib/polyphony/http/rack.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+export :load
+
+def run(app)
+  ->(req) {
+    response = app.(env(req))
+    respond(req, response)
+  }
+end
+
+def load(path)
+  src = IO.read(path)
+  instance_eval(src)
+end
+
+def env(request)
+  { }
+end
+
+S_STATUS = ':status'
+
+def respond(request, (status_code, headers, body))
+  headers[S_STATUS] = status_code.to_s
+  body = body.first
+  request.respond(body, headers)
+end

data/lib/polyphony/http/server.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+export :serve, :listen
+
+Net   = import('../net')
+HTTP1 = import('./http1')
+HTTP2 = import('./http2')
+
+ALPN_PROTOCOLS = %w[h2 http/1.1].freeze
+H2_PROTOCOL = 'h2'
+
+async def serve(host, port, opts = {}, &handler)
+  opts[:alpn_protocols] = ALPN_PROTOCOLS
+  server = Net.tcp_listen(host, port, opts)
+
+  accept_loop(server, handler)
+end
+
+def listen(host, port, opts = {}, &handler)
+  opts[:alpn_protocols] = ALPN_PROTOCOLS
+  server = Net.tcp_listen(host, port, opts)
+  proc { accept_loop(server, handler) }
+end
+
+def accept_loop(server, handler)
+  while true
+    client = server.accept
+    spawn client_task(client, handler)
+  end
+rescue OpenSSL::SSL::SSLError
+  retry # disregard
+end
+
+async def client_task(client, handler)
+  client.no_delay
+  protocol_module(client).run(client, handler)
+end
+
+def protocol_module(socket)
+  use_http2 = socket.respond_to?(:alpn_protocol) &&
+              socket.alpn_protocol == H2_PROTOCOL
+  use_http2 ? HTTP2 : HTTP1
+end

data/lib/polyphony/line_reader.rb

@@ -0,0 +1,82 @@
+# frozen_string_literal: true
+
+export_default :LineReader
+
+Core = import('./core')
+
+# a stream that can read single lines from another stream
+class LineReader
+  # Initializes the line reader with a source and optional line separator
+  # @param source [Stream] source stream
+  # @param sep [String] line separator
+  def initialize(source = nil, sep = $/)
+    @source = source
+    if source
+      source.on(:data) { |data| push(data) }
+      source.on(:close) { close }
+      source.on(:error) { |err| error(err) }
+    end
+    @read_buffer = +''
+    @separator = sep
+    @separator_size = sep.bytesize
+  end
+
+  # Pushes data into the read buffer and emits lines
+  # @param data [String] data to be read
+  # @return [void]
+  def push(data)
+    @read_buffer << data
+    emit_lines
+  end
+
+  # Emits lines from the read buffer
+  # @return [void]
+  def emit_lines
+    while (line = _gets)
+      @lines_promise.resolve(line)
+    end
+  end
+
+  # Returns a line sliced from the read buffer
+  # @return [String] line
+  def _gets
+    idx = @read_buffer.index(@separator)
+    idx && @read_buffer.slice!(0, idx + @separator_size)
+  end
+
+  def gets
+    Core.promise do |p|
+      @lines_promise = p
+    end
+  end
+
+  # Returns a async generator of lines
+  # @return [Promise] line generator
+  def lines
+    Core.generator do |p|
+      @lines_promise = p
+    end
+  end
+
+  # Iterates asynchronously over lines received
+  # @return [void]
+  def each_line(&block)
+    lines.each(&block)
+  end
+
+  # Closes the stream and cancels any pending reads
+  # @return [void]
+  def close
+    @lines_promise&.stop
+  end
+
+  # handles error generated by source
+  # @param err [Exception] raised error
+  # @return [void]
+  def error(err)
+    return unless @lines_promise
+
+    @lines_promise.stop
+    @lines_promise.reject(err)
+  end
+end