func (r *SimulationRep) Perform(work rep.Work) (rep.Work, error) {
r.lock.Lock()
defer r.lock.Unlock()
failedWork := rep.Work{}
availableResources := r.availableResources()
for _, start := range work.LRPs {
hasRoom := availableResources.Containers >= 0
hasRoom = hasRoom && availableResources.MemoryMB >= start.MemoryMB
hasRoom = hasRoom && availableResources.DiskMB >= start.DiskMB
if hasRoom {
r.lrps[start.Identifier()] = start
availableResources.Containers -= 1
if start.Domain == "auction" {
r.startingContainerCount++
}
availableResources.MemoryMB -= start.MemoryMB
availableResources.DiskMB -= start.DiskMB
} else {
failedWork.LRPs = append(failedWork.LRPs, start)
}
}
for _, task := range work.Tasks {
hasRoom := availableResources.Containers >= 0
hasRoom = hasRoom && availableResources.MemoryMB >= task.MemoryMB
hasRoom = hasRoom && availableResources.DiskMB >= task.DiskMB
if hasRoom {
r.tasks[task.TaskGuid] = task
availableResources.Containers -= 1
if task.Domain == "auction" {
r.startingContainerCount++
}
availableResources.MemoryMB -= task.MemoryMB
availableResources.DiskMB -= task.DiskMB
} else {
failedWork.Tasks = append(failedWork.Tasks, task)
}
}
return failedWork, nil
}
func (a *AuctionCellRep) Perform(work rep.Work) (rep.Work, error) {
var failedWork = rep.Work{}
logger := a.logger.Session("auction-work", lager.Data{
"lrp-starts": len(work.LRPs),
"tasks": len(work.Tasks),
})
if a.evacuationReporter.Evacuating() {
return work, nil
}
if len(work.LRPs) > 0 {
lrpLogger := logger.Session("lrp-allocate-instances")
requests, lrpMap, untranslatedLRPs := a.lrpsToAllocationRequest(work.LRPs)
if len(untranslatedLRPs) > 0 {
lrpLogger.Info("failed-to-translate-lrps-to-containers", lager.Data{"num-failed-to-translate": len(untranslatedLRPs)})
failedWork.LRPs = untranslatedLRPs
}
lrpLogger.Info("requesting-container-allocation", lager.Data{"num-requesting-allocation": len(requests)})
failures, err := a.client.AllocateContainers(requests)
if err != nil {
lrpLogger.Error("failed-requesting-container-allocation", err)
failedWork.LRPs = work.LRPs
} else {
lrpLogger.Info("succeeded-requesting-container-allocation", lager.Data{"num-failed-to-allocate": len(failures)})
for i := range failures {
failure := &failures[i]
lrpLogger.Error("container-allocation-failure", failure, lager.Data{"failed-request": &failure.AllocationRequest})
if lrp, found := lrpMap[failure.Guid]; found {
failedWork.LRPs = append(failedWork.LRPs, *lrp)
}
}
}
}
if len(work.Tasks) > 0 {
taskLogger := logger.Session("task-allocate-instances")
requests, taskMap, failedTasks := a.tasksToAllocationRequests(work.Tasks)
if len(failedTasks) > 0 {
taskLogger.Info("failed-to-translate-tasks-to-containers", lager.Data{"num-failed-to-translate": len(failedTasks)})
failedWork.Tasks = failedTasks
}
taskLogger.Info("requesting-container-allocation", lager.Data{"num-requesting-allocation": len(requests)})
failures, err := a.client.AllocateContainers(requests)
if err != nil {
taskLogger.Error("failed-requesting-container-allocation", err)
failedWork.Tasks = work.Tasks
} else {
taskLogger.Info("succeeded-requesting-container-allocation", lager.Data{"num-failed-to-allocate": len(failures)})
for i := range failures {
failure := &failures[i]
taskLogger.Error("container-allocation-failure", failure, lager.Data{"failed-request": &failure.AllocationRequest})
if task, found := taskMap[failure.Guid]; found {
failedWork.Tasks = append(failedWork.Tasks, *task)
}
}
}
}
return failedWork, nil
}
