func ActualLRPNetInfoFromContainer(container executor.Container) (*models.ActualLRPNetInfo, error) {
ports := []*models.PortMapping{}
for _, portMapping := range container.Ports {
ports = append(ports, models.NewPortMapping(uint32(portMapping.HostPort), uint32(portMapping.ContainerPort)))
}
actualLRPNetInfo := models.NewActualLRPNetInfo(container.ExternalIP, ports...)
err := actualLRPNetInfo.Validate()
if err != nil {
return nil, err
}
return &actualLRPNetInfo, nil
}
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 itValidatesAbsenceOfNetInfo(lrp *models.ActualLRP) {
Context("when net info is set", func() {
BeforeEach(func() {
lrp.ActualLRPNetInfo = models.NewActualLRPNetInfo("1.2.3.4")
})
It("validate returns an error", func() {
err := lrp.Validate()
Expect(err).To(HaveOccurred())
Expect(err.Error()).To(ContainSubstring("net info"))
})
})
Context("when net info is not set", func() {
BeforeEach(func() {
lrp.ActualLRPNetInfo = models.ActualLRPNetInfo{}
})
It("validate does not return an error", func() {
Expect(lrp.Validate()).NotTo(HaveOccurred())
})
})
}
"index": 2,
"state": "RUNNING",
"since": 1138,
"cell_id":"some-cell-id",
"domain":"some-domain",
"crash_count": 1,
"modification_tag": {
"epoch": "some-guid",
"index": 50
}
}`
BeforeEach(func() {
lrpKey = models.NewActualLRPKey("some-guid", 2, "some-domain")
instanceKey = models.NewActualLRPInstanceKey("some-instance-guid", "some-cell-id")
netInfo = models.NewActualLRPNetInfo("1.2.3.4", models.NewPortMapping(5678, 8080), models.NewPortMapping(1234, 8081))
lrp = models.ActualLRP{
ActualLRPKey: lrpKey,
ActualLRPInstanceKey: instanceKey,
ActualLRPNetInfo: netInfo,
CrashCount: 1,
State: models.ActualLRPStateRunning,
Since: 1138,
ModificationTag: models.ModificationTag{
Epoch: "some-guid",
Index: 50,
},
}
})
logger = lager.NewLogger("test")
logger.RegisterSink(lager.NewWriterSink(GinkgoWriter, lager.DEBUG))
responseRecorder = httptest.NewRecorder()
handler = handlers.NewActualLRPHandler(fakeBBS, fakeLegacyBBS, logger)
actualLRP1 = models.NewRunningActualLRP(
models.NewActualLRPKey(
"process-guid-0",
1,
"domain-0",
),
models.NewActualLRPInstanceKey(
"instance-guid-0",
"cell-id-0",
),
models.NewActualLRPNetInfo("1.1.1.1", models.NewPortMapping(80, 5050)),
1138,
)
actualLRP2 = models.NewClaimedActualLRP(
models.NewActualLRPKey(
"process-guid-1",
2,
"domain-1",
),
models.NewActualLRPInstanceKey(
"instance-guid-1",
"cell-id-1",
),
4444,
)
Domain: "domain",
Instances: 1,
RootFs: "some:rootfs",
Action: models.WrapAction(&models.RunAction{Path: "/bin/true", User: "******"}),
}
index int32 = 0
lrpKey = models.NewActualLRPKey(desiredLRP.ProcessGuid, index, desiredLRP.Domain)
alphaInstanceKey = models.NewActualLRPInstanceKey(alphaInstanceGuid, alphaCellID)
betaInstanceKey = models.NewActualLRPInstanceKey(betaInstanceGuid, betaCellID)
omegaInstanceKey = models.NewActualLRPInstanceKey(omegaInstanceGuid, omegaCellID)
emptyInstanceKey = models.ActualLRPInstanceKey{}
alphaPorts = models.NewPortMapping(9872, 2349)
alphaNetInfo = models.NewActualLRPNetInfo(alphaAddress, alphaPorts)
betaPorts = models.NewPortMapping(9868, 2353)
betaNetInfo = models.NewActualLRPNetInfo(betaAddress, betaPorts)
omegaPorts = models.NewPortMapping(9876, 2345)
omegaNetInfo = models.NewActualLRPNetInfo(omegaAddress, omegaPorts)
emptyNetInfo = models.EmptyActualLRPNetInfo()
)
type testable interface {
Test()
}
type evacuationTest struct {
Name string
Subject func() (bool, error)
InstanceLRP lrpSetupFunc
dummyMessage = routing_table.RegistryMessageFor(dummyEndpoint, routing_table.Routes{Hostnames: []string{"baz.com"}, LogGuid: logGuid})
messagesToEmit = routing_table.MessagesToEmit{
RegistrationMessages: []routing_table.RegistryMessage{dummyMessage},
}
schedulingInfoResponse = &models.DesiredLRPSchedulingInfo{
DesiredLRPKey: models.NewDesiredLRPKey(processGuid, "domain", logGuid),
Routes: cfroutes.CFRoutes{{Hostnames: []string{"route-1", "route-2"}, Port: containerPort}}.RoutingInfo(),
}
actualResponses = []*models.ActualLRPGroup{
{
Instance: &models.ActualLRP{
ActualLRPKey: models.NewActualLRPKey(processGuid, 1, "domain"),
ActualLRPInstanceKey: models.NewActualLRPInstanceKey(instanceGuid, "cell-id"),
ActualLRPNetInfo: models.NewActualLRPNetInfo(lrpHost, models.NewPortMapping(1234, containerPort)),
State: models.ActualLRPStateRunning,
},
},
{
Instance: &models.ActualLRP{
ActualLRPKey: models.NewActualLRPKey("", 1, ""),
State: models.ActualLRPStateUnclaimed,
},
},
}
bbsClient.DesiredLRPSchedulingInfosReturns([]*models.DesiredLRPSchedulingInfo{schedulingInfoResponse}, nil)
bbsClient.ActualLRPGroupsReturns(actualResponses, nil)
fakeMetricSender = fake_metrics_sender.NewFakeMetricSender()
Describe("Process", func() {
const sessionPrefix = "test.ordinary-lrp-processor."
var (
desiredLRP *models.DesiredLRP
expectedLrpKey models.ActualLRPKey
expectedInstanceKey models.ActualLRPInstanceKey
expectedNetInfo models.ActualLRPNetInfo
expectedSessionName string
)
BeforeEach(func() {
desiredLRP = model_helpers.NewValidDesiredLRP("process-guid")
expectedLrpKey = models.NewActualLRPKey("process-guid", 2, "domain")
expectedInstanceKey = models.NewActualLRPInstanceKey("instance-guid", "cell-id")
expectedNetInfo = models.NewActualLRPNetInfo("1.2.3.4", models.NewPortMapping(61999, 8080))
})
Context("when given an LRP container", func() {
var container executor.Container
BeforeEach(func() {
container = newLRPContainer(expectedLrpKey, expectedInstanceKey, expectedNetInfo)
})
JustBeforeEach(func() {
processor.Process(logger, container)
})
Context("and the container is INVALID", func() {
BeforeEach(func() {
BeforeEach(func() {
bbsRunner = testrunner.New(bbsBinPath, bbsArgs)
bbsProcess = ginkgomon.Invoke(bbsRunner)
filter = models.ActualLRPFilter{}
expectedActualLRPGroups = []*models.ActualLRPGroup{}
actualActualLRPGroups = []*models.ActualLRPGroup{}
baseLRPKey = models.NewActualLRPKey(baseProcessGuid, baseIndex, baseDomain)
baseLRPInstanceKey = models.NewActualLRPInstanceKey(baseInstanceGuid, cellID)
evacuatingLRPInstanceKey = models.NewActualLRPInstanceKey(evacuatingInstanceGuid, cellID)
otherLRPKey = models.NewActualLRPKey(otherProcessGuid, otherIndex, otherDomain)
otherLRPInstanceKey = models.NewActualLRPInstanceKey(otherInstanceGuid, otherCellID)
netInfo = models.NewActualLRPNetInfo("127.0.0.1", models.NewPortMapping(8080, 80))
unclaimedLRPKey = models.NewActualLRPKey(unclaimedProcessGuid, unclaimedIndex, unclaimedDomain)
crashingLRPKey = models.NewActualLRPKey(crashingProcessGuid, crashingIndex, crashingDomain)
crashingLRPInstanceKey = models.NewActualLRPInstanceKey(crashingInstanceGuid, otherCellID)
baseLRP = &models.ActualLRP{
ActualLRPKey: baseLRPKey,
ActualLRPInstanceKey: baseLRPInstanceKey,
ActualLRPNetInfo: netInfo,
State: models.ActualLRPStateRunning,
Since: time.Now().UnixNano(),
}
evacuatingLRP = &models.ActualLRP{
Describe("ActualLRPProtoToResponse", func() {
var actualLRP *models.ActualLRP
BeforeEach(func() {
actualLRP = &models.ActualLRP{
ActualLRPKey: models.NewActualLRPKey(
"process-guid-0",
3,
"some-domain",
),
ActualLRPInstanceKey: models.NewActualLRPInstanceKey(
"instance-guid-0",
"cell-id-0",
),
ActualLRPNetInfo: models.NewActualLRPNetInfo(
"address-0",
models.NewPortMapping(9876, 2345),
),
State: models.ActualLRPStateRunning,
CrashCount: 42,
Since: 99999999999,
ModificationTag: models.ModificationTag{
Epoch: "some-guid",
Index: 50,
},
}
})
It("serializes all the fields", func() {
expectedResponse := receptor.ActualLRPResponse{
ProcessGuid: "process-guid-0",
InstanceGuid: "instance-guid-0",
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),
ActualLRPNetInfo: netInfo,
State: models.ActualLRPStateRunning,
Since: clock.Now().UnixNano() - 1000,
It("should not be included in the results", func() {
routes := routing_table.RoutesByRoutingKeyFromSchedulingInfos([]*models.DesiredLRPSchedulingInfo{
{DesiredLRPKey: models.NewDesiredLRPKey("abc", "tests", "abc-guid"), Routes: nil},
})
Expect(routes).To(HaveLen(0))
})
})
})
Describe("EndpointsByRoutingKeyFromActuals", func() {
It("should build a map of endpoints, ignoring those without ports", func() {
endpoints := routing_table.EndpointsByRoutingKeyFromActuals([]*routing_table.ActualLRPRoutingInfo{
{
ActualLRP: &models.ActualLRP{
ActualLRPKey: models.NewActualLRPKey("abc", 0, "domain"),
ActualLRPNetInfo: models.NewActualLRPNetInfo("1.1.1.1", models.NewPortMapping(11, 44), models.NewPortMapping(66, 99)),
},
},
{
ActualLRP: &models.ActualLRP{
ActualLRPKey: models.NewActualLRPKey("abc", 1, "domain"),
ActualLRPNetInfo: models.NewActualLRPNetInfo("2.2.2.2", models.NewPortMapping(22, 44), models.NewPortMapping(88, 99)),
},
},
{
ActualLRP: &models.ActualLRP{
ActualLRPKey: models.NewActualLRPKey("def", 0, "domain"),
ActualLRPNetInfo: models.NewActualLRPNetInfo("3.3.3.3", models.NewPortMapping(33, 55)),
},
},
{
diegoSSHRouteMessage := json.RawMessage(diegoSSHRoutePayload)
desiredLRP = &models.DesiredLRP{
ProcessGuid: "some-guid",
Instances: 2,
Routes: &models.Routes{
routes.DIEGO_SSH: &diegoSSHRouteMessage,
},
LogGuid: "log-guid",
}
actualLRPGroup = &models.ActualLRPGroup{
Instance: &models.ActualLRP{
ActualLRPKey: models.NewActualLRPKey("some-guid", 1, "some-domain"),
ActualLRPInstanceKey: models.NewActualLRPInstanceKey("some-instance-guid", "some-cell-id"),
ActualLRPNetInfo: models.NewActualLRPNetInfo("1.2.3.4", models.NewPortMapping(3333, 1111)),
},
}
bbsClient = new(fake_bbs.FakeClient)
bbsClient.ActualLRPGroupByProcessGuidAndIndexReturns(actualLRPGroup, nil)
bbsClient.DesiredLRPByProcessGuidReturns(desiredLRP, nil)
credentials = []byte("some-user:some-password")
permissionsBuilder = authenticators.NewPermissionsBuiler(bbsClient)
remoteAddr, err := net.ResolveIPAddr("ip", "1.1.1.1")
Expect(err).NotTo(HaveOccurred())
metadata = &fake_ssh.FakeConnMetadata{}
metadata.RemoteAddrReturns(remoteAddr)
Context("when a create event occurs", func() {
var (
actualLRPGroup *models.ActualLRPGroup
actualLRP *models.ActualLRP
actualLRPRoutingInfo *routing_table.ActualLRPRoutingInfo
)
Context("when the resulting LRP is in the RUNNING state", func() {
BeforeEach(func() {
actualLRP = &models.ActualLRP{
ActualLRPKey: models.NewActualLRPKey(expectedProcessGuid, 1, "domain"),
ActualLRPInstanceKey: models.NewActualLRPInstanceKey(expectedInstanceGuid, "cell-id"),
ActualLRPNetInfo: models.NewActualLRPNetInfo(
expectedHost,
models.NewPortMapping(expectedExternalPort, expectedContainerPort),
models.NewPortMapping(expectedExternalPort, expectedAdditionalContainerPort),
),
State: models.ActualLRPStateRunning,
}
actualLRPGroup = &models.ActualLRPGroup{
Instance: actualLRP,
}
actualLRPRoutingInfo = &routing_table.ActualLRPRoutingInfo{
ActualLRP: actualLRP,
Evacuating: false,
}
})
listener.Signal(os.Kill)
Eventually(listener.Wait()).Should(Receive())
}
})
Describe("GET /v1/actual_lrps/:guid", func() {
Context("when the bbs is running", func() {
JustBeforeEach(func() {
instanceKey0 := models.NewActualLRPInstanceKey("some-instance-guid-0", "cell-id")
err := bbsClient.ClaimActualLRP("some-process-guid", 0, &instanceKey0)
Expect(err).NotTo(HaveOccurred())
lrpKey1 := models.NewActualLRPKey("some-process-guid", 1, "some-domain")
instanceKey1 := models.NewActualLRPInstanceKey("some-instance-guid-1", "cell-id")
netInfo := models.NewActualLRPNetInfo("1.2.3.4", models.NewPortMapping(65100, 8080))
err = bbsClient.StartActualLRP(&lrpKey1, &instanceKey1, &netInfo)
Expect(err).NotTo(HaveOccurred())
})
It("reports the state of the given process guid's instances", func() {
getLRPs, err := requestGenerator.CreateRequest(
tps.LRPStatus,
rata.Params{"guid": "some-process-guid"},
nil,
)
Expect(err).NotTo(HaveOccurred())
response, err := httpClient.Do(getLRPs)
Expect(err).NotTo(HaveOccurred())
netInfo models.ActualLRPNetInfo
requestBody interface{}
)
BeforeEach(func() {
key = models.NewActualLRPKey(
processGuid,
index,
"domain-0",
)
instanceKey = models.NewActualLRPInstanceKey(
"instance-guid-0",
"cell-id-0",
)
netInfo = models.NewActualLRPNetInfo("1.1.1.1", models.NewPortMapping(10, 20))
requestBody = &models.StartActualLRPRequest{
ActualLrpKey: &key,
ActualLrpInstanceKey: &instanceKey,
ActualLrpNetInfo: &netInfo,
}
actualLRP = models.ActualLRP{
ActualLRPKey: key,
State: models.ActualLRPStateUnclaimed,
Since: 1138,
}
})
JustBeforeEach(func() {
request := newTestRequest(requestBody)
Instances: 1,
Action: &oldmodels.RunAction{
Path: "true",
User: "******",
},
}
legacyKey = oldmodels.NewActualLRPKey(processGuid, 0, domain)
legacyOldInstanceKey = oldmodels.NewActualLRPInstanceKey("instance-guid", "cell-id")
legacyNewInstanceKey = oldmodels.NewActualLRPInstanceKey("other-instance-guid", "other-cell-id")
legacyNetInfo = oldmodels.NewActualLRPNetInfo("1.1.1.1", []oldmodels.PortMapping{})
key = models.NewActualLRPKey(processGuid, 0, domain)
oldInstanceKey = models.NewActualLRPInstanceKey("instance-guid", "cell-id")
newInstanceKey = models.NewActualLRPInstanceKey("other-instance-guid", "other-cell-id")
netInfo = models.NewActualLRPNetInfo("1.1.1.1")
})
It("receives events", func() {
By("creating a ActualLRP")
err := legacyBBS.DesireLRP(logger, oldDesiredLRP)
Expect(err).NotTo(HaveOccurred())
actualLRPGroup, err := bbsClient.ActualLRPGroupByProcessGuidAndIndex(oldDesiredLRP.ProcessGuid, 0)
Expect(err).NotTo(HaveOccurred())
actualLRP := actualLRPGroup.Instance
var event receptor.Event
Eventually(func() receptor.Event {
Eventually(events).Should(Receive(&event))
return event
allowedCiphers = ""
allowedMACs = ""
allowedKeyExchanges = ""
expectedGetActualLRPRequest = &models.ActualLRPGroupByProcessGuidAndIndexRequest{
ProcessGuid: processGuid,
Index: 99,
}
actualLRPGroupResponse = &models.ActualLRPGroupResponse{
Error: nil,
ActualLrpGroup: &models.ActualLRPGroup{
Instance: &models.ActualLRP{
ActualLRPKey: models.NewActualLRPKey(processGuid, 99, "some-domain"),
ActualLRPInstanceKey: models.NewActualLRPInstanceKey("some-instance-guid", "some-cell-id"),
ActualLRPNetInfo: models.NewActualLRPNetInfo("127.0.0.1", models.NewPortMapping(uint32(sshdPort), 9999)),
},
},
}
getDesiredLRPRequest = &models.DesiredLRPByProcessGuidRequest{
ProcessGuid: processGuid,
}
sshRoute, err := json.Marshal(routes.SSHRoute{
ContainerPort: 9999,
PrivateKey: privateKeyPem,
HostFingerprint: hostKeyFingerprint,
})
Expect(err).NotTo(HaveOccurred())
BeforeEach(func() {
receptorProcess = ginkgomon.Invoke(receptorRunner)
for i := 0; i < lrpCount; i++ {
index := strconv.Itoa(i)
lrpKey := models.NewActualLRPKey(
"process-guid-"+index,
int32(i),
fmt.Sprintf("domain-%d", i/2),
)
instanceKey := models.NewActualLRPInstanceKey(
"instance-guid-"+index,
"cell-id",
)
netInfo := models.NewActualLRPNetInfo("the-host", models.NewPortMapping(uint32(1000+i), 80))
_, err := bbsClient.StartActualLRP(&lrpKey, &instanceKey, &netInfo)
Expect(err).NotTo(HaveOccurred())
}
desiredLRP := oldmodels.DesiredLRP{
ProcessGuid: "process-guid-0",
Domain: "domain-0",
Instances: 1,
RootFS: "some:rootfs",
Ports: []uint16{80},
Action: &oldmodels.RunAction{User: "******", Path: "/bin/true"},
}
err := legacyBBS.DesireLRP(logger, desiredLRP)
Expect(err).NotTo(HaveOccurred())
Expect(fakeContainerDelegate.DeleteContainerCallCount()).To(Equal(1))
_, actualContainerGuid := fakeContainerDelegate.DeleteContainerArgsForCall(0)
Expect(actualContainerGuid).To(Equal(container.Guid))
})
})
})
Context("when the container is Running", func() {
var lrpNetInfo models.ActualLRPNetInfo
BeforeEach(func() {
container.State = executor.StateRunning
externalIP := "executor-ip"
container.ExternalIP = externalIP
container.Ports = []executor.PortMapping{{ContainerPort: 1357, HostPort: 8642}}
lrpNetInfo = models.NewActualLRPNetInfo(externalIP, models.NewPortMapping(8642, 1357))
})
It("evacuates the lrp", func() {
Expect(fakeBBS.EvacuateRunningActualLRPCallCount()).To(Equal(1))
actualLRPKey, actualLRPContainerKey, actualLRPNetInfo, actualTTL := fakeBBS.EvacuateRunningActualLRPArgsForCall(0)
Expect(*actualLRPKey).To(Equal(lrpKey))
Expect(*actualLRPContainerKey).To(Equal(lrpInstanceKey))
Expect(*actualLRPNetInfo).To(Equal(lrpNetInfo))
Expect(actualTTL).To(Equal(uint64(evacuationTTL)))
})
Context("when the evacuation returns successfully", func() {
BeforeEach(func() {
fakeBBS.EvacuateRunningActualLRPReturns(true, nil)
})
_, err := etcdClient.Delete(ActualLRPSchemaPath(key.GetProcessGuid(), key.GetIndex()), true)
Expect(err).NotTo(HaveOccurred())
Eventually(deletes).Should(Receive(Equal(actualLRPGroup)))
_, err = etcdClient.Delete(ActualLRPProcessDir(key.GetProcessGuid()), true)
Consistently(logger).ShouldNot(Say("failed-to-unmarshal"))
})
Context("when the evacuating key changes", func() {
It("indicates passes the correct evacuating flag on event callbacks", func() {
key := models.NewActualLRPKey(lrpProcessGuid, lrpIndex, lrpDomain)
instanceKey := models.NewActualLRPInstanceKey("instance-guid", "cell-id")
netInfo := models.NewActualLRPNetInfo("1.1.1.1", nil)
evacuatedLRPGroup := &models.ActualLRPGroup{
Evacuating: &models.ActualLRP{
ActualLRPKey: key,
ActualLRPInstanceKey: instanceKey,
ActualLRPNetInfo: netInfo,
State: models.ActualLRPStateRunning,
Since: clock.Now().UnixNano(),
},
}
etcdHelper.SetRawEvacuatingActualLRP(evacuatedLRPGroup.Evacuating, 0)
Eventually(creates).Should(Receive(Equal(evacuatedLRPGroup)))
updatedGroup := &models.ActualLRPGroup{
}
fakeGarden.RouteToHandler("GET", "/containers/bulk_info",
ghttp.RespondWithJSONEncoded(http.StatusOK,
map[string]garden.ContainerInfoEntry{
containerGuid: garden.ContainerInfoEntry{Info: containerInfo},
},
),
)
fakeGarden.RouteToHandler("GET", fmt.Sprintf("/containers/%s/info", containerGuid), ghttp.RespondWithJSONEncoded(http.StatusOK, containerInfo))
Eventually(fetchCells(logger, serviceClient)).Should(HaveLen(1))
lrpKey := models.NewActualLRPKey(processGuid, 1, "domain")
instanceKey := models.NewActualLRPInstanceKey(instanceGuid, cellID)
netInfo := models.NewActualLRPNetInfo("bogus-ip")
err := bbsClient.StartActualLRP(&lrpKey, &instanceKey, &netInfo)
Expect(err).NotTo(HaveOccurred())
actualLRPGroup, err := bbsClient.ActualLRPGroupByProcessGuidAndIndex(lrpKey.ProcessGuid, int(lrpKey.Index))
Expect(err).NotTo(HaveOccurred())
runningLRP = actualLRPGroup.GetInstance()
})
It("should destroy the container", func() {
Eventually(getActualLRPGroups).Should(HaveLen(1))
err := bbsClient.RetireActualLRP(&runningLRP.ActualLRPKey)
Expect(err).NotTo(HaveOccurred())
findDestroyRequest := func() bool {
MemoryBytes: proto.Uint64(1024),
DiskBytes: proto.Uint64(2048),
},
}, nil)
bbsClient.DesiredLRPByProcessGuidReturns(&models.DesiredLRP{
LogGuid: logGuid,
ProcessGuid: guid,
}, nil)
actualLRP := &models.ActualLRP{
ActualLRPKey: models.NewActualLRPKey(guid, 5, "some-domain"),
ActualLRPInstanceKey: models.NewActualLRPInstanceKey("instanceId", "some-cell"),
ActualLRPNetInfo: models.NewActualLRPNetInfo(
"host",
models.NewPortMapping(5432, 7890),
models.NewPortMapping(1234, uint32(recipebuilder.DefaultPort)),
),
State: models.ActualLRPStateRunning,
Since: fakeClock.Now().UnixNano(),
}
bbsClient.ActualLRPGroupsByProcessGuidReturns([]*models.ActualLRPGroup{{
Instance: actualLRP},
}, nil)
})
Context("when the LRP has been running for a while", func() {
var expectedSinceTime int64
BeforeEach(func() {
