polyphony 0.19 → 0.20

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

@@ -0,0 +1,64 @@
+# frozen_string_literal: true
+
+export :load
+
+require 'rack'
+
+def run(app)
+  ->(req) { respond(req, app.(env(req))) }
+end
+
+def load(path)
+  src = IO.read(path)
+  instance_eval(src, path, 1)
+end
+
+# Implements a rack input stream:
+# https://www.rubydoc.info/github/rack/rack/master/file/SPEC#label-The+Input+Stream
+class InputStream
+  def initialize(request)
+    @request = request
+  end
+
+  def gets; end
+
+  def read(length = nil, outbuf = nil); end
+
+  def each(&block)
+    @request.each_chunk(&block)
+  end
+
+  def rewind; end
+end
+
+def env(request)
+  {
+    'REQUEST_METHOD'                 => request.method,
+    'SCRIPT_NAME'                    => '',
+    'PATH_INFO'                      => request.path,
+    'QUERY_STRING'                   => request.query_string || '',
+    'SERVER_NAME'                    => request.headers['Host'], # ?
+    'SERVER_PORT'                    => '80', # ?
+    'rack.version'                   => Rack::VERSION,
+    'rack.url_scheme'                => 'https', # ?
+    'rack.input'                     => InputStream.new(request),
+    'rack.errors'                    => STDERR, # ?
+    'rack.multithread'               => false,
+    'rack.run_once'                  => false,
+    'rack.hijack?'                   => false,
+    'rack.hijack'                    => nil,
+    'rack.hijack_io'                 => nil,
+    'rack.session'                   => nil,
+    'rack.logger'                    => nil,
+    'rack.multipart.buffer_size'     => nil,
+    'rack.multipar.tempfile_factory' => nil
+  }.tap do |env|
+    request.headers.each { |k, v| env["HTTP_#{k.upcase}"] = v }
+  end
+end
+
+def respond(request, (status_code, headers, body))
+  headers[':status'] = status_code.to_s
+  puts "headers: #{headers.inspect}"
+  request.respond(body.first, headers)
+end

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

@@ -0,0 +1,119 @@
+# frozen_string_literal: true
+
+export_default :Request
+
+require 'uri'
+
+# HTTP request
+class Request
+  attr_reader :headers, :adapter
+  attr_accessor :__next__
+
+  def initialize(headers, adapter)
+    @headers  = headers
+    @adapter  = adapter
+  end
+
+  def protocol
+    @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_string
+    @query_string ||= uri.query
+  end
+
+  def query
+    return @query if @query
+
+    @query = (q = uri.query) ? split_query_string(q) : {}
+  end
+
+  def split_query_string(query)
+    query.split('&').each_with_object({}) do |kv, h|
+      k, v = kv.split('=')
+      h[k.to_sym] = URI.decode_www_form_component(v)
+    end
+  end
+
+  def buffer_body_chunk(chunk)
+    @buffered_body_chunks ||= []
+    @buffered_body_chunks << chunk
+  end
+
+  def each_chunk(&block)
+    if @buffered_body_chunks
+      puts 'serve buffered body_chunks'
+      @buffered_body_chunks.each(&block)
+      @buffered_body_chunks = nil
+    end
+    while !@message_complete && (chunk = @adapter.get_body_chunk)
+      yield chunk
+    end
+  end
+
+  def complete!(keep_alive = nil)
+    @message_complete = true
+    @keep_alive = keep_alive
+  end
+
+  def complete?
+    @message_complete
+  end
+
+  def consume
+    @adapter.consume_request
+  end
+
+  def keep_alive?
+    @keep_alive
+  end
+
+  def read
+    buf = @buffered_body_chunks ? @buffered_body_chunks.join : +''
+    while (chunk = @adapter.get_body_chunk)
+      buf << chunk
+    end
+    buf
+  end
+
+  def respond(body, headers = {})
+    @adapter.respond(body, headers)
+    @headers_sent = true
+  end
+
+  def send_headers(headers = {}, empty_response = false)
+    return if @headers_sent
+
+    @headers_sent = true
+    @adapter.send_headers(headers, empty_response: empty_response)
+  end
+
+  def send_chunk(body, done: false)
+    send_headers({}) unless @headers_sent
+
+    @adapter.send_chunk(body, done: done)
+  end
+  alias_method :<<, :send_chunk
+
+  def finish
+    send_headers({}) unless @headers_sent
+
+    @adapter.finish
+  end
+end

data/lib/polyphony/net.rb

@@ -7,10 +7,10 @@ import('./extensions/socket')
 import('./extensions/openssl')
 
 def tcp_connect(host, port, opts = {})
-  socket = ::Socket.new(:INET, :STREAM).tap { |s|
+  socket = ::Socket.new(:INET, :STREAM).tap do |s|
     addr = ::Socket.sockaddr_in(port, host)
     s.connect(addr)
-  }
+  end
   if opts[:secure_context] || opts[:secure]
     secure_socket(socket, opts[:secure_context], opts.merge(host: host))
   else
@@ -20,27 +20,30 @@ end
 
 def tcp_listen(host = nil, port = nil, opts = {})
   host ||= '0.0.0.0'
-  raise "Port number not specified" unless port
-  socket = ::Socket.new(:INET, :STREAM).tap { |s|
+  raise 'Port number not specified' unless port
+
+  socket = socket_from_options(host, port, opts)
+  if opts[:secure_context] || opts[:secure]
+    secure_server(socket, opts[:secure_context], opts)
+  else
+    socket
+  end
+end
+
+def socket_from_options(host, port, opts)
+  ::Socket.new(:INET, :STREAM).tap do |s|
     s.reuse_addr if opts[:reuse_addr]
     s.dont_linger if opts[:dont_linger]
     addr = ::Socket.sockaddr_in(port, host)
     s.bind(addr)
     s.listen(0)
-  }
-  if opts[:secure_context] || opts[:secure]
-    secure_server(socket, opts[:secure_context], opts)
-  else
-    socket
   end
 end
 
 def secure_socket(socket, context, opts)
   setup_alpn(context, opts[:alpn_protocols]) if context && opts[:alpn_protocols]
-  socket = context ?
-    OpenSSL::SSL::SSLSocket.new(socket, context) :
-    OpenSSL::SSL::SSLSocket.new(socket)
-  
+  socket = secure_socket_wrapper(socket, context)
+
   socket.tap do |s|
     s.hostname = opts[:host] if opts[:host]
     s.connect
@@ -48,6 +51,14 @@ def secure_socket(socket, context, opts)
   end
 end
 
+def secure_socket_wrapper(socket, context)
+  if context
+    OpenSSL::SSL::SSLSocket.new(socket, context)
+  else
+    OpenSSL::SSL::SSLSocket.new(socket)
+  end
+end
+
 def secure_server(socket, context, opts)
   setup_alpn(context, opts[:alpn_protocols]) if opts[:alpn_protocols]
   OpenSSL::SSL::SSLServer.new(socket, context)
@@ -55,7 +66,7 @@ end
 
 def setup_alpn(context, protocols)
   context.alpn_protocols = protocols
-  context.alpn_select_cb = ->(peer_protocols) {
+  context.alpn_select_cb = lambda do |peer_protocols|
     (protocols & peer_protocols).first
-  }
+  end
 end

data/lib/polyphony/postgres.rb

@@ -3,21 +3,20 @@
 require_relative '../polyphony'
 require 'pg'
 
+# PG overrides
 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_FAILED   then raise Error, 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
+      when PGRES_POLLING_OK       then return conn.setnonblocking(true)
       end
     end
   end
@@ -26,8 +25,9 @@ module ::PG
     loop do
       res = conn.connect_poll
       case res
-      when PGRES_POLLING_FAILED   then raise Error.new(conn.error_message)
-      when PGRES_POLLING_OK       then
+      when PGRES_POLLING_FAILED
+        raise Error, conn.error_message
+      when PGRES_POLLING_OK
         conn.setnonblocking(true)
         return
       end
@@ -35,9 +35,10 @@ module ::PG
   end
 end
 
+# Overrides for PG connection
 class ::PG::Connection
   alias_method :orig_get_result, :get_result
-  
+
   def get_result(&block)
     while is_busy
       socket_io.read_watcher.await
@@ -55,7 +56,7 @@ class ::PG::Connection
     while get_result; end
   end
 
-  def block(timeout = 0)
+  def block(_timeout = 0)
     while is_busy
       socket_io.read_watcher.await
       consume_input
@@ -70,20 +71,23 @@ class ::PG::Connection
   # error is raised, the transaction is rolled back and the error is raised
   # again.
   # @return [void]
-  def transaction
-    began = false
+  def transaction(&block)
     return yield if @transaction # allow nesting of calls to #transactions
 
+    perform_transaction(&block)
+  end
+
+  def perform_transaction
     query(SQL_BEGIN)
     began = true
     @transaction = true
     yield
     query(SQL_COMMIT)
   rescue StandardError => e
-    (query(SQL_ROLLBACK) rescue nil) if began
+    query(SQL_ROLLBACK) if began
     raise e
   ensure
-    @transaction = false if began
+    @transaction = false
   end
 
   self.async_api = true

data/lib/polyphony/redis.rb

@@ -2,21 +2,22 @@
 
 require_relative '../polyphony'
 
-require "redis"
-require "hiredis/reader"
+require 'redis'
+require 'hiredis/reader'
 
+# Polyphony-based Redis driver
 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
+    raise 'unix sockets not supported' if config[:scheme] == 'unix'
+
+    # connection.connect_unix(config[:path], connect_timeout)
+
+    raise 'ssl not supported' if config[:scheme] == 'rediss' || config[:ssl]
+
+    # raise NotImplementedError, "SSL not supported by hiredis driver"
+
+    new(config[:host], config[:port])
+    # connection.connect(config[:host], config[:port], connect_timeout)
   end
 
   def initialize(host, port)
@@ -53,13 +54,13 @@ class Driver
   def read
     reply = @reader.gets
     return reply if reply
-    
+
     while (data = @connection.readpartial(8192))
       @reader.feed(data)
       reply = @reader.gets
-      return reply if reply
+      return reply unless reply == false
     end
   end
 end
 
-Redis::Connection.drivers << Driver
+Redis::Connection.drivers << Driver

data/lib/polyphony/version.rb

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

data/lib/polyphony/websocket.rb

@@ -5,6 +5,7 @@ export :handler
 require 'digest/sha1'
 require 'websocket'
 
+# Websocket connection
 class WebsocketConnection
   def initialize(client, headers)
     @client = client
@@ -13,24 +14,30 @@ class WebsocketConnection
   end
 
   S_WS_GUID = '258EAFA5-E914-47DA-95CA-C5AB0DC85B11'
-  UPGRADE_RESPONSE = "HTTP/1.1 101 Switching Protocols\r\nUpgrade: websocket\r\nConnection: Upgrade\r\nSec-WebSocket-Accept: %s\r\n\r\n"
+  UPGRADE_RESPONSE = <<~HTTP.gsub("\n", "\r\n")
+    HTTP/1.1 101 Switching Protocols
+    Upgrade: websocket
+    Connection: Upgrade
+    Sec-WebSocket-Accept: %<accept>s
+
+  HTTP
 
   def setup(headers)
     key = headers['Sec-WebSocket-Key']
     @version = headers['Sec-WebSocket-Version'].to_i
     accept = Digest::SHA1.base64digest([key, S_WS_GUID].join)
-    @client << UPGRADE_RESPONSE % accept
+    @client << format(UPGRADE_RESPONSE, accept: accept)
 
     @reader = ::WebSocket::Frame::Incoming::Server.new(version: @version)
   end
 
   def recv
-    while true
+    loop do
       data = @client.readpartial(8192)
       break nil unless data
 
       @reader << data
-      if msg = @reader.next
+      if (msg = @reader.next)
         break msg.to_s
       end
     end