Merge pull request #136 from robertbasic/feature/better-support-for-multiple-requests

Feature/better support for multiple requests. Fixes #129

Author: robertbasic

pugdebug/debugger.py

@@ -28,6 +28,7 @@ class PugdebugDebugger(QObject):
     current_file = ''
     current_line = 0
 
+    server_stopped_signal = pyqtSignal()
     debugging_started_signal = pyqtSignal()
     debugging_post_start_signal = pyqtSignal()
     debugging_stopped_signal = pyqtSignal()
@@ -58,8 +59,8 @@ def __init__(self):
     def connect_server_signals(self):
         """Connect server signals to slots
         """
-        self.server.server_connected_signal.connect(
-            self.handle_server_connected
+        self.server.new_connection_established_signal.connect(
+            self.handle_new_connection_established
         )
         self.server.server_stopped_signal.connect(
             self.handle_server_stopped
@@ -128,21 +129,15 @@ def connect_connection_signals(self, connection):
             self.handle_connection_error
         )
 
-    def cleanup(self):
-        """Cleanup debugger when it's done
+    def cleanup_current_connection(self):
+        """Cleanup the current debugger connection
 
-        If there is an active connection, disconnect from it and clear
-        all the remaining connections.
-
-        Stop the server from listening.
+        If there is an active connection, disconnect from it.
 
         Clean up attributes.
         """
         if self.is_connected():
             self.current_connection.disconnect()
-            self.connections.clear()
-
-        self.server.stop()
 
         self.current_connection = None
         self.step_result = ''
@@ -159,14 +154,12 @@ def has_pending_connections(self):
         """
         return len(self.connections) > 0
 
-    def start_debug(self):
-        """Start a debugging session
-
-        If the server is not connected, connect it.
+    def start_listening(self):
+        """Start listening to new connections
         """
-        self.server.connect()
+        self.server.start_listening()
 
-    def handle_server_connected(self, connection):
+    def handle_new_connection_established(self, connection):
         """Handle when the server establishes a new connection
 
         Connect the signals for the new connection.
@@ -180,9 +173,9 @@ def handle_server_connected(self, connection):
         self.connections.append(connection)
 
         if not self.is_connected():
-            self.start_new_connection()
+            self.start_debugging_new_connection()
 
-    def start_new_connection(self):
+    def start_debugging_new_connection(self):
         """Start a new connection
 
         Get the first (oldest) connection from the queue, set it's init
@@ -208,15 +201,20 @@ def handle_post_start(self):
         """
         self.debugging_post_start_signal.emit()
 
-    def handle_server_stopped(self):
-        """Handle when the server is stopped
+    def stop_listening(self):
+        """Stop listening for new connections
 
-        If the current connection is terminated, cleanup the debugging
-        session and emit the debugging stopped signal.
+        Clear connections queue, stop debugging the current connection.
         """
-        if not self.is_connected():
-            self.cleanup()
-            self.debugging_stopped_signal.emit()
+        self.connections.clear()
+        self.stop_debug()
+
+        self.server.stop_listening()
+
+    def handle_server_stopped(self):
+        """Handle when the server stops listening to new connections
+        """
+        self.server_stopped_signal.emit()
 
     def stop_debug(self):
         """Stop a debugging session
@@ -226,8 +224,6 @@ def stop_debug(self):
         """
         if self.is_connected():
             self.current_connection.stop()
-        else:
-            self.server.stop()
 
     def detach_debug(self):
         """Detach the current connection
@@ -240,13 +236,12 @@ def handle_stopped(self):
 
         If there are pending connections, start a new one.
 
-        Otherwise clean up and emit a server stopped signal.
+        Otherwise emit a debugging stopped signal.
         """
         if self.has_pending_connections():
-            self.start_new_connection()
+            self.start_debugging_new_connection()
         else:
-            self.cleanup()
-
+            self.cleanup_current_connection()
             self.debugging_stopped_signal.emit()
 
     def run_debug(self):

pugdebug/gui/main_window.py

@@ -147,27 +147,38 @@ def setup_file_actions(self):
         self.quit_action.triggered.connect(self.close)
 
     def setup_actions(self):
-        self.start_debug_action = QAction("Start", self)
-        self.start_debug_action.setToolTip("Start server (F1)")
-        self.start_debug_action.setStatusTip(
-            "Start listening to for connections. Shortcut: F1"
+        self.start_listening_action = QAction("Start listening", self)
+        self.start_listening_action.setToolTip(
+            "Start listening for new connections (F1)"
         )
-        self.start_debug_action.setShortcut(QKeySequence("F1"))
+        self.start_listening_action.setStatusTip(
+            "Start listening for incomming connections. Shortcut: F1"
+        )
+        self.start_listening_action.setShortcut(QKeySequence("F1"))
+
+        self.stop_listening_action = QAction("Stop listening", self)
+        self.stop_listening_action.setToolTip(
+            "Stop listening for new connections (F2)"
+        )
+        self.stop_listening_action.setStatusTip(
+            "Stop listening to incomming connections. Shortcut: F2"
+        )
+        self.stop_listening_action.setShortcut(QKeySequence("F2"))
 
         self.stop_debug_action = QAction("Stop", self)
-        self.stop_debug_action.setToolTip("Stop server (F2)")
+        self.stop_debug_action.setToolTip("Stop debugging (F3)")
         self.stop_debug_action.setStatusTip(
-            "Stop listening to for connections. Shortcut: F2"
+            "Stop debugging the current request. Shortcut: F3"
         )
-        self.stop_debug_action.setShortcut(QKeySequence("F2"))
+        self.stop_debug_action.setShortcut(QKeySequence("F3"))
 
         self.detach_debug_action = QAction("Detach", self)
-        self.detach_debug_action.setToolTip("Detach from server (F3)")
+        self.detach_debug_action.setToolTip("Detach debugger (F4)")
         self.detach_debug_action.setStatusTip(
-            "Stop the debugging session, but let the PHP process end normally."
-            " Shortcut: F3"
+            "Detach debugger from the current request."
+            " Shortcut: F4"
         )
-        self.detach_debug_action.setShortcut(QKeySequence("F3"))
+        self.detach_debug_action.setShortcut(QKeySequence("F4"))
 
         self.run_debug_action = QAction("Run", self)
         self.run_debug_action.setToolTip("Start/resume the script (F5)")
@@ -208,7 +219,9 @@ def setup_toolbar(self):
         toolbar = QToolBar("Main Toolbar")
         toolbar.setObjectName("main-toolbar")
 
-        toolbar.addAction(self.start_debug_action)
+        toolbar.addAction(self.start_listening_action)
+        toolbar.addAction(self.stop_listening_action)
+        toolbar.addSeparator()
         toolbar.addAction(self.stop_debug_action)
         toolbar.addAction(self.detach_debug_action)
         toolbar.addSeparator()
@@ -235,7 +248,9 @@ def setup_menubar(self):
             view_menu.addAction(widget.toggleViewAction())
 
         debug_menu = menu_bar.addMenu("&Debug")
-        debug_menu.addAction(self.start_debug_action)
+        debug_menu.addAction(self.start_listening_action)
+        debug_menu.addAction(self.stop_listening_action)
+        debug_menu.addSeparator()
         debug_menu.addAction(self.stop_debug_action)
         debug_menu.addAction(self.detach_debug_action)
         debug_menu.addSeparator()
@@ -247,13 +262,14 @@ def setup_menubar(self):
         self.setMenuBar(menu_bar)
 
     def toggle_actions(self, enabled):
+        self.stop_debug_action.setEnabled(enabled)
         self.detach_debug_action.setEnabled(enabled)
         self.run_debug_action.setEnabled(enabled)
         self.step_over_action.setEnabled(enabled)
         self.step_into_action.setEnabled(enabled)
         self.step_out_action.setEnabled(enabled)
 
-        self.start_debug_action.setEnabled(not enabled)
+        self.start_listening_action.setEnabled(not enabled)
 
     def get_file_browser(self):
         return self.file_browser

pugdebug/pugdebug.py

@@ -155,7 +155,12 @@ def connect_toolbar_action_signals(self):
         Connect signals when the run and step continuation commands are
         triggered are connected.
         """
-        self.main_window.start_debug_action.triggered.connect(self.start_debug)
+        self.main_window.start_listening_action.triggered.connect(
+            self.start_listening
+        )
+        self.main_window.stop_listening_action.triggered.connect(
+            self.stop_listening
+        )
         self.main_window.stop_debug_action.triggered.connect(self.stop_debug)
         self.main_window.detach_debug_action.triggered.connect(
             self.detach_debug
@@ -178,6 +183,9 @@ def connect_debugger_signals(self):
         """
 
         # Start/stop signals
+        self.debugger.server_stopped_signal.connect(
+            self.handle_server_stopped_listening
+        )
         self.debugger.debugging_started_signal.connect(
             self.handle_debugging_started
         )
@@ -429,8 +437,8 @@ def handle_debugger_features_changed(self):
         if self.debugger.is_connected():
             self.debugger.set_debugger_features()
 
-    def start_debug(self):
-        """Start a new debugging session
+    def start_listening(self):
+        """Start listening to new incomming connections
 
         Clear the variable viewer.
 
@@ -462,7 +470,7 @@ def start_debug(self):
 
             self.document_viewer.remove_line_highlights()
 
-            self.debugger.start_debug()
+            self.debugger.start_listening()
             self.main_window.set_debugging_status(1)
 
     def handle_debugging_started(self):
@@ -512,6 +520,12 @@ def handle_debugging_post_start(self):
         else:
             self.step_into()
 
+    def stop_listening(self):
+        self.debugger.stop_listening()
+
+    def handle_server_stopped_listening(self):
+        self.main_window.set_debugging_status(0)
+
     def stop_debug(self):
         """Stop a debugging session
 

pugdebug/server.py

@@ -23,7 +23,7 @@ class PugdebugServer(QThread):
 
     wait_for_accept = True
 
-    server_connected_signal = pyqtSignal(object)
+    new_connection_established_signal = pyqtSignal(object)
     server_stopped_signal = pyqtSignal()
 
     server_error_signal = pyqtSignal(str)
@@ -36,29 +36,41 @@ def __init__(self):
     def run(self):
         self.mutex.lock()
 
-        self.__connect()
+        socket_server = self.__connect()
+
+        if socket_server is not None:
+            self.__listen(socket_server)
 
         self.mutex.unlock()
 
-    def connect(self):
+    def start_listening(self):
         self.wait_for_accept = True
         self.start()
 
-    def stop(self):
+    def stop_listening(self):
         self.wait_for_accept = False
 
     def __connect(self):
-        """Connect to the server and listen to new incomming connections
+        """Connect to the socket server
+        """
+        try:
+            socket_server = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
+            socket_server.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
+            socket_server.settimeout(1)
+        except OSError as e:
+            socket_server = None
+            self.server_error_signal.emit(e.strerror)
+
+        return socket_server
+
+    def __listen(self, socket_server):
+        """Listen to new incomming connections
 
         For every accepted connection, see if it is valid and emit a signal
         with that new connection.
 
         Otherwise silently disregard that connection.
         """
-        socket_server = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
-        socket_server.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
-        socket_server.settimeout(1)
-
         host = get_setting('debugger/host')
         port_number = int(get_setting('debugger/port_number'))
 
@@ -76,7 +88,9 @@ def __connect(self):
                         is_valid = connection.init_connection()
 
                         if is_valid:
-                            self.server_connected_signal.emit(connection)
+                            self.new_connection_established_signal.emit(
+                                connection
+                            )
                 except socket.timeout:
                     pass