hakuban 0.6.5 → 0.7.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: b96f9b3980a477679e6500a226142873db6c0569706e2eae58b29c04b8a956e9
-  data.tar.gz: c66a0a751a8d95bbd5944edb8c5c9a2cdbd5f1dbc5f8094277357cb4aac146e0
+  metadata.gz: 73f369272bfa710ed6771c98f8ae2dc96986bff8937ee05a1a0019fa68ad11f6
+  data.tar.gz: 2495665b20ff9016201d09e22ece82414637cec6f501c79e4f6d80f3b11ca84f
 SHA512:
-  metadata.gz: 95ba2b481c476d7b5640a929531ee9e0b1cffaaed4968970a063bfe718a6cbe99151cc3b2c85cadef2227ea6ba3acf9264e9f10a2dc44077c3dee9b389639dcc
-  data.tar.gz: '0945092f4ebe7b07dadc6288ad39e05bc7a6ca282779b9b12f92f5427f233d651bc61337b272bed9e20186696e0359ba0d8431372d5bb56565a22056dfe357c7'
+  metadata.gz: c6da6b69026da23cc2388dbaae4a3e5e431db7636c6c6ed1744ce0c1547088c80591df142f25d062f8b12b1cb87b193820787b6888657693d5403f3c2893a092
+  data.tar.gz: 0cf9bd05050f247eb58276952eca9c54dbe3f4d9da0fdca3dccc1c0eabc90e1663a4bead9a9e74dc26602b424d9289ad0d9ffdcdce0d4152516d49aee5da0200

data/bin/{hakuban-thread-engine → hakuban-engine}

@@ -1,7 +1,7 @@
 #!/bin/env ruby
 
 require 'slop'
-require 'hakuban/thread'
+require 'hakuban'
 require 'socket'
 
 STDOUT.sync = true
@@ -9,7 +9,7 @@ STDOUT.sync = true
 
 OPTIONS = Slop.parse { |o|
 	o.string '-c', '--connect', "Hakuban upstream address (default: ws://127.0.0.1:3001)", default: "ws://127.0.0.1:3001"
-	o.string '-n', '--name', "Node name (default: engine-PID)", default: "engine##{$$}@#{Socket.gethostname}"
+	o.string '-n', '--name', "Exchange name (default: engine-PID)", default: "engine##{$$}@#{Socket.gethostname}"
 	o.array '-e', '--engines', "engines to start, a glob pattern matched against class name (default: *)", delimiter: ",", default: ["*"]
 	o.bool '-d', '--debug', 'Show debug messages'
 	o.on '-h', '--help' do puts o; exit end
@@ -17,8 +17,8 @@ OPTIONS = Slop.parse { |o|
 
 
 Hakuban.logger_initialize("hakuban=debug")  if OPTIONS.debug?
-$hakuban = Hakuban::LocalNode.new(name: OPTIONS["name"])
-connector = Hakuban::WebsocketConnector.new($hakuban, OPTIONS["connect"])
+$exchange = Hakuban::LocalExchange.new(name: OPTIONS["name"])
+connector = Hakuban::WebsocketConnector.new($exchange, OPTIONS["connect"])
 
 	
 OPTIONS.arguments.each { |to_require|
@@ -31,9 +31,10 @@ started_engines = OPTIONS[:engines].map { |engine_name_pattern|
 	}
 }.flatten.uniq.map { |engine_class|
 	engine_class.new
-}.each { |engine|
-	engine.start($hakuban)
+}.map { |engine|
+	engine.start($exchange)
 	puts "Started engine: #{engine.class.name}"
+	engine
 }
 
 sleep

data/bin/hakuban-observer

@@ -1,64 +1,68 @@
 #!/bin/env ruby
 
 require 'slop'
-require 'pp'
-require 'hakuban/thread'
+require 'hakuban'
+require 'set'
 
 
 OPTIONS = Slop.parse { |o|
 	o.string '-c', '--connect', "Hakuban upstream address (default: ws://127.0.0.1:3001)", default: "ws://127.0.0.1:3001"
 	o.string '-o', '--object', "Object descriptor"
-	o.array '-t', '--tag', "Tag descriptor(s)"
+	o.array '-t', '--tag', "Tag descriptor(s)", delimiter: nil
 	o.bool '-d', '--debug', 'Show debug messages'
 	o.on '-h', '--help' do puts o; exit end
 }
 
 Hakuban.logger_initialize("hakuban=debug")  if OPTIONS.debug?
-hakuban = Hakuban::LocalNode.new(name: OPTIONS["name"])
-connector = Hakuban::WebsocketConnector.new(hakuban, OPTIONS["connect"])
+exchange = Hakuban::LocalExchange.new(name: OPTIONS["name"])
+connector = Hakuban::WebsocketConnector.new(exchange, OPTIONS["connect"])
 
 observe_contract = if OPTIONS["object"]
 	json = JSON.load(OPTIONS["object"])
 	tags = OPTIONS["tag"].map { |tag| JSON.load(tag) }
-	hakuban.object(tags, json).observe
-else
+	exchange.object(tags, json).observe
+elsif (OPTIONS["tag"]&.size || 0) > 0
 	tag = OPTIONS["tag"].map { |tag| JSON.load(tag) }
-	hakuban.tag(tag[0]).observe
+	exchange.tag(tag[0]).observe
+else
+	puts "I have no idea what to observe :(\nPlease use -o or -t, or both."
+	exit 1
 end		
 
 
-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 '}'
+def event_description(descriptor, event)
+	[
+		'',
+		'Event: %s'%[event],
+		'Descriptor JSON: %s'%[JSON.dump(descriptor.json)],
+		'Descriptor tags: [%s]'%[descriptor.tags.map { |tag| JSON.dump(tag.json) }.join(", ")],
+	].join("\n")
 end
 
 
-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
-				[
-					'"version": %s,'%[JSON.dump(state.version)],
-					'"last_sync_ms_ago": %s,'%[JSON.dump(state.synchronized)],
-					'"data": %s,'%[JSON.dump(state.data)],
-				].join("\n")
+threads = Set.new
+threads << Thread.new {
+	while new_states_stream = observe_contract.next
+		Thread.new(new_states_stream) { |states_stream|
+			threads.add(Thread.current)
+			puts event_description(states_stream.descriptor, "create")
+			while state = states_stream.next
+				puts event_description(states_stream.descriptor, "change") +  
+					[
+						'',
+						'Version": %s'%[JSON.dump(state.version)],
+						'Last_sync_us_ago": %s'%[JSON.dump(state.synchronized_us_ago)],
+						'Data: %s'%[JSON.dump(state.data)],
+					].join("\n")
 			end
-		)
+			puts event_description(states_stream.descriptor, "drop")
+			states_stream.drop
+			threads.delete(Thread.current)
+		}
 	end
-	print_event(object.descriptor, "drop", nil)
 }
 
 $stdin.read(1)
-puts "]"
+
+observe_contract.terminate
+threads.each { |thread| thread.join }

data/lib/hakuban/contract.rb

@@ -0,0 +1,196 @@
+require 'hakuban/ffi-object.rb'
+require 'hakuban/stream.rb'
+
+
+module Hakuban
+
+	class Contract < FFIObject
+
+		attr_reader :descriptor
+
+		def inspect
+			"#<#{self.class.name} #{descriptor} #{self.dropped? ? "DROPPED" : ""}>"
+		end
+
+	end
+
+
+	class ObjectObserveContract < Contract
+		
+		private_class_method :new
+
+		def initialize(local_exchange, descriptor)
+			@local_exchange, @descriptor = local_exchange, descriptor
+			@local_exchange.with_pointer { |local_exchange_pointer|
+				@descriptor.with_pointer { |descriptor_pointer|
+					initialize_pointer(FFI::hakuban_object_observe_contract_new(local_exchange_pointer, descriptor_pointer),:hakuban_object_observe_contract_drop,nil)
+				}
+			}
+		end
+
+	public
+
+		include Stream
+
+		def next(&block)
+			return nil if ! pointer = FFI::FFIFutureReturningPointer.create_and_await(self) { |pointer| FFI::hakuban_object_observe_contract_next(pointer) }.unwrap
+			ObjectStateStream.send(:new, pointer).do_and_drop_or_return(&block)
+		rescue FFIObject::PointerAlreadyDropped
+		end
+
+		def ready(&block)
+			return nil  if ! pointer = with_pointer { |pointer| FFI::hakuban_object_observe_contract_ready(pointer) }.unwrap
+			ObjectStateStream.send(:new, pointer).do_and_drop_or_return(&block)
+		rescue FFIObject::PointerAlreadyDropped
+		end
+
+		def terminate
+			with_pointer { |pointer| FFI::hakuban_object_observe_contract_terminate(pointer) }
+		rescue FFIObject::PointerAlreadyDropped
+		end
+
+	end
+
+
+	class ObjectExposeContract < Contract
+
+		private_class_method :new
+
+		def initialize(local_exchange, descriptor)
+			@local_exchange, @descriptor = local_exchange, descriptor
+			@local_exchange.with_pointer { |local_exchange_pointer|
+				@descriptor.with_pointer { |descriptor_pointer|
+					initialize_pointer(FFI::hakuban_object_expose_contract_new(local_exchange_pointer, descriptor_pointer),:hakuban_object_expose_contract_drop,nil)
+				}
+			}
+		end
+
+	public 
+
+		include Stream
+
+		def next(&block)
+			return nil  if ! pointer = FFI::FFIFutureReturningPointer.create_and_await(self) { |pointer| FFI::hakuban_object_expose_contract_next(pointer) }.unwrap
+			ObjectStateSink.send(:new, pointer).do_and_drop_or_return(&block)
+		rescue FFIObject::PointerAlreadyDropped
+		end
+
+		def ready(&block)
+			return nil  if ! pointer = with_pointer { |pointer| FFI::hakuban_object_expose_contract_ready(pointer) }.unwrap
+			ObjectStateSink.send(:new, pointer).do_and_drop_or_return(&block)
+		rescue FFIObject::PointerAlreadyDropped
+		end
+
+		def terminate
+			with_pointer { |pointer| FFI::hakuban_object_expose_contract_terminate(pointer) }
+		rescue FFIObject::PointerAlreadyDropped
+		end
+
+	end
+
+
+	class TagObserveContract < Contract
+
+		private_class_method :new
+
+		def initialize(local_exchange, descriptor)
+			@local_exchange, @descriptor = local_exchange, descriptor
+			@local_exchange.with_pointer { |local_exchange_pointer|
+				@descriptor.with_pointer { |descriptor_pointer|
+					initialize_pointer(FFI::hakuban_tag_observe_contract_new(local_exchange_pointer, descriptor_pointer),:hakuban_tag_observe_contract_drop,nil)
+				}
+			}
+		end
+
+	public
+	
+		include Stream
+
+		def next(&block)
+			return nil  if ! pointer = FFI::FFIFutureReturningPointer.create_and_await(self) { |pointer| FFI::hakuban_tag_observe_contract_next(pointer) }.unwrap
+			ObjectStateStream.send(:new, pointer).do_and_drop_or_return(&block)
+		rescue FFIObject::PointerAlreadyDropped
+		end
+
+		def ready(&block)
+			streams_array = with_pointer { |pointer| FFI::hakuban_tag_observe_contract_ready(pointer) }
+			object_state_streams = streams_array[:pointer].read_array_of_pointer(streams_array[:length]).map { |object_state_stream_pointer|  
+				ObjectStateStream.send(:new, object_state_stream_pointer)
+			}
+			FFI::hakuban_array_drop(streams_array)
+			if block
+				Thread.handle_interrupt(Object => :never) {
+					begin
+						Thread.handle_interrupt(Object => :immediate) {
+							block.call(object_state_streams)
+						}
+					ensure
+						object_state_streams.each(&:drop)
+					end
+				}
+			else
+				object_state_streams
+			end
+		rescue FFIObject::PointerAlreadyDropped
+		end
+
+		def terminate
+			with_pointer { |pointer| FFI::hakuban_tag_observe_contract_terminate(pointer) }
+		rescue FFIObject::PointerAlreadyDropped
+		end
+
+	end
+
+
+	class TagExposeContract < Contract
+
+		private_class_method :new
+
+		def initialize(local_exchange, descriptor)
+			@local_exchange, @descriptor = local_exchange, descriptor
+			@local_exchange.with_pointer { |local_exchange_pointer|
+				@descriptor.with_pointer { |descriptor_pointer|
+					initialize_pointer(FFI::hakuban_tag_expose_contract_new(local_exchange_pointer, descriptor_pointer),:hakuban_tag_expose_contract_drop,nil)
+				}
+			}
+		end
+
+	public
+
+		include Stream
+
+		def next(&block)
+			return nil  if ! pointer = FFI::FFIFutureReturningPointer.create_and_await(self) { |pointer| FFI::hakuban_tag_expose_contract_next(pointer) }.unwrap
+			ObjectStateSink.send(:new, pointer).do_and_drop_or_return(&block)
+		rescue FFIObject::PointerAlreadyDropped
+		end
+
+		def ready(&block)
+			object_state_sinks_array = with_pointer { |pointer| FFI::hakuban_tag_expose_contract_ready(pointer) }
+			object_state_sinks = object_state_sinks_array[:pointer].read_array_of_pointer(object_state_sinks_array[:length]).map { |object_state_sinks_pointer|  
+				ObjectStateSink.send(:new, object_state_sinks_pointer)
+			}
+			FFI::hakuban_array_drop(object_state_sinks_array)
+			if block
+				Thread.handle_interrupt(Object => :never) {
+					begin
+						Thread.handle_interrupt(Object => :immediate) {
+							block.call(object_state_sinks)
+						}
+					ensure
+						object_state_sinks.each(&:drop)
+					end
+				}
+			else
+				object_state_sinks
+			end
+		rescue FFIObject::PointerAlreadyDropped
+		end
+		
+		def terminate
+			with_pointer { |pointer| FFI::hakuban_tag_expose_contract_terminate(pointer) }
+		rescue FFIObject::PointerAlreadyDropped
+		end
+	end
+	
+end

data/lib/hakuban/descriptor.rb

@@ -0,0 +1,90 @@
+require 'set'
+
+require 'hakuban/ffi-object.rb'
+
+
+module Hakuban
+
+
+	class ObjectDescriptor < FFIObject
+		attr_reader :tags, :json
+
+		def initialize(tags, json)
+			Hakuban::hakuban_initialize
+			@json = json.freeze
+			@tags = Set.new(tags.map { |tag| tag.kind_of?(TagDescriptor) ? tag : TagDescriptor.new(tag) })
+			FFIObject.with_pointers(@tags) { |tag_pointers|
+				tag_pointers_array = ::FFI::MemoryPointer.new(:pointer, tag_pointers.size)
+				tag_pointers_array.write_array_of_pointer(tag_pointers)
+				initialize_pointer(FFI::hakuban_object_descriptor_new(JSON.dump(@json),tag_pointers.size,tag_pointers_array).unwrap,:hakuban_object_descriptor_drop,:hakuban_object_descriptor_clone)
+			}
+		end
+
+
+		def initialize_copy(original)
+			super
+			@tags = original.tags.map(&:clone)
+		end
+
+		
+		private_class_method def self.from_ffi_pointer(pointer)
+			new_instance = allocate
+			new_instance.send(:initialize_pointer, pointer, :hakuban_object_descriptor_drop,:hakuban_object_descriptor_clone)
+			new_instance.instance_variable_set(:@json, JSON::parse(FFI::hakuban_object_descriptor_json(pointer).clone).freeze)
+			tags_array = FFI::hakuban_object_descriptor_tags(pointer)
+			tags = tags_array[:pointer].read_array_of_pointer(tags_array[:length]).map { |tag_pointer|  
+				TagDescriptor.send(:from_ffi_pointer, FFI::hakuban_tag_descriptor_clone(tag_pointer))
+			}
+			new_instance.instance_variable_set(:@tags, tags)
+			new_instance
+		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 < FFIObject
+		attr_reader :json
+
+		def initialize(json)
+			Hakuban::hakuban_initialize
+			@json = json.freeze
+			initialize_pointer(FFI::hakuban_tag_descriptor_new(JSON.dump(json)).unwrap, :hakuban_tag_descriptor_drop, :hakuban_tag_descriptor_clone)
+		end
+
+		private_class_method def self.from_ffi_pointer(pointer)
+			new_instance = allocate
+			new_instance.send(:initialize_pointer, pointer, :hakuban_tag_descriptor_drop, :hakuban_tag_descriptor_clone)
+			new_instance.instance_variable_set(:@json, JSON::parse(FFI::hakuban_tag_descriptor_json(pointer).clone))
+			new_instance
+		end
+
+		def ==(other)
+			@json == other.json
+		end
+
+		alias eql? ==
+
+		def hash
+			@json.hash
+		end
+
+		def inspect
+			"#<TagDescriptor @json=%p>"%[self.json]
+		end
+	end
+
+end

data/lib/hakuban/engine.rb

@@ -8,14 +8,14 @@ module Hakuban
 		end
 
 
-		def start(hakuban)
-			@contracts.concat([init(hakuban)])
+		def start(exchange)
+			@contracts.concat([init(exchange)])
 			@contracts.flatten!
 			@contracts.compact!
 			@contracts.uniq!
 		end
 
-		def init(hakuban)
+		def init(exchange)
 			raise "Hakuban::Engine::init is a pure virtual function, descendants should bring their own implementation"
 		end
 

data/lib/hakuban/exchange.rb

@@ -0,0 +1,75 @@
+require 'hakuban/ffi-object.rb'
+require 'socket'
+
+module Hakuban
+
+	class LocalExchange < FFIObject
+
+		def initialize(name: false, &block)
+			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)}:#{$$}"
+		end
+
+	public
+
+		def object(tags, descriptor=nil)
+			if tags.kind_of? ObjectDescriptor
+				ObjectBuilder.new(self, tags)
+			else 
+				ObjectBuilder.new(self, ObjectDescriptor.new(tags, descriptor))
+			end
+		end
+
+		def tag(descriptor)
+			if descriptor.kind_of? TagDescriptor
+				TagBuilder.new(self, descriptor)
+			else
+				TagBuilder.new(self, TagDescriptor.new(descriptor))
+			end
+		end
+
+	end
+
+
+	class ObjectBuilder
+
+		def initialize(store, descriptor)
+			@store, @descriptor = store, descriptor
+		end
+
+		def observe(&block)
+			ObjectObserveContract.send(:new, @store, @descriptor).do_and_drop_or_return(&block)
+		end
+
+		def expose(&block)
+			ObjectExposeContract.send(:new, @store, @descriptor).do_and_drop_or_return(&block)
+		end
+
+	end
+
+
+	class TagBuilder
+
+		def initialize(store, descriptor)
+			@store, @descriptor = store, descriptor
+		end
+
+		def observe(&block)
+			TagObserveContract.send(:new, @store, @descriptor).do_and_drop_or_return(&block)
+		end
+
+		def expose(&block)
+			TagExposeContract.send(:new, @store, @descriptor).do_and_drop_or_return(&block)
+		end
+
+	end
+	
+end

data/lib/hakuban/ffi-object.rb

@@ -0,0 +1,132 @@
+require 'set'
+
+
+module Hakuban
+
+	class FFIObject
+
+		class PointerAlreadyDropped < Exception; 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
+				ObjectSpace.undefine_finalizer(self)
+				ObjectSpace.define_finalizer(self, FFIObject::generate_finalizer(@drop_fn, @pointer))
+			}
+		end
+
+
+		def with_pointer
+			@mutex.synchronize {
+				raise PointerAlreadyDropped  if dropped?
+				yield ::FFI::Pointer.new(@pointer)
+			}
+		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
+			@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
+			}
+		end
+
+
+		def dropped?
+			@pointer.nil?
+		end
+
+
+		def self.generate_finalizer(symbol, pointer_address)
+			proc { |_|
+				FFI::method(symbol).call(::FFI::Pointer.new(pointer_address)) 
+			}
+		end
+
+
+		def do_and_drop
+			Thread.handle_interrupt(Object => :never) {
+				begin
+					Thread.handle_interrupt(Object => :immediate) {
+						yield self
+					}
+				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}>"
+		end
+
+	end
+
+end