bran 0.0.1 → 0.0.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 36a615f86cbc15a2b7c138816df60678ca2a0786
-  data.tar.gz: 48570f692b614243db475256f19265f74993be70
+  metadata.gz: 28390755dc30a2dc1027f082f7f5340d88222bb8
+  data.tar.gz: 32514e834d6f931cab276f2480d45be6588e3982
 SHA512:
-  metadata.gz: c14a66422d3310bc2619afb7c59e883c6c9ec6022b7e9139b7800b2a5aa3ca1114cab48ce76d4bce553ffbcab647de60c5604dfbc8f4f6159649ea3a18c31e6e
-  data.tar.gz: 2ba3d09c4a6786b300e3c4c96030ed692fdc60a880c539a396efc42ba081eb66c190529e4c9bc217d12fd415399b1bacc1088b9fe5b0261f6f616fcb17ab21e8
+  metadata.gz: 52c90e1f8c60ccc4607da7af594e30366732c1a97778b320749f09f5feced266b4169bb5e1320621fc7a8a72eef7aee3f1edc6ddac2bd85b392e3e33024e7aa6
+  data.tar.gz: 86e450e1c22aacd177e02e4331f71100de0761912361304d63eb9bd579327a05a4874202c3caccc86d085384959d7512c59b30ad52bb783f9d6c41e62852e1e1

data/README.md

@@ -18,6 +18,35 @@ Bran::Ext.check_assumptions = true
 
 The description of each Bran integration will also be labeled "Tested with" for known good combinations of dependent gems.
 
+### IO, TCPServer
+
+Use Bran with any pure-Ruby library or application that uses plain IO (such as TCPSocket and TCPServer). All blocking `read` operations on IO, `IO.select`, and `TCPServer#accept` will be patched to yield their fiber instead of blocking.
+
+Without any other Bran integrations, this requires manually running your own concurrent fibers of execution, scoped with a thread-local fiber manager. If no fiber manager is present, the methods will function as normal (without Bran). It's easier to use with another application-wide integration (like the Rainbows integration) that manages concurrent fibers for you.
+
+To activate the Bran integrations, simply load the corresponding files:
+
+```ruby
+require "bran/ext/io"
+require "bran/ext/tcp_server"
+```
+
+### Ethon (Typhoeus)
+
+Use Bran with any library or application that uses [Ethon][ethon] to perform HTTP requests (for example, [Typhoeus][typhoeus]). Both `Ethon::Easy#perform` and `Ethon::Multi#perform` will be patched to yield their fiber instead of blocking while waiting for the HTTP response.
+
+Without any other Bran integrations, this requires manually running your own concurrent fibers of execution, scoped with a thread-local fiber manager. If no fiber manager is present, the methods will function as normal (without Bran). It's easier to use with another application-wide integration (like the Rainbows integration) that manages concurrent fibers for you.
+
+To activate the Bran integration, simply load the corresponding file:
+
+```ruby
+require "bran/ext/ethon"
+```
+
+Tested with:
+
+- `ethon 0.8.1`
+
 ### Rainbows
 
 Use Bran with [Rainbows][rainbows], a [Unicorn][unicorn]-based and [Unicorn][unicorn]-compatible webserver from the creators of [Unicorn][unicorn].
@@ -36,8 +65,11 @@ end
 ```
 
 Tested with:
+
 - `rainbows 5.0.0` (`unicorn 5.0.0`, `kgio 2.10.0`)
 - `rainbows 5.0.0` (`unicorn 5.0.1`, `kgio 2.10.0`)
 
+[ethon]:    https://github.com/typhoeus/ethon
+[typhoeus]: https://github.com/typhoeus/typhoeus
 [rainbows]: http://rainbows.bogomips.org/
 [unicorn]:  http://unicorn.bogomips.org/

data/lib/bran/ext/ethon.rb

@@ -0,0 +1,11 @@
+
+require_relative "../../bran"
+require_relative "../../bran/ext"
+
+::Bran::Ext[:ethon] = true
+
+require "ethon"
+
+require_relative "ethon/curl"
+require_relative "ethon/multi"
+require_relative "ethon/easy"

data/lib/bran/ext/ethon/curl.rb

@@ -0,0 +1,21 @@
+
+Ethon::Curl.ffi_lib ["libcurl", "libcurl.so.4"]
+
+Ethon::Curl.attach_function :multi_socket_action, :curl_multi_socket_action,
+  [:pointer, :int, :int, :pointer], :multi_code, blocking: true
+
+module Ethon
+  module Curl
+    POLL_NONE   = 0
+    POLL_IN     = 1
+    POLL_OUT    = 2
+    POLL_INOUT  = 3
+    POLL_REMOVE = 4
+    
+    CSELECT_IN  = 0x01
+    CSELECT_OUT = 0x02
+    CSELECT_ERR = 0x04
+    
+    SOCKET_TIMEOUT = -1
+  end
+end

data/lib/bran/ext/ethon/easy.rb

@@ -0,0 +1,15 @@
+
+Module.new do
+  Ethon::Easy.prepend self
+  
+  def perform
+    fm = Thread.current.thread_variable_get(:fiber_manager)
+    return super unless fm
+    
+    multi = Ethon::Multi.new
+    multi.add self
+    multi.perform
+    
+    return_code
+  end
+end

data/lib/bran/ext/ethon/multi.rb

@@ -0,0 +1,24 @@
+
+require_relative "multi/bran"
+
+Module.new do
+  Ethon::Multi.prepend self
+  
+  def initialize(*)
+    super
+    
+    # Create a bran performer that can steal work from this multi.
+    # Fall back to normal path (no bran) if not under fiber management.
+    fm = Thread.current.thread_variable_get(:fiber_manager)
+    @bran = Ethon::Multi::Bran.new(fm, self) if fm
+  end
+  
+  def perform
+    # Use the bran performer instead of the normal path to perform this multi.
+    # Fall back to normal path (no bran) if not under fiber management,
+    # or if it fails because we are not under the same fiber manager as before.
+    (@bran && @bran.perform) || super
+    
+    nil
+  end
+end

data/lib/bran/ext/ethon/multi/bran.rb

@@ -0,0 +1,142 @@
+
+::Bran::Ext.assume do
+  check ::Ethon::Multi < ::Ethon::Multi::Operations
+  check ::Ethon::Multi::Operations.instance_method(:handle).arity == 0
+  check ::Ethon::Multi::Operations.instance_method(:check).arity == 0
+  
+  check ::Ethon::Multi < ::Ethon::Multi::Stack
+  check ::Ethon::Multi::Stack.instance_method(:easy_handles).arity == 0
+  
+  check ::Ethon::Multi < ::Ethon::Multi::Options
+  check ::Ethon::Multi::Options.instance_method(:socketfunction=).arity == 1
+  check ::Ethon::Multi::Options.instance_method(:timerfunction=).arity == 1
+  
+  check ::Ethon::Errors::MultiTimeout.instance_method(:initialize).arity == 1
+  
+  check ::Ethon::Curl.method(:multi_socket_action)
+  check ::Ethon::Curl::POLL_IN
+  check ::Ethon::Curl::POLL_OUT
+  check ::Ethon::Curl::POLL_INOUT
+  check ::Ethon::Curl::POLL_REMOVE
+  check ::Ethon::Curl::SOCKET_TIMEOUT
+  check ::Ethon::Curl::CSELECT_IN
+  check ::Ethon::Curl::CSELECT_OUT
+end
+
+module Ethon
+  
+  class Multi
+    class Bran
+      def initialize(fm, multi)
+        @fm    = fm
+        @multi = multi
+        
+        @multi.socketfunction = method(:_socketfunction_callback).to_proc
+        @multi.timerfunction  = method(:_timerfunction_callback).to_proc
+      end
+      
+      def perform
+        fm = Thread.current.thread_variable_get(:fiber_manager)
+        return unless fm == @fm # abort if not run within the same context.
+        
+        @curl_readables = {}
+        @curl_writables = {}
+        @fds_remaining_ptr = ::FFI::MemoryPointer.new(:int)
+        
+        raise @callback_error if @callback_error
+        
+        @perform_fiber = ::Fiber.current
+        ::Fiber.yield
+        @perform_fiber = nil
+        
+        raise @callback_error if @callback_error
+        
+        true
+      end
+      
+    private
+      
+      def _socketfunction_callback(easy_handle, fd, action, *)
+        case action
+        when ::Ethon::Curl::POLL_IN     then poll_in(fd)
+        when ::Ethon::Curl::POLL_OUT    then poll_out(fd)
+        when ::Ethon::Curl::POLL_INOUT  then poll_in(fd); poll_out(fd)
+        when ::Ethon::Curl::POLL_REMOVE then poll_remove(fd)
+        end
+        
+        0
+      rescue Exception => e
+        @callback_error = e
+        @fm.resume_soon(@perform_fiber) if @perform_fiber
+        
+        0
+      end
+      
+      def _timerfunction_callback(_, timeout_ms, *)
+        timer_cancel
+        
+        return if timeout_ms.is_a?(::Bignum) # corresponds to -1
+        
+        @timeout_timer = @fm.loop.timer_oneshot timeout_ms / 1000.0 do
+          @timeout_timer = nil
+          
+          socket_action!(::Ethon::Curl::SOCKET_TIMEOUT, 0) if @perform_fiber
+        end
+        
+        0
+      rescue Exception => e
+        @callback_error = e
+        @fm.resume_soon(@perform_fiber) if @perform_fiber
+        
+        0
+      end
+      
+      def poll_in(fd)
+        return if @curl_readables[fd]
+        @curl_readables[fd] = true
+        
+        @fm.loop.push_readable fd,
+          Proc.new { socket_action!(fd, ::Ethon::Curl::CSELECT_IN) }
+      end
+      
+      def poll_out(fd)
+        return if @curl_writables[fd]
+        @curl_writables[fd] = true
+        
+        @fm.loop.push_writable fd,
+          Proc.new { socket_action!(fd, ::Ethon::Curl::CSELECT_OUT) }
+      end
+      
+      def poll_remove(fd)
+        @fm.loop.pop_readable(fd) if @curl_readables.delete(fd)
+        @fm.loop.pop_writable(fd) if @curl_writables.delete(fd)
+        
+        maybe_finish!
+      end
+      
+      def timer_cancel
+        @fm.loop.timer_cancel @timeout_timer if @timeout_timer
+      end
+      
+      def socket_action!(fd, flags)
+        code = ::Ethon::Curl.multi_socket_action(@multi.handle, fd, flags,
+                                                 @fds_remaining_ptr)
+        raise ::Ethon::Errors::MultiTimeout.new(code) unless code == :ok
+        
+        if @fds_remaining_ptr.read_int == 0
+          @multi.__send__(:check)
+          maybe_finish!
+        end
+      end
+      
+      def maybe_finish!
+        return unless @curl_readables.empty? && @curl_writables.empty? \
+                                             && @multi.easy_handles.empty?
+        timer_cancel
+        
+        @perform_fiber.resume
+      end
+      
+    end
+  end
+end

data/lib/bran/fiber_manager.rb

@@ -39,5 +39,9 @@ module Bran
       ::Fiber.yield
     end
     
+    def resume_soon(fiber)
+      @loop.timer_oneshot_wake(0, fiber)
+    end
+    
   end
 end

data/lib/bran/libuv/reactor.rb

@@ -30,6 +30,7 @@ module Bran
         
         @poll_read_callback  = FFI.uv_poll_cb(&method(:_poll_read_callback))
         @poll_write_callback = FFI.uv_poll_cb(&method(:_poll_write_callback))
+        @poll_rw_callback    = FFI.uv_poll_cb(&method(:_poll_rw_callback))
         
         # TODO: add more Ruby-compatible signal handlers by default?
         signal_start(:INT) { @abort_signal = :INT; stop! }
@@ -103,54 +104,64 @@ module Bran
       # Push the given handler for the given fd, adding if necessary.
       # If persistent is false, the handler will be popped after one trigger.
       def push_readable(fd, handler, persistent = true)
-        ptr = ptr()
-        fd  = Integer(fd)
+        ptr  = ptr()
+        fd   = Integer(fd)
+        poll = nil
         
-        # TODO: worry about readable vs writable mixing/overlap
         if (readables = @on_readables[fd])
           readables << [handler, persistent]
-          return
+        elsif (poll = @running_writes[fd])
+          @running_reads[fd]              = poll
+          @fds_by_read_addr[poll.address] = fd
+          @on_readables[fd]               = [[handler, persistent]]
+          
+          Util.error_check "starting the poll readable + writable entry",
+            FFI.uv_poll_start(poll, FFI::UV_READABLE | FFI::UV_WRITABLE, @poll_rw_callback)
+        else
+          poll = @available_polls.pop || FFI.uv_poll_alloc
+          @running_reads[fd]              = poll
+          @fds_by_read_addr[poll.address] = fd
+          @on_readables[fd]               = [[handler, persistent]]
+          
+          Util.error_check "creating the poll readable entry",
+            FFI.uv_poll_init(ptr, poll, fd)
+          
+          Util.error_check "starting the poll readable entry",
+            FFI.uv_poll_start(poll, FFI::UV_READABLE, @poll_read_callback)
         end
         
-        poll = @available_polls.pop || FFI.uv_poll_alloc
-        @running_reads[fd]              = poll
-        @fds_by_read_addr[poll.address] = fd
-        @on_readables[fd]               = [[handler, persistent]]
-        
-        # TODO: investigate if need not init existing available_polls
-        Util.error_check "creating the poll readable entry",
-          FFI.uv_poll_init(ptr, poll, fd)
-        
-        Util.error_check "starting the poll readable entry",
-          FFI.uv_poll_start(poll, FFI::UV_READABLE, @poll_read_callback)
-        
         fd
       end
       
       # Push the given handler for the given fd, adding if necessary.
       # If persistent is false, the handler will be popped after one trigger.
       def push_writable(fd, handler, persistent = true)
-        ptr = ptr()
-        fd  = Integer(fd)
+        ptr  = ptr()
+        fd   = Integer(fd)
+        poll = nil
         
-        # TODO: worry about writable vs writable mixing/overlap
         if (writables = @on_writables[fd])
           writables << [handler, persistent]
-          return
+        elsif (poll = @running_reads[fd])
+          @running_writes[fd]              = poll
+          @fds_by_write_addr[poll.address] = fd
+          @on_writables[fd]                = [[handler, persistent]]
+          
+          Util.error_check "starting the poll readable + writable entry",
+            FFI.uv_poll_start(poll, FFI::UV_READABLE | FFI::UV_WRITABLE, @poll_rw_callback)
+        else
+          poll = @available_polls.pop || FFI.uv_poll_alloc
+          @running_writes[fd]              = poll
+          @fds_by_write_addr[poll.address] = fd
+          @on_writables[fd]                = [[handler, persistent]]
+          
+          Util.error_check "creating the poll writeable entry",
+            FFI.uv_poll_init(ptr, poll, fd)
+          
+          Util.error_check "starting the poll writeable entry",
+            FFI.uv_poll_start(poll, FFI::UV_WRITABLE, @poll_write_callback)
         end
         
-        poll = @available_polls.pop || FFI.uv_poll_alloc
-        @running_writes[fd]              = poll
-        @fds_by_write_addr[poll.address] = fd
-        @on_writables[fd]                = [[handler, persistent]]
-        
-        # TODO: investigate if need not init existing available_polls
-        Util.error_check "creating the poll writable entry",
-          FFI.uv_poll_init(ptr, poll, fd)
-        
-        Util.error_check "starting the poll writable entry",
-          FFI.uv_poll_start(poll, FFI::UV_WRITABLE, @poll_write_callback)
-        
         fd
       end
       
@@ -160,7 +171,7 @@ module Bran
         
         readables = @on_readables[fd]
         return unless readables
-          
+        
         readables.pop
         return unless readables.empty?
         
@@ -171,6 +182,13 @@ module Bran
         Util.error_check "stopping the poll readable entry",
           FFI.uv_poll_stop(poll)
         
+        if poll == @running_writes[fd]
+          Util.error_check "restarting the poll writable entry",
+            FFI.uv_poll_start(poll, FFI::UV_WRITABLE, @poll_write_callback)
+          
+          return
+        end
+        
         @available_polls << poll
         
         nil
@@ -193,6 +211,13 @@ module Bran
         Util.error_check "stopping the poll writable entry",
           FFI.uv_poll_stop(poll)
         
+        if poll == @running_reads[fd]
+          Util.error_check "restarting the poll readable entry",
+            FFI.uv_poll_start(poll, FFI::UV_READABLE, @poll_read_callback)
+          
+          return
+        end
+        
         @available_polls << poll
         
         nil
@@ -314,7 +339,9 @@ module Bran
       # Callback method called directly from FFI when an event is readable.
       def _poll_read_callback(poll, rc, events)
         rescue_abort do
-          fd        = @fds_by_read_addr.fetch(poll.address)
+          fd = @fds_by_read_addr[poll.address]
+          return unless fd
+          
           readables = @on_readables.fetch(fd)
           
           handler, persistent = readables.last
@@ -327,7 +354,9 @@ module Bran
       # Callback method called directly from FFI when an event is writable.
       def _poll_write_callback(poll, rc, events)
         rescue_abort do
-          fd        = @fds_by_write_addr.fetch(poll.address)
+          fd = @fds_by_write_addr[poll.address]
+          return unless fd
+          
           writables = @on_writables.fetch(fd)
           
           handler, persistent = writables.last
@@ -337,6 +366,12 @@ module Bran
         end
       end
       
+      # Callback method called directly from FFI when an event is readable or writable.
+      def _poll_rw_callback(poll, rc, events)
+        _poll_read_callback(poll, rc, events)  if events & FFI::UV_READABLE != 0
+        _poll_write_callback(poll, rc, events) if events & FFI::UV_WRITABLE != 0
+      end
+      
       # Invoke the given handler, possibly converting the given rc to an error.
       def invoke_handler(handler, rc)
         case handler

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: bran
 version: !ruby/object:Gem::Version
-  version: 0.0.1
+  version: 0.0.2
 platform: ruby
 authors:
 - Joe McIlvain
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2016-02-03 00:00:00.000000000 Z
+date: 2016-02-09 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: ffi
@@ -125,6 +125,11 @@ files:
 - ext/libuv/Rakefile
 - lib/bran.rb
 - lib/bran/ext.rb
+- lib/bran/ext/ethon.rb
+- lib/bran/ext/ethon/curl.rb
+- lib/bran/ext/ethon/easy.rb
+- lib/bran/ext/ethon/multi.rb
+- lib/bran/ext/ethon/multi/bran.rb
 - lib/bran/ext/io.rb
 - lib/bran/ext/rainbows.rb
 - lib/bran/ext/rainbows/bran.rb