chore(scheduler): move lower level deploy helpers into their respective resources (#1092)

Author: helgi

rootfs/scheduler/__init__.py

@@ -348,59 +348,5 @@ def run(self, namespace, name, image, entrypoint, command, **kwargs):
             # cleanup
             self.pod.delete(namespace, name)
 
-    def _get_deploy_steps(self, batches, tags):
-        # if there is no batch information available default to available nodes for app
-        if not batches:
-            # figure out how many nodes the application can go on
-            steps = len(self.node.get(labels=tags).json()['items'])
-        else:
-            steps = int(batches)
-
-        return steps
-
-    def _get_deploy_batches(self, steps, desired):
-        # figure out what kind of batches the deploy is done in - 1 in, 1 out or higher
-        if desired < steps:
-            # do it all in one go
-            batches = [desired]
-        else:
-            # figure out the stepped deploy count and then see if there is a leftover
-            batches = [steps for n in set(range(1, (desired + 1))) if n % steps == 0]
-            if desired - sum(batches) > 0:
-                batches.append(desired - sum(batches))
-
-        return batches
-
-    def _deploy_probe_timeout(self, timeout, namespace, labels, containers):
-        """
-        Added in additional timeouts based on readiness and liveness probe
-
-        Uses the max of the two instead of combining them as the checks are stacked.
-        """
-
-        container_name = '{}-{}'.format(labels['app'], labels['type'])
-        container = self.pod.find_container(container_name, containers)
-
-        # get health info from container
-        added_timeout = []
-        if 'readinessProbe' in container:
-            # If there is initial delay on the readiness check then timeout needs to be higher
-            # this is to account for kubernetes having readiness check report as failure until
-            # the initial delay period is up
-            added_timeout.append(int(container['readinessProbe'].get('initialDelaySeconds', 50)))
-
-        if 'livenessProbe' in container:
-            # If there is initial delay on the readiness check then timeout needs to be higher
-            # this is to account for kubernetes having liveness check report as failure until
-            # the initial delay period is up
-            added_timeout.append(int(container['livenessProbe'].get('initialDelaySeconds', 50)))
-
-        if added_timeout:
-            delay = max(added_timeout)
-            self.log(namespace, "adding {}s on to the original {}s timeout to account for the initial delay specified in the liveness / readiness probe".format(delay, timeout))  # noqa
-            timeout += delay
-
-        return timeout
-
 
 SchedulerClient = KubeHTTPClient

rootfs/scheduler/resources/deployment.py

@@ -171,7 +171,7 @@ def scale(self, namespace, name, image, entrypoint, command, **kwargs):
             kwargs['previous_replicas'] = current
             self.wait_until_ready(namespace, name, **kwargs)
 
-    def in_progress(self, namespace, name, deploy_timeout, batches, replicas, tags):
+    def in_progress(self, namespace, name, timeout, batches, replicas, tags):
         """
         Determine if a Deployment has a deploy in progress
 
@@ -207,7 +207,7 @@ def in_progress(self, namespace, name, deploy_timeout, batches, replicas, tags):
         containers = deployment['spec']['template']['spec']['containers']
 
         # calculate base deploy timeout
-        deploy_timeout = self._deploy_probe_timeout(deploy_timeout, namespace, labels, containers)
+        deploy_timeout = self.pod.deploy_probe_timeout(timeout, namespace, labels, containers)
 
         # a rough calculation that figures out an overall timeout
         steps = self._get_deploy_steps(batches, tags)
@@ -304,7 +304,7 @@ def wait_until_ready(self, namespace, name, **kwargs):
 
         current = int(kwargs.get('previous_replicas', 0))
         batches = kwargs.get('deploy_batches', None)
-        deploy_timeout = kwargs.get('deploy_timeout', 120)
+        timeout = kwargs.get('deploy_timeout', 120)
         tags = kwargs.get('tags', {})
         steps = self._get_deploy_steps(batches, tags)
         batches = self._get_deploy_batches(steps, replicas)
@@ -320,7 +320,7 @@ def wait_until_ready(self, namespace, name, **kwargs):
             return
 
         # calculate base deploy timeout
-        deploy_timeout = self._deploy_probe_timeout(deploy_timeout, namespace, labels, containers)
+        deploy_timeout = self.pod.deploy_probe_timeout(timeout, namespace, labels, containers)
 
         # a rough calculation that figures out an overall timeout
         timeout = len(batches) * deploy_timeout
@@ -351,3 +351,26 @@ def wait_until_ready(self, namespace, name, **kwargs):
         ready, _ = self.are_replicas_ready(namespace, name)
         if not ready:
             self.pod._handle_not_ready_pods(namespace, labels)
+
+    def _get_deploy_steps(self, batches, tags):
+        # if there is no batch information available default to available nodes for app
+        if not batches:
+            # figure out how many nodes the application can go on
+            steps = len(self.node.get(labels=tags).json()['items'])
+        else:
+            steps = int(batches)
+
+        return steps
+
+    def _get_deploy_batches(self, steps, desired):
+        # figure out what kind of batches the deploy is done in - 1 in, 1 out or higher
+        if desired < steps:
+            # do it all in one go
+            batches = [desired]
+        else:
+            # figure out the stepped deploy count and then see if there is a leftover
+            batches = [steps for n in set(range(1, (desired + 1))) if n % steps == 0]
+            if desired - sum(batches) > 0:
+                batches.append(desired - sum(batches))
+
+        return batches

rootfs/scheduler/resources/pod.py

@@ -624,7 +624,7 @@ def wait_until_ready(self, namespace, containers, labels, desired, timeout):  #
         if desired == 0:
             return
 
-        timeout = self._deploy_probe_timeout(timeout, namespace, labels, containers)
+        timeout = self.deploy_probe_timeout(timeout, namespace, labels, containers)
         self.log(namespace, "waiting for {} pods in {} namespace to be in services ({}s timeout)".format(desired, namespace, timeout))  # noqa
 
         # Ensure the minimum desired number of pods are available
@@ -694,3 +694,34 @@ def _handle_not_ready_pods(self, namespace, labels):
                     raise KubeException(message)
 
         return None
+
+    def deploy_probe_timeout(self, timeout, namespace, labels, containers):
+        """
+        Added in additional timeouts based on readiness and liveness probe
+
+        Uses the max of the two instead of combining them as the checks are stacked.
+        """
+
+        container_name = '{}-{}'.format(labels['app'], labels['type'])
+        container = self.pod.find_container(container_name, containers)
+
+        # get health info from container
+        added_timeout = []
+        if 'readinessProbe' in container:
+            # If there is initial delay on the readiness check then timeout needs to be higher
+            # this is to account for kubernetes having readiness check report as failure until
+            # the initial delay period is up
+            added_timeout.append(int(container['readinessProbe'].get('initialDelaySeconds', 50)))
+
+        if 'livenessProbe' in container:
+            # If there is initial delay on the readiness check then timeout needs to be higher
+            # this is to account for kubernetes having liveness check report as failure until
+            # the initial delay period is up
+            added_timeout.append(int(container['livenessProbe'].get('initialDelaySeconds', 50)))
+
+        if added_timeout:
+            delay = max(added_timeout)
+            self.log(namespace, "adding {}s on to the original {}s timeout to account for the initial delay specified in the liveness / readiness probe".format(delay, timeout))  # noqa
+            timeout += delay
+
+        return timeout