hakuban 0.6.0 → 0.6.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 80450f20193ebd24bb8f0b55e9e822be3a0271d26aa1c41954fe09a23c02a62d
-  data.tar.gz: 56a74e6c21534550ef484ae58ede825fd6690f847d45245c57be3271943d77bb
+  metadata.gz: e6822f983334fd24d18385b13f77352026609b85e2f386760b00bae8e60e53cb
+  data.tar.gz: e90301ced5b302e23fcc4c3da3d59c9ac32bf9e22d472272ff43bdb8ad78eadc
 SHA512:
-  metadata.gz: 9a67bad1007498001d0550abd1eab1827d155fe6b6f25ee94aa08149bd054090bc9d0b37e1767eb03b7b7971216643e4c7dd396f7ef7cc20420ea7b54fbebdea
-  data.tar.gz: 5f3d377665666e3cada421c1140c3a8e8b00e84564b61a6c29991560b45615846dfbddce318b212b2d386d9f3b84737b59a7fccc5c4068661da1b366032b8c6d
+  metadata.gz: 22eb5c5b3223bd25d7b3dea31f52134f9a71a07a1fcdf06e4d6077dc27df689e57a9e92cb059919f283f8708bfbe26e9ed679cdaeee7631d1203eedc4254aa85
+  data.tar.gz: e39db8ea279d53883c61333768928aca255891e105dfb27e82e6ddc88f73a1128fe0b9972da59921074479272ed7baf32b0317dc933bebef1664568414469e8c

data/lib/hakuban/async.rb

@@ -5,41 +5,28 @@ require 'async'
 module Hakuban
 
 	class AsyncObjectManager < ObjectManager
+
 		def async_run
 			Async { yield }
 		end
 
-		def async_join(async)
-			async.wait
-		end
-	end
-
-
-	class ObjectObserve
-		def async(&block)
-			AsyncObjectManager.new(self, ObservedObject, block)
+		def async_join(task)
+			task.wait
 		end
-	end
-
-
-	class ObjectExpose
-		def async(&block)
-			AsyncObjectManager.new(self, ExposedObject, block)
-		end
-	end
-
 
-	class TagObserve
-		def async(&block)
-			AsyncObjectManager.new(self, ObservedObject, block)
+		def async_stop(task)
+			task.stop	
 		end
+		
 	end
 
 
-	class TagExpose
-		def async(&block)
-			AsyncObjectManager.new(self, ExposedObject, block)
+	class ObjectManagerBuilder
+	
+		def with_async(&block)
+			build(AsyncObjectManager, block)
 		end
+		
 	end
 
 end

data/lib/hakuban/event-queue.rb

@@ -0,0 +1,75 @@
+#TODO: rebuild to handle event squashing on rust side
+
+require 'ostruct'
+
+
+module Hakuban
+
+	class Event < OpenStruct; end
+
+	class ObjectDescriptorCallbackEventQueue
+
+		def initialize(pointer)
+			@events_pointer = ::FFI::AutoPointer.new(pointer, proc { |ptr| FFI.hakuban_object_descriptor_events_return(ptr) })
+		end
+
+
+		# WARNING: this callback may be run from a separate, non-ruby, thread
+		def callback_register(&callback)
+			ffi_callback = proc { |_userdata, ffi_descriptor, ffi_action|
+				action = Hakuban::action_int_to_symbol(ffi_action)
+				descriptor = ObjectDescriptor.from_ffi(ffi_descriptor)
+				callback.call(descriptor, action)
+			}
+			@callback_pointer = ::FFI::AutoPointer.new(
+				FFI::hakuban_object_descriptor_events_callback_register(@events_pointer, ffi_callback, ::FFI::Pointer::NULL),
+				proc { |ptr| FFI::hakuban_object_descriptor_events_callback_unregister(ptr) }
+			)
+		end
+
+
+		def callback_unregister
+			@callback_pointer.free
+			@callback_pointer = nil
+		end
+
+
+		def drop
+			@events_pointer.free
+			@events_pointer = nil
+		end
+
+	end
+
+
+	class ObjectDescriptorEventQueue
+
+		def initialize(contract)
+			@contract = contract
+			@queue = Queue.new
+			@ffi_callback = proc { |descriptor, action|
+				@queue << Hakuban::Event.new(action: action, descriptor: descriptor)
+			}
+			@ffi_events = @contract.new_callback_event_queue
+			@ffi_events.callback_register(&@ffi_callback)
+		end
+
+
+		#def push(event)
+		#	@queue << event
+		#end
+
+
+		def next_event; next_change; end
+		def next_change
+			@queue.pop
+		end
+		
+
+		def close
+			@queue.close
+		end
+
+	end
+
+end

data/lib/hakuban/hakuban.rb

@@ -1,7 +1,7 @@
 require 'set'
 require 'ostruct'
 
-require_relative './ffi.rb'
+require_relative './event-queue.rb'
 
 #TODO: explicit drops?
 #TODO: privative methods
@@ -32,9 +32,14 @@ module Hakuban
 	end
 
 
+	def self.hakuban_initialize
+		require_relative './ffi.rb'
+	end
+
 	@@logger_initialized = false
 
 	def self.logger_initialize(default_level, skip_if_already_initialized = false)
+		::Hakuban::hakuban_initialize
 		if @@logger_initialized and !skip_if_already_initialized
 			raise "Logger already initialized. This can't be done more than once. Make sure logger_initialize is called before any LocalNode gets constructed."  
 		end
@@ -52,11 +57,12 @@ module Hakuban
 		attr_reader :local_node_pointer  #todo: hide
 
 		def initialize(name: nil)
+			::Hakuban::hakuban_initialize
 			@default_serializer = lambda { |data_type, data| 
 				[["JSON"]+data_type, JSON.dump(data)] 
 			}
 			@default_deserializer = lambda { |data_type, data| 
-				raise "Expected JSON serialized data, got: #{dat_type}"  if data_type[0] != "JSON"
+				raise "Expected JSON serialized data, got: #{data_type}"  if data_type[0] != "JSON"
 				[data_type[1..-1], JSON.load(data)] 
 			}
 			Hakuban::logger_initialize("hakuban=warn", true)
@@ -215,36 +221,6 @@ module Hakuban
 	end
 
 
-	class ObjectDescriptorEvents
-		def initialize(pointer)
-			@events_pointer = ::FFI::AutoPointer.new(pointer, proc { |ptr| FFI.hakuban_object_descriptor_events_return(ptr) })
-		end
-
-		# WARNING: this callback may be run from a separate, non-ruby, thread
-		def callback_register(&callback)
-			ffi_callback = proc { |_userdata, ffi_descriptor, ffi_action|
-				action = Hakuban::action_int_to_symbol(ffi_action)
-				descriptor = ObjectDescriptor.from_ffi(ffi_descriptor)
-				callback.call(descriptor, action)
-			}
-			@callback_pointer = ::FFI::AutoPointer.new(
-				FFI::hakuban_object_descriptor_events_callback_register(@events_pointer, ffi_callback, ::FFI::Pointer::NULL),
-				proc { |ptr| FFI::hakuban_object_descriptor_events_callback_unregister(ptr) }
-			)
-		end
-
-		def callback_unregister
-			@callback_pointer.free
-			@callback_pointer = nil
-		end
-
-		def drop
-			@events_pointer.free
-			@events_pointer = nil
-		end
-
-	end
-
 	class ObjectObserve
 
 		attr_reader :descriptor
@@ -253,6 +229,7 @@ module Hakuban
 			@local_node, @descriptor, @deserializer = local_node, descriptor, deserializer
 			result = FFI::hakuban_object_observe_new(@local_node.local_node_pointer, descriptor.to_ffi)
 			Hakuban::raise_if_error(result)
+			@queues = []
 			@object_observe_pointer = ::FFI::AutoPointer.new(result[:object_observe_pointer], proc { |ptr| FFI::hakuban_object_observe_drop(ptr) })
 		end
 
@@ -265,9 +242,16 @@ module Hakuban
 			end
 		end
 
-		def events
+		def new_callback_event_queue
+			raise "Attempt to use after 'drop'"  if not @object_observe_pointer
+			ObjectDescriptorCallbackEventQueue.new(FFI::hakuban_object_observe_events_get(@object_observe_pointer))
+		end 
+
+		def new_event_queue
 			raise "Attempt to use after 'drop'"  if not @object_observe_pointer
-			ObjectDescriptorEvents.new(FFI::hakuban_object_observe_events_get(@object_observe_pointer))
+			queue = ObjectDescriptorEventQueue.new(self)
+			@queues << queue
+			queue
 		end
 
 		def inspect
@@ -277,6 +261,8 @@ module Hakuban
 		def drop
 			@object_observe_pointer.free
 			@object_observe_pointer = nil
+			@queues.each(&:close)  #is this atomic?
+			@queues.clear
 		end
 
 		def dropped?
@@ -294,6 +280,7 @@ module Hakuban
 			@local_node, @descriptor, @serializer = local_node, descriptor, serializer
 			result = FFI::hakuban_object_expose_new(@local_node.local_node_pointer, descriptor.to_ffi)
 			Hakuban::raise_if_error(result)
+			@queues = []
 			@object_expose_pointer = ::FFI::AutoPointer.new(result[:object_expose_pointer], FFI::method(:hakuban_object_expose_drop))
 		end
 
@@ -319,9 +306,16 @@ module Hakuban
 			FFI::hakuban_object_expose_desynchronize(@object_expose_pointer, assignment)
 		end
 
-		def events
+		def new_callback_event_queue
 			raise "Attempt to use after 'drop'"  if not @object_expose_pointer
-			ObjectDescriptorEvents.new(FFI::hakuban_object_expose_events_get(@object_expose_pointer))
+			ObjectDescriptorCallbackEventQueue.new(FFI::hakuban_object_expose_events_get(@object_expose_pointer))
+		end
+
+		def new_event_queue
+			raise "Attempt to use after 'drop'"  if not @object_expose_pointer
+			queue = ObjectDescriptorEventQueue.new(self)
+			@queues << queue
+			queue
 		end
 
 		def inspect
@@ -331,7 +325,8 @@ module Hakuban
 		def drop
 			@object_expose_pointer.free
 			@object_expose_pointer = nil
-		end
+			@queues.each(&:close)  #is this atomic?
+			@queues.clear		end
 
 		def dropped?
 			@object_expose_pointer.nil?
@@ -394,6 +389,7 @@ module Hakuban
 			@local_node, @descriptor, @deserializer = local_node, descriptor, deserializer
 			result = FFI::hakuban_tag_observe_new(@local_node.local_node_pointer, @descriptor.to_ffi)
 			Hakuban::raise_if_error(result)
+			@queues = []
 			@tag_observe_pointer = ::FFI::AutoPointer.new(result[:tag_observe_pointer], FFI::method(:hakuban_tag_observe_drop))
 		end
 
@@ -413,14 +409,23 @@ module Hakuban
 			ObjectObserveState.new(result[:state], @deserializer)
 		end
 
-		def events
+		def new_callback_event_queue
 			raise "Attempt to use after 'drop'"  if not @tag_observe_pointer
-			ObjectDescriptorEvents.new(FFI::hakuban_tag_observe_events_get(@tag_observe_pointer))
+			ObjectDescriptorCallbackEventQueue.new(FFI::hakuban_tag_observe_events_get(@tag_observe_pointer))
+		end
+
+		def new_event_queue
+			raise "Attempt to use after 'drop'"  if not @tag_observe_pointer
+			queue = ObjectDescriptorEventQueue.new(self)
+			@queues << queue
+			queue
 		end
 
 		def drop
 			@tag_observe_pointer.free
 			@tag_observe_pointer = nil
+			@queues.each(&:close)  #is this atomic?
+			@queues.clear
 		end
 
 		def dropped?
@@ -438,6 +443,7 @@ module Hakuban
 			@local_node, @descriptor, @serializer = local_node, descriptor, serializer
 			result = FFI::hakuban_tag_expose_new(@local_node.local_node_pointer, descriptor.to_ffi)
 			Hakuban::raise_if_error(result)
+			@queues = []
 			@tag_expose_pointer = ::FFI::AutoPointer.new(result[:tag_expose_pointer], FFI::method(:hakuban_tag_expose_drop))
 		end
 
@@ -472,14 +478,23 @@ module Hakuban
 			FFI::hakuban_tag_expose_object_desynchronize(@tag_expose_pointer, object_descriptor.to_ffi, assignment)
 		end
 
-		def events
+		def new_callback_event_queue
+			raise "Attempt to use after 'drop'"  if not @tag_expose_pointer
+			ObjectDescriptorCallbackEventQueue.new(FFI::hakuban_tag_expose_events_get(@tag_expose_pointer))
+		end
+
+		def new_event_queue
 			raise "Attempt to use after 'drop'"  if not @tag_expose_pointer
-			ObjectDescriptorEvents.new(FFI::hakuban_tag_expose_events_get(@tag_expose_pointer))
+			queue = ObjectDescriptorEventQueue.new(self)
+			@queues << queue
+			queue
 		end
 
 		def drop
 			@tag_expose_pointer.free
 			@tag_expose_pointer = nil
+			@queues.each(&:close)  #is this atomic?
+			@queues.clear
 		end
 
 		def dropped?

data/lib/hakuban/manager.rb

@@ -6,16 +6,55 @@ require 'ostruct'
 
 module Hakuban
 
+	class ObjectManagerBuilder
+
+		def initialize(contract)
+			@contract = contract
+			@on_exception_policy = :retry
+			@retry_backoff = [0.01, 0.1, 1.0, 10.0]
+			@terminate_on_deactivation = false
+		end
+
+
+		def on_exception(policy)
+			@on_exception_policy = policy
+			self
+		end	
+
+
+		def terminate_on_deactivation
+			@terminate_on_deactivation = true
+			self
+		end
+
+
+		def retry_backoff(*times)
+			@retry_backoff = times.flatten
+			self
+		end
+
+	
+		def build(manager_class, block)
+			raise "don't use build() directly, use .with_thread {} or .with_async {} instead"  if not manager_class
+			manager_class.new(@contract, block, @retry_backoff, @terminate_on_deactivation, @on_exception_policy)
+		end
+
+	end
+
+
 	class ObjectManager
 
 		attr_reader :contract
 
 		class Event < OpenStruct; end
+		class HandlerException < OpenStruct; end
 
-		def initialize(contract, object_class, block)
+		def initialize(contract, block, retry_backoff, terminate_on_deactivation, on_exception_policy)
 			@contract = contract
-			@objects = {}
-			@running_handlers = {}
+			object_class = @contract.class.const_get(:ManagedObject)
+			@objects_mutex = Mutex.new
+			@existing_objects = {}  #TODO: turn this into a WeakMap, to keep object if external code still holds reference to it
+			@active_objects = {}
 			@event_queue = Queue.new
 
 			# This callback gets called from a separate thread, with no async reactor running.
@@ -23,60 +62,119 @@ module Hakuban
 			@ffi_callback = proc { |descriptor, action|
 				@event_queue << Event.new(action: action, descriptor: descriptor)
 			}
-			@ffi_events = @contract.events
+			@ffi_events = @contract.new_callback_event_queue
 			@ffi_events.callback_register(&@ffi_callback)
 
 			@async = async_run {
-				while event = @event_queue.shift
-					case event.action
-					when :insert
-						raise  if @objects[event.descriptor]
-						@objects[event.descriptor] = object_class.new(@contract, event.descriptor)
-						@event_queue << Event.new(action: :handler_start, descriptor: event.descriptor)  if block
-					when :change
-						raise  if not @objects[event.descriptor]
-						@objects[event.descriptor].do_change(:change)
-					when :remove
-						raise  if not @objects[event.descriptor]
-						@objects[event.descriptor].do_change(:remove)
-						@objects.delete(event.descriptor)
-					when :handler_start
-						if (object = @objects[event.descriptor]) and !object.handler_already_run and !@running_handlers[event.descriptor]
-							descriptor_for_lambda = event.descriptor	
-							@running_handlers[event.descriptor] = async_run {
-								object.run(block)
-								@event_queue << Event.new(action: :handler_finished, descriptor: descriptor_for_lambda)  if @event_queue
+				while @event_queue and event = @event_queue.shift
+					@objects_mutex.synchronize {
+						case event.action
+						when :insert, :change, :remove, :stopped, :timer
+							object = @existing_objects[event.descriptor] ||= object_class.new(@contract, event.descriptor)
+							if !object.running and object.async
+								error = async_join(object.async)
+								object.async = nil
+								if object.last_exception_at
+									interval_since_last_exception = Time.new - object.last_exception_at
+									heal_multiplier = 10.0
+									object.current_delay_index -= (interval_since_last_exception / (retry_backoff[-1]*heal_multiplier)).floor
+									object.current_delay_index = 0  if object.current_delay_index < 0
+								end
+								if error.kind_of? HandlerException
+									case on_exception_policy
+									when :raise
+										raise error.exception
+									when :retry
+										object.last_exception_at = Time.new
+										object.earliest_next_run = Time.new + retry_backoff[object.current_delay_index]
+										lambda_sleep_time = object.earliest_next_run - Time.new
+										lambda_descriptor = event.descriptor
+										async_run { 
+											sleep lambda_sleep_time
+											@event_queue << Event.new(action: :timer, descriptor: lambda_descriptor)  if @event_queue
+										}  #TODO: do we have to join this?
+										object.current_delay_index += 1  if object.current_delay_index < retry_backoff.size - 1
+									#when :ignore_failing_descriptor
+									#when :drop_contract
+									end
+								end
+							end
+							if object.check_active
+								if block and !object.running and (!object.earliest_next_run or Time.new >= object.earliest_next_run)
+									descriptor_for_lambda = event.descriptor
+									object.running = true
+							 		object.async = async_run do
+							 			object.run(block)
+									rescue Async::Stop
+										nil
+									rescue Exception => e
+										$stderr.puts "Exception in hakuban manager lambda: #{e}"
+										$stderr.puts "Contract: "+@contract.inspect
+										$stderr.puts "Descriptor: "+descriptor_for_lambda.inspect
+										$stderr.puts "Backtrace:\n\t#{e.backtrace.join("\n\t")}"
+										HandlerException.new(exception: e)  # exception has to wrapped here to stop async from throwing on join
+									ensure
+										object.running = false
+							 			@event_queue << Event.new(action: :stopped, descriptor: descriptor_for_lambda)  if @event_queue
+									end
+								end
+								@active_objects[event.descriptor] ||= object
+								object.change
+							else
+								@active_objects.delete(event.descriptor)
+								if object.running
+									object.stop
+									async_stop(object.async)  if terminate_on_deactivation
+								else
+									@existing_objects.delete(event.descriptor)
+								end
+							end
+						when :drop
+							@ffi_events.callback_unregister
+							@active_objects.clear
+							@existing_objects.dup.each { |descriptor, object| 
+								if object.running
+									object.stop
+									async_stop(object.async)  if terminate_on_deactivation
+								else
+									@existing_objects.delete(descriptor)
+								end
 							}
+							while @existing_objects.size > 0
+								event = @event_queue.shift
+								@existing_objects.delete(event.descriptor)  if event.action == :stopped
+							end
+							@event_queue.clear
+							@contract.drop
+							@contract, @event_queue = nil, nil
+							break
 						end
-					when :handler_finished
-						raise  if not @running_handlers[event.descriptor]
-						@running_handlers.delete(event.descriptor)
-						@event_queue << Event.new(action: :handler_start, descriptor: event.descriptor)  if @objects[event.descriptor]
-					when :drop
-						@ffi_events.callback_unregister
-						@objects.values.each { |object| object.do_change(:remove) }
-						while @running_handlers.size > 0
-							event = @event_queue.shift
-							@running_handlers.delete(event.descriptor)  if event.action == :handler_finished
-						end
-						@event_queue.clear
-						@objects.clear
-						@contract.drop
-						@contract, @event_queue = nil, nil
-						break
-					end
+					}
 				end
 			}
 		end
 
-		def objects; @objects; end
-		def object; @objects.values.first; end	
+
+		def objects
+			@objects_mutex.synchronize {
+				@active_objects.dup
+			}
+		end
+
+		
+		def object
+			@objects_mutex.synchronize {
+				@active_objects.values.first
+			}
+		end	
+
 
 		def drop
 			drop_nonblock
 			async_join(@async)
 		end
 
+
 		def drop_nonblock
 			if @contract
 				@event_queue << Event.new(action: :drop)
@@ -86,20 +184,20 @@ module Hakuban
 
 
 
-	class ManagedObject
+	class ManagedObjectBase
 
-		attr_reader :descriptor, :async, :handler_already_run
+		attr_reader :descriptor
+		attr_accessor :running, :async, :last_exception_at, :current_delay_index, :earliest_next_run
 
 
 		def initialize(contract, descriptor)
 			@contract,@descriptor = contract, descriptor
 			@changes = Queue.new
-			@handler_already_run = false
+			@current_delay_index = 0
 		end		
 
 
 		def run(handler)
-			@handler_already_run = true
 			handler.call(self)
 		end
 
@@ -109,23 +207,27 @@ module Hakuban
 			loop {
 				case @changes.shift
 				when :change then return true
-				when :remove then return false
+				when :stop then return false
 				end
 			}
 		end
 
 
-		def do_change(change)
-			@changes.push(change)
+		def change
+			@changes.push(:change)
 		end		
 
+		def stop
+			@changes.push(:stop)
+		end
+
 	end
 
 
 
 	class ObjectObserve
 
-		class ObservedObject < 	ManagedObject
+		class ManagedObject < ManagedObjectBase
 
 			def state
 				@contract.object_state
@@ -135,6 +237,15 @@ module Hakuban
 				@contract.object_state&.data
 			end
 
+			def check_active
+				!!state
+			end
+
+		end
+
+
+		def manage
+			ObjectManagerBuilder.new(self)
 		end
 
 	end
@@ -142,7 +253,7 @@ module Hakuban
 
 	class ObjectExpose
 
-		class ExposedObject < ManagedObject
+		class ManagedObject < ManagedObjectBase
 
 			def initialize(contract, descriptor)
 				super(contract, descriptor)
@@ -185,6 +296,15 @@ module Hakuban
 				set_data(value)
 			end
 
+			def check_active
+				assigned?
+			end
+
+		end
+
+		
+		def manage
+			ObjectManagerBuilder.new(self)
 		end
 
 	end
@@ -192,7 +312,7 @@ module Hakuban
 
 	class TagObserve
 
-		class ObservedObject < 	ManagedObject
+		class ManagedObject < ManagedObjectBase
 
 			def state
 				@contract.object_state(@descriptor)
@@ -202,6 +322,15 @@ module Hakuban
 				@contract.object_state(@descriptor)&.data
 			end
 
+			def check_active
+				!!state
+			end
+
+		end
+
+		
+		def manage
+			ObjectManagerBuilder.new(self)
 		end
 
 	end
@@ -209,7 +338,7 @@ module Hakuban
 
 	class TagExpose
 
-		class ExposedObject < 	ManagedObject
+		class ManagedObject < ManagedObjectBase
 
 			def initialize(contract, descriptor)
 				super(contract, descriptor)
@@ -252,6 +381,15 @@ module Hakuban
 				set_data(value)
 			end
 
+			def check_active
+				assigned?
+			end
+
+		end
+
+		
+		def manage
+			ObjectManagerBuilder.new(self)
 		end
 
 	end

data/lib/hakuban/thread.rb

@@ -4,41 +4,28 @@ require 'hakuban/manager'
 module Hakuban
 
 	class ThreadObjectManager < ObjectManager
+
 		def async_run
 			Thread.new { yield }
 		end
 
 		def async_join(thread)
-			thread.join
-		end
-	end
-
-
-	class ObjectObserve
-		def thread(&block)
-			ThreadObjectManager.new(self, ObservedObject, block)
+			thread.value
 		end
-	end
-
 
-	class ObjectExpose
-		def thread(&block)
-			ThreadObjectManager.new(self, ExposedObject, block)
+		def async_stop(thread)
+			thread.kill
 		end
+		
 	end
 
 
-	class TagObserve
-		def thread(&block)
-			ThreadObjectManager.new(self, ObservedObject, block)
+	class ObjectManagerBuilder
+	
+		def with_thread(&block)
+			build(ThreadObjectManager, block)
 		end
-	end
 
-
-	class TagExpose
-		def thread(&block)
-			ThreadObjectManager.new(self, ExposedObject, block)
-		end
 	end
 
 end

data/lib/hakuban/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Hakuban
-	VERSION = "0.6.0"
+	VERSION = "0.6.3"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: hakuban
 version: !ruby/object:Gem::Version
-  version: 0.6.0
+  version: 0.6.3
 platform: ruby
 authors:
 - yunta
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2022-01-16 00:00:00.000000000 Z
+date: 2022-03-12 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rspec
@@ -83,6 +83,7 @@ files:
 - lib/hakuban.rb
 - lib/hakuban/async.rb
 - lib/hakuban/engine.rb
+- lib/hakuban/event-queue.rb
 - lib/hakuban/ffi.rb
 - lib/hakuban/hakuban.rb
 - lib/hakuban/manager.rb