Merge pull request #91 from robertbasic/feature/debug-all-requests

Feature/debug all requests. Resolves #86

Author: robertbasic

pugdebug/debugger.py

@@ -9,22 +9,26 @@
 
 __author__ = "robertbasic"
 
+from collections import deque
 from PyQt5.QtCore import QObject, pyqtSignal
 
 from pugdebug.server import PugdebugServer
 
 
 class PugdebugDebugger(QObject):
+
     server = None
 
+    connections = deque()
+    current_connection = None
+
     init_message = None
     step_result = ''
 
     current_file = ''
     current_line = 0
 
     debugging_started_signal = pyqtSignal()
-    debugging_cancelled_signal = pyqtSignal()
     debugging_stopped_signal = pyqtSignal()
     step_command_signal = pyqtSignal()
     got_all_variables_signal = pyqtSignal(object)
@@ -39,67 +43,111 @@ class PugdebugDebugger(QObject):
     def __init__(self):
         """Init the debugger object
 
-        Create a PugdebugServer object used to communicate with xdebug client
-        through TCP.
+        Create a PugdebugServer objects that listens to new connections
+        from xdebug.
 
-        Connect signals to slots.
+        Connect server signals to slots.
         """
         super(PugdebugDebugger, self).__init__()
 
         self.server = PugdebugServer()
 
+        self.connect_server_signals()
+
+    def connect_server_signals(self):
+        """Connect server signals to slots
+        """
         self.server.server_connected_signal.connect(
             self.handle_server_connected
         )
-        self.server.server_cancelled_signal.connect(
-            self.handle_server_cancelled
+        self.server.server_stopped_signal.connect(
+            self.handle_server_stopped
+        )
+
+    def connect_connection_signals(self, connection):
+        """Connect signals for a new connection
+
+        Connect signals that gets emitted when a connection is stopped
+        or detached, when a step command is done, when variables are read,
+        when stacktraces are read, when breakpoints are set or removed,
+        when breakpoints are read, when expressions are evaluated.
+        """
+
+        # Stop/detach signals
+        connection.server_stopped_signal.connect(
+            self.handle_server_stopped
+        )
+        connection.server_detached_signal.connect(
+            self.handle_server_stopped
         )
-        self.server.server_stopped_signal.connect(self.handle_server_stopped)
-        self.server.server_detached_signal.connect(
-            self.handle_server_detached
+
+        # Step command signals
+        connection.server_stepped_signal.connect(
+            self.handle_server_stepped
         )
-        self.server.server_stepped_signal.connect(self.handle_server_stepped)
-        self.server.server_got_variables_signal.connect(
+
+        # Variables signals
+        connection.server_got_variables_signal.connect(
             self.handle_server_got_variables
         )
-        self.server.server_got_stacktraces_signal.connect(
+
+        # Stacktraces signals
+        connection.server_got_stacktraces_signal.connect(
             self.handle_server_got_stacktraces
         )
-        self.server.server_set_init_breakpoints_signal.connect(
+
+        # Breakpoints signals
+        connection.server_set_init_breakpoints_signal.connect(
             self.handle_server_set_breakpoint
         )
-        self.server.server_set_breakpoint_signal.connect(
+        connection.server_set_breakpoint_signal.connect(
             self.handle_server_set_breakpoint
         )
-        self.server.server_removed_breakpoint_signal.connect(
+        connection.server_removed_breakpoint_signal.connect(
             self.handle_server_removed_breakpoint
         )
-        self.server.server_listed_breakpoints_signal.connect(
+        connection.server_listed_breakpoints_signal.connect(
             self.handle_server_listed_breakpoints
         )
 
-        self.server.server_expression_evaluated_signal.connect(
+        # Expressions signals
+        connection.server_expression_evaluated_signal.connect(
             self.handle_server_expression_evaluated
         )
-        self.server.server_expressions_evaluated_signal.connect(
+        connection.server_expressions_evaluated_signal.connect(
             self.handle_server_expressions_evaluated
         )
 
     def cleanup(self):
         """Cleanup debugger when it's done
+
+        If there is an active connection, disconnect from it and clear
+        all the remaining connections.
+
+        Stop the server from listening.
+
+        Clean up attributes.
         """
-        if self.server.is_connected():
-            self.server.disconnect()
+        if self.is_connected():
+            self.current_connection.disconnect()
+            self.connections.clear()
+
+        self.server.stop()
 
+        self.current_connection = None
         self.step_result = ''
         self.current_file = ''
         self.current_line = 0
 
     def is_connected(self):
-        return self.server.is_connected()
+        """Is there an active connection
+        """
+        return self.current_connection is not None
 
-    def is_waiting_for_connection(self):
-        return self.server.is_waiting_for_connection()
+    def has_pending_connections(self):
+        """Are there any pending connections?
+        """
+        return len(self.connections) > 0
 
     def start_debug(self):
         """Start a debugging session
@@ -108,61 +156,77 @@ def start_debug(self):
         """
         self.server.connect()
 
-    def handle_server_connected(self, init_message):
-        """Handle when server gets connected
+    def handle_server_connected(self, connection):
+        """Handle when the server establishes a new connection
+
+        Connect the signals for the new connection.
+
+        Add it to the queue of connections.
 
-        Emit a debugging started signal.
+        If there is no active connection, start the new connection.
         """
-        if 'error' not in init_message:
-            self.init_message = init_message
+        self.connect_connection_signals(connection)
 
-            self.debugging_started_signal.emit()
-        else:
-            self.error_signal.emit(init_message['error'])
+        self.connections.append(connection)
 
-    def cancel_debug(self):
-        self.server.cancel()
+        if not self.is_connected():
+            self.start_new_connection()
 
-    def handle_server_cancelled(self):
-        self.debugging_cancelled_signal.emit()
+    def start_new_connection(self):
+        """Start a new connection
 
-    def stop_debug(self):
-        """Stop a debugging session
+        Get the first (oldest) connection from the queue, set it's init
+        message as the init message for the session, set it as the current
+        connection and emit the debugging started signal.
         """
-        self.server.stop()
+        connection = self.connections.popleft()
+        self.init_message = connection.init_message
+        self.current_connection = connection
 
-    def handle_server_stopped(self):
-        """Handle when server gets disconnected
+        self.debugging_started_signal.emit()
 
-        Emit a debugging stopped signal.
+    def stop_debug(self):
+        """Stop a debugging session
+
+        If there is an active connection, stop only that one, otherwise
+        stop the server from listening to new connections.
         """
-        self.debugging_stopped_signal.emit()
+        if self.is_connected():
+            self.current_connection.stop()
+        else:
+            self.server.stop()
 
     def detach_debug(self):
-        """Detach a debugging session
+        """Detach the current connection
         """
-        self.server.detach()
+        if self.is_connected():
+            self.current_connection.detach()
 
-    def handle_server_detached(self):
-        """Handle when server gets ditached
+    def handle_server_stopped(self):
+        """Handle when a server stopped signal is received
+
+        If there are pending connections, start a new one.
 
-        Emit a debugging stopped signal, as the
-        debugger should behave the same like when
-        a debugging session is stopped.
+        Otherwise clean up and emit a server stopped signal.
         """
-        self.debugging_stopped_signal.emit()
+        if self.has_pending_connections():
+            self.start_new_connection()
+        else:
+            self.cleanup()
+
+            self.debugging_stopped_signal.emit()
 
     def run_debug(self):
-        self.server.step_run()
+        self.current_connection.step_run()
 
     def step_over(self):
-        self.server.step_over()
+        self.current_connection.step_over()
 
     def step_into(self):
-        self.server.step_into()
+        self.current_connection.step_into()
 
     def step_out(self):
-        self.server.step_out()
+        self.current_connection.step_out()
 
     def handle_server_stepped(self, step_result):
         """Handle when server executes a step command
@@ -174,7 +238,7 @@ def handle_server_stepped(self, step_result):
         self.step_command_signal.emit()
 
     def post_step_command(self, post_step_data):
-        self.server.post_step_command(post_step_data)
+        self.current_connection.post_step_command(post_step_data)
 
     def handle_server_got_variables(self, variables):
         """Handle when server recieves all variables
@@ -191,23 +255,23 @@ def handle_server_got_stacktraces(self, stacktraces):
         self.got_stacktraces_signal.emit(stacktraces)
 
     def set_init_breakpoints(self, breakpoints):
-        self.server.set_init_breakpoints(breakpoints)
+        self.current_connection.set_init_breakpoints(breakpoints)
 
     def set_breakpoint(self, breakpoint):
-        self.server.set_breakpoint(breakpoint)
+        self.current_connection.set_breakpoint(breakpoint)
 
     def handle_server_set_breakpoint(self, successful):
         if successful:
             self.list_breakpoints()
 
     def remove_breakpoint(self, breakpoint_id):
-        self.server.remove_breakpoint(breakpoint_id)
+        self.current_connection.remove_breakpoint(breakpoint_id)
 
     def handle_server_removed_breakpoint(self, breakpoint_id):
         self.breakpoint_removed_signal.emit(breakpoint_id)
 
     def list_breakpoints(self):
-        self.server.list_breakpoints()
+        self.current_connection.list_breakpoints()
 
     def handle_server_listed_breakpoints(self, breakpoints):
         self.breakpoints_listed_signal.emit(breakpoints)
@@ -220,11 +284,11 @@ def get_index_file(self):
 
     def evaluate_expression(self, index, expression):
         """Evaluates a single expression"""
-        self.server.evaluate_expression(index, expression)
+        self.current_connection.evaluate_expression(index, expression)
 
     def evaluate_expressions(self, expressions):
         """Evaluates a list of expressions"""
-        self.server.evaluate_expressions(expressions)
+        self.current_connection.evaluate_expressions(expressions)
 
     def handle_server_expression_evaluated(self, index, result):
         """Handle when server evaluates an expression"""