bran 0.0.2 → 0.0.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 28390755dc30a2dc1027f082f7f5340d88222bb8
-  data.tar.gz: 32514e834d6f931cab276f2480d45be6588e3982
+  metadata.gz: a56dfe96ac8bd822a8dce4018ba0ad9f8fb090a6
+  data.tar.gz: 6e3045d8630a7264569f67350712d9f065b1f968
 SHA512:
-  metadata.gz: 52c90e1f8c60ccc4607da7af594e30366732c1a97778b320749f09f5feced266b4169bb5e1320621fc7a8a72eef7aee3f1edc6ddac2bd85b392e3e33024e7aa6
-  data.tar.gz: 86e450e1c22aacd177e02e4331f71100de0761912361304d63eb9bd579327a05a4874202c3caccc86d085384959d7512c59b30ad52bb783f9d6c41e62852e1e1
+  metadata.gz: 90634a69c9f5edb887124ca8a66c65dc0cf953ee4501146ac79aeb28fec9396c87ba062eb7a866c9dce6fe727cbf82f3e24133e077efcfbff28f072c6231fa4b
+  data.tar.gz: 7ec1e47489f14a4735134e0b51d00c68336de33924e01865968d3abacbd151570c141305b08637d0cf482967f4728abe4aef229b63882a20716eba96faacbb53

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

@@ -31,8 +31,12 @@ module Ethon
         @fm    = fm
         @multi = multi
         
-        @multi.socketfunction = method(:_socketfunction_callback).to_proc
-        @multi.timerfunction  = method(:_timerfunction_callback).to_proc
+        # We must hold a reference to these Procs, because the multi won't.
+        # This prevents the Procs from being GC'd while C holds the callbacks.
+        @socketfunction = method(:_socketfunction_callback).to_proc
+        @timerfunction  = method(:_timerfunction_callback).to_proc
+        @multi.socketfunction = @socketfunction
+        @multi.timerfunction  = @timerfunction
       end
       
       def perform
@@ -115,7 +119,7 @@ module Ethon
       end
       
       def timer_cancel
-        @fm.loop.timer_cancel @timeout_timer if @timeout_timer
+        @fm.loop.pop_timable @timeout_timer if @timeout_timer
       end
       
       def socket_action!(fd, flags)

data/lib/bran/ext/io.rb

@@ -80,7 +80,7 @@ Module.new do
       begin
         r_ary.each { |io| fm.loop.pop_readable(Integer(io)) } if r_ary
         w_ary.each { |io| fm.loop.pop_writable(Integer(io)) } if w_ary
-        fm.loop.timer_cancel(timer) if timer
+        fm.loop.pop_timable(timer) if timer
       ensure
         fiber.resume(item)
       end

data/lib/bran/ext/rainbows/bran.rb

@@ -31,19 +31,14 @@ module Rainbows
     def worker_loop(worker)
       readers = init_worker_process(worker)
       
-      # We have to skip the implementation from Rainbows::Base,
-      # and use the implementation from Unicorn::HttpServer directly.
-      process_client = ::Unicorn::HttpServer.instance_method(:process_client)
-      process_client = process_client.bind(self)
-      
       manager  = ::Bran::FiberManager.new
       stopping = false
       
       manager.run! do
-        manager.loop.signal_start(:INT)  { exit!(0) }
-        manager.loop.signal_start(:TERM) { exit!(0) }
-        manager.loop.signal_start(:USR1) { reopen_worker_logs(worker.nr) } # TODO: test
-        manager.loop.signal_start(:QUIT) { stopping = true } # TODO: test softness
+        manager.loop.push_signalable :INT,  Proc.new { exit!(0) }
+        manager.loop.push_signalable :TERM, Proc.new { exit!(0) }
+        manager.loop.push_signalable :USR1, Proc.new { reopen_worker_logs(worker.nr) } # TODO: test
+        manager.loop.push_signalable :QUIT, Proc.new { stopping = true } # TODO: test softness
         
         readers.each do |reader|
           next unless reader.is_a?(::Kgio::TCPServer) # TODO: other readers?
@@ -51,8 +46,14 @@ module Rainbows
           worker_connections.times.map do |i|
             ::Fiber.new do
               until stopping # TODO: rescue and report errors here
-                manager.wait_for_readable!(reader)
-                process_client.call(reader.kgio_accept)
+                # Try to accept a client, then if none, wait for one to appear.
+                # This may happen more than once when there all multiple
+                # workers all contending for clients on the same server socket.
+                until (client = reader.kgio_tryaccept)
+                  manager.wait_for_readable!(reader)
+                end
+                
+                process_client client
               end
             end.resume
           end

data/lib/bran/libuv/reactor.rb

@@ -1,4 +1,6 @@
 
+require_relative "reactor/collections"
+
 module Bran
   module LibUV
     class Reactor
@@ -14,26 +16,15 @@ module Bran
         @finalizer = self.class.create_finalizer_for(@ptr)
         ObjectSpace.define_finalizer(self, @finalizer)
         
-        @available_polls     = []
-        @running_reads       = {}
-        @running_writes      = {}
-        @fds_by_read_addr    = {}
-        @fds_by_write_addr   = {}
-        @on_readables        = {}
-        @on_writables        = {}
-        
-        @available_signals   = []
-        @running_signals     = {}
-        
-        @available_timers    = []
-        @running_timers      = {}
+        @read_polls  = Collections::Read.new(self)
+        @write_polls = Collections::Write.new(self)
+        @write_polls.bond_with @read_polls
         
-        @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))
+        @signal_polls = Collections::Signal.new(self)
+        @timer_polls  = Collections::Timer.new(self)
         
         # TODO: add more Ruby-compatible signal handlers by default?
-        signal_start(:INT) { @abort_signal = :INT; stop! }
+        push_signalable :INT, Proc.new { @abort_signal = :INT; stop! }
       end
       
       # Free the native resources associated with this object. This will
@@ -45,13 +36,8 @@ module Bran
         end
         @ptr = @finalizer = nil
         
-        @available_polls      = \
-          @running_reads      = @running_writes      = \
-          @fds_by_read_addr   = @fds_by_write_addr   = \
-          @on_readables       = @on_writables        = \
-          @available_signals  = @running_signals     = \
-          @available_timers   = @running_timers      = \
-          @poll_read_callback = @poll_write_callback = nil
+        @read_polls   = @write_polls = \
+        @signal_polls = @timer_polls = nil
         
         self
       end
@@ -104,293 +90,106 @@ 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)
-        poll = nil
-        
-        if (readables = @on_readables[fd])
-          readables << [handler, persistent]
-        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
-        
-        fd
+        @read_polls.push(Integer(fd), handler, persistent)
       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)
-        poll = nil
-        
-        if (writables = @on_writables[fd])
-          writables << [handler, persistent]
-        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
+        @write_polls.push(Integer(fd), handler, persistent)
+      end
+      
+      # Push the given handler for the given signo, adding if necessary.
+      # If persistent is false, the handler will be popped after one trigger.
+      def push_signalable(signo, handler, persistent = true)
+        signo = Signal.list.fetch(signo.to_s) unless signo.is_a?(Integer)
         
-        fd
+        @signal_polls.push(signo, handler, persistent)
+      end
+      
+      # Push the given handler for the given timer id, adding if necessary.
+      # If persistent is false, the handler will be popped after one trigger.
+      def push_timable(ident, timeout, handler, persistent = true)
+        @timer_polls.push(ident, handler, persistent, timeout)
       end
       
       # Remove the next readable handler for the given fd.
       def pop_readable(fd)
-        fd = Integer(fd)
-        
-        readables = @on_readables[fd]
-        return unless readables
-        
-        readables.pop
-        return unless readables.empty?
-        
-        @on_readables.delete(fd)
-        poll = @running_reads.delete(fd)
-        @fds_by_read_addr.delete(poll.address)
-        
-        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
+        @read_polls.pop(Integer(fd))
       end
       
       # Remove the next writable handler for the given fd.
       def pop_writable(fd)
-        fd = Integer(fd)
-        
-        writables = @on_writables[fd]
-        return unless writables
-          
-        writables.pop
-        return unless writables.empty?
-        
-        @on_writables.delete(fd)
-        poll = @running_writes.delete(fd)
-        @fds_by_write_addr.delete(poll.address)
-        
-        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
+        @write_polls.pop(Integer(fd))
       end
       
-      # Start handling the given signal, running the given block when it occurs.
-      def signal_start(signo, &block)
-        ptr   = ptr()
+      # Remove the next signal handler for the given signal.
+      def pop_signalable(signo)
         signo = Signal.list.fetch(signo.to_s) unless signo.is_a?(Integer)
         
-        signal_stop(signo) if @running_signals.has_key?(signo)
-        
-        callback = FFI.uv_signal_cb do |_, _|
-          rescue_abort do
-            block.call self, signo
-          end
-        end
-        
-        signal = @available_signals.pop || FFI.uv_signal_alloc
-        @running_signals[signo] = [signal, callback]
-        
-        # TODO: investigate if need not init existing available_signals
-        Util.error_check "creating the signal item",
-          FFI.uv_signal_init(ptr, signal)
-        
-        Util.error_check "starting the signal item",
-          FFI.uv_signal_start(signal, callback, signo)
+        @signal_polls.pop(signo)
       end
       
-      # Stop handling the given signal.
-      def signal_stop(signo)
-        signo = Signal.list.fetch(signo.to_s) unless signo.is_a?(Integer)
-        
-        signal, callback = @running_signals.delete(signo)
-        
-        return unless signal
-        
-        Util.error_check "stopping the signal item",
-          FFI.uv_signal_stop(signal)
-        
-        @available_signals << signal
-        
-        nil
-      end
-      
-      # Start a timer to run the given block after the given timeout.
-      # If a repeat_interval is given, after the first run, the block will be
-      # run repeatedly at that interval. If a repeat_interval is not given,
-      # or given as nil or 0, timer_cancel is called automatically at first run.
-      # Both timeout and repeat_interval should be given in seconds.
-      def timer_start(timeout, repeat_interval = nil, &block)
-        ptr = ptr()
-        
-        timeout = (timeout * 1000).ceil
-        
-        repeat = false
-        if repeat_interval and repeat_interval > 0
-          repeat_interval = (repeat_interval * 1000).ceil
-          repeat          = true
-        else
-          repeat_interval = 0
-        end
-        
-        raise ArgumentError, "callback block required" unless block
-        
-        timer = @available_timers.pop || FFI.uv_timer_alloc
-        id    = timer.address
-        
-        callback = FFI.uv_timer_cb do |_|
-          rescue_abort do
-            block.call self, id
-            
-            timer_cancel(id) unless repeat
-          end
-        end
-        
-        @running_timers[id] = [timer, callback]
-        
-        # TODO: investigate if need not init existing available_timers
-        Util.error_check "creating the timer item",
-          FFI.uv_timer_init(ptr, timer)
-        
-        Util.error_check "starting the timer item",
-          FFI.uv_timer_start(timer, callback, timeout, repeat_interval)
-        
-        id
-      end
-      
-      # Stop handling the given timer.
-      def timer_cancel(id)
-        id = Integer(id)
-        
-        timer, callback = @running_timers.delete(id)
-        
-        return unless timer
-        
-        Util.error_check "stopping the timer item",
-          FFI.uv_timer_stop(timer)
-        
-        @available_timers << timer
-        
-        nil
+      # Remove the next timer handler for the given timer.
+      def pop_timable(ident)
+        @timer_polls.pop(ident)
       end
       
       # Start a timer to run the given block after the given timeout.
       # The timer will be run just once, starting now.
       def timer_oneshot(time, &block)
-        timer_start(time, &block)
+        push_timable(block.object_id, time, block, false)
       end
       
       # Start a timer to wake the given fiber after the given timeout.
       # The timer will be run just once, starting now.
       def timer_oneshot_wake(time, fiber)
-        timer_start(time) { fiber.resume } # TODO: optimize this case
+        timer_oneshot(time) { fiber.resume } # TODO: optimize this case, but be careful of ident uniqueness
       end
       
     private
       
       # Callback method called directly from FFI when an event is readable.
-      def _poll_read_callback(poll, rc, events)
+      def _read_callback(poll, rc, events)
         rescue_abort do
-          fd = @fds_by_read_addr[poll.address]
-          return unless fd
-          
-          readables = @on_readables.fetch(fd)
-          
-          handler, persistent = readables.last
-          pop_readable(fd) unless persistent
-          
-          invoke_handler(handler, rc)
+          @read_polls.invoke_by_addr(poll.address, rc)
         end
       end
       
       # Callback method called directly from FFI when an event is writable.
-      def _poll_write_callback(poll, rc, events)
+      def _write_callback(poll, rc, events)
         rescue_abort do
-          fd = @fds_by_write_addr[poll.address]
-          return unless fd
-          
-          writables = @on_writables.fetch(fd)
-          
-          handler, persistent = writables.last
-          pop_writable(fd) unless persistent
-          
-          invoke_handler(handler, rc)
+          @write_polls.invoke_by_addr(poll.address, rc)
         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
-        when ::Fiber
-          if rc == 0
-            handler.resume nil
-          else
-            handler.resume Util.error_create("running the libuv loop", rc)
+      def _rw_callback(poll, rc, events)
+        rescue_abort do
+          if 0 != (events & FFI::UV_READABLE)
+            @read_polls.invoke_by_addr(poll.address, rc)
           end
-        when ::Proc
-          if rc == 0
-            handler.call nil
-          else
-            error = Util.error_create("running the libuv loop", rc)
-            handler.call error
+          
+          if 0 != (events & FFI::UV_WRITABLE)
+            @write_polls.invoke_by_addr(poll.address, rc)
           end
         end
       end
       
+      # Callback method called directly from FFI when an event is signalled.
+      def _signal_callback(handle, signo)
+        rescue_abort do
+          @signal_polls.invoke_by_ident(signo)
+        end
+      end
+      
+      # Callback method called directly from FFI when a timer has occurred.
+      def _timer_callback(handle)
+        rescue_abort do
+          @timer_polls.invoke_by_addr(handle.address)
+        end
+      end
+      
     end
   end
 end

data/lib/bran/libuv/reactor/collections.rb

@@ -0,0 +1,279 @@
+
+module Bran
+  module LibUV
+    class Reactor
+      module Collections
+        
+        class Abstract
+          def initialize(reactor)
+            @reactor = reactor
+            
+            @idents_by_addr  = {}
+            @items_by_ident  = {}
+            @stacks_by_ident = {}
+          end
+          
+          def push(ident, handler, persistent, *extra_args)
+            if (stack = @stacks_by_ident[ident])
+              stack << [handler, persistent]
+            else
+              item = make_item(ident, extra_args)
+              
+              @items_by_ident[ident]        = item
+              @idents_by_addr[item.address] = ident
+              @stacks_by_ident[ident]       = [[handler, persistent]]
+            end
+            
+            ident
+          end
+          
+          def pop(ident)
+            stack = @stacks_by_ident[ident]
+            return unless stack
+            
+            stack.pop
+            return unless stack.empty?
+            
+            @stacks_by_ident.delete(ident)
+            item = @items_by_ident.delete(ident)
+            @idents_by_addr.delete(item.address)
+            
+            drop_item(ident, item)
+          end
+          
+          def item_by_ident(ident)
+            @items_by_ident[ident]
+          end
+          
+          def invoke_by_ident(ident, rc = 0)
+            stack = @stacks_by_ident[ident]
+            return unless ident
+            
+            handler, persistent = stack.last
+            pop ident unless persistent
+            
+            invoke_handler(handler, rc)
+          end
+          
+          def invoke_by_addr(addr, rc = 0)
+            ident = @idents_by_addr[addr]
+            return unless ident
+            
+            stack = @stacks_by_ident.fetch(ident)
+            
+            handler, persistent = stack.last
+            pop ident unless persistent
+            
+            invoke_handler(handler, rc)
+          end
+          
+          def invoke_handler(handler, rc = 0)
+            case handler
+            when ::Fiber
+              if rc == 0
+                handler.resume nil
+              else
+                handler.resume Util.error_create("running the libuv loop", rc)
+              end
+            when ::Proc
+              if rc == 0
+                handler.call nil
+              else
+                error = Util.error_create("running the libuv loop", rc)
+                handler.call error
+              end
+            end
+          end
+          
+          def make_item(ident, extra_args)
+            item = concrete_alloc_item
+            concrete_start_item(ident, item, *extra_args)
+            
+            item
+          end
+          
+          def drop_item(ident, item)
+            concrete_stop_item(ident, item)
+            concrete_release_item(item)
+            
+            nil
+          end
+        end
+        
+        class AbstractSister < Abstract
+          attr_accessor :sister
+          attr_accessor :item_pool
+          
+          def bond_with(sister)
+            @sister = sister
+            @item_pool = []
+            
+            @sister.sister = self
+            @sister.item_pool = @item_pool
+          end
+          
+          def make_item(ident, extra_args)
+            item = @sister.item_by_ident(ident)
+            return super unless item
+            
+            @sister.concrete_sister_share_item(ident, item)
+            
+            item
+          end
+          
+          def drop_item(ident, item)
+            sister_item = @sister.item_by_ident(ident)
+            return super unless sister_item == item
+            
+            @sister.concrete_sister_unshare_item(ident, item)
+            
+            nil
+          end
+        end
+        
+        class Read < AbstractSister
+          def initialize(*)
+            super
+            @callback    = FFI.uv_poll_cb(&@reactor.method(:_read_callback))
+            @rw_callback = FFI.uv_poll_cb(&@reactor.method(:_rw_callback))
+          end
+          
+          def concrete_alloc_item
+            @item_pool.pop || FFI.uv_poll_alloc
+          end
+          
+          def concrete_release_item(item)
+            @item_pool << item
+          end
+          
+          def concrete_start_item(ident, item)
+            Util.error_check "creating the poll readable item",
+              FFI.uv_poll_init(@reactor.ptr, item, ident)
+            
+            Util.error_check "starting the poll readable item",
+              FFI.uv_poll_start(item, FFI::UV_READABLE, @callback)
+          end
+          
+          def concrete_stop_item(ident, item)
+            Util.error_check "stopping the poll readable item",
+              FFI.uv_poll_stop(item)
+          end
+          
+          def concrete_sister_share_item(ident, item)
+            Util.error_check "starting the poll readable + writable item",
+              FFI.uv_poll_start(item,
+                FFI::UV_READABLE | FFI::UV_WRITABLE, @rw_callback)
+          end
+          
+          def concrete_sister_unshare_item(ident, item)
+            Util.error_check "restarting the poll readable item",
+              FFI.uv_poll_start(item, FFI::UV_READABLE, @callback)
+          end
+        end
+        
+        class Write < AbstractSister
+          def initialize(*)
+            super
+            @callback    = FFI.uv_poll_cb(&@reactor.method(:_write_callback))
+            @rw_callback = FFI.uv_poll_cb(&@reactor.method(:_rw_callback))
+          end
+          
+          def concrete_alloc_item
+            @item_pool.pop || FFI.uv_poll_alloc
+          end
+          
+          def concrete_release_item(item)
+            @item_pool << item
+          end
+          
+          def concrete_start_item(ident, item)
+            Util.error_check "creating the poll writable item",
+              FFI.uv_poll_init(@reactor.ptr, item, ident)
+            
+            Util.error_check "starting the poll writable item",
+              FFI.uv_poll_start(item, FFI::UV_WRITABLE, @callback)
+          end
+          
+          def concrete_stop_item(ident, item)
+            Util.error_check "stopping the poll writable item",
+              FFI.uv_poll_stop(item)
+          end
+          
+          def concrete_sister_share_item(ident, item)
+            Util.error_check "starting the poll writable + writable item",
+              FFI.uv_poll_start(item,
+                FFI::UV_READABLE | FFI::UV_WRITABLE, @rw_callback)
+          end
+          
+          def concrete_sister_unshare_item(ident, item)
+            Util.error_check "restarting the poll writable item",
+              FFI.uv_poll_start(item, FFI::UV_WRITABLE, @callback)
+          end
+        end
+        
+        class Signal < Abstract
+          def initialize(*)
+            super
+            @item_pool = []
+            @callback  = FFI.uv_signal_cb(&@reactor.method(:_signal_callback))
+          end
+          
+          def concrete_alloc_item
+            @item_pool.pop || FFI.uv_signal_alloc
+          end
+          
+          def concrete_release_item(item)
+            @item_pool << item
+          end
+          
+          def concrete_start_item(ident, item)
+            # TODO: need not init existing signal item?
+            Util.error_check "creating the signal handler item",
+              FFI.uv_signal_init(@reactor.ptr, item)
+            
+            Util.error_check "starting the signal handler item",
+              FFI.uv_signal_start(item, @callback, ident)
+          end
+          
+          def concrete_stop_item(ident, item)
+            Util.error_check "stopping the signal handler item",
+              FFI.uv_signal_stop(item)
+          end
+        end
+        
+        class Timer < Abstract
+          def initialize(*)
+            super
+            @item_pool = []
+            @callback  = FFI.uv_timer_cb(&@reactor.method(:_timer_callback))
+          end
+          
+          def concrete_alloc_item
+            @item_pool.pop || FFI.uv_timer_alloc
+          end
+          
+          def concrete_release_item(item)
+            @item_pool << item
+          end
+          
+          def concrete_start_item(ident, item, timeout)
+            timeout_ms = (timeout * 1000).ceil
+            
+            # TODO: need not init existing timer item?
+            Util.error_check "creating the timer item",
+              FFI.uv_timer_init(@reactor.ptr, item)
+            
+            Util.error_check "starting the timer item",
+              FFI.uv_timer_start(item, @callback, timeout_ms, timeout_ms)
+          end
+          
+          def concrete_stop_item(ident, item)
+            Util.error_check "stopping the timer item",
+              FFI.uv_timer_stop(item)
+          end
+        end
+        
+      end
+    end
+  end
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: bran
 version: !ruby/object:Gem::Version
-  version: 0.0.2
+  version: 0.0.3
 platform: ruby
 authors:
 - Joe McIlvain
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2016-02-09 00:00:00.000000000 Z
+date: 2016-02-10 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: ffi
@@ -138,6 +138,7 @@ files:
 - lib/bran/libuv.rb
 - lib/bran/libuv/ffi.rb
 - lib/bran/libuv/reactor.rb
+- lib/bran/libuv/reactor/collections.rb
 - lib/bran/libuv/util.rb
 homepage: https://github.com/jemc/ruby-bran
 licenses: