chore: refactor logic to use additional flags

Author: wtrocki

cmd/rhoas/pkged.go

@@ -1,5 +1,5 @@
 [cluster.serviceBinding.namespaceInfo]
-one = '"Namespace not provided. Using {{.Namespace}} namespace'
+one = 'Namespace not provided. Using {{.Namespace}} namespace'
 
 [cluster.serviceBinding.confirm.message]
 one = 'Do you want to continue?'

docs/commands/rhoas_cluster_bind.adoc

@@ -29,8 +29,13 @@ $ rhoas cluster bind --namespace=ns --app-name=myapp
 [cluster.bind.flag.appName]
 one = '''Name of the kubernetes deployment to bind'''
 
-[cluster.bind.flag.onlyOperator.description]
+[cluster.bind.flag.forceOperator.description]
 one = '''Use ServiceBindingOperator only and fail if Operator is not installed'''
 
+[cluster.bind.flag.forceSDK.description]
+one = '''Use Service Binding SDK and skip ServiceBindingOperator even if installed on the cluster'''
+
+
+
 [cluster.bind.error.emptyResponse]
 one = '''Server returned empty response for service'''

locales/cluster/bind/active.en.toml

@@ -2,27 +2,26 @@ package cluster
 
 import (
 	"context"
+	"crypto/rand"
 	"errors"
 	"fmt"
 	"github.com/AlecAivazis/survey/v2"
+	"github.com/redhat-developer/app-services-cli/internal/localizer"
 	"github.com/redhat-developer/app-services-cli/pkg/color"
 	"github.com/redhat-developer/app-services-cli/pkg/logging"
+	"github.com/redhat-developer/service-binding-operator/api/v1alpha1"
+	"github.com/redhat-developer/service-binding-operator/pkg/reconcile/pipeline/builder"
 	sboContext "github.com/redhat-developer/service-binding-operator/pkg/reconcile/pipeline/context"
+	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
 	"k8s.io/apimachinery/pkg/apis/meta/v1/unstructured"
 	"k8s.io/apimachinery/pkg/runtime"
+	"k8s.io/apimachinery/pkg/runtime/schema"
+	"k8s.io/client-go/dynamic"
 	"k8s.io/client-go/rest"
+	"k8s.io/client-go/tools/clientcmd"
 	clientcmdapi "k8s.io/client-go/tools/clientcmd/api"
 	"os"
 	"path/filepath"
-	"time"
-
-	"github.com/redhat-developer/app-services-cli/internal/localizer"
-	"github.com/redhat-developer/service-binding-operator/api/v1alpha1"
-	"github.com/redhat-developer/service-binding-operator/pkg/reconcile/pipeline/builder"
-	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
-	"k8s.io/apimachinery/pkg/runtime/schema"
-	"k8s.io/client-go/dynamic"
-	"k8s.io/client-go/tools/clientcmd"
 	"sigs.k8s.io/controller-runtime/pkg/client/apiutil"
 )
 
@@ -34,20 +33,28 @@ type KubernetesClients struct {
 
 var deploymentResource = schema.GroupVersionResource{Group: "apps", Version: "v1", Resource: "deployments"}
 
-// TODO extract arguments
-func ExecuteServiceBinding(logger logging.Logger, serviceName string, ns string, appName string,
-	forceCreationWithoutAsk bool, forceUseOperator bool) error {
+type ServiceBindingOptions struct {
+	ServiceName             string
+	Namespace               string
+	AppName                 string
+	ForceCreationWithoutAsk bool
+	ForceUseOperator        bool
+	ForceUseSDK             bool
+	BindingName             string
+}
+
+func ExecuteServiceBinding(logger logging.Logger, options *ServiceBindingOptions) error {
 	clients, err := client()
 	if err != nil {
 		return err
 	}
-
+	ns := options.Namespace
 	if ns == "" {
 		ns, _, err = (*clients.clientConfig).Namespace()
 		if err != nil {
 			return err
 		}
-		logger.Info(&localizer.Config{
+		logger.Info(localizer.Config{
 			MessageID: "cluster.serviceBinding.namespaceInfo",
 			TemplateData: map[string]interface{}{
 				"Namespace": color.Info(ns),
@@ -56,22 +63,22 @@ func ExecuteServiceBinding(logger logging.Logger, serviceName string, ns string,
 	}
 
 	// Get proper deployment
-	if appName == "" {
-		appName, err = fetchAppNameFromCluster(clients, ns)
+	if options.AppName == "" {
+		options.AppName, err = fetchAppNameFromCluster(clients, ns)
 		if err != nil {
 			return err
 		}
 	} else {
-		_, err = clients.dynamicClient.Resource(deploymentResource).Namespace(ns).Get(context.TODO(), appName, metav1.GetOptions{})
+		_, err = clients.dynamicClient.Resource(deploymentResource).Namespace(ns).Get(context.TODO(), options.AppName, metav1.GetOptions{})
 		if err != nil {
 			return err
 		}
 	}
 
 	// Print desired action
-	logger.Info(fmt.Sprintf(localizer.MustLocalizeFromID("cluster.serviceBinding.status.message"), serviceName, appName))
+	logger.Info(fmt.Sprintf(localizer.MustLocalizeFromID("cluster.serviceBinding.status.message"), options.ServiceName, options.AppName))
 
-	if !forceCreationWithoutAsk {
+	if !options.ForceCreationWithoutAsk {
 		var shouldContinue bool
 		confirm := &survey.Confirm{
 			Message: localizer.MustLocalizeFromID("cluster.serviceBinding.confirm.message"),
@@ -87,30 +94,29 @@ func ExecuteServiceBinding(logger logging.Logger, serviceName string, ns string,
 	}
 
 	// Check KafkaConnection
-	_, err = clients.dynamicClient.Resource(AKCResource).Namespace(ns).Get(context.TODO(), serviceName, metav1.GetOptions{})
+	_, err = clients.dynamicClient.Resource(AKCResource).Namespace(ns).Get(context.TODO(), options.ServiceName, metav1.GetOptions{})
 	if err != nil {
 		return errors.New(localizer.MustLocalizeFromID("cluster.serviceBinding.serviceMissing.message"))
 	}
 
 	// Execute binding
-	err = performBinding(serviceName, appName, ns, clients, forceUseOperator, logger)
+	err = performBinding(options, ns, clients, logger)
 	if err != nil {
 		return err
 	}
 
-	logger.Info(fmt.Sprintf(localizer.MustLocalizeFromID("cluster.serviceBinding.bindingSuccess"), serviceName, appName))
+	logger.Info(fmt.Sprintf(localizer.MustLocalizeFromID("cluster.serviceBinding.bindingSuccess"), options.ServiceName, options.AppName))
 	return nil
 }
 
-func performBinding(serviceName string, appName string, ns string, clients *KubernetesClients,
-	forceUseOperator bool, logger logging.Logger) error {
+func performBinding(options *ServiceBindingOptions, ns string, clients *KubernetesClients, logger logging.Logger) error {
 	serviceRef := v1alpha1.Service{
 		NamespacedRef: v1alpha1.NamespacedRef{
 			Ref: v1alpha1.Ref{
 				Group:    AKCResource.Group,
 				Version:  AKCResource.Version,
 				Resource: AKCResource.Resource,
-				Name:     serviceName,
+				Name:     options.ServiceName,
 			},
 		},
 	}
@@ -120,15 +126,23 @@ func performBinding(serviceName string, appName string, ns string, clients *Kube
 			Group:    deploymentResource.Group,
 			Version:  deploymentResource.Version,
 			Resource: deploymentResource.Resource,
-			Name:     appName,
+			Name:     options.AppName,
 		},
 	}
 
-	now := time.Now()
+	if options.BindingName == "" {
+		randomValue := make([]byte, 4)
+		_, err := rand.Read(randomValue)
+		if err != nil {
+			return err
+		}
+		options.BindingName = fmt.Sprintf("%v-%x", options.ServiceName, randomValue)
+	}
+
 	sb := &v1alpha1.ServiceBinding{
 		ObjectMeta: metav1.ObjectMeta{
-			Name:      fmt.Sprintf("%v-%v", serviceName, now.Unix()),
-			Namespace: ns,
+			Name:      fmt.Sprintf("%v-%v", options.ServiceName, options.BindingName),
+			Namespace: options.Namespace,
 		},
 		Spec: v1alpha1.ServiceBindingSpec{
 			BindAsFiles: true,
@@ -138,26 +152,42 @@ func performBinding(serviceName string, appName string, ns string, clients *Kube
 	}
 	sb.SetGroupVersionKind(v1alpha1.GroupVersionKind)
 
+	if options.ForceUseSDK {
+		return useSDKForBinding(clients, sb)
+	}
+
 	// Check of operator is installed
 	_, err := clients.dynamicClient.Resource(v1alpha1.GroupVersionResource).Namespace(ns).
 		List(context.TODO(), metav1.ListOptions{Limit: 1})
 
 	if err != nil {
-		if forceUseOperator {
+		if options.ForceUseOperator {
 			return errors.New(localizer.MustLocalizeFromID("cluster.serviceBinding.operatorMissing") + err.Error())
 		}
-		logger.Debug("Service binding Operator not available. Will use SDK")
-	} else {
-		logger.Info(localizer.MustLocalizeFromID("cluster.serviceBinding.usingOperator"))
-		sbData, err := runtime.DefaultUnstructuredConverter.ToUnstructured(sb)
-		unstructuredSB := unstructured.Unstructured{Object: sbData}
-		_, err = clients.dynamicClient.Resource(v1alpha1.GroupVersionResource).Namespace(ns).
-			Create(context.TODO(), &unstructuredSB, metav1.CreateOptions{})
+		logger.Debug("Service binding Operator not available. Will use SDK option for binding")
+		return useSDKForBinding(clients, sb)
+	}
 
+	logger.Debug("Using Operator to perform binding")
+	return useOperatorForBinding(logger, sb, clients, ns)
+
+}
+
+func useOperatorForBinding(logger logging.Logger, sb *v1alpha1.ServiceBinding, clients *KubernetesClients, ns string) error {
+	logger.Info(localizer.MustLocalizeFromID("cluster.serviceBinding.usingOperator"))
+	sbData, err := runtime.DefaultUnstructuredConverter.ToUnstructured(sb)
+	if err != nil {
 		return err
 	}
 
-	// Use SDK instead of operatort
+	unstructuredSB := unstructured.Unstructured{Object: sbData}
+	_, err = clients.dynamicClient.Resource(v1alpha1.GroupVersionResource).Namespace(ns).
+		Create(context.TODO(), &unstructuredSB, metav1.CreateOptions{})
+
+	return err
+}
+
+func useSDKForBinding(clients *KubernetesClients, sb *v1alpha1.ServiceBinding) error {
 	restMapper, err := apiutil.NewDynamicRESTMapper(clients.restConfig)
 	if err != nil {
 		return err

locales/cmd/cluster/bind/active.en.toml

@@ -28,7 +28,10 @@ type Options struct {
 	ignoreContext           bool
 	appName                 string
 	selectedKafka           string
-	useOperator             bool
+
+	forceOperator bool
+	forceSDK      bool
+	bindingName   string
 }
 
 func NewBindCommand(f *factory.Factory) *cobra.Command {
@@ -70,13 +73,13 @@ func NewBindCommand(f *factory.Factory) *cobra.Command {
 	cmd.Flags().BoolVarP(&opts.forceCreationWithoutAsk, "yes", "y", false, localizer.MustLocalizeFromID("cluster.common.flag.yes.description"))
 	cmd.Flags().StringVarP(&opts.namespace, "namespace", "n", "", localizer.MustLocalizeFromID("cluster.common.flag.namespace.description"))
 	cmd.Flags().BoolVarP(&opts.ignoreContext, "ignore-context", "", false, localizer.MustLocalizeFromID("cluster.common.flag.ignoreContext.description"))
-	cmd.Flags().BoolVarP(&opts.useOperator, "force-operator", "", false, localizer.MustLocalizeFromID("cluster.bind.flag.onlyOperator.description"))
-
+	cmd.Flags().BoolVarP(&opts.forceOperator, "force-operator", "", false, localizer.MustLocalizeFromID("cluster.bind.flag.forceOperator.description"))
+	cmd.Flags().BoolVarP(&opts.forceSDK, "force-sdk", "", false, localizer.MustLocalizeFromID("cluster.bind.flag.forceSDK.description"))
 	return cmd
 }
 
 func runBind(opts *Options) error {
-	connection, err := opts.Connection(connection.DefaultConfigSkipMasAuth)
+	apiConnection, err := opts.Connection(connection.DefaultConfigSkipMasAuth)
 	if err != nil {
 		return err
 	}
@@ -94,7 +97,7 @@ func runBind(opts *Options) error {
 	// In future config will include Id's of other services
 	if cfg.Services.Kafka == nil || opts.ignoreContext {
 		// nolint
-		selectedKafka, err := kafka.InteractiveSelect(connection, logger)
+		selectedKafka, err := kafka.InteractiveSelect(apiConnection, logger)
 		if err != nil {
 
 			return err
@@ -104,22 +107,26 @@ func runBind(opts *Options) error {
 		opts.selectedKafka = cfg.Services.Kafka.ClusterID
 	}
 
-	api := connection.API()
-	kafkaInstance, _, error := api.Kafka().GetKafkaById(context.Background(), opts.selectedKafka).Execute()
+	api := apiConnection.API()
+	kafkaInstance, _, err2 := api.Kafka().GetKafkaById(context.Background(), opts.selectedKafka).Execute()
 
-	if error != nil {
-		return error
+	if err2 != nil {
+		return err2
 	}
 
 	if kafkaInstance.Name == nil {
 		return errors.New(localizer.MustLocalizeFromID("cluster.bind.error.emptyResponse"))
 	}
 
-	err = cluster.ExecuteServiceBinding(logger, *kafkaInstance.Name,
-		opts.namespace,
-		opts.appName,
-		opts.forceCreationWithoutAsk,
-		opts.useOperator)
+	err = cluster.ExecuteServiceBinding(logger, &cluster.ServiceBindingOptions{
+		ServiceName:             *kafkaInstance.Name,
+		Namespace:               opts.namespace,
+		AppName:                 opts.appName,
+		ForceCreationWithoutAsk: opts.forceCreationWithoutAsk,
+		ForceUseOperator:        opts.forceOperator,
+		ForceUseSDK:             opts.forceSDK,
+		BindingName:             opts.bindingName,
+	})
 
 	return err
 }