// State currently does not return tasks or lrp rootfs, because the
// auctioneer currently does not need them.
func (a *AuctionCellRep) State() (rep.CellState, error) {
logger := a.logger.Session("auction-state")
logger.Info("providing")
totalResources, err := a.fetchResourcesVia(a.client.TotalResources)
if err != nil {
logger.Error("failed-to-get-total-resources", err)
return rep.CellState{}, err
}
availableResources, err := a.fetchResourcesVia(a.client.RemainingResources)
if err != nil {
logger.Error("failed-to-get-remaining-resource", err)
return rep.CellState{}, err
}
containers, err := a.client.ListContainers(nil)
if err != nil {
logger.Error("failed-to-fetch-containers", err)
return rep.CellState{}, err
}
var taskGuid, taskDomain string
var key *models.ActualLRPKey
var keyErr error
tasks := []rep.Task{}
lrps := []rep.LRP{}
for i := range containers {
container := &containers[i]
resource := rep.Resource{MemoryMB: int32(container.MemoryMB), DiskMB: int32(container.DiskMB)}
if container.Tags[rep.LifecycleTag] == rep.TaskLifecycle {
taskGuid, taskDomain, keyErr = taskKeyFromTags(container.Tags)
if keyErr != nil {
logger.Error("failed-to-extract-task key", keyErr)
continue
}
tasks = append(tasks, rep.NewTask(taskGuid, taskDomain, resource))
} else {
key, keyErr = rep.ActualLRPKeyFromTags(container.Tags)
if keyErr != nil {
logger.Error("failed-to-extract-key", keyErr)
continue
}
lrps = append(lrps, rep.NewLRP(*key, resource))
}
}
state := rep.NewCellState(a.rootFSProviders, availableResources, totalResources, lrps, tasks, a.zone, a.evacuationReporter.Evacuating())
a.logger.Info("provided", lager.Data{
"available-resources": state.AvailableResources,
"total-resources": state.TotalResources,
"num-lrps": len(state.LRPs),
"zone": state.Zone,
"evacuating": state.Evacuating,
})
return state, nil
}
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))}
}
Expect(string(body)).To(ContainSubstring(`"handle":"the-task-guid"`))
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)
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(responseRecorder.Code).To(Equal(http.StatusAccepted))
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()},
},
},
FailedTasks: []auctiontypes.TaskAuction{
{
Task: rep.NewTask("failed-task", "domain", resource),
func BuildTask(taskGuid, domain, rootFS string, memoryMB, diskMB int32) *rep.Task {
task := rep.NewTask(taskGuid, domain, rep.NewResource(memoryMB, diskMB, rootFS))
return &task
}
. "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),
},
}
})
Context("and no perform error", func() {
BeforeEach(func() {
fakeLocalRep.PerformReturns(failedWork, nil)
})
// State currently does not return tasks or lrp rootfs, because the
// auctioneer currently does not need them.
func (a *AuctionCellRep) State() (rep.CellState, error) {
logger := a.logger.Session("auction-state")
logger.Info("providing")
containers, err := a.client.ListContainers(executor.Tags{})
if err != nil {
logger.Error("failed-to-fetch-containers", err)
return rep.CellState{}, err
}
totalResources, err := a.client.TotalResources()
if err != nil {
logger.Error("failed-to-get-total-resources", err)
return rep.CellState{}, err
}
availableResources, err := a.client.RemainingResourcesFrom(containers)
if err != nil {
logger.Error("failed-to-get-remaining-resource", err)
return rep.CellState{}, err
}
var key *models.ActualLRPKey
var keyErr error
lrps := []rep.LRP{}
tasks := []rep.Task{}
for i := range containers {
container := &containers[i]
resource := rep.Resource{MemoryMB: int32(container.MemoryMB), DiskMB: int32(container.DiskMB)}
if container.Tags == nil {
logger.Error("failed-to-extract-container-tags", nil)
continue
}
switch container.Tags[rep.LifecycleTag] {
case rep.LRPLifecycle:
key, keyErr = rep.ActualLRPKeyFromTags(container.Tags)
if keyErr != nil {
logger.Error("failed-to-extract-key", keyErr)
continue
}
lrps = append(lrps, rep.NewLRP(*key, resource))
case rep.TaskLifecycle:
domain := container.Tags[rep.DomainTag]
tasks = append(tasks, rep.NewTask(container.Guid, domain, resource))
}
}
state := rep.NewCellState(
a.rootFSProviders,
a.convertResources(availableResources),
a.convertResources(totalResources),
lrps,
tasks,
a.zone,
a.evacuationReporter.Evacuating(),
)
a.logger.Info("provided", lager.Data{
"available-resources": state.AvailableResources,
"total-resources": state.TotalResources,
"num-lrps": len(state.LRPs),
"zone": state.Zone,
"evacuating": state.Evacuating,
})
return state, nil
}
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()
Expect(err).To(MatchError(auction_cell_rep.ErrCellUnhealthy))
})
})
Context("when the client fails to fetch total resources", func() {
func NewTaskStartRequestFromModel(t *models.Task) TaskStartRequest {
return TaskStartRequest{rep.NewTask(t.TaskGuid, t.Domain, rep.NewResource(t.MemoryMb, t.DiskMb, t.RootFs))}
}