package edgestacks import ( "errors" "net/http" "strconv" httperror "github.com/portainer/libhttp/error" "github.com/portainer/libhttp/request" "github.com/portainer/libhttp/response" portainer "github.com/portainer/portainer/api" bolterrors "github.com/portainer/portainer/api/bolt/errors" "github.com/portainer/portainer/api/filesystem" "github.com/portainer/portainer/api/internal/edge" ) type updateEdgeStackPayload struct { StackFileContent string Version *int EdgeGroups []portainer.EdgeGroupID DeploymentType portainer.EdgeStackDeploymentType } func (payload *updateEdgeStackPayload) Validate(r *http.Request) error { if payload.StackFileContent == "" { return errors.New("Invalid stack file content") } if payload.EdgeGroups != nil && len(payload.EdgeGroups) == 0 { return errors.New("Edge Groups are mandatory for an Edge stack") } return nil } // @id EdgeStackUpdate // @summary Update an EdgeStack // @description **Access policy**: administrator // @tags edge_stacks // @security jwt // @accept json // @produce json // @param id path string true "EdgeStack Id" // @param body body updateEdgeStackPayload true "EdgeStack data" // @success 200 {object} portainer.EdgeStack // @failure 500 // @failure 400 // @failure 503 "Edge compute features are disabled" // @router /edge_stacks/{id} [put] func (handler *Handler) edgeStackUpdate(w http.ResponseWriter, r *http.Request) *httperror.HandlerError { stackID, err := request.RetrieveNumericRouteVariableValue(r, "id") if err != nil { return &httperror.HandlerError{http.StatusBadRequest, "Invalid stack identifier route variable", err} } stack, err := handler.DataStore.EdgeStack().EdgeStack(portainer.EdgeStackID(stackID)) if err == bolterrors.ErrObjectNotFound { return &httperror.HandlerError{http.StatusNotFound, "Unable to find a stack with the specified identifier inside the database", err} } else if err != nil { return &httperror.HandlerError{http.StatusInternalServerError, "Unable to find a stack with the specified identifier inside the database", err} } var payload updateEdgeStackPayload err = request.DecodeAndValidateJSONPayload(r, &payload) if err != nil { return &httperror.HandlerError{http.StatusBadRequest, "Invalid request payload", err} } relationConfig, err := fetchEndpointRelationsConfig(handler.DataStore) if err != nil { return &httperror.HandlerError{http.StatusInternalServerError, "Unable to retrieve environments relations config from database", err} } relatedEndpointIds, err := edge.EdgeStackRelatedEndpoints(stack.EdgeGroups, relationConfig.endpoints, relationConfig.endpointGroups, relationConfig.edgeGroups) if err != nil { return &httperror.HandlerError{http.StatusInternalServerError, "Unable to retrieve edge stack related environments from database", err} } if payload.EdgeGroups != nil { newRelated, err := edge.EdgeStackRelatedEndpoints(payload.EdgeGroups, relationConfig.endpoints, relationConfig.endpointGroups, relationConfig.edgeGroups) if err != nil { return &httperror.HandlerError{http.StatusInternalServerError, "Unable to retrieve edge stack related environments from database", err} } oldRelatedSet := EndpointSet(relatedEndpointIds) newRelatedSet := EndpointSet(newRelated) endpointsToRemove := map[portainer.EndpointID]bool{} for endpointID := range oldRelatedSet { if !newRelatedSet[endpointID] { endpointsToRemove[endpointID] = true } } for endpointID := range endpointsToRemove { relation, err := handler.DataStore.EndpointRelation().EndpointRelation(endpointID) if err != nil { return &httperror.HandlerError{http.StatusInternalServerError, "Unable to find environment relation in database", err} } delete(relation.EdgeStacks, stack.ID) err = handler.DataStore.EndpointRelation().UpdateEndpointRelation(endpointID, relation) if err != nil { return &httperror.HandlerError{http.StatusInternalServerError, "Unable to persist environment relation in database", err} } } endpointsToAdd := map[portainer.EndpointID]bool{} for endpointID := range newRelatedSet { if !oldRelatedSet[endpointID] { endpointsToAdd[endpointID] = true } } for endpointID := range endpointsToAdd { relation, err := handler.DataStore.EndpointRelation().EndpointRelation(endpointID) if err != nil { return &httperror.HandlerError{http.StatusInternalServerError, "Unable to find environment relation in database", err} } relation.EdgeStacks[stack.ID] = true err = handler.DataStore.EndpointRelation().UpdateEndpointRelation(endpointID, relation) if err != nil { return &httperror.HandlerError{http.StatusInternalServerError, "Unable to persist environment relation in database", err} } } stack.EdgeGroups = payload.EdgeGroups relatedEndpointIds = newRelated } if stack.DeploymentType != payload.DeploymentType { // deployment type was changed - need to delete the old file err = handler.FileService.RemoveDirectory(stack.ProjectPath) if err != nil { return &httperror.HandlerError{http.StatusInternalServerError, "Unable to clear old files", err} } stack.EntryPoint = "" stack.ManifestPath = "" stack.DeploymentType = payload.DeploymentType } stackFolder := strconv.Itoa(int(stack.ID)) if payload.DeploymentType == portainer.EdgeStackDeploymentCompose { if stack.EntryPoint == "" { stack.EntryPoint = filesystem.ComposeFileDefaultName } _, err = handler.FileService.StoreEdgeStackFileFromBytes(stackFolder, stack.EntryPoint, []byte(payload.StackFileContent)) if err != nil { return &httperror.HandlerError{http.StatusInternalServerError, "Unable to persist updated Compose file on disk", err} } err = handler.convertAndStoreKubeManifestIfNeeded(stack, relatedEndpointIds) if err != nil { return &httperror.HandlerError{http.StatusInternalServerError, "Unable to convert and persist updated Kubernetes manifest file on disk", err} } } else { if stack.ManifestPath == "" { stack.ManifestPath = filesystem.ManifestFileDefaultName } hasDockerEndpoint, err := hasDockerEndpoint(handler.DataStore.Endpoint(), relatedEndpointIds) if err != nil { return &httperror.HandlerError{http.StatusInternalServerError, "Unable to check for existence of docker environment", err} } if hasDockerEndpoint { return &httperror.HandlerError{http.StatusBadRequest, "Edge stack with docker environment cannot be deployed with kubernetes config", err} } _, err = handler.FileService.StoreEdgeStackFileFromBytes(stackFolder, stack.ManifestPath, []byte(payload.StackFileContent)) if err != nil { return &httperror.HandlerError{http.StatusInternalServerError, "Unable to persist updated Compose file on disk", err} } } if payload.Version != nil && *payload.Version != stack.Version { stack.Version = *payload.Version stack.Status = map[portainer.EndpointID]portainer.EdgeStackStatus{} } err = handler.DataStore.EdgeStack().UpdateEdgeStack(stack.ID, stack) if err != nil { return &httperror.HandlerError{http.StatusInternalServerError, "Unable to persist the stack changes inside the database", err} } return response.JSON(w, stack) } func EndpointSet(endpointIDs []portainer.EndpointID) map[portainer.EndpointID]bool { set := map[portainer.EndpointID]bool{} for _, endpointID := range endpointIDs { set[endpointID] = true } return set }