ref(scheduler): create base k8s resources on app creation and update them during deploy

This modifies things so that k8s resources are created during app creation, allowing Domains and other resources to be added on at any point, even before a deploy.
Changes the world a little bit around if a scale vs deploy internally is called on first deploy (as it was before)

Technically this change brings in the ability to change the target port based on a deploy but that's just a by product

Fixes #420

Author: helgi

Makefile

@@ -8,7 +8,7 @@ SHELL_SCRIPTS = $(wildcard rootfs/bin/*) $(shell find "rootfs" -name '*.sh') $(w
 
 # Get the component informtation to a tmp location and get replica count
 $(shell kubectl get rc deis-$(COMPONENT) --namespace deis -o yaml > /tmp/deis-$(COMPONENT))
-DESIRED_REPLICAS=$(shell kubectl get -o template rc/deis-$(COMPONENT) --template={{.status.replicas}})
+DESIRED_REPLICAS=$(shell kubectl get -o template rc/deis-$(COMPONENT) --template={{.status.replicas}} --namespace deis)
 
 info:
 	@echo "Build tag:  ${VERSION}"

rootfs/api/models/app.py

@@ -123,10 +123,17 @@ def create(self, *args, **kwargs):
         config = Config.objects.create(owner=self.owner, app=self)
         Release.objects.create(version=1, owner=self.owner, app=self, config=config, 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()
+
     def delete(self, *args, **kwargs):
         """Delete this application including all containers"""
         try:
             # attempt to remove containers from the scheduler
+            self._scheduler.destroy(self.id)
             self._destroy_containers([c for c in self.container_set.exclude(type='run')])
         except RuntimeError:
             pass
@@ -323,12 +330,6 @@ def _scale_containers(self, scale_types, to_remove):
                     command=command,
                     **kwargs
                 )
-
-                # Attach the platform specific application sub domain
-                # scheduler.scale creates the required service on apps:create
-                if not Domain.objects.filter(owner=self.owner, app=self, domain=self).exists():
-                    Domain(owner=self.owner, app=self, domain=str(self)).save()
-
             except Exception as e:
                 err = '{} (scale): {}'.format(job_id, e)
                 log_event(self, err, logging.ERROR)
@@ -375,14 +376,19 @@ def _destroy_containers(self, to_destroy):
         """Destroys containers via the scheduler"""
         if not to_destroy:
             return
-        destroy_threads = [Thread(target=c.destroy) for c in to_destroy]
-        [t.start() for t in destroy_threads]
-        [t.join() for t in destroy_threads]
-        [c.delete() for c in to_destroy if c.state == 'destroyed']
-        if any(c.state != 'destroyed' for c in to_destroy):
-            err = 'aborting, failed to destroy some containers'
-            log_event(self, err, logging.ERROR)
-            raise RuntimeError(err)
+
+        # for mock scheduler
+        if "scale" not in dir(self._scheduler):
+            destroy_threads = [Thread(target=c.destroy) for c in to_destroy]
+            [t.start() for t in destroy_threads]
+            [t.join() for t in destroy_threads]
+            [c.delete() for c in to_destroy if c.state == 'destroyed']
+            if any(c.state != 'destroyed' for c in to_destroy):
+                err = 'aborting, failed to destroy some containers'
+                log_event(self, err, logging.ERROR)
+                raise RuntimeError(err)
+        else:
+            [c.delete() for c in to_destroy]
 
     def deploy(self, user, release):
         """Deploy a new release to this application"""
@@ -418,7 +424,7 @@ def _deploy_app(self, scale_types, release, existing):
                 'cpu': release.config.cpu,
                 'tags': release.config.tags,
                 'envs': release.config.values,
-                'num': 0,
+                'num': 0,  # Scaling up happens in a separate operation
                 'version': version,
                 'app_type': scale_type,
                 'build_type': build_type,
@@ -458,7 +464,16 @@ def _default_scale(self, user, release):
         else:
             structure = {'web': 1}
 
-        self.scale(user, structure)
+        if "scale" in dir(self._scheduler):
+            self._deploy_app(structure, release, [])
+        else:
+            for key, num in structure.items():
+                c = Container.objects.create(owner=self.owner,
+                                             app=self,
+                                             release=release,
+                                             type=key,
+                                             num=num)
+                self._start_containers([c])
 
     def logs(self, log_lines=str(settings.LOG_LINES)):
         """Return aggregated log data for this application."""

rootfs/api/tests/test_domain.py

@@ -87,8 +87,8 @@ def test_manage_domain(self):
                 content_type='application/json',
                 HTTP_AUTHORIZATION='token {}'.format(self.token)
             )
-            result = response.data['results'][0]
-            self.assertEqual(domain, result['domain'], msg)
+            expected = [data['domain'] for data in response.data['results']]
+            self.assertEqual([self.app_id, domain], expected, msg)
 
             # Delete
             url = '/v2/apps/{app_id}/domains/{hostname}'.format(hostname=domain,
@@ -107,7 +107,11 @@ def test_manage_domain(self):
                 content_type='application/json',
                 HTTP_AUTHORIZATION='token {}'.format(self.token)
             )
-            self.assertEqual(0, response.data['count'], msg)
+            self.assertEqual(1, response.data['count'], msg)
+
+            # verify only app domain is left
+            expected = [data['domain'] for data in response.data['results']]
+            self.assertEqual([self.app_id], expected, msg)
 
     def test_delete_domain_does_not_exist(self):
         """Remove a domain that does not exist"""
@@ -146,7 +150,7 @@ def test_delete_domain_does_not_remove_latest(self):
     def test_delete_domain_does_not_remove_others(self):
         """https://github.com/deis/deis/issues/3475"""
         self.test_delete_domain_does_not_remove_latest()
-        self.assertEqual(Domain.objects.all().count(), 1)
+        self.assertEqual(Domain.objects.all().count(), 2)
 
     def test_manage_domain_invalid_app(self):
         # Create domain