dont-stall-my-process 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: bba5b99c3f45cf21b973302a4b9d43711045d8e0
+  data.tar.gz: b5754b5ebf28641cb7968a6a117e17c6fbf6f43e
+SHA512:
+  metadata.gz: d3c8179f80acb4dbbb5a84311d18fa0625dd4a5980cfe4692d74c32cba4555b68de05d12caec8879f4b239f936185b7e6e864b49ee25d0dfc753b026b0f45e65
+  data.tar.gz: 5b56b6b4699377beebcd92479930b31390897976b46763f8d6f222032ece2404e05cc32cda0be096fe28ba9425155ea9ae19ac3630ac6471e4c89440a44dfb68

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

@@ -0,0 +1,48 @@
+require 'dont-stall-my-process/local/child_process'
+require 'dont-stall-my-process/local/local_proxy'
+require 'dont-stall-my-process/remote/remote_application'
+require 'dont-stall-my-process/remote/remote_proxy'
+require 'dont-stall-my-process/version'
+
+module DontStallMyProcess
+  DEFAULT_TIMEOUT = 300
+
+  def self.create(klass, opts = {}, sigkill_only = false)
+    fail 'no klass given' unless klass && klass.is_a?(Class)
+
+    # Set default values and validate configuration.
+    opts = sanitize_options(opts)
+
+    # Fork the child process.
+    p = Local::ChildProcess.new(klass, opts)
+
+    # Return the main proxy class.
+    Local::MainLocalProxy.new(p, opts, sigkill_only)
+  end
+
+  def self.sanitize_options(opts, default_timeout = DEFAULT_TIMEOUT)
+    fail 'opts is not a hash' unless opts.is_a?(Hash)
+
+    opts[:timeout] ||= default_timeout
+    opts[:methods] ||= {}
+
+    fail 'no timeout given' unless opts[:timeout] && opts[:timeout].is_a?(Fixnum)
+    fail 'timeout too low' unless opts[:timeout] > 0
+    fail 'methods is not a hash' if opts[:methods] && !opts[:methods].is_a?(Hash)
+
+    {
+      timeout: opts[:timeout],
+      methods: Hash[
+        opts[:methods].map { |meth, mopts| [meth, sanitize_options(mopts, opts[:timeout])] }
+      ]
+    }
+  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/local/child_process.rb

@@ -0,0 +1,53 @@
+module DontStallMyProcess
+  module Local
+
+    # The ChildProcess class encapsulates the forked subprocess that
+    # provides the DRb service object.
+    class ChildProcess
+      attr_reader :main_uri
+
+      def initialize(klass, opts)
+        # 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!
+        end
+        w.close
+
+        # Wait for the RemoteApplication to finish its setup.
+        @main_uri = Marshal.load(r.gets)
+        r.close
+
+        # RemoteApplication sends us the DRb URI or an Exception.
+        raise @main_uri if @main_uri.is_a?(Exception)
+      end
+
+      def term
+        # Exceptions in these methods almost always mean the process is already dead.
+        Process.kill('TERM', @pid) rescue nil
+      end
+
+      def detach
+        Process.detach(@pid) rescue nil
+      end
+
+      def kill
+        Process.kill('KILL', @pid) rescue nil
+      end
+
+      def wait
+        Process.wait(@pid) rescue nil
+      end
+
+      def alive?
+        # 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?
+      end
+    end
+
+  end
+end

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

@@ -0,0 +1,113 @@
+require 'drb'
+require 'timeout'
+
+module DontStallMyProcess
+  module Local
+
+    # LocalProxy connects to an instance of a class on a child process
+    # and watches the execution of remote procedure calls.
+    class LocalProxy
+      def initialize(uri, process, opts, sigkill_only)
+        @process      = process
+        @opts         = opts
+        @sigkill_only = sigkill_only
+
+        # Get a DRb reference to the remote class.
+        @object  = DRbObject.new_with_uri(uri)
+      end
+
+      def respond_to?(m, ia = false)
+        @opts[:methods].keys.include?(m) || @object.respond_to?(m, ia) || super(m, ia)
+      end
+
+      def method_missing(meth, *args, &block)
+        case
+        when Kernel.public_methods(false).include?(meth)
+          fail KernelMethodCalled, "Method '#{meth}' called. This would run the method that was privately inherited " +
+            'from the \'Kernel\' module on the local proxy, which is most certainly not what you want. Kernel methods ' +
+            'are not supported at the moment. Please consider adding an alias to your function.'
+        when @opts[:methods].keys.include?(meth)
+          __create_nested_proxy(meth, *args, &block)
+        when @object.respond_to?(meth)
+          __delegate_with_timeout(meth, *args, &block)
+        else
+          super
+        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)
+      end
+
+      def __delegate_with_timeout(meth, *args, &block)
+        __timed(meth) do
+          @object.public_send(meth, *args, &block)
+        end
+      end
+
+      def __timed(meth)
+        Timeout.timeout(@opts[:timeout]) do
+          yield
+        end
+      rescue Timeout::Error
+        __kill_child_process!
+        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 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) }
+      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)
+
+        # 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))
+      end
+    end
+  end
+end

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

@@ -0,0 +1,44 @@
+module DontStallMyProcess
+  module Remote
+
+    # 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)
+        @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))
+      rescue => e
+        # Something went wrong, also tell our parent.
+        pipe.write(Marshal.dump(e))
+      ensure
+        pipe.close
+      end
+
+      def loop!
+        # Sleep to keep the DRb service running, until woken up.
+        @m.synchronize do
+          @c.wait(@m)
+        end
+      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
+      end
+    end
+
+  end
+end

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

@@ -0,0 +1,75 @@
+require 'drb'
+require 'securerandom'
+
+module DontStallMyProcess
+  module Remote
+
+    # RemoteProxy is an decorator class for any of the 'real' classes
+    # to be served via DRb. It delegates method calls to the encapsulated
+    # instance of the 'real' class. Furthermore, it takes care of creating
+    # nested DRb services as requested in the option hash.
+    class RemoteProxy
+      attr_reader :uri
+
+      def initialize(opts, instance)
+        @opts     = opts
+        @object   = instance
+        @children = {}
+
+        @uri      = "drbunix:///tmp/dsmp-#{SecureRandom.hex(8)}"
+        DRb.start_service(uri, self)
+      end
+
+      def respond_to?(m, ia = false)
+        @opts[:methods].keys.include?(m) || @object.respond_to?(m, ia) || super(m, ia)
+      end
+
+      def method_missing(meth, *args, &block)
+        case
+        when (mopts = @opts[:methods][meth])
+          __create_nested_proxy(meth, *args, &block)
+        when @object.respond_to?(meth)
+          # Delegate the method call to the real object.
+          @object.public_send(meth, *args, &block)
+        else
+          super
+        end
+      end
+
+    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)
+
+          # 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]
+      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
+
+        # 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!
+      end
+    end
+
+  end
+end

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

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

metadata

@@ -0,0 +1,50 @@
+--- !ruby/object:Gem::Specification
+name: dont-stall-my-process
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- FlavourSys Technology GmbH
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2014-09-05 00:00:00.000000000 Z
+dependencies: []
+description: Executes code or native extensions in child processes and monitors their
+  execution times
+email: technology@flavoursys.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/dont-stall-my-process.rb
+- lib/dont-stall-my-process/local/child_process.rb
+- lib/dont-stall-my-process/local/local_proxy.rb
+- lib/dont-stall-my-process/remote/remote_application.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
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.2.2
+signing_key: 
+specification_version: 4
+summary: Fork/Watchdog jail your Ruby code and native extensions
+test_files: []