func (m *SplitDesiredLRP) WriteSchedulingInfo(logger lager.Logger, desiredLRP models.DesiredLRP) {
schedulingInfo := models.DesiredLRPSchedulingInfo{
DesiredLRPKey: desiredLRP.DesiredLRPKey(),
Annotation: desiredLRP.Annotation,
Instances: desiredLRP.Instances,
DesiredLRPResource: desiredLRP.DesiredLRPResource(),
}
if desiredLRP.Routes != nil {
schedulingInfo.Routes = *desiredLRP.Routes
}
if desiredLRP.ModificationTag != nil {
schedulingInfo.ModificationTag = *desiredLRP.ModificationTag
}
schedulingInfoPayload, marshalErr := m.serializer.Marshal(logger, format.ENCRYPTED_PROTO, &schedulingInfo)
if marshalErr != nil {
logger.Error("failed-marshaling-scheduling-info", marshalErr, lager.Data{"process_guid": schedulingInfo.ProcessGuid})
}
_, setErr := m.storeClient.Set(etcd.DesiredLRPSchedulingInfoSchemaPath(desiredLRP.ProcessGuid), schedulingInfoPayload, etcd.NO_TTL)
if setErr != nil {
logger.Error("failed-set-of-scheduling-info", marshalErr, lager.Data{"process_guid": schedulingInfo.ProcessGuid})
}
}
func (m *SplitDesiredLRP) WriteRunInfo(logger lager.Logger, desiredLRP models.DesiredLRP) {
environmentVariables := make([]models.EnvironmentVariable, len(desiredLRP.EnvironmentVariables))
for i := range desiredLRP.EnvironmentVariables {
environmentVariables[i] = *desiredLRP.EnvironmentVariables[i]
}
egressRules := make([]models.SecurityGroupRule, len(desiredLRP.EgressRules))
for i := range desiredLRP.EgressRules {
egressRules[i] = *desiredLRP.EgressRules[i]
}
runInfo := models.DesiredLRPRunInfo{
DesiredLRPKey: desiredLRP.DesiredLRPKey(),
EnvironmentVariables: environmentVariables,
Setup: desiredLRP.Setup,
Action: desiredLRP.Action,
Monitor: desiredLRP.Monitor,
StartTimeoutMs: desiredLRP.StartTimeoutMs,
Privileged: desiredLRP.Privileged,
CpuWeight: desiredLRP.CpuWeight,
Ports: desiredLRP.Ports,
EgressRules: egressRules,
LogSource: desiredLRP.LogSource,
MetricsGuid: desiredLRP.MetricsGuid,
}
runInfoPayload, marshalErr := m.serializer.Marshal(logger, format.ENCRYPTED_PROTO, &runInfo)
if marshalErr != nil {
logger.Error("failed-marshaling-run-info", marshalErr, lager.Data{"process_guid": runInfo.ProcessGuid})
}
_, setErr := m.storeClient.Set(etcd.DesiredLRPRunInfoSchemaPath(runInfo.ProcessGuid), runInfoPayload, etcd.NO_TTL)
if setErr != nil {
logger.Error("failed-set-of-run-info", marshalErr, lager.Data{"process_guid": runInfo.ProcessGuid})
}
}
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())))
})
It("sets the ModificationTag on the DesiredLRP", func() {
err := etcdDB.DesireLRP(logger, lrp)
Expect(err).NotTo(HaveOccurred())
lrp, err := etcdDB.DesiredLRPByProcessGuid(logger, "some-process-guid")
Expect(err).NotTo(HaveOccurred())
Expect(lrp.ModificationTag.Epoch).NotTo(BeEmpty())
Expect(lrp.ModificationTag.Index).To(BeEquivalentTo(0))
desireErr error
)
BeforeEach(func() {
desiredLRP = model_helpers.NewValidDesiredLRP("super-lrp")
})
JustBeforeEach(func() {
desireErr = client.DesireLRP(logger, desiredLRP)
})
It("creates the desired LRP in the system", func() {
Expect(desireErr).NotTo(HaveOccurred())
persistedDesiredLRP, err := client.DesiredLRPByProcessGuid(logger, "super-lrp")
Expect(err).NotTo(HaveOccurred())
Expect(persistedDesiredLRP.DesiredLRPKey()).To(Equal(desiredLRP.DesiredLRPKey()))
Expect(persistedDesiredLRP.DesiredLRPResource()).To(Equal(desiredLRP.DesiredLRPResource()))
Expect(persistedDesiredLRP.Annotation).To(Equal(desiredLRP.Annotation))
Expect(persistedDesiredLRP.Instances).To(Equal(desiredLRP.Instances))
Expect(persistedDesiredLRP.DesiredLRPRunInfo(time.Unix(42, 0))).To(Equal(desiredLRP.DesiredLRPRunInfo(time.Unix(42, 0))))
Expect(persistedDesiredLRP.Action.RunAction.SuppressLogOutput).To(BeFalse())
})
Context("when suppressing log output", func() {
BeforeEach(func() {
desiredLRP.Action.RunAction.SuppressLogOutput = true
})
It("has an action with SuppressLogOutput set to true", func() {
Expect(desireErr).NotTo(HaveOccurred())
persistedDesiredLRP, err := client.DesiredLRPByProcessGuid(logger, "super-lrp")