pyconstrobe 1.0.2__tar.gz → 1.0.4__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pyconstrobe
-Version: 1.0.2
+Version: 1.0.4
 Summary: This package is used to automate the DES application ConStrobe.
 Author: Joseph Louis
 Author-email: joseph.louis@oregonstate.edu
@@ -15,8 +15,7 @@ Dynamic: license-file
 Dynamic: requires-python
 Dynamic: summary
 
-This package works when jStrobe is installed at c:/Program Files/jStrobe/jStrobe/jStrobe.exe
+This package works when ConStrobe is installed at C:/Program Files/ConStrobe/ConStrobe.exe
 
-Download example files from https://github.com/jlouis2k4/TestPythonJS
 
 

pyconstrobe-1.0.4/README.md

@@ -0,0 +1,4 @@
+This package works when ConStrobe is installed at C:/Program Files/ConStrobe/ConStrobe.exe
+
+
+

pyconstrobe-1.0.4/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, request_federation_shutdown
+
+
+# You can add any other initializations or imports here
+__version__ = "1.0.4"
+__all__ = ['ProcessManager', 'run_federation','send_control', 'request_federation_shutdown']

pyconstrobe-1.0.4/pyconstrobe/hlaconstrobe.py

@@ -0,0 +1,235 @@
+import subprocess
+import threading
+import time
+import os
+import platform
+from pyconstrobe import ProcessManager
+from pathlib import Path
+FEDERATION_NAME = "SimulationFederation"
+rtig_proc = None
+listener_proc = None
+listener_thread = None
+shutdown_now = threading.Event()
+fedhandles = {}
+ending_federates = set()
+federation_ending = False
+build_mode = os.getenv('BUILD_MODE', 'Release')
+system = platform.system()
+listener_write_lock = threading.Lock()
+if system == "Windows":
+    RUNTIME_DIR = Path(r"C:/Program Files/constrobe")
+    if build_mode == "Debug":
+        LISTENER_PATH = Path(r"C:/dev/tools/certi/ListenerFederate/x64/Debug/ListenerFederate.exe")
+    else:
+        LISTENER_PATH = RUNTIME_DIR / "ListenerFederate.exe"
+    RTIG_PATH = RUNTIME_DIR / "rtig.exe"
+    FOM_DIR = RUNTIME_DIR
+elif system == "Linux":
+    RUNTIME_DIR = Path.home() / "dev" / "constrobe-runtime"
+    if build_mode == "Debug":
+        LISTENER_PATH = (Path.home() / "dev/tools/certi/ListenerFederate/build-linux/ListenerFederate")
+    else:
+        LISTENER_PATH = RUNTIME_DIR / "bin" / "ListenerFederate"
+    RTIG_PATH = RUNTIME_DIR / "bin" / "rtig"
+    FOM_DIR = RUNTIME_DIR / "fom"
+else:
+    raise RuntimeError(f"Unsupported operating system: {system}")
+
+def start_rtig():
+    global rtig_proc
+    print("Starting rtig...")
+    if system == "Windows":
+        subprocess.run(
+            ["taskkill", "/F", "/IM", "rtig.exe"],
+            stdout=subprocess.DEVNULL,
+            stderr=subprocess.DEVNULL
+        )
+        appdata = Path(os.environ["LOCALAPPDATA"]) / "ConStrobe"
+    elif system == "Linux":
+        subprocess.run(
+            ["pkill", "-x", "rtig"],
+            stdout=subprocess.DEVNULL,
+            stderr=subprocess.DEVNULL
+        )
+        appdata = Path.home() / ".local" / "share" / "ConStrobe"
+    appdata.mkdir(parents=True, exist_ok=True)
+    rtig_proc = subprocess.Popen(
+        [str(RTIG_PATH), "-v", "2", "-l", "127.0.0.1"],
+        cwd=appdata,
+        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(
+        [
+            str(LISTENER_PATH),
+            str(num_feds),
+        ],
+        cwd=FOM_DIR,
+        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 not line:
+            continue
+        line = line.strip()
+        if line.startswith("[DEBUG]"):
+            print(line)
+            continue
+        is_hla_message = (line.startswith("[HLACOMMUNICATION]") or line.startswith("[HLACOORDINATION]"))
+        if not is_hla_message:
+            if logging:
+                print(line)
+            continue
+        line = line.split("]", 1)[1].strip()
+        
+        if "|" not in line:
+            continue
+        fed, msg = line.split("|", 1)
+        fed = fed.strip()
+        msg = msg.strip()
+        if msg == "ENDFEDERATION":
+            callback(fed, "ENDFEDERATION Requested. Proceeding to do so...")
+            request_federation_shutdown()
+            continue
+        if msg == "ENDFEDERATE":
+            callback(fed, "ENDFEDERATE Requested. Proceeding to do so...")
+            request_federate_shutdown(fed)
+            continue
+        callback(fed, msg)
+
+
+def send_control(line):
+    try:
+        with listener_write_lock:
+            if listener_proc and listener_proc.stdin:
+                listener_proc.stdin.write(line + "\n")
+                listener_proc.stdin.flush()
+    except Exception as e:
+        print(f"send_control failed: {e}")
+def start_simulation(fedName, modelName,pythoncallback=None,startupCommands= 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)
+    if startupCommands is not None:
+        for command in startupCommands:
+            manager.write_message(command)
+    message = f"STARTFEDERATE {fedName};"
+    manager.write_message(message)
+    return manager
+def run_federation(simfederates,listenerCallback,logging=True):
+    global federation_ending
+    shutdown_now.clear()
+    fedhandles.clear()
+    ending_federates.clear()
+    federation_ending = False
+    start_rtig()
+    launch_listener(len(simfederates),listenerCallback, logging)
+    for fedName, modelName, callback, startupCommands in simfederates:
+        if fedName.upper() == "UNITY":
+            print("Unity federate expected externally. Start it manually from Unity.")
+            continue
+        h = start_simulation(fedName, modelName, callback, startupCommands, logging)
+        h.write_message(f"RUNMODEL;")
+        fedhandles[fedName] = h
+    try:
+        while not shutdown_now.is_set():
+            check_all_federates_closed()
+            time.sleep(0.1)
+    finally:
+        print("Stop federation: Initiated")
+        stop_federation()
+        print("Stop federation: Success")
+def request_federate_shutdown(fedName):
+    print(f"Stop federate: Requested for {fedName}")
+    if fedName in ending_federates:
+        print(f"Stop federate: {fedName} already ending")
+        return
+    h = fedhandles.get(fedName)
+    if h is not None:
+        ending_federates.add(fedName)
+        send_control(f"CONTROLSIGNAL {fedName} ENDFEDERATE")
+    else:
+        print(f"Stop federate: No Python handle found for {fedName}")
+def federate_closed(fedName):
+    print(f"Stop federate: Closed {fedName}")
+
+    fedhandles.pop(fedName, None)
+    ending_federates.discard(fedName)
+
+    if not fedhandles:
+        print("All federates closed.")
+        shutdown_now.set() 
+def check_all_federates_closed():
+    if fedhandles and all(h.closedFlag for h in fedhandles.values()):
+        print("All federates closed.")
+        fedhandles.clear()
+        ending_federates.clear()
+        shutdown_now.set()
+def request_federation_shutdown():
+    global federation_ending
+    if federation_ending:
+        print("Stop federation: Already requested")
+        return
+    federation_ending = True
+    print("Stop federation: Requested")
+    for fedName in list(fedhandles.keys()):
+        request_federate_shutdown(fedName)
+    #shutdown_now.set()
+def stop_federation():
+    global listener_proc, listener_thread, rtig_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
+    if listener_thread is not None:
+        try:
+            listener_thread.join(timeout=2)
+        except Exception:
+            pass
+
+    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

{pyconstrobe-1.0.2 → pyconstrobe-1.0.4}/pyconstrobe/process_manager.py

@@ -1,12 +1,11 @@
 import subprocess
 import threading
 import os
+import platform
 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':
@@ -19,37 +18,53 @@ class ProcessManager:
         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"
+        system = platform.system()
+        if system == "Windows":
+            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"
+
+                #comment this
+                #path_to_exe = r"C:\\dev\\source\\constrobe\\csApp\\Release\\constrobe.exe"
+            creationflags = subprocess.CREATE_NEW_CONSOLE
+        elif system == "Linux":
+            if build_mode == "Debug":
+                path_to_exe = os.path.expanduser("~/dev/source/constrobe/build-linux/csApp")
+            else:
+                path_to_exe = os.path.expanduser("~/dev/constrobe-runtime/bin/ConStrobe")
+            creationflags = 0
         else:
-            path_to_exe = r"C:\\Program Files\\constrobe\\constrobe.exe"
-            #path_to_exe = r"C:\\dev\\source\\constrobe\\deploy\\constrobe.exe"
+            raise RuntimeError(f"Unsupported operating system: {system}")
+               
         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
+            creationflags=creationflags
         )
         self.keep_reading = True  # Flag to control the reading loop
         self.finishRunFlag = False
         self.gotTraceFlag = False
         self.gotResultsFlag = False
+        self.closedFlag = 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)
+        #print(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)
+            #print(f"Received message: {response}",self.name)
             if response:
+                #print(response)
                 parts = response.split(" ",1)
                 type = parts[0]
                 message = parts[1] if len(parts)>1 else ""
@@ -57,6 +72,7 @@ class ProcessManager:
                     self.finishRunFlag = True
                 elif type == "CLOSED_CONSTROBE":
                     self.keep_reading = False  # Stop reading messages
+                    self.closedFlag = True
                     break
                 elif self.callback:
                     if type == "TRACE":
@@ -70,64 +86,40 @@ class ProcessManager:
                     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."""
+    def stop(self, send_close=True, timeout=5):
         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:
+        if send_close and self.process.poll() is None:
             try:
                 if self.process.stdin:
-                    self.process.stdin.write("EXIT\n")
+                    self.process.stdin.write("CLOSE;\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)
+            if self.process.poll() is None:
+                self.process.terminate()
+                self.process.wait(timeout=timeout)
         except subprocess.TimeoutExpired:
             try:
                 self.process.kill()
+                self.process.wait()
             except Exception:
                 pass
+        except Exception:
+            pass
+        try:
+            self.reader_thread.join(timeout=2)
+        except Exception:
+            pass
+        for pipe in (
+            self.process.stdin,
+            self.process.stdout,
+            self.process.stderr,
+        ):
             try:
-                self.process.wait()
+                if pipe:
+                    pipe.close()
             except Exception:
-                pass
-
-        print(f"[{self.name}] Process stopped.")
+                pass

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pyconstrobe
-Version: 1.0.2
+Version: 1.0.4
 Summary: This package is used to automate the DES application ConStrobe.
 Author: Joseph Louis
 Author-email: joseph.louis@oregonstate.edu
@@ -15,8 +15,7 @@ Dynamic: license-file
 Dynamic: requires-python
 Dynamic: summary
 
-This package works when jStrobe is installed at c:/Program Files/jStrobe/jStrobe/jStrobe.exe
+This package works when ConStrobe is installed at C:/Program Files/ConStrobe/ConStrobe.exe
 
-Download example files from https://github.com/jlouis2k4/TestPythonJS
 
 

pyconstrobe-1.0.2/README.md

@@ -1,5 +0,0 @@
-This package works when jStrobe is installed at c:/Program Files/jStrobe/jStrobe/jStrobe.exe
-
-Download example files from https://github.com/jlouis2k4/TestPythonJS
-
-

pyconstrobe-1.0.2/pyconstrobe/__init__.py

@@ -1,8 +0,0 @@
-# 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

@@ -1,144 +0,0 @@
-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()
-
-