func (s *Scheduler) scheduleLRPAuction(lrpAuction *auctiontypes.LRPAuction) (*auctiontypes.LRPAuction, error) {
var winnerCell *Cell
winnerScore := 1e20
zones := accumulateZonesByInstances(s.zones, lrpAuction.ProcessGuid)
filteredZones := filterZonesByRootFS(zones, lrpAuction.RootFs)
if len(filteredZones) == 0 {
return nil, auctiontypes.ErrorCellMismatch
}
sortedZones := sortZonesByInstances(filteredZones)
for zoneIndex, lrpByZone := range sortedZones {
for _, cell := range lrpByZone.zone {
score, err := cell.ScoreForLRP(&lrpAuction.LRP, s.startingContainerWeight)
if err != nil {
continue
}
if score < winnerScore {
winnerScore = score
winnerCell = cell
}
}
// if (not last zone) && (this zone has the same # of instances as the next sorted zone)
// acts as a tie breaker
if zoneIndex+1 < len(sortedZones) &&
lrpByZone.instances == sortedZones[zoneIndex+1].instances {
continue
}
if winnerCell != nil {
break
}
}
if winnerCell == nil {
return nil, rep.ErrorInsufficientResources
}
err := winnerCell.ReserveLRP(&lrpAuction.LRP)
if err != nil {
s.logger.Error("lrp-failed-to-reserve-cell", err, lager.Data{"cell-guid": winnerCell.Guid, "lrp-guid": lrpAuction.Identifier()})
return nil, err
}
winningAuction := lrpAuction.Copy()
winningAuction.Winner = winnerCell.Guid
return &winningAuction, nil
}
func (s *DiegoScheduler) createLrpTaskInfo(slaveId *mesos.SlaveID, lrpAuction *auctiontypes.LRPAuction) *mesos.TaskInfo {
work, _ := json.Marshal(rep.Work{LRPs: []rep.LRP{lrpAuction.LRP}, Tasks: []rep.Task{}})
taskId := mesos.TaskID{Value: proto.String(lrpAuction.Identifier())}
taskInfo := mesos.TaskInfo{
Name: proto.String(lrpAuction.Identifier()),
TaskId: &taskId,
SlaveId: slaveId,
Executor: s.executor,
Resources: []*mesos.Resource{
util.NewScalarResource("cpus", taskCpuAllocation), // TODO: ??
util.NewScalarResource("mem", float64(lrpAuction.MemoryMB)),
util.NewScalarResource("disk", float64(lrpAuction.DiskMB)),
},
Data: work,
}
return &taskInfo
}
func matchLrpAuction(offerAggregates [][]*mesos.Offer, lrpAuction *auctiontypes.LRPAuction) (int, []*mesos.Offer) {
lrpAuction.Attempts++
for i, offers := range offerAggregates {
if getOffersMem(offers) > float64(lrpAuction.MemoryMB) &&
getOffersCpu(offers) > taskCpuAllocation &&
getOffersDisk(offers) > float64(lrpAuction.DiskMB) {
lrpAuction.Winner = offers[0].SlaveId.GetValue()
lrpAuction.WaitDuration = time.Now().Sub(lrpAuction.QueueTime)
offers[0].Resources = append(offers[0].Resources,
util.NewScalarResource("mem", float64(-lrpAuction.MemoryMB)),
util.NewScalarResource("cpu", -taskCpuAllocation),
util.NewScalarResource("disk", float64(-lrpAuction.DiskMB)))
return i, offers
}
}
lrpAuction.PlacementError = rep.ErrorInsufficientResources.Error()
return -1, nil
}
failedLRPStart := results.FailedLRPs[0]
Expect(failedLRPStart.Identifier()).To(Equal(startAuction.Identifier()))
Expect(failedLRPStart.Attempts).To(Equal(startAuction.Attempts + 1))
Expect(failedLRPStart.PlacementError).To(Equal(auctiontypes.ErrorCellMismatch.Error()))
By("all tasks are marked failed, and their attempts are incremented")
Expect(results.FailedTasks).To(HaveLen(1))
failedTask := results.FailedTasks[0]
Expect(failedTask.Identifier()).To(Equal(taskAuction.Identifier()))
Expect(failedTask.Attempts).To(Equal(taskAuction.Attempts + 1))
Expect(failedLRPStart.PlacementError).To(Equal(auctiontypes.ErrorCellMismatch.Error()))
})
})
Describe("handling start auctions", func() {
var startAuction auctiontypes.LRPAuction
BeforeEach(func() {
clients["A-cell"] = &repfakes.FakeSimClient{}
zones["A-zone"] = auctionrunner.Zone{
auctionrunner.NewCell(
logger,
"A-cell",
clients["A-cell"],
BuildCellState("A-zone", 100, 100, 100, false, linuxOnlyRootFSProviders, []rep.LRP{
*BuildLRP("pg-1", "domain", 0, "", 10, 10),
*BuildLRP("pg-2", "domain", 0, "", 10, 10),
}),
),
}