func ActualLRPInstanceKeyFromContainer(container executor.Container, cellID string) (*models.ActualLRPInstanceKey, error) {
if container.Tags == nil {
return &models.ActualLRPInstanceKey{}, ErrContainerMissingTags
}
actualLRPInstanceKey := models.NewActualLRPInstanceKey(
container.Tags[InstanceGuidTag],
cellID,
)
err := actualLRPInstanceKey.Validate()
if err != nil {
return &models.ActualLRPInstanceKey{}, err
}
return &actualLRPInstanceKey, nil
}
func (o *ResidualJointLRPOperation) Execute() {
logger := o.logger.Session("executing-residual-joint-lrp-operation", lager.Data{
"lrp-key": o.ActualLRPKey,
"lrp-instance-key": o.ActualLRPInstanceKey,
})
logger.Info("starting")
defer logger.Info("finished")
_, exists := o.containerDelegate.GetContainer(logger, rep.LRPContainerGuid(o.GetProcessGuid(), o.GetInstanceGuid()))
if exists {
logger.Info("skipped-because-container-exists")
return
}
actualLRPKey := models.NewActualLRPKey(o.ProcessGuid, int32(o.Index), o.Domain)
actualLRPInstanceKey := models.NewActualLRPInstanceKey(o.InstanceGuid, o.CellId)
o.bbsClient.RemoveActualLRP(o.ProcessGuid, int(o.Index))
o.bbsClient.RemoveEvacuatingActualLRP(&actualLRPKey, &actualLRPInstanceKey)
}
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())
})
})
}
})
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"},
))
})
})
)
var _ = Describe("Operation", func() {
Describe("ResidualInstanceLRPOperation", func() {
var (
containerDelegate *fake_internal.FakeContainerDelegate
residualLRPOperation *generator.ResidualInstanceLRPOperation
lrpKey models.ActualLRPKey
instanceKey models.ActualLRPInstanceKey
expectedContainerGuid string
)
BeforeEach(func() {
lrpKey = models.NewActualLRPKey("the-process-guid", 0, "the-domain")
instanceKey = models.NewActualLRPInstanceKey("the-instance-guid", "the-cell-id")
containerDelegate = new(fake_internal.FakeContainerDelegate)
residualLRPOperation = generator.NewResidualInstanceLRPOperation(logger, fakeBBS, containerDelegate, lrpKey, instanceKey)
expectedContainerGuid = rep.LRPContainerGuid(lrpKey.GetProcessGuid(), instanceKey.GetInstanceGuid())
})
Describe("Key", func() {
It("returns the InstanceGuid", func() {
Expect(residualLRPOperation.Key()).To(Equal("the-instance-guid"))
})
})
Describe("Execute", func() {
const sessionName = "test.executing-residual-instance-lrp-operation"
guidTaskOnly = "guid-task-only"
processGuid = "process-guid"
)
BeforeEach(func() {
containers := []executor.Container{
{Guid: rep.LRPContainerGuid(processGuid, instanceGuidContainerOnly)},
{Guid: rep.LRPContainerGuid(processGuid, instanceGuidContainerForInstanceLRP)},
{Guid: rep.LRPContainerGuid(processGuid, instanceGuidContainerForEvacuatingLRP)},
{Guid: guidContainerForTask},
}
actualLRPKey := models.ActualLRPKey{ProcessGuid: processGuid}
containerOnlyLRP := models.ActualLRP{ActualLRPKey: actualLRPKey, ActualLRPInstanceKey: models.NewActualLRPInstanceKey(instanceGuidContainerForInstanceLRP, cellID)}
instanceOnlyLRP := models.ActualLRP{ActualLRPKey: actualLRPKey, ActualLRPInstanceKey: models.NewActualLRPInstanceKey(instanceGuidInstanceLRPOnly, cellID)}
containerForEvacuatingLRP := models.ActualLRP{ActualLRPKey: actualLRPKey, ActualLRPInstanceKey: models.NewActualLRPInstanceKey(instanceGuidContainerForEvacuatingLRP, cellID)}
evacuatingOnlyLRP := models.ActualLRP{ActualLRPKey: actualLRPKey, ActualLRPInstanceKey: models.NewActualLRPInstanceKey(instanceGuidEvacuatingLRPOnly, cellID)}
instanceAndEvacuatingLRP := models.ActualLRP{ActualLRPKey: actualLRPKey, ActualLRPInstanceKey: models.NewActualLRPInstanceKey(instanceGuidInstanceAndEvacuatingLRPsOnly, cellID)}
lrpGroups := []*models.ActualLRPGroup{
{Instance: &containerOnlyLRP, Evacuating: nil},
{Instance: &instanceOnlyLRP, Evacuating: nil},
{Instance: &instanceAndEvacuatingLRP, Evacuating: &instanceAndEvacuatingLRP},
{Instance: nil, Evacuating: &containerForEvacuatingLRP},
{Instance: nil, Evacuating: &evacuatingOnlyLRP},
}
var (
evacuatingLRPKey models.ActualLRPKey
)
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"},
}
desiredLRPRemovedEvent, ok := event.(*models.DesiredLRPRemovedEvent)
Expect(ok).To(BeTrue())
Expect(desiredLRPRemovedEvent.DesiredLrp).To(Equal(desiredLRP))
})
})
})
Describe("Actual LRP changes", func() {
var actualLRPGroup *models.ActualLRPGroup
BeforeEach(func() {
actualLRPGroup = &models.ActualLRPGroup{
Instance: &models.ActualLRP{
ActualLRPKey: models.NewActualLRPKey(expectedProcessGuid, 1, "domain"),
ActualLRPInstanceKey: models.NewActualLRPInstanceKey(expectedInstanceGuid, "cell-id"),
},
}
})
Context("when a create arrives", func() {
BeforeEach(func() {
actualCreateCB(actualLRPGroup)
})
It("emits an ActualLRPCreatedEvent to the hub", func() {
Expect(hub.EmitCallCount()).To(Equal(1))
event := hub.EmitArgsForCall(0)
Expect(event).To(BeAssignableToTypeOf(&models.ActualLRPCreatedEvent{}))
actualLRPCreatedEvent := event.(*models.ActualLRPCreatedEvent)
filter models.ActualLRPFilter
getErr error
)
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,
processGuid = "process-guid"
index = int32(1)
key models.ActualLRPKey
instanceKey models.ActualLRPInstanceKey
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,
}
})
JustBeforeEach(func() {
request := newTestRequest(requestBody)
handler.RemoveEvacuatingActualLRP(responseRecorder, request)
})
Context("when removeEvacuatinging the actual lrp in the DB succeeds", func() {
BeforeEach(func() {
fakeEvacuationDB.RemoveEvacuatingActualLRPReturns(nil)
})
syncEvents.Sync <- struct{}{}
Eventually(emitter.EmitCallCount).ShouldNot(Equal(0))
})
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,
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),
err := bbsClient.DesireLRP(desiredLRP)
Expect(err).NotTo(HaveOccurred())
})
AfterEach(func() {
if listener != nil {
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"},
err := etcdDB.RemoveDesiredLRP(logger, lrp.ProcessGuid)
Expect(err).NotTo(HaveOccurred())
_, err = etcdDB.DesiredLRPByProcessGuid(logger, lrp.ProcessGuid)
Expect(err).To(HaveOccurred())
Expect(err).To(Equal(models.ErrResourceNotFound))
})
Context("when there are running instances on a present cell", func() {
cellPresence := models.NewCellPresence("the-cell-id", "cell.example.com", "az1", models.NewCellCapacity(128, 1024, 6), []string{}, []string{})
BeforeEach(func() {
consulHelper.RegisterCell(&cellPresence)
for i := int32(0); i < lrp.Instances; i++ {
instanceKey := models.NewActualLRPInstanceKey(fmt.Sprintf("some-instance-guid-%d", i), cellPresence.CellID)
err := etcdDB.ClaimActualLRP(logger, lrp.ProcessGuid, i, &instanceKey)
Expect(err).NotTo(HaveOccurred())
}
})
It("stops all actual lrps for the desired lrp", func() {
originalStopCallCount := fakeRepClient.StopLRPInstanceCallCount()
err := etcdDB.RemoveDesiredLRP(logger, lrp.ProcessGuid)
Expect(err).NotTo(HaveOccurred())
callCount := originalStopCallCount + int(lrp.Instances)
Expect(fakeRepClientFactory.CreateClientCallCount()).To(Equal(callCount))
Expect(fakeRepClientFactory.CreateClientArgsForCall(0)).To(Equal(cellPresence.RepAddress))
ProcessGuid: "process-guid",
RootFs: "some:rootfs",
Domain: "some-domain",
Instances: 1,
Action: models.WrapAction(&models.RunAction{
User: "******",
Path: "the-path",
Args: []string{},
}),
}
index := 0
err := bbsClient.DesireLRP(desiredLRP)
Expect(err).NotTo(HaveOccurred())
instanceKey := models.NewActualLRPInstanceKey("some-instance-guid", cellID)
err = bbsClient.ClaimActualLRP(desiredLRP.ProcessGuid, index, &instanceKey)
Expect(err).NotTo(HaveOccurred())
})
It("eventually reaps actual LRPs with no corresponding container", func() {
Eventually(getActualLRPGroups, 5*pollingInterval).Should(BeEmpty())
})
})
Describe("Evacuation", func() {
JustBeforeEach(func() {
resp, err := http.Post(fmt.Sprintf("http://127.0.0.1:%d/evacuate", serverPort), "text/html", nil)
Expect(err).NotTo(HaveOccurred())
resp.Body.Close()
Expect(resp.StatusCode).To(Equal(http.StatusAccepted))
logger.RegisterSink(lager.NewWriterSink(GinkgoWriter, lager.DEBUG))
responseRecorder = httptest.NewRecorder()
handler = handlers.NewActualLRPLifecycleHandler(logger, fakeActualLRPDB)
})
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,
Domain: domain,
RootFS: "some:rootfs",
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 {
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())
dummyEndpoint = routing_table.Endpoint{InstanceGuid: "instance-guid-2", Host: "2.2.2.2", Port: 22, ContainerPort: 2222}
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)
})
Describe("ActualLRPGroups", func() {
var request *http.Request
BeforeEach(func() {
request = newTestRequest("")
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",
),
omegaAddress = "omega-address"
)
var (
desiredLRP = models.DesiredLRP{
ProcessGuid: processGuid,
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()
instanceGuid = "instance-guid"
index = 0
container = executor.Container{
Guid: rep.LRPContainerGuid(desiredLRP.ProcessGuid, instanceGuid),
Tags: executor.Tags{
rep.LifecycleTag: rep.LRPLifecycle,
rep.DomainTag: desiredLRP.Domain,
rep.ProcessGuidTag: desiredLRP.ProcessGuid,
rep.InstanceGuidTag: instanceGuid,
rep.ProcessIndexTag: strconv.Itoa(index),
},
}
lrpKey = models.NewActualLRPKey(processGuid, int32(index), desiredLRP.Domain)
lrpInstanceKey = models.NewActualLRPInstanceKey(instanceGuid, localCellID)
})
JustBeforeEach(func() {
lrpProcessor.Process(logger, container)
})
Context("when the container is Reserved", func() {
BeforeEach(func() {
container.State = executor.StateReserved
})
It("evacuates the lrp", func() {
Expect(fakeBBS.EvacuateClaimedActualLRPCallCount()).To(Equal(1))
actualLRPKey, actualLRPContainerKey := fakeBBS.EvacuateClaimedActualLRPArgsForCall(0)
Expect(*actualLRPKey).To(Equal(lrpKey))
Eventually(errors).Should(BeClosed())
})
It("sends an event down the pipe for create", func() {
etcdHelper.SetRawActualLRP(actualLRPGroup.Instance)
Eventually(creates).Should(Receive(Equal(actualLRPGroup)))
})
It("sends an event down the pipe for updates", func() {
etcdHelper.SetRawActualLRP(actualLRPGroup.Instance)
Eventually(creates).Should(Receive())
updatedGroup := &models.ActualLRPGroup{
Instance: &models.ActualLRP{
ActualLRPKey: models.NewActualLRPKey(lrpProcessGuid, lrpIndex, lrpDomain),
ActualLRPInstanceKey: models.NewActualLRPInstanceKey("instance-guid", lrpCellId),
State: models.ActualLRPStateClaimed,
Since: clock.Now().UnixNano(),
},
}
etcdHelper.SetRawActualLRP(updatedGroup.Instance)
var actualLRPChange *models.ActualLRPChange
Eventually(changes).Should(Receive(&actualLRPChange))
before, after := actualLRPChange.Before, actualLRPChange.After
Expect(before).To(Equal(actualLRPGroup))
Expect(after).To(Equal(updatedGroup))
})
It("sends an event down the pipe for delete", func() {
ProcessGuid: "process-guid",
RootFs: "some:rootfs",
Domain: "some-domain",
Instances: 1,
Action: models.WrapAction(&models.RunAction{
User: "******",
Path: "the-path",
Args: []string{},
}),
}
index := 0
err := bbsClient.DesireLRP(desiredLRP)
Expect(err).NotTo(HaveOccurred())
instanceKey := models.NewActualLRPInstanceKey("some-instance-guid", cellID)
err = bbsClient.ClaimActualLRP(desiredLRP.ProcessGuid, index, &instanceKey)
Expect(err).NotTo(HaveOccurred())
})
It("eventually reaps actual LRPs with no corresponding container", func() {
Eventually(getActualLRPGroups, 5*pollingInterval).Should(BeEmpty())
})
})
Describe("when a StopLRPInstance request comes in", func() {
const processGuid = "process-guid"
const instanceGuid = "some-instance-guid"
var runningLRP *models.ActualLRP
var containerGuid = rep.LRPContainerGuid(processGuid, instanceGuid)
var expectedDestroyRoute = "/containers/" + containerGuid
ApplicationId: proto.String("appId"),
InstanceIndex: proto.Int32(5),
CpuPercentage: proto.Float64(4),
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() {