Ejemplo n.º 1
0
		It("retrieves all actual lrps for its cell id", func() {
			Expect(fakeBBS.ActualLRPGroupsCallCount()).To(Equal(1))
			actualFilter := fakeBBS.ActualLRPGroupsArgsForCall(0)
			Expect(actualFilter.CellID).To(Equal(cellID))
		})

		It("retrieves all tasks for its cell id", func() {
			Expect(fakeBBS.TasksByCellIDCallCount()).To(Equal(1))
			actualCellID := fakeBBS.TasksByCellIDArgsForCall(0)
			Expect(actualCellID).To(Equal(cellID))
		})

		It("lists all containers from the executor", func() {
			Expect(fakeExecutorClient.ListContainersCallCount()).To(Equal(1))
			tags := fakeExecutorClient.ListContainersArgsForCall(0)
			Expect(tags).To(BeNil())
		})

		Context("when retrieving container and BBS data succeeds", func() {
			const (
				instanceGuidContainerOnly                 = "guid-container-only"
				instanceGuidContainerForInstanceLRP       = "guid-container-for-instance-lrp"
				instanceGuidContainerForEvacuatingLRP     = "guid-container-for-evacuating-lrp"
				guidContainerForTask                      = "guid-container-for-task"
				instanceGuidInstanceLRPOnly               = "guid-instance-lrp-only"
				instanceGuidEvacuatingLRPOnly             = "guid-evacuating-lrp-only"
				instanceGuidInstanceAndEvacuatingLRPsOnly = "guid-instance-and-evacuating-lrps-only"
				guidTaskOnly                              = "guid-task-only"

				processGuid = "process-guid"
Ejemplo n.º 2
0
					Guid:     "other-task",
					Resource: executor.NewResource(40, 30, "rootfs"),
					Tags:     nil,
				},
			}

			client.TotalResourcesReturns(totalResources, nil)
			client.RemainingResourcesFromReturns(availableResources, nil)
			client.ListContainersReturns(containers, nil)
		})

		It("queries the client and returns state", func() {
			state, err := cellRep.State()
			Expect(err).NotTo(HaveOccurred())

			Expect(client.ListContainersArgsForCall(0)).To(Equal(executor.Tags{}))
			Expect(client.RemainingResourcesFromArgsForCall(0)).To(Equal(containers))

			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),
				Containers: availableResources.Containers,
			}))

			Expect(state.TotalResources).To(Equal(rep.Resources{