Switch to github.com/golang/dep for vendoring

Signed-off-by: Mrunal Patel <mrunalp@gmail.com>

vendor/k8s.io/kubernetes/pkg/controller/route/BUILD

@@ -0,0 +1,62 @@
+package(default_visibility = ["//visibility:public"])
+
+licenses(["notice"])
+
+load(
+    "@io_bazel_rules_go//go:def.bzl",
+    "go_library",
+    "go_test",
+)
+
+go_library(
+    name = "go_default_library",
+    srcs = [
+        "doc.go",
+        "routecontroller.go",
+    ],
+    tags = ["automanaged"],
+    deps = [
+        "//pkg/api/v1:go_default_library",
+        "//pkg/client/cache:go_default_library",
+        "//pkg/client/clientset_generated/clientset:go_default_library",
+        "//pkg/cloudprovider:go_default_library",
+        "//pkg/controller:go_default_library",
+        "//pkg/util/metrics:go_default_library",
+        "//pkg/util/node:go_default_library",
+        "//vendor:github.com/golang/glog",
+        "//vendor:k8s.io/apimachinery/pkg/api/errors",
+        "//vendor:k8s.io/apimachinery/pkg/apis/meta/v1",
+        "//vendor:k8s.io/apimachinery/pkg/runtime",
+        "//vendor:k8s.io/apimachinery/pkg/types",
+        "//vendor:k8s.io/apimachinery/pkg/util/wait",
+        "//vendor:k8s.io/apimachinery/pkg/watch",
+    ],
+)
+
+go_test(
+    name = "go_default_test",
+    srcs = ["routecontroller_test.go"],
+    library = ":go_default_library",
+    tags = ["automanaged"],
+    deps = [
+        "//pkg/api/v1:go_default_library",
+        "//pkg/client/clientset_generated/clientset/fake:go_default_library",
+        "//pkg/client/testing/core:go_default_library",
+        "//pkg/cloudprovider:go_default_library",
+        "//pkg/cloudprovider/providers/fake:go_default_library",
+        "//vendor:k8s.io/apimachinery/pkg/types",
+    ],
+)
+
+filegroup(
+    name = "package-srcs",
+    srcs = glob(["**"]),
+    tags = ["automanaged"],
+    visibility = ["//visibility:private"],
+)
+
+filegroup(
+    name = "all-srcs",
+    srcs = [":package-srcs"],
+    tags = ["automanaged"],
+)

vendor/k8s.io/kubernetes/pkg/controller/route/OWNERS

@@ -0,0 +1,3 @@
+reviewers:
+- gmarek
+- wojtek-t

vendor/k8s.io/kubernetes/pkg/controller/route/doc.go

@@ -0,0 +1,19 @@
+/*
+Copyright 2015 The Kubernetes 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 route contains code for syncing cloud routing rules with
+// the list of registered nodes.
+package route // import "k8s.io/kubernetes/pkg/controller/route"

vendor/k8s.io/kubernetes/pkg/controller/route/routecontroller.go

@@ -0,0 +1,249 @@
+/*
+Copyright 2015 The Kubernetes 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 route
+
+import (
+	"fmt"
+	"net"
+	"sync"
+	"time"
+
+	"github.com/golang/glog"
+	"k8s.io/apimachinery/pkg/api/errors"
+	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
+	"k8s.io/apimachinery/pkg/runtime"
+	"k8s.io/apimachinery/pkg/types"
+	"k8s.io/apimachinery/pkg/util/wait"
+	"k8s.io/apimachinery/pkg/watch"
+	"k8s.io/kubernetes/pkg/api/v1"
+	"k8s.io/kubernetes/pkg/client/cache"
+	"k8s.io/kubernetes/pkg/client/clientset_generated/clientset"
+	"k8s.io/kubernetes/pkg/cloudprovider"
+	"k8s.io/kubernetes/pkg/controller"
+	"k8s.io/kubernetes/pkg/util/metrics"
+	nodeutil "k8s.io/kubernetes/pkg/util/node"
+)
+
+const (
+	// Maximal number of concurrent CreateRoute API calls.
+	// TODO: This should be per-provider.
+	maxConcurrentRouteCreations int = 200
+	// Maximum number of retries of route creations.
+	maxRetries int = 5
+	// Maximum number of retries of node status update.
+	updateNodeStatusMaxRetries int = 3
+)
+
+type RouteController struct {
+	routes      cloudprovider.Routes
+	kubeClient  clientset.Interface
+	clusterName string
+	clusterCIDR *net.IPNet
+	// Node framework and store
+	nodeController cache.Controller
+	nodeStore      cache.StoreToNodeLister
+}
+
+func New(routes cloudprovider.Routes, kubeClient clientset.Interface, clusterName string, clusterCIDR *net.IPNet) *RouteController {
+	if kubeClient != nil && kubeClient.Core().RESTClient().GetRateLimiter() != nil {
+		metrics.RegisterMetricAndTrackRateLimiterUsage("route_controller", kubeClient.Core().RESTClient().GetRateLimiter())
+	}
+	rc := &RouteController{
+		routes:      routes,
+		kubeClient:  kubeClient,
+		clusterName: clusterName,
+		clusterCIDR: clusterCIDR,
+	}
+
+	rc.nodeStore.Store, rc.nodeController = cache.NewInformer(
+		&cache.ListWatch{
+			ListFunc: func(options v1.ListOptions) (runtime.Object, error) {
+				return rc.kubeClient.Core().Nodes().List(options)
+			},
+			WatchFunc: func(options v1.ListOptions) (watch.Interface, error) {
+				return rc.kubeClient.Core().Nodes().Watch(options)
+			},
+		},
+		&v1.Node{},
+		controller.NoResyncPeriodFunc(),
+		cache.ResourceEventHandlerFuncs{},
+	)
+
+	return rc
+}
+
+func (rc *RouteController) Run(syncPeriod time.Duration) {
+	go rc.nodeController.Run(wait.NeverStop)
+
+	// TODO: If we do just the full Resync every 5 minutes (default value)
+	// that means that we may wait up to 5 minutes before even starting
+	// creating a route for it. This is bad.
+	// We should have a watch on node and if we observe a new node (with CIDR?)
+	// trigger reconciliation for that node.
+	go wait.NonSlidingUntil(func() {
+		if err := rc.reconcileNodeRoutes(); err != nil {
+			glog.Errorf("Couldn't reconcile node routes: %v", err)
+		}
+	}, syncPeriod, wait.NeverStop)
+}
+
+func (rc *RouteController) reconcileNodeRoutes() error {
+	routeList, err := rc.routes.ListRoutes(rc.clusterName)
+	if err != nil {
+		return fmt.Errorf("error listing routes: %v", err)
+	}
+	if !rc.nodeController.HasSynced() {
+		return fmt.Errorf("nodeController is not yet synced")
+	}
+	nodeList, err := rc.nodeStore.List()
+	if err != nil {
+		return fmt.Errorf("error listing nodes: %v", err)
+	}
+	return rc.reconcile(nodeList.Items, routeList)
+}
+
+func (rc *RouteController) reconcile(nodes []v1.Node, routes []*cloudprovider.Route) error {
+	// nodeCIDRs maps nodeName->nodeCIDR
+	nodeCIDRs := make(map[types.NodeName]string)
+	// routeMap maps routeTargetNode->route
+	routeMap := make(map[types.NodeName]*cloudprovider.Route)
+	for _, route := range routes {
+		routeMap[route.TargetNode] = route
+	}
+
+	wg := sync.WaitGroup{}
+	rateLimiter := make(chan struct{}, maxConcurrentRouteCreations)
+
+	for _, node := range nodes {
+		// Skip if the node hasn't been assigned a CIDR yet.
+		if node.Spec.PodCIDR == "" {
+			continue
+		}
+		nodeName := types.NodeName(node.Name)
+		// Check if we have a route for this node w/ the correct CIDR.
+		r := routeMap[nodeName]
+		if r == nil || r.DestinationCIDR != node.Spec.PodCIDR {
+			// If not, create the route.
+			route := &cloudprovider.Route{
+				TargetNode:      nodeName,
+				DestinationCIDR: node.Spec.PodCIDR,
+			}
+			nameHint := string(node.UID)
+			wg.Add(1)
+			go func(nodeName types.NodeName, nameHint string, route *cloudprovider.Route) {
+				defer wg.Done()
+				for i := 0; i < maxRetries; i++ {
+					startTime := time.Now()
+					// Ensure that we don't have more than maxConcurrentRouteCreations
+					// CreateRoute calls in flight.
+					rateLimiter <- struct{}{}
+					glog.Infof("Creating route for node %s %s with hint %s, throttled %v", nodeName, route.DestinationCIDR, nameHint, time.Now().Sub(startTime))
+					err := rc.routes.CreateRoute(rc.clusterName, nameHint, route)
+					<-rateLimiter
+
+					rc.updateNetworkingCondition(nodeName, err == nil)
+					if err != nil {
+						glog.Errorf("Could not create route %s %s for node %s after %v: %v", nameHint, route.DestinationCIDR, nodeName, time.Now().Sub(startTime), err)
+					} else {
+						glog.Infof("Created route for node %s %s with hint %s after %v", nodeName, route.DestinationCIDR, nameHint, time.Now().Sub(startTime))
+						return
+					}
+				}
+			}(nodeName, nameHint, route)
+		} else {
+			// Update condition only if it doesn't reflect the current state.
+			_, condition := v1.GetNodeCondition(&node.Status, v1.NodeNetworkUnavailable)
+			if condition == nil || condition.Status != v1.ConditionFalse {
+				rc.updateNetworkingCondition(types.NodeName(node.Name), true)
+			}
+		}
+		nodeCIDRs[nodeName] = node.Spec.PodCIDR
+	}
+	for _, route := range routes {
+		if rc.isResponsibleForRoute(route) {
+			// Check if this route applies to a node we know about & has correct CIDR.
+			if nodeCIDRs[route.TargetNode] != route.DestinationCIDR {
+				wg.Add(1)
+				// Delete the route.
+				go func(route *cloudprovider.Route, startTime time.Time) {
+					glog.Infof("Deleting route %s %s", route.Name, route.DestinationCIDR)
+					if err := rc.routes.DeleteRoute(rc.clusterName, route); err != nil {
+						glog.Errorf("Could not delete route %s %s after %v: %v", route.Name, route.DestinationCIDR, time.Now().Sub(startTime), err)
+					} else {
+						glog.Infof("Deleted route %s %s after %v", route.Name, route.DestinationCIDR, time.Now().Sub(startTime))
+					}
+					wg.Done()
+
+				}(route, time.Now())
+			}
+		}
+	}
+	wg.Wait()
+	return nil
+}
+
+func (rc *RouteController) updateNetworkingCondition(nodeName types.NodeName, routeCreated bool) error {
+	var err error
+	for i := 0; i < updateNodeStatusMaxRetries; i++ {
+		// Patch could also fail, even though the chance is very slim. So we still do
+		// patch in the retry loop.
+		currentTime := metav1.Now()
+		if routeCreated {
+			err = nodeutil.SetNodeCondition(rc.kubeClient, nodeName, v1.NodeCondition{
+				Type:               v1.NodeNetworkUnavailable,
+				Status:             v1.ConditionFalse,
+				Reason:             "RouteCreated",
+				Message:            "RouteController created a route",
+				LastTransitionTime: currentTime,
+			})
+		} else {
+			err = nodeutil.SetNodeCondition(rc.kubeClient, nodeName, v1.NodeCondition{
+				Type:               v1.NodeNetworkUnavailable,
+				Status:             v1.ConditionTrue,
+				Reason:             "NoRouteCreated",
+				Message:            "RouteController failed to create a route",
+				LastTransitionTime: currentTime,
+			})
+		}
+		if err == nil {
+			return nil
+		}
+		if i == updateNodeStatusMaxRetries || !errors.IsConflict(err) {
+			glog.Errorf("Error updating node %s: %v", nodeName, err)
+			return err
+		}
+		glog.Errorf("Error updating node %s, retrying: %v", nodeName, err)
+	}
+	return err
+}
+
+func (rc *RouteController) isResponsibleForRoute(route *cloudprovider.Route) bool {
+	_, cidr, err := net.ParseCIDR(route.DestinationCIDR)
+	if err != nil {
+		glog.Errorf("Ignoring route %s, unparsable CIDR: %v", route.Name, err)
+		return false
+	}
+	// Not responsible if this route's CIDR is not within our clusterCIDR
+	lastIP := make([]byte, len(cidr.IP))
+	for i := range lastIP {
+		lastIP[i] = cidr.IP[i] | ^cidr.Mask[i]
+	}
+	if !rc.clusterCIDR.Contains(cidr.IP) || !rc.clusterCIDR.Contains(lastIP) {
+		return false
+	}
+	return true
+}

vendor/k8s.io/kubernetes/pkg/controller/route/routecontroller_test.go

@@ -0,0 +1,267 @@
+/*
+Copyright 2015 The Kubernetes 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 route
+
+import (
+	"net"
+	"testing"
+	"time"
+
+	"k8s.io/apimachinery/pkg/types"
+	"k8s.io/kubernetes/pkg/api/v1"
+	"k8s.io/kubernetes/pkg/client/clientset_generated/clientset/fake"
+	"k8s.io/kubernetes/pkg/client/testing/core"
+	"k8s.io/kubernetes/pkg/cloudprovider"
+	fakecloud "k8s.io/kubernetes/pkg/cloudprovider/providers/fake"
+)
+
+func TestIsResponsibleForRoute(t *testing.T) {
+	myClusterName := "my-awesome-cluster"
+	myClusterRoute := "my-awesome-cluster-12345678-90ab-cdef-1234-567890abcdef"
+	testCases := []struct {
+		clusterCIDR         string
+		routeName           string
+		routeCIDR           string
+		expectedResponsible bool
+	}{
+		// Routes that belong to this cluster
+		{"10.244.0.0/16", myClusterRoute, "10.244.0.0/24", true},
+		{"10.244.0.0/16", myClusterRoute, "10.244.10.0/24", true},
+		{"10.244.0.0/16", myClusterRoute, "10.244.255.0/24", true},
+		{"10.244.0.0/14", myClusterRoute, "10.244.0.0/24", true},
+		{"10.244.0.0/14", myClusterRoute, "10.247.255.0/24", true},
+		// Routes that match our naming/tagging scheme, but are outside our cidr
+		{"10.244.0.0/16", myClusterRoute, "10.224.0.0/24", false},
+		{"10.244.0.0/16", myClusterRoute, "10.0.10.0/24", false},
+		{"10.244.0.0/16", myClusterRoute, "10.255.255.0/24", false},
+		{"10.244.0.0/14", myClusterRoute, "10.248.0.0/24", false},
+		{"10.244.0.0/14", myClusterRoute, "10.243.255.0/24", false},
+	}
+	for i, testCase := range testCases {
+		_, cidr, err := net.ParseCIDR(testCase.clusterCIDR)
+		if err != nil {
+			t.Errorf("%d. Error in test case: unparsable cidr %q", i, testCase.clusterCIDR)
+		}
+		rc := New(nil, nil, myClusterName, cidr)
+		route := &cloudprovider.Route{
+			Name:            testCase.routeName,
+			TargetNode:      types.NodeName("doesnt-matter-for-this-test"),
+			DestinationCIDR: testCase.routeCIDR,
+		}
+		if resp := rc.isResponsibleForRoute(route); resp != testCase.expectedResponsible {
+			t.Errorf("%d. isResponsibleForRoute() = %t; want %t", i, resp, testCase.expectedResponsible)
+		}
+	}
+}
+
+func TestReconcile(t *testing.T) {
+	cluster := "my-k8s"
+	node1 := v1.Node{ObjectMeta: v1.ObjectMeta{Name: "node-1", UID: "01"}, Spec: v1.NodeSpec{PodCIDR: "10.120.0.0/24"}}
+	node2 := v1.Node{ObjectMeta: v1.ObjectMeta{Name: "node-2", UID: "02"}, Spec: v1.NodeSpec{PodCIDR: "10.120.1.0/24"}}
+	nodeNoCidr := v1.Node{ObjectMeta: v1.ObjectMeta{Name: "node-2", UID: "02"}, Spec: v1.NodeSpec{PodCIDR: ""}}
+
+	testCases := []struct {
+		nodes                      []v1.Node
+		initialRoutes              []*cloudprovider.Route
+		expectedRoutes             []*cloudprovider.Route
+		expectedNetworkUnavailable []bool
+		clientset                  *fake.Clientset
+	}{
+		// 2 nodes, routes already there
+		{
+			nodes: []v1.Node{
+				node1,
+				node2,
+			},
+			initialRoutes: []*cloudprovider.Route{
+				{cluster + "-01", "node-1", "10.120.0.0/24"},
+				{cluster + "-02", "node-2", "10.120.1.0/24"},
+			},
+			expectedRoutes: []*cloudprovider.Route{
+				{cluster + "-01", "node-1", "10.120.0.0/24"},
+				{cluster + "-02", "node-2", "10.120.1.0/24"},
+			},
+			expectedNetworkUnavailable: []bool{true, true},
+			clientset:                  fake.NewSimpleClientset(&v1.NodeList{Items: []v1.Node{node1, node2}}),
+		},
+		// 2 nodes, one route already there
+		{
+			nodes: []v1.Node{
+				node1,
+				node2,
+			},
+			initialRoutes: []*cloudprovider.Route{
+				{cluster + "-01", "node-1", "10.120.0.0/24"},
+			},
+			expectedRoutes: []*cloudprovider.Route{
+				{cluster + "-01", "node-1", "10.120.0.0/24"},
+				{cluster + "-02", "node-2", "10.120.1.0/24"},
+			},
+			expectedNetworkUnavailable: []bool{true, true},
+			clientset:                  fake.NewSimpleClientset(&v1.NodeList{Items: []v1.Node{node1, node2}}),
+		},
+		// 2 nodes, no routes yet
+		{
+			nodes: []v1.Node{
+				node1,
+				node2,
+			},
+			initialRoutes: []*cloudprovider.Route{},
+			expectedRoutes: []*cloudprovider.Route{
+				{cluster + "-01", "node-1", "10.120.0.0/24"},
+				{cluster + "-02", "node-2", "10.120.1.0/24"},
+			},
+			expectedNetworkUnavailable: []bool{true, true},
+			clientset:                  fake.NewSimpleClientset(&v1.NodeList{Items: []v1.Node{node1, node2}}),
+		},
+		// 2 nodes, a few too many routes
+		{
+			nodes: []v1.Node{
+				node1,
+				node2,
+			},
+			initialRoutes: []*cloudprovider.Route{
+				{cluster + "-01", "node-1", "10.120.0.0/24"},
+				{cluster + "-02", "node-2", "10.120.1.0/24"},
+				{cluster + "-03", "node-3", "10.120.2.0/24"},
+				{cluster + "-04", "node-4", "10.120.3.0/24"},
+			},
+			expectedRoutes: []*cloudprovider.Route{
+				{cluster + "-01", "node-1", "10.120.0.0/24"},
+				{cluster + "-02", "node-2", "10.120.1.0/24"},
+			},
+			expectedNetworkUnavailable: []bool{true, true},
+			clientset:                  fake.NewSimpleClientset(&v1.NodeList{Items: []v1.Node{node1, node2}}),
+		},
+		// 2 nodes, 2 routes, but only 1 is right
+		{
+			nodes: []v1.Node{
+				node1,
+				node2,
+			},
+			initialRoutes: []*cloudprovider.Route{
+				{cluster + "-01", "node-1", "10.120.0.0/24"},
+				{cluster + "-03", "node-3", "10.120.2.0/24"},
+			},
+			expectedRoutes: []*cloudprovider.Route{
+				{cluster + "-01", "node-1", "10.120.0.0/24"},
+				{cluster + "-02", "node-2", "10.120.1.0/24"},
+			},
+			expectedNetworkUnavailable: []bool{true, true},
+			clientset:                  fake.NewSimpleClientset(&v1.NodeList{Items: []v1.Node{node1, node2}}),
+		},
+		// 2 nodes, one node without CIDR assigned.
+		{
+			nodes: []v1.Node{
+				node1,
+				nodeNoCidr,
+			},
+			initialRoutes: []*cloudprovider.Route{},
+			expectedRoutes: []*cloudprovider.Route{
+				{cluster + "-01", "node-1", "10.120.0.0/24"},
+			},
+			expectedNetworkUnavailable: []bool{true, false},
+			clientset:                  fake.NewSimpleClientset(&v1.NodeList{Items: []v1.Node{node1, nodeNoCidr}}),
+		},
+	}
+	for i, testCase := range testCases {
+		cloud := &fakecloud.FakeCloud{RouteMap: make(map[string]*fakecloud.FakeRoute)}
+		for _, route := range testCase.initialRoutes {
+			fakeRoute := &fakecloud.FakeRoute{}
+			fakeRoute.ClusterName = cluster
+			fakeRoute.Route = *route
+			cloud.RouteMap[route.Name] = fakeRoute
+		}
+		routes, ok := cloud.Routes()
+		if !ok {
+			t.Error("Error in test: fakecloud doesn't support Routes()")
+		}
+		_, cidr, _ := net.ParseCIDR("10.120.0.0/16")
+		rc := New(routes, testCase.clientset, cluster, cidr)
+		if err := rc.reconcile(testCase.nodes, testCase.initialRoutes); err != nil {
+			t.Errorf("%d. Error from rc.reconcile(): %v", i, err)
+		}
+		for _, action := range testCase.clientset.Actions() {
+			if action.GetVerb() == "update" && action.GetResource().Resource == "nodes" {
+				node := action.(core.UpdateAction).GetObject().(*v1.Node)
+				_, condition := v1.GetNodeCondition(&node.Status, v1.NodeNetworkUnavailable)
+				if condition == nil {
+					t.Errorf("%d. Missing NodeNetworkUnavailable condition for Node %v", i, node.Name)
+				} else {
+					check := func(index int) bool {
+						return (condition.Status == v1.ConditionFalse) == testCase.expectedNetworkUnavailable[index]
+					}
+					index := -1
+					for j := range testCase.nodes {
+						if testCase.nodes[j].Name == node.Name {
+							index = j
+						}
+					}
+					if index == -1 {
+						// Something's wrong
+						continue
+					}
+					if !check(index) {
+						t.Errorf("%d. Invalid NodeNetworkUnavailable condition for Node %v, expected %v, got %v",
+							i, node.Name, testCase.expectedNetworkUnavailable[index], (condition.Status == v1.ConditionFalse))
+					}
+				}
+			}
+		}
+		var finalRoutes []*cloudprovider.Route
+		var err error
+		timeoutChan := time.After(200 * time.Millisecond)
+		tick := time.NewTicker(10 * time.Millisecond)
+		defer tick.Stop()
+	poll:
+		for {
+			select {
+			case <-tick.C:
+				if finalRoutes, err = routes.ListRoutes(cluster); err == nil && routeListEqual(finalRoutes, testCase.expectedRoutes) {
+					break poll
+				}
+			case <-timeoutChan:
+				t.Errorf("%d. rc.reconcile() = %v, routes:\n%v\nexpected: nil, routes:\n%v\n", i, err, flatten(finalRoutes), flatten(testCase.expectedRoutes))
+				break poll
+			}
+		}
+	}
+}
+
+func routeListEqual(list1, list2 []*cloudprovider.Route) bool {
+	if len(list1) != len(list2) {
+		return false
+	}
+	routeMap1 := make(map[string]*cloudprovider.Route)
+	for _, route1 := range list1 {
+		routeMap1[route1.Name] = route1
+	}
+	for _, route2 := range list2 {
+		if route1, exists := routeMap1[route2.Name]; !exists || *route1 != *route2 {
+			return false
+		}
+	}
+	return true
+}
+
+func flatten(list []*cloudprovider.Route) []cloudprovider.Route {
+	var structList []cloudprovider.Route
+	for _, route := range list {
+		structList = append(structList, *route)
+	}
+	return structList
+}