hakuban 0.6.5 → 0.8.0

data/lib/hakuban/manager.rb

@@ -1,398 +0,0 @@
-require 'hakuban/hakuban'
-require 'ostruct'
-
-#TODO: prevent usage of old object?
-#TODO: destructors
-
-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, block, retry_backoff, terminate_on_deactivation, on_exception_policy)
-			@contract = contract
-			object_class = @contract.class.const_get(:ManagedObject)
-			@objects_mutex = Mutex.new
-			@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.
-			# So, we only use it to forward actions to the main thread.
-			@ffi_callback = proc { |descriptor, action|
-				@event_queue << Event.new(action: action, descriptor: descriptor)
-			}
-			@ffi_events = @contract.new_callback_event_queue
-			@ffi_events.callback_register(&@ffi_callback)
-
-			@async = async_run {
-				while @event_queue and event = @event_queue.shift
-					@objects_mutex.synchronize {
-						case event.action
-						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 :drop
-							@ffi_events.callback_unregister
-							@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
-								@existing_objects.delete(event.descriptor)  if event.action == :stopped
-							end
-							@event_queue.clear
-							@contract.drop
-							@contract, @event_queue = nil, nil
-							break
-						end
-					}
-				end
-			}
-		end
-
-
-		def objects
-			@objects_mutex.synchronize {
-				@active_objects.dup
-			}
-		end
-
-		
-		def object
-			@objects_mutex.synchronize {
-				@active_objects.values.first
-			}
-		end	
-
-
-		def drop
-			drop_nonblock
-			async_join(@async)
-		end
-
-
-		def drop_nonblock
-			if @contract
-				@event_queue << Event.new(action: :drop)
-			end
-		end
-	end
-
-
-
-	class ManagedObjectBase
-
-		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
-			@current_delay_index = 0
-		end		
-
-
-		def run(handler)
-			handler.call(self)
-		end
-
-
-		def next_event; next_change; end
-		def next_change
-			loop {
-				case @changes.shift
-				when :change then return true
-				when :stop then return false
-				end
-			}
-		end
-
-
-		def change
-			@changes.push(:change)
-		end		
-
-		def stop
-			@changes.push(:stop)
-		end
-
-	end
-
-
-
-	class ObjectObserve
-
-		class ManagedObject < ManagedObjectBase
-
-			def state
-				@contract.object_state
-			end
-			
-			def data
-				@contract.object_state&.data
-			end
-
-			def check_active
-				!!state
-			end
-
-		end
-
-
-		def manage
-			ObjectManagerBuilder.new(self)
-		end
-
-	end
-
-
-	class ObjectExpose
-
-		class ManagedObject < ManagedObjectBase
-
-			def initialize(contract, descriptor)
-				super(contract, descriptor)
-				@assignment = contract.assignment
-			end
-
-			def run(handler)
-				super
-				@contract.desynchronize(@assignment)
-			end
-
-			def do_change(change)
-				@assignment = @contract.assignment
-				super(change)
-			end
-
-			def assignement
-				@assignment = @contract.assignment()
-			end
-
-			def assigned?
-				@contract.assigned?()
-			end
-
-			def set_state(*state, **kwargs)
-				kwargs[:assignment] ||= @assignment
-				@contract.set_object_state(*state, **kwargs)
-			end
-
-			def state=(state)
-				set_state(*state)
-			end
-
-			def set_data(value)
-				timestamp = Time.new.to_f
-				set_state([1, timestamp.floor, ((timestamp - timestamp.floor)*1000000000).floor, 0],value)
-			end
-
-			def data=(value)
-				set_data(value)
-			end
-
-			def check_active
-				assigned?
-			end
-
-		end
-
-		
-		def manage
-			ObjectManagerBuilder.new(self)
-		end
-
-	end
-
-
-	class TagObserve
-
-		class ManagedObject < ManagedObjectBase
-
-			def state
-				@contract.object_state(@descriptor)
-			end
-
-			def data
-				@contract.object_state(@descriptor)&.data
-			end
-
-			def check_active
-				!!state
-			end
-
-		end
-
-		
-		def manage
-			ObjectManagerBuilder.new(self)
-		end
-
-	end
-
-
-	class TagExpose
-
-		class ManagedObject < ManagedObjectBase
-
-			def initialize(contract, descriptor)
-				super(contract, descriptor)
-				@assignment = contract.assignment(@descriptor)
-			end
-
-			def run(handler)
-				super
-				@contract.desynchronize(@descriptor, @assignment)
-			end
-
-			def do_change(change)
-				@assignment = @contract.assignment(@descriptor)
-				super(change)
-			end
-
-			def assignement
-				@assignment = @contract.assignment(@descriptor)
-			end
-
-			def assigned?
-				@contract.assigned?(@descriptor)
-			end
-			
-			def set_state(*args, **kwargs)
-				kwargs[:assignment] ||= @assignment
-				@contract.set_object_state(@descriptor, *args, **kwargs)
-			end
-
-			def state=(state)
-				set_state(*state)
-			end
-
-			def set_data(value)
-				timestamp = Time.new.to_f
-				set_state([1, timestamp.floor, ((timestamp - timestamp.floor)*1000000000).floor, 0],value)
-			end
-
-			def data=(value)
-				set_data(value)
-			end
-
-			def check_active
-				assigned?
-			end
-
-		end
-
-		
-		def manage
-			ObjectManagerBuilder.new(self)
-		end
-
-	end
-
-end

data/lib/hakuban/thread.rb

@@ -1,35 +0,0 @@
-require 'hakuban'
-require 'hakuban/manager'
-
-module Hakuban
-
-	class ThreadObjectManager < ObjectManager
-
-		def async_run
-			Thread.new { yield }
-		end
-
-		def async_join(thread)
-			thread.value
-		end
-
-		def async_stop(thread)
-			thread.kill
-		end
-		
-		def async_filter_out_stop_exception
-			yield
-		end
-		
-	end
-
-
-	class ObjectManagerBuilder
-	
-		def with_thread(&block)
-			build(ThreadObjectManager, block)
-		end
-
-	end
-
-end