lightio 0.4.0.pre → 0.4.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: a88720041be21bfca13e5e2f38e63218661e81b1
-  data.tar.gz: 280863b2d6dee03a5f433c560137cf3a7f21cd7e
+  metadata.gz: 7bce34bd364d03347bca1a76cceede8fbad2838a
+  data.tar.gz: f99f66ed5d275bf5cd2e214faf131a5a391abb88
 SHA512:
-  metadata.gz: 9faf2d2f8cdbf5a54b012d534c059858c98425054a9698ed3ea93dd1a57947d3e1fc169e1acaf00ffed983b713b34e308b550681c08f939554f0294cf90c0718
-  data.tar.gz: 4a596272e41a00d3bd879b5fa9a4532f05a191a834df4ed187a6557becbb7a25e02cbce94fff1cf4cdf52b8e16f4436d44e6f11129b78756476b9a9fef779a83
+  metadata.gz: 61e90a11df62adf44a9e28f380a4083671b086830474a2f142622d74e8d2c2925cdfdd0941487589cf8206f98b218521d1907acb0e6f730235574695e5fd52c1
+  data.tar.gz: 2d8d16a78c200c491bd1ab4eba245e10888354aab0a2bd04bd00c220a8b780b87e6bd70b870c92d5f31fac14bc3f6f9e889dc5a4cf3aca946ecb8a2c9dbf8ec3

data/.rspec

@@ -1,3 +1,3 @@
---format documentation
+--format progress
 --color
 --require spec_helper

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    lightio (0.4.0.pre)
+    lightio (0.4.0)
       nio4r (~> 2.2)
 
 GEM

data/README.md

@@ -6,11 +6,37 @@
 [![Coverage Status](https://coveralls.io/repos/github/socketry/lightio/badge.svg?branch=master)](https://coveralls.io/github/socketry/lightio?branch=master)
 [![MIT licensed](https://img.shields.io/badge/license-MIT-blue.svg)](https://github.com/jjyr/lightio/blob/master/LICENSE.txt)
 
-LightIO is a ruby concurrency networking library, that combines ruby fiber and fast IO event loop.
+LightIO provide green thread to ruby. Like Golang's goroutine, or Crystal's fiber. In LightIO it called beam. 
+
+LightIO ship ruby stdlib compatible library under `LightIO` or `LightIO::Library` namespace, 
+these libraries provide ability to schedule LightIO beams when IO operations occur.
+
+See [Examples](/examples) for detail.
+
+LightIO also provide a monkey patch, it replace ruby `Thread` with `LightIO::Thread`, and also replace `IO` related classes.
+
+Example:
+
+``` ruby
+LightIO::Monkey.patch_all!
+# now you can just write normal ruby code
+start = Time.now
+10.times.map do
+  Thread.new do
+    `sleep 1`
+  end
+end.each(&:join)
+puts Time.now - start
+
+``` 
+
+### You Should Know
+
+In fact ruby core team already plan to implement `Thread::Green` in core language, see https://bugs.ruby-lang.org/issues/13618
+
+It mean if ruby implemented `Thread::Green`, this library is no meaning to exists.
+But as a crazy userland implemented green thread library, it bring lot's of fun to me, so I will continue to maintain it, and welcome to use  
 
-* **Simple**, LightIO provide same API with ruby stdlib, from low level to high level, use `LightIO::Thread` to start green threads, use `LightIO::Socket` `LightIO::TCPServer` for IO operations.
-* **Transparent**, LightIO encourage user to write multi threads and blocking-IO style code, LightIO will transfer actual IO operations to inner IO loop.
-* **Monkey patch**(experiment), LightIO provide reversible monkey patch, call `LightIO::Monkey.patch_all!` to apply, it will let LightIO inner loop to take over all IO operations, and patch threads to light weight fibers.
 
 See [Wiki](https://github.com/jjyr/lightio/wiki) and [Roadmap](https://github.com/jjyr/lightio/wiki/Current-status-and-roadmap) to get more information.
 

data/Rakefile

@@ -3,6 +3,7 @@ require "rspec/core/rake_task"
 
 RSpec::Core::RakeTask.new(:"spec:library") do |t|
   t.exclude_pattern = 'spec/**/monkey_spec.rb'
+  t.rspec_opts = "--tag ~skip_library"
 end
 
 RSpec::Core::RakeTask.new(:"spec:monkey_patch") do |t|

data/examples/http_requests.rb

@@ -0,0 +1,21 @@
+require 'lightio'
+# apply monkey patch at beginning
+LightIO::Monkey.patch_all!
+
+require 'net/http'
+
+host = 'github.com'
+port = 80
+
+start = Time.now
+
+10.times.map do
+  Thread.new do
+    Net::HTTP.start(host, port, use_ssl: false) do |http|
+      res = http.request_get('/ping')
+      p res.code
+    end
+  end
+end.each(&:join)
+
+p Time.now - start

data/lib/lightio/core/beam.rb

@@ -88,10 +88,19 @@ module LightIO::Core
         return self
       end
 
+      # return to current beam if beam done within time limit
+      origin_parent = parent
+      self.parent = Beam.current
       # set a transfer back timer
-      parent = Beam.current
       timer = LightIO::Watchers::Timer.new(limit)
-      timer.set_callback {parent.transfer}
+      timer.set_callback do
+        if alive?
+          caller_beam = parent
+          # resume to origin parent
+          self.parent = origin_parent
+          caller_beam.transfer
+        end
+      end
       ioloop.add_timer(timer)
       ioloop.transfer
 

data/lib/lightio/library.rb

@@ -6,6 +6,7 @@ require_relative 'library/timeout'
 require_relative 'library/io'
 require_relative 'library/file'
 require_relative 'library/socket'
+require_relative 'library/openssl'
 require_relative 'library/thread'
 require_relative 'library/threads_wait'
 

data/lib/lightio/library/base.rb

@@ -8,6 +8,7 @@ module LightIO::Library
         define_method_missing(singleton_class, @mock_klass)
         define_instance_method_missing(self, :@obj)
         define_mock_methods
+        define_inherited
         extend_class_methods
       end
 
@@ -61,6 +62,27 @@ module LightIO::Library
         end
       end
 
+      def define_inherited
+        mock_klass.define_singleton_method(:inherited) do |klass|
+          super(klass)
+          library_super_class = LightIO::Module::Base.find_library_class(self)
+          library_klass = Class.new(library_super_class) do
+            include LightIO::Library::Base
+            mock klass
+          end
+          if klass.name
+            LightIO::Library::Base.send(:full_const_set, LightIO::Library, klass.name, library_klass)
+          else
+            LightIO::Library::Base.send(:nameless_classes)[klass] = library_klass
+          end
+          klass.define_singleton_method :new do |*args, &blk|
+            obj = library_klass.__send__ :allocate
+            obj.__send__ :initialize, *args, &blk
+            obj
+          end
+        end
+      end
+
       def extend_class_methods
         class_methods_module = LightIO::Module.const_get("#{mock_klass}::ClassMethods")
         self.__send__ :extend, class_methods_module
@@ -86,11 +108,34 @@ module LightIO::Library
       @obj = obj
     end
 
+    private
+    def light_io_raw_obj
+      @obj
+    end
+
     class << self
       def included(base)
         base.send :extend, MockMethods
         base.send :extend, ClassMethods
       end
+
+      private
+      def nameless_classes
+        @nick_classes ||= {}
+      end
+
+      def full_const_set(base, mod_name, const)
+        mods = mod_name.split("::")
+        mod_name = mods.pop
+        full_mod_name = base.to_s
+        mods.each do |mod|
+          parent_mod = Object.const_get(full_mod_name)
+          parent_mod.const_get(mod) && next rescue nil
+          parent_mod.const_set(mod, Module.new)
+          full_mod_name = "#{full_mod_name}::#{mod}"
+        end
+        Object.const_get(full_mod_name).const_set(mod_name, const)
+      end
     end
   end
 end

data/lib/lightio/library/io.rb

@@ -6,118 +6,142 @@ module LightIO::Library
     mock ::IO
     extend LightIO::Module::IO::ClassMethods
 
-    wrap_blocking_methods :read, :write
+    def to_io
+      self
+    end
 
-    alias_method :<<, :write
+    # abstract for io-like operations
+    module IOMethods
+      class << self
+        def included(base)
+          base.send(:wrap_blocking_methods, :read, :write)
+          base.send(:alias_method, :<<, :write)
+        end
+      end
 
-    def read(length=nil, outbuf=nil)
-      raise ArgumentError, "negative length #{length} given" if length && length < 0
-      (outbuf ||= "").clear
-      loop do
-        readlen = length.nil? ? 4096 : length - outbuf.size
-        if (data = wait_nonblock(:read_nonblock, readlen))
-          outbuf << data
-          if length == outbuf.size
-            return outbuf
+      def wait(timeout = nil, mode = :read)
+        io_watcher.wait(timeout, mode) && self
+      end
+
+      def wait_readable(timeout = nil)
+        wait(timeout, :read) && self
+      end
+
+      def wait_writable(timeout = nil)
+        wait(timeout, :write) && self
+      end
+
+      def read(length=nil, outbuf=nil)
+        raise ArgumentError, "negative length #{length} given" if length && length < 0
+        (outbuf ||= "").clear
+        loop do
+          readlen = length.nil? ? 4096 : length - outbuf.size
+          if (data = wait_nonblock(:read_nonblock, readlen))
+            outbuf << data
+            if length == outbuf.size
+              return outbuf
+            end
+          else
+            return length.nil? ? outbuf : nil
           end
+        end
+      end
+
+      def readpartial(maxlen, outbuf=nil)
+        (outbuf ||= "").clear
+        if (data = wait_nonblock(:read_nonblock, maxlen))
+          outbuf << data
         else
-          return length.nil? ? outbuf : nil
+          raise EOFError, 'end of file reached'
         end
+        outbuf
       end
-    end
 
-    def readpartial(maxlen, outbuf=nil)
-      (outbuf ||= "").clear
-      if (data = wait_nonblock(:read_nonblock, maxlen))
-        outbuf << data
-      else
-        raise EOFError, 'end of file reached'
+      def getbyte
+        read(1)
       end
-      outbuf
-    end
 
-    def getbyte
-      read(1)
-    end
+      def getc
+        wait_readable
+        @obj.getc
+      end
 
-    def getc
-      wait_readable
-      @obj.getc
-    end
+      def readline(*args)
+        line = gets(*args)
+        raise EOFError, 'end of file reached' if line.nil?
+        line
+      end
 
-    def readline(*args)
-      line = gets(*args)
-      raise EOFError, 'end of file reached' if line.nil?
-      line
-    end
+      def readlines(*args)
+        result = []
+        until eof?
+          result << readline(*args)
+        end
+        result
+      end
 
-    def readlines(*args)
-      result = []
-      until eof?
-        result << readline(*args)
+      def readchar
+        c = getc
+        raise EOFError, 'end of file reached' if c.nil?
+        c
       end
-      result
-    end
 
-    def readchar
-      c = getc
-      raise EOFError, 'end of file reached' if c.nil?
-      c
-    end
+      def readbyte
+        b = getbyte
+        raise EOFError, 'end of file reached' if b.nil?
+        b
+      end
 
-    def readbyte
-      b = getbyte
-      raise EOFError, 'end of file reached' if b.nil?
-      b
-    end
+      def eof
+        wait_readable
+        @obj.eof
+      end
 
-    def eof
-      wait_readable
-      @obj.eof
-    end
+      alias eof? eof
 
-    alias eof? eof
-
-    def gets(*args)
-      raise ArgumentError, "wrong number of arguments (given #{args.size}, expected 0..2)" if args.size > 2
-      return nil if eof?
-      sep = $/
-      if args[0].is_a?(Numeric)
-        limit = args.shift
-      else
-        sep = args.shift if args.size > 0
-        limit = args.shift if args.first.is_a?(Numeric)
-      end
-      s = ''
-      while (c = getc)
-        s << c
-        break if limit && s.size == limit
-        break if c == sep
-      end
-      $_ = s
-    end
+      def gets(*args)
+        raise ArgumentError, "wrong number of arguments (given #{args.size}, expected 0..2)" if args.size > 2
+        sep = $/
+        if args[0].is_a?(Numeric)
+          limit = args.shift
+        else
+          sep = args.shift if args.size > 0
+          limit = args.shift if args.first.is_a?(Numeric)
+        end
+        s = ''
+        while (c = getbyte)
+          s << c
+          break if limit && s.size == limit
+          break if c == sep
+        end
+        s = nil if s.empty?
+        $_ = s
+      end
 
-    def to_io
-      self
-    end
+      def print(*obj)
+        obj.each do |s|
+          write(s)
+        end
+      end
 
-    def close(*args)
-      # close watcher before io closed
-      io_watcher.close
-      @obj.close
-    end
+      def printf(*args)
+        write(sprintf(*args))
+      end
+
+      def puts(*obj)
+        obj.each do |s|
+          write(s)
+          write($/)
+        end
+      end
 
-    private
-    def wait_readable
-      # if IO is already readable, continue wait_readable may block it forever
-      # so use getbyte detect this situation
-      # Maybe move getc and gets to thread pool is a good idea
-      b = getbyte
-      if b
-        ungetbyte(b)
-        return
-      end
-      io_watcher.wait_readable
+      def close(*args)
+        # close watcher before io closed
+        io_watcher.close
+        @obj.close
+      end
     end
+
+    prepend IOMethods
   end
 end

data/lib/lightio/library/kernel_ext.rb

@@ -1,5 +1,12 @@
+require 'open3'
+require 'forwardable'
 module LightIO::Library
   module KernelExt
+    KERNEL_PROXY = ::LightIO::RawProxy.new(::Kernel,
+                                           methods: [:spawn, :`])
+
+    extend Forwardable
+
     def sleep(*duration)
       if duration.size > 1
         raise ArgumentError, "wrong number of arguments (given #{duration.size}, expected 0..1)"
@@ -14,5 +21,60 @@ module LightIO::Library
       timer = LightIO::Watchers::Timer.new duration
       LightIO::IOloop.current.wait(timer)
     end
+
+    def spawn(*commands, **options)
+      options = options.dup
+      options.each do |key, v|
+        if key.is_a?(LightIO::Library::IO)
+          options.delete(key)
+          key = convert_io_or_array_to_raw(key)
+          options[key] = v
+        end
+        if (io = convert_io_or_array_to_raw(v))
+          options[key] = io
+        end
+      end
+      KERNEL_PROXY.send(:spawn, *commands, **options)
+    end
+
+    def `(cmd)
+      Open3.popen3(cmd, out: STDOUT, err: STDERR) do |stdin, stdout, stderr, wait_thr|
+        output = LightIO::Library::IO._wrap(stdout).read
+        KERNEL_PROXY.send(:`, "exit #{wait_thr.value.exitstatus}")
+        return output
+      end
+    end
+
+    def system(*cmd, **opt)
+      Open3.popen3(*cmd, **opt) do |stdin, stdout, stderr, wait_thr|
+        return nil if LightIO::Library::IO._wrap(stderr).read.size > 0
+        return wait_thr.value.exitstatus == 0
+      end
+    rescue Errno::ENOENT
+      nil
+    end
+
+    def_delegators :stdin, :gets, :readline, :readlines
+
+    private
+    def convert_io_or_array_to_raw(io_or_array)
+      if io_or_array.is_a?(LightIO::Library::IO)
+        io_or_array.send(:light_io_raw_obj)
+      elsif io_or_array.is_a?(Array)
+        io_or_array.map {|io| convert_io_or_array_to_raw(io)}
+      end
+    end
+
+    def stdin
+      @stdin ||= LightIO::Library::IO._wrap($stdin)
+    end
+
+    def stdout
+      @stdin ||= LightIO::Library::IO._wrap($stdout)
+    end
+
+    def stderr
+      @stdin ||= LightIO::Library::IO._wrap($stderr)
+    end
   end
 end

data/lib/lightio/library/openssl.rb

@@ -0,0 +1,26 @@
+require 'openssl'
+module LightIO::Library
+  module OpenSSL
+    module SSL
+      class SSLSocket
+        include Base
+        include LightIO::Wrap::IOWrapper
+
+        mock ::OpenSSL::SSL::SSLSocket
+        prepend LightIO::Library::IO::IOMethods
+
+        wrap_blocking_methods :connect, :accept
+
+        def initialize(io, *args)
+          io = io.send(:light_io_raw_obj) if io.is_a?(LightIO::Library::IO)
+          super(io, *args)
+        end
+
+        def accept_nonblock
+          socket = @obj.accept_nonblock(*args)
+          socket.is_a?(Symbol) ? socket : self.class._wrap(socket)
+        end
+      end
+    end
+  end
+end

data/lib/lightio/library/socket.rb

@@ -3,11 +3,53 @@ require 'socket'
 module LightIO::Library
 
   class Addrinfo
-    include LightIO::Wrap::Wrapper
     include Base
+    include LightIO::Wrap::Wrapper
+
     mock ::Addrinfo
+    extend LightIO::Module::Addrinfo::ClassMethods
+
+    module WrapHelper
+      protected
+      def wrap_socket_method(method)
+        define_method method do |*args|
+          socket = self.class.wrap_to_library(@obj.send(method, *args))
+          if block_given?
+            begin
+              yield socket
+            ensure
+              socket.close
+            end
+          else
+            socket
+          end
+        end
+      end
+
+      def wrap_socket_methods(*methods)
+        methods.each {|m| wrap_socket_method(m)}
+      end
+
+      def wrap_addrinfo_return_method(method)
+        define_method method do |*args|
+          result = @obj.send(method, *args)
+          if result.is_a?(::Addrinfo)
+            self.class.wrap_to_library(result)
+          elsif result.respond_to?(:map)
+            result.map {|r| self.class.wrap_to_library(r)}
+          else
+            result
+          end
+        end
+      end
+
+      def wrap_addrinfo_return_methods(*methods)
+        methods.each {|m| wrap_addrinfo_return_method(m)}
+      end
+    end
 
-    extend LightIO::Module::Addrinfo::WrapperHelper
+    include LightIO::Module::Base::Helper
+    extend WrapHelper
 
     wrap_socket_methods :bind, :connect, :connect_from, :connect_to, :listen
     wrap_addrinfo_return_methods :family_addrinfo, :ipv6_to_ipv4
@@ -96,12 +138,37 @@ module LightIO::Library
     include Base
     mock ::TCPSocket
     wrap_methods_run_in_threads_pool :gethostbyname
+
+    def initialize(*args)
+      raise ArgumentError, "wrong number of arguments (given #{args.size}, expected 2..4)" if args.size < 2 || args.size > 4
+      host, port = args[0..1]
+      local_host, local_port = args[2..3]
+      addrinfo = Addrinfo.getaddrinfo(host, port, nil, :STREAM)[0]
+      socket = ::Socket.send(:origin_new, addrinfo.afamily, Socket::SOCK_STREAM, 0)
+      if local_host || local_port
+        local_address = Socket.sockaddr_in(local_port, local_host)
+        socket.bind(local_address)
+      end
+      remote_address = Socket.sockaddr_in(addrinfo.ip_port, addrinfo.ip_address)
+      @obj = socket
+      wait_nonblock(:connect_nonblock, remote_address)
+      @obj
+    end
+
+    private
+    def connect_nonblock(*args)
+      @obj.connect_nonblock(*args)
+    end
   end
 
   class TCPServer < TCPSocket
     include Base
     mock ::TCPServer
 
+    def initialize(*args)
+      @obj = ::TCPServer.send(:origin_new, *args)
+    end
+
     def accept
       socket = wait_nonblock(:accept_nonblock)
       TCPSocket._wrap(socket)
@@ -125,12 +192,12 @@ module LightIO::Library
     wrap_blocking_methods :recvfrom
   end
 
-  class UNIXSocket < ::BasicSocket
+  class UNIXSocket < BasicSocket
     include Base
     mock ::UNIXSocket
 
     def send_io(io)
-      io = io.instance_variable_get(:@obj) || io
+      io = io.send(:light_io_raw_obj) if io.is_a?(LightIO::Library::IO)
       @obj.send_io(io)
     end
 

data/lib/lightio/module.rb

@@ -2,6 +2,7 @@ require_relative 'module/base'
 require_relative 'module/io'
 require_relative 'module/file'
 require_relative 'module/socket'
+require_relative 'module/openssl'
 require_relative 'module/thread'
 require_relative 'module/threads_wait'
 

data/lib/lightio/module/base.rb

@@ -1,5 +1,15 @@
 module LightIO::Module
   module Base
+    class << self
+      def find_library_class(klass)
+        return LightIO::Library::Base.send(:nameless_classes)[klass] if klass.name.nil?
+        name = klass.name
+        namespace_index = name.rindex("::")
+        class_name = namespace_index.nil? ? name : name[(namespace_index + 2)..-1]
+        LightIO::Library.const_get(class_name)
+      end
+    end
+
     module NewHelper
       protected
       def define_new_for_modules(*mods)
@@ -28,12 +38,8 @@ module LightIO::Module
         find_library_class._wrap(obj)
       end
 
-      # private
       def find_library_class
-        name = self.name
-        namespace_index = name.rindex("::")
-        class_name = namespace_index.nil? ? name : name[(namespace_index + 2)..-1]
-        LightIO::Library.const_get(class_name)
+        Base.find_library_class(self)
       end
     end
   end

data/lib/lightio/module/openssl.rb

@@ -0,0 +1,12 @@
+module LightIO::Module
+  extend Base::NewHelper
+
+  module OpenSSL
+    module SSL
+      module SSLSocket
+      end
+    end
+  end
+
+  define_new_for_module 'OpenSSL::SSL::SSLSocket'
+end

data/lib/lightio/module/socket.rb

@@ -10,44 +10,6 @@ module LightIO::Module
 
     module WrapperHelper
       protected
-      include LightIO::Module::Base::Helper
-
-      def wrap_socket_method(method)
-        define_method method do |*args|
-          socket = wrap_to_library(@obj.send(method, *args))
-          if block_given?
-            begin
-              yield socket
-            ensure
-              socket.close
-            end
-          else
-            socket
-          end
-        end
-      end
-
-      def wrap_socket_methods(*methods)
-        methods.each {|m| wrap_socket_method(m)}
-      end
-
-      def wrap_addrinfo_return_method(method)
-        define_method method do |*args|
-          result = @obj.send(method, *args)
-          if result.is_a?(::Addrinfo)
-            wrap_to_library(result)
-          elsif result.respond_to?(:map)
-            result.map {|r| wrap_to_library(r)}
-          else
-            result
-          end
-        end
-      end
-
-      def wrap_addrinfo_return_methods(*methods)
-        methods.each {|m| wrap_addrinfo_return_method(m)}
-      end
-
       def wrap_class_addrinfo_return_method(method)
         define_method method do |*args|
           result = __send__(:"origin_#{method}", *args)
@@ -67,10 +29,11 @@ module LightIO::Module
     end
 
     module ClassMethods
+      include LightIO::Module::Base::Helper
       extend WrapperHelper
 
       def foreach(*args, &block)
-        Addrinfo.getaddrinfo(*args).each(&block)
+        LightIO::Library::Addrinfo.getaddrinfo(*args).each(&block)
       end
 
       wrap_class_addrinfo_return_methods :getaddrinfo, :ip, :udp, :tcp, :unix

data/lib/lightio/monkey.rb

@@ -3,7 +3,7 @@ module LightIO
     class PatchError < StandardError
     end
 
-    IO_PATCH_CONSTANTS = %w{IO File Socket Socket::Ifaddr TCPServer TCPSocket BasicSocket Addrinfo IPSocket UDPSocket UNIXSocket UNIXServer}.freeze
+    IO_PATCH_CONSTANTS = %w{IO File Socket Socket::Ifaddr TCPServer TCPSocket BasicSocket Addrinfo IPSocket UDPSocket UNIXSocket UNIXServer OpenSSL::SSL::SSLSocket}.freeze
     THREAD_PATCH_CONSTANTS = %w{Thread ThreadGroup Queue SizedQueue ConditionVariable Mutex ThreadsWait}.freeze
 
     @patched
@@ -13,12 +13,14 @@ module LightIO
         patch_thread!
         patch_io!
         patch_kernel!
+        nil
       end
 
       def unpatch_all!
         unpatch_thread!
         unpatch_io!
         unpatch_kernel!
+        nil
       end
 
       def patched?(obj)
@@ -29,36 +31,54 @@ module LightIO
         require 'thread'
         THREAD_PATCH_CONSTANTS.each {|klass_name| patch!(klass_name)}
         patch_method!(Timeout, :timeout, LightIO::Timeout.method(:timeout))
+        nil
       end
 
       def unpatch_thread!
         require 'thread'
         THREAD_PATCH_CONSTANTS.each {|klass_name| unpatch!(klass_name)}
         unpatch_method!(Timeout, :timeout)
+        nil
       end
 
       def patch_io!
         require 'socket'
         IO_PATCH_CONSTANTS.each {|klass_name| patch!(klass_name)}
+        patch_method!(Process, :spawn, LightIO.method(:spawn).to_proc)
+        nil
       end
 
       def unpatch_io!
         require 'socket'
         IO_PATCH_CONSTANTS.each {|klass_name| unpatch!(klass_name)}
+        unpatch_method!(Process, :spawn)
+        nil
       end
 
       def patch_kernel!
-        patch_method!(Kernel, :sleep, LightIO.method(:sleep))
-        patch_method!(Kernel, :select, LightIO::Library::IO.method(:select))
-        patch_instance_method!(Kernel, :sleep, LightIO.method(:sleep))
-        patch_instance_method!(Kernel, :select, LightIO::Library::IO.method(:select))
+        patch_kernel_method!(:sleep, LightIO.method(:sleep))
+        patch_kernel_method!(:select, LightIO::Library::IO.method(:select))
+        patch_kernel_method!(:open, LightIO::Library::File.method(:open).to_proc)
+        patch_kernel_method!(:spawn, LightIO.method(:spawn).to_proc)
+        patch_kernel_method!(:`, LightIO.method(:`).to_proc)
+        patch_kernel_method!(:system, LightIO.method(:system).to_proc)
+        %w{gets readline readlines}.each do |method|
+          patch_kernel_method!(method.to_sym, LightIO.method(method.to_sym).to_proc)
+        end
+        nil
       end
 
       def unpatch_kernel!
-        unpatch_method!(Kernel, :sleep, LightIO.method(:sleep))
-        unpatch_method!(Kernel, :select, LightIO::Library::IO.method(:select))
-        unpatch_instance_method!(Kernel, :sleep, LightIO.method(:sleep))
-        unpatch_instance_method!(Kernel, :select, LightIO::Library::IO.method(:select))
+        unpatch_kernel_method!(:sleep)
+        unpatch_kernel_method!(:select)
+        unpatch_kernel_method!(:open)
+        unpatch_kernel_method!(:spawn)
+        unpatch_kernel_method!(:`)
+        unpatch_kernel_method!(:system)
+        %w{gets readline readlines}.each do |method|
+          unpatch_kernel_method!(method.to_sym, LightIO.method(method.to_sym).to_proc)
+        end
+        nil
       end
 
       private
@@ -88,6 +108,16 @@ module LightIO
         patched.delete(klass)
       end
 
+      def patch_kernel_method!(method_name, method)
+        patch_method!(Kernel, method_name, method)
+        patch_instance_method!(Kernel, method_name, method)
+      end
+
+      def unpatch_kernel_method!(method_name)
+        unpatch_method!(Kernel, method_name)
+        unpatch_instance_method!(Kernel, method_name)
+      end
+
       def find_class_methods_module(klass_name)
         LightIO::Module.const_get("#{klass_name}::ClassMethods", false)
       rescue NameError

data/lib/lightio/version.rb

@@ -1,3 +1,3 @@
 module LightIO
-  VERSION = "0.4.0.pre"
+  VERSION = "0.4.0"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: lightio
 version: !ruby/object:Gem::Version
-  version: 0.4.0.pre
+  version: 0.4.0
 platform: ruby
 authors:
 - Jiang Jinyang
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2018-01-30 00:00:00.000000000 Z
+date: 2018-02-10 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: nio4r
@@ -92,6 +92,7 @@ files:
 - examples/beams.rb
 - examples/echo_server.rb
 - examples/echo_server_with_raw_socket.rb
+- examples/http_requests.rb
 - examples/monkey_patch.rb
 - lib/lightio.rb
 - lib/lightio/core.rb
@@ -106,6 +107,7 @@ files:
 - lib/lightio/library/file.rb
 - lib/lightio/library/io.rb
 - lib/lightio/library/kernel_ext.rb
+- lib/lightio/library/openssl.rb
 - lib/lightio/library/queue.rb
 - lib/lightio/library/sized_queue.rb
 - lib/lightio/library/socket.rb
@@ -116,6 +118,7 @@ files:
 - lib/lightio/module/base.rb
 - lib/lightio/module/file.rb
 - lib/lightio/module/io.rb
+- lib/lightio/module/openssl.rb
 - lib/lightio/module/socket.rb
 - lib/lightio/module/thread.rb
 - lib/lightio/module/threads_wait.rb
@@ -144,9 +147,9 @@ required_ruby_version: !ruby/object:Gem::Requirement
       version: 2.3.4
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
-  - - ">"
+  - - ">="
     - !ruby/object:Gem::Version
-      version: 1.3.1
+      version: '0'
 requirements: []
 rubyforge_project: 
 rubygems_version: 2.6.11