speed up entry in SYNCHRONIZATION state

Author: julien6387

CHANGES.md

@@ -3,9 +3,13 @@
 ## 0.19.1 (2026-xx-xx)
 
 * Fix [Issue #134](https://github.com/julien6387/supvisors/issues/134).
-  Reload the Supvisors process configuration after Supervisor is updated.
+  Reload the **Supvisors** process configuration after Supervisor is updated.
 
-* Strengthen robustness against `psutil` issues realted to certain operating systems.
+* Set the lower limit of the option `synchro_timeout` to 0 instead of 15 (Default value remains unchanged).
+
+* Speed-up the entry in SYNCHRONIZATION state.
+
+* Strengthen robustness against `psutil` issues related to certain operating systems.
 
 * Review HTTP error codes returned by the REST API in `supvisorsflask`.
 

docs/configuration.rst

@@ -278,7 +278,7 @@ behavior may happen. The present section details where it is applicable.
 ``synchro_timeout``
 
     The time in seconds that |Supvisors| waits for all expected |Supvisors| instances to publish their TICK.
-    Value in [``15`` ; ``1200``]. |br|
+    Value in [``0`` ; ``1200``]. |br|
     This option is taken into account only if ``TIMEOUT`` is selected in the ``synchro_options``. |br|
     The use of this option is more detailed in :ref:`synchronizing`.
 

supvisors/context.py

@@ -489,6 +489,7 @@ def on_authorization(self, status: SupvisorsInstanceStatus, event: Payload) -> N
                              f' from Supvisors={status.usage_identifier}')
             # go back to STOPPED to give it a chance at next TICK
             status.state = SupvisorsInstanceStates.STOPPED
+            self.export_status(status)
         elif authorization == AuthorizationTypes.NOT_AUTHORIZED:
             self.logger.warn('Context.on_authorization: the local Supvisors instance is isolated'
                              f' by Supvisors={status.usage_identifier}')
@@ -501,6 +502,12 @@ def on_authorization(self, status: SupvisorsInstanceStatus, event: Payload) -> N
             self.logger.info(f'Context.on_authorization: the local Supvisors instance is authorized to work with'
                              f' Supvisors={status.usage_identifier}')
             status.state = SupvisorsInstanceStates.CHECKED
+            self.export_status(status)
+            # if status is the local instance, go straight to RUNNING to speed up the entry in SYNCHRONIZATION state
+            if status.identifier == self.local_identifier:
+                status.state = SupvisorsInstanceStates.RUNNING
+                self.export_status(status)
+        return None
 
     def on_local_tick_event(self, event: Payload) -> None:
         """ Method called upon reception of a tick event from the local Supvisors instance.
@@ -710,3 +717,4 @@ def on_process_state_event(self, status: SupvisorsInstanceStatus, event: Payload
                         self.external_publisher.send_process_status(process.serial())
                         self.external_publisher.send_application_status(application.serial())
                     return process
+        return None

supvisors/internal_com/mapper.py

@@ -480,14 +480,14 @@ def configure(self, supvisors_list: NameList, stereotypes: NameSet, core_list: N
             # get Supervisor identification from each element
             for item in supvisors_list:
                 self.add_instance(item)
-            # keep information about the initial Supvisors identifiers added to the configuration
-            self.initial_identifiers = list(self._instances.keys())
         else:
             # if supvisors_list is empty, use self identification from supervisor internal data
             supervisor = self.supvisors.supervisor_data
             item = f'<{supervisor.identifier}>{socket.gethostname()}:{supervisor.server_port}'
             self.logger.info(f'SupvisorsMapper.configure: define local Supvisors as {item}')
             self.add_instance(item)
+        # keep information about the initial Supvisors identifiers added to the configuration
+        self.initial_identifiers = list(self._instances.keys())
         self.logger.info(f'SupvisorsMapper.configure: identifiers={self._nick_identifiers}')
         self.logger.info(f'SupvisorsMapper.configure: nodes={self.nodes}')
         # get local Supervisor identification from list

supvisors/listener.py

@@ -162,6 +162,8 @@ def on_running(self, _):
             self.supvisors.external_publisher = create_external_publisher(self.supvisors)
             # Trigger the FSM
             self.fsm.next()
+            # Force first Tick to speed up the entry in SYNCHRONIZATION state
+            self.on_tick(events.TickEvent(time.time(), None))
         except Exception:
             # Supvisors shall never endanger the Supervisor thread
             self.logger.critical(f'SupervisorListener.on_running: {traceback.format_exc()}')

supvisors/options.py

@@ -31,6 +31,11 @@
                      Ipv4Address, NameList, Payload, StatisticsTypes,
                      GroupConfigInfo, ProgramConfig, SupvisorsProcessConfig)
 
+# Constants
+SYNCHRO_TIMEOUT_MIN = 0
+SYNCHRO_LIST_TIMEOUT_MIN = 15
+SYNCHRO_TIMEOUT_MAX = 1200
+
 
 # Options of main section
 def get_logger_configuration(**config) -> Payload:
@@ -65,7 +70,7 @@ class SupvisorsOptions:
         - multicast_interface: UDP Multicast Group interface ;
         - multicast_ttl: UDP Multicast time-to-live ;
         - rules_files: list of absolute or relative paths to the XML rules files ;
-        - css_files: list of css files used to override the Supvisors default CSS ;
+        - css_files: list of CSS files used to override the Supvisors default CSS ;
         - event_link: type of the event link used to publish all Supvisors events ;
         - event_port: port number used to publish all Supvisors events ;
         - auto_fence: when True, Supvisors won't try to reconnect to a Supvisors instance that has been inactive ;
@@ -88,9 +93,6 @@ class SupvisorsOptions:
         - tailf_limit: the number of bytes used to display the log tail of the file in the Web UI (tail -f mode).
     """
 
-    SYNCHRO_TIMEOUT_MIN = 15
-    SYNCHRO_TIMEOUT_MAX = 1200
-
     # default SynchronizationOptions list that is equivalent to previous Supvisors versions
     SYNCHRO_DEFAULT_OPTIONS = [SynchronizationOptions.STRICT,
                                SynchronizationOptions.TIMEOUT,
@@ -132,7 +134,7 @@ def __init__(self, supervisord, logger: Logger, **config):
         self.auto_fence = self._get_value(config, 'auto_fence', False, boolean)
         self.synchro_options = self._get_value(config, 'synchro_options', self.SYNCHRO_DEFAULT_OPTIONS,
                                                self.to_synchro_options)
-        self.synchro_timeout = self._get_value(config, 'synchro_timeout', self.SYNCHRO_TIMEOUT_MIN, self.to_timeout)
+        self.synchro_timeout = self._get_value(config, 'synchro_timeout', SYNCHRO_LIST_TIMEOUT_MIN, self.to_timeout)
         self.inactivity_ticks = self._get_value(config, 'inactivity_ticks', self.INACTIVITY_TICKS_MIN, self.to_ticks)
         # get the minimum list of identifiers to end the synchronization phase
         self.core_identifiers = self._get_value(config, 'core_identifiers', set(),
@@ -212,10 +214,10 @@ def check_options(self):
                              ' with no core_identifiers')
             self.synchro_options.remove(SynchronizationOptions.CORE)
         # when using LIST in synchro_options, supvisors_list cannot be empty
-        if not self.supvisors_list and SynchronizationOptions.STRICT in self.synchro_options:
-            self.logger.warn('SupvisorsOptions:check_options: cancellation of synchro_options STRICT'
-                             ' with no supvisors_list')
-            self.synchro_options.remove(SynchronizationOptions.STRICT)
+        #if not self.supvisors_list and SynchronizationOptions.STRICT in self.synchro_options:
+        #    self.logger.warn('SupvisorsOptions:check_options: cancellation of synchro_options STRICT'
+        #                     ' with no supvisors_list')
+        #    self.synchro_options.remove(SynchronizationOptions.STRICT)
         # synchro_options must not be empty
         if not self.synchro_options:
             raise ValueError('synchro_options shall not be empty')
@@ -226,6 +228,13 @@ def check_options(self):
             self.logger.warn('SupvisorsOptions:check_options: force supvisors_failure_strategy=CONTINUE'
                              ' because it is incompatible with synchro_options=TIMEOUT')
             self.supvisors_failure_strategy = SupvisorsFailureStrategies.CONTINUE
+        # use a minimum timeout of 15 seconds when LIST is in synchro_options to give a chance to discovered instances
+        #if (SynchronizationOptions.LIST in self.synchro_options
+        #    and SynchronizationOptions.TIMEOUT in self.synchro_options
+        #    and self.synchro_timeout < SYNCHRO_LIST_TIMEOUT_MIN):
+        #    self.logger.warn(f'SupvisorsOptions:check_options: force synchro_timeout={SYNCHRO_LIST_TIMEOUT_MIN}'
+        #                     ' to give a chance with synchro_options=TIMEOUT')
+        #    self.synchro_timeout = SYNCHRO_LIST_TIMEOUT_MIN
 
     def check_dirpath(self, file_path: str) -> str:
         """ Check if the path provided exists and create the folder tree if necessary.
@@ -418,20 +427,20 @@ def to_synchro_options(value: str) -> List[SynchronizationOptions]:
 
     @staticmethod
     def to_timeout(value: str) -> int:
-        """ Convert a string into a timeout value, in [15;1200].
+        """ Convert a string into a timeout value, in [0;1200].
 
-        :param value: the timeout as a string
-        :return: the timeout as an integer
+        :param value: the timeout as a string.
+        :return: the timeout as an integer.
         """
         try:
             timeout = integer(value)
-            if SupvisorsOptions.SYNCHRO_TIMEOUT_MIN > timeout or timeout > SupvisorsOptions.SYNCHRO_TIMEOUT_MAX:
+            if SYNCHRO_TIMEOUT_MIN > timeout or timeout > SYNCHRO_TIMEOUT_MAX:
                 raise ValueError
             return timeout
         except ValueError:
             raise ValueError(f'invalid value for synchro_timeout: "{value}".'
-                             f' integer expected in [{SupvisorsOptions.SYNCHRO_TIMEOUT_MIN};'
-                             f'{SupvisorsOptions.SYNCHRO_TIMEOUT_MAX}] (seconds)')
+                             f' integer expected in [{SYNCHRO_TIMEOUT_MIN};'
+                             f'{SYNCHRO_TIMEOUT_MAX}] (seconds)')
 
     @staticmethod
     def to_ticks(value: str) -> int:

supvisors/statemachine.py

@@ -21,14 +21,16 @@
 
 from .context import Context
 from .instancestatus import SupvisorsInstanceStatus
-from .options import SupvisorsOptions
 from .process import ProcessStatus
 from .statemodes import SupvisorsStateModes
 from .strategy import conciliate_conflicts
 from .ttypes import (SupvisorsInstanceStates, SupvisorsStates, SynchronizationOptions,
                      RunningFailureStrategies, SupvisorsFailureStrategies,
                      NameList, Payload, PayloadList)
 
+# Constants
+OFF_UPTIME = 10  # seconds
+
 
 # FSM base states
 class _SupvisorsBaseState:
@@ -178,7 +180,7 @@ def _check_consistence(self) -> Optional[SupvisorsStates]:
         # get duration from start date
         uptime: float = self.context.uptime
         # log current status
-        if uptime >= SupvisorsOptions.SYNCHRO_TIMEOUT_MIN:
+        if uptime >= OFF_UPTIME:
             self.logger.critical(f'OffState.next: local Supvisors={self.local_identifier} still'
                                  f' not RUNNING after {int(uptime)} seconds')
         else:
@@ -346,7 +348,7 @@ def _check_end_sync_timeout(self, uptime: float) -> Optional[bool]:
             return False
         return None
 
-    def _check_end_sync_core(self, uptime: float) -> Optional[bool]:
+    def _check_end_sync_core(self) -> Optional[bool]:
         """ End of sync phase if the CORE option is set, and all core Supvisors instances are RUNNING.
 
         NOTE: If the condition is reached, the ELECTION state will eventually be reached with non-core Supvisors
@@ -360,13 +362,7 @@ def _check_end_sync_core(self, uptime: float) -> Optional[bool]:
         failure = self._check_core_failure()
         if failure is False:
             # all core Supvisors instances are running
-            # in case of late start, a security limit of SYNCHRO_TIMEOUT_MIN is kept to give a chance
-            # to other Supvisors instances and limit the number of re-distributions
-            if uptime >= SupvisorsOptions.SYNCHRO_TIMEOUT_MIN:
-                return True
-            self.logger.info('SynchronizationState.check_end_sync_core: all core Supvisors instances are RUNNING,'
-                             f' waiting ({uptime} < {SupvisorsOptions.SYNCHRO_TIMEOUT_MIN})')
-            return False
+            return True
         return False if failure else None
 
     def _check_end_sync_user(self) -> Optional[bool]:
@@ -404,7 +400,7 @@ def next(self) -> Optional[SupvisorsStates]:
         strict_sync = self._check_end_sync_strict()
         list_sync = self._check_end_sync_list()
         timeout_sync = self._check_end_sync_timeout(uptime)
-        core_sync = self._check_end_sync_core(uptime)
+        core_sync = self._check_end_sync_core()
         user_sync = self._check_end_sync_user()
         self.logger.debug(f'SynchronizationState.next: strict_sync={strict_sync} list_sync={list_sync}'
                           f' timeout_sync={timeout_sync} core_sync={core_sync} user_sync={user_sync}')
@@ -1028,6 +1024,8 @@ def on_authorization(self, status: SupvisorsInstanceStatus, event: Payload) -> N
         self.logger.debug(f'FiniteStateMachine.on_authorization: identifier={status.usage_identifier}'
                           f' event={event}')
         self.context.on_authorization(status, event)
+        # evaluate next immediately to speed up the start sequence
+        self.next()
 
     def on_process_state_event(self, status: SupvisorsInstanceStatus, event: Payload) -> None:
         """ This event is used to refresh the process data related to the event sent from the Supvisors instance.

supvisors/test/etc/supervisord.conf

@@ -26,13 +26,13 @@ files = common/*/*.ini
 supervisor.rpcinterface_factory = supvisors.plugin:make_supvisors_rpcinterface
 software_name = Supvisors Tests
 software_icon = ../ui/img/icon.png
-supvisors_list = <supv-01>17.0.1.11,supv02,<supv-03>192.168.1.70:30000
+supvisors_list = <supv-01>17.0.1.11,supv02,<supv-03>192.168.1.15:30000
 rules_files = etc/my_movies*.xml
 css_files = ui/test.css
 auto_fence = false
 event_link = ZMQ
 event_port = 60002
-synchro_options = LIST,CORE,TIMEOUT,USER
+synchro_options = STRICT,TIMEOUT,CORE
 synchro_timeout = 30
 inactivity_ticks = 3
 core_identifiers = supv-01,supv-03

supvisors/test/etc/supervisord_alt.conf

@@ -20,11 +20,11 @@ files = common/*/*.ini
 
 [rpcinterface:supvisors]
 supervisor.rpcinterface_factory = supvisors.plugin:make_supvisors_rpcinterface
-supvisors_list = <supv-01>17.0.1.11:60000,supv02:60000,<supv-03>192.168.1.70
+supvisors_list = <supv-01>17.0.1.11:60000,supv02:60000,<supv-03>192.168.1.15
 stereotypes = third
 rules_files = etc/my_movies*.xml
 auto_fence = false
-synchro_options = LIST,CORE,TIMEOUT,USER
+synchro_options = STRICT,TIMEOUT,CORE
 synchro_timeout = 30
 inactivity_ticks = 3
 core_identifiers = supv-01,supv-03

supvisors/test/etc/supervisord_alt_mc.conf

@@ -23,8 +23,8 @@ multicast_group = 239.0.0.1:60001
 multicast_ttl = 1
 rules_files = etc/my_movies*.xml
 auto_fence = false
-synchro_options = LIST,CORE,TIMEOUT,USER
-synchro_timeout = 20
+synchro_options = LIST,TIMEOUT,USER
+synchro_timeout = 30
 inactivity_ticks = 3
 starting_strategy = CONFIG
 conciliation_strategy = USER