Refactor Gloo integration

- build Gloo UpstreamGroup clientset
- drop solo-io, envoyproxy, hcl, consul, opencensus, apiextensions deps
- use the native routers with supergloo

pkg/router/factory.go

@@ -1,7 +1,6 @@
 package router
 
 import (
-	"context"
 	"strings"
 
 	"go.uber.org/zap"
@@ -84,18 +83,40 @@ func (factory *Factory) MeshRouter(provider string) Interface {
 			smiClient:     factory.meshClient,
 			targetMesh:    "linkerd",
 		}
-	case strings.HasPrefix(provider, "supergloo"):
-		supergloo, err := NewSuperglooRouter(context.TODO(), provider, factory.flaggerClient, factory.logger, factory.kubeConfig)
-		if err != nil {
-			panic("failed creating supergloo client")
-		}
-		return supergloo
 	case strings.HasPrefix(provider, "gloo"):
-		gloo, err := NewGlooRouter(context.TODO(), provider, factory.flaggerClient, factory.logger, factory.kubeConfig)
-		if err != nil {
-			panic("failed creating gloo client")
+		upstreamDiscoveryNs := "gloo-system"
+		if strings.HasPrefix(provider, "gloo:") {
+			upstreamDiscoveryNs = strings.TrimPrefix(provider, "gloo:")
+		}
+		return &GlooRouter{
+			logger:              factory.logger,
+			flaggerClient:       factory.flaggerClient,
+			kubeClient:          factory.kubeClient,
+			glooClient:          factory.meshClient,
+			upstreamDiscoveryNs: upstreamDiscoveryNs,
+		}
+	case strings.HasPrefix(provider, "supergloo:appmesh"):
+		return &AppMeshRouter{
+			logger:        factory.logger,
+			flaggerClient: factory.flaggerClient,
+			kubeClient:    factory.kubeClient,
+			appmeshClient: factory.meshClient,
+		}
+	case strings.HasPrefix(provider, "supergloo:istio"):
+		return &IstioRouter{
+			logger:        factory.logger,
+			flaggerClient: factory.flaggerClient,
+			kubeClient:    factory.kubeClient,
+			istioClient:   factory.meshClient,
+		}
+	case strings.HasPrefix(provider, "supergloo:linkerd"):
+		return &SmiRouter{
+			logger:        factory.logger,
+			flaggerClient: factory.flaggerClient,
+			kubeClient:    factory.kubeClient,
+			smiClient:     factory.meshClient,
+			targetMesh:    "linkerd",
 		}
-		return gloo
 	default:
 		return &IstioRouter{
 			logger:        factory.logger,

pkg/router/gloo.go

@@ -1,21 +1,16 @@
 package router
 
 import (
-	"context"
 	"fmt"
-	"strings"
 
-	gloov1 "github.com/solo-io/gloo/projects/gloo/pkg/api/v1"
-	solokitclients "github.com/solo-io/solo-kit/pkg/api/v1/clients"
-	"github.com/solo-io/solo-kit/pkg/api/v1/clients/factory"
-	"github.com/solo-io/solo-kit/pkg/api/v1/clients/kube"
-	crdv1 "github.com/solo-io/solo-kit/pkg/api/v1/clients/kube/crd/solo.io/v1"
-	solokitcore "github.com/solo-io/solo-kit/pkg/api/v1/resources/core"
-	solokiterror "github.com/solo-io/solo-kit/pkg/errors"
+	"github.com/google/go-cmp/cmp"
+	"github.com/google/go-cmp/cmp/cmpopts"
+	gloov1 "github.com/weaveworks/flagger/pkg/apis/gloo/v1"
 	"go.uber.org/zap"
+	"k8s.io/apimachinery/pkg/api/errors"
 	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
 	"k8s.io/apimachinery/pkg/runtime/schema"
-	"k8s.io/client-go/rest"
+	"k8s.io/client-go/kubernetes"
 
 	flaggerv1 "github.com/weaveworks/flagger/pkg/apis/flagger/v1alpha3"
 	clientset "github.com/weaveworks/flagger/pkg/client/clientset/versioned"
@@ -23,54 +18,92 @@ import (
 
 // GlooRouter is managing Istio virtual services
 type GlooRouter struct {
-	ugClient            gloov1.UpstreamGroupClient
+	kubeClient          kubernetes.Interface
+	glooClient          clientset.Interface
+	flaggerClient       clientset.Interface
 	logger              *zap.SugaredLogger
 	upstreamDiscoveryNs string
 }
 
-func NewGlooRouter(ctx context.Context, provider string, flaggerClient clientset.Interface, logger *zap.SugaredLogger, cfg *rest.Config) (*GlooRouter, error) {
-	// TODO if cfg is nil use memory client instead?
-	sharedCache := kube.NewKubeCache(ctx)
-	upstreamGroupClient, err := gloov1.NewUpstreamGroupClient(&factory.KubeResourceClientFactory{
-		Crd:             gloov1.UpstreamGroupCrd,
-		Cfg:             cfg,
-		SharedCache:     sharedCache,
-		SkipCrdCreation: true,
-	})
-	if err != nil {
-		// this should never happen.
-		return nil, fmt.Errorf("creating UpstreamGroup client %v", err)
-	}
-	if err := upstreamGroupClient.Register(); err != nil {
-		return nil, err
-	}
-	upstreamDiscoveryNs := ""
-	if strings.HasPrefix(provider, "gloo:") {
-		upstreamDiscoveryNs = strings.TrimPrefix(provider, "gloo:")
-	}
-
-	return NewGlooRouterWithClient(ctx, upstreamGroupClient, upstreamDiscoveryNs, logger), nil
-}
-
-func NewGlooRouterWithClient(ctx context.Context, routingRuleClient gloov1.UpstreamGroupClient, upstreamDiscoveryNs string, logger *zap.SugaredLogger) *GlooRouter {
-
-	if upstreamDiscoveryNs == "" {
-		upstreamDiscoveryNs = "gloo-system"
-	}
-	return &GlooRouter{ugClient: routingRuleClient, logger: logger, upstreamDiscoveryNs: upstreamDiscoveryNs}
-}
-
 // Reconcile creates or updates the Istio virtual service
 func (gr *GlooRouter) Reconcile(canary *flaggerv1.Canary) error {
-	// do we have routes already?
-	if _, _, _, err := gr.GetRoutes(canary); err == nil {
-		// we have routes, no need to do anything else
-		return nil
-	} else if solokiterror.IsNotExist(err) {
-		return gr.SetRoutes(canary, 100, 0, false)
-	} else {
-		return err
+	targetName := canary.Spec.TargetRef.Name
+	canaryName := fmt.Sprintf("%s-%s-canary-%v", canary.Namespace, canary.Spec.TargetRef.Name, canary.Spec.Service.Port)
+	primaryName := fmt.Sprintf("%s-%s-primary-%v", canary.Namespace, canary.Spec.TargetRef.Name, canary.Spec.Service.Port)
+
+	newSpec := gloov1.UpstreamGroupSpec{
+		Destinations: []gloov1.WeightedDestination{
+			{
+				Destination: gloov1.Destination{
+					Upstream: gloov1.ResourceRef{
+						Name:      primaryName,
+						Namespace: gr.upstreamDiscoveryNs,
+					},
+				},
+				Weight: 100,
+			},
+			{
+				Destination: gloov1.Destination{
+					Upstream: gloov1.ResourceRef{
+						Name:      canaryName,
+						Namespace: gr.upstreamDiscoveryNs,
+					},
+				},
+				Weight: 0,
+			},
+		},
 	}
+
+	upstreamGroup, err := gr.glooClient.GlooV1().UpstreamGroups(canary.Namespace).Get(targetName, metav1.GetOptions{})
+	if errors.IsNotFound(err) {
+		upstreamGroup = &gloov1.UpstreamGroup{
+			ObjectMeta: metav1.ObjectMeta{
+				Name:      targetName,
+				Namespace: canary.Namespace,
+				OwnerReferences: []metav1.OwnerReference{
+					*metav1.NewControllerRef(canary, schema.GroupVersionKind{
+						Group:   flaggerv1.SchemeGroupVersion.Group,
+						Version: flaggerv1.SchemeGroupVersion.Version,
+						Kind:    flaggerv1.CanaryKind,
+					}),
+				},
+			},
+			Spec: newSpec,
+		}
+
+		_, err = gr.glooClient.GlooV1().UpstreamGroups(canary.Namespace).Create(upstreamGroup)
+		if err != nil {
+			return fmt.Errorf("UpstreamGroup %s.%s create error %v", targetName, canary.Namespace, err)
+		}
+		gr.logger.With("canary", fmt.Sprintf("%s.%s", canary.Name, canary.Namespace)).
+			Infof("UpstreamGroup %s.%s created", upstreamGroup.GetName(), canary.Namespace)
+		return nil
+	}
+
+	if err != nil {
+		return fmt.Errorf("UpstreamGroup %s.%s query error %v", targetName, canary.Namespace, err)
+	}
+
+	// update upstreamGroup but keep the original destination weights
+	if upstreamGroup != nil {
+		if diff := cmp.Diff(
+			newSpec,
+			upstreamGroup.Spec,
+			cmpopts.IgnoreFields(gloov1.WeightedDestination{}, "Weight"),
+		); diff != "" {
+			clone := upstreamGroup.DeepCopy()
+			clone.Spec = newSpec
+
+			_, err = gr.glooClient.GlooV1().UpstreamGroups(canary.Namespace).Update(clone)
+			if err != nil {
+				return fmt.Errorf("UpstreamGroup %s.%s update error %v", targetName, canary.Namespace, err)
+			}
+			gr.logger.With("canary", fmt.Sprintf("%s.%s", canary.Name, canary.Namespace)).
+				Infof("UpstreamGroup %s.%s updated", upstreamGroup.GetName(), canary.Namespace)
+		}
+	}
+
+	return nil
 }
 
 // GetRoutes returns the destinations weight for primary and canary
@@ -81,29 +114,31 @@ func (gr *GlooRouter) GetRoutes(canary *flaggerv1.Canary) (
 	err error,
 ) {
 	targetName := canary.Spec.TargetRef.Name
-	var ug *gloov1.UpstreamGroup
-	ug, err = gr.ugClient.Read(canary.Namespace, targetName, solokitclients.ReadOpts{})
+	primaryName := fmt.Sprintf("%s-%s-primary-%v", canary.Namespace, canary.Spec.TargetRef.Name, canary.Spec.Service.Port)
+
+	upstreamGroup, err := gr.glooClient.GlooV1().UpstreamGroups(canary.Namespace).Get(targetName, metav1.GetOptions{})
 	if err != nil {
+		if errors.IsNotFound(err) {
+			err = fmt.Errorf("UpstreamGroup %s.%s not found", targetName, canary.Namespace)
+			return
+		}
+		err = fmt.Errorf("UpstreamGroup %s.%s query error %v", targetName, canary.Namespace, err)
 		return
 	}
 
-	dests := ug.GetDestinations()
-	for _, dest := range dests {
-		if dest.GetDestination().GetUpstream().Name == upstreamName(canary.Namespace, fmt.Sprintf("%s-primary", targetName), canary.Spec.Service.Port) {
-			primaryWeight = int(dest.Weight)
-		}
-		if dest.GetDestination().GetUpstream().Name == upstreamName(canary.Namespace, fmt.Sprintf("%s-canary", targetName), canary.Spec.Service.Port) {
-			canaryWeight = int(dest.Weight)
-		}
+	if len(upstreamGroup.Spec.Destinations) < 2 {
+		err = fmt.Errorf("UpstreamGroup %s.%s destinations not found", targetName, canary.Namespace)
+		return
 	}
 
-	if primaryWeight == 0 && canaryWeight == 0 {
-		err = fmt.Errorf("RoutingRule %s.%s does not contain routes for %s-primary and %s-canary",
-			targetName, canary.Namespace, targetName, targetName)
+	for _, dst := range upstreamGroup.Spec.Destinations {
+		if dst.Destination.Upstream.Name == primaryName {
+			primaryWeight = int(dst.Weight)
+			canaryWeight = 100 - primaryWeight
+			return
+		}
 	}
 
-	mirrored = false
-
 	return
 }
 
@@ -115,77 +150,48 @@ func (gr *GlooRouter) SetRoutes(
 	mirrored bool,
 ) error {
 	targetName := canary.Spec.TargetRef.Name
+	canaryName := fmt.Sprintf("%s-%s-canary-%v", canary.Namespace, canary.Spec.TargetRef.Name, canary.Spec.Service.Port)
+	primaryName := fmt.Sprintf("%s-%s-primary-%v", canary.Namespace, canary.Spec.TargetRef.Name, canary.Spec.Service.Port)
 
 	if primaryWeight == 0 && canaryWeight == 0 {
 		return fmt.Errorf("RoutingRule %s.%s update failed: no valid weights", targetName, canary.Namespace)
 	}
 
-	destinations := []*gloov1.WeightedDestination{}
-	destinations = append(destinations, &gloov1.WeightedDestination{
-		Destination: &gloov1.Destination{
-			Upstream: solokitcore.ResourceRef{
-				Name:      upstreamName(canary.Namespace, fmt.Sprintf("%s-primary", targetName), canary.Spec.Service.Port),
-				Namespace: gr.upstreamDiscoveryNs,
-			},
-		},
-		Weight: uint32(primaryWeight),
-	})
-
-	destinations = append(destinations, &gloov1.WeightedDestination{
-		Destination: &gloov1.Destination{
-			Upstream: solokitcore.ResourceRef{
-				Name:      upstreamName(canary.Namespace, fmt.Sprintf("%s-canary", targetName), canary.Spec.Service.Port),
-				Namespace: gr.upstreamDiscoveryNs,
-			},
-		},
-		Weight: uint32(canaryWeight),
-	})
-
-	upstreamGroup := &gloov1.UpstreamGroup{
-		Metadata: solokitcore.Metadata{
-			Name:      canary.Spec.TargetRef.Name,
-			Namespace: canary.Namespace,
-		},
-		Destinations: destinations,
-	}
-
-	return gr.writeUpstreamGroupRuleForCanary(canary, upstreamGroup)
-}
-
-func (gr *GlooRouter) writeUpstreamGroupRuleForCanary(canary *flaggerv1.Canary, ug *gloov1.UpstreamGroup) error {
-	targetName := canary.Spec.TargetRef.Name
-
-	if oldUg, err := gr.ugClient.Read(ug.Metadata.Namespace, ug.Metadata.Name, solokitclients.ReadOpts{}); err != nil {
-		if solokiterror.IsNotExist(err) {
-			gr.logger.With("canary", fmt.Sprintf("%s.%s", canary.Name, canary.Namespace)).
-				Infof("UpstreamGroup %s created", ug.Metadata.Name)
-		} else {
-			return fmt.Errorf("RoutingRule %s.%s read failed: %v", targetName, canary.Namespace, err)
-		}
-	} else {
-		ug.Metadata.ResourceVersion = oldUg.Metadata.ResourceVersion
-		// if the old and the new one are equal, no need to do anything.
-		oldUg.Status = solokitcore.Status{}
-		if oldUg.Equal(ug) {
-			return nil
-		}
-	}
-
-	kubeWriteOpts := &kube.KubeWriteOpts{
-		PreWriteCallback: func(r *crdv1.Resource) {
-			r.ObjectMeta.OwnerReferences = []metav1.OwnerReference{
-				*metav1.NewControllerRef(canary, schema.GroupVersionKind{
-					Group:   flaggerv1.SchemeGroupVersion.Group,
-					Version: flaggerv1.SchemeGroupVersion.Version,
-					Kind:    flaggerv1.CanaryKind,
-				}),
-			}
-		},
-	}
-	writeOpts := solokitclients.WriteOpts{OverwriteExisting: true, StorageWriteOpts: kubeWriteOpts}
-	_, err := gr.ugClient.Write(ug, writeOpts)
+	upstreamGroup, err := gr.glooClient.GlooV1().UpstreamGroups(canary.Namespace).Get(targetName, metav1.GetOptions{})
 	if err != nil {
-		return fmt.Errorf("UpstreamGroup %s.%s update failed: %v", targetName, canary.Namespace, err)
+		if errors.IsNotFound(err) {
+			return fmt.Errorf("UpstreamGroup %s.%s not found", targetName, canary.Namespace)
+
+		}
+		return fmt.Errorf("UpstreamGroup %s.%s query error %v", targetName, canary.Namespace, err)
+	}
+
+	upstreamGroup.Spec = gloov1.UpstreamGroupSpec{
+		Destinations: []gloov1.WeightedDestination{
+			{
+				Destination: gloov1.Destination{
+					Upstream: gloov1.ResourceRef{
+						Name:      primaryName,
+						Namespace: gr.upstreamDiscoveryNs,
+					},
+				},
+				Weight: uint32(primaryWeight),
+			},
+			{
+				Destination: gloov1.Destination{
+					Upstream: gloov1.ResourceRef{
+						Name:      canaryName,
+						Namespace: gr.upstreamDiscoveryNs,
+					},
+				},
+				Weight: uint32(canaryWeight),
+			},
+		},
+	}
+
+	_, err = gr.glooClient.GlooV1().UpstreamGroups(canary.Namespace).Update(upstreamGroup)
+	if err != nil {
+		return fmt.Errorf("UpstreamGroup %s.%s update error %v", targetName, canary.Namespace, err)
 	}
 	return nil
 }

pkg/router/gloo_test.go

@@ -1,40 +1,34 @@
 package router
 
 import (
-	"context"
 	"fmt"
 	"testing"
 
-	gloov1 "github.com/solo-io/gloo/projects/gloo/pkg/api/v1"
-	solokitclients "github.com/solo-io/solo-kit/pkg/api/v1/clients"
-	"github.com/solo-io/solo-kit/pkg/api/v1/clients/factory"
-	solokitmemory "github.com/solo-io/solo-kit/pkg/api/v1/clients/memory"
+	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
+
+	gloov1 "github.com/weaveworks/flagger/pkg/apis/gloo/v1"
 )
 
 func TestGlooRouter_Sync(t *testing.T) {
 	mocks := setupfakeClients()
+	router := &GlooRouter{
+		logger:        mocks.logger,
+		flaggerClient: mocks.flaggerClient,
+		glooClient:    mocks.meshClient,
+		kubeClient:    mocks.kubeClient,
+	}
 
-	upstreamGroupClient, err := gloov1.NewUpstreamGroupClient(&factory.MemoryResourceClientFactory{
-		Cache: solokitmemory.NewInMemoryResourceCache(),
-	})
-	if err != nil {
-		t.Fatal(err.Error())
-	}
-	if err := upstreamGroupClient.Register(); err != nil {
-		t.Fatal(err.Error())
-	}
-	router := NewGlooRouterWithClient(context.TODO(), upstreamGroupClient, "gloo-system", mocks.logger)
-	err = router.Reconcile(mocks.canary)
+	err := router.Reconcile(mocks.canary)
 	if err != nil {
 		t.Fatal(err.Error())
 	}
 
 	// test insert
-	ug, err := upstreamGroupClient.Read("default", "podinfo", solokitclients.ReadOpts{})
+	ug, err := router.glooClient.GlooV1().UpstreamGroups("default").Get("podinfo", metav1.GetOptions{})
 	if err != nil {
 		t.Fatal(err.Error())
 	}
-	dests := ug.GetDestinations()
+	dests := ug.Spec.Destinations
 	if len(dests) != 2 {
 		t.Errorf("Got Destinations %v wanted %v", len(dests), 2)
 	}
@@ -49,21 +43,15 @@ func TestGlooRouter_Sync(t *testing.T) {
 }
 
 func TestGlooRouter_SetRoutes(t *testing.T) {
-
 	mocks := setupfakeClients()
-
-	upstreamGroupClient, err := gloov1.NewUpstreamGroupClient(&factory.MemoryResourceClientFactory{
-		Cache: solokitmemory.NewInMemoryResourceCache(),
-	})
-	if err != nil {
-		t.Fatal(err.Error())
+	router := &GlooRouter{
+		logger:        mocks.logger,
+		flaggerClient: mocks.flaggerClient,
+		glooClient:    mocks.meshClient,
+		kubeClient:    mocks.kubeClient,
 	}
-	if err := upstreamGroupClient.Register(); err != nil {
-		t.Fatal(err.Error())
-	}
-	router := NewGlooRouterWithClient(context.TODO(), upstreamGroupClient, "gloo-system", mocks.logger)
 
-	err = router.Reconcile(mocks.canary)
+	err := router.Reconcile(mocks.canary)
 	if err != nil {
 		t.Fatal(err.Error())
 	}
@@ -82,20 +70,21 @@ func TestGlooRouter_SetRoutes(t *testing.T) {
 		t.Fatal(err.Error())
 	}
 
-	ug, err := upstreamGroupClient.Read("default", "podinfo", solokitclients.ReadOpts{})
+	ug, err := router.glooClient.GlooV1().UpstreamGroups("default").Get("podinfo", metav1.GetOptions{})
 	if err != nil {
 		t.Fatal(err.Error())
 	}
 
-	var pRoute *gloov1.WeightedDestination
-	var cRoute *gloov1.WeightedDestination
-	targetName := mocks.canary.Spec.TargetRef.Name
+	var pRoute gloov1.WeightedDestination
+	var cRoute gloov1.WeightedDestination
+	canaryName := fmt.Sprintf("%s-%s-canary-%v", mocks.canary.Namespace, mocks.canary.Spec.TargetRef.Name, mocks.canary.Spec.Service.Port)
+	primaryName := fmt.Sprintf("%s-%s-primary-%v", mocks.canary.Namespace, mocks.canary.Spec.TargetRef.Name, mocks.canary.Spec.Service.Port)
 
-	for _, dest := range ug.GetDestinations() {
-		if dest.GetDestination().GetUpstream().Name == upstreamName(mocks.canary.Namespace, fmt.Sprintf("%s-primary", targetName), mocks.canary.Spec.Service.Port) {
+	for _, dest := range ug.Spec.Destinations {
+		if dest.Destination.Upstream.Name == primaryName {
 			pRoute = dest
 		}
-		if dest.GetDestination().GetUpstream().Name == upstreamName(mocks.canary.Namespace, fmt.Sprintf("%s-canary", targetName), mocks.canary.Spec.Service.Port) {
+		if dest.Destination.Upstream.Name == canaryName {
 			cRoute = dest
 		}
 	}
@@ -112,18 +101,14 @@ func TestGlooRouter_SetRoutes(t *testing.T) {
 
 func TestGlooRouter_GetRoutes(t *testing.T) {
 	mocks := setupfakeClients()
+	router := &GlooRouter{
+		logger:        mocks.logger,
+		flaggerClient: mocks.flaggerClient,
+		glooClient:    mocks.meshClient,
+		kubeClient:    mocks.kubeClient,
+	}
 
-	upstreamGroupClient, err := gloov1.NewUpstreamGroupClient(&factory.MemoryResourceClientFactory{
-		Cache: solokitmemory.NewInMemoryResourceCache(),
-	})
-	if err != nil {
-		t.Fatal(err.Error())
-	}
-	if err := upstreamGroupClient.Register(); err != nil {
-		t.Fatal(err.Error())
-	}
-	router := NewGlooRouterWithClient(context.TODO(), upstreamGroupClient, "gloo-system", mocks.logger)
-	err = router.Reconcile(mocks.canary)
+	err := router.Reconcile(mocks.canary)
 	if err != nil {
 		t.Fatal(err.Error())
 	}

pkg/router/supergloo.go

@@ -1,349 +0,0 @@
-package router
-
-import (
-	"context"
-	"fmt"
-	"strings"
-	"time"
-
-	solokitclients "github.com/solo-io/solo-kit/pkg/api/v1/clients"
-	"github.com/solo-io/solo-kit/pkg/api/v1/clients/factory"
-	"github.com/solo-io/solo-kit/pkg/api/v1/clients/kube"
-	crdv1 "github.com/solo-io/solo-kit/pkg/api/v1/clients/kube/crd/solo.io/v1"
-	solokitcore "github.com/solo-io/solo-kit/pkg/api/v1/resources/core"
-	solokiterror "github.com/solo-io/solo-kit/pkg/errors"
-
-	"github.com/gogo/protobuf/types"
-	gloov1 "github.com/solo-io/gloo/projects/gloo/pkg/api/v1"
-	supergloov1alpha3 "github.com/solo-io/supergloo/pkg/api/external/istio/networking/v1alpha3"
-	supergloov1 "github.com/solo-io/supergloo/pkg/api/v1"
-	"go.uber.org/zap"
-	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
-	"k8s.io/apimachinery/pkg/runtime/schema"
-	"k8s.io/client-go/rest"
-
-	flaggerv1 "github.com/weaveworks/flagger/pkg/apis/flagger/v1alpha3"
-	istiov1alpha3 "github.com/weaveworks/flagger/pkg/apis/istio/v1alpha3"
-	clientset "github.com/weaveworks/flagger/pkg/client/clientset/versioned"
-)
-
-// SuperglooRouter is managing Istio virtual services
-type SuperglooRouter struct {
-	rrClient   supergloov1.RoutingRuleClient
-	logger     *zap.SugaredLogger
-	targetMesh solokitcore.ResourceRef
-}
-
-func NewSuperglooRouter(ctx context.Context, provider string, flaggerClient clientset.Interface, logger *zap.SugaredLogger, cfg *rest.Config) (*SuperglooRouter, error) {
-	// TODO if cfg is nil use memory client instead?
-	sharedCache := kube.NewKubeCache(ctx)
-	routingRuleClient, err := supergloov1.NewRoutingRuleClient(&factory.KubeResourceClientFactory{
-		Crd:             supergloov1.RoutingRuleCrd,
-		Cfg:             cfg,
-		SharedCache:     sharedCache,
-		SkipCrdCreation: true,
-	})
-	if err != nil {
-		// this should never happen.
-		return nil, fmt.Errorf("creating RoutingRule client %v", err)
-	}
-	if err := routingRuleClient.Register(); err != nil {
-		return nil, err
-	}
-
-	// remove the supergloo: prefix
-	provider = strings.TrimPrefix(provider, "supergloo:")
-	// split name.namespace:
-	parts := strings.Split(provider, ".")
-	if len(parts) != 2 {
-		return nil, fmt.Errorf("invalid format for supergloo provider")
-	}
-	targetMesh := solokitcore.ResourceRef{
-		Namespace: parts[1],
-		Name:      parts[0],
-	}
-	return NewSuperglooRouterWithClient(ctx, routingRuleClient, targetMesh, logger), nil
-}
-
-func NewSuperglooRouterWithClient(ctx context.Context, routingRuleClient supergloov1.RoutingRuleClient, targetMesh solokitcore.ResourceRef, logger *zap.SugaredLogger) *SuperglooRouter {
-	return &SuperglooRouter{rrClient: routingRuleClient, logger: logger, targetMesh: targetMesh}
-}
-
-// Reconcile creates or updates the Istio virtual service
-func (sr *SuperglooRouter) Reconcile(canary *flaggerv1.Canary) error {
-
-	if err := sr.setRetries(canary); err != nil {
-		return err
-	}
-	if err := sr.setHeaders(canary); err != nil {
-		return err
-	}
-	if err := sr.setCors(canary); err != nil {
-		return err
-	}
-
-	// do we have routes already?
-	if _, _, _, err := sr.GetRoutes(canary); err == nil {
-		// we have routes, no need to do anything else
-		return nil
-	} else if solokiterror.IsNotExist(err) {
-		return sr.SetRoutes(canary, 100, 0, false)
-	} else {
-		return err
-	}
-}
-
-func (sr *SuperglooRouter) setRetries(canary *flaggerv1.Canary) error {
-	if canary.Spec.Service.Retries == nil {
-		return nil
-	}
-	retries, err := convertRetries(canary.Spec.Service.Retries)
-	if err != nil {
-		return err
-	}
-	rule := sr.createRule(canary, "retries", &supergloov1.RoutingRuleSpec{
-		RuleType: &supergloov1.RoutingRuleSpec_Retries{
-			Retries: retries,
-		},
-	})
-
-	return sr.writeRuleForCanary(canary, rule)
-}
-func (sr *SuperglooRouter) setHeaders(canary *flaggerv1.Canary) error {
-	if canary.Spec.Service.Headers == nil {
-		return nil
-	}
-	headerManipulation, err := convertHeaders(canary.Spec.Service.Headers)
-	if err != nil {
-		return err
-	}
-	if headerManipulation == nil {
-		return nil
-	}
-	rule := sr.createRule(canary, "headers", &supergloov1.RoutingRuleSpec{
-		RuleType: &supergloov1.RoutingRuleSpec_HeaderManipulation{
-			HeaderManipulation: headerManipulation,
-		},
-	})
-
-	return sr.writeRuleForCanary(canary, rule)
-}
-
-func convertHeaders(headers *istiov1alpha3.Headers) (*supergloov1.HeaderManipulation, error) {
-	var headersMaipulation *supergloov1.HeaderManipulation
-
-	if headers.Request != nil {
-		headersMaipulation = &supergloov1.HeaderManipulation{}
-
-		headersMaipulation.RemoveRequestHeaders = headers.Request.Remove
-		headersMaipulation.AppendRequestHeaders = make(map[string]string)
-		for k, v := range headers.Request.Add {
-			headersMaipulation.AppendRequestHeaders[k] = v
-		}
-	}
-	if headers.Response != nil {
-		if headersMaipulation == nil {
-			headersMaipulation = &supergloov1.HeaderManipulation{}
-		}
-
-		headersMaipulation.RemoveResponseHeaders = headers.Response.Remove
-		headersMaipulation.AppendResponseHeaders = make(map[string]string)
-		for k, v := range headers.Response.Add {
-			headersMaipulation.AppendResponseHeaders[k] = v
-		}
-	}
-
-	return headersMaipulation, nil
-}
-
-func convertRetries(retries *istiov1alpha3.HTTPRetry) (*supergloov1.RetryPolicy, error) {
-	perTryTimeout, err := time.ParseDuration(retries.PerTryTimeout)
-	return &supergloov1.RetryPolicy{
-		MaxRetries: &supergloov1alpha3.HTTPRetry{
-			Attempts:      int32(retries.Attempts),
-			PerTryTimeout: types.DurationProto(perTryTimeout),
-			RetryOn:       retries.RetryOn,
-		},
-	}, err
-}
-
-func (sr *SuperglooRouter) setCors(canary *flaggerv1.Canary) error {
-	corsPolicy := canary.Spec.Service.CorsPolicy
-	if corsPolicy == nil {
-		return nil
-	}
-	var maxAgeDuration *types.Duration
-	if maxAge, err := time.ParseDuration(corsPolicy.MaxAge); err == nil {
-		maxAgeDuration = types.DurationProto(maxAge)
-	}
-
-	rule := sr.createRule(canary, "cors", &supergloov1.RoutingRuleSpec{
-		RuleType: &supergloov1.RoutingRuleSpec_CorsPolicy{
-			CorsPolicy: &supergloov1alpha3.CorsPolicy{
-				AllowOrigin:      corsPolicy.AllowOrigin,
-				AllowMethods:     corsPolicy.AllowMethods,
-				AllowHeaders:     corsPolicy.AllowHeaders,
-				ExposeHeaders:    corsPolicy.ExposeHeaders,
-				MaxAge:           maxAgeDuration,
-				AllowCredentials: &types.BoolValue{Value: corsPolicy.AllowCredentials},
-			},
-		},
-	})
-	return sr.writeRuleForCanary(canary, rule)
-}
-
-func (sr *SuperglooRouter) createRule(canary *flaggerv1.Canary, namesuffix string, spec *supergloov1.RoutingRuleSpec) *supergloov1.RoutingRule {
-	if namesuffix != "" {
-		namesuffix = "-" + namesuffix
-	}
-	return &supergloov1.RoutingRule{
-		Metadata: solokitcore.Metadata{
-			Name:      canary.Spec.TargetRef.Name + namesuffix,
-			Namespace: canary.Namespace,
-		},
-		TargetMesh: &sr.targetMesh,
-		DestinationSelector: &supergloov1.PodSelector{
-			SelectorType: &supergloov1.PodSelector_UpstreamSelector_{
-				UpstreamSelector: &supergloov1.PodSelector_UpstreamSelector{
-					Upstreams: []solokitcore.ResourceRef{{
-						Name:      upstreamName(canary.Namespace, fmt.Sprintf("%s", canary.Spec.TargetRef.Name), canary.Spec.Service.Port),
-						Namespace: sr.targetMesh.Namespace,
-					}},
-				},
-			},
-		},
-		Spec: spec,
-	}
-}
-
-// GetRoutes returns the destinations weight for primary and canary
-func (sr *SuperglooRouter) GetRoutes(canary *flaggerv1.Canary) (
-	primaryWeight int,
-	canaryWeight int,
-	mirrored bool,
-	err error,
-) {
-	targetName := canary.Spec.TargetRef.Name
-	var rr *supergloov1.RoutingRule
-	rr, err = sr.rrClient.Read(canary.Namespace, targetName, solokitclients.ReadOpts{})
-	if err != nil {
-		return
-	}
-	traffic := rr.GetSpec().GetTrafficShifting()
-	if traffic == nil {
-		err = fmt.Errorf("target rule is not for traffic shifting")
-		return
-	}
-	dests := traffic.GetDestinations().GetDestinations()
-	for _, dest := range dests {
-		if dest.GetDestination().GetUpstream().Name == upstreamName(canary.Namespace, fmt.Sprintf("%s-primary", targetName), canary.Spec.Service.Port) {
-			primaryWeight = int(dest.Weight)
-		}
-		if dest.GetDestination().GetUpstream().Name == upstreamName(canary.Namespace, fmt.Sprintf("%s-canary", targetName), canary.Spec.Service.Port) {
-			canaryWeight = int(dest.Weight)
-		}
-	}
-
-	if primaryWeight == 0 && canaryWeight == 0 {
-		err = fmt.Errorf("RoutingRule %s.%s does not contain routes for %s-primary and %s-canary",
-			targetName, canary.Namespace, targetName, targetName)
-	}
-
-	mirrored = false
-
-	return
-}
-
-func upstreamName(serviceNamespace, serviceName string, port int32) string {
-	return fmt.Sprintf("%s-%s-%d", serviceNamespace, serviceName, port)
-}
-
-// SetRoutes updates the destinations weight for primary and canary
-func (sr *SuperglooRouter) SetRoutes(
-	canary *flaggerv1.Canary,
-	primaryWeight int,
-	canaryWeight int,
-	mirrored bool,
-) error {
-	// upstream name is
-	// in gloo-system
-	// and is the same as
-	targetName := canary.Spec.TargetRef.Name
-
-	destinations := []*gloov1.WeightedDestination{}
-	if primaryWeight != 0 {
-		destinations = append(destinations, &gloov1.WeightedDestination{
-			Destination: &gloov1.Destination{
-				Upstream: solokitcore.ResourceRef{
-					Name:      upstreamName(canary.Namespace, fmt.Sprintf("%s-primary", targetName), canary.Spec.Service.Port),
-					Namespace: sr.targetMesh.Namespace,
-				},
-			},
-			Weight: uint32(primaryWeight),
-		})
-	}
-
-	if canaryWeight != 0 {
-		destinations = append(destinations, &gloov1.WeightedDestination{
-			Destination: &gloov1.Destination{
-				Upstream: solokitcore.ResourceRef{
-					Name:      upstreamName(canary.Namespace, fmt.Sprintf("%s-canary", targetName), canary.Spec.Service.Port),
-					Namespace: sr.targetMesh.Namespace,
-				},
-			},
-			Weight: uint32(canaryWeight),
-		})
-	}
-
-	if len(destinations) == 0 {
-		return fmt.Errorf("RoutingRule %s.%s update failed: no valid weights", targetName, canary.Namespace)
-	}
-
-	rule := sr.createRule(canary, "", &supergloov1.RoutingRuleSpec{
-		RuleType: &supergloov1.RoutingRuleSpec_TrafficShifting{
-			TrafficShifting: &supergloov1.TrafficShifting{
-				Destinations: &gloov1.MultiDestination{
-					Destinations: destinations,
-				},
-			},
-		},
-	})
-
-	return sr.writeRuleForCanary(canary, rule)
-}
-
-func (sr *SuperglooRouter) writeRuleForCanary(canary *flaggerv1.Canary, rule *supergloov1.RoutingRule) error {
-	targetName := canary.Spec.TargetRef.Name
-
-	if oldRr, err := sr.rrClient.Read(rule.Metadata.Namespace, rule.Metadata.Name, solokitclients.ReadOpts{}); err != nil {
-		// ignore not exist errors..
-		if !solokiterror.IsNotExist(err) {
-			return fmt.Errorf("RoutingRule %s.%s read failed: %v", targetName, canary.Namespace, err)
-		}
-	} else {
-		rule.Metadata.ResourceVersion = oldRr.Metadata.ResourceVersion
-		// if the old and the new one are equal, no need to do anything.
-		oldRr.Status = solokitcore.Status{}
-		if oldRr.Equal(rule) {
-			return nil
-		}
-	}
-
-	kubeWriteOpts := &kube.KubeWriteOpts{
-		PreWriteCallback: func(r *crdv1.Resource) {
-			r.ObjectMeta.OwnerReferences = []metav1.OwnerReference{
-				*metav1.NewControllerRef(canary, schema.GroupVersionKind{
-					Group:   flaggerv1.SchemeGroupVersion.Group,
-					Version: flaggerv1.SchemeGroupVersion.Version,
-					Kind:    flaggerv1.CanaryKind,
-				}),
-			}
-		},
-	}
-	writeOpts := solokitclients.WriteOpts{OverwriteExisting: true, StorageWriteOpts: kubeWriteOpts}
-	_, err := sr.rrClient.Write(rule, writeOpts)
-	if err != nil {
-		return fmt.Errorf("RoutingRule %s.%s update failed: %v", targetName, canary.Namespace, err)
-	}
-	return nil
-}

pkg/router/supergloo_test.go

@@ -1,154 +0,0 @@
-package router
-
-import (
-	"context"
-	"fmt"
-	"testing"
-
-	gloov1 "github.com/solo-io/gloo/projects/gloo/pkg/api/v1"
-	solokitclients "github.com/solo-io/solo-kit/pkg/api/v1/clients"
-	"github.com/solo-io/solo-kit/pkg/api/v1/clients/factory"
-	solokitmemory "github.com/solo-io/solo-kit/pkg/api/v1/clients/memory"
-	solokitcore "github.com/solo-io/solo-kit/pkg/api/v1/resources/core"
-	supergloov1 "github.com/solo-io/supergloo/pkg/api/v1"
-)
-
-func TestSuperglooRouter_Sync(t *testing.T) {
-	mocks := setupfakeClients()
-
-	routingRuleClient, err := supergloov1.NewRoutingRuleClient(&factory.MemoryResourceClientFactory{
-		Cache: solokitmemory.NewInMemoryResourceCache(),
-	})
-	if err != nil {
-		t.Fatal(err.Error())
-	}
-	if err := routingRuleClient.Register(); err != nil {
-		t.Fatal(err.Error())
-	}
-	targetMesh := solokitcore.ResourceRef{
-		Namespace: "supergloo-system",
-		Name:      "mesh",
-	}
-	router := NewSuperglooRouterWithClient(context.TODO(), routingRuleClient, targetMesh, mocks.logger)
-	err = router.Reconcile(mocks.canary)
-	if err != nil {
-		t.Fatal(err.Error())
-	}
-
-	// test insert
-	rr, err := routingRuleClient.Read("default", "podinfo", solokitclients.ReadOpts{})
-	if err != nil {
-		t.Fatal(err.Error())
-	}
-	dests := rr.Spec.GetTrafficShifting().GetDestinations().GetDestinations()
-	if len(dests) != 1 {
-		t.Errorf("Got RoutingRule Destinations %v wanted %v", len(dests), 1)
-	}
-
-}
-
-func TestSuperglooRouter_SetRoutes(t *testing.T) {
-
-	mocks := setupfakeClients()
-
-	routingRuleClient, err := supergloov1.NewRoutingRuleClient(&factory.MemoryResourceClientFactory{
-		Cache: solokitmemory.NewInMemoryResourceCache(),
-	})
-	if err != nil {
-		t.Fatal(err.Error())
-	}
-	if err := routingRuleClient.Register(); err != nil {
-		t.Fatal(err.Error())
-	}
-	targetMesh := solokitcore.ResourceRef{
-		Namespace: "supergloo-system",
-		Name:      "mesh",
-	}
-	router := NewSuperglooRouterWithClient(context.TODO(), routingRuleClient, targetMesh, mocks.logger)
-
-	err = router.Reconcile(mocks.canary)
-	if err != nil {
-		t.Fatal(err.Error())
-	}
-
-	p, c, m, err := router.GetRoutes(mocks.canary)
-	if err != nil {
-		t.Fatal(err.Error())
-	}
-
-	p = 50
-	c = 50
-	m = false
-
-	err = router.SetRoutes(mocks.canary, p, c, m)
-	if err != nil {
-		t.Fatal(err.Error())
-	}
-
-	rr, err := routingRuleClient.Read("default", "podinfo", solokitclients.ReadOpts{})
-	if err != nil {
-		t.Fatal(err.Error())
-	}
-
-	var pRoute *gloov1.WeightedDestination
-	var cRoute *gloov1.WeightedDestination
-	targetName := mocks.canary.Spec.TargetRef.Name
-
-	for _, dest := range rr.GetSpec().GetTrafficShifting().GetDestinations().GetDestinations() {
-		if dest.GetDestination().GetUpstream().Name == upstreamName(mocks.canary.Namespace, fmt.Sprintf("%s-primary", targetName), mocks.canary.Spec.Service.Port) {
-			pRoute = dest
-		}
-		if dest.GetDestination().GetUpstream().Name == upstreamName(mocks.canary.Namespace, fmt.Sprintf("%s-canary", targetName), mocks.canary.Spec.Service.Port) {
-			cRoute = dest
-		}
-	}
-
-	if pRoute.Weight != uint32(p) {
-		t.Errorf("Got primary weight %v wanted %v", pRoute.Weight, p)
-	}
-
-	if cRoute.Weight != uint32(c) {
-		t.Errorf("Got canary weight %v wanted %v", cRoute.Weight, c)
-	}
-
-}
-
-func TestSuperglooRouter_GetRoutes(t *testing.T) {
-	mocks := setupfakeClients()
-
-	routingRuleClient, err := supergloov1.NewRoutingRuleClient(&factory.MemoryResourceClientFactory{
-		Cache: solokitmemory.NewInMemoryResourceCache(),
-	})
-	if err != nil {
-		t.Fatal(err.Error())
-	}
-	if err := routingRuleClient.Register(); err != nil {
-		t.Fatal(err.Error())
-	}
-	targetMesh := solokitcore.ResourceRef{
-		Namespace: "supergloo-system",
-		Name:      "mesh",
-	}
-	router := NewSuperglooRouterWithClient(context.TODO(), routingRuleClient, targetMesh, mocks.logger)
-	err = router.Reconcile(mocks.canary)
-	if err != nil {
-		t.Fatal(err.Error())
-	}
-
-	p, c, m, err := router.GetRoutes(mocks.canary)
-	if err != nil {
-		t.Fatal(err.Error())
-	}
-
-	if p != 100 {
-		t.Errorf("Got primary weight %v wanted %v", p, 100)
-	}
-
-	if c != 0 {
-		t.Errorf("Got canary weight %v wanted %v", c, 0)
-	}
-
-	if m != false {
-		t.Errorf("Got mirror %v wanted %v", m, false)
-	}
-}