func (h *ActualLRPLifecycleHandler) ClaimActualLRP(logger lager.Logger, w http.ResponseWriter, req *http.Request) { var err error logger = logger.Session("claim-actual-lrp") request := &models.ClaimActualLRPRequest{} response := &models.ActualLRPLifecycleResponse{} defer func() { exitIfUnrecoverable(logger, h.exitChan, response.Error) }() defer writeResponse(w, response) err = parseRequest(logger, req, request) if err != nil { response.Error = models.ConvertError(err) return } before, after, err := h.db.ClaimActualLRP(logger, request.ProcessGuid, request.Index, request.ActualLrpInstanceKey) if err != nil { response.Error = models.ConvertError(err) return } if !after.Equal(before) { go h.actualHub.Emit(models.NewActualLRPChangedEvent(before, after)) } }
// returns nil, nil if no version is found func (m *Manager) resolveStoredVersion(logger lager.Logger) (*models.Version, error) { var ( version *models.Version err error ) if m.hasSQLConfigured() { version, err = m.sqlDB.Version(logger) if err == nil { return version, nil } else if models.ConvertError(err) != models.ErrResourceNotFound { return nil, err } } if m.hasETCDConfigured() { version, err = m.etcdDB.Version(logger) if err != nil { if models.ConvertError(err) == models.ErrResourceNotFound { return nil, nil // totally fresh deploy } return nil, err } return version, nil } return nil, nil }
func (h *ActualLRPLifecycleHandler) StartActualLRP(logger lager.Logger, w http.ResponseWriter, req *http.Request) { var err error logger = logger.Session("start-actual-lrp") request := &models.StartActualLRPRequest{} response := &models.ActualLRPLifecycleResponse{} defer func() { exitIfUnrecoverable(logger, h.exitChan, response.Error) }() defer writeResponse(w, response) err = parseRequest(logger, req, request) if err != nil { response.Error = models.ConvertError(err) return } before, after, err := h.db.StartActualLRP(logger, request.ActualLrpKey, request.ActualLrpInstanceKey, request.ActualLrpNetInfo) if err != nil { response.Error = models.ConvertError(err) return } if before == nil { go h.actualHub.Emit(models.NewActualLRPCreatedEvent(after)) } else if !before.Equal(after) { go h.actualHub.Emit(models.NewActualLRPChangedEvent(before, after)) } }
func (h *TaskHandler) commonTasks(logger lager.Logger, w http.ResponseWriter, req *http.Request, version format.Version) { var err error logger = logger.Session("tasks", lager.Data{"revision": 0}) request := &models.TasksRequest{} response := &models.TasksResponse{} defer func() { exitIfUnrecoverable(logger, h.exitChan, response.Error) }() defer writeResponse(w, response) err = parseRequest(logger, req, request) if err != nil { logger.Error("failed-parsing-request", err) response.Error = models.ConvertError(err) return } filter := models.TaskFilter{Domain: request.Domain, CellID: request.CellId} response.Tasks, err = h.controller.Tasks(logger, filter.Domain, filter.CellID) if err != nil { response.Error = models.ConvertError(err) return } for i := range response.Tasks { task := response.Tasks[i] if task.TaskDefinition == nil { continue } response.Tasks[i] = task.VersionDownTo(version) } }
func (db *serviceClient) Cells(logger lager.Logger) (models.CellSet, error) { kvPairs, _, err := db.consulClient.KV().List(CellSchemaRoot(), nil) if err != nil { bbsErr := models.ConvertError(convertConsulError(err)) if bbsErr.Type != models.Error_ResourceNotFound { return nil, bbsErr } } if kvPairs == nil { err = consuladapter.NewPrefixNotFoundError(CellSchemaRoot()) bbsErr := models.ConvertError(convertConsulError(err)) if bbsErr.Type != models.Error_ResourceNotFound { return nil, bbsErr } } cellPresences := models.NewCellSet() for _, kvPair := range kvPairs { if kvPair.Session == "" { continue } cell := kvPair.Value presence := new(models.CellPresence) err := models.FromJSON(cell, presence) if err != nil { logger.Error("failed-to-unmarshal-cells-json", err) continue } cellPresences.Add(presence) } return cellPresences, nil }
func (h *DesiredLRPHandler) DesireDesiredLRP(logger lager.Logger, w http.ResponseWriter, req *http.Request) { logger = logger.Session("desire-lrp") request := &models.DesireLRPRequest{} response := &models.DesiredLRPLifecycleResponse{} defer func() { exitIfUnrecoverable(logger, h.exitChan, response.Error) }() defer writeResponse(w, response) err := parseRequest(logger, req, request) if err != nil { response.Error = models.ConvertError(err) return } err = h.desiredLRPDB.DesireLRP(logger, request.DesiredLrp) if err != nil { response.Error = models.ConvertError(err) return } desiredLRP, err := h.desiredLRPDB.DesiredLRPByProcessGuid(logger, request.DesiredLrp.ProcessGuid) if err != nil { response.Error = models.ConvertError(err) return } go h.desiredHub.Emit(models.NewDesiredLRPCreatedEvent(desiredLRP)) schedulingInfo := request.DesiredLrp.DesiredLRPSchedulingInfo() h.startInstanceRange(logger, 0, schedulingInfo.Instances, &schedulingInfo) }
func (h *DesiredLRPHandler) RemoveDesiredLRP(logger lager.Logger, w http.ResponseWriter, req *http.Request) { logger = logger.Session("remove-desired-lrp") request := &models.RemoveDesiredLRPRequest{} response := &models.DesiredLRPLifecycleResponse{} defer func() { exitIfUnrecoverable(logger, h.exitChan, response.Error) }() defer writeResponse(w, response) err := parseRequest(logger, req, request) if err != nil { response.Error = models.ConvertError(err) return } logger = logger.WithData(lager.Data{"process_guid": request.ProcessGuid}) desiredLRP, err := h.desiredLRPDB.DesiredLRPByProcessGuid(logger.Session("fetch-desired"), request.ProcessGuid) if err != nil { response.Error = models.ConvertError(err) return } err = h.desiredLRPDB.RemoveDesiredLRP(logger.Session("remove-desired"), request.ProcessGuid) if err != nil { response.Error = models.ConvertError(err) return } go h.desiredHub.Emit(models.NewDesiredLRPRemovedEvent(desiredLRP)) h.stopInstancesFrom(logger, request.ProcessGuid, 0) }
func (h *TaskHandler) commonTaskByGuid(logger lager.Logger, w http.ResponseWriter, req *http.Request, version format.Version) { var err error logger = logger.Session("task-by-guid", lager.Data{"revision": 0}) request := &models.TaskByGuidRequest{} response := &models.TaskResponse{} defer func() { exitIfUnrecoverable(logger, h.exitChan, response.Error) }() defer writeResponse(w, response) err = parseRequest(logger, req, request) if err != nil { logger.Error("failed-parsing-request", err) response.Error = models.ConvertError(err) return } response.Task, err = h.controller.TaskByGuid(logger, request.TaskGuid) if err != nil { response.Error = models.ConvertError(err) return } if response.Task.TaskDefinition != nil { response.Task = response.Task.VersionDownTo(version) } }
func (h *ActualLRPLifecycleHandler) RemoveActualLRP(logger lager.Logger, w http.ResponseWriter, req *http.Request) { var err error logger = logger.Session("remove-actual-lrp") request := &models.RemoveActualLRPRequest{} response := &models.ActualLRPLifecycleResponse{} defer func() { exitIfUnrecoverable(logger, h.exitChan, response.Error) }() defer writeResponse(w, response) err = parseRequest(logger, req, request) if err != nil { response.Error = models.ConvertError(err) return } beforeActualLRPGroup, err := h.db.ActualLRPGroupByProcessGuidAndIndex(logger, request.ProcessGuid, request.Index) if err != nil { response.Error = models.ConvertError(err) return } err = h.db.RemoveActualLRP(logger, request.ProcessGuid, request.Index, request.ActualLrpInstanceKey) if err != nil { response.Error = models.ConvertError(err) return } go h.actualHub.Emit(models.NewActualLRPRemovedEvent(beforeActualLRPGroup)) }
func (h *DesiredLRPHandler) UpdateDesiredLRP(logger lager.Logger, w http.ResponseWriter, req *http.Request) { logger = logger.Session("update-desired-lrp") request := &models.UpdateDesiredLRPRequest{} response := &models.DesiredLRPLifecycleResponse{} defer func() { exitIfUnrecoverable(logger, h.exitChan, response.Error) }() defer writeResponse(w, response) err := parseRequest(logger, req, request) if err != nil { logger.Error("failed-parsing-request", err) response.Error = models.ConvertError(err) return } logger = logger.WithData(lager.Data{"guid": request.ProcessGuid}) logger.Debug("updating-desired-lrp") beforeDesiredLRP, err := h.desiredLRPDB.UpdateDesiredLRP(logger, request.ProcessGuid, request.Update) if err != nil { logger.Debug("failed-updating-desired-lrp") response.Error = models.ConvertError(err) return } logger.Debug("completed-updating-desired-lrp") desiredLRP, err := h.desiredLRPDB.DesiredLRPByProcessGuid(logger, request.ProcessGuid) if err != nil { logger.Error("failed-fetching-desired-lrp", err) return } if request.Update.Instances != nil { logger.Debug("updating-lrp-instances") previousInstanceCount := beforeDesiredLRP.Instances requestedInstances := *request.Update.Instances - previousInstanceCount logger = logger.WithData(lager.Data{"instances_delta": requestedInstances}) if requestedInstances > 0 { logger.Debug("increasing-the-instances") schedulingInfo := desiredLRP.DesiredLRPSchedulingInfo() h.startInstanceRange(logger, previousInstanceCount, *request.Update.Instances, &schedulingInfo) } if requestedInstances < 0 { logger.Debug("decreasing-the-instances") numExtraActualLRP := previousInstanceCount + requestedInstances h.stopInstancesFrom(logger, request.ProcessGuid, int(numExtraActualLRP)) } } go h.desiredHub.Emit(models.NewDesiredLRPChangedEvent(beforeDesiredLRP, desiredLRP)) }
func (h *EvacuationHandler) EvacuateStoppedActualLRP(logger lager.Logger, w http.ResponseWriter, req *http.Request) { logger = logger.Session("evacuate-stopped-actual-lrp") request := &models.EvacuateStoppedActualLRPRequest{} response := &models.EvacuationResponse{} var bbsErr *models.Error defer func() { exitIfUnrecoverable(logger, h.exitChan, bbsErr) }() defer writeResponse(w, response) err := parseRequest(logger, req, request) if err != nil { logger.Error("failed-to-parse-request", err) bbsErr = models.ConvertError(err) response.Error = bbsErr return } guid := request.ActualLrpKey.ProcessGuid index := request.ActualLrpKey.Index group, err := h.actualLRPDB.ActualLRPGroupByProcessGuidAndIndex(logger, guid, index) if err != nil { logger.Error("failed-fetching-actual-lrp-group", err) bbsErr = models.ConvertError(err) response.Error = bbsErr return } err = h.db.RemoveEvacuatingActualLRP(logger, request.ActualLrpKey, request.ActualLrpInstanceKey) if err != nil { logger.Error("failed-removing-evacuating-actual-lrp", err) bbsErr = models.ConvertError(err) } else if group.Evacuating != nil { go h.actualHub.Emit(models.NewActualLRPRemovedEvent(&models.ActualLRPGroup{Evacuating: group.Evacuating})) } if group.Instance == nil || !group.Instance.ActualLRPInstanceKey.Equal(request.ActualLrpInstanceKey) { logger.Debug("cannot-remove-actual-lrp") response.Error = models.ErrActualLRPCannotBeRemoved return } err = h.actualLRPDB.RemoveActualLRP(logger, guid, index, request.ActualLrpInstanceKey) if err != nil { logger.Error("failed-to-remove-actual-lrp", err) bbsErr = models.ConvertError(err) response.Error = bbsErr return } else { go h.actualHub.Emit(models.NewActualLRPRemovedEvent(&models.ActualLRPGroup{Instance: group.Instance})) } }
func (h *DesiredLRPHandler) DesiredLRPs_r1(logger lager.Logger, w http.ResponseWriter, req *http.Request) { var err error logger = logger.Session("desired-lrps", lager.Data{"revision": 0}) request := &models.DesiredLRPsRequest{} response := &models.DesiredLRPsResponse{} err = parseRequest(logger, req, request) if err == nil { var lrps []*models.DesiredLRP filter := models.DesiredLRPFilter{Domain: request.Domain} lrps, err = h.desiredLRPDB.DesiredLRPs(logger, filter) if err == nil { for i := range lrps { transformedLRP := lrps[i].VersionDownTo(format.V1) response.DesiredLrps = append(response.DesiredLrps, transformedLRP) } } } response.Error = models.ConvertError(err) writeResponse(w, response) exitIfUnrecoverable(logger, h.exitChan, response.Error) }
func (db *ETCDDB) UnclaimActualLRP(logger lager.Logger, key *models.ActualLRPKey) (*models.ActualLRPGroup, *models.ActualLRPGroup, error) { actualLRP, modifiedIndex, err := db.rawActualLRPByProcessGuidAndIndex(logger, key.ProcessGuid, key.Index) bbsErr := models.ConvertError(err) if bbsErr != nil { return nil, nil, bbsErr } beforeActualLRP := *actualLRP if actualLRP.State == models.ActualLRPStateUnclaimed { logger.Debug("already-unclaimed") return nil, nil, models.ErrActualLRPCannotBeUnclaimed } actualLRP.State = models.ActualLRPStateUnclaimed actualLRP.ActualLRPKey = *key actualLRP.ActualLRPInstanceKey = models.ActualLRPInstanceKey{} actualLRP.ActualLRPNetInfo = models.EmptyActualLRPNetInfo() actualLRP.Since = db.clock.Now().UnixNano() actualLRP.ModificationTag.Increment() data, err := db.serializeModel(logger, actualLRP) if err != nil { return nil, nil, err } _, err = db.client.CompareAndSwap(ActualLRPSchemaPath(key.ProcessGuid, key.Index), data, 0, modifiedIndex) if err != nil { logger.Error("failed-compare-and-swap", err) return nil, nil, ErrorFromEtcdError(logger, err) } return &models.ActualLRPGroup{Instance: &beforeActualLRP}, &models.ActualLRPGroup{Instance: actualLRP}, nil }
func (h *ActualLRPLifecycleHandler) CrashActualLRP(logger lager.Logger, w http.ResponseWriter, req *http.Request) { logger = logger.Session("crash-actual-lrp") request := &models.CrashActualLRPRequest{} response := &models.ActualLRPLifecycleResponse{} defer func() { exitIfUnrecoverable(logger, h.exitChan, response.Error) }() defer writeResponse(w, response) err := parseRequest(logger, req, request) if err != nil { response.Error = models.ConvertError(err) return } actualLRPKey := request.ActualLrpKey actualLRPInstanceKey := request.ActualLrpInstanceKey before, after, shouldRestart, err := h.db.CrashActualLRP(logger, actualLRPKey, actualLRPInstanceKey, request.ErrorMessage) if err != nil { response.Error = models.ConvertError(err) return } if shouldRestart { desiredLRP, err := h.desiredLRPDB.DesiredLRPByProcessGuid(logger, actualLRPKey.ProcessGuid) if err != nil { logger.Error("failed-fetching-desired-lrp", err) response.Error = models.ConvertError(err) return } schedInfo := desiredLRP.DesiredLRPSchedulingInfo() startRequest := auctioneer.NewLRPStartRequestFromSchedulingInfo(&schedInfo, int(actualLRPKey.Index)) logger.Info("start-lrp-auction-request", lager.Data{"app_guid": schedInfo.ProcessGuid, "index": int(actualLRPKey.Index)}) err = h.auctioneerClient.RequestLRPAuctions(logger, []*auctioneer.LRPStartRequest{&startRequest}) logger.Info("finished-lrp-auction-request", lager.Data{"app_guid": schedInfo.ProcessGuid, "index": int(actualLRPKey.Index)}) if err != nil { logger.Error("failed-requesting-auction", err) response.Error = models.ConvertError(err) return } } actualLRP, _ := after.Resolve() go h.actualHub.Emit(models.NewActualLRPCrashedEvent(actualLRP)) go h.actualHub.Emit(models.NewActualLRPChangedEvent(before, after)) }
func (h *ActualLRPLifecycleHandler) RetireActualLRP(logger lager.Logger, w http.ResponseWriter, req *http.Request) { logger = logger.Session("retire-actual-lrp") request := &models.RetireActualLRPRequest{} response := &models.ActualLRPLifecycleResponse{} var err error defer func() { exitIfUnrecoverable(logger, h.exitChan, response.Error) }() defer writeResponse(w, response) err = parseRequest(logger, req, request) if err != nil { response.Error = models.ConvertError(err) return } err = h.retirer.RetireActualLRP(logger, request.ActualLrpKey.ProcessGuid, request.ActualLrpKey.Index) response.Error = models.ConvertError(err) }
func exitIfUnrecoverableError(logger lager.Logger, err error, exitChan chan<- struct{}) { bbsErr := models.ConvertError(err) if bbsErr != nil && bbsErr.GetType() == models.Error_Unrecoverable { select { case exitChan <- struct{}{}: default: } } }
func (h *DomainHandler) Domains(logger lager.Logger, w http.ResponseWriter, req *http.Request) { var err error logger = logger.Session("domains") response := &models.DomainsResponse{} response.Domains, err = h.db.Domains(logger) response.Error = models.ConvertError(err) writeResponse(w, response) exitIfUnrecoverable(logger, h.exitChan, response.Error) }
func (h *TaskHandler) CancelTask(logger lager.Logger, w http.ResponseWriter, req *http.Request) { logger = logger.Session("cancel-task") request := &models.TaskGuidRequest{} response := &models.TaskLifecycleResponse{} defer func() { exitIfUnrecoverable(logger, h.exitChan, response.Error) }() defer func() { writeResponse(w, response) }() err := parseRequest(logger, req, request) if err != nil { logger.Error("failed-parsing-request", err) response.Error = models.ConvertError(err) return } err = h.controller.CancelTask(logger, request.TaskGuid) response.Error = models.ConvertError(err) }
func (db *ETCDDB) StartActualLRP(logger lager.Logger, key *models.ActualLRPKey, instanceKey *models.ActualLRPInstanceKey, netInfo *models.ActualLRPNetInfo) (*models.ActualLRPGroup, *models.ActualLRPGroup, error) { logger = logger.WithData(lager.Data{ "actual_lrp_key": key, "actual_lrp_instance_key": instanceKey, "net_info": netInfo, }) lrp, prevIndex, err := db.rawActualLRPByProcessGuidAndIndex(logger, key.ProcessGuid, key.Index) bbsErr := models.ConvertError(err) if bbsErr != nil { if bbsErr.Type == models.Error_ResourceNotFound { lrp, err := db.createRunningActualLRP(logger, key, instanceKey, netInfo) return nil, &models.ActualLRPGroup{Instance: lrp}, err } logger.Error("failed-to-get-actual-lrp", err) return nil, nil, err } beforeActualLRP := *lrp if lrp.ActualLRPKey.Equal(key) && lrp.ActualLRPInstanceKey.Equal(instanceKey) && lrp.ActualLRPNetInfo.Equal(netInfo) && lrp.State == models.ActualLRPStateRunning { lrpGroup := &models.ActualLRPGroup{Instance: lrp} return lrpGroup, lrpGroup, nil } if !lrp.AllowsTransitionTo(key, instanceKey, models.ActualLRPStateRunning) { logger.Error("failed-to-transition-actual-lrp-to-started", nil) return nil, nil, models.ErrActualLRPCannotBeStarted } logger.Info("starting") defer logger.Info("completed") lrp.ModificationTag.Increment() lrp.State = models.ActualLRPStateRunning lrp.Since = db.clock.Now().UnixNano() lrp.ActualLRPInstanceKey = *instanceKey lrp.ActualLRPNetInfo = *netInfo lrp.PlacementError = "" lrpData, serializeErr := db.serializeModel(logger, lrp) if serializeErr != nil { return nil, nil, serializeErr } _, err = db.client.CompareAndSwap(ActualLRPSchemaPath(key.ProcessGuid, key.Index), lrpData, 0, prevIndex) if err != nil { logger.Error("failed", err) return nil, nil, models.ErrActualLRPCannotBeStarted } return &models.ActualLRPGroup{Instance: &beforeActualLRP}, &models.ActualLRPGroup{Instance: lrp}, nil }
func (r *actualLRPRetirer) RetireActualLRP(logger lager.Logger, processGuid string, index int32) error { var err error var cell *models.CellPresence logger = logger.Session("retire-actual-lrp", lager.Data{"process_guid": processGuid, "index": index}) for retryCount := 0; retryCount < models.RetireActualLRPRetryAttempts; retryCount++ { var lrpGroup *models.ActualLRPGroup lrpGroup, err = r.db.ActualLRPGroupByProcessGuidAndIndex(logger, processGuid, index) if err != nil { return err } lrp := lrpGroup.Instance if lrp == nil { return models.ErrResourceNotFound } switch lrp.State { case models.ActualLRPStateUnclaimed, models.ActualLRPStateCrashed: err = r.db.RemoveActualLRP(logger, lrp.ProcessGuid, lrp.Index, &lrp.ActualLRPInstanceKey) if err == nil { go r.actualHub.Emit(models.NewActualLRPRemovedEvent(lrpGroup)) } case models.ActualLRPStateClaimed, models.ActualLRPStateRunning: cell, err = r.serviceClient.CellById(logger, lrp.CellId) if err != nil { bbsErr := models.ConvertError(err) if bbsErr.Type == models.Error_ResourceNotFound { err = r.db.RemoveActualLRP(logger, lrp.ProcessGuid, lrp.Index, &lrp.ActualLRPInstanceKey) if err == nil { go r.actualHub.Emit(models.NewActualLRPRemovedEvent(lrpGroup)) } } return err } var client rep.Client client, err = r.repClientFactory.CreateClient(cell.RepAddress, cell.RepUrl) if err != nil { logger.Error("create-rep-client-failed", err) return err } err = client.StopLRPInstance(lrp.ActualLRPKey, lrp.ActualLRPInstanceKey) } if err == nil { return nil } logger.Error("retrying-failed-retire-of-actual-lrp", err, lager.Data{"attempt": retryCount + 1}) } return err }
func (h *TaskHandler) TaskByGuid(logger lager.Logger, w http.ResponseWriter, req *http.Request) { var err error logger = logger.Session("task-by-guid") request := &models.TaskByGuidRequest{} response := &models.TaskResponse{} defer func() { exitIfUnrecoverable(logger, h.exitChan, response.Error) }() defer func() { writeResponse(w, response) }() err = parseRequest(logger, req, request) if err != nil { logger.Error("failed-parsing-request", err) response.Error = models.ConvertError(err) return } response.Task, err = h.controller.TaskByGuid(logger, request.TaskGuid) response.Error = models.ConvertError(err) }
func (h *TaskHandler) DesireTask(logger lager.Logger, w http.ResponseWriter, req *http.Request) { var err error logger = logger.Session("desire-task") request := &models.DesireTaskRequest{} response := &models.TaskLifecycleResponse{} defer func() { exitIfUnrecoverable(logger, h.exitChan, response.Error) }() defer func() { writeResponse(w, response) }() err = parseRequest(logger, req, request) if err != nil { logger.Error("failed-parsing-request", err) response.Error = models.ConvertError(err) return } err = h.controller.DesireTask(logger, request.TaskDefinition, request.TaskGuid, request.Domain) response.Error = models.ConvertError(err) }
func (h *TaskHandler) CompleteTask(logger lager.Logger, w http.ResponseWriter, req *http.Request) { var err error logger = logger.Session("complete-task") request := &models.CompleteTaskRequest{} response := &models.TaskLifecycleResponse{} defer func() { exitIfUnrecoverable(logger, h.exitChan, response.Error) }() defer func() { writeResponse(w, response) }() err = parseRequest(logger, req, request) if err != nil { response.Error = models.ConvertError(err) logger.Error("failed-parsing-request", err) return } err = h.controller.CompleteTask(logger, request.TaskGuid, request.CellId, request.Failed, request.FailureReason, request.Result) response.Error = models.ConvertError(err) }
func (h *TaskHandler) StartTask(logger lager.Logger, w http.ResponseWriter, req *http.Request) { var err error logger = logger.Session("start-task") request := &models.StartTaskRequest{} response := &models.StartTaskResponse{} defer func() { exitIfUnrecoverable(logger, h.exitChan, response.Error) }() defer func() { writeResponse(w, response) }() err = parseRequest(logger, req, request) if err != nil { logger.Error("failed-parsing-request", err) response.Error = models.ConvertError(err) return } response.ShouldStart, err = h.controller.StartTask(logger, request.TaskGuid, request.CellId) response.Error = models.ConvertError(err) }
func (db *SQLDB) convertSQLError(err error) *models.Error { if err != nil { switch err.(type) { case *mysql.MySQLError: return db.convertMySQLError(err.(*mysql.MySQLError)) case *pq.Error: return db.convertPostgresError(err.(*pq.Error)) } } return models.ConvertError(err) }
func (db *ETCDDB) ActualLRPGroups(logger lager.Logger, filter models.ActualLRPFilter) ([]*models.ActualLRPGroup, error) { node, err := db.fetchRecursiveRaw(logger, ActualLRPSchemaRoot) bbsErr := models.ConvertError(err) if bbsErr != nil { if bbsErr.Type == models.Error_ResourceNotFound { return []*models.ActualLRPGroup{}, nil } return nil, err } if len(node.Nodes) == 0 { return []*models.ActualLRPGroup{}, nil } groups := []*models.ActualLRPGroup{} var workErr atomic.Value groupChan := make(chan []*models.ActualLRPGroup, len(node.Nodes)) wg := sync.WaitGroup{} logger.Debug("performing-deserialization-work") for _, node := range node.Nodes { node := node wg.Add(1) go func() { defer wg.Done() g, err := db.parseActualLRPGroups(logger, node, filter) if err != nil { workErr.Store(err) return } groupChan <- g }() } go func() { wg.Wait() close(groupChan) }() for g := range groupChan { groups = append(groups, g...) } if err, ok := workErr.Load().(error); ok { logger.Error("failed-performing-deserialization-work", err) return []*models.ActualLRPGroup{}, models.ErrUnknownError } logger.Debug("succeeded-performing-deserialization-work", lager.Data{"num_actual_lrp_groups": len(groups)}) return groups, nil }
func (h *CellHandler) Cells(logger lager.Logger, w http.ResponseWriter, req *http.Request) { var err error logger = logger.Session("cells") response := &models.CellsResponse{} cellSet, err := h.serviceClient.Cells(logger) cells := []*models.CellPresence{} for _, cp := range cellSet { cells = append(cells, cp) } response.Cells = cells response.Error = models.ConvertError(err) writeResponse(w, response) exitIfUnrecoverable(logger, h.exitChan, response.Error) }
func (h *EvacuationHandler) EvacuateClaimedActualLRP(logger lager.Logger, w http.ResponseWriter, req *http.Request) { logger = logger.Session("evacuate-claimed-actual-lrp") logger.Info("started") defer logger.Info("completed") request := &models.EvacuateClaimedActualLRPRequest{} response := &models.EvacuationResponse{} defer func() { exitIfUnrecoverable(logger, h.exitChan, response.Error) }() defer writeResponse(w, response) err := parseRequest(logger, req, request) if err != nil { logger.Error("failed-parsing-request", err) response.Error = models.ConvertError(err) response.KeepContainer = true return } beforeActualLRPGroup, err := h.actualLRPDB.ActualLRPGroupByProcessGuidAndIndex(logger, request.ActualLrpKey.ProcessGuid, request.ActualLrpKey.Index) if err == nil { err = h.db.RemoveEvacuatingActualLRP(logger, request.ActualLrpKey, request.ActualLrpInstanceKey) if err != nil { logger.Error("failed-removing-evacuating-actual-lrp", err) exitIfUnrecoverable(logger, h.exitChan, models.ConvertError(err)) } else { go h.actualHub.Emit(models.NewActualLRPRemovedEvent(beforeActualLRPGroup)) } } err = h.unclaimAndRequestAuction(logger, request.ActualLrpKey) bbsErr := models.ConvertError(err) if bbsErr != nil && bbsErr.Type != models.Error_ResourceNotFound { response.Error = bbsErr response.KeepContainer = true return } }
func (db *ETCDDB) desiredLRPs(logger lager.Logger, filter models.DesiredLRPFilter) ([]*models.DesiredLRP, guidSet, error) { root, err := db.fetchRecursiveRaw(logger, DesiredLRPComponentsSchemaRoot) bbsErr := models.ConvertError(err) if bbsErr != nil { if bbsErr.Type == models.Error_ResourceNotFound { return []*models.DesiredLRP{}, newGuidSet(), nil } return nil, newGuidSet(), err } if root.Nodes.Len() == 0 { return []*models.DesiredLRP{}, newGuidSet(), nil } var schedules map[string]*models.DesiredLRPSchedulingInfo var runs map[string]*models.DesiredLRPRunInfo var malformedInfos guidSet var malformedRunInfos guidSet var wg sync.WaitGroup for i := range root.Nodes { node := root.Nodes[i] switch node.Key { case DesiredLRPSchedulingInfoSchemaRoot: wg.Add(1) go func() { defer wg.Done() schedules, malformedInfos = db.deserializeScheduleInfos(logger, node.Nodes, filter) }() case DesiredLRPRunInfoSchemaRoot: wg.Add(1) go func() { defer wg.Done() runs, malformedRunInfos = db.deserializeRunInfos(logger, node.Nodes, filter) }() default: logger.Error("unexpected-etcd-key", nil, lager.Data{"key": node.Key}) } } wg.Wait() desiredLRPs := []*models.DesiredLRP{} for processGuid, schedule := range schedules { desired := models.NewDesiredLRP(*schedule, *runs[processGuid]) desiredLRPs = append(desiredLRPs, &desired) } malformedInfos.Merge(malformedRunInfos) return desiredLRPs, malformedInfos, nil }
func (db *ETCDDB) ActualLRPGroupsByProcessGuid(logger lager.Logger, processGuid string) ([]*models.ActualLRPGroup, error) { node, err := db.fetchRecursiveRaw(logger, ActualLRPProcessDir(processGuid)) bbsErr := models.ConvertError(err) if bbsErr != nil { if bbsErr.Type == models.Error_ResourceNotFound { return []*models.ActualLRPGroup{}, nil } return nil, err } if node.Nodes.Len() == 0 { return []*models.ActualLRPGroup{}, nil } return db.parseActualLRPGroups(logger, node, models.ActualLRPFilter{}) }