hakuban 0.6.5 → 0.8.0

data/lib/hakuban/ffi-object.rb

@@ -0,0 +1,123 @@
+require 'set'
+
+
+module Hakuban
+
+	class FFIObject
+
+		class PointerAlreadyDropped < Exception; end
+
+		def initialize
+			@pointer_mutex = Mutex.new
+		end
+
+		private def initialize_from_ffi_pointer(pointer, drop_fn, clone_fn)
+			@pointer_mutex = Mutex.new
+			initialize_pointer(pointer, drop_fn, clone_fn)
+		end
+
+
+		def self.from_ffi_pointer(cls, pointer)
+			cls.allocate.tap { |new_instance| new_instance.initialize_from_ffi_pointer(pointer) }
+		end
+
+		private def initialize_pointer(pointer, drop_fn, clone_fn)
+			@pointer, @drop_fn, @clone_fn = pointer.address, drop_fn, clone_fn
+			ObjectSpace.define_finalizer(self, FFIObject::generate_finalizer(drop_fn, @pointer))
+		end
+		
+
+		def initialize_copy(original)
+			Thread.handle_interrupt(Object => :never) {
+				if @clone_fn.nil?
+					@pointer_mutex.synchronize {
+						raise PointerAlreadyDropped  if original.instance_variable_get(:@pointer).nil?
+						original.instance_variable_set(:@pointer, nil)
+						ObjectSpace.undefine_finalizer(original)
+					}
+				else
+					original.with_pointer { |pointer|
+						@pointer = FFI::method(@clone_fn).call(::FFI::Pointer.new(pointer)).address 
+					}
+				end
+				@pointer_mutex = Mutex.new
+				ObjectSpace.undefine_finalizer(self)
+				ObjectSpace.define_finalizer(self, FFIObject::generate_finalizer(@drop_fn, @pointer))
+			}
+		end
+
+
+		def with_pointer
+			@pointer_mutex.synchronize {
+				if @pointer
+					yield ::FFI::Pointer.new(@pointer)
+				else
+					raise PointerAlreadyDropped
+				end
+			}
+		end
+
+
+		def self.with_pointers(objects,&original_block)
+			do_locked = proc { |original_block, remaining_objects, pointers|
+				if remaining_objects.size == 0
+					original_block.call(pointers)
+				else
+					object, i = remaining_objects.shift
+					object.with_pointer { |pointer|
+						pointers[i] = pointer
+						do_locked.call(original_block, remaining_objects, pointers)
+					}
+				end
+			}
+			do_locked.call(original_block, objects.each.with_index.sort_by { |object, i| object.instance_variable_get(:@pointer) || -i }, Array.new(objects.size))
+		end
+
+
+		def drop
+			@pointer_mutex.synchronize {
+				Thread.handle_interrupt(Object => :never) {
+					if !!@pointer
+						ObjectSpace.undefine_finalizer(self)
+						FFI::method(@drop_fn).call(::FFI::Pointer.new(@pointer))
+						@pointer = nil
+					end
+				}
+			}
+		end
+
+
+		def dropped?
+			!@pointer
+		end
+
+
+		def self.generate_finalizer(symbol, pointer_address)
+			proc { |_|
+				FFI::method(symbol).call(::FFI::Pointer.new(pointer_address)) 
+			}
+		end
+
+
+		# this should always be called with interrupts disabled, in the same section where pointer creation occurs
+		def do_and_drop_or_return(&block)
+			if block
+				begin
+					Thread.handle_interrupt(Object => :immediate) {
+						yield self
+					}
+				ensure
+					self.drop
+				end
+			else
+				self
+			end
+		end
+		
+		def inspect
+			"#<#{self.class.name} #{self.dropped? ? "DROPPED" : "%016X"%@pointer}>"
+		end
+
+	end
+
+end

data/lib/hakuban/ffi.rb

@@ -1,174 +1,157 @@
 require 'json'
 require 'ffi'
+require 'hakuban/ffi-object'
+require 'hakuban/refinements'
 
-
-# all functions which can trigger synchronuous callbacks, and those which wait on rust locks are "blocking: true" to avoid deadlock on GIL
 module Hakuban::FFI
 
-	class FFILocalNodeNewResult < FFI::Struct
-		layout :error, :uint8, :local_node_pointer, :pointer
-	end
-	
-	class FFIObjectObserveResult < FFI::Struct
-		layout :error, :uint8, :object_observe_pointer, :pointer
-	end
-	
-	class FFIObjectExposeResult < FFI::Struct
-		layout :error, :uint8, :object_expose_pointer, :pointer
-	end
-	
-	class FFITagObserveResult < FFI::Struct
-		layout :error, :uint8, :tag_observe_pointer, :pointer
-	end
-	
-	class FFITagExposeResult < FFI::Struct
-		layout :error, :uint8, :tag_expose_pointer, :pointer
-	end
-	
-	class FFIObjectObserveStateGetVersionResult < FFI::Struct
-		layout :version_length, :size_t, :version_elements, :pointer
-	end
+	extend FFI::Library
+	ffi_lib 'hakuban'
 
-	class FFIObjectObserveStateGetDataTypeResult < FFI::Struct
-		layout :type_length, :size_t, :type_elements, :pointer
-	end
 
-	class FFIObjectObserveStateGetDataResult < FFI::Struct
-		layout :data_length, :size_t, :data_bytes, :pointer
-	end
+	class FFIError < Exception; end
+	class FFIErrorInvalidString < FFIError; end
+	class FFIErrorInvalidJSON < FFIError; end
+	class FFIErrorInvalidURL < FFIError; end
+	class FFIErrorInvalidLogLevel < FFIError; end
+	class FFIErrorUnknownError < FFIError; end
 
-	class FFIObjectExposeState < FFI::Struct
-		layout :version_length, :size_t, :version, :pointer, :data_type_length, :size_t, :data_type, :pointer, :raw_length, :size_t, :raw, :pointer
-		attr_accessor :data_type_strings
-	
-		def self.construct(version, data_type, data)
-			state = FFIObjectExposeState::new
-			state[:version_length] = version.size
-			state[:version] = FFI::MemoryPointer.new(:int64, version.size)
-			state[:version].write_array_of_int64(version)
-			state[:data_type_length] = data_type.size
-			state[:data_type] = FFI::MemoryPointer.new(:pointer, data_type.size)
-			state.data_type_strings = data_type.map {|string| FFI::MemoryPointer.from_string(string)}
-			state[:data_type].write_array_of_pointer(state.data_type_strings)
-			state[:raw] = FFI::MemoryPointer.from_string(data)
-			state[:raw_length] = data.size
-			state
-		end
-	end
-	
-	class FFIObjectExposeStateResult < FFI::Struct
-		layout :error, :uint8, :changed, :uint8
-	end
-	
-	class FFITokioWebsocketConnectorNewResult < FFI::Struct
-		layout :error, :uint8, :websocket_connector_pointer, :pointer
-	end
-	
-	class FFITagObserveObjectStateBorrowResult < FFI::Struct
-		layout :error, :uint8, :state, :pointer
-	end
-	
-	class FFIObjectDescriptor < FFI::Struct
-		layout :tags_count, :size_t, :tags, :pointer, :json, :pointer
-		attr_accessor :tags_strings
-		
-		def tags
-			self[:tags].read_array_of_pointer(self[:tags_count]).map { |string| JSON.parse(string.read_string()) }	# does this copy the string? 
-		end
 	
-		def json
-			JSON.parse(self[:json].read_string())
+	class FFIResultStatus < FFI::Struct
+		layout :id, :uint8
+		ENUM = [:Ok, :Pointer, :Pending, :EndOfStream, :InvalidString, :InvalidJSON, :InvalidURL, :InvalidLogLevel, :LoggerInitializationError, :ConnectionTerminated].freeze
+
+		def to_sym
+			ENUM[self[:id]]
 		end
-	
-		def self.construct(tags,json)
-			descriptor = FFIObjectDescriptor.new
-			descriptor[:tags_count] = tags.size
-			descriptor.tags_strings = tags.map { |tag| FFI::MemoryPointer.from_string(JSON.dump(tag)) }
-			descriptor[:tags] = FFI::MemoryPointer.new(:pointer, descriptor.tags_strings.size)
-			descriptor[:tags].write_array_of_pointer(descriptor.tags_strings)
-			descriptor[:json] = FFI::MemoryPointer.from_string(JSON.dump(json))
-			descriptor
+
+		def to_exception
+			Hakuban::FFI::const_get("FFIError"+ENUM[self[:id]].to_s)
 		end
-	
 	end
-	
-	class FFITagDescriptor < FFI::Struct
-		layout :json, :pointer
-	
-		def json
-			JSON.parse(self[:json].read_string())
+
+
+	class FFIResult < FFI::Struct
+		layout :status, FFIResultStatus, :pointer, :pointer
+
+		def unwrap
+			return true  if self[:status].to_sym == :Ok
+			return nil  if self[:status].to_sym == :EndOfStream
+			raise self[:status].to_exception  if self[:status].to_sym != :Pointer
+			self[:pointer]
 		end
-	
-		def self.construct(json)
-			descriptor = FFITagDescriptor.new
-			descriptor[:json] = FFI::MemoryPointer.from_string(JSON.dump(json))
-			descriptor
+
+		def status
+			self[:status].to_sym
 		end
-	
 	end
-	
-	
-	class FFIObjectDescriptors < FFI::Struct
-		layout :count, :size_t, :descriptors, :pointer
-	
-		def descriptors
-			self[:count].times.map { |i| FFIObjectDescriptor.new(self[:descriptors] + i * FFIObjectDescriptor.size) }
+
+
+	class FFIFuture
+		
+		using ThreadExt
+
+		#This HAS to be called with interrupts disabled.
+		#If both, internal exception, and an interrupt fire, pay attention not to drop one of them.
+		def self.await(future_pointer)
+			error = result_thread = result = nil
+			future_pointer_for_blocking_await = Hakuban::FFI::hakuban_future_clone(future_pointer)
+			begin
+				# ThreadError gets raised here on process shutdown
+				result_thread = Thread.new { Hakuban::FFI::hakuban_future_await(future_pointer_for_blocking_await) }
+				Thread.handle_interrupt(Object => :immediate) { result_thread.join }
+			rescue Object => e
+				error = e
+			end
+			Hakuban::FFI::hakuban_future_drop(future_pointer)
+			if result_thread
+				result = result_thread.join_with_warning
+			else 
+				Hakuban::FFI::hakuban_future_drop(future_pointer_for_blocking_await)
+			end
+			return [result, error]
 		end
+
 	end
-	
 
-	extend FFI::Library
 
-	ffi_lib 'hakuban'
+	class FFIArray < FFI::Struct
+	 	layout :length, :size_t, :pointer, :pointer
+	end
 
-	callback :object_callback, [ :pointer, FFIObjectDescriptor.by_value, :uint8 ], :void
-	#callback :tag_callback, [ :pointer, FFITagDescriptor.by_value, :uint8 ], :void
-
-	attach_function :hakuban_local_node_new, [ :string ], FFILocalNodeNewResult.by_value
-	attach_function :hakuban_local_node_drop, [ :pointer ], :void, blocking: true
-
-	attach_function :hakuban_object_observe_new, [ :pointer, FFIObjectDescriptor.by_value ], FFIObjectObserveResult.by_value, blocking: true
-	attach_function :hakuban_object_observe_drop, [ :pointer ], :void, blocking: true
-	attach_function :hakuban_object_observe_state_borrow, [ :pointer ], :pointer, blocking: true
-	attach_function :hakuban_object_observe_events_get, [ :pointer ], :pointer, blocking: true
-	                 
-	attach_function :hakuban_object_expose_new, [ :pointer, FFIObjectDescriptor.by_value], FFIObjectExposeResult.by_value, blocking: true
-	attach_function :hakuban_object_expose_drop, [ :pointer ], :void, blocking: true
-	attach_function :hakuban_object_expose_state, [ :pointer, FFIObjectExposeState.by_value, :uint64 ], FFIObjectExposeStateResult.by_value, blocking: true
-	attach_function :hakuban_object_expose_assignment, [ :pointer ], :uint64, blocking: true
-	attach_function :hakuban_object_expose_desynchronize, [ :pointer, :uint64 ], :void, blocking: true
-	attach_function :hakuban_object_expose_events_get, [ :pointer ], :pointer, blocking: true
-
-	attach_function :hakuban_tag_observe_new, [ :pointer, FFITagDescriptor.by_value ], FFITagObserveResult.by_value, blocking: true
-	attach_function :hakuban_tag_observe_drop, [ :pointer ], :void, blocking: true
-	attach_function :hakuban_tag_observe_object_descriptors_borrow, [ :pointer ], FFIObjectDescriptors.by_value, blocking: true
-	attach_function :hakuban_tag_observe_object_state_borrow, [ :pointer, FFIObjectDescriptor.by_value ], FFITagObserveObjectStateBorrowResult.by_value, blocking: true
-	attach_function :hakuban_tag_observe_events_get, [ :pointer ], :pointer, blocking: true
-
-	attach_function :hakuban_tag_expose_new, [ :pointer, FFITagDescriptor.by_value ], FFITagExposeResult.by_value, blocking: true
-	attach_function :hakuban_tag_expose_drop, [ :pointer ], :void, blocking: true
-	attach_function :hakuban_tag_expose_object_descriptors_borrow, [ :pointer ], FFIObjectDescriptors.by_value, blocking: true
-	attach_function :hakuban_tag_expose_object_state, [ :pointer, FFIObjectDescriptor.by_value, FFIObjectExposeState.by_value, :uint64 ], FFIObjectExposeStateResult.by_value, blocking: true
-	attach_function :hakuban_tag_expose_object_assignment, [ :pointer, FFIObjectDescriptor.by_value ], :uint64, blocking: true
-	attach_function :hakuban_tag_expose_object_desynchronize, [ :pointer, FFIObjectDescriptor.by_value, :uint64 ], :void, blocking: true
-	attach_function :hakuban_tag_expose_events_get, [ :pointer ], :pointer, blocking: true
-
-	attach_function :hakuban_object_observe_state_get_synchronized, [ :pointer ], :uint64
-	attach_function :hakuban_object_observe_state_get_data_version, [ :pointer ], FFIObjectObserveStateGetVersionResult.by_value
-	attach_function :hakuban_object_observe_state_get_data_type, [ :pointer ], FFIObjectObserveStateGetDataTypeResult.by_value
-	attach_function :hakuban_object_observe_state_get_data, [ :pointer ], FFIObjectObserveStateGetDataResult.by_value
-
-	attach_function :hakuban_object_descriptor_events_callback_register, [ :pointer, :object_callback, :pointer ], :pointer, blocking: true
-	attach_function :hakuban_object_descriptor_events_callback_unregister, [ :pointer ], :void, blocking: true
-	attach_function :hakuban_object_descriptor_events_return, [ :pointer ], :void, blocking: true
-
-	attach_function :hakuban_object_observe_state_return, [ :pointer ], :void
-	attach_function :hakuban_object_descriptors_return, [ FFIObjectDescriptors.by_value ], :void
 
-	attach_function :hakuban_tokio_init_multi_thread, [ :size_t ], :pointer
-	attach_function :hakuban_tokio_websocket_connector_new, [ :pointer, :pointer, :string ], FFITokioWebsocketConnectorNewResult.by_value
-	attach_function :hakuban_tokio_websocket_connector_drop, [ :pointer, :pointer ], :void, blocking: true
+	# Every function which can cause a callback has to be "blocking: true".
+	# Otherwise they are very likely to deadlock on GVL and other locks acquired by Connection(s) on incomming message
+	# Fortunately, we don't use callbacks any more. And the only function with unbounded execution time is the future-await. So, only setting that one as blocking.
+	
+	callback :waker, [ :pointer ], :void
+
+	attach_function :hakuban_logger_initialize, [ :string ], FFIResult.by_value
 
-	attach_function :hakuban_logger_initialize, [ :string ], :uint8
+	attach_function :hakuban_exchange_new, [ ], FFIResult.by_value
+	attach_function :hakuban_exchange_drop, [ :pointer ], :void
+	attach_function :hakuban_exchange_clone, [ :pointer ], :pointer
 
+	attach_function :hakuban_tokio_init_multi_thread, [ :size_t ], :pointer
+	attach_function :hakuban_tokio_websocket_connector_new, [ :pointer, :pointer, :string ], FFIResult.by_value
+	attach_function :hakuban_tokio_websocket_connector_drop, [ :pointer ], :void
+
+	attach_function :hakuban_object_observe_contract_new, [ :pointer, :pointer ], :pointer
+	attach_function :hakuban_object_observe_contract_drop, [ :pointer ], :void
+	attach_function :hakuban_object_observe_contract_next, [ :pointer ], :pointer
+
+	attach_function :hakuban_object_expose_contract_new, [ :pointer, :pointer, :uint32 ], :pointer
+	attach_function :hakuban_object_expose_contract_drop, [ :pointer ], :void
+	attach_function :hakuban_object_expose_contract_next, [ :pointer ], :pointer
+
+	attach_function :hakuban_tag_observe_contract_new, [ :pointer, :pointer ], :pointer
+	attach_function :hakuban_tag_observe_contract_drop, [ :pointer ], :void
+	attach_function :hakuban_tag_observe_contract_next, [ :pointer ], :pointer
+
+	attach_function :hakuban_tag_expose_contract_new, [ :pointer, :pointer, :uint32 ], :pointer
+	attach_function :hakuban_tag_expose_contract_drop, [ :pointer ], :void
+	attach_function :hakuban_tag_expose_contract_next, [ :pointer ], :pointer
+
+	attach_function :hakuban_object_state_stream_drop, [ :pointer ], :void
+	attach_function :hakuban_object_state_stream_next, [ :pointer ], :pointer
+	attach_function :hakuban_object_state_stream_descriptor, [ :pointer ], :pointer
+
+	attach_function :hakuban_object_state_sink_drop, [ :pointer ], :void
+	attach_function :hakuban_object_state_sink_next, [ :pointer ], :pointer
+	attach_function :hakuban_object_state_sink_send, [ :pointer, :pointer ], :pointer
+	attach_function :hakuban_object_state_sink_descriptor, [ :pointer ], :pointer
+
+	attach_function :hakuban_object_state_sink_params_drop, [ :pointer ], :void
+	attach_function :hakuban_object_state_sink_params_clone, [ :pointer ], :pointer
+
+	attach_function :hakuban_object_state_new, [ :size_t, :pointer, :size_t, :pointer, :size_t, :pointer, :uint64 ], FFIResult.by_value
+	attach_function :hakuban_object_state_drop, [ :pointer ], :void
+	attach_function :hakuban_object_state_clone, [ :pointer ], :pointer
+	attach_function :hakuban_object_state_data, [ :pointer ], FFIArray.by_value
+	attach_function :hakuban_object_state_format, [ :pointer ], FFIArray.by_value
+	attach_function :hakuban_object_state_version, [ :pointer ], FFIArray.by_value
+	attach_function :hakuban_object_state_synchronized_ago, [ :pointer ], :uint64
+
+	attach_function :hakuban_tag_descriptor_new, [ :string ], FFIResult.by_value
+	attach_function :hakuban_tag_descriptor_drop, [ :pointer ], :void
+	attach_function :hakuban_tag_descriptor_clone, [ :pointer ], :pointer
+	attach_function :hakuban_tag_descriptor_json, [ :pointer ], :string
+
+	attach_function :hakuban_object_descriptor_new, [ :string, :size_t, :pointer ], FFIResult.by_value
+	attach_function :hakuban_object_descriptor_drop, [ :pointer ], :void
+	attach_function :hakuban_object_descriptor_clone, [ :pointer ], :pointer
+	attach_function :hakuban_object_descriptor_json, [ :pointer ], :string
+	attach_function :hakuban_object_descriptor_tags, [ :pointer ], FFIArray.by_value
+
+	attach_function :hakuban_future_clone, [ :pointer ], :pointer
+	attach_function :hakuban_future_drop, [ :pointer ], :void
+	#attach_function :hakuban_future_poll, [ :pointer, :waker, :pointer ], FFIResult.by_value  #this is pita to get working right with interrupts, and without leaking memory in weird cases
+	attach_function :hakuban_future_await, [ :pointer ], FFIResult.by_value, blocking: true
+
+	attach_function :hakuban_array_drop, [ FFIArray.by_value ], :void
+
+	FFIResultStatus.freeze
+	FFIResult.freeze
+	FFIFuture.freeze
+	freeze
 end

data/lib/hakuban/logger.rb

@@ -0,0 +1,16 @@
+module Hakuban
+
+	@@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 Exchange gets constructed."  
+		end
+		if not @@logger_initialized
+			raise "Invalid default log level string"  if FFI::hakuban_logger_initialize(default_level).status != :Ok
+			@@logger_initialized = true
+		end
+	end
+
+end

data/lib/hakuban/object_state.rb

@@ -0,0 +1,105 @@
+require 'hakuban/ffi-object.rb'
+
+
+
+module Hakuban
+
+	class ObjectState < FFIObject
+
+		class WrongFormatError < Exception; end
+
+		def initialize(data, version: nil, format: nil, synchronized_us_ago: 0, &block)
+			super()
+			if version.nil?
+				timestamp = Time.new
+				version = [0, timestamp.to_i, timestamp.nsec]
+			end
+			@version = version
+			@format = [format || []].flatten
+			@synchronized_us_ago = synchronized_us_ago
+			@data = data
+			@pointer = false
+			Thread.handle_interrupt(Object => :never) {
+				self.do_and_drop_or_return(&block)
+			}
+		end
+
+		def initialize_from_ffi_pointer(pointer)
+			super(pointer, :hakuban_object_state_drop, :hakuban_object_state_clone)
+		end
+
+
+
+		def with_pointer
+			@pointer_mutex.synchronize {
+				if @pointer == false
+					Hakuban::hakuban_initialize
+					version_pointer = ::FFI::MemoryPointer.new(:int64, @version.size)
+					version_pointer.write_array_of_int64(@version)
+					format_pointer = ::FFI::MemoryPointer.new(:pointer, @format.size)
+					format_strings = format.map {|string| ::FFI::MemoryPointer.from_string(string)}
+					format_pointer.write_array_of_pointer(format_strings)
+					data_pointer = ::FFI::MemoryPointer.from_string(@data)
+					pointer = FFI::hakuban_object_state_new(@version.size, version_pointer, @format.size, format_pointer, @data.bytesize, data_pointer, @synchronized_us_ago).unwrap
+					initialize_pointer(pointer, :hakuban_object_state_drop, :hakuban_object_state_clone)
+				end
+				yield ::FFI::Pointer.new(@pointer)
+			}
+		end
+
+		def data
+			return @data  if defined? @data
+			array = with_pointer { |pointer| FFI::hakuban_object_state_data(pointer) }
+			#array[:data_bytes].read_array_of_char(array[:length]) #.pack('c*').clone()
+			@data = array[:pointer].read_string(array[:length]).clone()
+		end
+
+		def format
+			return @format  if defined? @format
+			array = with_pointer { |pointer| FFI::hakuban_object_state_format(pointer) }
+			@format = array[:pointer].read_array_of_pointer(array[:length]).map { |string| string.read_string().clone() }
+		end
+
+		def version
+			return @version  if defined? @version
+			array = with_pointer { |pointer| FFI::hakuban_object_state_version(pointer) }
+			@version = array[:pointer].read_array_of_int64(array[:length])
+		end
+
+		def synchronized_us_ago
+			return @synchronized_us_ago  if defined? @synchronized_us_ago
+			@synchronized_us_ago = with_pointer { |pointer| FFI::hakuban_object_state_synchronized_ago(pointer) }
+		end
+
+		def with_data(data)
+			ObjectState.new(data, version: version, format: format, synchronized_us_ago: synchronized_us_ago)
+		end
+
+		def with_version(version)
+			ObjectState.new(data, version: version, format: format, synchronized_us_ago: synchronized_us_ago)
+		end
+
+		def with_format(format)
+			ObjectState.new(data, version: version, format: format, synchronized_us_ago: synchronized_us_ago)
+		end
+
+		def with_synchronized_us_ago(synchronized_us_ago)
+			ObjectState.new(data, version: version, format: format, synchronized_us_ago: synchronized_us_ago)
+		end
+
+		def json_deserialize
+			raise WrongFormatError  if format[-1] != "JSON"
+			ObjectState.new(JSON.parse(data), version: version, format: format[0...-1], synchronized_us_ago: synchronized_us_ago)
+		end
+
+		def json_serialize
+			ObjectState.new(data.to_json, version: version, format: format+["JSON"], synchronized_us_ago: synchronized_us_ago)
+		end
+
+		def inspect
+			"#<ObjectState @synchronized=%p @version=%p>"%[synchronized_us_ago, version]
+		end
+
+	end
+
+end

data/lib/hakuban/object_state_sink.rb

@@ -0,0 +1,56 @@
+require 'hakuban/ffi-object.rb'
+require 'hakuban/stream.rb'
+
+
+module Hakuban
+
+	class ObjectStateSink < FFIObject
+
+		private_class_method :new
+
+
+		def initialize_from_ffi_pointer(pointer)
+			super(pointer, :hakuban_object_state_sink_drop, nil)
+		end
+
+
+		include Stream
+
+
+		def next(drop_at_the_end_of_block=true, &block)
+			process_item(
+				lambda { |pointer| FFI::hakuban_object_state_sink_next(pointer) },
+				lambda { |pointer| FFIObject::from_ffi_pointer(ObjectStateSinkParams, pointer) },
+				&block
+			)
+		end
+
+
+		def send(object_state)
+			process_item(
+				lambda { |pointer| object_state.with_pointer { |object_state_pointer| FFI::hakuban_object_state_sink_send(pointer, object_state_pointer) } },
+				lambda { |_pointer| nil },
+				&lambda {}
+			)
+		end
+
+
+		def descriptor
+			Hakuban::FFIObject.from_ffi_pointer(Hakuban::ObjectDescriptor, with_pointer { |pointer| FFI::hakuban_object_state_sink_descriptor(pointer) })
+		end
+		
+
+	end
+
+	class ObjectStateSinkParams < FFIObject
+
+		private_class_method :new
+
+		def initialize_from_ffi_pointer(pointer)
+			super(pointer, :hakuban_object_state_sink_params_drop, :hakuban_object_state_sink_params_clone)
+		end
+
+	end
+
+
+end

data/lib/hakuban/object_state_stream.rb

@@ -0,0 +1,39 @@
+require 'hakuban/ffi.rb'
+require 'hakuban/ffi-object.rb'
+require 'hakuban/stream.rb'
+require 'hakuban/refinements.rb'
+
+module Hakuban
+
+
+	class ObjectStateStream < FFIObject
+
+		private_class_method :new
+		
+
+		def initialize_from_ffi_pointer(pointer)
+			super(pointer, :hakuban_object_state_stream_drop, nil)
+		end
+
+
+
+		include Stream
+
+
+		
+		def next(&block)
+			process_item(
+				lambda { |pointer| FFI::hakuban_object_state_stream_next(pointer) },
+				lambda { |pointer| FFIObject::from_ffi_pointer(ObjectState, pointer) },
+				&block
+			)
+		end
+		
+
+		def descriptor
+			Hakuban::FFIObject.from_ffi_pointer(Hakuban::ObjectDescriptor, with_pointer { |pointer| FFI::hakuban_object_state_stream_descriptor(pointer) })
+		end
+		
+	end
+
+end

data/lib/hakuban/refinements.rb

@@ -0,0 +1,23 @@
+module ThreadExt
+
+	refine Thread do
+
+		def join_with_warning(timeout=60)
+			loop {
+				self.join(60)
+				return self.value  if !self.status
+				$stderr.puts "Thread doesn't want to die: \n"+item_thread.backtrace.inspect+"\nat:\n"+caller.join("\n")
+			}
+		end
+
+
+		def Thread.process_interrupts
+			Thread.handle_interrupt(Object => :immediate) {
+				Thread.pass
+			}
+			nil
+		end
+
+	end 
+
+end