polyphony 0.19 → 0.20

data/lib/polyphony/core/fiber_pool.rb

@@ -1,98 +0,0 @@
-# frozen_string_literal: true
-
-export  :available,
-        :checked_out,
-        :reset!,
-        :size,
-        :run
-
-require 'fiber'
-
-# Array of available fibers
-@pool = []
-
-# Array of fibers in use
-@checked_out = {}
-
-# Fiber count
-@count = 0
-
-# Returns number of available fibers in pool
-# @return [Integer] available fibers count
-def available
-  @pool.size
-end
-
-def checked_out
-  @checked_out.size
-end
-
-# Returns size of fiber pool (including currently used fiber)
-# @return [Integer] fiber pool size
-def size
-  @count
-end
-
-def downsize
-  return if @count < 5
-  max_available = @count >= 5 ? @count / 5 : 2
-  if @pool.count > max_available
-    @pool.slice!(max_available, 50).each { |f| f.transfer :stop }
-  end
-end
-
-@downsize_timer = EV::Timer.new(5, 5)
-@downsize_timer.start { downsize }
-EV.unref
-
-# Invokes the given block using a fiber taken from the fiber pool. If the pool
-# is exhausted, a new fiber will be created.
-# @return [Fiber]
-def run(&block)
-  fiber = @pool.empty? ? new_fiber : @pool.shift
-  fiber.next_job = block
-  fiber
-end
-
-def reset!
-  @count = 0
-  @pool = []
-  @checked_out = {}
-end
-
-# Creates a new fiber to be added to the pool
-# @return [Fiber] new fiber
-def new_fiber
-  Fiber.new { fiber_loop }
-end
-
-# Runs a job-processing loop inside the current fiber
-# @return [void]
-def fiber_loop
-  fiber = Fiber.current
-  @count += 1
-  error = nil
-  loop do
-    job, fiber.next_job = fiber.next_job, nil
-    @checked_out[fiber] = true
-    fiber.cancelled = nil
-    
-    job&.(fiber)
-
-    @pool << fiber
-    @checked_out.delete(fiber)
-    break if suspend == :stop
-  end
-rescue => e
-  # uncaught error
-  error = e
-ensure
-  @pool.delete(self)
-  @checked_out.delete(fiber)
-  @count -= 1
-
-  # We need to explicitly transfer control to reactor fiber, otherwise it will
-  # be transferred to the main fiber, which would normally be blocking on 
-  # something
-  $__reactor_fiber__.transfer unless error
-end

data/lib/polyphony/extensions/kernel.rb

@@ -1,169 +0,0 @@
-# frozen_string_literal: true
-
-require 'fiber'
-require 'timeout'
-
-CancelScope = import('../core/cancel_scope')
-Coprocess   = import('../core/coprocess')
-Exceptions  = import('../core/exceptions')
-Supervisor  = import('../core/supervisor')
-Throttler   = import('../core/throttler')
-
-# Fiber extensions
-class ::Fiber
-  attr_writer :cancelled
-  attr_accessor :next_job, :coprocess
-
-  def cancelled?
-    @cancelled
-  end
-
-  def schedule(value = nil)
-    EV.schedule_fiber(self, value)
-  end
-
-  # Associate a (pseudo-)coprocess with the main fiber
-  current.coprocess = Coprocess.new(current)
-end
-
-class ::Exception
-  SANITIZE_RE = /lib\/polyphony/.freeze
-  SANITIZE_PROC = proc  { |l| l !~ SANITIZE_RE }
-
-  def cleanup_backtrace(caller = nil)
-    combined = caller ? backtrace + caller : backtrace
-    set_backtrace(combined.select(&SANITIZE_PROC))
-  end
-end
-
-class Pulser
-  def initialize(freq)
-    fiber = Fiber.current
-    @timer = EV::Timer.new(freq, freq)
-    @timer.start { fiber.transfer freq }
-  end
-
-  def await
-    suspend
-  rescue Exception => e
-    @timer.stop
-    raise e
-  end
-
-  def stop
-    @timer.stop
-  end
-end
-
-module ::Process
-  def self.detach(pid)
-    spin {
-      EV::Child.new(pid).await
-    }
-  end
-end
-
-require 'open3'
-
-# Kernel extensions (methods available to all objects)
-module ::Kernel
-  def after(duration, &block)
-    EV::Timer.new(freq, 0).start(&block)
-  end
-
-  def async(sym = nil, &block)
-    if sym
-      async_decorate(is_a?(Class) ? self : singleton_class, sym)
-    else
-      Coprocess.new(&block)
-    end
-  end
-
-  # Converts a regular method into an async method, i.e. a method that returns a
-  # proc that eventually executes the original code.
-  # @param receiver [Object] object receiving the method call
-  # @param sym [Symbol] method name
-  # @return [void]
-  def async_decorate(receiver, sym)
-    sync_sym = :"sync_#{sym}"
-    receiver.alias_method(sync_sym, sym)
-    receiver.class_eval("def #{sym}(*args, &block); Coprocess.new { send(#{sync_sym.inspect}, *args, &block) }; end")
-  end
-
-  def cancel_after(duration, &block)
-    CancelScope.new(timeout: duration, mode: :cancel).(&block)
-  end
-
-  def spin(proc = nil, &block)
-    if proc.is_a?(Coprocess)
-      proc.run
-    else
-      Coprocess.new(&(block || proc)).run
-    end
-  end
-
-  def every(freq, &block)
-    EV::Timer.new(freq, freq).start(&block)
-  end
-
-  def move_on_after(duration, &block)
-    CancelScope.new(timeout: duration).(&block)
-  end
-
-  def pulse(freq)
-    Pulser.new(freq)
-  end
-
-  def receive
-    Fiber.current.coprocess.receive
-  end
-
-  alias_method :sync_sleep, :sleep
-  def sleep(duration)
-    timer = EV::Timer.new(duration, 0)
-    timer.await
-  ensure
-    timer.stop
-  end
-
-  def supervise(&block)
-    Supervisor.new.await(&block)
-  end
-
-  alias_method :orig_system, :system
-  def system(*args)
-    Open3.popen2(*args) do |i, o, t|
-      i.close
-      o.read
-    end
-  rescue SystemCallError => e
-    nil
-  end
-
-  def throttled_loop(rate, count: nil, &block)
-    throttler = Throttler.new(rate)
-    if count
-      count.times { throttler.(&block) }
-    else
-      loop { throttler.(&block) }
-    end
-  end
-
-  def throttle(rate)
-    Throttler.new(rate)
-  end
-
-  def timeout(duration, opts = {}, &block)
-    CancelScope.new(**opts, timeout: duration).(&block)
-  end
-end
-
-module ::Timeout
-  def self.timeout(sec, klass = nil, message = nil, &block)
-    cancel_after(sec, &block)
-  rescue Exceptions::Cancel => e
-    error = klass ? klass.new(message) : ::Timeout::Error.new
-    error.set_backtrace(e.backtrace)
-    raise error
-  end
-end

data/lib/polyphony/http/http1_adapter.rb

@@ -1,254 +0,0 @@
-# frozen_string_literal: true
-
-export_default :HTTP1Adapter
-
-require 'http/parser'
-
-Request = import('./request')
-HTTP2 = import('./http2_adapter')
-
-# HTTP1 protocol implementation
-class HTTP1Adapter
-  # Initializes a protocol adapter instance
-  def initialize(conn, opts)
-    @conn = conn
-    @opts = opts
-    @parser = HTTP::Parser.new(self)
-    @parse_fiber = Fiber.new { parse_loop }
-  end
-
-  def protocol
-    'http/1.1'
-  end
-
-  # Parses incoming data, potentially firing parser callbacks. This loop runs on
-  # a separate fiber and is resumed only when the handler (client) loop asks for
-  # headers, or the request body, or waits for the request to be completed. The
-  # control flow is as follows (arrows represent control transfer between
-  # fibers):
-  #
-  #       handler               parse_loop
-  #       get_headers     -->   ...
-  #                             @parser << @conn.readpartial(8192)
-  #       ...             <--   on_headers
-  #
-  #       get_body        -->   ...
-  #       ...             <--   on_body
-  #       
-  #       consume_request -->   ...
-  #                             @parser << @conn.readpartial(8192)
-  #       ...             <--   on_message_complete
-  #
-  def parse_loop
-    while (data = @conn.readpartial(8192))
-      break unless data
-      @parser << data
-      snooze
-    end
-    @calling_fiber.transfer nil
-  rescue SystemCallError, IOError => error
-    # ignore IO/system call errors
-    @calling_fiber.transfer nil
-  rescue Exception => error
-    # an error return value will be raised by the receiving fiber
-    @calling_fiber.transfer error
-  end
-
-  # request API
-
-  # Iterates over incoming requests. Requests are yielded once all headers have
-  # been received. It is left to the application to read the request body or
-  # diesregard it.
-  def each(&block)
-    can_upgrade = true
-    while @parse_fiber.alive? && (headers = get_headers)
-      if can_upgrade
-        # The connection can be upgraded only on the first request
-        return if upgrade_connection(headers, &block)
-        can_upgrade = false
-      end
-
-      @headers_sent = nil
-      block.(Request.new(headers, self))
-      
-      if @parser.keep_alive?
-        @parsing = false
-      else
-        break
-      end
-    end
-  ensure
-    @conn.close rescue nil
-  end
-
-  # Reads headers for the next request. Transfers control to the parse loop,
-  # and resumes once the parse_loop has fired the on_headers callback
-  def get_headers
-    @parsing = true
-    @calling_fiber = Fiber.current
-    @parse_fiber.safe_transfer
-  end
-
-  # Reads a body chunk for the current request. Transfers control to the parse
-  # loop, and resumes once the parse_loop has fired the on_body callback
-  def get_body_chunk
-    @calling_fiber = Fiber.current
-    @read_body = true
-    @parse_fiber.safe_transfer
-  end
-
-  # Waits for the current request to complete. Transfers control to the parse
-  # loop, and resumes once the parse_loop has fired the on_message_complete
-  # callback
-  def consume_request
-    return unless @parsing
-
-    @calling_fiber = Fiber.current
-    @read_body = false
-    @parse_fiber.safe_transfer while @parsing
-  end
-
-  # Upgrades the connection to a different protocol, if the 'Upgrade' header is
-  # given. By default the only supported upgrade protocol is HTTP2. Additional
-  # protocols, notably WebSocket, can be specified by passing a hash to the
-  # :upgrade option when starting a server:
-  #
-  #     opts = {
-  #       upgrade: {
-  #         websocket: Polyphony::Websocket.handler(&method(:ws_handler))
-  #       }
-  #     }
-  #     Polyphony::HTTP::Server.serve('0.0.0.0', 1234, opts) { |req| ... }
-  #
-  # @param headers [Hash] request headers
-  # @return [boolean] truthy if the connection has been upgraded
-  def upgrade_connection(headers, &block)
-    upgrade_protocol = headers['Upgrade']
-    return nil unless upgrade_protocol
-
-    if @opts[:upgrade] && @opts[:upgrade][upgrade_protocol.to_sym]
-      @opts[:upgrade][upgrade_protocol.to_sym].(@conn, headers)
-      return true
-    end
-  
-    return nil unless upgrade_protocol == 'h2c'
-    
-    # upgrade to HTTP/2
-    HTTP2.upgrade_each(@conn, @opts, http2_upgraded_headers(headers), &block)
-    true
-  end
-  
-  # Returns headers for HTTP2 upgrade
-  # @param headers [Hash] request headers
-  # @return [Hash] headers for HTTP2 upgrade
-  def http2_upgraded_headers(headers)
-    headers.merge(
-      ':scheme'     => 'http',
-      ':authority'  => headers['Host'],
-    )
-  end
-    
-  # HTTP parser callbacks, called in the context of @parse_fiber
-
-  # Resumes client fiber on receipt of all headers
-  # @param headers [Hash] request headers
-  # @return [void]
-  def on_headers_complete(headers)
-    headers[':path'] = @parser.request_url
-    headers[':method'] = @parser.http_method
-    @calling_fiber.transfer(headers)
-  end
-
-  # Resumes client fiber on receipt of body chunk
-  # @param chunk [String] body chunk
-  # @return [void]
-  def on_body(chunk)
-    @calling_fiber.transfer(chunk) if @read_body
-  end
-
-  # Resumes client fiber on request completion
-  # @return [void]
-  def on_message_complete
-    @parsing = false
-    @calling_fiber.transfer nil
-  end
-
-  # response API
-
-  # Sends response including headers and body. Waits for the request to complete
-  # if not yet completed. The body is sent using chunked transfer encoding.
-  # @param chunk [String] response body
-  # @param headers
-  def respond(chunk, headers)
-    consume_request if @parsing
-    data = format_headers(headers, empty_response: !chunk)
-    if chunk
-      data << "#{chunk.bytesize.to_s(16)}\r\n#{chunk}\r\n0\r\n\r\n"
-    end
-    @conn << data
-    @headers_sent = true
-  end
-
-  DEFAULT_HEADERS_OPTS = {
-    empty_response: false,
-    consume_request: true
-  }
-
-  # Sends response headers. Waits for the request to complete if not yet
-  # completed. If empty_response is true(thy), the response status code will
-  # default to 204, otherwise to 200.
-  # @param headers [Hash] response headers
-  # @param empty_response [boolean] whether a response body will be sent
-  # @return [void]
-  def send_headers(headers, opts = DEFAULT_HEADERS_OPTS)
-    return if @headers_sent
-
-    consume_request if @parsing && opts[:consume_request]
-    @conn << format_headers(headers, opts[:empty_response])
-    @headers_sent = true
-  end
-
-  # Sends a response body chunk. If no headers were sent, default headers are
-  # sent using #send_headers. if the done option is true(thy), an empty chunk
-  # will be sent to signal response completion to the client.
-  # @param chunk [String] response body chunk
-  # @param done [boolean] whether the response is completed
-  # @return [void]
-  def send_body_chunk(chunk, done: false)
-    send_headers({}) unless @headers_sent
-
-    data = +"#{chunk.bytesize.to_s(16)}\r\n#{chunk}\r\n"
-    data << "0\r\n\r\n" if done
-    @conn << data
-  end
-  
-  # Finishes the response to the current request. If no headers were sent,
-  # default headers are sent using #send_headers.
-  # @return [void]
-  def finish
-    send_headers({}, true) unless @headers_sent
-
-    @conn << "0\r\n\r\n" if @body_sent
-  end
-
-  private
-
-  # Formats response headers. If empty_response is true(thy), the response
-  # status code will default to 204, otherwise to 200.
-  # @param headers [Hash] response headers
-  # @param empty_response [boolean] whether a response body will be sent
-  # @return [String] formatted response headers
-  def format_headers(headers, empty_response)
-    status = headers[':status'] || (empty_response ? 204 : 200)
-    data = empty_response ? 
-      +"HTTP/1.1 #{status}\r\n" :
-      +"HTTP/1.1 #{status}\r\nTransfer-Encoding: chunked\r\n"
-
-    headers.each do |k, v|
-      next if k =~ /^:/
-      v.is_a?(Array) ?
-        v.each { |o| data << "#{k}: #{o}\r\n" } : data << "#{k}: #{v}\r\n"
-    end
-    data << "\r\n"
-  end
-end