func lrpForState(state string, timeInState time.Duration) models.ActualLRP {
	var actualLRPKey = models.NewActualLRPKey("some-process-guid", 1, "tests")
	var instanceKey = models.NewActualLRPInstanceKey("some-instance-guid", "some-cell")

	lrp := models.ActualLRP{
		ActualLRPKey: actualLRPKey,
		State:        state,
		Since:        clock.Now().Add(-timeInState).UnixNano(),
	}

	switch state {
	case models.ActualLRPStateUnclaimed:
	case models.ActualLRPStateCrashed:
		lrp.CrashReason = "crashed"
	case models.ActualLRPStateClaimed:
		lrp.ActualLRPInstanceKey = instanceKey
	case models.ActualLRPStateRunning:
		lrp.ActualLRPInstanceKey = instanceKey
		lrp.ActualLRPNetInfo = models.NewActualLRPNetInfo("1.2.3.4", &models.PortMapping{ContainerPort: 1234, HostPort: 5678})
	}

	return lrp
}
示例#2
0
		Context("when the actual lrp data is the same", func() {
			It("does nothing", func() {
				_, err := etcdDBWithFakeStore.EvacuateActualLRP(logger, &actualLRP.ActualLRPKey, &actualLRP.ActualLRPInstanceKey, &actualLRP.ActualLRPNetInfo, ttl)
				Expect(err).NotTo(HaveOccurred())

				Expect(fakeStoreClient.CompareAndSwapCallCount()).To(Equal(0))
			})
		})

		Context("when the evacuating actual lrp does not exist", func() {
			BeforeEach(func() {
				_, err := storeClient.Delete(etcd.EvacuatingActualLRPSchemaPath(guid, index), false)
				Expect(err).NotTo(HaveOccurred())

				actualLRP.CrashCount = 0
				actualLRP.CrashReason = ""
				actualLRP.Since = clock.Now().UnixNano()
			})

			It("creates the evacuating actual lrp", func() {
				group, err := etcdDB.EvacuateActualLRP(logger, &actualLRP.ActualLRPKey, &actualLRP.ActualLRPInstanceKey, &actualLRP.ActualLRPNetInfo, ttl)
				Expect(err).NotTo(HaveOccurred())

				actualLRPGroup, err := etcdDB.ActualLRPGroupByProcessGuidAndIndex(logger, guid, index)
				Expect(err).NotTo(HaveOccurred())
				Expect(group).To(Equal(actualLRPGroup))

				Expect(actualLRPGroup.Evacuating.ModificationTag.Epoch).NotTo(BeNil())
				Expect(actualLRPGroup.Evacuating.ModificationTag.Index).To(BeEquivalentTo((1)))
				actualLRPGroup.Evacuating.ModificationTag = actualLRP.ModificationTag
				Expect(actualLRPGroup.Evacuating).To(BeEquivalentTo(actualLRP))
			actualLRP.State = ""
			Expect(serialization.ActualLRPProtoToResponse(actualLRP, false).State).To(Equal(receptor.ActualLRPStateInvalid))
		})

		Context("when there is placement error", func() {
			BeforeEach(func() {
				actualLRP.State = models.ActualLRPStateUnclaimed
				actualLRP.PlacementError = "some-error"
			})

			It("includes the placement error", func() {
				actualResponse := serialization.ActualLRPProtoToResponse(actualLRP, false)
				Expect(actualResponse.PlacementError).To(Equal("some-error"))
			})
		})

		Context("when there is a crash reason", func() {
			BeforeEach(func() {
				actualLRP.State = models.ActualLRPStateCrashed
				actualLRP.CrashReason = "crashed"
			})

			It("includes the placement error", func() {
				actualResponse := serialization.ActualLRPProtoToResponse(actualLRP, false)
				Expect(actualResponse.CrashReason).To(Equal("crashed"))
			})
		})
	})
})