func (t *ETCDHelper) CreateDesiredLRPsInDomains(domainCounts map[string]int) map[string][]*models.DesiredLRP { createdDesiredLRPs := map[string][]*models.DesiredLRP{} for domain, count := range domainCounts { createdDesiredLRPs[domain] = []*models.DesiredLRP{} for i := 0; i < count; i++ { guid := fmt.Sprintf("guid-%d-for-%s", i, domain) desiredLRP := model_helpers.NewValidDesiredLRP(guid) desiredLRP.Domain = domain schedulingInfo, runInfo := desiredLRP.Explode() schedulingInfoValue, err := t.serializer.Marshal(t.logger, t.format, &schedulingInfo) Expect(err).NotTo(HaveOccurred()) t.client.Set(etcddb.DesiredLRPSchedulingInfoSchemaPath(guid), schedulingInfoValue, 0) Expect(err).NotTo(HaveOccurred()) runInfoValue, err := t.serializer.Marshal(t.logger, t.format, &runInfo) Expect(err).NotTo(HaveOccurred()) t.client.Set(etcddb.DesiredLRPRunInfoSchemaPath(guid), runInfoValue, 0) Expect(err).NotTo(HaveOccurred()) createdDesiredLRPs[domain] = append(createdDesiredLRPs[domain], desiredLRP) } } return createdDesiredLRPs }
func (t *ETCDHelper) SetRawDesiredLRPSchedulingInfo(model *models.DesiredLRPSchedulingInfo) { value, err := t.serializer.Marshal(t.logger, t.format, model) Expect(err).NotTo(HaveOccurred()) key := etcddb.DesiredLRPSchedulingInfoSchemaPath(model.ProcessGuid) _, err = t.client.Set(key, value, 0) Expect(err).NotTo(HaveOccurred()) }
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 (t *ETCDHelper) DeleteDesiredLRP(guid string) { _, err := t.client.Delete(etcd.DesiredLRPSchedulingInfoSchemaPath(guid), false) Expect(err).NotTo(HaveOccurred()) _, err = t.client.Delete(etcd.DesiredLRPRunInfoSchemaPath(guid), false) Expect(err).NotTo(HaveOccurred()) }
It("should delete it", func() { err := etcdDB.RemoveDesiredLRP(logger, lrp.ProcessGuid) Expect(err).NotTo(HaveOccurred()) _, err = etcdDB.DesiredLRPByProcessGuid(logger, lrp.ProcessGuid) Expect(err).To(HaveOccurred()) Expect(err).To(Equal(models.ErrResourceNotFound)) }) }) Context("when the RunInfo exists, and the SchedulingInfo does not exist", func() { BeforeEach(func() { err := etcdDB.DesireLRP(logger, lrp) Expect(err).NotTo(HaveOccurred()) _, err = storeClient.Delete(etcd.DesiredLRPSchedulingInfoSchemaPath(lrp.ProcessGuid), true) Expect(err).NotTo(HaveOccurred()) }) It("deletes the RunInfo", func() { err := etcdDB.RemoveDesiredLRP(logger, lrp.ProcessGuid) Expect(err).ToNot(HaveOccurred()) _, err = etcdDB.DesiredLRPByProcessGuid(logger, lrp.ProcessGuid) Expect(err).To(Equal(models.ErrResourceNotFound)) _, err = storeClient.Get(etcd.DesiredLRPRunInfoSchemaPath(lrp.ProcessGuid), false, false) Expect(etcd.ErrorFromEtcdError(logger, err)).To(Equal(models.ErrResourceNotFound)) }) }) Context("when removing the SchedulingInfo fails", func() { BeforeEach(func() {
func (t *ETCDHelper) CreateMalformedDesiredLRP(guid string) { t.createMalformedValueForKey(etcddb.DesiredLRPSchedulingInfoSchemaPath(guid)) t.createMalformedValueForKey(etcddb.DesiredLRPRunInfoSchemaPath(guid)) }
Expect(*updated.Routes).To(HaveKey("router")) json, err := (*update.Routes)["router"].MarshalJSON() Expect(err).NotTo(HaveOccurred()) updatedJson, err := (*updated.Routes)["router"].MarshalJSON() Expect(err).NotTo(HaveOccurred()) Expect(updatedJson).To(MatchJSON(string(json))) Expect(updated.Annotation).To(Equal(*update.Annotation)) Expect(updated.Instances).To(Equal(*update.Instances)) Expect(updated.ModificationTag.Epoch).To(Equal(desiredLRP.ModificationTag.Epoch)) Expect(updated.ModificationTag.Index).To(Equal(desiredLRP.ModificationTag.Index + 1)) }) Context("when the compare and swap fails", func() { BeforeEach(func() { resp, err := storeClient.Get(etcd.DesiredLRPSchedulingInfoSchemaPath(lrp.ProcessGuid), false, false) Expect(err).NotTo(HaveOccurred()) fakeStoreClient.GetReturns(resp, nil) // return the pre-updated desired lrps }) Context("for a CAS failure", func() { BeforeEach(func() { fakeStoreClient.CompareAndSwapReturns(nil, etcdclient.EtcdError{ErrorCode: etcd.ETCDErrIndexComparisonFailed}) }) It("retries the update up to 2 times", func() { Expect(fakeStoreClient.CompareAndSwapCallCount()).To(Equal(0)) modelErr := etcdDBWithFakeStore.UpdateDesiredLRP(logger, lrp.ProcessGuid, update) Expect(modelErr).To(HaveOccurred()) Expect(fakeStoreClient.CompareAndSwapCallCount()).To(Equal(2)) })
"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) encryptedVolumePlacement, err := serializer.Marshal(logger, format.ENCRYPTED_PROTO, schedulingInfo.VolumePlacement) Expect(err).NotTo(HaveOccurred()) _, err = encoder.Decode(encryptedVolumePlacement) Expect(err).NotTo(HaveOccurred()) migration.SetStoreClient(storeClient) migration.SetCryptor(cryptor) migration.SetClock(fakeClock)
}) }) }) Context("when there are already 'migrated' data in the database", func() { var existingSplit *models.DesiredLRP BeforeEach(func() { existingSplit = newValidDesiredLRP("existing-split") schedulingInfo, runInfo := existingSplit.CreateComponents(time.Unix(42, 42)) schedulingInfoPayload, err := serializer.Marshal(logger, format.ENCRYPTED_PROTO, &schedulingInfo) Expect(err).NotTo(HaveOccurred()) runInfoPayload, err := serializer.Marshal(logger, format.ENCRYPTED_PROTO, &runInfo) Expect(err).NotTo(HaveOccurred()) _, err = storeClient.Set(etcd.DesiredLRPSchedulingInfoSchemaPath("existing-split"), schedulingInfoPayload, 0) Expect(err).NotTo(HaveOccurred()) _, err = storeClient.Set(etcd.DesiredLRPRunInfoSchemaPath("existing-split"), runInfoPayload, 0) Expect(err).NotTo(HaveOccurred()) }) It("deletes the existing lrp that was already split afterwards", func() { Expect(migrationErr).NotTo(HaveOccurred()) _, err := storeClient.Get(etcd.DesiredLRPSchedulingInfoSchemaPath("existing-split"), false, true) Expect(err).To(HaveOccurred()) _, err = storeClient.Get(etcd.DesiredLRPRunInfoSchemaPath("existing-split"), false, true) Expect(err).To(HaveOccurred()) }) })