Love for remote debugging

.rubocop.yml

@@ -18,19 +18,7 @@ Layout/ExtraSpacing:
 Lint/InterpolationCheck:
   Enabled: false
 
-Metrics/AbcSize:
-  Enabled: false
-
-Metrics/ClassLength:
-  Enabled: false
-
-Metrics/CyclomaticComplexity:
-  Enabled: false
-
-Metrics/MethodLength:
-  Enabled: false
-
-Metrics/PerceivedComplexity:
+Metrics:
   Enabled: false
 
 TrivialAccessors:

CHANGELOG.md

@@ -7,10 +7,14 @@
 * Show valid breakpoint locations when invalid location given (#393, @ko1).
 * Ruby 2.5.0 support (#397, @yui-knk).
 * Log host & port when launching byebug's client in remote mode.
+* Some love & tests to remote debugging (#82).
+* `remote_byebug` shortcut to start the most common case for remote debugging (#141).
 
 ## Fixed
 
 * Properly ignore ruby fullpath executable when passed to byebug script (#419).
+* Remote server crash when interrupting client (#141, #274).
+* Control server thread being able to `interrupt` main thread only a single time. (#239).
 
 ## 9.1.0 - 2017-08-22
 

bin/ci.sh

@@ -1,4 +1,8 @@
 #!/usr/bin/env bash
 
+set +x
+
 bin/bundle install --jobs 3 --retry 3 --path .bundle/gems
 bin/rake
+
+set -x

lib/byebug/attacher.rb

@@ -5,8 +5,7 @@
 #
 module Byebug
   #
-  # Enters byebug right before (or right after if _before_ is false) return
-  # events occur. Before entering byebug the init script is read.
+  # Starts byebug, and stops at the first line of user's code.
   #
   def self.attach
     require "byebug/core"
@@ -20,6 +19,13 @@ def self.attach
 
     current_context.step_out(3, true)
   end
+
+  def self.spawn(host = "localhost", port = nil)
+    require "byebug/core"
+
+    self.wait_connection = true
+    start_server(host, port || PORT)
+  end
 end
 
 #
@@ -32,5 +38,11 @@ def byebug
     Byebug.attach
   end
 
+  def remote_byebug(host = "localhost", port = nil)
+    Byebug.spawn(host, port)
+
+    Byebug.attach
+  end
+
   alias debugger byebug
 end

lib/byebug/commands/interrupt.rb

@@ -26,6 +26,8 @@ def self.short_description
     end
 
     def execute
+      Byebug.start
+
       Byebug.thread_context(Thread.main).interrupt
     end
   end

lib/byebug/interfaces/remote_interface.rb

@@ -16,25 +16,35 @@ def initialize(socket)
 
     def read_command(prompt)
       super("PROMPT #{prompt}")
+    rescue Errno::EPIPE, Errno::ECONNABORTED
+      "continue"
     end
 
     def confirm(prompt)
       super("CONFIRM #{prompt}")
+    rescue Errno::EPIPE, Errno::ECONNABORTED
+      false
+    end
+
+    def print(message)
+      super(message)
+    rescue Errno::EPIPE, Errno::ECONNABORTED
+      nil
+    end
+
+    def puts(message)
+      super(message)
+    rescue Errno::EPIPE, Errno::ECONNABORTED
+      nil
     end
 
     def close
       output.close
-    rescue IOError
-      errmsg("Error closing the interface...")
     end
 
     def readline(prompt)
-      output.puts(prompt)
-
-      result = input.gets
-      raise IOError unless result
-
-      result.chomp
+      puts(prompt)
+      (input.gets || "continue").chomp
     end
   end
 end

lib/byebug/processors/command_processor.rb

@@ -118,7 +118,6 @@ def before_repl
 
     def after_repl
       interface.autosave
-      interface.close
     end
 
     #

lib/byebug/processors/script_processor.rb

@@ -25,6 +25,12 @@ def repl
       end
     end
 
+    def after_repl
+      super
+
+      interface.close
+    end
+
     #
     # Prompt shown before reading a command.
     #

lib/byebug/remote.rb

@@ -2,12 +2,12 @@
 
 require "socket"
 require "byebug/processors/control_processor"
+require "byebug/remote/server"
+require "byebug/remote/client"
 
 #
 # Remote debugging functionality.
 #
-# @todo Refactor & add tests
-#
 module Byebug
   # Port number used for remote debugging
   PORT = 8989 unless defined?(PORT)
@@ -17,8 +17,14 @@ class << self
     attr_accessor :wait_connection
 
     # The actual port that the server is started at
-    attr_accessor :actual_port
-    attr_reader :actual_control_port
+    def actual_port
+      server.actual_port
+    end
+
+    # The actual port that the control server is started at
+    def actual_control_port
+      control.actual_port
+    end
 
     #
     # Interrupts the current thread
@@ -28,81 +34,52 @@ def interrupt
     end
 
     #
-    # Starts a remote byebug
+    # Starts the remote server main thread
     #
     def start_server(host = nil, port = PORT)
-      return if @thread
-
-      Context.interface = nil
-      start
-
       start_control(host, port.zero? ? 0 : port + 1)
 
-      mutex = Mutex.new
-      proceed = ConditionVariable.new
-
-      server = TCPServer.new(host, port)
-      self.actual_port = server.addr[1]
-
-      yield if block_given?
-
-      @thread = DebugThread.new do
-        while (session = server.accept)
-          Context.interface = RemoteInterface.new(session)
-          mutex.synchronize { proceed.signal } if wait_connection
-        end
-      end
-
-      mutex.synchronize { proceed.wait(mutex) } if wait_connection
+      server.start(host, port)
     end
 
-    def start_control(host = nil, ctrl_port = PORT + 1)
-      return @actual_control_port if @control_thread
-      server = TCPServer.new(host, ctrl_port)
-      @actual_control_port = server.addr[1]
-
-      @control_thread = DebugThread.new do
-        while (session = server.accept)
-          context = Byebug.current_context
-          interface = RemoteInterface.new(session)
-
-          ControlProcessor.new(context, interface).process_commands
-        end
-      end
-
-      @actual_control_port
+    #
+    # Starts the remote server control thread
+    #
+    def start_control(host = nil, port = PORT + 1)
+      control.start(host, port)
     end
 
     #
     # Connects to the remote byebug
     #
     def start_client(host = "localhost", port = PORT)
-      interface = LocalInterface.new
-      puts "Connecting to byebug server at #{host}:#{port}..."
-      socket = TCPSocket.new(host, port)
-      puts "Connected."
-
-      while (line = socket.gets)
-        case line
-        when /^PROMPT (.*)$/
-          input = interface.read_command(Regexp.last_match[1])
-          break unless input
-          socket.puts input
-        when /^CONFIRM (.*)$/
-          input = interface.readline(Regexp.last_match[1])
-          break unless input
-          socket.puts input
-        else
-          puts line
-        end
-      end
-
-      socket.close
+      client.start(host, port)
     end
 
     def parse_host_and_port(host_port_spec)
       location = host_port_spec.split(":")
       location[1] ? [location[0], location[1].to_i] : ["localhost", location[0]]
     end
+
+    private
+
+    def client
+      @client ||= Remote::Client.new(Context.interface)
+    end
+
+    def server
+      @server ||= Remote::Server.new(wait_connection: wait_connection) do |s|
+        Context.interface = RemoteInterface.new(s)
+      end
+    end
+
+    def control
+      @control ||= Remote::Server.new(wait_connection: false) do |s|
+        context = Byebug.current_context
+        interface = RemoteInterface.new(s)
+
+        ControlProcessor.new(context, interface).process_commands
+      end
+    end
   end
 end

lib/byebug/remote/client.rb

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+require "socket"
+
+module Byebug
+  module Remote
+    #
+    # Client for remote debugging
+    #
+    class Client
+      attr_reader :interface
+
+      def initialize(interface)
+        @interface = interface
+      end
+
+      #
+      # Connects to the remote byebug
+      #
+      def start(host = "localhost", port = PORT)
+        socket = connect_at(host, port)
+
+        while (line = socket.gets)
+          case line
+          when /^PROMPT (.*)$/
+            input = interface.read_command(Regexp.last_match[1])
+            break unless input
+            socket.puts input
+          when /^CONFIRM (.*)$/
+            input = interface.readline(Regexp.last_match[1])
+            break unless input
+            socket.puts input
+          else
+            interface.puts line
+          end
+        end
+
+        socket.close
+      end
+
+      private
+
+      def connect_at(host, port)
+        interface.puts "Connecting to byebug server at #{host}:#{port}..."
+        socket = TCPSocket.new(host, port)
+        interface.puts "Connected."
+        socket
+      end
+    end
+  end
+end

lib/byebug/remote/server.rb

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+require "socket"
+
+module Byebug
+  module Remote
+    #
+    # Server for remote debugging
+    #
+    class Server
+      attr_reader :actual_port, :wait_connection
+
+      def initialize(wait_connection:, &block)
+        @thread = nil
+        @wait_connection = wait_connection
+        @main_loop = block
+      end
+
+      #
+      # Start the remote debugging server
+      #
+      def start(host, port)
+        return if @thread
+
+        if wait_connection
+          mutex = Mutex.new
+          proceed = ConditionVariable.new
+        end
+
+        server = TCPServer.new(host, port)
+        @actual_port = server.addr[1]
+
+        yield if block_given?
+
+        @thread = DebugThread.new do
+          while (session = server.accept)
+            @main_loop.call(session)
+
+            mutex.synchronize { proceed.signal } if wait_connection
+          end
+        end
+
+        mutex.synchronize { proceed.wait(mutex) } if wait_connection
+      end
+    end
+  end
+end