hakuban 0.5.0 → 0.6.0

data/lib/hakuban/hakuban.rb

@@ -1,9 +1,13 @@
 require 'set'
+require 'ostruct'
 
 require_relative './ffi.rb'
 
 #TODO: explicit drops?
 #TODO: privative methods
+#TODO: error classes
+
+#AutoPointers use proc-wrapped calls because they segfault sometimes when used with FFI::method(:xxx) (why?)
 
 module Hakuban
 
@@ -28,26 +32,73 @@ module Hakuban
 	end
 
 
+	@@logger_initialized = false
+
+	def self.logger_initialize(default_level, skip_if_already_initialized = false)
+		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
+		if not @@logger_initialized
+			raise "Invalid default log level string"  if FFI::hakuban_logger_initialize(default_level) != 0
+			@@logger_initialized = true
+		end
+	end
+
+
 	class LocalNode
 
 		#TODO: explicit drop
 
 		attr_reader :local_node_pointer  #todo: hide
 
-		def initialize(name=nil)
-			result = FFI::hakuban_local_node_new(name || "local")
+		def initialize(name: nil)
+			@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"
+				[data_type[1..-1], JSON.load(data)] 
+			}
+			Hakuban::logger_initialize("hakuban=warn", true)
+			result = FFI::hakuban_local_node_new(name || File.basename(caller_locations(0..1)[1].path))
 			Hakuban::raise_if_error(result)
 			@local_node_pointer = ::FFI::AutoPointer.new(result[:local_node_pointer], FFI::method(:hakuban_local_node_drop))
 		end
 
+		def with_default_serializer(&block)
+			@default_serializer = block
+			self
+		end
+
+		def with_default_deserializer(&block)
+			@default_deserializer = block
+			self
+		end
+
+		def default_serializer(&block)
+			if block_given?
+				@default_serializer = block
+			else
+				@default_serializer
+			end
+		end
+
+		def default_deserializer(&block)
+			if block_given?
+				@default_deserializer = block
+			else
+				@default_deserializer
+			end
+		end
+
 		def object(tags, descriptor)
 			#TODO: accept real descriptor too
-			ObjectBuilder.new(self, ObjectDescriptor.new(tags,descriptor))
+			ObjectBuilder.new(self, ObjectDescriptor.new(tags,descriptor), @default_serializer, @default_deserializer)
 		end
 
 		def tag(descriptor)
 			#TODO: accept real descriptor too
-			TagBuilder.new(self, TagDescriptor.new(descriptor))
+			TagBuilder.new(self, TagDescriptor.new(descriptor), @default_serializer, @default_deserializer)
 		end
 
 	end
@@ -55,16 +106,24 @@ module Hakuban
 
 	class ObjectBuilder
 
-		def initialize(store, descriptor)
-			@store, @descriptor = store, descriptor
+		def initialize(store, descriptor, serializer, deserializer)
+			@store, @descriptor, @serializer, @deserializer = store, descriptor, serializer, deserializer
 		end
 
 		def observe
-			ObjectObserve.new(@store, @descriptor)
+			ObjectObserve.new(@store, @descriptor, @deserializer)
 		end
 
 		def expose
-			ObjectExpose.new(@store, @descriptor)
+			ObjectExpose.new(@store, @descriptor, @serializer)
+		end
+
+		def with_serializer(&block)
+			@serializer = block
+		end
+
+		def with_deserializer(&block)
+			@deserializer = block
 		end
 
 	end
@@ -72,16 +131,24 @@ module Hakuban
 
 	class TagBuilder
 
-		def initialize(store, descriptor)
-			@store, @descriptor = store, descriptor
+		def initialize(store, descriptor, serializer, deserializer)
+			@store, @descriptor, @serializer, @deserializer = store, descriptor, serializer, deserializer
 		end
 
 		def observe
-			TagObserve.new(@store, @descriptor)
+			TagObserve.new(@store, @descriptor, @deserializer)
 		end
 
 		def expose
-			TagExpose.new(@store, @descriptor)
+			TagExpose.new(@store, @descriptor, @serializer)
+		end
+
+		def with_serializer(&block)
+			@serializer = block
+		end
+
+		def with_deserializer(&block)
+			@deserializer = block
 		end
 
 	end
@@ -91,15 +158,16 @@ module Hakuban
 		attr_reader :tags, :json
 
 		def initialize(tags,json)
-			@tags, @json = Set.new(tags), json
+			@tags = Set.new(tags.map { |tag| tag.kind_of?(TagDescriptor) ? tag : TagDescriptor.new(tag) })
+			@json = json
 		end
 
 		def to_ffi
-			FFI::FFIObjectDescriptor.construct(@tags, @json)
+			FFI::FFIObjectDescriptor.construct(@tags.map(&:json), @json)
 		end
 
 		def self.from_ffi(ffi)
-			ObjectDescriptor.new(ffi.tags, ffi.json)
+			ObjectDescriptor.new(ffi.tags.map{ |tag| TagDescriptor.new(tag) }, ffi.json)
 		end
 
 		def ==(other)
@@ -111,6 +179,11 @@ module Hakuban
 		def hash
 			[@tags.hash, @json.hash].hash
 		end
+
+		def inspect
+			"#<ObjectDescriptor @tags={%s}, @json=%p>"%[self.tags.map(&:inspect).join(","), self.json]
+		end
+
 	end
 	
 
@@ -142,68 +215,59 @@ module Hakuban
 	end
 
 
-	class EventQueue
-
-		def initialize(queue, prefix, register_method, pointer, unregister_method)
-			@queue = queue
-			@callback = EventQueue.generate_callback(@queue, prefix)
-			@registered_callback_pointer = ::FFI::AutoPointer.new(
-				register_method.call(pointer, @callback, ::FFI::Pointer::NULL), 
-				EventQueue.generate_unregister(unregister_method, @callback)
-			)
-			#puts "Allocated callback pointer: #{@registered_callback_pointer}"
-			#puts "Allocated callback queue: #{@events}"
-		end	
+	class ObjectDescriptorEvents
+		def initialize(pointer)
+			@events_pointer = ::FFI::AutoPointer.new(pointer, proc { |ptr| FFI.hakuban_object_descriptor_events_return(ptr) })
+		end
 
-		def self.generate_callback(queue, prefix)
-			proc { |_userdata, ffi_descriptor, ffi_action|
-				#puts "Callback for queue: #{queue}"
+		# 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)
-				queue << prefix + [action, 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 self.generate_unregister(unregister_method, callback)
-			proc { |pointer|
-				#puts "Dropping callback pointer: #{pointer}"
-				callback # probably not needed, but I want to be sure this is captured
-				unregister_method.call(pointer)
-			}
+		def callback_unregister
+			@callback_pointer.free
+			@callback_pointer = nil
 		end
 
-	end
+		def drop
+			@events_pointer.free
+			@events_pointer = nil
+		end
 
+	end
 
 	class ObjectObserve
 
 		attr_reader :descriptor
 
-		def initialize(local_node, descriptor)
-			@local_node, @descriptor = local_node, descriptor
+		def initialize(local_node, descriptor, deserializer)
+			@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)
-			@object_observe_pointer = ::FFI::AutoPointer.new(result[:object_observe_pointer], FFI::method(:hakuban_object_observe_drop))
-			@queues = {}
+			@object_observe_pointer = ::FFI::AutoPointer.new(result[:object_observe_pointer], proc { |ptr| FFI::hakuban_object_observe_drop(ptr) })
 		end
 
 		def object_state
 			raise "Attempt to use after 'drop'"  if not @object_observe_pointer
-			ObjectObserveState.new(FFI::hakuban_object_observe_state_borrow(@object_observe_pointer))
-		end
-
-		def send_events_to(queue, *prefix)
-			@queues[queue] = EventQueue.new(
-				queue,
-				prefix,
-				FFI::method(:hakuban_object_observe_changes_callback_register), 
-				@object_observe_pointer, 
-				FFI::method(:hakuban_object_callback_unregister)
-			)
+			if (state_ptr = FFI::hakuban_object_observe_state_borrow(@object_observe_pointer)).null?
+				nil
+			else
+				ObjectObserveState.new(state_ptr, @deserializer)
+			end
 		end
 
-		def stop_sending_objects_events_to(queue)
-			@queues.delete(queue)
+		def events
+			raise "Attempt to use after 'drop'"  if not @object_observe_pointer
+			ObjectDescriptorEvents.new(FFI::hakuban_object_observe_events_get(@object_observe_pointer))
 		end
 
 		def inspect
@@ -213,12 +277,10 @@ module Hakuban
 		def drop
 			@object_observe_pointer.free
 			@object_observe_pointer = nil
-			@queues.values.each { |pointer| pointer.free }
-			@queues.clear
 		end
 
-		def manage(object_class, *object_constructor_params)
-			object_class::new(self, @descriptor, *object_constructor_params)
+		def dropped?
+			@object_observe_pointer.nil?
 		end
 
 	end
@@ -228,51 +290,51 @@ module Hakuban
 
 		attr_reader :descriptor
 
-		def initialize(local_node, descriptor)
-			@local_node, @descriptor = local_node, descriptor
+		def initialize(local_node, descriptor, serializer)
+			@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)
 			@object_expose_pointer = ::FFI::AutoPointer.new(result[:object_expose_pointer], FFI::method(:hakuban_object_expose_drop))
-			@queues = {}
 		end
 
-		def set_object_state(version, data_type, data)
+		def set_object_state(version, data, data_type: [], assignment: 0)
 			raise "Attempt to use after 'drop'"  if not @object_expose_pointer
-			data_type = ["MessagePack"] + data_type
-			serialized = MessagePack.pack(data)
-			result = FFI::hakuban_object_expose_state(@object_expose_pointer, FFI::FFIObjectExposeState.construct(version, data_type, serialized))
+			serialized_data_type, serialized_data = @serializer.call(data_type, data)
+			result = FFI::hakuban_object_expose_state(@object_expose_pointer, FFI::FFIObjectExposeState.construct(version, serialized_data_type, serialized_data), assignment)
 			Hakuban::raise_if_error(result)
 			result[:changed] == 1
 		end
 
-		def assigned
+		def assignment
 			raise "Attempt to use after 'drop'"  if not @object_expose_pointer
-			FFI::hakuban_object_expose_assigned(@object_expose_pointer) == 1
+			FFI::hakuban_object_expose_assignment(@object_expose_pointer)
 		end
 
-		def send_events_to(queue, *prefix)
-			@queues[queue] = EventQueue.new(
-				queue,
-				prefix,
-				FFI::method(:hakuban_object_expose_changes_callback_register), 
-				@object_expose_pointer,
-				FFI::method(:hakuban_object_callback_unregister)
-			)
+		def assigned?
+			assignment > 0
+		end
+		
+		def desynchronize(assignment)
+			raise "Attempt to use after 'drop'"  if not @object_expose_pointer
+			FFI::hakuban_object_expose_desynchronize(@object_expose_pointer, assignment)
 		end
 
-		def stop_sending_objects_events_to(queue)
-			@queues.delete(queue)
+		def events
+			raise "Attempt to use after 'drop'"  if not @object_expose_pointer
+			ObjectDescriptorEvents.new(FFI::hakuban_object_expose_events_get(@object_expose_pointer))
+		end
+
+		def inspect
+			"#<ObjectExpose #{@descriptor}>"
 		end
 
 		def drop
 			@object_expose_pointer.free
 			@object_expose_pointer = nil
-			@queues.values.each { |pointer| pointer.free }
-			@queues.clear
 		end
 
-		def manage(object_class, *object_constructor_params)
-			object_class::new(self, @descriptor, *object_constructor_params)
+		def dropped?
+			@object_expose_pointer.nil?
 		end
 
 	end
@@ -280,29 +342,45 @@ module Hakuban
 
 	class ObjectObserveState
 
-		attr_reader :data, :data_type, :data_version
-
-		def initialize(raw_state)
-			@raw_state = raw_state
-			@synchronized = (raw_state[:synchronized] == 1)
-			@data_type = raw_state[:data_type].read_array_of_pointer(raw_state[:data_type_length]).map { |string| string.read_string() }
-			@data_version = raw_state[:version].read_array_of_type(::FFI::TYPE_INT64, :read_int64, raw_state[:version_length])  if not raw_state[:version].null?
-			@data = MessagePack.unpack(raw_state[:raw].read_string_length(raw_state[:raw_length]))  if not raw_state[:raw].null?
-			ObjectSpace.define_finalizer(self, ObjectObserveState.finalize(@raw_state))
+		def initialize(state, deserializer)
+			@state, @deserializer = state, deserializer
+			ObjectSpace.define_finalizer(self, ObjectObserveState.finalize(@state))
 		end
 
-		def ObjectObserveState.finalize(raw_state)
+		def ObjectObserveState.finalize(state)
 			proc { |_|
-				FFI::hakuban_object_observe_state_return(raw_state)
+				FFI::hakuban_object_observe_state_return(state)
 			}
 		end
 
 		def version
-			@data_version
+			return @data_version  if @data_version
+			ffi_version = FFI::hakuban_object_observe_state_get_data_version(@state)
+			@data_version = ffi_version[:version_elements].read_array_of_type(::FFI::TYPE_INT64, :read_int64, ffi_version[:version_length])
+		end
+
+		def data
+			return @data  if @data
+			ffi_data = FFI::hakuban_object_observe_state_get_data(@state)
+			ffi_data_type = FFI::hakuban_object_observe_state_get_data_type(@state)
+			serialized_data_type = ffi_data_type[:type_elements].read_array_of_pointer(ffi_data_type[:type_length]).map { |string| string.read_string() }
+			@data_type, @data = @deserializer.call(serialized_data_type, ffi_data[:data_bytes].read_string_length(ffi_data[:data_length]))
+			@data
+		end
+
+		def data_type
+			return @data_type  if @data_type
+			data
+			@data_type
+		end
+
+		def synchronized
+			return @synchronized  if @synchronized
+			@synchronized = FFI::hakuban_object_observe_state_get_synchronized(@state)
 		end
 
 		def inspect
-			"#<ObjectObserveState version=#{@data_version}>"
+			"#<ObjectObserveState @synchronized=%p @version=%p>"%[@synchronized, @data_version]
 		end
 
 	end
@@ -312,12 +390,11 @@ module Hakuban
 
 		attr_reader :descriptor
 
-		def initialize(local_node, descriptor)
-			@local_node, @descriptor = local_node, descriptor
+		def initialize(local_node, descriptor, deserializer)
+			@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)
 			@tag_observe_pointer = ::FFI::AutoPointer.new(result[:tag_observe_pointer], FFI::method(:hakuban_tag_observe_drop))
-			@queues = {}
 		end
 
 		def object_descriptors
@@ -333,36 +410,21 @@ module Hakuban
 			result = FFI::hakuban_tag_observe_object_state_borrow(@tag_observe_pointer, object_descriptor.to_ffi)
 			return nil  if result[:error] == 4
 			Hakuban::raise_if_error(result)
-			ObjectObserveState.new(result[:state])
+			ObjectObserveState.new(result[:state], @deserializer)
 		end
 
-		def send_events_to(*params)
-			self.send_objects_events_to(*params)
-		end
-
-		def send_objects_events_to(queue, *prefix)
-			@queues[queue] = EventQueue.new(
-				queue,
-				prefix,
-				FFI::method(:hakuban_tag_observe_objects_changes_callback_register), 
-				@tag_observe_pointer, 
-				FFI::method(:hakuban_object_callback_unregister)
-			)
-		end
-
-		def stop_sending_objects_events_to(queue)
-			@queues.delete(queue)
+		def events
+			raise "Attempt to use after 'drop'"  if not @tag_observe_pointer
+			ObjectDescriptorEvents.new(FFI::hakuban_tag_observe_events_get(@tag_observe_pointer))
 		end
 
 		def drop
 			@tag_observe_pointer.free
 			@tag_observe_pointer = nil
-			@queues.values.each { |pointer| pointer.free }
-			@queues.clear
 		end
 
-		def manage(object_class, *object_constructor_params)
-			ObjectManager::new(self, object_class, *object_constructor_params)
+		def dropped?
+			@tag_observe_pointer.nil?
 		end
 
 	end
@@ -372,12 +434,11 @@ module Hakuban
 
 		attr_reader :descriptor
 		
-		def initialize(local_node, descriptor)
-			@local_node, @descriptor = local_node, descriptor
+		def initialize(local_node, descriptor, serializer)
+			@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)
 			@tag_expose_pointer = ::FFI::AutoPointer.new(result[:tag_expose_pointer], FFI::method(:hakuban_tag_expose_drop))
-			@queues = {}
 		end
 
 		def object_descriptors
@@ -388,42 +449,41 @@ module Hakuban
 			ret
 		end
 		
-		def set_object_state(object_descriptor, version, data_type, data)
+		def set_object_state(object_descriptor, version, data, data_type: [], assignment: 0)
 			raise "Attempt to use after 'drop'"  if not @tag_expose_pointer
-			data_type = ["MessagePack"] + data_type
-			serialized = MessagePack.pack(data)
-			result = FFI::hakuban_tag_expose_object_state(@tag_expose_pointer, object_descriptor.to_ffi, FFI::FFIObjectExposeState.construct(version, data_type, serialized))
+			raise if not version #TODO: replace this by type check
+			serialized_data_type, serialized_data = @serializer.call(data_type, data)
+			result = FFI::hakuban_tag_expose_object_state(@tag_expose_pointer, object_descriptor.to_ffi, FFI::FFIObjectExposeState.construct(version, serialized_data_type, serialized_data), assignment)
 			Hakuban::raise_if_error(result)
 			result[:changed] == 1
 		end
 
-		def send_events_to(*params)
-			self.send_objects_events_to(*params)
+		def assignment(object_descriptor)
+			raise "Attempt to use after 'drop'"  if not @tag_expose_pointer
+			FFI::hakuban_tag_expose_object_assignment(@tag_expose_pointer, object_descriptor.to_ffi)
 		end
 
-		def send_objects_events_to(queue, *prefix)
-			@queues[queue] = EventQueue.new(
-				queue,
-				prefix,
-				FFI::method(:hakuban_tag_expose_objects_changes_callback_register), 
-				@tag_expose_pointer, 
-				FFI::method(:hakuban_object_callback_unregister)
-			)
+		def assigned?(object_descriptor)
+			assignment(object_descriptor) > 0
+		end
+
+		def desynchronize(object_descriptor, assignment)
+			raise "Attempt to use after 'drop'"  if not @tag_expose_pointer
+			FFI::hakuban_tag_expose_object_desynchronize(@tag_expose_pointer, object_descriptor.to_ffi, assignment)
 		end
 
-		def stop_sending_objects_events_to(queue)
-			@queues.delete(queue)
+		def events
+			raise "Attempt to use after 'drop'"  if not @tag_expose_pointer
+			ObjectDescriptorEvents.new(FFI::hakuban_tag_expose_events_get(@tag_expose_pointer))
 		end
 
 		def drop
 			@tag_expose_pointer.free
 			@tag_expose_pointer = nil
-			@queues.values.each { |pointer| pointer.free }
-			@queues.clear
 		end
 
-		def manage(object_class, *object_constructor_params)
-			ObjectManager::new(self, object_class, *object_constructor_params)
+		def dropped?
+			@tag_expose_pointer.nil?
 		end
 
 	end
@@ -452,104 +512,19 @@ module Hakuban
 
 		#TODO: drop	
 
-		def initialize(url)
-			result = FFI::hakuban_tokio_websocket_connector_new(Tokio.pointer, url)
+		def initialize(local_node, url)
+			result = FFI::hakuban_tokio_websocket_connector_new(Tokio.pointer, local_node.local_node_pointer, url)
 			Hakuban::raise_if_error(result)
-			@websocket_connector_pointer = result[:websocket_connector_pointer]
+			@websocket_connector_pointer = ::FFI::AutoPointer.new(result[:websocket_connector_pointer], WebsocketConnector.generate_drop)
 		end
 
-		def start(local_node)
-			@local_node = local_node
-			FFI::hakuban_tokio_websocket_connector_start(Tokio.pointer, @websocket_connector_pointer, @local_node.local_node_pointer)
-			self
-		end
-
-	end
-
-
-	# convenience utils
-
-	class ObjectManager
-		
-		attr_reader :objects, :contract
-
-		def initialize(contract, object_class, *object_constructor_params)
-			@contract = contract
-			@objects = {}
-			@queue = Queue.new
-			contract.send_events_to(@queue, :object)
-			@thread = Thread.new {
-				loop {
-					event = @queue.shift
-					case event[0..1]
-					when [:control, :quit]
-						break
-					when [:object, :insert]
-						@objects[event[2]] = object_class.new(@contract, event[2], *object_constructor_params)
-					when [:object, :change]
-						@objects[event[2]].change  if @objects[event[2]].respond_to?(:change)
-					when [:object, :remove]
-						raise if not deleted = @objects.delete(event[2])
-						deleted.drop  if deleted.respond_to?(:drop)
-					end
-				}
+		def self.generate_drop
+			proc { |pointer|
+				FFI::hakuban_tokio_websocket_connector_drop(Tokio.pointer, pointer)
 			}
 		end
 
-		def drop
-			@contract.stop_sending_objects_events_to(@queue)
-			@queue.push [:control, :quit]
-			@thread.join
-			@queue, @contract, @thread, @objects = nil, nil, nil, {}
-		end
-
-
-		class ManagedObject
-			attr_reader :contract, :descriptor
-			def initialize(contract, descriptor)
-				@contract, @descriptor = contract, descriptor
-			end
-		end
-	
-
-		#TODO: fix the arity thing...
-		module ObservedObject
-			def state
-				if @contract.method(:object_state).arity == 1
-					@contract.object_state(@descriptor)
-				else
-					@contract.object_state
-				end
-			end
-			def data
-				if @contract.method(:object_state).arity == 1
-					@contract.object_state(@descriptor)&.data
-				else
-					@contract.object_state&.data
-				end
-			end
-		end
-
-		module ExposedObject
-			def state=(state)
-				if @contract.method(:set_object_state).arity == 4
-					@contract.set_object_state(@descriptor, *state)
-				else
-					@contract.set_object_state(*state)
-				end
-			end
-			def data=(value)
-				timestamp = Time.new.to_f.floor
-				if @contract.method(:set_object_state).arity == 4
-					@contract.set_object_state(@descriptor,[1, timestamp.floor, ((timestamp - timestamp.floor)*1000000000).floor, 0],[],value)
-				else 
-					@contract.set_object_state([1, timestamp.floor, ((timestamp - timestamp.floor)*1000000000).floor, 0],[],value)
-				end
-			end
-		end
 	end
 
 
-
-
 end