Merge pull request #483 from procrypt/empty_vols

delete objects based on label

pkg/transformer/kubernetes/kubernetes.go

@@ -47,6 +47,8 @@ import (
 	"k8s.io/kubernetes/pkg/util/intstr"
 	//"k8s.io/kubernetes/pkg/controller/daemon"
 	"github.com/pkg/errors"
+	"k8s.io/kubernetes/pkg/api/meta"
+	"k8s.io/kubernetes/pkg/labels"
 )
 
 // Kubernetes implements Transformer interface and represents Kubernetes transformer
@@ -250,7 +252,8 @@ func (k *Kubernetes) CreatePVC(name string, mode string) (*api.PersistentVolumeC
 			APIVersion: "v1",
 		},
 		ObjectMeta: api.ObjectMeta{
-			Name: name,
+			Name:   name,
+			Labels: transformer.ConfigLabels(name),
 		},
 		Spec: api.PersistentVolumeClaimSpec{
 			Resources: api.ResourceRequirements{
@@ -702,40 +705,67 @@ func (k *Kubernetes) Undeploy(komposeObject kobject.KomposeObject, opt kobject.C
 	}
 
 	for _, v := range objects {
+		label := labels.SelectorFromSet(labels.Set(map[string]string{transformer.Selector: v.(meta.Object).GetName()}))
+		options := api.ListOptions{LabelSelector: label}
+		komposeLabel := map[string]string{transformer.Selector: v.(meta.Object).GetName()}
 		switch t := v.(type) {
 		case *extensions.Deployment:
 			//delete deployment
-			rpDeployment, err := kubectl.ReaperFor(extensions.Kind("Deployment"), client)
+			deployment, err := client.Deployments(namespace).List(options)
 			if err != nil {
 				return err
 			}
-			//FIXME: gracePeriod is nil
-			err = rpDeployment.Stop(namespace, t.Name, TIMEOUT*time.Second, nil)
-			if err != nil {
-				return err
+			for _, l := range deployment.Items {
+				if reflect.DeepEqual(l.Labels, komposeLabel) {
+					rpDeployment, err := kubectl.ReaperFor(extensions.Kind("Deployment"), client)
+					if err != nil {
+						return err
+					}
+					//FIXME: gracePeriod is nil
+					err = rpDeployment.Stop(namespace, t.Name, TIMEOUT*time.Second, nil)
+					if err != nil {
+						return err
+					}
+					log.Infof("Successfully deleted Deployment: %s", t.Name)
+				}
 			}
-			log.Infof("Successfully deleted Deployment: %s", t.Name)
 
 		case *api.Service:
 			//delete svc
-			rpService, err := kubectl.ReaperFor(api.Kind("Service"), client)
+			svc, err := client.Services(namespace).List(options)
 			if err != nil {
 				return err
 			}
-			//FIXME: gracePeriod is nil
-			err = rpService.Stop(namespace, t.Name, TIMEOUT*time.Second, nil)
-			if err != nil {
-				return err
+			for _, l := range svc.Items {
+				if reflect.DeepEqual(l.Labels, komposeLabel) {
+					rpService, err := kubectl.ReaperFor(api.Kind("Service"), client)
+					if err != nil {
+						return err
+					}
+					//FIXME: gracePeriod is nil
+					err = rpService.Stop(namespace, t.Name, TIMEOUT*time.Second, nil)
+					if err != nil {
+						return err
+					}
+					log.Infof("Successfully deleted Service: %s", t.Name)
+				}
 			}
-			log.Infof("Successfully deleted Service: %s", t.Name)
 
 		case *api.PersistentVolumeClaim:
 			// delete pvc
-			err = client.PersistentVolumeClaims(namespace).Delete(t.Name)
+			pvc, err := client.PersistentVolumeClaims(namespace).List(options)
 			if err != nil {
 				return err
 			}
-			log.Infof("Successfully deleted PersistentVolumeClaim: %s", t.Name)
+			for _, l := range pvc.Items {
+				if reflect.DeepEqual(l.Labels, komposeLabel) {
+					err = client.PersistentVolumeClaims(namespace).Delete(t.Name)
+					if err != nil {
+						return err
+					}
+					log.Infof("Successfully deleted PersistentVolumeClaim: %s", t.Name)
+				}
+			}
 
 		case *extensions.Ingress:
 			// delete ingress
@@ -745,23 +775,41 @@ func (k *Kubernetes) Undeploy(komposeObject kobject.KomposeObject, opt kobject.C
 					APIVersion: "extensions/v1beta1",
 				},
 			}
-			err = client.Ingress(namespace).Delete(t.Name, ingDeleteOptions)
+			ingress, err := client.Ingress(namespace).List(options)
 			if err != nil {
 				return err
 			}
-			log.Infof("Successfully deleted Ingress: %s", t.Name)
+			for _, l := range ingress.Items {
+				if reflect.DeepEqual(l.Labels, komposeLabel) {
+
+					err = client.Ingress(namespace).Delete(t.Name, ingDeleteOptions)
+					if err != nil {
+						return err
+					}
+					log.Infof("Successfully deleted Ingress: %s", t.Name)
+				}
+			}
 
 		case *api.Pod:
-			rpPod, err := kubectl.ReaperFor(api.Kind("Pod"), client)
+			//delete pod
+			pod, err := client.Pods(namespace).List(options)
 			if err != nil {
 				return err
 			}
-			//FIXME: gracePeriod is nil
-			err = rpPod.Stop(namespace, t.Name, TIMEOUT*time.Second, nil)
-			if err != nil {
-				return err
+			for _, l := range pod.Items {
+				if reflect.DeepEqual(l.Labels, komposeLabel) {
+					rpPod, err := kubectl.ReaperFor(api.Kind("Pod"), client)
+					if err != nil {
+						return err
+					}
+					//FIXME: gracePeriod is nil
+					err = rpPod.Stop(namespace, t.Name, TIMEOUT*time.Second, nil)
+					if err != nil {
+						return err
+					}
+					log.Infof("Successfully deleted Pod: %s", t.Name)
+				}
 			}
-			log.Infof("Successfully deleted Pod: %s", t.Name)
 		}
 	}
 	return nil

pkg/transformer/openshift/openshift.go

@@ -39,14 +39,18 @@ import (
 
 	"time"
 
+	"github.com/kubernetes-incubator/kompose/pkg/transformer"
 	buildapi "github.com/openshift/origin/pkg/build/api"
 	deployapi "github.com/openshift/origin/pkg/deploy/api"
 	deploymentconfigreaper "github.com/openshift/origin/pkg/deploy/cmd"
 	imageapi "github.com/openshift/origin/pkg/image/api"
 	routeapi "github.com/openshift/origin/pkg/route/api"
 	"github.com/pkg/errors"
+	"k8s.io/kubernetes/pkg/api/meta"
 	"k8s.io/kubernetes/pkg/kubectl"
+	"k8s.io/kubernetes/pkg/labels"
 	"k8s.io/kubernetes/pkg/util/intstr"
+	"reflect"
 )
 
 // OpenShift implements Transformer interface and represents OpenShift transformer
@@ -161,7 +165,8 @@ func (o *OpenShift) initImageStream(name string, service kobject.ServiceConfig)
 			APIVersion: "v1",
 		},
 		ObjectMeta: api.ObjectMeta{
-			Name: name,
+			Name:   name,
+			Labels: transformer.ConfigLabels(name),
 		},
 		Spec: imageapi.ImageStreamSpec{
 			Tags: tags,
@@ -233,15 +238,15 @@ func (o *OpenShift) initDeploymentConfig(name string, service kobject.ServiceCon
 		},
 		ObjectMeta: api.ObjectMeta{
 			Name:   name,
-			Labels: map[string]string{"service": name},
+			Labels: transformer.ConfigLabels(name),
 		},
 		Spec: deployapi.DeploymentConfigSpec{
 			Replicas: int32(replicas),
-			Selector: map[string]string{"service": name},
+			Selector: transformer.ConfigLabels(name),
 			//UniqueLabelKey: p.Name,
 			Template: &api.PodTemplateSpec{
 				ObjectMeta: api.ObjectMeta{
-					Labels: map[string]string{"service": name},
+					Labels: transformer.ConfigLabels(name),
 				},
 				Spec: o.InitPodSpec(name, " "),
 			},
@@ -497,7 +502,6 @@ func (o *OpenShift) Undeploy(komposeObject kobject.KomposeObject, opt kobject.Co
 	if err != nil {
 		return errors.Wrap(err, "o.Transform failed")
 	}
-
 	oclient, err := o.getOpenShiftClient()
 	if err != nil {
 		return err
@@ -508,71 +512,132 @@ func (o *OpenShift) Undeploy(komposeObject kobject.KomposeObject, opt kobject.Co
 	}
 
 	for _, v := range objects {
+		label := labels.SelectorFromSet(labels.Set(map[string]string{transformer.Selector: v.(meta.Object).GetName()}))
+		options := api.ListOptions{LabelSelector: label}
+		komposeLabel := map[string]string{transformer.Selector: v.(meta.Object).GetName()}
 		switch t := v.(type) {
 		case *imageapi.ImageStream:
 			//delete imageStream
-			err = oclient.ImageStreams(namespace).Delete(t.Name)
+			imageStream, err := oclient.ImageStreams(namespace).List(options)
 			if err != nil {
 				return err
 			}
-			log.Infof("Successfully deleted ImageStream: %s", t.Name)
+			for _, l := range imageStream.Items {
+				if reflect.DeepEqual(l.Labels, komposeLabel) {
+					err = oclient.ImageStreams(namespace).Delete(t.Name)
+					if err != nil {
+						return err
+					}
+					log.Infof("Successfully deleted ImageStream: %s", t.Name)
+				}
+			}
 
 		case *buildapi.BuildConfig:
-			err := oclient.BuildConfigs(namespace).Delete(t.Name)
+			//options := api.ListOptions{LabelSelector: label}
+			buildConfig, err := oclient.BuildConfigs(namespace).List(options)
 			if err != nil {
 				return err
 			}
-			log.Infof("Successfully deleted BuildConfig: %s", t.Name)
+			for _, l := range buildConfig.Items {
+				if reflect.DeepEqual(l.Labels, komposeLabel) {
+					err := oclient.BuildConfigs(namespace).Delete(t.Name)
+					if err != nil {
+						return err
+					}
+					log.Infof("Successfully deleted BuildConfig: %s", t.Name)
+				}
+			}
 
 		case *deployapi.DeploymentConfig:
 			// delete deploymentConfig
-			dcreaper := deploymentconfigreaper.NewDeploymentConfigReaper(oclient, kclient)
-			err := dcreaper.Stop(namespace, t.Name, TIMEOUT*time.Second, nil)
+			deploymentConfig, err := oclient.DeploymentConfigs(namespace).List(options)
 			if err != nil {
 				return err
 			}
-			log.Infof("Successfully deleted DeploymentConfig: %s", t.Name)
+			for _, l := range deploymentConfig.Items {
+				if reflect.DeepEqual(l.Labels, komposeLabel) {
+					dcreaper := deploymentconfigreaper.NewDeploymentConfigReaper(oclient, kclient)
+					err := dcreaper.Stop(namespace, t.Name, TIMEOUT*time.Second, nil)
+					if err != nil {
+						return err
+					}
+					log.Infof("Successfully deleted DeploymentConfig: %s", t.Name)
+				}
+			}
 
 		case *api.Service:
 			//delete svc
-			rpService, err := kubectl.ReaperFor(api.Kind("Service"), kclient)
+			svc, err := kclient.Services(namespace).List(options)
 			if err != nil {
 				return err
 			}
-			//FIXME: gracePeriod is nil
-			err = rpService.Stop(namespace, t.Name, TIMEOUT*time.Second, nil)
-			if err != nil {
-				return err
+			for _, l := range svc.Items {
+				if reflect.DeepEqual(l.Labels, komposeLabel) {
+					rpService, err := kubectl.ReaperFor(api.Kind("Service"), kclient)
+					if err != nil {
+						return err
+					}
+					//FIXME: gracePeriod is nil
+					err = rpService.Stop(namespace, t.Name, TIMEOUT*time.Second, nil)
+					if err != nil {
+						return err
+					}
+					log.Infof("Successfully deleted Service: %s", t.Name)
+				}
 			}
-			log.Infof("Successfully deleted Service: %s", t.Name)
 
 		case *api.PersistentVolumeClaim:
 			// delete pvc
-			err = kclient.PersistentVolumeClaims(namespace).Delete(t.Name)
+			pvc, err := kclient.PersistentVolumeClaims(namespace).List(options)
 			if err != nil {
 				return err
 			}
-			log.Infof("Successfully deleted PersistentVolumeClaim: %s", t.Name)
+			for _, l := range pvc.Items {
+				if reflect.DeepEqual(l.Labels, komposeLabel) {
+					err = kclient.PersistentVolumeClaims(namespace).Delete(t.Name)
+					if err != nil {
+						return err
+					}
+					log.Infof("Successfully deleted PersistentVolumeClaim: %s", t.Name)
+				}
+			}
 
 		case *routeapi.Route:
 			// delete route
-			err = oclient.Routes(namespace).Delete(t.Name)
+			route, err := oclient.Routes(namespace).List(options)
 			if err != nil {
 				return err
 			}
-			log.Infof("Successfully deleted Route: %s", t.Name)
+			for _, l := range route.Items {
+				if reflect.DeepEqual(l.Labels, komposeLabel) {
+					err = oclient.Routes(namespace).Delete(t.Name)
+					if err != nil {
+						return err
+					}
+					log.Infof("Successfully deleted Route: %s", t.Name)
+				}
+			}
 
 		case *api.Pod:
-			rpPod, err := kubectl.ReaperFor(api.Kind("Pod"), kclient)
+			//delete pods
+			pod, err := kclient.Pods(namespace).List(options)
 			if err != nil {
 				return err
 			}
-			//FIXME: gracePeriod is nil
-			err = rpPod.Stop(namespace, t.Name, TIMEOUT*time.Second, nil)
-			if err != nil {
-				return err
+			for _, l := range pod.Items {
+				if reflect.DeepEqual(l.Labels, komposeLabel) {
+					rpPod, err := kubectl.ReaperFor(api.Kind("Pod"), kclient)
+					if err != nil {
+						return err
+					}
+					//FIXME: gracePeriod is nil
+					err = rpPod.Stop(namespace, t.Name, TIMEOUT*time.Second, nil)
+					if err != nil {
+						return err
+					}
+					log.Infof("Successfully deleted Pod: %s", t.Name)
+				}
 			}
-			log.Infof("Successfully deleted Pod: %s", t.Name)
 		}
 	}
 	return nil

pkg/transformer/utils.go

@@ -37,6 +37,7 @@ import (
 )
 
 const letterBytes = "abcdefghijklmnopqrstuvwxyz0123456789"
+const Selector = "io.kompose.service"
 
 // RandStringBytes generates randomly n-character string
 func RandStringBytes(n int) string {
@@ -116,7 +117,7 @@ func isPath(substring string) bool {
 
 // ConfigLabels configures label
 func ConfigLabels(name string) map[string]string {
-	return map[string]string{"service": name}
+	return map[string]string{Selector: name}
 }
 
 // ConfigAnnotations configures annotations