zoidberg 0.1.10 → 0.1.12

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 2bbdb961e871a0119977fa6b936a00ba8c0799ec
-  data.tar.gz: 8c83222944c0a2a60f0452d02dc72ce5b6b51bf1
+  metadata.gz: 99176e505b497b0889a91f059c260a8b1ef45645
+  data.tar.gz: 52260a78198f95b9babc69b92af2ac00e43e9769
 SHA512:
-  metadata.gz: d3e02732c39a3611c5e17224b6b27b6303c19fd7eeb884cf0215dec496b8d38a494ea322c1c4840d237831581afb70c17a74f422e0131f04d10ff08e310014d9
-  data.tar.gz: 7f9d18e3ad68bd304a00581a807b929e05d9c472a5761734bac8b525c232189c2dd40e38a3d25fdf767de12c3c5a00e064d6ff0cc00b8356b867b3a25670001a
+  metadata.gz: 6823ccd0afece4a93c2b4533dc301ffe75bc8344d4bba9409428cfedd8d10d5930f11a67c119accc05f4384cee6ae56b85d4891b938011c87f781acff22e971c
+  data.tar.gz: 7fd4eb56fbdf12be7e007f7fabf1cba8e6b8c850b3de906432330d89f559738c2a9d2d0b7038f3024d55fe4e4e1cc57515b69c1fa20adfbdd3ae3f1b145d1f9e

data/CHANGELOG.md

@@ -1,3 +1,10 @@
+# v0.1.12
+* Move event signal to abstract proxy
+* Update timeout library usage
+* Remove defer usage fetching worker within pool
+* Clean locking usage to prevent miscounts
+* Fix async style locking to ensure expected behavior
+
 # v0.1.10
 * Handle unexpected errors from asyncs while supervised
 * Pool releases lock once worker has been aquired

data/lib/zoidberg.rb

@@ -70,3 +70,7 @@ Zoidberg.default_shell = Zoidberg::SoftShell
     Zoidberg.signal_shutdown = true
   end
 end
+
+if(::ENV['ZOIDBERG_TESTING'])
+  ::Kernel.require 'timeout'
+end

data/lib/zoidberg/pool.rb

@@ -86,8 +86,8 @@ module Zoidberg
     #
     # @return [Object]
     def _zoidberg_free_worker
-      until(worker = @_workers.detect(&:_zoidberg_available?))
-        defer{ _signal.wait_for(:unlocked) }
+      unless(worker = _workers.detect(&:_zoidberg_available?))
+        until((worker = _signal.wait_for(:unlocked))._zoidberg_available?); end
       end
       worker
     end

data/lib/zoidberg/proxy.rb

@@ -69,13 +69,17 @@ module Zoidberg
     end
 
     # @return [TrueClass]
-    def _aquire_lock!
-      true
+    def _aquire_lock!(&block)
+      result = block ? block.call : true
+      _zoidberg_signal(:locked)
+      result
     end
 
     # @return [TrueClass]
-    def _release_lock!
-      true
+    def _release_lock!(&block)
+      result = block ? block.call : true
+      _zoidberg_signal(:unlocked, self) if _zoidberg_available?
+      result
     end
 
     # @return [TrueClass, FalseClass] currently unlocked
@@ -105,9 +109,9 @@ module Zoidberg
     #
     # @param sig [Symbol]
     # @return [TrueClass, FalseClass] signal was sent
-    def _zoidberg_signal(sig)
+    def _zoidberg_signal(*args)
       if(@_zoidberg_signal)
-        @_zoidberg_signal.signal(sig)
+        @_zoidberg_signal.signal(*args)
         true
       else
         false
@@ -162,13 +166,16 @@ module Zoidberg
         end
         _zoidberg_destroy!
         _aquire_lock!
-        args = _build_args.dup
-        inst = args.shift.unshelled_new(*args.first, &args.last)
-        _zoidberg_set_instance(inst)
-        if(_raw_instance.respond_to?(:restarted!))
-          _raw_instance.restarted!
+        begin
+          args = _build_args.dup
+          inst = args.shift.unshelled_new(*args.first, &args.last)
+          _zoidberg_set_instance(inst)
+          if(_raw_instance.respond_to?(:restarted!))
+            _raw_instance.restarted!
+          end
+        ensure
+          _release_lock!
         end
-        _release_lock!
       end
       true
     end
@@ -188,7 +195,7 @@ module Zoidberg
             _raw_instance.terminate(error)
           end
         end
-        death_from_above = ::Proc.new do
+        death_from_above = ::Proc.new do |*_|
           ::Kernel.raise ::Zoidberg::DeadException.new('Instance in terminated state!')
         end
         death_from_above_display = ::Proc.new do
@@ -219,6 +226,24 @@ module Zoidberg
       self
     end
 
+    # Override to directly output object stringification
+    def to_s
+      _raw_instance.to_s
+    end
+
+    # Override to directly output object inspection
+    def inspect
+      _raw_instance.inspect
+    end
+
+    def signal(*args)
+      _raw_instance.signal(*args)
+    end
+
+    def async(*args, &block)
+      _raw_instance.async(*args, &block)
+    end
+
   end
 end
 

data/lib/zoidberg/proxy/liberated.rb

@@ -31,10 +31,27 @@ module Zoidberg
         @_accessing_threads << ::Thread.current
         begin
           _aquire_lock!
+          @got_lock = true
           if(::ENV['ZOIDBERG_TESTING'])
-            ::Kernel.require 'timeout'
-            ::Timeout.timeout(::ENV.fetch('ZOIDBERG_TESTING_TIMEOUT', 5).to_i) do
-              res = @_raw_instance.__send__(*args, &block)
+            timer = ::Thread.new(::Thread.current) do |origin|
+              begin
+                time = ::ENV.fetch('ZOIDBERG_TESTING_TIMEOUT', 5).to_i
+                ::Timeout.timeout(time) do
+                  ::Kernel.sleep(time)
+                end
+                nil
+              rescue => error
+                error
+              end
+            end
+            res = @_raw_instance.__send__(*args, &block)
+            if(timer.alive?)
+              timer.kill
+            else
+              val = timer.value
+              if(val.is_a?(Exception))
+                raise val
+              end
             end
           else
             res = @_raw_instance.__send__(*args, &block)
@@ -51,9 +68,11 @@ module Zoidberg
             ::Kernel.raise e
           end
         ensure
-          _release_lock!
-          t_idx = @_accessing_threads.index(::Thread.current)
-          @_accessing_threads.delete_at(t_idx) if t_idx
+          if(@got_lock)
+            _release_lock!
+            t_idx = @_accessing_threads.index(::Thread.current)
+            @_accessing_threads.delete_at(t_idx) if t_idx
+          end
         end
         res
       end
@@ -68,41 +87,52 @@ module Zoidberg
         !_zoidberg_locked?
       end
 
+      # Register a running thread for this instance. Registered
+      # threads are tracked and killed on cleanup
+      #
+      # @param thread [Thread]
+      # @return [TrueClass]
+      def _zoidberg_thread(thread)
+        _raw_threads[self.object_id].push(thread)
+        true
+      end
+
       # Aquire the lock to access real instance. If already locked, will
       # wait until lock can be aquired.
       #
       # @return [TrueClas]
       def _aquire_lock!
-        if(@_lock)
-          if(::ENV['ZOIDBERG_DEBUG'] == 'true')
-            ::Timeout.timeout(::ENV.fetch('ZOIDBERG_DEBUG_TIMEOUT', 10).to_i) do
+        super do
+          if(@_lock)
+            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
-          else
-            @_lock.lock unless @_locker == ::Thread.current
+            @_locker = ::Thread.current
+            @_locker_count += 1
           end
-          @_locker = ::Thread.current
-          @_locker_count += 1
-          _zoidberg_signal(:locked)
+          true
         end
-        true
       end
 
       # Release the lock to access real instance
       #
       # @return [TrueClass]
       def _release_lock!
-        if(@_lock)
-          if(@_locker == ::Thread.current)
+        super do
+          if(@_lock && @_locker == ::Thread.current)
             @_locker_count -= 1
             if(@_locker_count < 1)
               @_locker = nil
               @_lock.unlock if @_lock.locked?
             end
+          else
+            false
           end
-          _zoidberg_signal(:unlocked)
         end
-        true
       end
 
       # Ensure any async threads are killed and accessing threads are

data/lib/zoidberg/shell.rb

@@ -9,20 +9,26 @@ module Zoidberg
   module SoftShell
 
     class AsyncProxy
+      attr_reader :locked
       attr_reader :target
       attr_reader :origin_proxy
-      def initialize(instance, proxy)
-        @target = instance
+      def initialize(locked_async, proxy)
+        @locked = locked_async
         @origin_proxy = proxy
+        @target = proxy._raw_instance
       end
       def method_missing(*args, &block)
         target._zoidberg_thread(
           Thread.new{
+            origin_proxy._aquire_lock! if locked
+            got_lock = locked
             begin
               target.send(*args, &block)
             rescue StandardError, ScriptError => e
               origin_proxy._zoidberg_unexpected_error(e)
               raise
+            ensure
+              origin_proxy._release_lock! if got_lock
             end
           }
         )
@@ -36,14 +42,14 @@ module Zoidberg
     # @yield block to execute without lock
     # @return [Object] result of block
     def defer
-      _zoidberg_proxy._release_lock!
+      re_lock = _zoidberg_proxy._release_lock!
       begin
         result = yield if block_given?
-        _zoidberg_proxy._aquire_lock!
         result
       rescue ::StandardError, ::ScriptError => e
-        _zoidberg_proxy._aquire_lock!
         raise e
+      ensure
+        _zoidberg_proxy._aquire_lock! if re_lock
       end
     end
 
@@ -58,24 +64,28 @@ module Zoidberg
             begin
               self.instance_exec(&block)
             rescue ::StandardError, ::ScriptError => e
-              current_self._zoidberg_unexpected_error(e)
+              _zoidberg_proxy._zoidberg_unexpected_error(e)
               raise
             end
           end
         else
           thread = ::Thread.new do
+            _zoidberg_proxy._aquire_lock!
             begin
-              current_self.instance_exec(&block)
+              got_lock = true
+              self.instance_exec(&block)
             rescue ::StandardError, ::ScriptError => e
-              current_self._zoidberg_unexpected_error(e)
+              _zoidberg_proxy._zoidberg_unexpected_error(e)
               raise
+            ensure
+              _zoidberg_proxy._release_lock! if got_lock
             end
           end
         end
         _zoidberg_thread(thread)
         nil
       else
-        ::Zoidberg::SoftShell::AsyncProxy.new(locked ? current_self : self, current_self)
+        ::Zoidberg::SoftShell::AsyncProxy.new(locked, _zoidberg_proxy)
       end
     end
 
@@ -85,7 +95,7 @@ module Zoidberg
     # @param thread [Thread]
     # @return [TrueClass]
     def _zoidberg_thread(thread)
-      _zoidberg_proxy._raw_threads[self.object_id].push(thread)
+      _zoidberg_proxy._zoidberg_thread(thread)
       true
     end
 
@@ -255,7 +265,7 @@ module Zoidberg
       # @param arg [Object] optional argument to transmit
       # @return [TrueClass, FalseClass]
       def broadcast(name, arg=nil)
-        current_self._zoidberg_signal_interface.broadcast(*[name, arg].compact)
+        _zoidberg_signal_interface.broadcast(*[name, arg].compact)
       end
 
       # Wait for a given signal
@@ -263,7 +273,7 @@ module Zoidberg
       # @param name [String, Symbol] name of signal
       # @return [Object]
       def wait_for(name)
-        defer{ current_self._zoidberg_signal_interface.wait_for(name) }
+        defer{ _zoidberg_signal_interface.wait_for(name) }
       end
       alias_method :wait, :wait_for
 

data/lib/zoidberg/version.rb

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

metadata

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