func NewTaskStartRequestFromModel(taskGuid, domain string, taskDef *models.TaskDefinition) TaskStartRequest {
volumeMounts := []string{}
for _, volumeMount := range taskDef.VolumeMounts {
volumeMounts = append(volumeMounts, volumeMount.Driver)
}
return TaskStartRequest{rep.NewTask(taskGuid, domain, rep.NewResource(taskDef.MemoryMb, taskDef.DiskMb, taskDef.RootFs, volumeMounts))}
}
func NewLRPStartRequestFromModel(d *models.DesiredLRP, indices ...int) LRPStartRequest {
volumeDrivers := []string{}
for _, volumeMount := range d.VolumeMounts {
volumeDrivers = append(volumeDrivers, volumeMount.Driver)
}
return NewLRPStartRequest(d.ProcessGuid, d.Domain, indices, rep.NewResource(d.MemoryMb, d.DiskMb, d.RootFs, volumeDrivers))
}
)
var _ = Describe("Auction Metric Emitter Delegate", func() {
var delegate auctiontypes.AuctionMetricEmitterDelegate
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()},
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)
}
func BuildTask(taskGuid, domain, rootFS string, memoryMB, diskMB int32) *rep.Task {
task := rep.NewTask(taskGuid, domain, rep.NewResource(memoryMB, diskMB, rootFS))
return &task
}
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 BuildLRPStartRequest(processGuid, domain string, indices []int, rootFS string, memoryMB, diskMB int32) auctioneer.LRPStartRequest {
return auctioneer.NewLRPStartRequest(processGuid, domain, indices, rep.NewResource(memoryMB, diskMB, rootFS))
}
handler http.Handler
)
BeforeEach(func() {
logger = lagertest.NewTestLogger("test")
logger.RegisterSink(lager.NewWriterSink(GinkgoWriter, lager.DEBUG))
runner = new(fake_auction_runner.FakeAuctionRunner)
responseRecorder = httptest.NewRecorder()
handler = handlers.New(runner, logger)
})
Describe("Task Handler", func() {
Context("with a valid task", func() {
BeforeEach(func() {
resource := rep.NewResource(1, 2, "rootfs")
task := rep.NewTask("the-task-guid", "test", resource)
tasks := []auctioneer.TaskStartRequest{auctioneer.TaskStartRequest{task}}
reqGen := rata.NewRequestGenerator("http://localhost", auctioneer.Routes)
payload, err := json.Marshal(tasks)
Expect(err).NotTo(HaveOccurred())
req, err := reqGen.CreateRequest(auctioneer.CreateTaskAuctionsRoute, rata.Params{}, bytes.NewBuffer(payload))
Expect(err).NotTo(HaveOccurred())
handler.ServeHTTP(responseRecorder, req)
})
It("responds with 202", func() {
"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))
}
generateUniqueLRPStartAuctions := func(numInstances int, memoryMB int32) []auctioneer.LRPStartRequest {
bbsClient.CellsReturns(nil, errors.New("boom"))
})
It("should error", func() {
cells, err := delegate.FetchCellReps()
Expect(err).To(MatchError(errors.New("boom")))
Expect(cells).To(BeEmpty())
})
})
})
Describe("when batches are distributed", func() {
var results auctiontypes.AuctionResults
BeforeEach(func() {
resource := rep.NewResource(10, 10, "linux", []string{})
results = 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),
}))
Expect(state.AvailableResources).To(Equal(rep.Resources{
MemoryMB: int32(availableResources.MemoryMB),
DiskMB: int32(availableResources.DiskMB),
Containers: availableResources.Containers,
}))
Expect(state.TotalResources).To(Equal(rep.Resources{
MemoryMB: int32(totalResources.MemoryMB),
DiskMB: int32(totalResources.DiskMB),
Containers: totalResources.Containers,
}))
Expect(state.LRPs).To(ConsistOf([]rep.LRP{
rep.NewLRP(models.NewActualLRPKey("the-first-app-guid", 17, "domain"), rep.NewResource(20, 10, "")),
rep.NewLRP(models.NewActualLRPKey("the-second-app-guid", 92, "domain"), rep.NewResource(40, 30, "")),
}))
Expect(state.Tasks).To(ConsistOf([]rep.Task{
rep.NewTask("da-task", "domain", rep.NewResource(40, 30, "")),
}))
})
Context("when the cell is not healthy", func() {
BeforeEach(func() {
client.HealthyReturns(false)
})
It("errors when reporting state", func() {
_, err := cellRep.State()
func NewLRPStartRequestFromSchedulingInfo(s *models.DesiredLRPSchedulingInfo, indices ...int) LRPStartRequest {
return NewLRPStartRequest(s.ProcessGuid, s.Domain, indices, rep.NewResource(s.MemoryMb, s.DiskMb, s.RootFs))
}
func NewLRPStartRequestFromModel(d *models.DesiredLRP, indices ...int) LRPStartRequest {
return NewLRPStartRequest(d.ProcessGuid, d.Domain, indices, rep.NewResource(d.MemoryMb, d.DiskMb, d.RootFs))
}
func NewTaskStartRequestFromModel(t *models.Task) TaskStartRequest {
return TaskStartRequest{rep.NewTask(t.TaskGuid, t.Domain, rep.NewResource(t.MemoryMb, t.DiskMb, t.RootFs))}
}
BeforeEach(func() {
logger = lagertest.NewTestLogger("test")
logger.RegisterSink(lager.NewWriterSink(GinkgoWriter, lager.DEBUG))
runner = new(fake_auction_runner.FakeAuctionRunner)
responseRecorder = httptest.NewRecorder()
sender = fake.NewFakeMetricSender()
metrics.Initialize(sender, nil)
handler = handlers.New(runner, logger)
})
Describe("Task Handler", func() {
Context("with a valid task", func() {
BeforeEach(func() {
resource := rep.NewResource(1, 2, "rootfs", []string{})
task := rep.NewTask("the-task-guid", "test", resource)
tasks := []auctioneer.TaskStartRequest{auctioneer.TaskStartRequest{task}}
reqGen := rata.NewRequestGenerator("http://localhost", auctioneer.Routes)
payload, err := json.Marshal(tasks)
Expect(err).NotTo(HaveOccurred())
req, err := reqGen.CreateRequest(auctioneer.CreateTaskAuctionsRoute, rata.Params{}, bytes.NewBuffer(payload))
Expect(err).NotTo(HaveOccurred())
handler.ServeHTTP(responseRecorder, req)
})
It("responds with 202", func() {
Expect(r.Body.Close()).NotTo(HaveOccurred())
close(containersCalled)
},
))
fakeGarden.RouteToHandler("PUT", "/containers/the-task-guid/limits/memory", ghttp.RespondWithJSONEncoded(http.StatusOK, garden.MemoryLimits{}))
fakeGarden.RouteToHandler("PUT", "/containers/the-task-guid/limits/disk", ghttp.RespondWithJSONEncoded(http.StatusOK, garden.DiskLimits{}))
fakeGarden.RouteToHandler("PUT", "/containers/the-task-guid/limits/cpu", ghttp.RespondWithJSONEncoded(http.StatusOK, garden.CPULimits{}))
fakeGarden.RouteToHandler("POST", "/containers/the-task-guid/net/out", ghttp.RespondWithJSONEncoded(http.StatusOK, garden.CPULimits{}))
fakeGarden.RouteToHandler("GET", "/containers/the-task-guid/info", ghttp.RespondWithJSONEncoded(http.StatusOK, garden.ContainerInfo{}))
taskModel := model_helpers.NewValidTask("the-task-guid")
task = rep.NewTask(
taskModel.TaskGuid,
taskModel.Domain,
rep.NewResource(taskModel.MemoryMb, taskModel.DiskMb, taskModel.RootFs),
)
err := bbsClient.DesireTask(taskModel.TaskGuid, taskModel.Domain, taskModel.TaskDefinition)
Expect(err).NotTo(HaveOccurred())
})
It("makes a request to executor to allocate the container", func() {
Expect(getTasksByState(bbsClient, models.Task_Pending)).To(HaveLen(1))
Expect(getTasksByState(bbsClient, models.Task_Running)).To(BeEmpty())
works := rep.Work{
Tasks: []rep.Task{task},
}
failedWorks, err := client.Perform(works)
Expect(err).NotTo(HaveOccurred())
import (
"bytes"
"errors"
"net/http"
"github.com/cloudfoundry-incubator/rep"
. "github.com/onsi/ginkgo"
. "github.com/onsi/gomega"
)
var _ = Describe("Perform", func() {
Context("with valid JSON", func() {
var requestedWork, failedWork rep.Work
BeforeEach(func() {
resourceA := rep.NewResource(128, 256, "some-rootfs")
resourceB := rep.NewResource(256, 512, "some-rootfs")
resourceC := rep.NewResource(512, 1024, "some-rootfs")
requestedWork = rep.Work{
Tasks: []rep.Task{
rep.NewTask("a", "domain", resourceA),
rep.NewTask("b", "domain", resourceB),
},
}
failedWork = rep.Work{
Tasks: []rep.Task{
rep.NewTask("c", "domain", resourceC),
},
}
