feat(system/upgrade): add upgrade banner [EE-4564] (#8046)

api/http/handler/status/handler.go

@@ -6,6 +6,7 @@ import (
 	"github.com/gorilla/mux"
 	httperror "github.com/portainer/libhttp/error"
 	portainer "github.com/portainer/portainer/api"
+	"github.com/portainer/portainer/api/dataservices"
 	"github.com/portainer/portainer/api/demo"
 	"github.com/portainer/portainer/api/http/security"
 )
@@ -13,21 +14,28 @@ import (
 // Handler is the HTTP handler used to handle status operations.
 type Handler struct {
 	*mux.Router
-	Status      *portainer.Status
+	status      *portainer.Status
+	dataStore   dataservices.DataStore
 	demoService *demo.Service
 }
 
 // NewHandler creates a handler to manage status operations.
-func NewHandler(bouncer *security.RequestBouncer, status *portainer.Status, demoService *demo.Service) *Handler {
+func NewHandler(bouncer *security.RequestBouncer, status *portainer.Status, demoService *demo.Service, dataStore dataservices.DataStore) *Handler {
 	h := &Handler{
 		Router:      mux.NewRouter(),
-		Status:      status,
+		dataStore:   dataStore,
 		demoService: demoService,
+		status:      status,
 	}
+
 	h.Handle("/status",
 		bouncer.PublicAccess(httperror.LoggerHandler(h.statusInspect))).Methods(http.MethodGet)
 	h.Handle("/status/version",
 		bouncer.AuthenticatedAccess(http.HandlerFunc(h.version))).Methods(http.MethodGet)
+	h.Handle("/status/nodes",
+		bouncer.AuthenticatedAccess(httperror.LoggerHandler(h.statusNodesCount))).Methods(http.MethodGet)
+	h.Handle("/status/system",
+		bouncer.AuthenticatedAccess(httperror.LoggerHandler(h.statusSystem))).Methods(http.MethodGet)
 
 	return h
 }

api/http/handler/status/status_inspect.go

@@ -24,7 +24,7 @@ type status struct {
 // @router /status [get]
 func (handler *Handler) statusInspect(w http.ResponseWriter, r *http.Request) *httperror.HandlerError {
 	return response.JSON(w, &status{
-		Status:          handler.Status,
+		Status:          handler.status,
 		DemoEnvironment: handler.demoService.Details(),
 	})
 }

api/http/handler/status/status_nodes_count.go

@@ -0,0 +1,42 @@
+package status
+
+import (
+	"net/http"
+
+	httperror "github.com/portainer/libhttp/error"
+	"github.com/portainer/libhttp/response"
+	statusutil "github.com/portainer/portainer/api/internal/nodes"
+	"github.com/portainer/portainer/api/internal/snapshot"
+)
+
+type nodesCountResponse struct {
+	Nodes int `json:"nodes"`
+}
+
+// @id statusNodesCount
+// @summary Retrieve the count of nodes
+// @description **Access policy**: authenticated
+// @security ApiKeyAuth
+// @security jwt
+// @tags status
+// @produce json
+// @success 200 {object} nodesCountResponse "Success"
+// @failure 500 "Server error"
+// @router /status/nodes [get]
+func (handler *Handler) statusNodesCount(w http.ResponseWriter, r *http.Request) *httperror.HandlerError {
+	endpoints, err := handler.dataStore.Endpoint().Endpoints()
+	if err != nil {
+		return httperror.InternalServerError("Failed to get environment list", err)
+	}
+
+	for i := range endpoints {
+		err = snapshot.FillSnapshotData(handler.dataStore, &endpoints[i])
+		if err != nil {
+			return httperror.InternalServerError("Unable to add snapshot data", err)
+		}
+	}
+
+	nodes := statusutil.NodesCount(endpoints)
+
+	return response.JSON(w, &nodesCountResponse{Nodes: nodes})
+}

api/http/handler/status/status_system.go

@@ -0,0 +1,60 @@
+package status
+
+import (
+	"net/http"
+
+	httperror "github.com/portainer/libhttp/error"
+	"github.com/portainer/libhttp/response"
+	"github.com/portainer/portainer/api/internal/endpointutils"
+	"github.com/portainer/portainer/api/platform"
+)
+
+type systemInfoResponse struct {
+	Platform    platform.ContainerPlatform `json:"platform"`
+	EdgeAgents  int                        `json:"edgeAgents"`
+	EdgeDevices int                        `json:"edgeDevices"`
+	Agents      int                        `json:"agents"`
+}
+
+// @id statusSystem
+// @summary Retrieve system info
+// @description **Access policy**: authenticated
+// @security ApiKeyAuth
+// @security jwt
+// @tags status
+// @produce json
+// @success 200 {object} systemInfoResponse "Success"
+// @failure 500 "Server error"
+// @router /status/system [get]
+func (handler *Handler) statusSystem(w http.ResponseWriter, r *http.Request) *httperror.HandlerError {
+	environments, err := handler.dataStore.Endpoint().Endpoints()
+	if err != nil {
+		return httperror.InternalServerError("Failed to get environment list", err)
+	}
+
+	agents := 0
+	edgeAgents := 0
+	edgeDevices := 0
+
+	for _, environment := range environments {
+		if endpointutils.IsAgentEndpoint(&environment) {
+			agents++
+		}
+
+		if endpointutils.IsEdgeEndpoint(&environment) {
+			edgeAgents++
+		}
+
+		if environment.IsEdgeDevice {
+			edgeDevices++
+		}
+
+	}
+
+	return response.JSON(w, &systemInfoResponse{
+		EdgeAgents:  edgeAgents,
+		EdgeDevices: edgeDevices,
+		Agents:      agents,
+		Platform:    platform.DetermineContainerPlatform(),
+	})
+}

api/http/server.go

@@ -252,7 +252,7 @@ func (server *Server) Start() error {
 	var teamMembershipHandler = teammemberships.NewHandler(requestBouncer)
 	teamMembershipHandler.DataStore = server.DataStore
 
-	var statusHandler = status.NewHandler(requestBouncer, server.Status, server.DemoService)
+	var statusHandler = status.NewHandler(requestBouncer, server.Status, server.DemoService, server.DataStore)
 
 	var templatesHandler = templates.NewHandler(requestBouncer)
 	templatesHandler.DataStore = server.DataStore

api/internal/nodes/nodes.go

@@ -0,0 +1,35 @@
+package status
+
+import (
+	portainer "github.com/portainer/portainer/api"
+)
+
+// NodesCount returns the total node number of all environments
+func NodesCount(endpoints []portainer.Endpoint) int {
+	nodes := 0
+	for _, env := range endpoints {
+		nodes += countNodes(&env)
+	}
+
+	return nodes
+}
+
+func countNodes(endpoint *portainer.Endpoint) int {
+	if len(endpoint.Snapshots) == 1 {
+		return max(endpoint.Snapshots[0].NodeCount, 1)
+	}
+
+	if len(endpoint.Kubernetes.Snapshots) == 1 {
+		return max(endpoint.Kubernetes.Snapshots[0].NodeCount, 1)
+	}
+
+	return 1
+}
+
+func max(a, b int) int {
+	if a > b {
+		return a
+	}
+
+	return b
+}

api/internal/snapshot/snapshot.go

@@ -124,8 +124,12 @@ func (service *Service) Create(snapshot portainer.Snapshot) error {
 }
 
 func (service *Service) FillSnapshotData(endpoint *portainer.Endpoint) error {
-	snapshot, err := service.dataStore.Snapshot().Snapshot(endpoint.ID)
-	if service.dataStore.IsErrObjectNotFound(err) {
+	return FillSnapshotData(service.dataStore, endpoint)
+}
+
+func FillSnapshotData(dataStore dataservices.DataStore, endpoint *portainer.Endpoint) error {
+	snapshot, err := dataStore.Snapshot().Snapshot(endpoint.ID)
+	if dataStore.IsErrObjectNotFound(err) {
 		endpoint.Snapshots = []portainer.DockerSnapshot{}
 		endpoint.Kubernetes.Snapshots = []portainer.KubernetesSnapshot{}
 

api/platform/platform.go

@@ -0,0 +1,44 @@
+package platform
+
+import "os"
+
+const (
+	PodmanMode            = "PODMAN"
+	KubernetesServiceHost = "KUBERNETES_SERVICE_HOST"
+	NomadJobName          = "NOMAD_JOB_NAME"
+)
+
+// ContainerPlatform represent the platform on which the container is running (Docker, Kubernetes, Nomad)
+type ContainerPlatform string
+
+const (
+	// PlatformDocker represent the Docker platform (Standalone/Swarm)
+	PlatformDocker = ContainerPlatform("Docker")
+	// PlatformKubernetes represent the Kubernetes platform
+	PlatformKubernetes = ContainerPlatform("Kubernetes")
+	// PlatformPodman represent the Podman platform (Standalone)
+	PlatformPodman = ContainerPlatform("Podman")
+	// PlatformNomad represent the Nomad platform (Standalone)
+	PlatformNomad = ContainerPlatform("Nomad")
+)
+
+// DetermineContainerPlatform will check for the existence of the PODMAN_MODE
+// or KUBERNETES_SERVICE_HOST environment variable to determine if
+// the container is running on Podman or inside the Kubernetes platform.
+// Defaults to Docker otherwise.
+func DetermineContainerPlatform() ContainerPlatform {
+	podmanModeEnvVar := os.Getenv(PodmanMode)
+	if podmanModeEnvVar == "1" {
+		return PlatformPodman
+	}
+	serviceHostKubernetesEnvVar := os.Getenv(KubernetesServiceHost)
+	if serviceHostKubernetesEnvVar != "" {
+		return PlatformKubernetes
+	}
+	nomadJobName := os.Getenv(NomadJobName)
+	if nomadJobName != "" {
+		return PlatformNomad
+	}
+
+	return PlatformDocker
+}

api/portainer.go

@@ -1499,10 +1499,12 @@ const (
 )
 
 const FeatureFlagEdgeRemoteUpdate Feature = "edgeRemoteUpdate"
+const FeatureFlagBEUpgrade = "beUpgrade"
 
 // List of supported features
 var SupportedFeatureFlags = []Feature{
 	FeatureFlagEdgeRemoteUpdate,
+	FeatureFlagBEUpgrade,
 }
 
 const (