func (s *DiegoScheduler) createTaskTaskInfo(slaveId *mesos.SlaveID, taskAuction *auctiontypes.TaskAuction) *mesos.TaskInfo {
work, _ := json.Marshal(rep.Work{LRPs: []rep.LRP{}, Tasks: []rep.Task{taskAuction.Task}})
taskId := mesos.TaskID{Value: proto.String(taskAuction.Identifier())}
taskInfo := mesos.TaskInfo{
Name: proto.String(taskAuction.Identifier()),
TaskId: &taskId,
SlaveId: slaveId,
Executor: s.executor,
Resources: []*mesos.Resource{
util.NewScalarResource("cpus", taskCpuAllocation),
util.NewScalarResource("mem", float64(taskAuction.MemoryMB)),
util.NewScalarResource("disk", float64(taskAuction.DiskMB)),
},
Data: work,
}
return &taskInfo
}
func (s *Scheduler) scheduleTaskAuction(taskAuction *auctiontypes.TaskAuction, startingContainerWeight float64) (*auctiontypes.TaskAuction, error) {
var winnerCell *Cell
winnerScore := 1e20
filteredZones := []Zone{}
for _, zone := range s.zones {
cells := zone.FilterCells(taskAuction.RootFs)
if len(cells) > 0 {
filteredZones = append(filteredZones, Zone(cells))
}
}
if len(filteredZones) == 0 {
return nil, auctiontypes.ErrorCellMismatch
}
for _, zone := range filteredZones {
for _, cell := range zone {
score, err := cell.ScoreForTask(&taskAuction.Task, startingContainerWeight)
if err != nil {
continue
}
if score < winnerScore {
winnerScore = score
winnerCell = cell
}
}
}
if winnerCell == nil {
return nil, rep.ErrorInsufficientResources
}
err := winnerCell.ReserveTask(&taskAuction.Task)
if err != nil {
s.logger.Error("task-failed-to-reserve-cell", err, lager.Data{"cell-guid": winnerCell.Guid, "task-guid": taskAuction.Identifier()})
return nil, err
}
winningAuction := taskAuction.Copy()
winningAuction.Winner = winnerCell.Guid
return &winningAuction, nil
}
func matchTaskAuction(offerAggregates [][]*mesos.Offer, taskAuction *auctiontypes.TaskAuction) (int, []*mesos.Offer) {
taskAuction.Attempts++
for i, offers := range offerAggregates {
if getOffersMem(offers) > float64(taskAuction.MemoryMB) &&
getOffersCpu(offers) > taskCpuAllocation &&
getOffersDisk(offers) > float64(taskAuction.DiskMB) {
taskAuction.Winner = offers[0].SlaveId.GetValue()
taskAuction.WaitDuration = time.Now().Sub(taskAuction.QueueTime)
offers[0].Resources = append(offers[0].Resources,
util.NewScalarResource("mem", float64(-taskAuction.MemoryMB)),
util.NewScalarResource("cpu", -taskCpuAllocation),
util.NewScalarResource("disk", float64(-taskAuction.DiskMB)))
return i, offers
}
}
taskAuction.PlacementError = rep.ErrorInsufficientResources.Error()
return -1, nil
}
It("should not attempt to start the LRP", func() {
Expect(clients["A-cell"].PerformCallCount()).To(Equal(0))
Expect(clients["B-cell"].PerformCallCount()).To(Equal(0))
})
It("should mark the start auction as failed", func() {
startAuction.Attempts = 1
Expect(results.SuccessfulLRPs).To(BeEmpty())
Expect(results.FailedLRPs).To(ConsistOf(startAuction))
})
})
})
Describe("handling task auctions", func() {
var taskAuction auctiontypes.TaskAuction
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("does-not-matter", "domain", 0, "", 10, 10),
*BuildLRP("does-not-matter", "domain", 0, "", 10, 10),
}))}
clients["B-cell"] = &repfakes.FakeSimClient{}
zones["B-zone"] = auctionrunner.Zone{auctionrunner.NewCell(logger, "B-cell", clients["B-cell"], BuildCellState("B-zone", 100, 100, 100, false, linuxOnlyRootFSProviders, []rep.LRP{
*BuildLRP("does-not-matter", "domain", 0, "", 10, 10),
}))}
taskAuction = BuildTaskAuction(BuildTask("tg-1", "domain", linuxRootFSURL, 10, 10), clock.Now())
clock.Increment(time.Minute)