ruby-debug-ide22 0.7.4

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

data/lib/ruby-debug-ide/command.rb

@@ -0,0 +1,187 @@
+if RUBY_VERSION < '2.0' || defined?(JRUBY_VERSION)
+  require 'ruby-debug-base'
+else
+  require 'debase'
+end
+
+require 'ruby-debug-ide/thread_alias'
+require 'ruby-debug-ide/helper'
+require 'delegate'
+
+module Debugger
+
+  class Command < SimpleDelegator # :nodoc:
+    SubcmdStruct=Struct.new(:name, :min, :short_help, :long_help) unless
+      defined?(SubcmdStruct)
+
+    # Find param in subcmds. param id downcased and can be abbreviated
+    # to the minimum length listed in the subcommands
+    def find(subcmds, param)
+      param.downcase!
+      for try_subcmd in subcmds do
+        if (param.size >= try_subcmd.min) and
+            (try_subcmd.name[0..param.size-1] == param)
+          return try_subcmd
+        end
+      end
+      return nil
+    end
+
+    class << self
+      def commands
+        @commands ||= []
+      end
+      
+      DEF_OPTIONS = {
+        :event => true, 
+        :control => false, 
+        :unknown => false,
+        :need_context => false,
+      }
+      
+      def inherited(klass)
+        DEF_OPTIONS.each do |o, v|
+          klass.options[o] = v if klass.options[o].nil?
+        end
+        commands << klass
+      end 
+
+      def load_commands
+        dir = File.dirname(__FILE__)
+        Dir[File.join(dir, 'commands', '*')].each do |file|
+          require file if file =~ /\.rb$/
+        end
+        Debugger.constants.grep(/Functions$/).map { |name| Debugger.const_get(name) }.each do |mod|
+          include mod
+        end
+      end
+      
+      def method_missing(meth, *args, &block)
+        if meth.to_s =~ /^(.+?)=$/
+          @options[$1.intern] = args.first
+        else
+          if @options.has_key?(meth)
+            @options[meth]
+          else
+            super
+          end
+        end
+      end
+      
+      def options
+        @options ||= {}
+      end
+
+      def unescape_incoming(str)
+        str.gsub(/((?:^|[^\\])(?:\\\\)*)((?:\\n)+)/) do |_|
+          $1 + "\n" * ($2.size / 2)
+        end.gsub(/\\\\/, '\\')
+      end
+
+      def file_filter_supported?
+        defined?(Debugger.file_filter)
+      end
+    end
+    
+    def initialize(state, printer)
+      @state, @printer = state, printer
+      super @printer
+    end
+    
+    def match(input)
+      @match = regexp.match(input)
+    end
+
+    protected
+
+    def errmsg(*args)
+      @printer.print_error(*args)
+    end
+
+    def print(*args)
+      @state.print(*args)
+    end
+
+    # see Timeout::timeout, the difference is that we must use a DebugThread
+    # because every other thread would be halted when the event hook is reached
+    # in ruby-debug.c
+    def timeout(sec)
+      return yield if sec == nil or sec.zero?
+      if Thread.respond_to?(:critical) and Thread.critical
+        raise ThreadError, "timeout within critical session"      
+      end
+      begin
+        x = Thread.current
+        y = DebugThread.start {
+          sleep sec
+          x.raise StandardError, "Timeout: evaluation took longer than #{sec} seconds." if x.alive?
+        }
+        yield sec
+      ensure
+        y.kill if y and y.alive?
+      end
+    end
+
+    def debug_eval(str, b = get_binding)
+      begin
+        str = str.to_s
+        str.force_encoding('UTF-8') if(RUBY_VERSION >= '2.0')
+        to_inspect = Command.unescape_incoming(str)
+        max_time = Debugger.evaluation_timeout
+        @printer.print_debug("Evaluating %s with timeout after %i sec", str, max_time)
+
+        Debugger::TimeoutHandler.do_thread_alias
+
+        eval_result = nil
+
+        timeout(max_time) do
+          eval_result = eval(to_inspect, b)
+        end
+
+        Debugger::TimeoutHandler.undo_thread_alias
+
+        return eval_result
+      rescue StandardError, ScriptError => e
+        @printer.print_exception(e, @state.binding) 
+        throw :debug_error
+      end
+    end
+
+    def debug_silent_eval(str)
+      begin
+        str = str.to_s
+        eval(str, get_binding)
+      rescue StandardError, ScriptError
+        nil
+      end
+    end
+    
+    def get_binding
+      @state.context.frame_binding(@state.frame_pos)
+    end
+
+    def line_at(file, line)
+      Debugger.line_at(file, line)
+    end
+
+    def get_context(thnum)
+      Debugger.contexts.find{|c| c.thnum == thnum}
+    end
+
+    def realpath(filename)
+      is_dir = filename.end_with?(File::SEPARATOR)
+      if filename.index(File::SEPARATOR) || File::ALT_SEPARATOR && filename.index(File::ALT_SEPARATOR)
+        filename = File.expand_path(filename)
+      end
+      if (RUBY_VERSION < '1.9') || (RbConfig::CONFIG['host_os'] =~ /mswin/)
+        filename
+      else
+        filename = File.realpath(filename) rescue filename
+        filename = filename + File::SEPARATOR if is_dir && !filename.end_with?(File::SEPARATOR)
+        filename
+      end
+    end
+  end
+  
+  Command.load_commands
+end

data/lib/ruby-debug-ide/commands/breakpoints.rb

@@ -0,0 +1,128 @@
+module Debugger
+  class AddBreakpoint < Command # :nodoc:
+    self.control = true
+    
+    def regexp
+      / ^\s*
+        b(?:reak)?
+        (?: \s+
+        (?:
+          (\d+) |
+          (.+?)[:.#]([^.:\s]+)
+        ))?
+        (?:\s+
+          if\s+(.+)
+        )?
+        $
+      /x
+    end
+
+    def execute
+      if @match[1]
+        line, _, _, expr = @match.captures
+      else
+        _, file, line, expr = @match.captures
+      end
+
+      if file.nil?
+        file = File.basename(@state.file)
+      else
+        if line !~ /^\d+$/
+          klass = debug_silent_eval(file)
+          if klass && !klass.kind_of?(Module)
+            print_error "Unknown class #{file}"
+            throw :debug_error
+          end
+          file = klass.name if klass
+        else
+          file = realpath(file)
+        end
+      end
+      
+      if line =~ /^\d+$/
+        line = line.to_i
+      else
+        line = line.intern.id2name
+      end
+      
+      b = Debugger.add_breakpoint file, line, expr
+      print_breakpoint_added b
+    end
+
+    class << self
+      def help_command
+        'break'
+      end
+
+      def help(cmd)
+        %{
+          b[reak] file:line [if expr]
+          b[reak] [file|class(:|.|#)]<line|method> [if expr] -
+          \tset breakpoint to some position, (optionally) if expr == true
+        }
+      end
+    end
+  end
+
+  class BreakpointsCommand < Command # :nodoc:
+    self.control = true
+
+    def regexp
+      /^\s*info\s*break$/
+    end
+
+    def execute
+      print_breakpoints Debugger.breakpoints
+    end
+
+    class << self
+      def help_command
+        'break'
+      end
+
+      def help(cmd)
+        %{
+          b[reak]\tlist breakpoints
+        }
+      end
+    end
+  end
+
+  class DeleteBreakpointCommand < Command # :nodoc:
+    self.control = true
+
+    def regexp
+      /^\s*del(?:ete)?(?:\s+(.*))?$/
+    end
+
+    def execute
+      brkpts = @match[1]
+      unless brkpts
+          Debugger.breakpoints.clear
+      else
+        brkpts.split(/[ \t]+/).each do |pos|
+          pos = get_int(pos, "Delete", 1)
+          return unless pos
+          b = Debugger.remove_breakpoint(pos)
+          if b
+            print_breakpoint_deleted b
+          else
+            print_error "No breakpoint number %d\n", pos
+          end
+        end
+      end
+    end
+
+    class << self
+      def help_command
+        'delete'
+      end
+
+      def help(cmd)
+        %{
+          del[ete][ nnn...]\tdelete some or all breakpoints
+        }
+      end
+    end
+  end
+end

data/lib/ruby-debug-ide/commands/catchpoint.rb

@@ -0,0 +1,64 @@
+module Debugger
+  class CatchCommand < Command # :nodoc:
+    self.control = true
+
+    def regexp
+      /^\s* cat(?:ch)? 
+           (?:\s+ (\S+))? 
+           (?:\s+ (off))? \s* $/ix
+    end
+
+    def execute
+      excn = @match[1] 
+      if not excn
+        # No args given.
+        errmsg "Exception class must be specified for 'catch' command"
+      elsif not @match[2]
+        # One arg given.
+        if 'off' == excn
+          clear_catchpoints
+        else
+          Debugger.add_catchpoint(excn)
+          print_catchpoint_set(excn)
+        end
+      elsif @match[2] != 'off'
+        errmsg "Off expected. Got %s\n", @match[2]
+      elsif remove_catchpoint(excn)
+        print_catchpoint_deleted(excn)
+      else
+        errmsg "Catch for exception %s not found.\n", excn
+      end
+    end
+
+    class << self
+      def help_command
+        'catch'
+      end
+
+      def help(cmd)
+        %{
+          cat[ch]\t\t\tshow catchpoint
+          cat[ch] off \tremove all catch points
+          cat[ch] <an Exception>\tset catchpoint to an exception
+          cat[ch] <an Exception> off \tremove catchpoint for an exception
+        }
+      end
+    end
+
+    private
+
+    def clear_catchpoints
+      if Debugger.respond_to?(:clear_catchpoints)
+        Debugger.clear_catchpoints
+      else
+        Debugger.catchpoints.clear
+      end
+    end
+
+    def remove_catchpoint(excn)
+      return Debugger.remove_catchpoint(excn) if Debugger.respond_to?(:remove_catchpoint)
+      return Debugger.catchpoints.delete(excn) if Debugger.catchpoints.member?(excn)
+      false
+    end
+  end
+end