polyphony 0.43.8

data/lib/polyphony/extensions/io.rb

@@ -0,0 +1,221 @@
+# frozen_string_literal: true
+
+require 'open3'
+
+# IO class method patches
+class ::IO
+  class << self
+    alias_method :orig_binread, :binread
+    def binread(name, length = nil, offset = nil)
+      File.open(name, 'rb:ASCII-8BIT') do |f|
+        f.seek(offset) if offset
+        length ? f.read(length) : f.read
+      end
+    end
+
+    alias_method :orig_binwrite, :binwrite
+    def binwrite(name, string, offset = nil)
+      File.open(name, 'wb:ASCII-8BIT') do |f|
+        f.seek(offset) if offset
+        f.write(string)
+      end
+    end
+
+    EMPTY_HASH = {}.freeze
+
+    # alias_method :orig_foreach, :foreach
+    # def foreach(_name, _sep = $/, _limit = nil, _getline_args = EMPTY_HASH,
+    #             &_block)
+    #   # IO.orig_read(name).each_line(&block)
+    #   raise NotImplementedError
+
+    #   # if sep.is_a?(Integer)
+    #   #   sep = $/
+    #   #   limit = sep
+    #   # end
+    #   # File.open(name, 'r') do |f|
+    #   #   f.each_line(sep, limit, getline_args, &block)
+    #   # end
+    # end
+
+    alias_method :orig_read, :read
+    def read(name, length = nil, offset = nil, opt = EMPTY_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
+      end
+    end
+
+    # alias_method :orig_readlines, :readlines
+    # def readlines(name, sep = $/, limit = nil, getline_args = EMPTY_HASH)
+    #   File.open(name, 'r') do |f|
+    #     f.readlines(sep, limit, getline_args)
+    #   end
+    # end
+
+    alias_method :orig_write, :write
+    def write(name, string, offset = nil, opt = EMPTY_HASH)
+      File.open(name, opt[:mode] || 'w') do |f|
+        f.seek(offset) if offset
+        f.write(string)
+      end
+    end
+
+    alias_method :orig_popen, :popen
+    def popen(cmd, mode = 'r')
+      return orig_popen(cmd, mode) unless block_given?
+
+      Open3.popen2(cmd) { |_i, o, _t| yield o }
+    end
+  end
+end
+
+# IO instance method patches
+class ::IO
+  # def each(sep = $/, limit = nil, chomp: nil)
+  #   sep, limit = $/, sep if sep.is_a?(Integer)
+  # end
+  # alias_method :each_line, :each
+
+  # def each_byte
+  # end
+
+  # def each_char
+  # end
+
+  # def each_codepoint
+  # end
+
+  # def getbyte
+  # end
+
+  # def getc
+  # end
+
+  alias_method :orig_read, :read
+  def read(len = nil)
+    @read_buffer ||= +''
+    result = Thread.current.agent.read(self, @read_buffer, len, true)
+    return nil unless result
+
+    already_read = @read_buffer
+    @read_buffer = +''
+    already_read
+  end
+
+  alias_method :orig_readpartial, :read
+  def readpartial(len, str = nil)
+    @read_buffer ||= +''
+    result = Thread.current.agent.read(self, @read_buffer, len, false)
+    raise EOFError unless result
+
+    if str
+      str << @read_buffer
+    else
+      str = @read_buffer
+    end
+    @read_buffer = +''
+    str
+  end
+
+  alias_method :orig_write, :write
+  def write(str, *args)
+    Thread.current.agent.write(self, str, *args)
+  end
+
+  alias_method :orig_write_chevron, :<<
+  def <<(str)
+    Thread.current.agent.write(self, str)
+    self
+  end
+
+  alias_method :orig_gets, :gets
+  def gets(sep = $/, _limit = nil, _chomp: nil)
+    if sep.is_a?(Integer)
+      sep = $/
+      _limit = sep
+    end
+    sep_size = sep.bytesize
+
+    @read_buffer ||= +''
+
+    loop do
+      idx = @read_buffer.index(sep)
+      return @read_buffer.slice!(0, idx + sep_size) if idx
+
+      data = readpartial(8192)
+      @read_buffer << data
+    rescue EOFError
+      return nil
+    end
+  end
+
+  # def print(*args)
+  # end
+
+  # def printf(format, *args)
+  # end
+
+  # def putc(obj)
+  # end
+
+  alias_method :orig_puts, :puts
+  def puts(*args)
+    if args.empty?
+      write "\n"
+      return
+    end
+
+    strs = args.inject([]) do |m, a|
+      a = a.to_s
+      m << a
+      m << "\n" unless a =~ /\n$/
+      m
+    end
+    write *strs
+    nil
+  end
+
+  # def readbyte
+  # end
+
+  # def readchar
+  # end
+
+  # def readline(sep = $/, limit = nil, chomp: nil)
+  # end
+
+  # def readlines(sep = $/, limit = nil, chomp: nil)
+  # end
+
+  alias_method :orig_write_nonblock, :write_nonblock
+  def write_nonblock(string, _options = {})
+    write(string)
+  end
+
+  alias_method :orig_read_nonblock, :read_nonblock
+  def read_nonblock(maxlen, buf = nil, _options = nil)
+    buf ? readpartial(maxlen, buf) : readpartial(maxlen)
+  end
+
+  def read_loop(&block)
+    Thread.current.agent.read_loop(self, &block)
+  end
+
+  # alias_method :orig_read, :read
+  # def read(length = nil, outbuf = nil)
+  #   if length
+  #     return outbuf ? readpartial(length) : readpartial(length, outbuf)
+  #   end
+
+  #   until eof?
+  #     outbuf ||= +''
+  #     outbuf << readpartial(8192)
+  #   end
+  #   outbuf
+  # end
+end

data/lib/polyphony/extensions/openssl.rb

@@ -0,0 +1,81 @@
+# frozen_string_literal: true
+
+require 'openssl'
+require_relative './socket'
+
+# Open ssl socket helper methods (to make it compatible with Socket API)
+class ::OpenSSL::SSL::SSLSocket
+  alias_method :orig_initialize, :initialize
+  def initialize(socket, context = nil)
+    socket = socket.respond_to?(:io) ? socket.io || socket : socket
+    context ? orig_initialize(socket, context) : orig_initialize(socket)
+  end
+
+  def dont_linger
+    io.dont_linger
+  end
+
+  def no_delay
+    io.no_delay
+  end
+
+  def reuse_addr
+    io.reuse_addr
+  end
+
+  alias_method :orig_accept, :accept
+  def accept
+    loop do
+      result = accept_nonblock(exception: false)
+      case result
+      when :wait_readable then Thread.current.agent.wait_io(io, false)
+      when :wait_writable then Thread.current.agent.wait_io(io, true)
+      else
+        return result
+      end
+    end
+  end
+
+  alias_method :orig_sysread, :sysread
+  def sysread(maxlen, buf = +'')
+    loop do
+      case (result = read_nonblock(maxlen, buf, exception: false))
+      when :wait_readable then Thread.current.agent.wait_io(io, false)
+      when :wait_writable then Thread.current.agent.wait_io(io, true)
+      else return result
+      end
+    end
+  end
+
+  alias_method :orig_syswrite, :syswrite
+  def syswrite(buf)
+    loop do
+      case (result = write_nonblock(buf, exception: false))
+      when :wait_readable then Thread.current.agent.wait_io(io, false)
+      when :wait_writable then Thread.current.agent.wait_io(io, true)
+      else
+        return result
+      end
+    end
+  end
+
+  def flush
+    # osync = @sync
+    # @sync = true
+    # do_write ""
+    # return self
+    # ensure
+    # @sync = osync
+  end
+
+  def readpartial(maxlen, buf = +'')
+    result = sysread(maxlen, buf)
+    result || (raise EOFError)
+  end
+
+  def read_loop
+    while (data = sysread(8192))
+      yield data
+    end
+  end
+end

data/lib/polyphony/extensions/socket.rb

@@ -0,0 +1,150 @@
+# frozen_string_literal: true
+
+require 'socket'
+
+require_relative './io'
+require_relative '../core/thread_pool'
+
+class ::BasicSocket
+  def write_nonblock(string, _options = {})
+    write(string)
+  end
+
+  def read_nonblock(maxlen, str = nil, _options = {})
+    readpartial(maxlen, str)
+  end
+end
+
+# Socket overrides (eventually rewritten in C)
+class ::Socket
+  def accept
+    Thread.current.agent.accept(self)
+  end
+
+  NO_EXCEPTION = { exception: false }.freeze
+
+  def connect(remotesockaddr)
+    loop do
+      result = connect_nonblock(remotesockaddr, **NO_EXCEPTION)
+      case result
+      when 0 then return
+      when :wait_writable then Thread.current.agent.wait_io(self, true)
+      else
+        raise IOError
+      end
+    end
+  end
+
+  def recv(maxlen, flags = 0, outbuf = nil)
+    outbuf ||= +''
+    loop do
+      result = recv_nonblock(maxlen, flags, outbuf, **NO_EXCEPTION)
+      case result
+      when nil then raise IOError
+      when :wait_readable then Thread.current.agent.wait_io(self, false)
+      else
+        return result
+      end
+    end
+  end
+
+  def recvfrom(maxlen, flags = 0)
+    @read_buffer ||= +''
+    loop do
+      result = recvfrom_nonblock(maxlen, flags, @read_buffer, **NO_EXCEPTION)
+      case result
+      when nil then raise IOError
+      when :wait_readable then Thread.current.agent.wait_io(self, false)
+      else
+        return result
+      end
+    end
+  end
+
+  ZERO_LINGER = [0, 0].pack('ii').freeze
+
+  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
+
+# Overide stock TCPSocket code by encapsulating a Socket instance
+class ::TCPSocket
+  NO_EXCEPTION = { exception: false }.freeze
+
+  attr_reader :io
+
+  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
+      addr = Addrinfo.tcp(local_host, local_port)
+      @io.bind(addr)
+    end
+
+    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 ? @io.close : orig_close
+  end
+
+  alias_method :orig_setsockopt, :setsockopt
+  def setsockopt(*args)
+    @io ? @io.setsockopt(*args) : orig_setsockopt(*args)
+  end
+
+  alias_method :orig_closed?, :closed?
+  def 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
+  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
+    @io.accept
+  end
+
+  alias_method :orig_close, :close
+  def close
+    @io.close
+  end
+end