LITE-28135 add support for django

Author: Francesco Faraone

connect/eaas/runner/config.py

@@ -57,6 +57,18 @@ def instance_id(self):
     def environment_type(self):
         return self.dyn_config.environment_type
 
+    @property
+    def environment_runtime(self):
+        return self.dyn_config.environment_runtime
+
+    @property
+    def environment_hostname(self):
+        return self.dyn_config.environment_hostname
+
+    @property
+    def environment_domain(self):
+        return self.dyn_config.environment_domain
+
     @property
     def account_id(self):
         return self.dyn_config.logging.meta.account_id
@@ -176,6 +188,15 @@ def update_dynamic_config(self, data):
             self.dyn_config.environment_type = (
                 data.environment_type or self.dyn_config.environment_type
             )
+            self.dyn_config.environment_runtime = (
+                data.environment_runtime or self.dyn_config.environment_runtime
+            )
+            self.dyn_config.environment_hostname = (
+                data.environment_hostname or self.dyn_config.environment_hostname
+            )
+            self.dyn_config.environment_domain = (
+                data.environment_domain or self.dyn_config.environment_domain
+            )
             self.dyn_config.logging.meta.account_id = (
                 data.logging.meta.account_id or self.dyn_config.logging.meta.account_id
             )

connect/eaas/runner/constants.py

@@ -157,3 +157,32 @@
 
 EXCEL_NULL_MARKER = '#N/A'
 ROW_DELETED_MARKER = '#INSTRUCTION/DELETE_ROW'
+
+DJANGO_NON_OVERRIDEABLE_SETTINGS = (
+    'SECRET_KEY',
+    'FORCE_SCRIPT_NAME',
+    'INSTALLED_APPS',
+    'ROOT_URLCONF',
+    'CSRF_COOKIE_SECURE',
+    'SECURE_CONTENT_TYPE_NOSNIFF',
+    'SECURE_CROSS_ORIGIN_OPENER_POLICY',
+    'SECURE_HSTS_INCLUDE_SUBDOMAINS',
+    'SECURE_HSTS_PRELOAD',
+    'SECURE_HSTS_SECONDS',
+    'SECURE_PROXY_SSL_HEADER',
+    'USE_X_FORWARDED_HOST',
+    'USE_X_FORWARDED_PORT',
+    'WSGI_APPLICATION',
+    'SESSION_COOKIE_HTTPONLY',
+    'SESSION_COOKIE_PATH',
+    'SESSION_COOKIE_SAMESITE',
+    'SESSION_COOKIE_SECURE',
+)
+DJANGO_REQUIRED_OVERRIDE_SETTINGS = tuple()
+DJANGO_ENFORCED_SETTINGS = {
+    'CSRF_COOKIE_SECURE': False,
+    'SECURE_PROXY_SSL_HEADER': ("HTTP_X_FORWARDED_PROTO", "https"),
+    'USE_X_FORWARDED_HOST': True,
+    'USE_X_FORWARDED_PORT': True,
+    'SESSION_COOKIE_SECURE': True,
+}

connect/eaas/runner/handlers/base.py

@@ -25,6 +25,8 @@ class ApplicationHandlerBase(ABC):
     def __init__(self, config):
         self._config = config
         self._logging_handler = None
+        self._django_settings_module = self.get_django_settings_module()
+        self._django_secret_key_variable = None
 
     @property
     def config(self):
@@ -70,7 +72,36 @@ def features(self):
     def variables(self):
         return self.get_variables()
 
+    @property
+    def django_settings_module(self):
+        return self._django_settings_module
+
+    @property
+    def django_secret_key_variable(self):
+        if not self._django_secret_key_variable:
+            application = self.get_application()
+            if hasattr(application, 'get_django_secret_key_variable'):
+                self._django_secret_key_variable = application.get_django_secret_key_variable()
+        return self._django_secret_key_variable
+
+    def get_django_settings_module(self):
+        ep = next(
+            iter_entry_points('connect.eaas.ext', 'djsettings'),
+            None,
+        )
+        if ep:
+            get_settings = ep.load()
+            return get_settings()
+        return None
+
+    def load_django(self):
+        if self._django_settings_module:
+            os.environ.setdefault('DJANGO_SETTINGS_MODULE', self._django_settings_module)
+            import django
+            django.setup()
+
     def load_application(self, name):
+        self.load_django()
         ep = next(
             iter_entry_points('connect.eaas.ext', name),
             None,

connect/eaas/runner/handlers/web.py

@@ -5,6 +5,7 @@
 import functools
 import inspect
 import logging
+import os
 
 from fastapi import (
     FastAPI,
@@ -186,9 +187,41 @@ def get_asgi_application(self):
         static_root = self.get_application().get_static_root()
         if static_root:
             app.mount('/static', StaticFiles(directory=static_root), name='static')
+        if self.django_settings_module:
+            self.mount_django_apps(app)
 
         return app
 
+    def mount_django_apps(self, app):
+        from django.conf import settings  # noqa: I001
+        from django.core.exceptions import ImproperlyConfigured  # noqa: I001
+        from django.core.handlers.asgi import ASGIHandler  # noqa: I001
+        script_name = getattr(settings, 'FORCE_SCRIPT_NAME', None)
+        if not (
+            script_name
+            and script_name.startswith('/guest/')
+            and len(script_name) > len('/guest/')
+        ):
+            raise ImproperlyConfigured(
+                '`FORCE_SCRIPT_NAME` must be set and must start with "/guest/"',
+            )
+        static_root = self.get_application().get_static_root()
+        if not (
+            settings.STATIC_ROOT.startswith(static_root)
+            and len(settings.STATIC_ROOT) > len(static_root) - 1
+        ):
+            raise ImproperlyConfigured(
+                f'`STATIC_ROOT` must be a directory within {static_root}',
+            )
+        static_path = os.path.join(script_name, settings.STATIC_URL)
+        app.mount(
+            static_path,
+            StaticFiles(
+                directory=settings.STATIC_ROOT,
+            ),
+        )
+        app.mount(script_name, ASGIHandler())
+
     def setup_middlewares(self, app, middlewares):
         for middleware in middlewares:
             if inspect.isfunction(middleware):

connect/eaas/runner/helpers.py

@@ -3,6 +3,7 @@
 #
 # Copyright (c) 2022 Ingram Micro. All Rights Reserved.
 #
+import copy
 import logging
 import os
 import subprocess
@@ -47,6 +48,9 @@
 )
 from connect.eaas.runner.constants import (
     BACKGROUND_TASK_MAX_EXECUTION_TIME,
+    DJANGO_ENFORCED_SETTINGS,
+    DJANGO_NON_OVERRIDEABLE_SETTINGS,
+    DJANGO_REQUIRED_OVERRIDE_SETTINGS,
     HANDLER_CLASS_TITLE,
     INTERACTIVE_TASK_MAX_EXECUTION_TIME,
     ORDINAL_SUFFIX,
@@ -618,3 +622,62 @@ def get_features_table(features):
                 Align.center(get_tfnapp_detail_table(details)),
             )
     return table
+
+
+def enforce_and_override_django_settings(
+    config,
+    django_secret_key_variable,
+    overridden_settings,
+):
+    from django.conf import settings  # noqa: I001
+    from django.core.exceptions import ImproperlyConfigured  # noqa: I001
+    if not django_secret_key_variable:
+        raise ImproperlyConfigured(
+            'Your extension class must be decorated with the '
+            '`@django_secret_key_variable` to specify the name of '
+            'the environment variable that store the django `SECRET_KEY`.',
+        )
+    if django_secret_key_variable not in config.variables:
+        raise ImproperlyConfigured(
+            f'The environment variable {django_secret_key_variable} has '
+            'not been found and it is mandatory to setup django.',
+        )
+
+    settings.SECRET_KEY = config.variables[django_secret_key_variable]
+
+    overrides = copy.copy(overridden_settings)
+
+    required_overrides = list(DJANGO_REQUIRED_OVERRIDE_SETTINGS)
+    if config.environment_runtime == 'cloud':
+        required_overrides.append('DATABASES')
+    for required_setting in required_overrides:
+        if required_setting not in overrides.keys():
+            raise ImproperlyConfigured(
+                f'The settings `{",".join(required_overrides)}` must be overridden.',
+            )
+    for non_overrideable_setting in DJANGO_NON_OVERRIDEABLE_SETTINGS:
+        if non_overrideable_setting in overrides.keys():
+            raise ImproperlyConfigured(
+                'The settings '
+                f'`{",".join(DJANGO_NON_OVERRIDEABLE_SETTINGS)}` cannot be overridden.',
+            )
+    databases_override = overrides.pop('DATABASES', None)
+
+    for setting, setting_value in overrides.items():
+        setattr(settings, setting, setting_value)
+
+    if databases_override:
+        for db, db_config in databases_override.items():
+            for prop, propvalue in db_config.items():
+                settings.DATABASES[db][prop] = propvalue
+
+    for setting, setting_value in DJANGO_ENFORCED_SETTINGS.items():
+        setattr(settings, setting, setting_value)
+
+    if config.environment_hostname and config.environment_domain:
+        settings.ALLOWED_HOSTS = [
+            f'{config.environment_hostname}.{config.environment_domain}',
+        ]
+
+    if config.environment_runtime == 'cloud':
+        settings.DEBUG = False

connect/eaas/runner/workers/base.py

@@ -44,6 +44,7 @@
     StopBackoffError,
 )
 from connect.eaas.runner.helpers import (
+    enforce_and_override_django_settings,
     to_ordinal,
 )
 
@@ -177,7 +178,11 @@ async def run(self):  # noqa: CCR001
                     message = await self.receive()
                     if not message:
                         continue
+                    if self.handler.django_settings_module:
+                        await self.close_django_old_connections()
                     await self.process_message(message)
+                    if self.handler.django_settings_module:
+                        await self.close_django_old_connections()
             except (ConnectionClosedOK, StopBackoffError) as exc:
                 self.stop()
                 if isinstance(exc, ConnectionClosedOK):
@@ -221,6 +226,12 @@ async def process_setup_response(self, data):
         reconfigured, then restart the tasks manager.
         """
         self.config.update_dynamic_config(data)
+        if self.handler.django_settings_module:
+            enforce_and_override_django_settings(
+                self.config,
+                self.handler.django_secret_key_variable,
+                await self.invoke_hook('get_django_settings'),
+            )
         await self.trigger_event('on_startup')
         logger.info('Extension configuration has been updated.')
 
@@ -235,19 +246,29 @@ async def trigger_event(self, event):
                     return
                 self.on_shutdown_fired.value = 1
 
+        await self.invoke_hook(event)
+
+    async def close_django_old_connections(self):
+        from django.db import close_old_connections  # noqa: I001
+        return await asyncio.get_event_loop().run_in_executor(
+            None,
+            close_old_connections,
+        )
+
+    async def invoke_hook(self, hook_name):
         application = self.handler.get_application()
-        event_handler = getattr(application, event, None)
+        hook = getattr(application, hook_name, None)
         if (
-            event_handler
-            and inspect.ismethod(event_handler)
-            and event_handler.__self__ is application
+            hook
+            and inspect.ismethod(hook)
+            and hook.__self__ is application
         ):
-            if inspect.iscoroutinefunction(event_handler):
-                await event_handler(self.handler.get_logger(), self.config.variables)
+            if inspect.iscoroutinefunction(hook):
+                return await hook(self.handler.get_logger(), self.config.variables)
             else:
-                await asyncio.get_event_loop().run_in_executor(
+                return await asyncio.get_event_loop().run_in_executor(
                     None,
-                    event_handler,
+                    hook,
                     self.handler.get_logger(),
                     self.config.variables,
                 )