pyconstrobe 0.1__tar.gz → 1.0.2__tar.gz

{pyconstrobe-0.1 → pyconstrobe-1.0.2}/PKG-INFO

@@ -1,6 +1,6 @@
-Metadata-Version: 2.2
+Metadata-Version: 2.4
 Name: pyconstrobe
-Version: 0.1
+Version: 1.0.2
 Summary: This package is used to automate the DES application ConStrobe.
 Author: Joseph Louis
 Author-email: joseph.louis@oregonstate.edu
@@ -11,6 +11,7 @@ Dynamic: author
 Dynamic: author-email
 Dynamic: description
 Dynamic: description-content-type
+Dynamic: license-file
 Dynamic: requires-python
 Dynamic: summary
 

pyconstrobe-1.0.2/pyconstrobe/__init__.py

@@ -0,0 +1,8 @@
+# Importing the ProcessManager class for easy access
+from .process_manager import ProcessManager
+from .hlaconstrobe import run_federation, send_control, graceful_shutdown, get_results
+
+
+# You can add any other initializations or imports here
+__version__ = "1.0.2"
+__all__ = ['ProcessManager', 'run_federation','send_control', 'graceful_shutdown', 'get_results']

pyconstrobe-1.0.2/pyconstrobe/hlaconstrobe.py

@@ -0,0 +1,144 @@
+import subprocess
+import threading
+import time
+import os
+import signal
+import queue
+import json
+import sys
+from pyconstrobe import ProcessManager
+
+FEDERATION_NAME = "SimulationFederation"
+rtig_proc = None
+listener_proc = None
+listener_thread = None
+shutdown_now = threading.Event()
+fedhandles = {}
+build_mode = os.getenv('BUILD_MODE', 'Release')
+if build_mode=='Debug':
+    LISTENER_PATH = "C:\\dev\\tools\\certi\\ListenerFederate\\x64\\Debug\\ListenerFederate.exe"
+else:
+    LISTENER_PATH = "C:\\Program Files\\constrobe\\ListenerFederate.exe";
+    #LISTENER_PATH = "C:\\dev\\source\\constrobe\\deploy\\ListenerFederate.exe"
+def start_rtig():
+    global rtig_proc
+    print("Starting rtig...")
+    rtig_path = "C:\\Program Files\\constrobe\\rtig.exe"
+    subprocess.run(
+        ["taskkill", "/F", "/IM", "rtig.exe"],
+        stdout=subprocess.DEVNULL,
+        stderr=subprocess.DEVNULL
+    )
+    time.sleep(0.5)
+    rtig_proc = subprocess.Popen(
+        [rtig_path, "-v", "2", "-l", "127.0.0.1"],
+        stdout=subprocess.PIPE,
+        stderr=subprocess.STDOUT,
+        text=True,
+        encoding="utf-8",
+        bufsize=1
+    )
+    while True:
+        line = rtig_proc.stdout.readline()
+        if not line:
+            raise RuntimeError("RTIG exited before becoming ready.")
+        print("[RTIG]", line.rstrip())
+        if "RTIG up and running" in line:
+            break
+        if ("aborted" in line or
+            "exiting" in line or
+            "Network Error" in line):
+            raise RuntimeError("RTIG failed to start (see output above).")
+def launch_listener(num_feds,handle_new_line,logging = True):
+    global listener_proc, listener_thread
+    listener_proc = subprocess.Popen(
+        [LISTENER_PATH, str(num_feds), 
+         "true" if logging else "false"],
+        stdin=subprocess.PIPE,
+        stdout=subprocess.PIPE,
+        stderr=subprocess.STDOUT,
+        text=True,
+        encoding="utf-8",
+        bufsize=1,
+    )
+    listener_thread = threading.Thread(target=read_stdout, args=(listener_proc, handle_new_line, logging), daemon=True)
+    listener_thread.start()
+def read_stdout(proc, callback, logging):
+    for line in proc.stdout:
+        if line:
+            if "|" in line:
+                print("[HLA]",line.strip())
+                fed, msg = line.split("|", 1)
+                callback(fed,msg.strip())
+            else:
+                if logging: 
+                    print("[LOG]",line.strip())
+def send_control(line):
+    try:
+        if listener_proc.stdin:
+            listener_proc.stdin.write(line + "\n")
+            listener_proc.stdin.flush()
+    except Exception:
+        pass
+
+def startSimulation(fedName, modelName,pythoncallback=None,logging=None):
+    manager = ProcessManager(pythoncallback,fedName,logging)
+    full_path=os.path.join(os.getcwd(),modelName)
+    message = f"LOAD {full_path};"
+    manager.write_message(message)
+    message = f"STARTFEDERATE {fedName};"
+    manager.write_message(message)
+    return manager
+def run_federation(simfederates,listenerCallback,logging=True):
+    start_rtig()
+    launch_listener(len(simfederates),listenerCallback, logging)
+    for fedName, modelName, callback in simfederates:
+        h = startSimulation(fedName, modelName, callback, logging)
+        message = f"RUNMODEL;"
+        h.write_message(message)
+        fedhandles[fedName] = h
+    try:
+        while not shutdown_now.is_set():
+            time.sleep(0.1)
+    finally:
+        print("All processes stopped. Exiting...")
+def get_results():
+    for fedName, h in fedhandles.items():
+        h.write_message("GETRESULTS;")
+def graceful_shutdown():
+    print("Graceful shutdown…")
+    send_control("CONTROLSIGNAL ALL ENDFEDERATE")
+    for h in fedhandles.values():
+        try:
+            h.write_message("CLOSE;")
+        except Exception:
+            pass
+    time.sleep(2)
+    for h in fedhandles.values():
+        try:
+            h.stop()
+        except Exception:
+            pass
+    global listener_proc
+    if listener_proc is not None:
+        try:
+            listener_proc.terminate()
+            listener_proc.wait(timeout=2)
+        except subprocess.TimeoutExpired:
+            listener_proc.kill()
+            listener_proc.wait()
+        except Exception:
+            pass
+        listener_proc = None
+    global rtig_proc
+    if rtig_proc is not None:
+        rtig_proc.terminate()
+        try:
+            rtig_proc.wait(timeout=2)
+        except subprocess.TimeoutExpired:
+            rtig_proc.kill()
+            rtig_proc.wait()
+        rtig_proc = None
+    shutdown_now.set()
+
+  

pyconstrobe-1.0.2/pyconstrobe/process_manager.py

@@ -0,0 +1,133 @@
+import subprocess
+import threading
+import os
+import sys
+from pathlib import Path
+import time
+
+INSTALL_DIR = Path(r"C:\Program Files\ConStrobe")
+
+def debug(msg,senderName = "Sim"):
+        build_mode = os.getenv('BUILD_MODE', 'Release')
+        if build_mode=='Debug':
+            sys.stderr.write(f"[PYCONSTROBE - {senderName}] {msg}\n")
+            sys.stderr.flush()  
+
+class ProcessManager:
+    def __init__(self, callback=None, name = "Sim", logging = True):
+        self.name = name
+        self.callback = callback
+        self.logging = logging
+        build_mode = os.getenv('BUILD_MODE', 'Release')  # Default to 'release' if not set
+        if build_mode=='Debug':
+            path_to_exe = r"C:\\dev\\source\\constrobe\\csApp\\Debug\\constrobe.exe"
+        else:
+            path_to_exe = r"C:\\Program Files\\constrobe\\constrobe.exe"
+            #path_to_exe = r"C:\\dev\\source\\constrobe\\deploy\\constrobe.exe"
+        self.process = subprocess.Popen(
+            [path_to_exe, '--from-python'],
+            stdin=subprocess.PIPE,
+            stdout=subprocess.PIPE,
+            stderr=subprocess.STDOUT,#PIPE,
+            text=True,
+            creationflags=subprocess.CREATE_NEW_CONSOLE
+        )
+        self.keep_reading = True  # Flag to control the reading loop
+        self.finishRunFlag = False
+        self.gotTraceFlag = False
+        self.gotResultsFlag = False
+        self.reader_thread = threading.Thread(target=self.read_messages)
+        self.reader_thread.daemon = True  # Allow thread to exit when main program exits
+        self.reader_thread.start()
+    def write_message(self, message):
+        #if self.logging: 
+        #    debug(f"Sending message: {message}",self.name)
+        self.process.stdin.write(message + "\n")
+        self.process.stdin.flush()
+    def read_messages(self):
+        while self.keep_reading:
+            response = self.process.stdout.readline().strip()
+            #if self.logging: 
+            #    debug(f"Received message: {response}",self.name)
+            if response:
+                parts = response.split(" ",1)
+                type = parts[0]
+                message = parts[1] if len(parts)>1 else ""
+                if type == "FINISHED_RUN":
+                    self.finishRunFlag = True
+                elif type == "CLOSED_CONSTROBE":
+                    self.keep_reading = False  # Stop reading messages
+                    break
+                elif self.callback:
+                    if type == "TRACE":
+                        message=message.replace("|","\n")
+                        self.gotTraceFlag = True
+                    if type == "RESULTS":
+                        self.gotResultsFlag = True
+
+                    response_value = self.callback(type,message)
+                    
+                    if type == "GET":
+                        response_message = f"RESPONSE_TO_GET {response_value}"
+                        self.write_message(response_message)                    
+    def cleanup(self):
+        print("Cleaning up resources...")
+        self.keep_reading = False  # Signal the thread to stop reading
+        self.running = False  
+        self.reader_thread.join(timeout = 2)  # Wait for the thread to finish
+        self.process.stdin.close()
+        self.process.stdout.close()
+        self.process.stderr.close()
+        if self.process:
+            self.process.terminate()  # Try to terminate the process gracefully
+            try:
+                return self.process.wait(timeout=5)  # Wait up to 5 seconds for it to finish
+            except subprocess.TimeoutExpired:
+                debug("Process did not terminate, force killing it...",self.name)
+                self.process.kill()  # Force kill the process if it doesn't terminate in time
+                return self.process.wait()  # Ensure it finishes
+    def stop(self, graceful=True, timeout=5):
+        """Stop the process and cleanup."""
+        self.keep_reading = False
+
+        if not getattr(self, "process", None):
+            return
+
+        # If already stopped, nothing to do
+        if self.process.poll() is not None:
+            print(f"[{self.name}] Process already stopped.")
+            return
+
+        if graceful:
+            try:
+                if self.process.stdin:
+                    self.process.stdin.write("EXIT\n")
+                    self.process.stdin.flush()
+                    # closing stdin often helps the child exit cleanly
+                    try:
+                        self.process.stdin.close()
+                    except Exception:
+                        pass
+            except Exception:
+                pass
+
+        # Ask OS to terminate
+        try:
+            self.process.terminate()
+        except Exception:
+            pass
+
+        # Wait, then force kill if needed
+        try:
+            self.process.wait(timeout=timeout)
+        except subprocess.TimeoutExpired:
+            try:
+                self.process.kill()
+            except Exception:
+                pass
+            try:
+                self.process.wait()
+            except Exception:
+                pass
+
+        print(f"[{self.name}] Process stopped.")

{pyconstrobe-0.1 → pyconstrobe-1.0.2}/pyconstrobe.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
-Metadata-Version: 2.2
+Metadata-Version: 2.4
 Name: pyconstrobe
-Version: 0.1
+Version: 1.0.2
 Summary: This package is used to automate the DES application ConStrobe.
 Author: Joseph Louis
 Author-email: joseph.louis@oregonstate.edu
@@ -11,6 +11,7 @@ Dynamic: author
 Dynamic: author-email
 Dynamic: description
 Dynamic: description-content-type
+Dynamic: license-file
 Dynamic: requires-python
 Dynamic: summary
 

{pyconstrobe-0.1 → pyconstrobe-1.0.2}/pyconstrobe.egg-info/SOURCES.txt

@@ -1,9 +1,8 @@
 LICENSE
 README.md
 setup.py
-csPy/__init__.py
-csPy/process_manager.py
 pyconstrobe/__init__.py
+pyconstrobe/hlaconstrobe.py
 pyconstrobe/process_manager.py
 pyconstrobe.egg-info/PKG-INFO
 pyconstrobe.egg-info/SOURCES.txt

{pyconstrobe-0.1 → pyconstrobe-1.0.2}/pyconstrobe.egg-info/top_level.txt

@@ -1,2 +1 @@
-csPy
 pyconstrobe

{pyconstrobe-0.1 → pyconstrobe-1.0.2}/setup.py

@@ -1,8 +1,15 @@
 from setuptools import setup, find_packages
+from pathlib import Path
+
+def get_version():
+    version_file = Path(__file__).parent / "pyconstrobe" / "__init__.py"
+    for line in version_file.read_text().splitlines():
+        if line.startswith("__version__"):
+            return line.split("=")[-1].strip().strip('"').strip("'")
 
 setup(
     name="pyconstrobe",      # Replace with your package name
-    version="0.1",                 # Version number
+    version=get_version(),                 # Version number
     packages=find_packages(),      # Automatically find and include all packages
     author="Joseph Louis",
     author_email="joseph.louis@oregonstate.edu",

pyconstrobe-0.1/csPy/__init__.py

@@ -1,6 +0,0 @@
-# Importing the ProcessManager class for easy access
-from .process_manager import ProcessManager
-
-# You can add any other initializations or imports here
-__version__ = "0.1.0"
-__all__ = ['ProcessManager']

pyconstrobe-0.1/csPy/process_manager.py

@@ -1,67 +0,0 @@
-import subprocess
-import threading
-import os
-
-
-
-class ProcessManager:
-    def __init__(self, callback=None):
-        build_mode = os.getenv('BUILD_MODE', 'Release')  # Default to 'release' if not set
-        print(build_mode)
-        if build_mode=='Debug':
-            path_to_exe = r"C:\source\constrobe\csApp\Debug\constrobe.exe"
-        else:
-            path_to_exe = r"C:\Program Files\constrobe\constrobe\constrobe.exe"
-
-
-
-        self.process = subprocess.Popen(
-            [path_to_exe, '--from-python'],
-            stdin=subprocess.PIPE,
-            stdout=subprocess.PIPE,
-            stderr=subprocess.PIPE,
-            text=True,
-            creationflags=subprocess.CREATE_NEW_CONSOLE
-        )
-        self.callback = callback  # Custom callback for processing messages
-        self.keep_reading = True  # Flag to control the reading loop
-        self.reader_thread = threading.Thread(target=self.read_messages)
-        self.reader_thread.daemon = True  # Allow thread to exit when main program exits
-        self.reader_thread.start()
-
-    def write_message(self, message):
-        """Write a message to the process's stdin."""
-        self.process.stdin.write(message + "\n")
-        self.process.stdin.flush()
-
-    def read_messages(self):
-        """Read messages from the process's stdout."""
-        while self.keep_reading:
-            response = self.process.stdout.readline().strip()
-            if response:
-                if response == "COMPLETE":
-                    print("Process completed.")
-                    self.keep_reading = False  # Stop reading messages
-                    break
-                if self.callback:
-                    response_message = self.callback(response)
-                    if response_message:
-                        self.write_message(response_message)
-
-    def cleanup(self):
-        """Clean up the process and close streams."""
-        print("Cleaning up resources...")
-        self.keep_reading = False  # Signal the thread to stop reading
-        self.running = False  
-        self.reader_thread.join()  # Wait for the thread to finish
-        self.process.stdin.close()
-        self.process.stdout.close()
-        self.process.stderr.close()
-        if self.process:
-            self.process.terminate()  # Try to terminate the process gracefully
-            try:
-                return self.process.wait(timeout=5)  # Wait up to 5 seconds for it to finish
-            except subprocess.TimeoutExpired:
-                print("Process did not terminate, force killing it...")
-                self.process.kill()  # Force kill the process if it doesn't terminate in time
-                return self.process.wait()  # Ensure it finishes

pyconstrobe-0.1/pyconstrobe/__init__.py

@@ -1,6 +0,0 @@
-# Importing the ProcessManager class for easy access
-from .process_manager import ProcessManager
-
-# You can add any other initializations or imports here
-__version__ = "0.1.0"
-__all__ = ['ProcessManager']

pyconstrobe-0.1/pyconstrobe/process_manager.py

@@ -1,67 +0,0 @@
-import subprocess
-import threading
-import os
-
-
-
-class ProcessManager:
-    def __init__(self, callback=None):
-        build_mode = os.getenv('BUILD_MODE', 'Release')  # Default to 'release' if not set
-        print(build_mode)
-        if build_mode=='Debug':
-            path_to_exe = r"C:\source\constrobe\csApp\Debug\constrobe.exe"
-        else:
-            path_to_exe = r"C:\Program Files\constrobe\constrobe\constrobe.exe"
-
-
-
-        self.process = subprocess.Popen(
-            [path_to_exe, '--from-python'],
-            stdin=subprocess.PIPE,
-            stdout=subprocess.PIPE,
-            stderr=subprocess.PIPE,
-            text=True,
-            creationflags=subprocess.CREATE_NEW_CONSOLE
-        )
-        self.callback = callback  # Custom callback for processing messages
-        self.keep_reading = True  # Flag to control the reading loop
-        self.reader_thread = threading.Thread(target=self.read_messages)
-        self.reader_thread.daemon = True  # Allow thread to exit when main program exits
-        self.reader_thread.start()
-
-    def write_message(self, message):
-        """Write a message to the process's stdin."""
-        self.process.stdin.write(message + "\n")
-        self.process.stdin.flush()
-
-    def read_messages(self):
-        """Read messages from the process's stdout."""
-        while self.keep_reading:
-            response = self.process.stdout.readline().strip()
-            if response:
-                if response == "COMPLETE":
-                    print("Process completed.")
-                    self.keep_reading = False  # Stop reading messages
-                    break
-                if self.callback:
-                    response_message = self.callback(response)
-                    if response_message:
-                        self.write_message(response_message)
-
-    def cleanup(self):
-        """Clean up the process and close streams."""
-        print("Cleaning up resources...")
-        self.keep_reading = False  # Signal the thread to stop reading
-        self.running = False  
-        self.reader_thread.join()  # Wait for the thread to finish
-        self.process.stdin.close()
-        self.process.stdout.close()
-        self.process.stderr.close()
-        if self.process:
-            self.process.terminate()  # Try to terminate the process gracefully
-            try:
-                return self.process.wait(timeout=5)  # Wait up to 5 seconds for it to finish
-            except subprocess.TimeoutExpired:
-                print("Process did not terminate, force killing it...")
-                self.process.kill()  # Force kill the process if it doesn't terminate in time
-                return self.process.wait()  # Ensure it finishes