func Update()

in aws-aps-workspace/cmd/resource/resource.go [138:241]
86 lines of code
15 McCabe index (conditional complexity)

func Update(req handler.Request, prevModel *Model, currentModel *Model) (handler.ProgressEvent, error) {
	// contract test: contract_read_without_create
	if currentModel.Arn == nil {
		return handler.ProgressEvent{
			OperationStatus:  handler.Failed,
			Message:          "Invalid Update: workspace ARN cannot be empty",
			HandlerErrorCode: cloudformation.HandlerErrorCodeNotFound,
		}, nil
	}

	client := internal.NewAPS(req.Session)

	_, workspaceID, err := internal.ParseARN(*currentModel.Arn)
	if err != nil {
		return handler.ProgressEvent{
			OperationStatus:  handler.Failed,
			Message:          "Invalid Read: invalid workspace ARN format",
			HandlerErrorCode: cloudformation.HandlerErrorCodeNotFound,
		}, nil
	}

	currentModel.WorkspaceId = aws.String(workspaceID)

	if arn, ok := req.CallbackContext[waitForWorkspaceStatusKey]; ok {
		currentModel.Arn = aws.String(arn.(string))

		evt, err := validateWorkspaceState(
			client,
			currentModel,
			prometheusservice.WorkspaceStatusCodeActive,
			messageUpdateComplete)
		if err != nil {
			return internal.NewFailedEvent(err)
		}

		if evt.OperationStatus == handler.InProgress {
			return evt, err
		}

		if !internal.StringDiffers(currentModel.AlertManagerDefinition, prevModel.AlertManagerDefinition) {
			return evt, err
		}

		return manageAlertManagerDefinition(currentModel, prevModel, client)
	}

	// AlertManagerDefinition is always updated last. As such we have to continue waiting after the Workspace is in ACTIVE state again
	if arn, ok := req.CallbackContext[waitForAlertManagerStatusActiveKey]; ok {
		currentModel.Arn = aws.String(arn.(string))

		return validateAlertManagerState(client,
			currentModel,
			prometheusservice.AlertManagerDefinitionStatusCodeActive,
			messageUpdateComplete)
	}

	if arn, ok := req.CallbackContext[waitForAlertManagerStatusDeleteKey]; ok {
		currentModel.Arn = aws.String(arn.(string))

		return validateAlertManagerDeleted(client,
			currentModel,
			messageUpdateComplete)
	}

	if internal.StringDiffers(currentModel.Alias, prevModel.Alias) {
		_, err = client.
			UpdateWorkspaceAlias(&prometheusservice.UpdateWorkspaceAliasInput{
				WorkspaceId: aws.String(workspaceID),
				Alias:       currentModel.Alias,
			})
		if err != nil {
			return internal.NewFailedEvent(err)
		}
	}

	toAdd, toRemove := internal.StringMapDifference(tagsToStringMap(currentModel.Tags), tagsToStringMap(prevModel.Tags))
	if len(toRemove) > 0 {
		_, err = client.UntagResource(&prometheusservice.UntagResourceInput{
			ResourceArn: currentModel.Arn,
			TagKeys:     toRemove,
		})
		if err != nil {
			return internal.NewFailedEvent(err)
		}
	}

	if len(toAdd) > 0 {
		_, err = client.TagResource(&prometheusservice.TagResourceInput{
			ResourceArn: currentModel.Arn,
			Tags:        toAdd,
		})
		if err != nil {
			return internal.NewFailedEvent(err)
		}
	}

	return handler.ProgressEvent{
		OperationStatus:      handler.InProgress,
		Message:              messageInProgress,
		ResourceModel:        currentModel,
		CallbackDelaySeconds: defaultCallbackSeconds,
		CallbackContext:      buildWaitForWorkspaceStatusCallbackContext(currentModel),
	}, nil
}