func (db *ETCDDB) rawActualLRPGroupByProcessGuidAndIndex(logger lager.Logger, processGuid string, index int32) (*models.ActualLRPGroup, error) {
node, err := db.fetchRecursiveRaw(logger, ActualLRPIndexDir(processGuid, index))
if err != nil {
return nil, err
}
group := models.ActualLRPGroup{}
for _, instanceNode := range node.Nodes {
var lrp models.ActualLRP
deserializeErr := db.deserializeModel(logger, instanceNode, &lrp)
if deserializeErr != nil {
logger.Error("failed-parsing-actual-lrp", deserializeErr, lager.Data{"key": instanceNode.Key})
return nil, deserializeErr
}
if isInstanceActualLRPNode(instanceNode) {
group.Instance = &lrp
}
if isEvacuatingActualLRPNode(instanceNode) {
group.Evacuating = &lrp
}
}
if group.Evacuating == nil && group.Instance == nil {
return nil, models.ErrResourceNotFound
}
return &group, nil
}
Expect(response.Error).To(Equal(models.ErrResourceNotFound))
})
It("does not emit a change event to the hub", func() {
Consistently(actualHub.EmitCallCount).Should(Equal(0))
})
})
})
Describe("RetireActualLRP", func() {
var (
request *http.Request
response *models.ActualLRPLifecycleResponse
processGuid = "process-guid"
index = int32(1)
key models.ActualLRPKey
requestBody interface{}
actualLRPGroup *models.ActualLRPGroup
)
BeforeEach(func() {
key = models.NewActualLRPKey(
processGuid,
index,
"domain-0",
)
requestBody = &models.RetireActualLRPRequest{
ActualLrpKey: &key,
netInfo := models.EmptyActualLRPNetInfo()
Expect(netInfo.GetAddress()).To(BeEmpty())
Expect(netInfo.GetPorts()).To(BeEmpty())
})
})
})
})
Describe("ActualLRPGroup", func() {
Describe("Resolve", func() {
var (
instanceLRP *models.ActualLRP
evacuatingLRP *models.ActualLRP
group models.ActualLRPGroup
resolvedLRP *models.ActualLRP
evacuating bool
)
BeforeEach(func() {
lrpKey := models.NewActualLRPKey("process-guid", 1, "domain")
instanceLRP = &models.ActualLRP{
ActualLRPKey: lrpKey,
Since: 1138,
}
evacuatingLRP = &models.ActualLRP{
ActualLRPKey: lrpKey,
Since: 3417,
}
It("returns an error", func() {
response := models.EvacuationResponse{}
err := response.Unmarshal(responseRecorder.Body.Bytes())
Expect(err).NotTo(HaveOccurred())
Expect(response.KeepContainer).To(BeFalse())
Expect(response.Error).To(Equal(models.ErrBadRequest))
})
})
})
Describe("EvacuateRunningActualLRP", func() {
var (
request *http.Request
requestBody *models.EvacuateRunningActualLRPRequest
actualLRPGroup *models.ActualLRPGroup
desiredLRP *models.DesiredLRP
actual *models.ActualLRP
evacuatingActual *models.ActualLRP
afterActual *models.ActualLRP
)
BeforeEach(func() {
request = nil
desiredLRP = model_helpers.NewValidDesiredLRP("the-guid")
fakeDesiredLRPDB.DesiredLRPByProcessGuidReturns(desiredLRP, nil)
actual = model_helpers.NewValidActualLRP("the-guid", 1)
evacuatingActual = model_helpers.NewValidActualLRP("the-guid", 1)
afterActual = model_helpers.NewValidActualLRP("the-guid", 1)
key := actual.ActualLRPKey