lightio 0.3.2 → 0.4.0.pre

data/lib/lightio/library/threads_wait.rb

@@ -5,6 +5,11 @@ module LightIO::Library
     ErrNoWaitingThread = ::ThreadsWait::ErrNoWaitingThread
     ErrNoFinishedThread = ::ThreadsWait::ErrNoFinishedThread
 
+    extend Base::MockMethods
+    mock ::ThreadsWait
+
+    extend LightIO::Module::ThreadsWait::ClassMethods
+
     attr_reader :threads
 
     def initialize(*threads)
@@ -36,7 +41,7 @@ module LightIO::Library
     end
 
     def next_wait(nonblock=nil)
-      raise ThreadsWait::ErrNoWaitingThread, 'No threads for waiting.' if empty?
+      raise ::ThreadsWait::ErrNoWaitingThread, 'No threads for waiting.' if empty?
       @threads.each do |thr|
         if thr.alive? && nonblock
           next
@@ -47,13 +52,7 @@ module LightIO::Library
         @threads.delete(thr)
         return thr
       end
-      raise ThreadsWait::ErrNoFinishedThread, 'No finished threads.'
-    end
-
-    class << self
-      def all_waits(*threads, &blk)
-        new(*threads).all_waits(&blk)
-      end
+      raise ::ThreadsWait::ErrNoFinishedThread, 'No finished threads.'
     end
   end
 end

data/lib/lightio/module.rb

@@ -0,0 +1,11 @@
+require_relative 'module/base'
+require_relative 'module/io'
+require_relative 'module/file'
+require_relative 'module/socket'
+require_relative 'module/thread'
+require_relative 'module/threads_wait'
+
+module LightIO
+  module Module
+  end
+end

data/lib/lightio/module/base.rb

@@ -0,0 +1,40 @@
+module LightIO::Module
+  module Base
+    module NewHelper
+      protected
+      def define_new_for_modules(*mods)
+        mods.each {|mod| define_new_for_module(mod)}
+      end
+
+      def define_new_for_module(mod)
+        LightIO::Module.send(:module_eval, <<-STR, __FILE__, __LINE__ + 1)
+          module #{mod}
+            module ClassMethods
+              def new(*args, &blk)
+                obj = LightIO::Library::#{mod}.__send__ :allocate
+                obj.__send__ :initialize, *args, &blk
+                obj
+              end
+            end
+          end
+        STR
+      end
+    end
+
+    module Helper
+      protected
+      def wrap_to_library(obj)
+        return _wrap(obj) if self.respond_to?(:_wrap)
+        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)
+      end
+    end
+  end
+end

data/lib/lightio/module/file.rb

@@ -0,0 +1,10 @@
+module LightIO::Module
+  extend Base::NewHelper
+
+  define_new_for_module "File"
+  module File
+    include Base
+    module ClassMethods
+    end
+  end
+end

data/lib/lightio/module/io.rb

@@ -0,0 +1,88 @@
+module LightIO::Module
+  extend Base::NewHelper
+
+  define_new_for_module "IO"
+
+  module IO
+    include LightIO::Module::Base
+
+    class << self
+      # helper methods
+      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?(LightIO::Library::IO)
+          raise TypeError, "can't process raw IO, use LightIO::IO._wrap(obj) to wrap it" if 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?(LightIO::Library::IO)
+          io = convert_to_io(io)
+        end
+        io.__send__(:io_watcher)
+      end
+    end
+
+    module ClassMethods
+      include LightIO::Module::Base::Helper
+
+      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 = origin_pipe(*args)
+        if block_given?
+          begin
+            return yield r, w
+          ensure
+            w.close
+            r.close
+          end
+        end
+        # [r, w]
+        [wrap_to_library(r), wrap_to_library(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| LightIO::Module::IO.get_io_watcher(fd).tap {|io| io.readable?; io.clear_status}}
+          write_fds.each {|fd| LightIO::Module::IO.get_io_watcher(fd).tap {|io| io.writable?; io.clear_status}}
+          # run ioloop once
+          LightIO.sleep 0
+          r_fds = read_fds.select {|fd|
+            io = LightIO::Module::IO.convert_to_io(fd)
+            io.closed? ? raise(IOError, 'closed stream') : LightIO::Module::IO.get_io_watcher(io).readable?
+          }
+          w_fds = write_fds.select {|fd|
+            io = LightIO::Module::IO.convert_to_io(fd)
+            io.closed? ? raise(IOError, 'closed stream') : LightIO::Module::IO.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
+    end
+  end
+end

data/lib/lightio/module/socket.rb

@@ -0,0 +1,165 @@
+require 'socket'
+
+module LightIO::Module
+  extend Base::NewHelper
+
+  define_new_for_modules *%w{Addrinfo Socket IPSocket TCPSocket TCPServer UDPSocket UNIXSocket UNIXServer}
+
+  module Addrinfo
+    include LightIO::Module::Base
+
+    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)
+          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_class_addrinfo_return_methods(*methods)
+        methods.each {|m| wrap_class_addrinfo_return_method(m)}
+      end
+    end
+
+    module ClassMethods
+      extend WrapperHelper
+
+      def foreach(*args, &block)
+        Addrinfo.getaddrinfo(*args).each(&block)
+      end
+
+      wrap_class_addrinfo_return_methods :getaddrinfo, :ip, :udp, :tcp, :unix
+    end
+  end
+
+  module BasicSocket
+    include LightIO::Module::Base
+
+    module ClassMethods
+      include LightIO::Module::Base::Helper
+
+      def for_fd(fd)
+        wrap_to_library(origin_for_fd(fd))
+      end
+    end
+  end
+
+  module Socket
+    include LightIO::Module::Base
+
+    module ClassMethods
+      include LightIO::Module::Base::Helper
+      extend LightIO::Wrap::Wrapper::HelperMethods
+      ## implement ::Socket class methods
+      wrap_methods_run_in_threads_pool :getaddrinfo, :gethostbyaddr, :gethostbyname, :gethostname,
+                                       :getnameinfo, :getservbyname
+
+      def getifaddrs
+        origin_getifaddrs.map {|ifaddr| LightIO::Library::Socket::Ifaddr._wrap(ifaddr)}
+      end
+
+      def socketpair(domain, type, protocol)
+        origin_socketpair(domain, type, protocol).map {|s| wrap_to_library(s)}
+      end
+
+      alias_method :pair, :socketpair
+
+      def unix_server_socket(path)
+        if block_given?
+          origin_unix_server_socket(path) {|s| yield wrap_to_library(s)}
+        else
+          wrap_to_library(origin_unix_server_socket(path))
+        end
+      end
+
+      def ip_sockets_port0(ai_list, reuseaddr)
+        origin_ip_sockets_port0(ai_list, reuseaddr).map {|s| wrap_to_library(s)}
+      end
+    end
+  end
+
+
+  module IPSocket
+    include LightIO::Module::Base
+
+    module ClassMethods
+      extend LightIO::Wrap::Wrapper::HelperMethods
+      wrap_methods_run_in_threads_pool :getaddress
+    end
+  end
+
+  module TCPSocket
+    include LightIO::Module::Base
+  end
+
+  module TCPServer
+    include LightIO::Module::Base
+  end
+
+  module UDPSocket
+    include LightIO::Module::Base
+  end
+
+  module UNIXSocket
+    include LightIO::Module::Base
+
+    module ClassMethods
+      include LightIO::Module::Base::Helper
+
+      def socketpair(*args)
+        origin_socketpair(*args).map {|io| wrap_to_library(io)}
+      end
+
+      alias_method :pair, :socketpair
+    end
+  end
+
+  module UNIXServer
+    include LightIO::Module::Base
+  end
+end

data/lib/lightio/module/thread.rb

@@ -0,0 +1,76 @@
+require 'thread'
+
+module LightIO::Module
+  extend Base::NewHelper
+
+  define_new_for_modules *%w{ThreadGroup Mutex Queue SizedQueue ConditionVariable}
+
+  module Thread
+    include LightIO::Module::Base
+
+    module ClassMethods
+      extend Forwardable
+
+      def new(*args, &blk)
+        obj = LightIO::Library::Thread.__send__ :allocate
+        obj.__send__ :initialize, *args, &blk
+        obj
+      end
+
+      def fork(*args, &blk)
+        obj = LightIO::Library::Thread.__send__ :allocate
+        obj.send(:init_core, *args, &blk)
+        obj
+      end
+
+      alias start fork
+
+      def kill(thr)
+        thr.kill
+      end
+
+      def current
+        return main if LightIO::Core::LightFiber.is_root?(Fiber.current)
+        LightIO::Library::Thread.instance_variable_get(:@current_thread) || origin_current
+      end
+
+      def exclusive(&blk)
+        LightIO::Library::Thread.__send__(:thread_mutex).synchronize(&blk)
+      end
+
+      def list
+        thread_list = []
+        LightIO::Library::Thread.__send__(:threads).keys.each {|id|
+          begin
+            thr = ObjectSpace._id2ref(id)
+            unless thr.alive?
+              # manually remove thr from threads
+              thr.kill
+              next
+            end
+            thread_list << thr
+          rescue RangeError
+            # mean object is recycled
+            # just wait ruby GC call finalizer to remove it from threads
+            next
+          end
+        }
+        thread_list
+      end
+
+      def pass
+        LightIO::Beam.pass
+      end
+
+      alias stop pass
+
+      def finalizer(object_id)
+        proc {LightIO::Library::Thread.__send__(:threads).delete(object_id)}
+      end
+
+      def main
+        origin_main
+      end
+    end
+  end
+end

data/lib/lightio/module/threads_wait.rb

@@ -0,0 +1,13 @@
+require 'thwait'
+
+module LightIO::Module
+  module ThreadsWait
+    include LightIO::Module::Base
+
+    module ClassMethods
+      def all_waits(*threads, &blk)
+        LightIO::Library::ThreadsWait.new(*threads).all_waits(&blk)
+      end
+    end
+  end
+end

data/lib/lightio/monkey.rb

@@ -0,0 +1,150 @@
+module LightIO
+  module Monkey
+    class PatchError < StandardError
+    end
+
+    IO_PATCH_CONSTANTS = %w{IO File Socket Socket::Ifaddr TCPServer TCPSocket BasicSocket Addrinfo IPSocket UDPSocket UNIXSocket UNIXServer}.freeze
+    THREAD_PATCH_CONSTANTS = %w{Thread ThreadGroup Queue SizedQueue ConditionVariable Mutex ThreadsWait}.freeze
+
+    @patched
+
+    class << self
+      def patch_all!
+        patch_thread!
+        patch_io!
+        patch_kernel!
+      end
+
+      def unpatch_all!
+        unpatch_thread!
+        unpatch_io!
+        unpatch_kernel!
+      end
+
+      def patched?(obj)
+        patched.key?(obj) && !patched[obj]&.empty?
+      end
+
+      def patch_thread!
+        require 'thread'
+        THREAD_PATCH_CONSTANTS.each {|klass_name| patch!(klass_name)}
+        patch_method!(Timeout, :timeout, LightIO::Timeout.method(:timeout))
+      end
+
+      def unpatch_thread!
+        require 'thread'
+        THREAD_PATCH_CONSTANTS.each {|klass_name| unpatch!(klass_name)}
+        unpatch_method!(Timeout, :timeout)
+      end
+
+      def patch_io!
+        require 'socket'
+        IO_PATCH_CONSTANTS.each {|klass_name| patch!(klass_name)}
+      end
+
+      def unpatch_io!
+        require 'socket'
+        IO_PATCH_CONSTANTS.each {|klass_name| unpatch!(klass_name)}
+      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))
+      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))
+      end
+
+      private
+      def patch!(klass_name)
+        klass = Object.const_get(klass_name)
+        raise PatchError, "already patched constant #{klass}" if patched?(klass)
+        patched[klass] = {}
+        class_methods_module = find_class_methods_module(klass_name)
+        methods = class_methods_module && find_monkey_patch_class_methods(klass_name)
+        return unless class_methods_module && methods
+        methods.each do |method_name|
+          method = class_methods_module.instance_method(method_name)
+          patch_method!(klass, method_name, method)
+        end
+      rescue
+        patched.delete(klass)
+        raise
+      end
+
+      def unpatch!(klass_name)
+        klass = Object.const_get(klass_name)
+        raise PatchError, "can't find patched constant #{klass}" unless patched?(klass)
+        unpatch_method!(klass, :new)
+        find_monkey_patch_class_methods(klass_name).each do |method_name|
+          unpatch_method!(klass, method_name)
+        end
+        patched.delete(klass)
+      end
+
+      def find_class_methods_module(klass_name)
+        LightIO::Module.const_get("#{klass_name}::ClassMethods", false)
+      rescue NameError
+        nil
+      end
+
+      def find_monkey_patch_class_methods(klass_name)
+        find_class_methods_module(klass_name).instance_methods
+      end
+
+      def patched_method?(obj, method)
+        patched?(obj) && patched[obj].key?(method)
+      end
+
+      def patched_methods(const)
+        patched[const] ||= {}
+      end
+
+      def patch_method!(const, method, patched_method)
+        raise PatchError, "already patched method #{const}.#{method}" if patched_method?(const, method)
+        patched_methods(const)[method] = patched_method
+        const.send(:define_singleton_method, method, patched_method)
+        nil
+      end
+
+      def unpatch_method!(const, method)
+        raise PatchError, "can't find patched method #{const}.#{method}" unless patched_method?(const, method)
+        origin_method = patched_methods(const).delete(method)
+        const.send(:define_singleton_method, method, origin_method)
+        nil
+      end
+
+      def patched_instance_method?(obj, method)
+        patched_instance_methods(obj).key?(method)
+      end
+
+      def patched_instance_methods(const)
+        (patched[:instance_methods] ||= {})[const] ||= {}
+      end
+
+      def patch_instance_method!(const, method, patched_method)
+        raise PatchError, "already patched method #{const}.#{method}" if patched_instance_method?(const, method)
+        patched_instance_methods(const)[method] = patched_method
+        const.send(:define_method, method, patched_method)
+        nil
+      end
+
+      def unpatch_instance_method!(const, method)
+        raise PatchError, "can't find patched method #{const}.#{method}" unless patched_instance_method?(const, method)
+        origin_method = patched_instance_methods(const).delete(method)
+        const.send(:define_method, method, origin_method)
+        nil
+      end
+
+      def patched
+        @patched ||= {}
+      end
+    end
+  end
+end