debug 1.0.0.alpha1 → 1.0.0.beta1

data/lib/debug/client.rb

@@ -2,6 +2,8 @@ require 'socket'
 require_relative 'config'
 
 module DEBUGGER__
+  class CommandLineOptionError < Exception; end
+
   class Client
     begin
       require 'readline'
@@ -15,14 +17,6 @@ module DEBUGGER__
       end
     end
 
-    def help
-      puts "-run -e attach       # connect via UNIX Domain socket"
-      puts "-run -e attach name  # connect via UNIX Domain socket with specified name"
-      puts "-run -e attach port_num  # connect via TCP/IP socket with specified port"
-      puts "-run -e attach host port_num"
-      puts "               # connect via TCP/IP socket with specified host and port"
-    end
-
     def initialize argv
       case argv.size
       when 0
@@ -40,8 +34,7 @@ module DEBUGGER__
       when 2
         connect_tcp argv[0], argv[1]
       else
-        help
-        exit!
+        raise CommandLineOptionError
       end
     end
 
@@ -69,7 +62,7 @@ module DEBUGGER__
         files = Dir.glob(DEBUGGER__.create_unix_domain_socket_name_prefix + '*')
         case files.size
         when 0
-          $stderr.puts "There is no debug sessions."
+          $stderr.puts "No debug session is available."
           exit
         when 1
           @s = Socket.unix(files.first)

data/lib/debug/config.rb

@@ -1,12 +1,17 @@
+
 module DEBUGGER__
-  def self.unix_domain_socket_basedir
+  def self.unix_domain_socket_dir
     case
-    when path = ENV['RUBY_DEBUG_SOCK_DIR']
+    when path = DEBUGGER__::CONFIG[:sock_dir]
     when path = ENV['XDG_RUNTIME_DIR']
     when home = ENV['HOME']
       path = File.join(home, '.ruby-debug-sock')
-      unless File.exist?(path)
+
+      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.'
@@ -15,12 +20,100 @@ module DEBUGGER__
     path
   end
 
-  def self.create_unix_domain_socket_name_prefix
+  def self.create_unix_domain_socket_name_prefix(base_dir = unix_domain_socket_dir)
     user = ENV['USER'] || 'ruby-debug'
-    File.join(unix_domain_socket_basedir, "ruby-debug-#{user}")
+    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
 
-  def self.create_unix_domain_socket_name
-    create_unix_domain_socket_name_prefix + "-#{Process.pid}"
+  CONFIG_MAP = {
+    # execution preferences
+    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 ';;'
+    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).
+
+    # 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 beggining of the script.') do
+        config[:nonstop] = '1'
+      end
+
+      o.on('-e [COMMAND]', 'execute debug command at the beggining of the script.') do |cmd|
+        config[:commands] ||= ''
+        config[:commands] << cmd + ';;'
+      end
+
+      o.on('-O', '--open', 'Start debuggee with opning the debagger 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
+
+      o.separator ''
+      o.separator '  Debug console mode runs Ruby program with the debug console.'
+      o.separator ''
+      o.separator "  #{$0} target.rb foo bar                 starts like 'ruby target.rb foo bar'."
+      o.separator "  #{$0} -- -r foo -e bar                  starts like 'ruby -r foo -e bar'."
+      o.separator "  #{$0} -O target.rb foo bar              starts and accepts attaching with UNIX domain socket."
+      o.separator "  #{$0} -O --port 1234 target.rb foo bar  starts accepts attaching with TCP/IP localhost:1234."
+      o.separator "  #{$0} -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 "  '#{$0} -A' tries to connect via UNIX domain socket."
+      o.separator "  #{' ' * $0.size}            If there are multiple processes are waiting for the"
+      o.separator "  #{' ' * $0.size}            debugger connection, list possible debuggee names."
+      o.separator "  '#{$0} -A path' tries to connect via UNIX domain socket with given path name."
+      o.separator "  '#{$0} -A port' tries to connect localhost:port via TCP/IP."
+      o.separator "  '#{$0} -A host port' tris to connect 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

@@ -1,40 +1,54 @@
 require 'socket'
 require_relative 'session'
+require_relative 'config'
 
 module DEBUGGER__
-  class UI_Server
+  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|
-          @sock = 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
 
-            begin
-              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
+            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
@@ -42,11 +56,14 @@ module DEBUGGER__
       end
     end
 
+    def remote?
+      true
+    end
 
     def setup_interrupt
       prev_handler = trap(:SIGINT) do
         # $stderr.puts "trapped SIGINT"
-        ThreadClient.current.on_trap
+        ThreadClient.current.on_trap :SIGINT
 
         case prev_handler
         when Proc
@@ -69,8 +86,23 @@ module DEBUGGER__
 
     class NoRemoteError < Exception; end
 
-    def sock
-      yield @sock if @sock
+    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
@@ -82,17 +114,24 @@ module DEBUGGER__
       end
     end
 
-    def puts str
+    def puts str = nil
       case str
       when Array
         enum = str.each
       when String
         enum = str.each_line
+      when nil
+        enum = [''].each
       end
 
-      sock do |s|
+      sock skip: true do |s|
         enum.each do |line|
-          s.puts "out #{line.chomp}"
+          msg = "out #{line.chomp}"
+          if s
+            s.puts msg
+          else
+            @unsent_messages << msg
+          end
         end
       end
     end
@@ -116,4 +155,72 @@ module DEBUGGER__
       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