func newCellPresence(cellID string) *models.CellPresence {
presence := models.NewCellPresence(
cellID,
"cell.example.com",
"the-zone",
models.NewCellCapacity(128, 1024, 6),
[]string{},
nil,
nil,
nil,
)
return &presence
}
&models.ActualLRPGroup{Instance: unclaimingActualLRP2}, nil
}
return nil, nil, models.ErrResourceNotFound
}
fakeLRPDB.ConvergeLRPsReturns(keysToAuction, keysWithMissingCells, keysToRetire)
logger.RegisterSink(lager.NewWriterSink(GinkgoWriter, lager.DEBUG))
fakeServiceClient = new(fake_bbs.FakeServiceClient)
fakeRepClientFactory = new(repfakes.FakeClientFactory)
fakeRepClient = new(repfakes.FakeClient)
fakeRepClientFactory.CreateClientReturns(fakeRepClient, nil)
fakeServiceClient.CellByIdReturns(nil, errors.New("hi"))
cellPresence := models.NewCellPresence("cell-id", "1.1.1.1", "", "z1", models.CellCapacity{}, nil, nil, nil, nil)
cellSet = models.CellSet{"cell-id": &cellPresence}
fakeServiceClient.CellsReturns(cellSet, nil)
actualHub = &eventfakes.FakeHub{}
retirer := controllers.NewActualLRPRetirer(fakeLRPDB, actualHub, fakeRepClientFactory, fakeServiceClient)
controller = controllers.NewLRPConvergenceController(logger, fakeLRPDB, actualHub, fakeAuctioneerClient, fakeServiceClient, retirer, 2)
})
JustBeforeEach(func() {
err = controller.ConvergeLRPs(logger)
})
It("calls ConvergeLRPs", func() {
Expect(err).NotTo(HaveOccurred())
Expect(fakeLRPDB.ConvergeLRPsCallCount()).To(Equal(1))
)
var _ = Describe("CellPresence", func() {
var (
cellPresence models.CellPresence
capacity models.CellCapacity
expectedProviderList []*models.Provider
)
BeforeEach(func() {
capacity = models.NewCellCapacity(128, 1024, 3)
rootfsProviders := []string{"provider-1"}
preloadedRootFSes := []string{"provider-2", "provider-3"}
placementTags := []string{"tag-1", "tag-2"}
optionalPlacementTags := []string{"optional-tag-1", "optional-tag-2"}
cellPresence = models.NewCellPresence("some-id", "some-address", "some-zone", capacity, rootfsProviders, preloadedRootFSes, placementTags, optionalPlacementTags)
expectedProviderList = []*models.Provider{
&models.Provider{"preloaded", []string{"provider-2", "provider-3"}},
&models.Provider{"provider-1", []string{}},
}
})
Describe("Validate", func() {
Context("when cell presence is valid", func() {
It("does not return an error", func() {
Expect(cellPresence.Validate()).NotTo(HaveOccurred())
Expect(cellPresence.GetRootfsProviders()).To(Equal(expectedProviderList))
})
})
Context("when cell presence is invalid", func() {
})
})
})
Describe("ConvergeTasks", func() {
Context("when the request is normal", func() {
var (
kickTaskDuration = 10 * time.Second
expirePendingTaskDuration = 10 * time.Second
expireCompletedTaskDuration = 10 * time.Second
cellSet models.CellSet
err error
)
BeforeEach(func() {
cellPresence := models.NewCellPresence("cell-id", "1.1.1.1", "", "z1", models.CellCapacity{}, nil, nil, nil, nil)
cellSet = models.CellSet{"cell-id": &cellPresence}
fakeServiceClient.CellsReturns(cellSet, nil)
})
JustBeforeEach(func() {
err = controller.ConvergeTasks(logger, kickTaskDuration, expirePendingTaskDuration, expireCompletedTaskDuration)
})
It("calls ConvergeTasks", func() {
Expect(err).NotTo(HaveOccurred())
Expect(fakeTaskDB.ConvergeTasksCallCount()).To(Equal(1))
taskLogger, actualCellSet, actualKickDuration, actualPendingDuration, actualCompletedDuration := fakeTaskDB.ConvergeTasksArgsForCall(0)
Expect(taskLogger.SessionName()).To(ContainSubstring("converge-tasks"))
Expect(actualCellSet).To(BeEquivalentTo(cellSet))
Expect(actualKickDuration).To(BeEquivalentTo(kickTaskDuration))
var _ = Describe("Convergence API", func() {
Describe("ConvergeLRPs", func() {
var processGuid string
BeforeEach(func() {
// make the converger more aggressive by running every second
bbsArgs.ConvergeRepeatInterval = time.Second
bbsRunner = testrunner.New(bbsBinPath, bbsArgs)
bbsProcess = ginkgomon.Invoke(bbsRunner)
cellPresence := models.NewCellPresence(
"some-cell",
"cell.example.com",
"the-zone",
models.NewCellCapacity(128, 1024, 6),
[]string{},
[]string{},
[]string{},
[]string{},
)
consulHelper.RegisterCell(&cellPresence)
processGuid = "some-process-guid"
err := client.DesireLRP(logger, model_helpers.NewValidDesiredLRP(processGuid))
Expect(err).NotTo(HaveOccurred())
err = client.RemoveActualLRP(logger, processGuid, 0, nil)
Expect(err).NotTo(HaveOccurred())
})
It("converges the lrps", func() {
Eventually(func() []*models.ActualLRPGroup {
groups, err := client.ActualLRPGroupsByProcessGuid(logger, processGuid)
_, err = etcdDB.StartTask(logger, taskGuid, "cell-id")
Expect(err).NotTo(HaveOccurred())
})
It("emits a running metric", func() {
Expect(sender.GetValue("TasksRunning").Value).To(Equal(float64(1)))
})
Context("when the associated cell is present", func() {
BeforeEach(func() {
cellPresence := models.NewCellPresence(
"cell-id",
"1.2.3.4",
"",
"the-zone",
models.NewCellCapacity(128, 1024, 3),
[]string{},
[]string{},
[]string{},
[]string{},
)
cells["cell-id"] = &cellPresence
})
It("leaves the task running", func() {
returnedTask, err := etcdDB.TaskByGuid(logger, taskGuid)
Expect(err).NotTo(HaveOccurred())
Expect(returnedTask.State).To(Equal(models.Task_Running))
})
})
actualLRP.CellId = cellID
actualLRP.ActualLRPInstanceKey = instanceKey
actualLRPGroup.Instance.State = models.ActualLRPStateClaimed
fakeActualLRPDB.ActualLRPGroupByProcessGuidAndIndexReturns(actualLRPGroup, nil)
})
Context("when the cell", func() {
Context("is present", func() {
BeforeEach(func() {
cellPresence = models.NewCellPresence(
cellID,
"cell1.addr",
"",
"the-zone",
models.NewCellCapacity(128, 1024, 6),
[]string{},
[]string{},
[]string{},
[]string{},
)
fakeServiceClient.CellByIdReturns(&cellPresence, nil)
})
It("stops the LRPs", func() {
Expect(fakeRepClientFactory.CreateClientCallCount()).To(Equal(1))
Expect(fakeRepClientFactory.CreateClientArgsForCall(0)).To(Equal(cellPresence.RepAddress))
Expect(fakeServiceClient.CellByIdCallCount()).To(Equal(1))
_, fetchedCellID := fakeServiceClient.CellByIdArgsForCall(0)
}()
// start convergence
go func() {
defer GinkgoRecover()
logger.Info("start-lrp-convergence-loop")
defer logger.Info("finish-lrp-convergence-loop")
wg.Add(1)
defer wg.Done()
for i := 0; i < numTrials; i++ {
sleepDuration := getSleepDuration(i, bulkCycle)
time.Sleep(sleepDuration)
cellSet := models.NewCellSet()
for i := 0; i < numReps; i++ {
cellID := fmt.Sprintf("cell-%d", i)
presence := models.NewCellPresence(cellID, "earth", "http://planet-earth", "north", models.CellCapacity{}, nil, nil, nil, nil)
cellSet.Add(&presence)
}
b.Time("BBS' internal gathering of LRPs", func() {
activeDB.ConvergeLRPs(logger, cellSet)
}, reporter.ReporterInfo{
MetricName: ConvergenceGathering,
})
}
}()
// start route-emitter
go func() {
defer GinkgoRecover()
logger.Info("start-route-emitter-loop")