func convertConsulError(err error) error { switch err.(type) { case consuladapter.KeyNotFoundError: return models.NewError(models.Error_ResourceNotFound, err.Error()) case consuladapter.PrefixNotFoundError: return models.NewError(models.Error_ResourceNotFound, err.Error()) default: return models.NewError(models.Error_UnknownError, err.Error()) } }
func (db *ETCDDB) createActualLRP(logger lager.Logger, desiredLRP *models.DesiredLRP, index int32) error { logger = logger.Session("create-actual-lrp") var err error if index >= desiredLRP.Instances { err = models.NewError(models.Error_InvalidRecord, "Index too large") logger.Error("actual-lrp-index-too-large", err, lager.Data{"actual_index": index, "desired_instances": desiredLRP.Instances}) return err } guid, err := uuid.NewV4() if err != nil { return err } actualLRP := &models.ActualLRP{ ActualLRPKey: models.NewActualLRPKey( desiredLRP.ProcessGuid, index, desiredLRP.Domain, ), State: models.ActualLRPStateUnclaimed, Since: db.clock.Now().UnixNano(), ModificationTag: models.ModificationTag{ Epoch: guid.String(), Index: 0, }, } err = db.createRawActualLRP(logger, actualLRP) if err != nil { return err } return nil }
func (c *client) do(request *http.Request, responseObject proto.Message) error { response, err := c.httpClient.Do(request) if err != nil { return err } defer func() { // don't worry about errors when closing the body _ = response.Body.Close() }() var parsedContentType string if contentType, ok := response.Header[ContentTypeHeader]; ok { parsedContentType, _, _ = mime.ParseMediaType(contentType[0]) } if routerError, ok := response.Header[XCfRouterErrorHeader]; ok { return models.NewError(models.Error_RouterError, routerError[0]) } if parsedContentType == ProtoContentType { return handleProtoResponse(response, responseObject) } else { return handleNonProtoResponse(response) } }
func parseRequestForDesireDesiredLRP_r0(logger lager.Logger, req *http.Request, request *models.DesireLRPRequest) error { data, err := ioutil.ReadAll(req.Body) if err != nil { logger.Error("failed-to-read-body", err) return models.ErrUnknownError } err = request.Unmarshal(data) if err != nil { logger.Error("failed-to-parse-request-body", err) return models.ErrBadRequest } request.DesiredLrp.Action.SetTimeoutMsFromDeprecatedTimeoutNs() request.DesiredLrp.Setup.SetTimeoutMsFromDeprecatedTimeoutNs() request.DesiredLrp.Monitor.SetTimeoutMsFromDeprecatedTimeoutNs() request.DesiredLrp.StartTimeoutMs = int64(request.DesiredLrp.DeprecatedStartTimeoutS * 1000) if err := request.Validate(); err != nil { logger.Error("invalid-request", err) return models.NewError(models.Error_InvalidRequest, err.Error()) } return nil }
func (db *SQLDB) serializeModel(logger lager.Logger, model format.Versioner) ([]byte, error) { encodedPayload, err := db.serializer.Marshal(logger, db.format, model) if err != nil { logger.Error("failed-to-serialize-model", err) return nil, models.NewError(models.Error_InvalidRecord, err.Error()) } return encodedPayload, nil }
func (db *SQLDB) deserializeModel(logger lager.Logger, data []byte, model format.Versioner) error { err := db.serializer.Unmarshal(logger, data, model) if err != nil { logger.Error("failed-to-deserialize-model", err) return models.NewError(models.Error_InvalidRecord, err.Error()) } return nil }
func handleProtoResponse(response *http.Response, responseObject proto.Message) error { if responseObject == nil { return models.NewError(models.Error_InvalidRequest, "responseObject cannot be nil") } buf, err := ioutil.ReadAll(response.Body) if err != nil { return models.NewError(models.Error_InvalidResponse, fmt.Sprint("failed to read body: ", err.Error())) } err = proto.Unmarshal(buf, responseObject) if err != nil { return models.NewError(models.Error_InvalidProtobufMessage, fmt.Sprintf("failed to unmarshal proto", err.Error())) } return nil }
func (db *ETCDDB) deserializeModel(logger lager.Logger, node *etcdclient.Node, model format.Versioner) error { // this is the number of desired instances err := db.serializer.Unmarshal(logger, []byte(node.Value), model) if err != nil { logger.Error("failed-to-deserialize-model", err) return models.NewError(models.Error_InvalidRecord, err.Error()) } return nil }
func (db *ETCDDB) unclaimActualLRPWithIndex( logger lager.Logger, lrp *models.ActualLRP, storeIndex uint64, actualLRPKey *models.ActualLRPKey, actualLRPInstanceKey *models.ActualLRPInstanceKey, ) (change stateChange, err error) { logger = logger.Session("unclaim-actual-lrp-with-index") defer logger.Debug("complete", lager.Data{"state_change": change, "error": err}) if !lrp.ActualLRPKey.Equal(actualLRPKey) { logger.Error("failed-actual-lrp-key-differs", models.ErrActualLRPCannotBeUnclaimed) return stateDidNotChange, models.ErrActualLRPCannotBeUnclaimed } if lrp.State == models.ActualLRPStateUnclaimed { logger.Info("already-unclaimed") return stateDidNotChange, nil } if !lrp.ActualLRPInstanceKey.Equal(actualLRPInstanceKey) { logger.Error("failed-actual-lrp-instance-key-differs", models.ErrActualLRPCannotBeUnclaimed) return stateDidNotChange, models.ErrActualLRPCannotBeUnclaimed } lrp.Since = db.clock.Now().UnixNano() lrp.State = models.ActualLRPStateUnclaimed lrp.ActualLRPInstanceKey = models.ActualLRPInstanceKey{} lrp.ActualLRPNetInfo = models.EmptyActualLRPNetInfo() lrp.ModificationTag.Increment() err = lrp.Validate() if err != nil { logger.Error("failed-to-validate-unclaimed-lrp", err) return stateDidNotChange, models.NewError(models.Error_InvalidRecord, err.Error()) } lrpData, serialErr := db.serializeModel(logger, lrp) if serialErr != nil { logger.Error("failed-to-marshal-unclaimed-lrp", serialErr) return stateDidNotChange, serialErr } _, err = db.client.CompareAndSwap(ActualLRPSchemaPath(actualLRPKey.ProcessGuid, actualLRPKey.Index), lrpData, 0, storeIndex) if err != nil { logger.Error("failed-to-compare-and-swap", err) return stateDidNotChange, models.ErrActualLRPCannotBeUnclaimed } logger.Debug("changed-to-unclaimed") return stateDidChange, nil }
func (db *serviceClient) CellById(logger lager.Logger, cellId string) (*models.CellPresence, error) { value, err := db.getAcquiredValue(CellSchemaPath(cellId)) if err != nil { return nil, convertConsulError(err) } presence := new(models.CellPresence) err = models.FromJSON(value, presence) if err != nil { return nil, models.NewError(models.Error_InvalidJSON, err.Error()) } return presence, nil }
func (db *ETCDDB) ClaimActualLRP(logger lager.Logger, processGuid string, index int32, instanceKey *models.ActualLRPInstanceKey) (*models.ActualLRPGroup, *models.ActualLRPGroup, error) { logger = logger.WithData(lager.Data{"process_guid": processGuid, "index": index, "actual_lrp_instance_key": instanceKey}) logger.Info("starting") lrp, prevIndex, err := db.rawActualLRPByProcessGuidAndIndex(logger, processGuid, index) if err != nil { logger.Error("failed", err) return nil, nil, err } beforeActualLRP := *lrp if !lrp.AllowsTransitionTo(&lrp.ActualLRPKey, instanceKey, models.ActualLRPStateClaimed) { return nil, nil, models.ErrActualLRPCannotBeClaimed } if lrp.State == models.ActualLRPStateClaimed && lrp.ActualLRPInstanceKey.Equal(instanceKey) { return &models.ActualLRPGroup{Instance: &beforeActualLRP}, &models.ActualLRPGroup{Instance: lrp}, nil } lrp.PlacementError = "" lrp.State = models.ActualLRPStateClaimed lrp.ActualLRPInstanceKey = *instanceKey lrp.ActualLRPNetInfo = models.ActualLRPNetInfo{} lrp.ModificationTag.Increment() lrp.Since = db.clock.Now().UnixNano() err = lrp.Validate() if err != nil { logger.Error("failed", err) return nil, nil, models.NewError(models.Error_InvalidRecord, err.Error()) } lrpData, serializeErr := db.serializeModel(logger, lrp) if serializeErr != nil { return nil, nil, serializeErr } _, err = db.client.CompareAndSwap(ActualLRPSchemaPath(processGuid, index), lrpData, 0, prevIndex) if err != nil { logger.Error("compare-and-swap-failed", err) return nil, nil, models.ErrActualLRPCannotBeClaimed } logger.Info("succeeded") return &models.ActualLRPGroup{Instance: &beforeActualLRP}, &models.ActualLRPGroup{Instance: lrp}, nil }
func parseRequest(logger lager.Logger, req *http.Request, request MessageValidator) error { data, err := ioutil.ReadAll(req.Body) if err != nil { logger.Error("failed-to-read-body", err) return models.ErrUnknownError } err = request.Unmarshal(data) if err != nil { logger.Error("failed-to-parse-request-body", err) return models.ErrBadRequest } if err := request.Validate(); err != nil { logger.Error("invalid-request", err) return models.NewError(models.Error_InvalidRequest, err.Error()) } return nil }
func parseRequestForDesireTask_r0(logger lager.Logger, req *http.Request, request *models.DesireTaskRequest) error { data, err := ioutil.ReadAll(req.Body) if err != nil { logger.Error("failed-to-read-body", err) return models.ErrUnknownError } err = request.Unmarshal(data) if err != nil { logger.Error("failed-to-parse-request-body", err) return models.ErrBadRequest } request.TaskDefinition.Action.SetTimeoutMsFromDeprecatedTimeoutNs() if err := request.Validate(); err != nil { logger.Error("invalid-request", err) return models.NewError(models.Error_InvalidRequest, err.Error()) } return nil }
func parseRequestForDesireDesiredLRP_r1(logger lager.Logger, req *http.Request, request *models.DesireLRPRequest) error { data, err := ioutil.ReadAll(req.Body) if err != nil { logger.Error("failed-to-read-body", err) return models.ErrUnknownError } err = request.Unmarshal(data) if err != nil { logger.Error("failed-to-parse-request-body", err) return models.ErrBadRequest } for i, mount := range request.DesiredLrp.VolumeMounts { request.DesiredLrp.VolumeMounts[i] = mount.VersionUpToV1() } if err := request.Validate(); err != nil { logger.Error("invalid-request", err) return models.NewError(models.Error_InvalidRequest, err.Error()) } return nil }
func handleNonProtoResponse(response *http.Response) error { if response.StatusCode > 299 { return models.NewError(models.Error_InvalidResponse, fmt.Sprintf("Invalid Response with status code: %d", response.StatusCode)) } return nil }
Context("when the task has a completion callback URL", func() { BeforeEach(func() { Expect(taskDB.ResolvingTaskCallCount()).To(Equal(0)) }) It("marks the task as resolving", func() { statusCodes <- 200 Eventually(taskDB.ResolvingTaskCallCount).Should(Equal(1)) _, actualGuid := taskDB.ResolvingTaskArgsForCall(0) Expect(actualGuid).To(Equal("the-task-guid")) }) Context("when marking the task as resolving fails", func() { BeforeEach(func() { taskDB.ResolvingTaskReturns(models.NewError(models.Error_UnknownError, "failed to resolve task")) }) It("does not make a request to the task's callback URL", func() { Consistently(fakeServer.ReceivedRequests, 0.25).Should(BeEmpty()) }) }) Context("when marking the task as resolving succeeds", func() { It("POSTs to the task's callback URL", func() { statusCodes <- 200 Eventually(fakeServer.ReceivedRequests).Should(HaveLen(1)) }) Context("when the request succeeds", func() { BeforeEach(func() {