ref(scheduler): move a few high level scheduling functions to the App model

Author: helgi

rootfs/api/models/app.py

@@ -151,7 +151,7 @@ def log(self, message, level=logging.INFO):
         """
         logger.log(level, "[{}]: {}".format(self.id, message))
 
-    def create(self, *args, **kwargs):
+    def create(self, *args, **kwargs):  # noqa
         """
         Create a application with an initial config, release, domain
         and k8s resource if needed
@@ -171,9 +171,28 @@ def create(self, *args, **kwargs):
             )
 
         # create required minimum resources in k8s for the application
+        namespace = self.id
+        service = self.id
         try:
-            self._scheduler.create(self.id)
+            self.log('creating Namespace {} and services'.format(namespace), level=logging.DEBUG)
+            # Create essential resources
+            try:
+                self._scheduler.get_namespace(namespace)
+            except KubeException:
+                self._scheduler.create_namespace(namespace)
+
+            try:
+                self._scheduler.get_service(namespace, service)
+            except KubeException:
+                self._scheduler.create_service(namespace, service)
         except KubeException as e:
+            # Blow it all away only if something horrible happens
+            try:
+                self._scheduler.delete_namespace(namespace)
+            except KubeException as e:
+                # Just feed into the item below
+                pass
+
             raise ServiceUnavailable('Kubernetes resources could not be created') from e
 
         # Attach the platform specific application sub domain to the k8s service
@@ -185,8 +204,14 @@ def delete(self, *args, **kwargs):
         """Delete this application including all containers"""
         self.log("deleting environment")
         try:
-            # attempt to remove application from kubernetes
-            self._scheduler.destroy(self.id)
+            self._scheduler.delete_namespace(self.id)
+
+            # wait 30 seconds for termination
+            for _ in range(30):
+                try:
+                    self._scheduler.get_namespace(self.id)
+                except KubeException:
+                    break
         except KubeException as e:
             raise ServiceUnavailable('Could not delete Kubernetes Namespace {}'.format(self.id)) from e  # noqa
 

rootfs/api/tests/__init__.py

@@ -45,7 +45,7 @@ class SilentDjangoTestSuiteRunner(DiscoverRunner):
 
     def run_tests(self, test_labels, extra_tests=None, **kwargs):
         """Run tests with all but critical log messages disabled."""
-        # hide any log messages less than critical
-        logging.disable(logging.ERROR)
+        # hide any log messages less than error (critical and error are shown)
+        logging.disable(logging.WARNING)
         return super(SilentDjangoTestSuiteRunner, self).run_tests(
             test_labels, extra_tests, **kwargs)

rootfs/api/tests/test_app.py

@@ -406,23 +406,23 @@ def test_app_exists_in_kubernetes(self, mock_requests):
 
     def test_app_create_failure_kubernetes_create(self, mock_requests):
         """
-        Create an app but have scheduler.create fail with an exception
+        Create an app but have scheduler.create_service fail with an exception
         """
-        with mock.patch('scheduler.KubeHTTPClient.create') as mock_kube:
+        with mock.patch('scheduler.KubeHTTPClient.create_service') as mock_kube:
             mock_kube.side_effect = KubeException('Boom!')
             response = self.client.post('/v2/apps', {'id': 'test-kube'})
             self.assertEqual(response.status_code, 503, response.data)
 
     def test_app_delete_failure_kubernetes_destroy(self, mock_requests):
         """
-        Create an app and then delete but have scheduler.destroy
+        Create an app and then delete but have scheduler.delete_namespace
         fail with an exception
         """
         # create
         response = self.client.post('/v2/apps', {'id': 'test'})
         self.assertEqual(response.status_code, 201, response.data)
 
-        with mock.patch('scheduler.KubeHTTPClient.destroy') as mock_kube:
+        with mock.patch('scheduler.KubeHTTPClient.delete_namespace') as mock_kube:
             # delete
             mock_kube.side_effect = KubeException('Boom!')
             response = self.client.delete('/v2/apps/test')

rootfs/scheduler/__init__.py

@@ -352,11 +352,10 @@ def cleanup_release(self, namespace, controller):
 
     def _update_application_service(self, namespace, name, app_type, port, routable=False):
         """Update application service with all the various required information"""
-        try:
-            # Fetch service
-            service = self.get_service(namespace, namespace).json()
-            old_service = service.copy()  # in case anything fails for rollback
+        service = self.get_service(namespace, namespace).json()
+        old_service = service.copy()  # in case anything fails for rollback
 
+        try:
             # Update service information
             if routable:
                 service['metadata']['labels']['router.deis.io/routable'] = 'true'
@@ -399,37 +398,6 @@ def scale(self, namespace, name, image, command, **kwargs):
             self._scale_rc(namespace, name, old['spec']['replicas'])
             raise
 
-    def create(self, namespace, **kwargs):
-        """Create a basic structure for an application in k8s"""
-        logger.debug('creating Namespace {} and services'.format(namespace))
-        try:
-            # Create essential resources
-            try:
-                self.get_namespace(namespace)
-            except KubeException:
-                self.create_namespace(namespace)
-
-            try:
-                self.get_service(namespace, namespace)
-            except KubeException:
-                self.create_service(namespace, namespace)
-        except KubeException:
-            # Blow it all away only if something horrible happens
-            self.delete_namespace(namespace)
-            raise
-
-    def destroy(self, namespace):
-        """Destroy a application by deleting its namespace."""
-        logger.debug("destroying Namespace {}".format(namespace))
-        self.delete_namespace(namespace)
-
-        # wait 30 seconds for termination
-        for _ in range(30):
-            try:
-                self.get_namespace(namespace).json()
-            except KubeException:
-                break
-
     def run(self, namespace, name, image, entrypoint, command, **kwargs):
         """Run a one-off command."""
         logger.info('run {}, img {}, entrypoint {}, cmd "{}"'.format(