fix(compose): fix support for ECR BE-11392 (#150)

Co-authored-by: andres-portainer <andres-portainer@users.noreply.github.com>

.air.toml

@@ -1,52 +0,0 @@
-root = "."
-testdata_dir = "testdata"
-tmp_dir = ".tmp"
-
-[build]
-  args_bin = []
-  bin = "./dist/portainer"
-  cmd = "SKIP_GO_GET=true make build-server"
-  delay = 1000
-  exclude_dir = []
-  exclude_file = []
-  exclude_regex = ["_test.go"]
-  exclude_unchanged = false
-  follow_symlink = false
-  full_bin = "./dist/portainer --log-level=DEBUG"
-  include_dir = ["api"]
-  include_ext = ["go"]
-  include_file = []
-  kill_delay = "0s"
-  log = "build-errors.log"
-  poll = false
-  poll_interval = 0
-  post_cmd = []
-  pre_cmd = []
-  rerun = false
-  rerun_delay = 500
-  send_interrupt = false
-  stop_on_error = false
-
-[color]
-  app = ""
-  build = "yellow"
-  main = "magenta"
-  runner = "green"
-  watcher = "cyan"
-
-[log]
-  main_only = false
-  silent = false
-  time = false
-
-[misc]
-  clean_on_exit = false
-
-[proxy]
-  app_port = 0
-  enabled = false
-  proxy_port = 0
-
-[screen]
-  clear_on_rebuild = false
-  keep_scroll = true

.github/ISSUE_TEMPLATE/bug_report.yml

@@ -2,17 +2,16 @@ name: Bug Report
 description: Create a report to help us improve.
 labels: kind/bug,bug/need-confirmation
 body:
+
   - type: markdown
     attributes:
       value: |
         # Welcome!
-
+        
         The issue tracker is for reporting bugs. If you have an [idea for a new feature](https://github.com/orgs/portainer/discussions/categories/ideas) or a [general question about Portainer](https://github.com/orgs/portainer/discussions/categories/help) please post in our [GitHub Discussions](https://github.com/orgs/portainer/discussions).
-
+        
         You can also ask for help in our [community Slack channel](https://join.slack.com/t/portainer/shared_invite/zt-txh3ljab-52QHTyjCqbe5RibC2lcjKA).
-
-        Please note that we only provide support for current versions of Portainer. You can find a list of supported versions in our [lifecycle policy](https://docs.portainer.io/start/lifecycle).
-
+        
         **DO NOT FILE ISSUES FOR GENERAL SUPPORT QUESTIONS**.
 
   - type: checkboxes
@@ -44,7 +43,7 @@ body:
   - type: textarea
     attributes:
       label: Problem Description
-      description: A clear and concise description of what the bug is.
+      description: A clear and concise description of what the bug is. 
     validations:
       required: true
 
@@ -70,7 +69,7 @@ body:
         1. Go to '...'
         2. Click on '....'
         3. Scroll down to '....'
-        4. See error
+        4. See error   
     validations:
       required: true
 
@@ -91,45 +90,35 @@ body:
   - type: dropdown
     attributes:
       label: Portainer version
-      description: We only provide support for current versions of Portainer as per the lifecycle policy linked above. If you are on an older version of Portainer we recommend [updating first](https://docs.portainer.io/start/upgrade) in case your bug has already been fixed.
+      description: We only provide support for the most recent version of Portainer and the previous 3 versions. If you are on an older version of Portainer we recommend [upgrading first](https://docs.portainer.io/start/upgrade) in case your bug has already been fixed.
       multiple: false
       options:
-        - '2.32.0'
-        - '2.31.3'
-        - '2.31.2'
-        - '2.31.1'
-        - '2.31.0'
-        - '2.30.1'
-        - '2.30.0'
-        - '2.29.2'
-        - '2.29.1'
-        - '2.29.0'
-        - '2.28.1'
-        - '2.28.0'
-        - '2.27.9'
-        - '2.27.8'
-        - '2.27.7'
-        - '2.27.6'
-        - '2.27.5'
-        - '2.27.4'
-        - '2.27.3'
-        - '2.27.2'
-        - '2.27.1'
-        - '2.27.0'
-        - '2.26.1'
-        - '2.26.0'
-        - '2.25.1'
-        - '2.25.0'
-        - '2.24.1'
-        - '2.24.0'
         - '2.23.0'
         - '2.22.0'
-        - '2.21.5'
         - '2.21.4'
         - '2.21.3'
         - '2.21.2'
         - '2.21.1'
         - '2.21.0'
+        - '2.20.3'
+        - '2.20.2'
+        - '2.20.1'
+        - '2.20.0'
+        - '2.19.5'
+        - '2.19.4'
+        - '2.19.3'
+        - '2.19.2'
+        - '2.19.1'
+        - '2.19.0'
+        - '2.18.4'
+        - '2.18.3'
+        - '2.18.2'
+        - '2.18.1'
+        - '2.17.1'
+        - '2.17.0'
+        - '2.16.2'
+        - '2.16.1'
+        - '2.16.0'
     validations:
       required: true
 
@@ -167,7 +156,7 @@ body:
   - type: input
     attributes:
       label: Browser
-      description: |
+      description: | 
         Enter your browser and version. Example: Google Chrome 114.0
     validations:
       required: false

.godir

@@ -0,0 +1 @@
+portainer

.golangci.yaml

@@ -1,59 +1,42 @@
-version: "2"
 linters:
-  default: none
+  # Disable all linters, the defaults don't pass on our code yet
+  disable-all: true
+
+  # Enable these for now
   enable:
-    - bodyclose
-    - copyloopvar
+    - unused
     - depguard
-    - errorlint
-    - forbidigo
+    - gosimple
     - govet
-    - ineffassign
+    - errorlint
+    - copyloopvar
     - intrange
     - perfsprint
-    - staticcheck
-    - unused
-  settings:
-    staticcheck:
-      checks: ["all", "-ST1003", "-ST1005", "-ST1016", "-SA1019", "-QF1003"]
-    depguard:
-      rules:
-        main:
-          files:
-            - '!**/*_test.go'
-            - '!**/base.go'
-            - '!**/base_tx.go'
-          deny:
-            - pkg: encoding/json
-              desc: use github.com/segmentio/encoding/json
-            - pkg: golang.org/x/exp
-              desc: exp is not allowed
-            - pkg: github.com/portainer/libcrypto
-              desc: use github.com/portainer/portainer/pkg/libcrypto
-            - pkg: github.com/portainer/libhttp
-              desc: use github.com/portainer/portainer/pkg/libhttp
-    forbidigo:
-      forbid:
-        - pattern: ^tls\.Config$
-          msg: Use crypto.CreateTLSConfiguration() instead
-        - pattern: ^tls\.Config\.(InsecureSkipVerify|MinVersion|MaxVersion|CipherSuites|CurvePreferences)$
-          msg: Do not set this field directly, use crypto.CreateTLSConfiguration() instead
-      analyze-types: true
-  exclusions:
-    generated: lax
-    presets:
-      - comments
-      - common-false-positives
-      - legacy
-      - std-error-handling
-    paths:
-      - third_party$
-      - builtin$
-      - examples$
-formatters:
-  exclusions:
-    generated: lax
-    paths:
-      - third_party$
-      - builtin$
-      - examples$
+
+linters-settings:
+  depguard:
+    rules:
+      main:
+        deny:
+          - pkg: 'encoding/json'
+            desc: 'use github.com/segmentio/encoding/json'
+          - pkg: 'github.com/sirupsen/logrus'
+            desc: 'logging is allowed only by github.com/rs/zerolog'
+          - pkg: 'golang.org/x/exp'
+            desc: 'exp is not allowed'
+          - pkg: 'github.com/portainer/libcrypto'
+            desc: 'use github.com/portainer/portainer/pkg/libcrypto'
+          - pkg: 'github.com/portainer/libhttp'
+            desc: 'use github.com/portainer/portainer/pkg/libhttp'
+        files:
+          - '!**/*_test.go'
+          - '!**/base.go'
+          - '!**/base_tx.go'
+
+# errorlint is causing a typecheck error for some reason. The go compiler will report these
+# anyway, so ignore them from the linter
+issues:
+  exclude-rules:
+    - path: ./
+      linters:
+        - typecheck

Makefile

@@ -17,13 +17,11 @@ GOTESTSUM=go run gotest.tools/gotestsum@latest
 
 
 ##@ Building
-.PHONY: all init-dist build-storybook build build-client build-server build-image devops
+.PHONY: init-dist build-storybook build build-client build-server build-image devops
 init-dist:
 	@mkdir -p dist
 
-all: tidy deps build-server build-client ## Build the client, server and download external dependancies (doesn't build an image)
-
-build-all: all ## Alias for the 'all' target (used by CI)
+build-all: deps build-server build-client ## Build the client, server and download external dependancies (doesn't build an image)
 
 build-client: init-dist ## Build the client
 	export NODE_ENV=$(ENV) && yarn build --config $(WEBPACK_CONFIG)
@@ -52,7 +50,7 @@ client-deps: ## Install client dependencies
 	yarn
 
 tidy: ## Tidy up the go.mod file
-	@go mod tidy
+	cd api && go mod tidy
 
 
 ##@ Cleanup
@@ -67,10 +65,10 @@ clean: ## Remove all build and download artifacts
 test: test-server test-client ## Run all tests
 
 test-client: ## Run client tests
-	yarn test $(ARGS) --coverage
+	yarn test $(ARGS)
 
 test-server:	## Run server tests
-	$(GOTESTSUM) --format pkgname-and-test-fails --format-hide-empty-pkg --hide-summary skipped -- -cover -covermode=atomic -coverprofile=coverage.out ./...
+	$(GOTESTSUM) --format pkgname-and-test-fails --format-hide-empty-pkg --hide-summary skipped -- -cover  ./...
 
 ##@ Dev
 .PHONY: dev dev-client dev-server

README.md

@@ -8,9 +8,9 @@ Portainer consists of a single container that can run on any cluster. It can be
 
 **Portainer Business Edition** builds on the open-source base and includes a range of advanced features and functions (like RBAC and Support) that are specific to the needs of business users.
 
-- [Compare Portainer CE and Compare Portainer BE](https://www.portainer.io/features)
+- [Compare Portainer CE and Compare Portainer BE](https://portainer.io/products)
 - [Take3 – get 3 free nodes of Portainer Business for as long as you want them](https://www.portainer.io/take-3)
-- [Portainer BE install guide](https://academy.portainer.io/install/)
+- [Portainer BE install guide](https://install.portainer.io)
 
 ## Latest Version
 
@@ -20,19 +20,22 @@ Portainer CE is updated regularly. We aim to do an update release every couple o
 
 ## Getting started
 
-- [Deploy Portainer](https://docs.portainer.io/start/install-ce)
+- [Deploy Portainer](https://docs.portainer.io/start/install)
 - [Documentation](https://docs.portainer.io)
 - [Contribute to the project](https://docs.portainer.io/contribute/contribute)
 
 ## Features & Functions
 
-View [this](https://www.portainer.io/features) table to see all of the Portainer CE functionality and compare to Portainer Business.
+View [this](https://www.portainer.io/products) table to see all of the Portainer CE functionality and compare to Portainer Business.
+
+- [Portainer CE for Docker / Docker Swarm](https://www.portainer.io/solutions/docker)
+- [Portainer CE for Kubernetes](https://www.portainer.io/solutions/kubernetes-ui)
 
 ## Getting help
 
 Portainer CE is an open source project and is supported by the community. You can buy a supported version of Portainer at portainer.io
 
-Learn more about Portainer's community support channels [here.](https://www.portainer.io/resources/get-help/get-support)
+Learn more about Portainer's community support channels [here.](https://www.portainer.io/get-support-for-portainer)
 
 - Issues: https://github.com/portainer/portainer/issues
 - Slack (chat): [https://portainer.io/slack](https://portainer.io/slack)
@@ -50,13 +53,13 @@ You can join the Portainer Community by visiting [https://www.portainer.io/join-
 
 ## Work for us
 
-If you are a developer, and our code in this repo makes sense to you, we would love to hear from you. We are always on the hunt for awesome devs, either freelance or employed. Drop us a line to success@portainer.io with your details and/or visit our [careers page](https://apply.workable.com/portainer/).
+If you are a developer, and our code in this repo makes sense to you, we would love to hear from you. We are always on the hunt for awesome devs, either freelance or employed. Drop us a line to info@portainer.io with your details and/or visit our [careers page](https://portainer.io/careers).
 
 ## Privacy
 
 **To make sure we focus our development effort in the right places we need to know which features get used most often. To give us this information we use [Matomo Analytics](https://matomo.org/), which is hosted in Germany and is fully GDPR compliant.**
 
-When Portainer first starts, you are given the option to DISABLE analytics. If you **don't** choose to disable it, we collect anonymous usage as per [our privacy policy](https://www.portainer.io/legal/privacy-policy). **Please note**, there is no personally identifiable information sent or stored at any time and we only use the data to help us improve Portainer.
+When Portainer first starts, you are given the option to DISABLE analytics. If you **don't** choose to disable it, we collect anonymous usage as per [our privacy policy](https://www.portainer.io/privacy-policy). **Please note**, there is no personally identifiable information sent or stored at any time and we only use the data to help us improve Portainer.
 
 ## Limitations
 

api/agent/version.go

@@ -16,7 +16,7 @@ import (
 // GetAgentVersionAndPlatform returns the agent version and platform
 //
 // it sends a ping to the agent and parses the version and platform from the headers
-func GetAgentVersionAndPlatform(endpointUrl string, tlsConfig *tls.Config) (portainer.AgentPlatform, string, error) { //nolint:forbidigo
+func GetAgentVersionAndPlatform(endpointUrl string, tlsConfig *tls.Config) (portainer.AgentPlatform, string, error) {
 	httpCli := &http.Client{
 		Timeout: 3 * time.Second,
 	}

api/archive/zip.go

@@ -2,6 +2,7 @@ package archive
 
 import (
 	"archive/zip"
+	"bytes"
 	"fmt"
 	"io"
 	"os"
@@ -11,6 +12,50 @@ import (
 	"github.com/pkg/errors"
 )
 
+// UnzipArchive will unzip an archive from bytes into the dest destination folder on disk
+func UnzipArchive(archiveData []byte, dest string) error {
+	zipReader, err := zip.NewReader(bytes.NewReader(archiveData), int64(len(archiveData)))
+	if err != nil {
+		return err
+	}
+
+	for _, zipFile := range zipReader.File {
+		err := extractFileFromArchive(zipFile, dest)
+		if err != nil {
+			return err
+		}
+	}
+
+	return nil
+}
+
+func extractFileFromArchive(file *zip.File, dest string) error {
+	f, err := file.Open()
+	if err != nil {
+		return err
+	}
+	defer f.Close()
+
+	data, err := io.ReadAll(f)
+	if err != nil {
+		return err
+	}
+
+	fpath := filepath.Join(dest, file.Name)
+
+	outFile, err := os.OpenFile(fpath, os.O_WRONLY|os.O_CREATE|os.O_TRUNC, file.Mode())
+	if err != nil {
+		return err
+	}
+
+	_, err = io.Copy(outFile, bytes.NewReader(data))
+	if err != nil {
+		return err
+	}
+
+	return outFile.Close()
+}
+
 // UnzipFile will decompress a zip archive, moving all files and folders
 // within the zip file (parameter 1) to an output directory (parameter 2).
 func UnzipFile(src string, dest string) error {
@@ -31,11 +76,11 @@ func UnzipFile(src string, dest string) error {
 		if f.FileInfo().IsDir() {
 			// Make Folder
 			os.MkdirAll(p, os.ModePerm)
-
 			continue
 		}
 
-		if err := unzipFile(f, p); err != nil {
+		err = unzipFile(f, p)
+		if err != nil {
 			return err
 		}
 	}
@@ -48,20 +93,20 @@ func unzipFile(f *zip.File, p string) error {
 	if err := os.MkdirAll(filepath.Dir(p), os.ModePerm); err != nil {
 		return errors.Wrapf(err, "unzipFile: can't make a path %s", p)
 	}
-
 	outFile, err := os.OpenFile(p, os.O_WRONLY|os.O_CREATE|os.O_TRUNC, f.Mode())
 	if err != nil {
 		return errors.Wrapf(err, "unzipFile: can't create file %s", p)
 	}
 	defer outFile.Close()
-
 	rc, err := f.Open()
 	if err != nil {
 		return errors.Wrapf(err, "unzipFile: can't open zip file %s in the archive", f.Name)
 	}
 	defer rc.Close()
 
-	if _, err = io.Copy(outFile, rc); err != nil {
+	_, err = io.Copy(outFile, rc)
+
+	if err != nil {
 		return errors.Wrapf(err, "unzipFile: can't copy an archived file content")
 	}
 

api/backup/backup.go

@@ -21,7 +21,6 @@ const rwxr__r__ os.FileMode = 0o744
 
 var filesToBackup = []string{
 	"certs",
-	"chisel",
 	"compose",
 	"config.json",
 	"custom_templates",
@@ -31,13 +30,40 @@ var filesToBackup = []string{
 	"portainer.key",
 	"portainer.pub",
 	"tls",
+	"chisel",
 }
 
 // Creates a tar.gz system archive and encrypts it if password is not empty. Returns a path to the archive file.
 func CreateBackupArchive(password string, gate *offlinegate.OfflineGate, datastore dataservices.DataStore, filestorePath string) (string, error) {
-	backupDirPath, err := backupDatabaseAndFilesystem(gate, datastore, filestorePath)
-	if err != nil {
-		return "", err
+	unlock := gate.Lock()
+	defer unlock()
+
+	backupDirPath := filepath.Join(filestorePath, "backup", time.Now().Format("2006-01-02_15-04-05"))
+	if err := os.MkdirAll(backupDirPath, rwxr__r__); err != nil {
+		return "", errors.Wrap(err, "Failed to create backup dir")
+	}
+
+	{
+		// new export
+		exportFilename := path.Join(backupDirPath, fmt.Sprintf("export-%d.json", time.Now().Unix()))
+
+		err := datastore.Export(exportFilename)
+		if err != nil {
+			log.Error().Err(err).Str("filename", exportFilename).Msg("failed to export")
+		} else {
+			log.Debug().Str("filename", exportFilename).Msg("file exported")
+		}
+	}
+
+	if err := backupDb(backupDirPath, datastore); err != nil {
+		return "", errors.Wrap(err, "Failed to backup database")
+	}
+
+	for _, filename := range filesToBackup {
+		err := filesystem.CopyPath(filepath.Join(filestorePath, filename), backupDirPath)
+		if err != nil {
+			return "", errors.Wrap(err, "Failed to create backup file")
+		}
 	}
 
 	archivePath, err := archive.TarGzDir(backupDirPath)
@@ -55,37 +81,6 @@ func CreateBackupArchive(password string, gate *offlinegate.OfflineGate, datasto
 	return archivePath, nil
 }
 
-func backupDatabaseAndFilesystem(gate *offlinegate.OfflineGate, datastore dataservices.DataStore, filestorePath string) (string, error) {
-	unlock := gate.Lock()
-	defer unlock()
-
-	backupDirPath := filepath.Join(filestorePath, "backup", time.Now().Format("2006-01-02_15-04-05"))
-	if err := os.MkdirAll(backupDirPath, rwxr__r__); err != nil {
-		return "", errors.Wrap(err, "Failed to create backup dir")
-	}
-
-	// new export
-	exportFilename := path.Join(backupDirPath, fmt.Sprintf("export-%d.json", time.Now().Unix()))
-
-	if err := datastore.Export(exportFilename); err != nil {
-		log.Error().Err(err).Str("filename", exportFilename).Msg("failed to export")
-	} else {
-		log.Debug().Str("filename", exportFilename).Msg("file exported")
-	}
-
-	if err := backupDb(backupDirPath, datastore); err != nil {
-		return "", errors.Wrap(err, "Failed to backup database")
-	}
-
-	for _, filename := range filesToBackup {
-		if err := filesystem.CopyPath(filepath.Join(filestorePath, filename), backupDirPath); err != nil {
-			return "", errors.Wrap(err, "Failed to create backup file")
-		}
-	}
-
-	return backupDirPath, nil
-}
-
 func backupDb(backupDirPath string, datastore dataservices.DataStore) error {
 	dbFileName := datastore.Connection().GetDatabaseFileName()
 	_, err := datastore.Backup(filepath.Join(backupDirPath, dbFileName))

api/build/variables.go

@@ -0,0 +1,12 @@
+package build
+
+import "runtime"
+
+// Variables to be set during the build time
+var BuildNumber string
+var ImageTag string
+var NodejsVersion string
+var YarnVersion string
+var WebpackVersion string
+var GoVersion string = runtime.Version()
+var GitCommit string

api/chisel/crypto/crypto.go

@@ -54,8 +54,8 @@ func ecdsaGenerateKey(c elliptic.Curve, rand io.Reader) (*ecdsa.PrivateKey, erro
 	}
 
 	priv := new(ecdsa.PrivateKey)
-	priv.Curve = c
+	priv.PublicKey.Curve = c
 	priv.D = k
-	priv.X, priv.Y = c.ScalarBaseMult(k.Bytes())
+	priv.PublicKey.X, priv.PublicKey.Y = c.ScalarBaseMult(k.Bytes())
 	return priv, nil
 }

api/chisel/service_test.go

@@ -9,15 +9,10 @@ import (
 
 	portainer "github.com/portainer/portainer/api"
 	"github.com/portainer/portainer/api/datastore"
-	"github.com/portainer/portainer/pkg/fips"
 
 	"github.com/stretchr/testify/require"
 )
 
-func init() {
-	fips.InitFIPS(false)
-}
-
 func TestPingAgentPanic(t *testing.T) {
 	endpoint := &portainer.Endpoint{
 		ID:          1,

api/chisel/tunnel.go

@@ -4,6 +4,7 @@ import (
 	"encoding/base64"
 	"errors"
 	"fmt"
+	"math/rand"
 	"net"
 	"strings"
 	"time"
@@ -13,7 +14,6 @@ import (
 	"github.com/portainer/portainer/api/internal/edge/cache"
 	"github.com/portainer/portainer/api/internal/endpointutils"
 	"github.com/portainer/portainer/pkg/libcrypto"
-	"github.com/portainer/portainer/pkg/librand"
 
 	"github.com/dchest/uniuri"
 	"github.com/rs/zerolog/log"
@@ -200,9 +200,7 @@ func (service *Service) getUnusedPort() int {
 
 	conn, err := net.DialTCP("tcp", nil, &net.TCPAddr{IP: net.IPv4(127, 0, 0, 1), Port: port})
 	if err == nil {
-		if err := conn.Close(); err != nil {
-			log.Warn().Msg("failed to close tcp connection that checks if port is free")
-		}
+		conn.Close()
 
 		log.Debug().
 			Int("port", port).
@@ -215,7 +213,7 @@ func (service *Service) getUnusedPort() int {
 }
 
 func randomInt(min, max int) int {
-	return min + librand.Intn(max-min)
+	return min + rand.Intn(max-min)
 }
 
 func generateRandomCredentials() (string, string) {

api/chisel/tunnel_test.go

@@ -1,79 +0,0 @@
-package chisel
-
-import (
-	"net"
-	"strings"
-	"testing"
-
-	portainer "github.com/portainer/portainer/api"
-	"github.com/portainer/portainer/api/dataservices"
-)
-
-type testSettingsService struct {
-	dataservices.SettingsService
-}
-
-func (s *testSettingsService) Settings() (*portainer.Settings, error) {
-	return &portainer.Settings{
-		EdgeAgentCheckinInterval: 1,
-	}, nil
-}
-
-type testStore struct {
-	dataservices.DataStore
-}
-
-func (s *testStore) Settings() dataservices.SettingsService {
-	return &testSettingsService{}
-}
-
-func TestGetUnusedPort(t *testing.T) {
-	testCases := []struct {
-		name            string
-		existingTunnels map[portainer.EndpointID]*portainer.TunnelDetails
-		expectedError   error
-	}{
-		{
-			name: "simple case",
-		},
-		{
-			name: "existing tunnels",
-			existingTunnels: map[portainer.EndpointID]*portainer.TunnelDetails{
-				portainer.EndpointID(1): {
-					Port: 53072,
-				},
-				portainer.EndpointID(2): {
-					Port: 63072,
-				},
-			},
-		},
-	}
-
-	for _, tc := range testCases {
-		t.Run(tc.name, func(t *testing.T) {
-			store := &testStore{}
-			s := NewService(store, nil, nil)
-			s.activeTunnels = tc.existingTunnels
-			port := s.getUnusedPort()
-
-			if port < 49152 || port > 65535 {
-				t.Fatalf("Expected port to be inbetween 49152 and 65535 but got %d", port)
-			}
-
-			for _, tun := range tc.existingTunnels {
-				if tun.Port == port {
-					t.Fatalf("returned port %d already has an existing tunnel", port)
-				}
-			}
-
-			conn, err := net.DialTCP("tcp", nil, &net.TCPAddr{IP: net.IPv4(127, 0, 0, 1), Port: port})
-			if err == nil {
-				// Ignore error
-				_ = conn.Close()
-				t.Fatalf("expected port %d to be unused", port)
-			} else if !strings.Contains(err.Error(), "connection refused") {
-				t.Fatalf("unexpected error: %v", err)
-			}
-		})
-	}
-}

api/cli/cli.go

@@ -9,8 +9,8 @@ import (
 
 	portainer "github.com/portainer/portainer/api"
 
-	"github.com/alecthomas/kingpin/v2"
 	"github.com/rs/zerolog/log"
+	"gopkg.in/alecthomas/kingpin.v2"
 )
 
 // Service implements the CLIService interface
@@ -35,9 +35,16 @@ func CLIFlags() *portainer.CLIFlags {
 		FeatureFlags:              kingpin.Flag("feat", "List of feature flags").Strings(),
 		EnableEdgeComputeFeatures: kingpin.Flag("edge-compute", "Enable Edge Compute features").Bool(),
 		NoAnalytics:               kingpin.Flag("no-analytics", "Disable Analytics in app (deprecated)").Bool(),
+		TLS:                       kingpin.Flag("tlsverify", "TLS support").Default(defaultTLS).Bool(),
 		TLSSkipVerify:             kingpin.Flag("tlsskipverify", "Disable TLS server verification").Default(defaultTLSSkipVerify).Bool(),
+		TLSCacert:                 kingpin.Flag("tlscacert", "Path to the CA").Default(defaultTLSCACertPath).String(),
+		TLSCert:                   kingpin.Flag("tlscert", "Path to the TLS certificate file").Default(defaultTLSCertPath).String(),
+		TLSKey:                    kingpin.Flag("tlskey", "Path to the TLS key").Default(defaultTLSKeyPath).String(),
 		HTTPDisabled:              kingpin.Flag("http-disabled", "Serve portainer only on https").Default(defaultHTTPDisabled).Bool(),
 		HTTPEnabled:               kingpin.Flag("http-enabled", "Serve portainer on http").Default(defaultHTTPEnabled).Bool(),
+		SSL:                       kingpin.Flag("ssl", "Secure Portainer instance using SSL (deprecated)").Default(defaultSSL).Bool(),
+		SSLCert:                   kingpin.Flag("sslcert", "Path to the SSL certificate used to secure the Portainer instance").String(),
+		SSLKey:                    kingpin.Flag("sslkey", "Path to the SSL key used to secure the Portainer instance").String(),
 		Rollback:                  kingpin.Flag("rollback", "Rollback the database to the previous backup").Bool(),
 		SnapshotInterval:          kingpin.Flag("snapshot-interval", "Duration between each environment snapshot job").String(),
 		AdminPassword:             kingpin.Flag("admin-password", "Set admin password with provided hash").String(),
@@ -52,49 +59,15 @@ func CLIFlags() *portainer.CLIFlags {
 		SecretKeyName:             kingpin.Flag("secret-key-name", "Secret key name for encryption and will be used as /run/secrets/<secret-key-name>.").Default(defaultSecretKeyName).String(),
 		LogLevel:                  kingpin.Flag("log-level", "Set the minimum logging level to show").Default("INFO").Enum("DEBUG", "INFO", "WARN", "ERROR"),
 		LogMode:                   kingpin.Flag("log-mode", "Set the logging output mode").Default("PRETTY").Enum("NOCOLOR", "PRETTY", "JSON"),
-		KubectlShellImage:         kingpin.Flag("kubectl-shell-image", "Kubectl shell image").Envar(portainer.KubectlShellImageEnvVar).Default(portainer.DefaultKubectlShellImage).String(),
-		PullLimitCheckDisabled:    kingpin.Flag("pull-limit-check-disabled", "Pull limit check").Envar(portainer.PullLimitCheckDisabledEnvVar).Default(defaultPullLimitCheckDisabled).Bool(),
-		TrustedOrigins:            kingpin.Flag("trusted-origins", "List of trusted origins for CSRF protection. Separate multiple origins with a comma.").Envar(portainer.TrustedOriginsEnvVar).String(),
-		CSP:                       kingpin.Flag("csp", "Content Security Policy (CSP) header").Envar(portainer.CSPEnvVar).Default("true").Bool(),
-		CompactDB:                 kingpin.Flag("compact-db", "Enable database compaction on startup").Envar(portainer.CompactDBEnvVar).Default("false").Bool(),
 	}
 }
 
 // ParseFlags parse the CLI flags and return a portainer.Flags struct
-func (Service) ParseFlags(version string) (*portainer.CLIFlags, error) {
+func (*Service) ParseFlags(version string) (*portainer.CLIFlags, error) {
 	kingpin.Version(version)
 
-	var hasSSLFlag, hasSSLCertFlag, hasSSLKeyFlag bool
-	sslFlag := kingpin.Flag(
-		"ssl",
-		"Secure Portainer instance using SSL (deprecated)",
-	).Default(defaultSSL).IsSetByUser(&hasSSLFlag)
-	ssl := sslFlag.Bool()
-	sslCertFlag := kingpin.Flag(
-		"sslcert",
-		"Path to the SSL certificate used to secure the Portainer instance",
-	).IsSetByUser(&hasSSLCertFlag)
-	sslCert := sslCertFlag.String()
-	sslKeyFlag := kingpin.Flag(
-		"sslkey",
-		"Path to the SSL key used to secure the Portainer instance",
-	).IsSetByUser(&hasSSLKeyFlag)
-	sslKey := sslKeyFlag.String()
-
 	flags := CLIFlags()
 
-	var hasTLSFlag, hasTLSCertFlag, hasTLSKeyFlag bool
-	tlsFlag := kingpin.Flag("tlsverify", "TLS support").Default(defaultTLS).IsSetByUser(&hasTLSFlag)
-	flags.TLS = tlsFlag.Bool()
-	tlsCertFlag := kingpin.Flag(
-		"tlscert",
-		"Path to the TLS certificate file",
-	).Default(defaultTLSCertPath).IsSetByUser(&hasTLSCertFlag)
-	flags.TLSCert = tlsCertFlag.String()
-	tlsKeyFlag := kingpin.Flag("tlskey", "Path to the TLS key").Default(defaultTLSKeyPath).IsSetByUser(&hasTLSKeyFlag)
-	flags.TLSKey = tlsKeyFlag.String()
-	flags.TLSCacert = kingpin.Flag("tlscacert", "Path to the CA").Default(defaultTLSCACertPath).String()
-
 	kingpin.Parse()
 
 	if !filepath.IsAbs(*flags.Assets) {
@@ -106,46 +79,11 @@ func (Service) ParseFlags(version string) (*portainer.CLIFlags, error) {
 		*flags.Assets = filepath.Join(filepath.Dir(ex), *flags.Assets)
 	}
 
-	// If the user didn't provide a tls flag remove the defaults to match previous behaviour
-	if !hasTLSFlag {
-		if !hasTLSCertFlag {
-			*flags.TLSCert = ""
-		}
-
-		if !hasTLSKeyFlag {
-			*flags.TLSKey = ""
-		}
-	}
-
-	if hasSSLFlag {
-		log.Warn().Msgf("the %q flag is deprecated. use %q instead.", sslFlag.Model().Name, tlsFlag.Model().Name)
-
-		if !hasTLSFlag {
-			flags.TLS = ssl
-		}
-	}
-
-	if hasSSLCertFlag {
-		log.Warn().Msgf("the %q flag is deprecated. use %q instead.", sslCertFlag.Model().Name, tlsCertFlag.Model().Name)
-
-		if !hasTLSCertFlag {
-			flags.TLSCert = sslCert
-		}
-	}
-
-	if hasSSLKeyFlag {
-		log.Warn().Msgf("the %q flag is deprecated. use %q instead.", sslKeyFlag.Model().Name, tlsKeyFlag.Model().Name)
-
-		if !hasTLSKeyFlag {
-			flags.TLSKey = sslKey
-		}
-	}
-
 	return flags, nil
 }
 
 // ValidateFlags validates the values of the flags.
-func (Service) ValidateFlags(flags *portainer.CLIFlags) error {
+func (*Service) ValidateFlags(flags *portainer.CLIFlags) error {
 	displayDeprecationWarnings(flags)
 
 	if err := validateEndpointURL(*flags.EndpointURL); err != nil {
@@ -167,6 +105,10 @@ func displayDeprecationWarnings(flags *portainer.CLIFlags) {
 	if *flags.NoAnalytics {
 		log.Warn().Msg("the --no-analytics flag has been kept to allow migration of instances running a previous version of Portainer with this flag enabled, to version 2.0 where enabling this flag will have no effect")
 	}
+
+	if *flags.SSL {
+		log.Warn().Msg("SSL is enabled by default and there is no need for the --ssl flag, it has been kept to allow migration of instances running a previous version of Portainer with this flag enabled")
+	}
 }
 
 func validateEndpointURL(endpointURL string) error {

api/cli/cli_test.go

@@ -1,209 +0,0 @@
-package cli
-
-import (
-	"io"
-	"os"
-	"strings"
-	"testing"
-
-	zerolog "github.com/rs/zerolog/log"
-	"github.com/stretchr/testify/require"
-)
-
-func TestOptionParser(t *testing.T) {
-	p := Service{}
-	require.NotNil(t, p)
-
-	a := os.Args
-	defer func() { os.Args = a }()
-
-	os.Args = []string{"portainer", "--edge-compute"}
-
-	opts, err := p.ParseFlags("2.34.5")
-	require.NoError(t, err)
-
-	require.False(t, *opts.HTTPDisabled)
-	require.True(t, *opts.EnableEdgeComputeFeatures)
-}
-
-func TestParseTLSFlags(t *testing.T) {
-	testCases := []struct {
-		name                string
-		args                []string
-		expectedTLSFlag     bool
-		expectedTLSCertFlag string
-		expectedTLSKeyFlag  string
-		expectedLogMessages []string
-	}{
-		{
-			name:                "no flags",
-			expectedTLSFlag:     false,
-			expectedTLSCertFlag: "",
-			expectedTLSKeyFlag:  "",
-		},
-		{
-			name: "only ssl flag",
-			args: []string{
-				"portainer",
-				"--ssl",
-			},
-			expectedTLSFlag:     true,
-			expectedTLSCertFlag: "",
-			expectedTLSKeyFlag:  "",
-		},
-		{
-			name: "only tls flag",
-			args: []string{
-				"portainer",
-				"--tlsverify",
-			},
-			expectedTLSFlag:     true,
-			expectedTLSCertFlag: defaultTLSCertPath,
-			expectedTLSKeyFlag:  defaultTLSKeyPath,
-		},
-		{
-			name: "partial ssl flags",
-			args: []string{
-				"portainer",
-				"--ssl",
-				"--sslcert=ssl-cert-flag-value",
-			},
-			expectedTLSFlag:     true,
-			expectedTLSCertFlag: "ssl-cert-flag-value",
-			expectedTLSKeyFlag:  "",
-		},
-		{
-			name: "partial tls flags",
-			args: []string{
-				"portainer",
-				"--tlsverify",
-				"--tlscert=tls-cert-flag-value",
-			},
-			expectedTLSFlag:     true,
-			expectedTLSCertFlag: "tls-cert-flag-value",
-			expectedTLSKeyFlag:  defaultTLSKeyPath,
-		},
-		{
-			name: "partial tls and ssl flags",
-			args: []string{
-				"portainer",
-				"--tlsverify",
-				"--tlscert=tls-cert-flag-value",
-				"--sslkey=ssl-key-flag-value",
-			},
-			expectedTLSFlag:     true,
-			expectedTLSCertFlag: "tls-cert-flag-value",
-			expectedTLSKeyFlag:  "ssl-key-flag-value",
-		},
-		{
-			name: "partial tls and ssl flags 2",
-			args: []string{
-				"portainer",
-				"--ssl",
-				"--tlscert=tls-cert-flag-value",
-				"--sslkey=ssl-key-flag-value",
-			},
-			expectedTLSFlag:     true,
-			expectedTLSCertFlag: "tls-cert-flag-value",
-			expectedTLSKeyFlag:  "ssl-key-flag-value",
-		},
-		{
-			name: "ssl flags",
-			args: []string{
-				"portainer",
-				"--ssl",
-				"--sslcert=ssl-cert-flag-value",
-				"--sslkey=ssl-key-flag-value",
-			},
-			expectedTLSFlag:     true,
-			expectedTLSCertFlag: "ssl-cert-flag-value",
-			expectedTLSKeyFlag:  "ssl-key-flag-value",
-			expectedLogMessages: []string{
-				"the \\\"ssl\\\" flag is deprecated. use \\\"tlsverify\\\" instead.",
-				"the \\\"sslcert\\\" flag is deprecated. use \\\"tlscert\\\" instead.",
-				"the \\\"sslkey\\\" flag is deprecated. use \\\"tlskey\\\" instead.",
-			},
-		},
-		{
-			name: "tls flags",
-			args: []string{
-				"portainer",
-				"--tlsverify",
-				"--tlscert=tls-cert-flag-value",
-				"--tlskey=tls-key-flag-value",
-			},
-			expectedTLSFlag:     true,
-			expectedTLSCertFlag: "tls-cert-flag-value",
-			expectedTLSKeyFlag:  "tls-key-flag-value",
-		},
-		{
-			name: "tls and ssl flags",
-			args: []string{
-				"portainer",
-				"--tlsverify",
-				"--tlscert=tls-cert-flag-value",
-				"--tlskey=tls-key-flag-value",
-				"--ssl",
-				"--sslcert=ssl-cert-flag-value",
-				"--sslkey=ssl-key-flag-value",
-			},
-			expectedTLSFlag:     true,
-			expectedTLSCertFlag: "tls-cert-flag-value",
-			expectedTLSKeyFlag:  "tls-key-flag-value",
-			expectedLogMessages: []string{
-				"the \\\"ssl\\\" flag is deprecated. use \\\"tlsverify\\\" instead.",
-				"the \\\"sslcert\\\" flag is deprecated. use \\\"tlscert\\\" instead.",
-				"the \\\"sslkey\\\" flag is deprecated. use \\\"tlskey\\\" instead.",
-			},
-		},
-	}
-
-	for _, tc := range testCases {
-		t.Run(tc.name, func(t *testing.T) {
-			var logOutput strings.Builder
-			setupLogOutput(t, &logOutput)
-
-			if tc.args == nil {
-				tc.args = []string{"portainer"}
-			}
-			setOsArgs(t, tc.args)
-
-			s := Service{}
-			flags, err := s.ParseFlags("test-version")
-			if err != nil {
-				t.Fatalf("error parsing flags: %v", err)
-			}
-
-			if flags.TLS == nil {
-				t.Fatal("TLS flag was nil")
-			}
-
-			require.Equal(t, tc.expectedTLSFlag, *flags.TLS, "tlsverify flag didn't match")
-			require.Equal(t, tc.expectedTLSCertFlag, *flags.TLSCert, "tlscert flag didn't match")
-			require.Equal(t, tc.expectedTLSKeyFlag, *flags.TLSKey, "tlskey flag didn't match")
-
-			for _, expectedLogMessage := range tc.expectedLogMessages {
-				require.Contains(t, logOutput.String(), expectedLogMessage, "Log didn't contain expected message")
-			}
-		})
-	}
-}
-
-func setOsArgs(t *testing.T, args []string) {
-	t.Helper()
-	previousArgs := os.Args
-	os.Args = args
-	t.Cleanup(func() {
-		os.Args = previousArgs
-	})
-}
-
-func setupLogOutput(t *testing.T, w io.Writer) {
-	t.Helper()
-
-	oldLogger := zerolog.Logger
-	zerolog.Logger = zerolog.Output(w)
-	t.Cleanup(func() {
-		zerolog.Logger = oldLogger
-	})
-}

api/cli/confirm.go

@@ -19,5 +19,7 @@ func Confirm(message string) (bool, error) {
 	}
 
 	answer = strings.ReplaceAll(answer, "\n", "")
-	return strings.EqualFold(answer, "y") || strings.EqualFold(answer, "yes"), nil
+	answer = strings.ToLower(answer)
+
+	return answer == "y" || answer == "yes", nil
 }

api/cli/defaults.go

@@ -4,21 +4,20 @@
 package cli
 
 const (
-	defaultBindAddress            = ":9000"
-	defaultHTTPSBindAddress       = ":9443"
-	defaultTunnelServerAddress    = "0.0.0.0"
-	defaultTunnelServerPort       = "8000"
-	defaultDataDirectory          = "/data"
-	defaultAssetsDirectory        = "./"
-	defaultTLS                    = "false"
-	defaultTLSSkipVerify          = "false"
-	defaultTLSCACertPath          = "/certs/ca.pem"
-	defaultTLSCertPath            = "/certs/cert.pem"
-	defaultTLSKeyPath             = "/certs/key.pem"
-	defaultHTTPDisabled           = "false"
-	defaultHTTPEnabled            = "false"
-	defaultSSL                    = "false"
-	defaultBaseURL                = "/"
-	defaultSecretKeyName          = "portainer"
-	defaultPullLimitCheckDisabled = "false"
+	defaultBindAddress         = ":9000"
+	defaultHTTPSBindAddress    = ":9443"
+	defaultTunnelServerAddress = "0.0.0.0"
+	defaultTunnelServerPort    = "8000"
+	defaultDataDirectory       = "/data"
+	defaultAssetsDirectory     = "./"
+	defaultTLS                 = "false"
+	defaultTLSSkipVerify       = "false"
+	defaultTLSCACertPath       = "/certs/ca.pem"
+	defaultTLSCertPath         = "/certs/cert.pem"
+	defaultTLSKeyPath          = "/certs/key.pem"
+	defaultHTTPDisabled        = "false"
+	defaultHTTPEnabled         = "false"
+	defaultSSL                 = "false"
+	defaultBaseURL             = "/"
+	defaultSecretKeyName       = "portainer"
 )

api/cli/defaults_windows.go

@@ -1,22 +1,21 @@
 package cli
 
 const (
-	defaultBindAddress            = ":9000"
-	defaultHTTPSBindAddress       = ":9443"
-	defaultTunnelServerAddress    = "0.0.0.0"
-	defaultTunnelServerPort       = "8000"
-	defaultDataDirectory          = "C:\\data"
-	defaultAssetsDirectory        = "./"
-	defaultTLS                    = "false"
-	defaultTLSSkipVerify          = "false"
-	defaultTLSCACertPath          = "C:\\certs\\ca.pem"
-	defaultTLSCertPath            = "C:\\certs\\cert.pem"
-	defaultTLSKeyPath             = "C:\\certs\\key.pem"
-	defaultHTTPDisabled           = "false"
-	defaultHTTPEnabled            = "false"
-	defaultSSL                    = "false"
-	defaultSnapshotInterval       = "5m"
-	defaultBaseURL                = "/"
-	defaultSecretKeyName          = "portainer"
-	defaultPullLimitCheckDisabled = "false"
+	defaultBindAddress         = ":9000"
+	defaultHTTPSBindAddress    = ":9443"
+	defaultTunnelServerAddress = "0.0.0.0"
+	defaultTunnelServerPort    = "8000"
+	defaultDataDirectory       = "C:\\data"
+	defaultAssetsDirectory     = "./"
+	defaultTLS                 = "false"
+	defaultTLSSkipVerify       = "false"
+	defaultTLSCACertPath       = "C:\\certs\\ca.pem"
+	defaultTLSCertPath         = "C:\\certs\\cert.pem"
+	defaultTLSKeyPath          = "C:\\certs\\key.pem"
+	defaultHTTPDisabled        = "false"
+	defaultHTTPEnabled         = "false"
+	defaultSSL                 = "false"
+	defaultSnapshotInterval    = "5m"
+	defaultBaseURL             = "/"
+	defaultSecretKeyName       = "portainer"
 )

api/cli/pairlist.go

@@ -6,7 +6,7 @@ import (
 	"fmt"
 	"strings"
 
-	"github.com/alecthomas/kingpin/v2"
+	"gopkg.in/alecthomas/kingpin.v2"
 )
 
 type pairList []portainer.Pair

api/cli/pairlistbool.go

@@ -0,0 +1,45 @@
+package cli
+
+import (
+	"strings"
+
+	portainer "github.com/portainer/portainer/api"
+
+	"gopkg.in/alecthomas/kingpin.v2"
+)
+
+type pairListBool []portainer.Pair
+
+// Set implementation for a list of portainer.Pair
+func (l *pairListBool) Set(value string) error {
+	p := new(portainer.Pair)
+
+	// default to true.  example setting=true is equivalent to setting
+	parts := strings.SplitN(value, "=", 2)
+	if len(parts) != 2 {
+		p.Name = parts[0]
+		p.Value = "true"
+	} else {
+		p.Name = parts[0]
+		p.Value = parts[1]
+	}
+
+	*l = append(*l, *p)
+	return nil
+}
+
+// String implementation for a list of pair
+func (l *pairListBool) String() string {
+	return ""
+}
+
+// IsCumulative implementation for a list of pair
+func (l *pairListBool) IsCumulative() bool {
+	return true
+}
+
+func BoolPairs(s kingpin.Settings) (target *[]portainer.Pair) {
+	target = new([]portainer.Pair)
+	s.SetValue((*pairListBool)(target))
+	return
+}

api/cmd/portainer/log.go

@@ -1,4 +1,4 @@
-package logs
+package main
 
 import (
 	"fmt"
@@ -10,7 +10,7 @@ import (
 	"github.com/rs/zerolog/pkgerrors"
 )
 
-func ConfigureLogger() {
+func configureLogger() {
 	zerolog.ErrorStackFieldName = "stack_trace"
 	zerolog.ErrorStackMarshaler = pkgerrors.MarshalStack
 	zerolog.TimeFieldFormat = zerolog.TimeFormatUnix
@@ -21,7 +21,7 @@ func ConfigureLogger() {
 	log.Logger = log.Logger.With().Caller().Stack().Logger()
 }
 
-func SetLoggingLevel(level string) {
+func setLoggingLevel(level string) {
 	switch level {
 	case "ERROR":
 		zerolog.SetGlobalLevel(zerolog.ErrorLevel)
@@ -34,7 +34,7 @@ func SetLoggingLevel(level string) {
 	}
 }
 
-func SetLoggingMode(mode string) {
+func setLoggingMode(mode string) {
 	switch mode {
 	case "PRETTY":
 		log.Logger = log.Output(zerolog.ConsoleWriter{

api/cmd/portainer/main.go

@@ -10,6 +10,7 @@ import (
 
 	portainer "github.com/portainer/portainer/api"
 	"github.com/portainer/portainer/api/apikey"
+	"github.com/portainer/portainer/api/build"
 	"github.com/portainer/portainer/api/chisel"
 	"github.com/portainer/portainer/api/cli"
 	"github.com/portainer/portainer/api/crypto"
@@ -39,7 +40,6 @@ import (
 	"github.com/portainer/portainer/api/kubernetes"
 	kubecli "github.com/portainer/portainer/api/kubernetes/cli"
 	"github.com/portainer/portainer/api/ldap"
-	"github.com/portainer/portainer/api/logs"
 	"github.com/portainer/portainer/api/oauth"
 	"github.com/portainer/portainer/api/pendingactions"
 	"github.com/portainer/portainer/api/pendingactions/actions"
@@ -47,20 +47,16 @@ import (
 	"github.com/portainer/portainer/api/platform"
 	"github.com/portainer/portainer/api/scheduler"
 	"github.com/portainer/portainer/api/stacks/deployments"
-	"github.com/portainer/portainer/pkg/build"
 	"github.com/portainer/portainer/pkg/featureflags"
-	"github.com/portainer/portainer/pkg/fips"
 	"github.com/portainer/portainer/pkg/libhelm"
-	libhelmtypes "github.com/portainer/portainer/pkg/libhelm/types"
 	"github.com/portainer/portainer/pkg/libstack/compose"
-	"github.com/portainer/portainer/pkg/validate"
 
 	"github.com/gofrs/uuid"
 	"github.com/rs/zerolog/log"
 )
 
 func initCLI() *portainer.CLIFlags {
-	cliService := cli.Service{}
+	cliService := &cli.Service{}
 
 	flags, err := cliService.ParseFlags(portainer.APIVersion)
 	if err != nil {
@@ -84,7 +80,7 @@ func initFileService(dataStorePath string) portainer.FileService {
 }
 
 func initDataStore(flags *portainer.CLIFlags, secretKey []byte, fileService portainer.FileService, shutdownCtx context.Context) dataservices.DataStore {
-	connection, err := database.NewDatabase("boltdb", *flags.Data, secretKey, *flags.CompactDB)
+	connection, err := database.NewDatabase("boltdb", *flags.Data, secretKey)
 	if err != nil {
 		log.Fatal().Err(err).Msg("failed creating database connection")
 	}
@@ -97,7 +93,7 @@ func initDataStore(flags *portainer.CLIFlags, secretKey []byte, fileService port
 		log.Fatal().Msg("failed creating database connection: expecting a boltdb database type but a different one was received")
 	}
 
-	store := datastore.NewStore(flags, fileService, connection)
+	store := datastore.NewStore(*flags.Data, fileService, connection)
 
 	isNew, err := store.Open()
 	if err != nil {
@@ -124,7 +120,7 @@ func initDataStore(flags *portainer.CLIFlags, secretKey []byte, fileService port
 			log.Fatal().Err(err).Msg("failed generating instance id")
 		}
 
-		migratorInstance := migrator.NewMigrator(&migrator.MigratorParameters{Flags: flags})
+		migratorInstance := migrator.NewMigrator(&migrator.MigratorParameters{})
 		migratorCount := migratorInstance.GetMigratorCountOfCurrentAPIVersion()
 
 		// from MigrateData
@@ -169,12 +165,12 @@ func checkDBSchemaServerVersionMatch(dbStore dataservices.DataStore, serverVersi
 	return v.SchemaVersion == serverVersion && v.Edition == serverEdition
 }
 
-func initKubernetesDeployer(kubernetesTokenCacheManager *kubeproxy.TokenCacheManager, kubernetesClientFactory *kubecli.ClientFactory, dataStore dataservices.DataStore, reverseTunnelService portainer.ReverseTunnelService, signatureService portainer.DigitalSignatureService, proxyManager *proxy.Manager) portainer.KubernetesDeployer {
-	return exec.NewKubernetesDeployer(kubernetesTokenCacheManager, kubernetesClientFactory, dataStore, reverseTunnelService, signatureService, proxyManager)
+func initKubernetesDeployer(kubernetesTokenCacheManager *kubeproxy.TokenCacheManager, kubernetesClientFactory *kubecli.ClientFactory, dataStore dataservices.DataStore, reverseTunnelService portainer.ReverseTunnelService, signatureService portainer.DigitalSignatureService, proxyManager *proxy.Manager, assetsPath string) portainer.KubernetesDeployer {
+	return exec.NewKubernetesDeployer(kubernetesTokenCacheManager, kubernetesClientFactory, dataStore, reverseTunnelService, signatureService, proxyManager, assetsPath)
 }
 
-func initHelmPackageManager() (libhelmtypes.HelmPackageManager, error) {
-	return libhelm.NewHelmPackageManager()
+func initHelmPackageManager(assetsPath string) (libhelm.HelmPackageManager, error) {
+	return libhelm.NewHelmPackageManager(libhelm.HelmConfig{BinaryPath: assetsPath})
 }
 
 func initAPIKeyService(datastore dataservices.DataStore) apikey.APIKeyService {
@@ -242,10 +238,10 @@ func updateSettingsFromFlags(dataStore dataservices.DataStore, flags *portainer.
 		return err
 	}
 
-	settings.SnapshotInterval = cmp.Or(*flags.SnapshotInterval, settings.SnapshotInterval)
-	settings.LogoURL = cmp.Or(*flags.Logo, settings.LogoURL)
-	settings.EnableEdgeComputeFeatures = cmp.Or(*flags.EnableEdgeComputeFeatures, settings.EnableEdgeComputeFeatures)
-	settings.TemplatesURL = cmp.Or(*flags.Templates, settings.TemplatesURL)
+	settings.SnapshotInterval = *cmp.Or(flags.SnapshotInterval, &settings.SnapshotInterval)
+	settings.LogoURL = *cmp.Or(flags.Logo, &settings.LogoURL)
+	settings.EnableEdgeComputeFeatures = *cmp.Or(flags.EnableEdgeComputeFeatures, &settings.EnableEdgeComputeFeatures)
+	settings.TemplatesURL = *cmp.Or(flags.Templates, &settings.TemplatesURL)
 
 	if *flags.Labels != nil {
 		settings.BlackListedLabels = *flags.Labels
@@ -307,19 +303,8 @@ func initKeyPair(fileService portainer.FileService, signatureService portainer.D
 	return generateAndStoreKeyPair(fileService, signatureService)
 }
 
-// dbSecretPath build the path to the file that contains the db encryption
-// secret. Normally in Docker this is built from the static path inside
-// /run/secrets for example: /run/secrets/<keyFilenameFlag> but for ease of
-// use outside Docker it also accepts an absolute path
-func dbSecretPath(keyFilenameFlag string) string {
-	if path.IsAbs(keyFilenameFlag) {
-		return keyFilenameFlag
-	}
-	return path.Join("/run/secrets", keyFilenameFlag)
-}
-
 func loadEncryptionSecretKey(keyfilename string) []byte {
-	content, err := os.ReadFile(keyfilename)
+	content, err := os.ReadFile(path.Join("/run/secrets", keyfilename))
 	if err != nil {
 		if os.IsNotExist(err) {
 			log.Info().Str("filename", keyfilename).Msg("encryption key file not present")
@@ -331,7 +316,6 @@ func loadEncryptionSecretKey(keyfilename string) []byte {
 	}
 
 	// return a 32 byte hash of the secret (required for AES)
-	// fips compliant version of this is not implemented in -ce
 	hash := sha256.Sum256(content)
 
 	return hash[:]
@@ -344,23 +328,8 @@ func buildServer(flags *portainer.CLIFlags) portainer.Server {
 		featureflags.Parse(*flags.FeatureFlags, portainer.SupportedFeatureFlags)
 	}
 
-	trustedOrigins := []string{}
-	if *flags.TrustedOrigins != "" {
-		// validate if the trusted origins are valid urls
-		for _, origin := range strings.Split(*flags.TrustedOrigins, ",") {
-			if !validate.IsTrustedOrigin(origin) {
-				log.Fatal().Str("trusted_origin", origin).Msg("invalid url for trusted origin. Please check the trusted origins flag.")
-			}
-
-			trustedOrigins = append(trustedOrigins, origin)
-		}
-	}
-
-	// -ce can not ever be run in FIPS mode
-	fips.InitFIPS(false)
-
 	fileService := initFileService(*flags.Data)
-	encryptionKey := loadEncryptionSecretKey(dbSecretPath(*flags.SecretKeyName))
+	encryptionKey := loadEncryptionSecretKey(*flags.SecretKeyName)
 	if encryptionKey == nil {
 		log.Info().Msg("proceeding without encryption key")
 	}
@@ -393,22 +362,21 @@ func buildServer(flags *portainer.CLIFlags) portainer.Server {
 		log.Fatal().Err(err).Msg("failed initializing JWT service")
 	}
 
-	ldapService := ldap.Service{}
+	ldapService := &ldap.Service{}
 
 	oauthService := oauth.NewService()
 
 	gitService := git.NewService(shutdownCtx)
 
-	// Setting insecureSkipVerify to true to preserve the old behaviour.
-	openAMTService := openamt.NewService(true)
+	openAMTService := openamt.NewService()
 
-	cryptoService := crypto.Service{}
+	cryptoService := &crypto.Service{}
 
 	signatureService := initDigitalSignatureService()
 
 	edgeStacksService := edgestacks.NewService(dataStore)
 
-	sslService, err := initSSLService(*flags.AddrHTTPS, *flags.TLSCert, *flags.TLSKey, fileService, dataStore, shutdownTrigger)
+	sslService, err := initSSLService(*flags.AddrHTTPS, *flags.SSLCert, *flags.SSLKey, fileService, dataStore, shutdownTrigger)
 	if err != nil {
 		log.Fatal().Err(err).Msg("")
 	}
@@ -453,7 +421,7 @@ func buildServer(flags *portainer.CLIFlags) portainer.Server {
 		log.Fatal().Err(err).Msg("failed initializing swarm stack manager")
 	}
 
-	kubernetesDeployer := initKubernetesDeployer(kubernetesTokenCacheManager, kubernetesClientFactory, dataStore, reverseTunnelService, signatureService, proxyManager)
+	kubernetesDeployer := initKubernetesDeployer(kubernetesTokenCacheManager, kubernetesClientFactory, dataStore, reverseTunnelService, signatureService, proxyManager, *flags.Assets)
 
 	pendingActionsService := pendingactions.NewService(dataStore, kubernetesClientFactory)
 	pendingActionsService.RegisterHandler(actions.CleanNAPWithOverridePolicies, handlers.NewHandlerCleanNAPWithOverridePolicies(authorizationService, dataStore))
@@ -467,9 +435,9 @@ func buildServer(flags *portainer.CLIFlags) portainer.Server {
 
 	snapshotService.Start()
 
-	proxyManager.NewProxyFactory(dataStore, signatureService, reverseTunnelService, dockerClientFactory, kubernetesClientFactory, kubernetesTokenCacheManager, gitService, snapshotService, jwtService)
+	proxyManager.NewProxyFactory(dataStore, signatureService, reverseTunnelService, dockerClientFactory, kubernetesClientFactory, kubernetesTokenCacheManager, gitService, snapshotService)
 
-	helmPackageManager, err := initHelmPackageManager()
+	helmPackageManager, err := initHelmPackageManager(*flags.Assets)
 	if err != nil {
 		log.Fatal().Err(err).Msg("failed initializing helm package manager")
 	}
@@ -575,7 +543,6 @@ func buildServer(flags *portainer.CLIFlags) portainer.Server {
 		Status:                      applicationStatus,
 		BindAddress:                 *flags.Addr,
 		BindAddressHTTPS:            *flags.AddrHTTPS,
-		CSP:                         *flags.CSP,
 		HTTPEnabled:                 sslDBSettings.HTTPEnabled,
 		AssetsPath:                  *flags.Assets,
 		DataStore:                   dataStore,
@@ -608,19 +575,17 @@ func buildServer(flags *portainer.CLIFlags) portainer.Server {
 		AdminCreationDone:           adminCreationDone,
 		PendingActionsService:       pendingActionsService,
 		PlatformService:             platformService,
-		PullLimitCheckDisabled:      *flags.PullLimitCheckDisabled,
-		TrustedOrigins:              trustedOrigins,
 	}
 }
 
 func main() {
-	logs.ConfigureLogger()
-	logs.SetLoggingMode("PRETTY")
+	configureLogger()
+	setLoggingMode("PRETTY")
 
 	flags := initCLI()
 
-	logs.SetLoggingLevel(*flags.LogLevel)
-	logs.SetLoggingMode(*flags.LogMode)
+	setLoggingLevel(*flags.LogLevel)
+	setLoggingMode(*flags.LogMode)
 
 	for {
 		server := buildServer(flags)

api/cmd/portainer/main_test.go

@@ -1,57 +0,0 @@
-package main
-
-import (
-	"os"
-	"path"
-	"testing"
-
-	"github.com/stretchr/testify/assert"
-	"github.com/stretchr/testify/require"
-)
-
-const secretFileName = "secret.txt"
-
-func createPasswordFile(t *testing.T, secretPath, password string) string {
-	err := os.WriteFile(secretPath, []byte(password), 0600)
-	require.NoError(t, err)
-	return secretPath
-}
-
-func TestLoadEncryptionSecretKey(t *testing.T) {
-	tempDir := t.TempDir()
-	secretPath := path.Join(tempDir, secretFileName)
-
-	// first pointing to file that does not exist, gives nil hash (no encryption)
-	encryptionKey := loadEncryptionSecretKey(secretPath)
-	require.Nil(t, encryptionKey)
-
-	// point to a directory instead of a file
-	encryptionKey = loadEncryptionSecretKey(tempDir)
-	require.Nil(t, encryptionKey)
-
-	password := "portainer@1234"
-	createPasswordFile(t, secretPath, password)
-
-	encryptionKey = loadEncryptionSecretKey(secretPath)
-	require.NotNil(t, encryptionKey)
-	// should be 32 bytes for aes256 encryption
-	require.Len(t, encryptionKey, 32)
-}
-
-func TestDBSecretPath(t *testing.T) {
-	tests := []struct {
-		keyFilenameFlag string
-		expected        string
-	}{
-		{keyFilenameFlag: "secret.txt", expected: "/run/secrets/secret.txt"},
-		{keyFilenameFlag: "/tmp/secret.txt", expected: "/tmp/secret.txt"},
-		{keyFilenameFlag: "/run/secrets/secret.txt", expected: "/run/secrets/secret.txt"},
-		{keyFilenameFlag: "./secret.txt", expected: "/run/secrets/secret.txt"},
-		{keyFilenameFlag: "../secret.txt", expected: "/run/secret.txt"},
-		{keyFilenameFlag: "foo/bar/secret.txt", expected: "/run/secrets/foo/bar/secret.txt"},
-	}
-
-	for _, test := range tests {
-		assert.Equal(t, test.expected, dbSecretPath(test.keyFilenameFlag))
-	}
-}

api/connection.go

@@ -6,10 +6,8 @@ import (
 
 type ReadTransaction interface {
 	GetObject(bucketName string, key []byte, object any) error
-	GetRawBytes(bucketName string, key []byte) ([]byte, error)
 	GetAll(bucketName string, obj any, append func(o any) (any, error)) error
 	GetAllWithKeyPrefix(bucketName string, keyPrefix []byte, obj any, append func(o any) (any, error)) error
-	KeyExists(bucketName string, key []byte) (bool, error)
 }
 
 type Transaction interface {
@@ -42,7 +40,6 @@ type Connection interface {
 	GetDatabaseFileName() string
 	GetDatabaseFilePath() string
 	GetStorePath() string
-	GetDatabaseFileSize() (int64, error)
 
 	IsEncryptedStore() bool
 	NeedsEncryptionMigration() (bool, error)

api/crypto/aes.go

@@ -5,15 +5,10 @@ import (
 	"bytes"
 	"crypto/aes"
 	"crypto/cipher"
-	"crypto/pbkdf2"
 	"crypto/rand"
-	"crypto/sha256"
 	"errors"
 	"fmt"
 	"io"
-	"strings"
-
-	"github.com/portainer/portainer/pkg/fips"
 
 	"golang.org/x/crypto/argon2"
 	"golang.org/x/crypto/scrypt"
@@ -24,32 +19,20 @@ const (
 	aesGcmHeader    = "AES256-GCM" // The encrypted file header
 	aesGcmBlockSize = 1024 * 1024  // 1MB block for aes gcm
 
-	aesGcmFIPSHeader    = "FIPS-AES256-GCM"
-	aesGcmFIPSBlockSize = 16 * 1024 * 1024 // 16MB block for aes gcm
-
 	// Argon2 settings
-	// Recommended settings lower memory hardware according to current OWASP recommendations
+	// Recommded settings lower memory hardware according to current OWASP recommendations
 	// Considering some people run portainer on a NAS I think it's prudent not to assume we're on server grade hardware
 	// https://cheatsheetseries.owasp.org/cheatsheets/Password_Storage_Cheat_Sheet.html#argon2id
 	argon2MemoryCost = 12 * 1024
 	argon2TimeCost   = 3
 	argon2Threads    = 1
 	argon2KeyLength  = 32
-
-	pbkdf2Iterations = 600_000 // use recommended iterations from https://cheatsheetseries.owasp.org/cheatsheets/Password_Storage_Cheat_Sheet.html#pbkdf2 a little overkill for this use
-	pbkdf2SaltLength = 32
 )
 
 // AesEncrypt reads from input, encrypts with AES-256 and writes to output. passphrase is used to generate an encryption key
 func AesEncrypt(input io.Reader, output io.Writer, passphrase []byte) error {
-	if fips.FIPSMode() {
-		if err := aesEncryptGCMFIPS(input, output, passphrase); err != nil {
-			return fmt.Errorf("error encrypting file: %w", err)
-		}
-	} else {
-		if err := aesEncryptGCM(input, output, passphrase); err != nil {
-			return fmt.Errorf("error encrypting file: %w", err)
-		}
+	if err := aesEncryptGCM(input, output, passphrase); err != nil {
+		return fmt.Errorf("error encrypting file: %w", err)
 	}
 
 	return nil
@@ -57,35 +40,14 @@ func AesEncrypt(input io.Reader, output io.Writer, passphrase []byte) error {
 
 // AesDecrypt reads from input, decrypts with AES-256 and returns the reader to read the decrypted content from
 func AesDecrypt(input io.Reader, passphrase []byte) (io.Reader, error) {
-	return aesDecrypt(input, passphrase, fips.FIPSMode())
-}
-
-func aesDecrypt(input io.Reader, passphrase []byte, fipsMode bool) (io.Reader, error) {
 	// Read file header to determine how it was encrypted
 	inputReader := bufio.NewReader(input)
-	header, err := inputReader.Peek(len(aesGcmFIPSHeader))
+	header, err := inputReader.Peek(len(aesGcmHeader))
 	if err != nil {
 		return nil, fmt.Errorf("error reading encrypted backup file header: %w", err)
 	}
 
-	if strings.HasPrefix(string(header), aesGcmFIPSHeader) {
-		if !fipsMode {
-			return nil, errors.New("fips encrypted file detected but fips mode is not enabled")
-		}
-
-		reader, err := aesDecryptGCMFIPS(inputReader, passphrase)
-		if err != nil {
-			return nil, fmt.Errorf("error decrypting file: %w", err)
-		}
-
-		return reader, nil
-	}
-
-	if strings.HasPrefix(string(header), aesGcmHeader) {
-		if fipsMode {
-			return nil, errors.New("fips mode is enabled but non-fips encrypted file detected")
-		}
-
+	if string(header) == aesGcmHeader {
 		reader, err := aesDecryptGCM(inputReader, passphrase)
 		if err != nil {
 			return nil, fmt.Errorf("error decrypting file: %w", err)
@@ -152,14 +114,15 @@ func aesEncryptGCM(input io.Reader, output io.Writer, passphrase []byte) error {
 			break // end of plaintext input
 		}
 
-		if err != nil && !errors.Is(err, io.EOF) && !errors.Is(err, io.ErrUnexpectedEOF) {
+		if err != nil && !(errors.Is(err, io.EOF) || errors.Is(err, io.ErrUnexpectedEOF)) {
 			return err
 		}
 
 		// Seal encrypts the plaintext using the nonce returning the updated slice.
 		ciphertext = aesgcm.Seal(ciphertext[:0], nonce.Value(), buf[:n], nil)
 
-		if _, err := output.Write(ciphertext); err != nil {
+		_, err = output.Write(ciphertext)
+		if err != nil {
 			return err
 		}
 
@@ -220,7 +183,7 @@ func aesDecryptGCM(input io.Reader, passphrase []byte) (io.Reader, error) {
 			break // end of ciphertext
 		}
 
-		if err != nil && !errors.Is(err, io.EOF) && !errors.Is(err, io.ErrUnexpectedEOF) {
+		if err != nil && !(errors.Is(err, io.EOF) || errors.Is(err, io.ErrUnexpectedEOF)) {
 			return nil, err
 		}
 
@@ -240,138 +203,15 @@ func aesDecryptGCM(input io.Reader, passphrase []byte) (io.Reader, error) {
 	return &buf, nil
 }
 
-// aesEncryptGCMFIPS reads from input, encrypts with AES-256 in a fips compliant
-// way and writes to output. passphrase is used to generate an encryption key.
-func aesEncryptGCMFIPS(input io.Reader, output io.Writer, passphrase []byte) error {
-	salt := make([]byte, pbkdf2SaltLength)
-	if _, err := io.ReadFull(rand.Reader, salt); err != nil {
-		return err
-	}
-
-	key, err := pbkdf2.Key(sha256.New, string(passphrase), salt, pbkdf2Iterations, 32)
-	if err != nil {
-		return fmt.Errorf("error deriving key: %w", err)
-	}
-
-	block, err := aes.NewCipher(key)
-	if err != nil {
-		return err
-	}
-
-	// write the header
-	if _, err := output.Write([]byte(aesGcmFIPSHeader)); err != nil {
-		return err
-	}
-
-	// Write nonce and salt to the output file
-	if _, err := output.Write(salt); err != nil {
-		return err
-	}
-
-	// Buffer for reading plaintext blocks
-	buf := make([]byte, aesGcmFIPSBlockSize)
-
-	// Encrypt plaintext in blocks
-	for {
-		// new random nonce for each block
-		aesgcm, err := cipher.NewGCMWithRandomNonce(block)
-		if err != nil {
-			return fmt.Errorf("error creating gcm: %w", err)
-		}
-
-		n, err := io.ReadFull(input, buf)
-		if n == 0 {
-			break // end of plaintext input
-		}
-
-		if err != nil && !errors.Is(err, io.EOF) && !errors.Is(err, io.ErrUnexpectedEOF) {
-			return err
-		}
-
-		// Seal encrypts the plaintext
-		ciphertext := aesgcm.Seal(nil, nil, buf[:n], nil)
-
-		if _, err := output.Write(ciphertext); err != nil {
-			return err
-		}
-	}
-
-	return nil
-}
-
-// aesDecryptGCMFIPS reads from input, decrypts with AES-256 in a fips compliant
-// way and returns the reader to read the decrypted content from.
-func aesDecryptGCMFIPS(input io.Reader, passphrase []byte) (io.Reader, error) {
-	// Reader & verify header
-	header := make([]byte, len(aesGcmFIPSHeader))
-	if _, err := io.ReadFull(input, header); err != nil {
-		return nil, err
-	}
-
-	if string(header) != aesGcmFIPSHeader {
-		return nil, errors.New("invalid header")
-	}
-
-	// Read salt
-	salt := make([]byte, pbkdf2SaltLength)
-	if _, err := io.ReadFull(input, salt); err != nil {
-		return nil, err
-	}
-
-	key, err := pbkdf2.Key(sha256.New, string(passphrase), salt, pbkdf2Iterations, 32)
-	if err != nil {
-		return nil, fmt.Errorf("error deriving key: %w", err)
-	}
-
-	// Initialize AES cipher block
-	block, err := aes.NewCipher(key)
-	if err != nil {
-		return nil, err
-	}
-
-	// Initialize a buffer to store decrypted data
-	buf := bytes.Buffer{}
-
-	// Decrypt the ciphertext in blocks
-	for {
-		// Create GCM mode with the cipher block
-		aesgcm, err := cipher.NewGCMWithRandomNonce(block)
-		if err != nil {
-			return nil, err
-		}
-
-		// Read a block of ciphertext from the input reader
-		ciphertextBlock := make([]byte, aesGcmFIPSBlockSize+aesgcm.Overhead())
-		n, err := io.ReadFull(input, ciphertextBlock)
-		if n == 0 {
-			break // end of ciphertext
-		}
-
-		if err != nil && !errors.Is(err, io.EOF) && !errors.Is(err, io.ErrUnexpectedEOF) {
-			return nil, err
-		}
-
-		// Decrypt the block of ciphertext
-		plaintext, err := aesgcm.Open(nil, nil, ciphertextBlock[:n], nil)
-		if err != nil {
-			return nil, err
-		}
-
-		if _, err := buf.Write(plaintext); err != nil {
-			return nil, err
-		}
-	}
-
-	return &buf, nil
-}
-
 // aesDecryptOFB reads from input, decrypts with AES-256 and returns the reader to a read decrypted content from.
 // passphrase is used to generate an encryption key.
 // note: This function used to decrypt files that were encrypted without a header i.e. old archives
 func aesDecryptOFB(input io.Reader, passphrase []byte) (io.Reader, error) {
+	var emptySalt []byte = make([]byte, 0)
+
 	// making a 32 bytes key that would correspond to AES-256
 	// don't necessarily need a salt, so just kept in empty
-	key, err := scrypt.Key(passphrase, nil, 32768, 8, 1, 32)
+	key, err := scrypt.Key(passphrase, emptySalt, 32768, 8, 1, 32)
 	if err != nil {
 		return nil, err
 	}
@@ -388,18 +228,3 @@ func aesDecryptOFB(input io.Reader, passphrase []byte) (io.Reader, error) {
 
 	return reader, nil
 }
-
-// HasEncryptedHeader checks if the data has an encrypted header, note that fips
-// mode changes this behavior and so will only recognize data encrypted by the
-// same mode (fips enabled or disabled)
-func HasEncryptedHeader(data []byte) bool {
-	return hasEncryptedHeader(data, fips.FIPSMode())
-}
-
-func hasEncryptedHeader(data []byte, fipsMode bool) bool {
-	if fipsMode {
-		return bytes.HasPrefix(data, []byte(aesGcmFIPSHeader))
-	}
-
-	return bytes.HasPrefix(data, []byte(aesGcmHeader))
-}

api/crypto/aes_test.go

@@ -1,25 +1,15 @@
 package crypto
 
 import (
-	"crypto/aes"
-	"crypto/cipher"
 	"io"
 	"math/rand"
 	"os"
 	"path/filepath"
 	"testing"
 
-	"github.com/portainer/portainer/pkg/fips"
-
 	"github.com/stretchr/testify/assert"
-	"github.com/stretchr/testify/require"
-	"golang.org/x/crypto/scrypt"
 )
 
-func init() {
-	fips.InitFIPS(false)
-}
-
 const letterBytes = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789"
 
 func randBytes(n int) []byte {
@@ -27,385 +17,201 @@ func randBytes(n int) []byte {
 	for i := range b {
 		b[i] = letterBytes[rand.Intn(len(letterBytes))]
 	}
-
 	return b
 }
 
-type encryptFunc func(input io.Reader, output io.Writer, passphrase []byte) error
-type decryptFunc func(input io.Reader, passphrase []byte) (io.Reader, error)
-
 func Test_encryptAndDecrypt_withTheSamePassword(t *testing.T) {
 	const passphrase = "passphrase"
 
-	testFunc := func(t *testing.T, encrypt encryptFunc, decrypt decryptFunc, decryptShouldSucceed bool) {
-		tmpdir := t.TempDir()
+	tmpdir := t.TempDir()
 
-		var (
-			originFilePath    = filepath.Join(tmpdir, "origin")
-			encryptedFilePath = filepath.Join(tmpdir, "encrypted")
-			decryptedFilePath = filepath.Join(tmpdir, "decrypted")
-		)
+	var (
+		originFilePath    = filepath.Join(tmpdir, "origin")
+		encryptedFilePath = filepath.Join(tmpdir, "encrypted")
+		decryptedFilePath = filepath.Join(tmpdir, "decrypted")
+	)
 
-		content := randBytes(1024*1024*100 + 523)
-		os.WriteFile(originFilePath, content, 0600)
+	content := randBytes(1024*1024*100 + 523)
+	os.WriteFile(originFilePath, content, 0600)
 
-		originFile, _ := os.Open(originFilePath)
-		defer originFile.Close()
+	originFile, _ := os.Open(originFilePath)
+	defer originFile.Close()
 
-		encryptedFileWriter, _ := os.Create(encryptedFilePath)
+	encryptedFileWriter, _ := os.Create(encryptedFilePath)
 
-		err := encrypt(originFile, encryptedFileWriter, []byte(passphrase))
-		require.Nil(t, err, "Failed to encrypt a file")
-		encryptedFileWriter.Close()
+	err := AesEncrypt(originFile, encryptedFileWriter, []byte(passphrase))
+	assert.Nil(t, err, "Failed to encrypt a file")
+	encryptedFileWriter.Close()
 
-		encryptedContent, err := os.ReadFile(encryptedFilePath)
-		require.Nil(t, err, "Couldn't read encrypted file")
-		assert.NotEqual(t, encryptedContent, content, "Content wasn't encrypted")
+	encryptedContent, err := os.ReadFile(encryptedFilePath)
+	assert.Nil(t, err, "Couldn't read encrypted file")
+	assert.NotEqual(t, encryptedContent, content, "Content wasn't encrypted")
 
-		encryptedFileReader, _ := os.Open(encryptedFilePath)
-		defer encryptedFileReader.Close()
+	encryptedFileReader, _ := os.Open(encryptedFilePath)
+	defer encryptedFileReader.Close()
 
-		decryptedFileWriter, _ := os.Create(decryptedFilePath)
-		defer decryptedFileWriter.Close()
+	decryptedFileWriter, _ := os.Create(decryptedFilePath)
+	defer decryptedFileWriter.Close()
 
-		decryptedReader, err := decrypt(encryptedFileReader, []byte(passphrase))
-		if !decryptShouldSucceed {
-			require.Error(t, err, "Failed to decrypt file as indicated by decryptShouldSucceed")
-		} else {
-			require.NoError(t, err, "Failed to decrypt file indicated by decryptShouldSucceed")
+	decryptedReader, err := AesDecrypt(encryptedFileReader, []byte(passphrase))
+	assert.Nil(t, err, "Failed to decrypt file")
 
-			io.Copy(decryptedFileWriter, decryptedReader)
+	io.Copy(decryptedFileWriter, decryptedReader)
 
-			decryptedContent, _ := os.ReadFile(decryptedFilePath)
-			assert.Equal(t, content, decryptedContent, "Original and decrypted content should match")
-		}
-	}
-
-	t.Run("fips", func(t *testing.T) {
-		testFunc(t, aesEncryptGCMFIPS, aesDecryptGCMFIPS, true)
-	})
-
-	t.Run("non_fips", func(t *testing.T) {
-		testFunc(t, aesEncryptGCM, aesDecryptGCM, true)
-	})
-
-	t.Run("system_fips_mode_public_entry_points", func(t *testing.T) {
-		// use the init mode, public entry points
-		testFunc(t, AesEncrypt, AesDecrypt, true)
-	})
-
-	t.Run("fips_encrypted_file_header_fails_in_non_fips_mode", func(t *testing.T) {
-		// use aesDecrypt which checks the header, confirm that it fails
-		decrypt := func(input io.Reader, passphrase []byte) (io.Reader, error) {
-			return aesDecrypt(input, passphrase, false)
-		}
-
-		testFunc(t, aesEncryptGCMFIPS, decrypt, false)
-	})
-
-	t.Run("non_fips_encrypted_file_header_fails_in_fips_mode", func(t *testing.T) {
-		// use aesDecrypt which checks the header, confirm that it fails
-		decrypt := func(input io.Reader, passphrase []byte) (io.Reader, error) {
-			return aesDecrypt(input, passphrase, true)
-		}
-
-		testFunc(t, aesEncryptGCM, decrypt, false)
-	})
-
-	t.Run("fips_encrypted_file_fails_in_non_fips_mode", func(t *testing.T) {
-		testFunc(t, aesEncryptGCMFIPS, aesDecryptGCM, false)
-	})
-
-	t.Run("non_fips_encrypted_file_with_fips_mode_should_fail", func(t *testing.T) {
-		testFunc(t, aesEncryptGCM, aesDecryptGCMFIPS, false)
-	})
-
-	t.Run("fips_with_base_aesDecrypt", func(t *testing.T) {
-		// maximize coverage, use the base aesDecrypt function with valid fips mode
-		decrypt := func(input io.Reader, passphrase []byte) (io.Reader, error) {
-			return aesDecrypt(input, passphrase, true)
-		}
-
-		testFunc(t, aesEncryptGCMFIPS, decrypt, true)
-	})
-
-	t.Run("legacy", func(t *testing.T) {
-		testFunc(t, legacyAesEncrypt, aesDecryptOFB, true)
-	})
+	decryptedContent, _ := os.ReadFile(decryptedFilePath)
+	assert.Equal(t, content, decryptedContent, "Original and decrypted content should match")
 }
 
 func Test_encryptAndDecrypt_withStrongPassphrase(t *testing.T) {
 	const passphrase = "A strong passphrase with special characters: !@#$%^&*()_+"
+	tmpdir := t.TempDir()
 
-	testFunc := func(t *testing.T, encrypt encryptFunc, decrypt decryptFunc) {
-		tmpdir := t.TempDir()
+	var (
+		originFilePath    = filepath.Join(tmpdir, "origin2")
+		encryptedFilePath = filepath.Join(tmpdir, "encrypted2")
+		decryptedFilePath = filepath.Join(tmpdir, "decrypted2")
+	)
 
-		var (
-			originFilePath    = filepath.Join(tmpdir, "origin2")
-			encryptedFilePath = filepath.Join(tmpdir, "encrypted2")
-			decryptedFilePath = filepath.Join(tmpdir, "decrypted2")
-		)
+	content := randBytes(500)
+	os.WriteFile(originFilePath, content, 0600)
 
-		content := randBytes(500)
-		os.WriteFile(originFilePath, content, 0600)
+	originFile, _ := os.Open(originFilePath)
+	defer originFile.Close()
 
-		originFile, _ := os.Open(originFilePath)
-		defer originFile.Close()
+	encryptedFileWriter, _ := os.Create(encryptedFilePath)
 
-		encryptedFileWriter, _ := os.Create(encryptedFilePath)
+	err := AesEncrypt(originFile, encryptedFileWriter, []byte(passphrase))
+	assert.Nil(t, err, "Failed to encrypt a file")
+	encryptedFileWriter.Close()
 
-		err := encrypt(originFile, encryptedFileWriter, []byte(passphrase))
-		assert.Nil(t, err, "Failed to encrypt a file")
-		encryptedFileWriter.Close()
+	encryptedContent, err := os.ReadFile(encryptedFilePath)
+	assert.Nil(t, err, "Couldn't read encrypted file")
+	assert.NotEqual(t, encryptedContent, content, "Content wasn't encrypted")
 
-		encryptedContent, err := os.ReadFile(encryptedFilePath)
-		assert.Nil(t, err, "Couldn't read encrypted file")
-		assert.NotEqual(t, encryptedContent, content, "Content wasn't encrypted")
+	encryptedFileReader, _ := os.Open(encryptedFilePath)
+	defer encryptedFileReader.Close()
 
-		encryptedFileReader, _ := os.Open(encryptedFilePath)
-		defer encryptedFileReader.Close()
+	decryptedFileWriter, _ := os.Create(decryptedFilePath)
+	defer decryptedFileWriter.Close()
 
-		decryptedFileWriter, _ := os.Create(decryptedFilePath)
-		defer decryptedFileWriter.Close()
+	decryptedReader, err := AesDecrypt(encryptedFileReader, []byte(passphrase))
+	assert.Nil(t, err, "Failed to decrypt file")
 
-		decryptedReader, err := decrypt(encryptedFileReader, []byte(passphrase))
-		assert.Nil(t, err, "Failed to decrypt file")
+	io.Copy(decryptedFileWriter, decryptedReader)
 
-		io.Copy(decryptedFileWriter, decryptedReader)
-
-		decryptedContent, _ := os.ReadFile(decryptedFilePath)
-		assert.Equal(t, content, decryptedContent, "Original and decrypted content should match")
-	}
-
-	t.Run("fips", func(t *testing.T) {
-		testFunc(t, aesEncryptGCMFIPS, aesDecryptGCMFIPS)
-	})
-
-	t.Run("non_fips", func(t *testing.T) {
-		testFunc(t, aesEncryptGCM, aesDecryptGCM)
-	})
+	decryptedContent, _ := os.ReadFile(decryptedFilePath)
+	assert.Equal(t, content, decryptedContent, "Original and decrypted content should match")
 }
 
 func Test_encryptAndDecrypt_withTheSamePasswordSmallFile(t *testing.T) {
-	testFunc := func(t *testing.T, encrypt encryptFunc, decrypt decryptFunc) {
-		tmpdir := t.TempDir()
+	tmpdir := t.TempDir()
 
-		var (
-			originFilePath    = filepath.Join(tmpdir, "origin2")
-			encryptedFilePath = filepath.Join(tmpdir, "encrypted2")
-			decryptedFilePath = filepath.Join(tmpdir, "decrypted2")
-		)
+	var (
+		originFilePath    = filepath.Join(tmpdir, "origin2")
+		encryptedFilePath = filepath.Join(tmpdir, "encrypted2")
+		decryptedFilePath = filepath.Join(tmpdir, "decrypted2")
+	)
 
-		content := randBytes(500)
-		os.WriteFile(originFilePath, content, 0600)
+	content := randBytes(500)
+	os.WriteFile(originFilePath, content, 0600)
 
-		originFile, _ := os.Open(originFilePath)
-		defer originFile.Close()
+	originFile, _ := os.Open(originFilePath)
+	defer originFile.Close()
 
-		encryptedFileWriter, _ := os.Create(encryptedFilePath)
+	encryptedFileWriter, _ := os.Create(encryptedFilePath)
 
-		err := encrypt(originFile, encryptedFileWriter, []byte("passphrase"))
-		assert.Nil(t, err, "Failed to encrypt a file")
-		encryptedFileWriter.Close()
+	err := AesEncrypt(originFile, encryptedFileWriter, []byte("passphrase"))
+	assert.Nil(t, err, "Failed to encrypt a file")
+	encryptedFileWriter.Close()
 
-		encryptedContent, err := os.ReadFile(encryptedFilePath)
-		assert.Nil(t, err, "Couldn't read encrypted file")
-		assert.NotEqual(t, encryptedContent, content, "Content wasn't encrypted")
+	encryptedContent, err := os.ReadFile(encryptedFilePath)
+	assert.Nil(t, err, "Couldn't read encrypted file")
+	assert.NotEqual(t, encryptedContent, content, "Content wasn't encrypted")
 
-		encryptedFileReader, _ := os.Open(encryptedFilePath)
-		defer encryptedFileReader.Close()
+	encryptedFileReader, _ := os.Open(encryptedFilePath)
+	defer encryptedFileReader.Close()
 
-		decryptedFileWriter, _ := os.Create(decryptedFilePath)
-		defer decryptedFileWriter.Close()
+	decryptedFileWriter, _ := os.Create(decryptedFilePath)
+	defer decryptedFileWriter.Close()
 
-		decryptedReader, err := decrypt(encryptedFileReader, []byte("passphrase"))
-		assert.Nil(t, err, "Failed to decrypt file")
+	decryptedReader, err := AesDecrypt(encryptedFileReader, []byte("passphrase"))
+	assert.Nil(t, err, "Failed to decrypt file")
 
-		io.Copy(decryptedFileWriter, decryptedReader)
+	io.Copy(decryptedFileWriter, decryptedReader)
 
-		decryptedContent, _ := os.ReadFile(decryptedFilePath)
-		assert.Equal(t, content, decryptedContent, "Original and decrypted content should match")
-	}
-
-	t.Run("fips", func(t *testing.T) {
-		testFunc(t, aesEncryptGCMFIPS, aesDecryptGCMFIPS)
-	})
-
-	t.Run("non_fips", func(t *testing.T) {
-		testFunc(t, aesEncryptGCM, aesDecryptGCM)
-	})
+	decryptedContent, _ := os.ReadFile(decryptedFilePath)
+	assert.Equal(t, content, decryptedContent, "Original and decrypted content should match")
 }
 
 func Test_encryptAndDecrypt_withEmptyPassword(t *testing.T) {
-	testFunc := func(t *testing.T, encrypt encryptFunc, decrypt decryptFunc) {
-		tmpdir := t.TempDir()
+	tmpdir := t.TempDir()
 
-		var (
-			originFilePath    = filepath.Join(tmpdir, "origin")
-			encryptedFilePath = filepath.Join(tmpdir, "encrypted")
-			decryptedFilePath = filepath.Join(tmpdir, "decrypted")
-		)
+	var (
+		originFilePath    = filepath.Join(tmpdir, "origin")
+		encryptedFilePath = filepath.Join(tmpdir, "encrypted")
+		decryptedFilePath = filepath.Join(tmpdir, "decrypted")
+	)
 
-		content := randBytes(1024 * 50)
-		os.WriteFile(originFilePath, content, 0600)
+	content := randBytes(1024 * 50)
+	os.WriteFile(originFilePath, content, 0600)
 
-		originFile, _ := os.Open(originFilePath)
-		defer originFile.Close()
+	originFile, _ := os.Open(originFilePath)
+	defer originFile.Close()
 
-		encryptedFileWriter, _ := os.Create(encryptedFilePath)
-		defer encryptedFileWriter.Close()
+	encryptedFileWriter, _ := os.Create(encryptedFilePath)
+	defer encryptedFileWriter.Close()
 
-		err := encrypt(originFile, encryptedFileWriter, []byte(""))
-		assert.Nil(t, err, "Failed to encrypt a file")
-		encryptedContent, err := os.ReadFile(encryptedFilePath)
-		assert.Nil(t, err, "Couldn't read encrypted file")
-		assert.NotEqual(t, encryptedContent, content, "Content wasn't encrypted")
+	err := AesEncrypt(originFile, encryptedFileWriter, []byte(""))
+	assert.Nil(t, err, "Failed to encrypt a file")
+	encryptedContent, err := os.ReadFile(encryptedFilePath)
+	assert.Nil(t, err, "Couldn't read encrypted file")
+	assert.NotEqual(t, encryptedContent, content, "Content wasn't encrypted")
 
-		encryptedFileReader, _ := os.Open(encryptedFilePath)
-		defer encryptedFileReader.Close()
+	encryptedFileReader, _ := os.Open(encryptedFilePath)
+	defer encryptedFileReader.Close()
 
-		decryptedFileWriter, _ := os.Create(decryptedFilePath)
-		defer decryptedFileWriter.Close()
+	decryptedFileWriter, _ := os.Create(decryptedFilePath)
+	defer decryptedFileWriter.Close()
 
-		decryptedReader, err := decrypt(encryptedFileReader, []byte(""))
-		assert.Nil(t, err, "Failed to decrypt file")
+	decryptedReader, err := AesDecrypt(encryptedFileReader, []byte(""))
+	assert.Nil(t, err, "Failed to decrypt file")
 
-		io.Copy(decryptedFileWriter, decryptedReader)
+	io.Copy(decryptedFileWriter, decryptedReader)
 
-		decryptedContent, _ := os.ReadFile(decryptedFilePath)
-		assert.Equal(t, content, decryptedContent, "Original and decrypted content should match")
-	}
-
-	t.Run("fips", func(t *testing.T) {
-		testFunc(t, aesEncryptGCMFIPS, aesDecryptGCMFIPS)
-	})
-
-	t.Run("non_fips", func(t *testing.T) {
-		testFunc(t, aesEncryptGCM, aesDecryptGCM)
-	})
+	decryptedContent, _ := os.ReadFile(decryptedFilePath)
+	assert.Equal(t, content, decryptedContent, "Original and decrypted content should match")
 }
 
 func Test_decryptWithDifferentPassphrase_shouldProduceWrongResult(t *testing.T) {
-	testFunc := func(t *testing.T, encrypt encryptFunc, decrypt decryptFunc) {
-		tmpdir := t.TempDir()
+	tmpdir := t.TempDir()
 
-		var (
-			originFilePath    = filepath.Join(tmpdir, "origin")
-			encryptedFilePath = filepath.Join(tmpdir, "encrypted")
-			decryptedFilePath = filepath.Join(tmpdir, "decrypted")
-		)
+	var (
+		originFilePath    = filepath.Join(tmpdir, "origin")
+		encryptedFilePath = filepath.Join(tmpdir, "encrypted")
+		decryptedFilePath = filepath.Join(tmpdir, "decrypted")
+	)
 
-		content := randBytes(1034)
-		os.WriteFile(originFilePath, content, 0600)
+	content := randBytes(1034)
+	os.WriteFile(originFilePath, content, 0600)
 
-		originFile, _ := os.Open(originFilePath)
-		defer originFile.Close()
+	originFile, _ := os.Open(originFilePath)
+	defer originFile.Close()
 
-		encryptedFileWriter, _ := os.Create(encryptedFilePath)
-		defer encryptedFileWriter.Close()
+	encryptedFileWriter, _ := os.Create(encryptedFilePath)
+	defer encryptedFileWriter.Close()
 
-		err := encrypt(originFile, encryptedFileWriter, []byte("passphrase"))
-		assert.Nil(t, err, "Failed to encrypt a file")
-		encryptedContent, err := os.ReadFile(encryptedFilePath)
-		assert.Nil(t, err, "Couldn't read encrypted file")
-		assert.NotEqual(t, encryptedContent, content, "Content wasn't encrypted")
+	err := AesEncrypt(originFile, encryptedFileWriter, []byte("passphrase"))
+	assert.Nil(t, err, "Failed to encrypt a file")
+	encryptedContent, err := os.ReadFile(encryptedFilePath)
+	assert.Nil(t, err, "Couldn't read encrypted file")
+	assert.NotEqual(t, encryptedContent, content, "Content wasn't encrypted")
 
-		encryptedFileReader, _ := os.Open(encryptedFilePath)
-		defer encryptedFileReader.Close()
+	encryptedFileReader, _ := os.Open(encryptedFilePath)
+	defer encryptedFileReader.Close()
 
-		decryptedFileWriter, _ := os.Create(decryptedFilePath)
-		defer decryptedFileWriter.Close()
+	decryptedFileWriter, _ := os.Create(decryptedFilePath)
+	defer decryptedFileWriter.Close()
 
-		_, err = decrypt(encryptedFileReader, []byte("garbage"))
-		assert.NotNil(t, err, "Should not allow decrypt with wrong passphrase")
-	}
-
-	t.Run("fips", func(t *testing.T) {
-		testFunc(t, aesEncryptGCMFIPS, aesDecryptGCMFIPS)
-	})
-
-	t.Run("non_fips", func(t *testing.T) {
-		testFunc(t, aesEncryptGCM, aesDecryptGCM)
-	})
-}
-
-func legacyAesEncrypt(input io.Reader, output io.Writer, passphrase []byte) error {
-	key, err := scrypt.Key(passphrase, nil, 32768, 8, 1, 32)
-	if err != nil {
-		return err
-	}
-
-	block, err := aes.NewCipher(key)
-	if err != nil {
-		return err
-	}
-
-	var iv [aes.BlockSize]byte
-	stream := cipher.NewOFB(block, iv[:])
-
-	writer := &cipher.StreamWriter{S: stream, W: output}
-	if _, err := io.Copy(writer, input); err != nil {
-		return err
-	}
-
-	return nil
-}
-
-func Test_hasEncryptedHeader(t *testing.T) {
-	tests := []struct {
-		name     string
-		data     []byte
-		fipsMode bool
-		want     bool
-	}{
-		{
-			name:     "non-FIPS mode with valid header",
-			data:     []byte("AES256-GCM" + "some encrypted data"),
-			fipsMode: false,
-			want:     true,
-		},
-		{
-			name:     "non-FIPS mode with FIPS header",
-			data:     []byte("FIPS-AES256-GCM" + "some encrypted data"),
-			fipsMode: false,
-			want:     false,
-		},
-		{
-			name:     "FIPS mode with valid header",
-			data:     []byte("FIPS-AES256-GCM" + "some encrypted data"),
-			fipsMode: true,
-			want:     true,
-		},
-		{
-			name:     "FIPS mode with non-FIPS header",
-			data:     []byte("AES256-GCM" + "some encrypted data"),
-			fipsMode: true,
-			want:     false,
-		},
-		{
-			name:     "invalid header",
-			data:     []byte("INVALID-HEADER" + "some data"),
-			fipsMode: false,
-			want:     false,
-		},
-		{
-			name:     "empty data",
-			data:     []byte{},
-			fipsMode: false,
-			want:     false,
-		},
-		{
-			name:     "nil data",
-			data:     nil,
-			fipsMode: false,
-			want:     false,
-		},
-	}
-
-	for _, tt := range tests {
-		t.Run(tt.name, func(t *testing.T) {
-			got := hasEncryptedHeader(tt.data, tt.fipsMode)
-			assert.Equal(t, tt.want, got)
-		})
-	}
+	_, err = AesDecrypt(encryptedFileReader, []byte("garbage"))
+	assert.NotNil(t, err, "Should not allow decrypt with wrong passphrase")
 }

api/crypto/ecdsa.go

@@ -112,7 +112,7 @@ func (service *ECDSAService) CreateSignature(message string) (string, error) {
 		message = service.secret
 	}
 
-	hash := libcrypto.InsecureHashFromBytes([]byte(message))
+	hash := libcrypto.HashFromBytes([]byte(message))
 
 	r, s, err := ecdsa.Sign(rand.Reader, service.privateKey, hash)
 	if err != nil {

api/crypto/ecdsa_test.go

@@ -1,22 +0,0 @@
-package crypto
-
-import (
-	"testing"
-
-	"github.com/stretchr/testify/require"
-)
-
-func TestCreateSignature(t *testing.T) {
-	var s = NewECDSAService("secret")
-
-	privKey, pubKey, err := s.GenerateKeyPair()
-	require.NoError(t, err)
-	require.Greater(t, len(privKey), 0)
-	require.Greater(t, len(pubKey), 0)
-
-	m := "test message"
-	r, err := s.CreateSignature(m)
-	require.NoError(t, err)
-	require.NotEqual(t, r, m)
-	require.Greater(t, len(r), 0)
-}

api/crypto/hash.go

@@ -8,16 +8,15 @@ import (
 type Service struct{}
 
 // Hash hashes a string using the bcrypt algorithm
-func (Service) Hash(data string) (string, error) {
+func (*Service) Hash(data string) (string, error) {
 	bytes, err := bcrypt.GenerateFromPassword([]byte(data), bcrypt.DefaultCost)
 	if err != nil {
 		return "", err
 	}
-
 	return string(bytes), err
 }
 
 // CompareHashAndData compares a hash to clear data and returns an error if the comparison fails.
-func (Service) CompareHashAndData(hash string, data string) error {
+func (*Service) CompareHashAndData(hash string, data string) error {
 	return bcrypt.CompareHashAndPassword([]byte(hash), []byte(data))
 }

api/crypto/hash_test.go

@@ -2,12 +2,10 @@ package crypto
 
 import (
 	"testing"
-
-	"github.com/stretchr/testify/require"
 )
 
 func TestService_Hash(t *testing.T) {
-	var s = Service{}
+	var s = &Service{}
 
 	type args struct {
 		hash string
@@ -53,11 +51,3 @@ func TestService_Hash(t *testing.T) {
 		})
 	}
 }
-
-func TestHash(t *testing.T) {
-	s := Service{}
-
-	hash, err := s.Hash("Passw0rd!")
-	require.NoError(t, err)
-	require.NotEmpty(t, hash)
-}

api/crypto/nonce.go

@@ -15,7 +15,7 @@ func NewNonce(size int) *Nonce {
 }
 
 // NewRandomNonce generates a new initial nonce with the lower byte set to a random value
-// This ensures there are plenty of nonce values available before rolling over
+// This ensures there are plenty of nonce values availble before rolling over
 // Based on ideas from the Secure Programming Cookbook for C and C++ by John Viega, Matt Messier
 // https://www.oreilly.com/library/view/secure-programming-cookbook/0596003943/ch04s09.html
 func NewRandomNonce(size int) (*Nonce, error) {

api/crypto/tls.go

@@ -4,32 +4,11 @@ import (
 	"crypto/tls"
 	"crypto/x509"
 	"os"
-
-	portainer "github.com/portainer/portainer/api"
-	"github.com/portainer/portainer/pkg/fips"
 )
 
 // CreateTLSConfiguration creates a basic tls.Config with recommended TLS settings
-func CreateTLSConfiguration(insecureSkipVerify bool) *tls.Config { //nolint:forbidigo
-	return createTLSConfiguration(fips.FIPSMode(), insecureSkipVerify)
-}
-
-func createTLSConfiguration(fipsEnabled bool, insecureSkipVerify bool) *tls.Config { //nolint:forbidigo
-	if fipsEnabled {
-		return &tls.Config{ //nolint:forbidigo
-			MinVersion: tls.VersionTLS12,
-			MaxVersion: tls.VersionTLS13,
-			CipherSuites: []uint16{
-				tls.TLS_ECDHE_RSA_WITH_AES_128_GCM_SHA256,
-				tls.TLS_ECDHE_RSA_WITH_AES_256_GCM_SHA384,
-				tls.TLS_ECDHE_ECDSA_WITH_AES_128_GCM_SHA256,
-				tls.TLS_ECDHE_ECDSA_WITH_AES_256_GCM_SHA384,
-			},
-			CurvePreferences: []tls.CurveID{tls.CurveP256, tls.CurveP384, tls.CurveP521},
-		}
-	}
-
-	return &tls.Config{ //nolint:forbidigo
+func CreateTLSConfiguration() *tls.Config {
+	return &tls.Config{
 		MinVersion: tls.VersionTLS12,
 		CipherSuites: []uint16{
 			tls.TLS_AES_128_GCM_SHA256,
@@ -50,33 +29,24 @@ func createTLSConfiguration(fipsEnabled bool, insecureSkipVerify bool) *tls.Conf
 			tls.TLS_ECDHE_RSA_WITH_CHACHA20_POLY1305_SHA256,
 			tls.TLS_ECDHE_ECDSA_WITH_CHACHA20_POLY1305_SHA256,
 		},
-		InsecureSkipVerify: insecureSkipVerify, //nolint:forbidigo
 	}
 }
 
 // CreateTLSConfigurationFromBytes initializes a tls.Config using a CA certificate, a certificate and a key
 // loaded from memory.
-func CreateTLSConfigurationFromBytes(useTLS bool, caCert, cert, key []byte, skipClientVerification, skipServerVerification bool) (*tls.Config, error) { //nolint:forbidigo
-	return createTLSConfigurationFromBytes(fips.FIPSMode(), useTLS, caCert, cert, key, skipClientVerification, skipServerVerification)
-}
+func CreateTLSConfigurationFromBytes(caCert, cert, key []byte, skipClientVerification, skipServerVerification bool) (*tls.Config, error) {
+	config := CreateTLSConfiguration()
+	config.InsecureSkipVerify = skipServerVerification
 
-func createTLSConfigurationFromBytes(fipsEnabled, useTLS bool, caCert, cert, key []byte, skipClientVerification, skipServerVerification bool) (*tls.Config, error) { //nolint:forbidigo
-	if !useTLS {
-		return nil, nil
-	}
-
-	config := createTLSConfiguration(fipsEnabled, skipServerVerification)
-
-	if !skipClientVerification || fipsEnabled {
+	if !skipClientVerification {
 		certificate, err := tls.X509KeyPair(cert, key)
 		if err != nil {
 			return nil, err
 		}
-
 		config.Certificates = []tls.Certificate{certificate}
 	}
 
-	if !skipServerVerification || fipsEnabled {
+	if !skipServerVerification {
 		caCertPool := x509.NewCertPool()
 		caCertPool.AppendCertsFromPEM(caCert)
 		config.RootCAs = caCertPool
@@ -87,36 +57,29 @@ func createTLSConfigurationFromBytes(fipsEnabled, useTLS bool, caCert, cert, key
 
 // CreateTLSConfigurationFromDisk initializes a tls.Config using a CA certificate, a certificate and a key
 // loaded from disk.
-func CreateTLSConfigurationFromDisk(config portainer.TLSConfiguration) (*tls.Config, error) { //nolint:forbidigo
-	return createTLSConfigurationFromDisk(fips.FIPSMode(), config)
-}
+func CreateTLSConfigurationFromDisk(caCertPath, certPath, keyPath string, skipServerVerification bool) (*tls.Config, error) {
+	config := CreateTLSConfiguration()
+	config.InsecureSkipVerify = skipServerVerification
 
-func createTLSConfigurationFromDisk(fipsEnabled bool, config portainer.TLSConfiguration) (*tls.Config, error) { //nolint:forbidigo
-	if !config.TLS {
-		return nil, nil
-	}
-
-	tlsConfig := createTLSConfiguration(fipsEnabled, config.TLSSkipVerify)
-
-	if config.TLSCertPath != "" && config.TLSKeyPath != "" {
-		cert, err := tls.LoadX509KeyPair(config.TLSCertPath, config.TLSKeyPath)
+	if certPath != "" && keyPath != "" {
+		cert, err := tls.LoadX509KeyPair(certPath, keyPath)
 		if err != nil {
 			return nil, err
 		}
 
-		tlsConfig.Certificates = []tls.Certificate{cert}
+		config.Certificates = []tls.Certificate{cert}
 	}
 
-	if !tlsConfig.InsecureSkipVerify && config.TLSCACertPath != "" { //nolint:forbidigo
-		caCert, err := os.ReadFile(config.TLSCACertPath)
+	if !skipServerVerification && caCertPath != "" {
+		caCert, err := os.ReadFile(caCertPath)
 		if err != nil {
 			return nil, err
 		}
 
 		caCertPool := x509.NewCertPool()
 		caCertPool.AppendCertsFromPEM(caCert)
-		tlsConfig.RootCAs = caCertPool
+		config.RootCAs = caCertPool
 	}
 
-	return tlsConfig, nil
+	return config, nil
 }

api/crypto/tls_test.go

@@ -1,87 +0,0 @@
-package crypto
-
-import (
-	"crypto/tls"
-	"testing"
-
-	portainer "github.com/portainer/portainer/api"
-
-	"github.com/stretchr/testify/require"
-)
-
-func TestCreateTLSConfiguration(t *testing.T) {
-	// InsecureSkipVerify = false
-	config := CreateTLSConfiguration(false)
-	require.Equal(t, config.MinVersion, uint16(tls.VersionTLS12)) //nolint:forbidigo
-	require.False(t, config.InsecureSkipVerify)                   //nolint:forbidigo
-
-	// InsecureSkipVerify = true
-	config = CreateTLSConfiguration(true)
-	require.Equal(t, config.MinVersion, uint16(tls.VersionTLS12)) //nolint:forbidigo
-	require.True(t, config.InsecureSkipVerify)                    //nolint:forbidigo
-}
-
-func TestCreateTLSConfigurationFIPS(t *testing.T) {
-	fips := true
-
-	fipsCipherSuites := []uint16{
-		tls.TLS_ECDHE_RSA_WITH_AES_128_GCM_SHA256,
-		tls.TLS_ECDHE_RSA_WITH_AES_256_GCM_SHA384,
-		tls.TLS_ECDHE_ECDSA_WITH_AES_128_GCM_SHA256,
-		tls.TLS_ECDHE_ECDSA_WITH_AES_256_GCM_SHA384,
-	}
-
-	fipsCurvePreferences := []tls.CurveID{tls.CurveP256, tls.CurveP384, tls.CurveP521}
-
-	config := createTLSConfiguration(fips, false)
-	require.Equal(t, config.MinVersion, uint16(tls.VersionTLS12))   //nolint:forbidigo
-	require.Equal(t, config.MaxVersion, uint16(tls.VersionTLS13))   //nolint:forbidigo
-	require.Equal(t, config.CipherSuites, fipsCipherSuites)         //nolint:forbidigo
-	require.Equal(t, config.CurvePreferences, fipsCurvePreferences) //nolint:forbidigo
-	require.False(t, config.InsecureSkipVerify)                     //nolint:forbidigo
-}
-
-func TestCreateTLSConfigurationFromBytes(t *testing.T) {
-	// No TLS
-	config, err := CreateTLSConfigurationFromBytes(false, nil, nil, nil, false, false)
-	require.Nil(t, err)
-	require.Nil(t, config)
-
-	// Skip TLS client/server verifications
-	config, err = CreateTLSConfigurationFromBytes(true, nil, nil, nil, true, true)
-	require.NoError(t, err)
-	require.NotNil(t, config)
-
-	// Empty TLS
-	config, err = CreateTLSConfigurationFromBytes(true, nil, nil, nil, false, false)
-	require.Error(t, err)
-	require.Nil(t, config)
-}
-
-func TestCreateTLSConfigurationFromDisk(t *testing.T) {
-	// No TLS
-	config, err := CreateTLSConfigurationFromDisk(portainer.TLSConfiguration{})
-	require.Nil(t, err)
-	require.Nil(t, config)
-
-	// Skip TLS verifications
-	config, err = CreateTLSConfigurationFromDisk(portainer.TLSConfiguration{
-		TLS:           true,
-		TLSSkipVerify: true,
-	})
-	require.NoError(t, err)
-	require.NotNil(t, config)
-}
-
-func TestCreateTLSConfigurationFromDiskFIPS(t *testing.T) {
-	fips := true
-
-	// Skipping TLS verifications cannot be done in FIPS mode
-	config, err := createTLSConfigurationFromDisk(fips, portainer.TLSConfiguration{
-		TLS:           true,
-		TLSSkipVerify: true,
-	})
-	require.NoError(t, err)
-	require.NotNil(t, config)
-	require.False(t, config.InsecureSkipVerify) //nolint:forbidigo
-}

api/database/boltdb/db.go

@@ -21,9 +21,6 @@ import (
 const (
 	DatabaseFileName          = "portainer.db"
 	EncryptedDatabaseFileName = "portainer.edb"
-
-	txMaxSize       = 65536
-	compactedSuffix = ".compacted"
 )
 
 var (
@@ -38,7 +35,6 @@ type DbConnection struct {
 	InitialMmapSize int
 	EncryptionKey   []byte
 	isEncrypted     bool
-	Compact         bool
 
 	*bolt.DB
 }
@@ -66,15 +62,6 @@ func (connection *DbConnection) GetStorePath() string {
 	return connection.Path
 }
 
-func (connection *DbConnection) GetDatabaseFileSize() (int64, error) {
-	file, err := os.Stat(connection.GetDatabaseFilePath())
-	if err != nil {
-		return 0, fmt.Errorf("Failed to stat database file path: %s err: %w", connection.GetDatabaseFilePath(), err)
-	}
-
-	return file.Size(), nil
-}
-
 func (connection *DbConnection) SetEncrypted(flag bool) {
 	connection.isEncrypted = flag
 }
@@ -139,7 +126,10 @@ func (connection *DbConnection) Open() error {
 	// Now we open the db
 	databasePath := connection.GetDatabaseFilePath()
 
-	db, err := bolt.Open(databasePath, 0600, connection.boltOptions())
+	db, err := bolt.Open(databasePath, 0600, &bolt.Options{
+		Timeout:         1 * time.Second,
+		InitialMmapSize: connection.InitialMmapSize,
+	})
 	if err != nil {
 		return err
 	}
@@ -148,15 +138,6 @@ func (connection *DbConnection) Open() error {
 	db.MaxBatchDelay = connection.MaxBatchDelay
 	connection.DB = db
 
-	if connection.Compact {
-		log.Info().Msg("compacting database")
-		if err := connection.compact(); err != nil {
-			log.Error().Err(err).Msg("failed to compact database")
-		} else {
-			log.Info().Msg("database compaction completed")
-		}
-	}
-
 	return nil
 }
 
@@ -254,32 +235,6 @@ func (connection *DbConnection) GetObject(bucketName string, key []byte, object
 	})
 }
 
-func (connection *DbConnection) GetRawBytes(bucketName string, key []byte) ([]byte, error) {
-	var value []byte
-
-	err := connection.ViewTx(func(tx portainer.Transaction) error {
-		var err error
-		value, err = tx.GetRawBytes(bucketName, key)
-
-		return err
-	})
-
-	return value, err
-}
-
-func (connection *DbConnection) KeyExists(bucketName string, key []byte) (bool, error) {
-	var exists bool
-
-	err := connection.ViewTx(func(tx portainer.Transaction) error {
-		var err error
-		exists, err = tx.KeyExists(bucketName, key)
-
-		return err
-	})
-
-	return exists, err
-}
-
 func (connection *DbConnection) getEncryptionKey() []byte {
 	if !connection.isEncrypted {
 		return nil
@@ -422,42 +377,3 @@ func (connection *DbConnection) RestoreMetadata(s map[string]any) error {
 
 	return err
 }
-
-// compact attempts to compact the database and replace it iff it succeeds
-func (connection *DbConnection) compact() error {
-	compactedPath := connection.GetDatabaseFilePath() + compactedSuffix
-	compactedDB, err := bolt.Open(compactedPath, 0o600, connection.boltOptions())
-	if err != nil {
-		return fmt.Errorf("failure to create the compacted database: %w", err)
-	}
-
-	compactedDB.MaxBatchSize = connection.MaxBatchSize
-	compactedDB.MaxBatchDelay = connection.MaxBatchDelay
-
-	if err := bolt.Compact(compactedDB, connection.DB, txMaxSize); err != nil {
-		return fmt.Errorf("failure to compact the database: %w",
-			errors.Join(err, compactedDB.Close(), os.Remove(compactedPath)))
-	}
-
-	if err := os.Rename(compactedPath, connection.GetDatabaseFilePath()); err != nil {
-		return fmt.Errorf("failure to move the compacted database: %w",
-			errors.Join(err, compactedDB.Close(), os.Remove(compactedPath)))
-	}
-
-	if err := connection.Close(); err != nil {
-		log.Warn().Err(err).Msg("failure to close the database after compaction")
-	}
-
-	connection.DB = compactedDB
-
-	return nil
-}
-
-func (connection *DbConnection) boltOptions() *bolt.Options {
-	return &bolt.Options{
-		Timeout:         1 * time.Second,
-		InitialMmapSize: connection.InitialMmapSize,
-		FreelistType:    bolt.FreelistMapType,
-		NoFreelistSync:  true,
-	}
-}

api/database/boltdb/db_test.go

@@ -6,8 +6,6 @@ import (
 	"testing"
 
 	"github.com/stretchr/testify/assert"
-	"github.com/stretchr/testify/require"
-	"go.etcd.io/bbolt"
 )
 
 func Test_NeedsEncryptionMigration(t *testing.T) {
@@ -121,57 +119,3 @@ func Test_NeedsEncryptionMigration(t *testing.T) {
 		})
 	}
 }
-
-func TestDBCompaction(t *testing.T) {
-	db := &DbConnection{
-		Path:    t.TempDir(),
-		Compact: true,
-	}
-
-	err := db.Open()
-	require.NoError(t, err)
-
-	err = db.Update(func(tx *bbolt.Tx) error {
-		b, err := tx.CreateBucketIfNotExists([]byte("testbucket"))
-		if err != nil {
-			return err
-		}
-
-		b.Put([]byte("key"), []byte("value"))
-
-		return nil
-	})
-	require.NoError(t, err)
-
-	err = db.Close()
-	require.NoError(t, err)
-
-	// Reopen the DB to trigger compaction
-	err = db.Open()
-	require.NoError(t, err)
-
-	// Check that the data is still there
-	err = db.View(func(tx *bbolt.Tx) error {
-		b := tx.Bucket([]byte("testbucket"))
-		if b == nil {
-			return nil
-		}
-
-		val := b.Get([]byte("key"))
-		require.Equal(t, []byte("value"), val)
-
-		return nil
-	})
-	require.NoError(t, err)
-
-	err = db.Close()
-	require.NoError(t, err)
-
-	// Failures
-
-	err = os.Mkdir(db.GetDatabaseFilePath()+compactedSuffix, 0o755)
-	require.NoError(t, err)
-
-	err = db.Open()
-	require.NoError(t, err)
-}

api/database/boltdb/json.go

@@ -4,6 +4,8 @@ import (
 	"bytes"
 	"crypto/aes"
 	"crypto/cipher"
+	"crypto/rand"
+	"io"
 
 	"github.com/pkg/errors"
 	"github.com/segmentio/encoding/json"
@@ -63,18 +65,18 @@ func (connection *DbConnection) UnmarshalObject(data []byte, object any) error {
 // https://gist.github.com/atoponce/07d8d4c833873be2f68c34f9afc5a78a#symmetric-encryption
 
 func encrypt(plaintext []byte, passphrase []byte) (encrypted []byte, err error) {
-	block, err := aes.NewCipher(passphrase)
+	block, _ := aes.NewCipher(passphrase)
+	gcm, err := cipher.NewGCM(block)
 	if err != nil {
 		return encrypted, err
 	}
 
-	// NewGCMWithRandomNonce in go 1.24 handles setting up the nonce and adding it to the encrypted output
-	gcm, err := cipher.NewGCMWithRandomNonce(block)
-	if err != nil {
+	nonce := make([]byte, gcm.NonceSize())
+	if _, err := io.ReadFull(rand.Reader, nonce); err != nil {
 		return encrypted, err
 	}
 
-	return gcm.Seal(nil, nil, plaintext, nil), nil
+	return gcm.Seal(nonce, nonce, plaintext, nil), nil
 }
 
 func decrypt(encrypted []byte, passphrase []byte) (plaintextByte []byte, err error) {
@@ -87,17 +89,19 @@ func decrypt(encrypted []byte, passphrase []byte) (plaintextByte []byte, err err
 		return encrypted, errors.Wrap(err, "Error creating cypher block")
 	}
 
-	// NewGCMWithRandomNonce in go 1.24 handles reading the nonce from the encrypted input for us
-	gcm, err := cipher.NewGCMWithRandomNonce(block)
+	gcm, err := cipher.NewGCM(block)
 	if err != nil {
 		return encrypted, errors.Wrap(err, "Error creating GCM")
 	}
 
-	if len(encrypted) < gcm.NonceSize() {
+	nonceSize := gcm.NonceSize()
+	if len(encrypted) < nonceSize {
 		return encrypted, errEncryptedStringTooShort
 	}
 
-	plaintextByte, err = gcm.Open(nil, nil, encrypted, nil)
+	nonce, ciphertextByteClean := encrypted[:nonceSize], encrypted[nonceSize:]
+
+	plaintextByte, err = gcm.Open(nil, nonce, ciphertextByteClean, nil)
 	if err != nil {
 		return encrypted, errors.Wrap(err, "Error decrypting text")
 	}

api/database/boltdb/json_test.go

@@ -1,19 +1,12 @@
 package boltdb
 
 import (
-	"crypto/aes"
-	"crypto/cipher"
-	"crypto/rand"
 	"crypto/sha256"
-	"encoding/base64"
 	"fmt"
-	"io"
 	"testing"
 
 	"github.com/gofrs/uuid"
-	"github.com/pkg/errors"
 	"github.com/stretchr/testify/assert"
-	"github.com/stretchr/testify/require"
 )
 
 const (
@@ -167,7 +160,7 @@ func Test_ObjectMarshallingEncrypted(t *testing.T) {
 	}
 
 	key := secretToEncryptionKey(passphrase)
-	conn := DbConnection{EncryptionKey: key, isEncrypted: true}
+	conn := DbConnection{EncryptionKey: key}
 	for _, test := range tests {
 		t.Run(fmt.Sprintf("%s -> %s", test.object, test.expected), func(t *testing.T) {
 
@@ -182,94 +175,3 @@ func Test_ObjectMarshallingEncrypted(t *testing.T) {
 		})
 	}
 }
-
-func Test_NonceSources(t *testing.T) {
-	// ensure that the new go 1.24 NewGCMWithRandomNonce works correctly with
-	// the old way of creating and including the nonce
-
-	encryptOldFn := func(plaintext []byte, passphrase []byte) (encrypted []byte, err error) {
-		block, _ := aes.NewCipher(passphrase)
-		gcm, err := cipher.NewGCM(block)
-		if err != nil {
-			return encrypted, err
-		}
-
-		nonce := make([]byte, gcm.NonceSize())
-		if _, err := io.ReadFull(rand.Reader, nonce); err != nil {
-			return encrypted, err
-		}
-
-		return gcm.Seal(nonce, nonce, plaintext, nil), nil
-	}
-
-	decryptOldFn := func(encrypted []byte, passphrase []byte) (plaintext []byte, err error) {
-		block, err := aes.NewCipher(passphrase)
-		if err != nil {
-			return encrypted, errors.Wrap(err, "Error creating cypher block")
-		}
-
-		gcm, err := cipher.NewGCM(block)
-		if err != nil {
-			return encrypted, errors.Wrap(err, "Error creating GCM")
-		}
-
-		nonceSize := gcm.NonceSize()
-		if len(encrypted) < nonceSize {
-			return encrypted, errEncryptedStringTooShort
-		}
-
-		nonce, ciphertextByteClean := encrypted[:nonceSize], encrypted[nonceSize:]
-
-		plaintext, err = gcm.Open(nil, nonce, ciphertextByteClean, nil)
-		if err != nil {
-			return encrypted, errors.Wrap(err, "Error decrypting text")
-		}
-
-		return plaintext, err
-	}
-
-	encryptNewFn := encrypt
-	decryptNewFn := decrypt
-
-	passphrase := make([]byte, 32)
-	_, err := io.ReadFull(rand.Reader, passphrase)
-	require.NoError(t, err)
-
-	junk := make([]byte, 1024)
-	_, err = io.ReadFull(rand.Reader, junk)
-	require.NoError(t, err)
-
-	junkEnc := make([]byte, base64.StdEncoding.EncodedLen(len(junk)))
-	base64.StdEncoding.Encode(junkEnc, junk)
-
-	cases := [][]byte{
-		[]byte("test"),
-		[]byte("35"),
-		[]byte("9ca4a1dd-a439-4593-b386-a7dfdc2e9fc6"),
-		[]byte(jsonobject),
-		passphrase,
-		junk,
-		junkEnc,
-	}
-
-	for _, plain := range cases {
-		var enc, dec []byte
-		var err error
-
-		enc, err = encryptOldFn(plain, passphrase)
-		require.NoError(t, err)
-
-		dec, err = decryptNewFn(enc, passphrase)
-		require.NoError(t, err)
-
-		require.Equal(t, plain, dec)
-
-		enc, err = encryptNewFn(plain, passphrase)
-		require.NoError(t, err)
-
-		dec, err = decryptOldFn(enc, passphrase)
-		require.NoError(t, err)
-
-		require.Equal(t, plain, dec)
-	}
-}

api/database/boltdb/tx.go

@@ -6,7 +6,6 @@ import (
 
 	dserrors "github.com/portainer/portainer/api/dataservices/errors"
 
-	"github.com/pkg/errors"
 	"github.com/rs/zerolog/log"
 	bolt "go.etcd.io/bbolt"
 )
@@ -32,33 +31,6 @@ func (tx *DbTransaction) GetObject(bucketName string, key []byte, object any) er
 	return tx.conn.UnmarshalObject(value, object)
 }
 
-func (tx *DbTransaction) GetRawBytes(bucketName string, key []byte) ([]byte, error) {
-	bucket := tx.tx.Bucket([]byte(bucketName))
-
-	value := bucket.Get(key)
-	if value == nil {
-		return nil, fmt.Errorf("%w (bucket=%s, key=%s)", dserrors.ErrObjectNotFound, bucketName, keyToString(key))
-	}
-
-	if tx.conn.getEncryptionKey() != nil {
-		var err error
-
-		if value, err = decrypt(value, tx.conn.getEncryptionKey()); err != nil {
-			return value, errors.Wrap(err, "Failed decrypting object")
-		}
-	}
-
-	return value, nil
-}
-
-func (tx *DbTransaction) KeyExists(bucketName string, key []byte) (bool, error) {
-	bucket := tx.tx.Bucket([]byte(bucketName))
-
-	value := bucket.Get(key)
-
-	return value != nil, nil
-}
-
 func (tx *DbTransaction) UpdateObject(bucketName string, key []byte, object any) error {
 	data, err := tx.conn.MarshalObject(object)
 	if err != nil {

api/database/database.go

@@ -8,12 +8,11 @@ import (
 )
 
 // NewDatabase should use config options to return a connection to the requested database
-func NewDatabase(storeType, storePath string, encryptionKey []byte, compact bool) (connection portainer.Connection, err error) {
+func NewDatabase(storeType, storePath string, encryptionKey []byte) (connection portainer.Connection, err error) {
 	if storeType == "boltdb" {
 		return &boltdb.DbConnection{
 			Path:          storePath,
 			EncryptionKey: encryptionKey,
-			Compact:       compact,
 		}, nil
 	}
 

api/dataservices/base.go

@@ -9,8 +9,7 @@ import (
 type BaseCRUD[T any, I constraints.Integer] interface {
 	Create(element *T) error
 	Read(ID I) (*T, error)
-	Exists(ID I) (bool, error)
-	ReadAll(predicates ...func(T) bool) ([]T, error)
+	ReadAll() ([]T, error)
 	Update(ID I, element *T) error
 	Delete(ID I) error
 }
@@ -43,26 +42,12 @@ func (service BaseDataService[T, I]) Read(ID I) (*T, error) {
 	})
 }
 
-func (service BaseDataService[T, I]) Exists(ID I) (bool, error) {
-	var exists bool
-
-	err := service.Connection.ViewTx(func(tx portainer.Transaction) error {
-		var err error
-		exists, err = service.Tx(tx).Exists(ID)
-
-		return err
-	})
-
-	return exists, err
-}
-
-// ReadAll retrieves all the elements that satisfy all the provided predicates.
-func (service BaseDataService[T, I]) ReadAll(predicates ...func(T) bool) ([]T, error) {
+func (service BaseDataService[T, I]) ReadAll() ([]T, error) {
 	var collection = make([]T, 0)
 
 	return collection, service.Connection.ViewTx(func(tx portainer.Transaction) error {
 		var err error
-		collection, err = service.Tx(tx).ReadAll(predicates...)
+		collection, err = service.Tx(tx).ReadAll()
 
 		return err
 	})

api/dataservices/base_test.go

@@ -1,92 +0,0 @@
-package dataservices
-
-import (
-	"strconv"
-	"testing"
-
-	portainer "github.com/portainer/portainer/api"
-	"github.com/portainer/portainer/api/slicesx"
-
-	"github.com/stretchr/testify/require"
-)
-
-type testObject struct {
-	ID    int
-	Value int
-}
-
-type mockConnection struct {
-	store map[int]testObject
-
-	portainer.Connection
-}
-
-func (m mockConnection) UpdateObject(bucket string, key []byte, value interface{}) error {
-	obj := value.(*testObject)
-
-	m.store[obj.ID] = *obj
-
-	return nil
-}
-
-func (m mockConnection) GetAll(bucketName string, obj any, appendFn func(o any) (any, error)) error {
-	for _, v := range m.store {
-		if _, err := appendFn(&v); err != nil {
-			return err
-		}
-	}
-
-	return nil
-}
-
-func (m mockConnection) UpdateTx(fn func(portainer.Transaction) error) error {
-	return fn(m)
-}
-
-func (m mockConnection) ViewTx(fn func(portainer.Transaction) error) error {
-	return fn(m)
-}
-
-func (m mockConnection) ConvertToKey(v int) []byte {
-	return []byte(strconv.Itoa(v))
-}
-
-func TestReadAll(t *testing.T) {
-	service := BaseDataService[testObject, int]{
-		Bucket:     "testBucket",
-		Connection: mockConnection{store: make(map[int]testObject)},
-	}
-
-	data := []testObject{
-		{ID: 1, Value: 1},
-		{ID: 2, Value: 2},
-		{ID: 3, Value: 3},
-		{ID: 4, Value: 4},
-		{ID: 5, Value: 5},
-	}
-
-	for _, item := range data {
-		err := service.Update(item.ID, &item)
-		require.NoError(t, err)
-	}
-
-	// ReadAll without predicates
-	result, err := service.ReadAll()
-	require.NoError(t, err)
-
-	expected := append([]testObject{}, data...)
-
-	require.ElementsMatch(t, expected, result)
-
-	// ReadAll with predicates
-	hasLowID := func(obj testObject) bool { return obj.ID < 3 }
-	isEven := func(obj testObject) bool { return obj.Value%2 == 0 }
-
-	result, err = service.ReadAll(hasLowID, isEven)
-	require.NoError(t, err)
-
-	expected = slicesx.Filter(expected, hasLowID)
-	expected = slicesx.Filter(expected, isEven)
-
-	require.ElementsMatch(t, expected, result)
-}

api/dataservices/base_tx.go

@@ -28,38 +28,13 @@ func (service BaseDataServiceTx[T, I]) Read(ID I) (*T, error) {
 	return &element, nil
 }
 
-func (service BaseDataServiceTx[T, I]) Exists(ID I) (bool, error) {
-	identifier := service.Connection.ConvertToKey(int(ID))
-
-	return service.Tx.KeyExists(service.Bucket, identifier)
-}
-
-// ReadAll retrieves all the elements that satisfy all the provided predicates.
-func (service BaseDataServiceTx[T, I]) ReadAll(predicates ...func(T) bool) ([]T, error) {
+func (service BaseDataServiceTx[T, I]) ReadAll() ([]T, error) {
 	var collection = make([]T, 0)
 
-	if len(predicates) == 0 {
-		return collection, service.Tx.GetAll(
-			service.Bucket,
-			new(T),
-			AppendFn(&collection),
-		)
-	}
-
-	filterFn := func(element T) bool {
-		for _, p := range predicates {
-			if !p(element) {
-				return false
-			}
-		}
-
-		return true
-	}
-
 	return collection, service.Tx.GetAll(
 		service.Bucket,
 		new(T),
-		FilterFn(&collection, filterFn),
+		AppendFn(&collection),
 	)
 }
 

api/dataservices/customtemplate/customtemplate.go

@@ -28,12 +28,13 @@ func NewService(connection portainer.Connection) (*Service, error) {
 	}, nil
 }
 
+// CreateCustomTemplate uses the existing id and saves it.
+// TODO: where does the ID come from, and is it safe?
+func (service *Service) Create(customTemplate *portainer.CustomTemplate) error {
+	return service.Connection.CreateObjectWithId(BucketName, int(customTemplate.ID), customTemplate)
+}
+
+// GetNextIdentifier returns the next identifier for a custom template.
 func (service *Service) GetNextIdentifier() int {
 	return service.Connection.GetNextIdentifier(BucketName)
 }
-
-func (service *Service) Create(customTemplate *portainer.CustomTemplate) error {
-	return service.Connection.UpdateTx(func(tx portainer.Transaction) error {
-		return service.Tx(tx).Create(customTemplate)
-	})
-}

api/dataservices/customtemplate/customtemplate_test.go

@@ -1,19 +0,0 @@
-package customtemplate_test
-
-import (
-	"testing"
-
-	portainer "github.com/portainer/portainer/api"
-	"github.com/portainer/portainer/api/datastore"
-	"github.com/stretchr/testify/require"
-)
-
-func TestCustomTemplateCreate(t *testing.T) {
-	_, ds := datastore.MustNewTestStore(t, true, false)
-	require.NotNil(t, ds)
-
-	require.NoError(t, ds.CustomTemplate().Create(&portainer.CustomTemplate{ID: 1}))
-	e, err := ds.CustomTemplate().Read(1)
-	require.NoError(t, err)
-	require.Equal(t, portainer.CustomTemplateID(1), e.ID)
-}

api/dataservices/customtemplate/tx.go

@@ -1,31 +0,0 @@
-package customtemplate
-
-import (
-	portainer "github.com/portainer/portainer/api"
-	"github.com/portainer/portainer/api/dataservices"
-)
-
-// Service represents a service for managing custom template data.
-type ServiceTx struct {
-	dataservices.BaseDataServiceTx[portainer.CustomTemplate, portainer.CustomTemplateID]
-}
-
-func (service *Service) Tx(tx portainer.Transaction) ServiceTx {
-	return ServiceTx{
-		BaseDataServiceTx: dataservices.BaseDataServiceTx[portainer.CustomTemplate, portainer.CustomTemplateID]{
-			Bucket:     BucketName,
-			Connection: service.Connection,
-			Tx:         tx,
-		},
-	}
-}
-
-func (service ServiceTx) GetNextIdentifier() int {
-	return service.Tx.GetNextIdentifier(BucketName)
-}
-
-// CreateCustomTemplate uses the existing id and saves it.
-// TODO: where does the ID come from, and is it safe?
-func (service ServiceTx) Create(customTemplate *portainer.CustomTemplate) error {
-	return service.Tx.CreateObjectWithId(BucketName, int(customTemplate.ID), customTemplate)
-}

api/dataservices/customtemplate/tx_test.go

@@ -1,28 +0,0 @@
-package customtemplate_test
-
-import (
-	"testing"
-
-	portainer "github.com/portainer/portainer/api"
-	"github.com/portainer/portainer/api/dataservices"
-	"github.com/portainer/portainer/api/datastore"
-	"github.com/stretchr/testify/require"
-)
-
-func TestCustomTemplateCreateTx(t *testing.T) {
-	_, ds := datastore.MustNewTestStore(t, true, false)
-	require.NotNil(t, ds)
-
-	require.NoError(t, ds.UpdateTx(func(tx dataservices.DataStoreTx) error {
-		return tx.CustomTemplate().Create(&portainer.CustomTemplate{ID: 1})
-	}))
-
-	var template *portainer.CustomTemplate
-	require.NoError(t, ds.ViewTx(func(tx dataservices.DataStoreTx) error {
-		var err error
-		template, err = tx.CustomTemplate().Read(1)
-		return err
-	}))
-
-	require.Equal(t, portainer.CustomTemplateID(1), template.ID)
-}

api/dataservices/edgegroup/tx.go

@@ -17,29 +17,11 @@ func (service ServiceTx) UpdateEdgeGroupFunc(ID portainer.EdgeGroupID, updateFun
 }
 
 func (service ServiceTx) Create(group *portainer.EdgeGroup) error {
-	es := group.Endpoints
-	group.Endpoints = nil // Clear deprecated field
-
-	err := service.Tx.CreateObject(
+	return service.Tx.CreateObject(
 		BucketName,
 		func(id uint64) (int, any) {
 			group.ID = portainer.EdgeGroupID(id)
 			return int(group.ID), group
 		},
 	)
-
-	group.Endpoints = es // Restore endpoints after create
-
-	return err
-}
-
-func (service ServiceTx) Update(ID portainer.EdgeGroupID, group *portainer.EdgeGroup) error {
-	es := group.Endpoints
-	group.Endpoints = nil // Clear deprecated field
-
-	err := service.BaseDataServiceTx.Update(ID, group)
-
-	group.Endpoints = es // Restore endpoints after update
-
-	return err
 }

api/dataservices/edgestack/edgestack.go

@@ -15,7 +15,7 @@ type Service struct {
 	connection          portainer.Connection
 	idxVersion          map[portainer.EdgeStackID]int
 	mu                  sync.RWMutex
-	cacheInvalidationFn func(portainer.Transaction, portainer.EdgeStackID)
+	cacheInvalidationFn func(portainer.EdgeStackID)
 }
 
 func (service *Service) BucketName() string {
@@ -23,7 +23,7 @@ func (service *Service) BucketName() string {
 }
 
 // NewService creates a new instance of a service.
-func NewService(connection portainer.Connection, cacheInvalidationFn func(portainer.Transaction, portainer.EdgeStackID)) (*Service, error) {
+func NewService(connection portainer.Connection, cacheInvalidationFn func(portainer.EdgeStackID)) (*Service, error) {
 	err := connection.SetServiceName(BucketName)
 	if err != nil {
 		return nil, err
@@ -36,7 +36,7 @@ func NewService(connection portainer.Connection, cacheInvalidationFn func(portai
 	}
 
 	if s.cacheInvalidationFn == nil {
-		s.cacheInvalidationFn = func(portainer.Transaction, portainer.EdgeStackID) {}
+		s.cacheInvalidationFn = func(portainer.EdgeStackID) {}
 	}
 
 	es, err := s.EdgeStacks()
@@ -106,7 +106,7 @@ func (service *Service) Create(id portainer.EdgeStackID, edgeStack *portainer.Ed
 
 	service.mu.Lock()
 	service.idxVersion[id] = edgeStack.Version
-	service.cacheInvalidationFn(service.connection, id)
+	service.cacheInvalidationFn(id)
 	service.mu.Unlock()
 
 	return nil
@@ -125,7 +125,7 @@ func (service *Service) UpdateEdgeStack(ID portainer.EdgeStackID, edgeStack *por
 	}
 
 	service.idxVersion[ID] = edgeStack.Version
-	service.cacheInvalidationFn(service.connection, ID)
+	service.cacheInvalidationFn(ID)
 
 	return nil
 }
@@ -142,7 +142,7 @@ func (service *Service) UpdateEdgeStackFunc(ID portainer.EdgeStackID, updateFunc
 		updateFunc(edgeStack)
 
 		service.idxVersion[ID] = edgeStack.Version
-		service.cacheInvalidationFn(service.connection, ID)
+		service.cacheInvalidationFn(ID)
 	})
 }
 
@@ -165,7 +165,7 @@ func (service *Service) DeleteEdgeStack(ID portainer.EdgeStackID) error {
 
 	delete(service.idxVersion, ID)
 
-	service.cacheInvalidationFn(service.connection, ID)
+	service.cacheInvalidationFn(ID)
 
 	return nil
 }

api/dataservices/edgestack/edgestack_test.go

@@ -1,50 +0,0 @@
-package edgestack
-
-import (
-	"testing"
-
-	portainer "github.com/portainer/portainer/api"
-	"github.com/portainer/portainer/api/database/boltdb"
-
-	"github.com/stretchr/testify/require"
-)
-
-func TestUpdate(t *testing.T) {
-	var conn portainer.Connection = &boltdb.DbConnection{Path: t.TempDir()}
-	err := conn.Open()
-	require.NoError(t, err)
-
-	defer conn.Close()
-
-	service, err := NewService(conn, func(portainer.Transaction, portainer.EdgeStackID) {})
-	require.NoError(t, err)
-
-	const edgeStackID = 1
-	edgeStack := &portainer.EdgeStack{
-		ID:   edgeStackID,
-		Name: "Test Stack",
-	}
-
-	err = service.Create(edgeStackID, edgeStack)
-	require.NoError(t, err)
-
-	err = service.UpdateEdgeStackFunc(edgeStackID, func(edgeStack *portainer.EdgeStack) {
-		edgeStack.Name = "Updated Stack"
-	})
-	require.NoError(t, err)
-
-	updatedStack, err := service.EdgeStack(edgeStackID)
-	require.NoError(t, err)
-	require.Equal(t, "Updated Stack", updatedStack.Name)
-
-	err = conn.UpdateTx(func(tx portainer.Transaction) error {
-		return service.UpdateEdgeStackFuncTx(tx, edgeStackID, func(edgeStack *portainer.EdgeStack) {
-			edgeStack.Name = "Updated Stack Again"
-		})
-	})
-	require.NoError(t, err)
-
-	updatedStack, err = service.EdgeStack(edgeStackID)
-	require.NoError(t, err)
-	require.Equal(t, "Updated Stack Again", updatedStack.Name)
-}

api/dataservices/edgestack/tx.go

@@ -44,7 +44,8 @@ func (service ServiceTx) EdgeStack(ID portainer.EdgeStackID) (*portainer.EdgeSta
 	var stack portainer.EdgeStack
 	identifier := service.service.connection.ConvertToKey(int(ID))
 
-	if err := service.tx.GetObject(BucketName, identifier, &stack); err != nil {
+	err := service.tx.GetObject(BucketName, identifier, &stack)
+	if err != nil {
 		return nil, err
 	}
 
@@ -64,17 +65,18 @@ func (service ServiceTx) EdgeStackVersion(ID portainer.EdgeStackID) (int, bool)
 func (service ServiceTx) Create(id portainer.EdgeStackID, edgeStack *portainer.EdgeStack) error {
 	edgeStack.ID = id
 
-	if err := service.tx.CreateObjectWithId(
+	err := service.tx.CreateObjectWithId(
 		BucketName,
 		int(edgeStack.ID),
 		edgeStack,
-	); err != nil {
+	)
+	if err != nil {
 		return err
 	}
 
 	service.service.mu.Lock()
 	service.service.idxVersion[id] = edgeStack.Version
-	service.service.cacheInvalidationFn(service.tx, id)
+	service.service.cacheInvalidationFn(id)
 	service.service.mu.Unlock()
 
 	return nil
@@ -87,12 +89,13 @@ func (service ServiceTx) UpdateEdgeStack(ID portainer.EdgeStackID, edgeStack *po
 
 	identifier := service.service.connection.ConvertToKey(int(ID))
 
-	if err := service.tx.UpdateObject(BucketName, identifier, edgeStack); err != nil {
+	err := service.tx.UpdateObject(BucketName, identifier, edgeStack)
+	if err != nil {
 		return err
 	}
 
 	service.service.idxVersion[ID] = edgeStack.Version
-	service.service.cacheInvalidationFn(service.tx, ID)
+	service.service.cacheInvalidationFn(ID)
 
 	return nil
 }
@@ -116,13 +119,14 @@ func (service ServiceTx) DeleteEdgeStack(ID portainer.EdgeStackID) error {
 
 	identifier := service.service.connection.ConvertToKey(int(ID))
 
-	if err := service.tx.DeleteObject(BucketName, identifier); err != nil {
+	err := service.tx.DeleteObject(BucketName, identifier)
+	if err != nil {
 		return err
 	}
 
 	delete(service.service.idxVersion, ID)
 
-	service.service.cacheInvalidationFn(service.tx, ID)
+	service.service.cacheInvalidationFn(ID)
 
 	return nil
 }

api/dataservices/edgestackstatus/edgestackstatus.go

@@ -1,89 +0,0 @@
-package edgestackstatus
-
-import (
-	portainer "github.com/portainer/portainer/api"
-	"github.com/portainer/portainer/api/dataservices"
-)
-
-var _ dataservices.EdgeStackStatusService = &Service{}
-
-const BucketName = "edge_stack_status"
-
-type Service struct {
-	conn portainer.Connection
-}
-
-func (service *Service) BucketName() string {
-	return BucketName
-}
-
-func NewService(connection portainer.Connection) (*Service, error) {
-	if err := connection.SetServiceName(BucketName); err != nil {
-		return nil, err
-	}
-
-	return &Service{conn: connection}, nil
-}
-
-func (s *Service) Tx(tx portainer.Transaction) ServiceTx {
-	return ServiceTx{
-		service: s,
-		tx:      tx,
-	}
-}
-
-func (s *Service) Create(edgeStackID portainer.EdgeStackID, endpointID portainer.EndpointID, status *portainer.EdgeStackStatusForEnv) error {
-	return s.conn.UpdateTx(func(tx portainer.Transaction) error {
-		return s.Tx(tx).Create(edgeStackID, endpointID, status)
-	})
-}
-
-func (s *Service) Read(edgeStackID portainer.EdgeStackID, endpointID portainer.EndpointID) (*portainer.EdgeStackStatusForEnv, error) {
-	var element *portainer.EdgeStackStatusForEnv
-
-	return element, s.conn.ViewTx(func(tx portainer.Transaction) error {
-		var err error
-		element, err = s.Tx(tx).Read(edgeStackID, endpointID)
-
-		return err
-	})
-}
-
-func (s *Service) ReadAll(edgeStackID portainer.EdgeStackID) ([]portainer.EdgeStackStatusForEnv, error) {
-	var collection = make([]portainer.EdgeStackStatusForEnv, 0)
-
-	return collection, s.conn.ViewTx(func(tx portainer.Transaction) error {
-		var err error
-		collection, err = s.Tx(tx).ReadAll(edgeStackID)
-
-		return err
-	})
-}
-
-func (s *Service) Update(edgeStackID portainer.EdgeStackID, endpointID portainer.EndpointID, status *portainer.EdgeStackStatusForEnv) error {
-	return s.conn.UpdateTx(func(tx portainer.Transaction) error {
-		return s.Tx(tx).Update(edgeStackID, endpointID, status)
-	})
-}
-
-func (s *Service) Delete(edgeStackID portainer.EdgeStackID, endpointID portainer.EndpointID) error {
-	return s.conn.UpdateTx(func(tx portainer.Transaction) error {
-		return s.Tx(tx).Delete(edgeStackID, endpointID)
-	})
-}
-
-func (s *Service) DeleteAll(edgeStackID portainer.EdgeStackID) error {
-	return s.conn.UpdateTx(func(tx portainer.Transaction) error {
-		return s.Tx(tx).DeleteAll(edgeStackID)
-	})
-}
-
-func (s *Service) Clear(edgeStackID portainer.EdgeStackID, relatedEnvironmentsIDs []portainer.EndpointID) error {
-	return s.conn.UpdateTx(func(tx portainer.Transaction) error {
-		return s.Tx(tx).Clear(edgeStackID, relatedEnvironmentsIDs)
-	})
-}
-
-func (s *Service) key(edgeStackID portainer.EdgeStackID, endpointID portainer.EndpointID) []byte {
-	return append(s.conn.ConvertToKey(int(edgeStackID)), s.conn.ConvertToKey(int(endpointID))...)
-}

api/dataservices/edgestackstatus/tx.go

@@ -1,95 +0,0 @@
-package edgestackstatus
-
-import (
-	"fmt"
-
-	portainer "github.com/portainer/portainer/api"
-	"github.com/portainer/portainer/api/dataservices"
-)
-
-var _ dataservices.EdgeStackStatusService = &Service{}
-
-type ServiceTx struct {
-	service *Service
-	tx      portainer.Transaction
-}
-
-func (service ServiceTx) Create(edgeStackID portainer.EdgeStackID, endpointID portainer.EndpointID, status *portainer.EdgeStackStatusForEnv) error {
-	identifier := service.service.key(edgeStackID, endpointID)
-	return service.tx.CreateObjectWithStringId(BucketName, identifier, status)
-}
-
-func (s ServiceTx) Read(edgeStackID portainer.EdgeStackID, endpointID portainer.EndpointID) (*portainer.EdgeStackStatusForEnv, error) {
-	var status portainer.EdgeStackStatusForEnv
-	identifier := s.service.key(edgeStackID, endpointID)
-
-	if err := s.tx.GetObject(BucketName, identifier, &status); err != nil {
-		return nil, err
-	}
-
-	return &status, nil
-}
-
-func (s ServiceTx) ReadAll(edgeStackID portainer.EdgeStackID) ([]portainer.EdgeStackStatusForEnv, error) {
-	keyPrefix := s.service.conn.ConvertToKey(int(edgeStackID))
-
-	statuses := make([]portainer.EdgeStackStatusForEnv, 0)
-
-	if err := s.tx.GetAllWithKeyPrefix(BucketName, keyPrefix, &portainer.EdgeStackStatusForEnv{}, dataservices.AppendFn(&statuses)); err != nil {
-		return nil, fmt.Errorf("unable to retrieve EdgeStackStatus for EdgeStack %d: %w", edgeStackID, err)
-	}
-
-	return statuses, nil
-}
-
-func (s ServiceTx) Update(edgeStackID portainer.EdgeStackID, endpointID portainer.EndpointID, status *portainer.EdgeStackStatusForEnv) error {
-	identifier := s.service.key(edgeStackID, endpointID)
-	return s.tx.UpdateObject(BucketName, identifier, status)
-}
-
-func (s ServiceTx) Delete(edgeStackID portainer.EdgeStackID, endpointID portainer.EndpointID) error {
-	identifier := s.service.key(edgeStackID, endpointID)
-	return s.tx.DeleteObject(BucketName, identifier)
-}
-
-func (s ServiceTx) DeleteAll(edgeStackID portainer.EdgeStackID) error {
-	keyPrefix := s.service.conn.ConvertToKey(int(edgeStackID))
-
-	statuses := make([]portainer.EdgeStackStatusForEnv, 0)
-
-	if err := s.tx.GetAllWithKeyPrefix(BucketName, keyPrefix, &portainer.EdgeStackStatusForEnv{}, dataservices.AppendFn(&statuses)); err != nil {
-		return fmt.Errorf("unable to retrieve EdgeStackStatus for EdgeStack %d: %w", edgeStackID, err)
-	}
-
-	for _, status := range statuses {
-		if err := s.tx.DeleteObject(BucketName, s.service.key(edgeStackID, status.EndpointID)); err != nil {
-			return fmt.Errorf("unable to delete EdgeStackStatus for EdgeStack %d and Endpoint %d: %w", edgeStackID, status.EndpointID, err)
-		}
-	}
-
-	return nil
-}
-
-func (s ServiceTx) Clear(edgeStackID portainer.EdgeStackID, relatedEnvironmentsIDs []portainer.EndpointID) error {
-	for _, envID := range relatedEnvironmentsIDs {
-		existingStatus, err := s.Read(edgeStackID, envID)
-		if err != nil && !dataservices.IsErrObjectNotFound(err) {
-			return fmt.Errorf("unable to retrieve status for environment %d: %w", envID, err)
-		}
-
-		var deploymentInfo portainer.StackDeploymentInfo
-		if existingStatus != nil {
-			deploymentInfo = existingStatus.DeploymentInfo
-		}
-
-		if err := s.Update(edgeStackID, envID, &portainer.EdgeStackStatusForEnv{
-			EndpointID:     envID,
-			Status:         []portainer.EdgeStackDeploymentStatus{},
-			DeploymentInfo: deploymentInfo,
-		}); err != nil {
-			return err
-		}
-	}
-
-	return nil
-}

api/dataservices/endpointrelation/endpointrelation.go

@@ -1,11 +1,11 @@
 package endpointrelation
 
 import (
-	"sync"
-
 	portainer "github.com/portainer/portainer/api"
 	"github.com/portainer/portainer/api/dataservices"
 	"github.com/portainer/portainer/api/internal/edge/cache"
+
+	"github.com/rs/zerolog/log"
 )
 
 // BucketName represents the name of the bucket where this service stores data.
@@ -13,21 +13,20 @@ const BucketName = "endpoint_relations"
 
 // Service represents a service for managing environment(endpoint) relation data.
 type Service struct {
-	connection             portainer.Connection
-	updateStackFnTx        func(tx portainer.Transaction, ID portainer.EdgeStackID, updateFunc func(edgeStack *portainer.EdgeStack)) error
-	endpointRelationsCache []portainer.EndpointRelation
-	mu                     sync.Mutex
+	connection      portainer.Connection
+	updateStackFn   func(ID portainer.EdgeStackID, updateFunc func(edgeStack *portainer.EdgeStack)) error
+	updateStackFnTx func(tx portainer.Transaction, ID portainer.EdgeStackID, updateFunc func(edgeStack *portainer.EdgeStack)) error
 }
 
-var _ dataservices.EndpointRelationService = &Service{}
-
 func (service *Service) BucketName() string {
 	return BucketName
 }
 
 func (service *Service) RegisterUpdateStackFunction(
+	updateFunc func(portainer.EdgeStackID, func(*portainer.EdgeStack)) error,
 	updateFuncTx func(portainer.Transaction, portainer.EdgeStackID, func(*portainer.EdgeStack)) error,
 ) {
+	service.updateStackFn = updateFunc
 	service.updateStackFnTx = updateFuncTx
 }
 
@@ -77,35 +76,107 @@ func (service *Service) Create(endpointRelation *portainer.EndpointRelation) err
 	err := service.connection.CreateObjectWithId(BucketName, int(endpointRelation.EndpointID), endpointRelation)
 	cache.Del(endpointRelation.EndpointID)
 
-	service.mu.Lock()
-	service.endpointRelationsCache = nil
-	service.mu.Unlock()
-
 	return err
 }
 
 // UpdateEndpointRelation updates an Environment(Endpoint) relation object
 func (service *Service) UpdateEndpointRelation(endpointID portainer.EndpointID, endpointRelation *portainer.EndpointRelation) error {
-	return service.connection.UpdateTx(func(tx portainer.Transaction) error {
-		return service.Tx(tx).UpdateEndpointRelation(endpointID, endpointRelation)
-	})
-}
+	previousRelationState, _ := service.EndpointRelation(endpointID)
 
-func (service *Service) AddEndpointRelationsForEdgeStack(endpointIDs []portainer.EndpointID, edgeStack *portainer.EdgeStack) error {
-	return service.connection.UpdateTx(func(tx portainer.Transaction) error {
-		return service.Tx(tx).AddEndpointRelationsForEdgeStack(endpointIDs, edgeStack)
-	})
-}
+	identifier := service.connection.ConvertToKey(int(endpointID))
+	err := service.connection.UpdateObject(BucketName, identifier, endpointRelation)
+	cache.Del(endpointID)
+	if err != nil {
+		return err
+	}
 
-func (service *Service) RemoveEndpointRelationsForEdgeStack(endpointIDs []portainer.EndpointID, edgeStackID portainer.EdgeStackID) error {
-	return service.connection.UpdateTx(func(tx portainer.Transaction) error {
-		return service.Tx(tx).RemoveEndpointRelationsForEdgeStack(endpointIDs, edgeStackID)
-	})
+	updatedRelationState, _ := service.EndpointRelation(endpointID)
+
+	service.updateEdgeStacksAfterRelationChange(previousRelationState, updatedRelationState)
+
+	return nil
 }
 
 // DeleteEndpointRelation deletes an Environment(Endpoint) relation object
 func (service *Service) DeleteEndpointRelation(endpointID portainer.EndpointID) error {
-	return service.connection.UpdateTx(func(tx portainer.Transaction) error {
-		return service.Tx(tx).DeleteEndpointRelation(endpointID)
-	})
+	deletedRelation, _ := service.EndpointRelation(endpointID)
+
+	identifier := service.connection.ConvertToKey(int(endpointID))
+	err := service.connection.DeleteObject(BucketName, identifier)
+	cache.Del(endpointID)
+	if err != nil {
+		return err
+	}
+
+	service.updateEdgeStacksAfterRelationChange(deletedRelation, nil)
+
+	return nil
+}
+
+func (service *Service) InvalidateEdgeCacheForEdgeStack(edgeStackID portainer.EdgeStackID) {
+	rels, err := service.EndpointRelations()
+	if err != nil {
+		log.Error().Err(err).Msg("cannot retrieve endpoint relations")
+		return
+	}
+
+	for _, rel := range rels {
+		for id := range rel.EdgeStacks {
+			if edgeStackID == id {
+				cache.Del(rel.EndpointID)
+			}
+		}
+	}
+}
+
+func (service *Service) updateEdgeStacksAfterRelationChange(previousRelationState *portainer.EndpointRelation, updatedRelationState *portainer.EndpointRelation) {
+	relations, _ := service.EndpointRelations()
+
+	stacksToUpdate := map[portainer.EdgeStackID]bool{}
+
+	if previousRelationState != nil {
+		for stackId, enabled := range previousRelationState.EdgeStacks {
+			// flag stack for update if stack is not in the updated relation state
+			// = stack has been removed for this relation
+			// or this relation has been deleted
+			if enabled && (updatedRelationState == nil || !updatedRelationState.EdgeStacks[stackId]) {
+				stacksToUpdate[stackId] = true
+			}
+		}
+	}
+
+	if updatedRelationState != nil {
+		for stackId, enabled := range updatedRelationState.EdgeStacks {
+			// flag stack for update if stack is not in the previous relation state
+			// = stack has been added for this relation
+			if enabled && (previousRelationState == nil || !previousRelationState.EdgeStacks[stackId]) {
+				stacksToUpdate[stackId] = true
+			}
+		}
+	}
+
+	// for each stack referenced by the updated relation
+	// list how many time this stack is referenced in all relations
+	// in order to update the stack deployments count
+	for refStackId, refStackEnabled := range stacksToUpdate {
+		if !refStackEnabled {
+			continue
+		}
+
+		numDeployments := 0
+
+		for _, r := range relations {
+			for sId, enabled := range r.EdgeStacks {
+				if enabled && sId == refStackId {
+					numDeployments += 1
+				}
+			}
+		}
+
+		if err := service.updateStackFn(refStackId, func(edgeStack *portainer.EdgeStack) {
+			edgeStack.NumDeployments = numDeployments
+		}); err != nil {
+			log.Error().Err(err).Msg("could not update the number of deployments")
+		}
+	}
 }

api/dataservices/endpointrelation/endpointrelation_test.go

@@ -1,140 +0,0 @@
-package endpointrelation
-
-import (
-	"testing"
-
-	portainer "github.com/portainer/portainer/api"
-	"github.com/portainer/portainer/api/database/boltdb"
-	"github.com/portainer/portainer/api/dataservices/edgestack"
-	"github.com/portainer/portainer/api/internal/edge/cache"
-
-	"github.com/stretchr/testify/require"
-)
-
-func TestUpdateRelation(t *testing.T) {
-	const endpointID = 1
-	const edgeStackID1 = 1
-	const edgeStackID2 = 2
-
-	var conn portainer.Connection = &boltdb.DbConnection{Path: t.TempDir()}
-	err := conn.Open()
-	require.NoError(t, err)
-
-	defer conn.Close()
-
-	service, err := NewService(conn)
-	require.NoError(t, err)
-
-	updateStackFnTxCalled := false
-
-	edgeStacks := make(map[portainer.EdgeStackID]portainer.EdgeStack)
-	edgeStacks[edgeStackID1] = portainer.EdgeStack{ID: edgeStackID1}
-	edgeStacks[edgeStackID2] = portainer.EdgeStack{ID: edgeStackID2}
-
-	service.RegisterUpdateStackFunction(func(tx portainer.Transaction, ID portainer.EdgeStackID, updateFunc func(edgeStack *portainer.EdgeStack)) error {
-		updateStackFnTxCalled = true
-
-		s, ok := edgeStacks[ID]
-		require.True(t, ok)
-
-		updateFunc(&s)
-		edgeStacks[ID] = s
-
-		return nil
-	})
-
-	// Nil relation
-
-	cache.Set(endpointID, []byte("value"))
-
-	err = service.UpdateEndpointRelation(endpointID, nil)
-	_, cacheKeyExists := cache.Get(endpointID)
-	require.NoError(t, err)
-	require.False(t, updateStackFnTxCalled)
-	require.False(t, cacheKeyExists)
-
-	// Add a relation to two edge stacks
-
-	cache.Set(endpointID, []byte("value"))
-
-	err = service.UpdateEndpointRelation(endpointID, &portainer.EndpointRelation{
-		EndpointID: endpointID,
-		EdgeStacks: map[portainer.EdgeStackID]bool{
-			edgeStackID1: true,
-			edgeStackID2: true,
-		},
-	})
-	_, cacheKeyExists = cache.Get(endpointID)
-	require.NoError(t, err)
-	require.True(t, updateStackFnTxCalled)
-	require.False(t, cacheKeyExists)
-	require.Equal(t, 1, edgeStacks[edgeStackID1].NumDeployments)
-	require.Equal(t, 1, edgeStacks[edgeStackID2].NumDeployments)
-
-	// Remove a relation to one edge stack
-
-	updateStackFnTxCalled = false
-	cache.Set(endpointID, []byte("value"))
-
-	err = service.UpdateEndpointRelation(endpointID, &portainer.EndpointRelation{
-		EndpointID: endpointID,
-		EdgeStacks: map[portainer.EdgeStackID]bool{
-			2: true,
-		},
-	})
-	_, cacheKeyExists = cache.Get(endpointID)
-	require.NoError(t, err)
-	require.True(t, updateStackFnTxCalled)
-	require.False(t, cacheKeyExists)
-	require.Equal(t, 0, edgeStacks[edgeStackID1].NumDeployments)
-	require.Equal(t, 1, edgeStacks[edgeStackID2].NumDeployments)
-
-	// Delete the relation
-
-	updateStackFnTxCalled = false
-	cache.Set(endpointID, []byte("value"))
-
-	err = service.DeleteEndpointRelation(endpointID)
-
-	_, cacheKeyExists = cache.Get(endpointID)
-	require.NoError(t, err)
-	require.True(t, updateStackFnTxCalled)
-	require.False(t, cacheKeyExists)
-	require.Equal(t, 0, edgeStacks[edgeStackID1].NumDeployments)
-	require.Equal(t, 0, edgeStacks[edgeStackID2].NumDeployments)
-}
-
-func TestAddEndpointRelationsForEdgeStack(t *testing.T) {
-	var conn portainer.Connection = &boltdb.DbConnection{Path: t.TempDir()}
-	err := conn.Open()
-	require.NoError(t, err)
-
-	defer conn.Close()
-
-	service, err := NewService(conn)
-	require.NoError(t, err)
-
-	edgeStackService, err := edgestack.NewService(conn, func(t portainer.Transaction, esi portainer.EdgeStackID) {})
-	require.NoError(t, err)
-
-	service.RegisterUpdateStackFunction(edgeStackService.UpdateEdgeStackFuncTx)
-	require.NoError(t, edgeStackService.Create(1, &portainer.EdgeStack{}))
-	require.NoError(t, service.Create(&portainer.EndpointRelation{EndpointID: 1, EdgeStacks: map[portainer.EdgeStackID]bool{}}))
-	require.NoError(t, service.AddEndpointRelationsForEdgeStack([]portainer.EndpointID{1}, &portainer.EdgeStack{ID: 1}))
-}
-
-func TestEndpointRelations(t *testing.T) {
-	var conn portainer.Connection = &boltdb.DbConnection{Path: t.TempDir()}
-	err := conn.Open()
-	require.NoError(t, err)
-
-	defer conn.Close()
-
-	service, err := NewService(conn)
-	require.NoError(t, err)
-
-	require.NoError(t, service.Create(&portainer.EndpointRelation{EndpointID: 1}))
-	rels, err := service.EndpointRelations()
-	require.NoError(t, err)
-	require.Equal(t, 1, len(rels))
-}

api/dataservices/endpointrelation/tx.go

@@ -13,8 +13,6 @@ type ServiceTx struct {
 	tx      portainer.Transaction
 }
 
-var _ dataservices.EndpointRelationService = &ServiceTx{}
-
 func (service ServiceTx) BucketName() string {
 	return BucketName
 }
@@ -47,10 +45,6 @@ func (service ServiceTx) Create(endpointRelation *portainer.EndpointRelation) er
 	err := service.tx.CreateObjectWithId(BucketName, int(endpointRelation.EndpointID), endpointRelation)
 	cache.Del(endpointRelation.EndpointID)
 
-	service.service.mu.Lock()
-	service.service.endpointRelationsCache = nil
-	service.service.mu.Unlock()
-
 	return err
 }
 
@@ -67,79 +61,11 @@ func (service ServiceTx) UpdateEndpointRelation(endpointID portainer.EndpointID,
 
 	updatedRelationState, _ := service.EndpointRelation(endpointID)
 
-	service.service.mu.Lock()
-	service.service.endpointRelationsCache = nil
-	service.service.mu.Unlock()
-
 	service.updateEdgeStacksAfterRelationChange(previousRelationState, updatedRelationState)
 
 	return nil
 }
 
-func (service ServiceTx) AddEndpointRelationsForEdgeStack(endpointIDs []portainer.EndpointID, edgeStack *portainer.EdgeStack) error {
-	for _, endpointID := range endpointIDs {
-		rel, err := service.EndpointRelation(endpointID)
-		if err != nil {
-			return err
-		}
-
-		rel.EdgeStacks[edgeStack.ID] = true
-
-		identifier := service.service.connection.ConvertToKey(int(endpointID))
-		err = service.tx.UpdateObject(BucketName, identifier, rel)
-		cache.Del(endpointID)
-		if err != nil {
-			return err
-		}
-	}
-
-	service.service.mu.Lock()
-	service.service.endpointRelationsCache = nil
-	service.service.mu.Unlock()
-
-	if err := service.service.updateStackFnTx(service.tx, edgeStack.ID, func(es *portainer.EdgeStack) {
-		es.NumDeployments += len(endpointIDs)
-
-		// sync changes in `edgeStack` in case it is re-persisted after `AddEndpointRelationsForEdgeStack` call
-		// to avoid overriding with the previous values
-		edgeStack.NumDeployments = es.NumDeployments
-	}); err != nil {
-		log.Error().Err(err).Msg("could not update the number of deployments")
-	}
-
-	return nil
-}
-
-func (service ServiceTx) RemoveEndpointRelationsForEdgeStack(endpointIDs []portainer.EndpointID, edgeStackID portainer.EdgeStackID) error {
-	for _, endpointID := range endpointIDs {
-		rel, err := service.EndpointRelation(endpointID)
-		if err != nil {
-			return err
-		}
-
-		delete(rel.EdgeStacks, edgeStackID)
-
-		identifier := service.service.connection.ConvertToKey(int(endpointID))
-		err = service.tx.UpdateObject(BucketName, identifier, rel)
-		cache.Del(endpointID)
-		if err != nil {
-			return err
-		}
-	}
-
-	service.service.mu.Lock()
-	service.service.endpointRelationsCache = nil
-	service.service.mu.Unlock()
-
-	if err := service.service.updateStackFnTx(service.tx, edgeStackID, func(edgeStack *portainer.EdgeStack) {
-		edgeStack.NumDeployments -= len(endpointIDs)
-	}); err != nil {
-		log.Error().Err(err).Msg("could not update the number of deployments")
-	}
-
-	return nil
-}
-
 // DeleteEndpointRelation deletes an Environment(Endpoint) relation object
 func (service ServiceTx) DeleteEndpointRelation(endpointID portainer.EndpointID) error {
 	deletedRelation, _ := service.EndpointRelation(endpointID)
@@ -151,88 +77,74 @@ func (service ServiceTx) DeleteEndpointRelation(endpointID portainer.EndpointID)
 		return err
 	}
 
-	service.service.mu.Lock()
-	service.service.endpointRelationsCache = nil
-	service.service.mu.Unlock()
-
 	service.updateEdgeStacksAfterRelationChange(deletedRelation, nil)
 
 	return nil
 }
 
 func (service ServiceTx) InvalidateEdgeCacheForEdgeStack(edgeStackID portainer.EdgeStackID) {
-	rels, err := service.cachedEndpointRelations()
+	rels, err := service.EndpointRelations()
 	if err != nil {
 		log.Error().Err(err).Msg("cannot retrieve endpoint relations")
 		return
 	}
 
 	for _, rel := range rels {
-		if _, ok := rel.EdgeStacks[edgeStackID]; ok {
-			cache.Del(rel.EndpointID)
+		for id := range rel.EdgeStacks {
+			if edgeStackID == id {
+				cache.Del(rel.EndpointID)
+			}
 		}
 	}
 }
 
-func (service ServiceTx) cachedEndpointRelations() ([]portainer.EndpointRelation, error) {
-	service.service.mu.Lock()
-	defer service.service.mu.Unlock()
-
-	if service.service.endpointRelationsCache == nil {
-		var err error
-		service.service.endpointRelationsCache, err = service.EndpointRelations()
-		if err != nil {
-			return nil, err
-		}
-	}
-
-	return service.service.endpointRelationsCache, nil
-}
-
 func (service ServiceTx) updateEdgeStacksAfterRelationChange(previousRelationState *portainer.EndpointRelation, updatedRelationState *portainer.EndpointRelation) {
+	relations, _ := service.EndpointRelations()
+
+	stacksToUpdate := map[portainer.EdgeStackID]bool{}
+
 	if previousRelationState != nil {
 		for stackId, enabled := range previousRelationState.EdgeStacks {
 			// flag stack for update if stack is not in the updated relation state
 			// = stack has been removed for this relation
 			// or this relation has been deleted
 			if enabled && (updatedRelationState == nil || !updatedRelationState.EdgeStacks[stackId]) {
-				if err := service.service.updateStackFnTx(service.tx, stackId, func(edgeStack *portainer.EdgeStack) {
-					// Sanity check
-					if edgeStack.NumDeployments <= 0 {
-						log.Error().
-							Int("edgestack_id", int(edgeStack.ID)).
-							Int("endpoint_id", int(previousRelationState.EndpointID)).
-							Int("num_deployments", edgeStack.NumDeployments).
-							Msg("cannot decrement the number of deployments for an edge stack with zero deployments")
-
-						return
-					}
-
-					edgeStack.NumDeployments--
-				}); err != nil {
-					log.Error().Err(err).Msg("could not update the number of deployments")
-				}
-
-				cache.Del(previousRelationState.EndpointID)
+				stacksToUpdate[stackId] = true
 			}
 		}
 	}
 
-	if updatedRelationState == nil {
-		return
+	if updatedRelationState != nil {
+		for stackId, enabled := range updatedRelationState.EdgeStacks {
+			// flag stack for update if stack is not in the previous relation state
+			// = stack has been added for this relation
+			if enabled && (previousRelationState == nil || !previousRelationState.EdgeStacks[stackId]) {
+				stacksToUpdate[stackId] = true
+			}
+		}
 	}
 
-	for stackId, enabled := range updatedRelationState.EdgeStacks {
-		// flag stack for update if stack is not in the previous relation state
-		// = stack has been added for this relation
-		if enabled && (previousRelationState == nil || !previousRelationState.EdgeStacks[stackId]) {
-			if err := service.service.updateStackFnTx(service.tx, stackId, func(edgeStack *portainer.EdgeStack) {
-				edgeStack.NumDeployments++
-			}); err != nil {
-				log.Error().Err(err).Msg("could not update the number of deployments")
-			}
+	// for each stack referenced by the updated relation
+	// list how many time this stack is referenced in all relations
+	// in order to update the stack deployments count
+	for refStackId, refStackEnabled := range stacksToUpdate {
+		if !refStackEnabled {
+			continue
+		}
 
-			cache.Del(updatedRelationState.EndpointID)
+		numDeployments := 0
+		for _, r := range relations {
+			for sId, enabled := range r.EdgeStacks {
+				if enabled && sId == refStackId {
+					numDeployments += 1
+				}
+			}
+		}
+
+		if err := service.service.updateStackFnTx(service.tx, refStackId, func(edgeStack *portainer.EdgeStack) {
+			edgeStack.NumDeployments = numDeployments
+		}); err != nil {
+			log.Error().Err(err).Msg("could not update the number of deployments")
 		}
 	}
 }

api/dataservices/interface.go

@@ -12,7 +12,6 @@ type (
 		EdgeGroup() EdgeGroupService
 		EdgeJob() EdgeJobService
 		EdgeStack() EdgeStackService
-		EdgeStackStatus() EdgeStackStatusService
 		Endpoint() EndpointService
 		EndpointGroup() EndpointGroupService
 		EndpointRelation() EndpointRelationService
@@ -40,8 +39,8 @@ type (
 		Open() (newStore bool, err error)
 		Init() error
 		Close() error
-		UpdateTx(func(tx DataStoreTx) error) error
-		ViewTx(func(tx DataStoreTx) error) error
+		UpdateTx(func(DataStoreTx) error) error
+		ViewTx(func(DataStoreTx) error) error
 		MigrateData() error
 		Rollback(force bool) error
 		CheckCurrentEdition() error
@@ -90,16 +89,6 @@ type (
 		BucketName() string
 	}
 
-	EdgeStackStatusService interface {
-		Create(edgeStackID portainer.EdgeStackID, endpointID portainer.EndpointID, status *portainer.EdgeStackStatusForEnv) error
-		Read(edgeStackID portainer.EdgeStackID, endpointID portainer.EndpointID) (*portainer.EdgeStackStatusForEnv, error)
-		ReadAll(edgeStackID portainer.EdgeStackID) ([]portainer.EdgeStackStatusForEnv, error)
-		Update(edgeStackID portainer.EdgeStackID, endpointID portainer.EndpointID, status *portainer.EdgeStackStatusForEnv) error
-		Delete(edgeStackID portainer.EdgeStackID, endpointID portainer.EndpointID) error
-		DeleteAll(edgeStackID portainer.EdgeStackID) error
-		Clear(edgeStackID portainer.EdgeStackID, relatedEnvironmentsIDs []portainer.EndpointID) error
-	}
-
 	// EndpointService represents a service for managing environment(endpoint) data
 	EndpointService interface {
 		Endpoint(ID portainer.EndpointID) (*portainer.Endpoint, error)
@@ -126,8 +115,6 @@ type (
 		EndpointRelation(EndpointID portainer.EndpointID) (*portainer.EndpointRelation, error)
 		Create(endpointRelation *portainer.EndpointRelation) error
 		UpdateEndpointRelation(EndpointID portainer.EndpointID, endpointRelation *portainer.EndpointRelation) error
-		AddEndpointRelationsForEdgeStack(endpointIDs []portainer.EndpointID, edgeStack *portainer.EdgeStack) error
-		RemoveEndpointRelationsForEdgeStack(endpointIDs []portainer.EndpointID, edgeStackID portainer.EdgeStackID) error
 		DeleteEndpointRelation(EndpointID portainer.EndpointID) error
 		BucketName() string
 	}
@@ -170,7 +157,6 @@ type (
 
 	SnapshotService interface {
 		BaseCRUD[portainer.Snapshot, portainer.EndpointID]
-		ReadWithoutSnapshotRaw(ID portainer.EndpointID) (*portainer.Snapshot, error)
 	}
 
 	// SSLSettingsService represents a service for managing application settings

api/dataservices/pendingactions/pendingactions.go

@@ -1,16 +1,26 @@
 package pendingactions
 
 import (
+	"fmt"
+	"time"
+
 	portainer "github.com/portainer/portainer/api"
 	"github.com/portainer/portainer/api/dataservices"
+	"github.com/rs/zerolog/log"
 )
 
-const BucketName = "pending_actions"
+const (
+	BucketName = "pending_actions"
+)
 
 type Service struct {
 	dataservices.BaseDataService[portainer.PendingAction, portainer.PendingActionID]
 }
 
+type ServiceTx struct {
+	dataservices.BaseDataServiceTx[portainer.PendingAction, portainer.PendingActionID]
+}
+
 func NewService(connection portainer.Connection) (*Service, error) {
 	err := connection.SetServiceName(BucketName)
 	if err != nil {
@@ -25,11 +35,6 @@ func NewService(connection portainer.Connection) (*Service, error) {
 	}, nil
 }
 
-// GetNextIdentifier returns the next identifier for a custom template.
-func (service *Service) GetNextIdentifier() int {
-	return service.Connection.GetNextIdentifier(BucketName)
-}
-
 func (s Service) Create(config *portainer.PendingAction) error {
 	return s.Connection.UpdateTx(func(tx portainer.Transaction) error {
 		return s.Tx(tx).Create(config)
@@ -57,3 +62,44 @@ func (service *Service) Tx(tx portainer.Transaction) ServiceTx {
 		},
 	}
 }
+
+func (s ServiceTx) Create(config *portainer.PendingAction) error {
+	return s.Tx.CreateObject(BucketName, func(id uint64) (int, any) {
+		config.ID = portainer.PendingActionID(id)
+		config.CreatedAt = time.Now().Unix()
+
+		return int(config.ID), config
+	})
+}
+
+func (s ServiceTx) Update(ID portainer.PendingActionID, config *portainer.PendingAction) error {
+	return s.BaseDataServiceTx.Update(ID, config)
+}
+
+func (s ServiceTx) DeleteByEndpointID(ID portainer.EndpointID) error {
+	log.Debug().Int("endpointId", int(ID)).Msg("deleting pending actions for endpoint")
+	pendingActions, err := s.BaseDataServiceTx.ReadAll()
+	if err != nil {
+		return fmt.Errorf("failed to retrieve pending-actions for endpoint (%d): %w", ID, err)
+	}
+
+	for _, pendingAction := range pendingActions {
+		if pendingAction.EndpointID == ID {
+			err := s.BaseDataServiceTx.Delete(pendingAction.ID)
+			if err != nil {
+				log.Debug().Int("endpointId", int(ID)).Msgf("failed to delete pending action: %v", err)
+			}
+		}
+	}
+	return nil
+}
+
+// GetNextIdentifier returns the next identifier for a custom template.
+func (service ServiceTx) GetNextIdentifier() int {
+	return service.Tx.GetNextIdentifier(BucketName)
+}
+
+// GetNextIdentifier returns the next identifier for a custom template.
+func (service *Service) GetNextIdentifier() int {
+	return service.Connection.GetNextIdentifier(BucketName)
+}

api/dataservices/pendingactions/pendingactions_test.go

@@ -1,32 +0,0 @@
-package pendingactions_test
-
-import (
-	"testing"
-
-	portainer "github.com/portainer/portainer/api"
-	"github.com/portainer/portainer/api/datastore"
-
-	"github.com/stretchr/testify/require"
-)
-
-func TestDeleteByEndpoint(t *testing.T) {
-	_, store := datastore.MustNewTestStore(t, false, false)
-
-	// Create Endpoint 1
-	err := store.PendingActions().Create(&portainer.PendingAction{EndpointID: 1})
-	require.NoError(t, err)
-
-	// Create Endpoint 2
-	err = store.PendingActions().Create(&portainer.PendingAction{EndpointID: 2})
-	require.NoError(t, err)
-
-	// Delete Endpoint 1
-	err = store.PendingActions().DeleteByEndpointID(1)
-	require.NoError(t, err)
-
-	// Check that only Endpoint 2 remains
-	pendingActions, err := store.PendingActions().ReadAll()
-	require.NoError(t, err)
-	require.Len(t, pendingActions, 1)
-	require.Equal(t, portainer.EndpointID(2), pendingActions[0].EndpointID)
-}

api/dataservices/pendingactions/tx.go

@@ -1,49 +0,0 @@
-package pendingactions
-
-import (
-	"fmt"
-	"time"
-
-	portainer "github.com/portainer/portainer/api"
-	"github.com/portainer/portainer/api/dataservices"
-	"github.com/rs/zerolog/log"
-)
-
-type ServiceTx struct {
-	dataservices.BaseDataServiceTx[portainer.PendingAction, portainer.PendingActionID]
-}
-
-func (s ServiceTx) Create(config *portainer.PendingAction) error {
-	return s.Tx.CreateObject(BucketName, func(id uint64) (int, any) {
-		config.ID = portainer.PendingActionID(id)
-		config.CreatedAt = time.Now().Unix()
-
-		return int(config.ID), config
-	})
-}
-
-func (s ServiceTx) Update(ID portainer.PendingActionID, config *portainer.PendingAction) error {
-	return s.BaseDataServiceTx.Update(ID, config)
-}
-
-func (s ServiceTx) DeleteByEndpointID(ID portainer.EndpointID) error {
-	log.Debug().Int("endpointId", int(ID)).Msg("deleting pending actions for endpoint")
-	pendingActions, err := s.ReadAll()
-	if err != nil {
-		return fmt.Errorf("failed to retrieve pending-actions for endpoint (%d): %w", ID, err)
-	}
-
-	for _, pendingAction := range pendingActions {
-		if pendingAction.EndpointID == ID {
-			if err := s.Delete(pendingAction.ID); err != nil {
-				log.Debug().Int("endpointId", int(ID)).Msgf("failed to delete pending action: %v", err)
-			}
-		}
-	}
-	return nil
-}
-
-// GetNextIdentifier returns the next identifier for a custom template.
-func (service ServiceTx) GetNextIdentifier() int {
-	return service.Tx.GetNextIdentifier(BucketName)
-}

api/dataservices/snapshot/snapshot.go

@@ -38,33 +38,3 @@ func (service *Service) Tx(tx portainer.Transaction) ServiceTx {
 func (service *Service) Create(snapshot *portainer.Snapshot) error {
 	return service.Connection.CreateObjectWithId(BucketName, int(snapshot.EndpointID), snapshot)
 }
-
-func (service *Service) ReadWithoutSnapshotRaw(ID portainer.EndpointID) (*portainer.Snapshot, error) {
-	var snapshot *portainer.Snapshot
-
-	err := service.Connection.ViewTx(func(tx portainer.Transaction) error {
-		var err error
-		snapshot, err = service.Tx(tx).ReadWithoutSnapshotRaw(ID)
-
-		return err
-	})
-
-	return snapshot, err
-}
-
-func (service *Service) ReadRawMessage(ID portainer.EndpointID) (*portainer.SnapshotRawMessage, error) {
-	var snapshot *portainer.SnapshotRawMessage
-
-	err := service.Connection.ViewTx(func(tx portainer.Transaction) error {
-		var err error
-		snapshot, err = service.Tx(tx).ReadRawMessage(ID)
-
-		return err
-	})
-
-	return snapshot, err
-}
-
-func (service *Service) CreateRawMessage(snapshot *portainer.SnapshotRawMessage) error {
-	return service.Connection.CreateObjectWithId(BucketName, int(snapshot.EndpointID), snapshot)
-}

api/dataservices/snapshot/tx.go

@@ -12,42 +12,3 @@ type ServiceTx struct {
 func (service ServiceTx) Create(snapshot *portainer.Snapshot) error {
 	return service.Tx.CreateObjectWithId(BucketName, int(snapshot.EndpointID), snapshot)
 }
-
-func (service ServiceTx) ReadWithoutSnapshotRaw(ID portainer.EndpointID) (*portainer.Snapshot, error) {
-	var snapshot struct {
-		Docker *struct {
-			X struct{} `json:"DockerSnapshotRaw"`
-			*portainer.DockerSnapshot
-		} `json:"Docker"`
-
-		portainer.Snapshot
-	}
-
-	identifier := service.Connection.ConvertToKey(int(ID))
-
-	if err := service.Tx.GetObject(service.Bucket, identifier, &snapshot); err != nil {
-		return nil, err
-	}
-
-	if snapshot.Docker != nil {
-		snapshot.Snapshot.Docker = snapshot.Docker.DockerSnapshot
-	}
-
-	return &snapshot.Snapshot, nil
-}
-
-func (service ServiceTx) ReadRawMessage(ID portainer.EndpointID) (*portainer.SnapshotRawMessage, error) {
-	var snapshot = portainer.SnapshotRawMessage{}
-
-	identifier := service.Connection.ConvertToKey(int(ID))
-
-	if err := service.Tx.GetObject(service.Bucket, identifier, &snapshot); err != nil {
-		return nil, err
-	}
-
-	return &snapshot, nil
-}
-
-func (service ServiceTx) CreateRawMessage(snapshot *portainer.SnapshotRawMessage) error {
-	return service.Tx.CreateObjectWithId(BucketName, int(snapshot.EndpointID), snapshot)
-}

api/datastore/datastore.go

@@ -16,9 +16,8 @@ import (
 )
 
 // NewStore initializes a new Store and the associated services
-func NewStore(cliFlags *portainer.CLIFlags, fileService portainer.FileService, connection portainer.Connection) *Store {
+func NewStore(storePath string, fileService portainer.FileService, connection portainer.Connection) *Store {
 	return &Store{
-		flags:       cliFlags,
 		fileService: fileService,
 		connection:  connection,
 	}

api/datastore/datastore_test.go

@@ -232,7 +232,7 @@ func (store *Store) createAccount(username, password string, role portainer.User
 	user := &portainer.User{Username: username, Role: role}
 
 	// encrypt the password
-	cs := crypto.Service{}
+	cs := &crypto.Service{}
 	user.Password, err = cs.Hash(password)
 	if err != nil {
 		return err
@@ -259,7 +259,7 @@ func (store *Store) checkAccount(username, expectPassword string, expectRole por
 	}
 
 	// Check the password
-	cs := crypto.Service{}
+	cs := &crypto.Service{}
 	expectPasswordHash, err := cs.Hash(expectPassword)
 	if err != nil {
 		return errors.Wrap(err, "hash failed")

api/datastore/init.go

@@ -57,7 +57,7 @@ func (store *Store) checkOrCreateDefaultSettings() error {
 			HelmRepositoryURL:        portainer.DefaultHelmRepositoryURL,
 			UserSessionTimeout:       portainer.DefaultUserSessionTimeout,
 			KubeconfigExpiry:         portainer.DefaultKubeconfigExpiry,
-			KubectlShellImage:        *store.flags.KubectlShellImage,
+			KubectlShellImage:        portainer.DefaultKubectlShellImage,
 
 			IsDockerDesktopExtension: isDDExtention,
 		}

api/datastore/migrate_data.go

@@ -32,7 +32,7 @@ func (store *Store) MigrateData() error {
 		return errors.Wrap(err, "while migrating legacy version")
 	}
 
-	migratorParams := store.newMigratorParameters(version, store.flags)
+	migratorParams := store.newMigratorParameters(version)
 	migrator := migrator.NewMigrator(migratorParams)
 
 	if !migrator.NeedsMigration() {
@@ -40,11 +40,13 @@ func (store *Store) MigrateData() error {
 	}
 
 	// before we alter anything in the DB, create a backup
-	if _, err := store.Backup(""); err != nil {
+	_, err = store.Backup("")
+	if err != nil {
 		return errors.Wrap(err, "while backing up database")
 	}
 
-	if err := store.FailSafeMigrate(migrator, version); err != nil {
+	err = store.FailSafeMigrate(migrator, version)
+	if err != nil {
 		err = errors.Wrap(err, "failed to migrate database")
 
 		log.Warn().Err(err).Msg("migration failed, restoring database to previous version")
@@ -60,9 +62,8 @@ func (store *Store) MigrateData() error {
 	return nil
 }
 
-func (store *Store) newMigratorParameters(version *models.Version, flags *portainer.CLIFlags) *migrator.MigratorParameters {
+func (store *Store) newMigratorParameters(version *models.Version) *migrator.MigratorParameters {
 	return &migrator.MigratorParameters{
-		Flags:                   flags,
 		CurrentDBVersion:        version,
 		EndpointGroupService:    store.EndpointGroupService,
 		EndpointService:         store.EndpointService,
@@ -83,9 +84,7 @@ func (store *Store) newMigratorParameters(version *models.Version, flags *portai
 		DockerhubService:        store.DockerHubService,
 		AuthorizationService:    authorization.NewService(store),
 		EdgeStackService:        store.EdgeStackService,
-		EdgeStackStatusService:  store.EdgeStackStatusService,
 		EdgeJobService:          store.EdgeJobService,
-		EdgeGroupService:        store.EdgeGroupService,
 		TunnelServerService:     store.TunnelServerService,
 		PendingActionsService:   store.PendingActionsService,
 	}
@@ -140,7 +139,8 @@ func (store *Store) connectionRollback(force bool) error {
 		}
 	}
 
-	if err := store.Restore(); err != nil {
+	err := store.Restore()
+	if err != nil {
 		return err
 	}
 

api/datastore/migrate_data_test.go

@@ -109,7 +109,7 @@ func TestMigrateData(t *testing.T) {
 			t.FailNow()
 		}
 
-		migratorParams := store.newMigratorParameters(v, store.flags)
+		migratorParams := store.newMigratorParameters(v)
 		m := migrator.NewMigrator(migratorParams)
 		latestMigrations := m.LatestMigrations()
 

api/datastore/migrate_dbversion29_test.go

@@ -48,7 +48,6 @@ func TestMigrateSettings(t *testing.T) {
 	}
 
 	m := migrator.NewMigrator(&migrator.MigratorParameters{
-		Flags:                   store.flags,
 		EndpointGroupService:    store.EndpointGroupService,
 		EndpointService:         store.EndpointService,
 		EndpointRelationService: store.EndpointRelationService,

api/datastore/migrator/migrate_2_31_0.go

@@ -1,31 +0,0 @@
-package migrator
-
-import portainer "github.com/portainer/portainer/api"
-
-func (m *Migrator) migrateEdgeStacksStatuses_2_31_0() error {
-	edgeStacks, err := m.edgeStackService.EdgeStacks()
-	if err != nil {
-		return err
-	}
-
-	for _, edgeStack := range edgeStacks {
-		for envID, status := range edgeStack.Status {
-			if err := m.edgeStackStatusService.Create(edgeStack.ID, envID, &portainer.EdgeStackStatusForEnv{
-				EndpointID:       envID,
-				Status:           status.Status,
-				DeploymentInfo:   status.DeploymentInfo,
-				ReadyRePullImage: status.ReadyRePullImage,
-			}); err != nil {
-				return err
-			}
-		}
-
-		edgeStack.Status = nil
-
-		if err := m.edgeStackService.UpdateEdgeStack(edgeStack.ID, &edgeStack); err != nil {
-			return err
-		}
-	}
-
-	return nil
-}

api/datastore/migrator/migrate_2_32_0.go

@@ -1,33 +0,0 @@
-package migrator
-
-import (
-	"github.com/pkg/errors"
-	portainer "github.com/portainer/portainer/api"
-	perrors "github.com/portainer/portainer/api/dataservices/errors"
-	"github.com/portainer/portainer/api/internal/endpointutils"
-)
-
-func (m *Migrator) addEndpointRelationForEdgeAgents_2_32_0() error {
-	endpoints, err := m.endpointService.Endpoints()
-	if err != nil {
-		return err
-	}
-
-	for _, endpoint := range endpoints {
-		if endpointutils.IsEdgeEndpoint(&endpoint) {
-			_, err := m.endpointRelationService.EndpointRelation(endpoint.ID)
-			if err != nil && errors.Is(err, perrors.ErrObjectNotFound) {
-				relation := &portainer.EndpointRelation{
-					EndpointID: endpoint.ID,
-					EdgeStacks: make(map[portainer.EdgeStackID]bool),
-				}
-
-				if err := m.endpointRelationService.Create(relation); err != nil {
-					return err
-				}
-			}
-		}
-	}
-
-	return nil
-}

api/datastore/migrator/migrate_2_33_0.go

@@ -1,25 +0,0 @@
-package migrator
-
-import (
-	"github.com/portainer/portainer/api/roar"
-)
-
-func (m *Migrator) migrateEdgeGroupEndpointsToRoars_2_33_0() error {
-	egs, err := m.edgeGroupService.ReadAll()
-	if err != nil {
-		return err
-	}
-
-	for _, eg := range egs {
-		if eg.EndpointIDs.Len() == 0 {
-			eg.EndpointIDs = roar.FromSlice(eg.Endpoints)
-			eg.Endpoints = nil
-		}
-
-		if err := m.edgeGroupService.Update(eg.ID, &eg); err != nil {
-			return err
-		}
-	}
-
-	return nil
-}

api/datastore/migrator/migrate_2_33_test.go

@@ -1,55 +0,0 @@
-package migrator
-
-import (
-	"testing"
-
-	portainer "github.com/portainer/portainer/api"
-	"github.com/portainer/portainer/api/database/boltdb"
-	"github.com/portainer/portainer/api/dataservices/edgegroup"
-
-	"github.com/stretchr/testify/require"
-)
-
-func TestMigrateEdgeGroupEndpointsToRoars_2_33_0Idempotency(t *testing.T) {
-	var conn portainer.Connection = &boltdb.DbConnection{Path: t.TempDir()}
-	err := conn.Open()
-	require.NoError(t, err)
-
-	defer conn.Close()
-
-	edgeGroupService, err := edgegroup.NewService(conn)
-	require.NoError(t, err)
-
-	edgeGroup := &portainer.EdgeGroup{
-		ID:        1,
-		Name:      "test-edge-group",
-		Endpoints: []portainer.EndpointID{1, 2, 3},
-	}
-
-	err = conn.CreateObjectWithId(edgegroup.BucketName, int(edgeGroup.ID), edgeGroup)
-	require.NoError(t, err)
-
-	m := NewMigrator(&MigratorParameters{EdgeGroupService: edgeGroupService})
-
-	// Run migration once
-
-	err = m.migrateEdgeGroupEndpointsToRoars_2_33_0()
-	require.NoError(t, err)
-
-	migratedEdgeGroup, err := edgeGroupService.Read(edgeGroup.ID)
-	require.NoError(t, err)
-
-	require.Len(t, migratedEdgeGroup.Endpoints, 0)
-	require.Equal(t, len(edgeGroup.Endpoints), migratedEdgeGroup.EndpointIDs.Len())
-
-	// Run migration again to ensure the results didn't change
-
-	err = m.migrateEdgeGroupEndpointsToRoars_2_33_0()
-	require.NoError(t, err)
-
-	migratedEdgeGroup, err = edgeGroupService.Read(edgeGroup.ID)
-	require.NoError(t, err)
-
-	require.Len(t, migratedEdgeGroup.Endpoints, 0)
-	require.Equal(t, len(edgeGroup.Endpoints), migratedEdgeGroup.EndpointIDs.Len())
-}

api/datastore/migrator/migrate_dbversion100.go

@@ -94,10 +94,6 @@ func (m *Migrator) updateEdgeStackStatusForDB100() error {
 				continue
 			}
 
-			if environmentStatus.Details == nil {
-				continue
-			}
-
 			statusArray := []portainer.EdgeStackDeploymentStatus{}
 			if environmentStatus.Details.Pending {
 				statusArray = append(statusArray, portainer.EdgeStackDeploymentStatus{

api/datastore/migrator/migrate_dbversion20.go

@@ -18,7 +18,8 @@ func (m *Migrator) updateResourceControlsToDBVersion22() error {
 	for _, resourceControl := range legacyResourceControls {
 		resourceControl.AdministratorsOnly = false
 
-		if err := m.resourceControlService.Update(resourceControl.ID, &resourceControl); err != nil {
+		err := m.resourceControlService.Update(resourceControl.ID, &resourceControl)
+		if err != nil {
 			return err
 		}
 	}
@@ -41,8 +42,8 @@ func (m *Migrator) updateUsersAndRolesToDBVersion22() error {
 
 	for _, user := range legacyUsers {
 		user.PortainerAuthorizations = authorization.DefaultPortainerAuthorizations()
-
-		if err := m.userService.Update(user.ID, &user); err != nil {
+		err = m.userService.Update(user.ID, &user)
+		if err != nil {
 			return err
 		}
 	}
@@ -51,47 +52,38 @@ func (m *Migrator) updateUsersAndRolesToDBVersion22() error {
 	if err != nil {
 		return err
 	}
-
 	endpointAdministratorRole.Priority = 1
 	endpointAdministratorRole.Authorizations = authorization.DefaultEndpointAuthorizationsForEndpointAdministratorRole()
 
-	if err := m.roleService.Update(endpointAdministratorRole.ID, endpointAdministratorRole); err != nil {
-		return err
-	}
+	err = m.roleService.Update(endpointAdministratorRole.ID, endpointAdministratorRole)
 
 	helpDeskRole, err := m.roleService.Read(portainer.RoleID(2))
 	if err != nil {
 		return err
 	}
-
 	helpDeskRole.Priority = 2
 	helpDeskRole.Authorizations = authorization.DefaultEndpointAuthorizationsForHelpDeskRole(settings.AllowVolumeBrowserForRegularUsers)
 
-	if err := m.roleService.Update(helpDeskRole.ID, helpDeskRole); err != nil {
-		return err
-	}
+	err = m.roleService.Update(helpDeskRole.ID, helpDeskRole)
 
 	standardUserRole, err := m.roleService.Read(portainer.RoleID(3))
 	if err != nil {
 		return err
 	}
-
 	standardUserRole.Priority = 3
 	standardUserRole.Authorizations = authorization.DefaultEndpointAuthorizationsForStandardUserRole(settings.AllowVolumeBrowserForRegularUsers)
 
-	if err := m.roleService.Update(standardUserRole.ID, standardUserRole); err != nil {
-		return err
-	}
+	err = m.roleService.Update(standardUserRole.ID, standardUserRole)
 
 	readOnlyUserRole, err := m.roleService.Read(portainer.RoleID(4))
 	if err != nil {
 		return err
 	}
-
 	readOnlyUserRole.Priority = 4
 	readOnlyUserRole.Authorizations = authorization.DefaultEndpointAuthorizationsForReadOnlyUserRole(settings.AllowVolumeBrowserForRegularUsers)
 
-	if err := m.roleService.Update(readOnlyUserRole.ID, readOnlyUserRole); err != nil {
+	err = m.roleService.Update(readOnlyUserRole.ID, readOnlyUserRole)
+	if err != nil {
 		return err
 	}
 

api/datastore/migrator/migrate_dbversion32.go

@@ -1,6 +1,8 @@
 package migrator
 
 import (
+	portainer "github.com/portainer/portainer/api"
+
 	"github.com/rs/zerolog/log"
 )
 
@@ -18,7 +20,7 @@ func (m *Migrator) migrateSettingsToDB33() error {
 	}
 
 	log.Info().Msg("setting default kubectl shell image")
-	settings.KubectlShellImage = *m.flags.KubectlShellImage
+	settings.KubectlShellImage = portainer.DefaultKubectlShellImage
 
 	return m.settingsService.UpdateSettings(settings)
 }

api/datastore/migrator/migrate_dbversion80.go

@@ -75,10 +75,6 @@ func (m *Migrator) updateEdgeStackStatusForDB80() error {
 
 	for _, edgeStack := range edgeStacks {
 		for endpointId, status := range edgeStack.Status {
-			if status.Details == nil {
-				status.Details = &portainer.EdgeStackStatusDetails{}
-			}
-
 			switch status.Type {
 			case portainer.EdgeStackStatusPending:
 				status.Details.Pending = true
@@ -97,10 +93,10 @@ func (m *Migrator) updateEdgeStackStatusForDB80() error {
 			edgeStack.Status[endpointId] = status
 		}
 
-		if err := m.edgeStackService.UpdateEdgeStack(edgeStack.ID, &edgeStack); err != nil {
+		err = m.edgeStackService.UpdateEdgeStack(edgeStack.ID, &edgeStack)
+		if err != nil {
 			return err
 		}
 	}
-
 	return nil
 }

api/datastore/migrator/migrator.go

@@ -3,13 +3,12 @@ package migrator
 import (
 	"errors"
 
+	"github.com/Masterminds/semver"
 	portainer "github.com/portainer/portainer/api"
 	"github.com/portainer/portainer/api/database/models"
 	"github.com/portainer/portainer/api/dataservices/dockerhub"
-	"github.com/portainer/portainer/api/dataservices/edgegroup"
 	"github.com/portainer/portainer/api/dataservices/edgejob"
 	"github.com/portainer/portainer/api/dataservices/edgestack"
-	"github.com/portainer/portainer/api/dataservices/edgestackstatus"
 	"github.com/portainer/portainer/api/dataservices/endpoint"
 	"github.com/portainer/portainer/api/dataservices/endpointgroup"
 	"github.com/portainer/portainer/api/dataservices/endpointrelation"
@@ -28,15 +27,12 @@ import (
 	"github.com/portainer/portainer/api/dataservices/user"
 	"github.com/portainer/portainer/api/dataservices/version"
 	"github.com/portainer/portainer/api/internal/authorization"
-
-	"github.com/Masterminds/semver"
 	"github.com/rs/zerolog/log"
 )
 
 type (
 	// Migrator defines a service to migrate data after a Portainer version update.
 	Migrator struct {
-		flags            *portainer.CLIFlags
 		currentDBVersion *models.Version
 		migrations       []Migrations
 
@@ -59,16 +55,13 @@ type (
 		authorizationService    *authorization.Service
 		dockerhubService        *dockerhub.Service
 		edgeStackService        *edgestack.Service
-		edgeStackStatusService  *edgestackstatus.Service
 		edgeJobService          *edgejob.Service
-		edgeGroupService        *edgegroup.Service
 		TunnelServerService     *tunnelserver.Service
 		pendingActionsService   *pendingactions.Service
 	}
 
 	// MigratorParameters represents the required parameters to create a new Migrator instance.
 	MigratorParameters struct {
-		Flags                   *portainer.CLIFlags
 		CurrentDBVersion        *models.Version
 		EndpointGroupService    *endpointgroup.Service
 		EndpointService         *endpoint.Service
@@ -89,9 +82,7 @@ type (
 		AuthorizationService    *authorization.Service
 		DockerhubService        *dockerhub.Service
 		EdgeStackService        *edgestack.Service
-		EdgeStackStatusService  *edgestackstatus.Service
 		EdgeJobService          *edgejob.Service
-		EdgeGroupService        *edgegroup.Service
 		TunnelServerService     *tunnelserver.Service
 		PendingActionsService   *pendingactions.Service
 	}
@@ -100,7 +91,6 @@ type (
 // NewMigrator creates a new Migrator.
 func NewMigrator(parameters *MigratorParameters) *Migrator {
 	migrator := &Migrator{
-		flags:                   parameters.Flags,
 		currentDBVersion:        parameters.CurrentDBVersion,
 		endpointGroupService:    parameters.EndpointGroupService,
 		endpointService:         parameters.EndpointService,
@@ -121,15 +111,12 @@ func NewMigrator(parameters *MigratorParameters) *Migrator {
 		authorizationService:    parameters.AuthorizationService,
 		dockerhubService:        parameters.DockerhubService,
 		edgeStackService:        parameters.EdgeStackService,
-		edgeStackStatusService:  parameters.EdgeStackStatusService,
 		edgeJobService:          parameters.EdgeJobService,
-		edgeGroupService:        parameters.EdgeGroupService,
 		TunnelServerService:     parameters.TunnelServerService,
 		pendingActionsService:   parameters.PendingActionsService,
 	}
 
 	migrator.initMigrations()
-
 	return migrator
 }
 
@@ -252,12 +239,6 @@ func (m *Migrator) initMigrations() {
 		m.migratePendingActionsDataForDB130,
 	)
 
-	m.addMigrations("2.31.0", m.migrateEdgeStacksStatuses_2_31_0)
-
-	m.addMigrations("2.32.0", m.addEndpointRelationForEdgeAgents_2_32_0)
-
-	m.addMigrations("2.33.1", m.migrateEdgeGroupEndpointsToRoars_2_33_0)
-
 	// Add new migrations above...
 	// One function per migration, each versions migration funcs in the same file.
 }

api/datastore/postinit/migrate_post_init.go

@@ -2,7 +2,6 @@ package postinit
 
 import (
 	"context"
-	"fmt"
 
 	"github.com/docker/docker/api/types/container"
 	"github.com/docker/docker/client"
@@ -12,7 +11,6 @@ import (
 	"github.com/portainer/portainer/api/internal/endpointutils"
 	"github.com/portainer/portainer/api/kubernetes/cli"
 	"github.com/portainer/portainer/api/pendingactions/actions"
-	"github.com/portainer/portainer/pkg/endpoints"
 
 	"github.com/rs/zerolog/log"
 )
@@ -51,29 +49,17 @@ func (postInitMigrator *PostInitMigrator) PostInitMigrate() error {
 
 	for _, environment := range environments {
 		// edge environments will run after the server starts, in pending actions
-		if endpoints.IsEdgeEndpoint(&environment) {
-			// Skip edge environments that do not have direct connectivity
-			if !endpoints.HasDirectConnectivity(&environment) {
-				continue
-			}
-
-			log.Info().
-				Int("endpoint_id", int(environment.ID)).
-				Msg("adding pending action 'PostInitMigrateEnvironment' for environment")
-
-			if err := postInitMigrator.createPostInitMigrationPendingAction(environment.ID); err != nil {
-				log.Error().
-					Err(err).
-					Int("endpoint_id", int(environment.ID)).
-					Msg("error creating pending action for environment")
+		if endpointutils.IsEdgeEndpoint(&environment) {
+			log.Info().Msgf("Adding pending action 'PostInitMigrateEnvironment' for environment %d", environment.ID)
+			err = postInitMigrator.createPostInitMigrationPendingAction(environment.ID)
+			if err != nil {
+				log.Error().Err(err).Msgf("Error creating pending action for environment %d", environment.ID)
 			}
 		} else {
-			// Non-edge environments will run before the server starts.
-			if err := postInitMigrator.MigrateEnvironment(&environment); err != nil {
-				log.Error().
-					Err(err).
-					Int("endpoint_id", int(environment.ID)).
-					Msg("error running post-init migrations for non-edge environment")
+			// non-edge environments will run before the server starts.
+			err = postInitMigrator.MigrateEnvironment(&environment)
+			if err != nil {
+				log.Error().Err(err).Msgf("Error running post-init migrations for non-edge environment %d", environment.ID)
 			}
 		}
 
@@ -84,27 +70,17 @@ func (postInitMigrator *PostInitMigrator) PostInitMigrate() error {
 
 // try to create a post init migration pending action. If it already exists, do nothing
 // this function exists for readability, not reusability
+// TODO: This should be moved into pending actions as part of the pending action migration
 func (postInitMigrator *PostInitMigrator) createPostInitMigrationPendingAction(environmentID portainer.EndpointID) error {
-	action := portainer.PendingAction{
+	// If there are no pending actions for the given endpoint, create one
+	err := postInitMigrator.dataStore.PendingActions().Create(&portainer.PendingAction{
 		EndpointID: environmentID,
 		Action:     actions.PostInitMigrateEnvironment,
-	}
-	pendingActions, err := postInitMigrator.dataStore.PendingActions().ReadAll()
+	})
 	if err != nil {
-		return fmt.Errorf("failed to retrieve pending actions: %w", err)
+		log.Error().Err(err).Msgf("Error creating pending action for environment %d", environmentID)
 	}
-
-	for _, dba := range pendingActions {
-		if dba.EndpointID == action.EndpointID && dba.Action == action.Action {
-			log.Debug().
-				Str("action", action.Action).
-				Int("endpoint_id", int(action.EndpointID)).
-				Msg("pending action already exists for environment, skipping...")
-			return nil
-		}
-	}
-
-	return postInitMigrator.dataStore.PendingActions().Create(&action)
+	return nil
 }
 
 // MigrateEnvironment runs migrations on a single environment
@@ -160,7 +136,7 @@ func (migrator *PostInitMigrator) MigrateGPUs(e portainer.Endpoint, dockerClient
 	return migrator.dataStore.UpdateTx(func(tx dataservices.DataStoreTx) error {
 		environment, err := tx.Endpoint().Endpoint(e.ID)
 		if err != nil {
-			log.Error().Err(err).Msgf("Error getting environment %d", e.ID)
+			log.Error().Err(err).Msgf("Error getting environment %d", environment.ID)
 			return err
 		}
 		// Early exit if we do not need to migrate!
@@ -186,11 +162,10 @@ func (migrator *PostInitMigrator) MigrateGPUs(e portainer.Endpoint, dockerClient
 				continue
 			}
 
-			deviceRequests := containerDetails.HostConfig.DeviceRequests
+			deviceRequests := containerDetails.HostConfig.Resources.DeviceRequests
 			for _, deviceRequest := range deviceRequests {
 				if deviceRequest.Driver == "nvidia" {
 					environment.EnableGPUManagement = true
-
 					break containersLoop
 				}
 			}
@@ -198,7 +173,8 @@ func (migrator *PostInitMigrator) MigrateGPUs(e portainer.Endpoint, dockerClient
 
 		// set the MigrateGPUs flag to false so we don't run this again
 		environment.PostInitMigrations.MigrateGPUs = false
-		if err := tx.Endpoint().UpdateEndpoint(environment.ID, environment); err != nil {
+		err = tx.Endpoint().UpdateEndpoint(environment.ID, environment)
+		if err != nil {
 			log.Error().Err(err).Msgf("Error updating EnableGPUManagement flag for environment %d", environment.ID)
 			return err
 		}

api/datastore/postinit/migrate_post_init_test.go

@@ -1,170 +0,0 @@
-package postinit
-
-import (
-	"net/http"
-	"net/http/httptest"
-	"strings"
-	"testing"
-
-	portainer "github.com/portainer/portainer/api"
-	"github.com/portainer/portainer/api/datastore"
-	"github.com/portainer/portainer/api/pendingactions/actions"
-
-	"github.com/docker/docker/api/types/container"
-	"github.com/docker/docker/client"
-	"github.com/segmentio/encoding/json"
-	"github.com/stretchr/testify/assert"
-	"github.com/stretchr/testify/require"
-)
-
-func TestMigrateGPUs(t *testing.T) {
-	srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
-		if strings.HasSuffix(r.URL.Path, "/containers/json") {
-			containerSummary := []container.Summary{{ID: "container1"}}
-
-			err := json.NewEncoder(w).Encode(containerSummary)
-			require.NoError(t, err)
-
-			return
-		}
-
-		container := container.InspectResponse{
-			ContainerJSONBase: &container.ContainerJSONBase{
-				ID: "container1",
-				HostConfig: &container.HostConfig{
-					Resources: container.Resources{
-						DeviceRequests: []container.DeviceRequest{
-							{Driver: "nvidia"},
-						},
-					},
-				},
-			},
-		}
-
-		err := json.NewEncoder(w).Encode(container)
-		require.NoError(t, err)
-	}))
-	defer srv.Close()
-
-	_, store := datastore.MustNewTestStore(t, true, false)
-
-	migrator := &PostInitMigrator{dataStore: store}
-
-	dockerCli, err := client.NewClientWithOpts(client.WithHost(srv.URL), client.WithHTTPClient(http.DefaultClient))
-	require.NoError(t, err)
-
-	// Nonexistent endpoint
-
-	err = migrator.MigrateGPUs(portainer.Endpoint{}, dockerCli)
-	require.Error(t, err)
-
-	// Valid endpoint
-
-	endpoint := portainer.Endpoint{ID: 1, PostInitMigrations: portainer.EndpointPostInitMigrations{MigrateGPUs: true}}
-
-	err = store.Endpoint().Create(&endpoint)
-	require.NoError(t, err)
-
-	err = migrator.MigrateGPUs(endpoint, dockerCli)
-	require.NoError(t, err)
-
-	migratedEndpoint, err := store.Endpoint().Endpoint(endpoint.ID)
-	require.NoError(t, err)
-
-	require.Equal(t, endpoint.ID, migratedEndpoint.ID)
-	require.False(t, migratedEndpoint.PostInitMigrations.MigrateGPUs)
-	require.True(t, migratedEndpoint.EnableGPUManagement)
-}
-
-func TestPostInitMigrate_PendingActionsCreated(t *testing.T) {
-	tests := []struct {
-		name                   string
-		existingPendingActions []*portainer.PendingAction
-		expectedPendingActions int
-		expectedAction         string
-	}{
-		{
-			name: "when existing non-matching action exists, should add migration action",
-			existingPendingActions: []*portainer.PendingAction{
-				{
-					EndpointID: 7,
-					Action:     "some-other-action",
-				},
-			},
-			expectedPendingActions: 2,
-			expectedAction:         actions.PostInitMigrateEnvironment,
-		},
-		{
-			name: "when matching action exists, should not add duplicate",
-			existingPendingActions: []*portainer.PendingAction{
-				{
-					EndpointID: 7,
-					Action:     actions.PostInitMigrateEnvironment,
-				},
-			},
-			expectedPendingActions: 1,
-			expectedAction:         actions.PostInitMigrateEnvironment,
-		},
-		{
-			name:                   "when no actions exist, should add migration action",
-			existingPendingActions: []*portainer.PendingAction{},
-			expectedPendingActions: 1,
-			expectedAction:         actions.PostInitMigrateEnvironment,
-		},
-	}
-
-	for _, tt := range tests {
-		t.Run(tt.name, func(t *testing.T) {
-			is := assert.New(t)
-			_, store := datastore.MustNewTestStore(t, true, true)
-
-			// Create test endpoint
-			endpoint := &portainer.Endpoint{
-				ID:          7,
-				UserTrusted: true,
-				Type:        portainer.EdgeAgentOnDockerEnvironment,
-				Edge: portainer.EnvironmentEdgeSettings{
-					AsyncMode: false,
-				},
-				EdgeID: "edgeID",
-			}
-			err := store.Endpoint().Create(endpoint)
-			is.NoError(err, "error creating endpoint")
-
-			// Create any existing pending actions
-			for _, action := range tt.existingPendingActions {
-				err = store.PendingActions().Create(action)
-				is.NoError(err, "error creating pending action")
-			}
-
-			migrator := NewPostInitMigrator(
-				nil, // kubeFactory not needed for this test
-				nil, // dockerFactory not needed for this test
-				store,
-				"",  // assetsPath not needed for this test
-				nil, // kubernetesDeployer not needed for this test
-			)
-
-			err = migrator.PostInitMigrate()
-			is.NoError(err, "PostInitMigrate should not return error")
-
-			// Verify the results
-			pendingActions, err := store.PendingActions().ReadAll()
-			is.NoError(err, "error reading pending actions")
-			is.Len(pendingActions, tt.expectedPendingActions, "unexpected number of pending actions")
-
-			// If we expect any actions, verify at least one has the expected action type
-			if tt.expectedPendingActions > 0 {
-				hasExpectedAction := false
-				for _, action := range pendingActions {
-					if action.Action == tt.expectedAction {
-						hasExpectedAction = true
-						is.Equal(endpoint.ID, action.EndpointID, "action should reference correct endpoint")
-						break
-					}
-				}
-				is.True(hasExpectedAction, "should have found action of expected type")
-			}
-		})
-	}
-}

api/datastore/services.go

@@ -13,7 +13,6 @@ import (
 	"github.com/portainer/portainer/api/dataservices/edgegroup"
 	"github.com/portainer/portainer/api/dataservices/edgejob"
 	"github.com/portainer/portainer/api/dataservices/edgestack"
-	"github.com/portainer/portainer/api/dataservices/edgestackstatus"
 	"github.com/portainer/portainer/api/dataservices/endpoint"
 	"github.com/portainer/portainer/api/dataservices/endpointgroup"
 	"github.com/portainer/portainer/api/dataservices/endpointrelation"
@@ -40,12 +39,9 @@ import (
 	"github.com/segmentio/encoding/json"
 )
 
-var _ dataservices.DataStore = &Store{}
-
 // Store defines the implementation of portainer.DataStore using
 // BoltDB as the storage system.
 type Store struct {
-	flags      *portainer.CLIFlags
 	connection portainer.Connection
 
 	fileService               portainer.FileService
@@ -54,7 +50,6 @@ type Store struct {
 	EdgeGroupService          *edgegroup.Service
 	EdgeJobService            *edgejob.Service
 	EdgeStackService          *edgestack.Service
-	EdgeStackStatusService    *edgestackstatus.Service
 	EndpointGroupService      *endpointgroup.Service
 	EndpointService           *endpoint.Service
 	EndpointRelationService   *endpointrelation.Service
@@ -104,20 +99,12 @@ func (store *Store) initServices() error {
 	}
 	store.EndpointRelationService = endpointRelationService
 
-	edgeStackService, err := edgestack.NewService(store.connection, func(tx portainer.Transaction, ID portainer.EdgeStackID) {
-		endpointRelationService.Tx(tx).InvalidateEdgeCacheForEdgeStack(ID)
-	})
+	edgeStackService, err := edgestack.NewService(store.connection, endpointRelationService.InvalidateEdgeCacheForEdgeStack)
 	if err != nil {
 		return err
 	}
 	store.EdgeStackService = edgeStackService
-	endpointRelationService.RegisterUpdateStackFunction(edgeStackService.UpdateEdgeStackFuncTx)
-
-	edgeStackStatusService, err := edgestackstatus.NewService(store.connection)
-	if err != nil {
-		return err
-	}
-	store.EdgeStackStatusService = edgeStackStatusService
+	endpointRelationService.RegisterUpdateStackFunction(edgeStackService.UpdateEdgeStackFunc, edgeStackService.UpdateEdgeStackFuncTx)
 
 	edgeGroupService, err := edgegroup.NewService(store.connection)
 	if err != nil {
@@ -279,10 +266,6 @@ func (store *Store) EdgeStack() dataservices.EdgeStackService {
 	return store.EdgeStackService
 }
 
-func (store *Store) EdgeStackStatus() dataservices.EdgeStackStatusService {
-	return store.EdgeStackStatusService
-}
-
 // Environment(Endpoint) gives access to the Environment(Endpoint) data management layer
 func (store *Store) Endpoint() dataservices.EndpointService {
 	return store.EndpointService

api/datastore/services_tx.go

@@ -14,9 +14,7 @@ func (tx *StoreTx) IsErrObjectNotFound(err error) bool {
 	return tx.store.IsErrObjectNotFound(err)
 }
 
-func (tx *StoreTx) CustomTemplate() dataservices.CustomTemplateService {
-	return tx.store.CustomTemplateService.Tx(tx.tx)
-}
+func (tx *StoreTx) CustomTemplate() dataservices.CustomTemplateService { return nil }
 
 func (tx *StoreTx) PendingActions() dataservices.PendingActionsService {
 	return tx.store.PendingActionsService.Tx(tx.tx)
@@ -34,10 +32,6 @@ func (tx *StoreTx) EdgeStack() dataservices.EdgeStackService {
 	return tx.store.EdgeStackService.Tx(tx.tx)
 }
 
-func (tx *StoreTx) EdgeStackStatus() dataservices.EdgeStackStatusService {
-	return tx.store.EdgeStackStatusService.Tx(tx.tx)
-}
-
 func (tx *StoreTx) Endpoint() dataservices.EndpointService {
 	return tx.store.EndpointService.Tx(tx.tx)
 }

api/datastore/test_data/output_24_to_latest.json

@@ -8,7 +8,6 @@
     }
   ],
   "edge_stack": null,
-  "edge_stack_status": null,
   "edgegroups": null,
   "edgejobs": null,
   "endpoint_groups": [
@@ -121,10 +120,6 @@
       "Ecr": {
         "Region": ""
       },
-      "Github": {
-        "OrganisationName": "",
-        "UseOrganisation": false
-      },
       "Gitlab": {
         "InstanceURL": "",
         "ProjectId": 0,
@@ -615,7 +610,7 @@
       "RequiredPasswordLength": 12
     },
     "KubeconfigExpiry": "0",
-    "KubectlShellImage": "portainer/kubectl-shell:2.33.2",
+    "KubectlShellImage": "portainer/kubectl-shell:2.24.0",
     "LDAPSettings": {
       "AnonymousMode": true,
       "AutoCreateUsers": true,
@@ -677,17 +672,19 @@
     {
       "Docker": {
         "ContainerCount": 0,
-        "DiagnosticsData": {},
         "DockerSnapshotRaw": {
           "Containers": null,
           "Images": null,
           "Info": {
             "Architecture": "",
+            "BridgeNfIp6tables": false,
+            "BridgeNfIptables": false,
             "CDISpecDirs": null,
             "CPUSet": false,
             "CPUShares": false,
             "CgroupDriver": "",
             "ContainerdCommit": {
+              "Expected": "",
               "ID": ""
             },
             "Containers": 0,
@@ -711,6 +708,7 @@
             "IndexServerAddress": "",
             "InitBinary": "",
             "InitCommit": {
+              "Expected": "",
               "ID": ""
             },
             "Isolation": "",
@@ -739,6 +737,7 @@
             },
             "RegistryConfig": null,
             "RuncCommit": {
+              "Expected": "",
               "ID": ""
             },
             "Runtimes": null,
@@ -780,7 +779,6 @@
         "ImageCount": 9,
         "IsPodman": false,
         "NodeCount": 0,
-        "PerformanceMetrics": null,
         "RunningContainerCount": 5,
         "ServiceCount": 0,
         "StackCount": 2,
@@ -944,7 +942,7 @@
     }
   ],
   "version": {
-    "VERSION": "{\"SchemaVersion\":\"2.33.2\",\"MigratorCount\":0,\"Edition\":1,\"InstanceID\":\"463d5c47-0ea5-4aca-85b1-405ceefee254\"}"
+    "VERSION": "{\"SchemaVersion\":\"2.24.0\",\"MigratorCount\":0,\"Edition\":1,\"InstanceID\":\"463d5c47-0ea5-4aca-85b1-405ceefee254\"}"
   },
   "webhooks": null
 }

api/datastore/teststore.go

@@ -29,10 +29,6 @@ func MustNewTestStore(t testing.TB, init, secure bool) (bool, *Store) {
 func NewTestStore(t testing.TB, init, secure bool) (bool, *Store, func(), error) {
 	// Creates unique temp directory in a concurrency friendly manner.
 	storePath := t.TempDir()
-	defaultKubectlShellImage := portainer.DefaultKubectlShellImage
-	flags := &portainer.CLIFlags{
-		KubectlShellImage: &defaultKubectlShellImage,
-	}
 
 	fileService, err := filesystem.NewService(storePath, "")
 	if err != nil {
@@ -44,12 +40,12 @@ func NewTestStore(t testing.TB, init, secure bool) (bool, *Store, func(), error)
 		secretKey = nil
 	}
 
-	connection, err := database.NewDatabase("boltdb", storePath, secretKey, false)
+	connection, err := database.NewDatabase("boltdb", storePath, secretKey)
 	if err != nil {
 		panic(err)
 	}
 
-	store := NewStore(flags, fileService, connection)
+	store := NewStore(storePath, fileService, connection)
 	newStore, err := store.Open()
 	if err != nil {
 		return newStore, nil, nil, err

api/datastore/validate/validate.go

@@ -0,0 +1,15 @@
+package validate
+
+import (
+	"github.com/go-playground/validator/v10"
+	portainer "github.com/portainer/portainer/api"
+)
+
+var validate *validator.Validate
+
+func ValidateLDAPSettings(ldp *portainer.LDAPSettings) error {
+	validate = validator.New()
+	registerValidationMethods(validate)
+
+	return validate.Struct(ldp)
+}

api/datastore/validate/validate_test.go

@@ -0,0 +1,61 @@
+package validate
+
+import (
+	"testing"
+
+	portainer "github.com/portainer/portainer/api"
+)
+
+func TestValidateLDAPSettings(t *testing.T) {
+
+	tests := []struct {
+		name    string
+		ldap    portainer.LDAPSettings
+		wantErr bool
+	}{
+		{
+			name:    "Empty LDAP Settings",
+			ldap:    portainer.LDAPSettings{},
+			wantErr: true,
+		},
+		{
+			name: "With URL",
+			ldap: portainer.LDAPSettings{
+				AnonymousMode: true,
+				URL:           "192.168.0.1:323",
+			},
+			wantErr: false,
+		},
+		{
+			name: "Validate URL and URLs",
+			ldap: portainer.LDAPSettings{
+				AnonymousMode: true,
+				URL:           "192.168.0.1:323",
+			},
+			wantErr: false,
+		},
+		{
+			name: "validate client ldap",
+			ldap: portainer.LDAPSettings{
+				AnonymousMode: false,
+				ReaderDN:      "CN=LDAP API Service Account",
+				Password:      "Qu**dfUUU**",
+				URL:           "aukdc15.pgc.co:389",
+				TLSConfig: portainer.TLSConfiguration{
+					TLS:           false,
+					TLSSkipVerify: false,
+				},
+			},
+			wantErr: false,
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			err := ValidateLDAPSettings(&tt.ldap)
+			if (err == nil) == tt.wantErr {
+				t.Errorf("No error expected but got %s", err)
+			}
+		})
+	}
+}

api/datastore/validate/validationMethods.go

@@ -0,0 +1,17 @@
+package validate
+
+import (
+	"github.com/go-playground/validator/v10"
+)
+
+func registerValidationMethods(v *validator.Validate) {
+	v.RegisterValidation("validate_bool", ValidateBool)
+}
+
+/**
+ * Validation methods below are being used for custom validation
+ */
+func ValidateBool(fl validator.FieldLevel) bool {
+	_, ok := fl.Field().Interface().(bool)
+	return ok
+}

api/docker/client/client.go

@@ -3,8 +3,8 @@ package client
 import (
 	"bytes"
 	"errors"
-	"fmt"
 	"io"
+	"maps"
 	"net/http"
 	"strings"
 	"time"
@@ -24,8 +24,6 @@ const (
 	dockerClientVersion         = "1.37"
 )
 
-type NodeNamesCtxKey struct{}
-
 // ClientFactory is used to create Docker clients
 type ClientFactory struct {
 	signatureService     portainer.DigitalSignatureService
@@ -75,6 +73,19 @@ func createLocalClient(endpoint *portainer.Endpoint) (*client.Client, error) {
 	)
 }
 
+func CreateClientFromEnv() (*client.Client, error) {
+	return client.NewClientWithOpts(
+		client.FromEnv,
+		client.WithAPIVersionNegotiation(),
+	)
+}
+
+func CreateSimpleClient() (*client.Client, error) {
+	return client.NewClientWithOpts(
+		client.WithAPIVersionNegotiation(),
+	)
+}
+
 func createTCPClient(endpoint *portainer.Endpoint, timeout *time.Duration) (*client.Client, error) {
 	httpCli, err := httpClient(endpoint, timeout)
 	if err != nil {
@@ -130,6 +141,7 @@ func createAgentClient(endpoint *portainer.Endpoint, endpointURL string, signatu
 
 type NodeNameTransport struct {
 	*http.Transport
+	nodeNames map[string]string
 }
 
 func (t *NodeNameTransport) RoundTrip(req *http.Request) (*http.Response, error) {
@@ -164,30 +176,28 @@ func (t *NodeNameTransport) RoundTrip(req *http.Request) (*http.Response, error)
 		return resp, nil
 	}
 
-	nodeNames, ok := req.Context().Value(NodeNamesCtxKey{}).(map[string]string)
-	if ok {
-		for idx, r := range rs {
-			// as there is no way to differentiate the same image available in multiple nodes only by their ID
-			// we append the index of the image in the payload response to match the node name later
-			// from the image.Summary[] list returned by docker's client.ImageList()
-			nodeNames[fmt.Sprintf("%s-%d", r.ID, idx)] = r.Portainer.Agent.NodeName
-		}
+	t.nodeNames = make(map[string]string)
+	for _, r := range rs {
+		t.nodeNames[r.ID] = r.Portainer.Agent.NodeName
 	}
 
 	return resp, err
 }
 
+func (t *NodeNameTransport) NodeNames() map[string]string {
+	return maps.Clone(t.nodeNames)
+}
+
 func httpClient(endpoint *portainer.Endpoint, timeout *time.Duration) (*http.Client, error) {
 	transport := &NodeNameTransport{
 		Transport: &http.Transport{},
 	}
 
 	if endpoint.TLSConfig.TLS {
-		tlsConfig, err := crypto.CreateTLSConfigurationFromDisk(endpoint.TLSConfig)
+		tlsConfig, err := crypto.CreateTLSConfigurationFromDisk(endpoint.TLSConfig.TLSCACertPath, endpoint.TLSConfig.TLSCertPath, endpoint.TLSConfig.TLSKeyPath, endpoint.TLSConfig.TLSSkipVerify)
 		if err != nil {
 			return nil, err
 		}
-
 		transport.TLSClientConfig = tlsConfig
 	}
 

api/docker/client/client_test.go

@@ -1,30 +0,0 @@
-package client
-
-import (
-	"testing"
-
-	portainer "github.com/portainer/portainer/api"
-	"github.com/portainer/portainer/pkg/fips"
-
-	"github.com/stretchr/testify/require"
-)
-
-func TestHttpClient(t *testing.T) {
-	fips.InitFIPS(false)
-
-	// Valid TLS configuration
-	endpoint := &portainer.Endpoint{}
-	endpoint.TLSConfig = portainer.TLSConfiguration{TLS: true}
-
-	cli, err := httpClient(endpoint, nil)
-	require.NoError(t, err)
-	require.NotNil(t, cli)
-
-	// Invalid TLS configuration
-	endpoint.TLSConfig.TLSCertPath = "/invalid/path/client.crt"
-	endpoint.TLSConfig.TLSKeyPath = "/invalid/path/client.key"
-
-	cli, err = httpClient(endpoint, nil)
-	require.Error(t, err)
-	require.Nil(t, cli)
-}

api/docker/images/digest.go

@@ -9,7 +9,7 @@ import (
 
 	"github.com/containers/image/v5/docker"
 	imagetypes "github.com/containers/image/v5/types"
-	"github.com/docker/docker/api/types/image"
+	"github.com/docker/docker/api/types"
 	"github.com/opencontainers/go-digest"
 	"github.com/pkg/errors"
 	"github.com/rs/zerolog/log"
@@ -38,10 +38,10 @@ func NewClientWithRegistry(registryClient *RegistryClient, clientFactory *docker
 func (c *DigestClient) RemoteDigest(image Image) (digest.Digest, error) {
 	ctx, cancel := c.timeoutContext()
 	defer cancel()
-
 	// Docker references with both a tag and digest are currently not supported
 	if image.Tag != "" && image.Digest != "" {
-		if err := image.TrimDigest(); err != nil {
+		err := image.trimDigest()
+		if err != nil {
 			return "", err
 		}
 	}
@@ -69,7 +69,7 @@ func (c *DigestClient) RemoteDigest(image Image) (digest.Digest, error) {
 	// Retrieve remote digest through HEAD request
 	rmDigest, err := docker.GetDigest(ctx, sysCtx, rmRef)
 	if err != nil {
-		// Fallback to public registry for hub
+		// fallback to public registry for hub
 		if image.HubLink != "" {
 			rmDigest, err = docker.GetDigest(ctx, c.sysCtx, rmRef)
 			if err == nil {
@@ -85,7 +85,7 @@ func (c *DigestClient) RemoteDigest(image Image) (digest.Digest, error) {
 	return rmDigest, nil
 }
 
-func ParseLocalImage(inspect image.InspectResponse) (*Image, error) {
+func ParseLocalImage(inspect types.ImageInspect) (*Image, error) {
 	if IsLocalImage(inspect) || IsDanglingImage(inspect) {
 		return nil, errors.New("the image is not regular")
 	}
@@ -131,7 +131,8 @@ func ParseRepoDigests(repoDigests []string) []digest.Digest {
 func ParseRepoTags(repoTags []string) []*Image {
 	images := make([]*Image, 0)
 	for _, repoTag := range repoTags {
-		if image := ParseRepoTag(repoTag); image != nil {
+		image := ParseRepoTag(repoTag)
+		if image != nil {
 			images = append(images, image)
 		}
 	}
@@ -146,7 +147,7 @@ func ParseRepoDigest(repoDigest string) digest.Digest {
 
 	d, err := digest.Parse(strings.Split(repoDigest, "@")[1])
 	if err != nil {
-		log.Warn().Err(err).Str("digest", repoDigest).Msg("skip invalid repo item")
+		log.Warn().Msgf("Skip invalid repo digest item: %s [error: %v]", repoDigest, err)
 
 		return ""
 	}

api/docker/images/digest_test.go

@@ -1,33 +0,0 @@
-package images
-
-import (
-	"testing"
-
-	"github.com/docker/docker/api/types/image"
-	"github.com/stretchr/testify/require"
-)
-
-func TestParseLocalImage(t *testing.T) {
-	// Test with a regular image
-
-	img, err := ParseLocalImage(image.InspectResponse{
-		ID:          "sha256:9234e8fb04c47cfe0f49931e4ac7eb76fa904e33b7f8576aec0501c085f02516",
-		RepoTags:    []string{"myimage:latest"},
-		RepoDigests: []string{"myimage@sha256:4bcff63911fcb4448bd4fdacec207030997caf25e9bea4045fa6c8c44de311d1"},
-	})
-	require.NoError(t, err)
-	require.NotNil(t, img)
-	require.Equal(t, "library/myimage", img.Path)
-	require.Equal(t, "latest", img.Tag)
-	require.Equal(t, "sha256:4bcff63911fcb4448bd4fdacec207030997caf25e9bea4045fa6c8c44de311d1", img.Digest.String())
-
-	// Test with a dangling image
-
-	img, err = ParseLocalImage(image.InspectResponse{
-		ID:          "sha256:abcdef1234567890",
-		RepoTags:    []string{"<none>:<none>"},
-		RepoDigests: []string{"<none>@<none>"},
-	})
-	require.Error(t, err)
-	require.Nil(t, img)
-}

api/docker/images/image.go

@@ -7,9 +7,9 @@ import (
 	"strings"
 	"text/template"
 
-	"github.com/containers/image/v5/docker/reference"
 	"github.com/docker/docker/api/types"
-	"github.com/docker/docker/api/types/image"
+
+	"github.com/containers/image/v5/docker/reference"
 	"github.com/opencontainers/go-digest"
 	"github.com/pkg/errors"
 )
@@ -26,7 +26,7 @@ type Image struct {
 	Digest  digest.Digest
 	HubLink string
 	named   reference.Named
-	Opts    ParseImageOptions `json:"-"`
+	opts    ParseImageOptions
 }
 
 // ParseImageOptions holds image options for parsing.
@@ -43,10 +43,9 @@ func (i *Image) Name() string {
 // FullName return the real full name may include Tag or Digest of the image, Tag first.
 func (i *Image) FullName() string {
 	if i.Tag == "" {
-		return i.Name() + "@" + i.Digest.String()
+		return fmt.Sprintf("%s@%s", i.Name(), i.Digest)
 	}
-
-	return i.Name() + ":" + i.Tag
+	return fmt.Sprintf("%s:%s", i.Name(), i.Tag)
 }
 
 // String returns the string representation of an image, including Tag and Digest if existed.
@@ -67,25 +66,22 @@ func (i *Image) Reference() string {
 func (i *Image) WithDigest(digest digest.Digest) (err error) {
 	i.Digest = digest
 	i.named, err = reference.WithDigest(i.named, digest)
-
 	return err
 }
 
 func (i *Image) WithTag(tag string) (err error) {
 	i.Tag = tag
 	i.named, err = reference.WithTag(i.named, tag)
-
 	return err
 }
 
-func (i *Image) TrimDigest() error {
+func (i *Image) trimDigest() error {
 	i.Digest = ""
 	named, err := ParseImage(ParseImageOptions{Name: i.FullName()})
 	if err != nil {
 		return err
 	}
 	i.named = &named
-
 	return nil
 }
 
@@ -96,12 +92,11 @@ func ParseImage(parseOpts ParseImageOptions) (Image, error) {
 	if err != nil {
 		return Image{}, errors.Wrapf(err, "parsing image %s failed", parseOpts.Name)
 	}
-
 	// Add the latest lag if they did not provide one.
 	named = reference.TagNameOnly(named)
 
 	i := Image{
-		Opts:   parseOpts,
+		opts:   parseOpts,
 		named:  named,
 		Domain: reference.Domain(named),
 		Path:   reference.Path(named),
@@ -127,16 +122,15 @@ func ParseImage(parseOpts ParseImageOptions) (Image, error) {
 }
 
 func (i *Image) hubLink() (string, error) {
-	if i.Opts.HubTpl != "" {
+	if i.opts.HubTpl != "" {
 		var out bytes.Buffer
 		tmpl, err := template.New("tmpl").
 			Option("missingkey=error").
-			Parse(i.Opts.HubTpl)
+			Parse(i.opts.HubTpl)
 		if err != nil {
 			return "", err
 		}
 		err = tmpl.Execute(&out, i)
-
 		return out.String(), err
 	}
 
@@ -148,7 +142,6 @@ func (i *Image) hubLink() (string, error) {
 			prefix = "_"
 			path = strings.Replace(i.Path, "library/", "", 1)
 		}
-
 		return "https://hub.docker.com/" + prefix + "/" + path, nil
 	case "docker.bintray.io", "jfrog-docker-reg2.bintray.io":
 		return "https://bintray.com/jfrog/reg2/" + strings.ReplaceAll(i.Path, "/", "%3A"), nil
@@ -179,11 +172,11 @@ func IsLocalImage(image types.ImageInspect) bool {
 // IsDanglingImage returns whether the given image is "dangling" which means
 // that there are no repository references to the given image and it has no
 // child images
-func IsDanglingImage(image image.InspectResponse) bool {
+func IsDanglingImage(image types.ImageInspect) bool {
 	return len(image.RepoTags) == 1 && image.RepoTags[0] == "<none>:<none>" && len(image.RepoDigests) == 1 && image.RepoDigests[0] == "<none>@<none>"
 }
 
 // IsNoTagImage returns whether the given image is damaged, has no tags
-func IsNoTagImage(image image.InspectResponse) bool {
+func IsNoTagImage(image types.ImageInspect) bool {
 	return len(image.RepoTags) == 0
 }

api/docker/images/image_test.go

@@ -16,7 +16,7 @@ func TestImageParser(t *testing.T) {
 		})
 		is.NoError(err, "")
 		is.Equal("docker.io/portainer/portainer-ee:latest", image.FullName())
-		is.Equal("portainer/portainer-ee", image.Opts.Name)
+		is.Equal("portainer/portainer-ee", image.opts.Name)
 		is.Equal("latest", image.Tag)
 		is.Equal("portainer/portainer-ee", image.Path)
 		is.Equal("docker.io", image.Domain)
@@ -32,7 +32,7 @@ func TestImageParser(t *testing.T) {
 		})
 		is.NoError(err, "")
 		is.Equal("gcr.io/k8s-minikube/kicbase@sha256:02c921df998f95e849058af14de7045efc3954d90320967418a0d1f182bbc0b2", image.FullName())
-		is.Equal("gcr.io/k8s-minikube/kicbase@sha256:02c921df998f95e849058af14de7045efc3954d90320967418a0d1f182bbc0b2", image.Opts.Name)
+		is.Equal("gcr.io/k8s-minikube/kicbase@sha256:02c921df998f95e849058af14de7045efc3954d90320967418a0d1f182bbc0b2", image.opts.Name)
 		is.Equal("", image.Tag)
 		is.Equal("k8s-minikube/kicbase", image.Path)
 		is.Equal("gcr.io", image.Domain)
@@ -49,7 +49,7 @@ func TestImageParser(t *testing.T) {
 		})
 		is.NoError(err, "")
 		is.Equal("gcr.io/k8s-minikube/kicbase:v0.0.30", image.FullName())
-		is.Equal("gcr.io/k8s-minikube/kicbase:v0.0.30@sha256:02c921df998f95e849058af14de7045efc3954d90320967418a0d1f182bbc0b2", image.Opts.Name)
+		is.Equal("gcr.io/k8s-minikube/kicbase:v0.0.30@sha256:02c921df998f95e849058af14de7045efc3954d90320967418a0d1f182bbc0b2", image.opts.Name)
 		is.Equal("v0.0.30", image.Tag)
 		is.Equal("k8s-minikube/kicbase", image.Path)
 		is.Equal("gcr.io", image.Domain)
@@ -71,7 +71,7 @@ func TestUpdateParsedImage(t *testing.T) {
 		is.NoError(err, "")
 		_ = image.WithTag("v0.0.31")
 		is.Equal("gcr.io/k8s-minikube/kicbase:v0.0.31", image.FullName())
-		is.Equal("gcr.io/k8s-minikube/kicbase:v0.0.30@sha256:02c921df998f95e849058af14de7045efc3954d90320967418a0d1f182bbc0b2", image.Opts.Name)
+		is.Equal("gcr.io/k8s-minikube/kicbase:v0.0.30@sha256:02c921df998f95e849058af14de7045efc3954d90320967418a0d1f182bbc0b2", image.opts.Name)
 		is.Equal("v0.0.31", image.Tag)
 		is.Equal("k8s-minikube/kicbase", image.Path)
 		is.Equal("gcr.io", image.Domain)
@@ -89,7 +89,7 @@ func TestUpdateParsedImage(t *testing.T) {
 		is.NoError(err, "")
 		_ = image.WithDigest("sha256:02c921df998f95e849058af14de7045efc3954d90320967418a0d1f182bbc0b3")
 		is.Equal("gcr.io/k8s-minikube/kicbase:v0.0.30", image.FullName())
-		is.Equal("gcr.io/k8s-minikube/kicbase:v0.0.30@sha256:02c921df998f95e849058af14de7045efc3954d90320967418a0d1f182bbc0b2", image.Opts.Name)
+		is.Equal("gcr.io/k8s-minikube/kicbase:v0.0.30@sha256:02c921df998f95e849058af14de7045efc3954d90320967418a0d1f182bbc0b2", image.opts.Name)
 		is.Equal("v0.0.30", image.Tag)
 		is.Equal("k8s-minikube/kicbase", image.Path)
 		is.Equal("gcr.io", image.Domain)
@@ -105,9 +105,9 @@ func TestUpdateParsedImage(t *testing.T) {
 			Name: "gcr.io/k8s-minikube/kicbase:v0.0.30@sha256:02c921df998f95e849058af14de7045efc3954d90320967418a0d1f182bbc0b2",
 		})
 		is.NoError(err, "")
-		_ = image.TrimDigest()
+		_ = image.trimDigest()
 		is.Equal("gcr.io/k8s-minikube/kicbase:v0.0.30", image.FullName())
-		is.Equal("gcr.io/k8s-minikube/kicbase:v0.0.30@sha256:02c921df998f95e849058af14de7045efc3954d90320967418a0d1f182bbc0b2", image.Opts.Name)
+		is.Equal("gcr.io/k8s-minikube/kicbase:v0.0.30@sha256:02c921df998f95e849058af14de7045efc3954d90320967418a0d1f182bbc0b2", image.opts.Name)
 		is.Equal("v0.0.30", image.Tag)
 		is.Equal("k8s-minikube/kicbase", image.Path)
 		is.Equal("gcr.io", image.Domain)

api/docker/images/puller.go

@@ -6,7 +6,7 @@ import (
 
 	"github.com/portainer/portainer/api/dataservices"
 
-	"github.com/docker/docker/api/types/image"
+	"github.com/docker/docker/api/types"
 	"github.com/docker/docker/client"
 	"github.com/rs/zerolog/log"
 )
@@ -25,18 +25,18 @@ func NewPuller(client *client.Client, registryClient *RegistryClient, dataStore
 	}
 }
 
-func (puller *Puller) Pull(ctx context.Context, img Image) error {
-	log.Debug().Str("image", img.FullName()).Msg("starting to pull the image")
+func (puller *Puller) Pull(ctx context.Context, image Image) error {
+	log.Debug().Str("image", image.FullName()).Msg("starting to pull the image")
 
-	registryAuth, err := puller.registryClient.EncodedRegistryAuth(img)
+	registryAuth, err := puller.registryClient.EncodedRegistryAuth(image)
 	if err != nil {
 		log.Debug().
-			Str("image", img.FullName()).
+			Str("image", image.FullName()).
 			Err(err).
 			Msg("failed to get an encoded registry auth via image, try to pull image without registry auth")
 	}
 
-	out, err := puller.client.ImagePull(ctx, img.FullName(), image.PullOptions{
+	out, err := puller.client.ImagePull(ctx, image.FullName(), types.ImagePullOptions{
 		RegistryAuth: registryAuth,
 	})
 	if err != nil {

api/docker/images/registry.go

@@ -29,7 +29,7 @@ func (c *RegistryClient) RegistryAuth(image Image) (string, string, error) {
 		return "", "", err
 	}
 
-	registry, err := findBestMatchRegistry(image.Opts.Name, registries)
+	registry, err := findBestMatchRegistry(image.opts.Name, registries)
 	if err != nil {
 		return "", "", err
 	}
@@ -59,7 +59,7 @@ func (c *RegistryClient) EncodedRegistryAuth(image Image) (string, error) {
 		return "", err
 	}
 
-	registry, err := findBestMatchRegistry(image.Opts.Name, registries)
+	registry, err := findBestMatchRegistry(image.opts.Name, registries)
 	if err != nil {
 		return "", err
 	}

api/docker/snapshot.go

@@ -1,9 +1,20 @@
 package docker
 
 import (
+	"context"
+	"strings"
+	"time"
+
 	portainer "github.com/portainer/portainer/api"
 	dockerclient "github.com/portainer/portainer/api/docker/client"
-	"github.com/portainer/portainer/pkg/snapshot"
+	"github.com/portainer/portainer/api/docker/consts"
+
+	"github.com/docker/docker/api/types"
+	"github.com/docker/docker/api/types/container"
+	_container "github.com/docker/docker/api/types/container"
+	"github.com/docker/docker/api/types/volume"
+	"github.com/docker/docker/client"
+	"github.com/rs/zerolog/log"
 )
 
 // Snapshotter represents a service used to create environment(endpoint) snapshots
@@ -26,5 +37,247 @@ func (snapshotter *Snapshotter) CreateSnapshot(endpoint *portainer.Endpoint) (*p
 	}
 	defer cli.Close()
 
-	return snapshot.CreateDockerSnapshot(cli)
+	return snapshot(cli, endpoint)
+}
+
+func snapshot(cli *client.Client, endpoint *portainer.Endpoint) (*portainer.DockerSnapshot, error) {
+	if _, err := cli.Ping(context.Background()); err != nil {
+		return nil, err
+	}
+
+	snapshot := &portainer.DockerSnapshot{
+		StackCount: 0,
+	}
+
+	if err := snapshotInfo(snapshot, cli); err != nil {
+		log.Warn().Str("environment", endpoint.Name).Err(err).Msg("unable to snapshot engine information")
+	}
+
+	if snapshot.Swarm {
+		if err := snapshotSwarmServices(snapshot, cli); err != nil {
+			log.Warn().Str("environment", endpoint.Name).Err(err).Msg("unable to snapshot Swarm services")
+		}
+
+		if err := snapshotNodes(snapshot, cli); err != nil {
+			log.Warn().Str("environment", endpoint.Name).Err(err).Msg("unable to snapshot Swarm nodes")
+		}
+	}
+
+	if err := snapshotContainers(snapshot, cli); err != nil {
+		log.Warn().Str("environment", endpoint.Name).Err(err).Msg("unable to snapshot containers")
+	}
+
+	if err := snapshotImages(snapshot, cli); err != nil {
+		log.Warn().Str("environment", endpoint.Name).Err(err).Msg("unable to snapshot images")
+	}
+
+	if err := snapshotVolumes(snapshot, cli); err != nil {
+		log.Warn().Str("environment", endpoint.Name).Err(err).Msg("unable to snapshot volumes")
+	}
+
+	if err := snapshotNetworks(snapshot, cli); err != nil {
+		log.Warn().Str("environment", endpoint.Name).Err(err).Msg("unable to snapshot networks")
+	}
+
+	if err := snapshotVersion(snapshot, cli); err != nil {
+		log.Warn().Str("environment", endpoint.Name).Err(err).Msg("unable to snapshot engine version")
+	}
+
+	snapshot.Time = time.Now().Unix()
+
+	return snapshot, nil
+}
+
+func snapshotInfo(snapshot *portainer.DockerSnapshot, cli *client.Client) error {
+	info, err := cli.Info(context.Background())
+	if err != nil {
+		return err
+	}
+
+	snapshot.Swarm = info.Swarm.ControlAvailable
+	snapshot.DockerVersion = info.ServerVersion
+	snapshot.TotalCPU = info.NCPU
+	snapshot.TotalMemory = info.MemTotal
+	snapshot.SnapshotRaw.Info = info
+
+	return nil
+}
+
+func snapshotNodes(snapshot *portainer.DockerSnapshot, cli *client.Client) error {
+	nodes, err := cli.NodeList(context.Background(), types.NodeListOptions{})
+	if err != nil {
+		return err
+	}
+
+	var nanoCpus int64
+	var totalMem int64
+
+	for _, node := range nodes {
+		nanoCpus += node.Description.Resources.NanoCPUs
+		totalMem += node.Description.Resources.MemoryBytes
+	}
+
+	snapshot.TotalCPU = int(nanoCpus / 1e9)
+	snapshot.TotalMemory = totalMem
+	snapshot.NodeCount = len(nodes)
+
+	return nil
+}
+
+func snapshotSwarmServices(snapshot *portainer.DockerSnapshot, cli *client.Client) error {
+	stacks := make(map[string]struct{})
+
+	services, err := cli.ServiceList(context.Background(), types.ServiceListOptions{})
+	if err != nil {
+		return err
+	}
+
+	for _, service := range services {
+		for k, v := range service.Spec.Labels {
+			if k == "com.docker.stack.namespace" {
+				stacks[v] = struct{}{}
+			}
+		}
+	}
+
+	snapshot.ServiceCount = len(services)
+	snapshot.StackCount += len(stacks)
+
+	return nil
+}
+
+func snapshotContainers(snapshot *portainer.DockerSnapshot, cli *client.Client) error {
+	containers, err := cli.ContainerList(context.Background(), container.ListOptions{All: true})
+	if err != nil {
+		return err
+	}
+
+	stacks := make(map[string]struct{})
+	gpuUseSet := make(map[string]struct{})
+	gpuUseAll := false
+
+	for _, container := range containers {
+		if container.State == "running" {
+			// Snapshot GPUs
+			response, err := cli.ContainerInspect(context.Background(), container.ID)
+			if err != nil {
+				// Inspect a container will fail when the container runs on a different
+				// Swarm node, so it is better to log the error instead of return error
+				// when the Swarm mode is enabled
+				if !snapshot.Swarm {
+					return err
+				} else {
+					if !strings.Contains(err.Error(), "No such container") {
+						return err
+					}
+					// It is common to have containers running on different Swarm nodes,
+					// so we just log the error in the debug level
+					log.Debug().Str("container", container.ID).Err(err).Msg("unable to inspect container in other Swarm nodes")
+				}
+			} else {
+				var gpuOptions *_container.DeviceRequest = nil
+				for _, deviceRequest := range response.HostConfig.Resources.DeviceRequests {
+					if deviceRequest.Driver == "nvidia" || deviceRequest.Capabilities[0][0] == "gpu" {
+						gpuOptions = &deviceRequest
+					}
+				}
+
+				if gpuOptions != nil {
+					if gpuOptions.Count == -1 {
+						gpuUseAll = true
+					}
+
+					for _, id := range gpuOptions.DeviceIDs {
+						gpuUseSet[id] = struct{}{}
+					}
+				}
+			}
+		}
+
+		for k, v := range container.Labels {
+			if k == consts.ComposeStackNameLabel {
+				stacks[v] = struct{}{}
+			}
+		}
+	}
+
+	gpuUseList := make([]string, 0, len(gpuUseSet))
+	for gpuUse := range gpuUseSet {
+		gpuUseList = append(gpuUseList, gpuUse)
+	}
+
+	snapshot.GpuUseAll = gpuUseAll
+	snapshot.GpuUseList = gpuUseList
+
+	stats := CalculateContainerStats(containers)
+
+	snapshot.ContainerCount = stats.Total
+	snapshot.RunningContainerCount = stats.Running
+	snapshot.StoppedContainerCount = stats.Stopped
+	snapshot.HealthyContainerCount = stats.Healthy
+	snapshot.UnhealthyContainerCount = stats.Unhealthy
+	snapshot.StackCount += len(stacks)
+
+	for _, container := range containers {
+		snapshot.SnapshotRaw.Containers = append(snapshot.SnapshotRaw.Containers, portainer.DockerContainerSnapshot{Container: container})
+	}
+
+	return nil
+}
+
+func snapshotImages(snapshot *portainer.DockerSnapshot, cli *client.Client) error {
+	images, err := cli.ImageList(context.Background(), types.ImageListOptions{})
+	if err != nil {
+		return err
+	}
+
+	snapshot.ImageCount = len(images)
+	snapshot.SnapshotRaw.Images = images
+
+	return nil
+}
+
+func snapshotVolumes(snapshot *portainer.DockerSnapshot, cli *client.Client) error {
+	volumes, err := cli.VolumeList(context.Background(), volume.ListOptions{})
+	if err != nil {
+		return err
+	}
+
+	snapshot.VolumeCount = len(volumes.Volumes)
+	snapshot.SnapshotRaw.Volumes = volumes
+
+	return nil
+}
+
+func snapshotNetworks(snapshot *portainer.DockerSnapshot, cli *client.Client) error {
+	networks, err := cli.NetworkList(context.Background(), types.NetworkListOptions{})
+	if err != nil {
+		return err
+	}
+
+	snapshot.SnapshotRaw.Networks = networks
+
+	return nil
+}
+
+func snapshotVersion(snapshot *portainer.DockerSnapshot, cli *client.Client) error {
+	version, err := cli.ServerVersion(context.Background())
+	if err != nil {
+		return err
+	}
+
+	snapshot.SnapshotRaw.Version = version
+	snapshot.IsPodman = isPodman(version)
+	return nil
+}
+
+// isPodman checks if the version is for Podman by checking if any of the components contain "podman".
+// If it's podman, a component name should be "Podman Engine"
+func isPodman(version types.Version) bool {
+	for _, component := range version.Components {
+		if strings.Contains(strings.ToLower(component.Name), "podman") {
+			return true
+		}
+	}
+	return false
 }

api/edge/edge.go

@@ -49,11 +49,6 @@ type (
 
 		// Is relative path supported
 		SupportRelativePath bool
-		// AlwaysCloneGitRepoForRelativePath is a flag indicating if the agent must always clone the git repository for relative path.
-		// This field is only valid when SupportRelativePath is true.
-		// Used only for EE
-		AlwaysCloneGitRepoForRelativePath bool
-
 		// Mount point for relative path
 		FilesystemPath string
 		// Used only for EE
@@ -63,20 +58,6 @@ type (
 		// Used only for EE async edge agent
 		// ReadyRePullImage is a flag to indicate whether the auto update is trigger to re-pull image
 		ReadyRePullImage bool
-
-		DeployerOptionsPayload DeployerOptionsPayload
-	}
-
-	DeployerOptionsPayload struct {
-		// Prune is a flag indicating if the agent must prune the containers or not when creating/updating an edge stack
-		// This flag drives `docker compose up --remove-orphans` and `docker stack up --prune` options
-		// Used only for EE
-		Prune bool
-		// RemoveVolumes is a flag indicating if the agent must remove the named volumes declared
-		// in the compose file and anonymouse volumes attached to containers
-		// This flag drives `docker compose down --volumes` option
-		// Used only for EE
-		RemoveVolumes bool
 	}
 
 	// RegistryCredentials holds the credentials for a Docker registry.

api/exec/exectest/kubernetes_mocks.go

@@ -4,12 +4,10 @@ import (
 	portainer "github.com/portainer/portainer/api"
 )
 
-type kubernetesMockDeployer struct {
-	portainer.KubernetesDeployer
-}
+type kubernetesMockDeployer struct{}
 
 // NewKubernetesDeployer creates a mock kubernetes deployer
-func NewKubernetesDeployer() *kubernetesMockDeployer {
+func NewKubernetesDeployer() portainer.KubernetesDeployer {
 	return &kubernetesMockDeployer{}
 }
 
@@ -20,7 +18,3 @@ func (deployer *kubernetesMockDeployer) Deploy(userID portainer.UserID, endpoint
 func (deployer *kubernetesMockDeployer) Remove(userID portainer.UserID, endpoint *portainer.Endpoint, manifestFiles []string, namespace string) (string, error) {
 	return "", nil
 }
-
-func (deployer *kubernetesMockDeployer) Restart(userID portainer.UserID, endpoint *portainer.Endpoint, manifestFiles []string, namespace string) (string, error) {
-	return "", nil
-}

api/exec/kubernetes_deploy.go

@@ -1,8 +1,13 @@
 package exec
 
 import (
-	"context"
+	"bytes"
 	"fmt"
+	"os"
+	"os/exec"
+	"path"
+	"runtime"
+	"strings"
 
 	portainer "github.com/portainer/portainer/api"
 	"github.com/portainer/portainer/api/dataservices"
@@ -10,17 +15,13 @@ import (
 	"github.com/portainer/portainer/api/http/proxy/factory"
 	"github.com/portainer/portainer/api/http/proxy/factory/kubernetes"
 	"github.com/portainer/portainer/api/kubernetes/cli"
-	"github.com/portainer/portainer/pkg/libkubectl"
 
 	"github.com/pkg/errors"
 )
 
-const (
-	defaultServerURL = "https://kubernetes.default.svc"
-)
-
 // KubernetesDeployer represents a service to deploy resources inside a Kubernetes environment(endpoint).
 type KubernetesDeployer struct {
+	binaryPath                  string
 	dataStore                   dataservices.DataStore
 	reverseTunnelService        portainer.ReverseTunnelService
 	signatureService            portainer.DigitalSignatureService
@@ -30,8 +31,9 @@ type KubernetesDeployer struct {
 }
 
 // NewKubernetesDeployer initializes a new KubernetesDeployer service.
-func NewKubernetesDeployer(kubernetesTokenCacheManager *kubernetes.TokenCacheManager, kubernetesClientFactory *cli.ClientFactory, datastore dataservices.DataStore, reverseTunnelService portainer.ReverseTunnelService, signatureService portainer.DigitalSignatureService, proxyManager *proxy.Manager) *KubernetesDeployer {
+func NewKubernetesDeployer(kubernetesTokenCacheManager *kubernetes.TokenCacheManager, kubernetesClientFactory *cli.ClientFactory, datastore dataservices.DataStore, reverseTunnelService portainer.ReverseTunnelService, signatureService portainer.DigitalSignatureService, proxyManager *proxy.Manager, binaryPath string) *KubernetesDeployer {
 	return &KubernetesDeployer{
+		binaryPath:                  binaryPath,
 		dataStore:                   datastore,
 		reverseTunnelService:        reverseTunnelService,
 		signatureService:            signatureService,
@@ -76,56 +78,63 @@ func (deployer *KubernetesDeployer) getToken(userID portainer.UserID, endpoint *
 }
 
 // Deploy upserts Kubernetes resources defined in manifest(s)
-func (deployer *KubernetesDeployer) Deploy(userID portainer.UserID, endpoint *portainer.Endpoint, resources []string, namespace string) (string, error) {
-	return deployer.command("apply", userID, endpoint, resources, namespace)
+func (deployer *KubernetesDeployer) Deploy(userID portainer.UserID, endpoint *portainer.Endpoint, manifestFiles []string, namespace string) (string, error) {
+	return deployer.command("apply", userID, endpoint, manifestFiles, namespace)
 }
 
 // Remove deletes Kubernetes resources defined in manifest(s)
-func (deployer *KubernetesDeployer) Remove(userID portainer.UserID, endpoint *portainer.Endpoint, resources []string, namespace string) (string, error) {
-	return deployer.command("delete", userID, endpoint, resources, namespace)
+func (deployer *KubernetesDeployer) Remove(userID portainer.UserID, endpoint *portainer.Endpoint, manifestFiles []string, namespace string) (string, error) {
+	return deployer.command("delete", userID, endpoint, manifestFiles, namespace)
 }
 
-func (deployer *KubernetesDeployer) command(operation string, userID portainer.UserID, endpoint *portainer.Endpoint, resources []string, namespace string) (string, error) {
+func (deployer *KubernetesDeployer) command(operation string, userID portainer.UserID, endpoint *portainer.Endpoint, manifestFiles []string, namespace string) (string, error) {
 	token, err := deployer.getToken(userID, endpoint, endpoint.Type == portainer.KubernetesLocalEnvironment)
 	if err != nil {
 		return "", errors.Wrap(err, "failed generating a user token")
 	}
 
-	serverURL := defaultServerURL
+	command := path.Join(deployer.binaryPath, "kubectl")
+	if runtime.GOOS == "windows" {
+		command = path.Join(deployer.binaryPath, "kubectl.exe")
+	}
+
+	args := []string{"--token", token}
+	if namespace != "" {
+		args = append(args, "--namespace", namespace)
+	}
+
 	if endpoint.Type == portainer.AgentOnKubernetesEnvironment || endpoint.Type == portainer.EdgeAgentOnKubernetesEnvironment {
 		url, proxy, err := deployer.getAgentURL(endpoint)
 		if err != nil {
 			return "", errors.WithMessage(err, "failed generating endpoint URL")
 		}
+
 		defer proxy.Close()
-
-		serverURL = url
+		args = append(args, "--server", url)
+		args = append(args, "--insecure-skip-tls-verify")
 	}
 
-	client, err := libkubectl.NewClient(&libkubectl.ClientAccess{
-		Token:     token,
-		ServerUrl: serverURL,
-	}, namespace, "", true)
+	if operation == "delete" {
+		args = append(args, "--ignore-not-found=true")
+	}
+
+	args = append(args, operation)
+	for _, path := range manifestFiles {
+		args = append(args, "-f", strings.TrimSpace(path))
+	}
+
+	var stderr bytes.Buffer
+	cmd := exec.Command(command, args...)
+	cmd.Env = os.Environ()
+	cmd.Env = append(cmd.Env, "POD_NAMESPACE=default")
+	cmd.Stderr = &stderr
+
+	output, err := cmd.Output()
 	if err != nil {
-		return "", errors.Wrap(err, "failed to create kubectl client")
+		return "", errors.Wrapf(err, "failed to execute kubectl command: %q", stderr.String())
 	}
 
-	operations := map[string]func(context.Context, []string) (string, error){
-		"apply":  client.Apply,
-		"delete": client.Delete,
-	}
-
-	operationFunc, ok := operations[operation]
-	if !ok {
-		return "", errors.Errorf("unsupported operation: %s", operation)
-	}
-
-	output, err := operationFunc(context.Background(), resources)
-	if err != nil {
-		return "", errors.Wrapf(err, "failed to execute kubectl %s command", operation)
-	}
-
-	return output, nil
+	return string(output), nil
 }
 
 func (deployer *KubernetesDeployer) getAgentURL(endpoint *portainer.Endpoint) (string, *factory.ProxyServer, error) {

api/exec/kubernetes_deploy_test.go

@@ -1,173 +0,0 @@
-package exec
-
-import (
-	"context"
-	"errors"
-	"fmt"
-	"testing"
-
-	"github.com/stretchr/testify/assert"
-)
-
-type mockKubectlClient struct {
-	applyFunc          func(ctx context.Context, files []string) error
-	deleteFunc         func(ctx context.Context, files []string) error
-	rolloutRestartFunc func(ctx context.Context, resources []string) error
-}
-
-func (m *mockKubectlClient) Apply(ctx context.Context, files []string) error {
-	if m.applyFunc != nil {
-		return m.applyFunc(ctx, files)
-	}
-	return nil
-}
-
-func (m *mockKubectlClient) Delete(ctx context.Context, files []string) error {
-	if m.deleteFunc != nil {
-		return m.deleteFunc(ctx, files)
-	}
-	return nil
-}
-
-func (m *mockKubectlClient) RolloutRestart(ctx context.Context, resources []string) error {
-	if m.rolloutRestartFunc != nil {
-		return m.rolloutRestartFunc(ctx, resources)
-	}
-	return nil
-}
-
-func testExecuteKubectlOperation(client *mockKubectlClient, operation string, manifestFiles []string) error {
-	operations := map[string]func(context.Context, []string) error{
-		"apply":           client.Apply,
-		"delete":          client.Delete,
-		"rollout-restart": client.RolloutRestart,
-	}
-
-	operationFunc, ok := operations[operation]
-	if !ok {
-		return fmt.Errorf("unsupported operation: %s", operation)
-	}
-
-	if err := operationFunc(context.Background(), manifestFiles); err != nil {
-		return fmt.Errorf("failed to execute kubectl %s command: %w", operation, err)
-	}
-
-	return nil
-}
-
-func TestExecuteKubectlOperation_Apply_Success(t *testing.T) {
-	called := false
-	mockClient := &mockKubectlClient{
-		applyFunc: func(ctx context.Context, files []string) error {
-			called = true
-			assert.Equal(t, []string{"manifest1.yaml", "manifest2.yaml"}, files)
-			return nil
-		},
-	}
-
-	manifests := []string{"manifest1.yaml", "manifest2.yaml"}
-	err := testExecuteKubectlOperation(mockClient, "apply", manifests)
-
-	assert.NoError(t, err)
-	assert.True(t, called)
-}
-
-func TestExecuteKubectlOperation_Apply_Error(t *testing.T) {
-	expectedErr := errors.New("kubectl apply failed")
-	called := false
-	mockClient := &mockKubectlClient{
-		applyFunc: func(ctx context.Context, files []string) error {
-			called = true
-			assert.Equal(t, []string{"error.yaml"}, files)
-			return expectedErr
-		},
-	}
-
-	manifests := []string{"error.yaml"}
-	err := testExecuteKubectlOperation(mockClient, "apply", manifests)
-
-	assert.Error(t, err)
-	assert.Contains(t, err.Error(), expectedErr.Error())
-	assert.True(t, called)
-}
-
-func TestExecuteKubectlOperation_Delete_Success(t *testing.T) {
-	called := false
-	mockClient := &mockKubectlClient{
-		deleteFunc: func(ctx context.Context, files []string) error {
-			called = true
-			assert.Equal(t, []string{"manifest1.yaml"}, files)
-			return nil
-		},
-	}
-
-	manifests := []string{"manifest1.yaml"}
-	err := testExecuteKubectlOperation(mockClient, "delete", manifests)
-
-	assert.NoError(t, err)
-	assert.True(t, called)
-}
-
-func TestExecuteKubectlOperation_Delete_Error(t *testing.T) {
-	expectedErr := errors.New("kubectl delete failed")
-	called := false
-	mockClient := &mockKubectlClient{
-		deleteFunc: func(ctx context.Context, files []string) error {
-			called = true
-			assert.Equal(t, []string{"error.yaml"}, files)
-			return expectedErr
-		},
-	}
-
-	manifests := []string{"error.yaml"}
-	err := testExecuteKubectlOperation(mockClient, "delete", manifests)
-
-	assert.Error(t, err)
-	assert.Contains(t, err.Error(), expectedErr.Error())
-	assert.True(t, called)
-}
-
-func TestExecuteKubectlOperation_RolloutRestart_Success(t *testing.T) {
-	called := false
-	mockClient := &mockKubectlClient{
-		rolloutRestartFunc: func(ctx context.Context, resources []string) error {
-			called = true
-			assert.Equal(t, []string{"deployment/nginx"}, resources)
-			return nil
-		},
-	}
-
-	resources := []string{"deployment/nginx"}
-	err := testExecuteKubectlOperation(mockClient, "rollout-restart", resources)
-
-	assert.NoError(t, err)
-	assert.True(t, called)
-}
-
-func TestExecuteKubectlOperation_RolloutRestart_Error(t *testing.T) {
-	expectedErr := errors.New("kubectl rollout restart failed")
-	called := false
-	mockClient := &mockKubectlClient{
-		rolloutRestartFunc: func(ctx context.Context, resources []string) error {
-			called = true
-			assert.Equal(t, []string{"deployment/error"}, resources)
-			return expectedErr
-		},
-	}
-
-	resources := []string{"deployment/error"}
-	err := testExecuteKubectlOperation(mockClient, "rollout-restart", resources)
-
-	assert.Error(t, err)
-	assert.Contains(t, err.Error(), expectedErr.Error())
-	assert.True(t, called)
-}
-
-func TestExecuteKubectlOperation_UnsupportedOperation(t *testing.T) {
-	mockClient := &mockKubectlClient{}
-
-	err := testExecuteKubectlOperation(mockClient, "unsupported", []string{})
-
-	assert.Error(t, err)
-	assert.Contains(t, err.Error(), "unsupported operation")
-}