// 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 (p *ordinaryLRPProcessor) Process(logger lager.Logger, container executor.Container) {
logger = logger.Session("ordinary-lrp-processor", lager.Data{
"container-guid": container.Guid,
"container-state": container.State,
})
logger.Debug("starting")
defer logger.Debug("finished")
lrpKey, err := rep.ActualLRPKeyFromTags(container.Tags)
if err != nil {
logger.Error("failed-to-generate-lrp-key", err)
return
}
logger = logger.WithData(lager.Data{"lrp-key": lrpKey})
instanceKey, err := rep.ActualLRPInstanceKeyFromContainer(container, p.cellID)
if err != nil {
logger.Error("failed-to-generate-instance-key", err)
return
}
logger = logger.WithData(lager.Data{"lrp-instance-key": instanceKey})
lrpContainer := newLRPContainer(lrpKey, instanceKey, container)
switch lrpContainer.Container.State {
case executor.StateReserved:
p.processReservedContainer(logger, lrpContainer)
case executor.StateInitializing:
p.processInitializingContainer(logger, lrpContainer)
case executor.StateCreated:
p.processCreatedContainer(logger, lrpContainer)
case executor.StateRunning:
p.processRunningContainer(logger, lrpContainer)
case executor.StateCompleted:
p.processCompletedContainer(logger, lrpContainer)
default:
p.processInvalidContainer(logger, lrpContainer)
}
}
tags executor.Tags
lrpKey *models.ActualLRPKey
keyConversionErr error
)
BeforeEach(func() {
tags = executor.Tags{
rep.LifecycleTag: rep.LRPLifecycle,
rep.DomainTag: "my-domain",
rep.ProcessGuidTag: "process-guid",
rep.ProcessIndexTag: "999",
}
})
JustBeforeEach(func() {
lrpKey, keyConversionErr = rep.ActualLRPKeyFromTags(tags)
})
Context("when the tags are valid", func() {
It("does not return an error", func() {
Expect(keyConversionErr).NotTo(HaveOccurred())
})
It("converts a valid tags without error", func() {
expectedKey := models.ActualLRPKey{
ProcessGuid: "process-guid",
Index: 999,
Domain: "my-domain",
}
Expect(*lrpKey).To(Equal(expectedKey))
})
// 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
}
