instanceAndEvacuatingLRP := models.ActualLRP{ActualLRPKey: actualLRPKey, ActualLRPInstanceKey: models.NewActualLRPInstanceKey(instanceGuidInstanceAndEvacuatingLRPsOnly, cellID)}
lrpGroups := []*models.ActualLRPGroup{
{Instance: &containerOnlyLRP, Evacuating: nil},
{Instance: &instanceOnlyLRP, Evacuating: nil},
{Instance: &instanceAndEvacuatingLRP, Evacuating: &instanceAndEvacuatingLRP},
{Instance: nil, Evacuating: &containerForEvacuatingLRP},
{Instance: nil, Evacuating: &evacuatingOnlyLRP},
}
tasks := []*models.Task{
{TaskGuid: guidContainerForTask},
{TaskGuid: guidTaskOnly},
}
fakeExecutorClient.ListContainersReturns(containers, nil)
fakeBBS.ActualLRPGroupsReturns(lrpGroups, nil)
fakeBBS.TasksByCellIDReturns(tasks, nil)
})
It("does not return an error", func() {
Expect(batchErr).NotTo(HaveOccurred())
})
It("logs success", func() {
Expect(logger).To(Say(sessionName + ".succeeded"))
})
It("returns a batch of the correct size", func() {
Expect(batch).To(HaveLen(8))
It("retries", func() {
fakeClock.Increment(pollingInterval)
Eventually(executorClient.ListContainersCallCount).Should(Equal(1))
fakeClock.Increment(pollingInterval)
Eventually(executorClient.ListContainersCallCount).Should(Equal(2))
Eventually(errChan).Should(Receive(BeNil()))
})
})
})
Context("and are not all destroyed before the timeout elapses", func() {
BeforeEach(func() {
executorClient.ListContainersReturns(containers, nil)
})
It("exits after the evacuation timeout", func() {
Eventually(fakeClock.WatcherCount).Should(Equal(2))
fakeClock.Increment(evacuationTimeout - time.Second)
Consistently(errChan).ShouldNot(Receive())
fakeClock.Increment(2 * time.Second)
Eventually(errChan).Should(Receive(BeNil()))
})
Context("when signaled", func() {
It("exits", func() {
process.Signal(os.Interrupt)
executorClient.TotalResourcesReturns(executor.ExecutorResources{
MemoryMB: 1024,
DiskMB: 2048,
Containers: 4096,
}, nil)
executorClient.RemainingResourcesReturns(executor.ExecutorResources{
MemoryMB: 128,
DiskMB: 256,
Containers: 512,
}, nil)
executorClient.ListContainersReturns([]executor.Container{
{Guid: "container-1"},
{Guid: "container-2"},
{Guid: "container-3"},
}, nil)
})
JustBeforeEach(func() {
reporter = ifrit.Envoke(&metrics.Reporter{
ExecutorSource: executorClient,
Interval: reportInterval,
Logger: logger,
})
})
AfterEach(func() {
reporter.Signal(os.Interrupt)
Eventually(reporter.Wait()).Should(Receive())
Resource: executor.NewResource(40, 30, "rootfs"),
Tags: executor.Tags{
rep.LifecycleTag: rep.TaskLifecycle,
rep.DomainTag: "domain",
},
},
{
Guid: "other-task",
Resource: executor.NewResource(40, 30, "rootfs"),
Tags: nil,
},
}
client.TotalResourcesReturns(totalResources, nil)
client.RemainingResourcesReturns(availableResources, nil)
client.ListContainersReturns(containers, nil)
})
It("queries the client and returns state", func() {
state, err := cellRep.State()
Expect(err).NotTo(HaveOccurred())
Expect(state.Evacuating).To(BeTrue())
Expect(state.RootFSProviders).To(Equal(rep.RootFSProviders{
models.PreloadedRootFSScheme: rep.NewFixedSetRootFSProvider("linux"),
"docker": rep.ArbitraryRootFSProvider{},
}))
Expect(state.AvailableResources).To(Equal(rep.Resources{
MemoryMB: int32(availableResources.MemoryMB),
DiskMB: int32(availableResources.DiskMB),
