feat(route): support multi backend

Author: duanhongyi

rootfs/api/models/app.py

@@ -938,8 +938,8 @@ def _create_default_ingress(self, target_port):
                 route.save()
         except Route.DoesNotExist:
             route = Route(app=self, owner=self.owner, kind="HTTPRoute", name=self.id,
-                          port=DEFAULT_HTTP_PORT, ptype=service.ptype)
-            route.rules = route.default_rules
+                          rules=[{"backendRefs": [{"kind": "Service", "name": service.name,
+                                                   "port": DEFAULT_HTTP_PORT, "weight": 100}]}])
             attached, msg = route.attach(gateway.name, DEFAULT_HTTP_PORT)
             if not attached:
                 raise DryccException(msg)

rootfs/api/models/gateway.py

@@ -1,14 +1,15 @@
 import logging
+import threading
 from django.db import models
 from django.conf import settings
-from django.shortcuts import get_object_or_404
 from django.contrib.auth import get_user_model
 from django.db.models import Q
+from django.http import Http404
 
 from api.exceptions import ServiceUnavailable
 from scheduler import KubeException
 
-from .base import AuditedModel, DEFAULT_HTTP_PORT, DEFAULT_HTTPS_PORT, PTYPE_MAX_LENGTH
+from .base import AuditedModel, DEFAULT_HTTP_PORT, DEFAULT_HTTPS_PORT
 
 User = get_user_model()
 logger = logging.getLogger(__name__)
@@ -167,6 +168,7 @@ class Meta:
 
 
 class Route(AuditedModel):
+    CACHE = threading.local()
     PROTOCOLS_CHOICES = {
         "TLSRoute": ("TCP", ),
         "TCPRoute": ("TCP", ),
@@ -180,11 +182,21 @@ class Route(AuditedModel):
     kind = models.CharField(max_length=15, choices=[
         (key, '/'.join(value)) for key, value in PROTOCOLS_CHOICES.items()])
     name = models.CharField(max_length=63, db_index=True)
-    port = models.PositiveIntegerField()
     rules = models.JSONField(default=list)
     routable = models.BooleanField(default=True)
     parent_refs = models.JSONField(default=list)
-    ptype = models.CharField(max_length=PTYPE_MAX_LENGTH)
+
+    @property
+    def services(self):
+        key = f"{self.app.id}_{self.name}"
+        if not hasattr(self.CACHE, key):
+            service_names = set()
+            for rule in self.rules:
+                for backend in rule['backendRefs']:
+                    service_names.add(backend['name'])
+            setattr(self.CACHE, key,
+                    [s for s in self.app.service_set.all() if s.name in service_names])
+        return getattr(self.CACHE, key)
 
     @property
     def protocols(self):
@@ -195,30 +207,47 @@ def protocols(self):
     @property
     def hostnames(self):
         return [domain.domain for domain in self.app.domain_set.filter(
-                ptype=self.ptype)]
+                ptype__in=[s.ptype for s in self.services])]
+
+    @property
+    def cleaned_rules(self):
+        services, rules = self.services, []
+        for rule in self.rules:
+            backend_refs = []
+            for backend_ref in rule["backendRefs"]:
+                for service in services:
+                    ports = [item["port"] for item in service.ports]
+                    if backend_ref["port"] in ports and backend_ref["name"] == service.name:
+                        backend_refs.append(backend_ref)
+            if backend_refs:
+                rule['backendRefs'] = backend_refs
+                rules.append(rule)
+        return rules
 
     @property
     def tls_force_hostnames(self):
         tls = self.app.tls_set.latest()
-        q = Q(ptype=self.ptype)
+        q = Q(ptype__int=[s.ptype for s in self.services])
         if not tls.certs_auto_enabled:
             q &= Q(certificate__isnull=False)
         domains = self.app.domain_set.filter(q)
         return [domain.domain for domain in domains]
 
-    @property
-    def default_rules(self):
-        service = get_object_or_404(self.app.service_set, ptype=self.ptype)
-        backend_refs = []
-        for item in service.ports:
-            if item["port"] == self.port:
-                backend_refs.append({
-                    "kind": "Service",
-                    "name": str(service),
-                    "port": item["port"],
-                    "weight": 100,
-                })
-        return [{"backendRefs": backend_refs}]
+    def check_rules(self, rules):
+        for rule in rules:
+            for backend_ref in rule["backendRefs"]:
+                kind = backend_ref.get("kind", "Service")
+                if kind != "Service":
+                    return False, {"detail": "BackendRef only supports service kind"}
+                has_service = False
+                for service in self.services:
+                    ports = [item["port"] for item in service.ports]
+                    if backend_ref["port"] in ports and backend_ref["name"] == service.name:
+                        has_service = True
+                        break
+                if not has_service:
+                    return False, {"detail": f"service {backend_ref['name']} not exists"}
+        return True, ""
 
     def log(self, message, level=logging.INFO):
         """Logs a message in the context of this service.
@@ -231,17 +260,6 @@ def log(self, message, level=logging.INFO):
         """
         logger.log(level, "[{}]: {}".format(self.app.id, message))
 
-    def check_rules(self):
-        service = self.app.service_set.filter(
-            ptype=self.ptype).first()
-        ports = [item["port"] for item in service.ports]
-        for rule in self.rules:
-            for backend_ref in rule["backendRefs"]:
-                port = backend_ref["port"]
-                if port not in ports or backend_ref["name"] != str(service):
-                    return False, {"detail": "backendRefs associated with incorrect service"}
-        return True, ""
-
     def refresh_to_k8s(self):
         if self.routable:
             parent_refs, http_parent_refs = self._get_all_parent_refs()
@@ -290,9 +308,12 @@ def detach(self, gateway_name, port):
 
     def save(self, *args, **kwargs):
         self.change_default_tls()
-        ok, msg = self.check_rules()
-        if not ok:
-            raise ValueError(msg)
+        cleaned_rules = self.cleaned_rules
+        if not cleaned_rules:
+            msg = f"route {self.name} no available backend"
+            self.log(msg, level=logging.ERROR)
+            raise Http404(msg)
+        self.rules = cleaned_rules
         super().save(*args, **kwargs)
         self.refresh_to_k8s()
 

rootfs/api/serializers/__init__.py

@@ -61,6 +61,14 @@
 HEALTHCHECK_MISMATCH_MSG = "Healthcheck pattern: %s" % HEALTHCHECK_MATCH.pattern
 
 
+def validate_port(value):
+    if not str(value).isnumeric():
+        raise serializers.ValidationError('port can only be a numeric value')
+    elif int(value) not in range(1, 65536):
+        raise serializers.ValidationError('port needs to be between 1 and 65535')
+    return value
+
+
 def validate_ptype(value):
     if not re.match(PROCTYPE_MATCH, value):
         raise serializers.ValidationError(PROCTYPE_MISMATCH_MSG)
@@ -482,14 +490,6 @@ class Meta:
         fields = ['owner', 'created', 'updated', 'app', 'ptype']
         read_only_fields = ['uuid']
 
-    @staticmethod
-    def validate_port(value):
-        if not str(value).isnumeric():
-            raise serializers.ValidationError('port can only be a numeric value')
-        elif int(value) not in range(1, 65536):
-            raise serializers.ValidationError('port needs to be between 1 and 65535')
-        return value
-
     @staticmethod
     def validate_protocol(value):
         if value is None or value == "":
@@ -502,6 +502,7 @@ def validate_protocol(value):
     def validate_target_port(cls, value):
         return cls.validate_port(value)
 
+    validate_port = staticmethod(validate_port)
     validate_ptype = staticmethod(validate_ptype)
 
 
@@ -722,51 +723,37 @@ def to_representation(self, instance):
         representation['addresses'] = instance.addresses
         return representation
 
-    @staticmethod
-    def validate_port(value):
-        if not str(value).isnumeric():
-            raise serializers.ValidationError('port can only be a numeric value')
-        elif int(value) not in range(1, 65536):
-            raise serializers.ValidationError('port needs to be between 1 and 65535')
-        return value
-
     @staticmethod
     def validate_protocol(value):
         if not re.match(GATEWAY_PROTOCOL_MATCH, value):
             raise serializers.ValidationError(GATEWAY_PROTOCOL_MISMATCH_MSG)
         return value
 
+    validate_port = staticmethod(validate_port)
     validate_ptype = staticmethod(validate_ptype)
 
 
-class RouteSerializer(serializers.Serializer):
+class RouteSerializer(serializers.ModelSerializer):
     app = serializers.SlugRelatedField(slug_field='id', queryset=models.app.App.objects.all())
     owner = serializers.ReadOnlyField(source='owner.username')
     kind = serializers.CharField(max_length=15, required=False)
     name = serializers.CharField(max_length=63, required=True)
-    port = serializers.IntegerField()
-    ptype = serializers.CharField(max_length=63, required=True)
     rules = serializers.JSONField(required=False)
     parent_refs = serializers.JSONField(required=False)
 
-    @staticmethod
-    def validate_port(value):
-        if not str(value).isnumeric():
-            raise serializers.ValidationError('port can only be a numeric value')
-        elif int(value) not in range(1, 65536):
-            raise serializers.ValidationError('port needs to be between 1 and 65535')
-        return value
+    class Meta:
+        """Metadata options for a :class:`RouteSerializer`."""
+        model = models.gateway.Route
+        fields = '__all__'
 
     @staticmethod
     def validate_kind(value):
         if not re.match(ROUTE_PROTOCOL_MATCH, value):
             raise serializers.ValidationError(ROUTE_PROTOCOL_MISMATCH_MSG)
         return value
 
-    validate_ptype = staticmethod(validate_ptype)
-
     def validate_rules(self, value):
-        kind = getattr(self, "initial_data", getattr(self, "data", {})).get("kind", None)
+        kind = getattr(self, "initial_data", {}).get("kind", None)
         if kind:
             schema = getattr(rules, f"{kind.replace("Route", "")}_RULES_SCHEMA", "SCHEMA")
         else:

rootfs/api/signals.py

@@ -182,7 +182,11 @@ def gateway_changed_handle(
 def service_changed_handle(
         sender, instance: Service, created=False, update_fields=None, **kwargs):
     if kwargs['signal'] == post_delete:
-        instance.app.route_set.filter(ptype=instance.ptype).delete()
+        for route in instance.app.route_set.all():
+            if route.cleaned_rules:
+                route.save()
+            else:
+                route.delete()
 
 
 @receiver(signal=[post_save, post_delete], sender=Domain)

rootfs/api/tests/test_gateway.py

@@ -410,10 +410,16 @@ def create_route(self, app_id, route_name="test-route",
         response = self.client.post(
             '/v2/apps/{}/routes/'.format(app_id),
             {
-                "port": 5000,
-                "ptype": ptype,
                 "kind": kind,
                 "name": route_name,
+                "rules": [{
+                    "backendRefs": [{
+                        "kind": "Service",
+                        "name": f"{app_id}-{ptype}",
+                        "port": 5000,
+                        "weight": 100,
+                    }],
+                }],
             }
         )
         self.assertEqual(response.status_code, 201, response.data)
@@ -433,6 +439,9 @@ def test_create_route(self):
             }
         )
         self.assertEqual(response.status_code, 404)
+        response = self.client.get('/v2/apps/{}/routes/'.format(app_id))
+        self.assertEqual(response.data["count"], 1)
+        self.assertEqual(len(response.data["results"][0]["rules"]), 1)
 
     def test_hostnames(self):
         app_id = self.create_app()
@@ -493,13 +502,14 @@ def test_route_check_parent_ok(self):
         _, port, route_name = self.create_route(app_id, "myroute1", "test")
         gateway_name_1 = 'bing-gateway-1'
         self.create_gateway(app_id, gateway_name_1, 5000, "HTTP")
-        self.client.patch(
+        response = self.client.patch(
             '/v2/apps/{}/routes/{}/attach/'.format(app_id, route_name),
             {
                 "gateway": gateway_name_1,
                 "port": port
             }
         )
+        self.assertEqual(response.status_code, 204, response.data)
         response = self.client.get('/v2/apps/{}/routes/'.format(app_id))
         self.assertEqual(len(response.data["results"][0]["parent_refs"]), 1)
         # create other route

rootfs/api/views.py

@@ -1086,45 +1086,16 @@ def set(self, request, *args, **kwargs):
         if isinstance(rules, str):
             rules = json.loads(rules)
         rules = self.get_serializer(route, many=False).validate_rules(rules)
-        route.rules = rules
-        ok, msg = route.check_rules()
+        ok, msg = route.check_rules(rules)
         if not ok:
             return Response(status=status.HTTP_400_BAD_REQUEST, data=msg)
+        route.rules = rules
         route.save()
         return Response(status=status.HTTP_204_NO_CONTENT)
 
-    def create(self, request, *args, **kwargs):
-        app = self.get_app()
-        port = self.get_serializer().validate_port(request.data.get('port'))
-        app_settings = app.appsettings_set.latest()
-        ptype = self.get_serializer().validate_ptype(
-            request.data.get('ptype'))
-        kind = self.get_serializer().validate_kind(request.data.get('kind'))
-        name = request.data['name']
-        route = app.route_set.filter(name=name).first()
-        if route:
-            return Response(status=status.HTTP_400_BAD_REQUEST, data={
-                "detail": f"this route {name} already exists"})
-        route = self.model(
-            app=app,
-            owner=app.owner,
-            kind=kind,
-            name=name,
-            port=port,
-            routable=app_settings.routable,
-            ptype=ptype,
-        )
-        route.rules = route.default_rules
-        if route.rules and not route.rules[0]["backendRefs"]:
-            return Response(status=status.HTTP_400_BAD_REQUEST, data={
-                "detail": "this route does not match services. please add service first."
-            })
-        route.save()
-        return Response(status=status.HTTP_201_CREATED)
-
     def attach(self, request, *args, **kwargs):
         app = self.get_app()
-        port = self.get_serializer().validate_port(request.data.get('port'))
+        port = serializers.validate_port(request.data.get('port'))
         gateway_name = request.data['gateway']
         route = get_object_or_404(self.model, app=app, name=kwargs['name'])
         attached, msg = route.attach(gateway_name, port)
@@ -1135,7 +1106,7 @@ def attach(self, request, *args, **kwargs):
 
     def detach(self, request, *args, **kwargs):
         app = self.get_app()
-        port = self.get_serializer().validate_port(request.data.get('port'))
+        port = serializers.validate_port(request.data.get('port'))
         gateway_name = request.data['gateway']
         route = get_object_or_404(self.model, app=app, name=kwargs['name'])
         detached, msg = route.detach(gateway_name, port)