hakuban 0.6.2 → 0.6.5

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 6d0b0d54e3b6dce8ecd11b991e94768247f2e978cca397d430fcab6bfd987484
-  data.tar.gz: 81466178ba54513cb665cd49800599125bda1ba108f7eee71efff3e5b496cbb5
+  metadata.gz: b96f9b3980a477679e6500a226142873db6c0569706e2eae58b29c04b8a956e9
+  data.tar.gz: c66a0a751a8d95bbd5944edb8c5c9a2cdbd5f1dbc5f8094277357cb4aac146e0
 SHA512:
-  metadata.gz: dc7157372663dc871a85b36ee042e0fc12b66ad45fb322398b593086b47896167ab4cb913ab8b1f636071a9a006d2a3ab3af34b6d32e4024d7f3121dc4d9e19c
-  data.tar.gz: 6b0b7c59f66be811b16322574f8f0670c5802760b8cf8e690b3d4fa4107ea17dffa1e085c0c9607a72fa0a025eef0665087d5b18b0d671e43bab1cf7b5eea95f
+  metadata.gz: 95ba2b481c476d7b5640a929531ee9e0b1cffaaed4968970a063bfe718a6cbe99151cc3b2c85cadef2227ea6ba3acf9264e9f10a2dc44077c3dee9b389639dcc
+  data.tar.gz: '0945092f4ebe7b07dadc6288ad39e05bc7a6ca282779b9b12f92f5427f233d651bc61337b272bed9e20186696e0359ba0d8431372d5bb56565a22056dfe357c7'

data/bin/hakuban-observer

@@ -2,7 +2,7 @@
 
 require 'slop'
 require 'pp'
-require 'hakuban/async'
+require 'hakuban/thread'
 
 
 OPTIONS = Slop.parse { |o|
@@ -27,30 +27,38 @@ else
 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)
+def print_event(descriptor, event, more)
+	if $subsequent 
+		puts ','
+	else
+		$subsequent = true
+	end
+	puts '{'
+	puts '"event": "%s",'%[event]
+	puts '"descriptor_json": %s,'%[JSON.dump(descriptor.json)]
+	puts '"descriptor_tags": [%s],'%[descriptor.tags.map { |tag| JSON.dump(tag.json) }.join(",")]
+	puts more  if more
+	puts '}'
 end
 
-Async {
-			
-	observe_contract.async { |object|
-		print_event(object.descriptor, "create")
-		while object.next_change
-			print_event(object.descriptor, "change")
+
+puts "["
+
+contract = observe_contract.manage.with_thread { |object|
+	print_event(object.descriptor, "create", nil)
+	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
+				[
+					'"version": %s,'%[JSON.dump(state.version)],
+					'"last_sync_ms_ago": %s,'%[JSON.dump(state.synchronized)],
+					'"data": %s,'%[JSON.dump(state.data)],
+				].join("\n")
 			end
-		end
-		print_event(object.descriptor, "drop")
-	}
-
+		)
+	end
+	print_event(object.descriptor, "drop", nil)
 }
+
+$stdin.read(1)
+puts "]"

data/lib/hakuban/async.rb

@@ -5,41 +5,34 @@ require 'async'
 module Hakuban
 
 	class AsyncObjectManager < ObjectManager
+
 		def async_run
 			Async { yield }
 		end
 
-		def async_join(async)
-			async.wait
+		def async_join(task)
+			task.wait
 		end
-	end
-
 
-	class ObjectObserve
-		def async(&block)
-			AsyncObjectManager.new(self, ObservedObject, block)
+		def async_stop(task)
+			task.stop	
 		end
-	end
-
-
-	class ObjectExpose
-		def async(&block)
-			AsyncObjectManager.new(self, ExposedObject, block)
-		end
-	end
-
 
-	class TagObserve
-		def async(&block)
-			AsyncObjectManager.new(self, ObservedObject, block)
+		def async_filter_out_stop_exception
+			yield
+		rescue Async::Stop
+			nil
 		end
+		
 	end
 
 
-	class TagExpose
-		def async(&block)
-			AsyncObjectManager.new(self, ExposedObject, block)
+	class ObjectManagerBuilder
+	
+		def with_async(&block)
+			build(AsyncObjectManager, block)
 		end
+		
 	end
 
 end

data/lib/hakuban/event-queue.rb

@@ -2,8 +2,6 @@
 
 require 'ostruct'
 
-require_relative './ffi.rb'
-
 
 module Hakuban
 

data/lib/hakuban/hakuban.rb

@@ -1,7 +1,6 @@
 require 'set'
 require 'ostruct'
 
-require_relative './ffi.rb'
 require_relative './event-queue.rb'
 
 #TODO: explicit drops?
@@ -33,9 +32,14 @@ module Hakuban
 	end
 
 
+	def self.hakuban_initialize
+		require_relative './ffi.rb'
+	end
+
 	@@logger_initialized = false
 
 	def self.logger_initialize(default_level, skip_if_already_initialized = false)
+		::Hakuban::hakuban_initialize
 		if @@logger_initialized and !skip_if_already_initialized
 			raise "Logger already initialized. This can't be done more than once. Make sure logger_initialize is called before any LocalNode gets constructed."  
 		end
@@ -53,6 +57,7 @@ module Hakuban
 		attr_reader :local_node_pointer  #todo: hide
 
 		def initialize(name: nil)
+			::Hakuban::hakuban_initialize
 			@default_serializer = lambda { |data_type, data| 
 				[["JSON"]+data_type, JSON.dump(data)] 
 			}

data/lib/hakuban/manager.rb

@@ -6,17 +6,56 @@ require 'ostruct'
 
 module Hakuban
 
+	class ObjectManagerBuilder
+
+		def initialize(contract)
+			@contract = contract
+			@on_exception_policy = :retry
+			@retry_backoff = [0.01, 0.1, 1.0, 10.0]
+			@terminate_on_deactivation = false
+		end
+
+
+		def on_exception(policy)
+			@on_exception_policy = policy
+			self
+		end	
+
+
+		def terminate_on_deactivation
+			@terminate_on_deactivation = true
+			self
+		end
+
+
+		def retry_backoff(*times)
+			@retry_backoff = times.flatten
+			self
+		end
+
+	
+		def build(manager_class, block)
+			raise "don't use build() directly, use .with_thread {} or .with_async {} instead"  if not manager_class
+			manager_class.new(@contract, block, @retry_backoff, @terminate_on_deactivation, @on_exception_policy)
+		end
+
+	end
+
+
 	class ObjectManager
 
 		attr_reader :contract
 
 		class Event < OpenStruct; end
+		class HandlerException < OpenStruct; end
+
 
-		def initialize(contract, object_class, block)
+		def initialize(contract, block, retry_backoff, terminate_on_deactivation, on_exception_policy)
 			@contract = contract
+			object_class = @contract.class.const_get(:ManagedObject)
 			@objects_mutex = Mutex.new
-			@objects = {}
-			@running_handlers = {}
+			@existing_objects = {}  #TODO: turn this into a WeakMap, to keep object if external code still holds reference to it
+			@active_objects = {}
 			@event_queue = Queue.new
 
 			# This callback gets called from a separate thread, with no async reactor running.
@@ -31,38 +70,82 @@ module Hakuban
 				while @event_queue and event = @event_queue.shift
 					@objects_mutex.synchronize {
 						case event.action
-						when :insert
-							raise  if @objects[event.descriptor]
-							@objects[event.descriptor] = object_class.new(@contract, event.descriptor)
-							@event_queue << Event.new(action: :handler_start, descriptor: event.descriptor)  if block
-						when :change
-							raise  if not @objects[event.descriptor]
-							@objects[event.descriptor].do_change(:change)
-						when :remove
-							raise  if not @objects[event.descriptor]
-							@objects[event.descriptor].do_change(:remove)
-							@objects.delete(event.descriptor)
-						when :handler_start
-							if (object = @objects[event.descriptor]) and !object.handler_already_run and !@running_handlers[event.descriptor]
-								descriptor_for_lambda = event.descriptor	
-								@running_handlers[event.descriptor] = async_run {
-									object.run(block)
-									@event_queue << Event.new(action: :handler_finished, descriptor: descriptor_for_lambda)  if @event_queue
-								}
+						when :insert, :change, :remove, :stopped, :timer
+							object = @existing_objects[event.descriptor] ||= object_class.new(@contract, event.descriptor)
+							if !object.running and object.async
+								error = async_join(object.async)
+								object.async = nil
+								if object.last_exception_at
+									interval_since_last_exception = Time.new - object.last_exception_at
+									heal_multiplier = 10.0
+									object.current_delay_index -= (interval_since_last_exception / (retry_backoff[-1]*heal_multiplier)).floor
+									object.current_delay_index = 0  if object.current_delay_index < 0
+								end
+								if error.kind_of? HandlerException
+									case on_exception_policy
+									when :raise
+										raise error.exception
+									when :retry
+										object.last_exception_at = Time.new
+										object.earliest_next_run = Time.new + retry_backoff[object.current_delay_index]
+										lambda_sleep_time = object.earliest_next_run - Time.new
+										lambda_descriptor = event.descriptor
+										async_run { 
+											sleep lambda_sleep_time
+											@event_queue << Event.new(action: :timer, descriptor: lambda_descriptor)  if @event_queue
+										}  #TODO: do we have to join this?
+										object.current_delay_index += 1  if object.current_delay_index < retry_backoff.size - 1
+									#when :ignore_failing_descriptor
+									#when :drop_contract
+									end
+								end
+							end
+							if object.check_active
+								if block and !object.running and (!object.earliest_next_run or Time.new >= object.earliest_next_run)
+									descriptor_for_lambda = event.descriptor
+									object.running = true
+							 		object.async = async_run do
+										async_filter_out_stop_exception {
+							 				object.run(block)
+										}
+									rescue Exception => e
+										$stderr.puts "Exception in hakuban manager lambda: #{e}"
+										$stderr.puts "Contract: "+@contract.inspect
+										$stderr.puts "Descriptor: "+descriptor_for_lambda.inspect
+										$stderr.puts "Backtrace:\n\t#{e.backtrace.join("\n\t")}"
+										HandlerException.new(exception: e)  # exception has to wrapped here to stop async from throwing on join
+									ensure
+										object.running = false
+							 			@event_queue << Event.new(action: :stopped, descriptor: descriptor_for_lambda)  if @event_queue
+									end
+								end
+								@active_objects[event.descriptor] ||= object
+								object.change
+							else
+								@active_objects.delete(event.descriptor)
+								if object.running
+									object.stop
+									async_stop(object.async)  if terminate_on_deactivation
+								else
+									@existing_objects.delete(event.descriptor)
+								end
 							end
-						when :handler_finished
-							raise  if not @running_handlers[event.descriptor]
-							@running_handlers.delete(event.descriptor)
-							@event_queue << Event.new(action: :handler_start, descriptor: event.descriptor)  if @objects[event.descriptor]
 						when :drop
 							@ffi_events.callback_unregister
-							@objects.values.each { |object| object.do_change(:remove) }
-							while @running_handlers.size > 0
+							@active_objects.clear
+							@existing_objects.dup.each { |descriptor, object| 
+								if object.running
+									object.stop
+									async_stop(object.async)  if terminate_on_deactivation
+								else
+									@existing_objects.delete(descriptor)
+								end
+							}
+							while @existing_objects.size > 0
 								event = @event_queue.shift
-								@running_handlers.delete(event.descriptor)  if event.action == :handler_finished
+								@existing_objects.delete(event.descriptor)  if event.action == :stopped
 							end
 							@event_queue.clear
-							@objects.clear
 							@contract.drop
 							@contract, @event_queue = nil, nil
 							break
@@ -75,14 +158,14 @@ module Hakuban
 
 		def objects
 			@objects_mutex.synchronize {
-				@objects.dup
+				@active_objects.dup
 			}
 		end
 
 		
 		def object
 			@objects_mutex.synchronize {
-				@objects.values.first
+				@active_objects.values.first
 			}
 		end	
 
@@ -102,20 +185,20 @@ module Hakuban
 
 
 
-	class ManagedObject
+	class ManagedObjectBase
 
-		attr_reader :descriptor, :async, :handler_already_run
+		attr_reader :descriptor
+		attr_accessor :running, :async, :last_exception_at, :current_delay_index, :earliest_next_run
 
 
 		def initialize(contract, descriptor)
 			@contract,@descriptor = contract, descriptor
 			@changes = Queue.new
-			@handler_already_run = false
+			@current_delay_index = 0
 		end		
 
 
 		def run(handler)
-			@handler_already_run = true
 			handler.call(self)
 		end
 
@@ -125,23 +208,27 @@ module Hakuban
 			loop {
 				case @changes.shift
 				when :change then return true
-				when :remove then return false
+				when :stop then return false
 				end
 			}
 		end
 
 
-		def do_change(change)
-			@changes.push(change)
+		def change
+			@changes.push(:change)
 		end		
 
+		def stop
+			@changes.push(:stop)
+		end
+
 	end
 
 
 
 	class ObjectObserve
 
-		class ObservedObject < 	ManagedObject
+		class ManagedObject < ManagedObjectBase
 
 			def state
 				@contract.object_state
@@ -151,6 +238,15 @@ module Hakuban
 				@contract.object_state&.data
 			end
 
+			def check_active
+				!!state
+			end
+
+		end
+
+
+		def manage
+			ObjectManagerBuilder.new(self)
 		end
 
 	end
@@ -158,7 +254,7 @@ module Hakuban
 
 	class ObjectExpose
 
-		class ExposedObject < ManagedObject
+		class ManagedObject < ManagedObjectBase
 
 			def initialize(contract, descriptor)
 				super(contract, descriptor)
@@ -201,6 +297,15 @@ module Hakuban
 				set_data(value)
 			end
 
+			def check_active
+				assigned?
+			end
+
+		end
+
+		
+		def manage
+			ObjectManagerBuilder.new(self)
 		end
 
 	end
@@ -208,7 +313,7 @@ module Hakuban
 
 	class TagObserve
 
-		class ObservedObject < 	ManagedObject
+		class ManagedObject < ManagedObjectBase
 
 			def state
 				@contract.object_state(@descriptor)
@@ -218,6 +323,15 @@ module Hakuban
 				@contract.object_state(@descriptor)&.data
 			end
 
+			def check_active
+				!!state
+			end
+
+		end
+
+		
+		def manage
+			ObjectManagerBuilder.new(self)
 		end
 
 	end
@@ -225,7 +339,7 @@ module Hakuban
 
 	class TagExpose
 
-		class ExposedObject < 	ManagedObject
+		class ManagedObject < ManagedObjectBase
 
 			def initialize(contract, descriptor)
 				super(contract, descriptor)
@@ -268,8 +382,17 @@ module Hakuban
 				set_data(value)
 			end
 
+			def check_active
+				assigned?
+			end
+
+		end
+
+		
+		def manage
+			ObjectManagerBuilder.new(self)
 		end
 
 	end
 
-end
+end

data/lib/hakuban/thread.rb

@@ -4,41 +4,32 @@ require 'hakuban/manager'
 module Hakuban
 
 	class ThreadObjectManager < ObjectManager
+
 		def async_run
 			Thread.new { yield }
 		end
 
 		def async_join(thread)
-			thread.join
+			thread.value
 		end
-	end
-
 
-	class ObjectObserve
-		def thread(&block)
-			ThreadObjectManager.new(self, ObservedObject, block)
+		def async_stop(thread)
+			thread.kill
 		end
-	end
-
-
-	class ObjectExpose
-		def thread(&block)
-			ThreadObjectManager.new(self, ExposedObject, block)
+		
+		def async_filter_out_stop_exception
+			yield
 		end
+		
 	end
 
 
-	class TagObserve
-		def thread(&block)
-			ThreadObjectManager.new(self, ObservedObject, block)
+	class ObjectManagerBuilder
+	
+		def with_thread(&block)
+			build(ThreadObjectManager, block)
 		end
-	end
 
-
-	class TagExpose
-		def thread(&block)
-			ThreadObjectManager.new(self, ExposedObject, block)
-		end
 	end
 
 end

data/lib/hakuban/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Hakuban
-	VERSION = "0.6.2"
+	VERSION = "0.6.5"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: hakuban
 version: !ruby/object:Gem::Version
-  version: 0.6.2
+  version: 0.6.5
 platform: ruby
 authors:
 - yunta
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2022-02-13 00:00:00.000000000 Z
+date: 2022-03-26 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rspec