Function TestConsistentHashBoundedLoadSearch

loadbalancer/algorithm_test.go:340–387

(t *testing.T)

}

func TestConsistentHashBoundedLoadSearch(t *testing.T) {
	endpoints := []string{"http://127.0.0.1:8080", "http://127.0.0.2:8080", "http://127.0.0.3:8080"}
	r, _ := http.NewRequest("GET", "http://127.0.0.1:1234/foo", nil)
	route := NewAlgorithmProvider().Do([]*routing.Route{{
		Route: eskip.Route{
			BackendType: eskip.LBBackend,
			LBAlgorithm: ConsistentHash.String(),
			LBEndpoints: eskip.NewLBEndpoints(endpoints),
		},
	}})[0]

	ch := route.LBAlgorithm.(*consistentHash)
	ctx := &routing.LBContext{
		Request:     r,
		Route:       route,
		LBEndpoints: route.LBEndpoints,
		Params:      map[string]interface{}{ConsistentHashBalanceFactor: 1.25},
	}
	endpointRegistry := routing.NewEndpointRegistry(routing.RegistryOptions{})
	defer endpointRegistry.Close()
	endpointRegistry.Do([]*routing.Route{route})
	noLoad := ch.Apply(ctx)
	nonBounded := ch.Apply(&routing.LBContext{Request: r, Route: route, LBEndpoints: route.LBEndpoints, Params: map[string]interface{}{}})

	if noLoad != nonBounded {
		t.Error("When no endpoints are overloaded, the chosen endpoint should be the same as standard consistentHash")
	}
	// now we know that noLoad is the endpoint which should be requested for somekey if load is not an issue.
	addInflightRequests(endpointRegistry, noLoad, 20)
	failover1 := ch.Apply(ctx)
	if failover1 == nonBounded {
		t.Error("When the selected endpoint is overloaded, the chosen endpoint should be different to standard consistentHash")
	}

	// now if 2 endpoints are overloaded, the request should go to the final endpoint
	addInflightRequests(endpointRegistry, failover1, 20)
	failover2 := ch.Apply(ctx)
	if failover2 == nonBounded || failover2 == failover1 {
		t.Error("Only the final endpoint had load below the average * balanceFactor, so it should have been selected.")
	}

	// now all will have same load, should select the original endpoint again
	addInflightRequests(endpointRegistry, failover2, 20)
	allLoaded := ch.Apply(ctx)
	if allLoaded != nonBounded {
		t.Error("When all endpoints have the same load, the consistentHash endpoint should be chosen again.")
	}
}

func TestConsistentHashKey(t *testing.T) {
	endpoints := []string{"http://127.0.0.1:8080", "http://127.0.0.2:8080", "http://127.0.0.3:8080"}