func (r *RouteRegistry) Register(uri route.Uri, endpoint *route.Endpoint) {
t := time.Now()
data := lager.Data{"uri": uri, "backend": endpoint.CanonicalAddr(), "modification_tag": endpoint.ModificationTag}
r.reporter.CaptureRegistryMessage(endpoint)
r.Lock()
uri = uri.RouteKey()
pool := r.byUri.Find(uri)
if pool == nil {
contextPath := parseContextPath(uri)
pool = route.NewPool(r.dropletStaleThreshold/4, contextPath)
r.byUri.Insert(uri, pool)
r.logger.Debug("uri-added", lager.Data{"uri": uri})
}
endpointAdded := pool.Put(endpoint)
r.timeOfLastUpdate = t
r.Unlock()
if endpointAdded {
r.logger.Debug("endpoint-registered", data)
} else {
r.logger.Debug("endpoint-not-registered", data)
}
}
func loadBalanceFor(strategy string, b *testing.B) {
pool := route.NewPool(2*time.Minute, "")
total := 5
endpoints := make([]*route.Endpoint, 0)
for i := 0; i < total; i++ {
ip := fmt.Sprintf("10.0.1.%d", i)
e := route.NewEndpoint("", ip, 60000, "", "", nil, -1, "", models.ModificationTag{})
endpoints = append(endpoints, e)
pool.Put(e)
}
var lb route.EndpointIterator
switch strategy {
case "round-robin":
lb = route.NewRoundRobin(pool, "")
case "least-connection":
lb = route.NewLeastConnection(pool, "")
default:
panic("invalid load balancing strategy")
}
for n := 0; n < b.N; n++ {
loadBalance(lb)
}
}
func (r *RouteRegistry) LookupWithInstance(uri route.Uri, appId string, appIndex string) *route.Pool {
uri = uri.RouteKey()
p := r.Lookup(uri)
var surgicalPool *route.Pool
p.Each(func(e *route.Endpoint) {
if (e.ApplicationId == appId) && (e.PrivateInstanceIndex == appIndex) {
surgicalPool = route.NewPool(0, "")
surgicalPool.Put(e)
}
})
return surgicalPool
}
var _ = Describe("Trie", func() {
var (
r *container.Trie
modTag models.ModificationTag
)
BeforeEach(func() {
r = container.NewTrie()
modTag = models.ModificationTag{}
})
Describe(".Find", func() {
It("works for the root node", func() {
p := route.NewPool(42, "")
r.Insert("/", p)
node := r.Find("/")
Expect(node).To(Equal(p))
})
It("finds an exact match to an existing key", func() {
p := route.NewPool(42, "")
r.Insert("/foo/bar", p)
node := r.Find("/foo/bar")
Expect(node).To(Equal(p))
})
It("returns nil when no exact match is found", func() {
p := route.NewPool(42, "")
r.Insert("/foo/bar/baz", p)
import (
"fmt"
"time"
"code.cloudfoundry.org/gorouter/route"
"code.cloudfoundry.org/routing-api/models"
. "github.com/onsi/ginkgo"
. "github.com/onsi/gomega"
)
var _ = Describe("LeastConnection", func() {
var pool *route.Pool
BeforeEach(func() {
pool = route.NewPool(2*time.Minute, "")
})
Describe("Next", func() {
Context("when pool is empty", func() {
It("does not select an endpoint", func() {
iter := route.NewLeastConnection(pool, "")
Expect(iter.Next()).To(BeNil())
})
})
Context("when pool has endpoints", func() {
var (
endpoints []*route.Endpoint
total int
import (
"time"
"code.cloudfoundry.org/gorouter/route"
"code.cloudfoundry.org/routing-api/models"
. "github.com/onsi/ginkgo"
. "github.com/onsi/gomega"
)
var _ = Describe("RoundRobin", func() {
var pool *route.Pool
var modTag models.ModificationTag
BeforeEach(func() {
pool = route.NewPool(2*time.Minute, "")
modTag = models.ModificationTag{}
})
Describe("Next", func() {
It("performs round-robin through the endpoints", func() {
e1 := route.NewEndpoint("", "1.2.3.4", 5678, "", "", nil, -1, "", modTag)
e2 := route.NewEndpoint("", "5.6.7.8", 1234, "", "", nil, -1, "", modTag)
e3 := route.NewEndpoint("", "1.2.7.8", 1234, "", "", nil, -1, "", modTag)
endpoints := []*route.Endpoint{e1, e2, e3}
for _, e := range endpoints {
pool.Put(e)
}
counts := make([]int, len(endpoints))