Add liqoctl info peer command

Author: claudiolor

cmd/liqoctl/cmd/info.go

@@ -25,6 +25,7 @@ import (
 	"github.com/liqotech/liqo/pkg/liqoctl/factory"
 	"github.com/liqotech/liqo/pkg/liqoctl/info"
 	"github.com/liqotech/liqo/pkg/liqoctl/info/localstatus"
+	"github.com/liqotech/liqo/pkg/liqoctl/info/peer"
 	"github.com/liqotech/liqo/pkg/liqoctl/output"
 	"github.com/liqotech/liqo/pkg/utils/args"
 )
@@ -54,6 +55,34 @@ get a specific field
   $ {{ .Executable }} info --get network.podcidr
 `
 
+const liqoctlInfoPeerLongHelp = `Show additional info about peered clusters.
+
+Liqoctl provides a set of commands to verify the status of the Liqo control
+plane, its configuration, as well as the characteristics of the currently
+active peerings, and reports the outcome in human-readable or
+machine-readable format (either JSON or YAML).
+Additionally, via '--get', it allows to retrieve each single field of the reports
+using a query in dot notation (e.g. '--get field.subfield')
+
+This command shows additional information about the peered clusters, the status
+of the modules and the amount of shared resources.
+
+Examples:
+  $ {{ .Executable }} info peer
+or
+  $ {{ .Executable }} info peer cluster1
+or
+  $ {{ .Executable }} info peer cluster1 cluster2
+or
+  $ {{ .Executable }} info peer cluster1 cluster2 --namespace liqo-system
+show the output in YAML format
+  $ {{ .Executable }} info peer -o yaml
+get a specific field
+  $ {{ .Executable }} info peer cluster1 cluster2 --get cluster2.network.cidr
+when a single cluster is specified, the cluster ID at the beginning of the query can be omitted
+  $ {{ .Executable }} info peer cluster1 --get network.cidr
+`
+
 func infoPreRun(options *info.Options) {
 	// When the output is redirected to a file is desiderable that errors ends in the stderr output.
 	options.Printer.Error.Writer = os.Stderr
@@ -70,17 +99,23 @@ func infoPreRun(options *info.Options) {
 func newPeerInfoCommand(ctx context.Context, f *factory.Factory, options *info.Options) *cobra.Command {
 	cmd := &cobra.Command{
 		Use:               "peer",
-		Short:             "Show additional info about one or more specific peerings",
-		Long:              WithTemplate(""),
-		Args:              cobra.MinimumNArgs(1),
+		Short:             "Show additional info about peered clusters",
+		Long:              WithTemplate(liqoctlInfoPeerLongHelp),
 		ValidArgsFunction: completion.ClusterIDs(ctx, f, completion.NoLimit),
 
 		PreRun: func(_ *cobra.Command, _ []string) {
 			infoPreRun(options)
 		},
 
 		Run: func(_ *cobra.Command, clusterIds []string) {
-			output.ExitOnErr(options.RunPeerInfo(ctx, clusterIds))
+			checkers := []info.MultiClusterChecker{
+				&peer.InfoChecker{},
+				&peer.NetworkChecker{},
+				&peer.AuthChecker{},
+				&peer.OffloadingChecker{},
+			}
+
+			output.ExitOnErr(options.RunPeerInfo(ctx, checkers, clusterIds))
 		},
 	}
 

pkg/liqo-controller-manager/networking/external-network/route/k8s.go

@@ -18,7 +18,6 @@ import (
 	"context"
 	"fmt"
 
-	kerrors "k8s.io/apimachinery/pkg/api/errors"
 	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
 	"k8s.io/apimachinery/pkg/labels"
 	"k8s.io/apimachinery/pkg/runtime"
@@ -141,13 +140,8 @@ func forgeMutateRouteConfiguration(cfg *networkingv1beta1.Configuration,
 
 // GetGatewayMode returns the mode of the Gateway related to the Configuration.
 func GetGatewayMode(ctx context.Context, cl client.Client, remoteClusterID liqov1beta1.ClusterID) (gateway.Mode, error) {
-	gwclient, err := getters.GetGatewayClientByClusterID(ctx, cl, remoteClusterID)
-	if err != nil && !kerrors.IsNotFound(err) {
-		return "", err
-	}
-
-	gwserver, err := getters.GetGatewayServerByClusterID(ctx, cl, remoteClusterID)
-	if err != nil && !kerrors.IsNotFound(err) {
+	gwserver, gwclient, err := getters.GetGatewaysByClusterID(ctx, cl, remoteClusterID)
+	if err != nil {
 		return "", err
 	}
 

pkg/liqoctl/info/checker.go

@@ -14,37 +14,56 @@
 
 package info
 
-import "context"
+import (
+	"context"
 
-// Checker is the interface to be implemented by all the checkers that
-// collect info about the current instance of Liqo.
-type Checker interface {
+	liqov1beta1 "github.com/liqotech/liqo/apis/core/v1beta1"
+)
+
+// CheckerBase is the base interface for the multiple types of checkers.
+type CheckerBase interface {
 	// Collect the data from the Liqo installation
 	Collect(ctx context.Context, options Options)
-	// Return the collected data using a user friendly output
-	Format(options Options) string
 	// Get the title of the section retrieve by the checker
 	GetTitle() string
 	// Get the id to be shown of machine readable output
 	GetID() string
-	// Get the data collected by the checker
-	GetData() interface{}
 	// Return the errors occurred during the collection of the data.
 	GetCollectionErrors() []error
 }
 
-// CheckerBase contains the common attributes and functions of the checkers.
-type CheckerBase struct {
+// Checker is the interface to be implemented by all the checkers that
+// collect info about the current instance of Liqo.
+type Checker interface {
+	CheckerBase
+	// Return the collected data using a user friendly output
+	Format(options Options) string
+	// Get the data collected by the checker
+	GetData() interface{}
+}
+
+// MultiClusterChecker is the interface to be implemented by all the checkers that
+// collect info from multiple clusters.
+type MultiClusterChecker interface {
+	CheckerBase
+	// Get the data collected by the checker for the specified clusterID
+	GetDataByClusterID(clusterID liqov1beta1.ClusterID) (interface{}, error)
+	// Return the collected data for the specified clusterID using a user friendly output
+	FormatForClusterID(clusterID liqov1beta1.ClusterID, options Options) string
+}
+
+// CheckerCommon contains the common attributes and functions of the checkers.
+type CheckerCommon struct {
 	collectionErrors []error
 }
 
 // AddCollectionError adds an error to the list of errors occurred while
 // collecting the info about a Liqo component.
-func (c *CheckerBase) AddCollectionError(err error) {
+func (c *CheckerCommon) AddCollectionError(err error) {
 	c.collectionErrors = append(c.collectionErrors, err)
 }
 
 // GetCollectionErrors returns the errors occurred during the collection of the data.
-func (c *CheckerBase) GetCollectionErrors() []error {
+func (c *CheckerCommon) GetCollectionErrors() []error {
 	return c.collectionErrors
 }

pkg/liqoctl/info/common/doc.go

@@ -0,0 +1,17 @@
+// Copyright 2019-2024 The Liqo Authors
+//
+// 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.
+//
+
+// Package common contains the utilities and the types common to the checkers
+package common

pkg/liqoctl/info/common/types.go

@@ -0,0 +1,28 @@
+// Copyright 2019-2024 The Liqo Authors
+//
+// 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.
+//
+
+package common
+
+// ModuleStatus represents the status of each of the modules.
+type ModuleStatus string
+
+const (
+	// ModuleHealthy indicates a module that works as expected.
+	ModuleHealthy ModuleStatus = "Healthy"
+	// ModuleUnhealthy indicates that there are issues with the module.
+	ModuleUnhealthy ModuleStatus = "Unhealthy"
+	// ModuleDisabled indicates that the modules is not currently used.
+	ModuleDisabled ModuleStatus = "Disabled"
+)

pkg/liqoctl/info/common/utils.go

@@ -0,0 +1,71 @@
+// Copyright 2019-2024 The Liqo Authors
+//
+// 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.
+//
+
+package common
+
+import (
+	"github.com/pterm/pterm"
+
+	liqov1beta1 "github.com/liqotech/liqo/apis/core/v1beta1"
+)
+
+var statusStyles = map[ModuleStatus]*pterm.Style{
+	ModuleHealthy:   pterm.NewStyle(pterm.FgGreen, pterm.Bold),
+	ModuleUnhealthy: pterm.NewStyle(pterm.FgRed, pterm.Bold),
+	ModuleDisabled:  pterm.NewStyle(pterm.FgLightCyan, pterm.Bold),
+}
+
+// CheckModuleStatusAndAlerts returns the status and the alerts of the given module.
+func CheckModuleStatusAndAlerts(module liqov1beta1.Module) (status ModuleStatus, alerts []string) {
+	status = CheckModuleStatus(module)
+	// Collect the alerts if status if module is not healthy
+	if status == ModuleUnhealthy {
+		alerts = GetModuleAlerts(module)
+	}
+	return
+}
+
+// CheckModuleStatus based on the conditions of a module returns its status.
+func CheckModuleStatus(module liqov1beta1.Module) ModuleStatus {
+	if module.Enabled {
+		for i := range module.Conditions {
+			condition := &module.Conditions[i]
+
+			if condition.Status != liqov1beta1.ConditionStatusEstablished && condition.Status != liqov1beta1.ConditionStatusReady {
+				return ModuleUnhealthy
+			}
+		}
+		return ModuleHealthy
+	}
+
+	return ModuleDisabled
+}
+
+// GetModuleAlerts returns the alerts for the given module.
+func GetModuleAlerts(module liqov1beta1.Module) []string {
+	alerts := []string{}
+	for _, condition := range module.Conditions {
+		if condition.Status != liqov1beta1.ConditionStatusEstablished && condition.Status != liqov1beta1.ConditionStatusReady {
+			alerts = append(alerts, condition.Message)
+		}
+	}
+	return alerts
+}
+
+// FormatStatus returns a formatted string with the provided status.
+func FormatStatus(moduleStatus ModuleStatus) string {
+	style := statusStyles[moduleStatus]
+	return style.Sprint(moduleStatus)
+}

pkg/liqoctl/info/handler.go

@@ -18,7 +18,10 @@ package info
 import (
 	"context"
 	"fmt"
+	"maps"
+	"slices"
 
+	liqov1beta1 "github.com/liqotech/liqo/apis/core/v1beta1"
 	"github.com/liqotech/liqo/pkg/liqoctl/factory"
 )
 
@@ -41,9 +44,10 @@ var LocalInfoQueryShortcuts = map[string]string{
 type Options struct {
 	*factory.Factory
 
-	Verbose  bool
-	Format   OutputFormat
-	GetQuery string
+	Verbose      bool
+	Format       OutputFormat
+	GetQuery     string
+	ClustersInfo map[liqov1beta1.ClusterID]*liqov1beta1.ForeignCluster
 }
 
 // NewOptions returns a new Options struct.
@@ -80,9 +84,11 @@ func (o *Options) RunInfo(ctx context.Context, checkers []Checker) error {
 		return nil
 	// If query specified try to retrieve the field from the output
 	case o.GetQuery != "":
-		output, err = o.sPrintField(o.GetQuery, checkers, LocalInfoQueryShortcuts)
+		data := o.collectDataFromCheckers(checkers)
+		output, err = o.sPrintField(o.GetQuery, data, LocalInfoQueryShortcuts)
 	default:
-		output, err = o.sPrintMachineReadable(checkers)
+		data := o.collectDataFromCheckers(checkers)
+		output, err = o.sPrintMachineReadable(data)
 	}
 
 	if err != nil {
@@ -95,6 +101,71 @@ func (o *Options) RunInfo(ctx context.Context, checkers []Checker) error {
 }
 
 // RunPeerInfo execute the `info peer` command.
-func (o *Options) RunPeerInfo(_ context.Context, _ []string) error {
-	panic("Not implemented")
+func (o *Options) RunPeerInfo(ctx context.Context, checkers []MultiClusterChecker, clusterIDs []string) error {
+	// Check whether Liqo is installed in the current cluster
+	if err := o.installationCheck(ctx); err != nil {
+		return err
+	}
+
+	if err := o.getForeignClusters(ctx, clusterIDs); err != nil {
+		return err
+	}
+
+	// Start collecting the data via the checkers
+	for i := range checkers {
+		checkers[i].Collect(ctx, *o)
+		for _, err := range checkers[i].GetCollectionErrors() {
+			o.Printer.Warning.Println(err)
+		}
+	}
+
+	var err error
+	var output string
+	switch {
+	// If no format is specified, format and print a user-friendly output
+	case o.Format == "" && o.GetQuery == "":
+		clustersCounter := 0
+		nPeers := len(o.ClustersInfo)
+		for clusterID := range o.ClustersInfo {
+			for i := range checkers {
+				o.Printer.BoxSetTitle(checkers[i].GetTitle())
+				o.Printer.BoxPrintln(checkers[i].FormatForClusterID(clusterID, *o))
+			}
+
+			clustersCounter++
+			if clustersCounter < nPeers {
+				fmt.Printf("\n\n")
+			}
+		}
+		return nil
+	// If query specified try to retrieve the field from the output
+	case o.GetQuery != "":
+		data, _ := o.collectDataFromMultiClusterCheckers(checkers)
+
+		selectedClusterIDs := slices.Collect(maps.Keys(o.ClustersInfo))
+		// Get the cluster selected by the query
+		query, selectedCluster := o.getClusterFromQuery(o.GetQuery, selectedClusterIDs)
+
+		// Get the field from the cluster data
+		if showData, ok := data[liqov1beta1.ClusterID(selectedCluster)]; ok {
+			output, err = o.sPrintField(query, showData, nil)
+		} else {
+			err = fmt.Errorf(
+				"cluster %q in query %q is not among the requested clusters",
+				selectedCluster,
+				o.GetQuery,
+			)
+		}
+	default:
+		data, _ := o.collectDataFromMultiClusterCheckers(checkers)
+		output, err = o.sPrintMachineReadable(data)
+	}
+
+	if err != nil {
+		o.Printer.Error.Println(err)
+	} else {
+		fmt.Println(output)
+	}
+
+	return err
 }