hakuban 0.5.1 → 0.6.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: aca4a31cd75c69917785c7d5d3110c9db07d44c9be8394b37714fcae3019b5f6
-  data.tar.gz: a3c81f4d62a36fbac4bbdf6cf709909bcc132b4330e62de9b2fb39ddd4e48e72
+  metadata.gz: f12beca62a4975af1ee3f85d5ec83e85753a6f6bb95fb36529c284d88eba41c5
+  data.tar.gz: ca7a3c890c4ba1b7dc337ac1e3120b8d5d260c8170f641493067b5f75060c3ab
 SHA512:
-  metadata.gz: 3a59840edfda985efda0031603f8901a24026b6edcc044f6ac61f3c04d6e8c4cae9199eb2b10b8496810b4182f85337907ee518f3d136c4a8bb829f10f66eb9d
-  data.tar.gz: bf7e24798ea39f0524075fcacc5a47bf8f060d72a797d2b7b92827be1b6cda252df2e8da8e64cd4c8e937b2ef08f5ae21e87ff15e3174ed9164ef2a6b64d7642
+  metadata.gz: fb3e86f190c140edb9658f42f33cb9bfdad718cb6b04a9f1bced7240ed2b64716d43ab651f3551b4ee084d103fdfc3bf038dc7e3f91332f1bac692e5b9b7001f
+  data.tar.gz: fd40ec84a8e7f713f857768e84dd0f5554beb00adf586adf7e739e12e1920cb568387df5cc8c4085c7bec83fbffc36a5d16bbe7211481774e849b5dda402fab6

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,10 +25,18 @@ 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
@@ -58,7 +65,7 @@ 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
@@ -118,38 +125,49 @@ 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_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, [ FFIObjectObserveState.by_value ], :void
+	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, :pointer, :string ], FFITokioWebsocketConnectorNewResult.by_value
-	attach_function :hakuban_tokio_websocket_connector_drop, [ :pointer, :pointer ], :void
+	attach_function :hakuban_tokio_websocket_connector_drop, [ :pointer, :pointer ], :void, blocking: true
 
 	attach_function :hakuban_logger_initialize, [ :string ], :uint8