hakuban 0.5.0 → 0.6.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 79db90522bce42223139845bf81169a9e75a2997a90e71952b0b00d852272ff6
-  data.tar.gz: 35d50834b1a5a2626e9e3ad62c063b04acfc86569f887e57afe2578125d994cc
+  metadata.gz: 80450f20193ebd24bb8f0b55e9e822be3a0271d26aa1c41954fe09a23c02a62d
+  data.tar.gz: 56a74e6c21534550ef484ae58ede825fd6690f847d45245c57be3271943d77bb
 SHA512:
-  metadata.gz: 5d74f9761c28495c9d6caed241fb907147aff987d8c9d5526ded5d15f6e43ac781354baae9894fc74684ecad374646d8fde4cf90b26550a2e954f6bbf95f5ecb
-  data.tar.gz: 2c48edc2b71800bf19e3a1f267de234493e1e54aa6ae6fb4042ba1fc79f22a35aa28015e2d0b37f6ddb5c491817cf6698330b609dba96077e6d26ddcd441cb28
+  metadata.gz: 9a67bad1007498001d0550abd1eab1827d155fe6b6f25ee94aa08149bd054090bc9d0b37e1767eb03b7b7971216643e4c7dd396f7ef7cc20420ea7b54fbebdea
+  data.tar.gz: 5f3d377665666e3cada421c1140c3a8e8b00e84564b61a6c29991560b45615846dfbddce318b212b2d386d9f3b84737b59a7fccc5c4068661da1b366032b8c6d

data/MIT-LICENSE

@@ -0,0 +1,20 @@
+Copyright 2015-2021 yunta
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/bin/hakuban-observer

@@ -0,0 +1,56 @@
+#!/bin/env ruby
+
+require 'slop'
+require 'pp'
+require 'hakuban/async'
+
+
+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.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"])
+
+observe_contract = if OPTIONS["object"]
+	json = JSON.load(OPTIONS["object"])
+	tags = OPTIONS["tag"].map { |tag| JSON.load(tag) }
+	hakuban.object(tags, json).observe
+else
+	tag = OPTIONS["tag"].map { |tag| JSON.load(tag) }
+	hakuban.tag(tag[0]).observe
+end		
+
+
+def print_event(descriptor, event)
+	puts "-"*120
+	puts "Event: " + event
+	puts "Descriptor: "
+	descriptor.tags.each { |tag|
+		puts "\tTags: " + JSON.dump(tag.json)
+	}
+	puts "\tJSON: " + JSON.dump(descriptor.json)
+end
+
+Async {
+			
+	observe_contract.async { |object|
+		print_event(object.descriptor, "create")
+		while object.next_change
+			print_event(object.descriptor, "change")
+			if state = object.state
+				puts "Version: " + state.version.inspect
+				puts "Last synchronized: " + state.synchronized.to_s + "ms ago"
+				puts "Data:\n"
+				pp state.data
+			end
+		end
+		print_event(object.descriptor, "drop")
+	}
+
+}

data/bin/hakuban-thread-engine

@@ -0,0 +1,45 @@
+#!/bin/env ruby
+
+require 'slop'
+require 'hakuban/thread'
+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.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
+}
+
+
+Hakuban.logger_initialize("hakuban=debug")  if OPTIONS.debug?
+$hakuban = Hakuban::LocalNode.new(name: OPTIONS["name"])
+connector = Hakuban::WebsocketConnector.new($hakuban, OPTIONS["connect"])
+
+	
+OPTIONS.arguments.each { |to_require|
+	require to_require
+}
+
+started_engines = 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}"
+}
+
+sleep
+
+started_engines.each { |engine|
+	engine.stop
+	puts "Stopped engine: #{engine.class.name}"
+}
+

data/lib/hakuban/async.rb

@@ -0,0 +1,45 @@
+require 'hakuban'
+require 'hakuban/manager'
+require 'async'
+
+module Hakuban
+
+	class AsyncObjectManager < ObjectManager
+		def async_run
+			Async { yield }
+		end
+
+		def async_join(async)
+			async.wait
+		end
+	end
+
+
+	class ObjectObserve
+		def async(&block)
+			AsyncObjectManager.new(self, ObservedObject, block)
+		end
+	end
+
+
+	class ObjectExpose
+		def async(&block)
+			AsyncObjectManager.new(self, ExposedObject, block)
+		end
+	end
+
+
+	class TagObserve
+		def async(&block)
+			AsyncObjectManager.new(self, ObservedObject, block)
+		end
+	end
+
+
+	class TagExpose
+		def async(&block)
+			AsyncObjectManager.new(self, ExposedObject, block)
+		end
+	end
+
+end

data/lib/hakuban/engine.rb

@@ -0,0 +1,44 @@
+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
+		end
+
+
+		def self.inherited(subclass)
+			@@descendants << subclass
+		end
+
+	end
+
+end

data/lib/hakuban/ffi.rb

@@ -1,6 +1,5 @@
 require 'json'
 require 'ffi'
-require 'msgpack'
 
 
 # all functions which can trigger synchronuous callbacks, and those which wait on rust locks are "blocking: true" to avoid deadlock on GIL
@@ -26,12 +25,21 @@ module Hakuban::FFI
 		layout :error, :uint8, :tag_expose_pointer, :pointer
 	end
 	
-	class FFIObjectObserveState < FFI::Struct
-		layout :synchronized, :uint8, :version_length, :size_t, :version, :pointer, :data_type_length, :size_t, :data_type, :pointer, :raw_length, :size_t, :raw, :pointer, :raw_arc, :pointer
+	class FFIObjectObserveStateGetVersionResult < FFI::Struct
+		layout :version_length, :size_t, :version_elements, :pointer
 	end
-	
+
+	class FFIObjectObserveStateGetDataTypeResult < FFI::Struct
+		layout :type_length, :size_t, :type_elements, :pointer
+	end
+
+	class FFIObjectObserveStateGetDataResult < FFI::Struct
+		layout :data_length, :size_t, :data_bytes, :pointer
+	end
+
 	class FFIObjectExposeState < FFI::Struct
 		layout :version_length, :size_t, :version, :pointer, :data_type_length, :size_t, :data_type, :pointer, :raw_length, :size_t, :raw, :pointer
+		attr_accessor :data_type_strings
 	
 		def self.construct(version, data_type, data)
 			state = FFIObjectExposeState::new
@@ -40,7 +48,8 @@ module Hakuban::FFI
 			state[:version].write_array_of_int64(version)
 			state[:data_type_length] = data_type.size
 			state[:data_type] = FFI::MemoryPointer.new(:pointer, data_type.size)
-			state[:data_type].write_array_of_pointer(data_type.map {|string| FFI::MemoryPointer.from_string(string)})
+			state.data_type_strings = data_type.map {|string| FFI::MemoryPointer.from_string(string)}
+			state[:data_type].write_array_of_pointer(state.data_type_strings)
 			state[:raw] = FFI::MemoryPointer.from_string(data)
 			state[:raw_length] = data.size
 			state
@@ -56,12 +65,13 @@ module Hakuban::FFI
 	end
 	
 	class FFITagObserveObjectStateBorrowResult < FFI::Struct
-		layout :error, :uint8, :state, FFIObjectObserveState.by_value
+		layout :error, :uint8, :state, :pointer
 	end
 	
 	class FFIObjectDescriptor < FFI::Struct
 		layout :tags_count, :size_t, :tags, :pointer, :json, :pointer
-	
+		attr_accessor :tags_strings
+		
 		def tags
 			self[:tags].read_array_of_pointer(self[:tags_count]).map { |string| JSON.parse(string.read_string()) }	# does this copy the string? 
 		end
@@ -71,12 +81,11 @@ module Hakuban::FFI
 		end
 	
 		def self.construct(tags,json)
-			tags_strings = tags.map { |tag| JSON.dump(tag) }
-			tags_strings_array = FFI::MemoryPointer.new(:pointer, tags_strings.size)
-			tags_strings_array.write_array_of_pointer(tags_strings.map {|string| FFI::MemoryPointer.from_string(string)})
 			descriptor = FFIObjectDescriptor.new
 			descriptor[:tags_count] = tags.size
-			descriptor[:tags] = tags_strings_array
+			descriptor.tags_strings = tags.map { |tag| FFI::MemoryPointer.from_string(JSON.dump(tag)) }
+			descriptor[:tags] = FFI::MemoryPointer.new(:pointer, descriptor.tags_strings.size)
+			descriptor[:tags].write_array_of_pointer(descriptor.tags_strings)
 			descriptor[:json] = FFI::MemoryPointer.from_string(JSON.dump(json))
 			descriptor
 		end
@@ -116,37 +125,50 @@ module Hakuban::FFI
 	#callback :tag_callback, [ :pointer, FFITagDescriptor.by_value, :uint8 ], :void
 
 	attach_function :hakuban_local_node_new, [ :string ], FFILocalNodeNewResult.by_value
-	attach_function :hakuban_local_node_drop, [ :pointer ], :void
+	attach_function :hakuban_local_node_drop, [ :pointer ], :void, blocking: true
 
 	attach_function :hakuban_object_observe_new, [ :pointer, FFIObjectDescriptor.by_value ], FFIObjectObserveResult.by_value, blocking: true
 	attach_function :hakuban_object_observe_drop, [ :pointer ], :void, blocking: true
-	attach_function :hakuban_object_observe_state_borrow, [ :pointer ], FFIObjectObserveState.by_value, blocking: true
-	attach_function :hakuban_object_observe_changes_callback_register, [ :pointer, :object_callback, :pointer ], :pointer, blocking: true
-
+	attach_function :hakuban_object_observe_state_borrow, [ :pointer ], :pointer, blocking: true
+	attach_function :hakuban_object_observe_events_get, [ :pointer ], :pointer, blocking: true
+	                 
 	attach_function :hakuban_object_expose_new, [ :pointer, FFIObjectDescriptor.by_value], FFIObjectExposeResult.by_value, blocking: true
 	attach_function :hakuban_object_expose_drop, [ :pointer ], :void, blocking: true
-	attach_function :hakuban_object_expose_state, [ :pointer, FFIObjectExposeState.by_value ], FFIObjectExposeStateResult.by_value, blocking: true
-	attach_function :hakuban_object_expose_assigned, [ :pointer ], :uint8, blocking: true
-	attach_function :hakuban_object_expose_changes_callback_register, [ :pointer, :object_callback, :pointer ], :pointer, blocking: true
+	attach_function :hakuban_object_expose_state, [ :pointer, FFIObjectExposeState.by_value, :uint64 ], FFIObjectExposeStateResult.by_value, blocking: true
+	attach_function :hakuban_object_expose_assignment, [ :pointer ], :uint64, blocking: true
+	attach_function :hakuban_object_expose_desynchronize, [ :pointer, :uint64 ], :void, blocking: true
+	attach_function :hakuban_object_expose_events_get, [ :pointer ], :pointer, blocking: true
 
 	attach_function :hakuban_tag_observe_new, [ :pointer, FFITagDescriptor.by_value ], FFITagObserveResult.by_value, blocking: true
 	attach_function :hakuban_tag_observe_drop, [ :pointer ], :void, blocking: true
 	attach_function :hakuban_tag_observe_object_descriptors_borrow, [ :pointer ], FFIObjectDescriptors.by_value, blocking: true
 	attach_function :hakuban_tag_observe_object_state_borrow, [ :pointer, FFIObjectDescriptor.by_value ], FFITagObserveObjectStateBorrowResult.by_value, blocking: true
-	attach_function :hakuban_tag_observe_objects_changes_callback_register, [ :pointer, :object_callback, :pointer ], :pointer, blocking: true
+	attach_function :hakuban_tag_observe_events_get, [ :pointer ], :pointer, blocking: true
 
 	attach_function :hakuban_tag_expose_new, [ :pointer, FFITagDescriptor.by_value ], FFITagExposeResult.by_value, blocking: true
 	attach_function :hakuban_tag_expose_drop, [ :pointer ], :void, blocking: true
 	attach_function :hakuban_tag_expose_object_descriptors_borrow, [ :pointer ], FFIObjectDescriptors.by_value, blocking: true
-	attach_function :hakuban_tag_expose_object_state, [ :pointer, FFIObjectDescriptor.by_value, FFIObjectExposeState.by_value ], FFIObjectExposeStateResult.by_value, blocking: true
-	attach_function :hakuban_tag_expose_objects_changes_callback_register, [ :pointer, :object_callback, :pointer ], :pointer, blocking: true
+	attach_function :hakuban_tag_expose_object_state, [ :pointer, FFIObjectDescriptor.by_value, FFIObjectExposeState.by_value, :uint64 ], FFIObjectExposeStateResult.by_value, blocking: true
+	attach_function :hakuban_tag_expose_object_assignment, [ :pointer, FFIObjectDescriptor.by_value ], :uint64, blocking: true
+	attach_function :hakuban_tag_expose_object_desynchronize, [ :pointer, FFIObjectDescriptor.by_value, :uint64 ], :void, blocking: true
+	attach_function :hakuban_tag_expose_events_get, [ :pointer ], :pointer, blocking: true
+
+	attach_function :hakuban_object_observe_state_get_synchronized, [ :pointer ], :uint64
+	attach_function :hakuban_object_observe_state_get_data_version, [ :pointer ], FFIObjectObserveStateGetVersionResult.by_value
+	attach_function :hakuban_object_observe_state_get_data_type, [ :pointer ], FFIObjectObserveStateGetDataTypeResult.by_value
+	attach_function :hakuban_object_observe_state_get_data, [ :pointer ], FFIObjectObserveStateGetDataResult.by_value
 
-	attach_function :hakuban_object_observe_state_return, [ FFIObjectObserveState.by_value ], :void
+	attach_function :hakuban_object_descriptor_events_callback_register, [ :pointer, :object_callback, :pointer ], :pointer, blocking: true
+	attach_function :hakuban_object_descriptor_events_callback_unregister, [ :pointer ], :void, blocking: true
+	attach_function :hakuban_object_descriptor_events_return, [ :pointer ], :void, blocking: true
+
+	attach_function :hakuban_object_observe_state_return, [ :pointer ], :void
 	attach_function :hakuban_object_descriptors_return, [ FFIObjectDescriptors.by_value ], :void
-	attach_function :hakuban_object_callback_unregister, [ :pointer ], :void, blocking: true
 
 	attach_function :hakuban_tokio_init_multi_thread, [ :size_t ], :pointer
-	attach_function :hakuban_tokio_websocket_connector_new, [ :pointer, :string ], FFITokioWebsocketConnectorNewResult.by_value
-	attach_function :hakuban_tokio_websocket_connector_start, [ :pointer, :pointer, :pointer ], :void
+	attach_function :hakuban_tokio_websocket_connector_new, [ :pointer, :pointer, :string ], FFITokioWebsocketConnectorNewResult.by_value
+	attach_function :hakuban_tokio_websocket_connector_drop, [ :pointer, :pointer ], :void, blocking: true
+
+	attach_function :hakuban_logger_initialize, [ :string ], :uint8
 
 end