func (r *RouteFetcher) deleteEndpoints(validRoutes []models.Route) {
var diff []models.Route
for _, curRoute := range r.endpoints {
routeFound := false
for _, validRoute := range validRoutes {
if routeEquals(curRoute, validRoute) {
routeFound = true
break
}
}
if !routeFound {
diff = append(diff, curRoute)
}
}
for _, aRoute := range diff {
r.RouteRegistry.Unregister(
route.Uri(aRoute.Route),
route.NewEndpoint(
aRoute.LogGuid,
aRoute.IP,
uint16(aRoute.Port),
aRoute.LogGuid,
"",
nil,
aRoute.GetTTL(),
aRoute.RouteServiceUrl,
aRoute.ModificationTag,
))
}
}
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 registerAddr(reg *registry.RouteRegistry, path string, routeServiceUrl string, addr net.Addr, instanceId, instanceIndex, appId string) {
host, portStr, err := net.SplitHostPort(addr.String())
Expect(err).NotTo(HaveOccurred())
port, err := strconv.Atoi(portStr)
Expect(err).NotTo(HaveOccurred())
reg.Register(route.Uri(path), route.NewEndpoint(appId, host, uint16(port), instanceId, instanceIndex, nil, -1, routeServiceUrl, models.ModificationTag{}))
}
func (rm *RegistryMessage) makeEndpoint() *route.Endpoint {
return route.NewEndpoint(
rm.App,
rm.Host,
rm.Port,
rm.PrivateInstanceID,
rm.PrivateInstanceIndex,
rm.Tags,
rm.StaleThresholdInSeconds,
rm.RouteServiceURL,
models.ModificationTag{})
}
func (r *RouteFetcher) HandleEvent(e routing_api.Event) {
eventRoute := e.Route
uri := route.Uri(eventRoute.Route)
endpoint := route.NewEndpoint(
eventRoute.LogGuid,
eventRoute.IP,
uint16(eventRoute.Port),
eventRoute.LogGuid,
"",
nil,
eventRoute.GetTTL(),
eventRoute.RouteServiceUrl,
eventRoute.ModificationTag)
switch e.Action {
case "Delete":
r.RouteRegistry.Unregister(uri, endpoint)
case "Upsert":
r.RouteRegistry.Register(uri, endpoint)
}
}
func (r *RouteFetcher) refreshEndpoints(validRoutes []models.Route) {
r.deleteEndpoints(validRoutes)
r.endpoints = validRoutes
for _, aRoute := range r.endpoints {
r.RouteRegistry.Register(
route.Uri(aRoute.Route),
route.NewEndpoint(
aRoute.LogGuid,
aRoute.IP,
uint16(aRoute.Port),
aRoute.LogGuid,
"",
nil,
aRoute.GetTTL(),
aRoute.RouteServiceUrl,
aRoute.ModificationTag,
))
}
}
func CreateAccessLogRecord() *schema.AccessLogRecord {
u, err := url.Parse("http://foo.bar:1234/quz?wat")
if err != nil {
panic(err)
}
req := &http.Request{
Method: "GET",
URL: u,
Proto: "HTTP/1.1",
Header: make(http.Header),
Host: "foo.bar",
RemoteAddr: "1.2.3.4:5678",
}
req.Header.Set("Referer", "referer")
req.Header.Set("User-Agent", "user-agent")
res := &http.Response{
StatusCode: http.StatusOK,
}
b := route.NewEndpoint("my_awesome_id", "127.0.0.1", 4567, "", "", nil, -1, "", models.ModificationTag{})
r := schema.AccessLogRecord{
Request: req,
StatusCode: res.StatusCode,
RouteEndpoint: b,
StartedAt: time.Unix(10, 100000000),
FirstByteAt: time.Unix(10, 200000000),
FinishedAt: time.Unix(10, 300000000),
BodyBytesSent: 42,
}
return &r
}
r.Insert("/foo/bar/baz", p1)
r.Insert("/foo/bar", p2)
Expect(r.PoolCount()).To(Equal(2))
})
Describe(".PruneDeadLeaves", func() {
It("removes dead leaves", func() {
segments := make([]string, 0)
count := 0
f := func(r *container.Trie) {
segments = append(segments, r.Segment)
count += 1
}
e1 := route.NewEndpoint("", "192.168.1.1", 1234, "", "", nil, -1, "", modTag)
e2 := route.NewEndpoint("", "192.168.1.1", 4321, "", "", nil, -1, "", modTag)
p1 := route.NewPool(42, "")
p2 := route.NewPool(42, "")
p3 := route.NewPool(42, "")
p4 := route.NewPool(42, "")
p1.Put(e1)
p2.Put(e2)
r.Insert("/foo", p1)
r.Insert("/foo/bar/baz", p2)
r.Insert("/zoo", p3)
r.Insert("/foo/bar/zak", p4)
r.EachNodeWithPool(f)
Expect(segments).To(ConsistOf("foo", "baz", "zak", "zoo"))
Expect(count).To(Equal(4))
var _ = Describe("AccessLogRecord", func() {
Measure("Register", func(b Benchmarker) {
logger := lagertest.NewTestLogger("test")
c := config.DefaultConfig()
r := registry.NewRouteRegistry(logger, c, new(fakes.FakeRouteRegistryReporter))
accesslog, err := access_log.CreateRunningAccessLogger(logger, c)
Expect(err).ToNot(HaveOccurred())
proxy.NewProxy(proxy.ProxyArgs{
EndpointTimeout: c.EndpointTimeout,
Ip: c.Ip,
TraceKey: c.TraceKey,
Registry: r,
Reporter: varz.NewVarz(r),
AccessLogger: accesslog,
})
b.Time("RegisterTime", func() {
for i := 0; i < 1000; i++ {
str := strconv.Itoa(i)
r.Register(
route.Uri("bench.vcap.me."+str),
route.NewEndpoint("", "localhost", uint16(i), "", "", nil, -1, "", models.ModificationTag{}),
)
}
})
}, 10)
})
err := fetcher.FetchRoutes()
Expect(err).ToNot(HaveOccurred())
Expect(registry.RegisterCallCount()).To(Equal(3))
for i := 0; i < 3; i++ {
expectedRoute := response[i]
uri, endpoint := registry.RegisterArgsForCall(i)
Expect(uri).To(Equal(route.Uri(expectedRoute.Route)))
Expect(endpoint).To(Equal(
route.NewEndpoint(expectedRoute.LogGuid,
expectedRoute.IP, uint16(expectedRoute.Port),
expectedRoute.LogGuid,
"",
nil,
*expectedRoute.TTL,
expectedRoute.RouteServiceUrl,
expectedRoute.ModificationTag,
)))
}
})
It("uses cache when fetching token from UAA", func() {
client.RoutesReturns(response, nil)
err := fetcher.FetchRoutes()
Expect(err).ToNot(HaveOccurred())
Expect(uaaClient.FetchTokenCallCount()).To(Equal(1))
Expect(uaaClient.FetchTokenArgsForCall(0)).To(Equal(false))
})
Expect(iter.Next()).To(BeNil())
})
})
Context("when pool has endpoints", func() {
var (
endpoints []*route.Endpoint
total int
)
BeforeEach(func() {
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)
}
// 10.0.1.0:6000
// 10.0.1.1:6000
// 10.0.1.2:6000
// 10.0.1.3:6000
// 10.0.1.4:6000
})
Context("when all endpoints have no statistics", func() {
It("selects a random endpoint", func() {
iter := route.NewLeastConnection(pool, "")
n := iter.Next()
Expect(n).NotTo(BeNil())
. "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))
iter := route.NewRoundRobin(pool, "")
loops := 50
for i := 0; i < len(endpoints)*loops; i += 1 {
n := iter.Next()
var modTag models.ModificationTag
BeforeEach(func() {
logger = lagertest.NewTestLogger("test")
configObj = config.DefaultConfig()
configObj.PruneStaleDropletsInterval = 50 * time.Millisecond
configObj.DropletStaleThreshold = 24 * time.Millisecond
reporter = new(fakes.FakeRouteRegistryReporter)
r = NewRouteRegistry(logger, configObj, reporter)
modTag = models.ModificationTag{}
fooEndpoint = route.NewEndpoint("12345", "192.168.1.1", 1234,
"id1", "0",
map[string]string{
"runtime": "ruby18",
"framework": "sinatra",
}, -1, "", modTag)
barEndpoint = route.NewEndpoint("54321", "192.168.1.2", 4321,
"id2", "0", map[string]string{
"runtime": "javascript",
"framework": "node",
}, -1, "https://my-rs.com", modTag)
bar2Endpoint = route.NewEndpoint("54321", "192.168.1.3", 1234,
"id3", "0", map[string]string{
"runtime": "javascript",
"framework": "node",
}, -1, "", modTag)
})
var fakeReporter2 *fakes.FakeProxyReporter
var composite reporter.ProxyReporter
var req *http.Request
var endpoint *route.Endpoint
var response *http.Response
var responseTime time.Time
var responseDuration time.Duration
BeforeEach(func() {
fakeReporter1 = new(fakes.FakeProxyReporter)
fakeReporter2 = new(fakes.FakeProxyReporter)
composite = metrics.NewCompositeReporter(fakeReporter1, fakeReporter2)
req, _ = http.NewRequest("GET", "https://example.com", nil)
endpoint = route.NewEndpoint("someId", "host", 2222, "privateId", "2", map[string]string{}, 30, "", models.ModificationTag{})
response = &http.Response{StatusCode: 200}
responseTime = time.Now()
responseDuration = time.Second
})
It("forwards CaptureBadRequest to both reporters", func() {
composite.CaptureBadRequest(req)
Expect(fakeReporter1.CaptureBadRequestCallCount()).To(Equal(1))
Expect(fakeReporter2.CaptureBadRequestCallCount()).To(Equal(1))
Expect(fakeReporter1.CaptureBadRequestArgsForCall(0)).To(Equal(req))
Expect(fakeReporter2.CaptureBadRequestArgsForCall(0)).To(Equal(req))
})
Expect(fakeLogSender.GetLogs()[0].Message).To(MatchRegexp("^.*foo.bar.*\n"))
Expect(fakeLogSender.GetLogs()[0].SourceType).To(Equal("RTR"))
Expect(fakeLogSender.GetLogs()[0].SourceInstance).To(Equal("42"))
Expect(fakeLogSender.GetLogs()[0].MessageType).To(Equal("OUT"))
accessLogger.Stop()
})
It("a record with no app id is not logged to dropsonde", func() {
fakeLogSender := fake.NewFakeLogSender()
logs.Initialize(fakeLogSender)
accessLogger := NewFileAndLoggregatorAccessLogger(logger, "43")
routeEndpoint := route.NewEndpoint("", "127.0.0.1", 4567, "", "", nil, -1, "", models.ModificationTag{})
accessLogRecord := CreateAccessLogRecord()
accessLogRecord.RouteEndpoint = routeEndpoint
accessLogger.Log(*accessLogRecord)
go accessLogger.Run()
Consistently(fakeLogSender.GetLogs).Should(HaveLen(0))
accessLogger.Stop()
})
})
Context("created with access log file", func() {
It("writes to the log file and Stdout", func() {
"code.cloudfoundry.org/gorouter/route"
. "github.com/onsi/ginkgo"
. "github.com/onsi/gomega"
"net/http"
"net/url"
"time"
)
var _ = Describe("AccessLogRecord", func() {
var (
endpoint *route.Endpoint
record *schema.AccessLogRecord
)
BeforeEach(func() {
endpoint = route.NewEndpoint("FakeApplicationId", "1.2.3.4", 1234, "", "3", nil, 0, "", models.ModificationTag{})
record = &schema.AccessLogRecord{
Request: &http.Request{
Host: "FakeRequestHost",
Method: "FakeRequestMethod",
Proto: "FakeRequestProto",
URL: &url.URL{
Opaque: "http://example.com/request",
},
Header: http.Header{
"Referer": []string{"FakeReferer"},
"User-Agent": []string{"FakeUserAgent"},
"X-Forwarded-For": []string{"FakeProxy1, FakeProxy2"},
"X-Forwarded-Proto": []string{"FakeOriginalRequestProto"},
router_http.VcapRequestIdHeader: []string{"abc-123-xyz-pdq"},
},
BeforeEach(func() {
pool = route.NewPool(2*time.Minute, "")
modTag = models.ModificationTag{}
})
Context("Put", func() {
It("adds endpoints", func() {
endpoint := &route.Endpoint{}
b := pool.Put(endpoint)
Expect(b).To(BeTrue())
})
It("handles duplicate endpoints", func() {
endpoint := route.NewEndpoint("", "1.2.3.4", 5678, "", "", nil, 1, "", modTag)
pool.Put(endpoint)
pool.MarkUpdated(time.Now().Add(-(10 * time.Minute)))
b := pool.Put(endpoint)
Expect(b).To(BeTrue())
prunedEndpoints := pool.PruneEndpoints(time.Second)
Expect(prunedEndpoints).To(BeEmpty())
})
It("handles equivalent (duplicate) endpoints", func() {
endpoint1 := route.NewEndpoint("", "1.2.3.4", 5678, "", "", nil, -1, "", modTag)
endpoint2 := route.NewEndpoint("", "1.2.3.4", 5678, "", "", nil, -1, "", modTag)
pool.Put(endpoint1)
})
It("reports seconds since last registry update", func() {
Registry.Register("foo", &route.Endpoint{})
time.Sleep(10 * time.Millisecond)
timeSince := findValue(Varz, "ms_since_last_registry_update").(float64)
Expect(timeSince).To(BeNumerically("<", 1000))
Expect(timeSince).To(BeNumerically(">=", 10))
})
It("has urls", func() {
Expect(findValue(Varz, "urls")).To(Equal(float64(0)))
var fooReg = route.NewEndpoint("12345", "192.168.1.1", 1234, "", "", map[string]string{}, -1, "", models.ModificationTag{})
// Add a route
Registry.Register("foo.vcap.me", fooReg)
Registry.Register("fooo.vcap.me", fooReg)
Expect(findValue(Varz, "urls")).To(Equal(float64(2)))
})
It("updates bad requests", func() {
r := http.Request{}
Varz.CaptureBadRequest(&r)
Expect(findValue(Varz, "bad_requests")).To(Equal(float64(1)))
Varz.CaptureBadRequest(&r)