fix deleting breakpoints not working properly

Author: atomicptr

src/mobdap/debug_server.clj

@@ -18,7 +18,7 @@
 
 (defn send-line! [server line]
   (let [writer (get-in server [:client :writer])]
-    (log/info "Server -> Client:" line)
+    (log/info "Debug Server -> Debuggee" line)
     (doto writer
       (.write line)
       (.write "\n")
@@ -27,12 +27,11 @@
 (defn read-response! [server]
   (let [reader (get-in server [:client :reader])]
     (when-let [message (.readLine reader)]
-      (log/info "Client -> Server:" message)
+      (log/info "Debuggee -> Debug Server:" message)
       (string/trim message))))
 
 (defn- send-command! [server command]
   (let [command (string/upper-case command)]
-    (log/info "Send Command:" command)
     (send-line! server command)
     (when (read-response! server)
       (loop []
@@ -76,6 +75,9 @@
                 (do (log/error "Unknown Error:" breakpoint)
                     nil)))))))))
 
+(defn send-command-delb! [server file line]
+  (send-line! server (format "DELB %s %d" file line)))
+
 (defn send-command-setb! [server file line]
   (send-line! server (format "SETB %s %d" file line)))
 
@@ -85,7 +87,6 @@
     (lua/extract-table stack-code)
     nil))
 
-; TODO: this doesnt actually work
 (defn is-connected? [socket]
   (and (not (.isClosed socket))
        (.isConnected socket)
@@ -97,7 +98,7 @@
       (with-open [server-socket (ServerSocket. port)]
         (try
           (let [client (.accept server-socket)
-                _      (log/info "Client connected" client)
+                _      (log/info "Debuggee connected" client)
                 writer (PrintWriter. (.getOutputStream client) true)
                 reader (BufferedReader. (InputStreamReader. (.getInputStream client)))
                 server-handle {:client   {:socket client
@@ -114,14 +115,18 @@
 
             (go-loop []
               (when-let [command (<!! to-debug-server)]
-                (log/info "Command to debug server" command)
+                (log/info "Handler -> Debug Server:" command)
                 (case (:cmd command)
                   :run             (send-command! server-handle "run")
 
-                  ; TODO: delete all prior breakpoints by using "LISTB" -> "DELB"
-                  :set-breakpoints (doseq [[filename breakpoints] (:breakpoints command)
-                                           {:keys [line]} breakpoints]
-                                     (send-command-setb! server-handle filename line))
+                  :set-breakpoints (do
+                                     ; this command only gets called before executing a command so we
+                                     ; can just delete and re-apply all breakpoints
+                                     (send-command-delb! server-handle "*" 0)
+
+                                     (doseq [[filename breakpoints] (:breakpoints command)
+                                             {:keys [line]} breakpoints]
+                                       (send-command-setb! server-handle filename line)))
 
                   :step-in         (send-command! server-handle "step")
 
@@ -143,7 +148,7 @@
             (loop []
               ; TODO: this actually doesnt work but we should shut down mobdap when client is gone
               (when (not (is-connected? client))
-                (log/info "Lost connection to client, exitting...")
+                (log/info "Lost connection to debuggee, exitting...")
                 (System/exit 0))
               (recur)))
 

src/mobdap/handler.clj

@@ -99,6 +99,17 @@
     :event event
     :body body}))
 
+(defn- send-command-to-debug-server
+  ([handler command] (send-command-to-debug-server handler command false))
+  ([handler command update-breakpoints?]
+   (let [to-debug-server (get-in handler [:channels :to-debug-server])]
+     (assert (some? to-debug-server))
+
+     (when update-breakpoints?
+       (>!! to-debug-server {:cmd :set-breakpoints :breakpoints (:breakpoints handler)}))
+
+     (>!! to-debug-server command))))
+
 (defn handle-initialize [handler message]
   (let [response
         (success
@@ -264,15 +275,14 @@
                :breakpoint (let [file (get-in command [:breakpoint :file])
                                  line (get-in command [:breakpoint :line])
                                  id   (find-breakpoint-id handler file line)]
-                             (assert (some? id))
                              (adapter/send-message!
                               (:adapter handler)
                               (event
                                "stopped"
                                {:reason "breakpoint"
                                 :allThreadsStopped true
                                 :threadId 1
-                                :hitBreakpointIds [id]})))
+                                :hitBreakpointIds (vec (filter some? [id]))})))
 
                (:step :out :over)
                (adapter/send-message!
@@ -344,11 +354,7 @@
 ;
 (defn handle-configuration-done [handler message]
   (adapter/send-message! (:adapter handler) (success (:seq message) "configurationDone" nil))
-
-  (let [to-debug-server (get-in handler [:channels :to-debug-server])]
-    (>!! to-debug-server {:cmd :set-breakpoints :breakpoints (:breakpoints handler)})
-    (>!! to-debug-server {:cmd :run}))
-
+  (send-command-to-debug-server handler {:cmd :run} true)
   handler)
 
 (defn handle-threads [handler message]
@@ -357,12 +363,9 @@
   handler)
 
 (defn handle-stacktrace [handler message]
-  (let [to-debug-server (get-in handler [:channels :to-debug-server])
-        start-frame (get-in message [:arguments :startFrame])
+  (let [start-frame (get-in message [:arguments :startFrame])
         levels      (get-in message [:arguments :levels])]
-
-    (>!! to-debug-server {:cmd :stacktrace :start start-frame :length levels :seq (:seq message)})
-
+    (send-command-to-debug-server handler {:cmd :stacktrace :start start-frame :length levels :seq (:seq message)})
     handler))
 
 (defn- create-scope [frame vars name hint]
@@ -387,7 +390,7 @@
      (:adapter handler)
      (success (:seq message)
               "scopes"
-              {:scopes (filter some? [stack-scope upvals-scope])}))
+              {:scopes (vec (filter some? [stack-scope upvals-scope]))}))
     handler))
 
 (defn- find-vars-scope-by-id [data id]
@@ -537,10 +540,10 @@
     (assert (and (some? vars) (some? type)))
 
     (let [variables
-          (filter some? (case type
-                          :scope (create-scope-variables vars)
-                          :vars  (create-variables vars)
-                          :else  []))]
+          (vec (filter some? (case type
+                               :scope (create-scope-variables vars)
+                               :vars  (create-variables vars)
+                               :else  [])))]
 
       (adapter/send-message!
        (:adapter handler)
@@ -550,33 +553,27 @@
     handler))
 
 (defn handle-continue [handler message]
-  (let [to-debug-server (get-in handler [:channels :to-debug-server])]
-    (>!! to-debug-server {:cmd :set-breakpoints :breakpoints (:breakpoints handler)})
-    (>!! to-debug-server {:cmd :run}))
+  (send-command-to-debug-server handler {:cmd :run} true)
   (adapter/send-message! (:adapter handler) (success (:seq message) "continue" nil))
   handler)
 
 (defn handle-step-in [handler message]
-  (let [to-debug-server (get-in handler [:channels :to-debug-server])]
-    (>!! to-debug-server {:cmd :set-breakpoints :breakpoints (:breakpoints handler)})
-    (>!! to-debug-server {:cmd :step-in})
-    (adapter/send-message! (:adapter handler) (success (:seq message) "stepIn" nil))
-    handler))
+  (send-command-to-debug-server handler {:cmd :step-in} true)
+  (adapter/send-message! (:adapter handler) (success (:seq message) "stepIn" nil))
+  handler)
 
 (defn handle-step-out [handler message]
-  (let [to-debug-server (get-in handler [:channels :to-debug-server])]
-    (>!! to-debug-server {:cmd :step-out})
-    (adapter/send-message! (:adapter handler) (success (:seq message) "stepOut" nil))
-    handler))
+  (send-command-to-debug-server handler {:cmd :step-out} true)
+  (adapter/send-message! (:adapter handler) (success (:seq message) "stepOut" nil))
+  handler)
 
 (defn handle-next [handler message]
-  (let [to-debug-server (get-in handler [:channels :to-debug-server])]
-    (>!! to-debug-server {:cmd :over})
-    (adapter/send-message! (:adapter handler) (success (:seq message) "next" nil))
-    handler))
+  (send-command-to-debug-server handler {:cmd :over} true)
+  (adapter/send-message! (:adapter handler) (success (:seq message) "next" nil))
+  handler)
 
 (defn handle-terminate [handler message]
-  (>!! (get-in handler [:channels :to-debug-server]) {:cmd :exit})
+  (send-command-to-debug-server handler {:cmd :exit})
   (adapter/send-message! (:adapter handler) (success (:seq message) "terminate" nil))
   handler)