func (db *ETCDDB) createActualLRP(logger lager.Logger, desiredLRP *models.DesiredLRP, index int32) error {
logger = logger.Session("create-actual-lrp")
var err error
if index >= desiredLRP.Instances {
err = models.NewError(models.Error_InvalidRecord, "Index too large")
logger.Error("actual-lrp-index-too-large", err, lager.Data{"actual_index": index, "desired_instances": desiredLRP.Instances})
return err
}
guid, err := uuid.NewV4()
if err != nil {
return err
}
actualLRP := &models.ActualLRP{
ActualLRPKey: models.NewActualLRPKey(
desiredLRP.ProcessGuid,
index,
desiredLRP.Domain,
),
State: models.ActualLRPStateUnclaimed,
Since: db.clock.Now().UnixNano(),
ModificationTag: models.ModificationTag{
Epoch: guid.String(),
Index: 0,
},
}
err = db.createRawActualLRP(logger, actualLRP)
if err != nil {
return err
}
return nil
}
func defaultCrashedActual(crashCount int32, lastCrashed int64) *models.ActualLRP {
return &models.ActualLRP{
ActualLRPKey: models.NewActualLRPKey("p-guid", 0, "domain"),
State: models.ActualLRPStateCrashed,
CrashCount: crashCount,
Since: lastCrashed,
}
}
func BuildLRPAuctions(start auctioneer.LRPStartRequest, queueTime time.Time) []auctiontypes.LRPAuction {
auctions := make([]auctiontypes.LRPAuction, 0, len(start.Indices))
for _, index := range start.Indices {
lrpKey := models.NewActualLRPKey(start.ProcessGuid, int32(index), start.Domain)
auctions = append(auctions, auctiontypes.NewLRPAuction(rep.NewLRP(lrpKey, start.Resource), queueTime))
}
return auctions
}
func (a *AuctionRunner) ScheduleLRPsForAuctions(lrpStarts []auctioneer.LRPStartRequest) {
a.lock.Lock()
defer a.lock.Unlock()
now := a.clock.Now()
for _, start := range lrpStarts {
log.Infof("+lrp auction posted: %v: %v\n", start.ProcessGuid, start.Indices)
for _, i := range start.Indices {
lrpKey := models.NewActualLRPKey(start.ProcessGuid, int32(i), start.Domain)
auction := auctiontypes.NewLRPAuction(rep.NewLRP(lrpKey, start.Resource), now)
a.lrpAuctions = append(a.lrpAuctions, auction)
}
}
a.claimToHaveWork()
}
func (b *Batch) AddLRPStarts(starts []auctioneer.LRPStartRequest) {
auctions := make([]auctiontypes.LRPAuction, 0, len(starts))
now := b.clock.Now()
for i := range starts {
start := &starts[i]
for _, index := range start.Indices {
lrpKey := models.NewActualLRPKey(start.ProcessGuid, int32(index), start.Domain)
auction := auctiontypes.NewLRPAuction(rep.NewLRP(lrpKey, start.Resource), now)
auctions = append(auctions, auction)
}
}
b.lock.Lock()
b.lrpAuctions = append(b.lrpAuctions, auctions...)
b.claimToHaveWork()
b.lock.Unlock()
}
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 (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 (db *ETCDDB) startInstanceRange(logger lager.Logger, lower, upper int32, schedulingInfo *models.DesiredLRPSchedulingInfo) {
logger = logger.Session("start-instance-range", lager.Data{"lower": lower, "upper": upper})
logger.Info("starting")
defer logger.Info("complete")
keys := make([]*models.ActualLRPKey, upper-lower)
i := 0
for actualIndex := lower; actualIndex < upper; actualIndex++ {
key := models.NewActualLRPKey(schedulingInfo.ProcessGuid, int32(actualIndex), schedulingInfo.Domain)
keys[i] = &key
i++
}
createdIndices := db.createUnclaimedActualLRPs(logger, keys)
start := auctioneer.NewLRPStartRequestFromSchedulingInfo(schedulingInfo, createdIndices...)
err := db.auctioneerClient.RequestLRPAuctions([]*auctioneer.LRPStartRequest{&start})
if err != nil {
logger.Error("failed-to-request-auction", err)
}
}
func itValidatesPresenceOfTheLRPKey(lrp *models.ActualLRP) {
Context("when the lrp key is set", func() {
BeforeEach(func() {
lrp.ActualLRPKey = models.NewActualLRPKey("some-guid", 1, "domain")
})
It("validate does not return an error", func() {
Expect(lrp.Validate()).NotTo(HaveOccurred())
})
})
Context("when the lrp key is not set", func() {
BeforeEach(func() {
lrp.ActualLRPKey = models.ActualLRPKey{}
})
It("validate returns an error", func() {
err := lrp.Validate()
Expect(err).To(HaveOccurred())
Expect(err.Error()).To(ContainSubstring("process_guid"))
})
})
}
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 ActualLRPKeyFromTags(tags executor.Tags) (*models.ActualLRPKey, error) {
if tags == nil {
return &models.ActualLRPKey{}, ErrContainerMissingTags
}
processIndex, err := strconv.Atoi(tags[ProcessIndexTag])
if err != nil {
return &models.ActualLRPKey{}, ErrInvalidProcessIndex
}
actualLRPKey := models.NewActualLRPKey(
tags[ProcessGuidTag],
int32(processIndex),
tags[DomainTag],
)
err = actualLRPKey.Validate()
if err != nil {
return &models.ActualLRPKey{}, err
}
return &actualLRPKey, nil
}
logger = lager.NewLogger("test")
logger.RegisterSink(lager.NewWriterSink(GinkgoWriter, lager.DEBUG))
responseRecorder = httptest.NewRecorder()
handler = handlers.NewActualLRPHandler(logger, fakeActualLRPDB)
})
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",
Describe("RemoveEvacuatingActualLRP", func() {
var (
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() {
uaaUsername = "******"
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,
})
var client rep.Client
BeforeEach(func() {
fakeServer = ghttp.NewServer()
client = rep.NewClient(cf_http.NewClient(), fakeServer.URL())
})
AfterEach(func() {
fakeServer.Close()
})
Describe("StopLRPInstance", func() {
const cellAddr = "cell.example.com"
var stopErr error
var actualLRP = models.ActualLRP{
ActualLRPKey: models.NewActualLRPKey("some-process-guid", 2, "test-domain"),
ActualLRPInstanceKey: models.NewActualLRPInstanceKey("some-instance-guid", "some-cell-id"),
}
JustBeforeEach(func() {
stopErr = client.StopLRPInstance(actualLRP.ActualLRPKey, actualLRP.ActualLRPInstanceKey)
})
Context("when the request is successful", func() {
BeforeEach(func() {
fakeServer.AppendHandlers(
ghttp.CombineHandlers(
ghttp.VerifyRequest("POST", "/v1/lrps/some-process-guid/instances/some-instance-guid/stop"),
ghttp.RespondWith(http.StatusAccepted, ""),
),
)
Expect(err).NotTo(HaveOccurred())
desiredLRPRemovedEvent, ok := event.(receptor.DesiredLRPRemovedEvent)
Expect(ok).To(BeTrue())
Expect(desiredLRPRemovedEvent).To(Equal(expectedEvent))
})
})
})
Describe("Actual LRP Events", func() {
var actualLRPResponse receptor.ActualLRPResponse
BeforeEach(func() {
actualLRPResponse = serialization.ActualLRPProtoToResponse(
&models.ActualLRP{
ActualLRPKey: models.NewActualLRPKey("some-guid", 0, "some-domain"),
State: models.ActualLRPStateUnclaimed,
Since: 1,
},
false,
)
})
Context("when receiving a ActualLRPCreatedEvent", func() {
var expectedEvent receptor.ActualLRPCreatedEvent
BeforeEach(func() {
expectedEvent = receptor.NewActualLRPCreatedEvent(actualLRPResponse)
payload, err := json.Marshal(expectedEvent)
Expect(err).NotTo(HaveOccurred())
event, err := eventSource.Next()
Expect(err).NotTo(HaveOccurred())
desiredLRPRemovedEvent, ok := event.(*models.DesiredLRPRemovedEvent)
Expect(ok).To(BeTrue())
Expect(desiredLRPRemovedEvent).To(Equal(expectedEvent))
})
})
})
Describe("Actual LRP Events", func() {
var actualLRPGroup *models.ActualLRPGroup
var actualLRP *models.ActualLRP
BeforeEach(func() {
actualLRP = models.NewUnclaimedActualLRP(models.NewActualLRPKey("some-guid", 0, "some-domain"), 1)
actualLRPGroup = models.NewRunningActualLRPGroup(actualLRP)
})
Context("when receiving a ActualLRPCreatedEvent", func() {
var expectedEvent *models.ActualLRPCreatedEvent
BeforeEach(func() {
expectedEvent = models.NewActualLRPCreatedEvent(actualLRPGroup)
payload, err := proto.Marshal(expectedEvent)
Expect(err).NotTo(HaveOccurred())
payload = []byte(base64.StdEncoding.EncodeToString(payload))
fakeRawEventSource.NextReturns(
sse.Event{
ID: "sup",
func BuildLRP(guid, domain string, index int, rootFS string, memoryMB, diskMB int32) *rep.LRP {
lrpKey := models.NewActualLRPKey(guid, int32(index), domain)
lrp := rep.NewLRP(lrpKey, rep.NewResource(memoryMB, diskMB, rootFS))
return &lrp
}
func CalculateConvergence(
logger lager.Logger,
clock clock.Clock,
restartCalculator models.RestartCalculator,
input *models.ConvergenceInput,
) *models.ConvergenceChanges {
sess := logger.Session("calculate-convergence")
var extraLRPCount, missingLRPCount int
sess.Info("start")
defer sess.Info("done")
changes := &models.ConvergenceChanges{}
now := clock.Now()
for processGuid, _ := range input.AllProcessGuids {
pLog := sess.WithData(lager.Data{
"process_guid": processGuid,
})
desired, hasDesired := input.DesiredLRPs[processGuid]
actualsByIndex := input.ActualLRPs[processGuid]
if hasDesired {
for i := int32(0); i < desired.Instances; i++ {
if _, hasIndex := actualsByIndex[i]; !hasIndex {
pLog.Info("missing", lager.Data{"index": i})
missingLRPCount++
lrpKey := models.NewActualLRPKey(desired.ProcessGuid, i, desired.Domain)
changes.ActualLRPKeysForMissingIndices = append(
changes.ActualLRPKeysForMissingIndices,
&lrpKey,
)
}
}
for i, actual := range actualsByIndex {
if actual.CellIsMissing(input.Cells) {
pLog.Info("missing-cell", lager.Data{"index": i, "cell_id": actual.CellId})
changes.ActualLRPsWithMissingCells = append(changes.ActualLRPsWithMissingCells, actual)
continue
}
if actual.Index >= desired.Instances && input.Domains.Contains(desired.Domain) {
pLog.Info("extra", lager.Data{"index": i})
extraLRPCount++
changes.ActualLRPsForExtraIndices = append(changes.ActualLRPsForExtraIndices, actual)
continue
}
if actual.ShouldRestartCrash(now, restartCalculator) {
pLog.Info("restart-crash", lager.Data{"index": i})
changes.RestartableCrashedActualLRPs = append(changes.RestartableCrashedActualLRPs, actual)
continue
}
if actual.ShouldStartUnclaimed(now) {
pLog.Info("stale-unclaimed", lager.Data{"index": i})
changes.StaleUnclaimedActualLRPs = append(changes.StaleUnclaimedActualLRPs, actual)
continue
}
}
} else {
for i, actual := range actualsByIndex {
if !input.Domains.Contains(actual.Domain) {
pLog.Info("skipping-unfresh-domain")
continue
}
pLog.Info("no-longer-desired", lager.Data{"index": i})
extraLRPCount++
changes.ActualLRPsForExtraIndices = append(changes.ActualLRPsForExtraIndices, actual)
}
}
}
missingLRPs.Send(missingLRPCount)
extraLRPs.Send(extraLRPCount)
return changes
}
. "github.com/onsi/gomega/gbytes"
)
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"
var _ = Describe("LRP Stopper", func() {
var (
cellID string
stopper lrp_stopper.LRPStopper
client *fake_client.FakeClient
logger lager.Logger
actualLRP *models.ActualLRP
)
BeforeEach(func() {
cellID = "the-cell-id"
actualLRP = &models.ActualLRP{
ActualLRPKey: models.NewActualLRPKey(
"some-process-guid",
1138,
"some-domain",
),
ActualLRPInstanceKey: models.NewActualLRPInstanceKey(
"some-instance-guid",
"some-cell-id",
),
}
client = new(fake_client.FakeClient)
logger = lagertest.NewTestLogger("test")
stopper = lrp_stopper.New(cellID, client, logger)
})
Describe("StopInstance", func() {
ProcessGuid: processGuid,
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
func BuildLRPAuctionWithPlacementError(processGuid, domain string, index int, rootFS string, memoryMB, diskMB int32, queueTime time.Time, placementError string) auctiontypes.LRPAuction {
lrpKey := models.NewActualLRPKey(processGuid, int32(index), domain)
a := auctiontypes.NewLRPAuction(rep.NewLRP(lrpKey, rep.NewResource(memoryMB, diskMB, rootFS)), queueTime)
a.PlacementError = placementError
return a
}
func BuildLRPAuction(processGuid, domain string, index int, rootFS string, memoryMB, diskMB int32, queueTime time.Time) auctiontypes.LRPAuction {
lrpKey := models.NewActualLRPKey(processGuid, int32(index), domain)
return auctiontypes.NewLRPAuction(rep.NewLRP(lrpKey, rep.NewResource(memoryMB, diskMB, rootFS)), queueTime)
}
unclaimedLRPKey models.ActualLRPKey
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,
var metricSender *fake.FakeMetricSender
BeforeEach(func() {
metricSender = fake.NewFakeMetricSender()
metrics.Initialize(metricSender, nil)
delegate = auctionmetricemitterdelegate.New()
})
Describe("AuctionCompleted", func() {
It("should adjust the metric counters", func() {
resource := rep.NewResource(10, 10, "linux")
delegate.AuctionCompleted(auctiontypes.AuctionResults{
SuccessfulLRPs: []auctiontypes.LRPAuction{
{
LRP: rep.NewLRP(models.NewActualLRPKey("successful-start", 0, "domain"), resource),
},
},
SuccessfulTasks: []auctiontypes.TaskAuction{
{
Task: rep.NewTask("successful-task", "domain", resource),
},
},
FailedLRPs: []auctiontypes.LRPAuction{
{
LRP: rep.NewLRP(models.NewActualLRPKey("insufficient-capacity", 0, "domain"), resource),
AuctionRecord: auctiontypes.AuctionRecord{PlacementError: rep.ErrorInsufficientResources.Error()},
},
{
LRP: rep.NewLRP(models.NewActualLRPKey("incompatible-stacks", 0, "domain"), resource),
AuctionRecord: auctiontypes.AuctionRecord{PlacementError: auctiontypes.ErrorCellMismatch.Error()},
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())
evacuatingLRPKey = models.NewActualLRPKey("process-guid-0", 0, "domain-0")
oldEvacuatingLRPKey = oldmodels.NewActualLRPKey("process-guid-0", 0, "domain-0")
instanceKey := oldmodels.NewActualLRPInstanceKey("instance-guid-0", "cell-id")
netInfo := oldmodels.NewActualLRPNetInfo("the-host", []oldmodels.PortMapping{{ContainerPort: 80, HostPort: 1000}})
_, err = legacyBBS.EvacuateRunningActualLRP(logger, oldEvacuatingLRPKey, instanceKey, netInfo, 0)
Expect(err).To(Equal(bbserrors.ErrServiceUnavailable))
})
AfterEach(func() {
ginkgomon.Kill(receptorProcess)
})
Describe("ActualLRPs", func() {
var actualLRPResponses []receptor.ActualLRPResponse
var getErr error
"github.com/cloudfoundry-incubator/auction/simulation/util"
"github.com/cloudfoundry-incubator/auction/simulation/visualization"
"github.com/cloudfoundry-incubator/auctioneer"
"github.com/cloudfoundry-incubator/bbs/models"
"github.com/cloudfoundry-incubator/rep"
. "github.com/onsi/ginkgo"
. "github.com/onsi/gomega"
)
var _ = Describe("Auction", func() {
var initialDistributions map[int][]rep.LRP
var linuxRootFSURL = models.PreloadedRootFS(linuxStack)
newLRP := func(processGuid string, index int, memoryMB int) rep.LRP {
lrpKey := models.NewActualLRPKey(processGuid, int32(index), "domain")
return rep.NewLRP(lrpKey, rep.NewResource(int32(memoryMB), 1, linuxRootFSURL))
}
generateUniqueLRPs := func(numInstances int, index int, memoryMB int) []rep.LRP {
instances := []rep.LRP{}
for i := 0; i < numInstances; i++ {
instances = append(instances, newLRP(util.NewGrayscaleGuid("AAA"), index, memoryMB))
}
return instances
}
newLRPStartAuction := func(processGuid string, index int, memoryMB int32) auctioneer.LRPStartRequest {
return auctioneer.NewLRPStartRequest(processGuid, "domain", []int{index}, rep.NewResource(memoryMB, 1, linuxRootFSURL))
}
gardenstore.ContainerStateProperty: string(executor.StateRunning),
gardenstore.ContainerMemoryMBProperty: "512", gardenstore.ContainerDiskMBProperty: "1024"},
}
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())
request.ErrorMessage = ""
})
It("returns a validation error", func() {
Expect(request.Validate()).To(ConsistOf(models.ErrInvalidField{"error_message"}))
})
})
})
})
Describe("ActualLRPKey", func() {
Describe("Validate", func() {
var actualLRPKey models.ActualLRPKey
BeforeEach(func() {
actualLRPKey = models.NewActualLRPKey("process-guid", 1, "domain")
})
Context("when valid", func() {
It("returns nil", func() {
Expect(actualLRPKey.Validate()).To(BeNil())
})
})
Context("when the ProcessGuid is blank", func() {
BeforeEach(func() {
actualLRPKey.ProcessGuid = ""
})
It("returns a validation error", func() {
Expect(actualLRPKey.Validate()).To(ConsistOf(models.ErrInvalidField{"process_guid"}))