nost-tools 2.3.0__tar.gz → 3.0.0__tar.gz

{nost_tools-2.3.0 → nost_tools-3.0.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: nost_tools
-Version: 2.3.0
+Version: 3.0.0
 Summary: Tools for Novel Observing Strategies Testbed (NOS-T) Applications
 Author-email: "Paul T. Grogan" <paul.grogan@asu.edu>, "Emmanuel M. Gonzalez" <emmanuelgonzalez@asu.edu>
 License-Expression: BSD-3-Clause

{nost_tools-2.3.0 → nost_tools-3.0.0}/nost_tools/__init__.py

@@ -1,4 +1,4 @@
-__version__ = "2.3.0"
+__version__ = "3.0.0"
 
 from .application import Application
 from .application_utils import ConnectionConfig, ModeStatusObserver, TimeStatusPublisher
@@ -6,7 +6,7 @@ from .configuration import ConnectionConfig
 from .entity import Entity
 from .logger_application import LoggerApplication
 from .managed_application import ManagedApplication
-from .manager import Manager, TimeScaleUpdate
+from .manager import Manager
 from .observer import Observable, Observer
 from .publisher import ScenarioTimeIntervalPublisher, WallclockTimeIntervalPublisher
 from .schemas import (

{nost_tools-2.3.0 → nost_tools-3.0.0}/nost_tools/application.py

@@ -4,6 +4,7 @@ Provides a base application that publishes messages from a simulator to a broker
 
 import functools
 import logging
+import logging.handlers
 import os
 import signal
 import ssl
@@ -216,21 +217,21 @@ class Application:
 
         def refresh_wallclock_periodically():
             while not self._should_stop.wait(
-                timeout=self.config.rc.wallclock_offset_properties.wallclock_offset_refresh_interval
+                timeout=self.config.rc.simulation_configuration.execution_parameters.general.wallclock_offset_refresh_interval
             ):
                 logger.debug("Wallclock refresh thread is running.")
                 try:
-                    logger.info(
-                        f"Contacting {self.config.rc.wallclock_offset_properties.ntp_host} to retrieve wallclock offset."
+                    logger.debug(
+                        f"Contacting {self.config.rc.simulation_configuration.execution_parameters.general.ntp_host} to retrieve wallclock offset."
                     )
                     response = ntplib.NTPClient().request(
-                        self.config.rc.wallclock_offset_properties.ntp_host,
+                        self.config.rc.simulation_configuration.execution_parameters.general.ntp_host,
                         version=3,
                         timeout=2,
                     )
                     offset = timedelta(seconds=response.offset)
                     self.simulator.set_wallclock_offset(offset)
-                    logger.info(f"Wallclock offset updated to {offset}.")
+                    logger.debug(f"Wallclock offset updated to {offset}.")
                 except Exception as e:
                     logger.debug(f"Failed to refresh wallclock offset: {e}")
 
@@ -308,6 +309,17 @@ class Application:
                 self.shut_down_when_terminated = getattr(
                     parameters, "shut_down_when_terminated", shut_down_when_terminated
                 )
+
+                # Configure file logging if requested
+                if getattr(parameters, "enable_file_logging", False):
+                    self.configure_file_logging(
+                        log_dir=getattr(parameters, "log_dir", None),
+                        log_filename=getattr(parameters, "log_filename", None),
+                        log_level=getattr(parameters, "log_level", None),
+                        max_bytes=getattr(parameters, "max_bytes", None),
+                        backup_count=getattr(parameters, "backup_count", None),
+                        log_format=getattr(parameters, "log_format", None),
+                    )
             else:
                 logger.warning("No parameters found in configuration, using defaults")
                 self.set_offset = set_offset
@@ -326,7 +338,7 @@ class Application:
         if self.set_offset:
             # Start periodic wallclock offset updates instead of one-time call
             logger.info(
-                f"Wallclock offset will be set every {self.config.rc.wallclock_offset_properties.wallclock_offset_refresh_interval} seconds using {self.config.rc.wallclock_offset_properties.ntp_host}."
+                f"Wallclock offset will be set every {self.config.rc.simulation_configuration.execution_parameters.general.wallclock_offset_refresh_interval} seconds using {self.config.rc.simulation_configuration.execution_parameters.general.ntp_host}."
             )
             self.start_wallclock_refresh_thread()
 
@@ -1475,9 +1487,67 @@ class Application:
 
     def _create_shut_down_observer(self) -> None:
         """
-        Creates an observer to shut down the application when the simulation is terminated.
+        Creates a shut down observer to close the application when the simulator is terminated.
         """
         if self._shut_down_observer is not None:
             self.simulator.remove_observer(self._shut_down_observer)
         self._shut_down_observer = ShutDownObserver(self)
         self.simulator.add_observer(self._shut_down_observer)
+
+    def configure_file_logging(
+        self,
+        log_dir: str = None,
+        log_filename: str = None,
+        log_level: str = None,
+        max_bytes: int = None,
+        backup_count: int = None,
+        log_format: str = None,
+    ):
+        """
+        Configures file logging for the application.
+
+        Args:
+            log_dir (str): Directory where log files will be stored
+            log_filename (str): Name of the log file. If None, a timestamped filename will be used
+            log_level (str): Logging level (e.g., 'DEBUG', 'INFO', 'WARNING', 'ERROR', 'CRITICAL')
+            max_bytes (int): Maximum file size in bytes before rotating
+            backup_count (int): Number of backup files to keep
+            log_format (str): Log message format
+        """
+        try:
+            if log_filename is None:
+                timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
+                log_filename = os.path.join(log_dir, f"{self.app_name}_{timestamp}.log")
+            else:
+                log_filename = os.path.join(log_dir, log_filename)
+
+            # Create log directory if it doesn't exist
+            if log_dir and not os.path.exists(log_dir):
+                os.makedirs(log_dir)
+                logger.info(f"Log directory {log_dir} successfully created.")
+
+            # Configure rotating file handler
+            handler = logging.handlers.RotatingFileHandler(
+                log_filename, maxBytes=max_bytes, backupCount=backup_count
+            )
+
+            # Set log level
+            level = getattr(logging, log_level.upper(), logging.INFO)
+            handler.setLevel(level)
+
+            # Set log format
+            if log_format is not None:
+                formatter = logging.Formatter(log_format)
+                handler.setFormatter(formatter)
+            else:
+                # Default format
+                formatter = logging.Formatter(
+                    "%(asctime)s - %(name)s - %(levelname)s - %(message)s"
+                )
+                handler.setFormatter(formatter)
+
+            # Add the handler to the root logger
+            logging.getLogger().addHandler(handler)
+            logger.info(f"File logging configured: {log_filename} (level: {log_level})")
+        except Exception as e:
+            logger.error(f"Error configuring file logging: {e}")

{nost_tools-2.3.0 → nost_tools-3.0.0}/nost_tools/configuration.py

@@ -21,7 +21,6 @@ from .schemas import (
     RuntimeConfig,
     ServersConfig,
     SimulationConfig,
-    WallclockOffsetProperties,
 )
 
 logger = logging.getLogger(__name__)
@@ -329,7 +328,6 @@ class ConnectionConfig:
             self.load_environment_variables()
 
         self.rc = RuntimeConfig(
-            wallclock_offset_properties=WallclockOffsetProperties(),
             credentials=self.credentials_config,
             server_configuration=server_config,
             simulation_configuration=self.simulation_config,

{nost_tools-2.3.0 → nost_tools-3.0.0}/nost_tools/managed_application.py

@@ -4,12 +4,25 @@ Provides a base application that manages communication between a simulator and b
 
 import logging
 import threading
+import time
 import traceback
 from datetime import datetime, timedelta
 
+from nost_tools.simulator import Mode
+
 from .application import Application
 from .application_utils import ConnectionConfig
-from .schemas import InitCommand, StartCommand, StopCommand, UpdateCommand
+from .schemas import (
+    FreezeCommand,
+    FreezeRequest,
+    InitCommand,
+    ResumeCommand,
+    ResumeRequest,
+    StartCommand,
+    StopCommand,
+    UpdateCommand,
+    UpdateRequest,
+)
 
 logger = logging.getLogger(__name__)
 
@@ -143,6 +156,17 @@ class ManagedApplication(Application):
             app_topic="update",
             user_callback=self.on_manager_update,
         )
+        self.add_message_callback(
+            app_name=self.manager_app_name,
+            app_topic="freeze",
+            user_callback=self.on_manager_freeze,
+        )
+
+        self.add_message_callback(
+            app_name=self.manager_app_name,
+            app_topic="resume",
+            user_callback=self.on_manager_resume,
+        )
 
     def shut_down(self) -> None:
         """
@@ -259,16 +283,166 @@ class ManagedApplication(Application):
             body (bytes): The actual message body sent, containing the message payload.
         """
         try:
-            # Parse message payload
             message = body.decode("utf-8")
-            params = UpdateCommand.model_validate_json(message).tasking_parameters
+            update_cmd = UpdateCommand.model_validate_json(message)
+            params = update_cmd.tasking_parameters
+            tcf = params.time_scaling_factor
+            sim_epoch = params.sim_update_time
+
             logger.info(f"Received update command {message}")
-            # update execution time scale factor
-            self.simulator.set_time_scale_factor(
-                params.time_scaling_factor, params.sim_update_time
+
+            def _apply_when_executing():
+                while self.simulator.get_mode() != Mode.EXECUTING:
+                    time.sleep(0.01)
+                # Apply update once executing
+                self.simulator.set_time_scale_factor(tcf, sim_epoch)
+
+            if self.simulator.get_mode() != Mode.EXECUTING:
+                logger.debug("Deferring time scale update until EXECUTING")
+                threading.Thread(target=_apply_when_executing, daemon=True).start()
+            else:
+                self.simulator.set_time_scale_factor(tcf, sim_epoch)
+        except Exception as e:
+            logger.error(
+                f"Exception (topic: {method.routing_key}, payload: {message}): {e}"
             )
+            print(traceback.format_exc())
+
+    def on_manager_freeze(self, ch, method, properties, body) -> None:
+        """
+        Callback function for the managed application ('self') to respond to a freeze command sent from the manager.
+        Parses the freeze duration and simulation freeze time and updates the simulator.
+
+        Args:
+            ch (:obj:`pika.channel.Channel`): The channel object used to communicate with the RabbitMQ server.
+            method (:obj:`pika.spec.Basic.Deliver`): Delivery-related information such as delivery tag, exchange, and routing key.
+            properties (:obj:`pika.BasicProperties`): Message properties including content type, headers, and more.
+            body (bytes): The actual message body sent, containing the message payload.
+        """
+        try:
+            # Parse message payload
+            message = body.decode("utf-8")
+            params = FreezeCommand.model_validate_json(message).tasking_parameters
+            logger.info(f"Received freeze command {message}")
+            # freeze simulation time
+            self.simulator.pause()
+
+        except Exception as e:
+            logger.error(
+                f"Exception (topic: {method.routing_key}, payload: {message}): {e}"
+            )
+            print(traceback.format_exc())
+
+    def on_manager_resume(self, ch, method, properties, body) -> None:
+        """
+        Callback function for the managed application ('self') to respond to a resume command sent from the manager.
+        Resumes the simulator execution.
+
+        Args:
+            ch (:obj:`pika.channel.Channel`): The channel object used to communicate with the RabbitMQ server.
+            method (:obj:`pika.spec.Basic.Deliver`): Delivery-related information such as delivery tag, exchange, and routing key.
+            properties (:obj:`pika.BasicProperties`): Message properties including content type, headers, and more.
+            body (bytes): The actual message body sent, containing the message payload.
+        """
+        try:
+            # Parse message payload
+            message = body.decode("utf-8")
+            params = ResumeCommand.model_validate_json(message).tasking_parameters
+            logger.info(f"Received resume command {message}")
+            # resume simulation time
+            self.simulator.resume()
         except Exception as e:
             logger.error(
                 f"Exception (topic: {method.routing_key}, payload: {message}): {e}"
             )
             print(traceback.format_exc())
+
+    def request_freeze(
+        self, freeze_duration: timedelta = None, sim_freeze_time: datetime = None
+    ) -> None:
+        """
+        Request a freeze from the manager.
+
+        Args:
+            freeze_duration (:obj:`timedelta`, optional): Duration for which to freeze execution.
+                                                        If None, creates an indefinite freeze.
+            sim_freeze_time (:obj:`datetime`, optional): Scenario time at which to freeze execution.
+                                                        If None, freezes immediately.
+        """
+        # Publish a freeze request message
+        wallclock_time = self.simulator.get_wallclock_time_at_simulation_time(
+            sim_freeze_time
+        )
+        request_params = {
+            "simFreezeTime": sim_freeze_time,
+            "freezeTime": wallclock_time,
+            "requestingApp": self.app_name,
+        }
+        if freeze_duration is not None:
+            request_params["freezeDuration"] = freeze_duration
+            request_params["resumeTime"] = wallclock_time + freeze_duration
+        # Create the freeze request
+        request = FreezeRequest.model_validate({"taskingParameters": request_params})
+        freeze_type = (
+            "indefinite" if freeze_duration is None else f"timed ({freeze_duration})"
+        )
+        logger.info(
+            f"Requesting {freeze_type} freeze: {request.model_dump_json(by_alias=True)}"
+        )
+        # Send the request to the manager
+        self.send_message(
+            app_name=self.app_name,
+            app_topics="request.freeze",
+            payload=request.model_dump_json(by_alias=True),
+        )
+
+    def request_resume(self) -> None:
+        """
+        Request a resume from the manager.
+        """
+        # Create the resume request
+        request = ResumeRequest.model_validate(
+            {"taskingParameters": {"requestingApp": self.app_name}}
+        )
+
+        logger.info(f"Requesting resume: {request.model_dump_json(by_alias=True)}")
+
+        # Send the request to the manager
+        self.send_message(
+            app_name=self.app_name,
+            app_topics="request.resume",
+            payload=request.model_dump_json(by_alias=True),
+        )
+
+    def request_update(
+        self, time_scale_factor: float, sim_update_time: datetime = None
+    ) -> None:
+        """
+        Request a time scale factor update from the manager.
+
+        Args:
+            time_scale_factor (float): scenario seconds per wallclock second
+            sim_update_time (:obj:`datetime`, optional): Scenario time at which to update.
+                                                        If None, updates immediately.
+        """
+        # Publish an update request message
+        request_params = {
+            "timeScalingFactor": time_scale_factor,
+            "requestingApp": self.app_name,
+        }
+        if sim_update_time is not None:
+            request_params["simUpdateTime"] = sim_update_time
+
+        # Create the update request
+        request = UpdateRequest.model_validate({"taskingParameters": request_params})
+
+        logger.info(
+            f"Requesting time scale factor update to {time_scale_factor}: {request.model_dump_json(by_alias=True)}"
+        )
+
+        # Send the request to the manager
+        self.send_message(
+            app_name=self.app_name,
+            app_topics="request.update",
+            payload=request.model_dump_json(by_alias=True),
+        )