polyphony 0.19 → 0.20

data/lib/polyphony/http/http2_adapter.rb

@@ -1,157 +0,0 @@
-# frozen_string_literal: true
-
-export_default :Protocol
-
-require 'http/2'
-
-Request = import('./request')
-
-class StreamWrapper
-  def initialize(stream, parse_fiber)
-    @stream = stream
-    @parse_fiber = parse_fiber
-    @parsing = true
-
-    stream.on(:data) { |data| on_body(data) }
-    stream.on(:half_close) { on_message_complete }
-  end
-
-  # Reads body chunk from connection
-  def get_body_chunk
-    @calling_fiber = Fiber.current
-    @read_body = true
-    @parse_fiber.safe_transfer
-  end
-
-  # Wait for request to finish
-  def consume_request
-    return unless @parsing
-
-    @calling_fiber = Fiber.current
-    @read_body = false
-    @parse_fiber.safe_transfer while @parsing
-  end
-
-  def on_body(data)
-    @calling_fiber.transfer(data) if @read_body
-  end
-
-  def on_message_complete
-    @parsing = false
-    @calling_fiber.transfer nil
-  end
-
-  # response API
-  def respond(chunk, headers)
-    consume_request if @parsing
-
-    headers[':status'] ||= '200'
-    @stream.headers(headers, end_stream: false)
-    @stream.data(chunk, end_stream: true)
-    @headers_sent = true
-  end
-
-  def send_headers(headers, empty_response = false)
-    return if @headers_sent
-
-    consume_request if @parsing
-
-    headers[':status'] ||= (empty_response ? 204 : 200).to_s
-    @stream.headers(headers, end_stream: false)
-    @headers_sent = true
-  end
-
-  def send_body_chunk(chunk, done: false)
-    send_headers({}, false) unless @headers_sent
-    @stream.data(chunk, end_stream: done)
-  end
-  
-  def finish
-    consume_request if @parsing
-
-    unless @headers_sent
-      headers[':status'] ||= '204'
-      @stream.headers(headers, end_stream: true)
-    else
-      @stream.close
-    end
-  end
-end
-
-class Protocol
-  def self.upgrade_each(socket, opts, headers, &block)
-    adapter = new(socket, opts, headers)
-    adapter.each(&block)
-  end
-
-  def initialize(conn, opts, upgrade_headers = nil)
-    @conn = conn  
-    @opts = opts
-
-    @interface = ::HTTP2::Server.new
-    @interface.on(:frame) { |bytes| conn << bytes }
-    @interface.on(:stream) { |stream| start_stream(stream) }
-    @parse_fiber = Fiber.new { parse_loop(upgrade_headers) }
-  end
-
-  def start_stream(stream)
-    stream.on(:headers) do |headers|
-      @calling_fiber.transfer([stream, headers.to_h])
-    end
-  end
-
-  def protocol
-    'h2'
-  end
-
-  def parse_loop(upgrade_headers)
-    upgrade(upgrade_headers) if upgrade_headers
-      
-    while (data = @conn.readpartial(8192))
-      @interface << data
-      snooze
-    end
-    @calling_fiber.transfer nil
-  rescue SystemCallError, IOError
-    # ignore
-    @calling_fiber.transfer nil
-  rescue => error
-    # an error return value will be raised by the receiving fiber
-    @calling_fiber.transfer error
-  end
-
-  # request API
-  
-  UPGRADE_MESSAGE = <<~HTTP.gsub("\n", "\r\n")
-  HTTP/1.1 101 Switching Protocols
-  Connection: Upgrade
-  Upgrade: h2c
-
-  HTTP
-
-def upgrade(headers)
-    settings = headers['HTTP2-Settings']
-    @conn << UPGRADE_MESSAGE
-    @interface.upgrade(settings, headers, '')
-  end
-
-  # Iterates over incoming requests
-  def each(&block)
-    can_upgrade = true
-    while @parse_fiber.alive?
-      stream, headers = get_headers
-      break unless stream
-      wrapper = StreamWrapper.new(stream, @parse_fiber)
-      request = Request.new(headers, wrapper)
-      Fiber.new { block.(request) }.resume
-    end
-  ensure
-    @conn.close rescue nil
-  end
-
-  # Reads headers from connection
-  def get_headers
-    @calling_fiber = Fiber.current
-    @parse_fiber.safe_transfer
-  end
-end

data/lib/polyphony/http/rack.rb

@@ -1,25 +0,0 @@
-# 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
-
-def respond(request, (status_code, headers, body))
-  headers[':status'] = status_code.to_s
-  body = body.first
-  request.respond(body, headers)
-end

data/lib/polyphony/http/request.rb

@@ -1,66 +0,0 @@
-# frozen_string_literal: true
-
-export_default :Request
-
-require 'uri'
-
-class Request
-  attr_reader :headers, :adapter
-
-  def initialize(headers, adapter)
-    @headers  = headers
-    @adapter  = adapter
-  end
-
-  def protocol
-    @adapter.protocol
-  end
-
-  def method
-    @method ||= @headers[':method']
-  end
-
-  def scheme
-    @scheme ||= @headers[':scheme']
-  end
-
-  def uri
-    @uri ||= URI.parse(@headers[':path'] || '')
-  end
-
-  def path
-    @path ||= uri.path
-  end
-
-  def query
-    @uri ||= URI.parse(@headers[':path'] || '')
-    return @query if @query
-  
-    if (q = uri.query)
-      @query = q.split('&').each_with_object({}) do |kv, h|
-        k, v = kv.split('=')
-        h[k.to_sym] = URI.decode_www_form_component(v)
-      end
-    else
-      @query = {}
-    end
-  end
-
-  EMPTY_HASH = {}
-
-  def respond(chunk, headers = EMPTY_HASH)
-    @adapter.respond(chunk, headers)
-  end
-
-  def send_headers(headers = EMPTY_HASH, empty_response = false)
-    @adapter.send_headers(headers, empty_response)
-  end
-
-  def send_body_chunk(body, done: false)
-    @adapter.send_body_chunk(body, done: done)
-  end
-
-  def finish
-    @adapter.finish
-  end
-end

data/test/test_ev.rb

@@ -1,110 +0,0 @@
-require 'minitest/autorun'
-require 'bundler/setup'
-require 'polyphony'
-
-class EVRunTest < Minitest::Test
-  def setup
-    EV.rerun
-  end
-
-  def test_that_run_loop_returns_immediately_if_no_watchers
-    t0 = Time.now
-    suspend
-    t1 = Time.now
-    assert (t1 - t0) < 0.001
-  end
-end
-
-class EVTimerTest < MiniTest::Test
-  def setup
-    EV.rerun
-  end
-
-  def test_that_one_shot_timer_works
-    count = 0
-    t = EV::Timer.new(0.01, 0)
-    t.start { count += 1}
-    suspend
-    assert_equal(1, count)
-  end
-
-  def test_that_repeating_timer_works
-    count = 0
-    t = EV::Timer.new(0.001, 0.001)
-    t.start { count += 1; t.stop if count >= 3}
-    suspend
-    assert_equal(3, count)
-  end
-end
-
-class EVIOTest < MiniTest::Test
-  def setup
-    EV.rerun
-  end
-
-  def test_that_reading_works
-    i, o = IO.pipe
-    data = +''
-    w = EV::IO.new(i, :r)
-    w.start do
-      i.read_nonblock(8192, data)
-      w.stop unless data.empty?
-    end
-    EV::Timer.new(0, 0).start { o << 'hello' }
-    suspend
-    assert_equal('hello', data)
-  end
-end
-
-class EVSignalTest < MiniTest::Test
-  def setup
-    EV.rerun
-    EV.restart
-  end
-
-  def test_that_signal_watcher_receives_signal
-    sig = Signal.list['USR1']
-    count = 0
-    w = EV::Signal.new(sig) { count += 1; w.stop }
-    Thread.new { sync_sleep 0.001; Process.kill(:USR1, Process.pid) }
-    suspend
-    assert_equal(1, count)
-  end
-
-  def test_that_signal_watcher_receives_signal
-    count = 0
-    w = Polyphony.trap(:usr1, true) { count += 1; w.stop }
-    assert_kind_of(EV::Signal, w)
-    Thread.new { sync_sleep 0.001; Process.kill(:USR1, Process.pid) }
-    suspend
-    assert_equal(1, count)
-  end
-end
-
-class EVAsyncTest < MiniTest::Test
-  def setup
-    EV.rerun
-  end
-
-  def test_that_async_watcher_receives_signal_across_threads
-    count = 0
-    a = EV::Async.new { count += 1; a.stop }
-    Thread.new { sync_sleep 0.001; a.signal! }
-    suspend
-    assert_equal(1, count)
-  end
-
-  def test_that_async_watcher_coalesces_signals
-    count = 0
-    a = EV::Async.new do
-      count += 1
-      EV::Timer.new(0.01, 0).start { a.stop }
-    end
-    Thread.new do
-      sync_sleep 0.001
-      3.times { a.signal! }
-    end
-    suspend
-    assert_equal(1, count)
-  end
-end