add resize for windows

Author: mainred

src/aks-agent/azext_aks_agent/agent/k8s/pod_exec.py

@@ -62,27 +62,51 @@ def _get_terminal_size() -> Tuple[int, int]:
         return int(os.environ.get('LINES', 24)), int(os.environ.get('COLUMNS', 80))
 
 
-def _resize_terminal_handler(_signum, _frame, exec_stream):
+def _send_terminal_size(exec_stream, rows, cols):
     """
-    Handle terminal resize signal and send new size to pod via WebSocket channel.
+    Send terminal size to pod via WebSocket channel.
 
     Args:
-        signum: Signal number
-        frame: Current stack frame
         exec_stream: The WebSocket stream object
+        rows: Terminal height
+        cols: Terminal width
     """
     try:
-        rows, cols = _get_terminal_size()
-        # Create resize message as JSON
         resize_message = json.dumps({
             "Width": cols,
             "Height": rows
         })
-        # Send resize message through WebSocket channel 4 (RESIZE_CHANNEL)
         exec_stream.write_channel(RESIZE_CHANNEL, resize_message)
         logger.debug("Terminal resized to %dx%d", cols, rows)
     except Exception as e:  # pylint: disable=broad-exception-caught
-        logger.debug("Failed to resize terminal: %s", e)
+        logger.debug("Failed to send terminal size: %s", e)
+
+
+def _monitor_resize_events_windows(exec_stream, stop_event):
+    """
+    Monitor terminal resize events on Windows by polling.
+    Implementation based on Kubernetes kubectl.
+    Reference: https://github.com/kubernetes/kubernetes/blob/master/staging/src/k8s.io/kubectl/
+               pkg/util/term/resizeevents_windows.go
+
+    Args:
+        exec_stream: The WebSocket stream object
+        stop_event: Threading event to stop monitoring
+    """
+    last_size = _get_terminal_size()
+
+    while not stop_event.is_set() and exec_stream.is_open():
+        try:
+            current_size = _get_terminal_size()
+            if current_size != last_size:
+                _send_terminal_size(exec_stream, current_size[0], current_size[1])
+                last_size = current_size
+        except Exception as e:  # pylint: disable=broad-exception-caught
+            logger.debug("Error monitoring terminal size: %s", e)
+            break
+
+        # Sleep to avoid hot looping (same interval as kubectl)
+        stop_event.wait(0.25)
 
 
 def _set_terminal_raw_mode():
@@ -294,6 +318,8 @@ def exec_command_in_pod(pod_name: str, command: List[str],  # pylint: disable=to
     fl = None
     cleanup_done = False
     windows_console_state = None
+    resize_stop_event = None
+    resize_thread = None
 
     def cleanup():
         """Cleanup function to ensure proper resource cleanup."""
@@ -304,7 +330,7 @@ def cleanup():
             return
         cleanup_done = True
 
-        # Restore signal handler
+        # Restore signal handler (Unix/Linux). Windows does not use signal handlers for resize.
         if original_sigwinch and not IS_WINDOWS:
             try:
                 signal.signal(signal.SIGWINCH, original_sigwinch)
@@ -403,13 +429,27 @@ def signal_handler(signum, _frame):
             if tty:
                 terminal_state = _set_terminal_raw_mode()
 
-            # Set up terminal resize handler (Unix/Linux only)
-            if not IS_WINDOWS and hasattr(signal, 'SIGWINCH'):
-                def resize_handler(signum, frame):
-                    _resize_terminal_handler(signum, frame, resp)
-
-                # Register signal handler for terminal resize
-                original_sigwinch = signal.signal(signal.SIGWINCH, resize_handler)
+            # Set up terminal resize monitoring
+            # Reference: https://github.com/kubernetes/kubernetes/blob/master/staging/src/k8s.io/kubectl/pkg/util/term/
+            if IS_WINDOWS:
+                # Windows: Poll for size changes in background thread
+                resize_stop_event = threading.Event()
+                resize_thread = threading.Thread(
+                    target=_monitor_resize_events_windows,
+                    args=(resp, resize_stop_event),
+                    daemon=True
+                )
+                resize_thread.start()
+            elif hasattr(signal, 'SIGWINCH'):
+                # Unix/Linux: Use SIGWINCH signal handler (must be in main thread)
+                def sigwinch_handler(_signum, _frame):
+                    try:
+                        rows, cols = _get_terminal_size()
+                        _send_terminal_size(resp, rows, cols)
+                    except Exception as e:  # pylint: disable=broad-exception-caught
+                        logger.debug("Error handling terminal resize: %s", e)
+
+                original_sigwinch = signal.signal(signal.SIGWINCH, sigwinch_handler)
 
             # Set up heartbeat mechanism
             heartbeat_stop_event = threading.Event()
@@ -524,6 +564,12 @@ def resize_handler(signum, frame):
             logger.info("Pod exec session interrupted by user")
             return True
         finally:
+            # Stop resize monitoring
+            if resize_stop_event:
+                resize_stop_event.set()
+            if resize_thread and resize_thread.is_alive():
+                resize_thread.join(timeout=2.0)
+
             # Stop heartbeat
             if heartbeat_stop_event:
                 heartbeat_stop_event.set()