BeforeEach(func() {
ready = make(chan struct{})
actualLRPRoutingInfo1 := &routing_table.ActualLRPRoutingInfo{
ActualLRP: actualLRPGroup1.Instance,
Evacuating: false,
}
actualLRPRoutingInfo2 := &routing_table.ActualLRPRoutingInfo{
ActualLRP: actualLRPGroup2.Instance,
Evacuating: false,
}
tempTable := routing_table.NewTempTable(
routing_table.RoutesByRoutingKeyFromSchedulingInfos([]*models.DesiredLRPSchedulingInfo{schedulingInfo1, schedulingInfo2}),
routing_table.EndpointsByRoutingKeyFromActuals([]*routing_table.ActualLRPRoutingInfo{
actualLRPRoutingInfo1,
actualLRPRoutingInfo2,
}),
)
table := routing_table.NewTable()
table.Swap(tempTable)
watcherProcess = watcher.NewWatcher(bbsClient, clock, table, emitter, syncEvents, logger)
bbsClient.DesiredLRPSchedulingInfosStub = func(f models.DesiredLRPFilter) ([]*models.DesiredLRPSchedulingInfo, error) {
defer GinkgoRecover()
ready <- struct{}{}
. "github.com/onsi/gomega"
)
var _ = Describe("ByRoutingKey", func() {
Describe("RoutesByRoutingKeyFromDesireds", func() {
It("should build a map of routes", func() {
abcRoutes := cfroutes.CFRoutes{
{Hostnames: []string{"foo.com", "bar.com"}, Port: 8080, RouteServiceUrl: "https://something.creative"},
{Hostnames: []string{"foo.example.com"}, Port: 9090},
}
defRoutes := cfroutes.CFRoutes{
{Hostnames: []string{"baz.com"}, Port: 8080},
}
routes := routing_table.RoutesByRoutingKeyFromSchedulingInfos([]*models.DesiredLRPSchedulingInfo{
{DesiredLRPKey: models.NewDesiredLRPKey("abc", "tests", "abc-guid"), Routes: abcRoutes.RoutingInfo()},
{DesiredLRPKey: models.NewDesiredLRPKey("def", "tests", "def-guid"), Routes: defRoutes.RoutingInfo()},
})
Expect(routes).To(HaveLen(3))
Expect(routes[routing_table.RoutingKey{ProcessGuid: "abc", ContainerPort: 8080}].Hostnames).To(Equal([]string{"foo.com", "bar.com"}))
Expect(routes[routing_table.RoutingKey{ProcessGuid: "abc", ContainerPort: 8080}].LogGuid).To(Equal("abc-guid"))
Expect(routes[routing_table.RoutingKey{ProcessGuid: "abc", ContainerPort: 8080}].RouteServiceUrl).To(Equal("https://something.creative"))
Expect(routes[routing_table.RoutingKey{ProcessGuid: "abc", ContainerPort: 9090}].Hostnames).To(Equal([]string{"foo.example.com"}))
Expect(routes[routing_table.RoutingKey{ProcessGuid: "abc", ContainerPort: 9090}].LogGuid).To(Equal("abc-guid"))
Expect(routes[routing_table.RoutingKey{ProcessGuid: "def", ContainerPort: 8080}].Hostnames).To(Equal([]string{"baz.com"}))
Expect(routes[routing_table.RoutingKey{ProcessGuid: "def", ContainerPort: 8080}].LogGuid).To(Equal("def-guid"))
})
Context("when the routing info is nil", func() {
func (watcher *Watcher) sync(logger lager.Logger, syncEndChan chan syncEndEvent) {
endEvent := syncEndEvent{logger: logger}
defer func() {
syncEndChan <- endEvent
}()
before := watcher.clock.Now()
var runningActualLRPs []*routing_table.ActualLRPRoutingInfo
var getActualLRPsErr error
var schedulingInfos []*models.DesiredLRPSchedulingInfo
var getSchedulingInfosErr error
wg := sync.WaitGroup{}
wg.Add(1)
go func() {
defer wg.Done()
logger.Debug("getting-actual-lrps")
actualLRPGroups, err := watcher.bbsClient.ActualLRPGroups(models.ActualLRPFilter{})
if err != nil {
logger.Error("failed-getting-actual-lrps", err)
getActualLRPsErr = err
return
}
logger.Debug("succeeded-getting-actual-lrps", lager.Data{"num-actual-responses": len(actualLRPGroups)})
runningActualLRPs = make([]*routing_table.ActualLRPRoutingInfo, 0, len(actualLRPGroups))
for _, actualLRPGroup := range actualLRPGroups {
actualLRP, evacuating := actualLRPGroup.Resolve()
if actualLRP.State == models.ActualLRPStateRunning {
runningActualLRPs = append(runningActualLRPs, &routing_table.ActualLRPRoutingInfo{
ActualLRP: actualLRP,
Evacuating: evacuating,
})
}
}
}()
wg.Add(1)
go func() {
var err error
defer wg.Done()
logger.Debug("getting-scheduling-infos")
schedulingInfos, err = watcher.bbsClient.DesiredLRPSchedulingInfos(models.DesiredLRPFilter{})
if err != nil {
logger.Error("failed-getting-desired-lrps", err)
getSchedulingInfosErr = err
return
}
logger.Debug("succeeded-getting-scheduling-infos", lager.Data{"num-desired-responses": len(schedulingInfos)})
}()
wg.Wait()
if getActualLRPsErr != nil || getSchedulingInfosErr != nil {
return
}
newTable := routing_table.NewTempTable(
routing_table.RoutesByRoutingKeyFromSchedulingInfos(schedulingInfos),
routing_table.EndpointsByRoutingKeyFromActuals(runningActualLRPs),
)
endEvent.table = newTable
endEvent.callback = func(table routing_table.RoutingTable) {
after := watcher.clock.Now()
routeSyncDuration.Send(after.Sub(before))
}
}