feat(rootfs/api): implement api for services.

implement api, models, serializers for services

Author: notmaxx

rootfs/api/models/__init__.py

@@ -142,6 +142,7 @@ class Meta:
 from .certificate import Certificate, validate_certificate  # noqa
 from .config import Config  # noqa
 from .domain import Domain  # noqa
+from .service import Service  # noqa
 from .key import Key, validate_base64  # noqa
 from .release import Release  # noqa
 from .tls import TLS  # noqa

rootfs/api/models/config.py

@@ -24,6 +24,7 @@ class Config(UuidAuditedModel):
     tags = JSONField(default={}, blank=True)
     registry = JSONField(default={}, blank=True)
     healthcheck = JSONField(default={}, blank=True)
+    termination_grace_period = JSONField(default={}, blank=True)
 
     class Meta:
         get_latest_by = 'created'

rootfs/api/models/service.py

@@ -0,0 +1,72 @@
+from django.db import models
+from django.conf import settings
+
+from api.models import AuditedModel
+
+class Service(AuditedModel):
+    owner = models.ForeignKey(settings.AUTH_USER_MODEL, on_delete=models.PROTECT)
+    app = models.ForeignKey('App', on_delete=models.CASCADE)
+    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'
+        unique_together = (('app', 'procfile_type'))
+        ordering = ['-created']
+
+    def __str__(self):
+        return "{}-{}".format(self.app.id, str(self.procfile_type))
+
+    def as_dict(self):
+        return {
+            "procfile_type": self.procfile_type,
+            "path_pattern": self.path_pattern
+        }
+
+    def save(self, *args, **kwargs):
+        # app = str(self.app)
+        # domain = str(self.domain)
+
+        # # get config for the service
+        # config = self._load_service_config(app, 'router')
+
+        # # See if domains are available
+        # if 'domains' not in config:
+        #     config['domains'] = ''
+
+        # # convert from string to list to work with and filter out empty strings
+        # domains = [_f for _f in config['domains'].split(',') if _f]
+        # if domain not in domains:
+        #     domains.append(domain)
+        # config['domains'] = ','.join(domains)
+
+        # self._save_service_config(app, 'router', config)
+
+        # Save to DB
+        return super(Service, self).save(*args, **kwargs)
+
+    def delete(self, *args, **kwargs):
+        # app = str(self.app)
+        # domain = str(self.domain)
+
+        # # Deatch cert, updates k8s
+        # if self.certificate:
+        #     self.certificate.detach(domain=domain)
+
+        # # get config for the service
+        # config = self._load_service_config(app, 'router')
+
+        # # See if domains are available
+        # if 'domains' not in config:
+        #     config['domains'] = ''
+
+        # # convert from string to list to work with and filter out empty strings
+        # domains = [_f for _f in config['domains'].split(',') if _f]
+        # if domain in domains:
+        #     domains.remove(domain)
+        # config['domains'] = ','.join(domains)
+
+        # self._save_service_config(app, 'router', config)
+
+        # Delete from DB
+        return super(Service, self).delete(*args, **kwargs)

rootfs/api/serializers.py

@@ -454,6 +454,39 @@ def ToACE(x): return idna.alabel(x).decode("utf-8", "strict")
 
         return aceValue
 
+class ServiceSerializer(serializers.ModelSerializer):
+    """Serialize a :class:`~api.models.Service` model."""
+
+    app = serializers.SlugRelatedField(slug_field='id', queryset=models.App.objects.all())
+    owner = serializers.ReadOnlyField(source='owner.username')
+    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
+        fields = ['owner', 'created', 'updated', 'app', 'procfile_type', 'path_pattern']
+        read_only_fields = ['uuid']
+
+    def validate_procfile_type(self, value):
+        if not re.match(PROCTYPE_MATCH, value):
+            raise serializers.ValidationError(PROCTYPE_MISMATCH_MSG)
+
+        return value
+
+    def validate_path_pattern(self, 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:
+                raise serializers.ValidationError(
+                    "Service value should be valid regex (or set of regex split by comma), error: {}"\
+                    .format(e.message))
+
+        return value
 
 class CertificateSerializer(serializers.ModelSerializer):
     """Serialize a :class:`~api.models.Cert` model."""

rootfs/api/urls.py

@@ -50,6 +50,9 @@
         views.DomainViewSet.as_view({'delete': 'destroy'})),
     url(r"^apps/(?P<id>{})/domains/?$".format(settings.APP_URL_REGEX),
         views.DomainViewSet.as_view({'post': 'create', 'get': 'list'})),
+    # application services
+    url(r"^apps/(?P<id>{})/services/?$".format(settings.APP_URL_REGEX),
+        views.ServiceViewSet.as_view({'post': 'create_or_update', 'get': 'list', 'delete': 'delete'})),
     # application actions
     url(r"^apps/(?P<id>{})/scale/?$".format(settings.APP_URL_REGEX),
         views.AppViewSet.as_view({'post': 'scale'})),

rootfs/api/views.py

@@ -371,6 +371,34 @@ def get_object(self, **kwargs):
             ace_domain = domain
         return get_object_or_404(qs, domain=ace_domain)
 
+class ServiceViewSet(AppResourceViewSet):
+    """A viewset for interacting with Service objects."""
+    model = models.Service
+    serializer_class = serializers.ServiceSerializer
+
+    def list(self, *args, **kwargs):
+        services = self.get_app().service_set.all()
+        data = [ obj.as_dict() for obj in services ]
+        return Response(data, status=status.HTTP_200_OK)
+
+    def create_or_update(self, request, **kwargs):
+        pft = self.get_serializer().validate_procfile_type(request.data.get('procfile_type'))
+        pp = self.get_serializer().validate_path_pattern(request.data.get('path_pattern'))
+        svc = self.get_app().service_set.filter(procfile_type=pft).first()
+        if svc:
+            if svc.path_pattern == pp:
+                return Response(status=status.HTTP_204_NO_CONTENT)
+            else:
+                svc.path_pattern = pp
+                svc.save()
+        return Response(status=status.HTTP_201_CREATED)
+
+    def delete(self, request, **kwargs):
+        pft = self.get_serializer().validate_procfile_type(request.data.get('procfile_type'))
+        qs = self.get_queryset(**kwargs)
+        svc = get_object_or_404(qs, procfile_type=pft)
+        svc.delete()
+        return Response(status=status.HTTP_204_NO_CONTENT)
 
 class CertificateViewSet(BaseDeisViewSet):
     """A viewset for interacting with Certificate objects."""