nost-tools 2.2.0__tar.gz → 2.4.0__tar.gz

{nost_tools-2.2.0 → nost_tools-2.4.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: nost_tools
-Version: 2.2.0
+Version: 2.4.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.2.0 → nost_tools-2.4.0}/nost_tools/__init__.py

@@ -1,4 +1,4 @@
-__version__ = "2.2.0"
+__version__ = "2.4.0"
 
 from .application import Application
 from .application_utils import ConnectionConfig, ModeStatusObserver, TimeStatusPublisher

{nost_tools-2.2.0 → nost_tools-2.4.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
@@ -48,13 +49,19 @@ class Application:
         time_status_init (:obj:`datetime`): Scenario time of first time status message
     """
 
-    def __init__(self, app_name: str, app_description: str = None):
+    def __init__(
+        self,
+        app_name: str,
+        app_description: str = None,
+        setup_signal_handlers: bool = True,
+    ):
         """
         Initializes a new application.
 
         Args:
             app_name (str): application name
             app_description (str): application description (optional)
+            setup_signal_handlers (bool): whether to set up signal handlers (default: True)
         """
         self.simulator = Simulator()
         self.connection = None
@@ -85,8 +92,12 @@ class Application:
         self._token_refresh_thread = None
         self.token_refresh_interval = None
         self._reconnect_delay = None
+        # Offset
+        self._wallclock_refresh_thread = None
+        self.wallclock_offset_refresh_interval = None
         # Set up signal handlers for graceful shutdown
-        self._setup_signal_handlers()
+        if setup_signal_handlers:
+            self._setup_signal_handlers()
 
     def _setup_signal_handlers(self):
         """
@@ -194,6 +205,42 @@ class Application:
         self._token_refresh_thread.start()
         logger.debug("Starting refresh token thread successfully completed.")
 
+    def start_wallclock_refresh_thread(self):  # , interval=30, host="pool.ntp.org"):
+        """
+        Starts a background thread to refresh the wallclock offset periodically.
+
+        Args:
+            interval (int): Seconds between wallclock offset refreshes (default: 3600 seconds/1 hour)
+            host (str): NTP host to query (default: 'pool.ntp.org')
+        """
+        logger.debug("Starting wallclock offset refresh thread.")
+
+        def refresh_wallclock_periodically():
+            while not self._should_stop.wait(
+                timeout=self.config.rc.wallclock_offset_properties.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."
+                    )
+                    response = ntplib.NTPClient().request(
+                        self.config.rc.wallclock_offset_properties.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}.")
+                except Exception as e:
+                    logger.debug(f"Failed to refresh wallclock offset: {e}")
+
+        self._wallclock_refresh_thread = threading.Thread(
+            target=refresh_wallclock_periodically
+        )
+        self._wallclock_refresh_thread.start()
+        logger.debug("Starting wallclock offset refresh thread successfully completed.")
+
     def update_connection_credentials(self, access_token):
         """
         Updates the connection credentials with the new access token.
@@ -203,14 +250,33 @@ class Application:
         """
         self.connection.update_secret(access_token, "secret")
 
+    def _get_parameters_from_config(self):
+        """
+        Gets application parameters from configuration or returns None if not available.
+        This method can be overridden by subclasses to customize parameter retrieval.
+
+        Returns:
+            object: Configuration parameters object or None
+        """
+        if self.config and self.config.rc.yaml_file:
+            try:
+                return getattr(
+                    self.config.rc.simulation_configuration.execution_parameters,
+                    "application",
+                    None,
+                )
+            except (AttributeError, KeyError):
+                return None
+        return None
+
     def start_up(
         self,
         prefix: str,
         config: ConnectionConfig,
-        set_offset: bool = None,  # True,
+        set_offset: bool = True,
         time_status_step: timedelta = None,
         time_status_init: datetime = None,
-        shut_down_when_terminated: bool = None,
+        shut_down_when_terminated: bool = False,
     ) -> None:
         """
         Starts up the application to prepare for scenario execution.
@@ -225,31 +291,56 @@ class Application:
             time_status_init (:obj:`datetime`): scenario time for first time status message
             shut_down_when_terminated (bool): True, if the application should shut down when the simulation is terminated
         """
-        if (
-            set_offset is not None
-            and time_status_step is not None
-            and time_status_init is not None
-            and shut_down_when_terminated is not None
-        ):
+        self.config = config
+
+        if self.config.rc.yaml_file:
+            logger.info(
+                f"Collecting start up parameters from YAML configuration file: {self.config.rc.yaml_file}"
+            )
+            parameters = self._get_parameters_from_config()
+            if parameters:
+                self.set_offset = getattr(parameters, "set_offset", set_offset)
+                self.time_status_step = getattr(
+                    parameters, "time_status_step", time_status_step
+                )
+                self.time_status_init = getattr(
+                    parameters, "time_status_init", time_status_init
+                )
+                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
+                self.time_status_step = time_status_step
+                self.time_status_init = time_status_init
+                self.shut_down_when_terminated = shut_down_when_terminated
+        else:
+            logger.info(
+                f"Collecting start up parameters from user input or default values."
+            )
             self.set_offset = set_offset
             self.time_status_step = time_status_step
             self.time_status_init = time_status_init
             self.shut_down_when_terminated = shut_down_when_terminated
-        else:
-            self.config = config
-            parameters = getattr(
-                self.config.rc.simulation_configuration.execution_parameters,
-                "application",
-                None,
-            )
-            self.set_offset = parameters.set_offset
-            self.time_status_step = parameters.time_status_step
-            self.time_status_init = parameters.time_status_init
-            self.shut_down_when_terminated = parameters.shut_down_when_terminated
 
         if self.set_offset:
-            # Set the system clock offset
-            self.set_wallclock_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}."
+            )
+            self.start_wallclock_refresh_thread()
 
         # Set the prefix and configuration parameters
         self.prefix = prefix
@@ -290,7 +381,6 @@ class Application:
             locale=config.rc.server_configuration.servers.rabbitmq.locale,
             blocked_connection_timeout=config.rc.server_configuration.servers.rabbitmq.blocked_connection_timeout,
         )
-        logger.info(parameters)
 
         # Configure transport layer security (TLS) if needed
         if self.config.rc.server_configuration.servers.rabbitmq.tls:
@@ -1348,34 +1438,26 @@ class Application:
                     )
                 else:
                     logger.info("Closing token refresh thread completed successfully")
-
+            # Also stop wallclock refresh thread if it exists
+            if (
+                hasattr(self, "_wallclock_refresh_thread")
+                and self._wallclock_refresh_thread
+                and self._wallclock_refresh_thread.is_alive()
+            ):
+                logger.info("Closing wallclock refresh thread.")
+                # Set a timeout to avoid hanging indefinitely
+                self._wallclock_refresh_thread.join(timeout=60.0)
+                # Check if it's still alive after timeout
+                if self._wallclock_refresh_thread.is_alive():
+                    logger.warning(
+                        "Closing wallclock refresh thread timed out after 60 seconds. "
+                    )
+                else:
+                    logger.info(
+                        "Closing wallclock refresh thread completed successfully"
+                    )
             logger.debug("Stop_application completed successfully.")
 
-    def set_wallclock_offset(
-        self, host="pool.ntp.org", retry_delay_s: int = 5, max_retry: int = 5
-    ) -> None:
-        """
-        Issues a Network Time Protocol (NTP) request to determine the system clock offset.
-
-        Args:
-            host (str): NTP host (default: 'pool.ntp.org')
-            retry_delay_s (int): number of seconds to wait before retrying
-            max_retry (int): maximum number of retries allowed
-        """
-        for i in range(max_retry):
-            try:
-                logger.info(f"Contacting {host} to retrieve wallclock offset.")
-                response = ntplib.NTPClient().request(host, version=3, timeout=2)
-                offset = timedelta(seconds=response.offset)
-                self.simulator.set_wallclock_offset(offset)
-                logger.info(f"Wallclock offset updated to {offset}.")
-                return
-            except ntplib.NTPException:
-                logger.warning(
-                    f"Could not connect to {host}, attempt #{i+1}/{max_retry} in {retry_delay_s} s."
-                )
-                time.sleep(retry_delay_s)
-
     def _create_time_status_publisher(
         self, time_status_step: timedelta, time_status_init: datetime
     ) -> None:
@@ -1405,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.2.0 → nost_tools-2.4.0}/nost_tools/configuration.py

@@ -21,6 +21,7 @@ from .schemas import (
     RuntimeConfig,
     ServersConfig,
     SimulationConfig,
+    WallclockOffsetProperties,
 )
 
 logger = logging.getLogger(__name__)
@@ -52,6 +53,7 @@ class ConnectionConfig:
         password: str = None,
         rabbitmq_host: str = None,
         rabbitmq_port: int = None,
+        keycloak_authentication: bool = False,
         keycloak_host: str = None,
         keycloak_port: int = None,
         keycloak_realm: str = None,
@@ -70,6 +72,7 @@ class ConnectionConfig:
             password (str): client password, provided by NOS-T operator
             host (str): broker hostname
             rabbitmq_port (int): RabbitMQ broker port number
+            keycloak_authentication (bool): True, if Keycloak IAM authentication is used
             keycloak_port (int): Keycloak IAM port number
             keycloak_realm (str): Keycloak realm name
             client_id (str): Keycloak client ID
@@ -84,6 +87,7 @@ class ConnectionConfig:
         self.rabbitmq_host = rabbitmq_host
         self.keycloak_host = keycloak_host
         self.rabbitmq_port = rabbitmq_port
+        self.keycloak_authentication = keycloak_authentication
         self.keycloak_port = keycloak_port
         self.keycloak_realm = keycloak_realm
         self.client_id = client_id
@@ -283,6 +287,7 @@ class ConnectionConfig:
                             port=self.rabbitmq_port,
                             virtual_host=self.virtual_host,
                             tls=self.is_tls,
+                            keycloak_authentication=self.keycloak_authentication,
                         ),
                         keycloak=KeycloakConfig(
                             host=self.keycloak_host,
@@ -312,13 +317,8 @@ class ConnectionConfig:
             del server_config.execution
         self.server_config = server_config
 
-        if (
-            self.username is not None
-            and self.password is not None
-            and self.client_id is not None
-            and self.client_secret_key is not None
-        ):
-            logger.info("Using provided credentials.")
+        if self.username is not None and self.password is not None:
+            logger.info("Using user-provided credentials.")
             self.credentials_config = Credentials(
                 username=self.username,
                 password=self.password,
@@ -329,8 +329,10 @@ 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,
             application_configuration=self.app_specific,
+            yaml_file=self.yaml_file,
         )

{nost_tools-2.2.0 → nost_tools-2.4.0}/nost_tools/managed_application.py

@@ -32,27 +32,57 @@ class ManagedApplication(Application):
         time_step (:obj:`timedelta`): scenario time step used in execution
     """
 
-    def __init__(self, app_name: str, app_description: str = None):
+    def __init__(
+        self,
+        app_name: str,
+        app_description: str = None,
+        setup_signal_handlers: bool = True,
+    ):
         """
         Initializes a new managed application.
 
         Args:
             app_name (str): application name
             app_description (str): application description
+            setup_signal_handlers (bool): whether to set up signal handlers (default: True)
         """
-        super().__init__(app_name, app_description)
+        super().__init__(
+            app_name, app_description, setup_signal_handlers=setup_signal_handlers
+        )
         self.time_step = None
         self._sim_start_time = None
         self._sim_stop_time = None
 
+    def _get_parameters_from_config(self):
+        """
+        Override to get parameters specific to managed applications
+
+        Returns:
+            object: Configuration parameters for this managed application
+        """
+        if self.config and self.config.rc.yaml_file:
+            try:
+                parameters = (
+                    self.config.rc.simulation_configuration.execution_parameters.managed_applications
+                )
+                try:
+                    # Try to get app-specific parameters
+                    return parameters[self.app_name]
+                except KeyError:
+                    # Fall back to default parameters
+                    return parameters.get("default")
+            except (AttributeError, KeyError):
+                return None
+        return None
+
     def start_up(
         self,
         prefix: str,
         config: ConnectionConfig,
-        set_offset: bool = None,
+        set_offset: bool = True,
         time_status_step: timedelta = None,
         time_status_init: datetime = None,
-        shut_down_when_terminated: bool = None,
+        shut_down_when_terminated: bool = False,
         time_step: timedelta = None,
         manager_app_name: str = None,
     ) -> None:
@@ -70,48 +100,27 @@ class ManagedApplication(Application):
             time_step (:obj:`timedelta`): scenario time step used in execution (Default: 1 second)
             manager_app_name (str): manager application name (Default: manager)
         """
-        if (
-            set_offset is not None
-            and time_status_step is not None
-            and time_status_init is not None
-            and shut_down_when_terminated is not None
-            and time_step is not None
-            and manager_app_name is not None
-        ):
-            self.set_offset = set_offset
-            self.time_status_step = time_status_step
-            self.time_status_init = time_status_init
-            self.shut_down_when_terminated = shut_down_when_terminated
-            self.time_step = time_step
-            self.manager_app_name = manager_app_name
-        else:
-            self.config = config
-            parameters = (
-                self.config.rc.simulation_configuration.execution_parameters.managed_applications
-            )
-
-            try:
-                parameters = parameters[self.app_name]
-            except KeyError:
-                parameters = parameters["default"]
-            self.set_offset = parameters.set_offset
-            self.time_status_step = parameters.time_status_step
-            self.time_status_init = parameters.time_status_init
-            self.shut_down_when_terminated = parameters.shut_down_when_terminated
-            self.time_step = parameters.time_step
-            self.manager_app_name = parameters.manager_app_name
+        self.config = config
 
-        # start up base application
+        # Call base start_up to handle common parameters
         super().start_up(
             prefix,
             config,
-            self.set_offset,
-            self.time_status_step,
-            self.time_status_init,
-            self.shut_down_when_terminated,
+            set_offset,
+            time_status_step,
+            time_status_init,
+            shut_down_when_terminated,
         )
-        self.time_step = self.time_step
-        self.manager_app_name = self.manager_app_name
+
+        # Get additional parameters specific to managed applications
+        if self.config.rc.yaml_file:
+            parameters = self._get_parameters_from_config()
+            if parameters:
+                self.time_step = parameters.time_step
+                self.manager_app_name = parameters.manager_app_name
+        else:
+            self.time_step = time_step
+            self.manager_app_name = manager_app_name
 
         # Register callback functions
         self.add_message_callback(

{nost_tools-2.2.0 → nost_tools-2.4.0}/nost_tools/manager.py

@@ -67,12 +67,22 @@ class Manager(Application):
         required_apps_status (dict): Ready status for all required applications
     """
 
-    def __init__(self):
+    def __init__(
+        self,
+        app_name: str = "manager",
+        app_description: str = None,
+        setup_signal_handlers: bool = True,
+    ):
         """
         Initializes a new manager.
+
+        Attributes:
+            setup_signal_handlers (bool): whether to set up signal handlers (default: True)
         """
         # call super class constructor
-        super().__init__("manager")
+        super().__init__(
+            app_name, app_description, setup_signal_handlers=setup_signal_handlers
+        )
         self.required_apps_status = {}
 
         self.sim_start_time = None
@@ -129,16 +139,32 @@ class Manager(Application):
                     f"Heartbeat check: {remaining:.2f} seconds remaining in sleep"
                 )
 
+    def _get_parameters_from_config(self):
+        """
+        Override to get parameters specific to manager application
+
+        Returns:
+            object: Configuration parameters for the manager application
+        """
+        if self.config and self.config.rc.yaml_file:
+            try:
+                return getattr(
+                    self.config.rc.simulation_configuration.execution_parameters,
+                    "manager",
+                    None,
+                )
+            except (AttributeError, KeyError):
+                return None
+        return None
+
     def start_up(
         self,
         prefix: str,
         config: ConnectionConfig,
-        set_offset: bool = None,
+        set_offset: bool = True,
         time_status_step: timedelta = None,
         time_status_init: datetime = None,
-        shut_down_when_terminated: bool = None,
-        time_step: timedelta = None,
-        manager_app_name: str = None,
+        shut_down_when_terminated: bool = False
     ) -> None:
         """
         Starts up the application by connecting to message broker, starting a background event loop,
@@ -151,45 +177,20 @@ class Manager(Application):
             time_status_step (:obj:`timedelta`): scenario duration between time status messages
             time_status_init (:obj:`datetime`): scenario time for first time status message
             shut_down_when_terminated (bool): True, if the application should shut down when the simulation is terminated
-            time_step (:obj:`timedelta`): scenario time step used in execution (Default: 1 second)
-            manager_app_name (str): manager application name (Default: manager)
         """
-        if (
-            set_offset is not None
-            and time_status_step is not None
-            and time_status_init is not None
-            and shut_down_when_terminated is not None
-            and time_step is not None
-            and manager_app_name is not None
-        ):
-            self.set_offset = set_offset
-            self.time_status_step = time_status_step
-            self.time_status_init = time_status_init
-            self.shut_down_when_terminated = shut_down_when_terminated
-            self.time_step = time_step
-            self.manager_app_name = manager_app_name
-        else:
-            self.config = config
-            parameters = (
-                self.config.rc.simulation_configuration.execution_parameters.manager
-            )
-            self.set_offset = parameters.set_offset
-            self.time_status_step = parameters.time_status_step
-            self.time_status_init = parameters.time_status_init
-            self.shut_down_when_terminated = parameters.shut_down_when_terminated
-            self.time_step = parameters.time_step
+        self.config = config
 
-        # start up base application
+        # Call base start_up to handle common parameters
         super().start_up(
             prefix,
             config,
-            self.set_offset,
-            self.time_status_step,
-            self.time_status_init,
-            self.shut_down_when_terminated,
+            set_offset,
+            time_status_step,
+            time_status_init,
+            shut_down_when_terminated,
         )
 
-        # Establish the exchange
+        # Additional manager-specific setup: establish the exchange
         self.establish_exchange()
 
     def execute_test_plan(self, *args, **kwargs) -> None:
@@ -241,8 +242,33 @@ class Manager(Application):
             init_retry_delay_s (float): number of seconds to wait between initialization commands while waiting for required applications
             init_max_retry (int): number of initialization commands while waiting for required applications before continuing to execution
         """
-        # Initialize parameters from arguments or config
-        if sim_start_time is not None and sim_stop_time is not None:
+        if self.config.rc.yaml_file:
+            logger.info(
+                f"Collecting execution parameters from YAML configuration file: {self.config.rc.yaml_file}"
+            )
+            parameters = getattr(
+                self.config.rc.simulation_configuration.execution_parameters,
+                self.app_name,
+                None,
+            )
+            self.sim_start_time = parameters.sim_start_time
+            self.sim_stop_time = parameters.sim_stop_time
+            self.start_time = parameters.start_time
+            self.time_step = parameters.time_step
+            self.time_scale_factor = parameters.time_scale_factor
+            self.time_scale_updates = parameters.time_scale_updates
+            self.time_status_step = parameters.time_status_step
+            self.time_status_init = parameters.time_status_init
+            self.command_lead = parameters.command_lead
+            self.required_apps = [
+                app for app in parameters.required_apps if app != self.app_name
+            ]
+            self.init_retry_delay_s = parameters.init_retry_delay_s
+            self.init_max_retry = parameters.init_max_retry
+        else:
+            logger.info(
+                f"Collecting execution parameters from user input or default values."
+            )
             self.sim_start_time = sim_start_time
             self.sim_stop_time = sim_stop_time
             self.start_time = start_time
@@ -255,36 +281,10 @@ class Manager(Application):
             self.required_apps = required_apps
             self.init_retry_delay_s = init_retry_delay_s
             self.init_max_retry = init_max_retry
-        else:
-            if self.config.rc:
-                logger.info("Retrieving execution parameters from YAML file.")
-                parameters = getattr(
-                    self.config.rc.simulation_configuration.execution_parameters,
-                    self.app_name,
-                    None,
-                )
-                self.sim_start_time = parameters.sim_start_time
-                self.sim_stop_time = parameters.sim_stop_time
-                self.start_time = parameters.start_time
-                self.time_step = parameters.time_step
-                self.time_scale_factor = parameters.time_scale_factor
-                self.time_scale_updates = parameters.time_scale_updates
-                self.time_status_step = parameters.time_status_step
-                self.time_status_init = parameters.time_status_init
-                self.command_lead = parameters.command_lead
-                self.required_apps = [
-                    app for app in parameters.required_apps if app != self.app_name
-                ]
-                self.init_retry_delay_s = parameters.init_retry_delay_s
-                self.init_max_retry = parameters.init_max_retry
-            else:
-                raise ValueError(
-                    "No configuration runtime. Please provide simulation start and stop times."
-                )
 
         # Convert TimeScaleUpdateSchema objects to TimeScaleUpdate objects
         converted_updates = []
-        for update_schema in parameters.time_scale_updates:
+        for update_schema in self.time_scale_updates:
             converted_updates.append(
                 TimeScaleUpdate(
                     time_scale_factor=update_schema.time_scale_factor,
@@ -563,8 +563,17 @@ class Manager(Application):
             app_topics="stop",
             payload=command.model_dump_json(by_alias=True),
         )
-        # update the execution end time
-        self.simulator.set_end_time(sim_stop_time)
+
+        # Update the execution end time if simulator is in EXECUTING mode
+        if self.simulator.get_mode() == Mode.EXECUTING:
+            try:
+                self.simulator.set_end_time(sim_stop_time)
+            except RuntimeError as e:
+                logger.warning(f"Could not set simulator end time: {e}")
+        else:
+            logger.debug(
+                "Skipping setting simulator end time as simulator is not in EXECUTING mode"
+            )
 
     def update(self, time_scale_factor: float, sim_update_time: datetime) -> None:
         """

{nost_tools-2.2.0 → nost_tools-2.4.0}/nost_tools/schemas.py

@@ -280,7 +280,7 @@ class KeycloakConfig(BaseModel):
     realm: str = Field("master", description="Keycloak realm.")
     tls: bool = Field(False, description="Keycloak TLS/SSL.")
     token_refresh_interval: int = Field(
-        60, description="Keycloak token refresh interval, in seconds."
+        240, description="Keycloak token refresh interval, in seconds."
     )
 
 
@@ -307,8 +307,21 @@ class ServersConfig(BaseModel):
         return values
 
 
+class WallclockOffsetProperties(BaseModel):
+    """
+    Properties to report wallclock offset.
+    """
+
+    wallclock_offset_refresh_interval: Optional[int] = Field(
+        10800, description="Wallclock offset refresh interval, in seconds."
+    )
+    ntp_host: Optional[str] = Field(
+        "pool.ntp.org", description="NTP host for wallclock offset synchronization."
+    )
+
+
 class GeneralConfig(BaseModel):
-    prefix: str = Field("nost", description="Execution prefix.")
+    prefix: Optional[str] = Field("nost", description="Execution prefix.")
 
 
 class TimeScaleUpdateSchema(BaseModel):
@@ -324,7 +337,35 @@ class TimeScaleUpdateSchema(BaseModel):
     )
 
 
-class ManagerConfig(BaseModel):
+class LoggingConfig(BaseModel):
+    """
+    Configuration for logging.
+    """
+
+    enable_file_logging: Optional[bool] = Field(
+        False, description="Enable file logging."
+    )
+    log_dir: Optional[str] = Field(
+        "logs", description="Directory path for log files."
+    )
+    log_filename: Optional[str] = Field(None, description="Path to the log file.")
+    log_level: Optional[str] = Field(
+        "INFO", description="Logging level (DEBUG, INFO, WARNING, ERROR, CRITICAL)."
+    )
+    max_bytes: Optional[int] = Field(
+        10 * 1024 * 1024,
+        description="Maximum size of the log file in bytes. Default is 10MB.",
+    )
+    backup_count: Optional[int] = Field(
+        5, description="Number of backup log files to keep."
+    )
+    log_format: Optional[str] = Field(
+        "%(asctime)s [%(levelname)s] %(name)s: %(message)s",
+        description="Format of the log messages.",
+    )
+
+
+class ManagerConfig(LoggingConfig):
     sim_start_time: Optional[datetime] = Field(
         None, description="Simulation start time."
     )
@@ -352,6 +393,10 @@ class ManagerConfig(BaseModel):
     shut_down_when_terminated: bool = Field(
         False, description="Shut down when terminated."
     )
+    is_scenario_time_step: bool = Field(
+        True,
+        description="If True, time_step is in scenario time and won't be scaled. If False, time_step is in wallclock time and will be scaled by the time scale factor.",
+    )
     is_scenario_time_status_step: bool = Field(
         True,
         description="If True, time_status_step is in scenario time and won't be scaled. If False, time_status_step is in wallclock time and will be scaled by the time scale factor.",
@@ -361,6 +406,16 @@ class ManagerConfig(BaseModel):
     def scale_time(cls, values):
         time_scale_factor = values.get("time_scale_factor", 1.0)
 
+        if "time_step" in values and not values.get("is_scenario_time_step", True):
+            time_step = values["time_step"]
+            if isinstance(time_step, str):
+                hours, minutes, seconds = map(int, time_step.split(":"))
+                time_step = timedelta(hours=hours, minutes=minutes, seconds=seconds)
+            if isinstance(time_step, timedelta):
+                values["time_step"] = timedelta(
+                    seconds=time_step.total_seconds() * time_scale_factor
+                )
+
         if "time_status_step" in values and not values.get(
             "is_scenario_time_status_step", True
         ):
@@ -378,7 +433,7 @@ class ManagerConfig(BaseModel):
         return values
 
 
-class ManagedApplicationConfig(BaseModel):
+class ManagedApplicationConfig(LoggingConfig):
     time_scale_factor: float = Field(1.0, description="Time scale factor.")
     time_step: timedelta = Field(
         timedelta(seconds=1), description="Time step for swe_change."
@@ -440,7 +495,7 @@ class LoggerApplicationConfig(BaseModel):
         timedelta(seconds=10), description="Time status step."
     )
     time_status_init: Optional[datetime] = Field(
-        datetime(2019, 3, 1, 0, 0, 0), description="Time status init."
+        datetime.now(), description="Time status init."
     )
     shut_down_when_terminated: Optional[bool] = Field(
         False, description="Shut down when terminated."
@@ -471,7 +526,9 @@ class ApplicationConfig(BaseModel):
 
 
 class ExecConfig(BaseModel):
-    general: GeneralConfig
+    general: Optional[GeneralConfig] = Field(
+        None, description="General configuration for the execution."
+    )
     manager: Optional[ManagerConfig] = Field(None, description="Manager configuration.")
     managed_applications: Optional[Dict[str, ManagedApplicationConfig]] = Field(
         default_factory=lambda: {"default": ManagedApplicationConfig()},
@@ -509,11 +566,11 @@ class ChannelConfig(BaseModel):
 
 
 class Credentials(BaseModel):
-    username: str = Field(..., description="Username for authentication.")
-    password: str = Field(..., description="Password for authentication.")
-    client_id: Optional[str] = Field("", description="Client ID for authentication.")
+    username: Optional[str] = Field("admin", description="Username for authentication.")
+    password: Optional[str] = Field("admin", description="Password for authentication.")
+    client_id: Optional[str] = Field(None, description="Client ID for authentication.")
     client_secret_key: Optional[str] = Field(
-        "", description="Client secret key for authentication."
+        None, description="Client secret key for authentication."
     )
 
 
@@ -529,6 +586,9 @@ class SimulationConfig(BaseModel):
 
 
 class RuntimeConfig(BaseModel):
+    wallclock_offset_properties: WallclockOffsetProperties = Field(
+        ..., description="Properties for wallclock offset."
+    )
     credentials: Credentials = Field(..., description="Credentials for authentication.")
     server_configuration: Config = (
         Field(..., description="Simulation configuration."),
@@ -539,3 +599,6 @@ class RuntimeConfig(BaseModel):
     application_configuration: Optional[Dict] = Field(
         None, description="Application-specific, user-provided configuration."
     )
+    yaml_file: Optional[str] = Field(
+        None, description="Path to the YAML file containing the configuration."
+    )

{nost_tools-2.2.0 → nost_tools-2.4.0}/nost_tools/simulator.py

@@ -516,9 +516,7 @@ class Simulator(Observable):
         Args:
             wallclock_offset(:obj:`timedelta`): difference between system clock and trusted wallclock source
         """
-        if self._mode == Mode.EXECUTING:
-            raise RuntimeError("Cannot set wallclock offset: simulator is executing")
-        elif self._mode == Mode.TERMINATING:
+        if self._mode == Mode.TERMINATING:
             raise RuntimeError("Cannot set wallclock offset: simulator is terminating")
         self._wallclock_offset = wallclock_offset
 

{nost_tools-2.2.0 → nost_tools-2.4.0}/nost_tools.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: nost_tools
-Version: 2.2.0
+Version: 2.4.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