hakuban 0.7.0 → 0.8.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 73f369272bfa710ed6771c98f8ae2dc96986bff8937ee05a1a0019fa68ad11f6
-  data.tar.gz: 2495665b20ff9016201d09e22ece82414637cec6f501c79e4f6d80f3b11ca84f
+  metadata.gz: aa2b0b0f5fc01b63fef4ef426d04edff5edc0bcd2c4098f5fe3ca0878e61ddd7
+  data.tar.gz: '038c42c98be06d5172c1a9dd17cca48ac9d2594ebd8231b8bb5f497ccfb80aa5'
 SHA512:
-  metadata.gz: c6da6b69026da23cc2388dbaae4a3e5e431db7636c6c6ed1744ce0c1547088c80591df142f25d062f8b12b1cb87b193820787b6888657693d5403f3c2893a092
-  data.tar.gz: 0cf9bd05050f247eb58276952eca9c54dbe3f4d9da0fdca3dccc1c0eabc90e1663a4bead9a9e74dc26602b424d9289ad0d9ffdcdce0d4152516d49aee5da0200
+  metadata.gz: e8b9c10a92ed1fb5e007653e4bfaac180c686f7824742585f2782464a57d1147ed6a325626c64b656950463b026271ab03cb09e399d410497038fd1198b0c202
+  data.tar.gz: 3f47125cd3d8ec7987472e0fccbdeb33b947457706499f019b08de8d1fd9c791c5f76c0526c2ca4283d91e385b7b22d43d3ad6c101d460b56134e245f32ac2fc

data/bin/hakuban-engine

@@ -8,8 +8,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', "Exchange name (default: engine-PID)", default: "engine##{$$}@#{Socket.gethostname}"
+	o.string '-c', '--connect', "Hakuban upstream address (default: ws://127.0.0.1:3001)", default: "ws://127.0.0.1:3001#name=engine"
 	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,30 +16,31 @@ OPTIONS = Slop.parse { |o|
 
 
 Hakuban.logger_initialize("hakuban=debug")  if OPTIONS.debug?
-$exchange = Hakuban::LocalExchange.new(name: OPTIONS["name"])
-connector = Hakuban::WebsocketConnector.new($exchange, OPTIONS["connect"])
+exchange = Hakuban::Exchange.new()
+connector = Hakuban::WebsocketConnector.new(exchange, OPTIONS["connect"])
 
 	
 OPTIONS.arguments.each { |to_require|
 	require to_require
 }
 
-started_engines = OPTIONS[:engines].map { |engine_name_pattern|
+engine_threads = OPTIONS[:engines].map { |engine_name_pattern|
 	Hakuban::Engine.engines.select { |engine_class|
 		File.fnmatch(engine_name_pattern, engine_class.name)
 	}
 }.flatten.uniq.map { |engine_class|
 	engine_class.new
 }.map { |engine|
-	engine.start($exchange)
-	puts "Started engine: #{engine.class.name}"
-	engine
+	Thread.new {
+		puts "Starting engine: #{engine.class.name}"
+		engine.run(exchange)
+	}
 }
 
 sleep
 
-started_engines.each { |engine|
-	engine.stop
+engine_threads.each { |thread|
+	Hakuban::Engine.stop(thread)
 	puts "Stopped engine: #{engine.class.name}"
 }
 

data/bin/{hakuban-observer → hakuban-observe}

@@ -6,7 +6,7 @@ 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 '-c', '--connect', "Hakuban upstream address (default: ws://127.0.0.1:3001)", default: "ws://127.0.0.1:3001#name=observer"
 	o.string '-o', '--object', "Object descriptor"
 	o.array '-t', '--tag', "Tag descriptor(s)", delimiter: nil
 	o.bool '-d', '--debug', 'Show debug messages'
@@ -14,16 +14,16 @@ OPTIONS = Slop.parse { |o|
 }
 
 Hakuban.logger_initialize("hakuban=debug")  if OPTIONS.debug?
-exchange = Hakuban::LocalExchange.new(name: OPTIONS["name"])
+exchange = Hakuban::Exchange.new()
 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) }
-	exchange.object(tags, json).observe
+	exchange.object_observe_contract(tags, json).build
 elsif (OPTIONS["tag"]&.size || 0) > 0
 	tag = OPTIONS["tag"].map { |tag| JSON.load(tag) }
-	exchange.tag(tag[0]).observe
+	exchange.tag_observe_contract(tag[0]).build
 else
 	puts "I have no idea what to observe :(\nPlease use -o or -t, or both."
 	exit 1
@@ -40,29 +40,22 @@ def event_description(descriptor, event)
 end
 
 
-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
+observe_contract.for_each_concurrent { |states_stream|
+	puts event_description(states_stream.descriptor, "create")
+	states_stream.for_each { |state|
+		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")
+	}
+	puts event_description(states_stream.descriptor, "drop")
 }
 
-$stdin.read(1)
 
-observe_contract.terminate
-threads.each { |thread| thread.join }
+
+sleep
+
+observe_contract.drop

data/lib/hakuban/contract.rb

@@ -14,17 +14,23 @@ module Hakuban
 
 	end
 
+	class ObserveContract < Contract; end
+	class ExposeContract < Contract; end
 
-	class ObjectObserveContract < Contract
+	class ObjectObserveContract < ObserveContract
 		
 		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)
+		def initialize(exchange, descriptor, &block)
+			super()
+			@exchange, @descriptor = exchange, descriptor
+			Thread.handle_interrupt(Object => :never) {
+				@exchange.with_pointer { |exchange_pointer|
+					@descriptor.with_pointer { |descriptor_pointer|
+						initialize_pointer(FFI::hakuban_object_observe_contract_new(exchange_pointer, descriptor_pointer),:hakuban_object_observe_contract_drop,nil)
+					}
 				}
+				do_and_drop_or_return(&block)
 			}
 		end
 
@@ -33,35 +39,31 @@ module Hakuban
 		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
+			process_item(
+				lambda { |pointer| FFI::hakuban_object_observe_contract_next(pointer) },
+				lambda { |pointer| FFIObject::from_ffi_pointer(ObjectStateStream, pointer) },
+				&block
+			)
 		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
+	class ObjectExposeContract < ExposeContract
 
 		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)
+		def initialize(exchange, descriptor, capacity, &block)
+			super()
+			@exchange, @descriptor = exchange, descriptor
+			Thread.handle_interrupt(Object => :never) {
+				@exchange.with_pointer { |exchange_pointer|
+					@descriptor.with_pointer { |descriptor_pointer|
+						initialize_pointer(FFI::hakuban_object_expose_contract_new(exchange_pointer, descriptor_pointer, capacity),:hakuban_object_expose_contract_drop,nil)
+					}
 				}
+				do_and_drop_or_return(&block)
 			}
 		end
 
@@ -70,35 +72,30 @@ module Hakuban
 		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
+			process_item(
+				lambda { |pointer| FFI::hakuban_object_expose_contract_next(pointer) },
+				lambda { |pointer| FFIObject::from_ffi_pointer(ObjectStateSink, pointer) },
+				&block
+			)
 		end
 
 	end
 
 
-	class TagObserveContract < Contract
+	class TagObserveContract < ObserveContract
 
 		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)
+		def initialize(exchange, descriptor, &block)
+			super()
+			@exchange, @descriptor = exchange, descriptor
+			Thread.handle_interrupt(Object => :never) {
+				@exchange.with_pointer { |exchange_pointer|
+					@descriptor.with_pointer { |descriptor_pointer|
+						initialize_pointer(FFI::hakuban_tag_observe_contract_new(exchange_pointer, descriptor_pointer),:hakuban_tag_observe_contract_drop,nil)
+					}
 				}
+				do_and_drop_or_return(&block)
 			}
 		end
 
@@ -107,51 +104,30 @@ module Hakuban
 		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
+			process_item(
+				lambda { |pointer| FFI::hakuban_tag_observe_contract_next(pointer) },
+				lambda { |pointer| FFIObject::from_ffi_pointer(ObjectStateStream, pointer) },
+				&block
+			)
 		end
 
 	end
 
 
-	class TagExposeContract < Contract
+	class TagExposeContract < ExposeContract
 
 		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)
+		def initialize(exchange, descriptor, capacity, &block)
+			super()
+			@exchange, @descriptor = exchange, descriptor
+			Thread.handle_interrupt(Object => :never) {
+				@exchange.with_pointer { |exchange_pointer|
+					@descriptor.with_pointer { |descriptor_pointer|
+						initialize_pointer(FFI::hakuban_tag_expose_contract_new(exchange_pointer, descriptor_pointer, capacity),:hakuban_tag_expose_contract_drop,nil)
+					}
 				}
+				do_and_drop_or_return(&block)
 			}
 		end
 
@@ -160,37 +136,13 @@ module Hakuban
 		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
+			process_item(
+				lambda { |pointer| FFI::hakuban_tag_expose_contract_next(pointer) },
+				lambda { |pointer| FFIObject::from_ffi_pointer(ObjectStateSink, pointer) },
+				&block				
+			)
 		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

@@ -10,35 +10,31 @@ module Hakuban
 		attr_reader :tags, :json
 
 		def initialize(tags, json)
+			super()
 			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)
+				initialize_pointer(FFI::hakuban_object_descriptor_new(@json.to_json,tag_pointers.size,tag_pointers_array).unwrap,:hakuban_object_descriptor_drop,:hakuban_object_descriptor_clone)
 			}
 		end
 
+		def initialize_from_ffi_pointer(pointer)
+			super(pointer, :hakuban_object_descriptor_drop,:hakuban_object_descriptor_clone)
+			@json = JSON::parse(FFI::hakuban_object_descriptor_json(pointer).clone)
+			tags_array = FFI::hakuban_object_descriptor_tags(pointer)
+		 	@tags = tags_array[:pointer].read_array_of_pointer(tags_array[:length]).map { |tag_pointer|
+				FFIObject.from_ffi_pointer(TagDescriptor, FFI::hakuban_tag_descriptor_clone(tag_pointer))
+		 	}
+		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
@@ -60,16 +56,15 @@ module Hakuban
 		attr_reader :json
 
 		def initialize(json)
+			super()
 			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)
+			initialize_pointer(FFI::hakuban_tag_descriptor_new(json.to_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
+		def initialize_from_ffi_pointer(pointer)
+			super(pointer, :hakuban_tag_descriptor_drop,:hakuban_tag_descriptor_clone)
+			@json = JSON::parse(FFI::hakuban_tag_descriptor_json(pointer).clone)
 		end
 
 		def ==(other)

data/lib/hakuban/engine.rb

@@ -2,41 +2,85 @@ module Hakuban
 
 	class Engine
 
-		def initialize
-			raise "Hakuban::Engine is abstract"  if self.class == Hakuban::Engine
-			@contracts = []
-		end
-
-
-		def start(exchange)
-			@contracts.concat([init(exchange)])
-			@contracts.flatten!
-			@contracts.compact!
-			@contracts.uniq!
-		end
-
-		def init(exchange)
-			raise "Hakuban::Engine::init is a pure virtual function, descendants should bring their own implementation"
-		end
-
-		def stop
-			@contracts.each { |contract|
-				contract.drop
-			}
-		end
-
-
-		
 		@@descendants = []
+		def self.engines = @@descendants
+		def self.inherited(subclass) = @@descendants << subclass
 
+		Stop = Class.new(Exception)
 
-		def self.engines
-			@@descendants
+		#TODO: handle errors in Ractors
+		def run(exchange)
+			contract = contract(exchange)
+			while next_sink_or_stream = contract.next
+				if respond_to?(:handle_with_thread)
+					if contract.class < ObserveContract
+						Thread.new(next_sink_or_stream) do |sink_or_stream|
+							handle_with_thread(sink_or_stream)
+						rescue Object => error
+							$stderr.puts "#{self.class.name} exception: #{error.message}\n#{error.backtrace.join("\n")}\n"
+							contract.drop
+						ensure
+							sink_or_stream.drop
+						end
+					else
+						Thread.new(next_sink_or_stream) do |sink_or_stream|
+							thread = Thread.handle_interrupt(Object => :never) {
+								Thread.new do 
+									Thread.handle_interrupt(Object => :immediate) {
+										handle_with_thread(sink_or_stream)
+									}
+								rescue Stop
+								ensure
+									sink_or_stream.drop
+								end
+							}
+							while sink_or_stream.next; end
+							thread.raise Hakuban::Engine::Stop
+							thread.join
+						rescue Object => error
+							$stderr.puts "#{self.class.name} exception: #{error.message}\n#{error.backtrace.join("\n")}\n"
+							contract.drop
+						end
+					end
+				elsif respond_to?(:handle_with_ractor)
+					raise "Ractors are not supported yet"
+					if contract.class < ObserveContract
+						Ractor.new(self, next_sink_or_stream) do |engine, sink_or_stream|
+							engine.handle_with_ractor(sink_or_stream)
+						ensure
+							sink_or_stream.drop
+						end
+					else
+						Ractor.new(self, next_sink_or_stream) do |engine, sink_or_stream|
+							thread = Thread.handle_interrupt(Object => :never) {
+								Thread.new do 
+									Thread.handle_interrupt(Object => :immediate) {
+										handle_with_ractor(sink_or_stream)
+									}
+								rescue Stop
+								ensure
+									sink_or_stream.drop
+								end
+							}
+							while sink_or_stream.next; end
+							thread.raise Hakuban::Engine::Stop
+							thread.join
+						end
+					end
+				else
+					raise "No handler defined. Engine class should define one of the following methods: handle_with_thread, handle_with_ractor"
+				end
+			end
+		rescue Stop
+		ensure
+			contract.drop  if contract
 		end
 
 
-		def self.inherited(subclass)
-			@@descendants << subclass
+		def self::stop(thread)
+			thread.raise Hakuban::Engine::Stop
+			thread.value
+		rescue Stop		
 		end
 
 	end