lightio 0.2.2 → 0.3.0

data/lib/lightio/library/sized_queue.rb

@@ -0,0 +1,64 @@
+require_relative 'queue'
+
+module LightIO::Library
+  class SizedQueue < LightIO::Library::Queue
+    attr_accessor :max
+
+    def initialize(max)
+      raise ArgumentError, 'queue size must be positive' unless max > 0
+      super()
+      @max = max
+      @enqueue_waiters = []
+    end
+
+    def push(object)
+      raise ClosedQueueError, "queue closed" if @close
+      if size >= max
+        future = LightIO::Future.new
+        @enqueue_waiters << future
+        future.value
+      end
+      super
+      self
+    end
+
+    alias enq push
+    alias << push
+
+    def pop(non_block=false)
+      result = super
+      check_release_enqueue_waiter
+      result
+    end
+
+    alias deq pop
+    alias shift pop
+
+    def clear
+      result = super
+      check_release_enqueue_waiter
+      result
+    end
+
+    def max=(value)
+      @max = value
+      check_release_enqueue_waiter if size < max
+    end
+
+    def num_waiting
+      super + @enqueue_waiters.size
+    end
+
+    private
+    def check_release_enqueue_waiter
+      if @enqueue_waiters.any?
+        future = LightIO::Future.new
+        LightIO::IOloop.current.add_callback {
+          @enqueue_waiters.shift.transfer
+          future.transfer
+        }
+        future.value
+      end
+    end
+  end
+end

data/lib/lightio/library/socket.rb

@@ -65,9 +65,11 @@ module LightIO::Library
   class BasicSocket < IO
     include LightIO::Wrap::IOWrapper
     wrap ::BasicSocket
-
     wrap_blocking_methods :recv, :recvmsg, :sendmsg
 
+    extend Forwardable
+    def_delegators :@io_watcher, :wait, :wait_writable
+
     def shutdown(*args)
       # close watcher before io shutdown
       @io_watcher.close
@@ -99,13 +101,40 @@ module LightIO::Library
       @io.sys_accept
     end
 
-    # bind addr?
+    Option = ::Socket::Option
+    UDPSource = ::Socket::UDPSource
+    SocketError = ::SocketError
+
+    class Ifaddr
+      include LightIO::Wrap::Wrapper
+      wrap ::Socket
+
+      def addr
+        @io.addr && Addrinfo._wrap(@io.addr)
+      end
+
+      def broadaddr
+        @io.broadaddr && Addrinfo._wrap(@io.broadaddr)
+      end
+
+      def dstaddr
+        @io.dstaddr && Addrinfo._wrap(@io.dstaddr)
+      end
+
+      def netmask
+        @io.netmask && Addrinfo._wrap(@io.netmask)
+      end
+    end
 
     class << self
       ## implement ::Socket class methods
-      wrap_methods_run_in_threads_pool :getaddrinfo, :gethostbyaddr, :gethostbyname, :gethostname, :getifaddrs,
+      wrap_methods_run_in_threads_pool :getaddrinfo, :gethostbyaddr, :gethostbyname, :gethostname,
                                        :getnameinfo, :getservbyname
 
+      def getifaddrs
+        raw_class.getifaddrs.map {|ifaddr| Ifaddr._wrap(ifaddr)}
+      end
+
       def socketpair(domain, type, protocol)
         raw_class.socketpair(domain, type, protocol).map {|s| _wrap(s)}
       end

data/lib/lightio/library/thread.rb

@@ -0,0 +1,295 @@
+require 'thread'
+require_relative 'mutex'
+require_relative 'queue'
+
+module LightIO::Library
+  class ThreadGroup
+    include LightIO::Wrap::Wrapper
+    wrap ::ThreadGroup
+
+    Default = ThreadGroup._wrap(::ThreadGroup::Default)
+
+    def add(thread)
+      if @io.enclosed?
+        raise ThreadError, "can't move from the enclosed thread group"
+      elsif thread.is_a?(LightIO::Library::Thread)
+        # let thread decide how to add to group
+        thread.send(:add_to_group, self)
+      else
+        @io.add(thread)
+      end
+      self
+    end
+
+    def list
+      @io.list + threads
+    end
+
+    private
+    def threads
+      @threads ||= []
+    end
+  end
+
+
+  class Thread
+    RAW_THREAD = ::Thread
+
+    # constants
+    ThreadError = ::ThreadError
+    Queue = LightIO::Library::Queue
+    Backtrace = ::Thread::Backtrace
+    SizedQueue = LightIO::Library::SizedQueue
+
+    @current_thread = nil
+
+    module FallbackHelper
+      module ClassMethods
+        def fallback_method(obj, method, warning_text)
+          define_method method do |*args|
+            warn warning_text
+            obj.public_send method, *args
+          end
+        end
+
+        def fallback_thread_class_methods(*methods)
+          methods.each {|m| fallback_method(RAW_THREAD.main, m, "This method is fallback to native Thread class,"\
+                                                   " it may cause unexpected behaviour,"\
+                                                   " open issues on https://github.com/socketry/lightio/issues"\
+                                                   " if this behaviour not approach you purpose")}
+        end
+      end
+
+      include ClassMethods
+
+      def fallback_main_thread_methods(*methods)
+        methods.each {|m| fallback_method(main, m, "This method is fallback to native main thread,"\
+                                                   " it may cause unexpected behaviour,"\
+                                                   " open issues on https://github.com/socketry/lightio/issues"\
+                                                   " if this behaviour not approach you purpose")}
+      end
+
+      def self.included(base)
+        base.send :extend, ClassMethods
+      end
+    end
+
+    class << self
+      extend Forwardable
+      def_delegators :'LightIO::Library::Thread::RAW_THREAD', :DEBUG, :DEBUG=
+
+      include FallbackHelper
+      fallback_thread_class_methods :abort_on_exception, :abort_on_exception=
+
+      def fork(*args, &blk)
+        obj = 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)
+        @current_thread || RAW_THREAD.current
+      end
+
+      def exclusive(&blk)
+        @thread_mutex.synchronize(&blk)
+      end
+
+      def list
+        thread_list = []
+        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 {threads.delete(object_id)}
+      end
+
+      def main
+        RAW_THREAD.main
+      end
+
+      private
+
+      # threads and threads variables
+      def threads
+        @threads ||= {}
+      end
+    end
+
+    extend Forwardable
+
+    def initialize(*args, &blk)
+      init_core(*args, &blk)
+    end
+
+    @thread_mutex = LightIO::Library::Mutex.new
+    def_delegators :@beam, :alive?, :value
+
+    fallback_main_thread_methods :abort_on_exception,
+                                 :abort_on_exception=,
+                                 :handle_interrupt,
+                                 :pending_interrupt,
+                                 :add_trace_func,
+                                 :backtrace,
+                                 :backtrace_locations,
+                                 :priority,
+                                 :priority=,
+                                 :safe_level
+
+    def kill
+      @beam.kill && self
+    end
+
+    alias exit kill
+    alias terminate kill
+
+    def status
+      if Thread.current == self
+        'run'
+      elsif alive?
+        @beam.error.nil? ? 'sleep' : 'abouting'
+      else
+        @beam.error.nil? ? false : nil
+      end
+    end
+
+    def thread_variables
+      thread_values.keys
+    end
+
+    def thread_variable_get(name)
+      thread_values[name.to_sym]
+    end
+
+    def thread_variable_set(name, value)
+      thread_values[name.to_sym] = value
+    end
+
+    def thread_variable?(key)
+      thread_values.key?(key)
+    end
+
+    def [](name)
+      fiber_values[name.to_sym]
+    end
+
+    def []=(name, val)
+      fiber_values[name.to_sym] = val
+    end
+
+    def group
+      @group
+    end
+
+    def inspect
+      "#<LightIO::Library::Thread:0x00#{object_id.to_s(16)} #{status}>"
+    end
+
+    def join(limit=nil)
+      @beam.join(limit) && self
+    end
+
+    def key?(sym)
+      fiber_values.has_key?(sym)
+    end
+
+    def keys
+      fiber_values.keys
+    end
+
+    def raise(exception, message=nil, backtrace=nil)
+      @beam.raise(LightIO::Beam::BeamError.new(exception), message, backtrace)
+    end
+
+    def run
+      Kernel.raise ThreadError, 'killed thread' unless alive?
+      Thread.pass
+    end
+
+    alias wakeup run
+
+    def stop?
+      !alive? || status == 'sleep'
+    end
+
+    private
+    def init_core(*args, &blk)
+      @beam = LightIO::Beam.new(*args, &blk)
+      @beam.on_dead = proc {on_dead}
+      @beam.on_transfer = proc {|from, to| on_transfer(from, to)}
+      # register this thread
+      thread_values
+      # add self to ThreadGroup::Default
+      add_to_group(ThreadGroup::Default)
+      # remove thread and thread variables
+      ObjectSpace.define_finalizer(self, self.class.finalizer(self.object_id))
+    end
+
+    # add self to thread group
+    def add_to_group(group)
+      # remove from old group
+      remove_from_group
+      @group = group
+      @group.send(:threads) << self
+    end
+
+    # remove thread from group when dead
+    def remove_from_group
+      @group.send(:threads).delete(self) if @group
+    end
+
+    def on_dead
+      # release references
+      remove_from_group
+    end
+
+    def on_transfer(from, to)
+      Thread.instance_variable_set(:@current_thread, self)
+    end
+
+    def thread_values
+      Thread.send(:threads)[object_id] ||= {}
+    end
+
+    def fibers_and_values
+      @fibers_and_values ||= {}
+    end
+
+    def fiber_values
+      beam_or_fiber = LightIO::Beam.current
+      # only consider non-root fiber
+      if !beam_or_fiber.instance_of?(::Fiber) || LightIO::LightFiber.is_root?(beam_or_fiber)
+        beam_or_fiber = @beam
+      end
+      fibers_and_values[beam_or_fiber] ||= {}
+    end
+  end
+end

data/lib/lightio/library/threads_wait.rb

@@ -0,0 +1,59 @@
+require 'thwait'
+
+module LightIO::Library
+  class ThreadsWait
+    ErrNoWaitingThread = ::ThreadsWait::ErrNoWaitingThread
+    ErrNoFinishedThread = ::ThreadsWait::ErrNoFinishedThread
+
+    attr_reader :threads
+
+    def initialize(*threads)
+      @threads = threads
+    end
+
+    def all_waits
+      until empty?
+        thr = next_wait
+        yield thr if block_given?
+      end
+    end
+
+    def empty?
+      @threads.empty?
+    end
+
+    def finished?
+      @threads.any? {|thr| !thr.alive?}
+    end
+
+    def join(*threads)
+      join_nowait(*threads)
+      next_wait
+    end
+
+    def join_nowait(*threads)
+      @threads.concat(threads)
+    end
+
+    def next_wait(nonblock=nil)
+      raise ThreadsWait::ErrNoWaitingThread, 'No threads for waiting.' if empty?
+      @threads.each do |thr|
+        if thr.alive? && nonblock
+          next
+        elsif thr.alive?
+          thr.join
+        end
+        # thr should dead
+        @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
+    end
+  end
+end

data/lib/lightio/library.rb

@@ -1,8 +1,11 @@
 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/socket'
+require_relative 'library/thread'
+require_relative 'library/threads_wait'
 
 module LightIO
   # Library include modules can cooperative with LightIO::Beam

data/lib/lightio/version.rb

@@ -1,3 +1,3 @@
 module LightIO
-  VERSION = "0.2.2"
+  VERSION = "0.3.0"
 end

data/lib/lightio/watchers/io.rb

@@ -21,12 +21,17 @@ module LightIO::Watchers
       @io = io
       @ioloop = LightIO::Core::IOloop.current
       @waiting = false
-      # NIO monitor
-      @monitor = @ioloop.add_io_wait(@io, interests) {callback_on_waiting}
       ObjectSpace.define_finalizer(self, self.class.finalizer(@monitor))
       @error = nil
     end
 
+    # NIO::Monitor
+    def monitor(interests=:rw)
+      @monitor ||= begin
+        @ioloop.add_io_wait(@io, interests) {callback_on_waiting}
+      end
+    end
+
     class << self
       def finalizer(monitor)
         proc {monitor.close if monitor && !monitor.close?}
@@ -34,8 +39,19 @@ module LightIO::Watchers
     end
 
     extend Forwardable
-    def_delegators :@monitor, :interests, :interests=, :closed?, :readable?, :writable?, :writeable?
+    def_delegators :monitor, :interests, :interests=, :closed?
+
+    def readable?
+      check_monitor_read
+      monitor.readable?
+    end
 
+    def writable?
+      check_monitor_write
+      monitor.writable?
+    end
+
+    alias :writeable? :writable?
 
     # Blocking until io is readable
     # @param [Numeric]  timeout return nil after timeout seconds, otherwise return self
@@ -53,9 +69,10 @@ module LightIO::Watchers
 
     def wait(timeout=nil, mode=:read)
       LightIO::Timeout.timeout(timeout) do
-        interests = {read: :r, write: :w, read_write: :rw}[mode]
-        self.interests = interests
-        wait_in_ioloop
+        check_monitor(mode)
+        in_waiting(mode) do
+          wait_in_ioloop
+        end
         self
       end
     rescue Timeout::Error
@@ -64,7 +81,7 @@ module LightIO::Watchers
 
     def close
       return if closed?
-      @monitor.close
+      monitor.close
       @error = IOError.new('closed stream')
       callback_on_waiting
     end
@@ -80,34 +97,70 @@ module LightIO::Watchers
     end
 
     private
+    def check_monitor(mode)
+      case mode
+        when :read
+          check_monitor_read
+        when :write
+          check_monitor_write
+        when :read_write
+          check_monitor_read_write
+        else
+          raise ArgumentError, "get unknown value #{mode}"
+      end
+    end
+
+    def check_monitor_read
+      if monitor(:r).interests == :w
+        monitor.interests = :rw
+      end
+    end
+
+    def check_monitor_write
+      if monitor(:w).interests == :r
+        monitor.interests = :rw
+      end
+    end
+
+    def check_monitor_read_write
+      if monitor(:rw).interests != :rw
+        monitor.interests = :rw
+      end
+    end
 
     # Blocking until io interests is satisfied
     def wait_in_ioloop
       raise LightIO::Error, "Watchers::IO can't cross threads" if @ioloop != LightIO::Core::IOloop.current
       raise EOFError, "can't wait closed IO watcher" if @monitor.closed?
-      @waiting = true
       @ioloop.wait(self)
+    end
+
+    def in_waiting(mode)
+      @waiting = mode
+      yield
       @waiting = false
     end
 
     def callback_on_waiting
       # only call callback on waiting
-      return unless @waiting && io_is_ready?
+      return unless io_is_ready?
       if @error
         # if error occurred in io waiting, send it to callback, see IOloop#wait
-        callback.call(LightIO::Core::Beam::BeamError.new(@error))
+        callback&.call(LightIO::Core::Beam::BeamError.new(@error))
       else
-        callback.call
+        callback&.call
       end
     end
 
     def io_is_ready?
-      if interests == :r
+      return false unless @waiting
+      return true if closed?
+      if @waiting == :r
         readable?
-      elsif interests == :w
-        writeable?
+      elsif @waiting == :w
+        writable?
       else
-        readable? || writeable?
+        readable? || writable?
       end
     end
   end

data/lib/lightio/wrap.rb

@@ -85,26 +85,16 @@ module LightIO::Wrap
     #
     # @param [Symbol]  method method name, example: wait_nonblock
     # @param [args] args arguments pass to method
-    def wait_nonblock(method, *args, exception_symbol: true)
+    def wait_nonblock(method, *args)
       loop do
-        begin
-          result = if RUBY_VERSION > "2.3" && exception_symbol
-                     @io.__send__(method, *args, exception: false)
-                   else
-                     @io.__send__(method, *args)
-                   end
-          case result
-            when :wait_readable
-              @io_watcher.wait_readable
-            when :wait_writable
-              @io_watcher.wait_writable
-            else
-              return result
-          end
-        rescue RAW_IO::WaitReadable
-          @io_watcher.wait_readable
-        rescue RAW_IO::WaitWritable
-          @io_watcher.wait_writable
+        result = @io.__send__(method, *args, exception: false)
+        case result
+          when :wait_readable
+            @io_watcher.wait_readable
+          when :wait_writable
+            @io_watcher.wait_writable
+          else
+            return result
         end
       end
     end
@@ -115,14 +105,14 @@ module LightIO::Wrap
       # wrap blocking method with "#{method}_nonblock"
       #
       # @param [Symbol]  method method name, example: wait
-      def wrap_blocking_method(method, exception_symbol: true)
+      def wrap_blocking_method(method)
         define_method method do |*args|
-          wait_nonblock(:"#{method}_nonblock", *args, exception_symbol: exception_symbol)
+          wait_nonblock(:"#{method}_nonblock", *args)
         end
       end
 
-      def wrap_blocking_methods(*methods, exception_symbol: true)
-        methods.each {|m| wrap_blocking_method(m, exception_symbol: exception_symbol)}
+      def wrap_blocking_methods(*methods)
+        methods.each {|m| wrap_blocking_method(m)}
       end
     end
 

data/lightio.gemspec

@@ -21,7 +21,7 @@ Gem::Specification.new do |spec|
   spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
   spec.require_paths = ["lib"]
 
-  spec.add_runtime_dependency "nio4r", "~> 2.1"
+  spec.add_runtime_dependency "nio4r", "~> 2.2"
   spec.add_development_dependency "bundler", "~> 1.16"
   spec.add_development_dependency "rake", "~> 10.0"
   spec.add_development_dependency "rspec", "~> 3.0"