RubyProcess 0.0.12

data/lib/ruby_process/class_proxy.rb

@@ -0,0 +1,106 @@
+#This class is used to seamlessly use leaky classes without working through 'RubyProcess'.
+#===Examples
+#  RubyProcess::ClassProxy.run do |data|
+#    data[:subproc].static(:Object, :require, "rubygems")
+#    data[:subproc].static(:Object, :require, "rexml/document")
+#
+#    doc = RubyProcess::ClassProxy::REXML::Document.new("test")
+#    strio = StringIO.new
+#    doc.write(strio)
+#    puts strio.string #=> "<test/>"
+#    raise "REXML shouldnt be defined?" if Kernel.const_defined?(:REXML)
+class RubyProcess::ClassProxy
+  #Lock is used to to create new Ruby-process-instances and not doing double-counts.
+  @@lock = Mutex.new
+
+  #Counts how many instances are using the Cproxy-module. This way it can be safely unset once no-body is using it again.
+  @@instances = 0
+
+  #This variable will hold the 'RubyProcess'-object where sub-objects will be created.
+  @@subproc = nil
+
+  #All use should go through this method to automatically destroy sub-processes and keep track of ressources.
+  def self.run
+    #Increase count of instances that are using Cproxy and set the subproc-object if not already set.
+    @@lock.synchronize do
+      #Check if the sub-process is alive.
+      if @@subproc && (!@@subproc.alive? || @@subproc.destroyed?)
+        raise "Cant destroy sub-process because instances are running: '#{@@instances}'." if @@instances > 0
+        @@subproc.destroy
+        @@subproc = nil
+      end
+
+      #Start a new subprocess if none is defined and active.
+      unless @@subproc
+        subproc = RubyProcess.new(title: "ruby_process_cproxy", debug: false)
+        subproc.spawn_process
+        @@subproc = subproc
+      end
+
+      @@instances += 1
+    end
+
+    begin
+      yield(subproc: @@subproc)
+      raise "'run'-caller destroyed sub-process. This shouldn't happen." if @@subproc.destroyed?
+    ensure
+      @@lock.synchronize do
+        @@instances -= 1
+
+        if @@instances <= 0
+          begin
+            @@subproc.destroy
+          ensure
+            @@subproc = nil
+            self.destroy_loaded_constants
+          end
+        end
+      end
+    end
+  end
+
+  #Returns the 'RubyProcess'-object or raises an error if it has not been set.
+  def self.subproc
+    raise "CProxy process not set for some reason?" unless @@subproc
+    return @@subproc
+  end
+
+  #Destroy all loaded sub-process-constants.
+  def self.destroy_loaded_constants
+    self.constants.each do |constant|
+      self.__send__(:remove_const, constant)
+    end
+  end
+
+  #Creates the new constant under the 'RubyProcess::ClassProxy'-namespace.
+  def self.const_missing(name)
+    RubyProcess::ClassProxy.load_class(self, name) unless const_defined?(name)
+    raise "Still not created on const: '#{name}'." unless const_defined?(name)
+    return self.const_get(name)
+  end
+
+  #Loads a new class to the given constants namespace for recursive creating of missing classes.
+  def self.load_class(const, name)
+    const.const_set(name, Class.new{
+      #Use 'const_missing' to auto-create missing sub-constants recursivly.
+      def self.const_missing(name)
+        RubyProcess::ClassProxy.load_class(self, name) unless const_defined?(name)
+        raise "Still not created on const: '#{name}'." unless self.const_defined?(name)
+        return self.const_get(name)
+      end
+
+      #Manipulate 'new'-method return proxy-objects instead of real objects.
+      def self.new(*args, &blk)
+        name_match = self.name.to_s.match(/^RubyProcess::ClassProxy::(.+)$/)
+        class_name = name_match[1]
+        return RubyProcess::ClassProxy.subproc.new(class_name, *args, &blk)
+      end
+
+      def self.method_missing(method_name, *args, &blk)
+        name_match = self.name.to_s.match(/^RubyProcess::ClassProxy::(.+)$/)
+        class_name = name_match[1]
+        return RubyProcess::ClassProxy.subproc.static(class_name, method_name, *args, &blk)
+      end
+    })
+  end
+end

data/lib/ruby_process/proxy_object.rb

@@ -0,0 +1,55 @@
+#This class handels the calling of methods on objects in the other process seamlessly.
+class RubyProcess::ProxyObject
+  #Hash that contains various information about the proxyobj.
+  attr_reader :__rp_rp, :__rp_id, :__rp_pid
+
+  #Constructor. This should not be called manually but through a running 'RubyProcess'.
+  #===Examples
+  # proxy_obj = rp.new(:String, "Kasper") #=> <RubyProcess::ProxyObject>
+  # proxy_obj = rp.static(:File, :open, "/tmp/somefile") #=> <RubyProcess::ProxyObject>
+  def initialize(rp, id, pid)
+    @__rp_rp, @__rp_id, @__rp_pid = rp, id, pid
+  end
+
+  #Returns the object as the real object transfered by using the marshal-lib.
+  #===Examples
+  # str = rp.new(:String, "Kasper") #=> <RubyProcess::ProxyObject>
+  # str.__rp_marshal #=> "Kasper"
+  def __rp_marshal
+    return Marshal.load(@__rp_rp.send(cmd: :obj_marshal, id: @__rp_id))
+  end
+
+  #Unsets all data on the object.
+  def __rp_destroy
+    @__rp_id = nil, @__rp_rp = nil, @__rp_pid = nil
+  end
+
+  #Overwrite certain convert methods.
+  RUBY_METHODS = [:to_i, :to_s, :to_str, :to_f]
+  RUBY_METHODS.each do |method_name|
+    define_method(method_name) do |*args, &blk|
+      return @__rp_rp.send(cmd: :obj_method, id: @__rp_id, method: method_name, args: args, &blk).__rp_marshal
+    end
+  end
+
+  #Overwrite certain methods.
+  PROXY_METHODS = [:send]
+  PROXY_METHODS.each do |method_name|
+    define_method(method_name) do |*args, &blk|
+      self.method_missing(method_name, *args, &blk)
+    end
+  end
+
+  #Proxies all calls to the process-object.
+  #===Examples
+  # str = rp.new(:String, "Kasper") #=> <RubyProcess::ProxyObject::1>
+  # length_int = str.length #=> <RubyProcess::ProxyObject::2>
+  # length_int.__rp_marshal #=> 6
+  def method_missing(method, *args, &block)
+    debug "Method-missing-args-before: #{args} (#{@__rp_pid})\n" if @debug
+    real_args = @__rp_rp.parse_args(args)
+    debug "Method-missing-args-after: #{real_args}\n" if @debug
+
+    return @__rp_rp.send(cmd: :obj_method, id: @__rp_id, method: method, args: real_args, &block)
+  end
+end

data/ruby_process.gemspec

@@ -0,0 +1,85 @@
+# Generated by jeweler
+# DO NOT EDIT THIS FILE DIRECTLY
+# Instead, edit Jeweler::Tasks in Rakefile, and run 'rake gemspec'
+# -*- encoding: utf-8 -*-
+# stub: ruby_process 0.0.10 ruby lib
+
+Gem::Specification.new do |s|
+  s.name = "ruby_process"
+  s.version = "0.0.10"
+
+  s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
+  s.require_paths = ["lib"]
+  s.authors = ["Kasper Johansen"]
+  s.date = "2015-04-06"
+  s.description = "A framework for spawning and communicating with other Ruby-processes"
+  s.email = "k@spernj.org"
+  s.extra_rdoc_files = [
+    "LICENSE.txt",
+    "README.md"
+  ]
+  s.files = [
+    ".document",
+    ".rspec",
+    "Gemfile",
+    "LICENSE.txt",
+    "README.md",
+    "Rakefile",
+    "VERSION",
+    "cmds/blocks.rb",
+    "cmds/marshal.rb",
+    "cmds/new.rb",
+    "cmds/numeric.rb",
+    "cmds/static.rb",
+    "cmds/str_eval.rb",
+    "cmds/system.rb",
+    "examples/example_csv.rb",
+    "examples/example_file_write.rb",
+    "examples/example_knj_db_dump.rb",
+    "examples/example_strscan.rb",
+    "include/args_handeling.rb",
+    "lib/ruby_process.rb",
+    "lib/ruby_process_cproxy.rb",
+    "lib/ruby_process_proxyobj.rb",
+    "ruby_process.gemspec",
+    "scripts/ruby_process_script.rb",
+    "shippable.yml",
+    "spec/cproxy_spec.rb",
+    "spec/hard_load_spec.rb",
+    "spec/leaks_spec.rb",
+    "spec/RubyProcess_spec.rb",
+    "spec/spec_helper.rb"
+  ]
+  s.homepage = "http://github.com/kaspernj/ruby_process"
+  s.licenses = ["MIT"]
+  s.rubygems_version = "2.4.0"
+  s.summary = "A framework for spawning and communicating with other Ruby-processes"
+
+  if s.respond_to? :specification_version then
+    s.specification_version = 4
+
+    if Gem::Version.new(Gem::VERSION) >= Gem::Version.new('1.2.0') then
+      s.add_runtime_dependency(%q<wref>, [">= 0"])
+      s.add_runtime_dependency(%q<tsafe>, [">= 0"])
+      s.add_development_dependency(%q<rspec>, ["~> 2.8.0"])
+      s.add_development_dependency(%q<rdoc>, ["~> 3.12"])
+      s.add_development_dependency(%q<bundler>, [">= 1.0.0"])
+      s.add_development_dependency(%q<jeweler>, ["~> 1.8.3"])
+    else
+      s.add_dependency(%q<wref>, [">= 0"])
+      s.add_dependency(%q<tsafe>, [">= 0"])
+      s.add_dependency(%q<rspec>, ["~> 2.8.0"])
+      s.add_dependency(%q<rdoc>, ["~> 3.12"])
+      s.add_dependency(%q<bundler>, [">= 1.0.0"])
+      s.add_dependency(%q<jeweler>, ["~> 1.8.3"])
+    end
+  else
+    s.add_dependency(%q<wref>, [">= 0"])
+    s.add_dependency(%q<tsafe>, [">= 0"])
+    s.add_dependency(%q<rspec>, ["~> 2.8.0"])
+    s.add_dependency(%q<rdoc>, ["~> 3.12"])
+    s.add_dependency(%q<bundler>, [">= 1.0.0"])
+    s.add_dependency(%q<jeweler>, ["~> 1.8.3"])
+  end
+end
+

data/scripts/ruby_process_script.rb

@@ -0,0 +1,37 @@
+#!/usr/bin/env ruby1.9
+
+require "base64"
+require "#{File.dirname(__FILE__)}/../lib/ruby_process.rb"
+
+$stdin.sync = true
+$stdout.sync = true
+$stderr.sync = true
+
+debug = false
+pid = nil
+
+ARGV.each do |arg|
+  if arg == "--debug"
+    debug = true
+  elsif match = arg.match(/--pid=(\d+)$/)
+    pid = match[1].to_i
+  elsif match = arg.match(/--title=(.+)$/)
+    #ignore - its for finding process via 'ps aux'.
+  else
+    raise "Unknown argument: '#{arg}'."
+  end
+end
+
+debug = true if ARGV.index("--debug") != nil
+raise "No PID given of parent process." if !pid
+
+rps = RubyProcess.new(
+  in: $stdin,
+  out: $stdout,
+  err: $stderr,
+  debug: debug,
+  pid: pid
+)
+rps.listen
+$stdout.puts("ruby_process_started")
+rps.join

data/shippable.yml

@@ -0,0 +1,7 @@
+language: ruby
+rvm:
+  - 2.1.2
+script:
+  - CODECLIMATE_REPO_TOKEN=32061319cc6d2e0bd0d0eb88afdc6d7b68829b357ca76efb99f86d7a1a89539e bundle exec rspec
+notifications:
+  email: false

data/spec/class_proxy_spec.rb

@@ -0,0 +1,95 @@
+require "spec_helper"
+
+describe "RubyProcess" do
+  it "should be able to do quick in-and-outs without leaking" do
+    ts = []
+
+    1.upto(2) do |tcount|
+      ts << Thread.new do
+        1.upto(10) do
+          RubyProcess::ClassProxy.run do |data|
+            sp = data[:subproc]
+            str = sp.new(:String, "Wee")
+            str.__rp_marshal.should eq "Wee"
+          end
+        end
+      end
+    end
+
+    ts.each do |thread|
+      thread.join
+    end
+  end
+
+  it "should be able to do basic stuff" do
+    require "stringio"
+
+    RubyProcess::ClassProxy.run do |data|
+      data[:subproc].static(:Object, :require, "rubygems")
+      data[:subproc].static(:Object, :require, "rexml/document")
+
+      doc = RubyProcess::ClassProxy::REXML::Document.new
+      doc.add_element("test")
+
+      strio = StringIO.new
+      doc.write(strio)
+
+      Kernel.const_defined?(:REXML).should eq false
+      strio.string.should eq "<test/>"
+    end
+  end
+
+  it "should be able to do multiple calls at once" do
+    ts = []
+
+    0.upto(9) do |tcount|
+      ts << Thread.new do
+        RubyProcess::ClassProxy.run do |data|
+          sp = data[:subproc]
+          sp.new(:String, "Wee")
+
+          1.upto(250) do
+            str = sp.new(:String, "Kasper Johansen")
+
+            str.__rp_marshal.should include "Kasper"
+            str << " More"
+
+            str.__rp_marshal.should include "Johansen"
+            str << " Even more"
+
+            str.__rp_marshal.should_not include "Christina"
+            str << " Much more"
+          end
+        end
+      end
+    end
+
+    count = 0
+    ts.each do |t|
+      count += 1
+      #puts "Thread #{count}"
+      t.join
+    end
+  end
+
+  it "should not leak" do
+    str = "kasper"
+    str = nil
+    sleep 0.1
+    GC.start
+    sleep 0.1
+
+    count_objs = 0
+    ObjectSpace.each_object(RubyProcess) do |obj|
+      count_objs += 1
+    end
+
+    count_proxy_objs = 0
+    ObjectSpace.each_object(RubyProcess::ProxyObject) do |obj|
+      count_proxy_objs += 1
+    end
+
+    count_objs.should be <= 1
+    RubyProcess::ClassProxy.constants.empty?.should eq true
+  end
+end

data/spec/hard_load_spec.rb

@@ -0,0 +1,35 @@
+require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
+
+describe "RubyProcess" do
+  it "should be able to do basic stuff" do
+    RubyProcess::ClassProxy.run do |data|
+      sp = data[:subproc]
+      sp.new(:String, "Wee")
+
+      ts = []
+
+      1.upto(50) do |tcount|
+        ts << Thread.new do
+          1.upto(250) do
+            str = sp.new(:String, "Kasper Johansen")
+
+            str.__rp_marshal.should eq "Kasper Johansen"
+            str << " More"
+
+            str.__rp_marshal.should include "Johansen"
+            str << " Even more"
+
+            str.__rp_marshal.should_not include "Christina"
+            str << " Much more"
+
+            str.__rp_marshal.should eq "Kasper Johansen More Even more Much more"
+          end
+        end
+      end
+
+      ts.each do |t|
+        t.join
+      end
+    end
+  end
+end

data/spec/leaks_spec.rb

@@ -0,0 +1,24 @@
+require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
+
+describe "RubyProcess" do
+  it "should be able to clean up after itself when timeout" do
+    require "timeout"
+
+    RubyProcess::ClassProxy.run do |data|
+      sp = data[:subproc]
+
+      begin
+        Timeout.timeout(1) do
+          sp.static(:Object, :sleep, 2)
+        end
+
+        raise "Expected timeout to be raised."
+      rescue Timeout::Error
+        #ignore.
+      end
+
+      answers = sp.instance_variable_get(:@answers)
+      answers.should be_empty
+    end
+  end
+end