debug 1.6.2 → 1.7.0

data/lib/debug/server_cdp.rb

@@ -7,13 +7,18 @@ require 'securerandom'
 require 'stringio'
 require 'open3'
 require 'tmpdir'
+require 'tempfile'
+require 'timeout'
 
 module DEBUGGER__
   module UI_CDP
     SHOW_PROTOCOL = ENV['RUBY_DEBUG_CDP_SHOW_PROTOCOL'] == '1'
 
+    class UnsupportedError < StandardError; end
+    class NotFoundChromeEndpointError < StandardError; end
+
     class << self
-      def setup_chrome addr
+      def setup_chrome addr, uuid
         return if CONFIG[:chrome_path] == ''
 
         port, path, pid = run_new_chrome
@@ -39,6 +44,8 @@ module DEBUGGER__
                           }
           when res['id'] == 2
             s_id = res.dig('result', 'sessionId')
+            # TODO: change id
+            ws_client.send sessionId: s_id, id: 100, method: 'Network.enable'
             ws_client.send sessionId: s_id, id: 3,
                           method: 'Page.enable'
           when res['id'] == 3
@@ -51,57 +58,191 @@ module DEBUGGER__
             ws_client.send sessionId: s_id, id: 5,
                           method: 'Page.navigate',
                           params: {
-                            url: "devtools://devtools/bundled/inspector.html?v8only=true&panel=sources&ws=#{addr}/#{SecureRandom.uuid}",
+                            url: "devtools://devtools/bundled/inspector.html?v8only=true&panel=sources&ws=#{addr}/#{uuid}",
                             frameId: f_id
                           }
-          when res['method'] == 'Page.loadEventFired'
+          when res['method'] == 'Network.webSocketWillSendHandshakeRequest'
+            s_id = res['sessionId']
+            # Display the console by entering ESC key
+            ws_client.send sessionId: s_id, id: 101,  # TODO: change id
+                          method:"Input.dispatchKeyEvent",
+                          params: {
+                            type:"keyDown",
+                            windowsVirtualKeyCode:27 # ESC key
+                          }
+          when res['id'] == 101
             break
           end
         end
         pid
-      rescue Errno::ENOENT
+      rescue Errno::ENOENT, UnsupportedError, NotFoundChromeEndpointError
         nil
       end
 
-      def get_chrome_path
-        return CONFIG[:chrome_path] if CONFIG[:chrome_path]
+      TIMEOUT_SEC = 5
+
+      def run_new_chrome
+        path = CONFIG[:chrome_path]
+
+        data = nil
+        port = nil
+        wait_thr = nil
 
         # The process to check OS is based on `selenium` project.
         case RbConfig::CONFIG['host_os']
         when /mswin|msys|mingw|cygwin|emc/
-          'C:\Program Files (x86)\Google\Chrome\Application\chrome.exe'
+          if path.nil?
+            candidates = ['C:\\Program Files (x86)\\Google\\Chrome\\Application\\chrome.exe', 'C:\\Program Files\\Google\\Chrome\\Application\\chrome.exe']
+            path = get_chrome_path candidates
+          end
+          uuid = SecureRandom.uuid
+          # The path is based on https://github.com/sindresorhus/open/blob/v8.4.0/index.js#L128.
+          stdin, stdout, stderr, wait_thr = *Open3.popen3("#{ENV['SystemRoot']}\\System32\\WindowsPowerShell\\v1.0\\powershell")
+          tf = Tempfile.create(['debug-', '.txt'])
+
+          stdin.puts("Start-process '#{path}' -Argumentlist '--remote-debugging-port=0', '--no-first-run', '--no-default-browser-check', '--user-data-dir=C:\\temp' -Wait -RedirectStandardError #{tf.path}")
+          stdin.close
+          stdout.close
+          stderr.close
+          port, path = get_devtools_endpoint(tf.path)
+
+          at_exit{
+            DEBUGGER__.skip_all
+
+            stdin, stdout, stderr, wait_thr = *Open3.popen3("#{ENV['SystemRoot']}\\System32\\WindowsPowerShell\\v1.0\\powershell")
+            stdin.puts("Stop-process -Name chrome")
+            stdin.close
+            stdout.close
+            stderr.close
+            tf.close
+            begin
+              File.unlink(tf)
+            rescue Errno::EACCES
+            end
+          }
         when /darwin|mac os/
-          '/Applications/Google\ Chrome.app/Contents/MacOS/Google\ Chrome'
+          path = path || '/Applications/Google\ Chrome.app/Contents/MacOS/Google\ Chrome'
+          dir = Dir.mktmpdir
+          # The command line flags are based on: https://developer.mozilla.org/en-US/docs/Tools/Remote_Debugging/Chrome_Desktop#connecting.
+          stdin, stdout, stderr, wait_thr = *Open3.popen3("#{path} --remote-debugging-port=0 --no-first-run --no-default-browser-check --user-data-dir=#{dir}")
+          stdin.close
+          stdout.close
+          data = stderr.readpartial 4096
+          stderr.close
+          if data.match /DevTools listening on ws:\/\/127.0.0.1:(\d+)(.*)/
+            port = $1
+            path = $2
+          end
+
+          at_exit{
+            DEBUGGER__.skip_all
+            FileUtils.rm_rf dir
+          }
         when /linux/
-          'google-chrome'
+          path = path || 'google-chrome'
+          dir = Dir.mktmpdir
+          # The command line flags are based on: https://developer.mozilla.org/en-US/docs/Tools/Remote_Debugging/Chrome_Desktop#connecting.
+          stdin, stdout, stderr, wait_thr = *Open3.popen3("#{path} --remote-debugging-port=0 --no-first-run --no-default-browser-check --user-data-dir=#{dir}")
+          stdin.close
+          stdout.close
+          data = ''
+          begin
+            Timeout.timeout(TIMEOUT_SEC) do
+              until data.match?(/DevTools listening on ws:\/\/127.0.0.1:\d+.*/)
+                data = stderr.readpartial 4096
+              end
+            end
+          rescue Exception
+            raise NotFoundChromeEndpointError
+          end
+          stderr.close
+          if data.match /DevTools listening on ws:\/\/127.0.0.1:(\d+)(.*)/
+            port = $1
+            path = $2
+          end
+
+          at_exit{
+            DEBUGGER__.skip_all
+            FileUtils.rm_rf dir
+          }
         else
-          raise "Unsupported OS"
+          raise UnsupportedError
         end
+
+        [port, path, wait_thr.pid]
       end
 
-      def run_new_chrome
-        dir = Dir.mktmpdir
-        # The command line flags are based on: https://developer.mozilla.org/en-US/docs/Tools/Remote_Debugging/Chrome_Desktop#connecting
-        stdin, stdout, stderr, wait_thr = *Open3.popen3("#{get_chrome_path} --remote-debugging-port=0 --no-first-run --no-default-browser-check --user-data-dir=#{dir}")
-        stdin.close
-        stdout.close
-
-        data = stderr.readpartial 4096
-        if data.match /DevTools listening on ws:\/\/127.0.0.1:(\d+)(.*)/
-          port = $1
-          path = $2
+      def get_chrome_path candidates
+        candidates.each{|c|
+          if File.exist? c
+            return c
+          end
+        }
+        raise UnsupportedError
+      end
+
+      ITERATIONS = 50
+
+      def get_devtools_endpoint tf
+        i = 1
+        while i < ITERATIONS
+          i += 1
+          if File.exist?(tf) && data = File.read(tf)
+            if data.match /DevTools listening on ws:\/\/127.0.0.1:(\d+)(.*)/
+              port = $1
+              path = $2
+              return [port, path]
+            end
+          end
+          sleep 0.1
         end
-        stderr.close
+        raise NotFoundChromeEndpointError
+      end
+    end
 
-        at_exit{
-          CONFIG[:skip_path] = [//] # skip all
-          FileUtils.rm_rf dir
+    def send_chrome_response req
+      @repl = false
+      case req
+      when /^GET\s\/json\/version\sHTTP\/1.1/
+        body = {
+          Browser: "ruby/v#{RUBY_VERSION}",
+          'Protocol-Version': "1.1"
         }
-
-        [port, path, wait_thr.pid]
+        send_http_res body
+        raise UI_ServerBase::RetryConnection
+
+      when /^GET\s\/json\sHTTP\/1.1/
+        @uuid = @uuid || SecureRandom.uuid
+        addr = @local_addr.inspect_sockaddr
+        body = [{
+          description: "ruby instance",
+          devtoolsFrontendUrl: "devtools://devtools/bundled/inspector.html?experiments=true&v8only=true&ws=#{addr}/#{@uuid}",
+          id: @uuid,
+          title: $0,
+          type: "node",
+          url: "file://#{File.absolute_path($0)}",
+          webSocketDebuggerUrl: "ws://#{addr}/#{@uuid}"
+        }]
+        send_http_res body
+        raise UI_ServerBase::RetryConnection
+
+      when /^GET\s\/(\w{8}-\w{4}-\w{4}-\w{4}-\w{12})\sHTTP\/1.1/
+        raise 'Incorrect uuid' unless $1 == @uuid
+
+        @need_pause_at_first = false
+        CONFIG.set_config no_color: true
+
+        @ws_server = WebSocketServer.new(@sock)
+        @ws_server.handshake
       end
     end
 
+    def send_http_res body
+      json = JSON.generate body
+      header = "HTTP/1.0 200 OK\r\nContent-Type: application/json; charset=UTF-8\r\nCache-Control: no-cache\r\nContent-Length: #{json.bytesize}\r\n\r\n"
+      @sock.puts "#{header}#{json}"
+    end
+
     module WebSocketUtils
       class Frame
         attr_reader :b
@@ -528,12 +669,6 @@ module DEBUGGER__
 
     ## Called by the SESSION thread
 
-    def readline prompt
-      return 'c' unless @q_msg
-
-      @q_msg.pop || 'kill!'
-    end
-
     def respond req, **result
       send_response req, **result
     end
@@ -561,6 +696,28 @@ module DEBUGGER__
   end
 
   class Session
+    # FIXME: unify this method with ThreadClient#propertyDescriptor.
+    def get_type obj
+      case obj
+      when Array
+        ['object', 'array']
+      when Hash
+        ['object', 'map']
+      when String
+        ['string']
+      when TrueClass, FalseClass
+        ['boolean']
+      when Symbol
+        ['symbol']
+      when Integer, Float
+        ['number']
+      when Exception
+        ['object', 'error']
+      else
+        ['object']
+      end
+    end
+
     def fail_response req, **result
       @ui.respond_fail req, **result
       return :retry
@@ -584,17 +741,38 @@ module DEBUGGER__
                         code: INVALID_PARAMS,
                         message: "'callFrameId' is an invalid"
         end
-      when 'Runtime.getProperties'
-        oid = req.dig('params', 'objectId')
+      when 'Runtime.getProperties', 'Runtime.getExceptionDetails'
+        oid = req.dig('params', 'objectId') || req.dig('params', 'errorObjectId')
         if ref = @obj_map[oid]
           case ref[0]
           when 'local'
             frame_id = ref[1]
             fid = @frame_map[frame_id]
             request_tc [:cdp, :scope, req, fid]
+          when 'global'
+            vars = global_variables.sort.map do |name|
+              gv = eval(name.to_s)
+              prop = {
+                name: name,
+                value: {
+                  description: gv.inspect
+                },
+                configurable: true,
+                enumerable: true
+              }
+              type, subtype = get_type(gv)
+              prop[:value][:type] = type
+              prop[:value][:subtype] = subtype if subtype
+              prop
+            end
+
+            @ui.respond req, result: vars
+            return :retry
           when 'properties'
             request_tc [:cdp, :properties, req, oid]
-          when 'script', 'global'
+          when 'exception'
+            request_tc [:cdp, :exception, req, oid]
+          when 'script'
             # TODO: Support script and global types
             @ui.respond req, result: []
             return :retry
@@ -730,6 +908,9 @@ module DEBUGGER__
                 frame[:scriptId] = s_id
               end
             }
+            if oid = exc[:exception][:objectId]
+              @obj_map[oid] = ['exception']
+            end
           end
           rs = result.dig(:response, :result)
           [rs].each{|obj|
@@ -767,6 +948,8 @@ module DEBUGGER__
           }
         }
         @ui.respond req, **result
+      when :exception
+        @ui.respond req, **result
       end
     end
   end
@@ -872,8 +1055,8 @@ module DEBUGGER__
                 result = b.local_variable_get(expr)
               rescue NameError
                 # try to check method
-                if b.receiver.respond_to? expr, include_all: true
-                  result = b.receiver.method(expr)
+                if M_RESPOND_TO_P.bind_call(b.receiver, expr, include_all: true)
+                  result = M_METHOD.bind_call(b.receiver, expr)
                 else
                   message = "Error: Can not evaluate: #{expr.inspect}"
                 end
@@ -886,35 +1069,7 @@ module DEBUGGER__
               result = current_frame.binding.eval(expr.to_s, '(DEBUG CONSOLE)')
             rescue Exception => e
               result = e
-              b = result.backtrace.map{|e| "    #{e}\n"}
-              frames = [
-                {
-                  columnNumber: 0,
-                  functionName: 'eval',
-                  lineNumber: 0,
-                  url: ''
-                }
-              ]
-              e.backtrace_locations&.each do |loc|
-                break if loc.path == __FILE__
-                path = loc.absolute_path || loc.path
-                frames << {
-                  columnNumber: 0,
-                  functionName: loc.base_label,
-                  lineNumber: loc.lineno - 1,
-                  url: path
-                }
-              end
-              res[:exceptionDetails] = {
-                exceptionId: 1,
-                text: 'Uncaught',
-                lineNumber: 0,
-                columnNumber: 0,
-                exception: evaluate_result(result),
-                stackTrace: {
-                  callFrames: frames
-                }
-              }
+              res[:exceptionDetails] = exceptionDetails(e, 'Uncaught')
             ensure
               output = $stdout.string
               $stdout = orig_stdout
@@ -987,21 +1142,63 @@ module DEBUGGER__
             ]
           end
 
-          result += obj.instance_variables.map{|iv|
-            variable(iv, obj.instance_variable_get(iv))
+          result += M_INSTANCE_VARIABLES.bind_call(obj).map{|iv|
+            variable(iv, M_INSTANCE_VARIABLE_GET.bind_call(obj, iv))
           }
-          prop += [internalProperty('#class', obj.class)]
+          prop += [internalProperty('#class', M_CLASS.bind_call(obj))]
         end
         event! :cdp_result, :properties, req, result: result, internalProperties: prop
+      when :exception
+        oid = args.shift
+        exc = nil
+        if obj = @obj_map[oid]
+          exc = exceptionDetails obj, obj.to_s
+        end
+        event! :cdp_result, :exception, req, exceptionDetails: exc
+      end
+    end
+
+    def exceptionDetails exc, text
+      frames = [
+        {
+          columnNumber: 0,
+          functionName: 'eval',
+          lineNumber: 0,
+          url: ''
+        }
+      ]
+      exc.backtrace_locations&.each do |loc|
+        break if loc.path == __FILE__
+        path = loc.absolute_path || loc.path
+        frames << {
+          columnNumber: 0,
+          functionName: loc.base_label,
+          lineNumber: loc.lineno - 1,
+          url: path
+        }
       end
+      {
+        exceptionId: 1,
+        text: text,
+        lineNumber: 0,
+        columnNumber: 0,
+        exception: evaluate_result(exc),
+        stackTrace: {
+          callFrames: frames
+        }
+      }
     end
 
     def search_const b, expr
       cs = expr.delete_prefix('::').split('::')
-      [Object, *b.eval('Module.nesting')].reverse_each{|mod|
+      [Object, *b.eval('::Module.nesting')].reverse_each{|mod|
         if cs.all?{|c|
              if mod.const_defined?(c)
-               mod = mod.const_get(c)
+               begin
+                 mod = mod.const_get(c)
+               rescue Exception
+                 false
+               end
              else
                false
              end
@@ -1045,25 +1242,29 @@ module DEBUGGER__
         v = prop[:value]
         v.delete :value
         v[:subtype] = subtype if subtype
-        v[:className] = obj.class
+        v[:className] = (klass = M_CLASS.bind_call(obj)).name || klass.to_s
       end
       prop
     end
 
     def preview_ value, hash, overflow
+      # The reason for not using "map" method is to prevent the object overriding it from causing bugs.
+      # https://github.com/ruby/debug/issues/781
+      props = []
+      hash.each{|k, v|
+        pd = propertyDescriptor k, v
+        props << {
+          name: pd[:name],
+          type: pd[:value][:type],
+          value: pd[:value][:description]
+        }
+      }
       {
         type: value[:type],
         subtype: value[:subtype],
         description: value[:description],
         overflow: overflow,
-        properties: hash.map{|k, v|
-          pd = propertyDescriptor k, v
-          {
-            name: pd[:name],
-            type: pd[:value][:type],
-            value: pd[:value][:description]
-          }
-        }
+        properties: props
       }
     end