add output formatter

Signed-off-by: Maskym Vavilov <mvavilov@redhat.com>

Author: maksymvavilov

cmd/plugin/cleanup_old_txt.go

@@ -16,6 +16,7 @@ import (
 	"sigs.k8s.io/external-dns/plan"
 
 	"github.com/kuadrant/dns-operator/cmd/plugin/common"
+	"github.com/kuadrant/dns-operator/cmd/plugin/output"
 	"github.com/kuadrant/dns-operator/internal/common/slice"
 	"github.com/kuadrant/dns-operator/internal/external-dns/registry"
 	"github.com/kuadrant/dns-operator/internal/provider"
@@ -52,7 +53,6 @@ func init() {
 }
 
 func deleteOldTXT(_ *cobra.Command, args []string) error {
-	log = logf.Log.WithName("prune-legacy-txt")
 
 	if cleanupOldTXTCMDFlags.domain == "" {
 		return fmt.Errorf("domain is required")
@@ -80,18 +80,18 @@ func deleteOldTXT(_ *cobra.Command, args []string) error {
 		Name:      secretName,
 	}
 
-	log.Info("obtaining list of endpoints from the provider")
+	output.Formatter.Info("obtaining list of endpoints from the provider")
 	endpointProvider, err := common.GetProviderForConfig(ctx, secretRef, provider.Config{
 		DomainFilter: externaldns.NewRegexDomainFilter(domainRegexp, nil),
 	})
 	if err != nil {
-		log.Error(err, "failed to get provider")
+		output.Formatter.Error(err, "failed to get provider")
 		return err
 	}
 
 	endpoints, err := endpointProvider.Records(ctx)
 	if err != nil {
-		log.Error(err, "failed to get endpoints")
+		output.Formatter.Error(err, "failed to get endpoints")
 		return err
 	}
 
@@ -111,7 +111,7 @@ func deleteOldTXT(_ *cobra.Command, args []string) error {
 			// owner and version in targets
 			owner, epVersion, epLabels, err := registry.NewLabelsFromString(e.Targets[0], []byte{})
 			if err != nil {
-				log.Info(fmt.Sprintf("failed to extract owner labels: %v\n ep name: %s, targets: %s", err, e.DNSName, e.Targets))
+				output.Formatter.Info(fmt.Sprintf("failed to extract owner labels: %v\n ep name: %s, targets: %s", err, e.DNSName, e.Targets))
 				return false
 			}
 
@@ -137,44 +137,44 @@ func deleteOldTXT(_ *cobra.Command, args []string) error {
 	})
 
 	if len(endpoints) == 0 {
-		log.Info("no endpoints to be deleted found")
+		output.Formatter.Info("no endpoints to be deleted found")
 		return nil
 	}
 
 	// display what is about to be deleted
-	log.Info(fmt.Sprintf("TXT records (%d) to be deleted:", len(endpoints)))
+	output.Formatter.Info(fmt.Sprintf("TXT records (%d) to be deleted:", len(endpoints)))
 	for _, txtRecord := range endpoints {
 		logf.Log.Info(fmt.Sprintf("%s\t IN\t %s\t %s", txtRecord.DNSName, txtRecord.RecordType, txtRecord.Targets))
 	}
-	log.Info(fmt.Sprintf("Do you want to proceed? [Y/N]"))
+	output.Formatter.Info(fmt.Sprintf("Do you want to proceed? [Y/N]"))
 	reader := bufio.NewReader(os.Stdin)
 
 	var answer string
 
 	if !cleanupOldTXTCMDFlags.assumeyes {
 		answer, err = reader.ReadString('\n')
 		if err != nil {
-			log.Error(err, "failed to read answer", "answer", answer)
+			output.Formatter.Error(err, fmt.Sprintf("failed to read answer: %s", answer))
 		}
 		answer = strings.TrimSpace(strings.ToLower(answer))
 	}
 
 	if answer == "y" || cleanupOldTXTCMDFlags.assumeyes {
 		//delete
-		log.Info("deleting old TXT records...")
+		output.Formatter.Info("deleting old TXT records...")
 		err = endpointProvider.ApplyChanges(ctx, &plan.Changes{
 			Delete: endpoints,
 		})
 		if err != nil {
-			log.Error(err, "failed to delete old TXT records")
+			output.Formatter.Error(err, "failed to delete old TXT records")
 			return err
 		}
-		log.Info("records are deleted")
+		output.Formatter.Info("records are deleted")
 		return nil
 	}
 
 	// do nothing
-	log.Info("canceling")
+	output.Formatter.Info("canceling")
 	return nil
 
 }

cmd/plugin/common/logging.go

@@ -3,7 +3,7 @@ package main
 import (
 	"github.com/spf13/cobra"
 
-	logf "sigs.k8s.io/controller-runtime/pkg/log"
+	"github.com/kuadrant/dns-operator/cmd/plugin/output"
 )
 
 var removeOwnerCMD = &cobra.Command{
@@ -12,8 +12,6 @@ var removeOwnerCMD = &cobra.Command{
 }
 
 func removeOwner(_ *cobra.Command, _ []string) error {
-	log = logf.Log.WithName("remove-owner")
-
-	log.Info("Deleting owner: TODO")
+	output.Formatter.Info("Deleting owner: TODO")
 	return nil
 }

cmd/plugin/common/pretty.go

@@ -8,7 +8,6 @@ import (
 	"strings"
 	"time"
 
-	"github.com/go-logr/logr"
 	"github.com/spf13/cobra"
 
 	corev1 "k8s.io/api/core/v1"
@@ -17,11 +16,11 @@ import (
 	"k8s.io/client-go/kubernetes/scheme"
 	controllerruntime "sigs.k8s.io/controller-runtime"
 	"sigs.k8s.io/controller-runtime/pkg/client"
-	logf "sigs.k8s.io/controller-runtime/pkg/log"
 	externaldns "sigs.k8s.io/external-dns/endpoint"
 
 	"github.com/kuadrant/dns-operator/api/v1alpha1"
 	"github.com/kuadrant/dns-operator/cmd/plugin/common"
+	"github.com/kuadrant/dns-operator/cmd/plugin/output"
 	"github.com/kuadrant/dns-operator/internal/common/slice"
 	"github.com/kuadrant/dns-operator/internal/provider"
 	"github.com/kuadrant/dns-operator/internal/provider/endpoint"
@@ -87,86 +86,84 @@ func init() {
 }
 
 func listZoneRecords(_ *cobra.Command, _ []string) error {
-	log = logf.Log.WithName("list-records")
-
 	d := time.Now().Add(time.Minute * 5)
 	ctx, cancel := context.WithDeadline(context.Background(), d)
 	defer cancel()
 
-	log.V(1).Info("Getting zone records", "name", name, "namespace", namespace, "resourceType", resourceType, "providerRef", providerRef)
+	output.Formatter.Debug(fmt.Sprintf("Getting zone records; Name: %s; Namespace: %s; resourceType: %s; providerRef: %s", name, namespace, resourceType, providerRef))
 
 	runtime.Must(v1alpha1.AddToScheme(scheme.Scheme))
 	config := controllerruntime.GetConfigOrDie()
 	k8sClient, err := client.New(config, client.Options{Scheme: scheme.Scheme})
 	if err != nil {
-		log.Error(err, "failed to create client")
+		output.Formatter.Error(err, "failed to create client")
 		return err
 	}
 
 	dynClient, err := dynamic.NewForConfig(config)
 	if err != nil {
-		log.Error(err, "failed to create dynamic client")
+		output.Formatter.Error(err, "failed to create dynamic client")
 		return err
 	}
 
 	switch strings.ToLower(resourceType) {
 	case host:
-		return hostWorkFlow(ctx, log, k8sClient, dynClient)
+		return hostWorkFlow(ctx, k8sClient, dynClient)
 	case DNSRecord:
-		return dnsRecordWorkFlow(ctx, log, k8sClient, dynClient)
+		return dnsRecordWorkFlow(ctx, k8sClient, dynClient)
 	default:
 		return fmt.Errorf("no workflow found for type: %s, this should be set to one of host of dnsrecord", resourceType)
 	}
 }
 
-func hostWorkFlow(ctx context.Context, log logr.Logger, k8sClient client.Client, dynClient *dynamic.DynamicClient) error {
-	log.V(1).Info("Get secret from cluster based on the providerRef.")
+func hostWorkFlow(ctx context.Context, k8sClient client.Client, dynClient *dynamic.DynamicClient) error {
+	output.Formatter.Debug("Get secret from cluster based on the providerRef.")
 	secretRef, err := common.ParseProviderRef(providerRef)
 	if err != nil {
 		return err
 	}
 
-	log.V(1).Info("secretRef", "name", secretRef.Name, "namespace", secretRef.Namespace)
+	output.Formatter.Debug(fmt.Sprintf("secretRef; name: %s; namespace: %s", secretRef.Name, secretRef.Namespace))
 
 	secret := &corev1.Secret{}
 	err = k8sClient.Get(ctx, client.ObjectKey{Name: secretRef.Name, Namespace: secretRef.Namespace}, secret)
 	if err != nil {
-		log.Error(err, "failed to get secret")
+		output.Formatter.Error(err, "failed to get secret")
 		return err
 	}
 
-	log.V(1).Info("found secret", "secret", secret)
+	output.Formatter.Debug(fmt.Sprintf("found secret: %s", secret))
 
-	p, err := getProviderFromSecret(ctx, log, k8sClient, dynClient, secret, name)
+	p, err := getProviderFromSecret(ctx, k8sClient, dynClient, secret, name)
 	if err != nil {
-		log.Error(err, "unable to get configure provider")
+		output.Formatter.Error(err, "unable to get configure provider")
 		return err
 	}
 
 	endpoints, err := getEndpoints(ctx, p, name)
 	if err != nil {
-		log.Error(err, "unable to get endpoints from provider")
+		output.Formatter.Error(err, "unable to get endpoints from provider")
 		return err
 	}
 
-	common.RenderEndpoints(endpoints)
+	output.Formatter.RenderEndpoints(endpoints)
 
 	return err
 }
 
-func dnsRecordWorkFlow(ctx context.Context, log logr.Logger, k8sClient client.Client, dynClient *dynamic.DynamicClient) error {
-	log.V(1).Info("Get DNSRecord from the cluster based on the name and namespace provided")
+func dnsRecordWorkFlow(ctx context.Context, k8sClient client.Client, dynClient *dynamic.DynamicClient) error {
+	output.Formatter.Debug("Get DNSRecord from the cluster based on the name and namespace provided")
 	dnsRecord := &v1alpha1.DNSRecord{}
 	err := k8sClient.Get(ctx, client.ObjectKey{Namespace: namespace, Name: name}, dnsRecord)
 	if err != nil {
-		log.Error(err, "Unable to get DNSRecord", "DNSRecord", name)
+		output.Formatter.Error(err, fmt.Sprintf("Unable to get DNSRecord; DNSREcord name: %s", name))
 		return err
 	}
 
 	// get the provider factory
 	providerFactory, err := provider.NewFactory(k8sClient, dynClient, provider.RegisteredDefaultProviders(), endpoint.NewAuthoritativeDNSRecordProvider)
 	if err != nil {
-		log.Error(err, "failed to create provider factory")
+		output.Formatter.Error(err, "failed to create provider factory")
 		return err
 	}
 
@@ -175,52 +172,52 @@ func dnsRecordWorkFlow(ctx context.Context, log logr.Logger, k8sClient client.Cl
 	_, zoneHost, found := strings.Cut(dnsRecord.GetRootHost(), ".")
 	if !found {
 		err = errors.New("invalid dns record hostname: " + dnsRecord.GetRootHost())
-		log.Error(err, "failed to prepare zone filter regexp")
+		output.Formatter.Error(err, "failed to prepare zone filter regexp")
 		return err
 	}
 
 	p, err := providerFactory.ProviderFor(ctx, dnsRecord, provider.Config{
 		DomainFilter: externaldns.NewDomainFilter([]string{zoneHost}),
 	})
 	if err != nil {
-		log.Error(err, "unable to get configure provider")
+		output.Formatter.Error(err, "unable to get configure provider")
 		return err
 	}
 
 	endpoints, err := getEndpoints(ctx, p, dnsRecord.GetRootHost())
 	if err != nil {
-		log.Error(err, "unable to get endpoints from provider")
+		output.Formatter.Error(err, "unable to get endpoints from provider")
 		return err
 	}
 
-	common.RenderEndpoints(endpoints)
+	output.Formatter.RenderEndpoints(endpoints)
 
 	return err
 }
 
-func getProviderFromSecret(ctx context.Context, log logr.Logger, k8sClient client.Client, dynClient *dynamic.DynamicClient, secret *corev1.Secret, host string) (provider.Provider, error) {
+func getProviderFromSecret(ctx context.Context, k8sClient client.Client, dynClient *dynamic.DynamicClient, secret *corev1.Secret, host string) (provider.Provider, error) {
 	if secret == nil {
 		err := errors.New("secret can not be nil")
 
-		log.Error(err, "please check configuration")
+		output.Formatter.Error(err, "please check configuration")
 		return nil, err
 	}
 
-	log.V(1).Info("secret passed", "secret", secret)
+	output.Formatter.Debug(fmt.Sprintf("secret passed: %s", secret))
 
 	providerFactory, err := provider.NewFactory(k8sClient, dynClient, provider.RegisteredDefaultProviders(), endpoint.NewAuthoritativeDNSRecordProvider)
 	if err != nil {
-		log.Error(err, "failed to create provider factory")
+		output.Formatter.Error(err, "failed to create provider factory")
 		return nil, err
 	}
 
 	// empty config to list all records
-	log.V(1).Info("obtaining list of endpoints from the provider")
+	output.Formatter.Debug("obtaining list of endpoints from the provider")
 	endpointProvider, err := providerFactory.ProviderForSecret(ctx, secret, provider.Config{
 		DomainFilter: externaldns.NewDomainFilter([]string{host}),
 	})
 	if err != nil {
-		log.Error(err, "failed to get provider")
+		output.Formatter.Error(err, "failed to get provider")
 		return nil, err
 	}
 
@@ -229,11 +226,11 @@ func getProviderFromSecret(ctx context.Context, log logr.Logger, k8sClient clien
 }
 
 func getEndpoints(ctx context.Context, p provider.Provider, rootHost string) ([]*externaldns.Endpoint, error) {
-	log.V(1).Info("get records from provider", "provider.name", p.Name(), "roothost", rootHost)
+	output.Formatter.Debug(fmt.Sprintf("get records from provider; provider.name: %s; rootHost: %s", p.Name(), rootHost))
 
 	endpoints, err := p.Records(ctx)
 	if err != nil {
-		log.Error(err, "unable to get records from provider")
+		output.Formatter.Error(err, "unable to get records from provider")
 		return nil, err
 	}