chore(controller): optimize the use of master and slave database rules

Author: duanhongyi

rootfs/api/models/app.py

@@ -207,21 +207,21 @@ def _refresh_ingress(self, hosts, tls_map, ssl_redirect, appsettings):
         except KubeException as e:
             raise ServiceUnavailable('Could not create Ingress in Kubernetes') from e
 
-    def refresh(self, app_settings=None, tls=None, domains=None):
+    def refresh(self):
         """
         Read and write are separated, in transaction the read database is not updated.
-        When calling, the corresponding resource object needs
+        When calling, the corresponding resource object needs.
         """
         if not getattr(self, 'refresh_enabled', True):
             return
-        app_settings = app_settings if app_settings else self.appsettings_set.latest()
+        app_settings = self.appsettings_set.latest()
         if not app_settings.routable:
             return
-        tls = tls if tls else self.tls_set.latest()
+        tls = self.tls_set.latest()
         ssl_redirect = bool(tls.https_enforced)
         certs_auto_enabled = bool(tls.certs_auto_enabled)
         hosts, tls_map = [], defaultdict(list)
-        domains = domains if domains else Domain.objects.filter(app=self)
+        domains = Domain.objects.filter(app=self)
         for domain in domains:
             host = str(domain.domain)
             hosts.append(host)

rootfs/api/models/appsettings.py

@@ -180,5 +180,4 @@ def save(self, *args, **kwargs):
         summary = ' '.join(self.summary)
         self.app.log('summary of app setting changes: {}'.format(summary), logging.DEBUG)
         super(AppSettings, self).save(**kwargs)
-        # Read and write are separated, in transaction the read database is not updated
-        self.app.refresh(app_settings=self)
+        self.app.refresh()

rootfs/api/models/domain.py

@@ -28,24 +28,15 @@ class Meta:
     @transaction.atomic
     def save(self, *args, **kwargs):
         super(Domain, self).save(*args, **kwargs)
-        # Read and write are separated, in transaction the read database is not updated
-        domains = list(self.app.domain_set.all())
-        if self in domains:
-            domains.remove(self)
-        domains.append(self)
-        self.app.refresh(domains=domains)
+        self.app.refresh()
 
     @transaction.atomic
     def delete(self, *args, **kwargs):
         # Deatch cert, updates k8s
         if self.certificate:
             self.certificate.detach(domain=str(self.domain))
         super(Domain, self).delete(*args, **kwargs)
-        # Read and write are separated, in transaction the read database is not updated
-        domains = list(self.app.domain_set.all())
-        if self in domains:
-            domains.remove(self)
-        self.app.refresh(domains=domains)
+        self.app.refresh()
 
     def __str__(self):
         return self.domain

rootfs/api/models/tls.py

@@ -49,5 +49,4 @@ def save(self, *args, **kwargs):
         self.sync()
 
     def sync(self):
-        # Read and write are separated, in transaction the read database is not updated
-        self.app.refresh(tls=self)
+        self.app.refresh()

rootfs/api/routers.py

@@ -1,14 +1,31 @@
+from asgiref.local import Local
 from django.conf import settings
 
 
 class DefaultReplicaRouter(object):
+    """
+    If a model of the current thread or coroutine has used the master db,
+    the model will also use the master in the future.
+    This can avoid the problem that the slave database is not synchronized
+    because a transaction is not committed.
+    """
+    thread_critical = False
+
+    def __init__(self):
+        self._tracker = Local(self.thread_critical)
 
     def db_for_read(self, model, **hints):
-        if 'replica' in settings.DATABASES:
+        tracker_key = ".".join([model.__module__, model.__name__])
+        if hasattr(self._tracker, tracker_key):
+            return getattr(self._tracker, tracker_key)
+        elif 'replica' in settings.DATABASES:
             return 'replica'
         return 'default'
 
     def db_for_write(self, model, **hints):
+        tracker_key = ".".join([model.__module__, model.__name__])
+        if 'replica' in settings.DATABASES:
+            setattr(self._tracker, tracker_key, 'default')
         return 'default'
 
     def allow_relation(self, obj1, obj2, **hints):