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})
}
}
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})
}
}
var (
desiredLRP *models.DesiredLRP
desireErr error
)
JustBeforeEach(func() {
desiredLRP = model_helpers.NewValidDesiredLRP("super-lrp")
desireErr = client.DesireLRP(desiredLRP)
})
It("creates the desired LRP in the system", func() {
Expect(desireErr).NotTo(HaveOccurred())
persistedDesiredLRP, err := client.DesiredLRPByProcessGuid("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()).To(Equal(desiredLRP.DesiredLRPRunInfo()))
})
})
Describe("RemoveDesiredLRP", func() {
var (
desiredLRP *models.DesiredLRP
removeErr error
)
JustBeforeEach(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())))
})
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))
migration.SetCryptor(cryptor)
migrationErr = migration.Up(logger)
})
It("creates a DesiredLRPSchedulingInfo for all desired LRPs", func() {
Expect(migrationErr).NotTo(HaveOccurred())
response, err := storeClient.Get(etcd.DesiredLRPSchedulingInfoSchemaRoot, false, true)
Expect(err).NotTo(HaveOccurred())
Expect(response.Node.Nodes).To(HaveLen(1))
for _, node := range response.Node.Nodes {
var schedulingInfo models.DesiredLRPSchedulingInfo
serializer.Unmarshal(logger, []byte(node.Value), &schedulingInfo)
Expect(schedulingInfo.DesiredLRPKey).To(Equal(existingDesiredLRP.DesiredLRPKey()))
Expect(schedulingInfo.DesiredLRPResource).To(Equal(existingDesiredLRP.DesiredLRPResource()))
Expect(schedulingInfo.Annotation).To(Equal(existingDesiredLRP.Annotation))
Expect(schedulingInfo.Instances).To(Equal(existingDesiredLRP.Instances))
Expect(schedulingInfo.Routes).To(Equal(*existingDesiredLRP.Routes))
Expect(schedulingInfo.ModificationTag).To(Equal(*existingDesiredLRP.ModificationTag))
}
})
It("creates a DesiredLRPRunInfo for all desired LRPs", func() {
Expect(migrationErr).NotTo(HaveOccurred())
response, err := storeClient.Get(etcd.DesiredLRPRunInfoSchemaRoot, false, true)
Expect(err).NotTo(HaveOccurred())
Expect(response.Node.Nodes).To(HaveLen(1))
