debug 0.2.0 → 1.0.0.beta3

data/lib/debug/config.rb

@@ -0,0 +1,125 @@
+
+module DEBUGGER__
+  def self.unix_domain_socket_dir
+    case
+    when path = DEBUGGER__::CONFIG[:sock_dir]
+    when path = ENV['XDG_RUNTIME_DIR']
+    when home = ENV['HOME']
+      path = File.join(home, '.ruby-debug-sock')
+
+      case
+      when !File.exist?(path)
+        Dir.mkdir(path, 0700)
+      when !File.directory?(path)
+        raise "#{path} is not a directory."
+      end
+    else
+      raise 'specify RUBY_DEBUG_SOCK_DIR environment variable for UNIX domain socket directory.'
+    end
+
+    path
+  end
+
+  def self.create_unix_domain_socket_name_prefix(base_dir = unix_domain_socket_dir)
+    user = ENV['USER'] || 'ruby-debug'
+    File.join(base_dir, "ruby-debug-#{user}")
+  end
+
+  def self.create_unix_domain_socket_name(base_dir = unix_domain_socket_dir)
+    create_unix_domain_socket_name_prefix(base_dir) + "-#{Process.pid}"
+  end
+
+  CONFIG_MAP = {
+    # boot setting
+    nonstop:     'RUBY_DEBUG_NONSTOP',     # Nonstop mode ('1' is nonstop)
+    init_script: 'RUBY_DEBUG_INIT_SCRIPT', # debug command script path loaded at first stop
+    commands:    'RUBY_DEBUG_COMMANDS',    # debug commands invoked at first stop. commands should be separated by ';;'
+
+    # UI setting
+    show_src_lines: 'RUBY_DEBUG_SHOW_SRC_LINES', # Show n lines source code on breakpoint (default: 10 lines).
+    show_frames:    'RUBY_DEBUG_SHOW_FRAMES',    # Show n frames on breakpoint (default: 2 frames).
+    use_short_path: 'RUBY_DEBUG_USE_SHORT_PATH', # Show shoten PATH (like $(Gem)/foo.rb).
+    skip_nosrc:     'RUBY_DEBUG_SKIP_NOSRC',     # Skip on no source code lines (default: false).
+
+    # remote
+    port:        'RUBY_DEBUG_PORT',        # TCP/IP remote debugging: port
+    host:        'RUBY_DEBUG_HOST',        # TCP/IP remote debugging: host (localhost if not given)
+    sock_dir:    'RUBY_DEBUG_SOCK_DIR',    # UNIX Domain Socket remote debugging: socket directory
+  }.freeze
+
+  def self.config_to_env config
+    CONFIG_MAP.each{|key, evname|
+      ENV[evname] = config[key]
+    }
+  end
+
+  def self.parse_argv argv
+    config = {
+      mode: :start,
+    }
+    CONFIG_MAP.each{|key, evname|
+      config[key] = ENV[evname] if ENV[evname]
+    }
+    return config if !argv || argv.empty?
+
+    require 'optparse'
+
+    opt = OptionParser.new do |o|
+      o.banner = "#{$0} [options] -- [debuggee options]"
+      o.separator ''
+
+      o.separator 'Debug console mode:'
+      o.on('-n', '--nonstop', 'Do not stop at the beginning of the script.') do
+        config[:nonstop] = '1'
+      end
+
+      o.on('-e [COMMAND]', 'execute debug command at the beginning of the script.') do |cmd|
+        config[:commands] ||= ''
+        config[:commands] << cmd + ';;'
+      end
+
+      o.on('-O', '--open', 'Start debuggee with opening the debugger port.',
+                           'If TCP/IP options are not given,',
+                           'a UNIX domain socket will be used.') do
+        config[:remote] = true
+      end
+      o.on('--port=[PORT]', 'Listening TCP/IP port') do |port|
+        config[:port] = port
+      end
+      o.on('--host=[HOST]', 'Listening TCP/IP host') do |host|
+        config[:host] = host
+      end
+
+      rdbg = 'rdbg'
+
+      o.separator ''
+      o.separator '  Debug console mode runs Ruby program with the debug console.'
+      o.separator ''
+      o.separator "  #{rdbg} target.rb foo bar                 starts like 'ruby target.rb foo bar'."
+      o.separator "  #{rdbg} -- -r foo -e bar                  starts like 'ruby -r foo -e bar'."
+      o.separator "  #{rdbg} -O target.rb foo bar              starts and accepts attaching with UNIX domain socket."
+      o.separator "  #{rdbg} -O --port 1234 target.rb foo bar  starts accepts attaching with TCP/IP localhost:1234."
+      o.separator "  #{rdbg} -O --port 1234 -- -r foo -e bar   starts accepts attaching with TCP/IP localhost:1234."
+
+      o.separator ''
+      o.separator 'Attach mode:'
+      o.on('-A', '--attach', 'Attach to debuggee process.') do
+        config[:mode] = :attach
+      end
+
+      o.separator ''
+      o.separator '  Attach mode attaches the remote debug console to the debuggee process.'
+      o.separator ''
+      o.separator "  '#{rdbg} -A' tries to connect via UNIX domain socket."
+      o.separator "  #{' ' * rdbg.size}      If there are multiple processes are waiting for the"
+      o.separator "  #{' ' * rdbg.size}      debugger connection, list possible debuggee names."
+      o.separator "  '#{rdbg} -A path' tries to connect via UNIX domain socket with given path name."
+      o.separator "  '#{rdbg} -A port' tries to connect to localhost:port via TCP/IP."
+      o.separator "  '#{rdbg} -A host port' tries to connect to host:port via TCP/IP."
+    end
+
+    opt.parse!(argv)
+
+    config
+  end
+end

data/lib/debug/console.rb

@@ -0,0 +1,89 @@
+require_relative 'session'
+
+module DEBUGGER__
+  class UI_Console
+    def initialize
+    end
+
+    def remote?
+      false
+    end
+
+    def quit n
+      exit n
+    end
+
+    def ask prompt
+      setup_interrupt do
+        print prompt
+        (gets || '').strip
+      end
+    end
+
+    def puts str = nil
+      case str
+      when Array
+        str.each{|line|
+          $stdout.puts line.chomp
+        }
+      when String
+        str.each_line{|line|
+          $stdout.puts line.chomp
+        }
+      when nil
+        $stdout.puts
+      end
+    end
+
+    begin
+      require 'readline'
+
+      def readline_setup
+        Readline.completion_proc = proc{|given|
+          buff = Readline.line_buffer
+          Readline.completion_append_character= ' '
+
+          if /\s/ =~ buff # second parameters
+            given = File.expand_path(given + 'a').sub(/a\z/, '')
+            files = Dir.glob(given + '*')
+            if files.size == 1 && File.directory?(files.first)
+              Readline.completion_append_character= '/'
+            end
+            files
+          else
+            DEBUGGER__.commands.grep(/\A#{given}/)
+          end
+        }
+      end
+
+      def readline_body
+        readline_setup
+        Readline.readline("\n(rdbg) ", true)
+      end
+    rescue LoadError
+      def readline_body
+        print "\n(rdbg) "
+        gets
+      end
+    end
+
+    def readline
+      setup_interrupt do
+        (readline_body || 'quit').strip
+      end
+    end
+
+    def setup_interrupt
+      current_thread = Thread.current # should be session_server thread
+
+      prev_handler = trap(:INT){
+        current_thread.raise Interrupt
+      }
+
+      yield
+    ensure
+      trap(:INT, prev_handler)
+    end
+  end
+end
+

data/lib/debug/open.rb

@@ -0,0 +1,10 @@
+#
+# Open the door for the debugger to connect.
+# Users can connect to debuggee program with "rdbg --attach" option.
+#
+# If RUBY_DEBUG_PORT envval is provided (digits), open TCP/IP port.
+# Otherwise, UNIX domain socket is used.
+#
+
+require_relative 'server'
+DEBUGGER__.open

data/lib/debug/run.rb

@@ -0,0 +1,2 @@
+require_relative 'console'
+DEBUGGER__.console

data/lib/debug/server.rb

@@ -0,0 +1,226 @@
+require 'socket'
+require_relative 'session'
+require_relative 'config'
+
+module DEBUGGER__
+  class UI_ServerBase
+    def initialize
+      @sock = nil
+      @accept_m = Mutex.new
+      @accept_cv = ConditionVariable.new
+      @client_addr = nil
+      @q_msg = Queue.new
+      @q_ans = Queue.new
+      @unsent_messages = []
+
+      @reader_thread = Thread.new do
+        accept do |server|
+          DEBUGGER__.message "Connected."
+
+          @accept_m.synchronize{
+            @sock = server
+            @accept_cv.signal
+
+            # flush unsent messages
+            @unsent_messages.each{|m|
+              @sock.puts m
+            }
+            @unsent_messages.clear
+          }
+          @q_msg = Queue.new
+          @q_ans = Queue.new
+
+          setup_interrupt do
+            pause
+
+            while line = @sock.gets
+              case line
+              when /\Apause/
+                pause
+              when /\Acommand ?(.+)/
+                @q_msg << $1
+              when /\Aanswer (.*)/
+                @q_ans << $1
+              else
+                STDERR.puts "unsupported: #{line}"
+                exit!
+              end
+            end
+          end
+        ensure
+          DEBUGGER__.message "Disconnected."
+          @sock = nil
+          @q_msg.close
+          @q_ans.close
+        end
+      end
+    end
+
+    def remote?
+      true
+    end
+
+    def setup_interrupt
+      prev_handler = trap(:SIGINT) do
+        # $stderr.puts "trapped SIGINT"
+        ThreadClient.current.on_trap :SIGINT
+
+        case prev_handler
+        when Proc
+          prev_handler.call
+        else
+          # ignore
+        end
+      end
+
+      yield
+    ensure
+      trap(:SIGINT, prev_handler)
+    end
+
+    def accept
+      raise "NOT IMPLEMENTED ERROR"
+    end
+
+    attr_reader :reader_thread
+
+    class NoRemoteError < Exception; end
+
+    def sock skip: false
+      if s = @sock         # already connection
+        # ok
+      elsif skip == true   # skip process
+        return yield nil
+      else                 # wait for connection
+        until s = @sock
+          @accept_m.synchronize{
+            unless @sock
+              DEBUGGER__.message "wait for debuger connection..."
+              @accept_cv.wait(@accept_m)
+            end
+          }
+        end
+      end
+
+      yield s
+    rescue Errno::EPIPE
+      # ignore
+    end
+
+    def ask prompt
+      sock do |s|
+        s.puts "ask #{prompt}"
+        @q_ans.pop
+      end
+    end
+
+    def puts str = nil
+      case str
+      when Array
+        enum = str.each
+      when String
+        enum = str.each_line
+      when nil
+        enum = [''].each
+      end
+
+      sock skip: true do |s|
+        enum.each do |line|
+          msg = "out #{line.chomp}"
+          if s
+            s.puts msg
+          else
+            @unsent_messages << msg
+          end
+        end
+      end
+    end
+
+    def readline
+      (sock do |s|
+        s.puts "input"
+        @q_msg.pop
+      end || 'continue').strip
+    end
+
+    def pause
+      # $stderr.puts "DEBUG: pause request"
+      Process.kill(:SIGINT, Process.pid)
+    end
+
+    def quit n
+      # ignore n
+      sock do |s|
+        s.puts "quit"
+      end
+    end
+  end
+
+  class UI_TcpServer < UI_ServerBase
+    def initialize host: nil, port: nil
+      @host = host || ::DEBUGGER__::CONFIG[:host] || 'localhost'
+      @port = port || begin
+        port_str = ::DEBUGGER__::CONFIG[:port] || raise("Specify listening port by RUBY_DEBUG_PORT environment variable.")
+        if /\A\d+\z/ !~ port_str
+          raise "Specify digits for port number"
+        else
+          port_str.to_i
+        end
+      end
+
+      super()
+    end
+
+    def accept
+      Socket.tcp_server_sockets @host, @port do |socks|
+        ::DEBUGGER__.message "Debugger can attach via TCP/IP (#{socks.map{|e| e.local_address.inspect}})"
+        Socket.accept_loop(socks) do |sock, client|
+          @client_addr = client
+          yield sock
+        end
+      end
+    rescue => e
+      $stderr.puts e.message
+      pp e.backtrace
+      exit
+    end
+  end
+
+  class UI_UnixDomainServer < UI_ServerBase
+    def initialize sock_dir: nil
+      @sock_dir = sock_dir || DEBUGGER__.unix_domain_socket_dir
+
+      super()
+    end
+
+    def accept
+      @file = DEBUGGER__.create_unix_domain_socket_name(@sock_dir)
+
+      ::DEBUGGER__.message "Debugger can attach via UNIX domain socket (#{@file})"
+      Socket.unix_server_loop @file do |sock, client|
+        @client_addr = client
+        yield sock
+      end
+    end
+  end
+
+  def self.open host: nil, port: ::DEBUGGER__::CONFIG[:port], sock_dir: nil
+    if port
+      open_tcp host: host, port: port
+    else
+      open_unix sock_dir: sock_dir
+    end
+  end
+
+  def self.open_tcp(host: nil, port:)
+    initialize_session UI_TcpServer.new(host: host, port: port)
+  end
+
+  def self.open_unix sock_dir: nil
+    initialize_session UI_UnixDomainServer.new(sock_dir: sock_dir)
+  end
+
+  def self.message msg
+    $stderr.puts "DEBUGGER: #{msg}"
+  end
+end