// 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 }