lightio 0.3.2 → 0.4.0.pre

data/lib/lightio/library/socket.rb

@@ -4,196 +4,162 @@ module LightIO::Library
 
   class Addrinfo
     include LightIO::Wrap::Wrapper
-    wrap ::Addrinfo
-
-    module WrapperHelper
-      protected
-      def wrap_socket_method(method)
-        define_method method do |*args|
-          socket = Socket._wrap(@io.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 = (@io || raw_class).send(method, *args)
-          if result.is_a?(raw_class)
-            _wrap(result)
-          elsif result.respond_to?(:map)
-            result.map {|r| _wrap(r)}
-          else
-            result
-          end
-        end
-      end
+    include Base
+    mock ::Addrinfo
 
-      def wrap_addrinfo_return_methods(*methods)
-        methods.each {|m| wrap_addrinfo_return_method(m)}
-      end
-    end
-
-    extend WrapperHelper
+    extend LightIO::Module::Addrinfo::WrapperHelper
 
     wrap_socket_methods :bind, :connect, :connect_from, :connect_to, :listen
-
     wrap_addrinfo_return_methods :family_addrinfo, :ipv6_to_ipv4
-
-    class << self
-      extend WrapperHelper
-
-      def foreach(*args, &block)
-        Addrinfo.getaddrinfo(*args).each(&block)
-      end
-
-      wrap_addrinfo_return_methods :getaddrinfo, :ip, :udp, :tcp, :unix
-    end
   end
 
-  class BasicSocket < IO
+  class BasicSocket < LightIO::Library::IO
+    include Base
     include LightIO::Wrap::IOWrapper
-    wrap ::BasicSocket
+    mock ::BasicSocket
+    extend LightIO::Module::BasicSocket::ClassMethods
+
     wrap_blocking_methods :recv, :recvmsg, :sendmsg
 
     extend Forwardable
-    def_delegators :@io_watcher, :wait, :wait_writable
+    def_delegators :io_watcher, :wait, :wait_writable
 
     def shutdown(*args)
       # close watcher before io shutdown
-      @io_watcher.close
-      @io.shutdown(*args)
-    end
-
-    class << self
-      def for_fd(fd)
-        self._wrap(raw_class.for_fd(fd))
-      end
+      io_watcher.close
+      @obj.shutdown(*args)
     end
   end
 
   class Socket < BasicSocket
-    include ::Socket::Constants
+    include Base
     include LightIO::Wrap::IOWrapper
-    wrap ::Socket
+    mock ::Socket
+    extend LightIO::Module::Socket::ClassMethods
 
-    wrap_blocking_methods :connect, :recvfrom
-
-    ## implement ::Socket instance methods
-    def accept
-      socket, addrinfo = wait_nonblock(:accept_nonblock)
-      [self.class._wrap(socket), Addrinfo._wrap(addrinfo)]
-    end
-
-    def accept_nonblock(*args)
-      socket, addrinfo = @io.accept_nonblock(*args)
-      [self.class._wrap(socket), Addrinfo._wrap(addrinfo)]
-    end
+    wrap_blocking_methods :connect, :recvfrom, :accept
 
     def sys_accept
-      @io_watcher.wait_readable
-      @io.sys_accept
+      io_watcher.wait_readable
+      @obj.sys_accept
     end
 
-    Option = ::Socket::Option
-    UDPSource = ::Socket::UDPSource
-    SocketError = ::SocketError
-
     class Ifaddr
-      include LightIO::Wrap::Wrapper
-      wrap ::Socket
+      include Base
+      mock ::Socket::Ifaddr
 
       def addr
-        @io.addr && Addrinfo._wrap(@io.addr)
+        @obj.addr && Addrinfo._wrap(@obj.addr)
       end
 
       def broadaddr
-        @io.broadaddr && Addrinfo._wrap(@io.broadaddr)
+        @obj.broadaddr && Addrinfo._wrap(@obj.broadaddr)
       end
 
       def dstaddr
-        @io.dstaddr && Addrinfo._wrap(@io.dstaddr)
+        @obj.dstaddr && Addrinfo._wrap(@obj.dstaddr)
       end
 
       def netmask
-        @io.netmask && Addrinfo._wrap(@io.netmask)
+        @obj.netmask && Addrinfo._wrap(@obj.netmask)
       end
     end
 
-    class << self
-      ## implement ::Socket class methods
-      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
-
-      alias_method :pair, :socketpair
+    include ::Socket::Constants
+    Option = ::Socket::Option
+    UDPSource = ::Socket::UDPSource
+    SocketError = ::SocketError
+    Addrinfo = Addrinfo
 
-      def unix_server_socket(path)
-        if block_given?
-          raw_class.unix_server_socket(path) {|s| yield _wrap(s)}
-        else
-          _wrap(raw_class.unix_server_socket(path))
-        end
-      end
+    def accept
+      socket, addrinfo = wait_nonblock(:accept_nonblock)
+      [self.class._wrap(socket), Addrinfo._wrap(addrinfo)]
+    end
 
-      def ip_sockets_port0(ai_list, reuseaddr)
-        raw_class.ip_sockets_port0(ai_list, reuseaddr).map {|s| _wrap(s)}
+    def accept_nonblock(*args)
+      socket, addrinfo = @obj.accept_nonblock(*args)
+      if socket.is_a?(Symbol)
+        [socket, nil]
+      else
+        [self.class._wrap(socket), Addrinfo._wrap(addrinfo)]
       end
     end
   end
 
 
   class IPSocket < BasicSocket
-    include LightIO::Wrap::IOWrapper
-    wrap ::IPSocket
-
-    class << self
-      wrap_methods_run_in_threads_pool :getaddress
-    end
+    include Base
+    mock ::IPSocket
   end
 
   class TCPSocket < IPSocket
-    include LightIO::Wrap::IOWrapper
-    wrap ::TCPSocket
+    include Base
+    mock ::TCPSocket
     wrap_methods_run_in_threads_pool :gethostbyname
   end
 
   class TCPServer < TCPSocket
-    include LightIO::Wrap::IOWrapper
-    wrap ::TCPServer
+    include Base
+    mock ::TCPServer
 
-    ## implement ::Socket instance methods
     def accept
       socket = wait_nonblock(:accept_nonblock)
       TCPSocket._wrap(socket)
     end
 
     def accept_nonblock(*args)
-      socket = @io.accept_nonblock(*args)
-      TCPSocket._wrap(socket)
+      socket = @obj.accept_nonblock(*args)
+      socket.is_a?(Symbol) ? socket : TCPSocket._wrap(socket)
     end
 
     def sys_accept
-      @io_watcher.wait_readable
-      @io.sys_accept
+      io_watcher.wait_readable
+      @obj.sys_accept
+    end
+  end
+
+  class UDPSocket < IPSocket
+    include Base
+    mock ::UDPSocket
+
+    wrap_blocking_methods :recvfrom
+  end
+
+  class UNIXSocket < ::BasicSocket
+    include Base
+    mock ::UNIXSocket
+
+    def send_io(io)
+      io = io.instance_variable_get(:@obj) || io
+      @obj.send_io(io)
+    end
+
+    def recv_io(*args)
+      io = @obj.recv_io(*args)
+      if (wrapper = LightIO.const_get(io.class.to_s))
+        return wrapper._wrap(io) if wrapper.respond_to?(:_wrap)
+      end
+      io
+    end
+  end
+
+  class UNIXServer < UNIXSocket
+    include Base
+    mock ::UNIXServer
+
+    def sys_accept
+      io_watcher.wait_readable
+      @obj.sys_accpet
+    end
+
+    def accept
+      socket = wait_nonblock(:accept_nonblock)
+      UNIXSocket._wrap(socket)
+    end
+
+    def accept_nonblock(*args)
+      socket = @obj.accept_nonblock(*args)
+      socket.is_a?(Symbol) ? socket : UNIXSocket._wrap(socket)
     end
   end
 end

data/lib/lightio/library/thread.rb

@@ -1,165 +1,66 @@
 require 'thread'
-require_relative 'mutex'
 require_relative 'queue'
 
 module LightIO::Library
   class ThreadGroup
+    include Base
     include LightIO::Wrap::Wrapper
-    wrap ::ThreadGroup
-
-    Default = ThreadGroup._wrap(::ThreadGroup::Default)
+    mock ::ThreadGroup
 
     def add(thread)
-      if @io.enclosed?
+      if @obj.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)
+        @obj.add(thread)
       end
       self
     end
 
     def list
-      @io.list + threads
+      @obj.list + threads
     end
 
     private
     def threads
       @threads ||= []
     end
+
+    Default = ThreadGroup._wrap(::ThreadGroup::Default)
   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
-      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=,
-                     :handle_interrupt,
-                     :abort_on_exception,
-                     :abort_on_exception=,
-                     :pending_interrupt?
-
-      include FallbackHelper
-
-      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 Base::MockMethods
+    mock ::Thread
 
+    extend LightIO::Module::Thread::ClassMethods
     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=,
-                                 :pending_interrupt?,
-                                 :add_trace_func,
-                                 :backtrace,
-                                 :backtrace_locations,
-                                 :priority,
-                                 :priority=,
-                                 :safe_level
+    def_delegators :"Thread.main",
+                   :abort_on_exception,
+                   :abort_on_exception=,
+                   :pending_interrupt?,
+                   :add_trace_func,
+                   :backtrace,
+                   :backtrace_locations,
+                   :priority,
+                   :priority=,
+                   :safe_level
 
     def kill
       @beam.kill && self
@@ -169,7 +70,7 @@ module LightIO::Library
     alias terminate kill
 
     def status
-      if Thread.current == self
+      if self.class.current == self
         'run'
       elsif alive?
         @beam.error.nil? ? 'sleep' : 'abouting'
@@ -245,9 +146,9 @@ module LightIO::Library
       # register this thread
       thread_values
       # add self to ThreadGroup::Default
-      add_to_group(ThreadGroup::Default)
+      add_to_group(LightIO::Library::ThreadGroup::Default)
       # remove thread and thread variables
-      ObjectSpace.define_finalizer(self, self.class.finalizer(self.object_id))
+      ObjectSpace.define_finalizer(self, LightIO::Library::Thread.finalizer(self.object_id))
     end
 
     # add self to thread group
@@ -288,5 +189,135 @@ module LightIO::Library
       end
       fibers_and_values[beam_or_fiber] ||= {}
     end
+
+    class << self
+      extend Forwardable
+      def_delegators :'::Thread',
+                     :DEBUG,
+                     :DEBUG=,
+                     :handle_interrupt,
+                     :abort_on_exception,
+                     :abort_on_exception=,
+                     :pending_interrupt?
+
+      def method_missing(*args)
+        ::Thread.__send__(*args)
+      end
+
+      def respond_to?(*args)
+        ::Thread.respond_to?(*args)
+      end
+
+      def respond_to_missing?(method, *)
+        ::Thread.respond_to?(method)
+      end
+
+      private
+
+      # threads and threads variables
+      def threads
+        thrs = Thread.instance_variable_get(:@threads)
+        thrs || Thread.instance_variable_set(:@threads, {})
+      end
+
+      def thread_mutex
+        mutex = Thread.instance_variable_get(:@thread_mutex)
+        mutex || Thread.instance_variable_set(:@thread_mutex, LightIO::Library::Mutex.new)
+      end
+    end
+
+    class Mutex
+      extend Base::MockMethods
+      mock ::Mutex
+
+      def initialize
+        @queue = LightIO::Library::Queue.new
+        @queue << true
+        @locked_thread = nil
+      end
+
+      def lock
+        raise ThreadError, "deadlock; recursive locking" if owned?
+        @queue.pop
+        @locked_thread = LightIO::Thread.current
+        self
+      end
+
+      def unlock
+        raise ThreadError, "Attempt to unlock a mutex which is not locked" unless owned?
+        @locked_thread = nil
+        @queue << true
+        self
+      end
+
+      def locked?
+        !@locked_thread.nil?
+      end
+
+      def owned?
+        @locked_thread == LightIO::Thread.current
+      end
+
+      def sleep(timeout=nil)
+        unlock
+        LightIO.sleep(timeout)
+        lock
+      end
+
+      def synchronize
+        raise ThreadError, 'must be called with a block' unless block_given?
+        lock
+        begin
+          yield
+        ensure
+          unlock
+        end
+      end
+
+      def try_lock
+        if @locked_thread.nil?
+          lock
+          true
+        else
+          false
+        end
+      end
+    end
+
+    class ConditionVariable
+      extend Base::MockMethods
+      mock ::ConditionVariable
+
+      def initialize
+        @queue = LightIO::Library::Queue.new
+      end
+
+
+      def broadcast
+        signal until @queue.num_waiting == 0
+        self
+      end
+
+      def signal
+        @queue << true unless @queue.num_waiting == 0
+        self
+      end
+
+      def wait(mutex, timeout=nil)
+        mutex.unlock
+        begin
+          LightIO::Library::Timeout.timeout(timeout) do
+            @queue.pop
+          end
+        rescue Timeout::Error
+          nil
+        end
+        mutex.lock
+        self
+      end
+    end
   end
+
+  Mutex = Thread::Mutex
+  ConditionVariable = Thread::ConditionVariable
 end