Esempio n. 1
0
			desiredLRP, err := etcdDB.DesiredLRPByProcessGuid(logger, lrp.GetProcessGuid())
			Expect(err).NotTo(HaveOccurred())

			Eventually(creates).Should(Receive(Equal(desiredLRP)))
		})

		It("sends an event down the pipe for updates", func() {
			etcdHelper.SetRawDesiredLRP(lrp)

			Eventually(creates).Should(Receive())

			desiredBeforeUpdate, err := etcdDB.DesiredLRPByProcessGuid(logger, lrp.GetProcessGuid())
			Expect(err).NotTo(HaveOccurred())

			lrp.Instances = lrp.GetInstances() + 1
			etcdHelper.SetRawDesiredLRP(lrp)
			Expect(err).NotTo(HaveOccurred())

			desiredAfterUpdate, err := etcdDB.DesiredLRPByProcessGuid(logger, lrp.GetProcessGuid())
			Expect(err).NotTo(HaveOccurred())

			Eventually(changes).Should(Receive(Equal(&models.DesiredLRPChange{
				Before: desiredBeforeUpdate,
				After:  desiredAfterUpdate,
			})))
		})

		It("sends an event down the pipe for deletes", func() {
			etcdHelper.SetRawDesiredLRP(lrp)
Esempio n. 2
0
				etcdRunner.Start()
			})

			It("errors", func() {
				_, err := etcdDB.DesiredLRPSchedulingInfos(logger, filter)
				Expect(err).To(HaveOccurred())
			})
		})
	})

	Describe("DesireLRP", func() {
		var lrp *models.DesiredLRP

		BeforeEach(func() {
			lrp = model_helpers.NewValidDesiredLRP("some-process-guid")
			lrp.Instances = 5
		})

		Context("when the desired LRP does not yet exist", func() {
			It("persists the scheduling info and run info", func() {
				err := etcdDB.DesireLRP(logger, lrp)
				Expect(err).NotTo(HaveOccurred())

				persisted, err := etcdDB.DesiredLRPByProcessGuid(logger, "some-process-guid")
				Expect(err).NotTo(HaveOccurred())

				Expect(persisted.DesiredLRPKey()).To(Equal(lrp.DesiredLRPKey()))
				Expect(persisted.DesiredLRPResource()).To(Equal(lrp.DesiredLRPResource()))
				Expect(persisted.Annotation).To(Equal(lrp.Annotation))
				Expect(persisted.Instances).To(Equal(lrp.Instances))
				Expect(persisted.DesiredLRPRunInfo(clock.Now())).To(Equal(lrp.DesiredLRPRunInfo(clock.Now())))
Esempio n. 3
0
				}(validGuid)
			}

			invalidGuids := []string{"", "bang!", "!!!", "\\slash", "star*", "params()", "invalid/key", "with.dots"}
			for _, invalidGuid := range invalidGuids {
				func(invalidGuid string) {
					It(fmt.Sprintf("'%s' is an invalid process_guid", invalidGuid), func() {
						desiredLRP.ProcessGuid = invalidGuid
						assertDesiredLRPValidationFailsWithMessage(desiredLRP, "process_guid")
					})
				}(invalidGuid)
			}
		})

		It("requires a positive nonzero number of instances", func() {
			desiredLRP.Instances = -1
			assertDesiredLRPValidationFailsWithMessage(desiredLRP, "instances")

			desiredLRP.Instances = 0
			validationErr := desiredLRP.Validate()
			Expect(validationErr).NotTo(HaveOccurred())

			desiredLRP.Instances = 1
			validationErr = desiredLRP.Validate()
			Expect(validationErr).NotTo(HaveOccurred())
		})

		It("requires a domain", func() {
			desiredLRP.Domain = ""
			assertDesiredLRPValidationFailsWithMessage(desiredLRP, "domain")
		})