DesiredLrp: desiredLRP,
}
})
JustBeforeEach(func() {
request := newTestRequest(requestBody)
handler.DesireDesiredLRP(logger, responseRecorder, request)
})
Context("when creating desired lrp in DB succeeds", func() {
var createdActualLRPGroups []*models.ActualLRPGroup
BeforeEach(func() {
createdActualLRPGroups = []*models.ActualLRPGroup{}
for i := 0; i < 5; i++ {
createdActualLRPGroups = append(createdActualLRPGroups, &models.ActualLRPGroup{Instance: model_helpers.NewValidActualLRP("some-guid", int32(i))})
}
fakeDesiredLRPDB.DesireLRPReturns(nil)
fakeActualLRPDB.CreateUnclaimedActualLRPStub = func(_ lager.Logger, key *models.ActualLRPKey) (*models.ActualLRPGroup, error) {
if int(key.Index) > len(createdActualLRPGroups)-1 {
return nil, errors.New("boom")
}
return createdActualLRPGroups[int(key.Index)], nil
}
fakeDesiredLRPDB.DesiredLRPByProcessGuidReturns(desiredLRP, nil)
})
It("creates desired lrp", func() {
Expect(fakeDesiredLRPDB.DesireLRPCallCount()).To(Equal(1))
_, actualDesiredLRP := fakeDesiredLRPDB.DesireLRPArgsForCall(0)
Expect(actualDesiredLRP).To(Equal(desiredLRP))
cellID string
cellSet models.CellSet
controller *controllers.LRPConvergenceController
)
BeforeEach(func() {
fakeLRPDB = new(dbfakes.FakeLRPDB)
fakeAuctioneerClient = new(auctioneerfakes.FakeClient)
logger = lagertest.NewTestLogger("test")
request1 := auctioneer.NewLRPStartRequestFromModel(model_helpers.NewValidDesiredLRP("to-auction-1"), 1, 2)
request2 := auctioneer.NewLRPStartRequestFromModel(model_helpers.NewValidDesiredLRP("to-auction-2"), 0, 4)
retiringActualLRP1 = model_helpers.NewValidActualLRP("to-retire-1", 0)
retiringActualLRP2 = model_helpers.NewValidActualLRP("to-retire-2", 1)
keysToRetire = []*models.ActualLRPKey{&retiringActualLRP1.ActualLRPKey, &retiringActualLRP2.ActualLRPKey}
desiredLRP1 = model_helpers.NewValidDesiredLRP("to-unclaim-1").DesiredLRPSchedulingInfo()
unclaimingActualLRP1 = model_helpers.NewValidActualLRP("to-unclaim-1", 0)
desiredLRP2 = model_helpers.NewValidDesiredLRP("to-unclaim-2").DesiredLRPSchedulingInfo()
unclaimingActualLRP2 = model_helpers.NewValidActualLRP("to-unclaim-2", 1)
keysWithMissingCells = []*models.ActualLRPKeyWithSchedulingInfo{
{Key: &unclaimingActualLRP1.ActualLRPKey, SchedulingInfo: &desiredLRP1},
{Key: &unclaimingActualLRP2.ActualLRPKey, SchedulingInfo: &desiredLRP2},
}
keysToAuction = []*auctioneer.LRPStartRequest{&request1, &request2}
cellID = "cell-id"
"code.cloudfoundry.org/bbs/test_helpers"
. "github.com/onsi/ginkgo"
. "github.com/onsi/gomega"
)
var _ = Describe("Evacuation", func() {
var (
actualLRP *models.ActualLRP
guid string
index int32
)
BeforeEach(func() {
guid = "some-guid"
index = int32(1)
actualLRP = model_helpers.NewValidActualLRP(guid, index)
actualLRP.CrashCount = 0
actualLRP.CrashReason = ""
actualLRP.Since = fakeClock.Now().UnixNano()
actualLRP.ModificationTag = models.ModificationTag{}
actualLRP.ModificationTag.Increment()
actualLRP.ModificationTag.Increment()
_, err := sqlDB.CreateUnclaimedActualLRP(logger, &actualLRP.ActualLRPKey)
Expect(err).NotTo(HaveOccurred())
_, _, err = sqlDB.ClaimActualLRP(logger, guid, index, &actualLRP.ActualLRPInstanceKey)
Expect(err).NotTo(HaveOccurred())
_, _, err = sqlDB.StartActualLRP(logger, &actualLRP.ActualLRPKey, &actualLRP.ActualLRPInstanceKey, &actualLRP.ActualLRPNetInfo)
Expect(err).NotTo(HaveOccurred())
})
expectedDesiredLRP *models.DesiredLRP
expectedActualLRP, expectedEvacuatingActualLRP *models.ActualLRP
expectedTask *models.Task
migrationErr error
)
BeforeEach(func() {
// DesiredLRP
expectedDesiredLRP = model_helpers.NewValidDesiredLRP("process-guid")
jsonValue, err := json.Marshal(expectedDesiredLRP)
Expect(err).NotTo(HaveOccurred())
_, err = storeClient.Set(deprecations.DesiredLRPSchemaPath(expectedDesiredLRP), jsonValue, 0)
Expect(err).NotTo(HaveOccurred())
// ActualLRP
expectedActualLRP = model_helpers.NewValidActualLRP("process-guid", 1)
jsonValue, err = json.Marshal(expectedActualLRP)
Expect(err).NotTo(HaveOccurred())
_, err = storeClient.Set(etcd.ActualLRPSchemaPath(expectedActualLRP.ProcessGuid, 1), jsonValue, 0)
Expect(err).NotTo(HaveOccurred())
// Evacuating ActualLRP
expectedEvacuatingActualLRP = model_helpers.NewValidActualLRP("process-guid", 4)
jsonValue, err = json.Marshal(expectedEvacuatingActualLRP)
Expect(err).NotTo(HaveOccurred())
_, err = storeClient.Set(
etcd.EvacuatingActualLRPSchemaPath(expectedEvacuatingActualLRP.ProcessGuid, 1),
jsonValue,
0,
)
Expect(err).NotTo(HaveOccurred())
func (t *ETCDHelper) CreateValidEvacuatingLRP(guid string, index int32) {
t.SetRawEvacuatingActualLRP(model_helpers.NewValidActualLRP(guid, index), 100)
}
DesiredLrp: desiredLRP,
}
})
JustBeforeEach(func() {
request := newTestRequest(requestBody)
handler.DesireDesiredLRP_r0(logger, responseRecorder, request)
})
Context("when creating desired lrp in DB succeeds", func() {
var createdActualLRPGroups []*models.ActualLRPGroup
BeforeEach(func() {
createdActualLRPGroups = []*models.ActualLRPGroup{}
for i := 0; i < 5; i++ {
createdActualLRPGroups = append(createdActualLRPGroups, &models.ActualLRPGroup{Instance: model_helpers.NewValidActualLRP("some-guid", int32(i))})
}
fakeDesiredLRPDB.DesireLRPReturns(nil)
fakeActualLRPDB.CreateUnclaimedActualLRPStub = func(_ lager.Logger, key *models.ActualLRPKey) (*models.ActualLRPGroup, error) {
if int(key.Index) > len(createdActualLRPGroups)-1 {
return nil, errors.New("boom")
}
return createdActualLRPGroups[int(key.Index)], nil
}
fakeDesiredLRPDB.DesiredLRPByProcessGuidReturns(expectedDesiredLRP, nil)
})
It("creates desired lrp", func() {
Expect(fakeDesiredLRPDB.DesireLRPCallCount()).To(Equal(1))
_, actualDesiredLRP := fakeDesiredLRPDB.DesireLRPArgsForCall(0)
Expect(actualDesiredLRP).To(Equal(expectedDesiredLRP))
func (t *ETCDHelper) CreateValidActualLRP(guid string, index int32) {
t.SetRawActualLRP(model_helpers.NewValidActualLRP(guid, index))
}
BeforeEach(func() {
fakeStoreClient.GetReturns(nil, etcderrors.EtcdError{ErrorCode: ETCDErrKeyNotFound})
fakeStoreClient.CreateReturns(nil, errors.New("oh no!"))
})
It("errors", func() {
_, err := etcdDBWithFakeStore.CreateUnclaimedActualLRP(logger, lrpKey)
Expect(err).To(HaveOccurred())
})
})
})
Context("when the actual LRP exists", func() {
var actualLRP *models.ActualLRP
BeforeEach(func() {
actualLRP = model_helpers.NewValidActualLRP(lrpKey.ProcessGuid, lrpKey.Index)
etcdHelper.SetRawActualLRP(actualLRP)
})
It("returns a ResourceExists error", func() {
_, err := etcdDB.CreateUnclaimedActualLRP(logger, lrpKey)
Expect(err).To(HaveOccurred())
})
})
})
Describe("UnclaimActualLRP", func() {
var (
lrpKey *models.ActualLRPKey
guid, domain string
index int32
"code.cloudfoundry.org/bbs/models"
"code.cloudfoundry.org/bbs/models/test/model_helpers"
"github.com/tedsuo/ifrit/ginkgomon"
. "github.com/onsi/ginkgo"
. "github.com/onsi/gomega"
)
var _ = Describe("Evacuation API", func() {
var actual *models.ActualLRP
BeforeEach(func() {
bbsRunner = testrunner.New(bbsBinPath, bbsArgs)
bbsProcess = ginkgomon.Invoke(bbsRunner)
actual = model_helpers.NewValidActualLRP("some-process-guid", 1)
actual.State = models.ActualLRPStateRunning
desiredLRP := model_helpers.NewValidDesiredLRP(actual.ProcessGuid)
desiredLRP.Instances = 2
Expect(client.DesireLRP(logger, desiredLRP)).To(Succeed())
Expect(client.ClaimActualLRP(logger, actual.ProcessGuid, 1, &actual.ActualLRPInstanceKey)).To(Succeed())
_, err := client.ActualLRPGroupByProcessGuidAndIndex(logger, actual.ProcessGuid, int(actual.Index))
Expect(err).NotTo(HaveOccurred())
})
Describe("RemoveEvacuatingActualLRP", func() {
It("removes the evacuating actual_lrp", func() {
_, err := client.EvacuateClaimedActualLRP(logger, &actual.ActualLRPKey, &actual.ActualLRPInstanceKey)
Expect(err).NotTo(HaveOccurred())
})
Describe("EvacuateClaimedActualLRP", func() {
var (
request *http.Request
requestBody *models.EvacuateClaimedActualLRPRequest
actual *models.ActualLRP
afterActual *models.ActualLRP
desiredLRP *models.DesiredLRP
)
BeforeEach(func() {
desiredLRP = model_helpers.NewValidDesiredLRP("the-guid")
fakeDesiredLRPDB.DesiredLRPByProcessGuidReturns(desiredLRP, nil)
actual = model_helpers.NewValidActualLRP("process-guid", 1)
requestBody = &models.EvacuateClaimedActualLRPRequest{
ActualLrpKey: &actual.ActualLRPKey,
ActualLrpInstanceKey: &actual.ActualLRPInstanceKey,
}
afterActual = model_helpers.NewValidActualLRP("process-guid", 1)
afterActual.State = models.ActualLRPStateUnclaimed
fakeActualLRPDB.ActualLRPGroupByProcessGuidAndIndexReturns(&models.ActualLRPGroup{Evacuating: actual}, nil)
fakeActualLRPDB.UnclaimActualLRPReturns(&models.ActualLRPGroup{Instance: actual}, &models.ActualLRPGroup{Instance: afterActual}, nil)
request = newTestRequest(requestBody)
})
JustBeforeEach(func() {
handler.EvacuateClaimedActualLRP(logger, responseRecorder, request)
Expect(responseRecorder.Code).To(Equal(http.StatusOK))
Expect(desiredLRPs).To(ConsistOf(existingDesiredLRPs))
})
})
Describe("Actual LRPs", func() {
var (
existingActualLRPs []migrations.ETCDToSQLActualLRP
instanceLRPsToCreate int
)
BeforeEach(func() {
instanceLRPsToCreate = 3
for i := 0; i < instanceLRPsToCreate; i++ {
processGuid := fmt.Sprintf("process-guid-%d", i)
actualLRP := model_helpers.NewValidActualLRP(processGuid, int32(i))
actualLRPData, err := serializer.Marshal(logger, format.ENCRYPTED_PROTO, actualLRP)
Expect(err).NotTo(HaveOccurred())
_, err = storeClient.Set(etcddb.ActualLRPSchemaPath(processGuid, int32(i)), actualLRPData, 0)
Expect(err).NotTo(HaveOccurred())
encoder := format.NewEncoder(cryptor)
encryptedNetInfo, err := serializer.Marshal(logger, format.ENCRYPTED_PROTO, &actualLRP.ActualLRPNetInfo)
Expect(err).NotTo(HaveOccurred())
netInfoData, err := encoder.Decode(encryptedNetInfo)
Expect(err).NotTo(HaveOccurred())
existingActualLRPs = append(existingActualLRPs, migrations.ETCDToSQLActualLRP{
ProcessGuid: actualLRP.ProcessGuid,
Index: actualLRP.Index,