zoidberg 0.1.8 → 0.1.10

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: df52de1159262a58d00a216caaa8fe027a77dd9b
-  data.tar.gz: 6cfa6c993544ef1e5eac1e8ebbc441d229127028
+  metadata.gz: 2bbdb961e871a0119977fa6b936a00ba8c0799ec
+  data.tar.gz: 8c83222944c0a2a60f0452d02dc72ce5b6b51bf1
 SHA512:
-  metadata.gz: 1a1428042644789759af29f18a7f91b9f4a4dd65a7aad27c965451ba2681f87730a2ad39b21efb1adbc34076ae032d759f11d25384aeb5923d468a6b29041b8e
-  data.tar.gz: 5996f95418dc32387a87558bdf43ea02494726124ec1955702f61b21a7e7137fedf4dfe0772617287dc40ad4d2f1298603b58b6b80cbf88bd45c2d3f077fdb22
+  metadata.gz: d3e02732c39a3611c5e17224b6b27b6303c19fd7eeb884cf0215dec496b8d38a494ea322c1c4840d237831581afb70c17a74f422e0131f04d10ff08e310014d9
+  data.tar.gz: 7f9d18e3ad68bd304a00581a807b929e05d9c472a5761734bac8b525c232189c2dd40e38a3d25fdf767de12c3c5a00e064d6ff0cc00b8356b867b3a25670001a

data/CHANGELOG.md

@@ -1,3 +1,8 @@
+# v0.1.10
+* Handle unexpected errors from asyncs while supervised
+* Pool releases lock once worker has been aquired
+* Provide better string generation of abort exceptions
+
 # v0.1.8
 * Fix to properly remove canceled actions
 

data/README.md

@@ -4,10 +4,12 @@
 
 ## About
 
-Zoidberg is a small library attempting to provide synchronization
-and supervision without requiring any modifications to existing
-implementations. It is heavily inspired by Celluloid and while some
-APIs may look familiar they do not share a familiar implementation.
+Zoidberg does a couple things. First, it can be a simple way to
+provide implicit synchronization for thread safety in existing
+code that is otherwise unsafe. Second, it can provide supervision
+and pooling. This library is heavily inspired by Celluloid but,
+while some APIs may look familiar, they do not share a familiar
+implementation.
 
 ## Usage
 
@@ -120,6 +122,10 @@ and running it lots of times we get:
 So this is pretty neat. We had a class that was shown to not be thread
 safe. We tossed a module into that class. Now that class is thread safe.
 
+### Should I really do this?
+
+Maybe?
+
 ## Features
 
 ### Implicit Locking
@@ -129,6 +135,39 @@ behavior can be short circuited if the actual instance creates a thread
 and calls a method on itself. Otherwise, all external access to the
 instance will be automatically synchronized. Nifty.
 
+This synchronization behavior comes from the shells included within
+Zoidberg. There are two styles of shells available:
+
+#### `Zoidberg::SoftShell`
+
+This is the default shell used when the generic `Zoidberg::Shell` module
+is included. It will wrap the raw instance and synchronize requests to
+the instance.
+
+#### `Zoidberg::HardShell`
+
+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.
+
+### Supervision
+
+Zoidberg can provide instance supervision. To enable supervision on a
+class, include the module:
+
+```ruby
+
+class Fubar
+  include Zoidberg::Supervise
+end
+```
+
+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

data/lib/zoidberg/pool.rb

@@ -78,7 +78,8 @@ module Zoidberg
     # Used to proxy request to worker
     def method_missing(*args, &block)
       worker = _zoidberg_free_worker
-      defer{ worker.send(*args, &block) }
+      current_self._release_lock!
+      worker.send(*args, &block)
     end
 
     # Find or wait for a free worker

data/lib/zoidberg/proxy/liberated.rb

@@ -74,7 +74,13 @@ module Zoidberg
       # @return [TrueClas]
       def _aquire_lock!
         if(@_lock)
-          @_lock.lock unless @_locker == ::Thread.current
+          if(::ENV['ZOIDBERG_DEBUG'] == 'true')
+            ::Timeout.timeout(::ENV.fetch('ZOIDBERG_DEBUG_TIMEOUT', 10).to_i) do
+              @_lock.lock unless @_locker == ::Thread.current
+            end
+          else
+            @_lock.lock unless @_locker == ::Thread.current
+          end
           @_locker = ::Thread.current
           @_locker_count += 1
           _zoidberg_signal(:locked)

data/lib/zoidberg/shell.rb

@@ -10,16 +10,19 @@ module Zoidberg
 
     class AsyncProxy
       attr_reader :target
-      def initialize(instance)
+      attr_reader :origin_proxy
+      def initialize(instance, proxy)
         @target = instance
+        @origin_proxy = proxy
       end
       def method_missing(*args, &block)
         target._zoidberg_thread(
           Thread.new{
             begin
               target.send(*args, &block)
-            rescue Exception => e
-              target._zoidberg_proxy.send(:raise, e)
+            rescue StandardError, ScriptError => e
+              origin_proxy._zoidberg_unexpected_error(e)
+              raise
             end
           }
         )
@@ -38,7 +41,7 @@ module Zoidberg
         result = yield if block_given?
         _zoidberg_proxy._aquire_lock!
         result
-      rescue Exception => e
+      rescue ::StandardError, ::ScriptError => e
         _zoidberg_proxy._aquire_lock!
         raise e
       end
@@ -52,15 +55,27 @@ module Zoidberg
       if(block_given?)
         unless(locked)
           thread = ::Thread.new do
-            self.instance_exec(&block)
+            begin
+              self.instance_exec(&block)
+            rescue ::StandardError, ::ScriptError => e
+              current_self._zoidberg_unexpected_error(e)
+              raise
+            end
           end
         else
-          thread = ::Thread.new{ current_self.instance_exec(&block) }
+          thread = ::Thread.new do
+            begin
+              current_self.instance_exec(&block)
+            rescue ::StandardError, ::ScriptError => e
+              current_self._zoidberg_unexpected_error(e)
+              raise
+            end
+          end
         end
         _zoidberg_thread(thread)
         nil
       else
-        ::Zoidberg::SoftShell::AsyncProxy.new(locked ? current_self : self)
+        ::Zoidberg::SoftShell::AsyncProxy.new(locked ? current_self : self, current_self)
       end
     end
 
@@ -232,7 +247,7 @@ module Zoidberg
       # @param arg [Object] optional argument to transmit
       # @return [TrueClass, FalseClass]
       def signal(name, arg=nil)
-        current_self._zoidberg_signal_interface.signal(*[name, arg].compact)
+        _zoidberg_signal_interface.signal(*[name, arg].compact)
       end
 
       # Broadcast a signal to all waiters

data/lib/zoidberg/supervise.rb

@@ -6,6 +6,14 @@ module Zoidberg
     # 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
@@ -16,6 +24,9 @@ module Zoidberg
       # @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

data/lib/zoidberg/version.rb

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

metadata

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