polyphony 0.21 → 0.22

data/ext/gyro/timer.c

@@ -95,29 +95,23 @@ static VALUE Gyro_Timer_initialize(VALUE self, VALUE after, VALUE repeat) {
 }
 
 void Gyro_Timer_callback(struct ev_loop *ev_loop, struct ev_timer *ev_timer, int revents) {
-  VALUE fiber;
-  VALUE resume_value;
   struct Gyro_Timer *timer = (struct Gyro_Timer*)ev_timer;
 
-  // if (!timer->active) {
-  //   return;
-  // }
-
   if (!timer->repeat) {
     timer->active = 0;
-    Gyro_del_watcher_ref(timer->self);
   }
 
   if (timer->fiber != Qnil) {
+    VALUE fiber = timer->fiber;
+    VALUE resume_value = DBL2NUM(timer->after);
+
     ev_timer_stop(EV_DEFAULT, ev_timer);
-    Gyro_del_watcher_ref(timer->self);
     timer->active = 0;
-    fiber = timer->fiber;
     timer->fiber = Qnil;
-    resume_value = DBL2NUM(timer->after);
-    SCHEDULE_FIBER(fiber, 1, resume_value);
+    Gyro_schedule_fiber(fiber, resume_value);
   }
   else if (timer->callback != Qnil) {
+    Gyro_ref_count_decr();
     rb_funcall(timer->callback, ID_call, 1, Qtrue);
   }
 }
@@ -127,13 +121,13 @@ static VALUE Gyro_Timer_start(VALUE self) {
   GetGyro_Timer(self, timer);
 
   if (rb_block_given_p()) {
+    Gyro_ref_count_incr();
     timer->callback = rb_block_proc();
   }
 
   if (!timer->active) {
     ev_timer_start(EV_DEFAULT, &timer->ev_timer);
     timer->active = 1;
-    Gyro_add_watcher_ref(self);
   }
 
   return self;
@@ -146,7 +140,6 @@ static VALUE Gyro_Timer_stop(VALUE self) {
   if (timer->active) {
     ev_timer_stop(EV_DEFAULT, &timer->ev_timer);
     timer->active = 0;
-    Gyro_del_watcher_ref(self);
   }
 
   return self;
@@ -166,7 +159,6 @@ static VALUE Gyro_Timer_reset(VALUE self) {
   ev_timer_start(EV_DEFAULT, &timer->ev_timer);
   if (!prev_active) {
     timer->active = 1;
-    Gyro_add_watcher_ref(self);
   }
 
   return self;
@@ -181,11 +173,11 @@ static VALUE Gyro_Timer_await(VALUE self) {
   timer->fiber = rb_fiber_current();
   timer->active = 1;
   ev_timer_start(EV_DEFAULT, &timer->ev_timer);
-  Gyro_add_watcher_ref(self);
 
-  ret = YIELD_TO_REACTOR();
+  ret = Gyro_yield();
 
   // fiber is resumed, check if resumed value is an exception
+  timer->fiber = Qnil;
   if (RTEST(rb_obj_is_kind_of(ret, rb_eException))) {
     if (timer->active) {
       timer->active = 0;
@@ -193,7 +185,6 @@ static VALUE Gyro_Timer_await(VALUE self) {
     }
     return rb_funcall(ret, ID_raise, 1, ret);
   }
-  else {
+  else
     return ret;
-  }
 }

data/lib/polyphony/auto_run.rb

@@ -3,10 +3,17 @@
 require_relative '../polyphony'
 
 at_exit do
-  repl = (Pry.current rescue nil) || (IRB.CurrentContext rescue nil)
+  unless Gyro.break?
+    repl = (Pry.current rescue nil) || (IRB.CurrentContext rescue nil)
 
-  # in most cases, once the root fiber is done there are still pending
-  # operations going on. If the reactor loop is not done, we suspend the root
-  # fiber until it is done
-  suspend if $__reactor_fiber__&.alive? && !repl
+    # in most cases, once the root fiber is done there are still pending
+    # operations going on. If the reactor loop is not done, we suspend the root
+    # fiber until it is done
+    begin
+      suspend unless repl
+    rescue Exception => e
+      p e
+      puts e.backtrace.join("\n")
+    end
+  end
 end

data/lib/polyphony/core/coprocess.rb

@@ -101,7 +101,7 @@ class Coprocess
   end
 
   def caller
-    @fiber&.__caller__[2..]
+    @fiber && @fiber.__caller__[2..-1]
   end
 
   def location

data/lib/polyphony/core/resource_pool.rb

@@ -4,52 +4,68 @@ export_default :ResourcePool
 
 # Implements a limited resource pool
 class ResourcePool
+  attr_reader :limit, :size
+
   # Initializes a new resource pool
   # @param opts [Hash] options
   # @param &block [Proc] allocator block
   def initialize(opts, &block)
     @allocator = block
 
-    @available = []
-    @waiting = []
+    @stock = []
+    @queue = []
 
     @limit = opts[:limit] || 4
-    @count = 0
+    @size = 0
+  end
+
+  def available
+    @stock.size
   end
 
   def acquire
+    Gyro.ref
     resource = wait_for_resource
     return unless resource
 
     yield resource
   ensure
-    dequeue(resource) || return_to_stock(resource) if resource
+    Gyro.unref
+    release(resource) if resource
   end
 
   def wait_for_resource
     fiber = Fiber.current
-    @waiting << fiber
+    @queue << fiber
     ready_resource = from_stock
     return ready_resource if ready_resource
 
     suspend
   ensure
-    @waiting.delete(fiber)
+    @queue.delete(fiber)
   end
 
-  def dequeue(resource)
-    return nil if @waiting.empty?
+  def release(resource)
+    if resource.__discarded__
+      @size -= 1
+    elsif resource
+      return_to_stock(resource)
+      dequeue
+    end
+  end
 
-    @waiting[0]&.schedule(resource)
-    true
+  def dequeue
+    return if @queue.empty? || @stock.empty?
+
+    @queue.shift.schedule(@stock.shift)
   end
 
   def return_to_stock(resource)
-    @available << resource
+    @stock << resource
   end
 
   def from_stock
-    @available.shift || (@count < @limit && allocate)
+    @stock.shift || (@size < @limit && allocate)
   end
 
   def method_missing(sym, *args, &block)
@@ -60,14 +76,32 @@ class ResourcePool
     true
   end
 
+  # Extension to allow discarding of resources
+  module ResourceExtensions
+    def __discarded__
+      @__discarded__
+    end
+
+    def __discard__
+      @__discarded__ = true
+    end
+  end
+
   # Allocates a resource
   # @return [any] allocated resource
   def allocate
-    @count += 1
-    @allocator.()
+    @size += 1
+    @allocator.().tap { |r| r.extend ResourceExtensions }
+  end
+
+  def <<(resource)
+    @size += 1
+    resource.extend ResourceExtensions
+    @stock << resource
+    dequeue
   end
 
   def preheat!
-    (@limit - @count).times { @available << from_stock }
+    (@limit - @size).times { @stock << from_stock }
   end
 end

data/lib/polyphony/core/supervisor.rb

@@ -16,7 +16,7 @@ class Supervisor
     @supervisor_fiber = Fiber.current
     block&.(self)
     suspend
-    @coprocesses.map { |cp| cp.result }
+    @coprocesses.map(&:result)
   rescue Exceptions::MoveOn => e
     e.value
   ensure
@@ -75,10 +75,11 @@ class Supervisor
   end
 end
 
+# Extension for Coprocess class
 class Coprocess
   def self.await(*coprocs)
     supervise do |s|
       coprocs.each { |cp| s.add cp }
     end
   end
-end
+end

data/lib/polyphony/extensions/core.rb

@@ -14,7 +14,7 @@ class ::Fiber
   attr_accessor :__calling_fiber__
   attr_accessor :__caller__
   attr_writer :cancelled
-  attr_accessor :coprocess, :scheduled_value
+  attr_accessor :coprocess
 
   class << self
     alias_method :orig_new, :new
@@ -23,8 +23,12 @@ class ::Fiber
       fiber_caller = caller
       fiber = orig_new do |v|
         block.call(v)
+      rescue Exception => e
+        puts "Uncaught exception #{calling_fiber.alive?}"
+        calling_fiber.transfer e if calling_fiber.alive?
       ensure
-        $__reactor_fiber__.safe_transfer if $__reactor_fiber__.alive?
+        fiber.mark_as_done!
+        suspend
       end
       fiber.__calling_fiber__ = calling_fiber
       fiber.__caller__ = fiber_caller
@@ -38,7 +42,7 @@ class ::Fiber
     def set_root_fiber
       @root_fiber = current
     end
-    end
+  end
 
   def caller
     @__caller__ ||= []
@@ -134,6 +138,10 @@ module ::Kernel
     timer.stop
   end
 
+  def defer(&block)
+    Fiber.new(&block).schedule
+  end
+
   def spin(&block)
     Coprocess.new(&block).run
   end
@@ -251,3 +259,8 @@ module ::Timeout
     raise error
   end
 end
+
+trap('SIGINT') do
+  Gyro.break!
+  exit
+end

data/lib/polyphony/extensions/io.rb

@@ -157,11 +157,13 @@ class ::IO
   # def readlines(sep = $/, limit = nil, chomp: nil)
   # end
 
+  alias_method :orig_write_nonblock, :write_nonblock
   def write_nonblock(string, _options = {})
     # STDOUT << '>'
     write(string, 0)
   end
 
+  alias_method :orig_read_nonblock, :read_nonblock
   def read_nonblock(maxlen, buf = nil, _options = nil)
     # STDOUT << '<'
     buf ? readpartial(maxlen, buf) : readpartial(maxlen)

data/lib/polyphony/extensions/openssl.rb

@@ -17,4 +17,64 @@ class ::OpenSSL::SSL::SSLSocket
   def reuse_addr
     io.reuse_addr
   end
+
+  def sysread(maxlen, buf)
+    loop do
+      read_watcher = nil
+      write_watcher = nil
+      result = read_nonblock(maxlen, buf, exception: false)
+      if result == :wait_readable
+        read_watcher ||= Gyro::IO.new(io, :r)
+        read_watcher.await
+      elsif result == :wait_writable
+        write_watcher ||= Gyro::IO.new(io, :w)
+        write_watcher.await
+      else
+        return result
+      end
+    end
+  end
+
+  def flush
+  #   osync = @sync
+  #   @sync = true
+  #   do_write ""
+  #   return self
+  # ensure
+  #   @sync = osync
+  end
+
+  # def do_write(s)
+  #   @wbuffer = "" unless defined? @wbuffer
+  #   @wbuffer << s
+  #   @wbuffer.force_encoding(Encoding::BINARY)
+  #   @sync ||= false
+  #   if @sync or @wbuffer.size > BLOCK_SIZE
+  #     until @wbuffer.empty?
+  #       begin
+  #         nwrote = syswrite(@wbuffer)
+  #       rescue Errno::EAGAIN
+  #         retry
+  #       end
+  #       @wbuffer[0, nwrote] = ""
+  #     end
+  #   end
+  # end
+
+  def syswrite(buf)
+    loop do
+      read_watcher = nil
+      write_watcher = nil
+      result = write_nonblock(buf, exception: false)
+      if result == :wait_readable
+        read_watcher ||= Gyro::IO.new(io, :r)
+        read_watcher.await
+      elsif result == :wait_writable
+        write_watcher ||= Gyro::IO.new(io, :w)
+        write_watcher.await
+      else
+        return result
+      end
+    end
+  end
 end

data/lib/polyphony/extensions/socket.rb

@@ -15,8 +15,6 @@ class ::Socket
 
       result == :wait_writable ? write_watcher.await : (raise IOError)
     end
-  ensure
-    @write_watcher&.stop
   end
 
   def recv(maxlen, flags = 0, outbuf = nil)
@@ -37,8 +35,6 @@ class ::Socket
 
       result == :wait_readable ? read_watcher.await : (return result)
     end
-  ensure
-    @read_watcher&.stop
   end
 
   ZERO_LINGER = [0, 0].pack('ii').freeze

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

@@ -0,0 +1,127 @@
+# 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|
+      response = adapter.request(ctx)
+      case response.status_code
+      when 200, 204
+        if block
+          block.(response)
+        else
+          # read body
+          response.body
+        end
+      end
+      response
+    end
+  rescue Exception => e
+    p e
+    puts e.backtrace.join("\n")
+  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