ruby-debug-ide-docker 0.6.1

data/lib/ruby-debug-ide/attach/debugger_loader.rb

@@ -0,0 +1,20 @@
+def load_debugger(gems_to_include, new_argv)
+  path_to_rdebug = File.expand_path(File.dirname(__FILE__)) + '/../../../bin/rdebug-ide'
+
+  old_argv = ARGV.clone
+  ARGV.clear
+  new_argv.each do |x|
+    ARGV << x
+  end
+
+  gems_to_include.each do |gem_path|
+    $LOAD_PATH.unshift(gem_path) unless $LOAD_PATH.include?(gem_path)
+  end
+
+  load path_to_rdebug
+  
+  ARGV.clear
+  old_argv.each do |x|
+    ARGV << x
+  end
+end

data/lib/ruby-debug-ide/attach/gdb.rb

@@ -0,0 +1,73 @@
+require 'ruby-debug-ide/attach/native_debugger'
+
+class GDB < NativeDebugger
+
+  def initialize(executable, pid, flags, gems_to_include, debugger_loader_path, argv)
+    super(executable, pid, flags, gems_to_include, debugger_loader_path, argv)
+  end
+
+  def set_flags
+    execute 'set scheduler-locking off' # we will deadlock with it
+    execute 'set unwindonsignal on'     # in case of some signal we will exit gdb
+  end
+
+  def update_threads
+    @process_threads = []
+    info_threads = (execute 'info threads').split("\n")
+    info_threads.each do |thread_info|
+      next unless thread_info =~ /[\s*]*\d+\s+Thread.*/
+      $stdout.puts "thread_info: #{thread_info}"
+      is_main = thread_info[0] == '*'
+      thread_num = thread_info.sub(/[\s*]*/, '').sub(/\s.*$/, '').to_i
+      thread = ProcessThread.new(thread_num, is_main, thread_info, self)
+      if thread.is_main
+        @main_thread = thread
+      end
+      @process_threads << thread
+    end
+    @process_threads
+  end
+
+  def check_already_under_debug
+    threads = execute 'info threads'
+    threads =~ /ruby-debug-ide/
+  end
+
+  def switch_to_thread(thread_num)
+    execute "thread #{thread_num}"
+  end
+
+  def set_break(str)
+    execute "tbreak #{str}"
+  end
+
+  def call_start_attach
+    super()
+    execute "call dlopen(\"#{@path_to_attach}\", 2)"
+    execute 'call debase_start_attach()'
+    set_break(@tbreak)
+  end
+
+  def print_delimiter
+    @pipe.puts "print \"#{@delimiter}\""
+  end
+
+  def check_delimiter(line)
+    line =~ /\$\d+\s=\s"#{@delimiter}"/
+  end
+
+  def load_debugger
+    execute "call #{@eval_string}"
+  end
+
+  def to_s
+    GDB.to_s
+  end
+
+  class << self
+    def to_s
+      'gdb'
+    end
+  end
+
+end

data/lib/ruby-debug-ide/attach/lldb.rb

@@ -0,0 +1,71 @@
+require 'ruby-debug-ide/attach/native_debugger'
+
+class LLDB < NativeDebugger
+
+  def initialize(executable, pid, flags, gems_to_include, debugger_loader_path, argv)
+    super(executable, pid, flags, gems_to_include, debugger_loader_path, argv)
+  end
+
+  def set_flags
+
+  end
+
+  def update_threads
+    @process_threads = []
+    info_threads = (execute 'thread list').split("\n")
+    info_threads.each do |thread_info|
+      next unless thread_info =~ /[\s*]*thread\s#\d+.*/
+      is_main = thread_info[0] == '*'
+      thread_num = thread_info.sub(/[\s*]*thread\s#/, '').sub(/:\s.*$/, '').to_i
+      thread = ProcessThread.new(thread_num, is_main, thread_info, self)
+      if thread.is_main
+        @main_thread = thread
+      end
+      @process_threads << thread
+    end
+    @process_threads
+  end
+
+  def check_already_under_debug
+    threads = execute 'thread list'
+    threads =~ /ruby-debug-ide/
+  end
+
+  def switch_to_thread(thread_num)
+    execute "thread select #{thread_num}"
+  end
+
+  def set_break(str)
+    execute "breakpoint set --shlib #{@path_to_attach} --name #{str}"
+  end
+
+  def call_start_attach
+    super()
+    execute "expr (void *) dlopen(\"#{@path_to_attach}\", 2)"
+    execute 'expr (int) debase_start_attach()'
+    set_break(@tbreak)
+  end
+
+  def print_delimiter
+    @pipe.puts "script print \"#{@delimiter}\""
+  end
+
+  def check_delimiter(line)
+    line =~ /#{@delimiter}$/
+  end
+
+  def load_debugger
+    execute "expr (void) #{@eval_string}"
+  end
+
+  def to_s
+    LLDB.to_s
+  end
+
+  class << self
+    def to_s
+      'lldb'
+    end
+  end
+
+end

data/lib/ruby-debug-ide/attach/native_debugger.rb

@@ -0,0 +1,133 @@
+class NativeDebugger
+
+  attr_reader :pid, :main_thread, :process_threads, :pipe
+
+  # @param executable -- path to ruby interpreter
+  # @param pid -- pid of process you want to debug
+  # @param flags -- flags you want to specify to your debugger as a string (e.g. "-nx -nh" for gdb to disable .gdbinit)
+  def initialize(executable, pid, flags, gems_to_include, debugger_loader_path, argv)
+    @pid = pid
+    @delimiter = '__OUTPUT_FINISHED__' # for getting response
+    @tbreak = '__func_to_set_breakpoint_at'
+    @main_thread = nil
+    @process_threads = nil
+    debase_path = gems_to_include.select {|gem_path| gem_path =~ /debase/}
+    if debase_path.size == 0
+      raise 'No debase gem found.'
+    end
+    @path_to_attach = find_attach_lib(debase_path[0])
+
+    @gems_to_include = '["' + gems_to_include * '", "' + '"]'
+    @debugger_loader_path = debugger_loader_path
+    @argv = argv
+
+    @eval_string = "debase_rb_eval(\"require '#{@debugger_loader_path}'; load_debugger(#{@gems_to_include.gsub("\"", "'")}, #{@argv.gsub("\"", "'")})\")"
+
+    launch_string = "#{self} #{executable} #{flags}"
+    @pipe = IO.popen(launch_string, 'r+')
+    $stdout.puts "executed '#{launch_string}'"
+  end
+
+  def find_attach_lib(debase_path)
+    attach_lib = debase_path + '/attach'
+    known_extensions = %w(.so .bundle .dll .dylib)
+    known_extensions.each do |ext|
+      if File.file?(attach_lib + ext)
+        return attach_lib + ext
+      end
+    end
+
+    raise 'Could not find attach library'
+  end
+
+  def attach_to_process
+    execute "attach #{@pid}"
+  end
+
+  def execute(command)
+    @pipe.puts command
+    $stdout.puts "executed `#{command}` command inside #{self}."
+    if command == 'q'
+      return ''
+    end
+    get_response
+  end
+
+  def get_response
+    # we need this hack to understand that debugger gave us all output from last executed command
+    print_delimiter
+
+    content = ''
+    loop do
+      line = @pipe.readline
+      DebugPrinter.print_debug('respond line: ' + line)
+      break if check_delimiter(line)
+      next if line =~ /\(lldb\)/ # lldb repeats your input to its output
+      content += line
+    end
+
+    content
+  end
+
+  def update_threads
+
+  end
+
+  def check_already_under_debug
+
+  end
+
+  def print_delimiter
+
+  end
+
+  def check_delimiter(line)
+
+  end
+
+  def switch_to_thread
+
+  end
+
+  def set_break(str)
+
+  end
+
+  def continue
+    $stdout.puts 'continuing'
+    @pipe.puts 'c'
+    loop do
+      line = @pipe.readline
+      DebugPrinter.print_debug('respond line: ' + line)
+      break if line =~ /#{Regexp.escape(@tbreak)}/
+    end
+    get_response
+  end
+
+  def call_start_attach
+    raise 'No main thread found. Did you forget to call `update_threads`?' if @main_thread == nil
+    @main_thread.switch
+  end
+
+  def wait_line_event
+    call_start_attach
+    continue
+  end
+
+  def load_debugger
+
+  end
+
+  def exited?
+    @pipe.closed?
+  end
+
+  def exit
+    @pipe.close
+  end
+
+  def to_s
+    'native_debugger'
+  end
+
+end

data/lib/ruby-debug-ide/attach/process_thread.rb

@@ -0,0 +1,54 @@
+require 'ruby-debug-ide/attach/native_debugger'
+
+class ProcessThread
+
+  attr_reader :thread_num, :is_main, :thread_info, :last_bt
+
+  def initialize(thread_num, is_main, thread_info, native_debugger)
+    @thread_num = thread_num
+    @is_main = is_main
+    @native_debugger = native_debugger
+    @thread_info = thread_info
+    @last_bt = nil
+  end
+
+  def switch
+    @native_debugger.switch_to_thread(thread_num)
+  end
+
+  def finish
+    @native_debugger.execute 'finish'
+  end
+
+  def get_bt
+    @last_bt = @native_debugger.execute 'bt'
+  end
+
+  def any_caller_match(bt, pattern)
+    bt =~ /#{pattern}/
+  end
+
+  def is_inside_malloc(bt = get_bt)
+    if any_caller_match(bt, '(malloc)')
+      $stderr.puts "process #{@native_debugger.pid} is currently inside malloc."
+      true
+    else
+      false
+    end
+  end
+
+  def is_inside_gc(bt = get_bt)
+    if any_caller_match(bt, '(gc\.c)')
+      $stderr.puts "process #{@native_debugger.pid} is currently in garbage collection phase."
+      true
+    else
+      false
+    end
+  end
+
+  def need_finish_frame
+    bt = get_bt
+    is_inside_malloc(bt) || is_inside_gc(bt)
+  end
+
+end

data/lib/ruby-debug-ide/attach/util.rb

@@ -0,0 +1,115 @@
+require 'ruby-debug-ide/attach/lldb'
+require 'ruby-debug-ide/attach/gdb'
+require 'socket'
+require 'set'
+
+def attach_and_return_thread(options, pid, debugger_loader_path, argv)
+  Thread.new(argv) do |argv|
+
+    debugger = choose_debugger(options.ruby_path, pid, options.gems_to_include, debugger_loader_path, argv)
+
+    trap('INT') do
+      unless debugger.exited?
+        $stderr.puts "backtraces for threads:\n\n"
+        process_threads = debugger.process_threads
+        if process_threads
+          process_threads.each do |thread|
+            $stderr.puts "#{thread.thread_info}\n#{thread.last_bt}\n\n"
+          end
+        end
+        debugger.exit
+      end
+      exit!
+    end
+
+    debugger.attach_to_process
+    debugger.set_flags
+
+    if debugger.check_already_under_debug
+      $stderr.puts "Process #{debugger.pid} is already under debug"
+      debugger.exit
+      exit!
+    end
+
+    should_check_threads_state = true
+
+    while should_check_threads_state
+      should_check_threads_state = false
+      debugger.update_threads.each do |thread|
+        thread.switch
+        while thread.need_finish_frame
+          should_check_threads_state = true
+          thread.finish
+        end
+      end
+    end
+
+    debugger.wait_line_event
+    debugger.load_debugger
+    debugger.exit
+  end
+end
+
+def get_child_pids(pid)
+  return [] unless command_exists 'pgrep'
+
+  pids = Array.new
+
+  q = Queue.new
+  q.push(pid)
+
+  until q.empty? do
+    pid = q.pop
+
+    pipe = IO.popen("pgrep -P #{pid}")
+
+    pipe.readlines.each do |child|
+      child_pid = child.strip.to_i
+      q.push(child_pid)
+      pids << child_pid
+    end
+  end
+
+  filter_ruby_processes(pids)
+end
+
+def filter_ruby_processes(pids)
+  pipe = IO.popen(%Q(lsof -c ruby | awk '{print $2 ":" $9}' | grep -E 'bin/ruby([[:digit:]]+\.?)*$'))
+
+  ruby_processes = Set.new
+
+  pipe.readlines.each do |process|
+    pid = process.split(/:/).first
+    ruby_processes.add(pid.to_i)
+  end
+
+  ruby_processes_pids, non_ruby_processes_pids = pids.partition {|pid| ruby_processes.include? pid}
+
+  DebugPrinter.print_debug("The following child processes was added to attach: #{ruby_processes_pids.join(', ')}") unless ruby_processes_pids.empty?
+  DebugPrinter.print_debug("The following child are not ruby processes: #{non_ruby_processes_pids.join(', ')}") unless non_ruby_processes_pids.empty?
+
+  ruby_processes_pids
+end
+
+def command_exists(command)
+  checking_command = "checking command #{command} for existence\n"
+  `command -v #{command} >/dev/null 2>&1 || { exit 1; }`
+  if $?.exitstatus != 0
+    DebugPrinter.print_debug("#{checking_command}command does not exist.")
+  else
+    DebugPrinter.print_debug("#{checking_command}command does exist.")
+  end
+  $?.exitstatus == 0
+end
+
+def choose_debugger(ruby_path, pid, gems_to_include, debugger_loader_path, argv)
+  if command_exists(LLDB.to_s)
+    debugger = LLDB.new(ruby_path, pid, '--no-lldbinit', gems_to_include, debugger_loader_path, argv)
+  elsif command_exists(GDB.to_s)
+    debugger = GDB.new(ruby_path, pid, '-nh -nx', gems_to_include, debugger_loader_path, argv)
+  else
+    raise 'Neither gdb nor lldb was found. Aborting.'
+  end
+
+  debugger
+end