feature: zone aware eskip.LBEndpoints

szuecs · szuecs · commit 2f8af02cd196 · 2024-06-19T15:02:19.000+02:00
Signed-off-by: Sandor Szücs &lt;sandor.szuecs@zalando.de&gt;
diff --git a/dataclients/kubernetes/ingressv1.go b/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
 }
diff --git a/dataclients/kubernetes/routegroup.go b/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()
diff --git a/eskip/copy.go b/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
 }
diff --git a/eskip/copy_test.go b/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)
diff --git a/eskip/eq.go b/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
diff --git a/eskip/eq_test.go b/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) {
diff --git a/eskip/eskip.go b/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:
diff --git a/eskip/json.go b/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
 		}
diff --git a/eskip/json_test.go b/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"]}}]`,
 		},
 		{
diff --git a/eskip/parser_test.go b/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"},
 			},
 		}},
 	}} {
diff --git a/eskip/string.go b/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('>')
diff --git a/eskip/string_test.go b/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
diff --git a/loadbalancer/algorithm.go b/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
 }
 
diff --git a/loadbalancer/algorithm_test.go b/loadbalancer/algorithm_test.go
diff --git a/loadbalancer/concurrency_test.go b/loadbalancer/concurrency_test.go
diff --git a/proxy/fadein_internal_test.go b/proxy/fadein_internal_test.go
diff --git a/proxy/fadeintesting_test.go b/proxy/fadeintesting_test.go

Original file line number	Diff line number	Diff line change
`@@ -208,7 +208,7 @@ func applyServiceBackend(ctx routeGroupContext, backend definitions.SkipperBac`
`208`	`208`	`}`
`209`	`209`
`210`	`210`	`r.BackendType = eskip.LBBackend`
`211`		`- r.LBEndpoints = eps`
	`211`	`+ r.LBEndpoints = eskip.NewLBEndpoints(eps)`
`212`	`212`	`r.LBAlgorithm = ctx.defaultLoadBalancerAlgorithm`
`213`	`213`	`if backend.Algorithm != loadbalancer.None {`
`214`	`214`	`r.LBAlgorithm = backend.Algorithm.String()`
`@@ -261,7 +261,7 @@ func applyBackend(ctx routeGroupContext, backend definitions.SkipperBackend, r`
`261`	`261`	`}`
`262`	`262`	`}`
`263`	`263`
`264`		`- r.LBEndpoints = backend.Endpoints`
	`264`	`+ r.LBEndpoints = eskip.NewLBEndpoints(backend.Endpoints)`
`265`	`265`	`r.LBAlgorithm = ctx.defaultLoadBalancerAlgorithm`
`266`	`266`	`if backend.Algorithm != loadbalancer.None {`
`267`	`267`	`r.LBAlgorithm = backend.Algorithm.String()`
Original file line number	Diff line number	Diff line change
`@@ -65,7 +65,7 @@ func Copy(r Route) Route {`
`65`	`65`	`c.BackendType = r.BackendType`
`66`	`66`	`c.Backend = r.Backend`
`67`	`67`	`c.LBAlgorithm = r.LBAlgorithm`
`68`		`- c.LBEndpoints = make([]string, len(r.LBEndpoints))`
	`68`	`+ c.LBEndpoints = make([]*LBEndpoint, len(r.LBEndpoints))`
`69`	`69`	`copy(c.LBEndpoints, r.LBEndpoints)`
`70`	`70`	`return c`
`71`	`71`	`}`
Original file line number	Diff line number	Diff line change
`@@ -40,13 +40,13 @@ func eqArgs(left, right []interface{}) bool {`
`40`	`40`	`return true`
`41`	`41`	`}`
`42`	`42`
`43`		`-func eqStrings(left, right []string) bool {`
	`43`	`+func eqLBEndpoints(left, right []*LBEndpoint) bool {`
`44`	`44`	`if len(left) != len(right) {`
`45`	`45`	`return false`
`46`	`46`	`}`
`47`	`47`
`48`	`48`	`for i := range left {`
`49`		`- if left[i] != right[i] {`
	`49`	`+ if left[i].Address != right[i].Address \|\| left[i].Zone != right[i].Zone {`
`50`	`50`	`return false`
`51`	`51`	`}`
`52`	`52`	`}`
`@@ -103,7 +103,7 @@ func eq2(left, right *Route) bool {`
`103`	`103`	`return false`
`104`	`104`	`}`
`105`	`105`
`106`		`- if !eqStrings(lc.LBEndpoints, rc.LBEndpoints) {`
	`106`	`+ if !eqLBEndpoints(lc.LBEndpoints, rc.LBEndpoints) {`
`107`	`107`	`return false`
`108`	`108`	`}`
`109`	`109`
`@@ -255,9 +255,11 @@ func Canonical(r Route) Route {`
`255`	`255`	`case LBBackend:`
`256`	`256`	`// using the LB fields only when apply:`
`257`	`257`	`c.LBAlgorithm = r.LBAlgorithm`
`258`		`- c.LBEndpoints = make([]string, len(r.LBEndpoints))`
	`258`	`+ c.LBEndpoints = make([]*LBEndpoint, len(r.LBEndpoints))`
`259`	`259`	`copy(c.LBEndpoints, r.LBEndpoints)`
`260`		`- sort.Strings(c.LBEndpoints)`
	`260`	`+ sort.Slice(c.LBEndpoints, func(i, j int) bool {`
	`261`	`+ return c.LBEndpoints[i].Address < c.LBEndpoints[j].Address`
	`262`	`+ })`
`261`	`263`	`}`
`262`	`264`
`263`	`265`	`// Name and Namespace stripped`
Original file line number	Diff line number	Diff line change
`@@ -37,7 +37,7 @@ func newJSONRoute(r Route) jsonRoute {`
`37`	`37`	`Type: cr.BackendType.String(),`
`38`	`38`	`Address: cr.Backend,`
`39`	`39`	`Algorithm: cr.LBAlgorithm,`
`40`		`- Endpoints: cr.LBEndpoints,`
	`40`	`+ Endpoints: LBEndpointString(cr.LBEndpoints),`
`41`	`41`	`}`
`42`	`42`	`}`
`43`	`43`
`@@ -94,7 +94,7 @@ func (r *Route) UnmarshalJSON(b []byte) error {`
`94`	`94`	`}`
`95`	`95`	`case LBBackend:`
`96`	`96`	`r.LBAlgorithm = jr.Backend.Algorithm`
`97`		`- r.LBEndpoints = jr.Backend.Endpoints`
	`97`	`+ r.LBEndpoints = NewLBEndpoints(jr.Backend.Endpoints)`
`98`	`98`	`if len(r.LBEndpoints) == 0 {`
`99`	`99`	`r.LBEndpoints = nil`
`100`	`100`	`}`
Original file line number	Diff line number	Diff line change
`@@ -88,7 +88,7 @@ func TestMarshalUnmarshalJSON(t *testing.T) {`
`88`	`88`	`},`
`89`	`89`	`{`
`90`	`90`	`"lb backend",`
`91`		`- []*Route{{Id: "beef", BackendType: LBBackend, LBAlgorithm: "yolo", LBEndpoints: []string{"localhost"}}},`
	`91`	`+ []Route{{Id: "beef", BackendType: LBBackend, LBAlgorithm: "yolo", LBEndpoints: []LBEndpoint{{Address: "localhost"}}}},`
`92`	`92`	`[{"id":"beef","backend":{"type":"lb","algorithm":"yolo","endpoints":["localhost"]}}]`,
`93`	`93`	`},`
`94`	`94`	`{`