hijack 0.1.9

data/COPYING

@@ -0,0 +1,18 @@
+Copyright (c) 2009 Ian Leitch
+
+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 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,121 @@
+= Hijack: Provides an irb session to an existing ruby process.
+
+== Intro
+
+Hijack allows you to connect to any ruby process and execute code as if it were a normal irb session. Hijack does not require your target process to require any hijacking code, hijack is able to connect to any ruby process. It achieves this by using gdb to inject a payload into the process which starts up a DRb server, hijack then detaches gdb and reconnects via DRb. Please note that gdb will halt your target process while it is attached, though the injection process is very quick and your process should only be halted for a few milliseconds.
+
+Hijack uses DRb over a unix socket file, so you need to be on the same machine as the process you want to hijack. This is by design for security reasons. You also need to run the hijack client as the same user as the remote process.
+
+== Using Hijack
+
+  $ hijack 16451
+  => Hijacked 16451 (my_script.rb) (ruby 1.8.7 [i686-darwin9])
+  >>
+
+== Using ruby-debug
+
+Hijack can be used to start ruby-debug in your target process, for example:
+
+  $ hijack 61378
+  => Hijacked 61378 (/opt/local/bin/thin) (ruby 1.8.7 [i686-darwin9])
+  >> hijack_debug_mode
+  => true
+
+We've enabled debug mode, but we still need to insert a breakpoint:
+
+  >> ActionController::Dispatcher.class_eval do
+  >>   class << self
+  >>     def dispatch_with_debugger(cgi, session_options, output)
+  >>       debugger
+  >>       dispatch_without_debugger(cgi, session_options, output)
+  >>     end
+  >>     alias_method :dispatch_without_debugger, :dispatch
+  >>     alias_method :dispatch, :dispatch_with_debugger
+  >>   end
+  >> end
+
+Now tell hijack that we can start debugging:
+
+  >> hijack_debug_start
+  Connected.
+
+Point your browser at http://0.0.0.0:3000 to trigger the breakpoint and ruby-debug's console will appear:
+
+  >> hijack_debug_start
+  Connected.
+  (eval):5
+  (rdb:4) step
+  /Users/ian/Projects/zioko/vendor/rails/actionpack/lib/action_controller/dispatcher.rb:28 new(output).dispatch_cgi(cgi, session_options)
+  (rdb:4) backtrace
+  --> #0 /Users/ian/Projects/zioko/vendor/rails/actionpack/lib/action_controller/dispatcher.rb:28 in 'dispatch_without_debugger'
+      #1 (eval):5 in 'dispatch'
+      #2 /opt/local/lib/ruby/gems/1.8/gems/thin-1.2.2/lib/rack/adapter/rails.rb:81 in 'call'
+      #3 /opt/local/lib/ruby/gems/1.8/gems/thin-1.2.2/lib/rack/adapter/rails.rb:69 in 'call'
+      #4 /opt/local/lib/ruby/gems/1.8/gems/thin-1.2.2/lib/thin/connection.rb:76 in 'pre_process'
+      #5 /opt/local/lib/ruby/gems/1.8/gems/thin-1.2.2/lib/thin/connection.rb:74 in 'pre_process'
+      #6 /opt/local/lib/ruby/gems/1.8/gems/thin-1.2.2/lib/thin/connection.rb:57 in 'process'
+      #7 /opt/local/lib/ruby/gems/1.8/gems/thin-1.2.2/lib/thin/connection.rb:42 in 'receive_data'
+  (rdb:4)
+
+One caveat is that ruby-debug's 'irb' command will not work because the debug connection is remote, you also can't use hijack's irb console whilst debugging. A future version of hijack will hopefully allow you to switch between the two.
+
+== Monkey Patching
+
+Just as in a normal irb session, you can redefine the code running in your target process.
+
+This example redefines ActionController's dispatcher to print basic request activity (the example can be found in examples/rails_dispatcher.rb).
+
+Start up a Thin web server:
+
+  $ thin start
+  >> Using rails adapter
+  >> Thin web server (v1.2.2 codename I Find Your Lack of Sauce Disturbing)
+  >> Maximum connections set to 1024
+  >> Listening on 0.0.0.0:3000, CTRL+C to stop
+
+In another console hijack the Thin process:
+
+  $ ps | grep thin
+  61160 ttys001    0:01.43 /opt/local/bin/ruby /opt/local/bin/thin start
+
+  $ hijack 61160
+  => Hijacked 61160 (/opt/local/bin/thin) (ruby 1.8.7 [i686-darwin9])
+  >> ActionController::Dispatcher.class_eval do
+  ?>   class << self
+  >>     def dispatch_with_spying(cgi, session_options, output)
+  >>       env = cgi.__send__(:env_table)
+  >>       puts "#{Time.now.strftime('%Y/%m/%d %H:%M:%S')} - #{env['REMOTE_ADDR']} - #{env['REQUEST_URI']}"
+  >>       dispatch_without_spying(cgi, session_options, output)
+  >>     end
+  >>     alias_method :dispatch_without_spying, :dispatch
+  >>     alias_method :dispatch, :dispatch_with_spying
+  >>   end
+  >> end
+
+Point your browser to http://0.0.0.0:3000.
+
+Back in hijack you'll see your browsing activity:
+
+  2009/08/22 14:24:48 - 127.0.0.1 - /
+  2009/08/22 14:24:53 - 127.0.0.1 - /login
+  2009/08/22 14:24:54 - 127.0.0.1 - /signup
+
+Instead of pasting your code into hijack, you can pass hijack the -e option execute a local file on the target process.
+
+== Process Output
+
+By default hijack will forward your process output to the hijack client. This can get a little messy if your trying to write code at the same time as the target process writes to STDOUT/STDERR. You can mute and unmute the process with:
+
+  >> hijack_mute
+  => true
+  >> hijack_unmute
+  => true
+
+For ease of use, hijack helper methods are discoverable with tab completion. hi<tab><tab> will give you a list of available helpers.
+
+== Process Mirroring
+
+DRb cannot dump objects to the hijack client for types that are not loaded in the client process. E.g if the remote process had required ActiveRecord and you tried to dump ActiveRecord::Base back to the client, DRb would instead return a DRb::Unknown object as ActiveRecord
+isn't loaded in the hijack client.
+
+To work around this, when hijack connects to a remote process it will inspect all the files required by the process and also attempt to require them itself. This may not work for all object types however so you may still get a warning when an object cannot be dumped.

data/Rakefile

@@ -0,0 +1,4 @@
+require 'rake'
+require 'rake/clean'
+
+Dir['tasks/**/*.rake'].each { |rake| load rake }

data/TODO

@@ -0,0 +1,2 @@
+* Improve startup experience
+* Add a hijack_exec helper to execute a local .rb on the target

data/bin/hijack

@@ -0,0 +1,26 @@
+#!/usr/bin/env ruby
+require 'optparse'
+require File.dirname(__FILE__) + '/../lib/hijack'
+require 'hijack'
+
+options = {}
+usage = 'Usage: hijack [options] <PID>'
+pid = ARGV.find {|o| o =~ /\d/}
+new_argv = ARGV.clone
+new_argv.delete(pid)
+
+new_argv.options do |opts|
+  opts.banner = usage
+  opts.on("--gdb-debug", "Print gdb activity to the console.") { |v| options[:gdb_debug] = true }
+  opts.on("--mute", "Ignore stdout/stderr writes from the remote process.") { |v| options[:mute] = true }
+  opts.on("-e", "--execute=FILE", String, "Execute the specified file in the remote process and then disconnect.") { |v| options[:execute] = v }
+  opts.on("-h", "--help", "Show this help message.") { puts opts; exit }
+  opts.parse!
+end
+
+if pid.nil? || pid.to_s == ''
+  puts usage
+  exit 1
+end
+
+Hijack.start(pid, options)

data/examples/rails_dispatcher.rb

@@ -0,0 +1,11 @@
+ActionController::Dispatcher.class_eval do
+  class << self
+    def dispatch_with_spying(cgi, session_options, output)
+      env = cgi.__send__(:env_table)
+      puts "#{Time.now.strftime('%Y/%m/%d %H:%M:%S')} - #{env['REMOTE_ADDR']} - #{env['REQUEST_URI']}"
+      dispatch_without_spying(cgi, session_options, output)
+    end
+    alias_method :dispatch_without_spying, :dispatch
+    alias_method :dispatch, :dispatch_with_spying
+  end
+end

data/lib/hijack/console.rb

@@ -0,0 +1,137 @@
+module Hijack
+  class Console
+    def initialize(pid)
+      @pid = pid
+      @remote = nil
+      check_pid
+      str = "=> Hijacking..."
+      $stdout.write(str)
+      $stdout.flush
+      Payload.inject(@pid)
+      connect
+      $stdout.write("\b" * str.size)
+      $stdout.flush
+      mirror_process
+      banner
+      execute_file
+      OutputReceiver.start(@remote) unless Hijack.options[:mute]
+      start_irb
+    end
+
+  protected
+    def check_pid
+      begin
+        Process.kill(0, @pid.to_i)
+      rescue Errno::EPERM
+        puts "=> You do not have the correct permissions to hijack #{@pid}"
+        exit 1
+      rescue Errno::ESRCH
+        puts "=> No such process #{@pid}"
+        exit 1
+      end
+    end
+
+    def connect
+      loop do
+        break if File.exists?(Hijack.socket_path_for(@pid))
+        sleep 0.01
+      end
+      @remote = DRbObject.new(nil, Hijack.socket_for(@pid))
+    end
+
+    module OutputReceiver
+      class << self
+        def mute
+          @mute = true
+        end
+
+        def unmute(remote)
+          start(remote) unless @started
+          @mute = false
+        end
+
+        def write(where, str)
+          Object.const_get(where.upcase).write(str) unless @mute
+        end
+
+        def puts(where, str)
+          Object.const_get(where.upcase).puts(str) unless @mute
+        end
+
+        def start(remote)
+          DRb.start_service(Hijack.socket_for(Process.pid), self)
+          remote.evaluate("__hijack_output_receiver_ready_#{Process.pid}")
+          @started = true
+        end
+      end
+    end
+
+    def mirror_process
+      # Attempt to require all files currently loaded by the remote process so DRb can dump as many objects as possible.
+      #
+      # We have to first require everything in reverse order and then in the original order.
+      # This is because when you require file_a.rb which first sets a constant then requires file_b.rb
+      # the $" array will contain file_b.rb before file_a.rb. But if we require file_b.rb before file_a.rb
+      # we'll get a missing constant error.
+      load_path, loaded_files = @remote.evaluate('[$:, $"]')
+      to_load = (loaded_files - $").uniq
+      completion_percentage = 0
+      str = '=> Mirroring: '
+      percent_str = ''
+      $stdout.write(str)
+      $stdout.flush
+      $:.clear
+      $:.push(*load_path)
+      orig_stderr = $stderr
+      $stderr = File.open('/dev/null')
+      (to_load.reverse + to_load).each_with_index do |file, i|
+        begin
+          require file
+        rescue Exception, LoadError
+        end
+        $stdout.write("\b" * percent_str.size)
+        $stdout.flush
+        percent_str = "#{(((i + 1) / (to_load.size * 2).to_f) * 100.0).round}%"
+        $stdout.write(percent_str)
+        $stdout.flush
+      end
+      $stderr = orig_stderr
+      $stdout.write("\b" * (str.size + percent_str.size))
+      $stdout.flush
+    end
+
+    def start_irb
+      ARGV.replace ["--simple-prompt"]
+      IRB.setup(nil)
+      workspace = Hijack::Workspace.new
+      workspace.remote = @remote
+      workspace.pid = @pid
+      irb = IRB::Irb.new(workspace)
+      @CONF = IRB.instance_variable_get(:@CONF)
+      @CONF[:IRB_RC].call irb.context if @CONF[:IRB_RC]
+      @CONF[:MAIN_CONTEXT] = irb.context
+      @CONF[:PROMPT_MODE] = :SIMPLE
+      trap('SIGINT') { irb.signal_handle }
+      catch(:IRB_EXIT) { irb.eval_input }
+    end
+
+    def banner
+      script, ruby_version, platform, hijack_version = @remote.evaluate('[$0, RUBY_VERSION, RUBY_PLATFORM]')
+      puts "=> Hijacked #{@pid} (#{script}) (ruby #{ruby_version} [#{platform}])"
+    end
+
+    def execute_file
+      if Hijack.options[:execute]
+        if File.exists?(Hijack.options[:execute])
+          $stdout.write("=> Executing #{Hijack.options[:execute]}... ")
+          $stdout.flush
+          @remote.evaluate(File.read(Hijack.options[:execute]))
+          puts "done!"
+          exit
+        else
+          puts "=> Can't find #{Hijack.options[:execute]} to execute!"
+        end
+      end
+    end
+  end
+end

data/lib/hijack/gdb.rb

@@ -0,0 +1,111 @@
+# Based on gdb.rb by Jamis Buck, thanks Jamis!
+
+module Hijack
+  class GDB
+    def initialize(pid)
+      @pid = pid
+      @verbose = Hijack.options[:gdb_debug]
+      @exec_path = File.join(Config::CONFIG['bindir'], Config::CONFIG['RUBY_INSTALL_NAME'] + Config::CONFIG['EXEEXT'])
+      attach
+    end
+
+    def ensure_attached_to_ruby_process
+      unless backtrace.any? {|line| line =~ /rb_/}
+        puts "\n=> #{@pid} doesn't appear to be a Ruby process!"
+        detach
+        exit 1
+      end
+    end
+
+    def ensure_main_thread_not_blocked_by_join
+      if backtrace.any? {|line| line =~ /rb_thread_join/}
+        puts "\n=> Unable to hijack #{@pid} because the main thread is blocked waiting for another thread to join."
+        puts "=> Check that you are using the most recent version of hijack, a newer version may have solved this shortcoming."
+        detach
+        exit 1
+      end
+    end
+
+    def eval(cmd)
+      call("(void)rb_eval_string(#{cmd.strip.gsub(/"/, '\"').inspect})")
+    end
+
+    def detach
+      return unless @gdb
+      exec('detach')
+      exec('quit')
+      @backtrace = nil
+      @gdb.close
+      @gdb = nil
+    end
+
+  protected
+    def attach
+      loop do
+        @gdb = IO.popen("gdb -q #{@exec_path} #{@pid} 2>&1", 'r+')
+        wait
+        if backtrace.first =~ /Previous frame inner to this frame/
+          detach
+          sleep 0.1
+        else
+          break
+        end
+      end
+
+      ensure_attached_to_ruby_process
+      ensure_main_thread_not_blocked_by_join
+      set_trap_pending
+      set_breakpoint
+      continue
+      clear_breakpoint
+    end
+
+    def backtrace
+      @backtrace ||= exec('bt').reverse
+    end
+
+    def set_trap_pending
+      exec("set variable (int)rb_trap_pending=1")
+    end
+
+    def set_breakpoint
+      exec("break rb_trap_exec")
+    end
+
+    def clear_breakpoint
+      exec("clear rb_trap_exec")
+    end
+
+    def continue
+      exec('continue')
+    end
+
+    def call(cmd)
+      exec("call #{cmd}")
+    end
+
+    def exec(str)
+      puts("(gdb) #{str}") if @verbose
+      @gdb.puts(str)
+      wait
+    end
+
+    def wait
+      lines = []
+      line = ''
+      while result = IO.select([@gdb])
+        next if result.empty?
+        c = @gdb.read(1)
+        break if c.nil?
+        line << c
+        break if line == "(gdb) " || line == " >"
+        if line[-1] == ?\n
+          lines << line
+          line = ""
+        end
+      end
+      puts lines.map { |l| "> #{l}" } if @verbose
+      lines
+    end
+  end
+end

data/lib/hijack/helper.rb

@@ -0,0 +1,45 @@
+module Hijack
+  module Helper
+    class << self
+      def helpers
+        methods.find_all {|meth| meth =~ /^hijack_/}
+      end
+
+      def find_helper(statements)
+        helpers.include?(statements.strip) ? statements.strip : nil
+      end
+
+      def helpers_like(str)
+        found = helpers.find_all { |helper| helper =~ Regexp.new(str) }
+        found.empty? ? nil : found
+      end
+
+      def hijack_mute(remote)
+        Hijack::Console::OutputReceiver.mute
+        true
+      end
+
+      def hijack_unmute(remote)
+        Hijack::Console::OutputReceiver.unmute(remote)
+        true
+      end
+
+      def hijack_debug_mode(remote)
+        hijack_mute(remote)
+        require 'rubygems'
+        require 'ruby-debug'
+        remote.evaluate(<<-RB)
+          require 'rubygems'
+          require 'ruby-debug'
+          Debugger.start_remote
+        RB
+        true
+      end
+
+      def hijack_debug_start(remote)
+        Debugger.start_client
+        true
+      end
+    end
+  end
+end

data/lib/hijack/payload.rb

@@ -0,0 +1,110 @@
+module Hijack
+  class Payload
+    def self.inject(pid)
+      gdb = nil
+      trap('SIGINT') do
+        puts
+        @received_sigint = true
+      end
+      gdb = GDB.new(pid)
+      gdb.eval(payload(pid))
+      gdb.detach
+      exit if @received_sigint
+    end
+
+    def self.payload(pid)
+      <<-RUBY
+        require 'stringio'
+        require 'drb'
+
+        unless defined?(Hijack)
+          module Hijack
+            class OutputCopier
+              def self.remote
+                @remote
+              end
+
+              def self.stop
+                @remote = nil
+                [$stdout, $stderr].each do |io|
+                  if io.respond_to?(:write_with_copying)
+                    class << io
+                      alias_method :write, :write_without_copying
+                      remove_method :write_with_copying
+                    end
+                  end
+                end
+              end
+
+              def self.start(pid)
+                @remote = DRbObject.new(nil, 'drbunix://tmp/hijack.' + pid + '.sock')
+
+                class << $stdout
+                  def write_with_copying(str)
+                    write_without_copying(str)
+                    begin
+                      Hijack::OutputCopier.remote.write('stdout', str)
+                    rescue Exception
+                      Hijack.stop
+                    end
+                  end
+                  alias_method :write_without_copying, :write
+                  alias_method :write, :write_with_copying
+                end
+
+                class << $stderr
+                  def write_with_copying(str)
+                    write_without_copying(str)
+                    begin
+                      Hijack::OutputCopier.remote.write('stderr', str)
+                    rescue Exception
+                      Hijack.stop
+                    end
+                  end
+                  alias_method :write_without_copying, :write
+                  alias_method :write, :write_with_copying
+                end
+              end
+            end
+
+            class Evaluator
+              def initialize(context)
+                @context = context
+                @file = __FILE__
+              end
+
+              def evaluate(rb)
+                if rb =~ /__hijack_output_receiver_ready_([\\d]+)/
+                  OutputCopier.start($1)
+                elsif rb =~ /__hijack_get_remote_file_name/
+                  @file
+                elsif rb =~ /__hijack_exit/
+                  Hijack.stop
+                else
+                  @context.instance_eval(rb)
+                end
+              end
+            end
+
+            def self.start(context)
+              return if @service && @service.alive?
+              evaluator = Hijack::Evaluator.new(context)
+              @service = DRb.start_service('#{Hijack.socket_for(pid)}', evaluator)
+              File.chmod(0600, '#{Hijack.socket_path_for(pid)}')
+            end
+
+            def self.stop
+              begin
+                OutputCopier.stop
+                @service.stop_service
+                @service = nil
+              rescue Exception
+              end
+            end
+          end
+        end
+        Hijack.start(self)
+      RUBY
+    end
+  end
+end

data/lib/hijack/workspace.rb

@@ -0,0 +1,37 @@
+module Hijack
+  HijackCompletionProc = proc {|input|
+    bind = IRB.conf[:MAIN_CONTEXT].workspace.binding
+    if helpers = Helper.helpers_like(input)
+      helpers
+    else
+      IRB::InputCompletor::CompletionProc.call(input)
+    end
+  }
+  Readline.completion_proc = HijackCompletionProc
+
+  class Workspace < IRB::WorkSpace
+    attr_accessor :remote, :pid
+    def evaluate(context, statements, file = __FILE__, line = __LINE__)
+      if statements =~ /IRB\./
+        super
+      elsif statements.strip =~ /^exit/
+        remote.evaluate('__hijack_exit') rescue nil
+        super
+      elsif helper = Hijack::Helper.find_helper(statements)
+        Hijack::Helper.send(helper, remote)
+      else
+        begin
+          result = remote.evaluate(statements)
+        rescue DRb::DRbConnError
+          puts "=> Lost connection to #{@pid}!"
+          exit 1
+        end
+        if result.kind_of?(DRb::DRbUnknown)
+          puts "=> Hijack: Unable to dump unknown object type '#{result.name}', try inspecting it instead."
+          return nil
+        end
+        result
+      end
+    end
+  end
+end

data/lib/hijack.rb

@@ -0,0 +1,31 @@
+$:.unshift(File.dirname(__FILE__))
+require 'stringio'
+require 'drb'
+require 'drb/unix'
+require 'rbconfig'
+require 'irb'
+require 'irb/completion'
+require 'hijack/console'
+require 'hijack/gdb'
+require 'hijack/payload'
+require 'hijack/helper'
+require 'hijack/workspace'
+
+module Hijack
+  def self.start(pid, options)
+    @@options = options
+    Console.new(pid)
+  end
+
+  def self.options
+    @@options
+  end
+
+  def self.socket_for(pid)
+    "drbunix:/#{socket_path_for(pid)}"
+  end
+
+  def self.socket_path_for(pid)
+    "/tmp/hijack.#{pid}.sock"
+  end
+end

data/tasks/gem.rake

@@ -0,0 +1,41 @@
+require 'rake/gempackagetask'
+require 'yaml'
+
+HIJACK_VERSION = '0.1.9'
+
+task :clean => :clobber_package
+
+spec = Gem::Specification.new do |s|  
+  s.name                  = 'hijack'
+  s.version               = HIJACK_VERSION
+  s.platform              = Gem::Platform::RUBY
+  s.summary               = 
+  s.description           = 'Provides an irb session to an existing ruby process.'
+  s.author                = "Ian Leitch"
+  s.email                 = 'ian.leitch@systino.net'
+  s.homepage              = 'http://github.com/ileitch/hijack'
+  s.has_rdoc              = false
+  s.files                 = %w(COPYING TODO README.rdoc Rakefile) + Dir.glob("{lib,test,tasks,bin,examples}/**/*")
+  s.bindir                = "bin"
+  s.executables           = %w( hijack )
+  s.require_path          = "lib"
+end
+
+Rake::GemPackageTask.new(spec) do |p|
+  p.gem_spec = spec
+end
+
+namespace :gem do
+  desc "Update the gemspec for GitHub's gem server"
+  task :github do
+    File.open("hijack.gemspec", 'w') { |f| f << YAML.dump(spec) }
+  end  
+end
+
+task :install => [:clean, :clobber, :package] do
+  sh "sudo gem install pkg/#{spec.full_name}.gem"
+end
+
+task :uninstall => :clean do
+  sh "sudo gem uninstall -v #{HIJACK_VERSION} -x hijack"
+end

data/test/app.rb

@@ -0,0 +1,7 @@
+#!/usr/bin/ruby
+require 'rubygems'
+require 'sinatra'
+
+get '/' do
+    'You got it'
+end

data/test/gc.rb

@@ -0,0 +1,14 @@
+#!/usr/bin/ruby
+
+class MyObject
+  def initialize(i)
+    @i = i
+  end
+end
+
+puts Process.pid
+n = 0
+loop do
+  (n+=1).times {|i| MyObject.new(i)}
+  GC.start
+end

data/test/test.rb

@@ -0,0 +1,20 @@
+#!/usr/bin/ruby
+
+class SomeClass
+end
+
+def do_shit(i)
+  puts i
+end
+
+p Process.pid
+
+t = Thread.new do
+  i = 0
+  loop do
+    sleep 2
+    do_shit(i+=1)
+  end
+end
+
+t.join

metadata

@@ -0,0 +1,73 @@
+--- !ruby/object:Gem::Specification 
+name: hijack
+version: !ruby/object:Gem::Version 
+  version: 0.1.9
+platform: ruby
+authors: 
+- Ian Leitch
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2009-10-23 00:00:00 -04:00
+default_executable: 
+dependencies: []
+
+description: Provides an irb session to an existing ruby process.
+email: ian.leitch@systino.net
+executables: 
+- hijack
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- COPYING
+- TODO
+- README.rdoc
+- Rakefile
+- lib/hijack/console.rb
+- lib/hijack/gdb.rb
+- lib/hijack/helper.rb
+- lib/hijack/payload.rb
+- lib/hijack/workspace.rb
+- lib/hijack.rb
+- lib/hijack.rbc
+- test/app.rb
+- test/gc.rb
+- test/test.rb
+- test/test.rbc
+- tasks/gem.rake
+- bin/hijack
+- bin/hijack.compiled.rbc
+- examples/rails_dispatcher.rb
+has_rdoc: true
+homepage: http://github.com/ileitch/hijack
+licenses: []
+
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.3.5
+signing_key: 
+specification_version: 3
+summary: Provides an irb session to an existing ruby process.
+test_files: []
+