Fix non-working CoreDNS patch on AKS

cmd/cleanup/cleanup.go

@@ -23,21 +23,21 @@ func NewCmd(cConfig *cmd.CleanupConfiguration, loaders []cli.ResourceLoader) *cl
 }
 
 func cleanupCommand(cConfig *cmd.CleanupConfiguration) error {
-	log, err := cmd.NewLogger(cConfig.LogFormat, cConfig.LogLevel, false)
+	logger, err := cmd.NewLogger(cConfig.LogFormat, cConfig.LogLevel, false)
 	if err != nil {
 		return fmt.Errorf("could not create logger: %w", err)
 	}
 
-	log.Debug("Starting maesh cleanup...")
-	log.Debugf("Using masterURL: %q", cConfig.MasterURL)
-	log.Debugf("Using kubeconfig: %q", cConfig.KubeConfig)
+	logger.Debug("Starting maesh cleanup...")
+	logger.Debugf("Using masterURL: %q", cConfig.MasterURL)
+	logger.Debugf("Using kubeconfig: %q", cConfig.KubeConfig)
 
-	clients, err := k8s.NewClient(log, cConfig.MasterURL, cConfig.KubeConfig)
+	clients, err := k8s.NewClient(logger, cConfig.MasterURL, cConfig.KubeConfig)
 	if err != nil {
 		return fmt.Errorf("error building clients: %w", err)
 	}
 
-	c := cleanup.NewCleanup(log, clients, cConfig.Namespace)
+	c := cleanup.NewCleanup(logger, clients.KubernetesClient(), cConfig.Namespace)
 
 	if err := c.CleanShadowServices(); err != nil {
 		return fmt.Errorf("error encountered during cluster cleanup: %w", err)

pkg/cleanup/cleanup.go

@@ -4,42 +4,42 @@ import (
 	"fmt"
 
 	"github.com/containous/maesh/pkg/dns"
-	"github.com/containous/maesh/pkg/k8s"
 	"github.com/sirupsen/logrus"
 	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
+	"k8s.io/client-go/kubernetes"
 )
 
 // Cleanup holds the clients for the various resource controllers.
 type Cleanup struct {
-	client    k8s.Client
-	log       logrus.FieldLogger
-	namespace string
-	dns       *dns.Client
+	namespace  string
+	kubeClient kubernetes.Interface
+	dnsClient  *dns.Client
+	logger     logrus.FieldLogger
 }
 
 // NewCleanup returns an initialized cleanup object.
-func NewCleanup(log logrus.FieldLogger, client k8s.Client, namespace string) *Cleanup {
-	dns := dns.NewClient(log, client)
+func NewCleanup(logger logrus.FieldLogger, kubeClient kubernetes.Interface, namespace string) *Cleanup {
+	dnsClient := dns.NewClient(logger, kubeClient)
 
 	return &Cleanup{
-		client:    client,
-		log:       log,
-		namespace: namespace,
-		dns:       dns,
+		kubeClient: kubeClient,
+		logger:     logger,
+		namespace:  namespace,
+		dnsClient:  dnsClient,
 	}
 }
 
 // CleanShadowServices deletes all shadow services from the cluster.
 func (c *Cleanup) CleanShadowServices() error {
-	serviceList, err := c.client.KubernetesClient().CoreV1().Services(c.namespace).List(metav1.ListOptions{
+	serviceList, err := c.kubeClient.CoreV1().Services(c.namespace).List(metav1.ListOptions{
 		LabelSelector: "app=maesh,type=shadow",
 	})
 	if err != nil {
 		return err
 	}
 
 	for _, s := range serviceList.Items {
-		if err := c.client.KubernetesClient().CoreV1().Services(s.Namespace).Delete(s.Name, &metav1.DeleteOptions{}); err != nil {
+		if err := c.kubeClient.CoreV1().Services(s.Namespace).Delete(s.Name, &metav1.DeleteOptions{}); err != nil {
 			return err
 		}
 	}
@@ -49,19 +49,19 @@ func (c *Cleanup) CleanShadowServices() error {
 
 // RestoreDNSConfig restores the configmap and restarts the DNS pods.
 func (c *Cleanup) RestoreDNSConfig() error {
-	provider, err := c.dns.CheckDNSProvider()
+	provider, err := c.dnsClient.CheckDNSProvider()
 	if err != nil {
 		return err
 	}
 
 	// Restore configmaps based on DNS provider.
 	switch provider {
 	case dns.CoreDNS:
-		if err := c.dns.RestoreCoreDNS(); err != nil {
+		if err := c.dnsClient.RestoreCoreDNS(); err != nil {
 			return fmt.Errorf("unable to restore CoreDNS: %w", err)
 		}
 	case dns.KubeDNS:
-		if err := c.dns.RestoreKubeDNS(); err != nil {
+		if err := c.dnsClient.RestoreKubeDNS(); err != nil {
 			return fmt.Errorf("unable to restore KubeDNS: %w", err)
 		}
 	}

pkg/cleanup/cleanup_test.go

@@ -8,6 +8,7 @@ import (
 	"github.com/containous/maesh/pkg/k8s"
 	"github.com/sirupsen/logrus"
 	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
 	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
 )
 
@@ -16,38 +17,38 @@ func TestCleanup_New(t *testing.T) {
 	defer cancel()
 
 	clientMock := k8s.NewClientMock(t, ctx.Done(), "mock.yaml", false)
-	log := logrus.New()
+	logger := logrus.New()
 
-	log.SetOutput(os.Stdout)
-	log.SetLevel(logrus.DebugLevel)
+	logger.SetOutput(os.Stdout)
+	logger.SetLevel(logrus.DebugLevel)
 
-	cln := NewCleanup(log, clientMock, metav1.NamespaceDefault)
-	assert.NotNil(t, cln)
+	cleanup := NewCleanup(logger, clientMock.KubernetesClient(), metav1.NamespaceDefault)
+	require.NotNil(t, cleanup)
 }
 
 func TestCleanup_CleanShadowServices(t *testing.T) {
 	ctx, cancel := context.WithCancel(context.Background())
 	defer cancel()
 
 	clientMock := k8s.NewClientMock(t, ctx.Done(), "mock.yaml", false)
-	log := logrus.New()
+	logger := logrus.New()
 
-	log.SetOutput(os.Stdout)
-	log.SetLevel(logrus.DebugLevel)
+	logger.SetOutput(os.Stdout)
+	logger.SetLevel(logrus.DebugLevel)
 
-	cln := NewCleanup(log, clientMock, "maesh")
-	assert.NotNil(t, cln)
+	cleanup := NewCleanup(logger, clientMock.KubernetesClient(), "maesh")
+	require.NotNil(t, cleanup)
 
-	err := cln.CleanShadowServices()
-	assert.NoError(t, err)
+	err := cleanup.CleanShadowServices()
+	require.NoError(t, err)
 
-	sl, err := clientMock.KubernetesClient().CoreV1().Services(metav1.NamespaceAll).List(metav1.ListOptions{
+	serviceList, err := clientMock.KubernetesClient().CoreV1().Services(metav1.NamespaceAll).List(metav1.ListOptions{
 		LabelSelector: "app=maesh,type=shadow",
 	})
-	assert.NoError(t, err)
-	assert.Len(t, sl.Items, 0)
+	require.NoError(t, err)
+	assert.Len(t, serviceList.Items, 0)
 
-	srv, err := clientMock.KubernetesClient().CoreV1().Services(metav1.NamespaceAll).List(metav1.ListOptions{})
-	assert.NoError(t, err)
-	assert.Len(t, srv.Items, 2)
+	serviceList, err = clientMock.KubernetesClient().CoreV1().Services(metav1.NamespaceAll).List(metav1.ListOptions{})
+	require.NoError(t, err)
+	assert.Len(t, serviceList.Items, 2)
 }