feat(system): upgrade on swarm [EE-5848] (#11728)

Co-authored-by: Chaim Lev-Ari <chaim.levi-ari@portainer.io>
Co-authored-by: LP B <xAt0mZ@users.noreply.github.com>

api/http/handler/stacks/stack_start.go

@@ -161,7 +161,7 @@ func (handler *Handler) startStack(
 			return handler.StackDeployer.StartRemoteComposeStack(stack, endpoint, filteredRegistries)
 		}
 
-		return handler.ComposeStackManager.Up(context.TODO(), stack, endpoint, false)
+		return handler.ComposeStackManager.Up(context.TODO(), stack, endpoint, portainer.ComposeUpOptions{})
 	case portainer.DockerSwarmStack:
 		stack.Name = handler.SwarmStackManager.NormalizeStackName(stack.Name)
 

api/http/handler/system/handler.go

@@ -7,6 +7,7 @@ import (
 	"github.com/portainer/portainer/api/dataservices"
 	"github.com/portainer/portainer/api/http/security"
 	"github.com/portainer/portainer/api/internal/upgrade"
+	"github.com/portainer/portainer/api/platform"
 	httperror "github.com/portainer/portainer/pkg/libhttp/error"
 
 	"github.com/gorilla/mux"
@@ -15,22 +16,25 @@ import (
 // Handler is the HTTP handler used to handle status operations.
 type Handler struct {
 	*mux.Router
-	status         *portainer.Status
-	dataStore      dataservices.DataStore
-	upgradeService upgrade.Service
+	status          *portainer.Status
+	dataStore       dataservices.DataStore
+	upgradeService  upgrade.Service
+	platformService platform.Service
 }
 
 // NewHandler creates a handler to manage status operations.
 func NewHandler(bouncer security.BouncerService,
 	status *portainer.Status,
 	dataStore dataservices.DataStore,
+	platformService platform.Service,
 	upgradeService upgrade.Service) *Handler {
 
 	h := &Handler{
-		Router:         mux.NewRouter(),
-		dataStore:      dataStore,
-		status:         status,
-		upgradeService: upgradeService,
+		Router:          mux.NewRouter(),
+		dataStore:       dataStore,
+		status:          status,
+		upgradeService:  upgradeService,
+		platformService: platformService,
 	}
 
 	router := h.PathPrefix("/system").Subrouter()

api/http/handler/system/system_info.go

@@ -42,12 +42,11 @@ func (handler *Handler) systemInfo(w http.ResponseWriter, r *http.Request) *http
 		if endpointutils.IsEdgeEndpoint(&environment) {
 			edgeAgents++
 		}
-
 	}
 
-	platform, err := plf.DetermineContainerPlatform()
+	platform, err := handler.platformService.GetPlatform()
 	if err != nil {
-		return httperror.InternalServerError("Unable to determine container platform", err)
+		return httperror.InternalServerError("Failed to get platform", err)
 	}
 
 	return response.JSON(w, &systemInfoResponse{

api/http/handler/system/system_upgrade.go

@@ -4,8 +4,6 @@ import (
 	"net/http"
 	"regexp"
 
-	portainer "github.com/portainer/portainer/api"
-	"github.com/portainer/portainer/api/platform"
 	httperror "github.com/portainer/portainer/pkg/libhttp/error"
 	"github.com/portainer/portainer/pkg/libhttp/request"
 	"github.com/portainer/portainer/pkg/libhttp/response"
@@ -31,12 +29,6 @@ func (payload *systemUpgradePayload) Validate(r *http.Request) error {
 	return nil
 }
 
-var platformToEndpointType = map[platform.ContainerPlatform]portainer.EndpointType{
-	platform.PlatformDockerStandalone: portainer.DockerEnvironment,
-	platform.PlatformDockerSwarm:      portainer.DockerEnvironment,
-	platform.PlatformKubernetes:       portainer.KubernetesLocalEnvironment,
-}
-
 // @id systemUpgrade
 // @summary Upgrade Portainer to BE
 // @description Upgrade Portainer to BE
@@ -51,40 +43,20 @@ func (handler *Handler) systemUpgrade(w http.ResponseWriter, r *http.Request) *h
 		return httperror.BadRequest("Invalid request payload", err)
 	}
 
-	environment, err := handler.guessLocalEndpoint()
+	environment, err := handler.platformService.GetLocalEnvironment()
 	if err != nil {
-		return httperror.InternalServerError("Failed to guess local endpoint", err)
+		return httperror.InternalServerError("Failed to get local environment", err)
 	}
 
-	err = handler.upgradeService.Upgrade(environment, payload.License)
+	platform, err := handler.platformService.GetPlatform()
+	if err != nil {
+		return httperror.InternalServerError("Failed to get platform", err)
+	}
+
+	err = handler.upgradeService.Upgrade(platform, environment, payload.License)
 	if err != nil {
 		return httperror.InternalServerError("Failed to upgrade Portainer", err)
 	}
 
 	return response.Empty(w)
 }
-
-func (handler *Handler) guessLocalEndpoint() (*portainer.Endpoint, error) {
-	platform, err := platform.DetermineContainerPlatform()
-	if err != nil {
-		return nil, errors.Wrap(err, "failed to determine container platform")
-	}
-
-	endpointType, ok := platformToEndpointType[platform]
-	if !ok {
-		return nil, errors.New("failed to determine endpoint type")
-	}
-
-	endpoints, err := handler.dataStore.Endpoint().Endpoints()
-	if err != nil {
-		return nil, errors.Wrap(err, "failed to retrieve endpoints")
-	}
-
-	for _, endpoint := range endpoints {
-		if endpoint.Type == endpointType {
-			return &endpoint, nil
-		}
-	}
-
-	return nil, errors.New("failed to find local endpoint")
-}

api/http/handler/system/version_test.go

@@ -39,7 +39,7 @@ func Test_getSystemVersion(t *testing.T) {
 	apiKeyService := apikey.NewAPIKeyService(store.APIKeyRepository(), store.User())
 	requestBouncer := security.NewRequestBouncer(store, jwtService, apiKeyService)
 
-	h := NewHandler(requestBouncer, &portainer.Status{}, store, nil)
+	h := NewHandler(requestBouncer, &portainer.Status{}, store, nil, nil)
 
 	// generate standard and admin user tokens
 	jwt, _, _ := jwtService.GenerateToken(&portainer.TokenData{ID: adminUser.ID, Username: adminUser.Username, Role: adminUser.Role})

api/http/server.go

@@ -65,6 +65,7 @@ import (
 	k8s "github.com/portainer/portainer/api/kubernetes"
 	"github.com/portainer/portainer/api/kubernetes/cli"
 	"github.com/portainer/portainer/api/pendingactions"
+	"github.com/portainer/portainer/api/platform"
 	"github.com/portainer/portainer/api/scheduler"
 	"github.com/portainer/portainer/api/stacks/deployments"
 	"github.com/portainer/portainer/pkg/libhelm"
@@ -111,6 +112,7 @@ type Server struct {
 	UpgradeService              upgrade.Service
 	AdminCreationDone           chan struct{}
 	PendingActionsService       *pendingactions.PendingActionsService
+	PlatformService             platform.Service
 }
 
 // Start starts the HTTP server
@@ -265,6 +267,7 @@ func (server *Server) Start() error {
 	var systemHandler = system.NewHandler(requestBouncer,
 		server.Status,
 		server.DataStore,
+		server.PlatformService,
 		server.UpgradeService)
 
 	var templatesHandler = templates.NewHandler(requestBouncer)