Added timeout and limit to script entries

sia/repeat_entry.py

@@ -8,22 +8,46 @@ from .entry import Entry
 class RepeatEntry(Entry):
     """
     Entry type for scripts that are executed on every update.
+
+    Attributes:
+        script: The script/command to execute
+        timeout: Maximum time to wait for script execution
+        limit: Maximum number of characters to capture from stdout/stderr
+        stdout: Captured standard output from script execution
+        stderr: Captured standard error from script execution
+        exit_code: Process exit code after completion
+        _executed: Whether the script has been executed
     """
+
+    default_timeout = 1
+    default_limit = 1024
     
-    def __init__(self, script: str, id: str, timestamp: datetime):
+    def __init__(
+            self,
+            id: str,
+            timestamp: datetime,
+            script: str,
+            timeout: Optional[float],
+            limit: Optional[int],
+        ):
         """
         Initialize a new repeat entry.
         
         Args:
-            script: The script/command to execute
             id: Unique identifier for this entry
             timestamp: Creation timestamp for this entry
+            script: The script/command to execute
+            timeout: Maximum time to wait for script execution
+            limit: Maximum number of characters to capture from stdout/stderr
         """
         super().__init__(id, timestamp)
         self._script = script
+        self._timeout = timeout or self.default_timeout
+        self._limit = limit or self.default_limit
         self._stdout = ""
         self._stderr = ""
         self._exit_code: Optional[int] = None
+        self._timed_out = False
 
     @property
     def script(self) -> str:
@@ -50,15 +74,20 @@ class RepeatEntry(Entry):
         Execute the script and update the output.
         Captures stdout, stderr and exit code from each execution.
         """
-        process = subprocess.run(
-            self._script,
-            shell=True,
-            capture_output=True,
-            text=True
-        )
-        self._stdout = process.stdout
-        self._stderr = process.stderr
-        self._exit_code = process.returncode
+        try:
+            process = subprocess.run(
+                self._script,
+                timeout=self._timeout,
+                shell=True,
+                capture_output=True,
+                text=True
+            )
+            self._stdout = process.stdout
+            self._stderr = process.stderr
+            self._exit_code = process.returncode
+        except subprocess.TimeoutExpired as e:
+            self._timed_out = True
+
 
     def generate_context(self) -> ET.Element:
         """
@@ -69,12 +98,20 @@ class RepeatEntry(Entry):
         """
         element = ET.Element("repeat", {
             "id": self.id,
-            "exit_code": str(self._exit_code) if self._exit_code is not None else "-1"
         })
         element.text = self.script
-        stdout_elem = ET.SubElement(element, "stdout")
-        stdout_elem.text = self._stdout
-        stderr_elem = ET.SubElement(element, "stderr")
-        stderr_elem.text = self._stderr
+        if self._exit_code is not None:
+            element.set("exit_code", str(self._exit_code))
+        if self._timed_out:
+            element.set("timed_out", "true")
+        else:
+            if len(self._stdout) > self._limit:
+                element.set("stdout_truncated", "true")
+            stdout_elem = ET.SubElement(element, "stdout")
+            stdout_elem.text = self._stdout[:self._limit]
+            if len(self._stderr) > self._limit:
+                element.set("stderr_truncated", "true")
+            stderr_elem = ET.SubElement(element, "stderr")
+            stderr_elem.text = self._stderr[:self._limit]
         
         return element