polyphony 0.21 → 0.22

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

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

@@ -0,0 +1,109 @@
+# frozen_string_literal: true
+
+export_default :SiteConnectionManager
+
+ResourcePool = import '../../core/resource_pool'
+HTTP1Adapter = import './http1'
+HTTP2Adapter = import './http2'
+
+# HTTP site connection pool
+class SiteConnectionManager < ResourcePool
+  def initialize(uri_key)
+    @uri_key = uri_key
+    super(limit: 4)
+  end
+
+  # def method_missing(sym, *args)
+  #   raise "Invalid method #{sym}"
+  # end
+
+  def acquire
+    Gyro.ref
+    prepare_first_connection if @size.zero?
+    super
+  ensure
+    Gyro.unref
+    # The size goes back to 0 only in case existing connections get into an
+    # error state and then get discarded
+    @state = nil if @size == 0
+  end
+
+  def prepare_first_connection
+    case @state
+    when nil
+      @state = :first_connection
+      create_first_connection
+    when :first_connection
+      @first_connection_queue << Fiber.current
+      suspend
+    end
+  end
+
+  def create_first_connection
+    @first_connection_queue = []
+    # @first_connection_queue << Fiber.current
+
+    adapter = connect
+    @state = adapter.protocol
+    send(:"setup_#{@state}_allocator", adapter)
+    dequeue_first_connection_waiters
+  end
+
+  def setup_http1_allocator(adapter)
+    @size += 1
+    adapter.extend ResourceExtensions
+    @stock << adapter
+    @allocator = proc { connect }
+  end
+
+  def setup_http2_allocator(adapter)
+    @adapter = adapter
+    @limit = 20
+    @size += 1
+    stream_adapter = adapter.allocate_stream_adapter
+    stream_adapter.extend ResourceExtensions
+    @stock << stream_adapter
+    @allocator = proc { adapter.allocate_stream_adapter }
+  end
+
+  def dequeue_first_connection_waiters
+    return unless @first_connection_queue
+
+    @first_connection_queue.each(&:schedule)
+    @first_connection_queue = nil
+  end
+
+  def connect
+    socket = create_socket
+    protocol = socket_protocol(socket)
+    case protocol
+    when :http1
+      HTTP1Adapter.new(socket)
+    when :http2
+      HTTP2Adapter.new(socket)
+    else
+      raise "Unknown protocol #{protocol.inspect}"
+    end
+  end
+
+  def socket_protocol(socket)
+    if socket.is_a?(OpenSSL::SSL::SSLSocket) && socket.alpn_protocol == 'h2'
+      :http2
+    else
+      :http1
+    end
+  end
+
+  SECURE_OPTS = { secure: true, alpn_protocols: ['h2', 'http/1.1'] }.freeze
+
+  def create_socket
+    case @uri_key[:scheme]
+    when 'http'
+      Polyphony::Net.tcp_connect(@uri_key[:host], @uri_key[:port])
+    when 'https'
+      Polyphony::Net.tcp_connect(@uri_key[:host], @uri_key[:port], SECURE_OPTS)
+    else
+      raise "Invalid scheme #{@uri_key[:scheme].inspect}"
+    end
+  end
+end

data/lib/polyphony/http/server/request.rb

@@ -58,7 +58,6 @@ class Request
 
   def each_chunk(&block)
     if @buffered_body_chunks
-      puts 'serve buffered body_chunks'
       @buffered_body_chunks.each(&block)
       @buffered_body_chunks = nil
     end

data/lib/polyphony/http.rb

@@ -6,7 +6,7 @@ module Polyphony
   # HTTP imports (loaded dynamically)
   module HTTP
     auto_import(
-      Agent:  './http/agent',
+      Agent:  './http/client/agent',
       Rack:   './http/server/rack',
       Server: './http/server'
     )

data/lib/polyphony/net.rb

@@ -41,7 +41,8 @@ def socket_from_options(host, port, opts)
 end
 
 def secure_socket(socket, context, opts)
-  setup_alpn(context, opts[:alpn_protocols]) if context && opts[:alpn_protocols]
+  context ||= OpenSSL::SSL::SSLContext.new
+  setup_alpn(context, opts[:alpn_protocols]) if opts[:alpn_protocols]
   socket = secure_socket_wrapper(socket, context)
 
   socket.tap do |s|

data/lib/polyphony/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Polyphony
-  VERSION = '0.21'
+  VERSION = '0.22'
 end

data/lib/polyphony.rb

@@ -52,7 +52,7 @@ module Polyphony
     end
 
     def fork(&block)
-      Gyro.break
+      Gyro.break!
       pid = Kernel.fork do
         setup_forked_process
         block.()
@@ -64,13 +64,13 @@ module Polyphony
         # exiting.
         suspend
       end
-      Gyro.restart
+      Gyro.reset!
       pid
     end
 
     def reset!
-      Fiber.root.scheduled_value = nil
-      Gyro.restart
+      # Fiber.root.scheduled_value = nil
+      Gyro.reset!
     end
 
     private

data/polyphony.gemspec

@@ -16,6 +16,7 @@ Gem::Specification.new do |s|
   s.extra_rdoc_files = ["README.md"]
   s.extensions = ["ext/gyro/extconf.rb"]
   s.require_paths = ["lib"]
+  s.required_ruby_version = '>= 2.6'
 
   s.executables   = ['poly']
 

data/test/test_gyro.rb

@@ -2,7 +2,42 @@
 
 require_relative 'helper'
 
-class RunTest < Minitest::Test
+class SchedulingTest < MiniTest::Test
+  def test_fiber_state
+    assert_equal :running, Fiber.current.state
+
+    f = Fiber.new {}
+
+    assert_equal :paused, f.state
+    f.resume
+    assert_equal :dead, f.state
+
+    f = Fiber.new { }
+    f.schedule
+    assert_equal :scheduled, f.state
+    snooze
+    assert_equal :dead, f.state
+  end
+
+  def test_schedule
+    values = []
+    fibers = 3.times.map { |i| Fiber.new { values << i } }
+    fibers[0].schedule
+
+    assert_equal [], values
+    snooze
+    assert_equal [0], values
+    
+    fibers[1].schedule
+    fibers[2].schedule
+
+    assert_equal [0], values
+    snooze
+    assert_equal [0, 1, 2], values
+  end
+end
+
+class RunTest < MiniTest::Test
   def test_that_run_loop_returns_immediately_if_no_watchers
     t0 = Time.now
     suspend
@@ -88,7 +123,7 @@ class IdleTest < MiniTest::Test
     end.schedule
 
     Fiber.new do
-      Gyro.break
+      Gyro.break!
     end.schedule
 
     suspend
@@ -96,7 +131,7 @@ class IdleTest < MiniTest::Test
     assert_equal [:foo], values
   end
 
-  def test_start
+  def test_reset
     values = []
     f1 = Fiber.new do
       values << :foo
@@ -106,7 +141,7 @@ class IdleTest < MiniTest::Test
     end.schedule
 
     f2 = Fiber.new do
-      Gyro.break
+      Gyro.reset!
       values << :restarted
       snooze
       values << :baz
@@ -114,12 +149,9 @@ class IdleTest < MiniTest::Test
 
     suspend
 
-    Gyro.start
-    f2.schedule
     f1.schedule
     suspend
-
-    assert_equal %i[foo restarted bar baz], values
+    assert_equal %i[foo restarted baz], values
   end
 
   def test_restart
@@ -127,13 +159,13 @@ class IdleTest < MiniTest::Test
     Fiber.new do
       values << :foo
       snooze
-      # this part will not be reached, as f
+      # this part will not be reached, as Gyro state is reset
       values << :bar
       suspend
     end.schedule
 
     Fiber.new do
-      Gyro.restart
+      Gyro.reset!
 
       # control is transfer to the fiber that called Gyro.restart
       values << :restarted

data/test/test_resource_pool.rb

@@ -0,0 +1,107 @@
+# frozen_string_literal: true
+
+require_relative 'helper'
+
+class ResourcePoolTest < MiniTest::Test
+  def test_resource_pool_limit
+    resources = [+'a', +'b']
+    pool = Polyphony::ResourcePool.new(limit: 2) { resources.shift }
+
+    assert_equal 2, pool.limit
+    assert_equal 0, pool.available
+    assert_equal 0, pool.size
+
+    results = []
+    4.times {
+      spin {
+        snooze
+        pool.acquire { |resource|
+          results << resource
+          snooze
+        }
+      }
+    }
+    2.times { snooze }
+    assert_equal 2, pool.limit
+    assert_equal 0, pool.available
+    assert_equal 2, pool.size
+
+    2.times { snooze }
+
+    assert_equal ['a', 'b', 'a', 'b'], results
+
+    2.times { snooze }
+
+    assert_equal 2, pool.limit
+    assert_equal 2, pool.available
+    assert_equal 2, pool.size
+  end
+
+  def test_discard
+    resources = [+'a', +'b']
+    pool = Polyphony::ResourcePool.new(limit: 2) { resources.shift }
+
+    results = []
+    4.times {
+      spin {
+        snooze
+        pool.acquire { |resource|
+          results << resource
+          resource.__discard__ if resource == 'b'
+          snooze
+        }
+      }
+    }
+    6.times { snooze }
+
+    assert_equal ['a', 'b', 'a', 'a'], results
+    assert_equal 1, pool.size
+  end
+
+  def test_add
+    resources = [+'a', +'b']
+    pool = Polyphony::ResourcePool.new(limit: 2) { resources.shift }
+
+    pool << +'c'
+
+    results = []
+    4.times {
+      spin {
+        snooze
+        pool.acquire { |resource|
+          results << resource
+          resource.__discard__ if resource == 'b'
+          snooze
+        }
+      }
+    }
+    6.times { snooze }
+
+    assert_equal ['c', 'a', 'c', 'a'], results
+  end
+
+  def test_single_resource_limit
+    resources = [+'a', +'b']
+    pool = Polyphony::ResourcePool.new(limit: 1) { resources.shift }
+
+    results = []
+    10.times {
+      spin {
+        snooze
+        pool.acquire { |resource|
+          results << resource
+          snooze
+        }
+      }
+    }
+    20.times { snooze }
+
+    assert_equal ['a'] * 10, results
+  end
+
+  def test_failing_allocator
+    pool = Polyphony::ResourcePool.new(limit: 4) { raise }
+
+    assert_raises { pool.acquire { } }
+  end
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: polyphony
 version: !ruby/object:Gem::Version
-  version: '0.21'
+  version: '0.22'
 platform: ruby
 authors:
 - Sharon Rosner
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2019-12-12 00:00:00.000000000 Z
+date: 2020-01-02 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: modulation
@@ -272,6 +272,7 @@ files:
 - examples/http/config.ru
 - examples/http/cuba.ru
 - examples/http/happy_eyeballs.rb
+- examples/http/http2_raw.rb
 - examples/http/http_client.rb
 - examples/http/http_get.rb
 - examples/http/http_parse_experiment.rb
@@ -369,7 +370,11 @@ files:
 - lib/polyphony/extensions/socket.rb
 - lib/polyphony/fs.rb
 - lib/polyphony/http.rb
-- lib/polyphony/http/agent.rb
+- lib/polyphony/http/client/agent.rb
+- lib/polyphony/http/client/http1.rb
+- lib/polyphony/http/client/http2.rb
+- lib/polyphony/http/client/response.rb
+- lib/polyphony/http/client/site_connection_manager.rb
 - lib/polyphony/http/server.rb
 - lib/polyphony/http/server/http1.rb
 - lib/polyphony/http/server/http2.rb
@@ -393,6 +398,7 @@ files:
 - test/test_http_server.rb
 - test/test_io.rb
 - test/test_kernel.rb
+- test/test_resource_pool.rb
 - test/test_signal.rb
 - test/test_timer.rb
 homepage: http://github.com/digital-fabric/polyphony
@@ -412,7 +418,7 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: '0'
+      version: '2.6'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="