implement methods to handle namespace create and delete

ashish-amarnath · ashish-amarnath · commit 6f3b1244ac51 · 2018-08-24T12:57:46.000-07:00
diff --git a/clusterctl/clusterdeployer/BUILD.bazel b/clusterctl/clusterdeployer/BUILD.bazel
@@ -19,6 +19,7 @@ go_library(
         "//pkg/util:go_default_library",
         "//vendor/github.com/golang/glog:go_default_library",
         "//vendor/k8s.io/api/core/v1:go_default_library",
+        "//vendor/k8s.io/apimachinery/pkg/api/errors:go_default_library",
         "//vendor/k8s.io/apimachinery/pkg/apis/meta/v1:go_default_library",
         "//vendor/k8s.io/client-go/kubernetes:go_default_library",
         "//vendor/k8s.io/client-go/tools/clientcmd:go_default_library",
diff --git a/clusterctl/clusterdeployer/clusterclient.go b/clusterctl/clusterdeployer/clusterclient.go
@@ -25,6 +25,7 @@ import (
 	"time"
 
 	apiv1 "k8s.io/api/core/v1"
+	apierrors "k8s.io/apimachinery/pkg/api/errors"
 	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
 	tcmd "k8s.io/client-go/tools/clientcmd"
 	clusterv1 "sigs.k8s.io/cluster-api/pkg/apis/cluster/v1alpha1"
@@ -73,6 +74,37 @@ func (c *clusterClient) removeKubeconfigFile() error {
 	return os.Remove(c.kubeconfigFile)
 }
 
+func (c *clusterClient) EnsureNamespace(namespaceName string) error {
+	clientset, err := clientcmd.NewCoreClientSetForKubeconfig(c.kubeconfigFile)
+	if err != nil {
+		return fmt.Errorf("error creating core clientset: %v", err)
+	}
+
+	namespace := apiv1.Namespace{
+		ObjectMeta: metav1.ObjectMeta{
+			Name: namespaceName,
+		},
+	}
+	_, err = clientset.CoreV1().Namespaces().Create(&namespace)
+	if err != nil && !apierrors.IsAlreadyExists(err) {
+		return err
+	}
+	return nil
+}
+
+func (c *clusterClient) DeleteNamespace(namespaceName string) error {
+	clientset, err := clientcmd.NewCoreClientSetForKubeconfig(c.kubeconfigFile)
+	if err != nil {
+		return fmt.Errorf("error creating core clientset: %v", err)
+	}
+
+	err = clientset.CoreV1().Namespaces().Delete(namespaceName, &metav1.DeleteOptions{})
+	if err != nil && !apierrors.IsNotFound(err) {
+		return err
+	}
+	return nil
+}
+
 // NewClusterClientFromDefaultSearchPath creates and returns the address of a clusterClient, the kubeconfigFile argument is expected to be the path to a
 // valid kubeconfig file.
 func NewClusterClientFromDefaultSearchPath(kubeconfigFile string, overrides tcmd.ConfigOverrides) (*clusterClient, error) {
@@ -197,7 +229,7 @@ func (c *clusterClient) GetMachineObjects() ([]*clusterv1.Machine, error) {
 }
 
 func (c *clusterClient) CreateClusterObject(cluster *clusterv1.Cluster) error {
-	namespace := c.configOverrides.Context.Namespace
+	namespace := c.GetContextNamespace()
 	if cluster.Namespace != "" {
 		namespace = cluster.Namespace
 	}
diff --git a/clusterctl/clusterdeployer/clusterdeployer.go b/clusterctl/clusterdeployer/clusterdeployer.go
@@ -76,6 +76,8 @@ type ClusterClient interface {
 	DeleteMachineObjectsInNamespace(string) error
 	DeleteMachineObjects() error
 	UpdateClusterObjectEndpoint(string, string, string) error
+	EnsureNamespace(string) error
+	DeleteNamespace(string) error
 	Close() error
 }
 
@@ -140,7 +142,11 @@ func (d *ClusterDeployer) Create(cluster *clusterv1.Cluster, machines []*cluster
 	if cluster.Namespace == "" {
 		cluster.Namespace = bootstrapClient.GetContextNamespace()
 	}
-	// TODO: @ashisha Create cluster.Namespace in bootstrap and target clusters?
+
+	err = bootstrapClient.EnsureNamespace(cluster.Namespace)
+	if err != nil {
+		return fmt.Errorf("unable to ensure namespace %q in bootstrap cluster: %v", cluster.Namespace, err)
+	}
 
 	glog.Info("Applying Cluster API stack to bootstrap cluster")
 	if err := d.applyClusterAPIStack(bootstrapClient, cluster.Namespace); err != nil {
@@ -165,7 +171,7 @@ func (d *ClusterDeployer) Create(cluster *clusterv1.Cluster, machines []*cluster
 	}
 
 	glog.Info("Creating target cluster")
-	targetClient, err := d.createTargetCluster(bootstrapClient, provider, kubeconfigOutput, cluster.Name, cluster.Namespace)
+	targetClient, err := d.createTargetClusterClient(bootstrapClient, provider, kubeconfigOutput, cluster.Name, cluster.Namespace)
 	if err != nil {
 		return fmt.Errorf("unable to create target cluster: %v", err)
 	}
@@ -182,6 +188,11 @@ func (d *ClusterDeployer) Create(cluster *clusterv1.Cluster, machines []*cluster
 		return fmt.Errorf("unable to save provider components to target cluster: %v", err)
 	}
 
+	err = targetClient.EnsureNamespace(cluster.Namespace)
+	if err != nil {
+		return fmt.Errorf("unable to ensure namespace %q in targetCluster: %v", cluster.Namespace, err)
+	}
+
 	// For some reason, endpoint doesn't get updated in bootstrap cluster sometimes. So we
 	// update the target cluster endpoint as well to be sure.
 	glog.Infof("Updating target cluster object with master (%s) endpoint", master.Name)
@@ -235,6 +246,7 @@ func (d *ClusterDeployer) Delete(targetClient ClusterClient, namespace string) e
 	if err = deleteObjectsInNamespace(bootstrapClient, namespace); err != nil {
 		return fmt.Errorf("unable to finish deleting objects in bootstrap cluster, resources may have been leaked: %v", err)
 	}
+
 	glog.Info("Deletion of cluster complete")
 
 	return nil
@@ -265,7 +277,7 @@ func (d *ClusterDeployer) createBootstrapCluster() (ClusterClient, func(), error
 	return bootstrapClient, cleanupFn, nil
 }
 
-func (d *ClusterDeployer) createTargetCluster(bootstrapClient ClusterClient, provider ProviderDeployer, kubeconfigOutput, clusterName, namespace string) (ClusterClient, error) {
+func (d *ClusterDeployer) createTargetClusterClient(bootstrapClient ClusterClient, provider ProviderDeployer, kubeconfigOutput, clusterName, namespace string) (ClusterClient, error) {
 	cluster, master, _, err := getClusterAPIObject(bootstrapClient, clusterName, namespace)
 	if err != nil {
 		return nil, err
@@ -470,26 +482,31 @@ func pivotNamespace(from, to ClusterClient, namespace string) error {
 
 func deleteObjectsInNamespace(client ClusterClient, namespace string) error {
 	var errors []string
-	glog.Infof("Deleting machine deployments")
+	glog.Infof("Deleting machine deployments in namespace %q", namespace)
 	if err := client.DeleteMachineDeploymentObjectsInNamespace(namespace); err != nil {
 		err = fmt.Errorf("error deleting machine deployments: %v", err)
 		errors = append(errors, err.Error())
 	}
-	glog.Infof("Deleting machine sets")
+	glog.Infof("Deleting machine sets in namespace %q", namespace)
 	if err := client.DeleteMachineSetObjectsInNamespace(namespace); err != nil {
 		err = fmt.Errorf("error deleting machine sets: %v", err)
 		errors = append(errors, err.Error())
 	}
-	glog.Infof("Deleting machines")
+	glog.Infof("Deleting machines in namespace %q", namespace)
 	if err := client.DeleteMachineObjectsInNamespace(namespace); err != nil {
 		err = fmt.Errorf("error deleting machines: %v", err)
 		errors = append(errors, err.Error())
 	}
-	glog.Infof("Deleting clusters")
+	glog.Infof("Deleting clusters in namespace %q", namespace)
 	if err := client.DeleteClusterObjectsInNamespace(namespace); err != nil {
 		err = fmt.Errorf("error deleting clusters: %v", err)
 		errors = append(errors, err.Error())
 	}
+	glog.Infof("Deleting namespace %q", namespace)
+	if err := client.DeleteNamespace(namespace); err != nil {
+		err = fmt.Errorf("error deleting namespace: %v", err)
+		errors = append(errors, err.Error())
+	}
 	if len(errors) > 0 {
 		return fmt.Errorf("error(s) encountered deleting objects from bootstrap cluster: [%v]", strings.Join(errors, ", "))
 	}
diff --git a/clusterctl/clusterdeployer/clusterdeployer_test.go b/clusterctl/clusterdeployer/clusterdeployer_test.go
@@ -108,12 +108,15 @@ type testClusterClient struct {
 	DeleteMachineDeploymentsObjectsErr            error
 	DeleteMachineDeploymentsObjectsInNamespaceErr error
 	UpdateClusterObjectEndpointErr                error
+	EnsureNamespaceErr                            error
+	DeleteNamespaceErr                            error
 	CloseErr                                      error
 
 	clusters           map[string][]*clusterv1.Cluster
 	machineDeployments map[string][]*clusterv1.MachineDeployment
 	machineSets        map[string][]*clusterv1.MachineSet
 	machines           map[string][]*clusterv1.Machine
+	namespaces         []string
 	contextNamespace   string
 }
 
@@ -280,6 +283,40 @@ func (c *testClusterClient) Close() error {
 	return c.CloseErr
 }
 
+func (c *testClusterClient) EnsureNamespace(nsName string) error {
+	if len(c.namespaces) == 0 {
+		c.namespaces = append(c.namespaces, nsName)
+	}
+	if exists := contains(c.namespaces, nsName); !exists {
+		c.namespaces = append(c.namespaces, nsName)
+	}
+	return c.EnsureNamespaceErr
+}
+
+func (c *testClusterClient) DeleteNamespace(namespaceName string) error {
+	var ns []string
+	for _, n := range c.namespaces {
+		if n == namespaceName {
+			continue
+		}
+		ns = append(ns, n)
+	}
+	c.namespaces = ns
+
+	return c.DeleteNamespaceErr
+}
+
+func contains(s []string, e string) bool {
+	exists := false
+	for _, existingNs := range s {
+		if existingNs == e {
+			exists = true
+			break
+		}
+	}
+	return exists
+}
+
 type testClusterClientFactory struct {
 	ClusterClientErr    error
 	clusterClients      map[string]*testClusterClient
@@ -401,6 +438,28 @@ func TestClusterCreate(t *testing.T) {
 			},
 			expectedTotalInternalClustersCount: 1,
 		},
+		{
+			name:                                "fail ensureNamespace in bootstrap cluster",
+			targetClient:                        &testClusterClient{},
+			bootstrapClient:                     &testClusterClient{EnsureNamespaceErr: fmt.Errorf("Test failure")},
+			namespaceToExpectedInternalMachines: make(map[string]int),
+			namespaceToInputCluster:             map[string][]*clusterv1.Cluster{"foo": getClustersForNamespace("foo", 3)},
+			expectErr:                           true,
+			cleanupExternal:                     true,
+			expectExternalExists:                false,
+			expectExternalCreated:               true,
+		},
+		{
+			name:                                "fail ensureNamespace in target cluster",
+			targetClient:                        &testClusterClient{EnsureNamespaceErr: fmt.Errorf("Test failure")},
+			bootstrapClient:                     &testClusterClient{},
+			namespaceToExpectedInternalMachines: make(map[string]int),
+			namespaceToInputCluster:             map[string][]*clusterv1.Cluster{"foo": getClustersForNamespace("foo", 3)},
+			expectErr:                           true,
+			cleanupExternal:                     true,
+			expectExternalExists:                false,
+			expectExternalCreated:               true,
+		},
 		{
 			name:                                "fail provision multiple clusters in a namespace",
 			targetClient:                        &testClusterClient{},
@@ -564,7 +623,6 @@ func TestClusterCreate(t *testing.T) {
 	}
 
 	for _, testcase := range testcases {
-
 		t.Run(testcase.name, func(t *testing.T) {
 			kubeconfigOut := newTempFile(t)
 			defer os.Remove(kubeconfigOut)
@@ -637,6 +695,14 @@ func TestClusterCreate(t *testing.T) {
 							t.Fatalf("Unexpected machine name at %v in namespace %q. Got: %v, Want: %v", i, ns, inputMachines[i].Name, testcase.targetClient.machines[ns][i].Name)
 						}
 					}
+
+					if !contains(testcase.targetClient.namespaces, ns) {
+						t.Fatalf("Expected namespace %q in target namespace not found. Got: NotFound, Want: Found", ns)
+					}
+
+					if !contains(testcase.bootstrapClient.namespaces, ns) {
+						t.Fatalf("Expected namespace %q in bootstrap namespace not found. Got: NotFound, Want: Found", ns)
+					}
 				}
 				// Validate across all namespaces
 				if len(testcase.targetClient.clusters) != testcase.expectedTotalInternalClustersCount {
@@ -800,7 +866,7 @@ func TestDeleteCleanupExternalCluster(t *testing.T) {
 	}
 }
 
-func TestDeleteClusters(t *testing.T) {
+func TestClusterDelete(t *testing.T) {
 	const bootstrapKubeconfig = "bootstrap"
 	const targetKubeconfig = "target"
 
@@ -1101,10 +1167,15 @@ func TestDeleteClusters(t *testing.T) {
 				if len(testCase.bootstrapClient.machineDeployments[testCase.namespace]) != 0 {
 					t.Fatalf("Unexpected machineDeployments count in namespace %q. Got: %d, Want: 0", testCase.namespace, len(testCase.targetClient.machineDeployments[testCase.namespace]))
 				}
-
 				if len(testCase.bootstrapClient.clusters) != testCase.expectedExternalClusterCount {
 					t.Fatalf("Unexpected remaining cluster count. Got: %d, Want: %d", len(testCase.bootstrapClient.clusters), testCase.expectedExternalClusterCount)
 				}
+				if contains(testCase.bootstrapClient.namespaces, testCase.namespace) {
+					t.Fatalf("Unexpected remaining namespace %q in bootstrap cluster. Got: Found, Want: NotFound", testCase.namespace)
+				}
+				if contains(testCase.targetClient.namespaces, testCase.namespace) {
+					t.Fatalf("Unexpected remaining namespace %q in target cluster. Got: Found, Want: NotFound", testCase.namespace)
+				}
 			}
 		})
 	}
