Skip to content

Home Information - Your home, your data, organized.

Python

Refactored integrations from registration to discovery model.

Anthony Cassandraa677e329fffe
diff --git a/src/gunicorn.conf.py b/src/gunicorn.conf.py
index ea37ca51..6cf67f59 100644
--- a/src/gunicorn.conf.py
+++ b/src/gunicorn.conf.py
@@ -11,14 +11,18 @@ import signal
def post_worker_init( worker ):
- from hi.apps.monitor.monitor_manager import MonitorManager
+ from hi.apps.monitor.monitor_manager import AppMonitorManager
+ from hi.integrations.core.integration_manager import IntegrationManager
_ = asyncio.get_event_loop() # Ensure event loop exists, or creates it
- worker.log.info("Starting monitors in worker...")
- asyncio.run( MonitorManager().initialize() )
+ worker.log.info("Starting app monitor manager ...")
+ asyncio.run( AppMonitorManager().initialize() )
+ worker.log.info("Starting integration manager ...")
+ asyncio.run( IntegrationManager().initialize() )
def handle_signal(signal_number, frame):
worker.log.info(f"Worker received signal {signal_number}. Cleaning up monitors...")
- MonitorManager().shutdown()
+ AppMonitorManager().shutdown()
+ IntegrationManager().shutdown()
import sys
sys.exit(0)
@@ -28,7 +32,9 @@ def post_worker_init( worker ):
def on_exit(server):
- from hi.apps.monitor.monitor_manager import MonitorManager
+ from hi.apps.monitor.monitor_manager import AppMonitorManager
+ from hi.integrations.core.integration_manager import IntegrationManager
server.log.info("Stopping all monitors on Gunicorn exit...")
- MonitorManager().shutdown()
+ AppMonitorManager().shutdown()
+ IntegrationManager().shutdown()
return
diff --git a/src/hi/apps/control/controller_manager.py b/src/hi/apps/control/controller_manager.py
index 665170fc..0f4d7f97 100644
--- a/src/hi/apps/control/controller_manager.py
+++ b/src/hi/apps/control/controller_manager.py
@@ -3,7 +3,7 @@ import logging
from hi.apps.common.singleton import Singleton
-from hi.integrations.core.integration_factory import IntegrationFactory
+from hi.integrations.core.integration_manager import IntegrationManager
from hi.integrations.core.transient_models import IntegrationControlResult
from .models import Controller
@@ -21,7 +21,7 @@ class ControllerManager( Singleton ):
control_value : str ) -> IntegrationControlResult:
logger.debug( f'Controller action: {controller} = {control_value}' )
- integration_gateway = IntegrationFactory().get_integration_gateway(
+ integration_gateway = IntegrationManager().get_integration_gateway(
integration_id = controller.integration_id,
)
integration_controller = integration_gateway.get_controller()
diff --git a/src/hi/apps/monitor/apps.py b/src/hi/apps/monitor/apps.py
index dcc9b456..caaca878 100644
--- a/src/hi/apps/monitor/apps.py
+++ b/src/hi/apps/monitor/apps.py
@@ -4,7 +4,6 @@ import signal
import threading
from django.apps import AppConfig
-from hi.apps.monitor.monitor_manager import MonitorManager
class MonitorConfig(AppConfig):
@@ -12,6 +11,7 @@ class MonitorConfig(AppConfig):
name = "hi.apps.monitor"
def ready(self):
+ from hi.apps.monitor.monitor_manager import AppMonitorManager
if os.getenv( "RUN_MAIN", None ) != "true":
# Avoid double initialization when using the reloader in development
return
@@ -19,7 +19,7 @@ class MonitorConfig(AppConfig):
if settings.DEBUG:
# This app.py initialization runs in synchronous mode, so we
# need to defer the background monitor tasks creation by
- # creating a sepaarte thread.
+ # creating a separate thread.
#
# This is for development only as the gunicorn.conf.py file
# handles this initialization when execution with gunicorn.
@@ -28,7 +28,7 @@ class MonitorConfig(AppConfig):
thread.start()
def handle_signal(signal_number, frame):
- MonitorManager().shutdown()
+ AppMonitorManager().shutdown()
import sys
sys.exit(0)
@@ -38,9 +38,10 @@ class MonitorConfig(AppConfig):
return
def _start_monitors(self):
+ from hi.apps.monitor.monitor_manager import AppMonitorManager
loop = asyncio.new_event_loop()
asyncio.set_event_loop( loop )
- monitor_manager = MonitorManager()
+ monitor_manager = AppMonitorManager()
try:
loop.create_task( monitor_manager.initialize() )
loop.run_forever()
diff --git a/src/hi/apps/monitor/monitor_manager.py b/src/hi/apps/monitor/monitor_manager.py
index 8c00e6db..299b1860 100644
--- a/src/hi/apps/monitor/monitor_manager.py
+++ b/src/hi/apps/monitor/monitor_manager.py
@@ -1,5 +1,6 @@
import asyncio
import logging
+from typing import List, Type
from django.apps import apps
@@ -11,44 +12,12 @@ from .periodic_monitor import PeriodicMonitor
logger = logging.getLogger(__name__)
-class MonitorManager( Singleton ):
+class AppMonitorManager( Singleton ):
def __init_singleton__( self ):
self._monitor_map = {} # Known monitors
self._event_loop = None # Added dynamically and indicates if thread/event loop initialized
return
-
- def register( self, monitor : PeriodicMonitor ) -> None:
- if monitor.id in self._monitor_map:
- logger.debug(f"Monitor: {monitor.id} already registered")
- return
-
- logger.debug(f"Registering monitor: {monitor.id}")
- self._monitor_map[monitor.id] = monitor
-
- if not self._event_loop:
- logger.warning("No running event loop. Deferring monitor start")
- return
-
- if self._event_loop.is_running():
- logger.debug(f"Scheduling monitor start: {monitor.id}")
- asyncio.run_coroutine_threadsafe( monitor.start(), self._event_loop )
- else:
- logger.error("Event loop is not running")
-
- return
-
- def deregister( self, monitor_id : str ) -> None:
- monitor = self._monitor_map.get( monitor_id )
- if not monitor:
- logger.debug(f"Monitor: {monitor.id} not registered")
- return
-
- logger.debug(f"Deregistering monitor: {monitor.id}")
- if monitor.is_running():
- monitor.stop()
- del self._monitor_map[monitor.id]
- return
async def initialize(self) -> None:
if self._event_loop:
@@ -84,17 +53,16 @@ class MonitorManager( Singleton ):
return
- def _discover_periodic_monitors(self):
+ def _discover_periodic_monitors(self) -> List[ Type[ PeriodicMonitor ]]:
periodic_monitor_class_list = list()
for app_config in apps.get_app_configs():
- if not app_config.name.startswith( 'hi' ):
+ if not app_config.name.startswith( 'hi.apps' ):
continue
module_name = f'{app_config.name}.monitors'
try:
app_module = import_module_safe( module_name = module_name )
if not app_module:
- logger.debug( f'No monitor module for {app_config.name}' )
continue
logger.debug( f'Found monitor module for {app_config.name}' )
@@ -109,7 +77,7 @@ class MonitorManager( Singleton ):
continue
except Exception as e:
- logger.exception( f'Problem loading settings for {module_name}.', e )
+ logger.exception( f'Problem loading monitor for {module_name}.', e )
continue
return periodic_monitor_class_list
diff --git a/src/hi/apps/security/security_manager.py b/src/hi/apps/security/security_manager.py
index 8c9fc5ab..06cf9a14 100644
--- a/src/hi/apps/security/security_manager.py
+++ b/src/hi/apps/security/security_manager.py
@@ -1,3 +1,4 @@
+from asgiref.sync import sync_to_async
import logging
from threading import Timer, Lock
from typing import Dict
@@ -39,17 +40,33 @@ class SecurityManager(Singleton):
self._security_status_lock = Lock()
self._redis_client = get_redis_client()
+ self._was_initialized = False
return
+ def ensure_initialized(self):
+ if self._was_initialized:
+ return
+ try:
+ self._initialize_security_state()
+ except Exception as e:
+ logger.exception( 'Problem trying to initialize security state', e )
+ self._security_state = SecurityState.DISABLED
+ self._was_initialized = True
+ return
+
+ async def ensure_initialized_async(self):
+ if self._was_initialized:
+ return
+ try:
+ await sync_to_async( self._initialize_security_state )()
+ except Exception as e:
+ logger.exception( 'Problem trying to initialize security state', e )
+ self._security_state = SecurityState.DISABLED
+ self._was_initialized = True
+ return
+
@property
def security_state(self) -> SecurityState:
- if not self._security_state:
- try:
- self._initialize_security_state()
- except Exception as e:
- logger.exception( 'Problem trying to initialize security state', e )
- self._security_state = SecurityState.DISABLED
-
return self._security_state
@property
diff --git a/src/hi/apps/security/security_mixins.py b/src/hi/apps/security/security_mixins.py
index 703ef160..83928305 100644
--- a/src/hi/apps/security/security_mixins.py
+++ b/src/hi/apps/security/security_mixins.py
@@ -8,9 +8,11 @@ class SecurityMixin:
def security_manager(self):
if not hasattr( self, '_security_manager' ):
self._security_manager = SecurityManager()
+ self._security_manager.ensure_initialized()
return self._security_manager
async def security_manager_async(self):
if not hasattr( self, '_security_manager' ):
self._security_manager = await sync_to_async( SecurityManager )()
+ await self._security_manager.ensure_initialized_async()
return self._security_manager
diff --git a/src/hi/apps/security/security_monitor.py b/src/hi/apps/security/security_monitor.py
new file mode 100644
index 00000000..8fa90911
--- /dev/null
+++ b/src/hi/apps/security/security_monitor.py
@@ -0,0 +1,74 @@
+import logging
+
+import hi.apps.common.datetimeproxy as datetimeproxy
+from hi.apps.config.settings_manager import SettingsManager
+from hi.apps.console.settings import ConsoleSetting
+from hi.apps.monitor.periodic_monitor import PeriodicMonitor
+
+from .enums import SecurityState
+from .security_manager import SecurityManager
+from .settings import SecuritySetting
+
+logger = logging.getLogger(__name__)
+
+
+class SecurityMonitor( PeriodicMonitor ):
+
+ SECURITY_POLLING_INTERVAL_SECS = 5 * 60
+
+ def __init__( self ):
+ super().__init__(
+ id = 'security-monitor',
+ interval_secs = self.SECURITY_POLLING_INTERVAL_SECS,
+ )
+ self._security_manager = SecurityManager()
+ self._last_security_state_check_datetime = datetimeproxy.now()
+ return
+
+ async def do_work(self):
+ await self._check_security_state()
+ return
+
+ async def _check_security_state( self ):
+ logger.debug( 'Checking security state.' )
+ settings_manager = SettingsManager()
+ current_datetime = datetimeproxy.now()
+ tz_name = settings_manager.get_setting_value(
+ ConsoleSetting.TIMEZONE,
+ )
+ try:
+ # Some states do not allow automated changes
+ if not self._security_manager.security_state.auto_change_allowed:
+ return
+
+ day_start_time_of_day = settings_manager.get_setting_value(
+ SecuritySetting.SECURITY_DAY_START,
+ )
+ if datetimeproxy.is_time_of_day_in_interval(
+ time_of_day_str = day_start_time_of_day,
+ tz_name = tz_name,
+ start_datetime = self._last_security_state_check_datetime,
+ end_datetime = current_datetime ):
+ logger.debug( 'Security state check: Setting as DAY.' )
+ self._security_manager.update_security_state_auto(
+ new_security_state = SecurityState.DAY,
+ )
+ return
+
+ night_start_time_of_day = settings_manager.get_setting_value(
+ SecuritySetting.SECURITY_NIGHT_START,
+ )
+ if datetimeproxy.is_time_of_day_in_interval(
+ time_of_day_str = night_start_time_of_day,
+ tz_name = tz_name,
+ start_datetime = self._last_security_state_check_datetime,
+ end_datetime = current_datetime ):
+ logger.debug( 'Security state check: Setting as NIGHT.' )
+ self._security_manager.update_security_state_auto(
+ new_security_state = SecurityState.NIGHT,
+ )
+ return
+
+ finally:
+ self._last_security_state_check_datetime = current_datetime
+ return
diff --git a/src/hi/integrations/core/apps.py b/src/hi/integrations/core/apps.py
index a7e2a5d8..38fc3e56 100644
--- a/src/hi/integrations/core/apps.py
+++ b/src/hi/integrations/core/apps.py
@@ -1,3 +1,8 @@
+import asyncio
+import os
+import signal
+import threading
+
from django.apps import AppConfig
@@ -5,3 +10,45 @@ class CoreConfig(AppConfig):
default_auto_field = "django.db.models.BigAutoField"
name = "hi.integrations.core"
+
+ def ready(self):
+ from hi.integrations.core.integration_manager import IntegrationManager
+ if os.getenv( "RUN_MAIN", None ) != "true":
+ # Avoid double initialization when using the reloader in development
+ return
+ from django.conf import settings
+ if settings.DEBUG:
+ # This app.py initialization runs in synchronous mode, so we
+ # need to defer the background integration manager tasks
+ # creation by creating a separate thread.
+ #
+ # This is for development only as the gunicorn.conf.py file
+ # handles this initialization when execution with gunicorn.
+ #
+ thread = threading.Thread( target = self._start_integrations, daemon = True )
+ thread.start()
+
+ def handle_signal(signal_number, frame):
+ IntegrationManager().shutdown()
+ import sys
+ sys.exit(0)
+
+ signal.signal(signal.SIGINT, handle_signal)
+ signal.signal(signal.SIGTERM, handle_signal)
+
+ return
+
+ def _start_integrations(self):
+ from hi.integrations.core.integration_manager import IntegrationManager
+ loop = asyncio.new_event_loop()
+ asyncio.set_event_loop( loop )
+ integration_manager = IntegrationManager()
+ try:
+ loop.create_task( integration_manager.initialize() )
+ loop.run_forever()
+ except Exception as e:
+ print(f"Error in event loop: {e}")
+
+ finally:
+ loop.close()
+ return
diff --git a/src/hi/integrations/core/integration_data.py b/src/hi/integrations/core/integration_data.py
new file mode 100644
index 00000000..846e0d0f
--- /dev/null
+++ b/src/hi/integrations/core/integration_data.py
@@ -0,0 +1,25 @@
+from dataclasses import dataclass
+
+from .integration_gateway import IntegrationGateway
+from .models import Integration
+from .transient_models import IntegrationMetaData
+
+
+@dataclass
+class IntegrationData:
+
+ integration_gateway : IntegrationGateway
+ integration : Integration
+
+ @property
+ def integration_id(self) -> str:
+ return self.integration_meta_data.integration_id
+
+ @property
+ def integration_metadata(self) -> IntegrationMetaData:
+ return self.integration_gateway.get_meta_data()
+
+ @property
+ def is_enabled(self):
+ return self.integration.is_enabled
+
diff --git a/src/hi/integrations/core/integration_factory.py b/src/hi/integrations/core/integration_factory.py
deleted file mode 100644
index 217fd8d3..00000000
--- a/src/hi/integrations/core/integration_factory.py
+++ /dev/null
@@ -1,69 +0,0 @@
-import logging
-from typing import Dict, List
-
-from hi.apps.common.singleton import Singleton
-from hi.apps.monitor.monitor_manager import MonitorManager
-from hi.apps.monitor.periodic_monitor import PeriodicMonitor
-
-from .integration_gateway import IntegrationGateway
-from .models import Integration
-from .transient_models import IntegrationData
-
-logger = logging.getLogger(__name__)
-
-
-class IntegrationFactory( Singleton ):
-
- def __init_singleton__( self ):
- self._integration_gateway_map : Dict[ str, IntegrationGateway ] = dict()
- return
-
- def get_default_integration_data( self ):
- integration_data_list = self.get_integration_data_list( enabled_only = True )
- if not integration_data_list:
- return None
- return integration_data_list[0]
-
- def get_integration_data_list( self, enabled_only = False ) -> List[ IntegrationData ]:
- integration_data_list = list()
- if enabled_only:
- integration_queryset = Integration.objects.filter( is_enabled = True )
- else:
- integration_queryset = Integration.objects.all()
- integration_map = { x.integration_id: x for x in integration_queryset }
-
- for integration_id, integration_gateway in self._integration_gateway_map.items():
- integration_metadata = integration_gateway.get_meta_data()
- integration = integration_map.get( integration_id )
- if not integration and enabled_only:
- continue
- elif not integration:
- integration = Integration(
- integration_id = integration_id,
- is_enabled = False,
- )
- integration_data = IntegrationData(
- integration_metadata = integration_metadata,
- integration = integration,
- )
- integration_data_list.append( integration_data )
- continue
-
- integration_data_list.sort( key = lambda data : data.integration_metadata.label )
- return integration_data_list
-
- def get_integration_gateway( self, integration_id : str ) -> IntegrationGateway:
- if integration_id in self._integration_gateway_map:
- return self._integration_gateway_map[integration_id]
- raise KeyError( f'Unknown integration id "{integration_id}".' )
-
- def register( self, integration_gateway : IntegrationGateway ):
- integration_metadata = integration_gateway.get_meta_data()
- integration_id = integration_metadata.integration_id
- if integration_id in self._integration_gateway_map:
- logger.debug( f'Ignoring repeat integration registration: {integration_metadata.label}' )
- return
- logger.debug( f'Registering integration: {integration_metadata.label}' )
- self._integration_gateway_map[integration_id] = integration_gateway
- return
-
diff --git a/src/hi/integrations/core/integration_gateway.py b/src/hi/integrations/core/integration_gateway.py
index 18344db4..25e8c528 100644
--- a/src/hi/integrations/core/integration_gateway.py
+++ b/src/hi/integrations/core/integration_gateway.py
@@ -14,7 +14,7 @@ class IntegrationGateway:
def get_meta_data(self) -> IntegrationMetaData:
raise NotImplementedError('Subclasses must override this method')
- def get_sensor_monitor(self) -> PeriodicMonitor:
+ def get_monitor(self) -> PeriodicMonitor:
raise NotImplementedError('Subclasses must override this method')
def get_controller(self) -> IntegrationController:
diff --git a/src/hi/integrations/core/integration_manager.py b/src/hi/integrations/core/integration_manager.py
new file mode 100644
index 00000000..76861613
--- /dev/null
+++ b/src/hi/integrations/core/integration_manager.py
@@ -0,0 +1,148 @@
+from asgiref.sync import sync_to_async
+import asyncio
+import logging
+from typing import Dict, List
+
+from django.apps import apps
+
+from hi.apps.common.singleton import Singleton
+from hi.apps.common.module_utils import import_module_safe
+
+from .integration_gateway import IntegrationGateway
+from .models import Integration
+from .integration_data import IntegrationData
+
+logger = logging.getLogger(__name__)
+
+
+class IntegrationManager( Singleton ):
+
+ def __init_singleton__( self ):
+ self._integration_data_map : Dict[ str, IntegrationData ] = dict()
+ self._monitor_map = {} # Known monitors
+ self._event_loop = None # Added dynamically and indicates if thread/event loop initialized
+ return
+
+ def get_integration_data_list( self, enabled_only = False ) -> List[ IntegrationData ]:
+ if enabled_only:
+ integration_data_list = [ x for x in self._integration_data_map.values() if x.is_enabled ]
+ else:
+ integration_data_list = list( self._integration_data_map.values() )
+
+ integration_data_list.sort( key = lambda data : data.integration_metadata.label )
+ return integration_data_list
+
+ def get_default_integration_data( self ) -> IntegrationData:
+ enabled_integration_data_list = [ x for x in self._integration_data_map.values()
+ if x.is_enabled ]
+ if not enabled_integration_data_list:
+ return None
+ enabled_integration_data_list.sort( key = lambda data : data.integration_metadata.label )
+ return enabled_integration_data_list[0]
+
+ def get_integration_gateway( self, integration_id : str ) -> IntegrationGateway:
+ if integration_id in self._integration_data_map:
+ return self._integration_data_map[integration_id].integration_gateway
+ raise KeyError( f'Unknown integration id "{integration_id}".' )
+
+ async def initialize(self) -> None:
+ await self._load_integration_data()
+ await self._start_monitors()
+ return
+
+ async def _load_integration_data(self) -> None:
+
+ logger.debug("Discovering defined integrations ...")
+ defined_integration_gateway_map = self._discover_defined_integrations()
+
+ logger.debug("Loading existing integrations ...")
+ existing_integration_map = await sync_to_async( self._load_existing_integrations )()
+
+ for integration_id, integration_gateway in defined_integration_gateway_map.items():
+ integration_metadata = integration_gateway.get_meta_data()
+ integration_id = integration_metadata.integration_id
+ if integration_id in existing_integration_map:
+ integration = existing_integration_map[integration_id]
+ else:
+ integration = Integration.objects.create(
+ integration_id = integration_id,
+ is_enabled = False,
+ )
+ integration_data = IntegrationData(
+ integration_gateway = integration_gateway,
+ integration = integration,
+ )
+ self._integration_data_map[integration_id] = integration_data
+ continue
+ return
+
+ async def _start_monitors(self) -> None:
+ if self._event_loop:
+ self.shutdown()
+
+ self._event_loop = asyncio.get_event_loop()
+
+ for integration_data in self._integration_data_map.values():
+ monitor = integration_data.integration_gateway.get_monitor()
+ if not monitor:
+ continue
+ self._monitor_map[monitor.id] = monitor
+ if not monitor.is_running:
+ logger.debug(f"Starting monitor: {monitor.id}")
+ asyncio.run_coroutine_threadsafe( monitor.start(), self._event_loop )
+ continue
+ return
+
+ def shutdown(self) -> None:
+ if not self._event_loop:
+ logger.info("Cannot stop all monitors. No event loop.")
+ return
+
+ logger.info("Stopping all registered monitors...")
+
+ for monitor in self._monitor_map.values():
+ monitor.stop()
+ continue
+
+ if self._event_loop.is_running():
+ self._event_loop.stop()
+
+ return
+
+ def _discover_defined_integrations(self) -> Dict[ str, IntegrationGateway ]:
+
+ integration_id_to_gateway = dict()
+ for app_config in apps.get_app_configs():
+ if not app_config.name.startswith( 'hi.integrations' ):
+ continue
+ module_name = f'{app_config.name}.integration'
+ try:
+ app_module = import_module_safe( module_name = module_name )
+ if not app_module:
+ logger.debug( f'No integration module for {app_config.name}' )
+ continue
+
+ logger.debug( f'Found integration module for {app_config.name}' )
+
+ for attr_name in dir(app_module):
+ attr = getattr( app_module, attr_name )
+ if ( isinstance( attr, type )
+ and issubclass( attr, IntegrationGateway )
+ and attr is not IntegrationGateway ):
+ logger.debug(f'Found integration gateway: {attr_name}')
+ integration_gateway = attr()
+ integration_metadata = integration_gateway.get_meta_data()
+ integration_id = integration_metadata.integration_id
+ integration_id_to_gateway[integration_id] = integration_gateway
+ continue
+
+ except Exception as e:
+ logger.exception( f'Problem getting integration gateway for {module_name}.', e )
+ continue
+
+ return integration_id_to_gateway
+
+ def _load_existing_integrations(self):
+ integration_queryset = Integration.objects.all()
+ return { x.integration_id: x for x in integration_queryset }
+
diff --git a/src/hi/integrations/core/transient_models.py b/src/hi/integrations/core/transient_models.py
index fd8f152d..79808981 100644
--- a/src/hi/integrations/core/transient_models.py
+++ b/src/hi/integrations/core/transient_models.py
@@ -2,7 +2,6 @@ from dataclasses import dataclass
from typing import List
from .enums import IntegrationAttributeType
-from .models import Integration
@dataclass
@@ -15,13 +14,6 @@ class IntegrationMetaData:
allow_entity_deletion : bool
-@dataclass
-class IntegrationData:
-
- integration_metadata : IntegrationMetaData
- integration : Integration
-
-
@dataclass
class IntegrationControlResult:
diff --git a/src/hi/integrations/core/views.py b/src/hi/integrations/core/views.py
index 61594d26..64063921 100644
--- a/src/hi/integrations/core/views.py
+++ b/src/hi/integrations/core/views.py
@@ -12,8 +12,8 @@ from hi.apps.sense.models import SensorHistory
from hi.exceptions import ForceRedirectException
from hi.hi_async_view import HiModalView
-from .integration_factory import IntegrationFactory
-from .transient_models import IntegrationData
+from .integration_manager import IntegrationManager
+from .integration_data import IntegrationData
logger = logging.getLogger(__name__)
@@ -27,8 +27,8 @@ class IntegrationPageView( ConfigPageView ):
We do this with these:
- - IntegrationMetaData - Integrations register this with the
- IntegrationFactory to define their exisatence and common
+ - IntegrationMetaData - Integrations discovered with the
+ IntegrationManager defines their existence and common
properties.
- IntegrationPageView (this view) - Each integration should subclass
@@ -44,7 +44,7 @@ class IntegrationPageView( ConfigPageView ):
"""
def dispatch( self, request, *args, **kwargs ):
- request.integration_data_list = IntegrationFactory().get_integration_data_list( enabled_only = True )
+ request.integration_data_list = IntegrationManager().get_integration_data_list( enabled_only = True )
request.current_integration_metadata = self.integration_metadata
return super().dispatch( request, *args, **kwargs )
@@ -66,7 +66,7 @@ class IntegrationsHomeView( ConfigPageView ):
def get_template_context( self, request, *args, **kwargs ):
- integration_data = IntegrationFactory().get_default_integration_data()
+ integration_data = IntegrationManager().get_default_integration_data()
if not integration_data:
return dict()
@@ -81,7 +81,7 @@ class IntegrationsManageView( HiModalView ):
def get( self, request, *args, **kwargs ):
context = {
- 'integration_data_list': IntegrationFactory().get_integration_data_list(),
+ 'integration_data_list': IntegrationManager().get_integration_data_list(),
}
return self.modal_response( request, context )
@@ -95,7 +95,7 @@ class IntegrationActionView( View ):
integration_id = kwargs.get('integration_id')
action = kwargs.get('action')
- integration_gateway = IntegrationFactory().get_integration_gateway(
+ integration_gateway = IntegrationManager().get_integration_gateway(
integration_id = integration_id,
)
diff --git a/src/hi/integrations/hass/hass_controller.py b/src/hi/integrations/hass/hass_controller.py
index 3d397789..f151d82e 100644
--- a/src/hi/integrations/hass/hass_controller.py
+++ b/src/hi/integrations/hass/hass_controller.py
@@ -5,15 +5,14 @@ from hi.integrations.core.integration_key import IntegrationKey
from hi.integrations.core.transient_models import IntegrationControlResult
from .hass_converter import HassConverter
-from .hass_manager import HassManager
+from .hass_mixins import HassMixin
logger = logging.getLogger(__name__)
-class HassController( IntegrationController ):
+class HassController( IntegrationController, HassMixin ):
def __init__(self):
- self._hass_manager = HassManager()
return
def do_control( self,
@@ -26,7 +25,7 @@ class HassController( IntegrationController ):
hi_value = control_value,
)
- response = self._hass_manager.hass_client.set_state(
+ response = self.hass_manager().hass_client.set_state(
entity_id = entity_id,
state = hass_state_value,
)
diff --git a/src/hi/integrations/hass/hass_manager.py b/src/hi/integrations/hass/hass_manager.py
index bb1698c8..96586156 100644
--- a/src/hi/integrations/hass/hass_manager.py
+++ b/src/hi/integrations/hass/hass_manager.py
@@ -1,3 +1,4 @@
+from asgiref.sync import sync_to_async
import logging
from typing import Dict
@@ -24,9 +25,23 @@ class HassManager( Singleton ):
self._hass_client = None
self._change_listeners = list()
- self.reload()
+ self._was_initialized = False
return
+ def ensure_initialized(self):
+ if self._was_initialized:
+ return
+ self.reload()
+ self._was_initialized = True
+ return
+
+ async def ensure_initialized_async(self):
+ if self._was_initialized:
+ return
+ await sync_to_async( self.reload )()
+ self._was_initialized = True
+ return
+
def register_change_listener( self, callback ):
logger.debug( f'Adding HAss setting change listener from {callback.__module__}' )
self._change_listeners.append( callback )
diff --git a/src/hi/integrations/hass/hass_mixins.py b/src/hi/integrations/hass/hass_mixins.py
index 93557101..312dd6a3 100644
--- a/src/hi/integrations/hass/hass_mixins.py
+++ b/src/hi/integrations/hass/hass_mixins.py
@@ -8,9 +8,11 @@ class HassMixin:
def hass_manager(self):
if not hasattr( self, '_hass_manager' ):
self._hass_manager = HassManager()
+ self._hass_manager.ensure_initialized()
return self._hass_manager
async def hass_manager_async(self):
if not hasattr( self, '_hass_manager' ):
self._hass_manager = await sync_to_async( HassManager )()
+ await self._hass_manager.ensure_initialized_async()
return self._hass_manager
diff --git a/src/hi/integrations/hass/hass_sync.py b/src/hi/integrations/hass/hass_sync.py
index fbe8eee1..851346ca 100644
--- a/src/hi/integrations/hass/hass_sync.py
+++ b/src/hi/integrations/hass/hass_sync.py
@@ -12,17 +12,17 @@ from hi.integrations.core.integration_key import IntegrationKey
from .hass_converter import HassConverter
from .hass_models import HassDevice
from .hass_manager import HassManager
+from .hass_mixins import HassMixin
from .hass_metadata import HassMetaData
logger = logging.getLogger(__name__)
-class HassSynchronizer:
+class HassSynchronizer( HassMixin ):
SYNCHRONIZATION_LOCK_NAME = 'hass_integration_sync'
def __init__(self):
- self._hass_manager = HassManager()
return
def sync( self ) -> ProcessingResult:
@@ -40,15 +40,16 @@ class HassSynchronizer:
logger.debug( 'HAss integration sync ended.' )
def _sync_helper( self ) -> ProcessingResult:
+ hass_manager = self.hass_manager()
result = ProcessingResult( title = 'HAss Sync Result' )
- hass_client = self._hass_manager.hass_client
+ hass_client = hass_manager.hass_client
if not hass_client:
logger.debug( 'HAss client not created. HAss integration disabled?' )
result.error_list.append( 'Sync problem. HAss integration disabled?' )
return result
- hass_entity_id_to_state = self._hass_manager.fetch_hass_states_from_api()
+ hass_entity_id_to_state = hass_manager.fetch_hass_states_from_api()
result.message_list.append( f'Found {len(hass_entity_id_to_state)} current HAss states.' )
integration_key_to_entity = self._get_existing_hass_entities( result = result )
@@ -108,7 +109,7 @@ class HassSynchronizer:
result : ProcessingResult ):
entity = HassConverter.create_models_for_hass_device(
hass_device = hass_device,
- add_alarm_events = self._hass_manager.should_add_alarm_events,
+ add_alarm_events = self.hass_manager().should_add_alarm_events,
)
result.message_list.append( f'Created HAss entity: {entity}' )
return
diff --git a/src/hi/integrations/hass/hass_gateway.py b/src/hi/integrations/hass/integration.py
similarity index 95%
rename from src/hi/integrations/hass/hass_gateway.py
rename to src/hi/integrations/hass/integration.py
index f56cd9c4..0d18bb25 100644
--- a/src/hi/integrations/hass/hass_gateway.py
+++ b/src/hi/integrations/hass/integration.py
@@ -20,7 +20,7 @@ class HassGateway( IntegrationGateway ):
def get_meta_data(self) -> IntegrationMetaData:
return HassMetaData
- def get_sensor_monitor(self) -> PeriodicMonitor:
+ def get_monitor(self) -> PeriodicMonitor:
return HassMonitor()
def get_controller(self) -> IntegrationController:
diff --git a/src/hi/integrations/hass/monitors.py b/src/hi/integrations/hass/monitors.py
index 890b7466..ffc877a9 100644
--- a/src/hi/integrations/hass/monitors.py
+++ b/src/hi/integrations/hass/monitors.py
@@ -20,8 +20,6 @@ class HassMonitor( PeriodicMonitor, HassMixin, SensorResponseMixin ):
id = 'hass-monitor',
interval_secs = self.HASS_POLLING_INTERVAL_SECS,
)
-
- self.hass_manager().register_change_listener( self.refresh )
self._initialized = False
return
diff --git a/src/hi/integrations/hass/views.py b/src/hi/integrations/hass/views.py
index 76659625..ef1197db 100644
--- a/src/hi/integrations/hass/views.py
+++ b/src/hi/integrations/hass/views.py
@@ -13,12 +13,12 @@ from hi.integrations.core.views import IntegrationPageView
from hi.hi_async_view import HiModalView
-from .hass_manager import HassManager
+from .hass_mixins import HassMixin
from .hass_metadata import HassMetaData
from .hass_sync import HassSynchronizer
-class HassEnableView( HiModalView, IntegrationHelperMixin ):
+class HassEnableView( HiModalView, IntegrationHelperMixin, HassMixin ):
def get_template_name( self ) -> str:
return 'hass/modals/hass_enable.html'
@@ -133,7 +133,7 @@ class HassSettingsView( View, IntegrationHelperMixin ):
with transaction.atomic():
integration_attribute_formset.save()
- HassManager().notify_settings_changed()
+ self.hass_manager().notify_settings_changed()
context = {
'integration_attribute_formset': integration_attribute_formset,
diff --git a/src/hi/integrations/zoneminder/zm_gateway.py b/src/hi/integrations/zoneminder/integration.py
similarity index 95%
rename from src/hi/integrations/zoneminder/zm_gateway.py
rename to src/hi/integrations/zoneminder/integration.py
index aca1efbc..ed01dd84 100644
--- a/src/hi/integrations/zoneminder/zm_gateway.py
+++ b/src/hi/integrations/zoneminder/integration.py
@@ -20,7 +20,7 @@ class ZoneMinderGateway( IntegrationGateway ):
def get_meta_data(self) -> IntegrationMetaData:
return ZmMetaData
- def get_sensor_monitor(self) -> PeriodicMonitor:
+ def get_monitor(self) -> PeriodicMonitor:
return ZoneMinderMonitor()
def get_controller(self) -> IntegrationController:
diff --git a/src/hi/integrations/zoneminder/views.py b/src/hi/integrations/zoneminder/views.py
index 81f0af7b..f7aa9d91 100644
--- a/src/hi/integrations/zoneminder/views.py
+++ b/src/hi/integrations/zoneminder/views.py
@@ -10,7 +10,7 @@ from hi.integrations.core.views import IntegrationPageView
from hi.hi_async_view import HiModalView
-from .zm_manager import ZoneMinderManager
+from .zm_mixins import ZoneMinderMixin
from .zm_metadata import ZmMetaData
from .zm_sync import ZoneMinderSynchronizer
@@ -110,7 +110,7 @@ class ZmManageView( IntegrationPageView, IntegrationHelperMixin ):
}
-class ZmSettingsView( View, IntegrationHelperMixin ):
+class ZmSettingsView( View, IntegrationHelperMixin, ZoneMinderMixin ):
def post( self, request, *args, **kwargs ):
@@ -130,7 +130,7 @@ class ZmSettingsView( View, IntegrationHelperMixin ):
with transaction.atomic():
integration_attribute_formset.save()
- ZoneMinderManager().notify_settings_changed()
+ self.zm_manager().notify_settings_changed()
context = {
'integration_attribute_formset': integration_attribute_formset,
diff --git a/src/hi/integrations/zoneminder/zm_controller.py b/src/hi/integrations/zoneminder/zm_controller.py
index 4370a0e7..a4d2731c 100644
--- a/src/hi/integrations/zoneminder/zm_controller.py
+++ b/src/hi/integrations/zoneminder/zm_controller.py
@@ -5,25 +5,25 @@ from hi.integrations.core.integration_controller import IntegrationController
from hi.integrations.core.integration_key import IntegrationKey
from hi.integrations.core.transient_models import IntegrationControlResult
-from .zm_manager import ZoneMinderManager
+from .zm_mixins import ZoneMinderMixin
logger = logging.getLogger(__name__)
-class ZoneMinderController( IntegrationController ):
+class ZoneMinderController( IntegrationController, ZoneMinderMixin ):
def __init__(self):
- self._zm_manager = ZoneMinderManager()
return
def do_control( self,
integration_key : IntegrationKey,
control_value : str ) -> IntegrationControlResult:
+ zm_manager = self.zm_manager()
try:
- if integration_key.integration_name == self._zm_manager.ZM_RUN_STATE_SENSOR_INTEGRATION_NAME:
+ if integration_key.integration_name == zm_manager.ZM_RUN_STATE_SENSOR_INTEGRATION_NAME:
return self.set_run_state( run_state_value = control_value )
- if integration_key.integration_name.startswith( self._zm_manager.MONITOR_FUNCTION_SENSOR_PREFIX ):
+ if integration_key.integration_name.startswith( zm_manager.MONITOR_FUNCTION_SENSOR_PREFIX ):
m = re.match( r'.+\D(\d+)', integration_key.integration_name )
if m:
return self.set_monitor_function(
@@ -41,10 +41,10 @@ class ZoneMinderController( IntegrationController ):
error_list = [ str(e) ],
)
finally:
- self._zm_manager.clear_caches()
+ zm_manager.clear_caches()
def set_run_state( self, run_state_value : str ):
- response = self._zm_manager._zm_client.set_state( run_state_value )
+ response = self.zm_manager()._zm_client.set_state( run_state_value )
logger.debug( f'ZM Set run state to "{run_state_value}" = {response}' )
return IntegrationControlResult(
new_value = run_state_value,
@@ -54,7 +54,7 @@ class ZoneMinderController( IntegrationController ):
def set_monitor_function( self,
monitor_id : str,
function_value : str ):
- zm_monitor_list = self._zm_manager.get_zm_monitors()
+ zm_monitor_list = self.zm_manager().get_zm_monitors()
for zm_monitor in zm_monitor_list:
if str(zm_monitor.id()) == str(monitor_id):
response = zm_monitor.set_parameter({
diff --git a/src/hi/integrations/zoneminder/zm_manager.py b/src/hi/integrations/zoneminder/zm_manager.py
index 87056dcb..35bc2e80 100644
--- a/src/hi/integrations/zoneminder/zm_manager.py
+++ b/src/hi/integrations/zoneminder/zm_manager.py
@@ -1,3 +1,4 @@
+from asgiref.sync import sync_to_async
import logging
from pyzm.api import ZMApi
from pyzm.helpers.Event import Event as ZmEvent
@@ -56,7 +57,21 @@ class ZoneMinderManager( Singleton ):
self._zm_monitor_timestamp = datetimeproxy.min()
self._change_listeners = list()
+ self._was_initialized = False
+ return
+
+ def ensure_initialized(self):
+ if self._was_initialized:
+ return
self.reload()
+ self._was_initialized = True
+ return
+
+ async def ensure_initialized_async(self):
+ if self._was_initialized:
+ return
+ await sync_to_async( self.reload )()
+ self._was_initialized = True
return
def register_change_listener( self, callback ):
diff --git a/src/hi/integrations/zoneminder/zm_mixins.py b/src/hi/integrations/zoneminder/zm_mixins.py
index c3f41878..600aa85a 100644
--- a/src/hi/integrations/zoneminder/zm_mixins.py
+++ b/src/hi/integrations/zoneminder/zm_mixins.py
@@ -8,9 +8,11 @@ class ZoneMinderMixin:
def zm_manager(self):
if not hasattr( self, '_zm_manager' ):
self._zm_manager = ZoneMinderManager()
+ self._zm_manager.ensure_initialized()
return self._zm_manager
async def zm_manager_async(self):
if not hasattr( self, '_zm_manager' ):
self._zm_manager = await sync_to_async( ZoneMinderManager )()
+ await self._zm_manager.ensure_initialized_async()
return self._zm_manager
diff --git a/src/hi/integrations/zoneminder/zm_models.py b/src/hi/integrations/zoneminder/zm_models.py
index 6eaf7409..3ae6c49c 100644
--- a/src/hi/integrations/zoneminder/zm_models.py
+++ b/src/hi/integrations/zoneminder/zm_models.py
@@ -1,4 +1,3 @@
-from dataclasses import dataclass
from typing import Dict
import hi.apps.common.datetimeproxy as datetimeproxy
diff --git a/src/hi/integrations/zoneminder/zm_sync.py b/src/hi/integrations/zoneminder/zm_sync.py
index 9bee9c24..2f15e6a4 100644
--- a/src/hi/integrations/zoneminder/zm_sync.py
+++ b/src/hi/integrations/zoneminder/zm_sync.py
@@ -15,18 +15,17 @@ from hi.apps.model_helper import HiModelHelper
from hi.integrations.core.integration_key import IntegrationKey
from .enums import ZmMonitorFunction
-from .zm_manager import ZoneMinderManager
+from .zm_mixins import ZoneMinderMixin
from .zm_metadata import ZmMetaData
logger = logging.getLogger(__name__)
-class ZoneMinderSynchronizer:
+class ZoneMinderSynchronizer( ZoneMinderMixin ):
SYNCHRONIZATION_LOCK_NAME = 'zm_integration_sync'
def __init__(self):
- self._zm_manager = ZoneMinderManager()
return
def sync( self ) -> ProcessingResult:
@@ -45,7 +44,7 @@ class ZoneMinderSynchronizer:
def _sync_helper( self ) -> ProcessingResult:
result = ProcessingResult( title = 'ZM Sync Result' )
- if not self._zm_manager.zm_client:
+ if not self.zm_manager().zm_client:
logger.debug( 'ZoneMinder client not created. ZM integration disabled?' )
result.error_list.append( 'Sync problem. ZM integration disabled?' )
return result
@@ -56,12 +55,13 @@ class ZoneMinderSynchronizer:
return result
def _sync_states( self, result : ProcessingResult ) -> ProcessingResult:
-
- zm_run_state_list = self._zm_manager.get_zm_states( force_load = True )
+ zm_manager = self.zm_manager()
+
+ zm_run_state_list = zm_manager.get_zm_states( force_load = True )
new_state_values_dict = { x.name(): x.name() for x in zm_run_state_list }
zm_entity = Entity.objects.filter_by_integration_key(
- integration_key = self._zm_manager._zm_integration_key(),
+ integration_key = zm_manager._zm_integration_key(),
).first()
if not zm_entity:
@@ -71,7 +71,7 @@ class ZoneMinderSynchronizer:
)
zm_run_state_sensor = Sensor.objects.filter_by_integration_key(
- integration_key = self._zm_manager._zm_run_state_integration_key()
+ integration_key = zm_manager._zm_run_state_integration_key()
).select_related('entity_state').first()
if not zm_run_state_sensor:
@@ -118,12 +118,13 @@ class ZoneMinderSynchronizer:
return
def _fetch_zm_monitors( self, result : ProcessingResult ) -> Dict[ IntegrationKey, ZmMonitor ]:
+ zm_manager = self.zm_manager()
logger.debug( 'Getting current ZM monitors.' )
integration_key_to_monitor = dict()
- for zm_monitor in self._zm_manager.get_zm_monitors( force_load = True ):
- integration_key = self._zm_manager._to_integration_key(
- prefix = self._zm_manager.ZM_MONITOR_INTEGRATION_NAME_PREFIX,
+ for zm_monitor in zm_manager.get_zm_monitors( force_load = True ):
+ integration_key = zm_manager._to_integration_key(
+ prefix = zm_manager.ZM_MONITOR_INTEGRATION_NAME_PREFIX,
zm_monitor_id = zm_monitor.id(),
)
integration_key_to_monitor[integration_key] = zm_monitor
@@ -146,7 +147,7 @@ class ZoneMinderSynchronizer:
integration_name = str( mock_monitor_id ),
)
if integration_key.integration_name.startswith(
- self._zm_manager.ZM_MONITOR_INTEGRATION_NAME_PREFIX ):
+ self.zm_manager().ZM_MONITOR_INTEGRATION_NAME_PREFIX ):
integration_key_to_entity[integration_key] = entity
continue
@@ -155,18 +156,20 @@ class ZoneMinderSynchronizer:
def _create_zm_entity( self,
run_state_name_label_dict : Dict[ str, str ],
result : ProcessingResult ):
+ zm_manager = self.zm_manager()
+
with transaction.atomic():
zm_entity = Entity(
- name = self._zm_manager.ZM_ENTITY_NAME,
+ name = zm_manager.ZM_ENTITY_NAME,
entity_type_str = str(EntityType.SERVICE),
can_user_delete = ZmMetaData.allow_entity_deletion,
)
- zm_entity.integration_key = self._zm_manager._zm_integration_key()
+ zm_entity.integration_key = zm_manager._zm_integration_key()
zm_entity.save()
HiModelHelper.create_discrete_controller(
entity = zm_entity,
- integration_key = self._zm_manager._zm_run_state_integration_key(),
+ integration_key = zm_manager._zm_run_state_integration_key(),
name = f'{zm_entity.name} Run State',
name_label_dict = run_state_name_label_dict,
)
@@ -177,10 +180,11 @@ class ZoneMinderSynchronizer:
def _create_monitor_entity( self,
zm_monitor : ZmMonitor,
result : ProcessingResult ):
+ zm_manager = self.zm_manager()
with transaction.atomic():
- entity_integration_key = self._zm_manager._to_integration_key(
- prefix = self._zm_manager.ZM_MONITOR_INTEGRATION_NAME_PREFIX,
+ entity_integration_key = zm_manager._to_integration_key(
+ prefix = zm_manager.ZM_MONITOR_INTEGRATION_NAME_PREFIX,
zm_monitor_id = zm_monitor.id(),
)
entity = Entity(
@@ -193,34 +197,34 @@ class ZoneMinderSynchronizer:
HiModelHelper.create_video_stream_sensor(
entity = entity,
- integration_key = self._zm_manager._to_integration_key(
- prefix = self._zm_manager.VIDEO_STREAM_SENSOR_PREFIX,
+ integration_key = zm_manager._to_integration_key(
+ prefix = zm_manager.VIDEO_STREAM_SENSOR_PREFIX,
zm_monitor_id = zm_monitor.id(),
),
)
movement_sensor = HiModelHelper.create_movement_sensor(
entity = entity,
- integration_key = self._zm_manager._to_integration_key(
- prefix = self._zm_manager.MOVEMENT_SENSOR_PREFIX,
+ integration_key = zm_manager._to_integration_key(
+ prefix = zm_manager.MOVEMENT_SENSOR_PREFIX,
zm_monitor_id = zm_monitor.id(),
),
)
HiModelHelper.create_discrete_controller(
entity = entity,
- integration_key = self._zm_manager._to_integration_key(
- prefix = self._zm_manager.MONITOR_FUNCTION_SENSOR_PREFIX,
+ integration_key = zm_manager._to_integration_key(
+ prefix = zm_manager.MONITOR_FUNCTION_SENSOR_PREFIX,
zm_monitor_id = zm_monitor.id(),
),
name = f'{entity.name} Function',
name_label_dict = { str(x): x.label for x in ZmMonitorFunction },
)
- if self._zm_manager.should_add_alarm_events:
+ if zm_manager.should_add_alarm_events:
HiModelHelper.create_movement_event_definition(
name = f'{movement_sensor.name} Alarm',
entity_state = movement_sensor.entity_state,
- integration_key = self._zm_manager._to_integration_key(
- prefix = self._zm_manager.MOVEMENT_EVENT_PREFIX,
+ integration_key = zm_manager._to_integration_key(
+ prefix = zm_manager.MOVEMENT_EVENT_PREFIX,
zm_monitor_id = zm_monitor.id(),
),
)