Home Information - Your home, your data, organized.
Python
from datetime import datetime
import logging
from threading import Lock
from typing import List
from django.db.models.signals import post_save, post_delete
from django.dispatch import receiver
import hi.apps.common.datetimeproxy as datetimeproxy
from hi.apps.common.delayed_signal_processor import DelayedSignalProcessor
from hi.apps.common.singleton import Singleton
from .models import Subsystem, SubsystemAttribute
from .setting_enums import SettingEnum
logger = logging.getLogger(__name__)
class SettingsManager( Singleton ):
def __init_singleton__( self ):
self._server_start_datetime = datetimeproxy.now()
self._subsystem_list = list()
self._attribute_value_map = dict()
self._change_listeners = list()
self._was_initialized = False
self._subsystems_lock = Lock()
self._attributes_lock = Lock()
return
def ensure_initialized(self):
with self._subsystems_lock:
if self._was_initialized:
return
self._subsystem_list = self._load_settings()
self.reload()
self._was_initialized = True
return
def reload(self):
# Build the new map locally and atomically swap. Readers
# (``get_setting_value``) do not hold ``_attributes_lock``, so
# mutating the live map in place would briefly expose an empty
# or partially-populated view to any concurrent reader -- which
# caused spurious ``None`` returns during settings saves.
# CPython GIL dependency: lock-free reads work because the
# name rebind ``self._attribute_value_map = ...`` is a single
# ``STORE_ATTR`` bytecode, atomic against concurrent readers.
# Do NOT convert ``_attribute_value_map`` to a property or
# descriptor; that would break the atomicity guarantee.
with self._attributes_lock:
self._subsystem_list = sorted(self._subsystem_list, key=lambda s: s.name)
new_attribute_value_map = dict()
for subsystem in self._subsystem_list:
try:
subsystem.refresh_from_db()
for subsystem_attribute in subsystem.attributes.all():
attr_type = subsystem_attribute.setting_key
new_attribute_value_map[attr_type] = subsystem_attribute.value
continue
except Subsystem.DoesNotExist:
logger.error(f'Subsystem {subsystem} no longer exists in database during reload. '
'This may indicate a configuration issue or test teardown problem.')
continue
self._attribute_value_map = new_attribute_value_map
self._notify_change_listeners()
return
def register_change_listener( self, callback ):
logger.debug( f'Adding SYSTEM setting change listener from {callback.__module__}' )
self._change_listeners.append( callback )
return
def _notify_change_listeners(self):
for callback in self._change_listeners:
try:
callback()
except Exception as e:
logger.exception( 'Problem calling setting change callback.', e )
continue
return
def get_server_start_datetime( self ) -> datetime:
return self._server_start_datetime
def get_subsystem( self, subsystem_id : int ) -> List[ Subsystem ]:
for subsystem in self._subsystem_list:
if subsystem.id == subsystem_id:
return subsystem
continue
raise Subsystem.DoesNotExist()
def get_subsystems(self) -> List[ Subsystem ]:
return self._subsystem_list
def get_setting_value( self, setting_enum : SettingEnum ):
return self._attribute_value_map.get( setting_enum.key )
def set_setting_value( self, setting_enum : SettingEnum, value : str ):
self._attributes_lock.acquire()
try:
db_attribute = SubsystemAttribute.objects.get(
setting_key = setting_enum.key,
)
db_attribute.value = value
db_attribute.save()
self._attribute_value_map[setting_enum.key] = value # Just to avoid complete reload of settings
except SubsystemAttribute.DoesNotExist:
raise KeyError( f'No setting "{setting_enum.name}" found.' )
finally:
self._attributes_lock.release()
return
def _load_settings( self ):
return list( Subsystem.objects.prefetch_related('attributes').all() )
def _settings_manager_reload_callback():
"""Callback function for delayed settings manager reload."""
settings_manager = SettingsManager()
settings_manager.ensure_initialized()
settings_manager.reload()
# Create the delayed signal processor for settings manager
_settings_processor = DelayedSignalProcessor(
name="settings_manager",
callback_func=_settings_manager_reload_callback,
delay_seconds=0.1
)
@receiver( post_save, sender = Subsystem )
@receiver( post_save, sender = SubsystemAttribute )
@receiver( post_delete, sender = Subsystem )
@receiver( post_delete, sender = SubsystemAttribute )
def settings_manager_model_changed( sender, instance, **kwargs ):
"""
Queue the SettingsManager.reload() call to execute after the transaction
is committed. This prevents reloading multiple times if multiple
models saved as part of a transaction (which is the normal case for
SettingDefinition and its related models.)
"""
_settings_processor.schedule_processing()