dont-stall-my-process 0.0.1 → 0.1.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: bba5b99c3f45cf21b973302a4b9d43711045d8e0
-  data.tar.gz: b5754b5ebf28641cb7968a6a117e17c6fbf6f43e
+  metadata.gz: 68d9fbd15fa53138d40bf1c042bbc284421fade2
+  data.tar.gz: 262a38004cf7b4f8ecddbb49d370aae5343d5e6b
 SHA512:
-  metadata.gz: d3c8179f80acb4dbbb5a84311d18fa0625dd4a5980cfe4692d74c32cba4555b68de05d12caec8879f4b239f936185b7e6e864b49ee25d0dfc753b026b0f45e65
-  data.tar.gz: 5b56b6b4699377beebcd92479930b31390897976b46763f8d6f222032ece2404e05cc32cda0be096fe28ba9425155ea9ae19ac3630ac6471e4c89440a44dfb68
+  metadata.gz: 7fe43327afdc8e662ae41b40397a3395f097ccf81ff175321e544585d6250c39d57174d989120b4c38ca8be44d6c6a28809136006af2bd2ab20b3f6f636af220
+  data.tar.gz: 9cf418fc795e9382b0849731ffc347debfb427619ef725e05b55b28f4a3c952e6c3cb499906e156ab275957f66f07a6ad67500a4ffc4370165d83528c7a19312

data/lib/dont-stall-my-process.rb

@@ -1,26 +1,51 @@
+require 'dont-stall-my-process/configuration'
+require 'dont-stall-my-process/exceptions'
+require 'dont-stall-my-process/proxy_registry'
+require 'dont-stall-my-process/version'
 require 'dont-stall-my-process/local/child_process'
+require 'dont-stall-my-process/local/child_process_pool'
 require 'dont-stall-my-process/local/local_proxy'
+require 'dont-stall-my-process/local/process_exit_handler'
 require 'dont-stall-my-process/remote/remote_application'
+require 'dont-stall-my-process/remote/remote_application_controller'
 require 'dont-stall-my-process/remote/remote_proxy'
-require 'dont-stall-my-process/version'
 
 module DontStallMyProcess
-  DEFAULT_TIMEOUT = 300
+  def self.configure
+    yield Configuration.get if block_given?
+  end
 
-  def self.create(klass, opts = {}, sigkill_only = false)
+  def self.create(klass, opts = {})
     fail 'no klass given' unless klass && klass.is_a?(Class)
 
     # Set default values and validate configuration.
     opts = sanitize_options(opts)
 
+    # Start a local DRbServer (unnamed?) for callbacks (blocks!).
+    # Each new DontStallMyProcess object will overwrite the main master DRbServer.
+    # This looks weird, but doesn't affect concurrent uses of multiple
+    # Watchdogs, I tested it. Trust me.
+    DRb.start_service
+
     # Fork the child process.
-    p = Local::ChildProcess.new(klass, opts)
+    process = Local::ChildProcessPool.alloc
+
+    # Start the DRb service for the main class and create a proxy.
+    proxy = process.start_service(klass, opts)
 
-    # Return the main proxy class.
-    Local::MainLocalProxy.new(p, opts, sigkill_only)
+    # If a block is given, we finalize the service immediately after its return.
+    if block_given?
+
+      yield proxy
+
+      proxy.stop_service!
+      proxy = nil
+    end
+    
+    proxy
   end
 
-  def self.sanitize_options(opts, default_timeout = DEFAULT_TIMEOUT)
+  def self.sanitize_options(opts, default_timeout = Configuration::DEFAULT_TIMEOUT)
     fail 'opts is not a hash' unless opts.is_a?(Hash)
 
     opts[:timeout] ||= default_timeout
@@ -37,12 +62,4 @@ module DontStallMyProcess
       ]
     }
   end
-
-  # This exception is raised when the watchdog bites.
-  class TimeoutExceeded < StandardError; end
-
-  # This exception is raised when a forbidden Kernel method is called.
-  # These methods do not get forwarded over the DRb.
-  class KernelMethodCalled < StandardError; end
-
 end

data/lib/dont-stall-my-process/configuration.rb

@@ -0,0 +1,36 @@
+module DontStallMyProcess
+  class Configuration
+    DEFAULT_TIMEOUT = 300
+
+    ATTRIBUTES = [:sigkill_only, :close_stdio, :restore_all_traps, :skip_at_exit_handlers,
+      :process_pool_size, :subprocess_name, :after_fork_handler]
+    attr_writer *(ATTRIBUTES - [:after_fork_handler])
+
+    def initialize
+      @sigkill_only          = false
+      @close_stdio           = true
+      @restore_all_traps     = false
+      @skip_at_exit_handlers = false
+      @process_pool_size     = nil
+      @after_fork_handler    = Proc.new {}
+      @subprocess_name       = nil
+    end
+
+    def after_fork(p = nil, &block)
+      fail 'after_fork needs a block or Proc object' unless (p && p.is_a?(Proc)) || block_given?
+      @after_fork_handler = p || block
+    end
+
+    class << self
+      def get
+        @configuration ||= Configuration.new
+      end
+
+      ATTRIBUTES.each do |a|
+        define_method(a) do
+          get.instance_variable_get("@#{a}")
+        end
+      end
+    end
+  end
+end

data/lib/dont-stall-my-process/exceptions.rb

@@ -0,0 +1,14 @@
+module DontStallMyProcess
+  DontStallMyProcessError = Class.new(StandardError)
+
+  # This exception is raised when the watchdog bites.
+  TimeoutExceeded = Class.new(StandardError)
+
+  # This exception is raised when the subprocess could not be created, or
+  # its initialization failed.
+  SubprocessInitializationFailed = Class.new(StandardError)
+
+  # This exception is raised when a forbidden Kernel method is called.
+  # These methods do not get forwarded over the DRb.
+  KernelMethodCalled = Class.new(StandardError)
+end

data/lib/dont-stall-my-process/local/child_process.rb

@@ -4,48 +4,90 @@ module DontStallMyProcess
     # The ChildProcess class encapsulates the forked subprocess that
     # provides the DRb service object.
     class ChildProcess
-      attr_reader :main_uri
+      attr_reader :pid
 
-      def initialize(klass, opts)
+      def initialize
         # Start RemoteApplication in child process, connect to it thru pipe.
         r, w = IO.pipe
         @pid = fork do
           r.close
-          $stdin.close rescue nil
-          $stdout.reopen('/dev/null', 'w')
-          $stderr.reopen('/dev/null', 'w')
-          DontStallMyProcess::Remote::RemoteApplication.new(klass, opts, w).loop!
+
+          # Disable process cleanup, otherwise killing the
+          # subprocess (when Configuration.skip_at_exit_handlers is false) will
+          # terminate all the other subprocesses, or at least screw with their
+          # unix sockets.
+          ProcessExitHandler.disable_at_exit
+
+          app = DontStallMyProcess::Remote::RemoteApplication.new(w)
+          app.loop!
         end
         w.close
 
-        # Wait for the RemoteApplication to finish its setup.
-        @main_uri = Marshal.load(r.gets)
-        r.close
+        # Wait for the RemoteApplication to finish its setup, and retrieve
+        # the URI to the RemoteApplicationController.
+        ctrl_uri = Marshal.load(r)
 
-        # RemoteApplication sends us the DRb URI or an Exception.
-        raise @main_uri if @main_uri.is_a?(Exception)
-      end
+        # RemoteApplication sends us the URI or an Exception instance if anything
+        # went wrong.
+        if ctrl_uri.is_a?(Exception)
+          e = SubprocessInitializationFailed.new(ctrl_uri)
+          e.set_backtrace(ctrl_uri.backtrace)
+          raise e
+        end
+
+        # Connect to and store the controller DRb client.
+        @controller = DRbObject.new_with_uri(ctrl_uri)
+
+        # Setup LocalProxy registry for this pid.
+        LocalProxy.setup_proxy_registry(@pid) do
+          # This block will be called when all LocalProxies
+          # of this pid are gone (either garbage-collected or
+          # manually destroyed by 'stop_service!').
+
+          # Hand back ourself to the ChildProcessPool to get new jobs.
+          ChildProcessPool.free(self)
+        end
 
-      def term
-        # Exceptions in these methods almost always mean the process is already dead.
-        Process.kill('TERM', @pid) rescue nil
+        @alive = true
+      ensure
+        r.close
       end
 
-      def detach
-        Process.detach(@pid) rescue nil
+      def start_service(klass, opts)
+        uri = @controller.start_service(klass, opts)
+        
+        # Create the main proxy class.
+        Local::LocalProxy.new(uri, self, opts)
       end
 
-      def kill
-        Process.kill('KILL', @pid) rescue nil
+      def alive?
+        @alive && @controller.alive? rescue false
       end
 
-      def wait
-        Process.wait(@pid) rescue nil
+      def quit
+        @controller.stop_application rescue nil
+        @controller = nil
+        sleep 0.5
+        terminate(false, 0.5)
       end
 
-      def alive?
+      def terminate(sigkill = true, term_sleep = 5)
+        unless Configuration.sigkill_only
+          Process.kill('TERM', @pid)
+          sleep term_sleep
+        end
+
         # http://stackoverflow.com/questions/325082/how-can-i-check-from-ruby-whether-a-process-with-a-certain-pid-is-running
-        Process.waitpid(@pid, Process::WNOHANG).nil?
+        Process.kill('KILL', @pid) if sigkill && Process.waitpid(@pid, Process::WNOHANG).nil?
+
+        # Collect process status to not have a zombie hanging around.
+        Process.wait(@pid)
+
+        # Do not reuse this process ever again.
+        @alive = false
+      rescue
+        # Exceptions in these Process.* methods almost always mean the process is already dead.
+        nil
       end
     end
 

data/lib/dont-stall-my-process/local/child_process_pool.rb

@@ -0,0 +1,52 @@
+module DontStallMyProcess
+  module Local
+    class ChildProcessPool
+      MAX_ALLOC_TRIES = 5
+      SEMAPHORE = Mutex.new
+
+      def self.alloc
+        process = nil
+        tries   = MAX_ALLOC_TRIES
+        until (process && process.alive?) || tries == 0
+          tries -= 1
+          SEMAPHORE.synchronize do
+            if !@pool || @pool.empty?
+              process = ChildProcess.new
+            else
+              process = @pool.shift
+            end
+          end
+        end
+
+        unless process && process.alive?
+          fail SubprocessInitializationFailed, "failed to allocated subprocess (tried #{MAX_ALLOC_TRIES} times)"
+        end
+
+        process
+      end
+
+      def self.free(process)
+        # We do not want killed processes to enter the pool again.
+        return unless process.alive?
+
+        terminate = true
+
+        if Configuration.process_pool_size && Configuration.process_pool_size > 0
+          SEMAPHORE.synchronize do
+            @pool ||= []
+            if @pool.size < Configuration.process_pool_size
+              @pool << process
+              terminate = false
+            end
+          end
+        end
+
+        process.quit if terminate
+      end
+
+      def self.each(&block)
+        @pool.each(&block) if @pool
+      end
+    end
+  end
+end

data/lib/dont-stall-my-process/local/local_proxy.rb

@@ -6,14 +6,39 @@ module DontStallMyProcess
 
     # LocalProxy connects to an instance of a class on a child process
     # and watches the execution of remote procedure calls.
+    # Furthermore, it takes care of automatically ending the remote DRb
+    # service when the proxy object gets garbage-collected.
     class LocalProxy
-      def initialize(uri, process, opts, sigkill_only)
-        @process      = process
-        @opts         = opts
-        @sigkill_only = sigkill_only
+      class << self
+        include DontStallMyProcess::ProxyRegistry
+
+        def gc_finalize_proxy(pid, uri)
+          LocalProxy.unregister(pid, proxy_uri) { |proxy| proxy.__destroy }
+        end
+
+        def gc_finalize_proxy_proc(pid, uri)
+          # http://www.mikeperham.com/2010/02/24/the-trouble-with-ruby-finalizers/
+          proc { LocalProxy.gc_finalize_proxy(pid, uri) }
+        end
+      end
+
+      def initialize(uri, process, opts)
+        @uri     = uri
+        @process = process
+        @opts    = opts
 
         # Get a DRb reference to the remote class.
-        @object  = DRbObject.new_with_uri(uri)
+        @object   = DRbObject.new_with_uri(uri)
+
+        # Store this proxy in the registry for book-keeping.
+        LocalProxy.register(process.pid, uri, self)
+
+        # Destroy the proxy on GC.
+        ObjectSpace.define_finalizer(self, self.class.gc_finalize_proxy_proc(process.pid, uri))
+      end
+
+      def stop_service!
+        LocalProxy.each_proxy(@process.pid) { |proxy| proxy.send(:__destroy) }
       end
 
       def respond_to?(m, ia = false)
@@ -35,18 +60,12 @@ module DontStallMyProcess
         end
       end
 
-      private
-
-      def __create_nested_proxy(meth, *args, &block)
-        # Get the DRb URI from the remote.
-        uri = __timed(meth) { @object.public_send(meth, *args, &block) }
-
-        # Create a new local proxy and return that.
-        # Note: We do not need to cache these here, as there can be multiple
-        # clients to a single DRb service.
-        LocalProxy.new(uri, @process, @opts[:methods][meth], @sigkill_only)
+      def inspect
+        self.to_s.gsub('>', " URI=#{@uri} CHILD_PID=#{@process.pid}>") 
       end
 
+    private
+
       def __delegate_with_timeout(meth, *args, &block)
         __timed(meth) do
           @object.public_send(meth, *args, &block)
@@ -58,55 +77,23 @@ module DontStallMyProcess
           yield
         end
       rescue Timeout::Error
-        __kill_child_process!
+        @process.terminate
         fail TimeoutExceeded, "Method #{meth} took more than #{@opts[:timeout]} seconds to process! Child process killed."
       end
 
-      def __kill_child_process!
-        unless @sigkill_only
-          Sidekiq.logger.info "TERMINATIIIING"
-          @process.term
-          sleep 5
-        end
-
-        @process.detach
-        @process.kill if @process.alive?
-      end
-    end
-
-    # MainLocalProxy encapsulates the main DRb client, i.e. the top-level
-    # client class requested by the user. It takes care of initially starting
-    # the DRb service for callbacks and cleaning up child processes on
-    # garbage collection.
-    class MainLocalProxy < LocalProxy
-      def self.register_remote_proxy(main_uri, object)
-        @objects ||= {}
-        @objects[main_uri] = object
-      end
-
-      def self.stop_remote_application(main_uri)
-        @objects[main_uri].stop! rescue nil
-        @process.wait
-      end
+      def __create_nested_proxy(meth, *args, &block)
+        # Get the DRb URI from the remote.
+        uri = __timed(meth) { @object.public_send(meth, *args, &block) }
 
-      def self.stop_remote_application_proc(main_uri)
-        # See also: http://www.mikeperham.com/2010/02/24/the-trouble-with-ruby-finalizers/
-        proc { MainLocalProxy.stop_remote_application(main_uri) }
+        # Create a new local proxy and return that.
+        LocalProxy.new(uri, @process, @opts[:methods][meth])
       end
 
-      def initialize(process, opts, sigkill_only)
-        # Start a local DRbServer (unnamed?) for callbacks (blocks!).
-        # Each new Watchdog will overwrite the main master DRbServer.
-        # This looks weird, but doesn't affect concurrent uses of multiple
-        # Watchdogs, I tested it. Trust me.
-        DRb.start_service
-
-        # Initialize the base class, connect to the DRb service or the main client class.
-        super(process.main_uri, process, opts, sigkill_only)
+      def __destroy
+        # We rescue the exception here in case the subprocess is already dead.
+        @object.__local_proxy_destroyed rescue nil
 
-        # Stop the child process on GC.
-        MainLocalProxy.register_remote_proxy(process.main_uri, @object)
-        ObjectSpace.define_finalizer(self, self.class.stop_remote_application_proc(process.main_uri))
+        LocalProxy.unregister(@process.pid, @uri)
       end
     end
   end

data/lib/dont-stall-my-process/local/process_exit_handler.rb

@@ -0,0 +1,30 @@
+require 'fileutils'
+
+module DontStallMyProcess
+  module Local
+    class ProcessExitHandler
+      def self.disable_at_exit
+        @at_exit_disabled = true
+      end
+
+      def self.at_exit_disabled?
+        @at_exit_disabled
+      end
+
+      at_exit do
+        # If we're in a subprocess, this handler should not run.
+        unless ProcessExitHandler.at_exit_disabled?
+
+          # Make sure we terminate all subprocesses when
+          # the main process exits.
+          ChildProcessPool.each do |process|
+            process.quit
+          end
+
+          # Clean remaining unix sockets from /tmp.
+          FileUtils.rm(Dir["/tmp/dsmp-#{Process.pid}*"])
+        end
+      end
+    end
+  end
+end

data/lib/dont-stall-my-process/proxy_registry.rb

@@ -0,0 +1,29 @@
+module DontStallMyProcess
+  module ProxyRegistry
+    def setup_proxy_registry(pid, &block)
+      @empty_handler    ||= {}
+      @empty_handler[pid] = block
+
+      @proxies          ||= {}
+      @proxies[pid]       = {}
+    end
+
+    def register(pid, key, object)
+      @proxies[pid][key] = object
+    end
+
+    def unregister(pid, key)
+      if @proxies[pid].key?(key) && block_given?
+        yield @proxies[pid]
+      end
+      @proxies[pid].delete(key)
+
+      # Check if all proxies are gone now and call the process.
+      @empty_handler[pid].call if @proxies[pid].empty?
+    end
+
+    def each_proxy(pid, &block)
+      @proxies[pid].dup.values.each(&block)
+    end
+  end
+end

data/lib/dont-stall-my-process/remote/remote_application.rb

@@ -4,18 +4,62 @@ module DontStallMyProcess
     # RemoteObject is the base 'application' class for the child process.
     # It starts the DRb service and goes to sleep.
     class RemoteApplication
-      def initialize(klass, opts, pipe)
+      def self.update_process_name(klass_name = '<pool>')
+        if Configuration.subprocess_name
+          $0 = Configuration.subprocess_name % { klass: klass_name.to_s }
+        end
+      end
+
+      def initialize(pipe)
+        # Do not write to stdout/stderr unless requested by the client.
+        if Configuration.close_stdio
+          $stdout.reopen('/dev/null', 'w')
+          $stderr.reopen('/dev/null', 'w')
+        end
+
+        # Reset signal handlers if requested by client.
+        if Configuration.restore_all_traps
+          # Plenty of signals are not trappable, simply ignore this here.
+          Signal.list.keys.each { |sig| Signal.trap(sig, 'DEFAULT') rescue nil }
+        end
+
+        if Configuration.skip_at_exit_handlers
+          # Clearing the Ruby end proc list is not possible without modifying
+          # Ruby itself, see eval_jump.c in current Ruby sources. However,
+          # as these handlers get executed in reverse order, simply calling
+          # exit! here is enough.
+          at_exit { exit! }
+        end
+
+        # Call the after_block_handler early, before DRb setup (i.e. before anything
+        # can go wrong).
+        Configuration.after_fork_handler.call
+
+        # Initially display the process name without a class name (-> '<pool>').
+        RemoteApplication.update_process_name
+
+        RemoteProxy.setup_proxy_registry(Process.pid) do
+          # This block is called when all RemoteProxies have closed there
+          # DRb servers. We're now idling again, waiting for new jobs in the
+          # pool *or* are going to be be terminated in a second.
+
+          # Update process name again to indicate availability.
+          RemoteApplication.update_process_name
+        end
+
+        # Start our controller class, expose via DRb.
+        @controller = RemoteApplicationController.new(self)
+
+        # Everything went fine, set up the main process synchronization now.
         @m = Mutex.new
         @c = ConditionVariable.new
 
-        # Start the main DRb service.
-        proxy = MainRemoteProxy.new(self, klass, opts)
-
         # Tell our parent that setup is done and the new main DRb URI.
-        pipe.write(Marshal.dump(proxy.uri))
+        Marshal.dump(@controller.uri, pipe)
       rescue => e
         # Something went wrong, also tell our parent.
-        pipe.write(Marshal.dump(e))
+        Marshal.dump(e, pipe)
+        raise
       ensure
         pipe.close
       end
@@ -25,17 +69,17 @@ module DontStallMyProcess
         @m.synchronize do
           @c.wait(@m)
         end
+
+        # Remote application end.
+        exit 0
+      rescue SystemExit, Interrupt
+        raise
       end
 
       def stop!
-        Thread.new do
-          # Wait for DRb answer package to be sent.
-          sleep 0.2
-
-          # End main thread -> exit.
-          @m.synchronize do
-            @c.signal
-          end
+        # End main thread -> exit.
+        @m.synchronize do
+          @c.signal
         end
       end
     end

data/lib/dont-stall-my-process/remote/remote_application_controller.rb

@@ -0,0 +1,55 @@
+require 'fileutils'
+require 'drb'
+
+module DontStallMyProcess
+  module Remote
+    class RemoteApplicationController
+      attr_reader :uri
+
+      def initialize(application)
+        @applicarion = application
+
+        @uri         = "drbunix:///tmp/dsmp-#{Process.ppid}-controller-#{Process.pid}"
+        @server      = DRb.start_service(uri, self)
+      end
+
+      def start_service(klass, opts)
+        # Instantiate the main class now to get early failures.
+        instance = klass.new
+
+        # Start the main DRb service.
+        @proxy = RemoteProxy.new(opts, instance)
+
+        # Set subprocess name if requested.
+        RemoteApplication.update_process_name(klass.name.to_s)
+
+        # Return the DRb URI.
+        @proxy.uri
+      end
+
+      def stop_application
+        # Kill remaining DRb servers, shouldn't be any at this point.
+        RemoteProxy.each_proxy { |proxy| __destroy.destroy }
+
+        Thread.new do
+          # Wait for DRb answer package to be sent.
+          sleep 0.2
+
+          # Kill our own DRb server.
+          @server.stop_service
+          FileUtils.rm_f(@uri)
+
+          # Let DRb resolve its pthread mutexes and stuff.
+          sleep 0.2
+
+          # Wake up the main application thread.
+          @application.stop!
+        end
+      end
+
+      def alive?
+        true
+      end
+    end
+  end
+end

data/lib/dont-stall-my-process/remote/remote_proxy.rb

@@ -1,3 +1,4 @@
+require 'fileutils'
 require 'drb'
 require 'securerandom'
 
@@ -9,15 +10,24 @@ module DontStallMyProcess
     # instance of the 'real' class. Furthermore, it takes care of creating
     # nested DRb services as requested in the option hash.
     class RemoteProxy
+      class << self
+        include DontStallMyProcess::ProxyRegistry
+      end
+
       attr_reader :uri
 
-      def initialize(opts, instance)
+      def initialize(opts, instance, parent = nil)
         @opts     = opts
         @object   = instance
-        @children = {}
 
-        @uri      = "drbunix:///tmp/dsmp-#{SecureRandom.hex(8)}"
-        DRb.start_service(uri, self)
+        @uri      = "drbunix:///tmp/dsmp-#{Process.ppid}-#{SecureRandom.hex(8)}"
+        @server   = DRb.start_service(@uri, self)
+
+        RemoteProxy.register(Process.pid, @uri, self)
+      end
+
+      def __local_proxy_destroyed
+        __destroy
       end
 
       def respond_to?(m, ia = false)
@@ -39,37 +49,18 @@ module DontStallMyProcess
     private
 
       def __create_nested_proxy(meth, *args, &block)
-        # Create a new DRb proxy if needed, and save its URI.
-        unless @children[meth]
-          # Call the object method now, save the returned object.
-          instance = @object.public_send(meth, *args, &block)
+        instance = @object.public_send(meth, *args, &block)
 
-          # Start the proxy, convert the object 0into a DRb service.
-          @children[meth] = RemoteProxy.new(@opts[:methods][meth], instance).uri
-        end
-
-        # Return the DRb URI.
-        @children[meth]
+        # Start the proxy, convert the object into a DRb service.
+        RemoteProxy.new(@opts[:methods][meth], instance, self).uri
       end
-    end
 
-    # The MainRemoteProxy is the first DRb object to be created in
-    # the child process. In addition to the real class' methods it
-    # provides a 'stop!' method that brings down the child process
-    # gracefully.
-    class MainRemoteProxy < RemoteProxy
-      def initialize(mother, klass, opts)
-        @mother = mother
+      def __destroy
+        @server.stop_service
+        FileUtils.rm_f(@uri)
 
-        # Instantiate the main class now, initialize the base class with
-        # the new instance, create the DRb service.
-        super(opts, klass.new)
-      end
-
-      def stop!
-        @mother.stop!
+        RemoteProxy.unregister(Process.pid, @uri)
       end
     end
-
   end
 end

data/lib/dont-stall-my-process/version.rb

@@ -1,3 +1,3 @@
 module DontStallMyProcess
-  VERSION = '0.0.1'
+  VERSION = '0.1.1'
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: dont-stall-my-process
 version: !ruby/object:Gem::Version
-  version: 0.0.1
+  version: 0.1.1
 platform: ruby
 authors:
 - FlavourSys Technology GmbH
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-09-05 00:00:00.000000000 Z
+date: 2014-09-08 00:00:00.000000000 Z
 dependencies: []
 description: Executes code or native extensions in child processes and monitors their
   execution times
@@ -18,9 +18,15 @@ extensions: []
 extra_rdoc_files: []
 files:
 - lib/dont-stall-my-process.rb
+- lib/dont-stall-my-process/configuration.rb
+- lib/dont-stall-my-process/exceptions.rb
 - lib/dont-stall-my-process/local/child_process.rb
+- lib/dont-stall-my-process/local/child_process_pool.rb
 - lib/dont-stall-my-process/local/local_proxy.rb
+- lib/dont-stall-my-process/local/process_exit_handler.rb
+- lib/dont-stall-my-process/proxy_registry.rb
 - lib/dont-stall-my-process/remote/remote_application.rb
+- lib/dont-stall-my-process/remote/remote_application_controller.rb
 - lib/dont-stall-my-process/remote/remote_proxy.rb
 - lib/dont-stall-my-process/version.rb
 homepage: http://github.com/flavoursys/dont-stall-my-process