func NewValidActualLRP(guid string, index int32) *models.ActualLRP {
actualLRP := &models.ActualLRP{
ActualLRPKey: models.NewActualLRPKey(guid, index, "some-domain"),
ActualLRPInstanceKey: models.NewActualLRPInstanceKey("some-guid", "some-cell"),
ActualLRPNetInfo: models.NewActualLRPNetInfo("some-address", models.NewPortMapping(2222, 4444)),
CrashCount: 33,
CrashReason: "badness",
State: models.ActualLRPStateRunning,
Since: 1138,
ModificationTag: models.ModificationTag{
Epoch: "some-epoch",
Index: 999,
},
}
err := actualLRP.Validate()
Expect(err).NotTo(HaveOccurred())
return actualLRP
}
func lrpForState(state string, timeInState time.Duration) models.ActualLRP {
var actualLRPKey = models.NewActualLRPKey("some-process-guid", 1, "tests")
var instanceKey = models.NewActualLRPInstanceKey("some-instance-guid", "some-cell")
lrp := models.ActualLRP{
ActualLRPKey: actualLRPKey,
State: state,
Since: clock.Now().Add(-timeInState).UnixNano(),
}
switch state {
case models.ActualLRPStateUnclaimed:
case models.ActualLRPStateCrashed:
lrp.CrashReason = "crashed"
case models.ActualLRPStateClaimed:
lrp.ActualLRPInstanceKey = instanceKey
case models.ActualLRPStateRunning:
lrp.ActualLRPInstanceKey = instanceKey
lrp.ActualLRPNetInfo = models.NewActualLRPNetInfo("1.2.3.4", &models.PortMapping{ContainerPort: 1234, HostPort: 5678})
}
return lrp
}
func itValidatesAbsenceOfTheInstanceKey(lrp *models.ActualLRP) {
Context("when the instance key is set", func() {
BeforeEach(func() {
lrp.ActualLRPInstanceKey = models.NewActualLRPInstanceKey("some-instance", "some-cell")
})
It("validate returns an error", func() {
err := lrp.Validate()
Expect(err).To(HaveOccurred())
Expect(err.Error()).To(ContainSubstring("instance key"))
})
})
Context("when the instance key is not set", func() {
BeforeEach(func() {
lrp.ActualLRPInstanceKey = models.ActualLRPInstanceKey{}
})
It("validate does not return an error", func() {
Expect(lrp.Validate()).NotTo(HaveOccurred())
})
})
}
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"
instanceKey := models.NewActualLRPInstanceKey("instance-guid", cellID)
retiringActualLRP1.CellId = cellID
retiringActualLRP1.ActualLRPInstanceKey = instanceKey
retiringActualLRP1.State = models.ActualLRPStateClaimed
group1 := &models.ActualLRPGroup{Instance: retiringActualLRP1}
retiringActualLRP2.CellId = cellID
retiringActualLRP2.ActualLRPInstanceKey = instanceKey
retiringActualLRP2.State = models.ActualLRPStateClaimed
group2 := &models.ActualLRPGroup{Instance: retiringActualLRP2}
fakeLRPDB.ActualLRPGroupByProcessGuidAndIndexStub = func(_ lager.Logger, processGuid string, _ int32) (*models.ActualLRPGroup, error) {
if processGuid == retiringActualLRP1.ProcessGuid {
return group1, nil
}
exitCh = make(chan struct{}, 1)
retirer := controllers.NewActualLRPRetirer(fakeActualLRPDB, actualHub, fakeRepClientFactory, fakeServiceClient)
handler = handlers.NewActualLRPLifecycleHandler(fakeActualLRPDB, fakeDesiredLRPDB, actualHub, fakeAuctioneerClient, retirer, exitCh)
})
Describe("ClaimActualLRP", func() {
var (
processGuid = "process-guid"
index int32 = 1
instanceKey models.ActualLRPInstanceKey
requestBody interface{}
)
BeforeEach(func() {
instanceKey = models.NewActualLRPInstanceKey(
"instance-guid-0",
"cell-id-0",
)
requestBody = &instanceKey
requestBody = &models.ClaimActualLRPRequest{
ProcessGuid: processGuid,
Index: index,
ActualLrpInstanceKey: &instanceKey,
}
actualLRP = models.ActualLRP{
ActualLRPKey: models.NewActualLRPKey(
processGuid,
1,
"domain-0",
),
State: models.ActualLRPStateUnclaimed,
Since: 1138,
var (
baseLRP *models.ActualLRP
otherIndexLRP *models.ActualLRP
evacuatingLRP *models.ActualLRP
otherDomainLRP *models.ActualLRP
otherCellIdLRP *models.ActualLRP
baseLRPKey models.ActualLRPKey
baseLRPInstanceKey models.ActualLRPInstanceKey
otherLRPInstanceKey models.ActualLRPInstanceKey
netInfo models.ActualLRPNetInfo
)
BeforeEach(func() {
baseLRPKey = models.NewActualLRPKey(baseProcessGuid, baseIndex, baseDomain)
baseLRPInstanceKey = models.NewActualLRPInstanceKey(baseInstanceGuid, cellID)
otherLRPInstanceKey = models.NewActualLRPInstanceKey(otherInstanceGuid, otherCellID)
netInfo = models.NewActualLRPNetInfo("127.0.0.1", models.NewPortMapping(8080, 80))
baseLRP = &models.ActualLRP{
ActualLRPKey: baseLRPKey,
ActualLRPInstanceKey: baseLRPInstanceKey,
ActualLRPNetInfo: netInfo,
State: models.ActualLRPStateRunning,
Since: clock.Now().UnixNano(),
}
evacuatingLRP = &models.ActualLRP{
ActualLRPKey: baseLRPKey,
ActualLRPInstanceKey: models.NewActualLRPInstanceKey(evacuatingInstanceGuid, cellID),
handler = handlers.NewActualLRPHandler(fakeActualLRPDB, exitCh)
})
Describe("ActualLRPGroups", func() {
var requestBody interface{}
BeforeEach(func() {
requestBody = &models.ActualLRPGroupsRequest{}
actualLRP1 = models.ActualLRP{
ActualLRPKey: models.NewActualLRPKey(
"process-guid-0",
1,
"domain-0",
),
ActualLRPInstanceKey: models.NewActualLRPInstanceKey(
"instance-guid-0",
"cell-id-0",
),
State: models.ActualLRPStateRunning,
Since: 1138,
}
actualLRP2 = models.ActualLRP{
ActualLRPKey: models.NewActualLRPKey(
"process-guid-1",
2,
"domain-1",
),
ActualLRPInstanceKey: models.NewActualLRPInstanceKey(
"instance-guid-1",
"cell-id-1",
),
})
It("returns a validation error", func() {
Expect(actualLRPKey.Validate()).To(ConsistOf(models.ErrInvalidField{"index"}))
})
})
})
})
Describe("ActualLRPInstanceKey", func() {
Describe("Validate", func() {
var actualLRPInstanceKey models.ActualLRPInstanceKey
Context("when both instance guid and cell id are specified", func() {
It("returns nil", func() {
actualLRPInstanceKey = models.NewActualLRPInstanceKey("instance-guid", "cell-id")
Expect(actualLRPInstanceKey.Validate()).To(BeNil())
})
})
Context("when both instance guid and cell id are empty", func() {
It("returns a validation error", func() {
actualLRPInstanceKey = models.NewActualLRPInstanceKey("", "")
Expect(actualLRPInstanceKey.Validate()).To(ConsistOf(
models.ErrInvalidField{"cell_id"},
models.ErrInvalidField{"instance_guid"},
))
})
})
index = int32(1)
key models.ActualLRPKey
instanceKey models.ActualLRPInstanceKey
actual *models.ActualLRP
requestBody interface{}
)
BeforeEach(func() {
key = models.NewActualLRPKey(
processGuid,
index,
"domain-0",
)
instanceKey = models.NewActualLRPInstanceKey("instance-guid", "cell-id")
requestBody = &models.RemoveEvacuatingActualLRPRequest{
ActualLrpKey: &key,
ActualLrpInstanceKey: &instanceKey,
}
fakeActualLRPDB.ActualLRPGroupByProcessGuidAndIndexReturns(&models.ActualLRPGroup{Evacuating: actual}, nil)
})
JustBeforeEach(func() {
request := newTestRequest(requestBody)
handler.RemoveEvacuatingActualLRP(logger, responseRecorder, request)
})
Context("when removeEvacuatinging the actual lrp in the DB succeeds", func() {
BeforeEach(func() {
fakeEvacuationDB.RemoveEvacuatingActualLRPReturns(nil)
desiredLRPRemovedEvent, ok := event.(*models.DesiredLRPRemovedEvent)
Expect(ok).To(BeTrue())
Expect(desiredLRPRemovedEvent.DesiredLrp.ProcessGuid).To(Equal(desiredLRP.ProcessGuid))
})
})
Describe("Actual LRPs", func() {
const (
processGuid = "some-process-guid"
domain = "some-domain"
noExpirationTTL = 0
)
BeforeEach(func() {
key = models.NewActualLRPKey(processGuid, 0, domain)
instanceKey = models.NewActualLRPInstanceKey("instance-guid", "cell-id")
newInstanceKey = models.NewActualLRPInstanceKey("other-instance-guid", "other-cell-id")
netInfo = models.NewActualLRPNetInfo("1.1.1.1")
desiredLRP = &models.DesiredLRP{
ProcessGuid: processGuid,
Domain: domain,
RootFs: "some:rootfs",
Instances: 1,
Action: models.WrapAction(&models.RunAction{
Path: "true",
User: "******",
}),
}
})