ruby_process 0.0.4

data/.document

@@ -0,0 +1,5 @@
+lib/**/*.rb
+bin/*
+- 
+features/**/*.feature
+LICENSE.txt

data/.rspec

@@ -0,0 +1 @@
+--color

data/Gemfile

@@ -0,0 +1,17 @@
+source "http://rubygems.org"
+# Add dependencies required to use your gem here.
+# Example:
+#   gem "activesupport", ">= 2.3.5"
+
+gem "wref"
+gem "tsafe"
+
+# Add dependencies to develop your gem here.
+# Include everything needed to run rake, tests, features, etc.
+group :development do
+  gem "rspec", "~> 2.8.0"
+  gem "rdoc", "~> 3.12"
+  gem "bundler", ">= 1.0.0"
+  gem "jeweler", "~> 1.8.3"
+  gem "rcov", ">= 0"
+end

data/LICENSE.txt

@@ -0,0 +1,20 @@
+Copyright (c) 2012 Kasper Johansen
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.rdoc

@@ -0,0 +1,19 @@
+= ruby_process
+
+Description goes here.
+
+== Contributing to ruby_process
+ 
+* Check out the latest master to make sure the feature hasn't been implemented or the bug hasn't been fixed yet.
+* Check out the issue tracker to make sure someone already hasn't requested it and/or contributed it.
+* Fork the project.
+* Start a feature/bugfix branch.
+* Commit and push until you are happy with your contribution.
+* Make sure to add tests for it. This is important so I don't break it in a future version unintentionally.
+* Please try not to mess with the Rakefile, version, or history. If you want to have your own version, or is otherwise necessary, that is fine, but please isolate to its own commit so I can cherry-pick around it.
+
+== Copyright
+
+Copyright (c) 2012 Kasper Johansen. See LICENSE.txt for
+further details.
+

data/Rakefile

@@ -0,0 +1,49 @@
+# encoding: utf-8
+
+require 'rubygems'
+require 'bundler'
+begin
+  Bundler.setup(:default, :development)
+rescue Bundler::BundlerError => e
+  $stderr.puts e.message
+  $stderr.puts "Run `bundle install` to install missing gems"
+  exit e.status_code
+end
+require 'rake'
+
+require 'jeweler'
+Jeweler::Tasks.new do |gem|
+  # gem is a Gem::Specification... see http://docs.rubygems.org/read/chapter/20 for more options
+  gem.name = "ruby_process"
+  gem.homepage = "http://github.com/kaspernj/ruby_process"
+  gem.license = "MIT"
+  gem.summary = %Q{A framework for spawning and communicating with other Ruby-processes}
+  gem.description = %Q{A framework for spawning and communicating with other Ruby-processes}
+  gem.email = "k@spernj.org"
+  gem.authors = ["Kasper Johansen"]
+  # dependencies defined in Gemfile
+end
+Jeweler::RubygemsDotOrgTasks.new
+
+require 'rspec/core'
+require 'rspec/core/rake_task'
+RSpec::Core::RakeTask.new(:spec) do |spec|
+  spec.pattern = FileList['spec/**/*_spec.rb']
+end
+
+RSpec::Core::RakeTask.new(:rcov) do |spec|
+  spec.pattern = 'spec/**/*_spec.rb'
+  spec.rcov = true
+end
+
+task :default => :spec
+
+require 'rdoc/task'
+Rake::RDocTask.new do |rdoc|
+  version = File.exist?('VERSION') ? File.read('VERSION') : ""
+
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title = "ruby_process #{version}"
+  rdoc.rdoc_files.include('README*')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end

data/VERSION

@@ -0,0 +1 @@
+0.0.4

data/cmds/blocks.rb

@@ -0,0 +1,55 @@
+class Ruby_process
+  #Calls a block by its block-ID with given arguments.
+  def cmd_block_call(obj)
+    raise "Invalid block-ID: '#{obj}'." if obj[:block_id].to_i <= 0
+    block_ele = @objects[obj[:block_id]]
+    raise "No block by that ID: '#{obj[:block_id]}'." if !block_ele
+    raise "Not a block? '#{block_ele.class.name}'." if !block_ele.respond_to?(:call)
+    debug "Calling block #{obj[:block_id]}: #{obj}\n" if @debug
+    block_ele.call(*read_args(obj[:args]))
+    return nil
+  end
+  
+  #Spawns a block and returns its ID.
+  def cmd_spawn_proxy_block(obj)
+    block = proc{
+      send(:cmd => :block_call, :block_id => obj[:id])
+    }
+    
+    id = block.__id__
+    raise "ID already exists: '#{id}'." if @objects.key?(id)
+    @objects[id] = block
+    
+    return {:id => id}
+  end
+  
+  #Dynamically creates a block with a certain arity. If sub-methods measure arity, they will get the correct one from the other process.
+  def block_with_arity(args, &block)
+    eval_str = "proc{"
+    eval_argsarr = "\t\tblock.call("
+    
+    if args[:arity] > 0
+      eval_str << "|"
+      1.upto(args[:arity]) do |i|
+        if i > 1
+          eval_str << ","
+          eval_argsarr << ","
+        end
+        
+        eval_str << "arg#{i}"
+        eval_argsarr << "arg#{i}"
+      end
+      
+      eval_str << "|\n"
+      eval_argsarr << ")\n"
+    end
+    
+    eval_full = eval_str + eval_argsarr
+    eval_full << "}"
+    
+    debug "Block eval: #{eval_full}\n" if @debug
+    dynamic_proc = eval(eval_full)
+    
+    return dynamic_proc
+  end
+end

data/cmds/marshal.rb

@@ -0,0 +1,8 @@
+class Ruby_process
+  #This command returns an object as a marshalled string, so it can be re-created on the other side.
+  def cmd_obj_marshal(obj)
+    myobj = @objects[obj[:id]]
+    raise "Object by that ID does not exist: '#{obj[:id]}'." if !myobj
+    return Marshal.dump(myobj)
+  end
+end

data/cmds/new.rb

@@ -0,0 +1,44 @@
+class Ruby_process
+  #Spawns a new object in the process and returns a proxy-object for it.
+  def new(classname, *args, &block)
+    return send(:cmd => :new, :classname => classname, :args => parse_args(args), &block)
+  end
+  
+  #This command spawns a new object of a given class and returns its hash-handle, so a proxy-object can be spawned on the other side.
+  def cmd_new(obj)
+    const = obj[:classname].to_s.split("::").inject(Object, :const_get)
+    
+    debug "New-args-before: #{obj[:args]}\n" if @debug
+    real_args = read_args(obj[:args])
+    debug "New-args-after: #{real_args}\n" if @debug
+    
+    retobj = const.new(*real_args)
+    return handle_return_object(retobj)
+  end
+  
+  #Calls a method on an object.
+  def cmd_obj_method(obj)
+    myobj = @objects[obj[:id]]
+    raise "Object by that ID does not exist: '#{obj[:id]}' '(#{@objects.keys.sort.join(",")})." if !myobj
+    
+    if obj.key?(:block)
+      real_block = proc{|*args|
+        debug "Block called! #{args}\n" if @debug
+        send(:cmd => :block_call, :block_id => obj[:block][:id], :args => handle_return_args(args))
+      }
+      
+      block = block_with_arity(:arity => obj[:block][:arity], &real_block)
+      debug "Spawned fake block with arity: #{block.arity}\n" if @debug
+    else
+      block = nil
+    end
+    
+    debug "Obj-method-args-before: #{obj[:args]}\n" if @debug
+    real_args = read_args(obj[:args])
+    debug "Obj-methods-args-after: #{real_args}\n" if @debug
+    
+    debug "Calling #{myobj.class.name}.#{obj[:method]}(*#{obj[:args]}, &#{block})\n" if @debug
+    res = myobj.__send__(obj[:method], *real_args, &block)
+    return handle_return_object(res)
+  end
+end

data/cmds/numeric.rb

@@ -0,0 +1,14 @@
+class Ruby_process
+  #Returns a numeric value like a integer. This methods exists because it isnt possible to do: "Integer.new(5)".
+  #===Examples
+  # proxy_int = rp.numeric(5)
+  # proxy_int.__rp_marshal #=> 5
+  def numeric(val)
+    return send(:cmd => :numeric, :val => val)
+  end
+  
+  #Process-method for the 'numeric'-method.
+  def cmd_numeric(obj)
+    return handle_return_object(obj[:val].to_i)
+  end
+end

data/cmds/static.rb

@@ -0,0 +1,36 @@
+class Ruby_process
+  #Calls a static method on the process-side.
+  #===Examples
+  # rp.static(:File, :open, "/tmp/somefile", "w") do |fp|
+  #   fp.write("Test")
+  # end
+  def static(classname, method, *args, &block)
+    debug "Args-before: #{args} (#{@my_pid})\n" if @debug
+    real_args = parse_args(args)
+    debug "Real-args: #{real_args}\n" if @debug
+    
+    return send(:cmd => :static, :classname => classname, :method => method, :args => real_args, &block)
+  end
+  
+  #Process-method for the 'static'-method.
+  def cmd_static(obj)
+    if obj.key?(:block)
+      real_block = proc{|*args|
+        debug "Block called! #{args}\n" if @debug
+        send(:cmd => :block_call, :block_id => obj[:block][:id], :args => handle_return_args(args))
+      }
+      
+      block = block_with_arity(:arity => obj[:block][:arity], &real_block)
+    else
+      block = nil
+    end
+    
+    debug "Static-args-before: #{obj[:args]}\n" if @debug
+    real_args = read_args(obj[:args])
+    debug "Static-args-after: #{real_args}\n" if @debug
+    
+    const = obj[:classname].to_s.split("::").inject(Object, :const_get)
+    retobj = const.__send__(obj[:method], *real_args, &block)
+    return handle_return_object(retobj)
+  end
+end

data/cmds/str_eval.rb

@@ -0,0 +1,16 @@
+class Ruby_process
+  #Evalulates the given string in the process.
+  #===Examples
+  # rp.str_eval("return 10").__rp_marshal #=> 10
+  def str_eval(str)
+    send(:cmd => :str_eval, :str => str)
+  end
+  
+  #Process-method for 'str_eval'.
+  def cmd_str_eval(obj)
+    #Lamda is used here because 'return' might be used in evalled code and thereby return an unhandeled object.
+    return handle_return_object(lambda{
+      eval(obj[:str])
+    }.call)
+  end
+end

data/cmds/system.rb

@@ -0,0 +1,32 @@
+class Ruby_process
+  #Closes the process by executing exit.
+  def cmd_exit(obj)
+    exit
+  end
+  
+  #Flushes various collected object-IDs to the subprocess, where they will be garbage-collected.
+  def flush_finalized
+    @flush_mutex.synchronize do
+      debug "Ruby-process-debug: Checking finalized\n" if @debug
+      ids = @proxy_objs_unsets.shift(500)
+      debug "IDS: #{ids} #{@proxy_objs_unsets}\n" if @debug
+      return nil if ids.empty?
+      
+      debug "Ruby-process-debug: Finalizing (#{ids}).\n" if @debug
+      send(:cmd => :flush_finalized, :ids => ids)
+      @finalize_count += ids.length
+      return nil
+    end
+  end
+  
+  #Flushes references to the given object IDs.
+  def cmd_flush_finalized(obj)
+    debug "Command-flushing finalized: '#{obj[:ids]}'.\n" if @debug
+    obj[:ids].each do |id|
+      raise "Unknown ID: '#{id}' (#{id.class.name})." if !@objects.key?(id)
+      @objects.delete(id)
+    end
+    
+    return nil
+  end
+end

data/examples/example_file_write.rb

@@ -0,0 +1,15 @@
+#!/usr/bin/env ruby
+
+require "rubygems"
+require "ruby_process"
+
+fpath = "/tmp/somefile"
+Ruby_process.new.spawn_process do |rp|
+  #Opens file in subprocess.
+  rp.static(:File, :open, fpath, "w") do |fp|
+    #Writes to file in subprocess.
+    fp.write("Test!")
+  end
+end
+
+print "Content of '#{fpath}': #{File.read(fpath)}\n"

data/examples/example_knj_db_dump.rb

@@ -0,0 +1,52 @@
+#!/usr/bin/env ruby
+
+#This example shows how to dump a database using 10 processes to do so (and effectivly use 10 cores).
+
+require "rubygems"
+require "knjrbfw"
+require "ruby_process"
+
+#Holds the 'db_settings'-global-variable.
+require "#{Knj::Os.homedir}/example_knj_db_dump_settings.rb"
+
+#Create database-connection.
+db = Knj::Db.new($db_settings)
+
+#Get list of databases.
+tables = db.tables.list.values
+
+tables_per_thread = (tables.length.to_f / 10.0).ceil
+print "Tables per thread: #{tables_per_thread}\n"
+
+threads = []
+1.upto(1) do |i|
+  threads << Thread.new do
+    begin
+      thread_tables = tables.shift(tables_per_thread)
+      
+      Ruby_process.new(:debug => true).spawn_process do |rp|
+        rp.static(:Object, :require, "rubygems")
+        rp.static(:Object, :require, "knjrbfw")
+        
+        fpath = "/tmp/dbdump_#{i}.sql"
+        
+        thread_tables.each do |thread_db|
+          rp_db = rp.new("Knj::Db", $db_settings)
+          rp_dump = rp.new("Knj::Db::Dump", :db => rp_db, :tables => thread_tables)
+          
+          rp.static(:File, :open, fpath, "w") do |rp_fp|
+            print "#{i} dumping #{thread_db}\n"
+            rp_dump.dump(rp_fp)
+          end
+        end
+      end
+    rescue => e
+      puts e.inspect
+      puts e.backtrace
+    end
+  end
+end
+
+threads.each do |thread|
+  thread.join
+end

data/examples/example_strscan.rb

@@ -0,0 +1,14 @@
+#!/usr/bin/env ruby
+
+require "rubygems"
+require "ruby_process"
+
+Ruby_process.new.spawn_process do |rp|
+  #Spawns string in the subprocess.
+  str = rp.new(:String, "Kasper is 26 years old")
+  
+  #Scans with regex in subprocess, but yields proxy-objects in the current process.
+  str.scan(/is (\d+) years old/) do |match|
+    puts match.__rp_marshal
+  end
+end

data/include/args_handeling.rb

@@ -0,0 +1,86 @@
+class Ruby_process
+  #Recursivly parses arrays and hashes into proxy-object-hashes.
+  def parse_args(args)
+    if args.is_a?(Array)
+      newarr = []
+      args.each do |val|
+        newarr << parse_args(val)
+      end
+      
+      return newarr
+    elsif args.is_a?(Hash)
+      newh = {}
+      args.each do |key, val|
+        newh[parse_args(key)] = parse_args(val)
+      end
+      
+      return newh
+    elsif @args_allowed.index(args.class) != nil
+      return args
+    else
+      return handle_return_object(args)
+    end
+  end
+  
+  private
+  
+  #Returns a special hash instead of an actual object. Some objects will be returned in their normal form (true, false and nil).
+  def handle_return_object(obj, pid = @my_pid)
+    #Dont proxy these objects.
+    return obj if obj.is_a?(TrueClass) or obj.is_a?(FalseClass) or obj.is_a?(NilClass)
+    
+    #The object is a proxy-obj - just return its arguments that contains the true 'my_pid'.
+    if obj.is_a?(Ruby_process::Proxyobj)
+      debug "Returning from proxy-obj: (ID: #{obj.args[:id]}, PID: #{obj.args[:pid]}).\n" if @debug
+      return {:type => :proxy_obj, :id => obj.args[:id], :pid => obj.args[:pid]}
+    end
+    
+    #Check if object has already been spawned. If not: spawn id. Then returns hash for it.
+    id = obj.__id__
+    @objects[id] = obj if !@objects.key?(id)
+    
+    debug "Proxy-object spawned (ID: #{id}, PID: #{pid}).\n" if @debug
+    return {:type => :proxy_obj, :id => id, :pid => pid}
+  end
+  
+  #Parses an argument array to proxy-object-hashes.
+  def handle_return_args(arr)
+    newa = []
+    arr.each do |obj|
+      newa << handle_return_object(obj)
+    end
+    
+    return newa
+  end
+  
+  #Recursivly scans arrays and hashes for proxy-object-hashes and replaces them with actual proxy-objects.
+  def read_args(args)
+    if args.is_a?(Array)
+      newarr = []
+      args.each do |val|
+        newarr << read_args(val)
+      end
+      
+      return newarr
+    elsif args.is_a?(Hash) and args.length == 3 and args[:type] == :proxy_obj and args.key?(:id) and args.key?(:pid)
+      debug "Comparing PID (#{args[:pid]}, #{@my_pid}).\n" if @debug
+      
+      if args[:pid] == @my_pid
+        debug "Same!\n" if @debug
+        return proxyobj_object(args[:id])
+      else
+        debug "Not same!\n" if @debug
+        return proxyobj_get(args[:id], args[:pid])
+      end
+    elsif args.is_a?(Hash)
+      newh = {}
+      args.each do |key, val|
+        newh[read_args(key)] = read_args(val)
+      end
+      
+      return newh
+    end
+    
+    return args
+  end
+end

data/lib/ruby_process.rb

@@ -0,0 +1,394 @@
+require "rubygems"
+require "base64"
+require "wref" if !Kernel.const_defined?(:Wref)
+require "tsafe" if !Kernel.const_defined?(:Tsafe)
+
+#This class can communicate with another Ruby-process. It tries to integrate the work in the other process as seamless as possible by using proxy-objects.
+class Ruby_process
+  attr_reader :finalize_count
+  
+  #Require all the different commands.
+  dir = "#{File.dirname(__FILE__)}/../cmds"
+  Dir.foreach(dir) do |file|
+    require "#{dir}/#{file}" if file =~ /\.rb$/
+  end
+  
+  #Methods for handeling arguments and proxy-objects in arguments.
+  require "#{File.dirname(__FILE__)}/../include/args_handeling.rb"
+  
+  #Constructor.
+  #===Examples
+  # Ruby_process.new.spawn_process do |rp|
+  #   str = rp.new(:String, "Kasper")
+  # end
+  def initialize(args = {})
+    @args = args
+    @debug = @args[:debug]
+    @pid = @args[:pid]
+    
+    #These classes are allowed in call-arguments. They can be marshalled without any errors.
+    @args_allowed = [FalseClass, Fixnum, Integer, NilClass, String, Symbol, TrueClass]
+    
+    #Set IO variables if given.
+    @io_out = Tsafe::Proxy.new(:obj => @args[:out]) if @args[:out]
+    @io_in = @args[:in] if @args[:in]
+    @io_err = @args[:err] if @args[:err]
+    
+    #This hash holds answers coming from the subprocess.
+    @answers = Tsafe::MonHash.new
+    
+    #This hash holds objects that are referenced in the process.
+    @objects = Tsafe::MonHash.new
+    
+    #This weak-map holds all proxy objects.
+    @proxy_objs = Wref_map.new
+    @proxy_objs_ids = Tsafe::MonHash.new
+    @proxy_objs_unsets = Tsafe::MonArray.new
+    @flush_mutex = Mutex.new
+    @finalize_count = 0
+    
+    #Send ID is used to identify the correct answers.
+    @send_mutex = Mutex.new
+    @send_count = 0
+    
+    #The PID is used to know which process proxy-objects belongs to.
+    @my_pid = Process.pid
+  end
+  
+  #Spawns a new process in the same Ruby-inteterpeter as the current one.
+  #===Examples
+  # rp = Ruby_process.new.spawn_process
+  # rp.str_eval("return 10").__rp_marshal #=> 10
+  # rp.destroy
+  def spawn_process(args = nil)
+    #Used for printing debug-stuff.
+    @main = true
+    
+    if args and args[:exec]
+      cmd = "#{args[:exec]}"
+    else
+      cmd = "ruby"
+    end
+    
+    cmd << " \"#{File.realpath(File.dirname(__FILE__))}/../scripts/ruby_process_script.rb\" --pid=#{@my_pid}"
+    cmd << " --debug" if @args[:debug]
+    
+    #Start process and set IO variables.
+    require "open3"
+    @io_out, @io_in, @io_err = Open3.popen3(cmd)
+    @io_out = Tsafe::Proxy.new(:obj => @io_out)
+    @io_out.sync = true
+    @io_in.sync = true
+    @io_err.sync = true
+    
+    started = false
+    @io_in.each_line do |str|
+      if str == "ruby_process_started\n"
+        started = true
+        break
+      end
+      
+      debug "Ruby-process-debug from stdout before started: '#{str}'\n" if @debug
+    end
+    
+    raise "Ruby-sub-process couldnt start: '#{@io_err.read}'." if !started
+    self.listen
+    
+    #Start by getting the PID of the process.
+    begin
+      @pid = self.static(:Process, :pid).__rp_marshal
+      raise "Unexpected PID: '#{@pid}'." if !@pid.is_a?(Fixnum) and !@pid.is_a?(Integer)
+    rescue => e
+      self.destroy
+      raise e
+    end
+    
+    if block_given?
+      begin
+        yield(self)
+      ensure
+        self.destroy
+      end
+      
+      return nil
+    else
+      return self
+    end
+  end
+  
+  #Starts listening on the given IO's. It is useally not needed to call this method manually.
+  def listen
+    #Start listening for input.
+    start_listen
+    
+    #Start listening for errors.
+    start_listen_errors
+  end
+  
+  #First tries to make the sub-process exit gently. Then kills it with "TERM" and 9 afterwards to make sure its dead. If 'spawn_process' is given a block, this method is automatically ensured after the block is run.
+  def destroy
+    begin
+      send(:cmd => :exit) if alive?
+    rescue => e
+      raise e if e.message != "Process is dead." and e.message != "Not listening."
+    end
+    
+    #Make main kill it and make sure its dead...
+    begin
+      if @main and @pid
+        Process.kill("TERM", @pid)
+        Process.kill(9, @pid)
+      end
+    rescue Errno::ESRCH
+      #Process is already dead - ignore.
+    end
+  end
+  
+  #Joins the listen thread and error-thread. This is useually only called on the sub-process side, but can also be useful, if you are waiting for a delayed callback from the subprocess.
+  def join
+    debug "Joining listen-thread.\n" if @debug
+    @thr_listen.join if @thr_listen
+    raise @listen_err if @listen_err
+    
+    debug "Joining error-thread.\n" if @debug
+    @thr_err.join if @thr_join
+    raise @listen_err_err if @listen_err_err
+  end
+  
+  #Sends a command to the other process. This should not be called manually, but is used by various other parts of the framework.
+  def send(obj, &block)
+    raise "Ruby-process is dead." if !alive?
+    
+    #Parse block.
+    if block
+      block_proxy_res = self.send(:cmd => :spawn_proxy_block, :id => block.__id__)
+      raise "No block ID was returned?" if !block_proxy_res[:id]
+      raise "Invalid block-ID: '#{block_proxy_res[:id]}'." if block_proxy_res[:id].to_i <= 0
+      @proxy_objs[block_proxy_res[:id]] = block
+      @proxy_objs_ids[block.__id__] = block_proxy_res[:id]
+      @objects[block_proxy_res[:id]] = block
+      ObjectSpace.define_finalizer(block_proxy_res, self.method(:proxyobj_finalizer))
+      obj[:block] = {
+        :id => block_proxy_res[:id],
+        :arity => block.arity
+      }
+    end
+    
+    flush_finalized if obj[:cmd] != :flush_finalized
+    
+    #Sync ID stuff so they dont get mixed up.
+    id = nil
+    @send_mutex.synchronize do
+      id = @send_count
+      @send_count += 1
+    end
+    
+    debug "Sending(#{id}): #{obj}\n" if @debug
+    line = Base64.strict_encode64(Marshal.dump(
+      :id => id,
+      :type => :send,
+      :obj => obj
+    ))
+    @io_out.puts(line)
+    sleep 0.001
+    return answer_read(id)
+  end
+  
+  private
+  
+  def debug(str_full)
+    raise "Debug not enabled?" if !@debug
+    
+    str_full.each_line do |str|
+      if @main
+        $stderr.print "(M#{@my_pid}) #{str}"
+      else
+        $stderr.print "(S#{@my_pid}) #{str}"
+      end
+    end
+  end
+  
+  #Returns true if the child process is still running. Otherwise false.
+  def alive?
+    return false if !@io_out or !@io_in or @io_in.closed?
+    return true
+  end
+  
+  #Raises an error if the subprocess is no longer alive.
+  def alive_check!
+    raise "Process is dead." unless alive?
+    return nil
+  end
+  
+  #Registers an object ID as a proxy-object on the host-side.
+  def proxyobj_get(id, pid = @my_pid)
+    if proxy_obj = @proxy_objs.get!(id)
+      debug "Reuse proxy-obj (ID: #{id}, PID: #{pid}, fID: #{proxy_obj.args[:id]}, fPID: #{proxy_obj.args[:pid]})\n" if @debug
+      return proxy_obj
+    end
+    
+    @proxy_objs_unsets.delete(id)
+    proxy_obj = Ruby_process::Proxyobj.new(:rp => self, :id => id, :pid => pid)
+    @proxy_objs[id] = proxy_obj
+    @proxy_objs_ids[proxy_obj.__id__] = id
+    ObjectSpace.define_finalizer(proxy_obj, self.method(:proxyobj_finalizer))
+    
+    return proxy_obj
+  end
+  
+  def proxyobj_object(id)
+    obj = @objects[id]
+    raise "No object by that ID: '#{id}' (#{@objects})." if !obj
+    return obj
+  end
+  
+  #Method used for detecting garbage-collected proxy-objects. This way we can also free references to them in the other process, so it doesnt run out of memory.
+  def proxyobj_finalizer(id)
+    debug "Finalized #{id}\n" if @debug
+    proxy_id = @proxy_objs_ids[id]
+    
+    if !proxy_id
+      debug "No such ID in proxy objects IDs hash: '#{id}'.\n" if @debug
+    else
+      @proxy_objs_unsets << proxy_id
+      debug "Done finalizing #{id}\n" if @debug
+    end
+    
+    return nil
+  end
+  
+  #Waits for an answer to appear in the answers-hash. Then deletes it from hash and returns it.
+  def answer_read(id)
+    debug "Waiting for answer #{id}\n" if @debug
+    
+    loop do
+      if @answers.key?(id)
+        debug "Returning answer #{id}\n" if @debug
+        answer = @answers[id]
+        @answers.delete(id)
+        
+        if answer.is_a?(Hash) and answer[:type] == :error and answer.key?(:class) and answer.key?(:msg) and answer.key?(:bt)
+          begin
+            raise "#{answer[:class]}: #{answer[:msg]}"
+          rescue => e
+            bt = []
+            answer[:bt].each do |btline|
+              bt << "(#{@pid}): #{btline}"
+            end
+            
+            bt += e.backtrace
+            e.set_backtrace(bt)
+            raise e
+          end
+        elsif answer.is_a?(Hash) and answer[:type] == :proxy_obj and answer.key?(:id)
+          return proxyobj_get(answer[:id], answer[:pid])
+        end
+        
+        return answer
+      end
+      
+      debug "No answer by ID #{id} - sleeping...\n" if @debug
+      sleep 0.01
+      alive_check!
+      raise @listen_err if @listen_err
+      raise "Not listening." if !@thr_listen or !@thr_listen.alive?
+    end
+  end
+  
+  #Starts the listen-thread that listens for, and executes, commands.
+  def start_listen
+    @thr_listen = Thread.new do
+      begin
+        @io_in.each_line do |line|
+          raise "No line?" if !line or line.to_s.strip.length <= 0
+          alive_check!
+          debug "Received: #{line}" if @debug
+          
+          begin
+            obj = Marshal.load(Base64.strict_decode64(line.strip))
+            debug "Object received: #{obj}\n" if @debug
+          rescue => e
+            $stderr.puts "Base64Str: #{line}" if @debug
+            $stderr.puts e.inspect if @debug
+            $stderr.puts e.backtrace if @debug
+            
+            raise e
+          end
+          
+          if obj[:type] == :send
+            Thread.new do
+              begin
+                raise "Object was not a hash." if !obj.is_a?(Hash)
+                raise "No ID was given?" if !obj.key?(:id)
+                res = self.__send__("cmd_#{obj[:obj][:cmd]}", obj[:obj])
+              rescue Exception => e
+                raise e if e.is_a?(SystemExit) or e.is_a?(Interrupt)
+                res = {:type => :error, :class => e.class.name, :msg => e.message, :bt => e.backtrace}
+              end
+              
+              data = Base64.strict_encode64(Marshal.dump(:type => :answer, :id => obj[:id], :answer => res))
+              @io_out.puts(data)
+            end
+          elsif obj[:type] == :answer
+            debug "Answer #{obj[:id]} saved.\n" if @debug
+            @answers[obj[:id]] = obj[:answer]
+          else
+            raise "Unknown object: '#{obj}'."
+          end
+        end
+      rescue => e
+        @listen_err = e
+      end
+    end
+  end
+  
+  #Starts the listen thread that outputs the 'stderr' for the other process on this process's 'stderr'.
+  def start_listen_errors
+    return nil if !@io_err
+    
+    @thr_err = Thread.new do
+      begin
+        @io_err.each_line do |str|
+          $stderr.print str if @debug
+        end
+      rescue => e
+        @listen_err_err = e
+      end
+    end
+  end
+end
+
+#This class handels the calling of methods on objects in the other process seamlessly.
+class Ruby_process::Proxyobj
+  #Hash that contains various information about the proxyobj.
+  attr_reader :args
+  
+  #Constructor. This should not be called manually but through a running 'Ruby_process'.
+  #===Examples
+  # proxy_obj = rp.new(:String, "Kasper") #=> <Ruby_process::Proxyobj>
+  # proxy_obj = rp.static(:File, :open, "/tmp/somefile") #=> <Ruby_process::Proxyobj>
+  def initialize(args)
+    @args = args
+  end
+  
+  #Returns the object as the real object transfered by using the marshal-lib.
+  #===Examples
+  # str = rp.new(:String, "Kasper") #=> <Ruby_process::Proxyobj>
+  # str.__rp_marshal #=> "Kasper"
+  def __rp_marshal
+    return Marshal.load(@args[:rp].send(:cmd => :obj_marshal, :id => @args[:id]))
+  end
+  
+  #Proxies all calls to the process-object.
+  #===Examples
+  # str = rp.new(:String, "Kasper") #=> <Ruby_process::Proxyobj::1>
+  # length_int = str.length #=> <Ruby_process::Proxyobj::2>
+  # length_int.__rp_marshal #=> 6
+  def method_missing(method, *args, &block)
+    debug "Method-missing-args-before: #{args} (#{@my_pid})\n" if @debug
+    real_args = @args[:rp].parse_args(args)
+    debug "Method-missing-args-after: #{real_args}\n" if @debug
+    
+    return @args[:rp].send(:cmd => :obj_method, :id => @args[:id], :method => method, :args => real_args, &block)
+  end
+end

data/ruby_process.gemspec

@@ -0,0 +1,80 @@
+# Generated by jeweler
+# DO NOT EDIT THIS FILE DIRECTLY
+# Instead, edit Jeweler::Tasks in Rakefile, and run 'rake gemspec'
+# -*- encoding: utf-8 -*-
+
+Gem::Specification.new do |s|
+  s.name = %q{ruby_process}
+  s.version = "0.0.4"
+
+  s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
+  s.authors = ["Kasper Johansen"]
+  s.date = %q{2012-10-10}
+  s.description = %q{A framework for spawning and communicating with other Ruby-processes}
+  s.email = %q{k@spernj.org}
+  s.extra_rdoc_files = [
+    "LICENSE.txt",
+    "README.rdoc"
+  ]
+  s.files = [
+    ".document",
+    ".rspec",
+    "Gemfile",
+    "LICENSE.txt",
+    "README.rdoc",
+    "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_file_write.rb",
+    "examples/example_knj_db_dump.rb",
+    "examples/example_strscan.rb",
+    "include/args_handeling.rb",
+    "lib/ruby_process.rb",
+    "ruby_process.gemspec",
+    "scripts/ruby_process_script.rb",
+    "spec/ruby_process_spec.rb",
+    "spec/spec_helper.rb"
+  ]
+  s.homepage = %q{http://github.com/kaspernj/ruby_process}
+  s.licenses = ["MIT"]
+  s.require_paths = ["lib"]
+  s.rubygems_version = %q{1.6.2}
+  s.summary = %q{A framework for spawning and communicating with other Ruby-processes}
+
+  if s.respond_to? :specification_version then
+    s.specification_version = 3
+
+    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"])
+      s.add_development_dependency(%q<rcov>, [">= 0"])
+    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"])
+      s.add_dependency(%q<rcov>, [">= 0"])
+    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"])
+    s.add_dependency(%q<rcov>, [">= 0"])
+  end
+end
+

data/scripts/ruby_process_script.rb

@@ -0,0 +1,35 @@
+#!/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
+  else
+    raise "Unknown argument: '#{arg}'."
+  end
+end
+
+debug = true if ARGV.index("--debug") != nil
+raise "No PID given of parent process." if !pid
+
+rps = Ruby_process.new(
+  :in => $stdin,
+  :out => $stdout,
+  :err => $stderr,
+  :debug => debug,
+  :pid => pid
+)
+rps.listen
+$stdout.puts("ruby_process_started")
+rps.join

data/spec/ruby_process_spec.rb

@@ -0,0 +1,148 @@
+require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
+
+describe "RubyProcess" do
+  it "should be able to do basic stuff" do
+    $rp = Ruby_process.new(:debug => false)
+    $rp.spawn_process
+    
+    proxyarr = $rp.new(:Array)
+    proxyarr << 1
+    proxyarr << 3
+    proxyarr << 5
+    arr = proxyarr.__rp_marshal
+    
+    raise "Not an array." if !arr.is_a?(Array)
+    raise "Expected three elements." if arr.length != 3
+    raise "Expected 1" if arr[0] != 1
+    raise "Expected 3" if arr[1] != 3
+    raise "Expected 5" if arr[2] != 5
+  end
+  
+  it "should be able to pass proxy-objects as arguments." do
+    str = $rp.new(:String, "/tmp/somefile")
+    $rp.static(:File, :open, str, "w") do |fp|
+      fp.write("Test!")
+    end
+    
+    raise "Unexpected" if File.read(str.__rp_marshal) != "Test!"
+  end
+  
+  it "should be able to write files" do
+    fpath = "/tmp/ruby_process_file_write_test"
+    fp = $rp.static(:File, :open, fpath, "w")
+    fp.write("Test!")
+    fp.close
+    
+    raise "Expected 'Test!'" if File.read(fpath) != "Test!"
+  end
+  
+  it "should do garbage collection" do
+    GC.start
+  end
+  
+  it "should be able to do static calls" do
+    pid = $rp.static(:Process, :pid).__rp_marshal
+    raise "Expected stuff to be finalized but it wasnt." if $rp.finalize_count <= 0 if RUBY_ENGINE != "jruby"
+    raise "Unexpcted" if !pid.is_a?(Fixnum) and !pid.is_a?(Integer)
+  end
+  
+  it "should be able to handle blocking blocks" do
+    run_count = 0
+    fpath = "/tmp/ruby_process_file_write_test"
+    $rp.static(:File, :open, fpath, "w") do |fp|
+      sleep 0.1
+      run_count += 1
+      fp.write("Test!!!")
+    end
+    
+    raise "Expected run-count to be 1 but it wasnt: '#{run_count}'." if run_count <= 0
+    raise "Expected 'Test!'" if File.read(fpath) != "Test!!!"
+  end
+  
+  it "should be able to do slow block-results in JRuby." do
+    $rp.str_eval("
+      class ::Kaspertest
+        def self.kaspertest
+          8.upto(12) do |i|
+            yield(i)
+            sleep 0.5
+          end
+        end
+      end
+      
+      nil
+    ")
+    
+    require "timeout"
+    Timeout.timeout(10) do
+      expect = 8
+      $rp.static("Kaspertest", "kaspertest") do |count|
+        raise "Expected '#{expect}' but got: '#{count.__rp_marshal}'." if expect != count.__rp_marshal
+        expect += 1
+      end
+      
+      raise "Expected '13' but got: '#{expect}'." if expect != 13
+    end
+  end
+  
+  it "should be able to handle large block-runs" do
+    #Try to define an integer and run upto with a block.
+    proxy_int = $rp.numeric(5)
+    
+    expect = 5
+    proxy_int.upto(250) do |i|
+      raise "Expected '#{expect}' but got: '#{i.__rp_marshal}'." if i.__rp_marshal != expect
+      expect += 1
+    end
+    
+    #Ensure the expected has actually been increased by running the block.
+    raise "Expected end-result of 1001 but got: '#{expect}'." if expect != 251
+  end
+  
+  it "should handle stressed operations" do
+    #Spawn a test-object - a string - with a variable-name.
+    proxy_obj = $rp.new(:String, "Kasper")
+    raise "to_s should return 'Kasper' but didnt: '#{proxy_obj.__rp_marshal}'." if proxy_obj.__rp_marshal != "Kasper"
+    
+    #Stress it a little by doing 500 calls.
+    0.upto(500) do
+      res = proxy_obj.slice(0, 3).__rp_marshal
+      raise "Expected output was: 'Kas' but wasnt: '#{res}'." if res != "Kas"
+    end
+  end
+  
+  it "should be thread-safe" do
+    #Do a lot of calls at the same time to test thread-safety.
+    proxy_obj = $rp.new(:String, "Kasper")
+    threads = []
+    0.upto(5) do |thread_i|
+      should_return = "Kasper".slice(0, thread_i)
+      thread = Thread.new do
+        begin
+          0.upto(250) do |num_i|
+            res = proxy_obj.slice(0, thread_i).__rp_marshal
+            raise "Should return: '#{should_return}' but didnt: '#{res}'." if res != should_return
+          end
+        rescue => e
+          Thread.current[:error] = e
+        end
+      end
+      
+      threads << thread
+    end
+    
+    threads.each do |thread|
+      thread.join
+      raise thread[:error] if thread[:error]
+    end
+  end
+  
+  it "should be able to do evals" do
+    res = $rp.str_eval("return 10").__rp_marshal
+    raise "Unexpected: #{res}" if res != 10
+  end
+  
+  it "should be able to destroy itself" do
+    $rp.destroy
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,12 @@
+$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
+$LOAD_PATH.unshift(File.dirname(__FILE__))
+require 'rspec'
+require 'ruby_process'
+
+# Requires supporting files with custom matchers and macros, etc,
+# in ./support/ and its subdirectories.
+Dir["#{File.dirname(__FILE__)}/support/**/*.rb"].each {|f| require f}
+
+RSpec.configure do |config|
+  
+end

metadata

@@ -0,0 +1,152 @@
+--- !ruby/object:Gem::Specification
+name: ruby_process
+version: !ruby/object:Gem::Version
+  version: 0.0.4
+  prerelease: 
+platform: ruby
+authors:
+- Kasper Johansen
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2012-10-10 00:00:00.000000000 +02:00
+default_executable: 
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: wref
+  requirement: &11532040 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: *11532040
+- !ruby/object:Gem::Dependency
+  name: tsafe
+  requirement: &11531160 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: *11531160
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: &11530360 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 2.8.0
+  type: :development
+  prerelease: false
+  version_requirements: *11530360
+- !ruby/object:Gem::Dependency
+  name: rdoc
+  requirement: &11529480 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '3.12'
+  type: :development
+  prerelease: false
+  version_requirements: *11529480
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: &11528660 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: 1.0.0
+  type: :development
+  prerelease: false
+  version_requirements: *11528660
+- !ruby/object:Gem::Dependency
+  name: jeweler
+  requirement: &11527920 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 1.8.3
+  type: :development
+  prerelease: false
+  version_requirements: *11527920
+- !ruby/object:Gem::Dependency
+  name: rcov
+  requirement: &11527180 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: *11527180
+description: A framework for spawning and communicating with other Ruby-processes
+email: k@spernj.org
+executables: []
+extensions: []
+extra_rdoc_files:
+- LICENSE.txt
+- README.rdoc
+files:
+- .document
+- .rspec
+- Gemfile
+- LICENSE.txt
+- README.rdoc
+- 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_file_write.rb
+- examples/example_knj_db_dump.rb
+- examples/example_strscan.rb
+- include/args_handeling.rb
+- lib/ruby_process.rb
+- ruby_process.gemspec
+- scripts/ruby_process_script.rb
+- spec/ruby_process_spec.rb
+- spec/spec_helper.rb
+has_rdoc: true
+homepage: http://github.com/kaspernj/ruby_process
+licenses:
+- MIT
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+      segments:
+      - 0
+      hash: -762115718297605832
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.6.2
+signing_key: 
+specification_version: 3
+summary: A framework for spawning and communicating with other Ruby-processes
+test_files: []