// DesireLRP creates a DesiredLRPSchedulingInfo and a DesiredLRPRunInfo. In order
// to ensure that the complete model is available and there are no races in
// Desired Watches, DesiredLRPRunInfo is created before DesiredLRPSchedulingInfo.
func (db *ETCDDB) DesireLRP(logger lager.Logger, desiredLRP *models.DesiredLRP) error {
logger = logger.WithData(lager.Data{"process_guid": desiredLRP.ProcessGuid})
logger.Info("starting")
defer logger.Info("complete")
schedulingInfo, runInfo := desiredLRP.CreateComponents(db.clock.Now())
err := db.createDesiredLRPRunInfo(logger, &runInfo)
if err != nil {
return err
}
schedulingErr := db.createDesiredLRPSchedulingInfo(logger, &schedulingInfo)
if schedulingErr != nil {
logger.Info("deleting-orphaned-run-info")
_, err = db.client.Delete(DesiredLRPRunInfoSchemaPath(desiredLRP.ProcessGuid), true)
if err != nil {
logger.Error("failed-deleting-orphaned-run-info", err)
}
return schedulingErr
}
return nil
}
desiredLRP.Setup = models.WrapAction(&models.TimeoutAction{Action: models.WrapAction(&models.RunAction{Path: "ls", User: "******"}),
DeprecatedTimeoutNs: 7 * int64(time.Second),
})
desiredLRP.Monitor = models.WrapAction(models.EmitProgressFor(
&models.TimeoutAction{
Action: models.WrapAction(models.Try(models.Parallel(models.Serial(&models.RunAction{Path: "ls", User: "******"})))),
DeprecatedTimeoutNs: 10 * int64(time.Second),
},
"start-message",
"success-message",
"failure-message",
))
})
JustBeforeEach(func() {
schedulingInfo, runInfo := desiredLRP.CreateComponents(fakeClock.Now())
runInfo.DeprecatedStartTimeoutS = 15
_, err := json.Marshal(desiredLRP.Routes)
Expect(err).NotTo(HaveOccurred())
schedInfoData, err := serializer.Marshal(logger, format.ENCRYPTED_PROTO, &schedulingInfo)
Expect(err).NotTo(HaveOccurred())
_, err = storeClient.Set(etcddb.DesiredLRPSchedulingInfoSchemaPath(processGuid), schedInfoData, 0)
Expect(err).NotTo(HaveOccurred())
runInfoData, err := serializer.Marshal(logger, format.ENCRYPTED_PROTO, &runInfo)
Expect(err).NotTo(HaveOccurred())
_, err = storeClient.Set(etcddb.DesiredLRPRunInfoSchemaPath(processGuid), runInfoData, 0)
Expect(err).NotTo(HaveOccurred())
encoder := format.NewEncoder(cryptor)
func (t *ETCDHelper) SetRawDesiredLRP(lrp *models.DesiredLRP) {
schedulingInfo, runInfo := lrp.CreateComponents(t.clock.Now())
t.SetRawDesiredLRPSchedulingInfo(&schedulingInfo)
t.SetRawDesiredLRPRunInfo(&runInfo)
}
"properties": {
"key": "value",
"another_key": "another_value"
}
}
}`
BeforeEach(func() {
desiredLRP = models.DesiredLRP{}
err := json.Unmarshal([]byte(jsonDesiredLRP), &desiredLRP)
Expect(err).NotTo(HaveOccurred())
})
Describe("CreateComponents", func() {
It("decomposes the desired lrp into it's component parts", func() {
schedInfo, runInfo := desiredLRP.CreateComponents(time.Unix(123, 456))
newDesired := models.NewDesiredLRP(schedInfo, runInfo)
Expect(newDesired).To(BeEquivalentTo(desiredLRP))
})
It("saves the created at time on the run info", func() {
_, runInfo := desiredLRP.CreateComponents(time.Unix(123, 456))
Expect(runInfo.CreatedAt).To(BeEquivalentTo((time.Unix(123, 456).UnixNano())))
})
})
Describe("serialization", func() {
It("successfully round trips through json and protobuf", func() {
jsonSerialization, err := json.Marshal(desiredLRP)
Expect(err).NotTo(HaveOccurred())
Expect(jsonSerialization).To(MatchJSON(jsonDesiredLRP))