feat(controller): add svc type support

Author: duanhongyi

rootfs/api/exceptions.py

@@ -44,6 +44,7 @@ def custom_exception_handler(exc, context):
     # No response means DRF couldn't handle it
     # Output a generic 500 in a JSON format
     if response is None:
+        raise exc
         logging.exception('Uncaught Exception', exc_info=exc)
         set_rollback()
         return Response({'detail': 'Server Error'}, status=status.HTTP_500_INTERNAL_SERVER_ERROR)

rootfs/api/migrations/0001_initial.py

@@ -202,8 +202,8 @@ class Migration(migrations.Migration):
                 ('id', models.BigAutoField(auto_created=True, primary_key=True, serialize=False, verbose_name='ID')),
                 ('created', models.DateTimeField(auto_now_add=True)),
                 ('updated', models.DateTimeField(auto_now=True)),
+                ('service_type', models.TextField()),
                 ('procfile_type', models.TextField()),
-                ('path_pattern', models.TextField()),
                 ('app', models.ForeignKey(on_delete=django.db.models.deletion.CASCADE, to='api.app')),
                 ('owner', models.ForeignKey(on_delete=django.db.models.deletion.PROTECT, to=settings.AUTH_USER_MODEL)),
             ],

rootfs/api/models/service.py

@@ -13,8 +13,9 @@
 class Service(AuditedModel):
     owner = models.ForeignKey(User, on_delete=models.PROTECT)
     app = models.ForeignKey('App', on_delete=models.CASCADE)
+    service_type = models.TextField(blank=False, null=False, unique=False)
     procfile_type = models.TextField(blank=False, null=False, unique=False)
-    path_pattern = models.TextField(blank=False, null=False, unique=False)
+
 
     class Meta:
         get_latest_by = 'created'
@@ -26,8 +27,8 @@ def __str__(self):
 
     def as_dict(self):
         return {
-            "procfile_type": self.procfile_type,
-            "path_pattern": self.path_pattern
+            "service_type": self.service_type,
+            "procfile_type": self.procfile_type
         }
 
     def create(self, *args, **kwargs):  # noqa
@@ -39,7 +40,7 @@ def create(self, *args, **kwargs):  # noqa
             try:
                 self._scheduler.svc.get(namespace, svc_name)
             except KubeException:
-                self._scheduler.svc.create(namespace, svc_name)
+                self._scheduler.svc.create(namespace, svc_name, self.service_type)
         except KubeException as e:
             raise ServiceUnavailable('Kubernetes service could not be created') from e
 

rootfs/api/serializers.py

@@ -26,6 +26,8 @@
 User = get_user_model()
 logger = logging.getLogger(__name__)
 
+SVCTYPE_MATCH = re.compile(r'^(ClusterIP|LoadBalancer)$')
+SVCTYPE_MISMATCH_MSG = "The service type currently only supports ClusterIP and LoadBalancer"
 PROCTYPE_MATCH = re.compile(r'^(?P<type>[a-z0-9]+(\-[a-z0-9]+)*)$')
 PROCTYPE_MISMATCH_MSG = "Process types can only contain lowercase alphanumeric characters"
 MEMLIMIT_MATCH = re.compile(r'^(?P<mem>([1-9][0-9]*[mgMG]))$', re.IGNORECASE)
@@ -511,34 +513,26 @@ class ServiceSerializer(serializers.ModelSerializer):
 
     app = serializers.SlugRelatedField(slug_field='id', queryset=models.app.App.objects.all())
     owner = serializers.ReadOnlyField(source='owner.username')
+    service_type = serializers.CharField(allow_blank=False, allow_null=False, required=True)
     procfile_type = serializers.CharField(allow_blank=False, allow_null=False, required=True)
-    path_pattern = serializers.CharField(allow_blank=False, allow_null=False, required=True)
 
     class Meta:
         """Metadata options for a :class:`ServiceSerializer`."""
         model = models.service.Service
-        fields = ['owner', 'created', 'updated', 'app', 'procfile_type', 'path_pattern']
+        fields = ['owner', 'created', 'updated', 'app', 'service_type', 'procfile_type']
         read_only_fields = ['uuid']
 
     @staticmethod
-    def validate_procfile_type(value):
-        if not re.match(PROCTYPE_MATCH, value):
-            raise serializers.ValidationError(PROCTYPE_MISMATCH_MSG)
+    def validate_service_type(value):
+        if not re.match(SVCTYPE_MATCH, value):
+            raise serializers.ValidationError(SVCTYPE_MISMATCH_MSG)
 
         return value
 
     @staticmethod
-    def validate_path_pattern(value):
-        for pattern in str(value).split(","):
-            if not pattern.strip():
-                raise serializers.ValidationError(
-                    "Service value should be valid regex (or set of regex split by comma)")
-            try:
-                re.compile(pattern)
-            except re.error as e:
-                logger.exception(e)
-                raise serializers.ValidationError(
-                    "Service value should be valid regex (or set of regex split by comma)")
+    def validate_procfile_type(value):
+        if not re.match(PROCTYPE_MATCH, value):
+            raise serializers.ValidationError(PROCTYPE_MISMATCH_MSG)
 
         return value
 

rootfs/api/tests/test_services.py

@@ -34,46 +34,46 @@ def test_service_basic_ops(self):
         # create 1st service
         response = self.client.post(
             '/v2/apps/{}/services'.format(app_id),
-            {'procfile_type': 'test', 'path_pattern': '/testep/notify'}
+            {'service_type': 'ClusterIP', 'procfile_type': 'test'}
         )
         self.assertEqual(response.status_code, 201, response.data)
         # list 1st service
         response = self.client.get('/v2/apps/{}/services'.format(app_id))
         self.assertEqual(response.status_code, 200, response.data)
         self.assertEqual(len(response.data['services']), 1)
         expected1 = {
-            'procfile_type': 'test',
-            'path_pattern': '/testep/notify'
+            'service_type': 'ClusterIP',
+            'procfile_type': 'test'
         }
         self.assertDictContainsSubset(expected1, response.data['services'][0])
         # update 1st service
         response = self.client.post(
             '/v2/apps/{}/services'.format(app_id),
-            {'procfile_type': 'test', 'path_pattern': '/testep/notify_new'}
+            {'service_type': 'LoadBalancer', 'procfile_type': 'test'}
         )
         self.assertEqual(response.status_code, 201, response.data)
         # list 1st service and get new value
         response = self.client.get('/v2/apps/{}/services'.format(app_id))
         self.assertEqual(response.status_code, 200, response.data)
         self.assertEqual(len(response.data['services']), 1)
         expected1 = {
-            'procfile_type': 'test',
-            'path_pattern': '/testep/notify_new'
+            'service_type': 'LoadBalancer',
+            'procfile_type': 'test'
         }
         self.assertDictContainsSubset(expected1, response.data['services'][0])
         # create 2nd service
         response = self.client.post(
             '/v2/apps/{}/services'.format(app_id),
-            {'procfile_type': 'test2', 'path_pattern': '/testep2/notify'}
+            {'service_type': 'ClusterIP', 'procfile_type': 'test2'}
         )
         self.assertEqual(response.status_code, 201, response.data)
         # list two services
         response = self.client.get('/v2/apps/{}/services'.format(app_id))
         self.assertEqual(response.status_code, 200, response.data)
         self.assertEqual(len(response.data['services']), 2)
         expected2 = {
-            'procfile_type': 'test2',
-            'path_pattern': '/testep2/notify'
+            'service_type': 'ClusterIP',
+            'procfile_type': 'test2'
         }
         self.assertDictContainsSubset(expected2, response.data['services'][0])
         self.assertDictContainsSubset(expected1, response.data['services'][1])

rootfs/api/views.py

@@ -421,19 +421,19 @@ def list(self, *args, **kwargs):
         return Response({"services": data}, status=status.HTTP_200_OK)
 
     def create_or_update(self, request, **kwargs):
+        svt = self.get_serializer().validate_service_type(request.data.get('service_type'))
         pft = self.get_serializer().validate_procfile_type(request.data.get('procfile_type'))
-        pp = self.get_serializer().validate_path_pattern(request.data.get('path_pattern'))
         app = self.get_app()
         svc = app.service_set.filter(procfile_type=pft).first()
         if svc:
-            if svc.path_pattern == pp:
+            if svc.service_type == svt:
                 return Response(status=status.HTTP_204_NO_CONTENT)
             else:
-                svc.path_pattern = pp
+                svc.service_type = svt
                 svc.save()
         else:
             svc = models.service.Service.objects.create(
-                owner=app.owner, app=app, procfile_type=pft, path_pattern=pp)
+                owner=app.owner, app=app, service_type=svt, procfile_type=pft)
         return Response(status=status.HTTP_201_CREATED)
 
     def delete(self, request, **kwargs):

rootfs/scheduler/resources/service.py

@@ -27,7 +27,7 @@ def get(self, namespace, name=None, **kwargs):
 
         return response
 
-    def create(self, namespace, name, **kwargs):
+    def create(self, namespace, name, type="ClusterIP", **kwargs):
         # Ports and app type will be overwritten as required
         manifest = {
             'kind': 'Service',
@@ -41,14 +41,15 @@ def create(self, namespace, name, **kwargs):
                 'annotations': {}
             },
             'spec': {
+                'type': type,
                 'ports': [{
                     'name': 'http',
                     'port': 80,
                     'targetPort': 5000,
                     'protocol': 'TCP'
                 }],
                 'selector': {
-                    'app': namespace,
+                    'app': name,
                     'heritage': 'drycc'
                 }
             }