cli: create run servicedirectory command

This commit enables the operator to run with Google Service Directory.
This command is not enabled yet, and will be once all others will be
completed as well.

Signed-off-by: Elis Lulja <[email protected]>

Author: asimpleidea

pkg/command/run/run.go

@@ -324,7 +324,7 @@ func GetRunCommand() *cobra.Command {
 	// Sub commands
 	// -----------------------------
 
-	// TODO: add commands
+	cmd.AddCommand(getRunServiceDirectoryCommand(opts))
 
 	return cmd
 }

pkg/command/run/service_directory.go

@@ -0,0 +1,269 @@
+// Copyright © 2022 Cisco
+//
+// SPDX-License-Identifier: Apache-2.0
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+// All rights reserved.
+
+package run
+
+import (
+	"context"
+	"fmt"
+	"io/ioutil"
+	"time"
+
+	servicedirectory "cloud.google.com/go/servicedirectory/apiv1"
+	"github.com/CloudNativeSDWAN/cnwan-operator/pkg/cluster"
+	sd "github.com/CloudNativeSDWAN/cnwan-operator/pkg/servregistry/gcloud/servicedirectory"
+	"github.com/spf13/cobra"
+	"google.golang.org/api/option"
+	"gopkg.in/yaml.v3"
+	ctrl "sigs.k8s.io/controller-runtime"
+	"sigs.k8s.io/controller-runtime/pkg/log/zap"
+)
+
+const (
+	defaultServiceDirectoryConfigMapName            = "service-directory-options"
+	defaultServiceDirectoryServiceAccountSecretName = "service-directory-service-account"
+	autoKey                                         = "auto"
+)
+
+type ServiceDirectoryOptions struct {
+	DefaultRegion string `yaml:"defaultRegion"`
+	ProjectID     string `yaml:"projectID"`
+
+	serviceAccountBytes []byte
+}
+
+func getRunServiceDirectoryCommand(operatorOpts *Options) *cobra.Command {
+	// -----------------------------
+	// Inits and defaults
+	// -----------------------------
+
+	opts := &ServiceDirectoryOptions{}
+	var (
+		optsPath      string
+		optsConfigMap string
+		servAccPath   string
+		servAccSecret string
+	)
+
+	// -----------------------------
+	// The command
+	// -----------------------------
+
+	cmd := &cobra.Command{
+		Use:     "servicedirectory [COMMAND] [OPTIONS]",
+		Aliases: []string{"sd", "google-service-directory", "with-service-directory"},
+		Short:   "Run the program with Google Service Directory",
+		PreRunE: func(cmd *cobra.Command, args []string) error {
+			l := log.With().Str("cmd", "service-directory").Logger()
+
+			// -- Get the options from file or ConfigMap
+			if optsPath != "" || optsConfigMap != "" {
+				var (
+					fileOptions        []byte
+					decodedFileOptions *ServiceDirectoryOptions
+				)
+
+				// -- Get the options from path
+				if optsPath != "" {
+					if optsConfigMap != "" {
+						l.Warn().Msg("both path and configmap flags are provided: only the path will be used")
+						optsConfigMap = ""
+					}
+
+					log.Debug().Str("path", optsPath).
+						Msg("getting options from file...")
+					byteOpts, err := ioutil.ReadFile(optsPath)
+					if err != nil {
+						return fmt.Errorf("cannot open file %s: %w", optsPath, err)
+					}
+
+					fileOptions = byteOpts
+				}
+
+				// -- Get options from configmap
+				if optsConfigMap != "" {
+					log.Debug().
+						Str("namespace", operatorOpts.Namespace).
+						Str("name", optsConfigMap).
+						Msg("getting options from configmap...")
+
+					ctx, canc := context.WithTimeout(context.Background(), 10*time.Second)
+					cfg, err := cluster.GetFilesFromConfigMap(ctx, operatorOpts.Namespace, optsConfigMap)
+					if err != nil {
+						canc()
+						return fmt.Errorf("cannot get configmap: %w", err)
+					}
+					canc()
+
+					fileOptions = cfg[0]
+				}
+
+				if len(fileOptions) > 0 {
+					if err := yaml.Unmarshal(fileOptions, &decodedFileOptions); err != nil {
+						return fmt.Errorf("cannot decode options %s: %w", optsPath, err)
+					}
+				}
+
+				// -- Parse the cmd flags
+				if !cmd.Flag("default-region").Changed {
+					opts.DefaultRegion = decodedFileOptions.DefaultRegion
+				}
+
+				if !cmd.Flag("project-id").Changed {
+					opts.ProjectID = decodedFileOptions.ProjectID
+				}
+			}
+
+			// -- Are the settings provided at least?
+			if opts.DefaultRegion == "" {
+				return fmt.Errorf("no region provided")
+			}
+
+			if opts.ProjectID == "" {
+				return fmt.Errorf("no project ID provided")
+			}
+
+			// -- Get data automatically?
+			if opts.DefaultRegion == autoKey || opts.ProjectID == autoKey {
+				if cluster.WhereAmIRunning() != cluster.GKECluster {
+					return fmt.Errorf("cannot get data automatically: cluster is not GKE")
+				}
+
+				defaultRegion, err := cluster.GetGCPRegion()
+				if err != nil {
+					return fmt.Errorf("could not get region from GCP: %w", err)
+				}
+				opts.DefaultRegion = *defaultRegion
+				l.Info().Str("region", opts.DefaultRegion).Msg("retrieved region from GKE")
+
+				projectID, err := cluster.GetGCPProjectID()
+				if err != nil {
+					return fmt.Errorf("could not get project ID from GCP: %w", err)
+				}
+				opts.ProjectID = *projectID
+				l.Info().Str("project-id", opts.ProjectID).Msg("retrieved project ID from GCP")
+			}
+
+			// -- Get the service account
+			if servAccPath == "" && servAccSecret == "" {
+				return fmt.Errorf("no service account provided")
+			}
+
+			if servAccPath != "" {
+				if servAccSecret != "" {
+					l.Warn().Msg("both path and secret flags are provided: only the path will be used")
+					servAccSecret = ""
+				}
+
+				l.Debug().Str("path", servAccPath).
+					Msg("getting service account from file...")
+				byteOpts, err := ioutil.ReadFile(servAccPath)
+				if err != nil {
+					return fmt.Errorf("cannot open file %s: %w", servAccPath, err)
+				}
+
+				opts.serviceAccountBytes = byteOpts
+			}
+
+			if servAccSecret != "" {
+				l.Debug().
+					Str("namespace", operatorOpts.Namespace).
+					Str("name", servAccSecret).
+					Msg("getting service account from secret...")
+
+				ctx, canc := context.WithTimeout(context.Background(), 10*time.Second)
+				secret, err := cluster.GetFilesFromSecret(ctx, operatorOpts.Namespace, servAccSecret)
+				if err != nil {
+					canc()
+					return fmt.Errorf("cannot get secret: %w", err)
+				}
+				canc()
+
+				opts.serviceAccountBytes = secret[0]
+			}
+
+			return nil
+		},
+		RunE: func(_ *cobra.Command, _ []string) error {
+			return runWithServiceDirectory(operatorOpts, opts)
+		},
+		Example: "servicedirectory --project-id my-project-id default-region us-east1",
+	}
+
+	// -----------------------------
+	// Flags
+	// -----------------------------
+
+	cmd.Flags().StringVar(&opts.DefaultRegion, "default-region", "",
+		"region/location where to register resources. Write auto to try to get it automatically.")
+	cmd.Flags().StringVar(&opts.ProjectID, "project-id", "",
+		"Google Cloud project ID. Write auto to try to get it automatically.")
+	cmd.Flags().StringVar(&optsPath, "options-path", "",
+		"path to the file containing service directory options.")
+	cmd.Flags().StringVar(&optsConfigMap, "options-configmap", func() string {
+		if operatorOpts.RunningInK8s {
+			return defaultServiceDirectoryConfigMapName
+		}
+
+		return ""
+	}(),
+		"name of the Kubernetes config map containing settings.")
+	cmd.Flags().StringVar(&servAccPath, "service-account-path", "",
+		"path to the service account file.")
+	cmd.Flags().StringVar(&servAccSecret, "service-account-secret", func() string {
+		if operatorOpts.RunningInK8s {
+			return defaultServiceDirectoryServiceAccountSecretName
+		}
+
+		return ""
+	}(),
+		"name of the Kubernetes secret containing the service account.")
+
+	return cmd
+}
+
+func runWithServiceDirectory(operatorOpts *Options, sdOpts *ServiceDirectoryOptions) error {
+	ctx, canc := context.WithTimeout(context.Background(), 15*time.Second)
+	defer canc()
+
+	cli, err := servicedirectory.
+		NewRegistrationClient(ctx, option.WithCredentialsJSON(sdOpts.serviceAccountBytes))
+	if err != nil {
+		return fmt.Errorf("could not get start service directory client: %s", err)
+	}
+
+	defer cli.Close()
+
+	// TODO: when #81 is solved an merged this will be replaced
+	// with zerolog
+	l := ctrl.Log.WithName("ServiceDirectory")
+	ctrl.SetLogger(zap.New(zap.UseDevMode(true)))
+
+	sr := &sd.Handler{
+		ProjectID:     sdOpts.ProjectID,
+		DefaultRegion: sdOpts.DefaultRegion,
+		Log:           l,
+		Context:       ctx,
+		Client:        cli,
+	}
+
+	// TODO: use the handler (in next commits)
+	_ = sr
+
+	return nil
+}