Handle legacy cloud-provider types (#623)

Author: Samu

cmd/controller/app/app.go

@@ -109,27 +109,30 @@ func (a *App) Run(ctx context.Context) error {
 	})
 
 	// Initialize cloud provider if enabled
-	if cfg.CloudProviderConfig.CloudProvider.Type != "" {
+	if cfg.CloudProviderConfig.IsAnyControllerEnabled() {
 		provider, err := cloudprovider.NewProvider(ctx, cfg.CloudProviderConfig.CloudProvider)
-		if err != nil {
-			return fmt.Errorf("failed to initialize cloud provider: %w", err)
-		}
-		log.Infof("cloud provider %s initialized successfully", provider.Type())
+		if err == nil {
+			log.Infof("cloud provider %s initialized successfully", provider.Type())
 
-		kubeClient.SetCloudProvider(provider.Type())
+			kubeClient.SetCloudProvider(provider.Type())
 
-		if cfg.CloudProviderConfig.VPCStateController.Enabled {
-			errg.Go(func() error {
-				return controllers.NewVPCStateController(log,
-					cfg.CloudProviderConfig.VPCStateController, provider, kubeClient).Run(ctx)
-			})
-		}
+			if cfg.CloudProviderConfig.VPCStateController.Enabled {
+				errg.Go(func() error {
+					return controllers.NewVPCStateController(log,
+						cfg.CloudProviderConfig.VPCStateController, provider, kubeClient).Run(ctx)
+				})
+			}
 
-		if cfg.CloudProviderConfig.VolumeStateController.Enabled {
-			errg.Go(func() error {
-				return controllers.NewVolumeStateController(log,
-					cfg.CloudProviderConfig.VolumeStateController, provider, kubeClient).Run(ctx)
-			})
+			if cfg.CloudProviderConfig.VolumeStateController.Enabled {
+				errg.Go(func() error {
+					return controllers.NewVolumeStateController(log,
+						cfg.CloudProviderConfig.VolumeStateController, provider, kubeClient).Run(ctx)
+				})
+			}
+		} else {
+			if !errors.Is(err, cloudprovider.ErrProviderNotImplemented) {
+				return fmt.Errorf("failed to initialize cloud provider: %w", err)
+			}
 		}
 	}
 

cmd/controller/config/config.go

@@ -43,12 +43,16 @@ type Config struct {
 	CloudProviderConfig CloudProviderConfig           `json:"cloudProviderConfig"`
 }
 
+type AgentConfig struct {
+	Enabled bool `json:"enabled"`
+}
+
 type CloudProviderConfig struct {
 	CloudProvider         cloudtypes.ProviderConfig               `json:"cloudProvider"`
 	VPCStateController    controllers.VPCStateControllerConfig    `json:"vpcStateController"`
 	VolumeStateController controllers.VolumeStateControllerConfig `json:"volumeStateController"`
 }
 
-type AgentConfig struct {
-	Enabled bool `json:"enabled"`
+func (c CloudProviderConfig) IsAnyControllerEnabled() bool {
+	return c.VPCStateController.Enabled || c.VolumeStateController.Enabled
 }

cmd/controller/main.go

@@ -34,7 +34,7 @@ var (
 	serverHTTPListenPort  = pflag.Int("http-listen-port", 8080, "server http listen port")
 	kubeServerListenPort  = pflag.Int("kube-server-listen-port", 8090, "kube server grpc http listen port")
 
-	logLevel                  = pflag.String("log-level", slog.LevelDebug.String(), "Log level")
+	logLevel                  = pflag.String("log-level", slog.LevelDebug.String(), "Log level: debug, info, warn or error")
 	logRateInterval           = pflag.Duration("log-rate-interval", 100*time.Millisecond, "Log rate limit interval")
 	logRateBurst              = pflag.Int("log-rate-burst", 100, "Log rate burst")
 	promMetricsExportEnabled  = pflag.Bool("prom-metrics-export-enabled", false, "Enabled sending internal prometheus metrics")
@@ -98,6 +98,15 @@ var (
 func main() {
 	pflag.Parse()
 
+	var slogLevel slog.Level
+	if err := slogLevel.UnmarshalText([]byte(*logLevel)); err != nil {
+		fmt.Fprintf(os.Stderr, "invalid log level %q: %v\n", *logLevel, err)
+		os.Exit(1)
+	}
+	logHandler := slog.NewTextHandler(os.Stdout, &slog.HandlerOptions{Level: slogLevel})
+	logger := slog.New(logHandler)
+	slog.SetDefault(logger)
+
 	ctx, cancel := signal.NotifyContext(context.Background(), syscall.SIGINT, syscall.SIGTERM)
 	defer cancel()
 
@@ -120,12 +129,10 @@ func main() {
 		os.Exit(1)
 	}
 
-	var cloudProviderVal string
-	if *cloudProvider != "" {
-		cloudProviderVal = *cloudProvider
-	} else {
-		slog.Warn(`--kube-bench-cloud-provider is deprecated, please use --cloud-provider instead.`)
-		cloudProviderVal = *kubeBenchCloudProvider
+	cloudProviderType, err := parseCloudProvider(*cloudProvider, *kubeBenchCloudProvider)
+	if err != nil {
+		slog.Error(err.Error())
+		os.Exit(1)
 	}
 
 	podNs := os.Getenv("POD_NAMESPACE")
@@ -174,7 +181,7 @@ func main() {
 			CastaiClusterID:           castaiClientCfg.ClusterID,
 			CastaiGrpcInsecure:        *castaiServerInsecure,
 			ImageScanBlobsCacheURL:    *imageScanBlobsCacheURL,
-			CloudProvider:             cloudProviderVal,
+			CloudProvider:             cloudProviderType.KubernetesType(),
 			IgnoredNamespaces:         *imageScanIgnoredNamespaces,
 			DisabledAnalyzers:         *imageScanDisabledAnalyzers,
 		},
@@ -188,7 +195,7 @@ func main() {
 			Force:              *kubeBenchForceScan,
 			ScanInterval:       *kubeBenchScanInterval,
 			JobImagePullPolicy: *kubeBenchJobImagePullPolicy,
-			CloudProvider:      cloudProviderVal,
+			CloudProvider:      cloudProviderType.KubernetesType(),
 			JobNamespace:       podNs,
 		},
 		JobsCleanup: controllers.JobsCleanupConfig{
@@ -201,7 +208,7 @@ func main() {
 		},
 		CloudProviderConfig: config.CloudProviderConfig{
 			CloudProvider: cloudtypes.ProviderConfig{
-				Type:         cloudtypes.Type(*cloudProvider),
+				Type:         cloudProviderType,
 				GCPProjectID: *cloudProviderGCPProjectID,
 				AWSRegion:    *cloudProviderAWSRegion,
 			},
@@ -245,3 +252,13 @@ func getKubeConfig(kubepath string) (*rest.Config, error) {
 	}
 	return inClusterConfig, nil
 }
+
+func parseCloudProvider(cloudProvider string, kubeBenchCloudProvider string) (cloudtypes.Type, error) {
+	if cloudProvider != "" {
+		return cloudtypes.NewProviderType(cloudProvider)
+	} else if kubeBenchCloudProvider != "" {
+		slog.Warn(`--kube-bench-cloud-provider is deprecated, please use --cloud-provider instead.`)
+		return cloudtypes.NewProviderType(kubeBenchCloudProvider)
+	}
+	return "", nil
+}

pkg/cloudprovider/noop/noop.go

@@ -14,7 +14,7 @@ func NewProvider() types.Provider {
 }
 
 func (n *noOpProvider) Type() types.Type {
-	return types.TypeNone
+	return types.Type("noop")
 }
 
 func (n *noOpProvider) GetNetworkState(ctx context.Context) (*types.NetworkState, error) {

pkg/cloudprovider/provider.go

@@ -2,14 +2,17 @@ package cloudprovider
 
 import (
 	"context"
+	"errors"
 	"fmt"
 
 	"github.com/castai/kvisor/pkg/cloudprovider/aws"
 	"github.com/castai/kvisor/pkg/cloudprovider/gcp"
-	"github.com/castai/kvisor/pkg/cloudprovider/noop"
 	"github.com/castai/kvisor/pkg/cloudprovider/types"
 )
 
+// TODO(samu): Remove when all providers are implemented
+var ErrProviderNotImplemented = errors.New("provider not implemented yet")
+
 // NewProvider creates a cloud provider instance based on config.
 func NewProvider(ctx context.Context, cfg types.ProviderConfig) (types.Provider, error) {
 	switch cfg.Type {
@@ -18,9 +21,7 @@ func NewProvider(ctx context.Context, cfg types.ProviderConfig) (types.Provider,
 	case types.TypeAWS:
 		return aws.NewProvider(ctx, cfg)
 	case types.TypeAzure:
-		return nil, fmt.Errorf("azure provider not yet implemented")
-	case types.TypeNone:
-		return noop.NewProvider(), nil
+		return nil, fmt.Errorf("azure: %w", ErrProviderNotImplemented)
 	default:
 		return nil, fmt.Errorf("unsupported cloud provider type: %s", cfg.Type)
 	}

pkg/cloudprovider/types/type.go

@@ -1,13 +1,40 @@
 package types
 
+import "fmt"
+
 type Type string
 
 const (
 	TypeGCP   Type = "gcp"
 	TypeAWS   Type = "aws"
 	TypeAzure Type = "azure"
-	TypeNone  Type = "none"
 
 	DomainGCP string = "googleapis.com"
 	DomainAWS string = "amazonaws.com"
 )
+
+func NewProviderType(provider string) (Type, error) {
+	switch provider {
+	case "gcp", "gke":
+		return TypeGCP, nil
+	case "aws", "eks":
+		return TypeAWS, nil
+	case "azure", "aks":
+		return TypeAzure, nil
+	default:
+		return "", fmt.Errorf("unknown cloud provider: %s", provider)
+	}
+}
+
+func (t Type) KubernetesType() string {
+	switch t {
+	case TypeGCP:
+		return "gke"
+	case TypeAWS:
+		return "eks"
+	case TypeAzure:
+		return "aks"
+	default:
+		return ""
+	}
+}

pkg/cloudprovider/types/type_test.go

@@ -0,0 +1,113 @@
+package types
+
+import (
+	"testing"
+)
+
+func TestNewProvider(t *testing.T) {
+	tests := []struct {
+		name     string
+		provider string
+		want     Type
+		wantErr  bool
+	}{
+		{
+			name:     "gcp returns TypeGCP",
+			provider: "gcp",
+			want:     TypeGCP,
+			wantErr:  false,
+		},
+		{
+			name:     "gke returns TypeGCP",
+			provider: "gke",
+			want:     TypeGCP,
+			wantErr:  false,
+		},
+		{
+			name:     "aws returns TypeAWS",
+			provider: "aws",
+			want:     TypeAWS,
+			wantErr:  false,
+		},
+		{
+			name:     "eks returns TypeAWS",
+			provider: "eks",
+			want:     TypeAWS,
+			wantErr:  false,
+		},
+		{
+			name:     "azure returns TypeAzure",
+			provider: "azure",
+			want:     TypeAzure,
+			wantErr:  false,
+		},
+		{
+			name:     "aks returns TypeAzure",
+			provider: "aks",
+			want:     TypeAzure,
+			wantErr:  false,
+		},
+		{
+			name:     "unknown provider returns error",
+			provider: "unknown",
+			want:     "",
+			wantErr:  true,
+		},
+		{
+			name:     "empty string returns error",
+			provider: "",
+			want:     "",
+			wantErr:  true,
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			got, err := NewProviderType(tt.provider)
+			if (err != nil) != tt.wantErr {
+				t.Errorf("NewProvider() error = %v, wantErr %v", err, tt.wantErr)
+				return
+			}
+			if got != tt.want {
+				t.Errorf("NewProvider() = %v, want %v", got, tt.want)
+			}
+		})
+	}
+}
+
+func TestType_KubernetesType(t *testing.T) {
+	tests := []struct {
+		name string
+		t    Type
+		want string
+	}{
+		{
+			name: "TypeGCP returns gke",
+			t:    TypeGCP,
+			want: "gke",
+		},
+		{
+			name: "TypeAWS returns eks",
+			t:    TypeAWS,
+			want: "eks",
+		},
+		{
+			name: "TypeAzure returns aks",
+			t:    TypeAzure,
+			want: "aks",
+		},
+		{
+			name: "unknown type returns empty string",
+			t:    Type("unknown"),
+			want: "",
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			if got := tt.t.KubernetesType(); got != tt.want {
+				t.Errorf("Type.KubernetesType() = %v, want %v", got, tt.want)
+			}
+		})
+	}
+}