Delete from yaml

kubernetes/e2e_test/test_utils.py

@@ -408,3 +408,205 @@ def test_create_from_list_in_multi_resource_yaml_namespaced(self):
             name="mock-pod-1", namespace=self.test_namespace, body={})
         app_api.delete_namespaced_deployment(
             name="mock", namespace=self.test_namespace, body={})
+
+
+    def test_delete_apps_deployment_from_yaml(self):
+        """
+        Should delete a deployment 
+
+        First create deployment from file and ensure it is created
+        """
+        k8s_client = client.api_client.ApiClient(configuration=self.config)
+        utils.create_from_yaml(
+            k8s_client, self.path_prefix + "apps-deployment.yaml")
+        app_api = client.AppsV1Api(k8s_client)
+        dep = app_api.read_namespaced_deployment(name="nginx-app",
+                                                 namespace="default")
+        self.assertIsNotNone(dep)
+        """
+        Deployment should be created 
+
+        Now delete deployment using delete_from_yaml method
+        """
+        utils.delete_from_yaml(k8s_client, self.path_prefix + "apps-deployment.yaml")
+        self.assertIsNone(dep)
+
+    def test_delete_pod_from_yaml(self):
+        """
+        Should be able to delete pod
+
+        Create pod from file first and ensure it is created
+        """
+        k8s_client = client.api_client.ApiClient(configuration=self.config)
+        utils.create_from_yaml(
+            k8s_client, self.path_prefix + "core-pod.yaml")
+        core_api = client.CoreV1Api(k8s_client)
+        pod = core_api.read_namespaced_pod(name="myapp-pod",
+                                           namespace="default")
+        self.assertIsNotNone(pod)
+        """
+        Delete pod using delete_from_yaml
+        """
+        utils.delete_from_yaml(
+            k8s_client, self.path_prefix + "core-pod.yaml")
+        self.assertIsNone(pod)
+
+    def test_delete_service_from_yaml(self):
+        """
+        Should be able to delete a service
+
+        Create service from yaml first and ensure it is created
+        """
+        k8s_client = client.api_client.ApiClient(configuration=self.config)
+        utils.create_from_yaml(
+            k8s_client, self.path_prefix + "core-service.yaml")
+        core_api = client.CoreV1Api(k8s_client)
+        svc = core_api.read_namespaced_service(name="my-service",
+                                               namespace="default")
+        self.assertIsNotNone(svc)
+        """
+        Delete service from yaml
+        """
+        utils.delete_from_yaml(
+            k8s_client, self.path_prefix + "core-service.yaml")
+        svc = core_api.read_namespaced_service(name="my-service",
+                                               namespace="default")
+        self.assertIsNone(svc)
+
+    def test_delete_namespace_from_yaml(self):
+        """
+        Should be able to delete a namespace
+
+        Create namespace from file first and ensure it is created
+        """
+        k8s_client = client.api_client.ApiClient(configuration=self.config)
+        utils.create_from_yaml(
+            k8s_client, self.path_prefix + "core-namespace.yaml")
+        core_api = client.CoreV1Api(k8s_client)
+        nmsp = core_api.read_namespace(name="development")
+        self.assertIsNotNone(nmsp)
+        """
+        Delete namespace from yaml
+        """
+        utils.delete_from_yaml(
+            k8s_client, self.path_prefix + "core-namespace.yaml")
+        nmsp = core_api.read_namespace(name="development")
+        self.assertIsNone(nmsp)
+
+    def test_delete_rbac_role_from_yaml(self):
+        """
+        Should be able to delete rbac role
+
+        Create rbac role from file first and ensure it is created
+        """
+        k8s_client = client.api_client.ApiClient(configuration=self.config)
+        utils.create_from_yaml(
+            k8s_client, self.path_prefix + "rbac-role.yaml")
+        rbac_api = client.RbacAuthorizationV1Api(k8s_client)
+        rbac_role = rbac_api.read_namespaced_role(
+            name="pod-reader", namespace="default")
+        self.assertIsNotNone(rbac_role)
+        """
+        Delete rbac role from yaml
+        """
+        utils.delete_from_yaml(
+            k8s_client, self.path_prefix + "rbac-role.yaml")
+        rbac_role = rbac_api.read_namespaced_role(
+            name="pod-reader", namespace="default")
+        self.assertIsNone(rbac_role)
+
+    def test_delete_rbac_role_from_yaml_with_verbose_enabled(self):
+        """
+        Should delete a rbac role with verbose enabled
+
+        Create rbac role with verbose enabled and ensure it is created
+        """
+        k8s_client = client.api_client.ApiClient(configuration=self.config)
+        utils.create_from_yaml(
+            k8s_client, self.path_prefix + "rbac-role.yaml", verbose=True)
+        rbac_api = client.RbacAuthorizationV1Api(k8s_client)
+        rbac_role = rbac_api.read_namespaced_role(
+            name="pod-reader", namespace="default")
+        self.assertIsNotNone(rbac_role)
+        """
+        Delete the rbac role from yaml
+        """
+        utils.delete_from_yaml(
+            k8s_client, self.path_prefix + "rbac-role.yaml", verbose=True)
+        rbac_role = rbac_api.read_namespaced_role(
+            name="pod-reader", namespace="default")
+        self.assertIsNone(rbac_role) 
+
+    # Deletion Tests for multi resource objects in yaml files
+
+    def test_delete_from_multi_resource_yaml(self):
+        """
+        Should be able to delete service and replication controller 
+        from the multi resource yaml files
+
+        Create the resources first and ensure they exist
+        """
+        k8s_client = client.api_client.ApiClient(configuration=self.config)
+        utils.create_from_yaml(
+            k8s_client, self.path_prefix + "multi-resource.yaml")
+        core_api = client.CoreV1Api(k8s_client)
+        svc = core_api.read_namespaced_service(name="mock",
+                                               namespace="default")
+        self.assertIsNotNone(svc)
+        ctr = core_api.read_namespaced_replication_controller(
+            name="mock", namespace="default")
+        self.assertIsNotNone(ctr)
+        """
+        Delete service and replication controller using yaml file
+        """
+        utils.delete_from_yaml(
+            k8s_client, self.path_prefix + "multi-resource.yaml")
+        svc = core_api.read_namespaced_service(name="mock",
+                                               namespace="default")
+        self.assertIsNone(svc)
+        ctr = core_api.read_namespaced_replication_controller(
+            name="mock", namespace="default")
+        self.assertIsNone(ctr)
+
+    def test_delete_from_list_in_multi_resource_yaml(self):
+        """
+        Should delete the items in PodList and the deployment in the yaml file
+
+        Create the items first and ensure they exist
+        """
+        k8s_client = client.api_client.ApiClient(configuration=self.config)
+        utils.create_from_yaml(
+            k8s_client, self.path_prefix + "multi-resource-with-list.yaml")
+        core_api = client.CoreV1Api(k8s_client)
+        app_api = client.AppsV1Api(k8s_client)
+        pod_0 = core_api.read_namespaced_pod(
+            name="mock-pod-0", namespace="default")
+        self.assertIsNotNone(pod_0)
+        pod_1 = core_api.read_namespaced_pod(
+            name="mock-pod-1", namespace="default")
+        self.assertIsNotNone(pod_1)
+        dep = app_api.read_namespaced_deployment(
+            name="mock", namespace="default")
+        self.assertIsNotNone(dep)
+        """
+        Delete the PodList and Deployment using the yaml file
+        """
+        utils.delete_from_yaml(
+            k8s_client, self.path_prefix + "multi-resource-with-list.yaml")
+        pod_0 = core_api.read_namespaced_pod(
+            name="mock-pod-0", namespace="default")
+        self.assertIsNone(pod_0)
+        pod_1 = core_api.read_namespaced_pod(
+            name="mock-pod-1", namespace="default")
+        self.assertIsNone(pod_1)
+        dep = app_api.read_namespaced_deployment(
+            name="mock", namespace="default")
+        self.assertIsNone(dep)
+
+
+
+
+
+
+
+

kubernetes/utils/__init__.py

@@ -17,3 +17,5 @@
 from .create_from_yaml import (FailToCreateError, create_from_dict,
                                create_from_yaml)
 from .quantity import parse_quantity
+
+from .delete_from_yaml import (FailToDeleteError,delete_from_dict,delete_from_yaml)

kubernetes/utils/delete_from_yaml.py

@@ -0,0 +1,180 @@
+# Copyright 2018 The Kubernetes Authors.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+
+import re
+from os import path
+
+import yaml
+
+from kubernetes import client
+
+
+def delete_from_yaml(
+        k8s_client,
+        yaml_file,
+        verbose=False,
+        namespace="default",
+        **kwargs):
+        '''
+        Input:
+        yaml_file: string. Contains the path to yaml file.
+        k8s_client: an ApiClient object, initialized with the client args.
+        verbose: If True, print confirmation from the create action.
+            Default is False.
+        namespace: string. Contains the namespace to create all
+            resources inside. The namespace must preexist otherwise
+            the resource creation will fail. If the API object in
+            the yaml file already contains a namespace definition
+            this parameter has no effect.
+        Available parameters for creating <kind>:
+        :param async_req bool
+        :param str pretty: If 'true', then the output is pretty printed.
+        :param str dry_run: When present, indicates that modifications
+            should not be persisted. An invalid or unrecognized dryRun
+            directive will result in an error response and no further
+            processing of the request.
+            Valid values are: - All: all dry run stages will be processed
+        Raises:
+            FailToDeleteError which holds list of `client.rest.ApiException`
+            instances for each object that failed to delete.
+        '''
+        # open yml file
+        with open(path.abspath(yaml_file)) as f:
+            #load all yml content
+            yml_document_all = yaml.safe_load_all(f)
+
+            failures=[]
+            for yml_document in yml_document_all:
+                try:
+                    # call delete from dict function
+                    delete_from_dict(k8s_client,yml_document,verbose,
+                                 namespace=namespace,
+                                 **kwargs)    
+                except FailToDeleteError as failure:
+                    # if error is returned add to failures list
+                    failures.extend(failure.api_exceptions)
+            if failures:
+                #display the error 
+                raise FailToDeleteError(failures)
+
+def delete_from_dict(k8s_client,yml_document, verbose,namespace="default",**kwargs):
+    """
+    Perform an action from a dictionary containing valid kubernetes
+    API object (i.e. List, Service, etc).
+    Input:
+    k8s_client: an ApiClient object, initialized with the client args.
+    data: a dictionary holding valid kubernetes objects
+    verbose: If True, print confirmation from the create action.
+        Default is False.
+    yml_document: dictonary holding valid kubernetes object
+    namespace: string. Contains the namespace to create all
+        resources inside. The namespace must preexist otherwise
+        the resource creation will fail. If the API object in
+        the yaml file already contains a namespace definition
+        this parameter has no effect.
+    Raises:
+        FailToDeleteError which holds list of `client.rest.ApiException`
+        instances for each object that failed to delete.
+    """
+    api_exceptions = []
+
+    if "List" in yml_document["kind"]:
+        #For cases where it is List Pod/Service...
+        # For such cases iterate over the items
+        kind = yml_document["kind"].replace("List","")
+        for yml_doc in yml_document["items"]:
+            if kind!="":
+                yml_doc["apiVersion"]=yml_document["apiVersion"]
+                yml_doc["kind"]= kind
+            try:
+                # call function delete_from_yaml_single_item 
+                delete_from_yaml_single_item(
+                    k8s_client, yml_doc, verbose, namespace=namespace, **kwargs
+                )
+            except client.rest.ApiException as api_exception:
+                api_exceptions.append(api_exception)
+
+    else:
+
+        try:
+            # call function delete_from_yaml_single_item 
+            delete_from_yaml_single_item(
+                k8s_client, yml_document, verbose, namespace=namespace, **kwargs
+            )
+        except client.rest.ApiException as api_exception:
+            api_exceptions.append(api_exception)
+
+    if api_exceptions:
+        raise FailToDeleteError(api_exceptions)
+
+
+def delete_from_yaml_single_item(k8s_client, yml_document, verbose=False, **kwargs):
+    # get group and version from apiVersion
+    group,_,version = yml_document["apiVersion"].partition("/")
+    if version == "":
+        version = group
+        group = "core"
+    # Take care for the case e.g. api_type is "apiextensions.k8s.io"
+    group = "".join(group.rsplit(".k8s.io", 1))
+    # convert group name from DNS subdomain format to
+    # python class name convention
+    group = "".join(word.capitalize() for word in group.split('.'))
+    func = "{0}{1}Api".format(group, version.capitalize())
+    k8s_api = getattr(client, func)(k8s_client)
+    kind = yml_document["kind"]
+    kind = re.sub('(.)([A-Z][a-z]+)', r'\1_\2', kind)
+    kind = re.sub('([a-z0-9])([A-Z])', r'\1_\2', kind).lower()
+
+    if getattr(k8s_api,"delete_namespaced_{}".format(kind)):
+        # load namespace if provided in yml file
+        if "namespace" in yml_document["metadata"]:
+            namespace = yml_document["metadata"]["namespace"]
+            kwargs["namespace"] = namespace
+        # take name input of kubernetes object
+        name = yml_document["metadata"]["name"]
+        #call function to delete from namespace
+        res = getattr(k8s_api,"delete_namespaced_{}".format(kind))(
+         name=name,body=client.V1DeleteOptions(propagation_policy="Background", grace_period_seconds=5),**kwargs)
+
+    else:
+        # get name of object to delete
+        name = yml_document["metadata"]["name"]
+        kwargs.pop('namespace', None)
+        res = getattr(k8s_api,"delete_{}".format(kind))(
+         name=name,body=client.V1DeleteOptions(propagation_policy="Background", grace_period_seconds=5),**kwargs)
+    if verbose:
+        msg = "{0} deleted.".format(kind)
+        if hasattr(res, 'status'):
+            msg += " status='{0}'".format(str(res.status))
+        print(msg)
+
+
+class FailToDeleteError(Exception):
+    """
+    An exception class for handling error if an error occurred when
+    handling a yaml file during deletion of the resource.
+    """
+
+    def __init__(self, api_exceptions):
+        self.api_exceptions = api_exceptions
+
+    def __str__(self):
+        msg = ""
+        for api_exception in self.api_exceptions:
+            msg += "Error from server ({0}): {1}".format(
+                api_exception.reason, api_exception.body)
+        return msg
+
+