fix(k8s): recreate basic k8s resource required for apps if they are missing

gunicorn reload will fix things up, as will a deploy and scale operation.

Author: helgi

rootfs/api/models/app.py

@@ -75,13 +75,18 @@ def select_app_name(self):
 
         return name
 
-    def save(self, **kwargs):
+    def save(self, *args, **kwargs):
         if not self.id:
             self.id = generate_app_name()
             while App.objects.filter(id=self.id).exists():
                 self.id = generate_app_name()
 
-        return super(App, self).save(**kwargs)
+        application = super(App, self).save(**kwargs)
+
+        # create all the required resources
+        self.create(*args, **kwargs)
+
+        return application
 
     def __str__(self):
         return self.id
@@ -119,15 +124,31 @@ def log(self, message, level=logging.INFO):
         logger.log(level, "[{}]: {}".format(self.id, message))
 
     def create(self, *args, **kwargs):
-        """Create a new application with an initial config and release"""
-        config = Config.objects.create(owner=self.owner, app=self)
-        Release.objects.create(version=1, owner=self.owner, app=self, config=config, build=None)
+        """
+        Create a application with an initial config, release, domain
+        and k8s resource if needed
+        """
+        try:
+            cfg = self.config_set.latest()
+        except Config.DoesNotExist:
+            cfg = Config.objects.create(owner=self.owner, app=self)
+
+        # Only create if no release can be found
+        try:
+            rel = self.release_set.latest()
+        except Release.DoesNotExist:
+            rel = Release.objects.create(
+                version=1, owner=self.owner, app=self,
+                config=cfg, build=None
+            )
 
         # create required minimum resources in k8s for the application
         self._scheduler.create(self.id)
 
         # Attach the platform specific application sub domain to the k8s service
-        Domain(owner=self.owner, app=self, domain=self.id).save()
+        # Only attach it on first release in case a customer has remove the app domain
+        if rel.version == 1 and not Domain.objects.filter(domain=self.id).exists():
+            Domain(owner=self.owner, app=self, domain=self.id).save()
 
     def delete(self, *args, **kwargs):
         """Delete this application including all containers"""
@@ -231,6 +252,9 @@ def _clean_app_logs(self):
 
     def scale(self, user, structure):  # noqa
         """Scale containers up or down to match requested structure."""
+        # use create to make sure minimum resources are created
+        self.create()
+
         if self.release_set.latest().build is None:
             raise EnvironmentError('No build associated with this release')
 
@@ -392,6 +416,9 @@ def _destroy_containers(self, to_destroy):
 
     def deploy(self, user, release):
         """Deploy a new release to this application"""
+        # use create to make sure minimum resources are created
+        self.create()
+
         existing = self.container_set.exclude(type='run')
         new = []
         scale_types = set()

rootfs/api/views.py

@@ -220,9 +220,6 @@ def list(self, request, *args, **kwargs):
 
         return Response(serializer.data)
 
-    def post_save(self, app):
-        app.create()
-
     def scale(self, request, **kwargs):
         new_structure = {}
         app = self.get_object()

rootfs/scheduler/__init__.py

@@ -414,10 +414,22 @@ def create(self, namespace, **kwargs):
         logger.debug('create {}'.format(namespace))
         try:
             # Create essential resources
-            self._create_namespace(namespace)
-            self._create_minio_secret(namespace)
-            self._create_service(namespace, namespace)
+            try:
+                self._get_namespace(namespace)
+            except KubeException:
+                self._create_namespace(namespace)
+
+            try:
+                self._get_secret(namespace, 'minio-user')
+            except KubeException:
+                self._create_minio_secret(namespace)
+
+            try:
+                self._get_service(namespace, namespace)
+            except KubeException:
+                self._create_service(namespace, namespace)
         except KubeException as e:
+            # Blow it all away only if something horrible happens
             logger.debug(e)
             self._delete_namespace(namespace)
             raise