hakuban 0.5.2 → 0.6.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 79890c306cc3df4c9d3382773a66d38fa6373c6f1c2c874301ba0409050ab20d
-  data.tar.gz: e17ffc0520c6605a3cb2b207de58fc98c19d3c8d2472adf681a99dcbcb48b450
+  metadata.gz: 6d0b0d54e3b6dce8ecd11b991e94768247f2e978cca397d430fcab6bfd987484
+  data.tar.gz: 81466178ba54513cb665cd49800599125bda1ba108f7eee71efff3e5b496cbb5
 SHA512:
-  metadata.gz: a243af479fa4f47245696cb408498ce37fb46c4ca03563fc7b648dbec40cc0a18c76d227358f1dc36a1c66c31f102dc042fcf162168210b8d87f863230f4bf3f
-  data.tar.gz: ef2eec57f61f45da32b363e9b77b6cdda3de545b82ff5fce506f5970509b998b195d229625ca590e496b2679cd7fc18da61497a478226cf69b73c04be136189d
+  metadata.gz: dc7157372663dc871a85b36ee042e0fc12b66ad45fb322398b593086b47896167ab4cb913ab8b1f636071a9a006d2a3ab3af34b6d32e4024d7f3121dc4d9e19c
+  data.tar.gz: 6b0b7c59f66be811b16322574f8f0670c5802760b8cf8e690b3d4fa4107ea17dffa1e085c0c9607a72fa0a025eef0665087d5b18b0d671e43bab1cf7b5eea95f

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/event-queue.rb

@@ -0,0 +1,77 @@
+#TODO: rebuild to handle event squashing on rust side
+
+require 'ostruct'
+
+require_relative './ffi.rb'
+
+
+module Hakuban
+
+	class Event < OpenStruct; end
+
+	class ObjectDescriptorCallbackEventQueue
+
+		def initialize(pointer)
+			@events_pointer = ::FFI::AutoPointer.new(pointer, proc { |ptr| FFI.hakuban_object_descriptor_events_return(ptr) })
+		end
+
+
+		# WARNING: this callback may be run from a separate, non-ruby, thread
+		def callback_register(&callback)
+			ffi_callback = proc { |_userdata, ffi_descriptor, ffi_action|
+				action = Hakuban::action_int_to_symbol(ffi_action)
+				descriptor = ObjectDescriptor.from_ffi(ffi_descriptor)
+				callback.call(descriptor, action)
+			}
+			@callback_pointer = ::FFI::AutoPointer.new(
+				FFI::hakuban_object_descriptor_events_callback_register(@events_pointer, ffi_callback, ::FFI::Pointer::NULL),
+				proc { |ptr| FFI::hakuban_object_descriptor_events_callback_unregister(ptr) }
+			)
+		end
+
+
+		def callback_unregister
+			@callback_pointer.free
+			@callback_pointer = nil
+		end
+
+
+		def drop
+			@events_pointer.free
+			@events_pointer = nil
+		end
+
+	end
+
+
+	class ObjectDescriptorEventQueue
+
+		def initialize(contract)
+			@contract = contract
+			@queue = Queue.new
+			@ffi_callback = proc { |descriptor, action|
+				@queue << Hakuban::Event.new(action: action, descriptor: descriptor)
+			}
+			@ffi_events = @contract.new_callback_event_queue
+			@ffi_events.callback_register(&@ffi_callback)
+		end
+
+
+		#def push(event)
+		#	@queue << event
+		#end
+
+
+		def next_event; next_change; end
+		def next_change
+			@queue.pop
+		end
+		
+
+		def close
+			@queue.close
+		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
@@ -122,30 +129,41 @@ module Hakuban::FFI
 
 	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