hakuban 0.7.0 → 0.8.0

data/lib/hakuban/exchange.rb

@@ -3,73 +3,113 @@ require 'socket'
 
 module Hakuban
 
-	class LocalExchange < FFIObject
+	class Exchange < FFIObject
 
-		def initialize(name: false, &block)
+		def initialize(&block)
+			super()
 			Hakuban::hakuban_initialize
 			Hakuban::logger_initialize("hakuban=warn", skip_if_already_initialized: true)
-			name = LocalExchange.default_name  if name == false
-			pointer = FFI::hakuban_local_exchange_new(name).unwrap
-			initialize_pointer(pointer, :hakuban_local_exchange_drop, :hakuban_local_exchange_clone)
-			self.do_and_drop_or_return(&block)
-		end
-
-		def self.default_name
-			"#{Socket.gethostname}:#{File.basename(caller_locations(0..1)[1].path)}:#{$$}"
+			Thread.handle_interrupt(Object => :never) {
+				pointer = FFI::hakuban_exchange_new().unwrap
+				initialize_pointer(pointer, :hakuban_exchange_drop, :hakuban_exchange_clone)
+				self.do_and_drop_or_return(&block)
+			}
 		end
 
 	public
 
-		def object(tags, descriptor=nil)
+		def object_observe_contract(tags, descriptor=nil)
+			if tags.kind_of? ObjectDescriptor
+				ObjectObserveContractBuilder.new(self, tags)
+			else 
+				ObjectObserveContractBuilder.new(self, ObjectDescriptor.new(tags, descriptor))
+			end
+		end
+
+		def object_expose_contract(tags, descriptor=nil)
 			if tags.kind_of? ObjectDescriptor
-				ObjectBuilder.new(self, tags)
+				ObjectExposeContractBuilder.new(self, tags)
 			else 
-				ObjectBuilder.new(self, ObjectDescriptor.new(tags, descriptor))
+				ObjectExposeContractBuilder.new(self, ObjectDescriptor.new(tags, descriptor))
 			end
 		end
 
-		def tag(descriptor)
+		def tag_observe_contract(descriptor)
 			if descriptor.kind_of? TagDescriptor
-				TagBuilder.new(self, descriptor)
+				TagObserveContractBuilder.new(self, descriptor)
 			else
-				TagBuilder.new(self, TagDescriptor.new(descriptor))
+				TagObserveContractBuilder.new(self, TagDescriptor.new(descriptor))
+			end
+		end
+
+		def tag_expose_contract(descriptor)
+			if descriptor.kind_of? TagDescriptor
+				TagExposeContractBuilder.new(self, descriptor)
+			else
+				TagExposeContractBuilder.new(self, TagDescriptor.new(descriptor))
 			end
 		end
 
 	end
 
 
-	class ObjectBuilder
+	class ObjectObserveContractBuilder
 
-		def initialize(store, descriptor)
-			@store, @descriptor = store, descriptor
+		def initialize(exchange, descriptor)
+			@exchange, @descriptor = exchange, descriptor
 		end
 
-		def observe(&block)
-			ObjectObserveContract.send(:new, @store, @descriptor).do_and_drop_or_return(&block)
+		def build(&block)
+			ObjectObserveContract.send(:new, @exchange, @descriptor, &block)
 		end
 
-		def expose(&block)
-			ObjectExposeContract.send(:new, @store, @descriptor).do_and_drop_or_return(&block)
+	end
+
+	class ObjectExposeContractBuilder
+
+		def initialize(exchange, descriptor)
+			@exchange, @descriptor = exchange, descriptor
+			@capacity = 1
+		end
+
+		def with_capacity(capacity)
+			@capacity = capacity
+		end
+
+		def build(&block)
+			ObjectExposeContract.send(:new, @exchange, @descriptor, @capacity, &block)
 		end
 
 	end
 
 
-	class TagBuilder
+	class TagObserveContractBuilder
 
-		def initialize(store, descriptor)
-			@store, @descriptor = store, descriptor
+		def initialize(exchange, descriptor)
+			@exchange, @descriptor = exchange, descriptor
 		end
 
-		def observe(&block)
-			TagObserveContract.send(:new, @store, @descriptor).do_and_drop_or_return(&block)
+		def build(&block)
+			TagObserveContract.send(:new, @exchange, @descriptor, &block)
 		end
 
-		def expose(&block)
-			TagExposeContract.send(:new, @store, @descriptor).do_and_drop_or_return(&block)
+	end
+
+	class TagExposeContractBuilder
+
+		def initialize(exchange, descriptor)
+			@exchange, @descriptor = exchange, descriptor
+			@capacity = 1
+		end
+
+		def with_capacity(capacity)
+			@capacity = capacity
+		end
+
+		def build(&block)
+			TagExposeContract.send(:new, @exchange, @descriptor, @capacity, &block)
 		end
 
 	end
-	
+
 end

data/lib/hakuban/ffi-object.rb

@@ -7,25 +7,40 @@ module Hakuban
 
 		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
-			@mutex ||= Mutex.new
-			@drop_requested = false
-			@drop_locked_by = Set.new
-			@drop_locked_by_condvar = nil
 			ObjectSpace.define_finalizer(self, FFIObject::generate_finalizer(drop_fn, @pointer))
 		end
-
+		
 
 		def initialize_copy(original)
-			raise "#{self.class.name} can't be cloned. Consider making a new one instead."  if @clone_fn.nil?
-			@mutex.synchronize {
-				raise "#{self.class.name} can't be cloned after 'drop' has been called on it."  if @pointer.nil?
-				@pointer = FFI::method(@clone_fn).call(::FFI::Pointer.new(@pointer)).address 
-				@mutex = Mutex.new
-				@drop_requested = false
-				@drop_locked_by = Set.new
-				@drop_locked_by_condvar = nil
+			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))
 			}
@@ -33,9 +48,12 @@ module Hakuban
 
 
 		def with_pointer
-			@mutex.synchronize {
-				raise PointerAlreadyDropped  if dropped?
-				yield ::FFI::Pointer.new(@pointer)
+			@pointer_mutex.synchronize {
+				if @pointer
+					yield ::FFI::Pointer.new(@pointer)
+				else
+					raise PointerAlreadyDropped
+				end
 			}
 		end
 
@@ -57,40 +75,20 @@ module Hakuban
 
 
 		def drop
-			@mutex.synchronize {
-				#TODO: wait here till dropped?
-				return  if @drop_requested
-				@drop_requested = true
-				@drop_locked_by.each { |queue| queue << :dropping }
-				@drop_locked_by_condvar ||= ConditionVariable.new
-				@drop_locked_by_condvar.wait(@mutex)  while @drop_locked_by.size > 0
-				return  if dropped?
-				ObjectSpace.undefine_finalizer(self)
-				FFI::method(@drop_fn).call(::FFI::Pointer.new(@pointer))
-				@pointer = @finalizer = nil
-			}
-		end
-
-
-		def drop_lock(queue)
-			@mutex.synchronize {
-				raise FFIObject::PointerAlreadyDropped  if @drop_requested
-				@drop_locked_by << queue
-			}
-			true
-		end
-
-
-		def drop_release(queue)
-			@mutex.synchronize {
-				@drop_locked_by.delete(queue)
-				@drop_locked_by_condvar.broadcast  if @drop_locked_by_condvar
+			@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.nil?
+			!@pointer
 		end
 
 
@@ -101,8 +99,9 @@ module Hakuban
 		end
 
 
-		def do_and_drop
-			Thread.handle_interrupt(Object => :never) {
+		# 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
@@ -110,18 +109,10 @@ module Hakuban
 				ensure
 					self.drop
 				end
-			}
-		end
-
-
-		def do_and_drop_or_return(&block)
-			if block
-				do_and_drop(&block)
 			else
 				self
 			end
 		end
-
 		
 		def inspect
 			"#<#{self.class.name} #{self.dropped? ? "DROPPED" : "%016X"%@pointer}>"

data/lib/hakuban/ffi.rb

@@ -1,7 +1,7 @@
 require 'json'
 require 'ffi'
 require 'hakuban/ffi-object'
-
+require 'hakuban/refinements'
 
 module Hakuban::FFI
 
@@ -16,9 +16,10 @@ module Hakuban::FFI
 	class FFIErrorInvalidLogLevel < FFIError; end
 	class FFIErrorUnknownError < FFIError; end
 
+	
 	class FFIResultStatus < FFI::Struct
 		layout :id, :uint8
-		ENUM = [:Ok, :Pending, :NotAvailable, :InvalidString, :InvalidJSON, :InvalidURL, :InvalidLogLevel, :UnknownError]
+		ENUM = [:Ok, :Pointer, :Pending, :EndOfStream, :InvalidString, :InvalidJSON, :InvalidURL, :InvalidLogLevel, :LoggerInitializationError, :ConnectionTerminated].freeze
 
 		def to_sym
 			ENUM[self[:id]]
@@ -31,196 +32,99 @@ module Hakuban::FFI
 
 
 	class FFIResult < FFI::Struct
-		FFIResultStatus::ENUM.each { |sym|
-			define_method(("is_"+sym.to_s+"?").to_sym) {
-				FFIResultStatus::ENUM[self[:status][:id]] == sym
-			}
-		}
-	end
-
-
-	class FFIResultWithNothing < FFIResult
-		layout :status, FFIResultStatus
-
-		def unwrap
-			return nil  if self[:status].to_sym == :NotAvailable
-			raise self[:status].to_exception  if self[:status].to_sym != :Ok
-			nil
-		end
-	end
-
-
-	class FFIResultWithPointer < FFIResult
 		layout :status, FFIResultStatus, :pointer, :pointer
 
 		def unwrap
-			return nil  if self[:status].to_sym == :NotAvailable
-			raise self[:status].to_exception  if self[:status].to_sym != :Ok
+			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
-	end
-	
-	
-	class Callbacks
-
-		attr_reader :waker
-
-		def initialize
-			@queues = {}
-			@queues_sequence = 0
-			@queues_mutex = Mutex.new
-			@waker = proc { |pointer|
-				queue_id = pointer.address
-				@queues_mutex.synchronize {
-					@queues[queue_id]&.each { |queue|
-						queue << :wake
-					}
-				}
-			}
-		end
-		
-		def register_queue(queue)
-			@queues_mutex.synchronize {
-				@queues_sequence = (@queues_sequence+1) % 2**32
-				queue_id = @queues_sequence
-				(@queues[queue_id] ||= Set.new) << queue
-				queue_id
-			}
-		end
-
-		def unregister_queue(queue_id)
-			@queues_mutex.synchronize {
-				@queues[queue_id].delete(queue_id)
-				@queues.delete(queue_id)  if @queues[queue_id].empty?
-			}
-		end
-	end
 
-	
-	class FFIFutureReturningNothing < FFI::Struct
-		layout :pointer, :pointer
-
-		@@callbacks = Callbacks.new
-
-		def self.create_and_await(owner)
-			Thread.handle_interrupt(Object => :never) {
-				begin
-					queue = queue_id = drop_locked = pointer = nil
-					Thread.handle_interrupt(Object => :immediate) {
-						queue = Queue.new
-						queue_id = @@callbacks.register_queue(queue)
-						drop_locked = owner.drop_lock(queue)
-						return nil  if !pointer = owner.with_pointer { |pointer| yield pointer }
-						loop {
-							result = owner.with_pointer { Hakuban::FFI::hakuban_future_returning_nothing_poll(pointer[:pointer],@@callbacks.waker,::FFI::Pointer.new(queue_id)) }
-							return result  if not result.is_Pending?
-							# Currently the only future returning nothing is guaranteed to complete at first poll
-							# :unreachable:
-							raise Hakuban::FFIObject::PointerAlreadyDropped  if queue.pop == :dropping
-							# :unreachable:
-						}
-					}
-				ensure
-					Hakuban::FFI::hakuban_future_returning_nothing_drop(pointer[:pointer])  if pointer
-					owner.drop_release(queue)  if drop_locked
-					@@callbacks.unregister_queue(queue_id)
-				end
-			}
+		def status
+			self[:status].to_sym
 		end
 	end
 
 
-	class FFIFutureReturningPointer < FFI::Struct
-		layout :pointer, :pointer
-
-		@@callbacks = Callbacks.new
-
-		def self.create_and_await(owner)
-			Thread.handle_interrupt(Object => :never) {
-				begin
-					queue = queue_id = drop_locked = pointer = nil
-					Thread.handle_interrupt(Object => :immediate) {
-						queue = Queue.new
-						queue_id = @@callbacks.register_queue(queue)
-						drop_locked = owner.drop_lock(queue)
-						return nil  if !pointer = owner.with_pointer { |pointer| yield pointer }
-						loop {
-							result = owner.with_pointer { Hakuban::FFI::hakuban_future_returning_pointer_poll(pointer[:pointer],@@callbacks.waker,::FFI::Pointer.new(queue_id)) }
-							return result  if not result.is_Pending?
-							raise Hakuban::FFIObject::PointerAlreadyDropped  if queue.pop == :dropping
-						}
-					}
-				ensure
-					Hakuban::FFI::hakuban_future_returning_pointer_drop(pointer[:pointer])  if pointer
-					owner.drop_release(queue)  if drop_locked
-					@@callbacks.unregister_queue(queue_id)
-				end
-			}
+	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
 
 
 	class FFIArray < FFI::Struct
 	 	layout :length, :size_t, :pointer, :pointer
 	end
-	
 
-	# Every function which can cause a wake() has to be "blocking: true".
-	# Otherwise they are very likely to deadlock on GVL and other locks acquired by RemoteExchange on incomming message.
-	# FIXME: way too many functions are marked as blocking here
 
-	callback :waker, [ :pointer ], :void	
+	# 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 ], FFIResultWithNothing.by_value
+	attach_function :hakuban_logger_initialize, [ :string ], FFIResult.by_value
 
-	attach_function :hakuban_local_exchange_new, [ :string ], FFIResultWithPointer.by_value
-	attach_function :hakuban_local_exchange_drop, [ :pointer ], :void
-	attach_function :hakuban_local_exchange_clone, [ :pointer ], :pointer
+	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 ], FFIResultWithPointer.by_value
-	attach_function :hakuban_tokio_websocket_connector_drop, [ :pointer ], :void, blocking: true
-
-	attach_function :hakuban_object_observe_contract_new, [ :pointer, :pointer ], :pointer, blocking: true
-	attach_function :hakuban_object_observe_contract_drop, [ :pointer ], :void, blocking: true
-	attach_function :hakuban_object_observe_contract_terminate, [ :pointer ], :void, blocking: true
-	attach_function :hakuban_object_observe_contract_next, [ :pointer ], FFIFutureReturningPointer.by_value, blocking: true
-	attach_function :hakuban_object_observe_contract_ready, [ :pointer ], FFIResultWithPointer.by_value, blocking: true
-
-	attach_function :hakuban_object_expose_contract_new, [ :pointer, :pointer ], :pointer, blocking: true
-	attach_function :hakuban_object_expose_contract_drop, [ :pointer ], :void, blocking: true
-	attach_function :hakuban_object_expose_contract_terminate, [ :pointer ], :void, blocking: true
-	attach_function :hakuban_object_expose_contract_next, [ :pointer ], FFIFutureReturningPointer.by_value, blocking: true
-	attach_function :hakuban_object_expose_contract_ready, [ :pointer ], FFIResultWithPointer.by_value, blocking: true
-
-	attach_function :hakuban_tag_observe_contract_new, [ :pointer, :pointer ], :pointer, blocking: true
-	attach_function :hakuban_tag_observe_contract_drop, [ :pointer ], :void, blocking: true
-	attach_function :hakuban_tag_observe_contract_terminate, [ :pointer ], :void, blocking: true
-	attach_function :hakuban_tag_observe_contract_next, [ :pointer ], FFIFutureReturningPointer.by_value, blocking: true
-	attach_function :hakuban_tag_observe_contract_ready, [ :pointer ], FFIArray.by_value, blocking: true
-
-	attach_function :hakuban_tag_expose_contract_new, [ :pointer, :pointer ], :pointer, blocking: true
-	attach_function :hakuban_tag_expose_contract_drop, [ :pointer ], :void, blocking: true
-	attach_function :hakuban_tag_expose_contract_terminate, [ :pointer ], :void, blocking: true
-	attach_function :hakuban_tag_expose_contract_next, [ :pointer ], FFIFutureReturningPointer.by_value, blocking: true
-	attach_function :hakuban_tag_expose_contract_ready, [ :pointer ], FFIArray.by_value, blocking: true
-
-	attach_function :hakuban_object_state_stream_drop, [ :pointer ], :void, blocking: true
-	attach_function :hakuban_object_state_stream_next, [ :pointer ], FFIFutureReturningPointer.by_value, blocking: true
-	attach_function :hakuban_object_state_stream_current, [ :pointer ], FFIResultWithPointer.by_value
+	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, blocking: true
-	attach_function :hakuban_object_state_sink_next, [ :pointer ], FFIFutureReturningPointer.by_value, blocking: true
-	attach_function :hakuban_object_state_sink_send, [ :pointer, :pointer ], FFIFutureReturningNothing.by_value, blocking: true
-	attach_function :hakuban_object_state_sink_current, [ :pointer ], FFIResultWithPointer.by_value, blocking: true
+	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_desynchronize, [ :pointer ], :void, blocking: true
 
 	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 ], FFIResultWithPointer.by_value
+	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
@@ -228,23 +132,26 @@ module Hakuban::FFI
 	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 ], FFIResultWithPointer.by_value
+	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 ], FFIResultWithPointer.by_value
+	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_returning_nothing_drop, [ :pointer ], :void, blocking: true
-	attach_function :hakuban_future_returning_pointer_drop, [ :pointer ], :void, blocking: true
-	attach_function :hakuban_future_returning_nothing_poll, [ :pointer, :waker, :pointer ], FFIResultWithNothing.by_value, blocking: true
-	attach_function :hakuban_future_returning_pointer_poll, [ :pointer, :waker, :pointer ], FFIResultWithPointer.by_value, blocking: true
+	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

@@ -5,10 +5,10 @@ module Hakuban
 	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 LocalExchange gets constructed."  
+			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).is_Ok?
+			raise "Invalid default log level string"  if FFI::hakuban_logger_initialize(default_level).status != :Ok
 			@@logger_initialized = true
 		end
 	end