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")