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() {