lightio 0.3.2 → 0.4.0.pre

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: e60501b7bca5cc445161d405a11e4a7d688de116
-  data.tar.gz: 6068963377b9805a4cc93090d6d14eaba2df280a
+  metadata.gz: a88720041be21bfca13e5e2f38e63218661e81b1
+  data.tar.gz: 280863b2d6dee03a5f433c560137cf3a7f21cd7e
 SHA512:
-  metadata.gz: c9e29908ede0af65b6b8a6d86d7ed88f85de30e6275c7a34917ef3ed3e444ac6df2567de2392b9859daabae6158ead27dc2be4b13669adb0070aa895cae3d8ee
-  data.tar.gz: 391014cc0762ba84b948e9a18efe76377a61dcc6135926eec7c543a93b0921d9e707b52a1b260173a4286a90822716e264c4973c5238f85c2b4da24b0a875235
+  metadata.gz: 9faf2d2f8cdbf5a54b012d534c059858c98425054a9698ed3ea93dd1a57947d3e1fc169e1acaf00ffed983b713b34e308b550681c08f939554f0294cf90c0718
+  data.tar.gz: 4a596272e41a00d3bd879b5fa9a4532f05a191a834df4ed187a6557becbb7a25e02cbce94fff1cf4cdf52b8e16f4436d44e6f11129b78756476b9a9fef779a83

data/Gemfile.lock

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

data/README.md

@@ -6,9 +6,11 @@
 [![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 networking library, that combines ruby fiber and fast IO event loop.
+LightIO is a ruby concurrency networking library, that combines ruby fiber and fast IO event loop.
 
-The intent of LightIO is to provide ruby stdlib compatible modules, that user can use these modules instead stdlib, to gain the benefits of IO event loop without care any details about react or async programming.
+* **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.
 
@@ -59,7 +61,7 @@ Bug reports and pull requests are welcome on GitHub at https://github.com/jjyr/l
 
 The gem is available as open source under the terms of the [MIT License](https://opensource.org/licenses/MIT).
 
-Copyright, 2017, by [Jiang Jinyang](http://justjjy.com/)
+Copyright, 2017-2018, by [Jiang Jinyang](http://justjjy.com/)
 
 ## Code of Conduct
 

data/Rakefile

@@ -1,6 +1,14 @@
 require "bundler/gem_tasks"
 require "rspec/core/rake_task"
 
-RSpec::Core::RakeTask.new(:spec)
+RSpec::Core::RakeTask.new(:"spec:library") do |t|
+  t.exclude_pattern = 'spec/**/monkey_spec.rb'
+end
+
+RSpec::Core::RakeTask.new(:"spec:monkey_patch") do |t|
+  t.rspec_opts = "-r monkey_patch.rb --tag ~skip_monkey_patch"
+end
 
 task :default => :spec
+
+task :spec => [:"spec:library", :"spec:monkey_patch"]

data/examples/echo_server.rb

@@ -1,5 +1,7 @@
 # Example from https://github.com/socketry/nio4r/blob/master/examples/echo_server.rb
 # rewrite it in lightio for demonstrate
+# this example demonstrate LightIO Libraries API
+# look LightIO::Library namespace to find more
 
 require 'lightio'
 

data/examples/echo_server_with_raw_socket.rb

@@ -1,6 +1,7 @@
 # Example from https://github.com/socketry/nio4r/blob/master/examples/echo_server.rb
 # rewrite it in lightio for demonstrate
-# this example demonstrate how to use ruby 'raw' socket with LightIO
+# this example demonstrate LightIO low-level API
+# how to use ruby 'raw'(unpatched) socket with LightIO
 
 require 'lightio'
 require 'socket'

data/examples/monkey_patch.rb

@@ -0,0 +1,26 @@
+require 'lightio'
+
+# apply monkey patch as early as possible
+# after monkey patch, it just normal ruby code
+LightIO::Monkey.patch_all!
+
+
+TCPServer.open('localhost', 3000) do |server|
+  while (socket = server.accept)
+    _, port, host = socket.peeraddr
+    puts "accept connection from #{host}:#{port}"
+
+    # Don't worry, Thread.new create green threads, it cost very light
+    Thread.new(socket) do |socket|
+      data = nil
+      begin
+        socket.write(data) while (data = socket.readpartial(4096))
+      rescue EOFError
+        _, port, host = socket.peeraddr
+        puts "*** #{host}:#{port} disconnected"
+        socket.close
+      end
+    end
+
+  end
+end

data/lib/lightio.rb

@@ -1,10 +1,13 @@
 # LightIO
 require 'lightio/version'
 require 'lightio/errors'
+require 'lightio/raw_proxy'
 require 'lightio/core'
 require 'lightio/watchers'
 require 'lightio/wrap'
+require 'lightio/module'
 require 'lightio/library'
+require 'lightio/monkey'
 
 # LightIO provide light-weight executor: LightIO::Beam and batch io libraries,
 # view LightIO::Core::Beam to learn how to concurrent programming with Beam,

data/lib/lightio/core/beam.rb

@@ -45,7 +45,7 @@ module LightIO::Core
     # @param [Proc]  blk block to execute
     # @return [Beam]
     def initialize(*args, &blk)
-      raise Error, "must be called with a block" unless blk
+      raise LightIO::Error, "must be called with a block" unless blk
       super() {
         begin
           @value = yield(*args)

data/lib/lightio/core/ioloop.rb

@@ -7,8 +7,6 @@ module LightIO::Core
   # IOloop handle io waiting and schedule beams, user do not supposed to directly use this class
   class IOloop
 
-    RAW_THREAD = ::Thread
-
     def initialize
       @fiber = Fiber.new {run}
       @backend = Backend::NIO.new
@@ -48,15 +46,23 @@ module LightIO::Core
       @fiber.transfer
     end
 
+    THREAD_PROXY = ::LightIO::RawProxy.new(::Thread,
+                                           methods: [:current],
+                                           instance_methods: [:thread_variable_get, :thread_variable_set, :thread_variable?])
+
     class << self
       # return current ioloop or create new one
       def current
         key = :"lightio.ioloop"
-        unless RAW_THREAD.current.thread_variable?(key)
-          RAW_THREAD.current.thread_variable_set(key, IOloop.new)
+        current_thread = THREAD_PROXY.send(:current)
+        unless THREAD_PROXY.instance_send(current_thread, :thread_variable?, key)
+          THREAD_PROXY.instance_send(current_thread, :thread_variable_set, key, IOloop.new)
         end
-        RAW_THREAD.current.thread_variable_get(key)
+        THREAD_PROXY.instance_send(current_thread, :thread_variable_get, key)
       end
     end
   end
+
+  # Initialize IOloop
+  IOloop.current
 end

data/lib/lightio/library.rb

@@ -1,8 +1,10 @@
+require_relative 'library/base'
 require_relative 'library/queue'
 require_relative 'library/sized_queue'
 require_relative 'library/kernel_ext'
 require_relative 'library/timeout'
 require_relative 'library/io'
+require_relative 'library/file'
 require_relative 'library/socket'
 require_relative 'library/thread'
 require_relative 'library/threads_wait'

data/lib/lightio/library/base.rb

@@ -0,0 +1,96 @@
+module LightIO::Library
+  module Base
+    module MockMethods
+      protected
+      def mock(klass)
+        @mock_klass = klass
+        define_alias_methods
+        define_method_missing(singleton_class, @mock_klass)
+        define_instance_method_missing(self, :@obj)
+        define_mock_methods
+        extend_class_methods
+      end
+
+      attr_reader :mock_klass
+
+      private
+
+      def define_alias_methods
+        class_methods_module = LightIO::Module.const_get("#{mock_klass}::ClassMethods") rescue nil
+        return unless class_methods_module
+        methods = class_methods_module.instance_methods(false).select {|method| mock_klass.respond_to?(method)}
+        methods.each do |method|
+          origin_method_name = "origin_#{method}"
+          mock_klass.singleton_class.__send__(:alias_method, origin_method_name, method)
+          mock_klass.singleton_class.__send__(:protected, origin_method_name)
+        end
+      end
+
+      def define_method_missing(base, target_var)
+        base.send(:define_method, :method_missing) {|*args| target_var.__send__(*args)}
+        base.send(:define_method, :respond_to_missing?) {|method, *| target_var.respond_to?(method)}
+      end
+
+      def define_instance_method_missing(base, target_var)
+        base.send(:define_method, :method_missing) {|*args| instance_variable_get(target_var).__send__(*args)}
+        base.send(:define_method, :respond_to_missing?) {|method, *| instance_variable_get(target_var).respond_to?(method)}
+      end
+
+      def define_mock_methods
+        define_method :is_a? do |klass|
+          mock_klass = self.class.__send__(:call_method_from_ancestors, :mock_klass)
+          return super(klass) unless mock_klass
+          mock_klass <= klass || super(klass)
+        end
+
+        alias_method :kind_of?, :is_a?
+
+        define_method :instance_of? do |klass|
+          mock_klass = self.class.__send__(:mock_klass)
+          return super(klass) unless mock_klass
+          mock_klass == klass || super(klass)
+        end
+      end
+
+      def call_method_from_ancestors(method)
+        __send__(method) || begin
+          self.ancestors.each do |klass|
+            result = klass.__send__(method)
+            break result if result
+          end
+        end
+      end
+
+      def extend_class_methods
+        class_methods_module = LightIO::Module.const_get("#{mock_klass}::ClassMethods")
+        self.__send__ :extend, class_methods_module
+      rescue NameError
+        nil
+      end
+    end
+
+    module ClassMethods
+      def _wrap(obj)
+        if obj.instance_of? self
+          obj
+        else
+          mock_obj = allocate
+          mock_obj.instance_variable_set(:@obj, obj)
+          mock_obj
+        end
+      end
+    end
+
+    def initialize(*args)
+      obj = self.class.send(:call_method_from_ancestors, :mock_klass).send(:origin_new, *args)
+      @obj = obj
+    end
+
+    class << self
+      def included(base)
+        base.send :extend, MockMethods
+        base.send :extend, ClassMethods
+      end
+    end
+  end
+end

data/lib/lightio/library/file.rb

@@ -0,0 +1,9 @@
+module LightIO::Library
+  class File < LightIO::Library::IO
+    include Base
+    include LightIO::Wrap::IOWrapper
+
+    mock ::File
+    extend LightIO::Module::File::ClassMethods
+  end
+end

data/lib/lightio/library/io.rb

@@ -1,8 +1,10 @@
-require 'forwardable'
 module LightIO::Library
   class IO
+    include Base
     include LightIO::Wrap::IOWrapper
-    wrap ::IO
+
+    mock ::IO
+    extend LightIO::Module::IO::ClassMethods
 
     wrap_blocking_methods :read, :write
 
@@ -19,7 +21,7 @@ module LightIO::Library
             return outbuf
           end
         else
-          return length.nil? ? '' : nil
+          return length.nil? ? outbuf : nil
         end
       end
     end
@@ -40,7 +42,7 @@ module LightIO::Library
 
     def getc
       wait_readable
-      @io.getc
+      @obj.getc
     end
 
     def readline(*args)
@@ -71,7 +73,7 @@ module LightIO::Library
 
     def eof
       wait_readable
-      @io.eof?
+      @obj.eof
     end
 
     alias eof? eof
@@ -95,16 +97,16 @@ module LightIO::Library
       $_ = s
     end
 
-    def close(*args)
-      # close watcher before io closed
-      @io_watcher.close
-      @io.close(*args)
-    end
-
     def to_io
       self
     end
 
+    def close(*args)
+      # close watcher before io closed
+      io_watcher.close
+      @obj.close
+    end
+
     private
     def wait_readable
       # if IO is already readable, continue wait_readable may block it forever
@@ -115,80 +117,7 @@ module LightIO::Library
         ungetbyte(b)
         return
       end
-      @io_watcher.wait_readable
-    end
-
-    class << self
-      def open(*args)
-        io = self.new(*args)
-        return io unless block_given?
-        begin
-          yield io
-        ensure
-          io.close if io.respond_to? :close
-        end
-      end
-
-      def pipe(*args)
-        r, w = raw_class.pipe
-        if block_given?
-          begin
-            return yield r, w
-          ensure
-            w.close
-            r.close
-          end
-        end
-        [IO._wrap(r), IO._wrap(w)]
-      end
-
-      def select(read_fds, write_fds=nil, _except_fds=nil, timeout=nil)
-        timer = timeout && Time.now
-        read_fds ||= []
-        write_fds ||= []
-        loop do
-          # make sure io registered, then clear io watcher status
-          read_fds.each {|fd| get_io_watcher(fd).tap {|io| io.readable?; io.clear_status}}
-          write_fds.each {|fd| get_io_watcher(fd).tap {|io| io.writable?; io.clear_status}}
-          # run ioloop once
-          LightIO.sleep 0
-          r_fds = read_fds.select {|fd|
-            io = convert_to_io(fd)
-            io.closed? ? raise(IOError, 'closed stream') : get_io_watcher(io).readable?
-          }
-          w_fds = write_fds.select {|fd|
-            io = convert_to_io(fd)
-            io.closed? ? raise(IOError, 'closed stream') : get_io_watcher(io).writable?
-          }
-          e_fds = []
-          if r_fds.empty? && w_fds.empty?
-            if timeout && Time.now - timer > timeout
-              return nil
-            end
-          else
-            return [r_fds, w_fds, e_fds]
-          end
-        end
-      end
-
-      private
-      def convert_to_io(io)
-        unless io.respond_to?(:to_io)
-          raise TypeError, "no implicit conversion of #{io.class} into IO"
-        end
-        to_io = io.to_io
-        unless to_io.is_a?(IO)
-          raise TypeError, "can't convert #{io.class} to IO (#{io.class}#to_io gives #{to_io.class})"
-        end
-        to_io
-      end
-
-      def get_io_watcher(io)
-        unless io.is_a?(IO)
-          io = convert_to_io(io)
-        end
-        io.instance_variable_get(:@io_watcher)
-      end
+      io_watcher.wait_readable
     end
   end
 end

data/lib/lightio/library/queue.rb

@@ -1,5 +1,8 @@
 module LightIO::Library
   class Queue
+    extend Base::MockMethods
+    mock ::Queue
+
     def initialize
       @queue = []
       @waiters = []
@@ -97,4 +100,4 @@ module LightIO::Library
       @waiters.size
     end
   end
-end
+end

data/lib/lightio/library/sized_queue.rb

@@ -2,6 +2,9 @@ require_relative 'queue'
 
 module LightIO::Library
   class SizedQueue < LightIO::Library::Queue
+    extend Base::MockMethods
+    mock ::SizedQueue
+
     attr_accessor :max
 
     def initialize(max)