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() {
