Merge pull request #137 from ferryproxy/clean/hub

Cleanup

Author: wzshiming

.github/workflows/test.yml

@@ -142,6 +142,16 @@ jobs:
           TARGET_1: web-1
           TARGET_2: web-0
 
+      - name: Test chaotic control-plane and cluster-1
+        run: ./test/test/test-in-both-chaotic.sh
+        env:
+          ROUTE_NAME: ferry-test
+          CONTROL_PLANE: control-plane
+          CLUSTER_1: cluster-1
+          CLUSTER_2: control-plane
+          TARGET_1: web-1
+          TARGET_2: web-0
+
   test-3-cluster-cases:
     continue-on-error: true
     strategy:

cmd/ferry-controller/main.go

@@ -20,6 +20,7 @@ import (
 	"context"
 	"os"
 
+	"github.com/ferryproxy/ferry/pkg/client"
 	"github.com/ferryproxy/ferry/pkg/consts"
 	"github.com/ferryproxy/ferry/pkg/controllers"
 	"github.com/ferryproxy/ferry/pkg/utils/env"
@@ -49,9 +50,15 @@ func main() {
 		os.Exit(1)
 	}
 
+	clientset, err := client.NewForConfig(restConfig)
+	if err != nil {
+		log.Error(err, "failed to create kubernetes clientset")
+		os.Exit(1)
+	}
+
 	control := controllers.NewController(&controllers.ControllerConfig{
 		Logger:    log.WithName("controller"),
-		Config:    restConfig,
+		Clientset: clientset,
 		Namespace: namespace,
 	})
 

go.mod

@@ -17,7 +17,6 @@ require (
 	go.uber.org/zap v1.21.0
 	golang.org/x/crypto v0.0.0-20220622213112-05595931fe9d
 	k8s.io/api v0.24.2
-	k8s.io/apiextensions-apiserver v0.24.2
 	k8s.io/apimachinery v0.24.2
 	k8s.io/client-go v0.24.2
 	sigs.k8s.io/mcs-api v0.1.0

go.sum

@@ -21,83 +21,100 @@ import (
 	"fmt"
 
 	"github.com/ferryproxy/api/apis/traffic/v1alpha2"
-	versioned "github.com/ferryproxy/client-go/generated/clientset/versioned"
+	ferryversioned "github.com/ferryproxy/client-go/generated/clientset/versioned"
 	"github.com/ferryproxy/ferry/pkg/utils/objref"
+	"github.com/go-logr/logr"
 	corev1 "k8s.io/api/core/v1"
 	"k8s.io/client-go/kubernetes"
 	"k8s.io/client-go/rest"
+	mcsversioned "sigs.k8s.io/mcs-api/pkg/client/clientset/versioned"
 )
 
 type clientset struct {
 	kubeClientset  kubernetes.Interface
-	ferryClientset versioned.Interface
+	ferryClientset ferryversioned.Interface
+	mcsClientset   mcsversioned.Interface
 }
 
 type Interface interface {
 	Kubernetes() kubernetes.Interface
-	Ferry() versioned.Interface
+	Ferry() ferryversioned.Interface
+	MCS() mcsversioned.Interface
 }
 
 func NewForConfig(conf *rest.Config) (Interface, error) {
 	kubeClientset, err := kubernetes.NewForConfig(conf)
 	if err != nil {
 		return nil, err
 	}
-	ferryClientset, err := versioned.NewForConfig(conf)
+	_, err = kubeClientset.ServerVersion()
+	if err != nil {
+		return nil, err
+	}
+	ferryClientset, err := ferryversioned.NewForConfig(conf)
+	if err != nil {
+		return nil, err
+	}
+	mcsClientset, err := mcsversioned.NewForConfig(conf)
 	if err != nil {
 		return nil, err
 	}
 	return &clientset{
 		kubeClientset:  kubeClientset,
 		ferryClientset: ferryClientset,
+		mcsClientset:   mcsClientset,
 	}, nil
 }
 
 func (c *clientset) Kubernetes() kubernetes.Interface {
 	return c.kubeClientset
 }
 
-func (c *clientset) Ferry() versioned.Interface {
+func (c *clientset) Ferry() ferryversioned.Interface {
 	return c.ferryClientset
 }
 
-func Apply(ctx context.Context, c Interface, obj objref.KMetadata) error {
+func (c *clientset) MCS() mcsversioned.Interface {
+	return c.mcsClientset
+}
+
+func Apply(ctx context.Context, logger logr.Logger, c Interface, obj objref.KMetadata) error {
 	switch o := obj.(type) {
 	case *corev1.ConfigMap:
-		return configMap{o}.Apply(ctx, c)
+		return configMap{o}.Apply(ctx, logger, c)
 	case *corev1.Secret:
-		return secret{o}.Apply(ctx, c)
+		return secret{o}.Apply(ctx, logger, c)
 	case *corev1.Service:
-		return service{o}.Apply(ctx, c)
+		return service{o}.Apply(ctx, logger, c)
 	case *corev1.Endpoints:
-		return endpoints{o}.Apply(ctx, c)
+		return endpoints{o}.Apply(ctx, logger, c)
 	case *v1alpha2.Hub:
-		return hub{o}.Apply(ctx, c)
+		return hub{o}.Apply(ctx, logger, c)
 	case *v1alpha2.RoutePolicy:
-		return routePolicy{o}.Apply(ctx, c)
+		return routePolicy{o}.Apply(ctx, logger, c)
 	case *v1alpha2.Route:
-		return route{o}.Apply(ctx, c)
+		return route{o}.Apply(ctx, logger, c)
 	default:
 		return fmt.Errorf("unsupport type")
 	}
 }
 
-func Delete(ctx context.Context, c Interface, obj objref.KMetadata) error {
+func Delete(ctx context.Context, logger logr.Logger, c Interface, obj objref.KMetadata) error {
 	switch o := obj.(type) {
 	case *corev1.ConfigMap:
-		return configMap{o}.Delete(ctx, c)
+		return configMap{o}.Delete(ctx, logger, c)
 	case *corev1.Secret:
-		return secret{o}.Delete(ctx, c)
+		return secret{o}.Delete(ctx, logger, c)
 	case *corev1.Service:
-		return service{o}.Delete(ctx, c)
+		return service{o}.Delete(ctx, logger, c)
 	case *corev1.Endpoints:
-		return endpoints{o}.Delete(ctx, c)
+		return endpoints{o}.Delete(ctx, logger, c)
 	case *v1alpha2.Hub:
-		return hub{o}.Delete(ctx, c)
+		return hub{o}.Delete(ctx, logger, c)
 	case *v1alpha2.RoutePolicy:
-		return routePolicy{o}.Delete(ctx, c)
+		return routePolicy{o}.Delete(ctx, logger, c)
 	case *v1alpha2.Route:
-		return route{o}.Delete(ctx, c)
+		return route{o}.Delete(ctx, logger, c)
 	default:
 		return fmt.Errorf("unsupport type")
 	}