zoidberg 0.1.12 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 99176e505b497b0889a91f059c260a8b1ef45645
-  data.tar.gz: 52260a78198f95b9babc69b92af2ac00e43e9769
+  metadata.gz: 8f631edac70299825464b22bcb61b054248eb0da
+  data.tar.gz: 841685d0521b5b932c542db06d6d922a74d6c5ed
 SHA512:
-  metadata.gz: 6823ccd0afece4a93c2b4533dc301ffe75bc8344d4bba9409428cfedd8d10d5930f11a67c119accc05f4384cee6ae56b85d4891b938011c87f781acff22e971c
-  data.tar.gz: 7fd4eb56fbdf12be7e007f7fabf1cba8e6b8c850b3de906432330d89f559738c2a9d2d0b7038f3024d55fe4e4e1cc57515b69c1fa20adfbdd3ae3f1b145d1f9e
+  metadata.gz: c4da51a62307d58f60fb8947337f41e45786bcd3b364b6ada62c6f5f2c3dc225afd1193b8f020d4dcc00da6b9eab459520182ff4b6818993a753b67536c4c543
+  data.tar.gz: 76b9c10d8f7896f66eb5640e7218bc84779e7df993dccb2807832b874729150c2e1979ca78601d9ad1d91429b2420839276c5c58716fd55011738d694018128a

data/CHANGELOG.md

@@ -1,3 +1,9 @@
+# v0.2.0
+* Update termination behaviors to ensure expected results
+* Provide and use flag for system shutdown to disable supervision
+* Proper termination behavior when not supervised
+* Prevent pool from dying on worker exceptions
+
 # v0.1.12
 * Move event signal to abstract proxy
 * Update timeout library usage

data/README.md

@@ -128,6 +128,9 @@ Maybe?
 
 ## Features
 
+Originally, we looked at just adding safety but this library provides
+a handful more of things.
+
 ### Implicit Locking
 
 Zoidberg automatically synchronizes requests made to an instance. This
@@ -150,6 +153,84 @@ This shell is still in development and not fully supported yet. The
 hard shell is an implementation that is more reflective of the actor
 model with a single thread wrapping an instance and synchronizing access.
 
+### Garbage Collection
+
+Garbage collection happens as usual with Zoidberg. When an instance is created
+the result may look like the instance but really it is a proxy wrapping the
+raw instance. When the proxy falls out of scope and is garbage collected the
+raw instance it wrapped will also fall out of scope and be garbage collected.
+This wrapping behavior is what allows supervised instances to be automatically
+swapped out on failure state without requiring intervention. It also introduces
+the ability to add support for destructors, which is pretty cool.
+
+#### Destructors
+
+Instances can define destructors via the `#terminate` method. When the instance
+is garbage collected, the `#terminate` method will be called prior to the instance
+falling out of scope and being removed from the system. This allows the introduction
+of destructors:
+
+```ruby
+
+class Fubar
+  include Zoidberg::Shell
+
+  ...
+
+  def terminate
+    puts "I am being garbage collected!"
+  end
+end
+```
+
+### Signals
+
+Simple signals are available as well as signals pushing data.
+
+#### Simple Signals
+
+```ruby
+sig = Zoidberg::Signal.new
+Thread.new do
+  sig.wait(:go)
+  puts 'Done!'
+end
+puts 'Ready to signal!'
+sleep(1)
+sig.signal(:go)
+puts 'Signal sent'
+```
+
+#### Simple Broadcasting
+
+```ruby
+sig = Zoidberg::Signal.new
+5.times do
+  Thread.new do
+    sig.wait(:go)
+    puts 'Done!'
+  end
+end
+puts 'Ready to signal!'
+sleep(1)
+sig.broadcast(:go)
+puts 'Broadcast sent'
+```
+
+#### Pushing data
+
+```ruby
+sig = Zoidberg::Signal.new
+Thread.new do
+  value = sig.wait(:go)
+  puts "Done! Received: #{value.inspect}"
+end
+puts 'Ready to signal!'
+sleep(1)
+sig.signal(:go, :ohai)
+puts 'Signal sent'
+```
+
 ### Supervision
 
 Zoidberg can provide instance supervision. To enable supervision on a
@@ -166,14 +247,8 @@ This will implicitly load the `Zoidberg::Shell` module and new instances
 will be supervised. Supervision means Zoidberg will watch for unexpected
 exceptions. What are "unexpected exceptions"? They are any exception raised
 via `raise`. This will cause the instance to be torn down and a new instance
-to be instantiated.
-
-### Supervision
-
-Zoidberg provides lazy supervision. There is no single supervisor. Instead
-supervision is handled by the proxy which wraps the class. Failure of an
-instance will result in termination + reinstantiation. When externally
-accessing the instance nothing requires modification.
+to be instantiated. To the outside observer, nothing will change and no
+modification is required.
 
 ### Pools
 
@@ -181,10 +256,3 @@ Zoidberg allows pooling lazy supervised instances. Unexpected failures will
 cause the instance to be terminated and re-initialized as usual. The pool
 will deliver requests to free instances, or queue them until a free instance
 is available.
-
-### Garbage Collection
-
-Garbage collection happens as usual with Zoidberg. When an instance is created
-the result may look like the instance but really it is proxy wrapping the
-raw instance. When the proxy falls out of scope and is garbage collected the
-raw instance it wrapped will also fall out of scope and be garbage collected.

data/lib/zoidberg.rb

@@ -66,8 +66,9 @@ Zoidberg.logger = Zoidberg::Logger.new(STDERR)
 Zoidberg.default_shell = Zoidberg::SoftShell
 
 %w(INT TERM).each do |sig_name|
-  Signal.trap(sig_name) do |*_|
-    Zoidberg.signal_shutdown = true
+  original = Signal.trap(sig_name) do |*_|
+    Zoidberg.signal_shutdown = true unless ENV['ZOIDBERG_TESTING']
+    original.call if original.respond_to?(:call)
   end
 end
 

data/lib/zoidberg/pool.rb

@@ -79,7 +79,17 @@ module Zoidberg
     def method_missing(*args, &block)
       worker = _zoidberg_free_worker
       current_self._release_lock!
-      worker.send(*args, &block)
+      begin
+        worker.send(*args, &block)
+      rescue Zoidberg::DeadException => e
+        if(e.origin_object_id == object_id)
+          raise e
+        else
+          abort e
+        end
+      rescue => e
+        abort e
+      end
     end
 
     # Find or wait for a free worker

data/lib/zoidberg/proxy.rb

@@ -53,6 +53,10 @@ module Zoidberg
       raise NotImplementedError
     end
 
+    def _zoidberg_unsupervise
+      @_supervised = false
+    end
+
     # Set the raw instance into the proxy and link proxy to instance
     #
     # @param inst [Object] raw instance being wrapped
@@ -124,21 +128,15 @@ module Zoidberg
     def _zoidberg_unexpected_error(e)
       ::Zoidberg.logger.error "Unexpected exception: #{e.class} - #{e}"
       ::Zoidberg.logger.debug "#{e.class}: #{e}\n#{e.backtrace.join("\n")}"
-      unless((defined?(Timeout) && e.is_a?(Timeout::Error)) || e.is_a?(::Zoidberg::DeadException))
-        if(_zoidberg_link)
-          if(_zoidberg_link.class.trap_exit)
-            ::Zoidberg.logger.warn "Calling linked exit trapper #{@_raw_instance.class.name} -> #{_zoidberg_link.class}: #{e.class} - #{e}"
-            _zoidberg_link.async.send(
-              _zoidberg_link.class.trap_exit, @_raw_instance, e
-            )
-          end
-        else
-          if(@_supervised)
-            ::Zoidberg.logger.warn "Unexpected error for supervised class `#{@_raw_instance.class.name}`. Handling error (#{e.class} - #{e})"
-            ::Zoidberg.logger.debug "#{e.class}: #{e}\n#{e.backtrace.join("\n")}"
-            _zoidberg_handle_unexpected_error(e)
-          end
+      if(_zoidberg_link)
+        if(_zoidberg_link.class.trap_exit)
+          ::Zoidberg.logger.warn "Calling linked exit trapper #{@_raw_instance.class.name} -> #{_zoidberg_link.class}: #{e.class} - #{e}"
+          _zoidberg_link.async.send(
+            _zoidberg_link.class.trap_exit, @_raw_instance, e
+          )
         end
+      else
+        _zoidberg_handle_unexpected_error(e)
       end
     end
 
@@ -156,20 +154,23 @@ module Zoidberg
     # @param error [Exception] exception that was caught
     # @return [TrueClass]
     def _zoidberg_handle_unexpected_error(error)
-      unless(::Zoidberg.in_shutdown?)
-        if(_raw_instance.respond_to?(:restart))
+      if(_raw_instance.respond_to?(:restart))
+        unless(::Zoidberg.in_shutdown?)
           begin
             _raw_instance.restart(error)
             return # short circuit
           rescue => e
           end
         end
-        _zoidberg_destroy!
+      end
+      _zoidberg_destroy!
+      if(@_supervised && !::Zoidberg.in_shutdown?)
         _aquire_lock!
         begin
           args = _build_args.dup
           inst = args.shift.unshelled_new(*args.first, &args.last)
           _zoidberg_set_instance(inst)
+          ::Zoidberg.logger.debug "Supervised instance has been rebuilt: #{inst}"
           if(_raw_instance.respond_to?(:restarted!))
             _raw_instance.restarted!
           end
@@ -188,20 +189,30 @@ module Zoidberg
     # @return [TrueClass]
     def _zoidberg_destroy!(error=nil, &block)
       unless(_raw_instance.respond_to?(:_zoidberg_destroyed))
+        if(::Zoidberg.in_shutdown?)
+          @_zoidberg_timer.terminate if @_zoidberg_timer
+          @_zoidberg_signal.terminate if @_zoidberg_signal
+        end
         if(_raw_instance.respond_to?(:terminate))
-          if(_raw_instance.method(:terminate).arity == 0)
-            _raw_instance.terminate
-          else
-            _raw_instance.terminate(error)
+          begin
+            if(_raw_instance.method(:terminate).arity == 0)
+              _raw_instance.terminate
+            else
+              _raw_instance.terminate(error)
+            end
+          rescue => e
+            ::Zoidberg.logger.error "Unexpected exception caught during terminatation of #{self}: #{e}"
+            ::Zoidberg.logger.debug "#{e.class}: #{e}\n#{e.backtrace.join("\n")}"
           end
         end
+        block.call if block
+        oid = _raw_instance.object_id
         death_from_above = ::Proc.new do |*_|
-          ::Kernel.raise ::Zoidberg::DeadException.new('Instance in terminated state!')
+          ::Kernel.raise ::Zoidberg::DeadException.new('Instance in terminated state!', oid)
         end
         death_from_above_display = ::Proc.new do
           "#<#{self.class.name}:TERMINATED>"
         end
-        block.call if block
         _raw_instance.instance_variables.each do |i_var|
           _raw_instance.remove_instance_variable(i_var)
         end
@@ -219,7 +230,12 @@ module Zoidberg
       end
       true
     end
-    alias_method :terminate, :_zoidberg_destroy!
+
+    def terminate
+      _zoidberg_unsupervise
+      _zoidberg_destroy!
+    end
+#    alias_method :terminate, :_zoidberg_destroy!
 
     # @return [self]
     def _zoidberg_object
@@ -244,6 +260,23 @@ module Zoidberg
       _raw_instance.async(*args, &block)
     end
 
+    # Initialize the signal instance if not
+    def _zoidberg_signal_interface
+      unless(@_zoidberg_signal)
+        @_zoidberg_signal = ::Zoidberg::Signal.new(:cache_signals => self.class.option?(:cache_signals))
+      end
+      @_zoidberg_signal
+    end
+
+    # @return [Timer]
+    def _zoidberg_timer
+      unless(@_zoidberg_timer)
+        @_zoidberg_timer = Timer.new
+      end
+      @_zoidberg_timer
+    end
+
+
   end
 end
 

data/lib/zoidberg/proxy/confined.rb

@@ -60,7 +60,7 @@ module Zoidberg
           else
             res = _isolated_request(*args, &block)
           end
-        rescue ::Zoidberg::Supervise::AbortException => e
+        rescue ::Zoidberg::AbortException => e
           ::Kernel.raise e.original_exception
         rescue ::Exception => e
           _zoidberg_unexpected_error(e)
@@ -82,7 +82,7 @@ module Zoidberg
           _raw_instance.__send__(method_name, *args, &block)
         else
           unless(_source_thread.alive?)
-            ::Kernel.raise ::Zoidberg::DeadException.new('Instance in terminated state!')
+            ::Kernel.raise ::Zoidberg::DeadException.new('Instance in terminated state!', object_id)
           end
           ::Zoidberg.logger.debug "Received request from remote thread. Added to queue: #{_raw_instance.class}##{method_name}(#{args.map(&:inspect).join(', ')})"
           response_queue = ::Queue.new
@@ -140,7 +140,7 @@ module Zoidberg
           end
         ensure
           until(_requests.empty)
-            requests.pop[:response] << ::Zoidberg::DeadException.new('Instance in terminated state!')
+            requests.pop[:response] << ::Zoidberg::DeadException.new('Instance in terminated state!', object_id)
           end
         end
       end
@@ -191,7 +191,7 @@ module Zoidberg
                 end
               end
             else
-              request[:response] << ::Zoidberg::DeadException.new('Instance in terminated state!')
+              request[:response] << ::Zoidberg::DeadException.new('Instance in terminated state!', object_id)
               request[:task].halt!
             end
           end

data/lib/zoidberg/proxy/liberated.rb

@@ -5,6 +5,9 @@ module Zoidberg
 
     class Liberated < Proxy
 
+      # Time allowed for threads to gracefully die
+      THREAD_KILL_AFTER = 5
+
       # @return [Thread] current owner of lock
       attr_reader :_locker
       # @return [Hash<Integer:Thread>]
@@ -21,7 +24,7 @@ module Zoidberg
         @_locker = nil
         @_locker_count = 0
         @_zoidberg_signal = nil
-        @_raw_threads = ::Smash.new{ ::Array.new }
+        @_raw_threads = []
         @_supervised = klass.ancestors.include?(::Zoidberg::Supervise)
       end
 
@@ -56,17 +59,12 @@ module Zoidberg
           else
             res = @_raw_instance.__send__(*args, &block)
           end
-        rescue ::Zoidberg::Supervise::AbortException => e
+        rescue ::Zoidberg::AbortException => e
           ::Kernel.raise e.original_exception
         rescue ::Exception => e
           ::Zoidberg.logger.debug "Exception on: #{_raw_instance.class.name}##{args.first}(#{args.slice(1, args.size).map(&:inspect).join(', ')})"
           _zoidberg_unexpected_error(e)
-          if(e.class.to_s == 'fatal' && !@_fatal_retry)
-            @_fatal_retry = true
-            retry
-          else
-            ::Kernel.raise e
-          end
+          ::Kernel.raise e
         ensure
           if(@got_lock)
             _release_lock!
@@ -93,7 +91,7 @@ module Zoidberg
       # @param thread [Thread]
       # @return [TrueClass]
       def _zoidberg_thread(thread)
-        _raw_threads[self.object_id].push(thread)
+        _raw_threads.push(thread)
         true
       end
 
@@ -140,23 +138,40 @@ module Zoidberg
       #
       # @return [TrueClass]
       def _zoidberg_destroy!(error=nil)
+        object_string = self.inspect
+        oid = _raw_instance.object_id
+        ::Zoidberg.logger.debug "*** Destroying zoidberg instance #{object_string}"
         super do
-          _raw_threads[_raw_instance.object_id].map do |thread|
-            thread.raise ::Zoidberg::DeadException.new('Instance in terminated state!')
-          end.map do |thread|
-            thread.join(2)
-          end.find_all(&:alive?).map(&:kill)
-          _raw_threads.delete(_raw_instance.object_id)
-          @_accessing_threads.each do |thr|
-            if(thr.alive?)
+          _raw_threads.map do |thread|
+            thread.raise ::Zoidberg::DeadException.new('Instance in terminated state!', oid)
+            ::Thread.new(thread) do |thread|
+              next if thread == ::Thread.current
+              thread.join(::Zoidberg::Proxy::Liberated::THREAD_KILL_AFTER)
+              if(thread.alive?)
+                ::Zoidberg.logger.error "Failed to halt async thread, killing: #{thread.inspect}"
+                thread.kill
+              end
+            end
+          end
+          @_accessing_threads.each do |thread|
+            if(thread.alive?)
               begin
-                thr.raise ::Zoidberg::DeadException.new('Instance in terminated state!')
+                thread.raise ::Zoidberg::DeadException.new('Instance in terminated state!', oid)
+                ::Thread.new(thread) do |thread|
+                  next if thread == ::Thread.current
+                  thread.join(::Zoidberg::Proxy::Liberated::THREAD_KILL_AFTER)
+                  if(thread.alive?)
+                    ::Zoidberg.logger.error "Failed to halt accessing thread, killing: #{thread.inspect}"
+                    thread.kill
+                  end
+                end
               rescue
               end
             end
           end
           @_accessing_threads.clear
         end
+        ::Zoidberg.logger.debug "!!! Destroyed zoidberg instance #{object_string}"
       end
 
     end

data/lib/zoidberg/shell.rb

@@ -3,7 +3,26 @@ require 'zoidberg'
 module Zoidberg
 
   # Customized exception type used when instance has been terminated
-  class DeadException < RuntimeError; end
+  class DeadException < StandardError
+    attr_reader :origin_object_id
+    def initialize(message, origin_id=nil)
+      super message
+      @origin_object_id = origin_id
+    end
+  end
+
+  # Customized exception type to wrap allowed errors
+  class AbortException < StandardError
+    attr_accessor :original_exception
+
+    def to_s
+      if(original_exception)
+        "#{original_exception.class}: #{original_exception}"
+      else
+        super
+      end
+    end
+  end
 
   # Librated proxy based shell
   module SoftShell
@@ -24,6 +43,11 @@ module Zoidberg
             got_lock = locked
             begin
               target.send(*args, &block)
+            rescue Zoidberg::DeadException => e
+              if(e.origin_object_id == target.object_id)
+                got_lock = false
+              end
+              raise
             rescue StandardError, ScriptError => e
               origin_proxy._zoidberg_unexpected_error(e)
               raise
@@ -46,6 +70,9 @@ module Zoidberg
       begin
         result = yield if block_given?
         result
+      rescue ::Zoidberg::DeadException => e
+        re_lock = false if e.origin_object_id == object_id
+        raise
       rescue ::StandardError, ::ScriptError => e
         raise e
       ensure
@@ -63,6 +90,13 @@ module Zoidberg
           thread = ::Thread.new do
             begin
               self.instance_exec(&block)
+            rescue Zoidberg::DeadException => e
+              if(e.origin_object_id == object_id)
+                raise
+              else
+                _zoidberg_proxy._zoidberg_unexpected_error(e)
+                raise
+              end
             rescue ::StandardError, ::ScriptError => e
               _zoidberg_proxy._zoidberg_unexpected_error(e)
               raise
@@ -74,6 +108,13 @@ module Zoidberg
             begin
               got_lock = true
               self.instance_exec(&block)
+            rescue Zoidberg::DeadException => e
+              if(e.origin_object_id == object_id)
+                got_lock = false
+              else
+                _zoidberg_proxy._zoidberg_unexpected_error(e)
+              end
+              raise
             rescue ::StandardError, ::ScriptError => e
               _zoidberg_proxy._zoidberg_unexpected_error(e)
               raise
@@ -219,18 +260,12 @@ module Zoidberg
 
       # Initialize the signal instance if not
       def _zoidberg_signal_interface
-        unless(@_zoidberg_signal)
-          @_zoidberg_signal = ::Zoidberg::Signal.new(:cache_signals => self.class.option?(:cache_signals))
-        end
-        @_zoidberg_signal
+        _zoidberg_proxy._zoidberg_signal_interface
       end
 
       # @return [Timer]
       def timer
-        unless(@_zoidberg_timer)
-          @_zoidberg_timer = Timer.new
-        end
-        @_zoidberg_timer
+        _zoidberg_proxy._zoidberg_timer
       end
 
       # Register a recurring action
@@ -309,6 +344,21 @@ module Zoidberg
         true
       end
 
+      # Customized method for raising exceptions that have been
+      # properly handled (preventing termination)
+      #
+      # @param e [Exception]
+      # @raises [AbortException]
+      def abort(e)
+        unless(e.is_a?(::Exception))
+          $stdout.puts "E: #{e.class} - #{e.ancestors}"
+          e = StandardError.new(e)
+        end
+        new_e = ::Zoidberg::AbortException.new
+        new_e.original_exception = e
+        ::Kernel.raise new_e
+      end
+
     end
 
     module ClassMethods

data/lib/zoidberg/signal.rb

@@ -80,6 +80,15 @@ module Zoidberg
       val == EMPTY_VALUE ? (Time.now.to_f - start_sleep) : val
     end
 
+    # Force any waiter threads into an error state
+    def terminate
+      waiters.each do |k,v|
+        v[:threads].each do |thread|
+          thread.raise ::Zoidberg::DeadException.new('Instance in terminated state!', object_id)
+        end
+      end
+    end
+
     protected
 
     # Initialize the signal structure data

data/lib/zoidberg/supervise.rb

@@ -3,36 +3,6 @@ require 'zoidberg'
 module Zoidberg
   # Add supervision to instance
   module Supervise
-    # Customized exception type to wrap allowed errors
-    class AbortException < StandardError
-      attr_accessor :original_exception
-
-      def to_s
-        if(original_exception)
-          "#{original_exception.class}: #{original_exception}"
-        else
-          super
-        end
-      end
-    end
-
-    module InstanceMethods
-
-      # Customized method for raising exceptions that have been
-      # properly handled (preventing termination)
-      #
-      # @param e [Exception]
-      # @raises [AbortException]
-      def abort(e)
-        unless(e.is_a?(::Exception))
-          e = StandardError.new(e)
-        end
-        new_e = ::Zoidberg::Supervise::AbortException.new
-        new_e.original_exception = e
-        ::Kernel.raise new_e
-      end
-
-    end
 
     # Include supervision into given class when included
     #
@@ -41,11 +11,6 @@ module Zoidberg
       unless(klass.include?(Zoidberg::Shell))
         klass.class_eval{ include Zoidberg::Shell }
       end
-      unless(klass.include?(Zoidberg::Supervise::InstanceMethods))
-        klass.class_eval do
-          include InstanceMethods
-        end
-      end
     end
 
   end

data/lib/zoidberg/timer.rb

@@ -70,9 +70,6 @@ module Zoidberg
 
     include Zoidberg::SoftShell
 
-    # Custom exception used to wakeup timer
-    class Wakeup < StandardError; end
-
     # Wakeup string
     WAKEUP = "WAKEUP\n"
 
@@ -204,6 +201,11 @@ module Zoidberg
       current_self
     end
 
+    # Clean up timer thread
+    def terminate
+      @thread.raise Zoidberg::DeadException.new('Instance in terminated state', object_id)
+    end
+
     protected
 
     # Run the timer loop
@@ -218,8 +220,13 @@ module Zoidberg
         begin
           run_ready
           reset(false)
-        rescue DeadException
-          raise
+        rescue DeadException => e
+          if(e.origin_object_id == object_id)
+            Zoidberg.logger.debug "<#{self}> Terminated state encountered. Falling out of run loop!"
+            raise
+          else
+            current_self.raise e
+          end
         rescue => e
           Zoidberg.logger.error "<#{self}> Unexpected error in runner: #{e.class.name} - #{e}"
           Zoidberg.logger.debug "<#{self}> #{e.class.name}: #{e}\n#{e.backtrace.join("\n")}"

data/lib/zoidberg/version.rb

@@ -1,4 +1,4 @@
 module Zoidberg
   # Current library version
-  VERSION = Gem::Version.new('0.1.12')
+  VERSION = Gem::Version.new('0.2.0')
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: zoidberg
 version: !ruby/object:Gem::Version
-  version: 0.1.12
+  version: 0.2.0
 platform: ruby
 authors:
 - Chris Roberts
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-10-13 00:00:00.000000000 Z
+date: 2015-10-23 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bogo