polyphony 0.19 → 0.20

data/lib/polyphony/extensions/io.rb

@@ -1,5 +1,8 @@
 # frozen_string_literal: true
 
+require 'open3'
+
+# IO overrides
 class ::IO
   class << self
     alias_method :orig_binread, :binread
@@ -18,11 +21,14 @@ class ::IO
       end
     end
 
-    EMPTY_HASH = {}
+    EMPTY_HASH = {}.freeze
 
     alias_method :orig_foreach, :foreach
     def foreach(name, sep = $/, limit = nil, getline_args = EMPTY_HASH, &block)
-      sep, limit = $/, sep if sep.is_a?(Integer)
+      if sep.is_a?(Integer)
+        sep = $/
+        limit = sep
+      end
       File.open(name, 'r') do |f|
         f.each_line(sep, limit, getline_args, &block)
       end
@@ -30,7 +36,10 @@ class ::IO
 
     alias_method :orig_read, :read
     def read(name, length = nil, offset = nil, opt = EMPTY_HASH)
-      opt, length = length, nil if length.is_a?(Hash)
+      if length.is_a?(Hash)
+        opt = length
+        length = nil
+      end
       File.open(name, opt[:mode] || 'r') do |f|
         f.seek(offset) if offset
         length ? f.read(length) : f.read
@@ -40,7 +49,6 @@ class ::IO
     # alias_method :orig_readlines, :readlines
     # def readlines(name, sep = $/, limit = nil, getline_args = EMPTY_HASH)
     #   File.open(name, 'r') do |f|
-    #     puts "readlines(#{sep.inspect}, #{limit.inspect}, #{getline_args.inspect}"
     #     f.readlines(sep, limit, getline_args)
     #   end
     # end
@@ -54,10 +62,10 @@ class ::IO
     end
 
     alias_method :orig_popen, :popen
-    def popen(*args)
-      Open3.popen2(*args) do |i, o, t|
-        yield o
-      end
+    def popen(cmd, mode = 'r')
+      return orig_popen(cmd, mode) unless block_given?
+
+      Open3.popen2(cmd) { |_i, o, _t| yield o }
     end
   end
 
@@ -82,8 +90,11 @@ class ::IO
   # end
 
   alias_method :orig_gets, :gets
-  def gets(sep = $/, limit = nil, chomp: nil)
-    sep, limit = $/, sep if sep.is_a?(Integer)
+  def gets(sep = $/, _limit = nil, _chomp: nil)
+    if sep.is_a?(Integer)
+      sep = $/
+      _limit = sep
+    end
     sep_size = sep.bytesize
 
     @gets_buffer ||= +''
@@ -92,12 +103,13 @@ class ::IO
       idx = @gets_buffer.index(sep)
       return @gets_buffer.slice!(0, idx + sep_size) if idx
 
-      data = readpartial(8192)
-      if data
+      if (data = readpartial(8192))
         @gets_buffer << data
       else
         return nil if @gets_buffer.empty?
-        line, @gets_buffer = @gets_buffer.freeze, +''
+
+        line = @gets_buffer.freeze
+        @gets_buffer = +''
         return line
       end
     end
@@ -130,6 +142,7 @@ class ::IO
       end
     end
     write s
+    nil
   end
 
   # def readbyte
@@ -144,14 +157,13 @@ class ::IO
   # def readlines(sep = $/, limit = nil, chomp: nil)
   # end
 
-  def write_nonblock(string, options = {})
+  def write_nonblock(string, _options = {})
     # STDOUT << '>'
     write(string, 0)
   end
 
-  def read_nonblock(maxlen, buf = nil, options = nil)
+  def read_nonblock(maxlen, buf = nil, _options = nil)
     # STDOUT << '<'
     buf ? readpartial(maxlen, buf) : readpartial(maxlen)
   end
-
 end

data/lib/polyphony/extensions/openssl.rb

@@ -4,6 +4,7 @@ require 'openssl'
 
 import('./socket')
 
+# Open ssl socket helper methods (to make it compatible with Socket API)
 class ::OpenSSL::SSL::SSLSocket
   def dont_linger
     io.dont_linger
@@ -16,4 +17,4 @@ class ::OpenSSL::SSL::SSLSocket
   def reuse_addr
     io.reuse_addr
   end
-end
+end

data/lib/polyphony/extensions/socket.rb

@@ -4,31 +4,16 @@ require 'socket'
 
 import('./io')
 
+# Socket overrides (eventually rewritten in C)
 class ::Socket
   NO_EXCEPTION = { exception: false }.freeze
 
-  def accept
-    loop do
-      result, client_addr = accept_nonblock(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, NO_EXCEPTION)
-      case result
-      when 0              then return
-      when :wait_writable then write_watcher.await
-      else                raise IOError
-      end
+      return if result == 0
+
+      result == :wait_writable ? write_watcher.await : (raise IOError)
     end
   ensure
     @write_watcher&.stop
@@ -38,12 +23,9 @@ class ::Socket
     outbuf ||= +''
     loop do
       result = recv_nonblock(maxlen, flags, outbuf, NO_EXCEPTION)
-      case result
-      when :wait_readable
-        read_watcher.await
-      else
-        return result
-      end
+      raise IOError unless result
+
+      result == :wait_readable ? read_watcher.await : (return result)
     end
   end
 
@@ -51,17 +33,15 @@ class ::Socket
     @read_buffer ||= +''
     loop do
       result = recvfrom_nonblock(maxlen, flags, @read_buffer, NO_EXCEPTION)
-      case result
-      when nil            then raise IOError
-      when :wait_readable then read_watcher.await
-      else                return result
-      end
+      raise IOError unless result
+
+      result == :wait_readable ? read_watcher.await : (return result)
     end
   ensure
     @read_watcher&.stop
   end
 
-  ZERO_LINGER = [0, 0].pack("ii")
+  ZERO_LINGER = [0, 0].pack('ii').freeze
 
   def dont_linger
     setsockopt(Socket::SOL_SOCKET, Socket::SO_LINGER, ZERO_LINGER)
@@ -83,46 +63,61 @@ class ::Socket
   end
 end
 
+# Overide stock TCPSocket code by encapsulating a Socket instance
 class ::TCPSocket
   NO_EXCEPTION = { exception: false }.freeze
 
-  def foo; :bar; end
-
-  def initialize(remote_host, remote_port, local_host=nil, local_port=nil)
+  def initialize(remote_host, remote_port, local_host = nil, local_port = nil)
     @io = Socket.new Socket::AF_INET, Socket::SOCK_STREAM
     if local_host && local_port
-      @io.bind(Addrinfo.tcp(local_host, local_port))
+      addr = Addrinfo.tcp(local_host, local_port)
+      @io.bind(addr)
     end
-    @io.connect(Addrinfo.tcp(remote_host, remote_port))
+
+    return unless remote_host && remote_port
+
+    addr = Addrinfo.tcp(remote_host, remote_port)
+    @io.connect(addr)
   end
 
+  alias_method :orig_close, :close
   def close
-    @io.close
+    @io ? @io.close : orig_close
   end
 
+  alias_method :orig_setsockopt, :setsockopt
   def setsockopt(*args)
-    @io.setsockopt(*args)
+    @io ? @io.setsockopt(*args) : orig_setsockopt(*args)
   end
 
+  alias_method :orig_closed?, :closed?
   def closed?
-    @io.closed?
+    @io ? @io.closed? : orig_closed?
+  end
+
+  def dont_linger
+    setsockopt(::Socket::SOL_SOCKET, ::Socket::SO_LINGER, ::Socket::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
 end
 
+# Override stock TCPServer code by encapsulating a Socket instance.
 class ::TCPServer
-  NO_EXCEPTION = { exception: false }.freeze
+  def initialize(hostname = nil, port = 0)
+    @io = Socket.new Socket::AF_INET, Socket::SOCK_STREAM
+    @io.bind(Addrinfo.tcp(hostname, port))
+    @io.listen(0)
+  end
 
+  alias_method :orig_accept, :accept
   def accept
-    loop do
-      result, client_addr = accept_nonblock(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
+    @io ? @io.accept : orig_accept
   end
-end
+end

data/lib/polyphony/http.rb

@@ -3,11 +3,12 @@
 require_relative '../polyphony'
 
 module Polyphony
+  # HTTP imports (loaded dynamically)
   module HTTP
     auto_import(
-      Agent:      './http/agent',
-      Rack:       './http/rack',
-      Server:     './http/server',
+      Agent:  './http/agent',
+      Rack:   './http/server/rack',
+      Server: './http/server'
     )
   end
 end

data/lib/polyphony/http/agent.rb

@@ -9,6 +9,7 @@ require 'json'
 
 ResourcePool = import('../core/resource_pool')
 
+# Response mixin
 module ResponseMixin
   def body
     self[:body]
@@ -49,7 +50,6 @@ class Agent
     request(url, opts.merge(method: :POST))
   end
 
-
   def request(url, opts = OPTS_DEFAULT)
     ctx = request_ctx(url, opts)
 
@@ -66,19 +66,20 @@ class Agent
 
   def redirect(url, ctx, opts)
     url = case url
-    when /^http(?:s)?\:\/\//
-      url
-    when /^\/\/(.+)$/
-      ctx[:uri].scheme + url
-    when /^\//
-      "%s://%s%s" % [
-        ctx[:uri].scheme,
-        ctx[:uri].host,
-        url
-      ]
-    else
-      ctx[:uri] + url
-    end
+          when /^http(?:s)?\:\/\//
+            url
+          when /^\/\/(.+)$/
+            ctx[:uri].scheme + url
+          when /^\//
+            format(
+              '%<scheme>s://%<host>s%<url>s',
+              scheme: ctx[:uri].scheme,
+              host:   ctx[:uri].host,
+              url:    url
+            )
+          else
+            ctx[:uri] + url
+          end
 
     request(url, opts)
   end
@@ -88,14 +89,14 @@ class Agent
       method: opts[:method] || :GET,
       uri:    url_to_uri(url, opts),
       opts:   opts,
-      retry:  0,
+      retry:  0
     }
   end
 
   def url_to_uri(url, opts)
     uri = URI(url)
     if opts[:query]
-      query = opts[:query].map { |k, v| "#{k}=#{v}" }.join("&")
+      query = opts[:query].map { |k, v| "#{k}=#{v}" }.join('&')
       if uri.query
         v.query = "#{uri.query}&#{query}"
       else
@@ -109,23 +110,22 @@ class Agent
     key = uri_key(ctx[:uri])
     @pools[key].acquire do |state|
       cancel_after(10) do
-        state[:socket] ||=  connect(key)
+        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
+      rescue Exception => e
+        state[:socket]&.close
         state.clear
-        if ctx[:retry] < 3
-          ctx[:retry] += 1
-          do_request(ctx)
-        else
-          raise e
-        end
+
+        raise e unless ctx[:retry] < 3
+
+        ctx[:retry] += 1
+        do_request(ctx)
       end
     end
   end
 
-  def protocol_method(socket, ctx)
+  def protocol_method(socket, _ctx)
     if socket.is_a?(::OpenSSL::SSL::SSLSocket) && (socket.alpn_protocol == 'h2')
       :do_http2
     else
@@ -142,32 +142,31 @@ class Agent
     request = format_http1_request(ctx)
 
     state[:socket] << request
-    while !done
-      parser << state[:socket].readpartial(8192)
-    end
+    parser << state[:socket].readpartial(8192) until done
 
     {
-      protocol:     'http1.1',
-      status_code:  parser.status_code,
-      headers:      parser.headers,
-      body:         body
+      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 }
+      socket = state[:socket]
+      client = HTTP2::Client.new
+      client.on(:frame) { |bytes| socket << bytes }
       state[:http2_client] = client
     end
 
     stream = state[:http2_client].new_stream # allocate new stream
 
     headers = {
-      ':method'     => ctx[:method].to_s,
-      ':scheme'     => ctx[:uri].scheme,      
-      ':authority'  => [ctx[:uri].host, ctx[:uri].port].join(':'),
-      ':path'       => ctx[:uri].request_uri,
+      ':method'    => ctx[:method].to_s,
+      ':scheme'    => ctx[:uri].scheme,
+      ':authority' => [ctx[:uri].host, ctx[:uri].port].join(':'),
+      ':path'      => ctx[:uri].request_uri
     }
     headers.merge!(ctx[:opts][:headers]) if ctx[:opts][:headers]
     puts "* proxy request headers: #{headers.inspect}"
@@ -185,35 +184,47 @@ class Agent
 
     stream.on(:headers) { |h| headers = h.to_h }
     stream.on(:data) { |c| body << c }
-    stream.on(:close) {
+    stream.on(:close) do
       done = true
       return {
-        protocol:     'http2',
-        status_code:  headers && headers[':status'].to_i,
-        headers:      headers || {},
-        body:         body
+        protocol:    'http2',
+        status_code: headers && headers[':status'].to_i,
+        headers:     headers || {},
+        body:        body
       }
-    }
+    end
 
-    while data = state[:socket].readpartial(8192)
+    while (data = state[:socket].readpartial(8192))
       state[:http2_client] << data
     end
   ensure
-    (stream.close rescue nil) unless done
+    stream.close unless done
   end
 
-  HTTP1_REQUEST = "%<method>s %<request>s HTTP/1.1\r\nHost: %<host>s\r\n%<headers>s\r\n"
+  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 = ctx[:opts][:headers] ? ctx[:opts][:headers].map { |k, v| "#{k}: #{v}\r\n"}.join : nil
+    headers = format_headers(ctx)
     puts "* proxy request headers: #{headers.inspect}"
 
-    HTTP1_REQUEST % {
-      method:   ctx[:method],
-      request:  ctx[:uri].request_uri,
-      host:     ctx[:uri].host,
-      headers:  headers
-    }
+    format(
+      HTTP1_REQUEST,
+      method:  ctx[:method],
+      request: ctx[:uri].request_uri,
+      host:    ctx[:uri].host,
+      headers: headers
+    )
+  end
+
+  def format_headers(headers)
+    return nil unless ctx[:opts][:headers]
+
+    headers.map { |k, v| "#{k}: #{v}\r\n" }.join
   end
 
   def uri_key(uri)
@@ -224,7 +235,7 @@ class Agent
     }
   end
 
-  SECURE_OPTS = { secure: true, alpn_protocols: ['h2', 'http/1.1'] }
+  SECURE_OPTS = { secure: true, alpn_protocols: ['h2', 'http/1.1'] }.freeze
 
   def connect(key)
     case key[:scheme]
@@ -236,4 +247,4 @@ class Agent
       raise "Invalid scheme #{key[:scheme].inspect}"
     end
   end
-end
+end