polyphony 0.13

data/lib/polyphony/extensions/postgres.rb

@@ -0,0 +1,96 @@
+# frozen_string_literal: true
+
+export :Client
+
+require 'pg'
+
+Core  = import('../core')
+
+module ::PG
+  def self.connect(*args)
+    Connection.connect_start(*args).tap(&method(:connect_async))
+  end
+  
+  def self.connect_async(conn)
+    loop do
+      res = conn.connect_poll
+      case res
+      when PGRES_POLLING_FAILED   then raise Error.new(conn.error_message)
+      when PGRES_POLLING_READING  then conn.socket_io.read_watcher.await
+      when PGRES_POLLING_WRITING  then conn.socket_io.write_watcher.await
+      when PGRES_POLLING_OK       then
+        conn.setnonblocking(true)
+        return
+      end
+    end
+  ensure
+    conn.socket_io.stop_watchers
+  end
+
+  def self.connect_sync(conn)
+    loop do
+      res = conn.connect_poll
+      case res
+      when PGRES_POLLING_FAILED   then raise Error.new(conn.error_message)
+      when PGRES_POLLING_OK       then
+        conn.setnonblocking(true)
+        return
+      end
+    end
+  end
+end
+
+class ::PG::Connection
+  alias_method :orig_get_result, :get_result
+  
+  def get_result(&block)
+    while is_busy
+      socket_io.read_watcher.await
+      consume_input
+    end
+    orig_get_result(&block)
+  ensure
+    socket_io.stop_watchers
+  end
+
+  alias_method :orig_async_exec, :async_exec
+  def async_exec(*args, &block)
+    send_query(*args)
+    result = get_result(&block)
+    while get_result; end
+    result
+  end
+
+  def block(timeout = 0)
+    while is_busy
+      socket_io.read_watcher.await
+      consume_input
+    end
+  end
+
+  SQL_BEGIN = 'begin'
+  SQL_COMMIT = 'commit'
+  SQL_ROLLBACK = 'rollback'
+
+  # Starts a transaction, runs given block, and commits transaction. If an
+  # error is raised, the transaction is rolled back and the error is raised
+  # again.
+  # @return [void]
+  def transaction
+    began = false
+    return yield if @transaction # allow nesting of calls to #transactions
+
+    query(SQL_BEGIN)
+    began = true
+    @transaction = true
+    yield
+    query(SQL_COMMIT)
+  rescue StandardError => e
+    (query(SQL_ROLLBACK) rescue nil) if began
+    raise e
+  ensure
+    @transaction = false if began
+  end
+
+  self.async_api = true
+end

data/lib/polyphony/extensions/redis.rb

@@ -0,0 +1,68 @@
+# frozen_string_literal: true
+
+export :Connection
+
+require "redis"
+require "hiredis/reader"
+
+Net = import('../net')
+
+class Driver
+  def self.connect(config)
+    if config[:scheme] == "unix"
+      raise "unix sockets not supported"
+      # connection.connect_unix(config[:path], connect_timeout)
+    elsif config[:scheme] == "rediss" || config[:ssl]
+      raise "ssl not supported"
+      # raise NotImplementedError, "SSL not supported by hiredis driver"
+    else
+      new(config[:host], config[:port])
+      # connection.connect(config[:host], config[:port], connect_timeout)
+    end
+  end
+
+  def initialize(host, port)
+    @connection = Net.tcp_connect(host, port)
+    @reader = ::Hiredis::Reader.new
+  end
+
+  def connected?
+    @connection && !@connection.closed?
+  end
+
+  def timeout=(timeout)
+    # ignore timeout for now
+  end
+
+  def disconnect
+    @connection.close
+    @connection = nil
+  end
+
+  def write(command)
+    @connection.write(format_command(command))
+  end
+
+  def format_command(args)
+    (+"*#{args.size}\r\n").tap do |s|
+      args.each do |a|
+        a = a.to_s
+        s << "$#{a.bytesize}\r\n#{a}\r\n"
+      end
+    end
+  end
+
+  def read
+    reply = @reader.gets
+    return reply if reply
+    
+    loop do
+      data = @connection.read
+      @reader.feed(data)
+      reply = @reader.gets
+      return reply if reply
+    end
+  end
+end
+
+Redis::Connection.drivers << Driver

data/lib/polyphony/extensions/socket.rb

@@ -0,0 +1,85 @@
+# frozen_string_literal: true
+
+require 'socket'
+
+import('./io')
+
+class ::Socket
+  def accept
+    loop do
+      result, client_addr = accept_nonblock(::IO::NO_EXCEPTION)
+      case result
+      when Socket         then return result
+      when :wait_readable then read_watcher.await
+      else
+        raise "failed to accept (#{result.inspect})"
+      end
+    end
+  ensure
+    @read_watcher&.stop
+  end
+
+  def connect(remotesockaddr)
+    loop do
+      result = connect_nonblock(remotesockaddr, ::IO::NO_EXCEPTION)
+      case result
+      when 0              then return
+      when :wait_writable then write_watcher.await
+      else                raise IOError
+      end
+    end
+  ensure
+    @write_watcher&.stop
+  end
+
+  def recvfrom(maxlen, flags = 0)
+    @read_buffer ||= +''
+    loop do
+      result = recvfrom_nonblock(maxlen, flags, @read_buffer, ::IO::NO_EXCEPTION)
+      case result
+      when nil            then raise IOError
+      when :wait_readable then read_watcher.await
+      else                return result
+      end
+    end
+  ensure
+    @read_watcher&.stop
+  end
+
+  ZERO_LINGER = [0, 0].pack("ii")
+
+  def dont_linger
+    setsockopt(Socket::SOL_SOCKET, Socket::SO_LINGER, ZERO_LINGER)
+  end
+
+  def no_delay
+    setsockopt(Socket::IPPROTO_TCP, Socket::TCP_NODELAY, 1)
+  end
+
+  def reuse_addr
+    setsockopt(Socket::SOL_SOCKET, Socket::SO_REUSEADDR, 1)
+  end
+
+  class << self
+    alias_method :orig_getaddrinfo, :getaddrinfo
+    def getaddrinfo(*args)
+      Polyphony::ThreadPool.process { orig_getaddrinfo(*args) }
+    end
+  end
+end
+
+class ::TCPServer
+  def accept
+    loop do
+      result, client_addr = accept_nonblock(::IO::NO_EXCEPTION)
+      case result
+      when TCPSocket         then return result
+      when :wait_readable then read_watcher.await
+      else
+        raise "failed to accept (#{result.inspect})"
+      end
+    end
+  ensure
+    @read_watcher&.stop
+  end
+end

data/lib/polyphony/extensions/ssl.rb

@@ -0,0 +1,73 @@
+# frozen_string_literal: true
+
+require 'openssl'
+
+import('./socket')
+
+class ::OpenSSL::SSL::SSLSocket
+  def accept
+    loop do
+      result = accept_nonblock(::IO::NO_EXCEPTION)
+      case result
+      when :wait_readable then io.read_watcher.await
+      when :wait_writable then io.write_watcher.await
+      else                     return true
+      end
+    end
+  ensure
+    io.stop_watchers
+  end
+
+  def connect
+    loop do
+      result = connect_nonblock(::IO::NO_EXCEPTION)
+      case result
+      when :wait_readable then io.read_watcher.await
+      when :wait_writable then io.write_watcher.await
+      else                     return true
+      end
+    end
+  ensure
+    io.stop_watchers
+  end
+
+  def read(max = 8192)
+    @read_buffer ||= +''
+    loop do
+      result = read_nonblock(max, @read_buffer, ::IO::NO_EXCEPTION)
+      case result
+      when nil            then raise ::IOError
+      when :wait_readable then io.read_watcher.await
+      else                return result
+      end
+    end
+  ensure
+    io.stop_watchers
+  end
+
+  def write(data)
+    loop do
+      result = write_nonblock(data, ::IO::NO_EXCEPTION)
+      case result
+      when nil            then raise ::IOError
+      when :wait_writable then io.write_watcher.await
+      else
+        (result == data.bytesize) ? (return result) : (data = data[result..-1])
+      end
+    end
+  ensure
+    io.stop_watchers
+  end
+
+  def dont_linger
+    io.dont_linger
+  end
+
+  def no_delay
+    io.no_delay
+  end
+
+  def reuse_addr
+    io.reuse_addr
+  end
+end

data/lib/polyphony/fs.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+export  :stat,
+        :read
+
+require 'fileutils'
+
+ThreadPool = import('./core/thread_pool')
+
+::File.singleton_class.instance_eval do
+  alias_method :orig_stat, :stat
+  def stat(path)
+    ThreadPool.process { orig_stat(path) }
+  end
+end
+
+::IO.singleton_class.instance_eval do
+  alias_method :orig_read, :read
+  def read(path)
+    ThreadPool.process { orig_read(path) }
+  end
+end

data/lib/polyphony/http/agent.rb

@@ -0,0 +1,214 @@
+# frozen_string_literal: true
+
+export_default :Agent
+
+require 'uri'
+require 'http/parser'
+require 'http/2'
+require 'json'
+
+ResourcePool = import('../resource_pool')
+
+module ResponseMixin
+  def body
+    self[:body]
+  end
+
+  def json
+    @json ||= ::JSON.parse(self[:body])
+  end
+end
+
+# Implements an HTTP agent
+class Agent
+  def self.get(url, query = nil)
+    default.get(url, query)
+  end
+
+  def self.post(url, query = nil)
+    default.post(url, query)
+  end
+
+  def self.default
+    @default ||= new
+  end
+
+  def initialize(max_conns = 6)
+    @pools = Hash.new do |h, k|
+      h[k] = ResourcePool.new(limit: max_conns) { {} }
+    end
+  end
+
+  def get(url, query = nil)
+    request(url, method: :GET, query: query)
+  end
+
+  def post(url, query = nil)
+    request(url, method: :POST, query: query)
+  end
+
+  S_LOCATION = 'Location'
+
+  OPTS_DEFAULT = {}.freeze
+
+  def request(url, opts = OPTS_DEFAULT)
+    ctx = request_ctx(url, opts)
+    response = do_request(ctx)
+
+    case response[:status_code]
+    when 301, 302
+      request(response[:headers][S_LOCATION])
+    when 200, 204
+      response.extend(ResponseMixin)
+    else
+      raise "Error received from server: #{response[:status_code]}"
+    end
+  end
+
+  def request_ctx(url, opts)
+    {
+      method: opts[:method] || :GET,
+      uri:    url_to_uri(url, opts),
+      opts:   opts
+    }
+  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)
+    key = uri_key(ctx[:uri])
+    @pools[key].acquire do |state|
+      state[:socket] ||=  connect(key)
+      state[:protocol_method] ||= protocol_method(state[:socket], ctx)
+      send(state[:protocol_method], state, ctx)
+    rescue => e
+      state[:socket]&.close rescue nil
+      state.clear
+      raise e
+    end
+  end
+
+  S_H2 = 'h2'
+
+  def protocol_method(socket, ctx)
+    if socket.is_a?(::OpenSSL::SSL::SSLSocket) && (socket.alpn_protocol == S_H2)
+      :do_http2
+    else
+      :do_http1
+    end
+  end
+
+  def do_http1(state, ctx)
+    done = false
+    body = +''
+    parser = HTTP::Parser.new
+    parser.on_message_complete = proc { done = true }
+    parser.on_body = proc { |data| body << data }
+    request = format_http1_request(ctx)
+
+    state[:socket] << request
+    while !done
+      parser << state[:socket].read
+    end
+
+    {
+      protocol:     'http1.1',
+      status_code:  parser.status_code,
+      headers:      parser.headers,
+      body:         body
+    }
+  end
+
+  def do_http2(state, ctx)
+    unless state[:http2_client]
+      socket, client = state[:socket], HTTP2::Client.new
+      client.on(:frame) {|bytes| socket << bytes }
+      state[:http2_client] = client
+    end
+
+    stream = state[:http2_client].new_stream # allocate new stream
+
+    headers = {
+      ':scheme'     => ctx[:uri].scheme,
+      ':method'     => ctx[:method].to_s,
+      ':path'       => ctx[:uri].request_uri,
+      ':authority'  => [ctx[:uri].host, ctx[:uri].port].join(':'),
+    }
+    headers.merge!(ctx[:opts][:headers]) if ctx[:opts][:headers]
+
+    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
+
+    headers = nil
+    body = +''
+    done = nil
+
+    stream.on(:headers) { |h| headers = h.to_h }
+    stream.on(:data) { |c| body << c }
+    stream.on(:close) {
+      done = true
+      return {
+        protocol:     'http1.1',
+        status_code:  headers && headers[':status'].to_i,
+        headers:      headers || {},
+        body:         body
+      }
+    }
+
+    while data = state[:socket].read
+      state[:http2_client] << data
+    end
+  ensure
+    (stream.close rescue nil) unless done
+  end
+
+  HTTP1_REQUEST = "%<method>s %<request>s HTTP/1.1\r\nHost: %<host>s\r\n\r\n"
+
+  def format_http1_request(ctx)
+    HTTP1_REQUEST % {
+      method:   ctx[:method],
+      request:  ctx[:uri].request_uri,
+      host:     ctx[:uri].host
+    }
+  end
+
+  def uri_key(uri)
+    {
+      scheme: uri.scheme,
+      host:   uri.host,
+      port:   uri.port
+    }
+  end
+
+  S_HTTP = 'http'
+  S_HTTPS = 'https'
+  SECURE_OPTS = { secure: true, alpn_protocols: ['h2', 'http/1.1'] }
+
+  def connect(key)
+    case key[:scheme]
+    when S_HTTP
+      Polyphony::Net.tcp_connect(key[:host], key[:port])
+    when S_HTTPS
+      Polyphony::Net.tcp_connect(key[:host], key[:port], SECURE_OPTS).tap do |socket|
+        socket.post_connection_check(key[:host])
+      end
+    else
+      raise "Invalid scheme #{key[:scheme].inspect}"
+    end
+  end
+end