def create(self, namespace=None, name=generate_random_name(), **kwargs):
        """
        Helper function to create and verify a horizontalpodautoscaler on the namespace

        Creates a Deployment so that HPA can work off an object
        """
        namespace = self.namespace if namespace is None else namespace
        # these are all required even if it is kwargs...
        d_kwargs = {
            "app_type": kwargs.get("app_type", "web"),
            "version": kwargs.get("version", "v99"),
            "replicas": kwargs.get("replicas", 1),
            "pod_termination_grace_period_seconds": 2,
            "image": "quay.io/fake/image",
            "entrypoint": "sh",
            "command": "start",
        }

        # create a Deployment to test HPA with
        deployment = self.scheduler.deployment.create(namespace, name, **d_kwargs)
        self.assertEqual(deployment.status_code, 201, deployment.json())

        # create HPA referencing the Deployment above
        data = {"min": kwargs.get("min", 2), "max": kwargs.get("max", 4), "cpu_percent": 45, "wait": True}
        horizontalpodautoscaler = self.scheduler.hpa.create(
            namespace, name, d_kwargs.get("app_type"), deployment.json(), **data
        )  # noqa
        self.assertEqual(horizontalpodautoscaler.status_code, 201, horizontalpodautoscaler.json())  # noqa
        return name
    def create(self, namespace=None, name=generate_random_name(), **kwargs):
        """
        Helper function to create and verify a horizontalpodautoscaler on the namespace

        Creates a Deployment so that HPA can work off an object
        """
        namespace = self.namespace if namespace is None else namespace
        # these are all required even if it is kwargs...
        d_kwargs = {
            'app_type': kwargs.get('app_type', 'web'),
            'version': kwargs.get('version', 'v99'),
            'replicas': kwargs.get('replicas', 1),
            'pod_termination_grace_period_seconds': 2,
            'image': 'quay.io/fake/image',
            'entrypoint': 'sh',
            'command': 'start',
        }

        # create a Deployment to test HPA with
        deployment = self.scheduler.deployment.create(namespace, name, **d_kwargs)
        self.assertEqual(deployment.status_code, 201, deployment.json())

        # create HPA referencing the Deployment above
        data = {
            'min': kwargs.get('min', 2),
            'max': kwargs.get('max', 4),
            'cpu_percent': 45,
            'wait': True
        }
        horizontalpodautoscaler = self.scheduler.hpa.create(namespace, name, kwargs.get('app_type'), deployment.json(), **data)  # noqa
        self.assertEqual(horizontalpodautoscaler.status_code, 201, horizontalpodautoscaler.json())  # noqa
        return name
 def create(self, data={}):
     """
     Helper function to create and verify a service on the namespace
     """
     name = generate_random_name()
     service = self.scheduler.svc.create(self.namespace, name, data=data)
     data = service.json()
     self.assertEqual(service.status_code, 201, data)
     self.assertEqual(data['metadata']['name'], name)
     return name
    def update(self, namespace=None, name=generate_random_name(), **kwargs):
        """
        Helper function to update and verify a horizontalpodautoscaler on the namespace
        """
        namespace = self.namespace if namespace is None else namespace
        deployment = self.scheduler.deployment.get(namespace, name)

        data = {"min": kwargs.get("min", 2), "max": kwargs.get("max", 4), "cpu_percent": 45, "wait": True}
        horizontalpodautoscaler = self.scheduler.hpa.update(
            namespace, name, kwargs.get("app_type"), deployment.json(), **data
        )  # noqa
        self.assertEqual(horizontalpodautoscaler.status_code, 200, horizontalpodautoscaler.json())  # noqa
        return name
    def scale(self, namespace=None, name=generate_random_name(), **kwargs):
        """
        Helper function to scale and verify a deployment on the namespace
        """
        namespace = self.namespace if namespace is None else namespace
        # these are all required even if it is kwargs...
        kwargs = {
            'app_type': kwargs.get('app_type', 'web'),
            'version': kwargs.get('version', 'v99'),
            'replicas': kwargs.get('replicas', 4),
            'pod_termination_grace_period_seconds': 2,
        }

        self.scheduler.scale(namespace, name, 'quay.io/fake/image', 'sh', 'start', **kwargs)
        return name
    def update(self, namespace=None, name=generate_random_name(), **kwargs):
        """
        Helper function to update and verify a horizontalpodautoscaler on the namespace
        """
        namespace = self.namespace if namespace is None else namespace
        deployment = self.scheduler.deployment.get(namespace, name)

        kwargs = {
            'min': kwargs.get('replicas'),
            'max': 4,
            'cpu_percent': 45,
            'wait': True
        }
        horizontalpodautoscaler = self.scheduler.hpa.update(namespace, name, kwargs.get('app_type'), deployment.json(), **kwargs)  # noqa
        self.assertEqual(horizontalpodautoscaler.status_code, 200, horizontalpodautoscaler.json())  # noqa
        return name
Example #7
0
    def scale_rc(self, namespace=None, name=generate_random_name(), **kwargs):
        """
        Helper function to scale and verify a deployment on the namespace
        """
        namespace = self.namespace if namespace is None else namespace
        # these are all required even if it is kwargs...
        kwargs = {
            'app_type': kwargs.get('app_type', 'web'),
            'version': kwargs.get('version', 'v99'),
            'replicas': kwargs.get('replicas', 4),
            'deploy_timeout': 120,
            'pod_termination_grace_period_seconds': 2,
        }

        self.scheduler.scale_rc(namespace, name, 'quay.io/fake/image', 'sh',
                                'start', **kwargs)
        return name
Example #8
0
 def create(self):
     """
     Helper function to create and verify a secret on the namespace
     """
     name = generate_random_name()
     data = {
         'foo': 'bar',
         'this': 'that',
         'empty': None,
     }
     secret = self.scheduler.secret.create(self.namespace, name, data)
     data = secret.json()
     self.assertEqual(secret.status_code, 201, data)
     self.assertEqual(data['metadata']['name'], name)
     self.assertIn('foo', data['data'])
     self.assertIn('this', data['data'])
     return name
 def create(self):
     """
     Helper function to create and verify a secret on the namespace
     """
     name = generate_random_name()
     data = {
         'foo': 'bar',
         'this': 'that',
         'empty': None,
     }
     secret = self.scheduler.secret.create(self.namespace, name, data)
     data = secret.json()
     self.assertEqual(secret.status_code, 201, data)
     self.assertEqual(data['metadata']['name'], name)
     self.assertIn('foo', data['data'])
     self.assertIn('this', data['data'])
     return name
Example #10
0
    def create_namespace(self):
        namespace = generate_random_name()
        response = self.scheduler.ns.create(namespace)
        self.assertEqual(response.status_code, 201, response.json())
        # assert minimal amount data
        data = response.json()
        self.assertEqual(data['apiVersion'], 'v1')
        self.assertEqual(data['kind'], 'Namespace')
        self.assertDictContainsSubset(
            {
                'name': namespace,
                'labels': {
                    'heritage': 'deis'
                }
            }, data['metadata'])

        return namespace
Example #11
0
    def update(self, namespace=None, name=generate_random_name(), **kwargs):
        """
        Helper function to update and verify a deployment on the namespace
        """
        namespace = self.namespace if namespace is None else namespace
        # these are all required even if it is kwargs...
        kwargs = {
            'app_type': kwargs.get('app_type', 'web'),
            'version': kwargs.get('version', 'v99'),
            'replicas': kwargs.get('replicas', 4),
            'pod_termination_grace_period_seconds': 2,
        }

        deployment = self.scheduler.deployment.update(namespace, name, 'quay.io/fake/image',
                                                      'sh', 'start', **kwargs)
        data = deployment.json()
        self.assertEqual(deployment.status_code, 200, data)
        return name
Example #12
0
 def create_instince(self, namespace=None, name=generate_random_name(),
                     **kwargs):
     """
     Helper function to create and verify a serviceinstances on the namespace
     """
     namespace = self.namespace if namespace is None else namespace
     # these are all required even if it is kwargs...
     kwargs = {
         "instance_class": "server",
         "instance_plan": "1-1",
         "parameters": {
             "param-1": "value-1",
             "param-2": "value-2"
         }
     }
     instance = self.scheduler.svcat.create_instance(
         namespace, name, **kwargs)
     self.assertEqual(instance.status_code, 201, instance.json())
     return name
    def update(self, namespace=None, name=generate_random_name(), **kwargs):
        """
        Helper function to update and verify a horizontalpodautoscaler on the namespace
        """
        namespace = self.namespace if namespace is None else namespace
        deployment = self.scheduler.deployment.get(namespace, name)

        data = {
            'min': kwargs.get('min', 2),
            'max': kwargs.get('max', 4),
            'cpu_percent': 45,
            'wait': True
        }
        horizontalpodautoscaler = self.scheduler.hpa.update(
            namespace, name, kwargs.get('app_type'), deployment.json(),
            **data)  # noqa
        self.assertEqual(horizontalpodautoscaler.status_code, 200,
                         horizontalpodautoscaler.json())  # noqa
        return name
Example #14
0
    def create_namespace(self):
        namespace = generate_random_name()
        response = self.scheduler.ns.create(namespace)
        self.assertEqual(response.status_code, 201, response.json())
        # assert minimal amount data
        data = response.json()
        self.assertEqual(data['apiVersion'], 'v1')
        self.assertEqual(data['kind'], 'Namespace')
        self.assertDictContainsSubset(
            {
                'name': namespace,
                'labels': {
                    'heritage': 'deis'
                }
            },
            data['metadata']
        )

        return namespace
    def update_deployment(self, namespace=None, name=generate_random_name(), **kwargs):
        """
        Helper function to update and verify a deployment on the namespace
        """
        namespace = self.namespace if namespace is None else namespace
        # these are all required even if it is kwargs...
        kwargs = {
            "app_type": kwargs.get("app_type", "web"),
            "version": kwargs.get("version", "v99"),
            "replicas": kwargs.get("replicas", 4),
            "pod_termination_grace_period_seconds": 2,
            "image": "quay.io/fake/image",
            "entrypoint": "sh",
            "command": "start",
        }

        deployment = self.scheduler.deployment.update(namespace, name, **kwargs)
        data = deployment.json()
        self.assertEqual(deployment.status_code, 200, data)
        return name
Example #16
0
    def create(self, namespace=None, name=generate_random_name(), **kwargs):
        """
        Helper function to create and verify a pod on the namespace
        """
        namespace = self.namespace if namespace is None else namespace
        # these are all required even if it is kwargs...
        kwargs = {
            'app_type': kwargs.get('app_type', 'web'),
            'version': kwargs.get('version', 'v99'),
            'replicas': kwargs.get('replicas', 4),
            'pod_termination_grace_period_seconds': 2,
            'image': 'quay.io/fake/image',
            'entrypoint': 'sh',
            'command': 'start',
            'deploy_timeout': 10,
        }

        pod = self.scheduler.pod.create(namespace, name, **kwargs)
        self.assertEqual(pod.status_code, 201, pod.json())
        return name
Example #17
0
    def create(self, namespace=None, name=generate_random_name(), **kwargs):
        """
        Helper function to create and verify a pod on the namespace
        """
        namespace = self.namespace if namespace is None else namespace
        # these are all required even if it is kwargs...
        kwargs = {
            'app_type': kwargs.get('app_type', 'web'),
            'version': kwargs.get('version', 'v99'),
            'replicas': kwargs.get('replicas', 4),
            'pod_termination_grace_period_seconds': 2,
            'image': 'quay.io/fake/image',
            'entrypoint': 'sh',
            'command': 'start',
            'deploy_timeout': 10,
        }

        pod = self.scheduler.pod.create(namespace, name, **kwargs)
        self.assertEqual(pod.status_code, 201, pod.json())
        return name
 def test_check_for_failed_events(self):
     deploy_name = self.create(self.namespace)
     deployment = self.scheduler.deployment.get(self.namespace, deploy_name).json()
     response = self.scheduler.rs.get(self.namespace, labels=deployment['metadata']['labels'])
     rs = response.json()
     involved_object = {
         'involvedObject.kind': 'ReplicaSet',
         'involvedObject.name': rs['items'][0]['metadata']['name'],
         'involvedObject.namespace': self.namespace,
         'involvedObject.uid': rs['items'][0]['metadata']['uid'],
     }
     message = 'Quota exeeded'
     self.scheduler.ev.create(self.namespace,
                              '{}'.format(generate_random_name()),
                              message,
                              type='Warning',
                              involved_object=involved_object,
                              reason='FailedCreate')
     with self.assertRaisesRegex(KubeException,
                                 'Message:{}.*'.format(message)):
         self.scheduler.deployment._check_for_failed_events(self.namespace,
                                                            labels=deployment['metadata']['labels'])  # noqa
    def create(self, namespace=None, name=generate_random_name(), **kwargs):
        """
        Helper function to create and verify a horizontalpodautoscaler on the namespace

        Creates a Deployment so that HPA can work off an object
        """
        namespace = self.namespace if namespace is None else namespace
        # these are all required even if it is kwargs...
        d_kwargs = {
            'app_type': kwargs.get('app_type', 'web'),
            'version': kwargs.get('version', 'v99'),
            'replicas': kwargs.get('replicas', 1),
            'pod_termination_grace_period_seconds': 2,
            'image': 'quay.io/fake/image',
            'entrypoint': 'sh',
            'command': 'start',
            'spec_annotations': kwargs.get('spec_annotations', {}),
        }

        # create a Deployment to test HPA with
        deployment = self.scheduler.deployment.create(namespace, name,
                                                      **d_kwargs)
        self.assertEqual(deployment.status_code, 201, deployment.json())

        # create HPA referencing the Deployment above
        data = {
            'min': kwargs.get('min', 2),
            'max': kwargs.get('max', 4),
            'cpu_percent': 45,
            'wait': True
        }
        horizontalpodautoscaler = self.scheduler.hpa.create(
            namespace, name, kwargs.get('app_type'), deployment.json(),
            **data)  # noqa
        self.assertEqual(horizontalpodautoscaler.status_code, 201,
                         horizontalpodautoscaler.json())  # noqa
        return name