feature: zone aware routing - Option 1

dataclients/kubernetes/ingressv1.go

@@ -151,7 +151,7 @@ func convertPathRuleV1(
 	r := &eskip.Route{
 		Id:          routeID(ns, name, host, prule.Path, svcName),
 		BackendType: eskip.LBBackend,
-		LBEndpoints: eps,
+		LBEndpoints: eskip.NewLBEndpoints(eps),
 		LBAlgorithm: getLoadBalancerAlgorithm(metadata, defaultLoadBalancerAlgorithm),
 		HostRegexps: hostRegexp,
 	}
@@ -397,7 +397,7 @@ func (ing *ingress) convertDefaultBackendV1(
 	return &eskip.Route{
 		Id:          routeID(ns, name, "", "", ""),
 		BackendType: eskip.LBBackend,
-		LBEndpoints: eps,
+		LBEndpoints: eskip.NewLBEndpoints(eps),
 		LBAlgorithm: getLoadBalancerAlgorithm(i.Metadata, ing.defaultLoadBalancerAlgorithm),
 	}, true, nil
 }

dataclients/kubernetes/routegroup.go

@@ -208,7 +208,7 @@ func applyServiceBackend(ctx *routeGroupContext, backend *definitions.SkipperBac
 	}
 
 	r.BackendType = eskip.LBBackend
-	r.LBEndpoints = eps
+	r.LBEndpoints = eskip.NewLBEndpoints(eps)
 	r.LBAlgorithm = ctx.defaultLoadBalancerAlgorithm
 	if backend.Algorithm != loadbalancer.None {
 		r.LBAlgorithm = backend.Algorithm.String()
@@ -261,7 +261,7 @@ func applyBackend(ctx *routeGroupContext, backend *definitions.SkipperBackend, r
 			}
 		}
 
-		r.LBEndpoints = backend.Endpoints
+		r.LBEndpoints = eskip.NewLBEndpoints(backend.Endpoints)
 		r.LBAlgorithm = ctx.defaultLoadBalancerAlgorithm
 		if backend.Algorithm != loadbalancer.None {
 			r.LBAlgorithm = backend.Algorithm.String()

eskip/copy.go

@@ -65,7 +65,7 @@ func Copy(r *Route) *Route {
 	c.BackendType = r.BackendType
 	c.Backend = r.Backend
 	c.LBAlgorithm = r.LBAlgorithm
-	c.LBEndpoints = make([]string, len(r.LBEndpoints))
+	c.LBEndpoints = make([]*LBEndpoint, len(r.LBEndpoints))
 	copy(c.LBEndpoints, r.LBEndpoints)
 	return c
 }

eskip/copy_test.go

@@ -42,7 +42,7 @@ func TestCopy(t *testing.T) {
 			checkFilter(t, c.Filters[i], r.Filters[i])
 		}
 
-		r.LBEndpoints[0] = "test-slice-identity"
+		r.LBEndpoints[0] = &LBEndpoint{Address: "test-slice-identity"}
 		if c.LBEndpoints[0] == r.LBEndpoints[0] {
 			t.Error("failed to copy LB endpoints")
 		}
@@ -132,7 +132,10 @@ func TestCopy(t *testing.T) {
 				},
 				BackendType: LBBackend,
 				LBAlgorithm: "roundRobin",
-				LBEndpoints: []string{"10.0.0.1:80", "10.0.0.2:80"},
+				LBEndpoints: []*LBEndpoint{
+					{Address: "10.0.0.1:80"},
+					{Address: "10.0.0.2:80"},
+				},
 			}
 
 			c := Copy(r)
@@ -154,7 +157,10 @@ func TestCopy(t *testing.T) {
 				},
 				BackendType: LBBackend,
 				LBAlgorithm: "roundRobin",
-				LBEndpoints: []string{"10.0.1.1:80", "10.0.1.2:80"},
+				LBEndpoints: []*LBEndpoint{
+					{Address: "10.0.1.1:80"},
+					{Address: "10.0.1.2:80"},
+				},
 			}, {
 				Id: "route2",
 				Predicates: []*Predicate{
@@ -169,7 +175,10 @@ func TestCopy(t *testing.T) {
 				},
 				BackendType: LBBackend,
 				LBAlgorithm: "roundRobin",
-				LBEndpoints: []string{"10.0.2.1:80", "10.0.2.2:80"},
+				LBEndpoints: []*LBEndpoint{
+					{Address: "10.0.2.1:80"},
+					{Address: "10.0.2.2:80"},
+				},
 			}, {
 				Id: "route3",
 				Predicates: []*Predicate{
@@ -184,7 +193,10 @@ func TestCopy(t *testing.T) {
 				},
 				BackendType: LBBackend,
 				LBAlgorithm: "roundRobin",
-				LBEndpoints: []string{"10.0.3.1:80", "10.0.3.2:80"},
+				LBEndpoints: []*LBEndpoint{
+					{Address: "10.0.3.1:80"},
+					{Address: "10.0.3.2:80"},
+				},
 			}}
 
 			c := CopyRoutes(r)

eskip/eq.go

@@ -40,13 +40,13 @@ func eqArgs(left, right []interface{}) bool {
 	return true
 }
 
-func eqStrings(left, right []string) bool {
+func eqLBEndpoints(left, right []*LBEndpoint) bool {
 	if len(left) != len(right) {
 		return false
 	}
 
 	for i := range left {
-		if left[i] != right[i] {
+		if left[i].Address != right[i].Address || left[i].Zone != right[i].Zone {
 			return false
 		}
 	}
@@ -103,7 +103,7 @@ func eq2(left, right *Route) bool {
 		return false
 	}
 
-	if !eqStrings(lc.LBEndpoints, rc.LBEndpoints) {
+	if !eqLBEndpoints(lc.LBEndpoints, rc.LBEndpoints) {
 		return false
 	}
 
@@ -255,9 +255,11 @@ func Canonical(r *Route) *Route {
 	case LBBackend:
 		// using the LB fields only when apply:
 		c.LBAlgorithm = r.LBAlgorithm
-		c.LBEndpoints = make([]string, len(r.LBEndpoints))
+		c.LBEndpoints = make([]*LBEndpoint, len(r.LBEndpoints))
 		copy(c.LBEndpoints, r.LBEndpoints)
-		sort.Strings(c.LBEndpoints)
+		sort.Slice(c.LBEndpoints, func(i, j int) bool {
+			return c.LBEndpoints[i].Address < c.LBEndpoints[j].Address
+		})
 	}
 
 	// Name and Namespace stripped

eskip/eq_test.go

@@ -99,14 +99,14 @@ func TestEq(t *testing.T) {
 	}, {
 		title: "non-eq lb endpoint count",
 		routes: []*Route{
-			{BackendType: LBBackend, LBEndpoints: []string{"", ""}},
-			{BackendType: LBBackend, LBEndpoints: []string{""}},
+			{BackendType: LBBackend, LBEndpoints: []*LBEndpoint{{Address: "https://one.example.org"}, {Address: "https://one.example.org"}}},
+			{BackendType: LBBackend, LBEndpoints: []*LBEndpoint{{Address: "https://one.example.org"}}},
 		},
 	}, {
 		title: "non-eq lb endpoints",
 		routes: []*Route{
-			{BackendType: LBBackend, LBEndpoints: []string{"https://one.example.org"}},
-			{BackendType: LBBackend, LBEndpoints: []string{"https://two.example.org"}},
+			{BackendType: LBBackend, LBEndpoints: []*LBEndpoint{{Address: "https://one.example.org"}}},
+			{BackendType: LBBackend, LBEndpoints: []*LBEndpoint{{Address: "https://two.example.org"}}},
 		},
 	}, {
 		title: "all eq",
@@ -116,14 +116,14 @@ func TestEq(t *testing.T) {
 			Filters:     []*Filter{{Name: "foo", Args: []interface{}{3, 4}}},
 			BackendType: LBBackend,
 			LBAlgorithm: "random",
-			LBEndpoints: []string{"https://one.example.org", "https://two.example.org"},
+			LBEndpoints: []*LBEndpoint{{Address: "https://one.example.org"}, {Address: "https://two.example.org"}},
 		}, {
 			Id:          "foo",
 			Predicates:  []*Predicate{{Name: "Foo", Args: []interface{}{1, 2}}},
 			Filters:     []*Filter{{Name: "foo", Args: []interface{}{3, 4}}},
 			BackendType: LBBackend,
 			LBAlgorithm: "random",
-			LBEndpoints: []string{"https://one.example.org", "https://two.example.org"},
+			LBEndpoints: []*LBEndpoint{{Address: "https://one.example.org"}, {Address: "https://two.example.org"}},
 		}},
 		expect: true,
 	}, {
@@ -282,7 +282,7 @@ func TestCanonical(t *testing.T) {
 		expect: &Route{BackendType: NetworkBackend, Backend: "https://www.example.org"},
 	}, {
 		title:  "clear LB when different type",
-		route:  &Route{LBEndpoints: []string{"https://one.example.org", "https://two.example.org"}},
+		route:  &Route{LBEndpoints: []*LBEndpoint{{Address: "https://one.example.org"}, {Address: "https://two.example.org"}}},
 		expect: &Route{},
 	}} {
 		t.Run(test.title, func(t *testing.T) {

eskip/eskip.go

@@ -321,7 +321,7 @@ type Route struct {
 
 	// LBEndpoints stores one or more backend endpoint in case of
 	// load balancing backends.
-	LBEndpoints []string
+	LBEndpoints []*LBEndpoint
 
 	// Name is deprecated and not used.
 	Name string
@@ -330,6 +330,43 @@ type Route struct {
 	Namespace string
 }
 
+func NewLBEndpoints(eps []string) []*LBEndpoint {
+	if len(eps) == 0 {
+		return nil
+	}
+	result := make([]*LBEndpoint, len(eps))
+
+	for i := 0; i < len(eps); i++ {
+		result[i] = &LBEndpoint{
+			Address: eps[i],
+		}
+	}
+
+	return result
+}
+
+func LBEndpointString(eps []*LBEndpoint) []string {
+	if len(eps) == 0 {
+		return nil
+	}
+	result := make([]string, len(eps))
+
+	for i := 0; i < len(eps); i++ {
+		result[i] = eps[i].String()
+	}
+
+	return result
+}
+
+type LBEndpoint struct {
+	Address string
+	Zone    string
+}
+
+func (ep LBEndpoint) String() string {
+	return ep.Address
+}
+
 type RoutePredicate func(*Route) bool
 
 // RouteInfo contains a route id, plus the loaded and parsed route or
@@ -402,7 +439,7 @@ func (r *Route) Copy() *Route {
 	}
 
 	if len(r.LBEndpoints) > 0 {
-		c.LBEndpoints = make([]string, len(r.LBEndpoints))
+		c.LBEndpoints = make([]*LBEndpoint, len(r.LBEndpoints))
 		copy(c.LBEndpoints, r.LBEndpoints)
 	}
 
@@ -561,7 +598,7 @@ func newRouteDefinition(r *parsedRoute) (*Route, error) {
 	rd.Shunt = r.shunt
 	rd.Backend = r.backend
 	rd.LBAlgorithm = r.lbAlgorithm
-	rd.LBEndpoints = r.lbEndpoints
+	rd.LBEndpoints = NewLBEndpoints(r.lbEndpoints)
 
 	switch {
 	case r.shunt:

eskip/json.go

@@ -37,7 +37,7 @@ func newJSONRoute(r *Route) *jsonRoute {
 			Type:      cr.BackendType.String(),
 			Address:   cr.Backend,
 			Algorithm: cr.LBAlgorithm,
-			Endpoints: cr.LBEndpoints,
+			Endpoints: LBEndpointString(cr.LBEndpoints),
 		}
 	}
 
@@ -94,7 +94,7 @@ func (r *Route) UnmarshalJSON(b []byte) error {
 		}
 	case LBBackend:
 		r.LBAlgorithm = jr.Backend.Algorithm
-		r.LBEndpoints = jr.Backend.Endpoints
+		r.LBEndpoints = NewLBEndpoints(jr.Backend.Endpoints)
 		if len(r.LBEndpoints) == 0 {
 			r.LBEndpoints = nil
 		}

eskip/json_test.go

@@ -88,7 +88,7 @@ func TestMarshalUnmarshalJSON(t *testing.T) {
 		},
 		{
 			"lb backend",
-			[]*Route{{Id: "beef", BackendType: LBBackend, LBAlgorithm: "yolo", LBEndpoints: []string{"localhost"}}},
+			[]*Route{{Id: "beef", BackendType: LBBackend, LBAlgorithm: "yolo", LBEndpoints: []*LBEndpoint{{Address: "localhost"}}}},
 			`[{"id":"beef","backend":{"type":"lb","algorithm":"yolo","endpoints":["localhost"]}}]`,
 		},
 		{

eskip/parser_test.go

@@ -255,7 +255,7 @@ func TestLBBackend(t *testing.T) {
 		code:  `* -> <"https://example.org">`,
 		expectedResult: []*Route{{
 			BackendType: LBBackend,
-			LBEndpoints: []string{"https://example.org"},
+			LBEndpoints: []*LBEndpoint{{Address: "https://example.org"}},
 		}},
 	}, {
 		title: "multiple endpoints, default algorithm",
@@ -264,10 +264,10 @@ func TestLBBackend(t *testing.T) {
 		             "https://example3.org">`,
 		expectedResult: []*Route{{
 			BackendType: LBBackend,
-			LBEndpoints: []string{
-				"https://example1.org",
-				"https://example2.org",
-				"https://example3.org",
+			LBEndpoints: []*LBEndpoint{
+				{Address: "https://example1.org"},
+				{Address: "https://example2.org"},
+				{Address: "https://example3.org"},
 			},
 		}},
 	}, {
@@ -276,7 +276,7 @@ func TestLBBackend(t *testing.T) {
 		expectedResult: []*Route{{
 			BackendType: LBBackend,
 			LBAlgorithm: "algFoo",
-			LBEndpoints: []string{"https://example.org"},
+			LBEndpoints: []*LBEndpoint{{Address: "https://example.org"}},
 		}},
 	}, {
 		title: "multiple endpoints, default algorithm",
@@ -287,10 +287,10 @@ func TestLBBackend(t *testing.T) {
 		expectedResult: []*Route{{
 			BackendType: LBBackend,
 			LBAlgorithm: "algFoo",
-			LBEndpoints: []string{
-				"https://example1.org",
-				"https://example2.org",
-				"https://example3.org",
+			LBEndpoints: []*LBEndpoint{
+				{Address: "https://example1.org"},
+				{Address: "https://example2.org"},
+				{Address: "https://example3.org"},
 			},
 		}},
 	}, {
@@ -303,10 +303,10 @@ func TestLBBackend(t *testing.T) {
 			Filters:     []*Filter{{Name: "foo"}},
 			BackendType: LBBackend,
 			LBAlgorithm: "algFoo",
-			LBEndpoints: []string{
-				"https://example1.org",
-				"https://example2.org",
-				"https://example3.org",
+			LBEndpoints: []*LBEndpoint{
+				{Address: "https://example1.org"},
+				{Address: "https://example2.org"},
+				{Address: "https://example3.org"},
 			},
 		}},
 	}} {

eskip/string.go

@@ -167,7 +167,7 @@ func lbBackendString(r *Route) string {
 			b.WriteString(", ")
 		}
 		b.WriteByte('"')
-		b.WriteString(ep)
+		b.WriteString(ep.String())
 		b.WriteByte('"')
 	}
 	b.WriteByte('>')

eskip/string_test.go

@@ -112,13 +112,16 @@ func TestRouteString(t *testing.T) {
 			BackendType: DynamicBackend},
 		`* -> filter0("Line 1\r\nLine 2") -> <dynamic>`,
 	}, {
-		&Route{Method: "GET", BackendType: LBBackend, LBEndpoints: []string{"http://127.0.0.1:9997"}},
+		&Route{Method: "GET", BackendType: LBBackend, LBEndpoints: []*LBEndpoint{{Address: "http://127.0.0.1:9997"}}},
 		`Method("GET") -> <"http://127.0.0.1:9997">`,
 	}, {
-		&Route{Method: "GET", LBAlgorithm: "random", BackendType: LBBackend, LBEndpoints: []string{"http://127.0.0.1:9997"}},
+		&Route{Method: "GET", LBAlgorithm: "random", BackendType: LBBackend, LBEndpoints: []*LBEndpoint{{Address: "http://127.0.0.1:9997"}}},
 		`Method("GET") -> <random, "http://127.0.0.1:9997">`,
 	}, {
-		&Route{Method: "GET", LBAlgorithm: "random", BackendType: LBBackend, LBEndpoints: []string{"http://127.0.0.1:9997", "http://127.0.0.1:9998"}},
+		&Route{Method: "GET", LBAlgorithm: "random", BackendType: LBBackend, LBEndpoints: []*LBEndpoint{
+			{Address: "http://127.0.0.1:9997"},
+			{Address: "http://127.0.0.1:9998"},
+		}},
 		`Method("GET") -> <random, "http://127.0.0.1:9997", "http://127.0.0.1:9998">`,
 	}, {
 		// test slash escaping

loadbalancer/algorithm.go

@@ -312,7 +312,7 @@ func (a Algorithm) String() string {
 func parseEndpoints(r *routing.Route) error {
 	r.LBEndpoints = make([]routing.LBEndpoint, len(r.Route.LBEndpoints))
 	for i, e := range r.Route.LBEndpoints {
-		scheme, host, err := snet.SchemeHost(e)
+		scheme, host, err := snet.SchemeHost(e.String())
 		if err != nil {
 			return err
 		}
@@ -337,7 +337,7 @@ func setAlgorithm(r *routing.Route) error {
 		initialize = algorithms[t]
 	}
 
-	r.LBAlgorithm = initialize(r.Route.LBEndpoints)
+	r.LBAlgorithm = initialize(eskip.LBEndpointString(r.Route.LBEndpoints))
 	return nil
 }