Merge pull request #818 from helgi/scheduler_public

ref(scheduler): move a lot of scheduler functions from private to public

Author: helgi

rootfs/api/models/__init__.py

@@ -52,7 +52,7 @@ def _scheduler(self):
     def _fetch_service_config(self, app):
         try:
             # Get the service from k8s to attach the domain correctly
-            svc = self._scheduler._get_service(app, app).json()
+            svc = self._scheduler.get_service(app, app).json()
         except KubeException as e:
             raise ServiceUnavailable('Could not fetch Kubernetes Service {}'.format(app)) from e
 
@@ -89,7 +89,7 @@ def _save_service_config(self, app, component, data):
 
         # Update the k8s service for the application with new service information
         try:
-            self._scheduler._update_service(app, app, svc)
+            self._scheduler.update_service(app, app, svc)
         except KubeException as e:
             raise ServiceUnavailable('Could not update Kubernetes Service {}'.format(app)) from e
 

rootfs/api/models/app.py

@@ -83,7 +83,7 @@ def save(self, *args, **kwargs):
             self.release_set.latest()
         except Release.DoesNotExist:
             try:
-                if self._scheduler._get_namespace(self.id).status_code == 200:
+                if self._scheduler.get_namespace(self.id).status_code == 200:
                     # Namespace already exists
                     err = "{} already exists as a namespace in this kuberenetes setup".format(self.id)  # noqa
                     self.log(err, logging.INFO)
@@ -214,7 +214,7 @@ def restart(self, **kwargs):  # noqa
             if 'name' not in kwargs:
                 desired = 0
                 labels = self._scheduler_filter(**kwargs)
-                controllers = self._scheduler._get_rcs(kwargs['id'], labels=labels).json()['items']
+                controllers = self._scheduler.get_rcs(kwargs['id'], labels=labels).json()['items']
                 for controller in controllers:
                     desired += controller['spec']['replicas']
         except KubeException:
@@ -224,7 +224,7 @@ def restart(self, **kwargs):  # noqa
         try:
             for pod in self.list_pods(**kwargs):
                 # This function verifies the delete. Gives pod 30 seconds
-                self._scheduler._delete_pod(self.id, pod['name'])
+                self._scheduler.delete_pod(self.id, pod['name'])
         except Exception as e:
             err = "warning, some pods failed to stop:\n{}".format(str(e))
             self.log(err, logging.WARNING)
@@ -617,24 +617,24 @@ def list_pods(self, *args, **kwargs):
 
             # in case a singular pod is requested
             if 'name' in kwargs:
-                pods = [self._scheduler._get_pod(self.id, kwargs['name']).json()]
+                pods = [self._scheduler.get_pod(self.id, kwargs['name']).json()]
             else:
-                pods = self._scheduler._get_pods(self.id, labels=labels).json()['items']
+                pods = self._scheduler.get_pods(self.id, labels=labels).json()['items']
 
             data = []
             for p in pods:
                 # specifically ignore run pods
                 if p['metadata']['labels']['type'] == 'run':
                     continue
 
-                state = str(self._scheduler._pod_state(p))
+                state = str(self._scheduler.pod_state(p))
 
                 # follows kubelete convention - these are hidden unless show-all is set
                 if state in ['down', 'crashed']:
                     continue
 
                 # hide pod if it is passed the graceful termination period
-                if self._scheduler._pod_deleted(p):
+                if self._scheduler.pod_deleted(p):
                     continue
 
                 item = Pod()

rootfs/api/models/certificate.py

@@ -179,14 +179,14 @@ def attach_in_kubernetes(self, domain):
                 'tls.key': self.key
             }
 
-            secret = self._scheduler._get_secret(app, name).json()['data']
+            secret = self._scheduler.get_secret(app, name).json()['data']
         except KubeException:
-            self._scheduler._create_secret(app, name, data)
+            self._scheduler.create_secret(app, name, data)
         else:
             # update cert secret to the TLS Ingress format if required
             if secret != data:
                 try:
-                    self._scheduler._update_secret(app, name, data)
+                    self._scheduler.update_secret(app, name, data)
                 except KubeException as e:
                     msg = 'There was a problem updating the certificate secret ' \
                           '{} for {}'.format(name, app)
@@ -221,8 +221,8 @@ def detach(self, *args, **kwargs):
         if len(self.domains) == 0:
             try:
                 # We raise an exception when a secret doesn't exist
-                self._scheduler._get_secret(app, name)
-                self._scheduler._delete_secret(app, name)
+                self._scheduler.get_secret(app, name)
+                self._scheduler.delete_secret(app, name)
             except KubeException as e:
                 raise ServiceUnavailable("Could not delete certificate secret {} for application {}".format(name, app)) from e  # noqa
 

rootfs/api/models/config.py

@@ -98,7 +98,7 @@ def set_tags(self, previous_config):
             return
 
         # Get all nodes with label selectors
-        nodes = self._scheduler._get_nodes(labels=self.tags).json()
+        nodes = self._scheduler.get_nodes(labels=self.tags).json()
         if nodes['items']:
             return
 

rootfs/api/models/release.py

@@ -261,7 +261,7 @@ def cleanup_old(self):
             'heritage': 'deis'
         }
         controller_removal = []
-        controllers = self._scheduler._get_rcs(self.app.id, labels=labels).json()
+        controllers = self._scheduler.get_rcs(self.app.id, labels=labels).json()
         for controller in controllers['items']:
             current_version = controller['metadata']['labels']['version']
             # skip the latest release
@@ -288,30 +288,30 @@ def cleanup_old(self):
             'app': self.app.id,
             'type': 'env'
         }
-        secrets = self._scheduler._get_secrets(self.app.id, labels=labels).json()
+        secrets = self._scheduler.get_secrets(self.app.id, labels=labels).json()
         for secret in secrets['items']:
             current_version = secret['metadata']['labels']['version']
             # skip the latest release
             if current_version == latest_version:
                 continue
 
-            self._scheduler._delete_secret(self.app.id, secret['metadata']['name'])
+            self._scheduler.delete_secret(self.app.id, secret['metadata']['name'])
 
         # Remove stray pods
         labels = {
             'heritage': 'deis'
         }
-        pods = self._scheduler._get_pods(self.app.id, labels=labels).json()
+        pods = self._scheduler.get_pods(self.app.id, labels=labels).json()
         for pod in pods['items']:
-            if self._scheduler._pod_deleted(pod):
+            if self._scheduler.pod_deleted(pod):
                 continue
 
             current_version = pod['metadata']['labels']['version']
             # skip the latest release
             if current_version == latest_version:
                 continue
 
-            self._scheduler._delete_pod(self.app.id, pod['metadata']['name'])
+            self._scheduler.delete_pod(self.app.id, pod['metadata']['name'])
 
     def _delete_release_in_scheduler(self, namespace, version):
         """
@@ -325,14 +325,14 @@ def _delete_release_in_scheduler(self, namespace, version):
             'app': namespace,
             'version': 'v{}'.format(version)
         }
-        controllers = self._scheduler._get_rcs(namespace, labels=labels).json()
+        controllers = self._scheduler.get_rcs(namespace, labels=labels).json()
         for controller in controllers['items']:
-            self._scheduler._cleanup_release(namespace, controller)
+            self._scheduler.cleanup_release(namespace, controller)
 
         # remove secret that contains env vars for the release
         try:
             secret_name = "{}-{}-env".format(namespace, version)
-            self._scheduler._delete_secret(namespace, secret_name)
+            self._scheduler.delete_secret(namespace, secret_name)
         except KubeHTTPException:
             pass
 

rootfs/api/tests/test_domain.py

@@ -216,16 +216,16 @@ def test_kubernetes_service_failure(self):
         """
         self.client.post('/v2/apps', {'id': 'test'})
 
-        # scheduler._get_service exception
-        with mock.patch('scheduler.KubeHTTPClient._get_service') as mock_kube:
+        # scheduler.get_service exception
+        with mock.patch('scheduler.KubeHTTPClient.get_service') as mock_kube:
             mock_kube.side_effect = KubeException('Boom!')
             domain = 'foo.com'
             url = '/v2/apps/test/domains'
             response = self.client.post(url, {'domain': domain})
             self.assertEqual(response.status_code, 503, response.data)
 
-        # scheduler._update_service exception
-        with mock.patch('scheduler.KubeHTTPClient._update_service') as mock_kube:
+        # scheduler.update_service exception
+        with mock.patch('scheduler.KubeHTTPClient.update_service') as mock_kube:
             domain = 'foo.com'
             url = '/v2/apps/test/domains'
             response = self.client.post(url, {'domain': domain})

rootfs/api/tests/test_pods.py

@@ -840,8 +840,8 @@ def test_list_pods_failure(self, mock_requests):
         self.assertEqual(response.status_code, 201, response.data)
         app_id = response.data['id']
 
-        with mock.patch('scheduler.KubeHTTPClient._get_pod') as kube_pod:
-            with mock.patch('scheduler.KubeHTTPClient._get_pods') as kube_pods:
+        with mock.patch('scheduler.KubeHTTPClient.get_pod') as kube_pod:
+            with mock.patch('scheduler.KubeHTTPClient.get_pods') as kube_pods:
                 kube_pod.side_effect = KubeException('boom!')
                 kube_pods.side_effect = KubeException('boom!')
                 url = "/v2/apps/{app_id}/pods".format(**locals())