Merge branch 'master' into chore/add-publiccode-parser-action

Author: nemesifier

.github/FUNDING.yml

@@ -1,5 +1,5 @@
 # These are supported funding model platforms
-github: # Replace with up to 4 GitHub Sponsors-enabled usernames e.g., [user1, user2]
+github: [openwisp]
 patreon: # Replace with a single Patreon username
 open_collective: # Replace with a single Open Collective username
 ko_fi: # Replace with a single Ko-fi username

docs/user/templates.rst

@@ -79,7 +79,7 @@ Default Templates
     :alt: Templates enabled by default
 
 When templates are flagged as **"Enabled by default"**, they will be
-automatically assigned to new devices.
+automatically assigned to all devices, **this includes existing devices**.
 
 This is a very powerful feature: **once default templates are correctly
 configured to implement the use case you need, you will only have to
@@ -95,11 +95,10 @@ default templates without the need of manual intervention from the network
 operators.
 
 An organization specific template flagged as default will be automatically
-assigned to any new device which will be created in the same organization.
+assigned to all current and future devices in the same organization.
 
 A shared default template instead will be automatically assigned to all
-the new devices which will be created in the system, regardless of
-organization.
+existing and new devices in the system, regardless of organization.
 
 .. _required_templates:
 

openwisp_controller/config/base/template.py

@@ -1,4 +1,5 @@
 import json
+import logging
 from collections import OrderedDict
 from copy import copy
 
@@ -7,14 +8,19 @@
 from django.utils.translation import gettext_lazy as _
 from jsonfield import JSONField
 from netjsonconfig.exceptions import ValidationError as NetjsonconfigValidationError
-from swapper import get_model_name
+from swapper import get_model_name, load_model
 from taggit.managers import TaggableManager
 
 from ...base import ShareableOrgMixinUniqueName
 from ..settings import DEFAULT_AUTO_CERT
-from ..tasks import update_template_related_config_status
+from ..tasks import (
+    auto_add_template_to_existing_configs,
+    update_template_related_config_status,
+)
 from .base import BaseConfig
 
+logger = logging.getLogger(__name__)
+
 TYPE_CHOICES = (("generic", _("Generic")), ("vpn", _("VPN-client")))
 
 
@@ -61,7 +67,8 @@ class AbstractTemplate(ShareableOrgMixinUniqueName, BaseConfig):
         default=False,
         db_index=True,
         help_text=_(
-            "whether new configurations will have this template enabled by default"
+            "whether this template is applied to all current and future devices"
+            " by default (can be unassigned manually)"
         ),
     )
     required = models.BooleanField(
@@ -124,14 +131,31 @@ def pre_save_handler(cls, instance, *args, **kwargs):
             # the old configuration may become invalid, raising an exception.
             # Setting the checksum to None forces related configurations to update.
             current_checksum = None
-        instance._update_related_config_status = instance.checksum != current_checksum
+        instance._should_update_related_config_status = (
+            instance.checksum != current_checksum
+        )
+
+        # Check if template is becoming default or required
+        if (instance.default and not current.default) or (
+            instance.required and not current.required
+        ):
+            instance._should_add_to_existing_configs = True
 
     @classmethod
     def post_save_handler(cls, instance, created, *args, **kwargs):
-        if not created and getattr(instance, "_update_related_config_status", False):
+        if not created and getattr(
+            instance, "_should_update_related_config_status", False
+        ):
             transaction.on_commit(
                 lambda: update_template_related_config_status.delay(instance.pk)
             )
+        # Auto-add template to existing configs if it's new or became default/required
+        if getattr(instance, "_should_add_to_existing_configs", False) or (
+            created and (instance.default or instance.required)
+        ):
+            transaction.on_commit(
+                lambda: auto_add_template_to_existing_configs.delay(str(instance.pk))
+            )
 
     def _update_related_config_status(self):
         # use atomic to ensure any code bound to
@@ -153,6 +177,44 @@ def _update_related_config_status(self):
                 if config.pk in changing_status:
                     config._send_config_status_changed_signal()
 
+    def _auto_add_to_existing_configs(self):
+        """
+        When a template is ``default`` or ``required``, adds the template
+        to each relevant ``Config`` object
+        """
+        Config = load_model("config", "Config")
+
+        # Only proceed if template is default or required
+        if not (self.default or self.required):
+            return
+
+        # use atomic to ensure any code bound to
+        # be executed via transaction.on_commit
+        # is executed after the whole block
+        with transaction.atomic():
+            # Exclude deactivating or deactivated configs
+            configs = (
+                Config.objects.select_related("device")
+                .filter(
+                    backend=self.backend,
+                )
+                .exclude(
+                    models.Q(status__in=["deactivating", "deactivated"])
+                    | models.Q(templates__id=self.pk)
+                )
+            )
+            if self.organization_id:
+                configs = configs.filter(device__organization_id=self.organization_id)
+            for config in configs.iterator():
+                try:
+                    config.templates.add(self)
+                except Exception as e:
+                    # Log error but continue with other configs
+                    logger.exception(
+                        f"Failed to add template {self.pk} to "
+                        f"config {config.pk}: {e}"
+                    )
+
     def clean(self, *args, **kwargs):
         """
         * validates org relationship of VPN if present

openwisp_controller/config/base/vpn.py

@@ -904,7 +904,7 @@ def _get_common_name(self):
     @classmethod
     def post_save(cls, instance, **kwargs):
         def _post_save():
-            instance.vpn._invalidate_peer_cache(update=True)
+            instance.vpn._invalidate_peer_cache()
 
         transaction.on_commit(_post_save)
         # ZT network member should be authorized and assigned

openwisp_controller/config/migrations/0001_squashed_0002_config_settings_uuid.py

@@ -294,8 +294,8 @@ class Migration(migrations.Migration):
                         db_index=True,
                         default=False,
                         help_text=(
-                            "whether new configurations will have this "
-                            "template enabled by default"
+                            "whether this template is applied to all current and future"
+                            " devices by default (can be unassigned manually)"
                         ),
                         verbose_name="enabled by default",
                     ),

openwisp_controller/config/tasks.py

@@ -37,6 +37,26 @@ def update_template_related_config_status(template_pk):
         )
 
 
+@shared_task(soft_time_limit=7200)
+def auto_add_template_to_existing_configs(template_pk):
+    Template = load_model("config", "Template")
+    try:
+        template = Template.objects.get(pk=template_pk)
+    except ObjectDoesNotExist as e:
+        logger.warning(
+            f'auto_add_template_to_existing_configs("{template_pk}") failed: {e}'
+        )
+        return
+    try:
+        template._auto_add_to_existing_configs()
+    except SoftTimeLimitExceeded:
+        logger.error(
+            "soft time limit hit while executing "
+            f"_auto_add_to_existing_configs for {template} "
+            f"(ID: {template_pk})"
+        )
+
+
 @shared_task(soft_time_limit=1200)
 def create_vpn_dh(vpn_pk):
     """
@@ -97,7 +117,9 @@ def invalidate_devicegroup_cache_delete(instance_id, model_name, **kwargs):
         )
 
 
-@shared_task(base=OpenwispCeleryTask)
+# Generating large configurations can be time-consuming; hence,
+# a custom soft time limit is applied here.
+@shared_task(soft_time_limit=300)
 def trigger_vpn_server_endpoint(endpoint, auth_token, vpn_id):
     Vpn = load_model("config", "Vpn")
     try: