ruby_process 0.0.7 → 0.0.8

data/VERSION

@@ -1 +1 @@
-0.0.7
+0.0.8

data/cmds/blocks.rb

@@ -2,18 +2,31 @@ 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]]
+    block_ele = @proxy_objs[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]))
+    
+    answer_id = obj[:answer_id]
+    raise "No ':answer_id' was given (#{obj})." if !answer_id
+    
+    if answer = @answers[answer_id]
+      #Use a queue to sleep thread until the block has been executed.
+      queue = Queue.new
+      answer.push(:type => :proxy_block_call, :block => block_ele, :args => read_args(obj[:args]), :queue => queue)
+      res = queue.pop
+      raise "Expected true but didnt get that: '#{res}'." if res != true
+    else
+      block_ele.call(*read_args(obj[:args]))
+    end
+    
     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])
+      send(:cmd => :block_call, :block_id => obj[:id], :answer_id => obj[:answer_id])
     }
     
     id = block.__id__

data/cmds/new.rb

@@ -24,7 +24,7 @@ class Ruby_process
     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))
+        send(:cmd => :block_call, :block_id => obj[:block][:id], :answer_id => obj[:send_id], :args => handle_return_args(args))
       }
       
       block = block_with_arity(:arity => obj[:block][:arity], &real_block)

data/cmds/static.rb

@@ -17,7 +17,7 @@ class Ruby_process
     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))
+        send(:cmd => :block_call, :block_id => obj[:block][:id], :answer_id => obj[:send_id], :args => handle_return_args(args))
       }
       
       block = block_with_arity(:arity => obj[:block][:arity], &real_block)

data/cmds/system.rb

@@ -29,4 +29,19 @@ class Ruby_process
     
     return nil
   end
+  
+  #Starts garbage-collecting and then flushes the finalized objects to the sub-process. Does the same thing in the sub-process.
+  def garbage_collect
+    GC.start
+    self.flush_finalized
+    send(:cmd => :garbage_collect)
+    return nil
+  end
+  
+  #The sub-process-side execution of 'garbage_collect'.
+  def cmd_garbage_collect(obj)
+    GC.start
+    self.flush_finalized
+    return nil
+  end
 end

data/include/args_handeling.rb

@@ -31,8 +31,8 @@ class Ruby_process
     
     #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]}
+      debug "Returning from proxy-obj: (ID: #{obj.args[:id]}, PID: #{obj.__rp_pid}).\n" if @debug
+      return {:type => :proxy_obj, :id => obj.__rp_id, :pid => obj.__rp_pid}
     end
     
     #Check if object has already been spawned. If not: spawn id. Then returns hash for it.

data/lib/ruby_process.rb

@@ -1,11 +1,13 @@
 require "rubygems"
-require "base64"
 require "wref" if !Kernel.const_defined?(:Wref)
 require "tsafe" if !Kernel.const_defined?(:Tsafe)
+require "base64"
+require "thread"
+require "timeout"
 
 #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
+  attr_reader :finalize_count, :pid
   
   #Require all the different commands.
   dir = "#{File.dirname(__FILE__)}/../cmds"
@@ -139,21 +141,56 @@ class Ruby_process
   
   #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
+    return nil if self.destroyed?
+    
+    debug "Destroying Ruby-process (#{caller}).\n" if @debug
+    pid = @pid
+    tries = 0
     
     #Make main kill it and make sure its dead...
     begin
       if @main and @pid
-        Process.kill("TERM", @pid)
-        Process.kill(9, @pid)
+        tries += 1
+        Process.kill("TERM", pid) rescue Errno::ESRCH
+        
+        #Ensure subprocess is dead.
+        begin
+          Timeout.timeout(1) do
+            sleep 0.01
+            
+            loop do
+              begin
+                Process.getpgid(pid)
+                alive = true
+              rescue Errno::ESRCH
+                alive = false
+              end
+              
+              break if !alive
+            end
+          end
+        rescue Timeout::Error
+          Process.kill(9, pid) rescue Errno::ESRCH
+          retry
+        end
       end
     rescue Errno::ESRCH
       #Process is already dead - ignore.
+    ensure
+      @pid = nil
+      @io_out = nil
+      @io_in = nil
+      @io_err = nil
+      @main = nil
     end
+    
+    return nil
+  end
+  
+  #Returns true if the Ruby process has been destroyed.
+  def destroyed?
+    return true if !@pid and !@io_out and !@io_in and !@io_err and @main == nil
+    return false
   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.
@@ -171,46 +208,51 @@ class Ruby_process
   def send(obj, &block)
     alive_check!
     
+    #Sync ID stuff so they dont get mixed up.
+    id = nil
+    @send_mutex.synchronize do
+      id = @send_count
+      @send_count += 1
+    end
+    
     #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))
+      block_proxy_res = self.send(:cmd => :spawn_proxy_block, :id => block.__id__, :answer_id => id)
+      block_proxy_res_id = block_proxy_res[: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
+      ObjectSpace.define_finalizer(block, self.method(:proxyobj_finalizer))
       obj[:block] = {
-        :id => block_proxy_res[:id],
+        :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
     ))
-    @answers[id] = Queue.new
-    @io_out.puts(line)
     
-    return answer_read(id)
+    begin
+      @answers[id] = Queue.new
+      @io_out.puts(line)
+      return answer_read(id)
+    ensure
+      #Be sure that the answer is actually deleted to avoid memory-leaking.
+      @answers.delete(id)
+    end
   end
   
   #Returns true if the child process is still running. Otherwise false.
   def alive?
     begin
-      self.alive_check!
+      alive_check!
       return true
     rescue
       return false
@@ -219,6 +261,19 @@ class Ruby_process
   
   private
   
+  #Raises an error if the subprocess is no longer alive.
+  def alive_check!
+    raise "Has been destroyed." if self.destroyed?
+    raise "No 'io_out'." if !@io_out
+    raise "No 'io_in'." if !@io_in
+    raise "'io_in' was closed." if @io_in.closed?
+    raise "No listen thread." if !@thr_listen
+    #raise "Listen thread wasnt alive?" if !@thr_listen.alive?
+    
+    return nil
+  end
+  
+  #Prints the given string to stderr. Raises error if debugging is not enabled.
   def debug(str_full)
     raise "Debug not enabled?" if !@debug
     
@@ -231,17 +286,6 @@ class Ruby_process
     end
   end
   
-  #Raises an error if the subprocess is no longer alive.
-  def alive_check!
-    raise "No 'io_out'." if !@io_out
-    raise "No 'io_in'." if !@io_in
-    raise "'io_in' was closed." if @io_in.closed?
-    raise "No listen thread." if !@thr_listen
-    raise "Listen thread wasnt alive?" if !@thr_listen.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)
@@ -250,7 +294,7 @@ class Ruby_process
     end
     
     @proxy_objs_unsets.delete(id)
-    proxy_obj = Ruby_process::Proxyobj.new(:rp => self, :id => id, :pid => pid)
+    proxy_obj = Ruby_process::Proxyobj.new(self, id, pid)
     @proxy_objs[id] = proxy_obj
     @proxy_objs_ids[proxy_obj.__id__] = id
     ObjectSpace.define_finalizer(proxy_obj, self.method(:proxyobj_finalizer))
@@ -258,10 +302,13 @@ class Ruby_process
     return proxy_obj
   end
   
+  #Returns the saved proxy-object by the given ID. Raises error if it doesnt exist.
   def proxyobj_object(id)
-    obj = @objects[id]
-    raise "No object by that ID: '#{id}' (#{@objects})." if !obj
-    return obj
+    if obj = @objects[id]
+      return obj
+    end
+    
+    raise "No object by that ID: '#{id}' (#{@objects})."
   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.
@@ -281,38 +328,50 @@ class Ruby_process
   
   #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
-    answer = @answers[id].pop
-    
-    debug "Returning answer #{id}\n" if @debug
-    @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}"
+    loop do
+      debug "Waiting for answer #{id}\n" if @debug
+      answer = @answers[id].pop
+      debug "Returning answer #{id}\n" if @debug
+      
+      if answer.is_a?(Hash) and type = answer[:type]
+        if type == :error and class_str = answer[:class] and msg = answer[:msg] and bt_orig = answer[:bt]
+          begin
+            raise "#{class_str}: #{msg}"
+          rescue => e
+            bt = []
+            bt_orig.each do |btline|
+              bt << "(#{@pid}): #{btline}"
+            end
+            
+            bt += e.backtrace
+            e.set_backtrace(bt)
+            raise e
+          end
+        elsif type == :proxy_obj and id = answer[:id] and pid = answer[:pid]
+          return proxyobj_get(id, pid)
+        elsif type == :proxy_block_call and block = answer[:block] and args = answer[:args] and queue = answer[:queue]
+          #Calls the block. This is used to call the block from the same thread that the answer is being read from. This can cause problems in Hayabusa, that uses thread-variables to determine output and such.
+          block.call(*args)
+          
+          #Tells the parent thread that the block has been executed and it should continue.
+          queue << true
+        else
+          return answer
         end
-        
-        bt += e.backtrace
-        e.set_backtrace(bt)
-        raise e
+      else
+        return answer
       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
+    raise "This should never be reached."
   end
   
-  #Starts the listen-thread that listens for, and executes, commands.
+  #Starts the listen-thread that listens for, and executes, commands. This is normally automatically called and should not be called manually.
   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
+          raise "No line?" if !line or line.to_s.strip.empty?
           alive_check!
           debug "Received: #{line}" if @debug
           
@@ -327,28 +386,43 @@ class Ruby_process
             raise e
           end
           
-          if obj[:type] == :send
+          id = obj[:id]
+          obj_type = obj[:type]
+          
+          if obj_type == :send
             Thread.new do
+              #Hack to be able to do callbacks from same thread when using blocks. This should properly be cleaned a bit up in the future.
+              obj[:obj][:send_id] = id
+              
               begin
                 raise "Object was not a hash." if !obj.is_a?(Hash)
-                raise "No ID was given?" if !obj.key?(:id)
+                raise "No ID was given?" if !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))
+              data = Base64.strict_encode64(Marshal.dump(:type => :answer, :id => id, :answer => res))
               @io_out.puts(data)
             end
-          elsif obj[:type] == :answer and id = obj[:id].to_i
-            debug "Answer #{id} saved.\n" if @debug
-            @answers[id] << obj[:answer]
+          elsif obj_type == :answer
+            if answer_queue = @answers[id]
+              debug "Answer #{id} saved.\n" if @debug
+              answer_queue << obj[:answer]
+            elsif @debug
+              debug "No answer-queue could be found for ID #{id}."
+            end
           else
             raise "Unknown object: '#{obj}'."
           end
         end
       rescue => e
+        if @debug
+          debug "Error while listening: #{e.inspect}"
+          debug e.backtrace.join("\n") + "\n"
+        end
+        
         @listen_err = e
       end
     end

data/lib/ruby_process_cproxy.rb

@@ -1,5 +1,3 @@
-require "monitor"
-
 #This class is used to seamlessly use leaky classes without working through 'Ruby_process'.
 #===Examples
 #  Ruby_process::Cproxy.run do |data|
@@ -13,7 +11,7 @@ require "monitor"
 #    raise "REXML shouldnt be defined?" if Kernel.const_defined?(:REXML)
 class Ruby_process::Cproxy
   #Lock is used to to create new Ruby-process-instances and not doing double-counts.
-  @@lock = Monitor.new
+  @@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
@@ -25,30 +23,37 @@ class Ruby_process::Cproxy
   def self.run
     #Increase count of instances that are using Cproxy and set the subproc-object if not already set.
     @@lock.synchronize do
-      @@instances += 1
-      
       #Check if the sub-process is alive.
-      if @@subproc and !@@subproc.alive?
+      if @@subproc and (!@@subproc.alive? or @@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.
       if !@@subproc
-        @@subproc = Ruby_process.new(:title => "cproxy", :debug => false)
-        @@subproc.spawn_process
+        subproc = Ruby_process.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
-          @@subproc.destroy
-          @@subproc = nil
+          begin
+            @@subproc.destroy
+          ensure
+            @@subproc = nil
+            self.destroy_loaded_constants
+          end
         end
       end
     end
@@ -60,6 +65,13 @@ class Ruby_process::Cproxy
     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 'Ruby_process::Cproxy'-namespace.
   def self.const_missing(name)
     Ruby_process::Cproxy.load_class(self, name) if !self.const_defined?(name)
@@ -81,20 +93,13 @@ class Ruby_process::Cproxy
       def self.new(*args, &blk)
         name_match = self.name.to_s.match(/^Ruby_process::Cproxy::(.+)$/)
         class_name = name_match[1]
-        
-        subproc = Ruby_process::Cproxy.subproc
-        obj = subproc.new(class_name, *args, &blk)
-        
-        return obj
+        return Ruby_process::Cproxy.subproc.new(class_name, *args, &blk)
       end
       
       def self.method_missing(method_name, *args, &blk)
         name_match = self.name.to_s.match(/^Ruby_process::Cproxy::(.+)$/)
         class_name = name_match[1]
-        
-        subproc = Ruby_process::Cproxy.subproc
-        
-        return subproc.static(class_name, method_name, *args, &blk)
+        return Ruby_process::Cproxy.subproc.static(class_name, method_name, *args, &blk)
       end
     })
   end

data/lib/ruby_process_proxyobj.rb

@@ -1,14 +1,14 @@
 #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
+  attr_reader :__rp_rp, :__rp_id, :__rp_pid
   
   #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
+  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.
@@ -16,14 +16,19 @@ class Ruby_process::Proxyobj
   # 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]))
+    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 @args[:rp].send(:cmd => :obj_method, :id => @args[:id], :method => method_name, :args => args, &blk).__rp_marshal
+      return @__rp_rp.send(:cmd => :obj_method, :id => @__rp_id, :method => method_name, :args => args, &blk).__rp_marshal
     end
   end
   
@@ -41,10 +46,10 @@ class Ruby_process::Proxyobj
   # 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-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 @args[:rp].send(:cmd => :obj_method, :id => @args[:id], :method => method, :args => real_args, &block)
+    return @__rp_rp.send(:cmd => :obj_method, :id => @__rp_id, :method => method, :args => real_args, &block)
   end
 end

data/ruby_process.gemspec

@@ -5,11 +5,11 @@
 
 Gem::Specification.new do |s|
   s.name = %q{ruby_process}
-  s.version = "0.0.7"
+  s.version = "0.0.8"
 
   s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
   s.authors = ["Kasper Johansen"]
-  s.date = %q{2012-10-16}
+  s.date = %q{2012-10-24}
   s.description = %q{A framework for spawning and communicating with other Ruby-processes}
   s.email = %q{k@spernj.org}
   s.extra_rdoc_files = [
@@ -42,6 +42,7 @@ Gem::Specification.new do |s|
     "scripts/ruby_process_script.rb",
     "spec/cproxy_spec.rb",
     "spec/hard_load_spec.rb",
+    "spec/leaks_spec.rb",
     "spec/ruby_process_spec.rb",
     "spec/spec_helper.rb"
   ]

data/spec/cproxy_spec.rb

@@ -1,6 +1,26 @@
 require File.expand_path(File.dirname(__FILE__) + '/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
+          Ruby_process::Cproxy.run do |data|
+            sp = data[:subproc]
+            str = sp.new(:String, "Wee")
+            res1 = str.include?("Kasper")
+          end
+        end
+      end
+    end
+    
+    ts.each do |thread|
+      thread.join
+    end
+  end
+  
   it "should be able to do basic stuff" do
     require "stringio"
     
@@ -18,4 +38,64 @@ describe "RubyProcess" do
       raise "Expected strio to contain '<test/>' but it didnt: '#{strio.string}'." if strio.string != "<test/>"
     end
   end
+  
+  it "should be able to do multiple calls at once" do
+    ts = []
+    
+    0.upto(9) do |tcount|
+      ts << Thread.new do
+        Ruby_process::Cproxy.run do |data|
+          sp = data[:subproc]
+          sp.new(:String, "Wee")
+          
+          1.upto(250) do
+            str = sp.new(:String, "Kasper Johansen")
+            
+            res1 = str.include?("Kasper")
+            str << " More"
+            
+            res2 = str.include?("Johansen")
+            str << " Even more"
+            
+            res3 = str.include?("Christina")
+            str << " Much more"
+            
+            raise "Expected res1 to be true but it wasnt: '#{res1}'." if res1 != true
+            raise "Expected res2 to be true but it wasnt: '#{res2}'." if res2 != true
+            raise "Expected res3 to be false but it wasnt: '#{res3}'." if res3 != false
+            
+            #print tcount
+          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(Ruby_process) do |obj|
+      count_objs += 1
+    end
+    
+    count_proxy_objs = 0
+    ObjectSpace.each_object(Ruby_process::Proxyobj) do |obj|
+      count_proxy_objs += 1
+    end
+    
+    raise "Expected 1 or less 'Ruby_process' to be left but it wasnt like that: #{count_objs} (proxy objects: #{count_proxy_objs})" if count_objs > 1
+    raise "Expected 0 constants to be left on cproxy." if !Ruby_process::Cproxy.constants.empty?
+  end
 end

data/spec/hard_load_spec.rb

@@ -26,7 +26,7 @@ describe "RubyProcess" do
             raise "Expected res2 to be true but it wasnt: '#{res2}'." if res2 != true
             raise "Expected res3 to be false but it wasnt: '#{res3}'." if res3 != false
             
-            print "."
+            #print "."
           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"
+    
+    Ruby_process::Cproxy.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)
+      raise "'answers'-variable should be empty but wasnt: '#{answers}'." if !answers.empty?
+    end
+  end
+end

data/spec/ruby_process_spec.rb

@@ -20,11 +20,18 @@ describe "RubyProcess" do
   
   it "should be able to pass proxy-objects as arguments." do
     str = $rp.new(:String, "/tmp/somefile")
+    thread_id = Thread.current.__id__
+    write_called = false
+    
     $rp.static(:File, :open, str, "w") do |fp|
+      raise "Expected 'thread_id' to be the same but it wasnt: '#{thread_id}', '#{Thread.current.__id__}'." if thread_id != Thread.current.__id__
       fp.write("Test!")
+      write_called = true
     end
     
-    raise "Unexpected" if File.read(str.__rp_marshal) != "Test!"
+    raise "Expected 'write' on file-pointer to be called, but it wasnt." if !write_called
+    read = File.read(str.__rp_marshal)
+    raise "Unexpected content of file: '#{read}'." if read != "Test!"
   end
   
   it "should be able to write files" do
@@ -142,6 +149,27 @@ describe "RubyProcess" do
     raise "Unexpected: #{res}" if res != 10
   end
   
+  it "should clean itself" do
+    $rp.garbage_collect
+    GC.start
+    $rp.flush_finalized
+    GC.start
+    $rp.flush_finalized
+  end
+  
+  it "should be clean and not leaking" do
+    GC.start
+    $rp.flush_finalized
+    GC.start
+    $rp.flush_finalized
+    
+    answers = $rp.instance_variable_get(:@answers)
+    raise "Expected 0 answers to be present: #{answers}" if !answers.empty?
+    
+    objects = $rp.instance_variable_get(:@objects)
+    raise "Expected 0 objects to be present: #{objects}" if !objects.empty?
+  end
+  
   it "should be able to destroy itself" do
     $rp.destroy
   end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: ruby_process
 version: !ruby/object:Gem::Version
-  version: 0.0.7
+  version: 0.0.8
   prerelease: 
 platform: ruby
 authors:
@@ -9,12 +9,12 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-10-16 00:00:00.000000000 +02:00
+date: 2012-10-24 00:00:00.000000000 +02:00
 default_executable: 
 dependencies:
 - !ruby/object:Gem::Dependency
   name: wref
-  requirement: &19833520 !ruby/object:Gem::Requirement
+  requirement: &12893660 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -22,10 +22,10 @@ dependencies:
         version: '0'
   type: :runtime
   prerelease: false
-  version_requirements: *19833520
+  version_requirements: *12893660
 - !ruby/object:Gem::Dependency
   name: tsafe
-  requirement: &19832660 !ruby/object:Gem::Requirement
+  requirement: &12892340 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -33,10 +33,10 @@ dependencies:
         version: '0'
   type: :runtime
   prerelease: false
-  version_requirements: *19832660
+  version_requirements: *12892340
 - !ruby/object:Gem::Dependency
   name: rspec
-  requirement: &19831800 !ruby/object:Gem::Requirement
+  requirement: &12890800 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ~>
@@ -44,10 +44,10 @@ dependencies:
         version: 2.8.0
   type: :development
   prerelease: false
-  version_requirements: *19831800
+  version_requirements: *12890800
 - !ruby/object:Gem::Dependency
   name: rdoc
-  requirement: &19830660 !ruby/object:Gem::Requirement
+  requirement: &12889640 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ~>
@@ -55,10 +55,10 @@ dependencies:
         version: '3.12'
   type: :development
   prerelease: false
-  version_requirements: *19830660
+  version_requirements: *12889640
 - !ruby/object:Gem::Dependency
   name: bundler
-  requirement: &19828180 !ruby/object:Gem::Requirement
+  requirement: &12888460 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -66,10 +66,10 @@ dependencies:
         version: 1.0.0
   type: :development
   prerelease: false
-  version_requirements: *19828180
+  version_requirements: *12888460
 - !ruby/object:Gem::Dependency
   name: jeweler
-  requirement: &19827260 !ruby/object:Gem::Requirement
+  requirement: &12887260 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ~>
@@ -77,10 +77,10 @@ dependencies:
         version: 1.8.3
   type: :development
   prerelease: false
-  version_requirements: *19827260
+  version_requirements: *12887260
 - !ruby/object:Gem::Dependency
   name: rcov
-  requirement: &19826400 !ruby/object:Gem::Requirement
+  requirement: &12886420 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -88,7 +88,7 @@ dependencies:
         version: '0'
   type: :development
   prerelease: false
-  version_requirements: *19826400
+  version_requirements: *12886420
 description: A framework for spawning and communicating with other Ruby-processes
 email: k@spernj.org
 executables: []
@@ -122,6 +122,7 @@ files:
 - scripts/ruby_process_script.rb
 - spec/cproxy_spec.rb
 - spec/hard_load_spec.rb
+- spec/leaks_spec.rb
 - spec/ruby_process_spec.rb
 - spec/spec_helper.rb
 has_rdoc: true
@@ -140,7 +141,7 @@ required_ruby_version: !ruby/object:Gem::Requirement
       version: '0'
       segments:
       - 0
-      hash: 1714435591026867569
+      hash: -2651984765676101078
 required_rubygems_version: !ruby/object:Gem::Requirement
   none: false
   requirements: