hakuban 0.6.5 → 0.8.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: b96f9b3980a477679e6500a226142873db6c0569706e2eae58b29c04b8a956e9
-  data.tar.gz: c66a0a751a8d95bbd5944edb8c5c9a2cdbd5f1dbc5f8094277357cb4aac146e0
+  metadata.gz: 79f0597271e97381de53272d50c3878a56b816ff24947aedca9e7c309b2f2490
+  data.tar.gz: e845a290fa0e13548ead5d04110720fb8f6ffa63966201702c1e0a02b116433e
 SHA512:
-  metadata.gz: 95ba2b481c476d7b5640a929531ee9e0b1cffaaed4968970a063bfe718a6cbe99151cc3b2c85cadef2227ea6ba3acf9264e9f10a2dc44077c3dee9b389639dcc
-  data.tar.gz: '0945092f4ebe7b07dadc6288ad39e05bc7a6ca282779b9b12f92f5427f233d651bc61337b272bed9e20186696e0359ba0d8431372d5bb56565a22056dfe357c7'
+  metadata.gz: 2002cf8603e02ce094bc3220a3cd28af3ef55695b8cefe232cd76cdd8543c5e02e894c456fd84e740ad16fba4253dacc670254d8ee991335fc0e3bc70d664156
+  data.tar.gz: 32dcf7d561c69d6d6ff2b53c695f2978a324789b90766224eb468cfd71c0709c76231ee30d03bdf2bfed6f403c050b299de18a24221781e1d89b0bd8d8e3e6b0

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

@@ -1,15 +1,14 @@
 #!/bin/env ruby
 
 require 'slop'
-require 'hakuban/thread'
+require 'hakuban'
 require 'socket'
 
 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 '-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,29 +16,31 @@ 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::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
-}.each { |engine|
-	engine.start($hakuban)
-	puts "Started engine: #{engine.class.name}"
+}.map { |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-observe

@@ -0,0 +1,61 @@
+#!/bin/env ruby
+
+require 'slop'
+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#name=observer"
+	o.string '-o', '--object', "Object descriptor"
+	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?
+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_observe_contract(tags, json).build
+elsif (OPTIONS["tag"]&.size || 0) > 0
+	tag = OPTIONS["tag"].map { |tag| JSON.load(tag) }
+	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
+end		
+
+
+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
+
+
+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")
+}
+
+
+
+sleep
+
+observe_contract.drop

data/lib/hakuban/contract.rb

@@ -0,0 +1,148 @@
+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 ObserveContract < Contract; end
+	class ExposeContract < Contract; end
+
+	class ObjectObserveContract < ObserveContract
+		
+		private_class_method :new
+
+		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
+
+	public
+
+		include Stream
+
+		def next(&block)
+			process_item(
+				lambda { |pointer| FFI::hakuban_object_observe_contract_next(pointer) },
+				lambda { |pointer| FFIObject::from_ffi_pointer(ObjectStateStream, pointer) },
+				&block
+			)
+		end
+
+
+	end
+
+
+	class ObjectExposeContract < ExposeContract
+
+		private_class_method :new
+
+		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
+
+	public 
+
+		include Stream
+
+		def next(&block)
+			process_item(
+				lambda { |pointer| FFI::hakuban_object_expose_contract_next(pointer) },
+				lambda { |pointer| FFIObject::from_ffi_pointer(ObjectStateSink, pointer) },
+				&block
+			)
+		end
+
+	end
+
+
+	class TagObserveContract < ObserveContract
+
+		private_class_method :new
+
+		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
+
+	public
+	
+		include Stream
+
+		def next(&block)
+			process_item(
+				lambda { |pointer| FFI::hakuban_tag_observe_contract_next(pointer) },
+				lambda { |pointer| FFIObject::from_ffi_pointer(ObjectStateStream, pointer) },
+				&block
+			)
+		end
+
+	end
+
+
+	class TagExposeContract < ExposeContract
+
+		private_class_method :new
+
+		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
+
+	public
+
+		include Stream
+
+		def next(&block)
+			process_item(
+				lambda { |pointer| FFI::hakuban_tag_expose_contract_next(pointer) },
+				lambda { |pointer| FFIObject::from_ffi_pointer(ObjectStateSink, pointer) },
+				&block				
+			)
+		end
+
+	end
+	
+end

data/lib/hakuban/descriptor.rb

@@ -0,0 +1,85 @@
+require 'set'
+
+require 'hakuban/ffi-object.rb'
+
+
+module Hakuban
+
+
+	class ObjectDescriptor < FFIObject
+		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.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
+
+		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)
+			super()
+			Hakuban::hakuban_initialize
+			@json = json.freeze
+			initialize_pointer(FFI::hakuban_tag_descriptor_new(json.to_json).unwrap, :hakuban_tag_descriptor_drop, :hakuban_tag_descriptor_clone)
+		end
+
+		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)
+			@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

@@ -2,41 +2,85 @@ module Hakuban
 
 	class Engine
 
-		def initialize
-			raise "Hakuban::Engine is abstract"  if self.class == Hakuban::Engine
-			@contracts = []
-		end
-
-
-		def start(hakuban)
-			@contracts.concat([init(hakuban)])
-			@contracts.flatten!
-			@contracts.compact!
-			@contracts.uniq!
-		end
-
-		def init(hakuban)
-			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

data/lib/hakuban/exchange.rb

@@ -0,0 +1,115 @@
+require 'hakuban/ffi-object.rb'
+require 'socket'
+
+module Hakuban
+
+	class Exchange < FFIObject
+
+		def initialize(&block)
+			super()
+			Hakuban::hakuban_initialize
+			Hakuban::logger_initialize("hakuban=warn", skip_if_already_initialized: true)
+			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_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
+				ObjectExposeContractBuilder.new(self, tags)
+			else 
+				ObjectExposeContractBuilder.new(self, ObjectDescriptor.new(tags, descriptor))
+			end
+		end
+
+		def tag_observe_contract(descriptor)
+			if descriptor.kind_of? TagDescriptor
+				TagObserveContractBuilder.new(self, descriptor)
+			else
+				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 ObjectObserveContractBuilder
+
+		def initialize(exchange, descriptor)
+			@exchange, @descriptor = exchange, descriptor
+		end
+
+		def build(&block)
+			ObjectObserveContract.send(:new, @exchange, @descriptor, &block)
+		end
+
+	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 TagObserveContractBuilder
+
+		def initialize(exchange, descriptor)
+			@exchange, @descriptor = exchange, descriptor
+		end
+
+		def build(&block)
+			TagObserveContract.send(:new, @exchange, @descriptor, &block)
+		end
+
+	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