hakuban 0.6.5 → 0.8.0

data/lib/hakuban/hakuban.rb

@@ -1,545 +0,0 @@
-require 'set'
-require 'ostruct'
-
-require_relative './event-queue.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
-
-	def self.raise_if_error(result)
-		case result[:error] 
-		when 0 then true
-		when 1 then raise "Invalid string"
-		when 2 then raise "Invalid JSON"
-		when 3 then raise "Invalid URL"
-		when 4 then raise "Object Not Found"
-		else raise "Unknown error, sorry :("
-		end
-	end
-
-
-	def self.action_int_to_symbol(number)
-		case number
-		when 0 then :insert
-		when 1 then :change
-		when 2 then :remove
-		end
-	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
-		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)
-			::Hakuban::hakuban_initialize
-			@default_serializer = lambda { |data_type, data| 
-				[["JSON"]+data_type, JSON.dump(data)] 
-			}
-			@default_deserializer = lambda { |data_type, data| 
-				raise "Expected JSON serialized data, got: #{data_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), @default_serializer, @default_deserializer)
-		end
-
-		def tag(descriptor)
-			#TODO: accept real descriptor too
-			TagBuilder.new(self, TagDescriptor.new(descriptor), @default_serializer, @default_deserializer)
-		end
-
-	end
-
-
-	class ObjectBuilder
-
-		def initialize(store, descriptor, serializer, deserializer)
-			@store, @descriptor, @serializer, @deserializer = store, descriptor, serializer, deserializer
-		end
-
-		def observe
-			ObjectObserve.new(@store, @descriptor, @deserializer)
-		end
-
-		def expose
-			ObjectExpose.new(@store, @descriptor, @serializer)
-		end
-
-		def with_serializer(&block)
-			@serializer = block
-		end
-
-		def with_deserializer(&block)
-			@deserializer = block
-		end
-
-	end
-
-
-	class TagBuilder
-
-		def initialize(store, descriptor, serializer, deserializer)
-			@store, @descriptor, @serializer, @deserializer = store, descriptor, serializer, deserializer
-		end
-
-		def observe
-			TagObserve.new(@store, @descriptor, @deserializer)
-		end
-
-		def expose
-			TagExpose.new(@store, @descriptor, @serializer)
-		end
-
-		def with_serializer(&block)
-			@serializer = block
-		end
-
-		def with_deserializer(&block)
-			@deserializer = block
-		end
-
-	end
-
-
-	class ObjectDescriptor
-		attr_reader :tags, :json
-
-		def initialize(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.map(&:json), @json)
-		end
-
-		def self.from_ffi(ffi)
-			ObjectDescriptor.new(ffi.tags.map{ |tag| TagDescriptor.new(tag) }, ffi.json)
-		end
-
-		def ==(other)
-			@tags == other.tags and @json == other.json
-		end
-
-		alias eql? ==
-		
-		def hash
-			[@tags.hash, @json.hash].hash
-		end
-
-		def inspect
-			"#<ObjectDescriptor @tags={%s}, @json=%p>"%[self.tags.map(&:inspect).join(","), self.json]
-		end
-
-	end
-	
-
-	class TagDescriptor
-		attr_reader :json
-
-		def initialize(json)
-			@json = json
-		end
-
-		def to_ffi
-			FFI::FFITagDescriptor.construct(@json)
-		end
-
-		def self.from_ffi(ffi)
-			TagDescriptor.new(ffi.json)
-		end
-
-		def ==(other)
-			@json == other.json
-		end
-
-		alias eql? ==
-
-		def hash
-			@json.hash
-		end
-
-	end
-
-
-	class ObjectObserve
-
-		attr_reader :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)
-			@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
-			if (state_ptr = FFI::hakuban_object_observe_state_borrow(@object_observe_pointer)).null?
-				nil
-			else
-				ObjectObserveState.new(state_ptr, @deserializer)
-			end
-		end
-
-		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
-			queue = ObjectDescriptorEventQueue.new(self)
-			@queues << queue
-			queue
-		end
-
-		def inspect
-			"#<ObjectObserve #{@descriptor}>"
-		end
-
-		def drop
-			@object_observe_pointer.free
-			@object_observe_pointer = nil
-			@queues.each(&:close)  #is this atomic?
-			@queues.clear
-		end
-
-		def dropped?
-			@object_observe_pointer.nil?
-		end
-
-	end
-
-
-	class ObjectExpose
-
-		attr_reader :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)
-			@queues = []
-			@object_expose_pointer = ::FFI::AutoPointer.new(result[:object_expose_pointer], FFI::method(:hakuban_object_expose_drop))
-		end
-
-		def set_object_state(version, data, data_type: [], assignment: 0)
-			raise "Attempt to use after 'drop'"  if not @object_expose_pointer
-			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 assignment
-			raise "Attempt to use after 'drop'"  if not @object_expose_pointer
-			FFI::hakuban_object_expose_assignment(@object_expose_pointer)
-		end
-
-		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 new_callback_event_queue
-			raise "Attempt to use after 'drop'"  if not @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
-			"#<ObjectExpose #{@descriptor}>"
-		end
-
-		def drop
-			@object_expose_pointer.free
-			@object_expose_pointer = nil
-			@queues.each(&:close)  #is this atomic?
-			@queues.clear		end
-
-		def dropped?
-			@object_expose_pointer.nil?
-		end
-
-	end
-
-
-	class ObjectObserveState
-
-		def initialize(state, deserializer)
-			@state, @deserializer = state, deserializer
-			ObjectSpace.define_finalizer(self, ObjectObserveState.finalize(@state))
-		end
-
-		def ObjectObserveState.finalize(state)
-			proc { |_|
-				FFI::hakuban_object_observe_state_return(state)
-			}
-		end
-
-		def 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 @synchronized=%p @version=%p>"%[@synchronized, @data_version]
-		end
-
-	end
-
-
-	class TagObserve
-
-		attr_reader :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)
-			@queues = []
-			@tag_observe_pointer = ::FFI::AutoPointer.new(result[:tag_observe_pointer], FFI::method(:hakuban_tag_observe_drop))
-		end
-
-		def object_descriptors
-			raise "Attempt to use after 'drop'"  if not @tag_observe_pointer
-			result = FFI::hakuban_tag_observe_object_descriptors_borrow(@tag_observe_pointer)
-			ret = result.descriptors.map { |raw_descriptor| ObjectDescriptor::from_ffi(raw_descriptor) }
-			FFI::hakuban_object_descriptors_return(result)
-			ret
-		end
-		
-		def object_state(object_descriptor)
-			raise "Attempt to use after 'drop'"  if not @tag_observe_pointer
-			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], @deserializer)
-		end
-
-		def new_callback_event_queue
-			raise "Attempt to use after 'drop'"  if not @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?
-			@tag_observe_pointer.nil?
-		end
-
-	end
-
-
-	class TagExpose
-
-		attr_reader :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)
-			@queues = []
-			@tag_expose_pointer = ::FFI::AutoPointer.new(result[:tag_expose_pointer], FFI::method(:hakuban_tag_expose_drop))
-		end
-
-		def object_descriptors
-			raise "Attempt to use after 'drop'"  if not @tag_expose_pointer
-			result = FFI::hakuban_tag_expose_object_descriptors_borrow(@tag_expose_pointer)
-			ret = result.descriptors.map { |raw_descriptor| ObjectDescriptor::from_ffi(raw_descriptor) }
-			FFI::hakuban_object_descriptors_return(result)
-			ret
-		end
-		
-		def set_object_state(object_descriptor, version, data, data_type: [], assignment: 0)
-			raise "Attempt to use after 'drop'"  if not @tag_expose_pointer
-			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 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 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 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
-			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?
-			@tag_expose_pointer.nil?
-		end
-
-	end
-
-
-
-	class Tokio
-
-		@@tokio_pointer = nil
-
-		def Tokio.init(workers_count=0)
-			@@tokio_pointer ||= FFI::hakuban_tokio_init_multi_thread(0)
-		end
-
-		def Tokio.pointer
-			Tokio.init  if not @@tokio_pointer
-			@@tokio_pointer
-		end
-
-		#TODO: drop?	
-
-	end
-
-
-	class WebsocketConnector
-
-		#TODO: drop	
-
-		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 = ::FFI::AutoPointer.new(result[:websocket_connector_pointer], WebsocketConnector.generate_drop)
-		end
-
-		def self.generate_drop
-			proc { |pointer|
-				FFI::hakuban_tokio_websocket_connector_drop(Tokio.pointer, pointer)
-			}
-		end
-
-	end
-
-
-end