hakuban 0.6.1 → 0.6.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: f12beca62a4975af1ee3f85d5ec83e85753a6f6bb95fb36529c284d88eba41c5
-  data.tar.gz: ca7a3c890c4ba1b7dc337ac1e3120b8d5d260c8170f641493067b5f75060c3ab
+  metadata.gz: 8c827f2e6b27d41fbc349a9928b2039fc04b9cd139ce90641491b3dee250482c
+  data.tar.gz: 6081be62f7bc8abf6ea90543ee79543bc6b7f20678fbe5cce38bd72fc09de897
 SHA512:
-  metadata.gz: fb3e86f190c140edb9658f42f33cb9bfdad718cb6b04a9f1bced7240ed2b64716d43ab651f3551b4ee084d103fdfc3bf038dc7e3f91332f1bac692e5b9b7001f
-  data.tar.gz: fd40ec84a8e7f713f857768e84dd0f5554beb00adf586adf7e739e12e1920cb568387df5cc8c4085c7bec83fbffc36a5d16bbe7211481774e849b5dda402fab6
+  metadata.gz: 36ed621045173a200cdcf65832f6c126496aae26584c74fc07ceebc303b22f387e22852b03034b0b97164b0b06e739c5b192d06babc275c49b75a8ca5b872f4a
+  data.tar.gz: 35bb3c5a6937b3fbecf3088d90f2da945e7b6643d736df272896eb5a8a2c624bf62629e2c598a2206a4a98bab444f0a6b3736aed803d04c085a2746d54d43653

data/bin/hakuban-observer

@@ -2,7 +2,7 @@
 
 require 'slop'
 require 'pp'
-require 'hakuban/async'
+require 'hakuban/thread'
 
 
 OPTIONS = Slop.parse { |o|
@@ -27,30 +27,38 @@ else
 end		
 
 
-def print_event(descriptor, event)
-	puts "-"*120
-	puts "Event: " + event
-	puts "Descriptor: "
-	descriptor.tags.each { |tag|
-		puts "\tTags: " + JSON.dump(tag.json)
-	}
-	puts "\tJSON: " + JSON.dump(descriptor.json)
+def print_event(descriptor, event, more)
+	if $subsequent 
+		puts ','
+	else
+		$subsequent = true
+	end
+	puts '{'
+	puts '"event": "%s",'%[event]
+	puts '"descriptor_json": %s,'%[JSON.dump(descriptor.json)]
+	puts '"descriptor_tags": [%s],'%[descriptor.tags.map { |tag| JSON.dump(tag.json) }.join(",")]
+	puts more  if more
+	puts '}'
 end
 
-Async {
-			
-	observe_contract.async { |object|
-		print_event(object.descriptor, "create")
-		while object.next_change
-			print_event(object.descriptor, "change")
+
+puts "["
+
+contract = observe_contract.manage.with_thread { |object|
+	print_event(object.descriptor, "create", nil)
+	while object.next_change
+		print_event(object.descriptor, "change", 
 			if state = object.state
-				puts "Version: " + state.version.inspect
-				puts "Last synchronized: " + state.synchronized.to_s + "ms ago"
-				puts "Data:\n"
-				pp state.data
+				[
+					'"version": %s,'%[JSON.dump(state.version)],
+					'"last_sync_ms_ago": %s,'%[JSON.dump(state.synchronized)],
+					'"data": %s,'%[JSON.dump(state.data)],
+				].join("\n")
 			end
-		end
-		print_event(object.descriptor, "drop")
-	}
-
+		)
+	end
+	print_event(object.descriptor, "drop", nil)
 }
+
+$stdin.read(1)
+puts "]"

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,6 +57,7 @@ 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)] 
 			}
@@ -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,58 @@ 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
+		if not defined?(:Async)
+			module Async; class Stop < Exception; end; end  #in case Async is not included, meh
+		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 +65,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 +187,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 +210,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 +240,15 @@ module Hakuban
 				@contract.object_state&.data
 			end
 
+			def check_active
+				!!state
+			end
+
+		end
+
+
+		def manage
+			ObjectManagerBuilder.new(self)
 		end
 
 	end
@@ -142,7 +256,7 @@ module Hakuban
 
 	class ObjectExpose
 
-		class ExposedObject < ManagedObject
+		class ManagedObject < ManagedObjectBase
 
 			def initialize(contract, descriptor)
 				super(contract, descriptor)
@@ -185,6 +299,15 @@ module Hakuban
 				set_data(value)
 			end
 
+			def check_active
+				assigned?
+			end
+
+		end
+
+		
+		def manage
+			ObjectManagerBuilder.new(self)
 		end
 
 	end
@@ -192,7 +315,7 @@ module Hakuban
 
 	class TagObserve
 
-		class ObservedObject < 	ManagedObject
+		class ManagedObject < ManagedObjectBase
 
 			def state
 				@contract.object_state(@descriptor)
@@ -202,6 +325,15 @@ module Hakuban
 				@contract.object_state(@descriptor)&.data
 			end
 
+			def check_active
+				!!state
+			end
+
+		end
+
+		
+		def manage
+			ObjectManagerBuilder.new(self)
 		end
 
 	end
@@ -209,7 +341,7 @@ module Hakuban
 
 	class TagExpose
 
-		class ExposedObject < 	ManagedObject
+		class ManagedObject < ManagedObjectBase
 
 			def initialize(contract, descriptor)
 				super(contract, descriptor)
@@ -252,8 +384,17 @@ module Hakuban
 				set_data(value)
 			end
 
+			def check_active
+				assigned?
+			end
+
+		end
+
+		
+		def manage
+			ObjectManagerBuilder.new(self)
 		end
 
 	end
 
-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.1"
+	VERSION = "0.6.4"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: hakuban
 version: !ruby/object:Gem::Version
-  version: 0.6.1
+  version: 0.6.4
 platform: ruby
 authors:
 - yunta
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2022-02-06 00:00:00.000000000 Z
+date: 2022-03-20 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