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
}
func NewActualLRPRoutingInfo(actualLRPGroup *models.ActualLRPGroup) *ActualLRPRoutingInfo {
lrp, evacuating := actualLRPGroup.Resolve()
return &ActualLRPRoutingInfo{
ActualLRP: lrp,
Evacuating: evacuating,
}
}
Expect(netInfo.GetAddress()).To(BeEmpty())
Expect(netInfo.GetPorts()).NotTo(BeNil())
Expect(netInfo.GetPorts()).To(HaveLen(0))
})
})
})
})
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
