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{}{}
Eventually(ready).Should(Receive())
endpoint3 := routing_table.Endpoint{InstanceGuid: "ig-3", Host: "3.3.3.3", Port: 33, ContainerPort: 8080, Evacuating: false, ModificationTag: currentTag}
evacuating1 := routing_table.Endpoint{InstanceGuid: "ig-1", Host: "1.1.1.1", Port: 11, ContainerPort: 8080, Evacuating: true, ModificationTag: currentTag}
logGuid := "some-log-guid"
BeforeEach(func() {
table = routing_table.NewTable()
})
Describe("Swap", func() {
Context("when a new routing key arrives", func() {
Context("when the routing key has both routes and endpoints", func() {
BeforeEach(func() {
tempTable := routing_table.NewTempTable(
routing_table.RoutesByRoutingKey{key: routing_table.Routes{Hostnames: []string{hostname1, hostname2}, LogGuid: logGuid}},
routing_table.EndpointsByRoutingKey{key: {endpoint1, endpoint2}},
)
messagesToEmit = table.Swap(tempTable)
})
It("emits registrations for each pairing", func() {
expected := routing_table.MessagesToEmit{
RegistrationMessages: []routing_table.RegistryMessage{
routing_table.RegistryMessageFor(endpoint1, routing_table.Routes{Hostnames: []string{hostname1, hostname2}, LogGuid: logGuid}),
routing_table.RegistryMessageFor(endpoint2, routing_table.Routes{Hostnames: []string{hostname1, hostname2}, LogGuid: logGuid}),
},
}
Expect(messagesToEmit).To(MatchMessagesToEmit(expected))
})
})
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))
}
}