WIP: settings models

api/backup/backup.go

@@ -1,110 +1,110 @@
 package backup
 
-import (
-	"fmt"
-	"os"
-	"path"
-	"path/filepath"
-	"time"
+// import (
+// 	"fmt"
+// 	"os"
+// 	"path"
+// 	"path/filepath"
+// 	"time"
 
-	"github.com/portainer/portainer/api/archive"
-	"github.com/portainer/portainer/api/crypto"
-	"github.com/portainer/portainer/api/dataservices"
-	"github.com/portainer/portainer/api/filesystem"
-	"github.com/portainer/portainer/api/http/offlinegate"
+// 	"github.com/portainer/portainer/api/archive"
+// 	"github.com/portainer/portainer/api/crypto"
+// 	"github.com/portainer/portainer/api/dataservices"
+// 	"github.com/portainer/portainer/api/filesystem"
+// 	"github.com/portainer/portainer/api/http/offlinegate"
 
-	"github.com/pkg/errors"
-	"github.com/rs/zerolog/log"
-)
+// 	"github.com/pkg/errors"
+// 	"github.com/rs/zerolog/log"
+// )
 
-const rwxr__r__ os.FileMode = 0744
+// const rwxr__r__ os.FileMode = 0744
 
-var filesToBackup = []string{
-	"certs",
-	"compose",
-	"config.json",
-	"custom_templates",
-	"edge_jobs",
-	"edge_stacks",
-	"extensions",
-	"portainer.key",
-	"portainer.pub",
-	"tls",
-}
+// var filesToBackup = []string{
+// 	"certs",
+// 	"compose",
+// 	"config.json",
+// 	"custom_templates",
+// 	"edge_jobs",
+// 	"edge_stacks",
+// 	"extensions",
+// 	"portainer.key",
+// 	"portainer.pub",
+// 	"tls",
+// }
 
-// 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) {
-	unlock := gate.Lock()
-	defer unlock()
+// // 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) {
+// 	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")
-	}
+// 	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()))
+// 	{
+// 		// 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")
-		}
-	}
+// 		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")
-	}
+// 	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")
-		}
-	}
+// 	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)
-	if err != nil {
-		return "", errors.Wrap(err, "Failed to make an archive")
-	}
+// 	archivePath, err := archive.TarGzDir(backupDirPath)
+// 	if err != nil {
+// 		return "", errors.Wrap(err, "Failed to make an archive")
+// 	}
 
-	if password != "" {
-		archivePath, err = encrypt(archivePath, password)
-		if err != nil {
-			return "", errors.Wrap(err, "Failed to encrypt backup with the password")
-		}
-	}
+// 	if password != "" {
+// 		archivePath, err = encrypt(archivePath, password)
+// 		if err != nil {
+// 			return "", errors.Wrap(err, "Failed to encrypt backup with the password")
+// 		}
+// 	}
 
-	return archivePath, nil
-}
+// 	return archivePath, nil
+// }
 
-func backupDb(backupDirPath string, datastore dataservices.DataStore) error {
-	backupWriter, err := os.Create(filepath.Join(backupDirPath, "portainer.db"))
-	if err != nil {
-		return err
-	}
-	if err = datastore.BackupTo(backupWriter); err != nil {
-		return err
-	}
-	return backupWriter.Close()
-}
+// func backupDb(backupDirPath string, datastore dataservices.DataStore) error {
+// 	backupWriter, err := os.Create(filepath.Join(backupDirPath, "portainer.db"))
+// 	if err != nil {
+// 		return err
+// 	}
+// 	if err = datastore.BackupTo(backupWriter); err != nil {
+// 		return err
+// 	}
+// 	return backupWriter.Close()
+// }
 
-func encrypt(path string, passphrase string) (string, error) {
-	in, err := os.Open(path)
-	if err != nil {
-		return "", err
-	}
-	defer in.Close()
+// func encrypt(path string, passphrase string) (string, error) {
+// 	in, err := os.Open(path)
+// 	if err != nil {
+// 		return "", err
+// 	}
+// 	defer in.Close()
 
-	outFileName := fmt.Sprintf("%s.encrypted", path)
-	out, err := os.Create(outFileName)
-	if err != nil {
-		return "", err
-	}
+// 	outFileName := fmt.Sprintf("%s.encrypted", path)
+// 	out, err := os.Create(outFileName)
+// 	if err != nil {
+// 		return "", err
+// 	}
 
-	err = crypto.AesEncrypt(in, out, []byte(passphrase))
+// 	err = crypto.AesEncrypt(in, out, []byte(passphrase))
 
-	return outFileName, err
-}
+// 	return outFileName, err
+// }

api/backup/restore.go

@@ -1,85 +1,85 @@
 package backup
 
-import (
-	"context"
-	"io"
-	"os"
-	"path/filepath"
-	"time"
+// import (
+// 	"context"
+// 	"io"
+// 	"os"
+// 	"path/filepath"
+// 	"time"
 
-	"github.com/pkg/errors"
-	"github.com/portainer/portainer/api/archive"
-	"github.com/portainer/portainer/api/crypto"
-	"github.com/portainer/portainer/api/database/boltdb"
-	"github.com/portainer/portainer/api/dataservices"
-	"github.com/portainer/portainer/api/filesystem"
-	"github.com/portainer/portainer/api/http/offlinegate"
-)
+// 	"github.com/pkg/errors"
+// 	"github.com/portainer/portainer/api/archive"
+// 	"github.com/portainer/portainer/api/crypto"
+// 	"github.com/portainer/portainer/api/dataservices"
+// 	"github.com/portainer/portainer/api/filesystem"
+// 	"github.com/portainer/portainer/api/http/offlinegate"
+// )
 
-var filesToRestore = append(filesToBackup, "portainer.db")
+// var filesToRestore = append(filesToBackup, "portainer.db")
 
-// Restores system state from backup archive, will trigger system shutdown, when finished.
-func RestoreArchive(archive io.Reader, password string, filestorePath string, gate *offlinegate.OfflineGate, datastore dataservices.DataStore, shutdownTrigger context.CancelFunc) error {
-	var err error
-	if password != "" {
-		archive, err = decrypt(archive, password)
-		if err != nil {
-			return errors.Wrap(err, "failed to decrypt the archive")
-		}
-	}
+// // Restores system state from backup archive, will trigger system shutdown, when finished.
+// func RestoreArchive(archive io.Reader, password string, filestorePath string, gate *offlinegate.OfflineGate, datastore dataservices.DataStore, shutdownTrigger context.CancelFunc) error {
+// 	var err error
+// 	if password != "" {
+// 		archive, err = decrypt(archive, password)
+// 		if err != nil {
+// 			return errors.Wrap(err, "failed to decrypt the archive")
+// 		}
+// 	}
 
-	restorePath := filepath.Join(filestorePath, "restore", time.Now().Format("20060102150405"))
-	defer os.RemoveAll(filepath.Dir(restorePath))
+// 	restorePath := filepath.Join(filestorePath, "restore", time.Now().Format("20060102150405"))
+// 	defer os.RemoveAll(filepath.Dir(restorePath))
 
-	err = extractArchive(archive, restorePath)
-	if err != nil {
-		return errors.Wrap(err, "cannot extract files from the archive. Please ensure the password is correct and try again")
-	}
+// 	err = extractArchive(archive, restorePath)
+// 	if err != nil {
+// 		return errors.Wrap(err, "cannot extract files from the archive. Please ensure the password is correct and try again")
+// 	}
 
-	unlock := gate.Lock()
-	defer unlock()
+// 	unlock := gate.Lock()
+// 	defer unlock()
 
-	if err = datastore.Close(); err != nil {
-		return errors.Wrap(err, "Failed to stop db")
-	}
+// 	if err = datastore.Close(); err != nil {
+// 		return errors.Wrap(err, "Failed to stop db")
+// 	}
 
-	if err = restoreFiles(restorePath, filestorePath); err != nil {
-		return errors.Wrap(err, "failed to restore the system state")
-	}
+// 	if err = restoreFiles(restorePath, filestorePath); err != nil {
+// 		return errors.Wrap(err, "failed to restore the system state")
+// 	}
 
-	shutdownTrigger()
-	return nil
-}
+// 	shutdownTrigger()
+// 	return nil
+// }
 
-func decrypt(r io.Reader, password string) (io.Reader, error) {
-	return crypto.AesDecrypt(r, []byte(password))
-}
+// func decrypt(r io.Reader, password string) (io.Reader, error) {
+// 	return crypto.AesDecrypt(r, []byte(password))
+// }
 
-func extractArchive(r io.Reader, destinationDirPath string) error {
-	return archive.ExtractTarGz(r, destinationDirPath)
-}
+// func extractArchive(r io.Reader, destinationDirPath string) error {
+// 	return archive.ExtractTarGz(r, destinationDirPath)
+// }
 
-func restoreFiles(srcDir string, destinationDir string) error {
-	for _, filename := range filesToRestore {
-		err := filesystem.CopyPath(filepath.Join(srcDir, filename), destinationDir)
-		if err != nil {
-			return err
-		}
-	}
+// func restoreFiles(srcDir string, destinationDir string) error {
+// 	for _, filename := range filesToRestore {
+// 		err := filesystem.CopyPath(filepath.Join(srcDir, filename), destinationDir)
+// 		if err != nil {
+// 			return err
+// 		}
+// 	}
 
-	// TODO:  This is very boltdb module specific once again due to the filename.  Move to bolt module? Refactor for another day
+// 	// TODO:  This is very boltdb module specific once again due to the filename.  Move to bolt module? Refactor for another day
 
-	// Prevent the possibility of having both databases.  Remove any default new instance
-	os.Remove(filepath.Join(destinationDir, boltdb.DatabaseFileName))
-	os.Remove(filepath.Join(destinationDir, boltdb.EncryptedDatabaseFileName))
+// 	// Prevent the possibility of having both databases.  Remove any default new instance
+// 	os.Remove(filepath.Join(destinationDir, boltdb.DatabaseFileName))
+// 	os.Remove(filepath.Join(destinationDir, boltdb.EncryptedDatabaseFileName))
 
-	// Now copy the database.  It'll be either portainer.db or portainer.edb
+// 	// Now copy the database.  It'll be either portainer.db or portainer.edb
 
-	// Note: CopyPath does not return an error if the source file doesn't exist
-	err := filesystem.CopyPath(filepath.Join(srcDir, boltdb.EncryptedDatabaseFileName), destinationDir)
-	if err != nil {
-		return err
-	}
+// 	// Note: CopyPath does not return an error if the source file doesn't exist
+// 	err := filesystem.CopyPath(filepath.Join(srcDir, boltdb.EncryptedDatabaseFileName), destinationDir)
+// 	if err != nil {
+// 		return err
+// 	}
 
-	return filesystem.CopyPath(filepath.Join(srcDir, boltdb.DatabaseFileName), destinationDir)
-}
+// 	// return filesystem.CopyPath(filepath.Join(srcDir, boltdb.DatabaseFileName), destinationDir)
+// 	return nil
+// }

api/cmd/portainer/import.go

@@ -1,28 +0,0 @@
-package main
-
-import (
-	portainer "github.com/portainer/portainer/api"
-	"github.com/portainer/portainer/api/datastore"
-
-	"github.com/rs/zerolog/log"
-)
-
-func importFromJson(fileService portainer.FileService, store *datastore.Store) {
-	// EXPERIMENTAL - if used with an incomplete json file, it will fail, as we don't have a way to default the model values
-	importFile := "/data/import.json"
-	if exists, _ := fileService.FileExists(importFile); exists {
-		if err := store.Import(importFile); err != nil {
-			log.Error().Str("filename", importFile).Err(err).Msg("import failed")
-			// TODO: should really rollback on failure, but then we have nothing.
-		} else {
-			log.Info().Str("filename", importFile).Msg("successfully imported the file to a new portainer database")
-		}
-
-		// TODO: this is bad - its to ensure that any defaults that were broken in import, or migrations get set back to what we want
-		// I also suspect that everything from "Init to Init" is potentially a migration
-		err := store.Init()
-		if err != nil {
-			log.Fatal().Err(err).Msg("failed initializing data store")
-		}
-	}
-}

api/cmd/portainer/main.go

@@ -8,7 +8,6 @@ import (
 	"path"
 	"strconv"
 	"strings"
-	"time"
 
 	"github.com/portainer/libhelm"
 	portainer "github.com/portainer/portainer/api"
@@ -18,7 +17,6 @@ import (
 	"github.com/portainer/portainer/api/cli"
 	"github.com/portainer/portainer/api/crypto"
 	"github.com/portainer/portainer/api/database"
-	"github.com/portainer/portainer/api/database/boltdb"
 	"github.com/portainer/portainer/api/dataservices"
 	"github.com/portainer/portainer/api/datastore"
 	"github.com/portainer/portainer/api/demo"
@@ -71,36 +69,28 @@ 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)
+	connection, err := database.NewDatabase("sqlite", *flags.Data, secretKey)
 	if err != nil {
 		log.Fatal().Err(err).Msg("failed creating database connection")
 	}
 
-	if bconn, ok := connection.(*boltdb.DbConnection); ok {
-		bconn.MaxBatchSize = *flags.MaxBatchSize
-		bconn.MaxBatchDelay = *flags.MaxBatchDelay
-		bconn.InitialMmapSize = *flags.InitialMmapSize
-	} else {
-		log.Fatal().Msg("failed creating database connection: expecting a boltdb database type but a different one was received")
-	}
-
 	store := datastore.NewStore(*flags.Data, fileService, connection)
 	isNew, err := store.Open()
 	if err != nil {
 		log.Fatal().Err(err).Msg("failed opening store")
 	}
 
-	if *flags.Rollback {
-		err := store.Rollback(false)
-		if err != nil {
-			log.Fatal().Err(err).Msg("failed rolling back")
-		}
+	// if *flags.Rollback {
+	// 	err := store.Rollback(false)
+	// 	if err != nil {
+	// 		log.Fatal().Err(err).Msg("failed rolling back")
+	// 	}
 
-		log.Info().Msg("exiting rollback")
-		os.Exit(0)
+	// 	log.Info().Msg("exiting rollback")
+	// 	os.Exit(0)
 
-		return nil
-	}
+	// 	return nil
+	// }
 
 	// Init sets some defaults - it's basically a migration
 	err = store.Init()
@@ -117,17 +107,17 @@ func initDataStore(flags *portainer.CLIFlags, secretKey []byte, fileService port
 			log.Fatal().Err(err).Msg("failed updating settings from flags")
 		}
 	} else {
-		storedVersion, err := store.VersionService.DBVersion()
-		if err != nil {
-			log.Fatal().Err(err).Msg("failure during creation of new database")
-		}
+		// storedVersion, err := store.VersionService.DBVersion()
+		// if err != nil {
+		// 	log.Fatal().Err(err).Msg("failure during creation of new database")
+		// }
 
-		if storedVersion != portainer.DBVersion {
-			err = store.MigrateData()
-			if err != nil {
-				log.Fatal().Err(err).Msg("failed migration")
-			}
-		}
+		// if storedVersion != portainer.DBVersion {
+		// 	err = store.MigrateData()
+		// 	if err != nil {
+		// 		log.Fatal().Err(err).Msg("failed migration")
+		// 	}
+		// }
 	}
 
 	err = updateSettingsFromFlags(store, flags)
@@ -140,14 +130,14 @@ func initDataStore(flags *portainer.CLIFlags, secretKey []byte, fileService port
 		<-shutdownCtx.Done()
 		defer connection.Close()
 
-		exportFilename := path.Join(*flags.Data, fmt.Sprintf("export-%d.json", time.Now().Unix()))
+		// exportFilename := path.Join(*flags.Data, fmt.Sprintf("export-%d.json", time.Now().Unix()))
 
-		err := store.Export(exportFilename)
-		if err != nil {
-			log.Error().Str("filename", exportFilename).Err(err).Msg("failed to export")
-		} else {
-			log.Debug().Str("filename", exportFilename).Msg("exported")
-		}
+		// err := store.Export(exportFilename)
+		// if err != nil {
+		// 	log.Error().Str("filename", exportFilename).Err(err).Msg("failed to export")
+		// } else {
+		// 	log.Debug().Str("filename", exportFilename).Msg("exported")
+		// }
 	}()
 
 	return store

api/cmd/portainer/main_test.go

@@ -1,111 +1,111 @@
 package main
 
-import (
-	"fmt"
-	"testing"
+// import (
+// 	"fmt"
+// 	"testing"
 
-	portainer "github.com/portainer/portainer/api"
-	"github.com/portainer/portainer/api/cli"
-	"github.com/portainer/portainer/api/dataservices"
-	"github.com/portainer/portainer/api/datastore"
+// 	portainer "github.com/portainer/portainer/api"
+// 	"github.com/portainer/portainer/api/cli"
+// 	"github.com/portainer/portainer/api/dataservices"
+// 	"github.com/portainer/portainer/api/datastore"
 
-	"github.com/stretchr/testify/assert"
-	"gopkg.in/alecthomas/kingpin.v2"
-)
+// 	"github.com/stretchr/testify/assert"
+// 	"gopkg.in/alecthomas/kingpin.v2"
+// )
 
-type mockKingpinSetting string
+// type mockKingpinSetting string
 
-func (m mockKingpinSetting) SetValue(value kingpin.Value) {
-	value.Set(string(m))
-}
+// func (m mockKingpinSetting) SetValue(value kingpin.Value) {
+// 	value.Set(string(m))
+// }
 
-func Test_enableFeaturesFromFlags(t *testing.T) {
-	is := assert.New(t)
+// func Test_enableFeaturesFromFlags(t *testing.T) {
+// 	is := assert.New(t)
 
-	_, store, teardown := datastore.MustNewTestStore(t, true, true)
-	defer teardown()
+// 	_, store, teardown := datastore.MustNewTestStore(t, true, true)
+// 	defer teardown()
 
-	tests := []struct {
-		featureFlag string
-		isSupported bool
-	}{
-		{"test", false},
-	}
-	for _, test := range tests {
-		t.Run(fmt.Sprintf("%s succeeds:%v", test.featureFlag, test.isSupported), func(t *testing.T) {
-			mockKingpinSetting := mockKingpinSetting(test.featureFlag)
-			flags := &portainer.CLIFlags{FeatureFlags: cli.BoolPairs(mockKingpinSetting)}
-			err := enableFeaturesFromFlags(store, flags)
-			if test.isSupported {
-				is.NoError(err)
-			} else {
-				is.Error(err)
-			}
-		})
-	}
+// 	tests := []struct {
+// 		featureFlag string
+// 		isSupported bool
+// 	}{
+// 		{"test", false},
+// 	}
+// 	for _, test := range tests {
+// 		t.Run(fmt.Sprintf("%s succeeds:%v", test.featureFlag, test.isSupported), func(t *testing.T) {
+// 			mockKingpinSetting := mockKingpinSetting(test.featureFlag)
+// 			flags := &portainer.CLIFlags{FeatureFlags: cli.BoolPairs(mockKingpinSetting)}
+// 			err := enableFeaturesFromFlags(store, flags)
+// 			if test.isSupported {
+// 				is.NoError(err)
+// 			} else {
+// 				is.Error(err)
+// 			}
+// 		})
+// 	}
 
-	t.Run("passes for all supported feature flags", func(t *testing.T) {
-		for _, flag := range portainer.SupportedFeatureFlags {
-			mockKingpinSetting := mockKingpinSetting(flag)
-			flags := &portainer.CLIFlags{FeatureFlags: cli.BoolPairs(mockKingpinSetting)}
-			err := enableFeaturesFromFlags(store, flags)
-			is.NoError(err)
-		}
-	})
-}
+// 	t.Run("passes for all supported feature flags", func(t *testing.T) {
+// 		for _, flag := range portainer.SupportedFeatureFlags {
+// 			mockKingpinSetting := mockKingpinSetting(flag)
+// 			flags := &portainer.CLIFlags{FeatureFlags: cli.BoolPairs(mockKingpinSetting)}
+// 			err := enableFeaturesFromFlags(store, flags)
+// 			is.NoError(err)
+// 		}
+// 	})
+// }
 
-const FeatTest portainer.Feature = "optional-test"
+// const FeatTest portainer.Feature = "optional-test"
 
-func optionalFunc(dataStore dataservices.DataStore) string {
+// func optionalFunc(dataStore dataservices.DataStore) string {
 
-	// TODO: this is a code smell - finding out if a feature flag is enabled should not require having access to the store, and asking for a settings obj.
-	//       ideally, the `if` should look more like:
-	//       if featureflags.FlagEnabled(FeatTest) {}
-	settings, err := dataStore.Settings().Settings()
-	if err != nil {
-		return err.Error()
-	}
+// 	// TODO: this is a code smell - finding out if a feature flag is enabled should not require having access to the store, and asking for a settings obj.
+// 	//       ideally, the `if` should look more like:
+// 	//       if featureflags.FlagEnabled(FeatTest) {}
+// 	settings, err := dataStore.Settings().Settings()
+// 	if err != nil {
+// 		return err.Error()
+// 	}
 
-	if settings.FeatureFlagSettings[FeatTest] {
-		return "enabled"
-	}
-	return "disabled"
-}
+// 	if settings.FeatureFlagSettings[FeatTest] {
+// 		return "enabled"
+// 	}
+// 	return "disabled"
+// }
 
-func Test_optionalFeature(t *testing.T) {
-	portainer.SupportedFeatureFlags = append(portainer.SupportedFeatureFlags, FeatTest)
+// func Test_optionalFeature(t *testing.T) {
+// 	portainer.SupportedFeatureFlags = append(portainer.SupportedFeatureFlags, FeatTest)
 
-	is := assert.New(t)
+// 	is := assert.New(t)
 
-	_, store, teardown := datastore.MustNewTestStore(t, true, true)
-	defer teardown()
+// 	_, store, teardown := datastore.MustNewTestStore(t, true, true)
+// 	defer teardown()
 
-	// Enable the test feature
-	t.Run(fmt.Sprintf("%s succeeds:%v", FeatTest, true), func(t *testing.T) {
-		mockKingpinSetting := mockKingpinSetting(FeatTest)
-		flags := &portainer.CLIFlags{FeatureFlags: cli.BoolPairs(mockKingpinSetting)}
-		err := enableFeaturesFromFlags(store, flags)
-		is.NoError(err)
-		is.Equal("enabled", optionalFunc(store))
-	})
+// 	// Enable the test feature
+// 	t.Run(fmt.Sprintf("%s succeeds:%v", FeatTest, true), func(t *testing.T) {
+// 		mockKingpinSetting := mockKingpinSetting(FeatTest)
+// 		flags := &portainer.CLIFlags{FeatureFlags: cli.BoolPairs(mockKingpinSetting)}
+// 		err := enableFeaturesFromFlags(store, flags)
+// 		is.NoError(err)
+// 		is.Equal("enabled", optionalFunc(store))
+// 	})
 
-	// Same store, so the feature flag should still be enabled
-	t.Run(fmt.Sprintf("%s succeeds:%v", FeatTest, true), func(t *testing.T) {
-		is.Equal("enabled", optionalFunc(store))
-	})
+// 	// Same store, so the feature flag should still be enabled
+// 	t.Run(fmt.Sprintf("%s succeeds:%v", FeatTest, true), func(t *testing.T) {
+// 		is.Equal("enabled", optionalFunc(store))
+// 	})
 
-	// disable the test feature
-	t.Run(fmt.Sprintf("%s succeeds:%v", FeatTest, true), func(t *testing.T) {
-		mockKingpinSetting := mockKingpinSetting(FeatTest + "=false")
-		flags := &portainer.CLIFlags{FeatureFlags: cli.BoolPairs(mockKingpinSetting)}
-		err := enableFeaturesFromFlags(store, flags)
-		is.NoError(err)
-		is.Equal("disabled", optionalFunc(store))
-	})
+// 	// disable the test feature
+// 	t.Run(fmt.Sprintf("%s succeeds:%v", FeatTest, true), func(t *testing.T) {
+// 		mockKingpinSetting := mockKingpinSetting(FeatTest + "=false")
+// 		flags := &portainer.CLIFlags{FeatureFlags: cli.BoolPairs(mockKingpinSetting)}
+// 		err := enableFeaturesFromFlags(store, flags)
+// 		is.NoError(err)
+// 		is.Equal("disabled", optionalFunc(store))
+// 	})
 
-	// Same store, so feature flag should still be disabled
-	t.Run(fmt.Sprintf("%s succeeds:%v", FeatTest, true), func(t *testing.T) {
-		is.Equal("disabled", optionalFunc(store))
-	})
+// 	// Same store, so feature flag should still be disabled
+// 	t.Run(fmt.Sprintf("%s succeeds:%v", FeatTest, true), func(t *testing.T) {
+// 		is.Equal("disabled", optionalFunc(store))
+// 	})
 
-}
+// }

api/connection.go

@@ -1,39 +1,20 @@
 package portainer
 
-import (
-	"io"
-)
+import "gorm.io/gorm"
 
 type Connection interface {
 	Open() error
 	Close() error
 
-	// write the db contents to filename as json (the schema needs defining)
-	ExportRaw(filename string) error
+	Init() error
+
+	GetDB() *gorm.DB
 
-	// TODO: this one is very database specific atm
-	BackupTo(w io.Writer) error
 	GetDatabaseFileName() string
 	GetDatabaseFilePath() string
 	GetStorePath() string
 
+	SetEncrypted(encrypted bool)
 	IsEncryptedStore() bool
 	NeedsEncryptionMigration() (bool, error)
-	SetEncrypted(encrypted bool)
-
-	SetServiceName(bucketName string) error
-	GetObject(bucketName string, key []byte, object interface{}) error
-	UpdateObject(bucketName string, key []byte, object interface{}) error
-	DeleteObject(bucketName string, key []byte) error
-	DeleteAllObjects(bucketName string, matching func(o interface{}) (id int, ok bool)) error
-	GetNextIdentifier(bucketName string) int
-	CreateObject(bucketName string, fn func(uint64) (int, interface{})) error
-	CreateObjectWithId(bucketName string, id int, obj interface{}) error
-	CreateObjectWithStringId(bucketName string, id []byte, obj interface{}) error
-	GetAll(bucketName string, obj interface{}, append func(o interface{}) (interface{}, error)) error
-	GetAllWithJsoniter(bucketName string, obj interface{}, append func(o interface{}) (interface{}, error)) error
-	ConvertToKey(v int) []byte
-
-	BackupMetadata() (map[string]interface{}, error)
-	RestoreMetadata(s map[string]interface{}) error
 }

api/database/boltdb/db.go

@@ -1,434 +0,0 @@
-package boltdb
-
-import (
-	"bytes"
-	"encoding/binary"
-	"errors"
-	"fmt"
-	"io"
-	"io/ioutil"
-	"os"
-	"path"
-	"time"
-
-	dserrors "github.com/portainer/portainer/api/dataservices/errors"
-
-	"github.com/rs/zerolog/log"
-	bolt "go.etcd.io/bbolt"
-)
-
-const (
-	DatabaseFileName          = "portainer.db"
-	EncryptedDatabaseFileName = "portainer.edb"
-)
-
-var (
-	ErrHaveEncryptedAndUnencrypted = errors.New("Portainer has detected both an encrypted and un-encrypted database and cannot start.  Only one database should exist")
-	ErrHaveEncryptedWithNoKey      = errors.New("The portainer database is encrypted, but no secret was loaded")
-)
-
-type DbConnection struct {
-	Path            string
-	MaxBatchSize    int
-	MaxBatchDelay   time.Duration
-	InitialMmapSize int
-	EncryptionKey   []byte
-	isEncrypted     bool
-
-	*bolt.DB
-}
-
-// GetDatabaseFileName get the database filename
-func (connection *DbConnection) GetDatabaseFileName() string {
-	if connection.IsEncryptedStore() {
-		return EncryptedDatabaseFileName
-	}
-
-	return DatabaseFileName
-}
-
-// GetDataseFilePath get the path + filename for the database file
-func (connection *DbConnection) GetDatabaseFilePath() string {
-	if connection.IsEncryptedStore() {
-		return path.Join(connection.Path, EncryptedDatabaseFileName)
-	}
-
-	return path.Join(connection.Path, DatabaseFileName)
-}
-
-// GetStorePath get the filename and path for the database file
-func (connection *DbConnection) GetStorePath() string {
-	return connection.Path
-}
-
-func (connection *DbConnection) SetEncrypted(flag bool) {
-	connection.isEncrypted = flag
-}
-
-// Return true if the database is encrypted
-func (connection *DbConnection) IsEncryptedStore() bool {
-	return connection.getEncryptionKey() != nil
-}
-
-// NeedsEncryptionMigration returns true if database encryption is enabled and
-// we have an un-encrypted DB that requires migration to an encrypted DB
-func (connection *DbConnection) NeedsEncryptionMigration() (bool, error) {
-
-	// Cases:  Note, we need to check both portainer.db and portainer.edb
-	// to determine if it's a new store.   We only need to differentiate between cases 2,3 and 5
-
-	// 1) portainer.edb + key     => False
-	// 2) portainer.edb + no key  => ERROR Fatal!
-	// 3) portainer.db  + key     => True  (needs migration)
-	// 4) portainer.db  + no key  => False
-	// 5) NoDB (new)    + key     => False
-	// 6) NoDB (new)    + no key  => False
-	// 7) portainer.db & portainer.edb => ERROR Fatal!
-
-	// If we have a loaded encryption key, always set encrypted
-	if connection.EncryptionKey != nil {
-		connection.SetEncrypted(true)
-	}
-
-	// Check for portainer.db
-	dbFile := path.Join(connection.Path, DatabaseFileName)
-	_, err := os.Stat(dbFile)
-	haveDbFile := err == nil
-
-	// Check for portainer.edb
-	edbFile := path.Join(connection.Path, EncryptedDatabaseFileName)
-	_, err = os.Stat(edbFile)
-	haveEdbFile := err == nil
-
-	if haveDbFile && haveEdbFile {
-		// 7 - encrypted and unencrypted db?
-		return false, ErrHaveEncryptedAndUnencrypted
-	}
-
-	if haveDbFile && connection.EncryptionKey != nil {
-		// 3 - needs migration
-		return true, nil
-	}
-
-	if haveEdbFile && connection.EncryptionKey == nil {
-		// 2 - encrypted db, but no key?
-		return false, ErrHaveEncryptedWithNoKey
-	}
-
-	// 1, 4, 5, 6
-	return false, nil
-}
-
-// Open opens and initializes the BoltDB database.
-func (connection *DbConnection) Open() error {
-
-	log.Info().Str("filename", connection.GetDatabaseFileName()).Msg("loading PortainerDB")
-
-	// Now we open the db
-	databasePath := connection.GetDatabaseFilePath()
-	db, err := bolt.Open(databasePath, 0600, &bolt.Options{
-		Timeout:         1 * time.Second,
-		InitialMmapSize: connection.InitialMmapSize,
-	})
-	if err != nil {
-		return err
-	}
-	db.MaxBatchSize = connection.MaxBatchSize
-	db.MaxBatchDelay = connection.MaxBatchDelay
-	connection.DB = db
-	return nil
-}
-
-// Close closes the BoltDB database.
-// Safe to being called multiple times.
-func (connection *DbConnection) Close() error {
-	if connection.DB != nil {
-		return connection.DB.Close()
-	}
-	return nil
-}
-
-// BackupTo backs up db to a provided writer.
-// It does hot backup and doesn't block other database reads and writes
-func (connection *DbConnection) BackupTo(w io.Writer) error {
-	return connection.View(func(tx *bolt.Tx) error {
-		_, err := tx.WriteTo(w)
-		return err
-	})
-}
-
-func (connection *DbConnection) ExportRaw(filename string) error {
-	databasePath := connection.GetDatabaseFilePath()
-	if _, err := os.Stat(databasePath); err != nil {
-		return fmt.Errorf("stat on %s failed: %s", databasePath, err)
-	}
-
-	b, err := connection.ExportJSON(databasePath, true)
-	if err != nil {
-		return err
-	}
-	return ioutil.WriteFile(filename, b, 0600)
-}
-
-// ConvertToKey returns an 8-byte big endian representation of v.
-// This function is typically used for encoding integer IDs to byte slices
-// so that they can be used as BoltDB keys.
-func (connection *DbConnection) ConvertToKey(v int) []byte {
-	b := make([]byte, 8)
-	binary.BigEndian.PutUint64(b, uint64(v))
-	return b
-}
-
-// CreateBucket is a generic function used to create a bucket inside a database database.
-func (connection *DbConnection) SetServiceName(bucketName string) error {
-	return connection.Batch(func(tx *bolt.Tx) error {
-		_, err := tx.CreateBucketIfNotExists([]byte(bucketName))
-		return err
-	})
-}
-
-// GetObject is a generic function used to retrieve an unmarshalled object from a database database.
-func (connection *DbConnection) GetObject(bucketName string, key []byte, object interface{}) error {
-	var data []byte
-
-	err := connection.View(func(tx *bolt.Tx) error {
-		bucket := tx.Bucket([]byte(bucketName))
-
-		value := bucket.Get(key)
-		if value == nil {
-			return dserrors.ErrObjectNotFound
-		}
-
-		data = make([]byte, len(value))
-		copy(data, value)
-
-		return nil
-	})
-	if err != nil {
-		return err
-	}
-
-	return connection.UnmarshalObjectWithJsoniter(data, object)
-}
-
-func (connection *DbConnection) getEncryptionKey() []byte {
-	if !connection.isEncrypted {
-		return nil
-	}
-
-	return connection.EncryptionKey
-}
-
-// UpdateObject is a generic function used to update an object inside a database database.
-func (connection *DbConnection) UpdateObject(bucketName string, key []byte, object interface{}) error {
-	data, err := connection.MarshalObject(object)
-	if err != nil {
-		return err
-	}
-
-	return connection.Batch(func(tx *bolt.Tx) error {
-		bucket := tx.Bucket([]byte(bucketName))
-		return bucket.Put(key, data)
-	})
-}
-
-// DeleteObject is a generic function used to delete an object inside a database database.
-func (connection *DbConnection) DeleteObject(bucketName string, key []byte) error {
-	return connection.Batch(func(tx *bolt.Tx) error {
-		bucket := tx.Bucket([]byte(bucketName))
-		return bucket.Delete(key)
-	})
-}
-
-// DeleteAllObjects delete all objects where matching() returns (id, ok).
-// TODO: think about how to return the error inside (maybe change ok to type err, and use "notfound"?
-func (connection *DbConnection) DeleteAllObjects(bucketName string, matching func(o interface{}) (id int, ok bool)) error {
-	return connection.Batch(func(tx *bolt.Tx) error {
-		bucket := tx.Bucket([]byte(bucketName))
-
-		cursor := bucket.Cursor()
-		for k, v := cursor.First(); k != nil; k, v = cursor.Next() {
-			var obj interface{}
-			err := connection.UnmarshalObject(v, &obj)
-			if err != nil {
-				return err
-			}
-
-			if id, ok := matching(obj); ok {
-				err := bucket.Delete(connection.ConvertToKey(id))
-				if err != nil {
-					return err
-				}
-			}
-		}
-
-		return nil
-	})
-}
-
-// GetNextIdentifier is a generic function that returns the specified bucket identifier incremented by 1.
-func (connection *DbConnection) GetNextIdentifier(bucketName string) int {
-	var identifier int
-
-	connection.Batch(func(tx *bolt.Tx) error {
-		bucket := tx.Bucket([]byte(bucketName))
-		id, err := bucket.NextSequence()
-		if err != nil {
-			return err
-		}
-		identifier = int(id)
-		return nil
-	})
-
-	return identifier
-}
-
-// CreateObject creates a new object in the bucket, using the next bucket sequence id
-func (connection *DbConnection) CreateObject(bucketName string, fn func(uint64) (int, interface{})) error {
-	return connection.Batch(func(tx *bolt.Tx) error {
-		bucket := tx.Bucket([]byte(bucketName))
-
-		seqId, _ := bucket.NextSequence()
-		id, obj := fn(seqId)
-
-		data, err := connection.MarshalObject(obj)
-		if err != nil {
-			return err
-		}
-
-		return bucket.Put(connection.ConvertToKey(int(id)), data)
-	})
-}
-
-// CreateObjectWithId creates a new object in the bucket, using the specified id
-func (connection *DbConnection) CreateObjectWithId(bucketName string, id int, obj interface{}) error {
-	return connection.Batch(func(tx *bolt.Tx) error {
-		bucket := tx.Bucket([]byte(bucketName))
-		data, err := connection.MarshalObject(obj)
-		if err != nil {
-			return err
-		}
-
-		return bucket.Put(connection.ConvertToKey(id), data)
-	})
-}
-
-// CreateObjectWithStringId creates a new object in the bucket, using the specified id
-func (connection *DbConnection) CreateObjectWithStringId(bucketName string, id []byte, obj interface{}) error {
-	return connection.Batch(func(tx *bolt.Tx) error {
-		bucket := tx.Bucket([]byte(bucketName))
-		data, err := connection.MarshalObject(obj)
-		if err != nil {
-			return err
-		}
-
-		return bucket.Put(id, data)
-	})
-}
-
-func (connection *DbConnection) GetAll(bucketName string, obj interface{}, append func(o interface{}) (interface{}, error)) error {
-	err := connection.View(func(tx *bolt.Tx) error {
-		bucket := tx.Bucket([]byte(bucketName))
-
-		cursor := bucket.Cursor()
-		for k, v := cursor.First(); k != nil; k, v = cursor.Next() {
-			err := connection.UnmarshalObject(v, obj)
-			if err != nil {
-				return err
-			}
-			obj, err = append(obj)
-			if err != nil {
-				return err
-			}
-		}
-
-		return nil
-	})
-
-	return err
-}
-
-// TODO: decide which Unmarshal to use, and use one...
-func (connection *DbConnection) GetAllWithJsoniter(bucketName string, obj interface{}, append func(o interface{}) (interface{}, error)) error {
-	err := connection.View(func(tx *bolt.Tx) error {
-		bucket := tx.Bucket([]byte(bucketName))
-
-		cursor := bucket.Cursor()
-		for k, v := cursor.First(); k != nil; k, v = cursor.Next() {
-			err := connection.UnmarshalObjectWithJsoniter(v, obj)
-			if err != nil {
-				return err
-			}
-			obj, err = append(obj)
-			if err != nil {
-				return err
-			}
-		}
-
-		return nil
-	})
-	return err
-}
-
-func (connection *DbConnection) GetAllWithKeyPrefix(bucketName string, keyPrefix []byte, obj interface{}, append func(o interface{}) (interface{}, error)) error {
-	return connection.View(func(tx *bolt.Tx) error {
-		cursor := tx.Bucket([]byte(bucketName)).Cursor()
-
-		for k, v := cursor.Seek(keyPrefix); k != nil && bytes.HasPrefix(k, keyPrefix); k, v = cursor.Next() {
-			err := connection.UnmarshalObjectWithJsoniter(v, obj)
-			if err != nil {
-				return err
-			}
-
-			obj, err = append(obj)
-			if err != nil {
-				return err
-			}
-		}
-
-		return nil
-	})
-}
-
-// BackupMetadata will return a copy of the boltdb sequence numbers for all buckets.
-func (connection *DbConnection) BackupMetadata() (map[string]interface{}, error) {
-	buckets := map[string]interface{}{}
-
-	err := connection.View(func(tx *bolt.Tx) error {
-		err := tx.ForEach(func(name []byte, bucket *bolt.Bucket) error {
-			bucketName := string(name)
-			bucket = tx.Bucket([]byte(bucketName))
-			seqId := bucket.Sequence()
-			buckets[bucketName] = int(seqId)
-			return nil
-		})
-
-		return err
-	})
-
-	return buckets, err
-}
-
-// RestoreMetadata will restore the boltdb sequence numbers for all buckets.
-func (connection *DbConnection) RestoreMetadata(s map[string]interface{}) error {
-	var err error
-
-	for bucketName, v := range s {
-		id, ok := v.(float64) // JSON ints are unmarshalled to interface as float64. See: https://pkg.go.dev/encoding/json#Decoder.Decode
-		if !ok {
-			log.Error().Str("bucket", bucketName).Msg("failed to restore metadata to bucket, skipped")
-			continue
-		}
-
-		err = connection.Batch(func(tx *bolt.Tx) error {
-			bucket, err := tx.CreateBucketIfNotExists([]byte(bucketName))
-			if err != nil {
-				return err
-			}
-
-			return bucket.SetSequence(uint64(id))
-		})
-	}
-
-	return err
-}

api/database/boltdb/db_test.go

@@ -1,124 +0,0 @@
-package boltdb
-
-import (
-	"os"
-	"path"
-	"testing"
-
-	"github.com/stretchr/testify/assert"
-)
-
-func Test_NeedsEncryptionMigration(t *testing.T) {
-	// Test the specific scenarios mentioned in NeedsEncryptionMigration
-
-	// i.e.
-	// Cases:  Note, we need to check both portainer.db and portainer.edb
-	// to determine if it's a new store.   We only need to differentiate between cases 2,3 and 5
-
-	// 1) portainer.edb + key     => False
-	// 2) portainer.edb + no key  => ERROR Fatal!
-	// 3) portainer.db  + key     => True  (needs migration)
-	// 4) portainer.db  + no key  => False
-	// 5) NoDB (new)    + key     => False
-	// 6) NoDB (new)    + no key  => False
-	// 7) portainer.db & portainer.edb (key not important) => ERROR Fatal!
-
-	is := assert.New(t)
-	dir := t.TempDir()
-
-	cases := []struct {
-		name         string
-		dbname       string
-		key          bool
-		expectError  error
-		expectResult bool
-	}{
-		{
-			name:         "portainer.edb + key",
-			dbname:       EncryptedDatabaseFileName,
-			key:          true,
-			expectError:  nil,
-			expectResult: false,
-		},
-		{
-			name:         "portainer.db + key (migration needed)",
-			dbname:       DatabaseFileName,
-			key:          true,
-			expectError:  nil,
-			expectResult: true,
-		},
-		{
-			name:         "portainer.db + no key",
-			dbname:       DatabaseFileName,
-			key:          false,
-			expectError:  nil,
-			expectResult: false,
-		},
-		{
-			name:         "NoDB (new) + key",
-			dbname:       "",
-			key:          false,
-			expectError:  nil,
-			expectResult: false,
-		},
-		{
-			name:         "NoDB (new) + no key",
-			dbname:       "",
-			key:          false,
-			expectError:  nil,
-			expectResult: false,
-		},
-
-		// error tests
-		{
-			name:         "portainer.edb + no key",
-			dbname:       EncryptedDatabaseFileName,
-			key:          false,
-			expectError:  ErrHaveEncryptedWithNoKey,
-			expectResult: false,
-		},
-		{
-			name:         "portainer.db & portainer.edb",
-			dbname:       "both",
-			key:          true,
-			expectError:  ErrHaveEncryptedAndUnencrypted,
-			expectResult: false,
-		},
-	}
-
-	for _, tc := range cases {
-		tc := tc
-
-		t.Run(tc.name, func(t *testing.T) {
-
-			connection := DbConnection{Path: dir}
-
-			if tc.dbname == "both" {
-				// Special case.  If portainer.db and portainer.edb exist.
-				dbFile1 := path.Join(connection.Path, DatabaseFileName)
-				f, _ := os.Create(dbFile1)
-				f.Close()
-				defer os.Remove(dbFile1)
-
-				dbFile2 := path.Join(connection.Path, EncryptedDatabaseFileName)
-				f, _ = os.Create(dbFile2)
-				f.Close()
-				defer os.Remove(dbFile2)
-			} else if tc.dbname != "" {
-				dbFile := path.Join(connection.Path, tc.dbname)
-				f, _ := os.Create(dbFile)
-				f.Close()
-				defer os.Remove(dbFile)
-			}
-
-			if tc.key {
-				connection.EncryptionKey = []byte("secret")
-			}
-
-			result, err := connection.NeedsEncryptionMigration()
-
-			is.Equal(tc.expectError, err, "Fatal Error failure. Test: %s", tc.name)
-			is.Equal(result, tc.expectResult, "Failed test: %s", tc.name)
-		})
-	}
-}

api/database/boltdb/export.go

@@ -1,113 +0,0 @@
-package boltdb
-
-import (
-	"encoding/json"
-	"time"
-
-	"github.com/rs/zerolog/log"
-	bolt "go.etcd.io/bbolt"
-)
-
-func backupMetadata(connection *bolt.DB) (map[string]interface{}, error) {
-	buckets := map[string]interface{}{}
-
-	err := connection.View(func(tx *bolt.Tx) error {
-		err := tx.ForEach(func(name []byte, bucket *bolt.Bucket) error {
-			bucketName := string(name)
-			bucket = tx.Bucket([]byte(bucketName))
-			seqId := bucket.Sequence()
-			buckets[bucketName] = int(seqId)
-			return nil
-		})
-
-		return err
-	})
-
-	return buckets, err
-}
-
-// ExportJSON creates a JSON representation from a DbConnection. You can include
-// the database's metadata or ignore it. Ensure the database is closed before
-// using this function.
-// inspired by github.com/konoui/boltdb-exporter (which has no license)
-// but very much simplified, based on how we use boltdb
-func (c *DbConnection) ExportJSON(databasePath string, metadata bool) ([]byte, error) {
-	log.Debug().Str("databasePath", databasePath).Msg("exportJson")
-
-	connection, err := bolt.Open(databasePath, 0600, &bolt.Options{Timeout: 1 * time.Second, ReadOnly: true})
-	if err != nil {
-		return []byte("{}"), err
-	}
-	defer connection.Close()
-
-	backup := make(map[string]interface{})
-	if metadata {
-		meta, err := backupMetadata(connection)
-		if err != nil {
-			log.Error().Err(err).Msg("failed exporting metadata")
-		}
-
-		backup["__metadata"] = meta
-	}
-
-	err = connection.View(func(tx *bolt.Tx) error {
-		err = tx.ForEach(func(name []byte, bucket *bolt.Bucket) error {
-			bucketName := string(name)
-			var list []interface{}
-			version := make(map[string]string)
-			cursor := bucket.Cursor()
-			for k, v := cursor.First(); k != nil; k, v = cursor.Next() {
-				if v == nil {
-					continue
-				}
-
-				var obj interface{}
-				err := c.UnmarshalObject(v, &obj)
-				if err != nil {
-					log.Error().
-						Str("bucket", bucketName).
-						Str("object", string(v)).
-						Err(err).
-						Msg("failed to unmarshal")
-
-					obj = v
-				}
-
-				if bucketName == "version" {
-					version[string(k)] = string(v)
-				} else {
-					list = append(list, obj)
-				}
-			}
-
-			if bucketName == "version" {
-				backup[bucketName] = version
-				return nil
-			}
-
-			if len(list) > 0 {
-				if bucketName == "ssl" ||
-					bucketName == "settings" ||
-					bucketName == "tunnel_server" {
-					backup[bucketName] = nil
-					if len(list) > 0 {
-						backup[bucketName] = list[0]
-					}
-					return nil
-				}
-				backup[bucketName] = list
-				return nil
-			}
-
-			return nil
-		})
-
-		return err
-	})
-
-	if err != nil {
-		return []byte("{}"), err
-	}
-
-	return json.MarshalIndent(backup, "", "  ")
-}

api/database/boltdb/json.go

@@ -1,133 +0,0 @@
-package boltdb
-
-import (
-	"crypto/aes"
-	"crypto/cipher"
-	"crypto/rand"
-	"encoding/json"
-	"fmt"
-	"io"
-
-	jsoniter "github.com/json-iterator/go"
-	"github.com/pkg/errors"
-)
-
-var errEncryptedStringTooShort = fmt.Errorf("encrypted string too short")
-
-// MarshalObject encodes an object to binary format
-func (connection *DbConnection) MarshalObject(object interface{}) (data []byte, err error) {
-	// Special case for the VERSION bucket. Here we're not using json
-	if v, ok := object.(string); ok {
-		data = []byte(v)
-	} else {
-		data, err = json.Marshal(object)
-		if err != nil {
-			return data, err
-		}
-	}
-	if connection.getEncryptionKey() == nil {
-		return data, nil
-	}
-	return encrypt(data, connection.getEncryptionKey())
-}
-
-// UnmarshalObject decodes an object from binary data
-func (connection *DbConnection) UnmarshalObject(data []byte, object interface{}) error {
-	var err error
-	if connection.getEncryptionKey() != nil {
-		data, err = decrypt(data, connection.getEncryptionKey())
-		if err != nil {
-			return errors.Wrap(err, "Failed decrypting object")
-		}
-	}
-	e := json.Unmarshal(data, object)
-	if e != nil {
-		// Special case for the VERSION bucket. Here we're not using json
-		// So we need to return it as a string
-		s, ok := object.(*string)
-		if !ok {
-			return errors.Wrap(err, e.Error())
-		}
-
-		*s = string(data)
-	}
-	return err
-}
-
-// UnmarshalObjectWithJsoniter decodes an object from binary data
-// using the jsoniter library. It is mainly used to accelerate environment(endpoint)
-// decoding at the moment.
-func (connection *DbConnection) UnmarshalObjectWithJsoniter(data []byte, object interface{}) error {
-	if connection.getEncryptionKey() != nil {
-		var err error
-		data, err = decrypt(data, connection.getEncryptionKey())
-		if err != nil {
-			return err
-		}
-	}
-	var jsoni = jsoniter.ConfigCompatibleWithStandardLibrary
-	err := jsoni.Unmarshal(data, &object)
-	if err != nil {
-		if s, ok := object.(*string); ok {
-			*s = string(data)
-			return nil
-		}
-
-		return err
-	}
-
-	return nil
-}
-
-// mmm, don't have a KMS .... aes GCM seems the most likely from
-// https://gist.github.com/atoponce/07d8d4c833873be2f68c34f9afc5a78a#symmetric-encryption
-
-func encrypt(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
-	}
-	ciphertextByte := gcm.Seal(
-		nonce,
-		nonce,
-		plaintext,
-		nil)
-	return ciphertextByte, nil
-}
-
-func decrypt(encrypted []byte, passphrase []byte) (plaintextByte []byte, err error) {
-	if string(encrypted) == "false" {
-		return []byte("false"), nil
-	}
-	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:]
-	plaintextByte, err = gcm.Open(
-		nil,
-		nonce,
-		ciphertextByteClean,
-		nil)
-	if err != nil {
-		return encrypted, errors.Wrap(err, "Error decrypting text")
-	}
-
-	return plaintextByte, err
-}

api/database/boltdb/json_test.go

@@ -1,177 +0,0 @@
-package boltdb
-
-import (
-	"crypto/sha256"
-	"fmt"
-	"testing"
-
-	"github.com/gofrs/uuid"
-	"github.com/stretchr/testify/assert"
-)
-
-const (
-	jsonobject = `{"LogoURL":"","BlackListedLabels":[],"AuthenticationMethod":1,"InternalAuthSettings": {"RequiredPasswordLength": 12}"LDAPSettings":{"AnonymousMode":true,"ReaderDN":"","URL":"","TLSConfig":{"TLS":false,"TLSSkipVerify":false},"StartTLS":false,"SearchSettings":[{"BaseDN":"","Filter":"","UserNameAttribute":""}],"GroupSearchSettings":[{"GroupBaseDN":"","GroupFilter":"","GroupAttribute":""}],"AutoCreateUsers":true},"OAuthSettings":{"ClientID":"","AccessTokenURI":"","AuthorizationURI":"","ResourceURI":"","RedirectURI":"","UserIdentifier":"","Scopes":"","OAuthAutoCreateUsers":false,"DefaultTeamID":0,"SSO":true,"LogoutURI":"","KubeSecretKey":"j0zLVtY/lAWBk62ByyF0uP80SOXaitsABP0TTJX8MhI="},"OpenAMTConfiguration":{"Enabled":false,"MPSServer":"","MPSUser":"","MPSPassword":"","MPSToken":"","CertFileContent":"","CertFileName":"","CertFilePassword":"","DomainName":""},"FeatureFlagSettings":{},"SnapshotInterval":"5m","TemplatesURL":"https://raw.githubusercontent.com/portainer/templates/master/templates-2.0.json","EdgeAgentCheckinInterval":5,"EnableEdgeComputeFeatures":false,"UserSessionTimeout":"8h","KubeconfigExpiry":"0","EnableTelemetry":true,"HelmRepositoryURL":"https://charts.bitnami.com/bitnami","KubectlShellImage":"portainer/kubectl-shell","DisplayDonationHeader":false,"DisplayExternalContributors":false,"EnableHostManagementFeatures":false,"AllowVolumeBrowserForRegularUsers":false,"AllowBindMountsForRegularUsers":false,"AllowPrivilegedModeForRegularUsers":false,"AllowHostNamespaceForRegularUsers":false,"AllowStackManagementForRegularUsers":false,"AllowDeviceMappingForRegularUsers":false,"AllowContainerCapabilitiesForRegularUsers":false}`
-	passphrase = "my secret key"
-)
-
-func secretToEncryptionKey(passphrase string) []byte {
-	hash := sha256.Sum256([]byte(passphrase))
-	return hash[:]
-}
-
-func Test_MarshalObjectUnencrypted(t *testing.T) {
-	is := assert.New(t)
-
-	uuid := uuid.Must(uuid.NewV4())
-
-	tests := []struct {
-		object   interface{}
-		expected string
-	}{
-		{
-			object:   nil,
-			expected: `null`,
-		},
-		{
-			object:   true,
-			expected: `true`,
-		},
-		{
-			object:   false,
-			expected: `false`,
-		},
-		{
-			object:   123,
-			expected: `123`,
-		},
-		{
-			object:   "456",
-			expected: "456",
-		},
-		{
-			object:   uuid,
-			expected: "\"" + uuid.String() + "\"",
-		},
-		{
-			object:   uuid.String(),
-			expected: uuid.String(),
-		},
-		{
-			object:   map[string]interface{}{"key": "value"},
-			expected: `{"key":"value"}`,
-		},
-		{
-			object:   []bool{true, false},
-			expected: `[true,false]`,
-		},
-		{
-			object:   []int{1, 2, 3},
-			expected: `[1,2,3]`,
-		},
-		{
-			object:   []string{"1", "2", "3"},
-			expected: `["1","2","3"]`,
-		},
-		{
-			object:   []map[string]interface{}{{"key1": "value1"}, {"key2": "value2"}},
-			expected: `[{"key1":"value1"},{"key2":"value2"}]`,
-		},
-		{
-			object:   []interface{}{1, "2", false, map[string]interface{}{"key1": "value1"}},
-			expected: `[1,"2",false,{"key1":"value1"}]`,
-		},
-	}
-
-	conn := DbConnection{}
-
-	for _, test := range tests {
-		t.Run(fmt.Sprintf("%s -> %s", test.object, test.expected), func(t *testing.T) {
-			data, err := conn.MarshalObject(test.object)
-			is.NoError(err)
-			is.Equal(test.expected, string(data))
-		})
-	}
-}
-
-func Test_UnMarshalObjectUnencrypted(t *testing.T) {
-	is := assert.New(t)
-
-	// Based on actual data entering and what we expect out of the function
-
-	tests := []struct {
-		object   []byte
-		expected string
-	}{
-		{
-			object:   []byte(""),
-			expected: "",
-		},
-		{
-			object:   []byte("35"),
-			expected: "35",
-		},
-		{
-			// An unmarshalled byte string should return the same without error
-			object:   []byte("9ca4a1dd-a439-4593-b386-a7dfdc2e9fc6"),
-			expected: "9ca4a1dd-a439-4593-b386-a7dfdc2e9fc6",
-		},
-		{
-			// An un-marshalled json object string should return the same as a string without error also
-			object:   []byte(jsonobject),
-			expected: jsonobject,
-		},
-	}
-
-	conn := DbConnection{}
-
-	for _, test := range tests {
-		t.Run(fmt.Sprintf("%s -> %s", test.object, test.expected), func(t *testing.T) {
-			var object string
-			err := conn.UnmarshalObject(test.object, &object)
-			is.NoError(err)
-			is.Equal(test.expected, string(object))
-		})
-	}
-}
-
-func Test_ObjectMarshallingEncrypted(t *testing.T) {
-	is := assert.New(t)
-
-	// Based on actual data entering and what we expect out of the function
-
-	tests := []struct {
-		object   []byte
-		expected string
-	}{
-		{
-			object: []byte(""),
-		},
-		{
-			object: []byte("35"),
-		},
-		{
-			// An unmarshalled byte string should return the same without error
-			object: []byte("9ca4a1dd-a439-4593-b386-a7dfdc2e9fc6"),
-		},
-		{
-			// An un-marshalled json object string should return the same as a string without error also
-			object: []byte(jsonobject),
-		},
-	}
-
-	key := secretToEncryptionKey(passphrase)
-	conn := DbConnection{EncryptionKey: key}
-	for _, test := range tests {
-		t.Run(fmt.Sprintf("%s -> %s", test.object, test.expected), func(t *testing.T) {
-
-			data, err := conn.MarshalObject(test.object)
-			is.NoError(err)
-
-			var object []byte
-			err = conn.UnmarshalObject(data, &object)
-
-			is.NoError(err)
-			is.Equal(test.object, object)
-		})
-	}
-}

api/database/database.go

@@ -4,14 +4,14 @@ import (
 	"fmt"
 
 	portainer "github.com/portainer/portainer/api"
-	"github.com/portainer/portainer/api/database/boltdb"
+	"github.com/portainer/portainer/api/database/sqlite"
 )
 
 // NewDatabase should use config options to return a connection to the requested database
 func NewDatabase(storeType, storePath string, encryptionKey []byte) (connection portainer.Connection, err error) {
 	switch storeType {
-	case "boltdb":
-		return &boltdb.DbConnection{
+	case "sqlite":
+		return &sqlite.DbConnection{
 			Path:          storePath,
 			EncryptionKey: encryptionKey,
 		}, nil

api/database/models/accessPolicy.go

@@ -0,0 +1,9 @@
+package models
+
+type (
+	// AccessPolicy represent a policy that can be associated to a user or team
+	AccessPolicy struct {
+		// Role identifier. Reference the role that will be associated to this access policy
+		RoleID RoleID `json:"RoleId" example:"1"`
+	}
+)

api/database/models/authorizations.go

@@ -0,0 +1,9 @@
+package models
+
+type (
+	// Authorization represents an authorization associated to an operation
+	Authorization string
+
+	// Authorizations represents a set of authorizations associated to a role
+	Authorizations map[Authorization]bool
+)

api/database/models/fdo.go

@@ -0,0 +1,21 @@
+package models
+
+type (
+	FDOConfiguration struct {
+		Enabled       bool   `json:"enabled"`
+		OwnerURL      string `json:"ownerURL"`
+		OwnerUsername string `json:"ownerUsername"`
+		OwnerPassword string `json:"ownerPassword"`
+	}
+
+	// FDOProfileID represents a fdo profile id
+	FDOProfileID int
+
+	FDOProfile struct {
+		ID            FDOProfileID `json:"id"`
+		Name          string       `json:"name"`
+		FilePath      string       `json:"filePath"`
+		NumberDevices int          `json:"numberDevices"`
+		DateCreated   int64        `json:"dateCreated"`
+	}
+)

api/database/models/ldap.go

@@ -0,0 +1,48 @@
+package models
+
+type (
+	// LDAPSettings represents the settings used to connect to a LDAP server
+	LDAPSettings struct {
+		// Enable this option if the server is configured for Anonymous access. When enabled, ReaderDN and Password will not be used
+		AnonymousMode bool `json:"AnonymousMode" example:"true" validate:"validate_bool"`
+		// Account that will be used to search for users
+		ReaderDN string `json:"ReaderDN" example:"cn=readonly-account,dc=ldap,dc=domain,dc=tld" validate:"required_if=AnonymousMode false"`
+		// Password of the account that will be used to search users
+		Password string `json:"Password,omitempty" example:"readonly-password" validate:"required_if=AnonymousMode false"`
+		// URL or IP address of the LDAP server
+		URL       string           `json:"URL" example:"myldap.domain.tld:389" validate:"hostname_port"`
+		TLSConfig TLSConfiguration `json:"TLSConfig"`
+		// Whether LDAP connection should use StartTLS
+		StartTLS            bool                      `json:"StartTLS" example:"true"`
+		SearchSettings      []LDAPSearchSettings      `json:"SearchSettings"`
+		GroupSearchSettings []LDAPGroupSearchSettings `json:"GroupSearchSettings"`
+		// Automatically provision users and assign them to matching LDAP group names
+		AutoCreateUsers bool `json:"AutoCreateUsers" example:"true"`
+	}
+
+	// LDAPUser represents a LDAP user
+	LDAPUser struct {
+		Name   string
+		Groups []string
+	}
+
+	// LDAPGroupSearchSettings represents settings used to search for groups in a LDAP server
+	LDAPGroupSearchSettings struct {
+		// The distinguished name of the element from which the LDAP server will search for groups
+		GroupBaseDN string `json:"GroupBaseDN" example:"dc=ldap,dc=domain,dc=tld"`
+		// The LDAP search filter used to select group elements, optional
+		GroupFilter string `json:"GroupFilter" example:"(objectClass=account"`
+		// LDAP attribute which denotes the group membership
+		GroupAttribute string `json:"GroupAttribute" example:"member"`
+	}
+
+	// LDAPSearchSettings represents settings used to search for users in a LDAP server
+	LDAPSearchSettings struct {
+		// The distinguished name of the element from which the LDAP server will search for users
+		BaseDN string `json:"BaseDN" example:"dc=ldap,dc=domain,dc=tld"`
+		// Optional LDAP search filter used to select user elements
+		Filter string `json:"Filter" example:"(objectClass=account)"`
+		// LDAP attribute which denotes the username
+		UserNameAttribute string `json:"UserNameAttribute" example:"uid"`
+	}
+)

api/database/models/membership.go

@@ -0,0 +1,6 @@
+package models
+
+type (
+	// MembershipRole represents the role of a user within a team
+	MembershipRole int
+)

api/database/models/openamt.go

@@ -0,0 +1,37 @@
+package models
+
+type (
+	// PowerState represents an AMT managed device power state
+	PowerState int
+
+	// OpenAMTConfiguration represents the credentials and configurations used to connect to an OpenAMT MPS server
+	OpenAMTConfiguration struct {
+		Enabled          bool   `json:"enabled"`
+		MPSServer        string `json:"mpsServer"`
+		MPSUser          string `json:"mpsUser"`
+		MPSPassword      string `json:"mpsPassword"`
+		MPSToken         string `json:"mpsToken"` // retrieved from API
+		CertFileName     string `json:"certFileName"`
+		CertFileContent  string `json:"certFileContent"`
+		CertFilePassword string `json:"certFilePassword"`
+		DomainName       string `json:"domainName"`
+	}
+
+	// OpenAMTDeviceInformation represents an AMT managed device information
+	OpenAMTDeviceInformation struct {
+		GUID             string                        `json:"guid"`
+		HostName         string                        `json:"hostname"`
+		ConnectionStatus bool                          `json:"connectionStatus"`
+		PowerState       PowerState                    `json:"powerState"`
+		EnabledFeatures  *OpenAMTDeviceEnabledFeatures `json:"features"`
+	}
+
+	// OpenAMTDeviceEnabledFeatures represents an AMT managed device features information
+	OpenAMTDeviceEnabledFeatures struct {
+		Redirection bool   `json:"redirection"`
+		KVM         bool   `json:"KVM"`
+		SOL         bool   `json:"SOL"`
+		IDER        bool   `json:"IDER"`
+		UserConsent string `json:"userConsent"`
+	}
+)

api/database/models/resourceAccess.go

@@ -0,0 +1,6 @@
+package models
+
+type (
+	// ResourceAccessLevel represents the level of control associated to a resource
+	ResourceAccessLevel int
+)

api/database/models/role.go

@@ -0,0 +1,20 @@
+package models
+
+type (
+	// Role represents a set of authorizations that can be associated to a user or
+	// to a team.
+	Role struct {
+		// Role Identifier
+		ID RoleID `json:"Id" example:"1"`
+		// Role name
+		Name string `json:"Name" example:"HelpDesk"`
+		// Role description
+		Description string `json:"Description" example:"Read-only access of all resources in an environment(endpoint)"`
+		// Authorizations associated to a role
+		Authorizations Authorizations `json:"Authorizations"`
+		Priority       int            `json:"Priority"`
+	}
+
+	// RoleID represents a role identifier
+	RoleID int
+)

api/database/models/settings.go

@@ -0,0 +1,118 @@
+package models
+
+const (
+	_ AuthenticationMethod = iota
+	// AuthenticationInternal represents the internal authentication method (authentication against Portainer API)
+	AuthenticationInternal
+	// AuthenticationLDAP represents the LDAP authentication method (authentication against a LDAP server)
+	AuthenticationLDAP
+	//AuthenticationOAuth represents the OAuth authentication method (authentication against a authorization server)
+	AuthenticationOAuth
+)
+
+type (
+
+	// AuthenticationMethod represents the authentication method used to authenticate a user
+	AuthenticationMethod int
+
+	// InternalAuthSettings represents settings used for the default 'internal' authentication
+	InternalAuthSettings struct {
+		RequiredPasswordLength int
+	}
+
+	// OAuthSettings represents the settings used to authorize with an authorization server
+	OAuthSettings struct {
+		ClientID             string `json:"ClientID"`
+		ClientSecret         string `json:"ClientSecret,omitempty"`
+		AccessTokenURI       string `json:"AccessTokenURI"`
+		AuthorizationURI     string `json:"AuthorizationURI"`
+		ResourceURI          string `json:"ResourceURI"`
+		RedirectURI          string `json:"RedirectURI"`
+		UserIdentifier       string `json:"UserIdentifier"`
+		Scopes               string `json:"Scopes"`
+		OAuthAutoCreateUsers bool   `json:"OAuthAutoCreateUsers"`
+		DefaultTeamID        TeamID `json:"DefaultTeamID"`
+		SSO                  bool   `json:"SSO"`
+		LogoutURI            string `json:"LogoutURI"`
+		KubeSecretKey        []byte `json:"KubeSecretKey"`
+	}
+
+	// Settings represents the application settings
+	Settings struct {
+		// URL to a logo that will be displayed on the login page as well as on top of the sidebar. Will use default Portainer logo when value is empty string
+		LogoURL string `json:"LogoURL" example:"https://mycompany.mydomain.tld/logo.png"`
+		// A list of label name & value that will be used to hide containers when querying containers
+		BlackListedLabels []Pair `json:"BlackListedLabels"`
+		// Active authentication method for the Portainer instance. Valid values are: 1 for internal, 2 for LDAP, or 3 for oauth
+		AuthenticationMethod AuthenticationMethod `json:"AuthenticationMethod" example:"1"`
+		InternalAuthSettings InternalAuthSettings `json:"InternalAuthSettings" example:""`
+		LDAPSettings         LDAPSettings         `json:"LDAPSettings" example:""`
+		OAuthSettings        OAuthSettings        `json:"OAuthSettings" example:""`
+		OpenAMTConfiguration OpenAMTConfiguration `json:"openAMTConfiguration" example:""`
+		FDOConfiguration     FDOConfiguration     `json:"fdoConfiguration" example:""`
+		FeatureFlagSettings  map[Feature]bool     `json:"FeatureFlagSettings" example:""`
+		// The interval in which environment(endpoint) snapshots are created
+		SnapshotInterval string `json:"SnapshotInterval" example:"5m"`
+		// URL to the templates that will be displayed in the UI when navigating to App Templates
+		TemplatesURL string `json:"TemplatesURL" example:"https://raw.githubusercontent.com/portainer/templates/master/templates.json"`
+		// The default check in interval for edge agent (in seconds)
+		EdgeAgentCheckinInterval int `json:"EdgeAgentCheckinInterval" example:"5"`
+		// Whether edge compute features are enabled
+		EnableEdgeComputeFeatures bool `json:"EnableEdgeComputeFeatures" example:""`
+		// The duration of a user session
+		UserSessionTimeout string `json:"UserSessionTimeout" example:"5m"`
+		// The expiry of a Kubeconfig
+		KubeconfigExpiry string `json:"KubeconfigExpiry" example:"24h"`
+		// Whether telemetry is enabled
+		EnableTelemetry bool `json:"EnableTelemetry" example:"false"`
+		// Helm repository URL, defaults to "https://charts.bitnami.com/bitnami"
+		HelmRepositoryURL string `json:"HelmRepositoryURL" example:"https://charts.bitnami.com/bitnami"`
+		// KubectlImage, defaults to portainer/kubectl-shell
+		KubectlShellImage string `json:"KubectlShellImage" example:"portainer/kubectl-shell"`
+		// TrustOnFirstConnect makes Portainer accepting edge agent connection by default
+		TrustOnFirstConnect bool `json:"TrustOnFirstConnect" example:"false"`
+		// EnforceEdgeID makes Portainer store the Edge ID instead of accepting anyone
+		EnforceEdgeID bool `json:"EnforceEdgeID" example:"false"`
+		// Container environment parameter AGENT_SECRET
+		AgentSecret string `json:"AgentSecret"`
+		// EdgePortainerURL is the URL that is exposed to edge agents
+		EdgePortainerURL string `json:"EdgePortainerUrl"`
+
+		Edge struct {
+			// The command list interval for edge agent - used in edge async mode (in seconds)
+			CommandInterval int `json:"CommandInterval" example:"5"`
+			// The ping interval for edge agent - used in edge async mode (in seconds)
+			PingInterval int `json:"PingInterval" example:"5"`
+			// The snapshot interval for edge agent - used in edge async mode (in seconds)
+			SnapshotInterval int `json:"SnapshotInterval" example:"5"`
+			// EdgeAsyncMode enables edge async mode by default
+			AsyncMode bool
+		}
+
+		// Deprecated fields
+		DisplayDonationHeader       bool
+		DisplayExternalContributors bool
+
+		// Deprecated fields v26
+		EnableHostManagementFeatures              bool `json:"EnableHostManagementFeatures"`
+		AllowVolumeBrowserForRegularUsers         bool `json:"AllowVolumeBrowserForRegularUsers"`
+		AllowBindMountsForRegularUsers            bool `json:"AllowBindMountsForRegularUsers"`
+		AllowPrivilegedModeForRegularUsers        bool `json:"AllowPrivilegedModeForRegularUsers"`
+		AllowHostNamespaceForRegularUsers         bool `json:"AllowHostNamespaceForRegularUsers"`
+		AllowStackManagementForRegularUsers       bool `json:"AllowStackManagementForRegularUsers"`
+		AllowDeviceMappingForRegularUsers         bool `json:"AllowDeviceMappingForRegularUsers"`
+		AllowContainerCapabilitiesForRegularUsers bool `json:"AllowContainerCapabilitiesForRegularUsers"`
+	}
+
+	/**
+	extras
+	*/
+	// Pair defines a key/value string pair
+	Pair struct {
+		Name  string `json:"name" example:"name"`
+		Value string `json:"value" example:"value"`
+	}
+
+	// Feature represents a feature that can be enabled or disabled via feature flags
+	Feature string
+)

api/database/models/team.go

@@ -0,0 +1,38 @@
+package models
+
+type (
+	// Team represents a list of user accounts
+	Team struct {
+		// Team Identifier
+		ID TeamID `json:"Id" example:"1"`
+		// Team name
+		Name string `json:"Name" example:"developers"`
+	}
+
+	// TeamAccessPolicies represent the association of an access policy and a team
+	TeamAccessPolicies map[TeamID]AccessPolicy
+
+	// TeamID represents a team identifier
+	TeamID int
+
+	// TeamMembership represents a membership association between a user and a team
+	TeamMembership struct {
+		// Membership Identifier
+		ID TeamMembershipID `json:"Id" example:"1"`
+		// User identifier
+		UserID UserID `json:"UserID" example:"1"`
+		// Team identifier
+		TeamID TeamID `json:"TeamID" example:"1"`
+		// Team role (1 for team leader and 2 for team member)
+		Role MembershipRole `json:"Role" example:"1"`
+	}
+
+	// TeamMembershipID represents a team membership identifier
+	TeamMembershipID int
+
+	// TeamResourceAccess represents the level of control on a resource for a specific team
+	TeamResourceAccess struct {
+		TeamID      TeamID              `json:"TeamId"`
+		AccessLevel ResourceAccessLevel `json:"AccessLevel"`
+	}
+)

api/database/models/tls.go

@@ -0,0 +1,17 @@
+package models
+
+type (
+	// TLSConfiguration represents a TLS configuration
+	TLSConfiguration struct {
+		// Use TLS
+		TLS bool `json:"TLS" example:"true"`
+		// Skip the verification of the server TLS certificate
+		TLSSkipVerify bool `json:"TLSSkipVerify" example:"false"`
+		// Path to the TLS CA certificate file
+		TLSCACertPath string `json:"TLSCACert,omitempty" example:"/data/tls/ca.pem"`
+		// Path to the TLS client certificate file
+		TLSCertPath string `json:"TLSCert,omitempty" example:"/data/tls/cert.pem"`
+		// Path to the TLS client key file
+		TLSKeyPath string `json:"TLSKey,omitempty" example:"/data/tls/key.pem"`
+	}
+)

api/database/models/user.go

@@ -0,0 +1,6 @@
+package models
+
+type (
+	// UserID represents a user identifier
+	UserID int
+)

api/database/models/version.go

@@ -0,0 +1,19 @@
+package models
+
+import "net/http"
+
+const (
+	VersionKey  string = "DB_VERSION"
+	InstanceKey string = "INSTANCE_ID"
+	EditionKey  string = "EDITION"
+	UpdatingKey string = "DB_UPDATING"
+)
+
+type Version struct {
+	Key   string `json:"Key"`
+	Value string `json:"Value"`
+}
+
+func (r *Version) Validate(request *http.Request) error {
+	return nil
+}

api/database/sqlite/db.go

@@ -0,0 +1,167 @@
+package sqlite
+
+import (
+	"errors"
+	"os"
+	"path"
+
+	"gorm.io/driver/sqlite"
+	"gorm.io/gorm"
+
+	"github.com/portainer/portainer/api/database/models"
+	"github.com/rs/zerolog/log"
+)
+
+const (
+	DatabaseFileName          = "portainer.db"
+	EncryptedDatabaseFileName = "portainer.edb"
+)
+
+var (
+	ErrHaveEncryptedAndUnencrypted = errors.New("Portainer has detected both an encrypted and un-encrypted database and cannot start.  Only one database should exist")
+	ErrHaveEncryptedWithNoKey      = errors.New("The portainer database is encrypted, but no secret was loaded")
+)
+
+type DbConnection struct {
+	Path          string
+	EncryptionKey []byte
+	isEncrypted   bool
+
+	*gorm.DB
+}
+
+func (connection *DbConnection) GetDB() *gorm.DB {
+	if connection.DB == nil {
+		err := connection.Open()
+		if err != nil {
+			panic(err)
+		}
+	}
+	return connection.DB
+}
+
+// GetDatabaseFileName get the database filename
+func (connection *DbConnection) GetDatabaseFileName() string {
+	if connection.IsEncryptedStore() {
+		return EncryptedDatabaseFileName
+	}
+
+	return DatabaseFileName
+}
+
+// GetDataseFilePath get the path + filename for the database file
+func (connection *DbConnection) GetDatabaseFilePath() string {
+	if connection.IsEncryptedStore() {
+		return path.Join(connection.Path, EncryptedDatabaseFileName)
+	}
+
+	return path.Join(connection.Path, DatabaseFileName)
+}
+
+// GetStorePath get the filename and path for the database file
+func (connection *DbConnection) GetStorePath() string {
+	return connection.Path
+}
+
+func (connection *DbConnection) SetEncrypted(flag bool) {
+	connection.isEncrypted = flag
+}
+
+// Return true if the database is encrypted
+func (connection *DbConnection) IsEncryptedStore() bool {
+	return connection.getEncryptionKey() != nil
+}
+
+// NeedsEncryptionMigration returns true if database encryption is enabled and
+// we have an un-encrypted DB that requires migration to an encrypted DB
+func (connection *DbConnection) NeedsEncryptionMigration() (bool, error) {
+
+	// Cases:  Note, we need to check both portainer.db and portainer.edb
+	// to determine if it's a new store.   We only need to differentiate between cases 2,3 and 5
+
+	// 1) portainer.edb + key     => False
+	// 2) portainer.edb + no key  => ERROR Fatal!
+	// 3) portainer.db  + key     => True  (needs migration)
+	// 4) portainer.db  + no key  => False
+	// 5) NoDB (new)    + key     => False
+	// 6) NoDB (new)    + no key  => False
+	// 7) portainer.db & portainer.edb => ERROR Fatal!
+
+	// If we have a loaded encryption key, always set encrypted
+	if connection.EncryptionKey != nil {
+		connection.SetEncrypted(true)
+	}
+
+	// Check for portainer.db
+	dbFile := path.Join(connection.Path, DatabaseFileName)
+	_, err := os.Stat(dbFile)
+	haveDbFile := err == nil
+
+	// Check for portainer.edb
+	edbFile := path.Join(connection.Path, EncryptedDatabaseFileName)
+	_, err = os.Stat(edbFile)
+	haveEdbFile := err == nil
+
+	if haveDbFile && haveEdbFile {
+		// 7 - encrypted and unencrypted db?
+		return false, ErrHaveEncryptedAndUnencrypted
+	}
+
+	if haveDbFile && connection.EncryptionKey != nil {
+		// 3 - needs migration
+		return true, nil
+	}
+
+	if haveEdbFile && connection.EncryptionKey == nil {
+		// 2 - encrypted db, but no key?
+		return false, ErrHaveEncryptedWithNoKey
+	}
+
+	// 1, 4, 5, 6
+	return false, nil
+}
+
+// Open opens and initializes the BoltDB database.
+func (connection *DbConnection) Open() error {
+
+	log.Info().Str("filename", connection.GetDatabaseFileName()).Msg("loading PortainerDB")
+
+	// Now we open the db
+	databasePath := connection.GetDatabaseFilePath()
+
+	db, err := gorm.Open(sqlite.Open(databasePath), &gorm.Config{})
+	if err != nil {
+		return err
+	}
+	sqlDB, err := db.DB()
+	if err != nil {
+		return err
+	}
+	sqlDB.SetMaxOpenConns(5)
+	sqlDB.SetMaxOpenConns(10)
+	connection.DB = db
+
+	return nil
+}
+
+func (connection *DbConnection) Close() error {
+	sqlDB, err := connection.DB.DB()
+	if err != nil {
+		return err
+	}
+	connection.DB = nil
+	return sqlDB.Close()
+}
+
+func (connection *DbConnection) getEncryptionKey() []byte {
+	if !connection.isEncrypted {
+		return nil
+	}
+
+	return connection.EncryptionKey
+}
+
+func (connection *DbConnection) Init() error {
+	connection.DB.AutoMigrate(&models.Version{})
+	return nil
+}

api/dataservices/apikeyrepository/apikeyrepository.go

@@ -1,13 +1,7 @@
 package apikeyrepository
 
 import (
-	"bytes"
-	"fmt"
-
 	portainer "github.com/portainer/portainer/api"
-	"github.com/portainer/portainer/api/dataservices/errors"
-
-	"github.com/rs/zerolog/log"
 )
 
 const (
@@ -22,10 +16,10 @@ type Service struct {
 
 // NewService creates a new instance of a service.
 func NewService(connection portainer.Connection) (*Service, error) {
-	err := connection.SetServiceName(BucketName)
-	if err != nil {
-		return nil, err
-	}
+	// err := connection.SetServiceName(BucketName)
+	// if err != nil {
+	// 	return nil, err
+	// }
 
 	return &Service{
 		connection: connection,
@@ -36,90 +30,93 @@ func NewService(connection portainer.Connection) (*Service, error) {
 func (service *Service) GetAPIKeysByUserID(userID portainer.UserID) ([]portainer.APIKey, error) {
 	var result = make([]portainer.APIKey, 0)
 
-	err := service.connection.GetAll(
-		BucketName,
-		&portainer.APIKey{},
-		func(obj interface{}) (interface{}, error) {
-			record, ok := obj.(*portainer.APIKey)
-			if !ok {
-				log.Debug().Str("obj", fmt.Sprintf("%#v", obj)).Msg("failed to convert to APIKey object")
-				return nil, fmt.Errorf("Failed to convert to APIKey object: %s", obj)
-			}
+	// err := service.connection.GetAll(
+	// 	BucketName,
+	// 	&portainer.APIKey{},
+	// 	func(obj interface{}) (interface{}, error) {
+	// 		record, ok := obj.(*portainer.APIKey)
+	// 		if !ok {
+	// 			log.Debug().Str("obj", fmt.Sprintf("%#v", obj)).Msg("failed to convert to APIKey object")
+	// 			return nil, fmt.Errorf("Failed to convert to APIKey object: %s", obj)
+	// 		}
 
-			if record.UserID == userID {
-				result = append(result, *record)
-			}
+	// 		if record.UserID == userID {
+	// 			result = append(result, *record)
+	// 		}
 
-			return &portainer.APIKey{}, nil
-		})
+	// 		return &portainer.APIKey{}, nil
+	// })
 
-	return result, err
+	return result, nil
 }
 
 // GetAPIKeyByDigest returns the API key for the associated digest.
 // Note: there is a 1-to-1 mapping of api-key and digest
 func (service *Service) GetAPIKeyByDigest(digest []byte) (*portainer.APIKey, error) {
-	var k *portainer.APIKey
-	stop := fmt.Errorf("ok")
-	err := service.connection.GetAll(
-		BucketName,
-		&portainer.APIKey{},
-		func(obj interface{}) (interface{}, error) {
-			key, ok := obj.(*portainer.APIKey)
-			if !ok {
-				log.Debug().Str("obj", fmt.Sprintf("%#v", obj)).Msg("failed to convert to APIKey object")
-				return nil, fmt.Errorf("Failed to convert to APIKey object: %s", obj)
-			}
-			if bytes.Equal(key.Digest, digest) {
-				k = key
-				return nil, stop
-			}
+	// var k *portainer.APIKey
+	// stop := fmt.Errorf("ok")
+	// err := service.connection.GetAll(
+	// 	BucketName,
+	// 	&portainer.APIKey{},
+	// 	func(obj interface{}) (interface{}, error) {
+	// 		key, ok := obj.(*portainer.APIKey)
+	// 		if !ok {
+	// 			log.Debug().Str("obj", fmt.Sprintf("%#v", obj)).Msg("failed to convert to APIKey object")
+	// 			return nil, fmt.Errorf("Failed to convert to APIKey object: %s", obj)
+	// 		}
+	// 		if bytes.Equal(key.Digest, digest) {
+	// 			k = key
+	// 			return nil, stop
+	// 		}
 
-			return &portainer.APIKey{}, nil
-		})
+	// 		return &portainer.APIKey{}, nil
+	// 	})
 
-	if err == stop {
-		return k, nil
-	}
+	// if err == stop {
+	// 	return k, nil
+	// }
 
-	if err == nil {
-		return nil, errors.ErrObjectNotFound
-	}
+	// if err == nil {
+	// 	return nil, errors.ErrObjectNotFound
+	// }
 
-	return nil, err
+	return nil, nil
 }
 
 // CreateAPIKey creates a new APIKey object.
 func (service *Service) CreateAPIKey(record *portainer.APIKey) error {
-	return service.connection.CreateObject(
-		BucketName,
-		func(id uint64) (int, interface{}) {
-			record.ID = portainer.APIKeyID(id)
+	// return service.connection.CreateObject(
+	// 	BucketName,
+	// 	func(id uint64) (int, interface{}) {
+	// 		record.ID = portainer.APIKeyID(id)
 
-			return int(record.ID), record
-		},
-	)
+	// 		return int(record.ID), record
+	// 	},
+	// )
+	return nil
 }
 
 // GetAPIKey retrieves an existing APIKey object by api key ID.
 func (service *Service) GetAPIKey(keyID portainer.APIKeyID) (*portainer.APIKey, error) {
 	var key portainer.APIKey
-	identifier := service.connection.ConvertToKey(int(keyID))
+	// identifier := service.connection.ConvertToKey(int(keyID))
 
-	err := service.connection.GetObject(BucketName, identifier, &key)
-	if err != nil {
-		return nil, err
-	}
+	// err := service.connection.GetObject(BucketName, identifier, &key)
+	// if err != nil {
+	// 	return nil, err
+	// }
 
 	return &key, nil
 }
 
 func (service *Service) UpdateAPIKey(key *portainer.APIKey) error {
-	identifier := service.connection.ConvertToKey(int(key.ID))
-	return service.connection.UpdateObject(BucketName, identifier, key)
+	// identifier := service.connection.ConvertToKey(int(key.ID))
+	// return service.connection.UpdateObject(BucketName, identifier, key)
+	return nil
 }
 
 func (service *Service) DeleteAPIKey(ID portainer.APIKeyID) error {
-	identifier := service.connection.ConvertToKey(int(ID))
-	return service.connection.DeleteObject(BucketName, identifier)
+	// identifier := service.connection.ConvertToKey(int(ID))
+	// return service.connection.DeleteObject(BucketName, identifier)
+	return nil
 }

api/dataservices/customtemplate/customtemplate.go

@@ -1,11 +1,7 @@
 package customtemplate
 
 import (
-	"fmt"
-
 	portainer "github.com/portainer/portainer/api"
-
-	"github.com/rs/zerolog/log"
 )
 
 const (
@@ -24,10 +20,10 @@ func (service *Service) BucketName() string {
 
 // NewService creates a new instance of a service.
 func NewService(connection portainer.Connection) (*Service, error) {
-	err := connection.SetServiceName(BucketName)
-	if err != nil {
-		return nil, err
-	}
+	// err := connection.SetServiceName(BucketName)
+	// if err != nil {
+	// 	return nil, err
+	// }
 
 	return &Service{
 		connection: connection,
@@ -38,56 +34,60 @@ func NewService(connection portainer.Connection) (*Service, error) {
 func (service *Service) CustomTemplates() ([]portainer.CustomTemplate, error) {
 	var customTemplates = make([]portainer.CustomTemplate, 0)
 
-	err := service.connection.GetAll(
-		BucketName,
-		&portainer.CustomTemplate{},
-		func(obj interface{}) (interface{}, error) {
-			//var tag portainer.Tag
-			customTemplate, ok := obj.(*portainer.CustomTemplate)
-			if !ok {
-				log.Debug().Str("obj", fmt.Sprintf("%#v", obj)).Msg("failed to convert to CustomTemplate object")
-				return nil, fmt.Errorf("Failed to convert to CustomTemplate object: %s", obj)
-			}
-			customTemplates = append(customTemplates, *customTemplate)
+	// err := service.connection.GetAll(
+	// 	BucketName,
+	// 	&portainer.CustomTemplate{},
+	// 	func(obj interface{}) (interface{}, error) {
+	// 		//var tag portainer.Tag
+	// 		customTemplate, ok := obj.(*portainer.CustomTemplate)
+	// 		if !ok {
+	// 			log.Debug().Str("obj", fmt.Sprintf("%#v", obj)).Msg("failed to convert to CustomTemplate object")
+	// 			return nil, fmt.Errorf("Failed to convert to CustomTemplate object: %s", obj)
+	// 		}
+	// 		customTemplates = append(customTemplates, *customTemplate)
 
-			return &portainer.CustomTemplate{}, nil
-		})
+	// 		return &portainer.CustomTemplate{}, nil
+	// 	})
 
-	return customTemplates, err
+	return customTemplates, nil
 }
 
 // CustomTemplate returns an custom template by ID.
 func (service *Service) CustomTemplate(ID portainer.CustomTemplateID) (*portainer.CustomTemplate, error) {
 	var customTemplate portainer.CustomTemplate
-	identifier := service.connection.ConvertToKey(int(ID))
+	// identifier := service.connection.ConvertToKey(int(ID))
 
-	err := service.connection.GetObject(BucketName, identifier, &customTemplate)
-	if err != nil {
-		return nil, err
-	}
+	// err := service.connection.GetObject(BucketName, identifier, &customTemplate)
+	// if err != nil {
+	// 	return nil, err
+	// }
 
 	return &customTemplate, nil
 }
 
 // UpdateCustomTemplate updates an custom template.
 func (service *Service) UpdateCustomTemplate(ID portainer.CustomTemplateID, customTemplate *portainer.CustomTemplate) error {
-	identifier := service.connection.ConvertToKey(int(ID))
-	return service.connection.UpdateObject(BucketName, identifier, customTemplate)
+	// identifier := service.connection.ConvertToKey(int(ID))
+	// return service.connection.UpdateObject(BucketName, identifier, customTemplate)
+	return nil
 }
 
 // DeleteCustomTemplate deletes an custom template.
 func (service *Service) DeleteCustomTemplate(ID portainer.CustomTemplateID) error {
-	identifier := service.connection.ConvertToKey(int(ID))
-	return service.connection.DeleteObject(BucketName, identifier)
+	// identifier := service.connection.ConvertToKey(int(ID))
+	// return service.connection.DeleteObject(BucketName, identifier)
+	return 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)
+	// return service.connection.CreateObjectWithId(BucketName, int(customTemplate.ID), customTemplate)
+	return nil
 }
 
 // GetNextIdentifier returns the next identifier for a custom template.
 func (service *Service) GetNextIdentifier() int {
-	return service.connection.GetNextIdentifier(BucketName)
+	// return service.connection.GetNextIdentifier(BucketName)
+	return 0
 }

api/dataservices/dockerhub/dockerhub.go

@@ -21,10 +21,10 @@ func (service *Service) BucketName() string {
 
 // NewService creates a new instance of a service.
 func NewService(connection portainer.Connection) (*Service, error) {
-	err := connection.SetServiceName(BucketName)
-	if err != nil {
-		return nil, err
-	}
+	// err := connection.SetServiceName(BucketName)
+	// if err != nil {
+	// 	return nil, err
+	// }
 
 	return &Service{
 		connection: connection,
@@ -35,15 +35,16 @@ func NewService(connection portainer.Connection) (*Service, error) {
 func (service *Service) DockerHub() (*portainer.DockerHub, error) {
 	var dockerhub portainer.DockerHub
 
-	err := service.connection.GetObject(BucketName, []byte(dockerHubKey), &dockerhub)
-	if err != nil {
-		return nil, err
-	}
+	// err := service.connection.GetObject(BucketName, []byte(dockerHubKey), &dockerhub)
+	// if err != nil {
+	// 	return nil, err
+	// }
 
 	return &dockerhub, nil
 }
 
 // UpdateDockerHub updates a DockerHub object.
 func (service *Service) UpdateDockerHub(dockerhub *portainer.DockerHub) error {
-	return service.connection.UpdateObject(BucketName, []byte(dockerHubKey), dockerhub)
+	// return service.connection.UpdateObject(BucketName, []byte(dockerHubKey), dockerhub)
+	return nil
 }

api/dataservices/edgegroup/edgegroup.go

@@ -1,11 +1,7 @@
 package edgegroup
 
 import (
-	"fmt"
-
 	portainer "github.com/portainer/portainer/api"
-
-	"github.com/rs/zerolog/log"
 )
 
 const (
@@ -24,10 +20,10 @@ func (service *Service) BucketName() string {
 
 // NewService creates a new instance of a service.
 func NewService(connection portainer.Connection) (*Service, error) {
-	err := connection.SetServiceName(BucketName)
-	if err != nil {
-		return nil, err
-	}
+	// err := connection.SetServiceName(BucketName)
+	// if err != nil {
+	// 	return nil, err
+	// }
 
 	return &Service{
 		connection: connection,
@@ -38,55 +34,58 @@ func NewService(connection portainer.Connection) (*Service, error) {
 func (service *Service) EdgeGroups() ([]portainer.EdgeGroup, error) {
 	var groups = make([]portainer.EdgeGroup, 0)
 
-	err := service.connection.GetAllWithJsoniter(
-		BucketName,
-		&portainer.EdgeGroup{},
-		func(obj interface{}) (interface{}, error) {
-			group, ok := obj.(*portainer.EdgeGroup)
-			if !ok {
-				log.Debug().Str("obj", fmt.Sprintf("%#v", obj)).Msg("failed to convert to EdgeGroup object")
-				return nil, fmt.Errorf("Failed to convert to EdgeGroup object: %s", obj)
-			}
-			groups = append(groups, *group)
+	// err := service.connection.GetAllWithJsoniter(
+	// 	BucketName,
+	// 	&portainer.EdgeGroup{},
+	// 	func(obj interface{}) (interface{}, error) {
+	// 		group, ok := obj.(*portainer.EdgeGroup)
+	// 		if !ok {
+	// 			log.Debug().Str("obj", fmt.Sprintf("%#v", obj)).Msg("failed to convert to EdgeGroup object")
+	// 			return nil, fmt.Errorf("Failed to convert to EdgeGroup object: %s", obj)
+	// 		}
+	// 		groups = append(groups, *group)
 
-			return &portainer.EdgeGroup{}, nil
-		})
+	// 		return &portainer.EdgeGroup{}, nil
+	// 	})
 
-	return groups, err
+	return groups, nil
 }
 
 // EdgeGroup returns an Edge group by ID.
 func (service *Service) EdgeGroup(ID portainer.EdgeGroupID) (*portainer.EdgeGroup, error) {
 	var group portainer.EdgeGroup
-	identifier := service.connection.ConvertToKey(int(ID))
+	// identifier := service.connection.ConvertToKey(int(ID))
 
-	err := service.connection.GetObject(BucketName, identifier, &group)
-	if err != nil {
-		return nil, err
-	}
+	// err := service.connection.GetObject(BucketName, identifier, &group)
+	// if err != nil {
+	// 	return nil, err
+	// }
 
 	return &group, nil
 }
 
 // UpdateEdgeGroup updates an Edge group.
 func (service *Service) UpdateEdgeGroup(ID portainer.EdgeGroupID, group *portainer.EdgeGroup) error {
-	identifier := service.connection.ConvertToKey(int(ID))
-	return service.connection.UpdateObject(BucketName, identifier, group)
+	// identifier := service.connection.ConvertToKey(int(ID))
+	// return service.connection.UpdateObject(BucketName, identifier, group)
+	return nil
 }
 
 // DeleteEdgeGroup deletes an Edge group.
 func (service *Service) DeleteEdgeGroup(ID portainer.EdgeGroupID) error {
-	identifier := service.connection.ConvertToKey(int(ID))
-	return service.connection.DeleteObject(BucketName, identifier)
+	// identifier := service.connection.ConvertToKey(int(ID))
+	// return service.connection.DeleteObject(BucketName, identifier)
+	return nil
 }
 
 // CreateEdgeGroup assign an ID to a new Edge group and saves it.
 func (service *Service) Create(group *portainer.EdgeGroup) error {
-	return service.connection.CreateObject(
-		BucketName,
-		func(id uint64) (int, interface{}) {
-			group.ID = portainer.EdgeGroupID(id)
-			return int(group.ID), group
-		},
-	)
+	// return service.connection.CreateObject(
+	// 	BucketName,
+	// 	func(id uint64) (int, interface{}) {
+	// 		group.ID = portainer.EdgeGroupID(id)
+	// 		return int(group.ID), group
+	// 	},
+	// )
+	return nil
 }

api/dataservices/edgejob/edgejob.go

@@ -1,11 +1,7 @@
 package edgejob
 
 import (
-	"fmt"
-
 	portainer "github.com/portainer/portainer/api"
-
-	"github.com/rs/zerolog/log"
 )
 
 const (
@@ -24,10 +20,10 @@ func (service *Service) BucketName() string {
 
 // NewService creates a new instance of a service.
 func NewService(connection portainer.Connection) (*Service, error) {
-	err := connection.SetServiceName(BucketName)
-	if err != nil {
-		return nil, err
-	}
+	// err := connection.SetServiceName(BucketName)
+	// if err != nil {
+	// 	return nil, err
+	// }
 
 	return &Service{
 		connection: connection,
@@ -38,61 +34,65 @@ func NewService(connection portainer.Connection) (*Service, error) {
 func (service *Service) EdgeJobs() ([]portainer.EdgeJob, error) {
 	var edgeJobs = make([]portainer.EdgeJob, 0)
 
-	err := service.connection.GetAll(
-		BucketName,
-		&portainer.EdgeJob{},
-		func(obj interface{}) (interface{}, error) {
-			job, ok := obj.(*portainer.EdgeJob)
-			if !ok {
-				log.Debug().Str("obj", fmt.Sprintf("%#v", obj)).Msg("failed to convert to EdgeJob object")
-				return nil, fmt.Errorf("Failed to convert to EdgeJob object: %s", obj)
-			}
+	// err := service.connection.GetAll(
+	// 	BucketName,
+	// 	&portainer.EdgeJob{},
+	// 	func(obj interface{}) (interface{}, error) {
+	// 		job, ok := obj.(*portainer.EdgeJob)
+	// 		if !ok {
+	// 			log.Debug().Str("obj", fmt.Sprintf("%#v", obj)).Msg("failed to convert to EdgeJob object")
+	// 			return nil, fmt.Errorf("Failed to convert to EdgeJob object: %s", obj)
+	// 		}
 
-			edgeJobs = append(edgeJobs, *job)
+	// 		edgeJobs = append(edgeJobs, *job)
 
-			return &portainer.EdgeJob{}, nil
-		})
+	// 		return &portainer.EdgeJob{}, nil
+	// 	})
 
-	return edgeJobs, err
+	return edgeJobs, nil
 }
 
 // EdgeJob returns an Edge job by ID
 func (service *Service) EdgeJob(ID portainer.EdgeJobID) (*portainer.EdgeJob, error) {
 	var edgeJob portainer.EdgeJob
-	identifier := service.connection.ConvertToKey(int(ID))
+	// identifier := service.connection.ConvertToKey(int(ID))
 
-	err := service.connection.GetObject(BucketName, identifier, &edgeJob)
-	if err != nil {
-		return nil, err
-	}
+	// err := service.connection.GetObject(BucketName, identifier, &edgeJob)
+	// if err != nil {
+	// 	return nil, err
+	// }
 
 	return &edgeJob, nil
 }
 
 // Create creates a new EdgeJob
 func (service *Service) Create(ID portainer.EdgeJobID, edgeJob *portainer.EdgeJob) error {
-	edgeJob.ID = ID
+	// edgeJob.ID = ID
 
-	return service.connection.CreateObjectWithId(
-		BucketName,
-		int(edgeJob.ID),
-		edgeJob,
-	)
+	// return service.connection.CreateObjectWithId(
+	// 	BucketName,
+	// 	int(edgeJob.ID),
+	// 	edgeJob,
+	// )
+	return nil
 }
 
 // UpdateEdgeJob updates an Edge job by ID
 func (service *Service) UpdateEdgeJob(ID portainer.EdgeJobID, edgeJob *portainer.EdgeJob) error {
-	identifier := service.connection.ConvertToKey(int(ID))
-	return service.connection.UpdateObject(BucketName, identifier, edgeJob)
+	// identifier := service.connection.ConvertToKey(int(ID))
+	// return service.connection.UpdateObject(BucketName, identifier, edgeJob)
+	return nil
 }
 
 // DeleteEdgeJob deletes an Edge job
 func (service *Service) DeleteEdgeJob(ID portainer.EdgeJobID) error {
-	identifier := service.connection.ConvertToKey(int(ID))
-	return service.connection.DeleteObject(BucketName, identifier)
+	// identifier := service.connection.ConvertToKey(int(ID))
+	// return service.connection.DeleteObject(BucketName, identifier)
+	return nil
 }
 
 // GetNextIdentifier returns the next identifier for an environment(endpoint).
 func (service *Service) GetNextIdentifier() int {
-	return service.connection.GetNextIdentifier(BucketName)
+	// return service.connection.GetNextIdentifier(BucketName)
+	return 0
 }

api/dataservices/edgestack/edgestack.go

@@ -1,11 +1,7 @@
 package edgestack
 
 import (
-	"fmt"
-
 	portainer "github.com/portainer/portainer/api"
-
-	"github.com/rs/zerolog/log"
 )
 
 const (
@@ -24,10 +20,10 @@ func (service *Service) BucketName() string {
 
 // NewService creates a new instance of a service.
 func NewService(connection portainer.Connection) (*Service, error) {
-	err := connection.SetServiceName(BucketName)
-	if err != nil {
-		return nil, err
-	}
+	// err := connection.SetServiceName(BucketName)
+	// if err != nil {
+	// 	return nil, err
+	// }
 
 	return &Service{
 		connection: connection,
@@ -38,34 +34,34 @@ func NewService(connection portainer.Connection) (*Service, error) {
 func (service *Service) EdgeStacks() ([]portainer.EdgeStack, error) {
 	var stacks = make([]portainer.EdgeStack, 0)
 
-	err := service.connection.GetAll(
-		BucketName,
-		&portainer.EdgeStack{},
-		func(obj interface{}) (interface{}, error) {
-			//var tag portainer.Tag
-			stack, ok := obj.(*portainer.EdgeStack)
-			if !ok {
-				log.Debug().Str("obj", fmt.Sprintf("%#v", obj)).Msg("failed to convert to EdgeStack object")
-				return nil, fmt.Errorf("Failed to convert to EdgeStack object: %s", obj)
-			}
+	// err := service.connection.GetAll(
+	// 	BucketName,
+	// 	&portainer.EdgeStack{},
+	// 	func(obj interface{}) (interface{}, error) {
+	// 		//var tag portainer.Tag
+	// 		stack, ok := obj.(*portainer.EdgeStack)
+	// 		if !ok {
+	// 			log.Debug().Str("obj", fmt.Sprintf("%#v", obj)).Msg("failed to convert to EdgeStack object")
+	// 			return nil, fmt.Errorf("Failed to convert to EdgeStack object: %s", obj)
+	// 		}
 
-			stacks = append(stacks, *stack)
+	// 		stacks = append(stacks, *stack)
 
-			return &portainer.EdgeStack{}, nil
-		})
+	// 		return &portainer.EdgeStack{}, nil
+	// 	})
 
-	return stacks, err
+	return stacks, nil
 }
 
 // EdgeStack returns an Edge stack by ID.
 func (service *Service) EdgeStack(ID portainer.EdgeStackID) (*portainer.EdgeStack, error) {
 	var stack portainer.EdgeStack
-	identifier := service.connection.ConvertToKey(int(ID))
+	// identifier := service.connection.ConvertToKey(int(ID))
 
-	err := service.connection.GetObject(BucketName, identifier, &stack)
-	if err != nil {
-		return nil, err
-	}
+	// err := service.connection.GetObject(BucketName, identifier, &stack)
+	// if err != nil {
+	// 	return nil, err
+	// }
 
 	return &stack, nil
 }
@@ -73,28 +69,32 @@ func (service *Service) EdgeStack(ID portainer.EdgeStackID) (*portainer.EdgeStac
 // CreateEdgeStack saves an Edge stack object to db.
 func (service *Service) Create(id portainer.EdgeStackID, edgeStack *portainer.EdgeStack) error {
 
-	edgeStack.ID = id
+	// edgeStack.ID = id
 
-	return service.connection.CreateObjectWithId(
-		BucketName,
-		int(edgeStack.ID),
-		edgeStack,
-	)
+	// return service.connection.CreateObjectWithId(
+	// 	BucketName,
+	// 	int(edgeStack.ID),
+	// 	edgeStack,
+	// )
+	return nil
 }
 
 // UpdateEdgeStack updates an Edge stack.
 func (service *Service) UpdateEdgeStack(ID portainer.EdgeStackID, edgeStack *portainer.EdgeStack) error {
-	identifier := service.connection.ConvertToKey(int(ID))
-	return service.connection.UpdateObject(BucketName, identifier, edgeStack)
+	// identifier := service.connection.ConvertToKey(int(ID))
+	// return service.connection.UpdateObject(BucketName, identifier, edgeStack)
+	return nil
 }
 
 // DeleteEdgeStack deletes an Edge stack.
 func (service *Service) DeleteEdgeStack(ID portainer.EdgeStackID) error {
-	identifier := service.connection.ConvertToKey(int(ID))
-	return service.connection.DeleteObject(BucketName, identifier)
+	// identifier := service.connection.ConvertToKey(int(ID))
+	// return service.connection.DeleteObject(BucketName, identifier)
+	return nil
 }
 
 // GetNextIdentifier returns the next identifier for an environment(endpoint).
 func (service *Service) GetNextIdentifier() int {
-	return service.connection.GetNextIdentifier(BucketName)
+	// return service.connection.GetNextIdentifier(BucketName)
+	return 0
 }

api/dataservices/edgeupdateschedule/edgeupdateschedule.go

@@ -1,14 +1,12 @@
 package edgeupdateschedule
 
 import (
-	"fmt"
 	"sync"
 
 	portainer "github.com/portainer/portainer/api"
 	"github.com/portainer/portainer/api/edgetypes"
 
 	"github.com/pkg/errors"
-	"github.com/rs/zerolog/log"
 )
 
 const (
@@ -30,10 +28,10 @@ func (service *Service) BucketName() string {
 
 // NewService creates a new instance of a service.
 func NewService(connection portainer.Connection) (*Service, error) {
-	err := connection.SetServiceName(BucketName)
-	if err != nil {
-		return nil, err
-	}
+	// err := connection.SetServiceName(BucketName)
+	// if err != nil {
+	// 	return nil, err
+	// }
 
 	service := &Service{
 		connection: connection,
@@ -79,59 +77,59 @@ func (service *Service) ActiveSchedules(environmentsIDs []portainer.EndpointID)
 func (service *Service) List() ([]edgetypes.UpdateSchedule, error) {
 	var list = make([]edgetypes.UpdateSchedule, 0)
 
-	err := service.connection.GetAll(
-		BucketName,
-		&edgetypes.UpdateSchedule{},
-		func(obj interface{}) (interface{}, error) {
-			item, ok := obj.(*edgetypes.UpdateSchedule)
-			if !ok {
-				log.Debug().Str("obj", fmt.Sprintf("%#v", obj)).Msg("failed to convert to EdgeUpdateSchedule object")
-				return nil, fmt.Errorf("Failed to convert to EdgeUpdateSchedule object: %s", obj)
-			}
-			list = append(list, *item)
-			return &edgetypes.UpdateSchedule{}, nil
-		})
+	// err := service.connection.GetAll(
+	// 	BucketName,
+	// 	&edgetypes.UpdateSchedule{},
+	// 	func(obj interface{}) (interface{}, error) {
+	// 		item, ok := obj.(*edgetypes.UpdateSchedule)
+	// 		if !ok {
+	// 			log.Debug().Str("obj", fmt.Sprintf("%#v", obj)).Msg("failed to convert to EdgeUpdateSchedule object")
+	// 			return nil, fmt.Errorf("Failed to convert to EdgeUpdateSchedule object: %s", obj)
+	// 		}
+	// 		list = append(list, *item)
+	// 		return &edgetypes.UpdateSchedule{}, nil
+	// 	})
 
-	return list, err
+	return list, nil
 }
 
 // Item returns a item by ID.
 func (service *Service) Item(ID edgetypes.UpdateScheduleID) (*edgetypes.UpdateSchedule, error) {
 	var item edgetypes.UpdateSchedule
-	identifier := service.connection.ConvertToKey(int(ID))
+	// identifier := service.connection.ConvertToKey(int(ID))
 
-	err := service.connection.GetObject(BucketName, identifier, &item)
-	if err != nil {
-		return nil, err
-	}
+	// err := service.connection.GetObject(BucketName, identifier, &item)
+	// if err != nil {
+	// 	return nil, err
+	// }
 
 	return &item, nil
 }
 
 // Create assign an ID to a new object and saves it.
 func (service *Service) Create(item *edgetypes.UpdateSchedule) error {
-	err := service.connection.CreateObject(
-		BucketName,
-		func(id uint64) (int, interface{}) {
-			item.ID = edgetypes.UpdateScheduleID(id)
-			return int(item.ID), item
-		},
-	)
+	// err := service.connection.CreateObject(
+	// 	BucketName,
+	// 	func(id uint64) (int, interface{}) {
+	// 		item.ID = edgetypes.UpdateScheduleID(id)
+	// 		return int(item.ID), item
+	// 	},
+	// )
 
-	if err != nil {
-		return err
-	}
+	// if err != nil {
+	// 	return err
+	// }
 
 	return service.setRelation(item)
 }
 
 // Update updates an item.
 func (service *Service) Update(id edgetypes.UpdateScheduleID, item *edgetypes.UpdateSchedule) error {
-	identifier := service.connection.ConvertToKey(int(id))
-	err := service.connection.UpdateObject(BucketName, identifier, item)
-	if err != nil {
-		return err
-	}
+	// identifier := service.connection.ConvertToKey(int(id))
+	// err := service.connection.UpdateObject(BucketName, identifier, item)
+	// if err != nil {
+	// 	return err
+	// }
 
 	service.cleanRelation(id)
 
@@ -143,8 +141,9 @@ func (service *Service) Delete(id edgetypes.UpdateScheduleID) error {
 
 	service.cleanRelation(id)
 
-	identifier := service.connection.ConvertToKey(int(id))
-	return service.connection.DeleteObject(BucketName, identifier)
+	// identifier := service.connection.ConvertToKey(int(id))
+	// return service.connection.DeleteObject(BucketName, identifier)
+	return nil
 }
 
 func (service *Service) cleanRelation(id edgetypes.UpdateScheduleID) {

api/dataservices/endpoint/endpoint.go

@@ -1,11 +1,7 @@
 package endpoint
 
 import (
-	"fmt"
-
 	portainer "github.com/portainer/portainer/api"
-
-	"github.com/rs/zerolog/log"
 )
 
 const (
@@ -24,10 +20,10 @@ func (service *Service) BucketName() string {
 
 // NewService creates a new instance of a service.
 func NewService(connection portainer.Connection) (*Service, error) {
-	err := connection.SetServiceName(BucketName)
-	if err != nil {
-		return nil, err
-	}
+	// err := connection.SetServiceName(BucketName)
+	// if err != nil {
+	// 	return nil, err
+	// }
 
 	return &Service{
 		connection: connection,
@@ -37,56 +33,60 @@ func NewService(connection portainer.Connection) (*Service, error) {
 // Endpoint returns an environment(endpoint) by ID.
 func (service *Service) Endpoint(ID portainer.EndpointID) (*portainer.Endpoint, error) {
 	var endpoint portainer.Endpoint
-	identifier := service.connection.ConvertToKey(int(ID))
+	// identifier := service.connection.ConvertToKey(int(ID))
 
-	err := service.connection.GetObject(BucketName, identifier, &endpoint)
-	if err != nil {
-		return nil, err
-	}
+	// err := service.connection.GetObject(BucketName, identifier, &endpoint)
+	// if err != nil {
+	// 	return nil, err
+	// }
 
 	return &endpoint, nil
 }
 
 // UpdateEndpoint updates an environment(endpoint).
 func (service *Service) UpdateEndpoint(ID portainer.EndpointID, endpoint *portainer.Endpoint) error {
-	identifier := service.connection.ConvertToKey(int(ID))
-	return service.connection.UpdateObject(BucketName, identifier, endpoint)
+	// identifier := service.connection.ConvertToKey(int(ID))
+	// return service.connection.UpdateObject(BucketName, identifier, endpoint)
+	return nil
 }
 
 // DeleteEndpoint deletes an environment(endpoint).
 func (service *Service) DeleteEndpoint(ID portainer.EndpointID) error {
-	identifier := service.connection.ConvertToKey(int(ID))
-	return service.connection.DeleteObject(BucketName, identifier)
+	// identifier := service.connection.ConvertToKey(int(ID))
+	// return service.connection.DeleteObject(BucketName, identifier)
+	return nil
 }
 
 // Endpoints return an array containing all the environments(endpoints).
 func (service *Service) Endpoints() ([]portainer.Endpoint, error) {
 	var endpoints = make([]portainer.Endpoint, 0)
 
-	err := service.connection.GetAllWithJsoniter(
-		BucketName,
-		&portainer.Endpoint{},
-		func(obj interface{}) (interface{}, error) {
-			endpoint, ok := obj.(*portainer.Endpoint)
-			if !ok {
-				log.Debug().Str("obj", fmt.Sprintf("%#v", obj)).Msg("failed to convert to Endpoint object")
-				return nil, fmt.Errorf("failed to convert to Endpoint object: %s", obj)
-			}
+	// err := service.connection.GetAllWithJsoniter(
+	// 	BucketName,
+	// 	&portainer.Endpoint{},
+	// 	func(obj interface{}) (interface{}, error) {
+	// 		endpoint, ok := obj.(*portainer.Endpoint)
+	// 		if !ok {
+	// 			log.Debug().Str("obj", fmt.Sprintf("%#v", obj)).Msg("failed to convert to Endpoint object")
+	// 			return nil, fmt.Errorf("failed to convert to Endpoint object: %s", obj)
+	// 		}
 
-			endpoints = append(endpoints, *endpoint)
+	// 		endpoints = append(endpoints, *endpoint)
 
-			return &portainer.Endpoint{}, nil
-		})
+	// 		return &portainer.Endpoint{}, nil
+	// 	})
 
-	return endpoints, err
+	return endpoints, nil
 }
 
 // CreateEndpoint assign an ID to a new environment(endpoint) and saves it.
 func (service *Service) Create(endpoint *portainer.Endpoint) error {
-	return service.connection.CreateObjectWithId(BucketName, int(endpoint.ID), endpoint)
+	// return service.connection.CreateObjectWithId(BucketName, int(endpoint.ID), endpoint)
+	return nil
 }
 
 // GetNextIdentifier returns the next identifier for an environment(endpoint).
 func (service *Service) GetNextIdentifier() int {
-	return service.connection.GetNextIdentifier(BucketName)
+	// return service.connection.GetNextIdentifier(BucketName)
+	return 0
 }

api/dataservices/endpointgroup/endpointgroup.go

@@ -1,11 +1,7 @@
 package endpointgroup
 
 import (
-	"fmt"
-
 	portainer "github.com/portainer/portainer/api"
-
-	"github.com/rs/zerolog/log"
 )
 
 const (
@@ -24,10 +20,10 @@ func (service *Service) BucketName() string {
 
 // NewService creates a new instance of a service.
 func NewService(connection portainer.Connection) (*Service, error) {
-	err := connection.SetServiceName(BucketName)
-	if err != nil {
-		return nil, err
-	}
+	// err := connection.SetServiceName(BucketName)
+	// if err != nil {
+	// 	return nil, err
+	// }
 
 	return &Service{
 		connection: connection,
@@ -37,57 +33,60 @@ func NewService(connection portainer.Connection) (*Service, error) {
 // EndpointGroup returns an environment(endpoint) group by ID.
 func (service *Service) EndpointGroup(ID portainer.EndpointGroupID) (*portainer.EndpointGroup, error) {
 	var endpointGroup portainer.EndpointGroup
-	identifier := service.connection.ConvertToKey(int(ID))
+	// identifier := service.connection.ConvertToKey(int(ID))
 
-	err := service.connection.GetObject(BucketName, identifier, &endpointGroup)
-	if err != nil {
-		return nil, err
-	}
+	// err := service.connection.GetObject(BucketName, identifier, &endpointGroup)
+	// if err != nil {
+	// 	return nil, err
+	// }
 
 	return &endpointGroup, nil
 }
 
 // UpdateEndpointGroup updates an environment(endpoint) group.
 func (service *Service) UpdateEndpointGroup(ID portainer.EndpointGroupID, endpointGroup *portainer.EndpointGroup) error {
-	identifier := service.connection.ConvertToKey(int(ID))
-	return service.connection.UpdateObject(BucketName, identifier, endpointGroup)
+	// identifier := service.connection.ConvertToKey(int(ID))
+	// return service.connection.UpdateObject(BucketName, identifier, endpointGroup)
+	return nil
 }
 
 // DeleteEndpointGroup deletes an environment(endpoint) group.
 func (service *Service) DeleteEndpointGroup(ID portainer.EndpointGroupID) error {
-	identifier := service.connection.ConvertToKey(int(ID))
-	return service.connection.DeleteObject(BucketName, identifier)
+	// identifier := service.connection.ConvertToKey(int(ID))
+	// return service.connection.DeleteObject(BucketName, identifier)
+	return nil
 }
 
 // EndpointGroups return an array containing all the environment(endpoint) groups.
 func (service *Service) EndpointGroups() ([]portainer.EndpointGroup, error) {
 	var endpointGroups = make([]portainer.EndpointGroup, 0)
 
-	err := service.connection.GetAll(
-		BucketName,
-		&portainer.EndpointGroup{},
-		func(obj interface{}) (interface{}, error) {
-			endpointGroup, ok := obj.(*portainer.EndpointGroup)
-			if !ok {
-				log.Debug().Str("obj", fmt.Sprintf("%#v", obj)).Msg("failed to convert to EndpointGroup object")
-				return nil, fmt.Errorf("Failed to convert to EndpointGroup object: %s", obj)
-			}
+	// err := service.connection.GetAll(
+	// 	BucketName,
+	// 	&portainer.EndpointGroup{},
+	// 	func(obj interface{}) (interface{}, error) {
+	// 		endpointGroup, ok := obj.(*portainer.EndpointGroup)
+	// 		if !ok {
+	// 			log.Debug().Str("obj", fmt.Sprintf("%#v", obj)).Msg("failed to convert to EndpointGroup object")
+	// 			return nil, fmt.Errorf("Failed to convert to EndpointGroup object: %s", obj)
+	// 		}
 
-			endpointGroups = append(endpointGroups, *endpointGroup)
+	// 		endpointGroups = append(endpointGroups, *endpointGroup)
 
-			return &portainer.EndpointGroup{}, nil
-		})
+	// 		return &portainer.EndpointGroup{}, nil
+	// 	})
 
-	return endpointGroups, err
+	return endpointGroups, nil
 }
 
 // CreateEndpointGroup assign an ID to a new environment(endpoint) group and saves it.
 func (service *Service) Create(endpointGroup *portainer.EndpointGroup) error {
-	return service.connection.CreateObject(
-		BucketName,
-		func(id uint64) (int, interface{}) {
-			endpointGroup.ID = portainer.EndpointGroupID(id)
-			return int(endpointGroup.ID), endpointGroup
-		},
-	)
+	// return service.connection.CreateObject(
+	// 	BucketName,
+	// 	func(id uint64) (int, interface{}) {
+	// 		endpointGroup.ID = portainer.EndpointGroupID(id)
+	// 		return int(endpointGroup.ID), endpointGroup
+	// 	},
+	// )
+	return nil
 }

api/dataservices/endpointrelation/endpointrelation.go

@@ -1,11 +1,7 @@
 package endpointrelation
 
 import (
-	"fmt"
-
 	portainer "github.com/portainer/portainer/api"
-
-	"github.com/rs/zerolog/log"
 )
 
 const (
@@ -24,10 +20,10 @@ func (service *Service) BucketName() string {
 
 // NewService creates a new instance of a service.
 func NewService(connection portainer.Connection) (*Service, error) {
-	err := connection.SetServiceName(BucketName)
-	if err != nil {
-		return nil, err
-	}
+	// err := connection.SetServiceName(BucketName)
+	// if err != nil {
+	// 	return nil, err
+	// }
 
 	return &Service{
 		connection: connection,
@@ -38,50 +34,53 @@ func NewService(connection portainer.Connection) (*Service, error) {
 func (service *Service) EndpointRelations() ([]portainer.EndpointRelation, error) {
 	var all = make([]portainer.EndpointRelation, 0)
 
-	err := service.connection.GetAll(
-		BucketName,
-		&portainer.EndpointRelation{},
-		func(obj interface{}) (interface{}, error) {
-			r, ok := obj.(*portainer.EndpointRelation)
-			if !ok {
-				log.Debug().Str("obj", fmt.Sprintf("%#v", obj)).Msg("failed to convert to EndpointRelation object")
-				return nil, fmt.Errorf("Failed to convert to EndpointRelation object: %s", obj)
-			}
+	// err := service.connection.GetAll(
+	// 	BucketName,
+	// 	&portainer.EndpointRelation{},
+	// 	func(obj interface{}) (interface{}, error) {
+	// 		r, ok := obj.(*portainer.EndpointRelation)
+	// 		if !ok {
+	// 			log.Debug().Str("obj", fmt.Sprintf("%#v", obj)).Msg("failed to convert to EndpointRelation object")
+	// 			return nil, fmt.Errorf("Failed to convert to EndpointRelation object: %s", obj)
+	// 		}
 
-			all = append(all, *r)
+	// 		all = append(all, *r)
 
-			return &portainer.EndpointRelation{}, nil
-		})
+	// 		return &portainer.EndpointRelation{}, nil
+	// 	})
 
-	return all, err
+	return all, nil
 }
 
 // EndpointRelation returns a Environment(Endpoint) relation object by EndpointID
 func (service *Service) EndpointRelation(endpointID portainer.EndpointID) (*portainer.EndpointRelation, error) {
 	var endpointRelation portainer.EndpointRelation
-	identifier := service.connection.ConvertToKey(int(endpointID))
+	// identifier := service.connection.ConvertToKey(int(endpointID))
 
-	err := service.connection.GetObject(BucketName, identifier, &endpointRelation)
-	if err != nil {
-		return nil, err
-	}
+	// err := service.connection.GetObject(BucketName, identifier, &endpointRelation)
+	// if err != nil {
+	// 	return nil, err
+	// }
 
 	return &endpointRelation, nil
 }
 
 // CreateEndpointRelation saves endpointRelation
 func (service *Service) Create(endpointRelation *portainer.EndpointRelation) error {
-	return service.connection.CreateObjectWithId(BucketName, int(endpointRelation.EndpointID), endpointRelation)
+	// return service.connection.CreateObjectWithId(BucketName, int(endpointRelation.EndpointID), endpointRelation)
+	return nil
 }
 
 // UpdateEndpointRelation updates an Environment(Endpoint) relation object
 func (service *Service) UpdateEndpointRelation(EndpointID portainer.EndpointID, endpointRelation *portainer.EndpointRelation) error {
-	identifier := service.connection.ConvertToKey(int(EndpointID))
-	return service.connection.UpdateObject(BucketName, identifier, endpointRelation)
+	// identifier := service.connection.ConvertToKey(int(EndpointID))
+	// return service.connection.UpdateObject(BucketName, identifier, endpointRelation)
+	return nil
 }
 
 // DeleteEndpointRelation deletes an Environment(Endpoint) relation object
 func (service *Service) DeleteEndpointRelation(EndpointID portainer.EndpointID) error {
-	identifier := service.connection.ConvertToKey(int(EndpointID))
-	return service.connection.DeleteObject(BucketName, identifier)
+	// identifier := service.connection.ConvertToKey(int(EndpointID))
+	// return service.connection.DeleteObject(BucketName, identifier)
+	return nil
 }

api/dataservices/extension/extension.go

@@ -1,11 +1,7 @@
 package extension
 
 import (
-	"fmt"
-
 	portainer "github.com/portainer/portainer/api"
-
-	"github.com/rs/zerolog/log"
 )
 
 const (
@@ -24,10 +20,10 @@ func (service *Service) BucketName() string {
 
 // NewService creates a new instance of a service.
 func NewService(connection portainer.Connection) (*Service, error) {
-	err := connection.SetServiceName(BucketName)
-	if err != nil {
-		return nil, err
-	}
+	// err := connection.SetServiceName(BucketName)
+	// if err != nil {
+	// 	return nil, err
+	// }
 
 	return &Service{
 		connection: connection,
@@ -37,12 +33,12 @@ func NewService(connection portainer.Connection) (*Service, error) {
 // Extension returns a extension by ID
 func (service *Service) Extension(ID portainer.ExtensionID) (*portainer.Extension, error) {
 	var extension portainer.Extension
-	identifier := service.connection.ConvertToKey(int(ID))
+	// identifier := service.connection.ConvertToKey(int(ID))
 
-	err := service.connection.GetObject(BucketName, identifier, &extension)
-	if err != nil {
-		return nil, err
-	}
+	// err := service.connection.GetObject(BucketName, identifier, &extension)
+	// if err != nil {
+	// 	return nil, err
+	// }
 
 	return &extension, nil
 }
@@ -51,31 +47,33 @@ func (service *Service) Extension(ID portainer.ExtensionID) (*portainer.Extensio
 func (service *Service) Extensions() ([]portainer.Extension, error) {
 	var extensions = make([]portainer.Extension, 0)
 
-	err := service.connection.GetAll(
-		BucketName,
-		&portainer.Extension{},
-		func(obj interface{}) (interface{}, error) {
-			extension, ok := obj.(*portainer.Extension)
-			if !ok {
-				log.Debug().Str("obj", fmt.Sprintf("%#v", obj)).Msg("failed to convert to Extension object")
-				return nil, fmt.Errorf("Failed to convert to Extension object: %s", obj)
-			}
+	// err := service.connection.GetAll(
+	// 	BucketName,
+	// 	&portainer.Extension{},
+	// 	func(obj interface{}) (interface{}, error) {
+	// 		extension, ok := obj.(*portainer.Extension)
+	// 		if !ok {
+	// 			log.Debug().Str("obj", fmt.Sprintf("%#v", obj)).Msg("failed to convert to Extension object")
+	// 			return nil, fmt.Errorf("Failed to convert to Extension object: %s", obj)
+	// 		}
 
-			extensions = append(extensions, *extension)
+	// 		extensions = append(extensions, *extension)
 
-			return &portainer.Extension{}, nil
-		})
+	// 		return &portainer.Extension{}, nil
+	// 	})
 
-	return extensions, err
+	return extensions, nil
 }
 
 // Persist persists a extension inside the database.
 func (service *Service) Persist(extension *portainer.Extension) error {
-	return service.connection.CreateObjectWithId(BucketName, int(extension.ID), extension)
+	// return service.connection.CreateObjectWithId(BucketName, int(extension.ID), extension)
+	return nil
 }
 
 // DeleteExtension deletes a Extension.
 func (service *Service) DeleteExtension(ID portainer.ExtensionID) error {
-	identifier := service.connection.ConvertToKey(int(ID))
-	return service.connection.DeleteObject(BucketName, identifier)
+	// identifier := service.connection.ConvertToKey(int(ID))
+	// return service.connection.DeleteObject(BucketName, identifier)
+	return nil
 }

api/dataservices/fdoprofile/fdoprofile.go

@@ -1,11 +1,7 @@
 package fdoprofile
 
 import (
-	"fmt"
-
 	portainer "github.com/portainer/portainer/api"
-
-	"github.com/rs/zerolog/log"
 )
 
 const (
@@ -24,10 +20,10 @@ func (service *Service) BucketName() string {
 
 // NewService creates a new instance of a service.
 func NewService(connection portainer.Connection) (*Service, error) {
-	err := connection.SetServiceName(BucketName)
-	if err != nil {
-		return nil, err
-	}
+	// err := connection.SetServiceName(BucketName)
+	// if err != nil {
+	// 	return nil, err
+	// }
 
 	return &Service{
 		connection: connection,
@@ -38,58 +34,62 @@ func NewService(connection portainer.Connection) (*Service, error) {
 func (service *Service) FDOProfiles() ([]portainer.FDOProfile, error) {
 	var fdoProfiles = make([]portainer.FDOProfile, 0)
 
-	err := service.connection.GetAll(
-		BucketName,
-		&portainer.FDOProfile{},
-		func(obj interface{}) (interface{}, error) {
-			fdoProfile, ok := obj.(*portainer.FDOProfile)
-			if !ok {
-				log.Debug().Str("obj", fmt.Sprintf("%#v", obj)).Msg("failed to convert to FDOProfile object")
+	// err := service.connection.GetAll(
+	// 	BucketName,
+	// 	&portainer.FDOProfile{},
+	// 	func(obj interface{}) (interface{}, error) {
+	// 		fdoProfile, ok := obj.(*portainer.FDOProfile)
+	// 		if !ok {
+	// 			log.Debug().Str("obj", fmt.Sprintf("%#v", obj)).Msg("failed to convert to FDOProfile object")
 
-				return nil, fmt.Errorf("Failed to convert to FDOProfile object: %s", obj)
-			}
-			fdoProfiles = append(fdoProfiles, *fdoProfile)
-			return &portainer.FDOProfile{}, nil
-		})
+	// 			return nil, fmt.Errorf("Failed to convert to FDOProfile object: %s", obj)
+	// 		}
+	// 		fdoProfiles = append(fdoProfiles, *fdoProfile)
+	// 		return &portainer.FDOProfile{}, nil
+	// 	})
 
-	return fdoProfiles, err
+	return fdoProfiles, nil
 }
 
 // FDOProfile returns an FDO Profile by ID.
 func (service *Service) FDOProfile(ID portainer.FDOProfileID) (*portainer.FDOProfile, error) {
 	var FDOProfile portainer.FDOProfile
-	identifier := service.connection.ConvertToKey(int(ID))
+	// identifier := service.connection.ConvertToKey(int(ID))
 
-	err := service.connection.GetObject(BucketName, identifier, &FDOProfile)
-	if err != nil {
-		return nil, err
-	}
+	// err := service.connection.GetObject(BucketName, identifier, &FDOProfile)
+	// if err != nil {
+	// 	return nil, err
+	// }
 
 	return &FDOProfile, nil
 }
 
 // Create assign an ID to a new FDO Profile and saves it.
 func (service *Service) Create(FDOProfile *portainer.FDOProfile) error {
-	return service.connection.CreateObjectWithId(
-		BucketName,
-		int(FDOProfile.ID),
-		FDOProfile,
-	)
+	// return service.connection.CreateObjectWithId(
+	// 	BucketName,
+	// 	int(FDOProfile.ID),
+	// 	FDOProfile,
+	// )
+	return nil
 }
 
 // Update updates an FDO Profile.
 func (service *Service) Update(ID portainer.FDOProfileID, FDOProfile *portainer.FDOProfile) error {
-	identifier := service.connection.ConvertToKey(int(ID))
-	return service.connection.UpdateObject(BucketName, identifier, FDOProfile)
+	// identifier := service.connection.ConvertToKey(int(ID))
+	// return service.connection.UpdateObject(BucketName, identifier, FDOProfile)
+	return nil
 }
 
 // Delete deletes an FDO Profile.
 func (service *Service) Delete(ID portainer.FDOProfileID) error {
-	identifier := service.connection.ConvertToKey(int(ID))
-	return service.connection.DeleteObject(BucketName, identifier)
+	// identifier := service.connection.ConvertToKey(int(ID))
+	// return service.connection.DeleteObject(BucketName, identifier)
+	return nil
 }
 
 // GetNextIdentifier returns the next identifier for a FDO Profile.
 func (service *Service) GetNextIdentifier() int {
-	return service.connection.GetNextIdentifier(BucketName)
+	// return service.connection.GetNextIdentifier(BucketName)
+	return 0
 }

api/dataservices/helmuserrepository/helmuserrepository.go

@@ -1,11 +1,7 @@
 package helmuserrepository
 
 import (
-	"fmt"
-
 	portainer "github.com/portainer/portainer/api"
-
-	"github.com/rs/zerolog/log"
 )
 
 const (
@@ -24,10 +20,10 @@ func (service *Service) BucketName() string {
 
 // NewService creates a new instance of a service.
 func NewService(connection portainer.Connection) (*Service, error) {
-	err := connection.SetServiceName(BucketName)
-	if err != nil {
-		return nil, err
-	}
+	// err := connection.SetServiceName(BucketName)
+	// if err != nil {
+	// 	return nil, err
+	// }
 
 	return &Service{
 		connection: connection,
@@ -38,67 +34,70 @@ func NewService(connection portainer.Connection) (*Service, error) {
 func (service *Service) HelmUserRepositories() ([]portainer.HelmUserRepository, error) {
 	var repos = make([]portainer.HelmUserRepository, 0)
 
-	err := service.connection.GetAll(
-		BucketName,
-		&portainer.HelmUserRepository{},
-		func(obj interface{}) (interface{}, error) {
-			r, ok := obj.(*portainer.HelmUserRepository)
-			if !ok {
-				log.Debug().Str("obj", fmt.Sprintf("%#v", obj)).Msg("failed to convert to HelmUserRepository object")
-				return nil, fmt.Errorf("Failed to convert to HelmUserRepository object: %s", obj)
-			}
+	// err := service.connection.GetAll(
+	// 	BucketName,
+	// 	&portainer.HelmUserRepository{},
+	// 	func(obj interface{}) (interface{}, error) {
+	// 		r, ok := obj.(*portainer.HelmUserRepository)
+	// 		if !ok {
+	// 			log.Debug().Str("obj", fmt.Sprintf("%#v", obj)).Msg("failed to convert to HelmUserRepository object")
+	// 			return nil, fmt.Errorf("Failed to convert to HelmUserRepository object: %s", obj)
+	// 		}
 
-			repos = append(repos, *r)
+	// 		repos = append(repos, *r)
 
-			return &portainer.HelmUserRepository{}, nil
-		})
+	// 		return &portainer.HelmUserRepository{}, nil
+	// 	})
 
-	return repos, err
+	return repos, nil
 }
 
 // HelmUserRepositoryByUserID return an array containing all the HelmUserRepository objects where the specified userID is present.
 func (service *Service) HelmUserRepositoryByUserID(userID portainer.UserID) ([]portainer.HelmUserRepository, error) {
 	var result = make([]portainer.HelmUserRepository, 0)
 
-	err := service.connection.GetAll(
-		BucketName,
-		&portainer.HelmUserRepository{},
-		func(obj interface{}) (interface{}, error) {
-			record, ok := obj.(*portainer.HelmUserRepository)
-			if !ok {
-				log.Debug().Str("obj", fmt.Sprintf("%#v", obj)).Msg("failed to convert to HelmUserRepository object")
-				return nil, fmt.Errorf("Failed to convert to HelmUserRepository object: %s", obj)
-			}
+	// err := service.connection.GetAll(
+	// 	BucketName,
+	// 	&portainer.HelmUserRepository{},
+	// 	func(obj interface{}) (interface{}, error) {
+	// 		record, ok := obj.(*portainer.HelmUserRepository)
+	// 		if !ok {
+	// 			log.Debug().Str("obj", fmt.Sprintf("%#v", obj)).Msg("failed to convert to HelmUserRepository object")
+	// 			return nil, fmt.Errorf("Failed to convert to HelmUserRepository object: %s", obj)
+	// 		}
 
-			if record.UserID == userID {
-				result = append(result, *record)
-			}
+	// 		if record.UserID == userID {
+	// 			result = append(result, *record)
+	// 		}
 
-			return &portainer.HelmUserRepository{}, nil
-		})
+	// 		return &portainer.HelmUserRepository{}, nil
+	// 	})
 
-	return result, err
+	return result, nil
 }
 
 // CreateHelmUserRepository creates a new HelmUserRepository object.
 func (service *Service) Create(record *portainer.HelmUserRepository) error {
-	return service.connection.CreateObject(
-		BucketName,
-		func(id uint64) (int, interface{}) {
-			record.ID = portainer.HelmUserRepositoryID(id)
-			return int(record.ID), record
-		},
-	)
+	// return service.connection.CreateObject(
+	// 	BucketName,
+	// 	func(id uint64) (int, interface{}) {
+	// 		record.ID = portainer.HelmUserRepositoryID(id)
+	// 		return int(record.ID), record
+	// 	},
+	// )
+	return nil
 }
 
 // UpdateHelmUserRepostory updates an registry.
 func (service *Service) UpdateHelmUserRepository(ID portainer.HelmUserRepositoryID, registry *portainer.HelmUserRepository) error {
-	identifier := service.connection.ConvertToKey(int(ID))
-	return service.connection.UpdateObject(BucketName, identifier, registry)
+	// identifier := service.connection.ConvertToKey(int(ID))
+	// return service.connection.UpdateObject(BucketName, identifier, registry)
+	return nil
 }
 
 // DeleteHelmUserRepository deletes an registry.
 func (service *Service) DeleteHelmUserRepository(ID portainer.HelmUserRepositoryID) error {
-	identifier := service.connection.ConvertToKey(int(ID))
-	return service.connection.DeleteObject(BucketName, identifier)
+	// identifier := service.connection.ConvertToKey(int(ID))
+	// return service.connection.DeleteObject(BucketName, identifier)
+	return nil
 }

api/dataservices/interface.go

@@ -3,7 +3,6 @@ package dataservices
 // 	"github.com/portainer/portainer/api/dataservices"
 
 import (
-	"io"
 	"time"
 
 	"github.com/portainer/portainer/api/dataservices/errors"
@@ -18,11 +17,8 @@ type (
 		Open() (newStore bool, err error)
 		Init() error
 		Close() error
-		MigrateData() error
-		Rollback(force bool) error
+
 		CheckCurrentEdition() error
-		BackupTo(w io.Writer) error
-		Export(filename string) (err error)
 		IsErrObjectNotFound(err error) bool
 		CustomTemplate() CustomTemplateService
 		EdgeGroup() EdgeGroupService
@@ -59,7 +55,6 @@ type (
 		Create(customTemplate *portainer.CustomTemplate) error
 		UpdateCustomTemplate(ID portainer.CustomTemplateID, customTemplate *portainer.CustomTemplate) error
 		DeleteCustomTemplate(ID portainer.CustomTemplateID) error
-		BucketName() string
 	}
 
 	// EdgeGroupService represents a service to manage Edge groups
@@ -69,7 +64,6 @@ type (
 		Create(group *portainer.EdgeGroup) error
 		UpdateEdgeGroup(ID portainer.EdgeGroupID, group *portainer.EdgeGroup) error
 		DeleteEdgeGroup(ID portainer.EdgeGroupID) error
-		BucketName() string
 	}
 
 	// EdgeJobService represents a service to manage Edge jobs
@@ -80,7 +74,6 @@ type (
 		UpdateEdgeJob(ID portainer.EdgeJobID, edgeJob *portainer.EdgeJob) error
 		DeleteEdgeJob(ID portainer.EdgeJobID) error
 		GetNextIdentifier() int
-		BucketName() string
 	}
 
 	EdgeUpdateScheduleService interface {
@@ -91,7 +84,6 @@ type (
 		Create(edgeUpdateSchedule *edgetypes.UpdateSchedule) error
 		Update(ID edgetypes.UpdateScheduleID, edgeUpdateSchedule *edgetypes.UpdateSchedule) error
 		Delete(ID edgetypes.UpdateScheduleID) error
-		BucketName() string
 	}
 
 	// EdgeStackService represents a service to manage Edge stacks
@@ -102,7 +94,6 @@ type (
 		UpdateEdgeStack(ID portainer.EdgeStackID, edgeStack *portainer.EdgeStack) error
 		DeleteEdgeStack(ID portainer.EdgeStackID) error
 		GetNextIdentifier() int
-		BucketName() string
 	}
 
 	// EndpointService represents a service for managing environment(endpoint) data
@@ -113,7 +104,6 @@ type (
 		UpdateEndpoint(ID portainer.EndpointID, endpoint *portainer.Endpoint) error
 		DeleteEndpoint(ID portainer.EndpointID) error
 		GetNextIdentifier() int
-		BucketName() string
 	}
 
 	// EndpointGroupService represents a service for managing environment(endpoint) group data
@@ -123,7 +113,6 @@ type (
 		Create(group *portainer.EndpointGroup) error
 		UpdateEndpointGroup(ID portainer.EndpointGroupID, group *portainer.EndpointGroup) error
 		DeleteEndpointGroup(ID portainer.EndpointGroupID) error
-		BucketName() string
 	}
 
 	// EndpointRelationService represents a service for managing environment(endpoint) relations data
@@ -133,7 +122,6 @@ type (
 		Create(endpointRelation *portainer.EndpointRelation) error
 		UpdateEndpointRelation(EndpointID portainer.EndpointID, endpointRelation *portainer.EndpointRelation) error
 		DeleteEndpointRelation(EndpointID portainer.EndpointID) error
-		BucketName() string
 	}
 
 	// FDOProfileService represents a service to manage FDO Profiles
@@ -144,7 +132,6 @@ type (
 		Update(ID portainer.FDOProfileID, FDOProfile *portainer.FDOProfile) error
 		Delete(ID portainer.FDOProfileID) error
 		GetNextIdentifier() int
-		BucketName() string
 	}
 
 	// HelmUserRepositoryService represents a service to manage HelmUserRepositories
@@ -154,7 +141,6 @@ type (
 		Create(record *portainer.HelmUserRepository) error
 		UpdateHelmUserRepository(ID portainer.HelmUserRepositoryID, repository *portainer.HelmUserRepository) error
 		DeleteHelmUserRepository(ID portainer.HelmUserRepositoryID) error
-		BucketName() string
 	}
 
 	// JWTService represents a service for managing JWT tokens
@@ -173,7 +159,6 @@ type (
 		Create(registry *portainer.Registry) error
 		UpdateRegistry(ID portainer.RegistryID, registry *portainer.Registry) error
 		DeleteRegistry(ID portainer.RegistryID) error
-		BucketName() string
 	}
 
 	// ResourceControlService represents a service for managing resource control data
@@ -184,7 +169,6 @@ type (
 		Create(rc *portainer.ResourceControl) error
 		UpdateResourceControl(ID portainer.ResourceControlID, resourceControl *portainer.ResourceControl) error
 		DeleteResourceControl(ID portainer.ResourceControlID) error
-		BucketName() string
 	}
 
 	// RoleService represents a service for managing user roles
@@ -193,7 +177,6 @@ type (
 		Roles() ([]portainer.Role, error)
 		Create(role *portainer.Role) error
 		UpdateRole(ID portainer.RoleID, role *portainer.Role) error
-		BucketName() string
 	}
 
 	// APIKeyRepositoryService
@@ -211,7 +194,6 @@ type (
 		Settings() (*portainer.Settings, error)
 		UpdateSettings(settings *portainer.Settings) error
 		IsFeatureFlagEnabled(feature portainer.Feature) bool
-		BucketName() string
 	}
 
 	SnapshotService interface {
@@ -220,14 +202,12 @@ type (
 		UpdateSnapshot(snapshot *portainer.Snapshot) error
 		DeleteSnapshot(endpointID portainer.EndpointID) error
 		Create(snapshot *portainer.Snapshot) error
-		BucketName() string
 	}
 
 	// SSLSettingsService represents a service for managing application settings
 	SSLSettingsService interface {
 		Settings() (*portainer.SSLSettings, error)
 		UpdateSettings(settings *portainer.SSLSettings) error
-		BucketName() string
 	}
 
 	// StackService represents a service for managing stack data
@@ -242,7 +222,6 @@ type (
 		GetNextIdentifier() int
 		StackByWebhookID(ID string) (*portainer.Stack, error)
 		RefreshableStacks() ([]portainer.Stack, error)
-		BucketName() string
 	}
 
 	// TagService represents a service for managing tag data
@@ -252,7 +231,6 @@ type (
 		Create(tag *portainer.Tag) error
 		UpdateTag(ID portainer.TagID, tag *portainer.Tag) error
 		DeleteTag(ID portainer.TagID) error
-		BucketName() string
 	}
 
 	// TeamService represents a service for managing user data
@@ -263,7 +241,6 @@ type (
 		Create(team *portainer.Team) error
 		UpdateTeam(ID portainer.TeamID, team *portainer.Team) error
 		DeleteTeam(ID portainer.TeamID) error
-		BucketName() string
 	}
 
 	// TeamMembershipService represents a service for managing team membership data
@@ -277,14 +254,12 @@ type (
 		DeleteTeamMembership(ID portainer.TeamMembershipID) error
 		DeleteTeamMembershipByUserID(userID portainer.UserID) error
 		DeleteTeamMembershipByTeamID(teamID portainer.TeamID) error
-		BucketName() string
 	}
 
 	// TunnelServerService represents a service for managing data associated to the tunnel server
 	TunnelServerService interface {
 		Info() (*portainer.TunnelServerInfo, error)
 		UpdateInfo(info *portainer.TunnelServerInfo) error
-		BucketName() string
 	}
 
 	// UserService represents a service for managing user data
@@ -296,7 +271,6 @@ type (
 		Create(user *portainer.User) error
 		UpdateUser(ID portainer.UserID, user *portainer.User) error
 		DeleteUser(ID portainer.UserID) error
-		BucketName() string
 	}
 
 	// VersionService represents a service for managing version data
@@ -306,7 +280,6 @@ type (
 		InstanceID() (string, error)
 		StoreDBVersion(version int) error
 		StoreInstanceID(ID string) error
-		BucketName() string
 	}
 
 	// WebhookService represents a service for managing webhook data.
@@ -318,7 +291,6 @@ type (
 		WebhookByResourceID(resourceID string) (*portainer.Webhook, error)
 		WebhookByToken(token string) (*portainer.Webhook, error)
 		DeleteWebhook(ID portainer.WebhookID) error
-		BucketName() string
 	}
 )
 

api/dataservices/registry/registry.go

@@ -1,11 +1,7 @@
 package registry
 
 import (
-	"fmt"
-
 	portainer "github.com/portainer/portainer/api"
-
-	"github.com/rs/zerolog/log"
 )
 
 const (
@@ -24,10 +20,10 @@ func (service *Service) BucketName() string {
 
 // NewService creates a new instance of a service.
 func NewService(connection portainer.Connection) (*Service, error) {
-	err := connection.SetServiceName(BucketName)
-	if err != nil {
-		return nil, err
-	}
+	// err := connection.SetServiceName(BucketName)
+	// if err != nil {
+	// 	return nil, err
+	// }
 
 	return &Service{
 		connection: connection,
@@ -37,12 +33,12 @@ func NewService(connection portainer.Connection) (*Service, error) {
 // Registry returns an registry by ID.
 func (service *Service) Registry(ID portainer.RegistryID) (*portainer.Registry, error) {
 	var registry portainer.Registry
-	identifier := service.connection.ConvertToKey(int(ID))
+	// identifier := service.connection.ConvertToKey(int(ID))
 
-	err := service.connection.GetObject(BucketName, identifier, &registry)
-	if err != nil {
-		return nil, err
-	}
+	// err := service.connection.GetObject(BucketName, identifier, &registry)
+	// if err != nil {
+	// 	return nil, err
+	// }
 
 	return &registry, nil
 }
@@ -51,43 +47,46 @@ func (service *Service) Registry(ID portainer.RegistryID) (*portainer.Registry,
 func (service *Service) Registries() ([]portainer.Registry, error) {
 	var registries = make([]portainer.Registry, 0)
 
-	err := service.connection.GetAll(
-		BucketName,
-		&portainer.Registry{},
-		func(obj interface{}) (interface{}, error) {
-			registry, ok := obj.(*portainer.Registry)
-			if !ok {
-				log.Debug().Str("obj", fmt.Sprintf("%#v", obj)).Msg("failed to convert to Registry object")
-				return nil, fmt.Errorf("Failed to convert to Registry object: %s", obj)
-			}
+	// err := service.connection.GetAll(
+	// 	BucketName,
+	// 	&portainer.Registry{},
+	// 	func(obj interface{}) (interface{}, error) {
+	// 		registry, ok := obj.(*portainer.Registry)
+	// 		if !ok {
+	// 			log.Debug().Str("obj", fmt.Sprintf("%#v", obj)).Msg("failed to convert to Registry object")
+	// 			return nil, fmt.Errorf("Failed to convert to Registry object: %s", obj)
+	// 		}
 
-			registries = append(registries, *registry)
+	// 		registries = append(registries, *registry)
 
-			return &portainer.Registry{}, nil
-		})
+	// 		return &portainer.Registry{}, nil
+	// 	})
 
-	return registries, err
+	return registries, nil
 }
 
 // CreateRegistry creates a new registry.
 func (service *Service) Create(registry *portainer.Registry) error {
-	return service.connection.CreateObject(
-		BucketName,
-		func(id uint64) (int, interface{}) {
-			registry.ID = portainer.RegistryID(id)
-			return int(registry.ID), registry
-		},
-	)
+	// return service.connection.CreateObject(
+	// 	BucketName,
+	// 	func(id uint64) (int, interface{}) {
+	// 		registry.ID = portainer.RegistryID(id)
+	// 		return int(registry.ID), registry
+	// 	},
+	// )
+	return nil
 }
 
 // UpdateRegistry updates an registry.
 func (service *Service) UpdateRegistry(ID portainer.RegistryID, registry *portainer.Registry) error {
-	identifier := service.connection.ConvertToKey(int(ID))
-	return service.connection.UpdateObject(BucketName, identifier, registry)
+	// identifier := service.connection.ConvertToKey(int(ID))
+	// return service.connection.UpdateObject(BucketName, identifier, registry)
+	return nil
 }
 
 // DeleteRegistry deletes an registry.
 func (service *Service) DeleteRegistry(ID portainer.RegistryID) error {
-	identifier := service.connection.ConvertToKey(int(ID))
-	return service.connection.DeleteObject(BucketName, identifier)
+	// identifier := service.connection.ConvertToKey(int(ID))
+	// return service.connection.DeleteObject(BucketName, identifier)
+	return nil
 }

api/dataservices/resourcecontrol/resourcecontrol.go

@@ -1,11 +1,7 @@
 package resourcecontrol
 
 import (
-	"fmt"
-
 	portainer "github.com/portainer/portainer/api"
-
-	"github.com/rs/zerolog/log"
 )
 
 const (
@@ -24,10 +20,10 @@ func (service *Service) BucketName() string {
 
 // NewService creates a new instance of a service.
 func NewService(connection portainer.Connection) (*Service, error) {
-	err := connection.SetServiceName(BucketName)
-	if err != nil {
-		return nil, err
-	}
+	// err := connection.SetServiceName(BucketName)
+	// if err != nil {
+	// 	return nil, err
+	// }
 
 	return &Service{
 		connection: connection,
@@ -37,12 +33,12 @@ func NewService(connection portainer.Connection) (*Service, error) {
 // ResourceControl returns a ResourceControl object by ID
 func (service *Service) ResourceControl(ID portainer.ResourceControlID) (*portainer.ResourceControl, error) {
 	var resourceControl portainer.ResourceControl
-	identifier := service.connection.ConvertToKey(int(ID))
+	// identifier := service.connection.ConvertToKey(int(ID))
 
-	err := service.connection.GetObject(BucketName, identifier, &resourceControl)
-	if err != nil {
-		return nil, err
-	}
+	// err := service.connection.GetObject(BucketName, identifier, &resourceControl)
+	// if err != nil {
+	// 	return nil, err
+	// }
 
 	return &resourceControl, nil
 }
@@ -51,80 +47,83 @@ func (service *Service) ResourceControl(ID portainer.ResourceControlID) (*portai
 // to the main ResourceID or in SubResourceIDs. It also performs a check on the resource type. Return nil
 // if no ResourceControl was found.
 func (service *Service) ResourceControlByResourceIDAndType(resourceID string, resourceType portainer.ResourceControlType) (*portainer.ResourceControl, error) {
-	var resourceControl *portainer.ResourceControl
-	stop := fmt.Errorf("ok")
-	err := service.connection.GetAll(
-		BucketName,
-		&portainer.ResourceControl{},
-		func(obj interface{}) (interface{}, error) {
-			rc, ok := obj.(*portainer.ResourceControl)
-			if !ok {
-				log.Debug().Str("obj", fmt.Sprintf("%#v", obj)).Msg("failed to convert to ResourceControl object")
-				return nil, fmt.Errorf("Failed to convert to ResourceControl object: %s", obj)
-			}
+	// var resourceControl *portainer.ResourceControl
+	// stop := fmt.Errorf("ok")
+	// err := service.connection.GetAll(
+	// 	BucketName,
+	// 	&portainer.ResourceControl{},
+	// 	func(obj interface{}) (interface{}, error) {
+	// 		rc, ok := obj.(*portainer.ResourceControl)
+	// 		if !ok {
+	// 			log.Debug().Str("obj", fmt.Sprintf("%#v", obj)).Msg("failed to convert to ResourceControl object")
+	// 			return nil, fmt.Errorf("Failed to convert to ResourceControl object: %s", obj)
+	// 		}
 
-			if rc.ResourceID == resourceID && rc.Type == resourceType {
-				resourceControl = rc
-				return nil, stop
-			}
+	// 		if rc.ResourceID == resourceID && rc.Type == resourceType {
+	// 			resourceControl = rc
+	// 			return nil, stop
+	// 		}
 
-			for _, subResourceID := range rc.SubResourceIDs {
-				if subResourceID == resourceID {
-					resourceControl = rc
-					return nil, stop
-				}
-			}
+	// 		for _, subResourceID := range rc.SubResourceIDs {
+	// 			if subResourceID == resourceID {
+	// 				resourceControl = rc
+	// 				return nil, stop
+	// 			}
+	// 		}
 
-			return &portainer.ResourceControl{}, nil
-		})
-	if err == stop {
-		return resourceControl, nil
-	}
+	// 		return &portainer.ResourceControl{}, nil
+	// 	})
+	// if err == stop {
+	// 	return resourceControl, nil
+	// }
 
-	return nil, err
+	return nil, nil
 }
 
 // ResourceControls returns all the ResourceControl objects
 func (service *Service) ResourceControls() ([]portainer.ResourceControl, error) {
 	var rcs = make([]portainer.ResourceControl, 0)
 
-	err := service.connection.GetAll(
-		BucketName,
-		&portainer.ResourceControl{},
-		func(obj interface{}) (interface{}, error) {
-			rc, ok := obj.(*portainer.ResourceControl)
-			if !ok {
-				log.Debug().Str("obj", fmt.Sprintf("%#v", obj)).Msg("failed to convert to ResourceControl object")
-				return nil, fmt.Errorf("Failed to convert to ResourceControl object: %s", obj)
-			}
+	// err := service.connection.GetAll(
+	// 	BucketName,
+	// 	&portainer.ResourceControl{},
+	// 	func(obj interface{}) (interface{}, error) {
+	// 		rc, ok := obj.(*portainer.ResourceControl)
+	// 		if !ok {
+	// 			log.Debug().Str("obj", fmt.Sprintf("%#v", obj)).Msg("failed to convert to ResourceControl object")
+	// 			return nil, fmt.Errorf("Failed to convert to ResourceControl object: %s", obj)
+	// 		}
 
-			rcs = append(rcs, *rc)
+	// 		rcs = append(rcs, *rc)
 
-			return &portainer.ResourceControl{}, nil
-		})
+	// 		return &portainer.ResourceControl{}, nil
+	// 	})
 
-	return rcs, err
+	return rcs, nil
 }
 
 // CreateResourceControl creates a new ResourceControl object
 func (service *Service) Create(resourceControl *portainer.ResourceControl) error {
-	return service.connection.CreateObject(
-		BucketName,
-		func(id uint64) (int, interface{}) {
-			resourceControl.ID = portainer.ResourceControlID(id)
-			return int(resourceControl.ID), resourceControl
-		},
-	)
+	// return service.connection.CreateObject(
+	// 	BucketName,
+	// 	func(id uint64) (int, interface{}) {
+	// 		resourceControl.ID = portainer.ResourceControlID(id)
+	// 		return int(resourceControl.ID), resourceControl
+	// 	},
+	// )
+	return nil
 }
 
 // UpdateResourceControl saves a ResourceControl object.
 func (service *Service) UpdateResourceControl(ID portainer.ResourceControlID, resourceControl *portainer.ResourceControl) error {
-	identifier := service.connection.ConvertToKey(int(ID))
-	return service.connection.UpdateObject(BucketName, identifier, resourceControl)
+	// identifier := service.connection.ConvertToKey(int(ID))
+	// return service.connection.UpdateObject(BucketName, identifier, resourceControl)
+	return nil
 }
 
 // DeleteResourceControl deletes a ResourceControl object by ID
 func (service *Service) DeleteResourceControl(ID portainer.ResourceControlID) error {
-	identifier := service.connection.ConvertToKey(int(ID))
-	return service.connection.DeleteObject(BucketName, identifier)
+	// identifier := service.connection.ConvertToKey(int(ID))
+	// return service.connection.DeleteObject(BucketName, identifier)
+	return nil
 }

api/dataservices/role/role.go

@@ -1,11 +1,7 @@
 package role
 
 import (
-	"fmt"
-
 	portainer "github.com/portainer/portainer/api"
-
-	"github.com/rs/zerolog/log"
 )
 
 const (
@@ -24,10 +20,10 @@ func (service *Service) BucketName() string {
 
 // NewService creates a new instance of a service.
 func NewService(connection portainer.Connection) (*Service, error) {
-	err := connection.SetServiceName(BucketName)
-	if err != nil {
-		return nil, err
-	}
+	// err := connection.SetServiceName(BucketName)
+	// if err != nil {
+	// 	return nil, err
+	// }
 
 	return &Service{
 		connection: connection,
@@ -37,12 +33,12 @@ func NewService(connection portainer.Connection) (*Service, error) {
 // Role returns a Role by ID
 func (service *Service) Role(ID portainer.RoleID) (*portainer.Role, error) {
 	var set portainer.Role
-	identifier := service.connection.ConvertToKey(int(ID))
+	// identifier := service.connection.ConvertToKey(int(ID))
 
-	err := service.connection.GetObject(BucketName, identifier, &set)
-	if err != nil {
-		return nil, err
-	}
+	// err := service.connection.GetObject(BucketName, identifier, &set)
+	// if err != nil {
+	// 	return nil, err
+	// }
 
 	return &set, nil
 }
@@ -51,37 +47,39 @@ func (service *Service) Role(ID portainer.RoleID) (*portainer.Role, error) {
 func (service *Service) Roles() ([]portainer.Role, error) {
 	var sets = make([]portainer.Role, 0)
 
-	err := service.connection.GetAll(
-		BucketName,
-		&portainer.Role{},
-		func(obj interface{}) (interface{}, error) {
-			set, ok := obj.(*portainer.Role)
-			if !ok {
-				log.Debug().Str("obj", fmt.Sprintf("%#v", obj)).Msg("failed to convert to Role object")
-				return nil, fmt.Errorf("Failed to convert to Role object: %s", obj)
-			}
+	// err := service.connection.GetAll(
+	// 	BucketName,
+	// 	&portainer.Role{},
+	// 	func(obj interface{}) (interface{}, error) {
+	// 		set, ok := obj.(*portainer.Role)
+	// 		if !ok {
+	// 			log.Debug().Str("obj", fmt.Sprintf("%#v", obj)).Msg("failed to convert to Role object")
+	// 			return nil, fmt.Errorf("Failed to convert to Role object: %s", obj)
+	// 		}
 
-			sets = append(sets, *set)
+	// 		sets = append(sets, *set)
 
-			return &portainer.Role{}, nil
-		})
+	// 		return &portainer.Role{}, nil
+	// 	})
 
-	return sets, err
+	return sets, nil
 }
 
 // CreateRole creates a new Role.
 func (service *Service) Create(role *portainer.Role) error {
-	return service.connection.CreateObject(
-		BucketName,
-		func(id uint64) (int, interface{}) {
-			role.ID = portainer.RoleID(id)
-			return int(role.ID), role
-		},
-	)
+	// return service.connection.CreateObject(
+	// 	BucketName,
+	// 	func(id uint64) (int, interface{}) {
+	// 		role.ID = portainer.RoleID(id)
+	// 		return int(role.ID), role
+	// 	},
+	// )
+	return nil
 }
 
 // UpdateRole updates a role.
 func (service *Service) UpdateRole(ID portainer.RoleID, role *portainer.Role) error {
-	identifier := service.connection.ConvertToKey(int(ID))
-	return service.connection.UpdateObject(BucketName, identifier, role)
+	// identifier := service.connection.ConvertToKey(int(ID))
+	// return service.connection.UpdateObject(BucketName, identifier, role)
+	return nil
 }

api/dataservices/schedule/schedule.go

@@ -1,11 +1,7 @@
 package schedule
 
 import (
-	"fmt"
-
 	portainer "github.com/portainer/portainer/api"
-
-	"github.com/rs/zerolog/log"
 )
 
 const (
@@ -24,10 +20,10 @@ func (service *Service) BucketName() string {
 
 // NewService creates a new instance of a service.
 func NewService(connection portainer.Connection) (*Service, error) {
-	err := connection.SetServiceName(BucketName)
-	if err != nil {
-		return nil, err
-	}
+	// err := connection.SetServiceName(BucketName)
+	// if err != nil {
+	// 	return nil, err
+	// }
 
 	return &Service{
 		connection: connection,
@@ -37,48 +33,33 @@ func NewService(connection portainer.Connection) (*Service, error) {
 // Schedule returns a schedule by ID.
 func (service *Service) Schedule(ID portainer.ScheduleID) (*portainer.Schedule, error) {
 	var schedule portainer.Schedule
-	identifier := service.connection.ConvertToKey(int(ID))
+	// identifier := service.connection.ConvertToKey(int(ID))
 
-	err := service.connection.GetObject(BucketName, identifier, &schedule)
-	if err != nil {
-		return nil, err
-	}
+	// err := service.connection.GetObject(BucketName, identifier, &schedule)
+	// if err != nil {
+	// 	return nil, err
+	// }
 
 	return &schedule, nil
 }
 
 // UpdateSchedule updates a schedule.
 func (service *Service) UpdateSchedule(ID portainer.ScheduleID, schedule *portainer.Schedule) error {
-	identifier := service.connection.ConvertToKey(int(ID))
-	return service.connection.UpdateObject(BucketName, identifier, schedule)
+	// identifier := service.connection.ConvertToKey(int(ID))
+	// return service.connection.UpdateObject(BucketName, identifier, schedule)
+	return nil
 }
 
 // DeleteSchedule deletes a schedule.
 func (service *Service) DeleteSchedule(ID portainer.ScheduleID) error {
-	identifier := service.connection.ConvertToKey(int(ID))
-	return service.connection.DeleteObject(BucketName, identifier)
+	return nil
 }
 
 // Schedules return a array containing all the schedules.
 func (service *Service) Schedules() ([]portainer.Schedule, error) {
 	var schedules = make([]portainer.Schedule, 0)
 
-	err := service.connection.GetAll(
-		BucketName,
-		&portainer.Schedule{},
-		func(obj interface{}) (interface{}, error) {
-			schedule, ok := obj.(*portainer.Schedule)
-			if !ok {
-				log.Debug().Str("obj", fmt.Sprintf("%#v", obj)).Msg("failed to convert to Schedule object")
-				return nil, fmt.Errorf("Failed to convert to Schedule object: %s", obj)
-			}
-
-			schedules = append(schedules, *schedule)
-
-			return &portainer.Schedule{}, nil
-		})
-
-	return schedules, err
+	return schedules, nil
 }
 
 // SchedulesByJobType return a array containing all the schedules
@@ -86,32 +67,15 @@ func (service *Service) Schedules() ([]portainer.Schedule, error) {
 func (service *Service) SchedulesByJobType(jobType portainer.JobType) ([]portainer.Schedule, error) {
 	var schedules = make([]portainer.Schedule, 0)
 
-	err := service.connection.GetAll(
-		BucketName,
-		&portainer.Schedule{},
-		func(obj interface{}) (interface{}, error) {
-			schedule, ok := obj.(*portainer.Schedule)
-			if !ok {
-				log.Debug().Str("obj", fmt.Sprintf("%#v", obj)).Msg("failed to convert to Schedule object")
-				return nil, fmt.Errorf("Failed to convert to Schedule object: %s", obj)
-			}
-
-			if schedule.JobType == jobType {
-				schedules = append(schedules, *schedule)
-			}
-
-			return &portainer.Schedule{}, nil
-		})
-
-	return schedules, err
+	return schedules, nil
 }
 
 // Create assign an ID to a new schedule and saves it.
 func (service *Service) CreateSchedule(schedule *portainer.Schedule) error {
-	return service.connection.CreateObjectWithId(BucketName, int(schedule.ID), schedule)
+	return nil
 }
 
 // GetNextIdentifier returns the next identifier for a schedule.
 func (service *Service) GetNextIdentifier() int {
-	return service.connection.GetNextIdentifier(BucketName)
+	return 0
 }

api/dataservices/settings/settings.go

@@ -21,11 +21,6 @@ func (service *Service) BucketName() string {
 
 // NewService creates a new instance of a service.
 func NewService(connection portainer.Connection) (*Service, error) {
-	err := connection.SetServiceName(BucketName)
-	if err != nil {
-		return nil, err
-	}
-
 	return &Service{
 		connection: connection,
 	}, nil
@@ -35,29 +30,14 @@ func NewService(connection portainer.Connection) (*Service, error) {
 func (service *Service) Settings() (*portainer.Settings, error) {
 	var settings portainer.Settings
 
-	err := service.connection.GetObject(BucketName, []byte(settingsKey), &settings)
-	if err != nil {
-		return nil, err
-	}
-
 	return &settings, nil
 }
 
 // UpdateSettings persists a Settings object.
 func (service *Service) UpdateSettings(settings *portainer.Settings) error {
-	return service.connection.UpdateObject(BucketName, []byte(settingsKey), settings)
+	return nil
 }
 
 func (service *Service) IsFeatureFlagEnabled(feature portainer.Feature) bool {
-	settings, err := service.Settings()
-	if err != nil {
-		return false
-	}
-
-	featureFlagSetting, ok := settings.FeatureFlagSettings[feature]
-	if ok {
-		return featureFlagSetting
-	}
-
 	return false
 }

api/dataservices/snapshot/snapshot.go

@@ -1,11 +1,7 @@
 package snapshot
 
 import (
-	"fmt"
-
 	portainer "github.com/portainer/portainer/api"
-
-	"github.com/rs/zerolog/log"
 )
 
 const (
@@ -21,10 +17,6 @@ func (service *Service) BucketName() string {
 }
 
 func NewService(connection portainer.Connection) (*Service, error) {
-	err := connection.SetServiceName(BucketName)
-	if err != nil {
-		return nil, err
-	}
 
 	return &Service{
 		connection: connection,
@@ -33,12 +25,6 @@ func NewService(connection portainer.Connection) (*Service, error) {
 
 func (service *Service) Snapshot(endpointID portainer.EndpointID) (*portainer.Snapshot, error) {
 	var snapshot portainer.Snapshot
-	identifier := service.connection.ConvertToKey(int(endpointID))
-
-	err := service.connection.GetObject(BucketName, identifier, &snapshot)
-	if err != nil {
-		return nil, err
-	}
 
 	return &snapshot, nil
 }
@@ -46,32 +32,17 @@ func (service *Service) Snapshot(endpointID portainer.EndpointID) (*portainer.Sn
 func (service *Service) Snapshots() ([]portainer.Snapshot, error) {
 	var snapshots = make([]portainer.Snapshot, 0)
 
-	err := service.connection.GetAllWithJsoniter(
-		BucketName,
-		&portainer.Snapshot{},
-		func(obj interface{}) (interface{}, error) {
-			snapshot, ok := obj.(*portainer.Snapshot)
-			if !ok {
-				log.Debug().Str("obj", fmt.Sprintf("%#v", obj)).Msg("failed to convert to Snapshot object")
-				return nil, fmt.Errorf("failed to convert to Snapshot object: %s", obj)
-			}
-			snapshots = append(snapshots, *snapshot)
-			return &portainer.Snapshot{}, nil
-		})
-
-	return snapshots, err
+	return snapshots, nil
 }
 
 func (service *Service) UpdateSnapshot(snapshot *portainer.Snapshot) error {
-	identifier := service.connection.ConvertToKey(int(snapshot.EndpointID))
-	return service.connection.UpdateObject(BucketName, identifier, snapshot)
+	return nil
 }
 
 func (service *Service) DeleteSnapshot(endpointID portainer.EndpointID) error {
-	identifier := service.connection.ConvertToKey(int(endpointID))
-	return service.connection.DeleteObject(BucketName, identifier)
+	return nil
 }
 
 func (service *Service) Create(snapshot *portainer.Snapshot) error {
-	return service.connection.CreateObjectWithId(BucketName, int(snapshot.EndpointID), snapshot)
+	return nil
 }

api/dataservices/ssl/ssl.go

@@ -21,11 +21,6 @@ func (service *Service) BucketName() string {
 
 // NewService creates a new instance of a service.
 func NewService(connection portainer.Connection) (*Service, error) {
-	err := connection.SetServiceName(BucketName)
-	if err != nil {
-		return nil, err
-	}
-
 	return &Service{
 		connection: connection,
 	}, nil
@@ -35,15 +30,10 @@ func NewService(connection portainer.Connection) (*Service, error) {
 func (service *Service) Settings() (*portainer.SSLSettings, error) {
 	var settings portainer.SSLSettings
 
-	err := service.connection.GetObject(BucketName, []byte(key), &settings)
-	if err != nil {
-		return nil, err
-	}
-
 	return &settings, nil
 }
 
 // UpdateSettings persists a SSLSettings object.
 func (service *Service) UpdateSettings(settings *portainer.SSLSettings) error {
-	return service.connection.UpdateObject(BucketName, []byte(key), settings)
+	return nil
 }

api/dataservices/stack/stack.go

@@ -1,13 +1,7 @@
 package stack
 
 import (
-	"fmt"
-	"strings"
-
 	portainer "github.com/portainer/portainer/api"
-	"github.com/portainer/portainer/api/dataservices/errors"
-
-	"github.com/rs/zerolog/log"
 )
 
 const (
@@ -26,10 +20,6 @@ func (service *Service) BucketName() string {
 
 // NewService creates a new instance of a service.
 func NewService(connection portainer.Connection) (*Service, error) {
-	err := connection.SetServiceName(BucketName)
-	if err != nil {
-		return nil, err
-	}
 
 	return &Service{
 		connection: connection,
@@ -39,171 +29,56 @@ func NewService(connection portainer.Connection) (*Service, error) {
 // Stack returns a stack object by ID.
 func (service *Service) Stack(ID portainer.StackID) (*portainer.Stack, error) {
 	var stack portainer.Stack
-	identifier := service.connection.ConvertToKey(int(ID))
-
-	err := service.connection.GetObject(BucketName, identifier, &stack)
-	if err != nil {
-		return nil, err
-	}
-
 	return &stack, nil
 }
 
 // StackByName returns a stack object by name.
 func (service *Service) StackByName(name string) (*portainer.Stack, error) {
-	var s *portainer.Stack
-
-	stop := fmt.Errorf("ok")
-	err := service.connection.GetAll(
-		BucketName,
-		&portainer.Stack{},
-		func(obj interface{}) (interface{}, error) {
-			stack, ok := obj.(*portainer.Stack)
-			if !ok {
-				log.Debug().Str("obj", fmt.Sprintf("%#v", obj)).Msg("failed to convert to Stack object")
-				return nil, fmt.Errorf("Failed to convert to Stack object: %s", obj)
-			}
-
-			if stack.Name == name {
-				s = stack
-				return nil, stop
-			}
-
-			return &portainer.Stack{}, nil
-		})
-	if err == stop {
-		return s, nil
-	}
-	if err == nil {
-		return nil, errors.ErrObjectNotFound
-	}
-
-	return nil, err
+	return nil, nil
 }
 
 // Stacks returns an array containing all the stacks with same name
 func (service *Service) StacksByName(name string) ([]portainer.Stack, error) {
 	var stacks = make([]portainer.Stack, 0)
-
-	err := service.connection.GetAll(
-		BucketName,
-		&portainer.Stack{},
-		func(obj interface{}) (interface{}, error) {
-			stack, ok := obj.(portainer.Stack)
-			if !ok {
-				log.Debug().Str("obj", fmt.Sprintf("%#v", obj)).Msg("failed to convert to Stack object")
-				return nil, fmt.Errorf("Failed to convert to Stack object: %s", obj)
-			}
-
-			if stack.Name == name {
-				stacks = append(stacks, stack)
-			}
-
-			return &portainer.Stack{}, nil
-		})
-
-	return stacks, err
+	return stacks, nil
 }
 
 // Stacks returns an array containing all the stacks.
 func (service *Service) Stacks() ([]portainer.Stack, error) {
 	var stacks = make([]portainer.Stack, 0)
-
-	err := service.connection.GetAll(
-		BucketName,
-		&portainer.Stack{},
-		func(obj interface{}) (interface{}, error) {
-			stack, ok := obj.(*portainer.Stack)
-			if !ok {
-				log.Debug().Str("obj", fmt.Sprintf("%#v", obj)).Msg("failed to convert to Stack object")
-				return nil, fmt.Errorf("Failed to convert to Stack object: %s", obj)
-			}
-
-			stacks = append(stacks, *stack)
-
-			return &portainer.Stack{}, nil
-		})
-
-	return stacks, err
+	return stacks, nil
 }
 
 // GetNextIdentifier returns the next identifier for a stack.
 func (service *Service) GetNextIdentifier() int {
-	return service.connection.GetNextIdentifier(BucketName)
+	return 0
 }
 
 // CreateStack creates a new stack.
 func (service *Service) Create(stack *portainer.Stack) error {
-	return service.connection.CreateObjectWithId(BucketName, int(stack.ID), stack)
+	return nil
 }
 
 // UpdateStack updates a stack.
 func (service *Service) UpdateStack(ID portainer.StackID, stack *portainer.Stack) error {
-	identifier := service.connection.ConvertToKey(int(ID))
-	return service.connection.UpdateObject(BucketName, identifier, stack)
+	return nil
 }
 
 // DeleteStack deletes a stack.
 func (service *Service) DeleteStack(ID portainer.StackID) error {
-	identifier := service.connection.ConvertToKey(int(ID))
-	return service.connection.DeleteObject(BucketName, identifier)
+	return nil
 }
 
 // StackByWebhookID returns a pointer to a stack object by webhook ID.
 // It returns nil, errors.ErrObjectNotFound if there's no stack associated with the webhook ID.
 func (service *Service) StackByWebhookID(id string) (*portainer.Stack, error) {
-	var s *portainer.Stack
-	stop := fmt.Errorf("ok")
-	err := service.connection.GetAll(
-		BucketName,
-		&portainer.Stack{},
-		func(obj interface{}) (interface{}, error) {
-			var ok bool
-			s, ok = obj.(*portainer.Stack)
 
-			if !ok {
-				log.Debug().Str("obj", fmt.Sprintf("%#v", obj)).Msg("failed to convert to Stack object")
-
-				return &portainer.Stack{}, nil
-			}
-
-			if s.AutoUpdate != nil && strings.EqualFold(s.AutoUpdate.Webhook, id) {
-				return nil, stop
-			}
-
-			return &portainer.Stack{}, nil
-		})
-	if err == stop {
-		return s, nil
-	}
-	if err == nil {
-		return nil, errors.ErrObjectNotFound
-	}
-
-	return nil, err
+	return nil, nil
 
 }
 
 // RefreshableStacks returns stacks that are configured for a periodic update
 func (service *Service) RefreshableStacks() ([]portainer.Stack, error) {
 	stacks := make([]portainer.Stack, 0)
-
-	err := service.connection.GetAll(
-		BucketName,
-		&portainer.Stack{},
-		func(obj interface{}) (interface{}, error) {
-			stack, ok := obj.(*portainer.Stack)
-			if !ok {
-				log.Debug().Str("obj", fmt.Sprintf("%#v", obj)).Msg("failed to convert to Stack object")
-				return nil, fmt.Errorf("Failed to convert to Stack object: %s", obj)
-			}
-
-			if stack.AutoUpdate != nil && stack.AutoUpdate.Interval != "" {
-				stacks = append(stacks, *stack)
-			}
-
-			return &portainer.Stack{}, nil
-		})
-
-	return stacks, err
+	return stacks, nil
 }

api/dataservices/tag/tag.go

@@ -1,11 +1,7 @@
 package tag
 
 import (
-	"fmt"
-
 	portainer "github.com/portainer/portainer/api"
-
-	"github.com/rs/zerolog/log"
 )
 
 const (
@@ -24,11 +20,6 @@ func (service *Service) BucketName() string {
 
 // NewService creates a new instance of a service.
 func NewService(connection portainer.Connection) (*Service, error) {
-	err := connection.SetServiceName(BucketName)
-	if err != nil {
-		return nil, err
-	}
-
 	return &Service{
 		connection: connection,
 	}, nil
@@ -37,57 +28,26 @@ func NewService(connection portainer.Connection) (*Service, error) {
 // Tags return an array containing all the tags.
 func (service *Service) Tags() ([]portainer.Tag, error) {
 	var tags = make([]portainer.Tag, 0)
-
-	err := service.connection.GetAll(
-		BucketName,
-		&portainer.Tag{},
-		func(obj interface{}) (interface{}, error) {
-			tag, ok := obj.(*portainer.Tag)
-			if !ok {
-				log.Debug().Str("obj", fmt.Sprintf("%#v", obj)).Msg("failed to convert to Tag object")
-				return nil, fmt.Errorf("Failed to convert to Tag object: %s", obj)
-			}
-
-			tags = append(tags, *tag)
-
-			return &portainer.Tag{}, nil
-		})
-
-	return tags, err
+	return tags, nil
 }
 
 // Tag returns a tag by ID.
 func (service *Service) Tag(ID portainer.TagID) (*portainer.Tag, error) {
 	var tag portainer.Tag
-	identifier := service.connection.ConvertToKey(int(ID))
-
-	err := service.connection.GetObject(BucketName, identifier, &tag)
-	if err != nil {
-		return nil, err
-	}
-
 	return &tag, nil
 }
 
 // CreateTag creates a new tag.
 func (service *Service) Create(tag *portainer.Tag) error {
-	return service.connection.CreateObject(
-		BucketName,
-		func(id uint64) (int, interface{}) {
-			tag.ID = portainer.TagID(id)
-			return int(tag.ID), tag
-		},
-	)
+	return nil
 }
 
 // UpdateTag updates a tag.
 func (service *Service) UpdateTag(ID portainer.TagID, tag *portainer.Tag) error {
-	identifier := service.connection.ConvertToKey(int(ID))
-	return service.connection.UpdateObject(BucketName, identifier, tag)
+	return nil
 }
 
 // DeleteTag deletes a tag.
 func (service *Service) DeleteTag(ID portainer.TagID) error {
-	identifier := service.connection.ConvertToKey(int(ID))
-	return service.connection.DeleteObject(BucketName, identifier)
+	return nil
 }

api/dataservices/team/team.go

@@ -1,13 +1,7 @@
 package team
 
 import (
-	"fmt"
-	"strings"
-
 	portainer "github.com/portainer/portainer/api"
-	"github.com/portainer/portainer/api/dataservices/errors"
-
-	"github.com/rs/zerolog/log"
 )
 
 const (
@@ -26,11 +20,6 @@ func (service *Service) BucketName() string {
 
 // NewService creates a new instance of a service.
 func NewService(connection portainer.Connection) (*Service, error) {
-	err := connection.SetServiceName(BucketName)
-	if err != nil {
-		return nil, err
-	}
-
 	return &Service{
 		connection: connection,
 	}, nil
@@ -39,89 +28,31 @@ func NewService(connection portainer.Connection) (*Service, error) {
 // Team returns a Team by ID
 func (service *Service) Team(ID portainer.TeamID) (*portainer.Team, error) {
 	var team portainer.Team
-	identifier := service.connection.ConvertToKey(int(ID))
-
-	err := service.connection.GetObject(BucketName, identifier, &team)
-	if err != nil {
-		return nil, err
-	}
-
 	return &team, nil
 }
 
 // TeamByName returns a team by name.
 func (service *Service) TeamByName(name string) (*portainer.Team, error) {
-	var t *portainer.Team
-
-	stop := fmt.Errorf("ok")
-	err := service.connection.GetAll(
-		BucketName,
-		&portainer.Team{},
-		func(obj interface{}) (interface{}, error) {
-			team, ok := obj.(*portainer.Team)
-			if !ok {
-				log.Debug().Str("obj", fmt.Sprintf("%#v", obj)).Msg("failed to convert to Team object")
-				return nil, fmt.Errorf("Failed to convert to Team object: %s", obj)
-			}
-
-			if strings.EqualFold(team.Name, name) {
-				t = team
-				return nil, stop
-			}
-
-			return &portainer.Team{}, nil
-		})
-	if err == stop {
-		return t, nil
-	}
-	if err == nil {
-		return nil, errors.ErrObjectNotFound
-	}
-
-	return nil, err
+	return nil, nil
 }
 
 // Teams return an array containing all the teams.
 func (service *Service) Teams() ([]portainer.Team, error) {
 	var teams = make([]portainer.Team, 0)
-
-	err := service.connection.GetAll(
-		BucketName,
-		&portainer.Team{},
-		func(obj interface{}) (interface{}, error) {
-			team, ok := obj.(*portainer.Team)
-			if !ok {
-				log.Debug().Str("obj", fmt.Sprintf("%#v", obj)).Msg("failed to convert to Team object")
-				return nil, fmt.Errorf("Failed to convert to Team object: %s", obj)
-			}
-
-			teams = append(teams, *team)
-
-			return &portainer.Team{}, nil
-		})
-
-	return teams, err
+	return teams, nil
 }
 
 // UpdateTeam saves a Team.
 func (service *Service) UpdateTeam(ID portainer.TeamID, team *portainer.Team) error {
-	identifier := service.connection.ConvertToKey(int(ID))
-	return service.connection.UpdateObject(BucketName, identifier, team)
+	return nil
 }
 
 // CreateTeam creates a new Team.
 func (service *Service) Create(team *portainer.Team) error {
-	return service.connection.CreateObject(
-		BucketName,
-		func(id uint64) (int, interface{}) {
-			team.ID = portainer.TeamID(id)
-			return int(team.ID), team
-		},
-	)
+	return nil
 }
 
 // DeleteTeam deletes a Team.
 func (service *Service) DeleteTeam(ID portainer.TeamID) error {
-	identifier := service.connection.ConvertToKey(int(ID))
-	return service.connection.DeleteObject(BucketName, identifier)
+	return nil
 }

api/dataservices/teammembership/teammembership.go

@@ -1,11 +1,7 @@
 package teammembership
 
 import (
-	"fmt"
-
 	portainer "github.com/portainer/portainer/api"
-
-	"github.com/rs/zerolog/log"
 )
 
 const (
@@ -24,11 +20,6 @@ func (service *Service) BucketName() string {
 
 // NewService creates a new instance of a service.
 func NewService(connection portainer.Connection) (*Service, error) {
-	err := connection.SetServiceName(BucketName)
-	if err != nil {
-		return nil, err
-	}
-
 	return &Service{
 		connection: connection,
 	}, nil
@@ -37,145 +28,48 @@ func NewService(connection portainer.Connection) (*Service, error) {
 // TeamMembership returns a TeamMembership object by ID
 func (service *Service) TeamMembership(ID portainer.TeamMembershipID) (*portainer.TeamMembership, error) {
 	var membership portainer.TeamMembership
-	identifier := service.connection.ConvertToKey(int(ID))
-
-	err := service.connection.GetObject(BucketName, identifier, &membership)
-	if err != nil {
-		return nil, err
-	}
-
 	return &membership, nil
 }
 
 // TeamMemberships return an array containing all the TeamMembership objects.
 func (service *Service) TeamMemberships() ([]portainer.TeamMembership, error) {
 	var memberships = make([]portainer.TeamMembership, 0)
-
-	err := service.connection.GetAll(
-		BucketName,
-		&portainer.TeamMembership{},
-		func(obj interface{}) (interface{}, error) {
-			membership, ok := obj.(*portainer.TeamMembership)
-			if !ok {
-				log.Debug().Str("obj", fmt.Sprintf("%#v", obj)).Msg("failed to convert to TeamMembership object")
-				return nil, fmt.Errorf("Failed to convert to TeamMembership object: %s", obj)
-			}
-
-			memberships = append(memberships, *membership)
-
-			return &portainer.TeamMembership{}, nil
-		})
-
-	return memberships, err
+	return memberships, nil
 }
 
 // TeamMembershipsByUserID return an array containing all the TeamMembership objects where the specified userID is present.
 func (service *Service) TeamMembershipsByUserID(userID portainer.UserID) ([]portainer.TeamMembership, error) {
 	var memberships = make([]portainer.TeamMembership, 0)
-
-	err := service.connection.GetAll(
-		BucketName,
-		&portainer.TeamMembership{},
-		func(obj interface{}) (interface{}, error) {
-			membership, ok := obj.(*portainer.TeamMembership)
-			if !ok {
-				log.Debug().Str("obj", fmt.Sprintf("%#v", obj)).Msg("failed to convert to TeamMembership object")
-				return nil, fmt.Errorf("Failed to convert to TeamMembership object: %s", obj)
-			}
-
-			if membership.UserID == userID {
-				memberships = append(memberships, *membership)
-			}
-
-			return &portainer.TeamMembership{}, nil
-		})
-
-	return memberships, err
+	return memberships, nil
 }
 
 // TeamMembershipsByTeamID return an array containing all the TeamMembership objects where the specified teamID is present.
 func (service *Service) TeamMembershipsByTeamID(teamID portainer.TeamID) ([]portainer.TeamMembership, error) {
 	var memberships = make([]portainer.TeamMembership, 0)
-
-	err := service.connection.GetAll(
-		BucketName,
-		&portainer.TeamMembership{},
-		func(obj interface{}) (interface{}, error) {
-			membership, ok := obj.(*portainer.TeamMembership)
-			if !ok {
-				log.Debug().Str("obj", fmt.Sprintf("%#v", obj)).Msg("failed to convert to TeamMembership object")
-				return nil, fmt.Errorf("Failed to convert to TeamMembership object: %s", obj)
-			}
-
-			if membership.TeamID == teamID {
-				memberships = append(memberships, *membership)
-			}
-
-			return &portainer.TeamMembership{}, nil
-		})
-
-	return memberships, err
+	return memberships, nil
 }
 
 // UpdateTeamMembership saves a TeamMembership object.
 func (service *Service) UpdateTeamMembership(ID portainer.TeamMembershipID, membership *portainer.TeamMembership) error {
-	identifier := service.connection.ConvertToKey(int(ID))
-	return service.connection.UpdateObject(BucketName, identifier, membership)
+	return nil
 }
 
 // CreateTeamMembership creates a new TeamMembership object.
 func (service *Service) Create(membership *portainer.TeamMembership) error {
-	return service.connection.CreateObject(
-		BucketName,
-		func(id uint64) (int, interface{}) {
-			membership.ID = portainer.TeamMembershipID(id)
-			return int(membership.ID), membership
-		},
-	)
+	return nil
 }
 
 // DeleteTeamMembership deletes a TeamMembership object.
 func (service *Service) DeleteTeamMembership(ID portainer.TeamMembershipID) error {
-	identifier := service.connection.ConvertToKey(int(ID))
-	return service.connection.DeleteObject(BucketName, identifier)
+	return nil
 }
 
 // DeleteTeamMembershipByUserID deletes all the TeamMembership object associated to a UserID.
 func (service *Service) DeleteTeamMembershipByUserID(userID portainer.UserID) error {
-	return service.connection.DeleteAllObjects(
-		BucketName,
-		func(obj interface{}) (id int, ok bool) {
-			membership, ok := obj.(portainer.TeamMembership)
-			if !ok {
-				log.Debug().Str("obj", fmt.Sprintf("%#v", obj)).Msg("failed to convert to TeamMembership object")
-				//return fmt.Errorf("Failed to convert to TeamMembership object: %s", obj)
-				return -1, false
-			}
-
-			if membership.UserID == userID {
-				return int(membership.ID), true
-			}
-
-			return -1, false
-		})
+	return nil
 }
 
 // DeleteTeamMembershipByTeamID deletes all the TeamMembership object associated to a TeamID.
 func (service *Service) DeleteTeamMembershipByTeamID(teamID portainer.TeamID) error {
-	return service.connection.DeleteAllObjects(
-		BucketName,
-		func(obj interface{}) (id int, ok bool) {
-			membership, ok := obj.(portainer.TeamMembership)
-			if !ok {
-				log.Debug().Str("obj", fmt.Sprintf("%#v", obj)).Msg("failed to convert to TeamMembership object")
-				//return fmt.Errorf("Failed to convert to TeamMembership object: %s", obj)
-				return -1, false
-			}
-
-			if membership.TeamID == teamID {
-				return int(membership.ID), true
-			}
-
-			return -1, false
-		})
+	return nil
 }

api/dataservices/tunnelserver/tunnelserver.go

@@ -21,11 +21,6 @@ func (service *Service) BucketName() string {
 
 // NewService creates a new instance of a service.
 func NewService(connection portainer.Connection) (*Service, error) {
-	err := connection.SetServiceName(BucketName)
-	if err != nil {
-		return nil, err
-	}
-
 	return &Service{
 		connection: connection,
 	}, nil
@@ -35,15 +30,10 @@ func NewService(connection portainer.Connection) (*Service, error) {
 func (service *Service) Info() (*portainer.TunnelServerInfo, error) {
 	var info portainer.TunnelServerInfo
 
-	err := service.connection.GetObject(BucketName, []byte(infoKey), &info)
-	if err != nil {
-		return nil, err
-	}
-
 	return &info, nil
 }
 
 // UpdateInfo persists a TunnelServerInfo object.
 func (service *Service) UpdateInfo(settings *portainer.TunnelServerInfo) error {
-	return service.connection.UpdateObject(BucketName, []byte(infoKey), settings)
+	return nil
 }

api/dataservices/user/user.go

@@ -1,13 +1,7 @@
 package user
 
 import (
-	"fmt"
-	"strings"
-
 	portainer "github.com/portainer/portainer/api"
-	"github.com/portainer/portainer/api/dataservices/errors"
-
-	"github.com/rs/zerolog/log"
 )
 
 const (
@@ -26,11 +20,6 @@ func (service *Service) BucketName() string {
 
 // NewService creates a new instance of a service.
 func NewService(connection portainer.Connection) (*Service, error) {
-	err := connection.SetServiceName(BucketName)
-	if err != nil {
-		return nil, err
-	}
-
 	return &Service{
 		connection: connection,
 	}, nil
@@ -39,120 +28,38 @@ func NewService(connection portainer.Connection) (*Service, error) {
 // User returns a user by ID
 func (service *Service) User(ID portainer.UserID) (*portainer.User, error) {
 	var user portainer.User
-	identifier := service.connection.ConvertToKey(int(ID))
-
-	err := service.connection.GetObject(BucketName, identifier, &user)
-	if err != nil {
-		return nil, err
-	}
 
 	return &user, nil
 }
 
 // UserByUsername returns a user by username.
 func (service *Service) UserByUsername(username string) (*portainer.User, error) {
-	var u *portainer.User
-	stop := fmt.Errorf("ok")
-	err := service.connection.GetAll(
-		BucketName,
-		&portainer.User{},
-		func(obj interface{}) (interface{}, error) {
-			user, ok := obj.(*portainer.User)
-			if !ok {
-				log.Debug().Str("obj", fmt.Sprintf("%#v", obj)).Msg("failed to convert to User object")
-
-				return nil, fmt.Errorf("Failed to convert to User object: %s", obj)
-			}
-
-			if strings.EqualFold(user.Username, username) {
-				u = user
-				return nil, stop
-			}
-
-			return &portainer.User{}, nil
-		})
-
-	if err == stop {
-		return u, nil
-	}
-
-	if err == nil {
-		return nil, errors.ErrObjectNotFound
-	}
-
-	return nil, err
+	return nil, nil
 }
 
 // Users return an array containing all the users.
 func (service *Service) Users() ([]portainer.User, error) {
 	var users = make([]portainer.User, 0)
-
-	err := service.connection.GetAll(
-		BucketName,
-		&portainer.User{},
-		func(obj interface{}) (interface{}, error) {
-			user, ok := obj.(*portainer.User)
-			if !ok {
-				log.Debug().Str("obj", fmt.Sprintf("%#v", obj)).Msg("failed to convert to User object")
-
-				return nil, fmt.Errorf("Failed to convert to User object: %s", obj)
-			}
-
-			users = append(users, *user)
-
-			return &portainer.User{}, nil
-		})
-
-	return users, err
+	return users, nil
 }
 
 // UsersByRole return an array containing all the users with the specified role.
 func (service *Service) UsersByRole(role portainer.UserRole) ([]portainer.User, error) {
 	var users = make([]portainer.User, 0)
-
-	err := service.connection.GetAll(
-		BucketName,
-		&portainer.User{},
-		func(obj interface{}) (interface{}, error) {
-			user, ok := obj.(*portainer.User)
-			if !ok {
-				log.Debug().Str("obj", fmt.Sprintf("%#v", obj)).Msg("failed to convert to User object")
-
-				return nil, fmt.Errorf("Failed to convert to User object: %s", obj)
-			}
-
-			if user.Role == role {
-				users = append(users, *user)
-			}
-
-			return &portainer.User{}, nil
-		})
-
-	return users, err
+	return users, nil
 }
 
 // UpdateUser saves a user.
 func (service *Service) UpdateUser(ID portainer.UserID, user *portainer.User) error {
-	identifier := service.connection.ConvertToKey(int(ID))
-	user.Username = strings.ToLower(user.Username)
-	return service.connection.UpdateObject(BucketName, identifier, user)
+	return nil
 }
 
 // CreateUser creates a new user.
 func (service *Service) Create(user *portainer.User) error {
-	return service.connection.CreateObject(
-		BucketName,
-		func(id uint64) (int, interface{}) {
-			user.ID = portainer.UserID(id)
-			user.Username = strings.ToLower(user.Username)
-
-			return int(user.ID), user
-		},
-	)
+	return nil
 }
 
 // DeleteUser deletes a user.
 func (service *Service) DeleteUser(ID portainer.UserID) error {
-	identifier := service.connection.ConvertToKey(int(ID))
-	return service.connection.DeleteObject(BucketName, identifier)
+	return nil
 }

api/dataservices/version/version.go

@@ -1,18 +1,11 @@
 package version
 
 import (
+	"fmt"
 	"strconv"
 
 	portainer "github.com/portainer/portainer/api"
-)
-
-const (
-	// BucketName represents the name of the bucket where this service stores data.
-	BucketName  = "version"
-	versionKey  = "DB_VERSION"
-	instanceKey = "INSTANCE_ID"
-	editionKey  = "EDITION"
-	updatingKey = "DB_UPDATING"
+	"github.com/portainer/portainer/api/database/models"
 )
 
 // Service represents a service to manage stored versions.
@@ -20,17 +13,8 @@ type Service struct {
 	connection portainer.Connection
 }
 
-func (service *Service) BucketName() string {
-	return BucketName
-}
-
 // NewService creates a new instance of a service.
 func NewService(connection portainer.Connection) (*Service, error) {
-	err := connection.SetServiceName(BucketName)
-	if err != nil {
-		return nil, err
-	}
-
 	return &Service{
 		connection: connection,
 	}, nil
@@ -38,22 +22,24 @@ func NewService(connection portainer.Connection) (*Service, error) {
 
 // DBVersion retrieves the stored database version.
 func (service *Service) DBVersion() (int, error) {
-	var version string
-	err := service.connection.GetObject(BucketName, []byte(versionKey), &version)
-	if err != nil {
-		return 0, err
+	db := service.connection.GetDB()
+	var version models.Version
+	tx := db.First(&version, `key = ?`, models.VersionKey)
+	if tx.Error != nil {
+		return 0, tx.Error
 	}
-	return strconv.Atoi(version)
+	return strconv.Atoi(version.Value)
 }
 
 // Edition retrieves the stored portainer edition.
 func (service *Service) Edition() (portainer.SoftwareEdition, error) {
-	var edition string
-	err := service.connection.GetObject(BucketName, []byte(editionKey), &edition)
-	if err != nil {
-		return 0, err
+	db := service.connection.GetDB()
+	var version models.Version
+	tx := db.First(&version, `key = ?`, models.EditionKey)
+	if tx.Error != nil {
+		return 0, tx.Error
 	}
-	e, err := strconv.Atoi(edition)
+	e, err := strconv.Atoi(version.Value)
 	if err != nil {
 		return 0, err
 	}
@@ -61,31 +47,56 @@ func (service *Service) Edition() (portainer.SoftwareEdition, error) {
 }
 
 // StoreDBVersion store the database version.
-func (service *Service) StoreDBVersion(version int) error {
-	return service.connection.UpdateObject(BucketName, []byte(versionKey), strconv.Itoa(version))
+func (service *Service) StoreDBVersion(v int) error {
+	db := service.connection.GetDB()
+	version := &models.Version{Key: models.VersionKey}
+	fmt.Printf("## version %s", version)
+	tx := db.Model(version).Update("value", strconv.FormatInt(int64(v), 10))
+	if tx.Error != nil {
+		return tx.Error
+	}
+	return nil
 }
 
 // IsUpdating retrieves the database updating status.
 func (service *Service) IsUpdating() (bool, error) {
-	var isUpdating bool
-	err := service.connection.GetObject(BucketName, []byte(updatingKey), &isUpdating)
-	return isUpdating, err
+	db := service.connection.GetDB()
+	var version models.Version
+	tx := db.First(&version, `key = ?`, models.UpdatingKey)
+	if tx.Error != nil {
+		return false, tx.Error
+	}
+	return version.Value == "true", nil
 }
 
 // StoreIsUpdating store the database updating status.
 func (service *Service) StoreIsUpdating(isUpdating bool) error {
-	return service.connection.UpdateObject(BucketName, []byte(updatingKey), isUpdating)
+	db := service.connection.GetDB()
+	tx := db.Model(&models.Version{Key: models.UpdatingKey}).Update("value", strconv.FormatBool(isUpdating))
+	if tx.Error != nil {
+		return tx.Error
+	}
+	return nil
 }
 
 // InstanceID retrieves the stored instance ID.
 func (service *Service) InstanceID() (string, error) {
-	var id string
-	err := service.connection.GetObject(BucketName, []byte(instanceKey), &id)
-	return id, err
+	db := service.connection.GetDB()
+	var version models.Version
+	tx := db.First(&version, `key = ?`, models.InstanceKey)
+	if tx.Error != nil {
+		return "", tx.Error
+	}
+	return version.Value, nil
 }
 
 // StoreInstanceID store the instance ID.
 func (service *Service) StoreInstanceID(ID string) error {
-	return service.connection.UpdateObject(BucketName, []byte(instanceKey), ID)
+	db := service.connection.GetDB()
+	tx := db.FirstOrCreate(&models.Version{Key: models.InstanceKey, Value: ID})
+	if tx.Error != nil {
+		return tx.Error
+	}
 
+	return nil
 }

api/dataservices/webhook/webhook.go

@@ -1,12 +1,7 @@
 package webhook
 
 import (
-	"fmt"
-
 	portainer "github.com/portainer/portainer/api"
-	"github.com/portainer/portainer/api/dataservices/errors"
-
-	"github.com/rs/zerolog/log"
 )
 
 const (
@@ -25,11 +20,6 @@ func (service *Service) BucketName() string {
 
 // NewService creates a new instance of a service.
 func NewService(connection portainer.Connection) (*Service, error) {
-	err := connection.SetServiceName(BucketName)
-	if err != nil {
-		return nil, err
-	}
-
 	return &Service{
 		connection: connection,
 	}, nil
@@ -38,125 +28,36 @@ func NewService(connection portainer.Connection) (*Service, error) {
 // Webhooks returns an array of all webhooks
 func (service *Service) Webhooks() ([]portainer.Webhook, error) {
 	var webhooks = make([]portainer.Webhook, 0)
-
-	err := service.connection.GetAll(
-		BucketName,
-		&portainer.Webhook{},
-		func(obj interface{}) (interface{}, error) {
-			webhook, ok := obj.(*portainer.Webhook)
-			if !ok {
-				log.Debug().Str("obj", fmt.Sprintf("%#v", obj)).Msg("failed to convert to Webhook object")
-				return nil, fmt.Errorf("Failed to convert to Webhook object: %s", obj)
-			}
-
-			webhooks = append(webhooks, *webhook)
-
-			return &portainer.Webhook{}, nil
-		})
-
-	return webhooks, err
+	return webhooks, nil
 }
 
 // Webhook returns a webhook by ID.
 func (service *Service) Webhook(ID portainer.WebhookID) (*portainer.Webhook, error) {
 	var webhook portainer.Webhook
-	identifier := service.connection.ConvertToKey(int(ID))
-
-	err := service.connection.GetObject(BucketName, identifier, &webhook)
-	if err != nil {
-		return nil, err
-	}
-
 	return &webhook, nil
 }
 
 // WebhookByResourceID returns a webhook by the ResourceID it is associated with.
 func (service *Service) WebhookByResourceID(ID string) (*portainer.Webhook, error) {
-	var w *portainer.Webhook
-	stop := fmt.Errorf("ok")
-	err := service.connection.GetAll(
-		BucketName,
-		&portainer.Webhook{},
-		func(obj interface{}) (interface{}, error) {
-			webhook, ok := obj.(*portainer.Webhook)
-			if !ok {
-				log.Debug().Str("obj", fmt.Sprintf("%#v", obj)).Msg("failed to convert to Webhook object")
-
-				return nil, fmt.Errorf("Failed to convert to Webhook object: %s", obj)
-			}
-
-			if webhook.ResourceID == ID {
-				w = webhook
-				return nil, stop
-			}
-
-			return &portainer.Webhook{}, nil
-		})
-
-	if err == stop {
-		return w, nil
-	}
-
-	if err == nil {
-		return nil, errors.ErrObjectNotFound
-	}
-
-	return nil, err
+	return nil, nil
 }
 
 // WebhookByToken returns a webhook by the random token it is associated with.
 func (service *Service) WebhookByToken(token string) (*portainer.Webhook, error) {
-	var w *portainer.Webhook
-	stop := fmt.Errorf("ok")
-	err := service.connection.GetAll(
-		BucketName,
-		&portainer.Webhook{},
-		func(obj interface{}) (interface{}, error) {
-			webhook, ok := obj.(*portainer.Webhook)
-			if !ok {
-				log.Debug().Str("obj", fmt.Sprintf("%#v", obj)).Msg("failed to convert to Webhook object")
-
-				return nil, fmt.Errorf("Failed to convert to Webhook object: %s", obj)
-			}
-
-			if webhook.Token == token {
-				w = webhook
-				return nil, stop
-			}
-
-			return &portainer.Webhook{}, nil
-		})
-
-	if err == stop {
-		return w, nil
-	}
-
-	if err == nil {
-		return nil, errors.ErrObjectNotFound
-	}
-
-	return nil, err
+	return nil, nil
 }
 
 // DeleteWebhook deletes a webhook.
 func (service *Service) DeleteWebhook(ID portainer.WebhookID) error {
-	identifier := service.connection.ConvertToKey(int(ID))
-	return service.connection.DeleteObject(BucketName, identifier)
+	return nil
 }
 
 // CreateWebhook assign an ID to a new webhook and saves it.
 func (service *Service) Create(webhook *portainer.Webhook) error {
-	return service.connection.CreateObject(
-		BucketName,
-		func(id uint64) (int, interface{}) {
-			webhook.ID = portainer.WebhookID(id)
-			return int(webhook.ID), webhook
-		},
-	)
+	return nil
 }
 
 // UpdateWebhook update a webhook.
 func (service *Service) UpdateWebhook(ID portainer.WebhookID, webhook *portainer.Webhook) error {
-	identifier := service.connection.ConvertToKey(int(ID))
-	return service.connection.UpdateObject(BucketName, identifier, webhook)
+	return nil
 }

api/datastore/backup.go

@@ -1,184 +0,0 @@
-package datastore
-
-import (
-	"fmt"
-	"os"
-	"path"
-	"time"
-
-	"github.com/rs/zerolog/log"
-)
-
-var backupDefaults = struct {
-	backupDir string
-	commonDir string
-}{
-	"backups",
-	"common",
-}
-
-//
-// Backup Helpers
-//
-
-// createBackupFolders create initial folders for backups
-func (store *Store) createBackupFolders() {
-	// create common dir
-	commonDir := store.commonBackupDir()
-	if exists, _ := store.fileService.FileExists(commonDir); !exists {
-		if err := os.MkdirAll(commonDir, 0700); err != nil {
-			log.Error().Err(err).Msg("error while creating common backup folder")
-		}
-	}
-}
-
-func (store *Store) databasePath() string {
-	return store.connection.GetDatabaseFilePath()
-}
-
-func (store *Store) commonBackupDir() string {
-	return path.Join(store.connection.GetStorePath(), backupDefaults.backupDir, backupDefaults.commonDir)
-}
-
-func (store *Store) copyDBFile(from string, to string) error {
-	log.Info().Str("from", from).Str("to", to).Msg("copying DB file")
-
-	err := store.fileService.Copy(from, to, true)
-	if err != nil {
-		log.Error().Err(err).Msg("failed")
-	}
-
-	return err
-}
-
-// BackupOptions provide a helper to inject backup options
-type BackupOptions struct {
-	Version        int // I can't find this used for anything other than a filename
-	BackupDir      string
-	BackupFileName string
-	BackupPath     string
-}
-
-// getBackupRestoreOptions returns options to store db at common backup dir location; used by:
-// - db backup prior to version upgrade
-// - db rollback
-func getBackupRestoreOptions(backupDir string) *BackupOptions {
-	return &BackupOptions{
-		BackupDir:      backupDir, //connection.commonBackupDir(),
-		BackupFileName: beforePortainerVersionUpgradeBackup,
-	}
-}
-
-// Backup current database with default options
-func (store *Store) Backup() (string, error) {
-	return store.backupWithOptions(nil)
-}
-
-func (store *Store) setupOptions(options *BackupOptions) *BackupOptions {
-	if options == nil {
-		options = &BackupOptions{}
-	}
-	if options.Version == 0 {
-		version, err := store.version()
-		if err != nil {
-			version = 0
-		}
-		options.Version = version
-	}
-	if options.BackupDir == "" {
-		options.BackupDir = store.commonBackupDir()
-	}
-	if options.BackupFileName == "" {
-		options.BackupFileName = fmt.Sprintf("%s.%s.%s", store.connection.GetDatabaseFileName(), fmt.Sprintf("%03d", options.Version), time.Now().Format("20060102150405"))
-	}
-	if options.BackupPath == "" {
-		options.BackupPath = path.Join(options.BackupDir, options.BackupFileName)
-	}
-	return options
-}
-
-// BackupWithOptions backup current database with options
-func (store *Store) backupWithOptions(options *BackupOptions) (string, error) {
-	log.Info().Msg("creating DB backup")
-
-	store.createBackupFolders()
-
-	options = store.setupOptions(options)
-	dbPath := store.databasePath()
-
-	if err := store.Close(); err != nil {
-		return options.BackupPath, fmt.Errorf(
-			"error closing datastore before creating backup: %v",
-			err,
-		)
-	}
-
-	if err := store.copyDBFile(dbPath, options.BackupPath); err != nil {
-		return options.BackupPath, err
-	}
-
-	if _, err := store.Open(); err != nil {
-		return options.BackupPath, fmt.Errorf(
-			"error opening datastore after creating backup: %v",
-			err,
-		)
-	}
-
-	return options.BackupPath, nil
-}
-
-// RestoreWithOptions previously saved backup for the current Edition  with options
-// Restore strategies:
-// - default: restore latest from current edition
-// - restore a specific
-func (store *Store) restoreWithOptions(options *BackupOptions) error {
-	options = store.setupOptions(options)
-
-	// Check if backup file exist before restoring
-	_, err := os.Stat(options.BackupPath)
-	if os.IsNotExist(err) {
-		log.Error().Str("path", options.BackupPath).Err(err).Msg("backup file to restore does not exist %s")
-
-		return err
-	}
-
-	err = store.Close()
-	if err != nil {
-		log.Error().Err(err).Msg("error while closing store before restore")
-
-		return err
-	}
-
-	log.Info().Msg("restoring DB backup")
-	err = store.copyDBFile(options.BackupPath, store.databasePath())
-	if err != nil {
-		return err
-	}
-
-	_, err = store.Open()
-	return err
-}
-
-// RemoveWithOptions removes backup database based on supplied options
-func (store *Store) removeWithOptions(options *BackupOptions) error {
-	log.Info().Msg("removing DB backup")
-
-	options = store.setupOptions(options)
-	_, err := os.Stat(options.BackupPath)
-
-	if os.IsNotExist(err) {
-		log.Error().Str("path", options.BackupPath).Err(err).Msg("backup file to remove does not exist")
-
-		return err
-	}
-
-	log.Info().Str("path", options.BackupPath).Msg("removing DB file")
-	err = os.Remove(options.BackupPath)
-	if err != nil {
-		log.Error().Err(err).Msg("failed")
-
-		return err
-	}
-
-	return nil
-}

api/datastore/backup_test.go

@@ -1,108 +0,0 @@
-package datastore
-
-import (
-	"fmt"
-	"os"
-	"path"
-	"testing"
-
-	portainer "github.com/portainer/portainer/api"
-)
-
-func TestCreateBackupFolders(t *testing.T) {
-	_, store, teardown := MustNewTestStore(t, false, true)
-	defer teardown()
-
-	connection := store.GetConnection()
-	backupPath := path.Join(connection.GetStorePath(), backupDefaults.backupDir)
-
-	if isFileExist(backupPath) {
-		t.Error("Expect backups folder to not exist")
-	}
-
-	store.createBackupFolders()
-	if !isFileExist(backupPath) {
-		t.Error("Expect backups folder to exist")
-	}
-}
-
-func TestStoreCreation(t *testing.T) {
-	_, store, teardown := MustNewTestStore(t, true, true)
-	defer teardown()
-
-	if store == nil {
-		t.Error("Expect to create a store")
-	}
-
-	if store.CheckCurrentEdition() != nil {
-		t.Error("Expect to get CE Edition")
-	}
-}
-
-func TestBackup(t *testing.T) {
-	_, store, teardown := MustNewTestStore(t, true, true)
-	connection := store.GetConnection()
-	defer teardown()
-
-	t.Run("Backup should create default db backup", func(t *testing.T) {
-		store.VersionService.StoreDBVersion(portainer.DBVersion)
-		store.backupWithOptions(nil)
-
-		backupFileName := path.Join(connection.GetStorePath(), "backups", "common", fmt.Sprintf("portainer.edb.%03d.*", portainer.DBVersion))
-		if !isFileExist(backupFileName) {
-			t.Errorf("Expect backup file to be created %s", backupFileName)
-		}
-	})
-
-	t.Run("BackupWithOption should create a name specific backup at common path", func(t *testing.T) {
-		store.backupWithOptions(&BackupOptions{
-			BackupFileName: beforePortainerVersionUpgradeBackup,
-			BackupDir:      store.commonBackupDir(),
-		})
-		backupFileName := path.Join(connection.GetStorePath(), "backups", "common", beforePortainerVersionUpgradeBackup)
-		if !isFileExist(backupFileName) {
-			t.Errorf("Expect backup file to be created %s", backupFileName)
-		}
-	})
-}
-
-func TestRemoveWithOptions(t *testing.T) {
-	_, store, teardown := MustNewTestStore(t, true, true)
-	defer teardown()
-
-	t.Run("successfully removes file if existent", func(t *testing.T) {
-		store.createBackupFolders()
-		options := &BackupOptions{
-			BackupDir:      store.commonBackupDir(),
-			BackupFileName: "test.txt",
-		}
-
-		filePath := path.Join(options.BackupDir, options.BackupFileName)
-		f, err := os.Create(filePath)
-		if err != nil {
-			t.Fatalf("file should be created; err=%s", err)
-		}
-		f.Close()
-
-		err = store.removeWithOptions(options)
-		if err != nil {
-			t.Errorf("RemoveWithOptions should successfully remove file; err=%v", err)
-		}
-
-		if isFileExist(f.Name()) {
-			t.Errorf("RemoveWithOptions should successfully remove file; file=%s", f.Name())
-		}
-	})
-
-	t.Run("fails to removes file if non-existent", func(t *testing.T) {
-		options := &BackupOptions{
-			BackupDir:      store.commonBackupDir(),
-			BackupFileName: "test.txt",
-		}
-
-		err := store.removeWithOptions(options)
-		if err == nil {
-			t.Error("RemoveWithOptions should fail for non-existent file")
-		}
-	})
-}

api/datastore/datastore.go

@@ -1,16 +1,9 @@
 package datastore
 
 import (
-	"fmt"
-	"io"
-	"os"
-	"path"
-	"time"
-
 	portainer "github.com/portainer/portainer/api"
 	portainerErrors "github.com/portainer/portainer/api/dataservices/errors"
-
-	"github.com/rs/zerolog/log"
+	"gorm.io/gorm"
 )
 
 func (store *Store) version() (int, error) {
@@ -41,18 +34,6 @@ func NewStore(storePath string, fileService portainer.FileService, connection po
 func (store *Store) Open() (newStore bool, err error) {
 	newStore = true
 
-	encryptionReq, err := store.connection.NeedsEncryptionMigration()
-	if err != nil {
-		return false, err
-	}
-
-	if encryptionReq {
-		err = store.encryptDB()
-		if err != nil {
-			return false, err
-		}
-	}
-
 	err = store.connection.Open()
 	if err != nil {
 		return newStore, err
@@ -64,20 +45,20 @@ func (store *Store) Open() (newStore bool, err error) {
 	}
 
 	// if we have DBVersion in the database then ensure we flag this as NOT a new store
-	version, err := store.VersionService.DBVersion()
-	if err != nil {
-		if store.IsErrObjectNotFound(err) {
-			return newStore, nil
-		}
+	// version, err := store.VersionService.DBVersion()
+	// if err != nil {
+	// 	if store.IsErrObjectNotFound(err) {
+	// 		return newStore, nil
+	// 	}
 
-		return newStore, err
-	}
+	// 	return newStore, err
+	// }
 
-	if version > 0 {
-		log.Debug().Int("version", version).Msg("opened existing store")
+	// if version > 0 {
+	// 	log.Debug().Int("version", version).Msg("opened existing store")
 
-		return false, nil
-	}
+	// 	return false, nil
+	// }
 
 	return newStore, nil
 }
@@ -86,12 +67,6 @@ func (store *Store) Close() error {
 	return store.connection.Close()
 }
 
-// BackupTo backs up db to a provided writer.
-// It does hot backup and doesn't block other database reads and writes
-func (store *Store) BackupTo(w io.Writer) error {
-	return store.connection.BackupTo(w)
-}
-
 // CheckCurrentEdition checks if current edition is community edition
 func (store *Store) CheckCurrentEdition() error {
 	if store.edition() != portainer.PortainerCE {
@@ -102,78 +77,5 @@ func (store *Store) CheckCurrentEdition() error {
 
 // TODO: move the use of this to dataservices.IsErrObjectNotFound()?
 func (store *Store) IsErrObjectNotFound(e error) bool {
-	return e == portainerErrors.ErrObjectNotFound
-}
-
-func (store *Store) Rollback(force bool) error {
-	return store.connectionRollback(force)
-}
-
-func (store *Store) encryptDB() error {
-	store.connection.SetEncrypted(false)
-	err := store.connection.Open()
-	if err != nil {
-		return err
-	}
-
-	err = store.initServices()
-	if err != nil {
-		return err
-	}
-
-	// The DB is not currently encrypted.  First save the encrypted db filename
-	oldFilename := store.connection.GetDatabaseFilePath()
-	log.Info().Msg("encrypting database")
-
-	// export file path for backup
-	exportFilename := path.Join(store.databasePath() + "." + fmt.Sprintf("backup-%d.json", time.Now().Unix()))
-
-	log.Info().Str("filename", exportFilename).Msg("exporting database backup")
-
-	err = store.Export(exportFilename)
-	if err != nil {
-		log.Error().Str("filename", exportFilename).Err(err).Msg("failed to export")
-
-		return err
-	}
-
-	log.Info().Msg("database backup exported")
-
-	// Close existing un-encrypted db so that we can delete the file later
-	store.connection.Close()
-
-	// Tell the db layer to create an encrypted db when opened
-	store.connection.SetEncrypted(true)
-	store.connection.Open()
-
-	// We have to init services before import
-	err = store.initServices()
-	if err != nil {
-		return err
-	}
-
-	err = store.Import(exportFilename)
-	if err != nil {
-		// Remove the new encrypted file that we failed to import
-		os.Remove(store.connection.GetDatabaseFilePath())
-
-		log.Fatal().Err(portainerErrors.ErrDBImportFailed).Msg("")
-	}
-
-	err = os.Remove(oldFilename)
-	if err != nil {
-		log.Error().Msg("failed to remove the un-encrypted db file")
-	}
-
-	err = os.Remove(exportFilename)
-	if err != nil {
-		log.Error().Msg("failed to remove the json backup file")
-	}
-
-	// Close db connection
-	store.connection.Close()
-
-	log.Info().Msg("database successfully encrypted")
-
-	return nil
+	return e == gorm.ErrRecordNotFound
 }

api/datastore/datastore_test.go

@@ -1,417 +0,0 @@
-package datastore
-
-import (
-	"fmt"
-	"runtime"
-	"strings"
-	"testing"
-
-	"github.com/dchest/uniuri"
-	"github.com/pkg/errors"
-	portainer "github.com/portainer/portainer/api"
-	"github.com/portainer/portainer/api/chisel"
-	"github.com/portainer/portainer/api/crypto"
-	"github.com/stretchr/testify/assert"
-)
-
-const (
-	adminUsername                       = "admin"
-	adminPassword                       = "password"
-	standardUsername                    = "standard"
-	standardPassword                    = "password"
-	agentOnDockerEnvironmentUrl         = "tcp://192.168.167.207:30775"
-	edgeAgentOnKubernetesEnvironmentUrl = "tcp://192.168.167.207"
-	kubernetesLocalEnvironmentUrl       = "https://kubernetes.default.svc"
-)
-
-// TestStoreFull an eventually comprehensive set of tests for the Store.
-// The idea is what we write to the store, we should read back.
-func TestStoreFull(t *testing.T) {
-	_, store, teardown := MustNewTestStore(t, true, true)
-	defer teardown()
-
-	testCases := map[string]func(t *testing.T){
-		"User Accounts": func(t *testing.T) {
-			store.testUserAccounts(t)
-		},
-		"Environments": func(t *testing.T) {
-			store.testEnvironments(t)
-		},
-		"Settings": func(t *testing.T) {
-			store.testSettings(t)
-		},
-		"SSL Settings": func(t *testing.T) {
-			store.testSSLSettings(t)
-		},
-		"Tunnel Server": func(t *testing.T) {
-			store.testTunnelServer(t)
-		},
-		"Custom Templates": func(t *testing.T) {
-			store.testCustomTemplates(t)
-		},
-		"Registries": func(t *testing.T) {
-			store.testRegistries(t)
-		},
-		"Resource Control": func(t *testing.T) {
-			store.testResourceControl(t)
-		},
-		"Schedules": func(t *testing.T) {
-			store.testSchedules(t)
-		},
-		"Tags": func(t *testing.T) {
-			store.testTags(t)
-		},
-
-		// "Test Title": func(t *testing.T) {
-		// },
-	}
-
-	for name, test := range testCases {
-		t.Run(name, test)
-	}
-
-}
-
-func (store *Store) testEnvironments(t *testing.T) {
-	id := store.CreateEndpoint(t, "local", portainer.KubernetesLocalEnvironment, "", true)
-	store.CreateEndpointRelation(id)
-
-	id = store.CreateEndpoint(t, "agent", portainer.AgentOnDockerEnvironment, agentOnDockerEnvironmentUrl, true)
-	store.CreateEndpointRelation(id)
-
-	id = store.CreateEndpoint(t, "edge", portainer.EdgeAgentOnKubernetesEnvironment, edgeAgentOnKubernetesEnvironmentUrl, true)
-	store.CreateEndpointRelation(id)
-}
-
-func newEndpoint(endpointType portainer.EndpointType, id portainer.EndpointID, name, URL string, TLS bool) *portainer.Endpoint {
-	endpoint := &portainer.Endpoint{
-		ID:        id,
-		Name:      name,
-		URL:       URL,
-		Type:      endpointType,
-		GroupID:   portainer.EndpointGroupID(1),
-		PublicURL: "",
-		TLSConfig: portainer.TLSConfiguration{
-			TLS: false,
-		},
-		UserAccessPolicies: portainer.UserAccessPolicies{},
-		TeamAccessPolicies: portainer.TeamAccessPolicies{},
-		TagIDs:             []portainer.TagID{},
-		Status:             portainer.EndpointStatusUp,
-		Snapshots:          []portainer.DockerSnapshot{},
-		Kubernetes:         portainer.KubernetesDefault(),
-	}
-
-	if TLS {
-		endpoint.TLSConfig = portainer.TLSConfiguration{
-			TLS:           true,
-			TLSSkipVerify: true,
-		}
-	}
-
-	return endpoint
-}
-
-func setEndpointAuthorizations(endpoint *portainer.Endpoint) {
-	endpoint.SecuritySettings = portainer.EndpointSecuritySettings{
-		AllowVolumeBrowserForRegularUsers: false,
-		EnableHostManagementFeatures:      false,
-
-		AllowSysctlSettingForRegularUsers:         true,
-		AllowBindMountsForRegularUsers:            true,
-		AllowPrivilegedModeForRegularUsers:        true,
-		AllowHostNamespaceForRegularUsers:         true,
-		AllowContainerCapabilitiesForRegularUsers: true,
-		AllowDeviceMappingForRegularUsers:         true,
-		AllowStackManagementForRegularUsers:       true,
-	}
-}
-
-func (store *Store) CreateEndpoint(t *testing.T, name string, endpointType portainer.EndpointType, URL string, tls bool) portainer.EndpointID {
-	is := assert.New(t)
-
-	var expectedEndpoint *portainer.Endpoint
-	id := portainer.EndpointID(store.Endpoint().GetNextIdentifier())
-
-	switch endpointType {
-	case portainer.DockerEnvironment:
-		if URL == "" {
-			URL = "unix:///var/run/docker.sock"
-			if runtime.GOOS == "windows" {
-				URL = "npipe:////./pipe/docker_engine"
-			}
-		}
-		expectedEndpoint = newEndpoint(endpointType, id, name, URL, tls)
-
-	case portainer.AgentOnDockerEnvironment:
-		expectedEndpoint = newEndpoint(endpointType, id, name, URL, tls)
-
-	case portainer.AgentOnKubernetesEnvironment:
-		URL = strings.TrimPrefix(URL, "tcp://")
-		expectedEndpoint = newEndpoint(endpointType, id, name, URL, tls)
-
-	case portainer.EdgeAgentOnKubernetesEnvironment:
-		cs := chisel.NewService(store, nil)
-		expectedEndpoint = newEndpoint(endpointType, id, name, URL, tls)
-		edgeKey := cs.GenerateEdgeKey(URL, "", int(id))
-		expectedEndpoint.EdgeKey = edgeKey
-		store.testTunnelServer(t)
-
-	case portainer.KubernetesLocalEnvironment:
-		if URL == "" {
-			URL = kubernetesLocalEnvironmentUrl
-		}
-		expectedEndpoint = newEndpoint(endpointType, id, name, URL, tls)
-	}
-
-	setEndpointAuthorizations(expectedEndpoint)
-	store.Endpoint().Create(expectedEndpoint)
-
-	endpoint, err := store.Endpoint().Endpoint(id)
-	is.NoError(err, "Endpoint() should not return an error")
-	is.Equal(expectedEndpoint, endpoint, "endpoint should be the same")
-
-	return endpoint.ID
-}
-
-func (store *Store) CreateEndpointRelation(id portainer.EndpointID) {
-	relation := &portainer.EndpointRelation{
-		EndpointID: id,
-		EdgeStacks: map[portainer.EdgeStackID]bool{},
-	}
-
-	store.EndpointRelation().Create(relation)
-}
-
-func (store *Store) testSSLSettings(t *testing.T) {
-	is := assert.New(t)
-	ssl := &portainer.SSLSettings{
-		CertPath:    "/data/certs/cert.pem",
-		HTTPEnabled: true,
-		KeyPath:     "/data/certs/key.pem",
-		SelfSigned:  true,
-	}
-
-	store.SSLSettings().UpdateSettings(ssl)
-
-	settings, err := store.SSLSettings().Settings()
-	is.NoError(err, "Get sslsettings should succeed")
-	is.Equal(ssl, settings, "Stored SSLSettings should be the same as what is read out")
-}
-
-func (store *Store) testTunnelServer(t *testing.T) {
-	is := assert.New(t)
-	expectPrivateKeySeed := uniuri.NewLen(16)
-
-	err := store.TunnelServer().UpdateInfo(&portainer.TunnelServerInfo{PrivateKeySeed: expectPrivateKeySeed})
-	is.NoError(err, "UpdateInfo should have succeeded")
-
-	serverInfo, err := store.TunnelServer().Info()
-	is.NoError(err, "Info should have succeeded")
-
-	is.Equal(expectPrivateKeySeed, serverInfo.PrivateKeySeed, "hashed passwords should not differ")
-}
-
-// add users, read them back and check the details are unchanged
-func (store *Store) testUserAccounts(t *testing.T) {
-	is := assert.New(t)
-
-	err := store.createAccount(adminUsername, adminPassword, portainer.AdministratorRole)
-	is.NoError(err, "CreateAccount should succeed")
-	store.checkAccount(adminUsername, adminPassword, portainer.AdministratorRole)
-	is.NoError(err, "Account failure")
-
-	err = store.createAccount(standardUsername, standardPassword, portainer.StandardUserRole)
-	is.NoError(err, "CreateAccount should succeed")
-	store.checkAccount(standardUsername, standardPassword, portainer.StandardUserRole)
-	is.NoError(err, "Account failure")
-}
-
-// create an account with the provided details
-func (store *Store) createAccount(username, password string, role portainer.UserRole) error {
-	var err error
-	user := &portainer.User{Username: username, Role: role}
-
-	// encrypt the password
-	cs := &crypto.Service{}
-	user.Password, err = cs.Hash(password)
-	if err != nil {
-		return err
-	}
-
-	err = store.User().Create(user)
-	if err != nil {
-		return err
-	}
-
-	return nil
-}
-
-func (store *Store) checkAccount(username, expectPassword string, expectRole portainer.UserRole) error {
-	// Read the account for username.  Check password and role is what we expect
-
-	user, err := store.User().UserByUsername(username)
-	if err != nil {
-		return errors.Wrap(err, "failed to find user")
-	}
-
-	if user.Username != username || user.Role != expectRole {
-		return fmt.Errorf("%s user details do not match", user.Username)
-	}
-
-	// Check the password
-	cs := &crypto.Service{}
-	expectPasswordHash, err := cs.Hash(expectPassword)
-	if err != nil {
-		return errors.Wrap(err, "hash failed")
-	}
-
-	if user.Password != expectPasswordHash {
-		return fmt.Errorf("%s user password hash failure", user.Username)
-	}
-
-	return nil
-}
-
-func (store *Store) testSettings(t *testing.T) {
-	is := assert.New(t)
-
-	// since many settings are default and basically nil, I'm going to update some and read them back
-	expectedSettings, err := store.Settings().Settings()
-	is.NoError(err, "Settings() should not return an error")
-	expectedSettings.TemplatesURL = "http://portainer.io/application-templates"
-	expectedSettings.HelmRepositoryURL = "http://portainer.io/helm-repository"
-	expectedSettings.EdgeAgentCheckinInterval = 60
-	expectedSettings.AuthenticationMethod = portainer.AuthenticationLDAP
-	expectedSettings.LDAPSettings = portainer.LDAPSettings{
-		AnonymousMode:   true,
-		StartTLS:        true,
-		AutoCreateUsers: true,
-		Password:        "random",
-	}
-	expectedSettings.SnapshotInterval = "10m"
-
-	err = store.Settings().UpdateSettings(expectedSettings)
-	is.NoError(err, "UpdateSettings() should succeed")
-
-	settings, err := store.Settings().Settings()
-	is.NoError(err, "Settings() should not return an error")
-	is.Equal(expectedSettings, settings, "stored settings should match")
-}
-
-func (store *Store) testCustomTemplates(t *testing.T) {
-	is := assert.New(t)
-
-	customTemplate := store.CustomTemplate()
-	is.NotNil(customTemplate, "customTemplate Service shouldn't be nil")
-
-	expectedTemplate := &portainer.CustomTemplate{
-		ID:              portainer.CustomTemplateID(customTemplate.GetNextIdentifier()),
-		Title:           "Custom Title",
-		Description:     "Custom Template Description",
-		ProjectPath:     "/data/custom_template/1",
-		Note:            "A note about this custom template",
-		EntryPoint:      "docker-compose.yaml",
-		CreatedByUserID: 10,
-	}
-
-	customTemplate.Create(expectedTemplate)
-
-	actualTemplate, err := customTemplate.CustomTemplate(expectedTemplate.ID)
-	is.NoError(err, "CustomTemplate should not return an error")
-	is.Equal(expectedTemplate, actualTemplate, "expected and actual template do not match")
-}
-
-func (store *Store) testRegistries(t *testing.T) {
-	is := assert.New(t)
-
-	regService := store.RegistryService
-	is.NotNil(regService, "RegistryService shouldn't be nil")
-
-	reg1 := &portainer.Registry{
-		ID:   1,
-		Type: portainer.DockerHubRegistry,
-		Name: "Dockerhub Registry Test",
-	}
-
-	reg2 := &portainer.Registry{
-		ID:   2,
-		Type: portainer.GitlabRegistry,
-		Name: "Gitlab Registry Test",
-		Gitlab: portainer.GitlabRegistryData{
-			ProjectID:   12345,
-			InstanceURL: "http://gitlab.com/12345",
-			ProjectPath: "mytestproject",
-		},
-	}
-
-	err := regService.Create(reg1)
-	is.NoError(err)
-
-	err = regService.Create(reg2)
-	is.NoError(err)
-
-	actualReg1, err := regService.Registry(reg1.ID)
-	is.NoError(err)
-	is.Equal(reg1, actualReg1, "registries differ")
-
-	actualReg2, err := regService.Registry(reg2.ID)
-	is.NoError(err)
-	is.Equal(reg2, actualReg2, "registries differ")
-}
-
-func (store *Store) testResourceControl(t *testing.T) {
-	// is := assert.New(t)
-	// resControl := store.ResourceControl()
-	// ctrl := &portainer.ResourceControl{
-	// }
-	// resControl().Create()
-}
-
-func (store *Store) testSchedules(t *testing.T) {
-	is := assert.New(t)
-
-	schedule := store.ScheduleService
-	s := &portainer.Schedule{
-		ID:             portainer.ScheduleID(schedule.GetNextIdentifier()),
-		Name:           "My Custom Schedule 1",
-		CronExpression: "*/5 * * * * portainer /bin/sh -c echo 'hello world'",
-	}
-
-	err := schedule.CreateSchedule(s)
-	is.NoError(err, "CreateSchedule should succeed")
-
-	actual, err := schedule.Schedule(s.ID)
-	is.NoError(err, "schedule should be found")
-	is.Equal(s, actual, "schedules differ")
-}
-
-func (store *Store) testTags(t *testing.T) {
-	is := assert.New(t)
-
-	tags := store.TagService
-
-	tag1 := &portainer.Tag{
-		ID:   1,
-		Name: "Tag 1",
-	}
-
-	tag2 := &portainer.Tag{
-		ID:   2,
-		Name: "Tag 1",
-	}
-
-	err := tags.Create(tag1)
-	is.NoError(err, "Tags.Create should succeed")
-
-	err = tags.Create(tag2)
-	is.NoError(err, "Tags.Create should succeed")
-
-	actual, err := tags.Tag(tag1.ID)
-	is.NoError(err, "tag1 should be found")
-	is.Equal(tag1, actual, "tags differ")
-
-	actual, err = tags.Tag(tag2.ID)
-	is.NoError(err, "tag2 should be found")
-	is.Equal(tag2, actual, "tags differ")
-}

api/datastore/init.go

@@ -1,31 +1,41 @@
 package datastore
 
 import (
+	"fmt"
+
 	"github.com/gofrs/uuid"
 	portainer "github.com/portainer/portainer/api"
+	"github.com/portainer/portainer/api/database/models"
 )
 
 // Init creates the default data set.
 func (store *Store) Init() error {
-	err := store.checkOrCreateInstanceID()
+	conn := store.GetConnection()
+	err := conn.Init()
 	if err != nil {
 		return err
 	}
 
-	err = store.checkOrCreateDefaultSettings()
+	err = store.initVersions()
 	if err != nil {
 		return err
 	}
 
-	err = store.checkOrCreateDefaultSSLSettings()
-	if err != nil {
-		return err
-	}
+	// err = store.checkOrCreateDefaultSettings()
+	// if err != nil {
+	// 	return err
+	// }
 
-	return store.checkOrCreateDefaultData()
+	// err = store.checkOrCreateDefaultSSLSettings()
+	// if err != nil {
+	// 	return err
+	// }
+
+	// return store.checkOrCreateDefaultData()
+	return nil
 }
 
-func (store *Store) checkOrCreateInstanceID() error {
+func (store *Store) initVersions() error {
 	_, err := store.VersionService.InstanceID()
 	if store.IsErrObjectNotFound(err) {
 		uid, err := uuid.NewV4()
@@ -34,10 +44,37 @@ func (store *Store) checkOrCreateInstanceID() error {
 		}
 
 		instanceID := uid.String()
-		return store.VersionService.StoreInstanceID(instanceID)
+
+		db := store.connection.GetDB()
+
+		fmt.Println("updating instance id")
+		tx := db.Create(&models.Version{Key: models.InstanceKey, Value: instanceID})
+		if tx.Error != nil {
+			return tx.Error
+		}
+
+		fmt.Printf("updating version id %s\n", models.VersionKey)
+		tx = db.Create(&models.Version{Key: models.VersionKey, Value: fmt.Sprint(portainer.DBVersion)})
+		if tx.Error != nil {
+			return tx.Error
+		}
+
+		fmt.Println("updating updating id")
+		tx = db.Create(&models.Version{Key: models.UpdatingKey, Value: "false"})
+		if tx.Error != nil {
+			return tx.Error
+		}
+
+		fmt.Println("updating edition id")
+		tx = db.Create(&models.Version{Key: models.EditionKey, Value: fmt.Sprint(portainer.PortainerCE)})
+		if tx.Error != nil {
+			return tx.Error
+		}
+	} else {
+		return err
 	}
 
-	return err
+	return nil
 }
 
 func (store *Store) checkOrCreateDefaultSettings() error {

api/datastore/migrate_data.go

@@ -1,166 +0,0 @@
-package datastore
-
-import (
-	"fmt"
-	"runtime/debug"
-
-	portainer "github.com/portainer/portainer/api"
-	"github.com/portainer/portainer/api/cli"
-	"github.com/portainer/portainer/api/dataservices/errors"
-	"github.com/portainer/portainer/api/datastore/migrator"
-	"github.com/portainer/portainer/api/internal/authorization"
-
-	werrors "github.com/pkg/errors"
-	"github.com/rs/zerolog/log"
-)
-
-const beforePortainerVersionUpgradeBackup = "portainer.db.bak"
-
-func (store *Store) MigrateData() error {
-	version, err := store.version()
-	if err != nil {
-		return err
-	}
-
-	// Backup Database
-	backupPath, err := store.Backup()
-	if err != nil {
-		return werrors.Wrap(err, "while backing up db before migration")
-	}
-
-	migratorParams := &migrator.MigratorParameters{
-		DatabaseVersion:         version,
-		EndpointGroupService:    store.EndpointGroupService,
-		EndpointService:         store.EndpointService,
-		EndpointRelationService: store.EndpointRelationService,
-		ExtensionService:        store.ExtensionService,
-		FDOProfilesService:      store.FDOProfilesService,
-		RegistryService:         store.RegistryService,
-		ResourceControlService:  store.ResourceControlService,
-		RoleService:             store.RoleService,
-		ScheduleService:         store.ScheduleService,
-		SettingsService:         store.SettingsService,
-		SnapshotService:         store.SnapshotService,
-		StackService:            store.StackService,
-		TagService:              store.TagService,
-		TeamMembershipService:   store.TeamMembershipService,
-		UserService:             store.UserService,
-		VersionService:          store.VersionService,
-		FileService:             store.fileService,
-		DockerhubService:        store.DockerHubService,
-		AuthorizationService:    authorization.NewService(store),
-	}
-
-	// restore on error
-	err = store.connectionMigrateData(migratorParams)
-	if err != nil {
-		log.Error().Err(err).Msg("while DB migration, restoring DB")
-
-		// Restore options
-		options := BackupOptions{
-			BackupPath: backupPath,
-		}
-
-		err := store.restoreWithOptions(&options)
-		if err != nil {
-			log.Fatal().
-				Str("database_file", store.databasePath()).
-				Str("backup", options.BackupPath).Err(err).
-				Msg("failed restoring the backup, Portainer database file needs to restored manually by replacing the database file with a recent backup")
-		}
-	}
-
-	return err
-}
-
-// FailSafeMigrate backup and restore DB if migration fail
-func (store *Store) FailSafeMigrate(migrator *migrator.Migrator) (err error) {
-	defer func() {
-		if e := recover(); e != nil {
-			store.Rollback(true)
-			// return error with cause and stacktrace (recover() doesn't include a stacktrace)
-			err = fmt.Errorf("%v %s", e, string(debug.Stack()))
-		}
-	}()
-
-	// !Important: we must use a named return value in the function definition and not a local
-	// !variable referenced from the closure or else the return value will be incorrectly set
-	return migrator.Migrate()
-}
-
-// MigrateData automatically migrate the data based on the DBVersion.
-// This process is only triggered on an existing database, not if the database was just created.
-// if force is true, then migrate regardless.
-func (store *Store) connectionMigrateData(migratorParams *migrator.MigratorParameters) error {
-	migrator := migrator.NewMigrator(migratorParams)
-
-	// backup db file before upgrading DB to support rollback
-	isUpdating, err := migratorParams.VersionService.IsUpdating()
-	if err != nil && err != errors.ErrObjectNotFound {
-		return err
-	}
-
-	if !isUpdating && migrator.Version() != portainer.DBVersion {
-		err = store.backupVersion(migrator)
-		if err != nil {
-			return werrors.Wrapf(err, "failed to backup database")
-		}
-	}
-
-	if migrator.Version() < portainer.DBVersion {
-		log.Info().
-			Int("migrator_version", migrator.Version()).
-			Int("db_version", portainer.DBVersion).
-			Msg("migrating database")
-
-		err = store.FailSafeMigrate(migrator)
-		if err != nil {
-			log.Error().Err(err).Msg("an error occurred during database migration")
-
-			return err
-		}
-	}
-
-	return nil
-}
-
-// backupVersion will backup the database or panic if any errors occur
-func (store *Store) backupVersion(migrator *migrator.Migrator) error {
-	log.Info().Msg("backing up database prior to version upgrade")
-
-	options := getBackupRestoreOptions(store.commonBackupDir())
-
-	_, err := store.backupWithOptions(options)
-	if err != nil {
-		log.Error().Err(err).Msg("an error occurred during database backup")
-
-		removalErr := store.removeWithOptions(options)
-		if removalErr != nil {
-			log.Error().Err(err).Msg("an error occurred during store removal prior to backup")
-		}
-
-		return err
-	}
-
-	return nil
-}
-
-// Rollback to a pre-upgrade backup copy/snapshot of portainer.db
-func (store *Store) connectionRollback(force bool) error {
-
-	if !force {
-		confirmed, err := cli.Confirm("Are you sure you want to rollback your database to the previous backup?")
-		if err != nil || !confirmed {
-			return err
-		}
-	}
-
-	options := getBackupRestoreOptions(store.commonBackupDir())
-
-	err := store.restoreWithOptions(options)
-	if err != nil {
-		return err
-	}
-
-	return store.connection.Close()
-}

api/datastore/migrate_data_test.go

@@ -1,465 +0,0 @@
-package datastore
-
-import (
-	"bytes"
-	"encoding/json"
-	"fmt"
-	"io"
-	"os"
-	"path/filepath"
-	"strings"
-	"testing"
-
-	portainer "github.com/portainer/portainer/api"
-	"github.com/portainer/portainer/api/database/boltdb"
-
-	"github.com/google/go-cmp/cmp"
-	"github.com/rs/zerolog/log"
-)
-
-// testVersion is a helper which tests current store version against wanted version
-func testVersion(store *Store, versionWant int, t *testing.T) {
-	v, err := store.VersionService.DBVersion()
-	if err != nil {
-		t.Errorf("Expect store version to be %d but was %d with error: %s", versionWant, v, err)
-	}
-	if v != versionWant {
-		t.Errorf("Expect store version to be %d but was %d", versionWant, v)
-	}
-}
-
-func TestMigrateData(t *testing.T) {
-	snapshotTests := []struct {
-		testName string
-		srcPath  string
-		wantPath string
-	}{
-		{
-			testName: "migrate version 24 to latest",
-			srcPath:  "test_data/input_24.json",
-			wantPath: "test_data/output_24_to_latest.json",
-		},
-	}
-	for _, test := range snapshotTests {
-		t.Run(test.testName, func(t *testing.T) {
-			err := migrateDBTestHelper(t, test.srcPath, test.wantPath)
-			if err != nil {
-				t.Errorf(
-					"Failed migrating mock database %v: %v",
-					test.srcPath,
-					err,
-				)
-			}
-		})
-	}
-
-	t.Run("MigrateData for New Store & Re-Open Check", func(t *testing.T) {
-		newStore, store, teardown := MustNewTestStore(t, false, true)
-		defer teardown()
-
-		if !newStore {
-			t.Error("Expect a new DB")
-		}
-
-		// not called for new stores
-		//store.MigrateData()
-
-		testVersion(store, portainer.DBVersion, t)
-		store.Close()
-
-		newStore, _ = store.Open()
-		if newStore {
-			t.Error("Expect store to NOT be new DB")
-		}
-	})
-
-	tests := []struct {
-		version         int
-		expectedVersion int
-	}{
-		{version: 17, expectedVersion: portainer.DBVersion},
-		{version: 21, expectedVersion: portainer.DBVersion},
-	}
-	for _, tc := range tests {
-		_, store, teardown := MustNewTestStore(t, true, true)
-		defer teardown()
-
-		// Setup data
-		store.VersionService.StoreDBVersion(tc.version)
-
-		// Required roles by migrations 22.2
-		store.RoleService.Create(&portainer.Role{ID: 1})
-		store.RoleService.Create(&portainer.Role{ID: 2})
-		store.RoleService.Create(&portainer.Role{ID: 3})
-		store.RoleService.Create(&portainer.Role{ID: 4})
-
-		t.Run(fmt.Sprintf("MigrateData for version %d", tc.version), func(t *testing.T) {
-			store.MigrateData()
-			testVersion(store, tc.expectedVersion, t)
-		})
-
-		t.Run(fmt.Sprintf("Restoring DB after migrateData for version %d", tc.version), func(t *testing.T) {
-			store.Rollback(true)
-			store.Open()
-			testVersion(store, tc.version, t)
-		})
-	}
-
-	t.Run("Error in MigrateData should restore backup before MigrateData", func(t *testing.T) {
-		_, store, teardown := MustNewTestStore(t, false, true)
-		defer teardown()
-
-		version := 17
-		store.VersionService.StoreDBVersion(version)
-
-		store.MigrateData()
-
-		testVersion(store, version, t)
-	})
-
-	t.Run("MigrateData should create backup file upon update", func(t *testing.T) {
-		_, store, teardown := MustNewTestStore(t, false, true)
-		defer teardown()
-		store.VersionService.StoreDBVersion(0)
-
-		store.MigrateData()
-
-		options := store.setupOptions(getBackupRestoreOptions(store.commonBackupDir()))
-
-		if !isFileExist(options.BackupPath) {
-			t.Errorf("Backup file should exist; file=%s", options.BackupPath)
-		}
-	})
-
-	t.Run("MigrateData should fail to create backup if database file is set to updating", func(t *testing.T) {
-		_, store, teardown := MustNewTestStore(t, false, true)
-		defer teardown()
-
-		store.VersionService.StoreIsUpdating(true)
-
-		store.MigrateData()
-
-		options := store.setupOptions(getBackupRestoreOptions(store.commonBackupDir()))
-
-		if isFileExist(options.BackupPath) {
-			t.Errorf("Backup file should not exist for dirty database; file=%s", options.BackupPath)
-		}
-	})
-
-	t.Run("MigrateData should not create backup on startup if portainer version matches db", func(t *testing.T) {
-		_, store, teardown := MustNewTestStore(t, false, true)
-		defer teardown()
-
-		store.MigrateData()
-
-		options := store.setupOptions(getBackupRestoreOptions(store.commonBackupDir()))
-
-		if isFileExist(options.BackupPath) {
-			t.Errorf("Backup file should not exist for dirty database; file=%s", options.BackupPath)
-		}
-	})
-}
-
-func Test_getBackupRestoreOptions(t *testing.T) {
-	_, store, teardown := MustNewTestStore(t, false, true)
-	defer teardown()
-
-	options := getBackupRestoreOptions(store.commonBackupDir())
-
-	wantDir := store.commonBackupDir()
-	if !strings.HasSuffix(options.BackupDir, wantDir) {
-		log.Fatal().Str("got", options.BackupDir).Str("want", wantDir).Msg("incorrect backup dir")
-	}
-
-	wantFilename := "portainer.db.bak"
-	if options.BackupFileName != wantFilename {
-		log.Fatal().Str("got", options.BackupFileName).Str("want", wantFilename).Msg("incorrect backup file")
-	}
-}
-
-func TestRollback(t *testing.T) {
-	t.Run("Rollback should restore upgrade after backup", func(t *testing.T) {
-		version := 21
-		_, store, teardown := MustNewTestStore(t, false, true)
-		defer teardown()
-		store.VersionService.StoreDBVersion(version)
-
-		_, err := store.backupWithOptions(getBackupRestoreOptions(store.commonBackupDir()))
-		if err != nil {
-			log.Fatal().Err(err).Msg("")
-		}
-
-		// Change the current edition
-		err = store.VersionService.StoreDBVersion(version + 10)
-		if err != nil {
-			log.Fatal().Err(err).Msg("")
-		}
-
-		err = store.Rollback(true)
-		if err != nil {
-			t.Logf("Rollback failed: %s", err)
-			t.Fail()
-
-			return
-		}
-
-		store.Open()
-		testVersion(store, version, t)
-	})
-}
-
-// isFileExist is helper function to check for file existence
-func isFileExist(path string) bool {
-	matches, err := filepath.Glob(path)
-	if err != nil {
-		return false
-	}
-	return len(matches) > 0
-}
-
-// migrateDBTestHelper loads a json representation of a bolt database from srcPath,
-// parses it into a database, runs a migration on that database, and then
-// compares it with an expected output database.
-func migrateDBTestHelper(t *testing.T, srcPath, wantPath string) error {
-	srcJSON, err := os.ReadFile(srcPath)
-	if err != nil {
-		t.Fatalf("failed loading source JSON file %v: %v", srcPath, err)
-	}
-
-	// Parse source json to db.
-	_, store, teardown := MustNewTestStore(t, true, false)
-	defer teardown()
-	err = importJSON(t, bytes.NewReader(srcJSON), store)
-	if err != nil {
-		return err
-	}
-
-	// Run the actual migrations on our input database.
-	err = store.MigrateData()
-	if err != nil {
-		return err
-	}
-
-	// Assert that our database connection is using bolt so we can call
-	// exportJson rather than ExportRaw. The exportJson function allows us to
-	// strip out the metadata which we don't want for our tests.
-	// TODO: update connection interface in CE to allow us to use ExportRaw and pass meta false
-	err = store.connection.Close()
-	if err != nil {
-		t.Fatalf("err closing bolt connection: %v", err)
-	}
-	con, ok := store.connection.(*boltdb.DbConnection)
-	if !ok {
-		t.Fatalf("backing database is not using boltdb, but the migrations test requires it")
-	}
-
-	// Convert database back to json.
-	databasePath := con.GetDatabaseFilePath()
-	if _, err := os.Stat(databasePath); err != nil {
-		return fmt.Errorf("stat on %s failed: %s", databasePath, err)
-	}
-
-	gotJSON, err := con.ExportJSON(databasePath, false)
-	if err != nil {
-		t.Logf(
-			"failed re-exporting database %s to JSON: %v",
-			databasePath,
-			err,
-		)
-	}
-
-	wantJSON, err := os.ReadFile(wantPath)
-	if err != nil {
-		t.Fatalf("failed loading want JSON file %v: %v", wantPath, err)
-	}
-
-	// Compare the result we got with the one we wanted.
-	if diff := cmp.Diff(wantJSON, gotJSON); diff != "" {
-		gotPath := filepath.Join(t.TempDir(), "portainer-migrator-test-fail.json")
-		os.WriteFile(
-			gotPath,
-			gotJSON,
-			0600,
-		)
-		t.Errorf(
-			"migrate data from %s to %s failed\nwrote migrated input to %s\nmismatch (-want +got):\n%s",
-			srcPath,
-			wantPath,
-			gotPath,
-			diff,
-		)
-	}
-	return nil
-}
-
-// importJSON reads input JSON and commits it to a portainer datastore.Store.
-// Errors are logged with the testing package.
-func importJSON(t *testing.T, r io.Reader, store *Store) error {
-	objects := make(map[string]interface{})
-
-	// Parse json into map of objects.
-	d := json.NewDecoder(r)
-	d.UseNumber()
-	err := d.Decode(&objects)
-	if err != nil {
-		return err
-	}
-
-	// Get database connection from store.
-	con := store.connection
-
-	for k, v := range objects {
-		switch k {
-		case "version":
-			versions, ok := v.(map[string]interface{})
-			if !ok {
-				t.Logf("failed casting %s to map[string]interface{}", k)
-			}
-
-			dbVersion, ok := versions["DB_VERSION"]
-			if !ok {
-				t.Logf("failed getting DB_VERSION from %s", k)
-			}
-
-			numDBVersion, ok := dbVersion.(json.Number)
-			if !ok {
-				t.Logf("failed parsing DB_VERSION as json number from %s", k)
-			}
-
-			intDBVersion, err := numDBVersion.Int64()
-			if err != nil {
-				t.Logf("failed casting %v to int: %v", numDBVersion, intDBVersion)
-			}
-
-			err = con.CreateObjectWithStringId(
-				k,
-				[]byte("DB_VERSION"),
-				int(intDBVersion),
-			)
-			if err != nil {
-				t.Logf("failed writing DB_VERSION in %s: %v", k, err)
-			}
-
-			instanceID, ok := versions["INSTANCE_ID"]
-			if !ok {
-				t.Logf("failed getting INSTANCE_ID from %s", k)
-			}
-
-			err = con.CreateObjectWithStringId(
-				k,
-				[]byte("INSTANCE_ID"),
-				instanceID,
-			)
-			if err != nil {
-				t.Logf("failed writing INSTANCE_ID in %s: %v", k, err)
-			}
-
-		case "dockerhub":
-			obj, ok := v.([]interface{})
-			if !ok {
-				t.Logf("failed to cast %s to []interface{}", k)
-			}
-			err := con.CreateObjectWithStringId(
-				k,
-				[]byte("DOCKERHUB"),
-				obj[0],
-			)
-			if err != nil {
-				t.Logf("failed writing DOCKERHUB in %s: %v", k, err)
-			}
-
-		case "ssl":
-			obj, ok := v.(map[string]interface{})
-			if !ok {
-				t.Logf("failed to case %s to map[string]interface{}", k)
-			}
-			err := con.CreateObjectWithStringId(
-				k,
-				[]byte("SSL"),
-				obj,
-			)
-			if err != nil {
-				t.Logf("failed writing SSL in %s: %v", k, err)
-			}
-
-		case "settings":
-			obj, ok := v.(map[string]interface{})
-			if !ok {
-				t.Logf("failed to case %s to map[string]interface{}", k)
-			}
-			err := con.CreateObjectWithStringId(
-				k,
-				[]byte("SETTINGS"),
-				obj,
-			)
-			if err != nil {
-				t.Logf("failed writing SETTINGS in %s: %v", k, err)
-			}
-
-		case "tunnel_server":
-			obj, ok := v.(map[string]interface{})
-			if !ok {
-				t.Logf("failed to case %s to map[string]interface{}", k)
-			}
-			err := con.CreateObjectWithStringId(
-				k,
-				[]byte("INFO"),
-				obj,
-			)
-			if err != nil {
-				t.Logf("failed writing INFO in %s: %v", k, err)
-			}
-		case "templates":
-			continue
-
-		default:
-			objlist, ok := v.([]interface{})
-			if !ok {
-				t.Logf("failed to cast %s to []interface{}", k)
-			}
-
-			for _, obj := range objlist {
-				value, ok := obj.(map[string]interface{})
-				if !ok {
-					t.Logf("failed to cast %v to map[string]interface{}", obj)
-				} else {
-					var ok bool
-					var id interface{}
-					switch k {
-					case "endpoint_relations":
-						// TODO: need to make into an int, then do that weird
-						// stringification
-						id, ok = value["EndpointID"]
-					default:
-						id, ok = value["Id"]
-					}
-					if !ok {
-						// endpoint_relations: EndpointID
-						t.Logf("missing Id field: %s", k)
-						id = "error"
-					}
-					n, ok := id.(json.Number)
-					if !ok {
-						t.Logf("failed to cast %v to json.Number in %s", id, k)
-					} else {
-						key, err := n.Int64()
-						if err != nil {
-							t.Logf("failed to cast %v to int in %s", n, k)
-						} else {
-							err := con.CreateObjectWithId(
-								k,
-								int(key),
-								value,
-							)
-							if err != nil {
-								t.Logf("failed writing %v in %s: %v", key, k, err)
-							}
-						}
-					}
-				}
-			}
-		}
-	}
-
-	return nil
-}

api/datastore/migrate_dbversion29_test.go

@@ -1,91 +0,0 @@
-package datastore
-
-import (
-	"testing"
-
-	portainer "github.com/portainer/portainer/api"
-	"github.com/portainer/portainer/api/datastore/migrator"
-	"github.com/portainer/portainer/api/internal/authorization"
-)
-
-const dummyLogoURL = "example.com"
-
-// initTestingDBConn creates a settings service with raw database DB connection
-// for unit testing usage only since using NewStore will cause cycle import inside migrator pkg
-func initTestingSettingsService(dbConn portainer.Connection, preSetObj map[string]interface{}) error {
-	//insert a obj
-	if err := dbConn.UpdateObject("settings", []byte("SETTINGS"), preSetObj); err != nil {
-		return err
-	}
-	return nil
-}
-
-func setup(store *Store) error {
-	var err error
-	dummySettingsObj := map[string]interface{}{
-		"LogoURL": dummyLogoURL,
-	}
-	err = initTestingSettingsService(store.connection, dummySettingsObj)
-	if err != nil {
-		return err
-	}
-	return nil
-}
-
-func TestMigrateSettings(t *testing.T) {
-	_, store, teardown := MustNewTestStore(t, false, true)
-	defer teardown()
-
-	err := setup(store)
-	if err != nil {
-		t.Errorf("failed to complete testing setups, err: %v", err)
-	}
-
-	updatedSettings, err := store.SettingsService.Settings()
-	// SO -basically, this test _isn't_ testing migration, its testing golang type defaults.
-	if updatedSettings.LogoURL != dummyLogoURL { // ensure a pre-migrate setting isn't unset
-		t.Errorf("unexpected value changes in the updated settings, want LogoURL value: %s, got LogoURL value: %s", dummyLogoURL, updatedSettings.LogoURL)
-	}
-	if updatedSettings.OAuthSettings.SSO != false { // I recon golang defaulting will make this false
-		t.Errorf("unexpected default OAuth SSO setting, want: false, got: %t", updatedSettings.OAuthSettings.SSO)
-	}
-	if updatedSettings.OAuthSettings.LogoutURI != "" {
-		t.Errorf("unexpected default OAuth HideInternalAuth setting, want:, got: %s", updatedSettings.OAuthSettings.LogoutURI)
-	}
-
-	m := migrator.NewMigrator(&migrator.MigratorParameters{
-		DatabaseVersion:         29,
-		EndpointGroupService:    store.EndpointGroupService,
-		EndpointService:         store.EndpointService,
-		EndpointRelationService: store.EndpointRelationService,
-		ExtensionService:        store.ExtensionService,
-		RegistryService:         store.RegistryService,
-		ResourceControlService:  store.ResourceControlService,
-		RoleService:             store.RoleService,
-		ScheduleService:         store.ScheduleService,
-		SettingsService:         store.SettingsService,
-		StackService:            store.StackService,
-		TagService:              store.TagService,
-		TeamMembershipService:   store.TeamMembershipService,
-		UserService:             store.UserService,
-		VersionService:          store.VersionService,
-		FileService:             store.fileService,
-		DockerhubService:        store.DockerHubService,
-		AuthorizationService:    authorization.NewService(store),
-	})
-	if err := m.MigrateSettingsToDB30(); err != nil {
-		t.Errorf("failed to update settings: %v", err)
-	}
-	if err != nil {
-		t.Errorf("failed to retrieve the updated settings: %v", err)
-	}
-	if updatedSettings.LogoURL != dummyLogoURL {
-		t.Errorf("unexpected value changes in the updated settings, want LogoURL value: %s, got LogoURL value: %s", dummyLogoURL, updatedSettings.LogoURL)
-	}
-	if updatedSettings.OAuthSettings.SSO != false {
-		t.Errorf("unexpected default OAuth SSO setting, want: false, got: %t", updatedSettings.OAuthSettings.SSO)
-	}
-	if updatedSettings.OAuthSettings.LogoutURI != "" {
-		t.Errorf("unexpected default OAuth HideInternalAuth setting, want:, got: %s", updatedSettings.OAuthSettings.LogoutURI)
-	}
-}

api/datastore/migrate_dbversion33_test.go

@@ -1,53 +0,0 @@
-package datastore
-
-import (
-	"testing"
-
-	portainer "github.com/portainer/portainer/api"
-	"github.com/portainer/portainer/api/datastore/migrator"
-	gittypes "github.com/portainer/portainer/api/git/types"
-	"github.com/stretchr/testify/assert"
-)
-
-func TestMigrateStackEntryPoint(t *testing.T) {
-	_, store, teardown := MustNewTestStore(t, false, true)
-	defer teardown()
-
-	stackService := store.Stack()
-
-	stacks := []*portainer.Stack{
-		{
-			ID:         1,
-			EntryPoint: "dir/sub/compose.yml",
-		},
-		{
-			ID:         2,
-			EntryPoint: "dir/sub/compose.yml",
-			GitConfig:  &gittypes.RepoConfig{},
-		},
-	}
-
-	for _, s := range stacks {
-		err := stackService.Create(s)
-		assert.NoError(t, err, "failed to create stack")
-	}
-
-	s, err := stackService.Stack(1)
-	assert.NoError(t, err)
-	assert.Nil(t, s.GitConfig, "first stack should not have git config")
-
-	s, err = stackService.Stack(2)
-	assert.NoError(t, err)
-	assert.Equal(t, "", s.GitConfig.ConfigFilePath, "not migrated yet migrated")
-
-	err = migrator.MigrateStackEntryPoint(stackService)
-	assert.NoError(t, err, "failed to migrate entry point to Git ConfigFilePath")
-
-	s, err = stackService.Stack(1)
-	assert.NoError(t, err)
-	assert.Nil(t, s.GitConfig, "first stack should not have git config")
-
-	s, err = stackService.Stack(2)
-	assert.NoError(t, err)
-	assert.Equal(t, "dir/sub/compose.yml", s.GitConfig.ConfigFilePath, "second stack should have config file path migrated")
-}

api/datastore/migrator/migrate_ce.go

@@ -1,143 +0,0 @@
-package migrator
-
-import (
-	"reflect"
-	"runtime"
-
-	portainer "github.com/portainer/portainer/api"
-
-	"github.com/pkg/errors"
-	"github.com/rs/zerolog/log"
-)
-
-type migration struct {
-	dbversion int
-	migrate   func() error
-}
-
-func migrationError(err error, context string) error {
-	return errors.Wrap(err, "failed in "+context)
-}
-
-func newMigration(dbversion int, migrate func() error) migration {
-	return migration{
-		dbversion: dbversion,
-		migrate:   migrate,
-	}
-}
-
-func dbTooOldError() error {
-	return errors.New("migrating from less than Portainer 1.21.0 is not supported, please contact Portainer support.")
-}
-
-func GetFunctionName(i interface{}) string {
-	return runtime.FuncForPC(reflect.ValueOf(i).Pointer()).Name()
-}
-
-// Migrate checks the database version and migrate the existing data to the most recent data model.
-func (m *Migrator) Migrate() error {
-	// set DB to updating status
-	err := m.versionService.StoreIsUpdating(true)
-	if err != nil {
-		return migrationError(err, "StoreIsUpdating")
-	}
-
-	migrations := []migration{
-		// Portainer < 1.21.0
-		newMigration(17, dbTooOldError),
-
-		// Portainer 1.21.0
-		newMigration(18, m.updateUsersToDBVersion18),
-		newMigration(18, m.updateEndpointsToDBVersion18),
-		newMigration(18, m.updateEndpointGroupsToDBVersion18),
-		newMigration(18, m.updateRegistriesToDBVersion18),
-
-		// 1.22.0
-		newMigration(19, m.updateSettingsToDBVersion19),
-
-		// 1.22.1
-		newMigration(20, m.updateUsersToDBVersion20),
-		newMigration(20, m.updateSettingsToDBVersion20),
-		newMigration(20, m.updateSchedulesToDBVersion20),
-
-		// Portainer 1.23.0
-		// DBVersion 21 is missing as it was shipped as via hotfix 1.22.2
-		newMigration(22, m.updateResourceControlsToDBVersion22),
-		newMigration(22, m.updateUsersAndRolesToDBVersion22),
-
-		// Portainer 1.24.0
-		newMigration(23, m.updateTagsToDBVersion23),
-		newMigration(23, m.updateEndpointsAndEndpointGroupsToDBVersion23),
-
-		// Portainer 1.24.1
-		newMigration(24, m.updateSettingsToDB24),
-
-		// Portainer 2.0.0
-		newMigration(25, m.updateSettingsToDB25),
-		newMigration(25, m.updateStacksToDB24), // yes this looks odd. Don't be tempted to move it
-
-		// Portainer 2.1.0
-		newMigration(26, m.updateEndpointSettingsToDB25),
-
-		// Portainer 2.2.0
-		newMigration(27, m.updateStackResourceControlToDB27),
-
-		// Portainer 2.6.0
-		newMigration(30, m.migrateDBVersionToDB30),
-
-		// Portainer 2.9.0
-		newMigration(32, m.migrateDBVersionToDB32),
-
-		// Portainer 2.9.1, 2.9.2
-		newMigration(33, m.migrateDBVersionToDB33),
-
-		// Portainer 2.10
-		newMigration(34, m.migrateDBVersionToDB34),
-
-		// Portainer 2.9.3 (yep out of order, but 2.10 is EE only)
-		newMigration(35, m.migrateDBVersionToDB35),
-
-		newMigration(36, m.migrateDBVersionToDB36),
-
-		// Portainer 2.13
-		newMigration(40, m.migrateDBVersionToDB40),
-
-		// Portainer 2.14
-		newMigration(50, m.migrateDBVersionToDB50),
-
-		// Portainer 2.15
-		newMigration(60, m.migrateDBVersionToDB60),
-
-		// Portainer 2.16
-		newMigration(70, m.migrateDBVersionToDB70),
-	}
-
-	var lastDbVersion int
-	for _, migration := range migrations {
-		if m.currentDBVersion < migration.dbversion {
-
-			// Print the next line only when the version changes
-			if migration.dbversion > lastDbVersion {
-				log.Info().Int("to_version", migration.dbversion).Msg("migrating DB")
-			}
-
-			err := migration.migrate()
-			if err != nil {
-				return migrationError(err, GetFunctionName(migration.migrate))
-			}
-		}
-		lastDbVersion = migration.dbversion
-	}
-
-	log.Info().Int("version", portainer.DBVersion).Msg("setting DB version")
-
-	err = m.versionService.StoreDBVersion(portainer.DBVersion)
-	if err != nil {
-		return migrationError(err, "StoreDBVersion")
-	}
-
-	log.Info().Int("version", portainer.DBVersion).Msg("updated DB version")
-
-	// reset DB updating status
-	return m.versionService.StoreIsUpdating(false)
-}

api/datastore/migrator/migrate_dbversion17.go

@@ -1,135 +0,0 @@
-package migrator
-
-import (
-	portainer "github.com/portainer/portainer/api"
-
-	"github.com/rs/zerolog/log"
-)
-
-func (m *Migrator) updateUsersToDBVersion18() error {
-	log.Info().Msg("updating users")
-
-	legacyUsers, err := m.userService.Users()
-	if err != nil {
-		return err
-	}
-
-	for _, user := range legacyUsers {
-		user.PortainerAuthorizations = map[portainer.Authorization]bool{
-			portainer.OperationPortainerDockerHubInspect:        true,
-			portainer.OperationPortainerEndpointGroupList:       true,
-			portainer.OperationPortainerEndpointList:            true,
-			portainer.OperationPortainerEndpointInspect:         true,
-			portainer.OperationPortainerEndpointExtensionAdd:    true,
-			portainer.OperationPortainerEndpointExtensionRemove: true,
-			portainer.OperationPortainerExtensionList:           true,
-			portainer.OperationPortainerMOTD:                    true,
-			portainer.OperationPortainerRegistryList:            true,
-			portainer.OperationPortainerRegistryInspect:         true,
-			portainer.OperationPortainerTeamList:                true,
-			portainer.OperationPortainerTemplateList:            true,
-			portainer.OperationPortainerTemplateInspect:         true,
-			portainer.OperationPortainerUserList:                true,
-			portainer.OperationPortainerUserMemberships:         true,
-		}
-
-		err = m.userService.UpdateUser(user.ID, &user)
-		if err != nil {
-			return err
-		}
-	}
-
-	return nil
-}
-
-func (m *Migrator) updateEndpointsToDBVersion18() error {
-	log.Info().Msg("updating endpoints")
-
-	legacyEndpoints, err := m.endpointService.Endpoints()
-	if err != nil {
-		return err
-	}
-
-	for _, endpoint := range legacyEndpoints {
-		endpoint.UserAccessPolicies = make(portainer.UserAccessPolicies)
-		for _, userID := range endpoint.AuthorizedUsers {
-			endpoint.UserAccessPolicies[userID] = portainer.AccessPolicy{
-				RoleID: 4,
-			}
-		}
-
-		endpoint.TeamAccessPolicies = make(portainer.TeamAccessPolicies)
-		for _, teamID := range endpoint.AuthorizedTeams {
-			endpoint.TeamAccessPolicies[teamID] = portainer.AccessPolicy{
-				RoleID: 4,
-			}
-		}
-
-		err = m.endpointService.UpdateEndpoint(endpoint.ID, &endpoint)
-		if err != nil {
-			return err
-		}
-	}
-
-	return nil
-}
-
-func (m *Migrator) updateEndpointGroupsToDBVersion18() error {
-	log.Info().Msg("updating endpoint groups")
-
-	legacyEndpointGroups, err := m.endpointGroupService.EndpointGroups()
-	if err != nil {
-		return err
-	}
-
-	for _, endpointGroup := range legacyEndpointGroups {
-		endpointGroup.UserAccessPolicies = make(portainer.UserAccessPolicies)
-		for _, userID := range endpointGroup.AuthorizedUsers {
-			endpointGroup.UserAccessPolicies[userID] = portainer.AccessPolicy{
-				RoleID: 4,
-			}
-		}
-
-		endpointGroup.TeamAccessPolicies = make(portainer.TeamAccessPolicies)
-		for _, teamID := range endpointGroup.AuthorizedTeams {
-			endpointGroup.TeamAccessPolicies[teamID] = portainer.AccessPolicy{
-				RoleID: 4,
-			}
-		}
-
-		err = m.endpointGroupService.UpdateEndpointGroup(endpointGroup.ID, &endpointGroup)
-		if err != nil {
-			return err
-		}
-	}
-
-	return nil
-}
-
-func (m *Migrator) updateRegistriesToDBVersion18() error {
-	log.Info().Msg("updating registries")
-
-	legacyRegistries, err := m.registryService.Registries()
-	if err != nil {
-		return err
-	}
-
-	for _, registry := range legacyRegistries {
-		registry.UserAccessPolicies = make(portainer.UserAccessPolicies)
-		for _, userID := range registry.AuthorizedUsers {
-			registry.UserAccessPolicies[userID] = portainer.AccessPolicy{}
-		}
-
-		registry.TeamAccessPolicies = make(portainer.TeamAccessPolicies)
-		for _, teamID := range registry.AuthorizedTeams {
-			registry.TeamAccessPolicies[teamID] = portainer.AccessPolicy{}
-		}
-
-		err = m.registryService.UpdateRegistry(registry.ID, &registry)
-		if err != nil {
-			return err
-		}
-	}
-
-	return nil
-}

api/datastore/migrator/migrate_dbversion18.go

@@ -1,22 +0,0 @@
-package migrator
-
-import (
-	portainer "github.com/portainer/portainer/api"
-
-	"github.com/rs/zerolog/log"
-)
-
-func (m *Migrator) updateSettingsToDBVersion19() error {
-	log.Info().Msg("updating settings")
-
-	legacySettings, err := m.settingsService.Settings()
-	if err != nil {
-		return err
-	}
-
-	if legacySettings.EdgeAgentCheckinInterval == 0 {
-		legacySettings.EdgeAgentCheckinInterval = portainer.DefaultEdgeAgentCheckinIntervalInSeconds
-	}
-
-	return m.settingsService.UpdateSettings(legacySettings)
-}

api/datastore/migrator/migrate_dbversion19.go

@@ -1,64 +0,0 @@
-package migrator
-
-import (
-	"strings"
-
-	"github.com/rs/zerolog/log"
-)
-
-const scheduleScriptExecutionJobType = 1
-
-func (m *Migrator) updateUsersToDBVersion20() error {
-	log.Info().Msg("updating user authentication")
-
-	return m.authorizationService.UpdateUsersAuthorizations()
-}
-
-func (m *Migrator) updateSettingsToDBVersion20() error {
-	log.Info().Msg("updating settings")
-	legacySettings, err := m.settingsService.Settings()
-	if err != nil {
-		return err
-	}
-
-	legacySettings.AllowVolumeBrowserForRegularUsers = false
-
-	return m.settingsService.UpdateSettings(legacySettings)
-}
-
-func (m *Migrator) updateSchedulesToDBVersion20() error {
-	log.Info().Msg("updating schedules")
-
-	legacySchedules, err := m.scheduleService.Schedules()
-	if err != nil {
-		return err
-	}
-
-	for _, schedule := range legacySchedules {
-		if schedule.JobType == scheduleScriptExecutionJobType {
-			if schedule.CronExpression == "0 0 * * *" {
-				schedule.CronExpression = "0 * * * *"
-			} else if schedule.CronExpression == "0 0 0/2 * *" {
-				schedule.CronExpression = "0 */2 * * *"
-			} else if schedule.CronExpression == "0 0 0 * *" {
-				schedule.CronExpression = "0 0 * * *"
-			} else {
-				revisedCronExpression := strings.Split(schedule.CronExpression, " ")
-				if len(revisedCronExpression) == 5 {
-					continue
-				}
-
-				revisedCronExpression = revisedCronExpression[1:]
-				schedule.CronExpression = strings.Join(revisedCronExpression, " ")
-			}
-
-			err := m.scheduleService.UpdateSchedule(schedule.ID, &schedule)
-			if err != nil {
-				return err
-			}
-		}
-
-	}
-
-	return nil
-}

api/datastore/migrator/migrate_dbversion20.go

@@ -1,91 +0,0 @@
-package migrator
-
-import (
-	portainer "github.com/portainer/portainer/api"
-	"github.com/portainer/portainer/api/internal/authorization"
-
-	"github.com/rs/zerolog/log"
-)
-
-func (m *Migrator) updateResourceControlsToDBVersion22() error {
-	log.Info().Msg("updating resource controls")
-
-	legacyResourceControls, err := m.resourceControlService.ResourceControls()
-	if err != nil {
-		return err
-	}
-
-	for _, resourceControl := range legacyResourceControls {
-		resourceControl.AdministratorsOnly = false
-
-		err := m.resourceControlService.UpdateResourceControl(resourceControl.ID, &resourceControl)
-		if err != nil {
-			return err
-		}
-	}
-
-	return nil
-}
-
-func (m *Migrator) updateUsersAndRolesToDBVersion22() error {
-	log.Info().Msg("updating users and roles")
-
-	legacyUsers, err := m.userService.Users()
-	if err != nil {
-		return err
-	}
-
-	settings, err := m.settingsService.Settings()
-	if err != nil {
-		return err
-	}
-
-	for _, user := range legacyUsers {
-		user.PortainerAuthorizations = authorization.DefaultPortainerAuthorizations()
-		err = m.userService.UpdateUser(user.ID, &user)
-		if err != nil {
-			return err
-		}
-	}
-
-	endpointAdministratorRole, err := m.roleService.Role(portainer.RoleID(1))
-	if err != nil {
-		return err
-	}
-	endpointAdministratorRole.Priority = 1
-	endpointAdministratorRole.Authorizations = authorization.DefaultEndpointAuthorizationsForEndpointAdministratorRole()
-
-	err = m.roleService.UpdateRole(endpointAdministratorRole.ID, endpointAdministratorRole)
-
-	helpDeskRole, err := m.roleService.Role(portainer.RoleID(2))
-	if err != nil {
-		return err
-	}
-	helpDeskRole.Priority = 2
-	helpDeskRole.Authorizations = authorization.DefaultEndpointAuthorizationsForHelpDeskRole(settings.AllowVolumeBrowserForRegularUsers)
-
-	err = m.roleService.UpdateRole(helpDeskRole.ID, helpDeskRole)
-
-	standardUserRole, err := m.roleService.Role(portainer.RoleID(3))
-	if err != nil {
-		return err
-	}
-	standardUserRole.Priority = 3
-	standardUserRole.Authorizations = authorization.DefaultEndpointAuthorizationsForStandardUserRole(settings.AllowVolumeBrowserForRegularUsers)
-
-	err = m.roleService.UpdateRole(standardUserRole.ID, standardUserRole)
-
-	readOnlyUserRole, err := m.roleService.Role(portainer.RoleID(4))
-	if err != nil {
-		return err
-	}
-	readOnlyUserRole.Priority = 4
-	readOnlyUserRole.Authorizations = authorization.DefaultEndpointAuthorizationsForReadOnlyUserRole(settings.AllowVolumeBrowserForRegularUsers)
-
-	err = m.roleService.UpdateRole(readOnlyUserRole.ID, readOnlyUserRole)
-	if err != nil {
-		return err
-	}
-
-	return m.authorizationService.UpdateUsersAuthorizations()
-}

api/datastore/migrator/migrate_dbversion22.go

@@ -1,102 +0,0 @@
-package migrator
-
-import (
-	portainer "github.com/portainer/portainer/api"
-
-	"github.com/rs/zerolog/log"
-)
-
-func (m *Migrator) updateTagsToDBVersion23() error {
-	log.Info().Msg("updating tags")
-
-	tags, err := m.tagService.Tags()
-	if err != nil {
-		return err
-	}
-
-	for _, tag := range tags {
-		tag.EndpointGroups = make(map[portainer.EndpointGroupID]bool)
-		tag.Endpoints = make(map[portainer.EndpointID]bool)
-		err = m.tagService.UpdateTag(tag.ID, &tag)
-		if err != nil {
-			return err
-		}
-	}
-
-	return nil
-}
-
-func (m *Migrator) updateEndpointsAndEndpointGroupsToDBVersion23() error {
-	log.Info().Msg("updating endpoints and endpoint groups")
-
-	tags, err := m.tagService.Tags()
-	if err != nil {
-		return err
-	}
-
-	tagsNameMap := make(map[string]portainer.Tag)
-	for _, tag := range tags {
-		tagsNameMap[tag.Name] = tag
-	}
-
-	endpoints, err := m.endpointService.Endpoints()
-	if err != nil {
-		return err
-	}
-
-	for _, endpoint := range endpoints {
-		endpointTags := make([]portainer.TagID, 0)
-		for _, tagName := range endpoint.Tags {
-			tag, ok := tagsNameMap[tagName]
-			if ok {
-				endpointTags = append(endpointTags, tag.ID)
-				tag.Endpoints[endpoint.ID] = true
-			}
-		}
-		endpoint.TagIDs = endpointTags
-		err = m.endpointService.UpdateEndpoint(endpoint.ID, &endpoint)
-		if err != nil {
-			return err
-		}
-
-		relation := &portainer.EndpointRelation{
-			EndpointID: endpoint.ID,
-			EdgeStacks: map[portainer.EdgeStackID]bool{},
-		}
-
-		err = m.endpointRelationService.Create(relation)
-		if err != nil {
-			return err
-		}
-	}
-
-	endpointGroups, err := m.endpointGroupService.EndpointGroups()
-	if err != nil {
-		return err
-	}
-
-	for _, endpointGroup := range endpointGroups {
-		endpointGroupTags := make([]portainer.TagID, 0)
-		for _, tagName := range endpointGroup.Tags {
-			tag, ok := tagsNameMap[tagName]
-			if ok {
-				endpointGroupTags = append(endpointGroupTags, tag.ID)
-				tag.EndpointGroups[endpointGroup.ID] = true
-			}
-		}
-		endpointGroup.TagIDs = endpointGroupTags
-		err = m.endpointGroupService.UpdateEndpointGroup(endpointGroup.ID, &endpointGroup)
-		if err != nil {
-			return err
-		}
-	}
-
-	for _, tag := range tagsNameMap {
-		err = m.tagService.UpdateTag(tag.ID, &tag)
-		if err != nil {
-			return err
-		}
-	}
-
-	return nil
-}

api/datastore/migrator/migrate_dbversion23.go

@@ -1,42 +0,0 @@
-package migrator
-
-import (
-	portainer "github.com/portainer/portainer/api"
-
-	"github.com/rs/zerolog/log"
-)
-
-func (m *Migrator) updateSettingsToDB24() error {
-	log.Info().Msg("updating Settings")
-
-	legacySettings, err := m.settingsService.Settings()
-	if err != nil {
-		return err
-	}
-
-	legacySettings.AllowHostNamespaceForRegularUsers = true
-	legacySettings.AllowDeviceMappingForRegularUsers = true
-	legacySettings.AllowStackManagementForRegularUsers = true
-
-	return m.settingsService.UpdateSettings(legacySettings)
-}
-
-func (m *Migrator) updateStacksToDB24() error {
-	log.Info().Msg("updating stacks")
-
-	stacks, err := m.stackService.Stacks()
-	if err != nil {
-		return err
-	}
-
-	for idx := range stacks {
-		stack := &stacks[idx]
-		stack.Status = portainer.StackStatusActive
-		err := m.stackService.UpdateStack(stack.ID, stack)
-		if err != nil {
-			return err
-		}
-	}
-
-	return nil
-}

api/datastore/migrator/migrate_dbversion24.go

@@ -1,27 +0,0 @@
-package migrator
-
-import (
-	portainer "github.com/portainer/portainer/api"
-
-	"github.com/rs/zerolog/log"
-)
-
-func (m *Migrator) updateSettingsToDB25() error {
-	log.Info().Msg("updating settings")
-
-	legacySettings, err := m.settingsService.Settings()
-	if err != nil {
-		return err
-	}
-
-	if legacySettings.TemplatesURL == "" {
-		legacySettings.TemplatesURL = portainer.DefaultTemplatesURL
-	}
-
-	legacySettings.UserSessionTimeout = portainer.DefaultUserSessionTimeout
-	legacySettings.EnableTelemetry = true
-
-	legacySettings.AllowContainerCapabilitiesForRegularUsers = true
-
-	return m.settingsService.UpdateSettings(legacySettings)
-}

api/datastore/migrator/migrate_dbversion25.go

@@ -1,55 +0,0 @@
-package migrator
-
-import (
-	portainer "github.com/portainer/portainer/api"
-
-	"github.com/rs/zerolog/log"
-)
-
-func (m *Migrator) updateEndpointSettingsToDB25() error {
-	log.Info().Msg("updating endpoint settings")
-
-	settings, err := m.settingsService.Settings()
-	if err != nil {
-		return err
-	}
-
-	endpoints, err := m.endpointService.Endpoints()
-	if err != nil {
-		return err
-	}
-
-	for i := range endpoints {
-		endpoint := endpoints[i]
-
-		securitySettings := portainer.EndpointSecuritySettings{}
-
-		if endpoint.Type == portainer.EdgeAgentOnDockerEnvironment ||
-			endpoint.Type == portainer.AgentOnDockerEnvironment ||
-			endpoint.Type == portainer.DockerEnvironment {
-
-			securitySettings = portainer.EndpointSecuritySettings{
-				AllowBindMountsForRegularUsers:            settings.AllowBindMountsForRegularUsers,
-				AllowContainerCapabilitiesForRegularUsers: settings.AllowContainerCapabilitiesForRegularUsers,
-				AllowDeviceMappingForRegularUsers:         settings.AllowDeviceMappingForRegularUsers,
-				AllowHostNamespaceForRegularUsers:         settings.AllowHostNamespaceForRegularUsers,
-				AllowPrivilegedModeForRegularUsers:        settings.AllowPrivilegedModeForRegularUsers,
-				AllowStackManagementForRegularUsers:       settings.AllowStackManagementForRegularUsers,
-			}
-
-			if endpoint.Type == portainer.AgentOnDockerEnvironment || endpoint.Type == portainer.EdgeAgentOnDockerEnvironment {
-				securitySettings.AllowVolumeBrowserForRegularUsers = settings.AllowVolumeBrowserForRegularUsers
-				securitySettings.EnableHostManagementFeatures = settings.EnableHostManagementFeatures
-			}
-		}
-
-		endpoint.SecuritySettings = securitySettings
-
-		err = m.endpointService.UpdateEndpoint(endpoint.ID, &endpoint)
-		if err != nil {
-			return err
-		}
-	}
-
-	return nil
-}

api/datastore/migrator/migrate_dbversion26.go

@@ -1,44 +0,0 @@
-package migrator
-
-import (
-	portainer "github.com/portainer/portainer/api"
-	"github.com/portainer/portainer/api/dataservices/errors"
-	"github.com/portainer/portainer/api/stacks/stackutils"
-
-	"github.com/rs/zerolog/log"
-)
-
-func (m *Migrator) updateStackResourceControlToDB27() error {
-	log.Info().Msg("updating stack resource controls")
-
-	resourceControls, err := m.resourceControlService.ResourceControls()
-	if err != nil {
-		return err
-	}
-
-	for _, resource := range resourceControls {
-		if resource.Type != portainer.StackResourceControl {
-			continue
-		}
-
-		stackName := resource.ResourceID
-
-		stack, err := m.stackService.StackByName(stackName)
-		if err != nil {
-			if err == errors.ErrObjectNotFound {
-				continue
-			}
-
-			return err
-		}
-
-		resource.ResourceID = stackutils.ResourceControlID(stack.EndpointID, stack.Name)
-
-		err = m.resourceControlService.UpdateResourceControl(resource.ID, &resource)
-		if err != nil {
-			return err
-		}
-	}
-
-	return nil
-}

api/datastore/migrator/migrate_dbversion29.go

@@ -1,24 +0,0 @@
-package migrator
-
-import "github.com/rs/zerolog/log"
-
-func (m *Migrator) migrateDBVersionToDB30() error {
-	log.Info().Msg("updating legacy settings")
-
-	return m.MigrateSettingsToDB30()
-}
-
-// so setting to false and "", is what would happen without this code
-// I'm going to bet there's zero point to changing the value inthe DB
-// Public for testing
-func (m *Migrator) MigrateSettingsToDB30() error {
-	legacySettings, err := m.settingsService.Settings()
-	if err != nil {
-		return err
-	}
-
-	legacySettings.OAuthSettings.SSO = false
-	legacySettings.OAuthSettings.LogoutURI = ""
-
-	return m.settingsService.UpdateSettings(legacySettings)
-}

api/datastore/migrator/migrate_dbversion31.go

@@ -1,285 +0,0 @@
-package migrator
-
-import (
-	"fmt"
-
-	portainer "github.com/portainer/portainer/api"
-	"github.com/portainer/portainer/api/dataservices/errors"
-	"github.com/portainer/portainer/api/internal/endpointutils"
-	snapshotutils "github.com/portainer/portainer/api/internal/snapshot"
-
-	"github.com/docker/docker/api/types/volume"
-	"github.com/rs/zerolog/log"
-)
-
-func (m *Migrator) migrateDBVersionToDB32() error {
-	err := m.updateRegistriesToDB32()
-	if err != nil {
-		return err
-	}
-
-	err = m.updateDockerhubToDB32()
-	if err != nil {
-		return err
-	}
-
-	if err := m.updateVolumeResourceControlToDB32(); err != nil {
-		return err
-	}
-
-	if err := m.kubeconfigExpiryToDB32(); err != nil {
-		return err
-	}
-
-	if err := m.helmRepositoryURLToDB32(); err != nil {
-		return err
-	}
-
-	return nil
-}
-
-func (m *Migrator) updateRegistriesToDB32() error {
-	log.Info().Msg("updating registries")
-
-	registries, err := m.registryService.Registries()
-	if err != nil {
-		return err
-	}
-
-	endpoints, err := m.endpointService.Endpoints()
-	if err != nil {
-		return err
-	}
-
-	for _, registry := range registries {
-
-		registry.RegistryAccesses = portainer.RegistryAccesses{}
-
-		for _, endpoint := range endpoints {
-
-			filteredUserAccessPolicies := portainer.UserAccessPolicies{}
-			for userId, registryPolicy := range registry.UserAccessPolicies {
-				if _, found := endpoint.UserAccessPolicies[userId]; found {
-					filteredUserAccessPolicies[userId] = registryPolicy
-				}
-			}
-
-			filteredTeamAccessPolicies := portainer.TeamAccessPolicies{}
-			for teamId, registryPolicy := range registry.TeamAccessPolicies {
-				if _, found := endpoint.TeamAccessPolicies[teamId]; found {
-					filteredTeamAccessPolicies[teamId] = registryPolicy
-				}
-			}
-
-			registry.RegistryAccesses[endpoint.ID] = portainer.RegistryAccessPolicies{
-				UserAccessPolicies: filteredUserAccessPolicies,
-				TeamAccessPolicies: filteredTeamAccessPolicies,
-				Namespaces:         []string{},
-			}
-		}
-		m.registryService.UpdateRegistry(registry.ID, &registry)
-	}
-	return nil
-}
-
-func (m *Migrator) updateDockerhubToDB32() error {
-	log.Info().Msg("updating dockerhub")
-
-	dockerhub, err := m.dockerhubService.DockerHub()
-	if err == errors.ErrObjectNotFound {
-		return nil
-	} else if err != nil {
-		return err
-	}
-
-	if !dockerhub.Authentication {
-		return nil
-	}
-
-	registry := &portainer.Registry{
-		Type:             portainer.DockerHubRegistry,
-		Name:             "Dockerhub (authenticated - migrated)",
-		URL:              "docker.io",
-		Authentication:   true,
-		Username:         dockerhub.Username,
-		Password:         dockerhub.Password,
-		RegistryAccesses: portainer.RegistryAccesses{},
-	}
-
-	// The following code will make this function idempotent.
-	// i.e. if run again, it will not change the data.  It will ensure that
-	// we only have one migrated registry entry. Duplicates will be removed
-	// if they exist and which has been happening due to earlier migration bugs
-	migrated := false
-	registries, _ := m.registryService.Registries()
-	for _, r := range registries {
-		if r.Type == registry.Type &&
-			r.Name == registry.Name &&
-			r.URL == registry.URL &&
-			r.Authentication == registry.Authentication {
-
-			if !migrated {
-				// keep this one entry
-				migrated = true
-			} else {
-				// delete subsequent duplicates
-				m.registryService.DeleteRegistry(portainer.RegistryID(r.ID))
-			}
-		}
-	}
-
-	if migrated {
-		return nil
-	}
-
-	endpoints, err := m.endpointService.Endpoints()
-	if err != nil {
-		return err
-	}
-
-	for _, endpoint := range endpoints {
-
-		if endpoint.Type != portainer.KubernetesLocalEnvironment &&
-			endpoint.Type != portainer.AgentOnKubernetesEnvironment &&
-			endpoint.Type != portainer.EdgeAgentOnKubernetesEnvironment {
-
-			userAccessPolicies := portainer.UserAccessPolicies{}
-			for userId := range endpoint.UserAccessPolicies {
-				if _, found := endpoint.UserAccessPolicies[userId]; found {
-					userAccessPolicies[userId] = portainer.AccessPolicy{
-						RoleID: 0,
-					}
-				}
-			}
-
-			teamAccessPolicies := portainer.TeamAccessPolicies{}
-			for teamId := range endpoint.TeamAccessPolicies {
-				if _, found := endpoint.TeamAccessPolicies[teamId]; found {
-					teamAccessPolicies[teamId] = portainer.AccessPolicy{
-						RoleID: 0,
-					}
-				}
-			}
-
-			registry.RegistryAccesses[endpoint.ID] = portainer.RegistryAccessPolicies{
-				UserAccessPolicies: userAccessPolicies,
-				TeamAccessPolicies: teamAccessPolicies,
-				Namespaces:         []string{},
-			}
-		}
-	}
-
-	return m.registryService.Create(registry)
-}
-
-func (m *Migrator) updateVolumeResourceControlToDB32() error {
-	log.Info().Msg("updating resource controls")
-
-	endpoints, err := m.endpointService.Endpoints()
-	if err != nil {
-		return fmt.Errorf("failed fetching environments: %w", err)
-	}
-
-	resourceControls, err := m.resourceControlService.ResourceControls()
-	if err != nil {
-		return fmt.Errorf("failed fetching resource controls: %w", err)
-	}
-
-	toUpdate := map[portainer.ResourceControlID]string{}
-	volumeResourceControls := map[string]*portainer.ResourceControl{}
-
-	for i := range resourceControls {
-		resourceControl := resourceControls[i]
-		if resourceControl.Type == portainer.VolumeResourceControl {
-			volumeResourceControls[resourceControl.ResourceID] = &resourceControl
-		}
-	}
-
-	for _, endpoint := range endpoints {
-		if !endpointutils.IsDockerEndpoint(&endpoint) {
-			continue
-		}
-
-		totalSnapshots := len(endpoint.Snapshots)
-		if totalSnapshots == 0 {
-			log.Debug().Msg("no snapshot found")
-			continue
-		}
-
-		snapshot := endpoint.Snapshots[totalSnapshots-1]
-
-		endpointDockerID, err := snapshotutils.FetchDockerID(snapshot)
-		if err != nil {
-			log.Warn().Err(err).Msg("failed fetching environment docker id")
-			continue
-		}
-
-		volumesData := snapshot.SnapshotRaw.Volumes
-		if volumesData.Volumes == nil {
-			log.Debug().Msg("no volume data found")
-			continue
-		}
-
-		findResourcesToUpdateForDB32(endpointDockerID, volumesData, toUpdate, volumeResourceControls)
-
-	}
-
-	for _, resourceControl := range volumeResourceControls {
-		if newResourceID, ok := toUpdate[resourceControl.ID]; ok {
-			resourceControl.ResourceID = newResourceID
-
-			err := m.resourceControlService.UpdateResourceControl(resourceControl.ID, resourceControl)
-			if err != nil {
-				return fmt.Errorf("failed updating resource control %d: %w", resourceControl.ID, err)
-			}
-		} else {
-			err := m.resourceControlService.DeleteResourceControl(resourceControl.ID)
-			if err != nil {
-				return fmt.Errorf("failed deleting resource control %d: %w", resourceControl.ID, err)
-			}
-
-			log.Debug().Str("resource_id", resourceControl.ResourceID).Msg("legacy resource control has been deleted")
-		}
-	}
-
-	return nil
-}
-
-func findResourcesToUpdateForDB32(dockerID string, volumesData volume.VolumeListOKBody, toUpdate map[portainer.ResourceControlID]string, volumeResourceControls map[string]*portainer.ResourceControl) {
-	volumes := volumesData.Volumes
-	for _, volume := range volumes {
-		volumeName := volume.Name
-		createTime := volume.CreatedAt
-
-		oldResourceID := fmt.Sprintf("%s%s", volumeName, createTime)
-		resourceControl, ok := volumeResourceControls[oldResourceID]
-
-		if ok {
-			toUpdate[resourceControl.ID] = fmt.Sprintf("%s_%s", volumeName, dockerID)
-		}
-	}
-}
-
-func (m *Migrator) kubeconfigExpiryToDB32() error {
-	log.Info().Msg("updating kubeconfig expiry")
-
-	settings, err := m.settingsService.Settings()
-	if err != nil {
-		return err
-	}
-
-	settings.KubeconfigExpiry = portainer.DefaultKubeconfigExpiry
-	return m.settingsService.UpdateSettings(settings)
-}
-
-func (m *Migrator) helmRepositoryURLToDB32() error {
-	log.Info().Msg("setting default helm repository URL")
-
-	settings, err := m.settingsService.Settings()
-	if err != nil {
-		return err
-	}
-
-	settings.HelmRepositoryURL = portainer.DefaultHelmRepositoryURL
-	return m.settingsService.UpdateSettings(settings)
-}

api/datastore/migrator/migrate_dbversion32.go

@@ -1,26 +0,0 @@
-package migrator
-
-import (
-	portainer "github.com/portainer/portainer/api"
-
-	"github.com/rs/zerolog/log"
-)
-
-func (m *Migrator) migrateDBVersionToDB33() error {
-	log.Info().Msg("updating settings")
-
-	return m.migrateSettingsToDB33()
-}
-
-func (m *Migrator) migrateSettingsToDB33() error {
-	log.Info().Msg("setting default kubctl shell")
-	settings, err := m.settingsService.Settings()
-	if err != nil {
-		return err
-	}
-
-	log.Info().Msg("setting default kubectl shell image")
-	settings.KubectlShellImage = portainer.DefaultKubectlShellImage
-
-	return m.settingsService.UpdateSettings(settings)
-}

api/datastore/migrator/migrate_dbversion33.go

@@ -1,35 +0,0 @@
-package migrator
-
-import (
-	"github.com/portainer/portainer/api/dataservices"
-
-	"github.com/rs/zerolog/log"
-)
-
-func (m *Migrator) migrateDBVersionToDB34() error {
-	log.Info().Msg("updating stacks")
-
-	return MigrateStackEntryPoint(m.stackService)
-}
-
-// MigrateStackEntryPoint exported for testing (blah.)
-func MigrateStackEntryPoint(stackService dataservices.StackService) error {
-	stacks, err := stackService.Stacks()
-	if err != nil {
-		return err
-	}
-
-	for i := range stacks {
-		stack := &stacks[i]
-		if stack.GitConfig == nil {
-			continue
-		}
-
-		stack.GitConfig.ConfigFilePath = stack.EntryPoint
-		if err := stackService.UpdateStack(stack.ID, stack); err != nil {
-			return err
-		}
-	}
-
-	return nil
-}

api/datastore/migrator/migrate_dbversion34.go

@@ -1,12 +0,0 @@
-package migrator
-
-import "github.com/rs/zerolog/log"
-
-func (m *Migrator) migrateDBVersionToDB35() error {
-	// These should have been migrated already, but due to an earlier bug and a bunch of duplicates,
-	// calling it again will now fix the issue as the function has been repaired.
-
-	log.Info().Msg("updating dockerhub registries")
-
-	return m.updateDockerhubToDB32()
-}

api/datastore/migrator/migrate_dbversion34_test.go

@@ -1,94 +0,0 @@
-package migrator
-
-const (
-	db35TestFile = "portainer-mig-35.db"
-	username     = "portainer"
-	password     = "password"
-)
-
-// TODO: this is exactly the kind of reaching into the internals of the store we should not do
-// func setupDB35Test(t *testing.T) *Migrator {
-// 	is := assert.New(t)
-// 	dbConn, err := bolt.Open(path.Join(t.TempDir(), db35TestFile), 0600, &bolt.Options{Timeout: 1 * time.Second})
-// 	is.NoError(err, "failed to init testing DB connection")
-
-// 	// Create an old style dockerhub authenticated account
-// 	dockerhubService, err := dockerhub.NewService(&database.DbConnection{DB: dbConn})
-// 	is.NoError(err, "failed to init testing registry service")
-// 	err = dockerhubService.UpdateDockerHub(&portainer.DockerHub{true, username, password})
-// 	is.NoError(err, "failed to create dockerhub account")
-
-// 	registryService, err := registry.NewService(&database.DbConnection{DB: dbConn})
-// 	is.NoError(err, "failed to init testing registry service")
-
-// 	endpointService, err := endpoint.NewService(&database.DbConnection{DB: dbConn})
-// 	is.NoError(err, "failed to init endpoint service")
-
-// 	m := &Migrator{
-// 		db:               dbConn,
-// 		dockerhubService: dockerhubService,
-// 		registryService:  registryService,
-// 		endpointService:  endpointService,
-// 	}
-
-// 	return m
-// }
-
-// // TestUpdateDockerhubToDB32 tests a normal upgrade
-// func TestUpdateDockerhubToDB32(t *testing.T) {
-// 	is := assert.New(t)
-// 	m := setupDB35Test(t)
-// 	defer m.db.Close()
-// 	defer os.Remove(db35TestFile)
-
-// 	if err := m.updateDockerhubToDB32(); err != nil {
-// 		t.Errorf("failed to update settings: %v", err)
-// 	}
-
-// 	// Verify we have a single registry were created
-// 	registries, err := m.registryService.Registries()
-// 	is.NoError(err, "failed to read registries from the RegistryService")
-// 	is.Equal(len(registries), 1, "only one migrated registry expected")
-// }
-
-// // TestUpdateDockerhubToDB32_with_duplicate_migrations tests an upgrade where in earlier versions a broken migration
-// // created a large number of duplicate "dockerhub migrated" registry entries.
-// func TestUpdateDockerhubToDB32_with_duplicate_migrations(t *testing.T) {
-// 	is := assert.New(t)
-// 	m := setupDB35Test(t)
-// 	defer m.db.Close()
-// 	defer os.Remove(db35TestFile)
-
-// 	// Create lots of duplicate entries...
-// 	registry := &portainer.Registry{
-// 		Type:             portainer.DockerHubRegistry,
-// 		Name:             "Dockerhub (authenticated - migrated)",
-// 		URL:              "docker.io",
-// 		Authentication:   true,
-// 		Username:         "portainer",
-// 		Password:         "password",
-// 		RegistryAccesses: portainer.RegistryAccesses{},
-// 	}
-
-// 	for i := 1; i < 150; i++ {
-// 		err := m.registryService.CreateRegistry(registry)
-// 		assert.NoError(t, err, "create registry failed")
-// 	}
-
-// 	// Verify they were created
-// 	registries, err := m.registryService.Registries()
-// 	is.NoError(err, "failed to read registries from the RegistryService")
-// 	is.Condition(func() bool {
-// 		return len(registries) > 1
-// 	}, "expected multiple duplicate registry entries")
-
-// 	// Now run the migrator
-// 	if err := m.updateDockerhubToDB32(); err != nil {
-// 		t.Errorf("failed to update settings: %v", err)
-// 	}
-
-// 	// Verify we have a single registry were created
-// 	registries, err = m.registryService.Registries()
-// 	is.NoError(err, "failed to read registries from the RegistryService")
-// 	is.Equal(len(registries), 1, "only one migrated registry expected")
-// }

api/datastore/migrator/migrate_dbversion35.go

@@ -1,37 +0,0 @@
-package migrator
-
-import (
-	portainer "github.com/portainer/portainer/api"
-	"github.com/portainer/portainer/api/internal/authorization"
-
-	"github.com/rs/zerolog/log"
-)
-
-func (m *Migrator) migrateDBVersionToDB36() error {
-	log.Info().Msg("updating user authorizations")
-
-	return m.migrateUsersToDB36()
-}
-
-func (m *Migrator) migrateUsersToDB36() error {
-	log.Info().Msg("updating user authorizations")
-
-	users, err := m.userService.Users()
-	if err != nil {
-		return err
-	}
-
-	for _, user := range users {
-		currentAuthorizations := authorization.DefaultPortainerAuthorizations()
-		currentAuthorizations[portainer.OperationPortainerUserListToken] = true
-		currentAuthorizations[portainer.OperationPortainerUserCreateToken] = true
-		currentAuthorizations[portainer.OperationPortainerUserRevokeToken] = true
-		user.PortainerAuthorizations = currentAuthorizations
-		err = m.userService.UpdateUser(user.ID, &user)
-		if err != nil {
-			return err
-		}
-	}
-
-	return nil
-}

api/datastore/migrator/migrate_dbversion40.go

@@ -1,32 +0,0 @@
-package migrator
-
-import (
-	"github.com/portainer/portainer/api/internal/endpointutils"
-
-	"github.com/rs/zerolog/log"
-)
-
-func (m *Migrator) migrateDBVersionToDB40() error {
-	return m.trustCurrentEdgeEndpointsDB40()
-}
-
-func (m *Migrator) trustCurrentEdgeEndpointsDB40() error {
-	log.Info().Msg("trusting current edge endpoints")
-
-	endpoints, err := m.endpointService.Endpoints()
-	if err != nil {
-		return err
-	}
-
-	for _, endpoint := range endpoints {
-		if endpointutils.IsEdgeEndpoint(&endpoint) {
-			endpoint.UserTrusted = true
-			err = m.endpointService.UpdateEndpoint(endpoint.ID, &endpoint)
-			if err != nil {
-				return err
-			}
-		}
-	}
-
-	return nil
-}

api/datastore/migrator/migrate_dbversion50.go

@@ -1,22 +0,0 @@
-package migrator
-
-import (
-	"github.com/pkg/errors"
-	"github.com/rs/zerolog/log"
-)
-
-func (m *Migrator) migrateDBVersionToDB50() error {
-	return m.migratePasswordLengthSettings()
-}
-
-func (m *Migrator) migratePasswordLengthSettings() error {
-	log.Info().Msg("updating required password length")
-
-	s, err := m.settingsService.Settings()
-	if err != nil {
-		return errors.Wrap(err, "unable to retrieve settings")
-	}
-
-	s.InternalAuthSettings.RequiredPasswordLength = 12
-	return m.settingsService.UpdateSettings(s)
-}

api/datastore/migrator/migrate_dbversion60.go

@@ -1,31 +0,0 @@
-package migrator
-
-import (
-	portainer "github.com/portainer/portainer/api"
-
-	"github.com/rs/zerolog/log"
-)
-
-func (m *Migrator) migrateDBVersionToDB60() error {
-	return m.addGpuInputFieldDB60()
-}
-
-func (m *Migrator) addGpuInputFieldDB60() error {
-	log.Info().Msg("add gpu input field")
-
-	endpoints, err := m.endpointService.Endpoints()
-	if err != nil {
-		return err
-	}
-
-	for _, endpoint := range endpoints {
-		endpoint.Gpus = []portainer.Pair{}
-		err = m.endpointService.UpdateEndpoint(endpoint.ID, &endpoint)
-		if err != nil {
-			return err
-		}
-
-	}
-
-	return nil
-}

api/datastore/migrator/migrate_dbversion70.go

@@ -1,69 +0,0 @@
-package migrator
-
-import (
-	portainer "github.com/portainer/portainer/api"
-
-	"github.com/rs/zerolog/log"
-)
-
-func (m *Migrator) migrateDBVersionToDB70() error {
-	log.Info().Msg("- add IngressAvailabilityPerNamespace field")
-	if err := m.addIngressAvailabilityPerNamespaceFieldDB70(); err != nil {
-		return err
-	}
-
-	endpoints, err := m.endpointService.Endpoints()
-	if err != nil {
-		return err
-	}
-
-	for _, endpoint := range endpoints {
-		// copy snapshots to new object
-		log.Info().Msg("moving snapshots from endpoint to new object")
-		snapshot := portainer.Snapshot{EndpointID: endpoint.ID}
-
-		if len(endpoint.Snapshots) > 0 {
-			snapshot.Docker = &endpoint.Snapshots[len(endpoint.Snapshots)-1]
-		}
-
-		if len(endpoint.Kubernetes.Snapshots) > 0 {
-			snapshot.Kubernetes = &endpoint.Kubernetes.Snapshots[len(endpoint.Kubernetes.Snapshots)-1]
-		}
-
-		// save new object
-		err = m.snapshotService.Create(&snapshot)
-		if err != nil {
-			return err
-		}
-
-		// set to nil old fields
-		log.Info().Msg("deleting snapshot from endpoint")
-		endpoint.Snapshots = []portainer.DockerSnapshot{}
-		endpoint.Kubernetes.Snapshots = []portainer.KubernetesSnapshot{}
-
-		// update endpoint
-		err = m.endpointService.UpdateEndpoint(endpoint.ID, &endpoint)
-		if err != nil {
-			return err
-		}
-	}
-
-	return nil
-}
-
-func (m *Migrator) addIngressAvailabilityPerNamespaceFieldDB70() error {
-	endpoints, err := m.endpointService.Endpoints()
-	if err != nil {
-		return err
-	}
-
-	for _, endpoint := range endpoints {
-		endpoint.Kubernetes.Configuration.IngressAvailabilityPerNamespace = true
-
-		err = m.endpointService.UpdateEndpoint(endpoint.ID, &endpoint)
-		if err != nil {
-			return err
-		}
-	}
-	return nil
-}

api/datastore/migrator/migrator.go

@@ -1,104 +0,0 @@
-package migrator
-
-import (
-	portainer "github.com/portainer/portainer/api"
-	"github.com/portainer/portainer/api/dataservices/dockerhub"
-	"github.com/portainer/portainer/api/dataservices/endpoint"
-	"github.com/portainer/portainer/api/dataservices/endpointgroup"
-	"github.com/portainer/portainer/api/dataservices/endpointrelation"
-	"github.com/portainer/portainer/api/dataservices/extension"
-	"github.com/portainer/portainer/api/dataservices/fdoprofile"
-	"github.com/portainer/portainer/api/dataservices/registry"
-	"github.com/portainer/portainer/api/dataservices/resourcecontrol"
-	"github.com/portainer/portainer/api/dataservices/role"
-	"github.com/portainer/portainer/api/dataservices/schedule"
-	"github.com/portainer/portainer/api/dataservices/settings"
-	"github.com/portainer/portainer/api/dataservices/snapshot"
-	"github.com/portainer/portainer/api/dataservices/stack"
-	"github.com/portainer/portainer/api/dataservices/tag"
-	"github.com/portainer/portainer/api/dataservices/teammembership"
-	"github.com/portainer/portainer/api/dataservices/user"
-	"github.com/portainer/portainer/api/dataservices/version"
-	"github.com/portainer/portainer/api/internal/authorization"
-)
-
-type (
-	// Migrator defines a service to migrate data after a Portainer version update.
-	Migrator struct {
-		currentDBVersion        int
-		endpointGroupService    *endpointgroup.Service
-		endpointService         *endpoint.Service
-		endpointRelationService *endpointrelation.Service
-		extensionService        *extension.Service
-		fdoProfilesService      *fdoprofile.Service
-		registryService         *registry.Service
-		resourceControlService  *resourcecontrol.Service
-		roleService             *role.Service
-		scheduleService         *schedule.Service
-		settingsService         *settings.Service
-		snapshotService         *snapshot.Service
-		stackService            *stack.Service
-		tagService              *tag.Service
-		teamMembershipService   *teammembership.Service
-		userService             *user.Service
-		versionService          *version.Service
-		fileService             portainer.FileService
-		authorizationService    *authorization.Service
-		dockerhubService        *dockerhub.Service
-	}
-
-	// MigratorParameters represents the required parameters to create a new Migrator instance.
-	MigratorParameters struct {
-		DatabaseVersion         int
-		EndpointGroupService    *endpointgroup.Service
-		EndpointService         *endpoint.Service
-		EndpointRelationService *endpointrelation.Service
-		ExtensionService        *extension.Service
-		FDOProfilesService      *fdoprofile.Service
-		RegistryService         *registry.Service
-		ResourceControlService  *resourcecontrol.Service
-		RoleService             *role.Service
-		ScheduleService         *schedule.Service
-		SettingsService         *settings.Service
-		SnapshotService         *snapshot.Service
-		StackService            *stack.Service
-		TagService              *tag.Service
-		TeamMembershipService   *teammembership.Service
-		UserService             *user.Service
-		VersionService          *version.Service
-		FileService             portainer.FileService
-		AuthorizationService    *authorization.Service
-		DockerhubService        *dockerhub.Service
-	}
-)
-
-// NewMigrator creates a new Migrator.
-func NewMigrator(parameters *MigratorParameters) *Migrator {
-	return &Migrator{
-		currentDBVersion:        parameters.DatabaseVersion,
-		endpointGroupService:    parameters.EndpointGroupService,
-		endpointService:         parameters.EndpointService,
-		endpointRelationService: parameters.EndpointRelationService,
-		extensionService:        parameters.ExtensionService,
-		fdoProfilesService:      parameters.FDOProfilesService,
-		registryService:         parameters.RegistryService,
-		resourceControlService:  parameters.ResourceControlService,
-		roleService:             parameters.RoleService,
-		scheduleService:         parameters.ScheduleService,
-		settingsService:         parameters.SettingsService,
-		snapshotService:         parameters.SnapshotService,
-		tagService:              parameters.TagService,
-		teamMembershipService:   parameters.TeamMembershipService,
-		stackService:            parameters.StackService,
-		userService:             parameters.UserService,
-		versionService:          parameters.VersionService,
-		fileService:             parameters.FileService,
-		authorizationService:    parameters.AuthorizationService,
-		dockerhubService:        parameters.DockerhubService,
-	}
-}
-
-// Version exposes version of database
-func (migrator *Migrator) Version() int {
-	return migrator.currentDBVersion
-}

api/datastore/services.go

@@ -1,11 +1,6 @@
 package datastore
 
 import (
-	"encoding/json"
-	"fmt"
-	"io/ioutil"
-	"strconv"
-
 	portainer "github.com/portainer/portainer/api"
 	"github.com/portainer/portainer/api/dataservices"
 	"github.com/portainer/portainer/api/dataservices/apikeyrepository"
@@ -36,8 +31,6 @@ import (
 	"github.com/portainer/portainer/api/dataservices/user"
 	"github.com/portainer/portainer/api/dataservices/version"
 	"github.com/portainer/portainer/api/dataservices/webhook"
-
-	"github.com/rs/zerolog/log"
 )
 
 // Store defines the implementation of portainer.DataStore using
@@ -399,321 +392,3 @@ type storeExport struct {
 	Webhook            []portainer.Webhook            `json:"webhooks,omitempty"`
 	Metadata           map[string]interface{}         `json:"metadata,omitempty"`
 }
-
-func (store *Store) Export(filename string) (err error) {
-
-	backup := storeExport{}
-
-	if c, err := store.CustomTemplate().CustomTemplates(); err != nil {
-		if !store.IsErrObjectNotFound(err) {
-			log.Error().Err(err).Msg("exporting Custom Templates")
-		}
-	} else {
-		backup.CustomTemplate = c
-	}
-
-	if e, err := store.EdgeGroup().EdgeGroups(); err != nil {
-		if !store.IsErrObjectNotFound(err) {
-			log.Error().Err(err).Msg("exporting Edge Groups")
-		}
-	} else {
-		backup.EdgeGroup = e
-	}
-
-	if e, err := store.EdgeJob().EdgeJobs(); err != nil {
-		if !store.IsErrObjectNotFound(err) {
-			log.Error().Err(err).Msg("exporting Edge Jobs")
-		}
-	} else {
-		backup.EdgeJob = e
-	}
-
-	if e, err := store.EdgeStack().EdgeStacks(); err != nil {
-		if !store.IsErrObjectNotFound(err) {
-			log.Error().Err(err).Msg("exporting Edge Stacks")
-		}
-	} else {
-		backup.EdgeStack = e
-	}
-
-	if e, err := store.Endpoint().Endpoints(); err != nil {
-		if !store.IsErrObjectNotFound(err) {
-			log.Error().Err(err).Msg("exporting Endpoints")
-		}
-	} else {
-		backup.Endpoint = e
-	}
-
-	if e, err := store.EndpointGroup().EndpointGroups(); err != nil {
-		if !store.IsErrObjectNotFound(err) {
-			log.Error().Err(err).Msg("exporting Endpoint Groups")
-		}
-	} else {
-		backup.EndpointGroup = e
-	}
-
-	if r, err := store.EndpointRelation().EndpointRelations(); err != nil {
-		if !store.IsErrObjectNotFound(err) {
-			log.Error().Err(err).Msg("exporting Endpoint Relations")
-		}
-	} else {
-		backup.EndpointRelation = r
-	}
-
-	if r, err := store.ExtensionService.Extensions(); err != nil {
-		if !store.IsErrObjectNotFound(err) {
-			log.Error().Err(err).Msg("exporting Extensions")
-		}
-	} else {
-		backup.Extensions = r
-	}
-
-	if r, err := store.HelmUserRepository().HelmUserRepositories(); err != nil {
-		if !store.IsErrObjectNotFound(err) {
-			log.Error().Err(err).Msg("exporting Helm User Repositories")
-		}
-	} else {
-		backup.HelmUserRepository = r
-	}
-
-	if r, err := store.Registry().Registries(); err != nil {
-		if !store.IsErrObjectNotFound(err) {
-			log.Error().Err(err).Msg("exporting Registries")
-		}
-	} else {
-		backup.Registry = r
-	}
-
-	if c, err := store.ResourceControl().ResourceControls(); err != nil {
-		if !store.IsErrObjectNotFound(err) {
-			log.Error().Err(err).Msg("exporting Resource Controls")
-		}
-	} else {
-		backup.ResourceControl = c
-	}
-
-	if role, err := store.Role().Roles(); err != nil {
-		if !store.IsErrObjectNotFound(err) {
-			log.Error().Err(err).Msg("exporting Roles")
-		}
-	} else {
-		backup.Role = role
-	}
-
-	if r, err := store.ScheduleService.Schedules(); err != nil {
-		if !store.IsErrObjectNotFound(err) {
-			log.Error().Err(err).Msg("exporting Schedules")
-		}
-	} else {
-		backup.Schedules = r
-	}
-
-	if settings, err := store.Settings().Settings(); err != nil {
-		if !store.IsErrObjectNotFound(err) {
-			log.Error().Err(err).Msg("exporting Settings")
-		}
-	} else {
-		backup.Settings = *settings
-	}
-
-	if snapshot, err := store.Snapshot().Snapshots(); err != nil {
-		if !store.IsErrObjectNotFound(err) {
-			log.Error().Err(err).Msg("exporting Snapshots")
-		}
-	} else {
-		backup.Snapshot = snapshot
-	}
-
-	if settings, err := store.SSLSettings().Settings(); err != nil {
-		if !store.IsErrObjectNotFound(err) {
-			log.Error().Err(err).Msg("exporting SSL Settings")
-		}
-	} else {
-		backup.SSLSettings = *settings
-	}
-
-	if t, err := store.Stack().Stacks(); err != nil {
-		if !store.IsErrObjectNotFound(err) {
-			log.Error().Err(err).Msg("exporting Stacks")
-		}
-	} else {
-		backup.Stack = t
-	}
-
-	if t, err := store.Tag().Tags(); err != nil {
-		if !store.IsErrObjectNotFound(err) {
-			log.Error().Err(err).Msg("exporting Tags")
-		}
-	} else {
-		backup.Tag = t
-	}
-
-	if t, err := store.TeamMembership().TeamMemberships(); err != nil {
-		if !store.IsErrObjectNotFound(err) {
-			log.Error().Err(err).Msg("exporting Team Memberships")
-		}
-	} else {
-		backup.TeamMembership = t
-	}
-
-	if t, err := store.Team().Teams(); err != nil {
-		if !store.IsErrObjectNotFound(err) {
-			log.Error().Err(err).Msg("exporting Teams")
-		}
-	} else {
-		backup.Team = t
-	}
-
-	if info, err := store.TunnelServer().Info(); err != nil {
-		if !store.IsErrObjectNotFound(err) {
-			log.Error().Err(err).Msg("exporting Tunnel Server")
-		}
-	} else {
-		backup.TunnelServer = *info
-	}
-
-	if users, err := store.User().Users(); err != nil {
-		if !store.IsErrObjectNotFound(err) {
-			log.Error().Err(err).Msg("exporting Users")
-		}
-	} else {
-		backup.User = users
-	}
-
-	if webhooks, err := store.Webhook().Webhooks(); err != nil {
-		if !store.IsErrObjectNotFound(err) {
-			log.Error().Err(err).Msg("exporting Webhooks")
-		}
-	} else {
-		backup.Webhook = webhooks
-	}
-
-	v, err := store.Version().DBVersion()
-	if err != nil && !store.IsErrObjectNotFound(err) {
-		log.Error().Err(err).Msg("exporting DB version")
-	}
-	instance, _ := store.Version().InstanceID()
-	backup.Version = map[string]string{
-		"DB_VERSION":  strconv.Itoa(v),
-		"INSTANCE_ID": instance,
-	}
-
-	backup.Metadata, err = store.connection.BackupMetadata()
-	if err != nil {
-		log.Error().Err(err).Msg("exporting Metadata")
-	}
-
-	b, err := json.MarshalIndent(backup, "", "  ")
-	if err != nil {
-		return err
-	}
-	return ioutil.WriteFile(filename, b, 0600)
-}
-
-func (store *Store) Import(filename string) (err error) {
-	backup := storeExport{}
-
-	s, err := ioutil.ReadFile(filename)
-	if err != nil {
-		return err
-	}
-	err = json.Unmarshal([]byte(s), &backup)
-	if err != nil {
-		return err
-	}
-
-	// TODO: yup, this is bad, and should be in a version struct...
-	if dbversion, ok := backup.Version["DB_VERSION"]; ok {
-		if v, err := strconv.Atoi(dbversion); err == nil {
-			if err := store.Version().StoreDBVersion(v); err != nil {
-				log.Error().Err(err).Msg("DB_VERSION import issue")
-			}
-		}
-	}
-	if instanceID, ok := backup.Version["INSTANCE_ID"]; ok {
-		if err := store.Version().StoreInstanceID(instanceID); err != nil {
-			log.Error().Err(err).Msg("INSTANCE_ID import issue")
-		}
-	}
-
-	for _, v := range backup.CustomTemplate {
-		store.CustomTemplate().UpdateCustomTemplate(v.ID, &v)
-	}
-
-	for _, v := range backup.EdgeGroup {
-		store.EdgeGroup().UpdateEdgeGroup(v.ID, &v)
-	}
-
-	for _, v := range backup.EdgeJob {
-		store.EdgeJob().UpdateEdgeJob(v.ID, &v)
-	}
-
-	for _, v := range backup.EdgeStack {
-		store.EdgeStack().UpdateEdgeStack(v.ID, &v)
-	}
-
-	for _, v := range backup.Endpoint {
-		store.Endpoint().UpdateEndpoint(v.ID, &v)
-	}
-
-	for _, v := range backup.EndpointGroup {
-		store.EndpointGroup().UpdateEndpointGroup(v.ID, &v)
-	}
-
-	for _, v := range backup.EndpointRelation {
-		store.EndpointRelation().UpdateEndpointRelation(v.EndpointID, &v)
-	}
-
-	for _, v := range backup.HelmUserRepository {
-		store.HelmUserRepository().UpdateHelmUserRepository(v.ID, &v)
-	}
-
-	for _, v := range backup.Registry {
-		store.Registry().UpdateRegistry(v.ID, &v)
-	}
-
-	for _, v := range backup.ResourceControl {
-		store.ResourceControl().UpdateResourceControl(v.ID, &v)
-	}
-
-	for _, v := range backup.Role {
-		store.Role().UpdateRole(v.ID, &v)
-	}
-
-	store.Settings().UpdateSettings(&backup.Settings)
-	store.SSLSettings().UpdateSettings(&backup.SSLSettings)
-
-	for _, v := range backup.Snapshot {
-		store.Snapshot().UpdateSnapshot(&v)
-	}
-
-	for _, v := range backup.Stack {
-		store.Stack().UpdateStack(v.ID, &v)
-	}
-
-	for _, v := range backup.Tag {
-		store.Tag().UpdateTag(v.ID, &v)
-	}
-
-	for _, v := range backup.TeamMembership {
-		store.TeamMembership().UpdateTeamMembership(v.ID, &v)
-	}
-
-	for _, v := range backup.Team {
-		store.Team().UpdateTeam(v.ID, &v)
-	}
-
-	store.TunnelServer().UpdateInfo(&backup.TunnelServer)
-
-	for _, user := range backup.User {
-		if err := store.User().UpdateUser(user.ID, &user); err != nil {
-			log.Debug().Str("user", fmt.Sprintf("%+v", user)).Err(err).Msg("failed to update the user in the database")
-		}
-	}
-
-	for _, v := range backup.Webhook {
-		store.Webhook().UpdateWebhook(v.ID, &v)
-	}
-
-	return store.connection.RestoreMetadata(backup.Metadata)
-}

api/datastore/test_data/output_24_to_latest.json

@@ -1,933 +0,0 @@
-{
-  "dockerhub": [
-    {
-      "Authentication": false,
-      "Username": ""
-    }
-  ],
-  "endpoint_groups": [
-    {
-      "AuthorizedTeams": null,
-      "AuthorizedUsers": null,
-      "Description": "Unassigned endpoints",
-      "Id": 1,
-      "Labels": [],
-      "Name": "Unassigned",
-      "TagIds": [],
-      "Tags": null,
-      "TeamAccessPolicies": {},
-      "UserAccessPolicies": {}
-    }
-  ],
-  "endpoint_relations": [
-    {
-      "EdgeStacks": {},
-      "EndpointID": 1
-    }
-  ],
-  "endpoints": [
-    {
-      "Agent": {
-        "Version": ""
-      },
-      "AuthorizedTeams": null,
-      "AuthorizedUsers": null,
-      "AzureCredentials": {
-        "ApplicationID": "",
-        "AuthenticationKey": "",
-        "TenantID": ""
-      },
-      "ComposeSyntaxMaxVersion": "",
-      "Edge": {
-        "AsyncMode": false,
-        "CommandInterval": 0,
-        "PingInterval": 0,
-        "SnapshotInterval": 0
-      },
-      "EdgeCheckinInterval": 0,
-      "EdgeKey": "",
-      "Gpus": [],
-      "GroupId": 1,
-      "Id": 1,
-      "IsEdgeDevice": false,
-      "Kubernetes": {
-        "Configuration": {
-          "EnableResourceOverCommit": false,
-          "IngressAvailabilityPerNamespace": true,
-          "IngressClasses": null,
-          "ResourceOverCommitPercentage": 0,
-          "RestrictDefaultNamespace": false,
-          "StorageClasses": null,
-          "UseLoadBalancer": false,
-          "UseServerMetrics": false
-        },
-        "Snapshots": []
-      },
-      "LastCheckInDate": 0,
-      "Name": "local",
-      "PublicURL": "",
-      "QueryDate": 0,
-      "SecuritySettings": {
-        "allowBindMountsForRegularUsers": true,
-        "allowContainerCapabilitiesForRegularUsers": true,
-        "allowDeviceMappingForRegularUsers": true,
-        "allowHostNamespaceForRegularUsers": true,
-        "allowPrivilegedModeForRegularUsers": true,
-        "allowStackManagementForRegularUsers": true,
-        "allowSysctlSettingForRegularUsers": false,
-        "allowVolumeBrowserForRegularUsers": false,
-        "enableHostManagementFeatures": false
-      },
-      "Snapshots": [],
-      "Status": 1,
-      "TLSConfig": {
-        "TLS": false,
-        "TLSSkipVerify": false
-      },
-      "TagIds": [],
-      "Tags": null,
-      "TeamAccessPolicies": {},
-      "Type": 1,
-      "URL": "unix:///var/run/docker.sock",
-      "UserAccessPolicies": {},
-      "UserTrusted": false
-    }
-  ],
-  "registries": [
-    {
-      "Authentication": true,
-      "AuthorizedTeams": null,
-      "AuthorizedUsers": null,
-      "BaseURL": "",
-      "Ecr": {
-        "Region": ""
-      },
-      "Gitlab": {
-        "InstanceURL": "",
-        "ProjectId": 0,
-        "ProjectPath": ""
-      },
-      "Id": 1,
-      "ManagementConfiguration": null,
-      "Name": "canister.io",
-      "Password": "MjWbx8A6YK7cw7",
-      "Quay": {
-        "OrganisationName": "",
-        "UseOrganisation": false
-      },
-      "RegistryAccesses": {
-        "1": {
-          "Namespaces": [],
-          "TeamAccessPolicies": {},
-          "UserAccessPolicies": {}
-        }
-      },
-      "TeamAccessPolicies": {},
-      "Type": 3,
-      "URL": "cloud.canister.io:5000",
-      "UserAccessPolicies": {},
-      "Username": "prabhatkhera"
-    }
-  ],
-  "resource_control": [
-    {
-      "AdministratorsOnly": false,
-      "Id": 2,
-      "Public": true,
-      "ResourceId": "762gbwaj8r4gcsdy8ld1u4why",
-      "SubResourceIds": [],
-      "System": false,
-      "TeamAccesses": [],
-      "Type": 5,
-      "UserAccesses": []
-    },
-    {
-      "AdministratorsOnly": false,
-      "Id": 3,
-      "Public": true,
-      "ResourceId": "1_alpine",
-      "SubResourceIds": [],
-      "System": false,
-      "TeamAccesses": [],
-      "Type": 6,
-      "UserAccesses": []
-    },
-    {
-      "AdministratorsOnly": false,
-      "Id": 4,
-      "Public": true,
-      "ResourceId": "1_redis",
-      "SubResourceIds": [],
-      "System": false,
-      "TeamAccesses": [],
-      "Type": 6,
-      "UserAccesses": []
-    },
-    {
-      "AdministratorsOnly": false,
-      "Id": 5,
-      "Public": false,
-      "ResourceId": "1_nginx",
-      "SubResourceIds": [],
-      "System": false,
-      "TeamAccesses": [
-        {
-          "AccessLevel": 1,
-          "TeamId": 1
-        }
-      ],
-      "Type": 6,
-      "UserAccesses": []
-    }
-  ],
-  "roles": [
-    {
-      "Authorizations": {
-        "DockerAgentBrowseDelete": true,
-        "DockerAgentBrowseGet": true,
-        "DockerAgentBrowseList": true,
-        "DockerAgentBrowsePut": true,
-        "DockerAgentBrowseRename": true,
-        "DockerAgentHostInfo": true,
-        "DockerAgentList": true,
-        "DockerAgentPing": true,
-        "DockerAgentUndefined": true,
-        "DockerBuildCancel": true,
-        "DockerBuildPrune": true,
-        "DockerConfigCreate": true,
-        "DockerConfigDelete": true,
-        "DockerConfigInspect": true,
-        "DockerConfigList": true,
-        "DockerConfigUpdate": true,
-        "DockerContainerArchive": true,
-        "DockerContainerArchiveInfo": true,
-        "DockerContainerAttach": true,
-        "DockerContainerAttachWebsocket": true,
-        "DockerContainerChanges": true,
-        "DockerContainerCreate": true,
-        "DockerContainerDelete": true,
-        "DockerContainerExec": true,
-        "DockerContainerExport": true,
-        "DockerContainerInspect": true,
-        "DockerContainerKill": true,
-        "DockerContainerList": true,
-        "DockerContainerLogs": true,
-        "DockerContainerPause": true,
-        "DockerContainerPrune": true,
-        "DockerContainerPutContainerArchive": true,
-        "DockerContainerRename": true,
-        "DockerContainerResize": true,
-        "DockerContainerRestart": true,
-        "DockerContainerStart": true,
-        "DockerContainerStats": true,
-        "DockerContainerStop": true,
-        "DockerContainerTop": true,
-        "DockerContainerUnpause": true,
-        "DockerContainerUpdate": true,
-        "DockerContainerWait": true,
-        "DockerDistributionInspect": true,
-        "DockerEvents": true,
-        "DockerExecInspect": true,
-        "DockerExecResize": true,
-        "DockerExecStart": true,
-        "DockerImageBuild": true,
-        "DockerImageCommit": true,
-        "DockerImageCreate": true,
-        "DockerImageDelete": true,
-        "DockerImageGet": true,
-        "DockerImageGetAll": true,
-        "DockerImageHistory": true,
-        "DockerImageInspect": true,
-        "DockerImageList": true,
-        "DockerImageLoad": true,
-        "DockerImagePrune": true,
-        "DockerImagePush": true,
-        "DockerImageSearch": true,
-        "DockerImageTag": true,
-        "DockerInfo": true,
-        "DockerNetworkConnect": true,
-        "DockerNetworkCreate": true,
-        "DockerNetworkDelete": true,
-        "DockerNetworkDisconnect": true,
-        "DockerNetworkInspect": true,
-        "DockerNetworkList": true,
-        "DockerNetworkPrune": true,
-        "DockerNodeDelete": true,
-        "DockerNodeInspect": true,
-        "DockerNodeList": true,
-        "DockerNodeUpdate": true,
-        "DockerPing": true,
-        "DockerPluginCreate": true,
-        "DockerPluginDelete": true,
-        "DockerPluginDisable": true,
-        "DockerPluginEnable": true,
-        "DockerPluginInspect": true,
-        "DockerPluginList": true,
-        "DockerPluginPrivileges": true,
-        "DockerPluginPull": true,
-        "DockerPluginPush": true,
-        "DockerPluginSet": true,
-        "DockerPluginUpgrade": true,
-        "DockerSecretCreate": true,
-        "DockerSecretDelete": true,
-        "DockerSecretInspect": true,
-        "DockerSecretList": true,
-        "DockerSecretUpdate": true,
-        "DockerServiceCreate": true,
-        "DockerServiceDelete": true,
-        "DockerServiceInspect": true,
-        "DockerServiceList": true,
-        "DockerServiceLogs": true,
-        "DockerServiceUpdate": true,
-        "DockerSessionStart": true,
-        "DockerSwarmInit": true,
-        "DockerSwarmInspect": true,
-        "DockerSwarmJoin": true,
-        "DockerSwarmLeave": true,
-        "DockerSwarmUnlock": true,
-        "DockerSwarmUnlockKey": true,
-        "DockerSwarmUpdate": true,
-        "DockerSystem": true,
-        "DockerTaskInspect": true,
-        "DockerTaskList": true,
-        "DockerTaskLogs": true,
-        "DockerUndefined": true,
-        "DockerVersion": true,
-        "DockerVolumeCreate": true,
-        "DockerVolumeDelete": true,
-        "DockerVolumeInspect": true,
-        "DockerVolumeList": true,
-        "DockerVolumePrune": true,
-        "EndpointResourcesAccess": true,
-        "IntegrationStoridgeAdmin": true,
-        "PortainerResourceControlCreate": true,
-        "PortainerResourceControlUpdate": true,
-        "PortainerStackCreate": true,
-        "PortainerStackDelete": true,
-        "PortainerStackFile": true,
-        "PortainerStackInspect": true,
-        "PortainerStackList": true,
-        "PortainerStackMigrate": true,
-        "PortainerStackUpdate": true,
-        "PortainerWebhookCreate": true,
-        "PortainerWebhookDelete": true,
-        "PortainerWebhookList": true,
-        "PortainerWebsocketExec": true
-      },
-      "Description": "Full control of all resources in an endpoint",
-      "Id": 1,
-      "Name": "Endpoint administrator",
-      "Priority": 1
-    },
-    {
-      "Authorizations": {
-        "DockerAgentHostInfo": true,
-        "DockerAgentList": true,
-        "DockerAgentPing": true,
-        "DockerConfigInspect": true,
-        "DockerConfigList": true,
-        "DockerContainerArchiveInfo": true,
-        "DockerContainerChanges": true,
-        "DockerContainerInspect": true,
-        "DockerContainerList": true,
-        "DockerContainerLogs": true,
-        "DockerContainerStats": true,
-        "DockerContainerTop": true,
-        "DockerDistributionInspect": true,
-        "DockerEvents": true,
-        "DockerImageGet": true,
-        "DockerImageGetAll": true,
-        "DockerImageHistory": true,
-        "DockerImageInspect": true,
-        "DockerImageList": true,
-        "DockerImageSearch": true,
-        "DockerInfo": true,
-        "DockerNetworkInspect": true,
-        "DockerNetworkList": true,
-        "DockerNodeInspect": true,
-        "DockerNodeList": true,
-        "DockerPing": true,
-        "DockerPluginList": true,
-        "DockerSecretInspect": true,
-        "DockerSecretList": true,
-        "DockerServiceInspect": true,
-        "DockerServiceList": true,
-        "DockerServiceLogs": true,
-        "DockerSwarmInspect": true,
-        "DockerSystem": true,
-        "DockerTaskInspect": true,
-        "DockerTaskList": true,
-        "DockerTaskLogs": true,
-        "DockerVersion": true,
-        "DockerVolumeInspect": true,
-        "DockerVolumeList": true,
-        "EndpointResourcesAccess": true,
-        "PortainerStackFile": true,
-        "PortainerStackInspect": true,
-        "PortainerStackList": true,
-        "PortainerWebhookList": true
-      },
-      "Description": "Read-only access of all resources in an endpoint",
-      "Id": 2,
-      "Name": "Helpdesk",
-      "Priority": 2
-    },
-    {
-      "Authorizations": {
-        "DockerAgentHostInfo": true,
-        "DockerAgentList": true,
-        "DockerAgentPing": true,
-        "DockerAgentUndefined": true,
-        "DockerBuildCancel": true,
-        "DockerBuildPrune": true,
-        "DockerConfigCreate": true,
-        "DockerConfigDelete": true,
-        "DockerConfigInspect": true,
-        "DockerConfigList": true,
-        "DockerConfigUpdate": true,
-        "DockerContainerArchive": true,
-        "DockerContainerArchiveInfo": true,
-        "DockerContainerAttach": true,
-        "DockerContainerAttachWebsocket": true,
-        "DockerContainerChanges": true,
-        "DockerContainerCreate": true,
-        "DockerContainerDelete": true,
-        "DockerContainerExec": true,
-        "DockerContainerExport": true,
-        "DockerContainerInspect": true,
-        "DockerContainerKill": true,
-        "DockerContainerList": true,
-        "DockerContainerLogs": true,
-        "DockerContainerPause": true,
-        "DockerContainerPutContainerArchive": true,
-        "DockerContainerRename": true,
-        "DockerContainerResize": true,
-        "DockerContainerRestart": true,
-        "DockerContainerStart": true,
-        "DockerContainerStats": true,
-        "DockerContainerStop": true,
-        "DockerContainerTop": true,
-        "DockerContainerUnpause": true,
-        "DockerContainerUpdate": true,
-        "DockerContainerWait": true,
-        "DockerDistributionInspect": true,
-        "DockerEvents": true,
-        "DockerExecInspect": true,
-        "DockerExecResize": true,
-        "DockerExecStart": true,
-        "DockerImageBuild": true,
-        "DockerImageCommit": true,
-        "DockerImageCreate": true,
-        "DockerImageDelete": true,
-        "DockerImageGet": true,
-        "DockerImageGetAll": true,
-        "DockerImageHistory": true,
-        "DockerImageInspect": true,
-        "DockerImageList": true,
-        "DockerImageLoad": true,
-        "DockerImagePush": true,
-        "DockerImageSearch": true,
-        "DockerImageTag": true,
-        "DockerInfo": true,
-        "DockerNetworkConnect": true,
-        "DockerNetworkCreate": true,
-        "DockerNetworkDelete": true,
-        "DockerNetworkDisconnect": true,
-        "DockerNetworkInspect": true,
-        "DockerNetworkList": true,
-        "DockerNodeDelete": true,
-        "DockerNodeInspect": true,
-        "DockerNodeList": true,
-        "DockerNodeUpdate": true,
-        "DockerPing": true,
-        "DockerPluginCreate": true,
-        "DockerPluginDelete": true,
-        "DockerPluginDisable": true,
-        "DockerPluginEnable": true,
-        "DockerPluginInspect": true,
-        "DockerPluginList": true,
-        "DockerPluginPrivileges": true,
-        "DockerPluginPull": true,
-        "DockerPluginPush": true,
-        "DockerPluginSet": true,
-        "DockerPluginUpgrade": true,
-        "DockerSecretCreate": true,
-        "DockerSecretDelete": true,
-        "DockerSecretInspect": true,
-        "DockerSecretList": true,
-        "DockerSecretUpdate": true,
-        "DockerServiceCreate": true,
-        "DockerServiceDelete": true,
-        "DockerServiceInspect": true,
-        "DockerServiceList": true,
-        "DockerServiceLogs": true,
-        "DockerServiceUpdate": true,
-        "DockerSessionStart": true,
-        "DockerSwarmInit": true,
-        "DockerSwarmInspect": true,
-        "DockerSwarmJoin": true,
-        "DockerSwarmLeave": true,
-        "DockerSwarmUnlock": true,
-        "DockerSwarmUnlockKey": true,
-        "DockerSwarmUpdate": true,
-        "DockerSystem": true,
-        "DockerTaskInspect": true,
-        "DockerTaskList": true,
-        "DockerTaskLogs": true,
-        "DockerUndefined": true,
-        "DockerVersion": true,
-        "DockerVolumeCreate": true,
-        "DockerVolumeDelete": true,
-        "DockerVolumeInspect": true,
-        "DockerVolumeList": true,
-        "PortainerResourceControlUpdate": true,
-        "PortainerStackCreate": true,
-        "PortainerStackDelete": true,
-        "PortainerStackFile": true,
-        "PortainerStackInspect": true,
-        "PortainerStackList": true,
-        "PortainerStackMigrate": true,
-        "PortainerStackUpdate": true,
-        "PortainerWebhookCreate": true,
-        "PortainerWebhookList": true,
-        "PortainerWebsocketExec": true
-      },
-      "Description": "Full control of assigned resources in an endpoint",
-      "Id": 3,
-      "Name": "Standard user",
-      "Priority": 3
-    },
-    {
-      "Authorizations": {
-        "DockerAgentHostInfo": true,
-        "DockerAgentList": true,
-        "DockerAgentPing": true,
-        "DockerConfigInspect": true,
-        "DockerConfigList": true,
-        "DockerContainerArchiveInfo": true,
-        "DockerContainerChanges": true,
-        "DockerContainerInspect": true,
-        "DockerContainerList": true,
-        "DockerContainerLogs": true,
-        "DockerContainerStats": true,
-        "DockerContainerTop": true,
-        "DockerDistributionInspect": true,
-        "DockerEvents": true,
-        "DockerImageGet": true,
-        "DockerImageGetAll": true,
-        "DockerImageHistory": true,
-        "DockerImageInspect": true,
-        "DockerImageList": true,
-        "DockerImageSearch": true,
-        "DockerInfo": true,
-        "DockerNetworkInspect": true,
-        "DockerNetworkList": true,
-        "DockerNodeInspect": true,
-        "DockerNodeList": true,
-        "DockerPing": true,
-        "DockerPluginList": true,
-        "DockerSecretInspect": true,
-        "DockerSecretList": true,
-        "DockerServiceInspect": true,
-        "DockerServiceList": true,
-        "DockerServiceLogs": true,
-        "DockerSwarmInspect": true,
-        "DockerSystem": true,
-        "DockerTaskInspect": true,
-        "DockerTaskList": true,
-        "DockerTaskLogs": true,
-        "DockerVersion": true,
-        "DockerVolumeInspect": true,
-        "DockerVolumeList": true,
-        "PortainerStackFile": true,
-        "PortainerStackInspect": true,
-        "PortainerStackList": true,
-        "PortainerWebhookList": true
-      },
-      "Description": "Read-only access of assigned resources in an endpoint",
-      "Id": 4,
-      "Name": "Read-only user",
-      "Priority": 4
-    }
-  ],
-  "schedules": [
-    {
-      "Created": 1648608136,
-      "CronExpression": "@every 5m",
-      "EdgeSchedule": null,
-      "EndpointSyncJob": null,
-      "Id": 1,
-      "JobType": 2,
-      "Name": "system_snapshot",
-      "Recurring": true,
-      "ScriptExecutionJob": null,
-      "SnapshotJob": {}
-    }
-  ],
-  "settings": {
-    "AgentSecret": "",
-    "AllowBindMountsForRegularUsers": true,
-    "AllowContainerCapabilitiesForRegularUsers": true,
-    "AllowDeviceMappingForRegularUsers": true,
-    "AllowHostNamespaceForRegularUsers": true,
-    "AllowPrivilegedModeForRegularUsers": true,
-    "AllowStackManagementForRegularUsers": true,
-    "AllowVolumeBrowserForRegularUsers": false,
-    "AuthenticationMethod": 1,
-    "BlackListedLabels": [],
-    "DisplayDonationHeader": false,
-    "DisplayExternalContributors": false,
-    "Edge": {
-      "AsyncMode": false,
-      "CommandInterval": 0,
-      "PingInterval": 0,
-      "SnapshotInterval": 0
-    },
-    "EdgeAgentCheckinInterval": 5,
-    "EdgePortainerUrl": "",
-    "EnableEdgeComputeFeatures": false,
-    "EnableHostManagementFeatures": false,
-    "EnableTelemetry": true,
-    "EnforceEdgeID": false,
-    "FeatureFlagSettings": null,
-    "HelmRepositoryURL": "https://charts.bitnami.com/bitnami",
-    "InternalAuthSettings": {
-      "RequiredPasswordLength": 12
-    },
-    "KubeconfigExpiry": "0",
-    "KubectlShellImage": "portainer/kubectl-shell",
-    "LDAPSettings": {
-      "AnonymousMode": true,
-      "AutoCreateUsers": true,
-      "GroupSearchSettings": [
-        {
-          "GroupAttribute": "",
-          "GroupBaseDN": "",
-          "GroupFilter": ""
-        }
-      ],
-      "ReaderDN": "",
-      "SearchSettings": [
-        {
-          "BaseDN": "",
-          "Filter": "",
-          "UserNameAttribute": ""
-        }
-      ],
-      "StartTLS": false,
-      "TLSConfig": {
-        "TLS": false,
-        "TLSSkipVerify": false
-      },
-      "URL": ""
-    },
-    "LogoURL": "",
-    "OAuthSettings": {
-      "AccessTokenURI": "",
-      "AuthorizationURI": "",
-      "ClientID": "",
-      "DefaultTeamID": 0,
-      "KubeSecretKey": null,
-      "LogoutURI": "",
-      "OAuthAutoCreateUsers": false,
-      "RedirectURI": "",
-      "ResourceURI": "",
-      "SSO": false,
-      "Scopes": "",
-      "UserIdentifier": ""
-    },
-    "SnapshotInterval": "5m",
-    "TemplatesURL": "https://raw.githubusercontent.com/portainer/templates/master/templates-2.0.json",
-    "TrustOnFirstConnect": false,
-    "UserSessionTimeout": "8h",
-    "fdoConfiguration": {
-      "enabled": false,
-      "ownerPassword": "",
-      "ownerURL": "",
-      "ownerUsername": ""
-    },
-    "openAMTConfiguration": {
-      "certFileContent": "",
-      "certFileName": "",
-      "certFilePassword": "",
-      "domainName": "",
-      "enabled": false,
-      "mpsPassword": "",
-      "mpsServer": "",
-      "mpsToken": "",
-      "mpsUser": ""
-    }
-  },
-  "snapshots": [
-    {
-      "Docker": {
-        "DockerSnapshotRaw": {
-          "Containers": null,
-          "Images": null,
-          "Info": {
-            "Architecture": "",
-            "BridgeNfIp6tables": false,
-            "BridgeNfIptables": false,
-            "CPUSet": false,
-            "CPUShares": false,
-            "CgroupDriver": "",
-            "ContainerdCommit": {
-              "Expected": "",
-              "ID": ""
-            },
-            "Containers": 0,
-            "ContainersPaused": 0,
-            "ContainersRunning": 0,
-            "ContainersStopped": 0,
-            "CpuCfsPeriod": false,
-            "CpuCfsQuota": false,
-            "Debug": false,
-            "DefaultRuntime": "",
-            "DockerRootDir": "",
-            "Driver": "",
-            "DriverStatus": null,
-            "ExperimentalBuild": false,
-            "GenericResources": null,
-            "HttpProxy": "",
-            "HttpsProxy": "",
-            "ID": "",
-            "IPv4Forwarding": false,
-            "Images": 0,
-            "IndexServerAddress": "",
-            "InitBinary": "",
-            "InitCommit": {
-              "Expected": "",
-              "ID": ""
-            },
-            "Isolation": "",
-            "KernelMemory": false,
-            "KernelMemoryTCP": false,
-            "KernelVersion": "",
-            "Labels": null,
-            "LiveRestoreEnabled": false,
-            "LoggingDriver": "",
-            "MemTotal": 0,
-            "MemoryLimit": false,
-            "NCPU": 0,
-            "NEventsListener": 0,
-            "NFd": 0,
-            "NGoroutines": 0,
-            "Name": "",
-            "NoProxy": "",
-            "OSType": "",
-            "OSVersion": "",
-            "OomKillDisable": false,
-            "OperatingSystem": "",
-            "PidsLimit": false,
-            "Plugins": {
-              "Authorization": null,
-              "Log": null,
-              "Network": null,
-              "Volume": null
-            },
-            "RegistryConfig": null,
-            "RuncCommit": {
-              "Expected": "",
-              "ID": ""
-            },
-            "Runtimes": null,
-            "SecurityOptions": null,
-            "ServerVersion": "",
-            "SwapLimit": false,
-            "Swarm": {
-              "ControlAvailable": false,
-              "Error": "",
-              "LocalNodeState": "",
-              "NodeAddr": "",
-              "NodeID": "",
-              "RemoteManagers": null
-            },
-            "SystemTime": "",
-            "Warnings": null
-          },
-          "Networks": null,
-          "Version": {
-            "ApiVersion": "",
-            "Arch": "",
-            "GitCommit": "",
-            "GoVersion": "",
-            "Os": "",
-            "Platform": {
-              "Name": ""
-            },
-            "Version": ""
-          },
-          "Volumes": {
-            "Volumes": null,
-            "Warnings": null
-          }
-        },
-        "DockerVersion": "20.10.13",
-        "GpuUseAll": false,
-        "GpuUseList": null,
-        "HealthyContainerCount": 0,
-        "ImageCount": 9,
-        "NodeCount": 0,
-        "RunningContainerCount": 5,
-        "ServiceCount": 0,
-        "StackCount": 2,
-        "StoppedContainerCount": 0,
-        "Swarm": false,
-        "Time": 1648610112,
-        "TotalCPU": 8,
-        "TotalMemory": 25098706944,
-        "UnhealthyContainerCount": 0,
-        "VolumeCount": 10
-      },
-      "EndpointId": 1,
-      "Kubernetes": null
-    }
-  ],
-  "ssl": {
-    "certPath": "",
-    "httpEnabled": true,
-    "keyPath": "",
-    "selfSigned": false
-  },
-  "stacks": [
-    {
-      "AdditionalFiles": null,
-      "AutoUpdate": null,
-      "CreatedBy": "",
-      "CreationDate": 0,
-      "EndpointId": 1,
-      "EntryPoint": "docker/alpine37-compose.yml",
-      "Env": [],
-      "FromAppTemplate": false,
-      "GitConfig": null,
-      "Id": 2,
-      "IsComposeFormat": false,
-      "Name": "alpine",
-      "Namespace": "",
-      "Option": null,
-      "ProjectPath": "/home/prabhat/portainer/data/ce1.25/compose/2",
-      "ResourceControl": null,
-      "Status": 1,
-      "SwarmId": "s3fd604zdba7z13tbq2x6lyue",
-      "Type": 1,
-      "UpdateDate": 0,
-      "UpdatedBy": ""
-    },
-    {
-      "AdditionalFiles": null,
-      "AutoUpdate": null,
-      "CreatedBy": "",
-      "CreationDate": 0,
-      "EndpointId": 1,
-      "EntryPoint": "docker-compose.yml",
-      "Env": [],
-      "FromAppTemplate": false,
-      "GitConfig": null,
-      "Id": 5,
-      "IsComposeFormat": false,
-      "Name": "redis",
-      "Namespace": "",
-      "Option": null,
-      "ProjectPath": "/home/prabhat/portainer/data/ce1.25/compose/5",
-      "ResourceControl": null,
-      "Status": 1,
-      "SwarmId": "",
-      "Type": 2,
-      "UpdateDate": 0,
-      "UpdatedBy": ""
-    },
-    {
-      "AdditionalFiles": null,
-      "AutoUpdate": null,
-      "CreatedBy": "",
-      "CreationDate": 0,
-      "EndpointId": 1,
-      "EntryPoint": "docker-compose.yml",
-      "Env": [],
-      "FromAppTemplate": false,
-      "GitConfig": null,
-      "Id": 6,
-      "IsComposeFormat": false,
-      "Name": "nginx",
-      "Namespace": "",
-      "Option": null,
-      "ProjectPath": "/home/prabhat/portainer/data/ce1.25/compose/6",
-      "ResourceControl": null,
-      "Status": 1,
-      "SwarmId": "",
-      "Type": 2,
-      "UpdateDate": 0,
-      "UpdatedBy": ""
-    }
-  ],
-  "teams": [
-    {
-      "Id": 1,
-      "Name": "hello"
-    }
-  ],
-  "tunnel_server": {
-    "PrivateKeySeed": "IvX6ZPRuWtLS5zyg"
-  },
-  "users": [
-    {
-      "EndpointAuthorizations": null,
-      "Id": 1,
-      "Password": "$2a$10$siRDprr/5uUFAU8iom3Sr./WXQkN2dhSNjAC471pkJaALkghS762a",
-      "PortainerAuthorizations": {
-        "PortainerDockerHubInspect": true,
-        "PortainerEndpointGroupList": true,
-        "PortainerEndpointInspect": true,
-        "PortainerEndpointList": true,
-        "PortainerMOTD": true,
-        "PortainerRegistryInspect": true,
-        "PortainerRegistryList": true,
-        "PortainerTeamList": true,
-        "PortainerTemplateInspect": true,
-        "PortainerTemplateList": true,
-        "PortainerUserCreateToken": true,
-        "PortainerUserInspect": true,
-        "PortainerUserList": true,
-        "PortainerUserListToken": true,
-        "PortainerUserMemberships": true,
-        "PortainerUserRevokeToken": true
-      },
-      "Role": 1,
-      "TokenIssueAt": 0,
-      "UserTheme": "",
-      "Username": "admin"
-    },
-    {
-      "EndpointAuthorizations": null,
-      "Id": 2,
-      "Password": "$2a$10$WpCAW8mSt6FRRp1GkynbFOGSZnHR6E5j9cETZ8HiMlw06hVlDW/Li",
-      "PortainerAuthorizations": {
-        "PortainerDockerHubInspect": true,
-        "PortainerEndpointGroupList": true,
-        "PortainerEndpointInspect": true,
-        "PortainerEndpointList": true,
-        "PortainerMOTD": true,
-        "PortainerRegistryInspect": true,
-        "PortainerRegistryList": true,
-        "PortainerTeamList": true,
-        "PortainerTemplateInspect": true,
-        "PortainerTemplateList": true,
-        "PortainerUserCreateToken": true,
-        "PortainerUserInspect": true,
-        "PortainerUserList": true,
-        "PortainerUserListToken": true,
-        "PortainerUserMemberships": true,
-        "PortainerUserRevokeToken": true
-      },
-      "Role": 1,
-      "TokenIssueAt": 0,
-      "UserTheme": "",
-      "Username": "prabhat"
-    }
-  ],
-  "version": {
-    "DB_UPDATING": "false",
-    "DB_VERSION": "80",
-    "INSTANCE_ID": "null"
-  }
-}

api/datastore/validate/validate.go

@@ -1,15 +0,0 @@
-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

@@ -1,61 +0,0 @@
-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

@@ -1,17 +0,0 @@
-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/go.mod

@@ -17,10 +17,8 @@ require (
 	github.com/g07cha/defender v0.0.0-20180505193036-5665c627c814
 	github.com/go-git/go-git/v5 v5.3.0
 	github.com/go-ldap/ldap/v3 v3.1.8
-	github.com/go-playground/validator/v10 v10.10.1
 	github.com/gofrs/uuid v4.0.0+incompatible
 	github.com/golang-jwt/jwt v3.2.2+incompatible
-	github.com/google/go-cmp v0.5.8
 	github.com/gorilla/handlers v1.5.1
 	github.com/gorilla/mux v1.7.3
 	github.com/gorilla/securecookie v1.1.1
@@ -28,7 +26,6 @@ require (
 	github.com/hashicorp/golang-lru v0.5.4
 	github.com/joho/godotenv v1.3.0
 	github.com/jpillora/chisel v0.0.0-20190724232113-f3a8df20e389
-	github.com/json-iterator/go v1.1.12
 	github.com/koding/websocketproxy v0.0.0-20181220232114-7ed82d81a28c
 	github.com/orcaman/concurrent-map v0.0.0-20190826125027-8c72a8bb44f6
 	github.com/pkg/errors v0.9.1
@@ -41,13 +38,14 @@ require (
 	github.com/rs/zerolog v1.28.0
 	github.com/stretchr/testify v1.7.0
 	github.com/viney-shih/go-lock v1.1.1
-	go.etcd.io/bbolt v1.3.6
 	golang.org/x/crypto v0.0.0-20211215153901-e495a2d5b3d3
 	golang.org/x/exp v0.0.0-20220613132600-b0d781184e0d
 	golang.org/x/oauth2 v0.0.0-20210819190943-2bc19b11175f
 	golang.org/x/sync v0.0.0-20210220032951-036812b2e83c
 	gopkg.in/alecthomas/kingpin.v2 v2.2.6
 	gopkg.in/yaml.v3 v3.0.0-20210107192922-496545a6307b
+	gorm.io/driver/sqlite v1.4.2
+	gorm.io/gorm v1.24.0
 	k8s.io/api v0.22.5
 	k8s.io/apimachinery v0.22.5
 	k8s.io/client-go v0.22.5
@@ -74,23 +72,26 @@ require (
 	github.com/go-git/gcfg v1.5.0 // indirect
 	github.com/go-git/go-billy/v5 v5.1.0 // indirect
 	github.com/go-logr/logr v1.2.2 // indirect
-	github.com/go-playground/locales v0.14.0 // indirect
-	github.com/go-playground/universal-translator v0.18.0 // indirect
 	github.com/gogo/protobuf v1.3.2 // indirect
 	github.com/golang/protobuf v1.5.2 // indirect
+	github.com/google/go-cmp v0.5.8 // indirect
 	github.com/google/gofuzz v1.2.0 // indirect
 	github.com/google/shlex v0.0.0-20191202100458-e7afc7fbc510 // indirect
 	github.com/googleapis/gnostic v0.5.5 // indirect
 	github.com/imdario/mergo v0.3.12 // indirect
 	github.com/jbenet/go-context v0.0.0-20150711004518-d14ea06fba99 // indirect
+	github.com/jinzhu/inflection v1.0.0 // indirect
+	github.com/jinzhu/now v1.1.5 // indirect
 	github.com/jmespath/go-jmespath v0.4.0 // indirect
 	github.com/jpillora/ansi v1.0.2 // indirect
 	github.com/jpillora/requestlog v1.0.0 // indirect
 	github.com/jpillora/sizestr v1.0.0 // indirect
+	github.com/json-iterator/go v1.1.12 // indirect
 	github.com/kevinburke/ssh_config v0.0.0-20201106050909-4977a11b4351 // indirect
-	github.com/leodido/go-urn v1.2.1 // indirect
+	github.com/kr/pretty v0.3.0 // indirect
 	github.com/mattn/go-colorable v0.1.12 // indirect
 	github.com/mattn/go-isatty v0.0.14 // indirect
+	github.com/mattn/go-sqlite3 v1.14.15 // indirect
 	github.com/mitchellh/go-homedir v1.1.0 // indirect
 	github.com/mitchellh/mapstructure v1.1.2 // indirect
 	github.com/moby/spdystream v0.2.0 // indirect
@@ -103,6 +104,7 @@ require (
 	github.com/opencontainers/go-digest v1.0.0 // indirect
 	github.com/opencontainers/image-spec v1.0.2 // indirect
 	github.com/pmezard/go-difflib v1.0.0 // indirect
+	github.com/rogpeppe/go-internal v1.8.0 // indirect
 	github.com/sergi/go-diff v1.1.0 // indirect
 	github.com/sirupsen/logrus v1.8.1 // indirect
 	github.com/spf13/pflag v1.0.5 // indirect

api/go.sum

@@ -159,14 +159,6 @@ github.com/go-logr/logr v1.2.2/go.mod h1:jdQByPbusPIv2/zmleS9BjJVeZ6kBagPoEUsqbV
 github.com/go-openapi/jsonpointer v0.19.3/go.mod h1:Pl9vOtqEWErmShwVjC8pYs9cog34VGT37dQOVbmoatg=
 github.com/go-openapi/jsonreference v0.19.3/go.mod h1:rjx6GuL8TTa9VaixXglHmQmIL98+wF9xc8zWvFonSJ8=
 github.com/go-openapi/swag v0.19.5/go.mod h1:POnQmlKehdgb5mhVOsnJFsivZCEZ/vjK9gh66Z9tfKk=
-github.com/go-playground/assert/v2 v2.0.1 h1:MsBgLAaY856+nPRTKrp3/OZK38U/wa0CcBYNjji3q3A=
-github.com/go-playground/assert/v2 v2.0.1/go.mod h1:VDjEfimB/XKnb+ZQfWdccd7VUvScMdVu0Titje2rxJ4=
-github.com/go-playground/locales v0.14.0 h1:u50s323jtVGugKlcYeyzC0etD1HifMjqmJqb8WugfUU=
-github.com/go-playground/locales v0.14.0/go.mod h1:sawfccIbzZTqEDETgFXqTho0QybSa7l++s0DH+LDiLs=
-github.com/go-playground/universal-translator v0.18.0 h1:82dyy6p4OuJq4/CByFNOn/jYrnRPArHwAcmLoJZxyho=
-github.com/go-playground/universal-translator v0.18.0/go.mod h1:UvRDBj+xPUEGrFYl+lu/H90nyDXpg0fqeB/AQUGNTVA=
-github.com/go-playground/validator/v10 v10.10.1 h1:uA0+amWMiglNZKZ9FJRKUAe9U3RX91eVn1JYXMWt7ig=
-github.com/go-playground/validator/v10 v10.10.1/go.mod h1:i+3WkQ1FvaUjjxh1kSvIA4dMGDBiPU55YFDl0WbKdWU=
 github.com/go-task/slim-sprig v0.0.0-20210107165309-348f09dbbbc0/go.mod h1:fyg7847qk6SyHyPtNmDHnmrv/HOrqktSC+C9fM+CJOE=
 github.com/godbus/dbus/v5 v5.0.4/go.mod h1:xhWf0FNVPg57R7Z0UbKHbJfkEywrmjJnf7w5xrFpKfA=
 github.com/gofrs/uuid v4.0.0+incompatible h1:1SD/1F5pU8p29ybwgQSwpQk+mwdRrXCYuPhW6m+TnJw=
@@ -264,6 +256,11 @@ github.com/imdario/mergo v0.3.12/go.mod h1:jmQim1M+e3UYxmgPu/WyfjB3N3VflVyUjjjwH
 github.com/jbenet/go-context v0.0.0-20150711004518-d14ea06fba99 h1:BQSFePA1RWJOlocH6Fxy8MmwDt+yVQYULKfN0RoTN8A=
 github.com/jbenet/go-context v0.0.0-20150711004518-d14ea06fba99/go.mod h1:1lJo3i6rXxKeerYnT8Nvf0QmHCRC1n8sfWVwXF2Frvo=
 github.com/jessevdk/go-flags v1.5.0/go.mod h1:Fw0T6WPc1dYxT4mKEZRfG5kJhaTDP9pj1c2EWnYs/m4=
+github.com/jinzhu/inflection v1.0.0 h1:K317FqzuhWc8YvSVlFMCCUb36O/S9MCKRDI7QkRKD/E=
+github.com/jinzhu/inflection v1.0.0/go.mod h1:h+uFLlag+Qp1Va5pdKtLDYj+kHp5pxUVkryuEj+Srlc=
+github.com/jinzhu/now v1.1.4/go.mod h1:d3SSVoowX0Lcu0IBviAWJpolVfI5UJVZZ7cO71lE/z8=
+github.com/jinzhu/now v1.1.5 h1:/o9tlHleP7gOFmsnYNz3RGnqzefHA47wQpKrrdTIwXQ=
+github.com/jinzhu/now v1.1.5/go.mod h1:d3SSVoowX0Lcu0IBviAWJpolVfI5UJVZZ7cO71lE/z8=
 github.com/jmespath/go-jmespath v0.4.0 h1:BEgLn5cpjn8UN1mAw4NjwDrS35OdebyEtFe+9YPoQUg=
 github.com/jmespath/go-jmespath v0.4.0/go.mod h1:T8mJZnbsbmF+m6zOOFylbeCJqk5+pHWvzYPziyZiYoo=
 github.com/jmespath/go-jmespath/internal/testify v1.5.1 h1:shLQSRRSCCPj3f2gpwzGwWFoC7ycTf1rcQZHOlsJ6N8=
@@ -304,14 +301,14 @@ github.com/kr/pty v1.1.1/go.mod h1:pFQYn66WHrOpPYNljwOMqo10TkYh1fy3cYio2l3bCsQ=
 github.com/kr/text v0.1.0/go.mod h1:4Jbv+DJW3UT/LiOwJeYQe1efqtUx/iVham/4vfdArNI=
 github.com/kr/text v0.2.0 h1:5Nx0Ya0ZqY2ygV366QzturHI13Jq95ApcVaJBhpS+AY=
 github.com/kr/text v0.2.0/go.mod h1:eLer722TekiGuMkidMxC/pM04lWEeraHUUmBw8l2grE=
-github.com/leodido/go-urn v1.2.1 h1:BqpAaACuzVSgi/VLzGZIobT2z4v53pjosyNd9Yv6n/w=
-github.com/leodido/go-urn v1.2.1/go.mod h1:zt4jvISO2HfUBqxjfIshjdMTYS56ZS/qv49ictyFfxY=
 github.com/mailru/easyjson v0.0.0-20190614124828-94de47d64c63/go.mod h1:C1wdFJiN94OJF2b5HbByQZoLdCWB1Yqtg26g4irojpc=
 github.com/mailru/easyjson v0.0.0-20190626092158-b2ccc519800e/go.mod h1:C1wdFJiN94OJF2b5HbByQZoLdCWB1Yqtg26g4irojpc=
 github.com/mattn/go-colorable v0.1.12 h1:jF+Du6AlPIjs2BiUiQlKOX0rt3SujHxPnksPKZbaA40=
 github.com/mattn/go-colorable v0.1.12/go.mod h1:u5H1YNBxpqRaxsYJYSkiCWKzEfiAb1Gb520KVy5xxl4=
 github.com/mattn/go-isatty v0.0.14 h1:yVuAays6BHfxijgZPzw+3Zlu5yQgKGP2/hcQbHb7S9Y=
 github.com/mattn/go-isatty v0.0.14/go.mod h1:7GGIvUiUoEMVVmxf/4nioHXj79iQHKdU27kJ6hsGG94=
+github.com/mattn/go-sqlite3 v1.14.15 h1:vfoHhTN1af61xCRSWzFIWzx2YskyMTwHLrExkBOjvxI=
+github.com/mattn/go-sqlite3 v1.14.15/go.mod h1:2eHXhiwb8IkHr+BDWZGa96P6+rkvnG63S2DGjv9HUNg=
 github.com/mitchellh/go-homedir v1.1.0 h1:lukF9ziXFxDFPkA1vsr5zpc1XuPDn/wFntq5mG+4E0Y=
 github.com/mitchellh/go-homedir v1.1.0/go.mod h1:SfyaCUpYCn1Vlf4IUYiD9fPX4A5wJrkLzIz1N1q0pr0=
 github.com/mitchellh/mapstructure v1.1.2 h1:fmNYVwqnSfB9mZU6OS2O6GsXM+wcskZDuKQzvN1EDeE=
@@ -397,7 +394,6 @@ github.com/stretchr/testify v1.2.2/go.mod h1:a8OnRcib4nhh0OaRAV+Yts87kKdq0PP7pXf
 github.com/stretchr/testify v1.3.0/go.mod h1:M5WIy9Dh21IEIfnGCwXGc5bZfKNJtfHm1UVUgZn+9EI=
 github.com/stretchr/testify v1.4.0/go.mod h1:j7eGeouHqKxXV5pUuKE4zz7dFj8WfuZ+81PSLYec5m4=
 github.com/stretchr/testify v1.5.1/go.mod h1:5W2xD1RspED5o8YsWQXVCued0rvSQ+mT+I5cxcmMvtA=
-github.com/stretchr/testify v1.6.1/go.mod h1:6Fq8oRcR53rry900zMqJjRRixrwX3KX962/h/Wwjteg=
 github.com/stretchr/testify v1.7.0 h1:nwc3DEeHmmLAfoZucVR881uASk0Mfjw8xYJ99tb5CcY=
 github.com/stretchr/testify v1.7.0/go.mod h1:6Fq8oRcR53rry900zMqJjRRixrwX3KX962/h/Wwjteg=
 github.com/tomasen/realip v0.0.0-20180522021738-f0c99a92ddce h1:fb190+cK2Xz/dvi9Hv8eCYJYvIGUTN2/KLq1pT6CjEc=
@@ -418,8 +414,6 @@ github.com/yuin/goldmark v1.1.25/go.mod h1:3hX8gzYuyVAZsxl0MRgGTJEmQBFcNTphYh9de
 github.com/yuin/goldmark v1.1.27/go.mod h1:3hX8gzYuyVAZsxl0MRgGTJEmQBFcNTphYh9decYSb74=
 github.com/yuin/goldmark v1.1.32/go.mod h1:3hX8gzYuyVAZsxl0MRgGTJEmQBFcNTphYh9decYSb74=
 github.com/yuin/goldmark v1.2.1/go.mod h1:3hX8gzYuyVAZsxl0MRgGTJEmQBFcNTphYh9decYSb74=
-go.etcd.io/bbolt v1.3.6 h1:/ecaJf0sk1l4l6V4awd65v2C3ILy7MSj+s/x1ADCIMU=
-go.etcd.io/bbolt v1.3.6/go.mod h1:qXsaaIqmgQH0T+OPdb99Bf+PKfBBQVAdyD6TY9G8XM4=
 go.opencensus.io v0.21.0/go.mod h1:mSImk1erAIZhrmZN+AvHh14ztQfjbGwt4TtuofqLduU=
 go.opencensus.io v0.22.0/go.mod h1:+kGneAE2xo2IficOXnaByMWTGM9T73dGwxeWcUqIpI8=
 go.opencensus.io v0.22.2/go.mod h1:yxeiOL68Rb0Xd1ddK5vPZ/oVn4vY4Ynel7k9FzqtOIw=
@@ -503,7 +497,6 @@ golang.org/x/net v0.0.0-20201021035429-f5854403a974/go.mod h1:sp8m0HH+o8qH0wwXwY
 golang.org/x/net v0.0.0-20210226172049-e18ecbb05110/go.mod h1:m0MpNAwzfU5UDzcl9v0D8zg8gWTRqZa9RBIspLL5mdg=
 golang.org/x/net v0.0.0-20210326060303-6b1517762897/go.mod h1:uSPa2vr4CLtc/ILN5odXGNXS6mhrKVzTaCXzk9m6W3k=
 golang.org/x/net v0.0.0-20210428140749-89ef3d95e781/go.mod h1:OJAsFXCWl8Ukc7SiCT/9KSuxbyM7479/AVlXFRxuMCk=
-golang.org/x/net v0.0.0-20211112202133-69e39bad7dc2/go.mod h1:9nx3DQGgdP8bBQD5qxJ1jj9UTztislL4KSBs9R2vV5Y=
 golang.org/x/net v0.0.0-20211209124913-491a49abca63/go.mod h1:9nx3DQGgdP8bBQD5qxJ1jj9UTztislL4KSBs9R2vV5Y=
 golang.org/x/net v0.0.0-20211216030914-fe4d6282115f h1:hEYJvxw1lSnWIl8X9ofsYMklzaDs90JI2az5YMd4fPM=
 golang.org/x/net v0.0.0-20211216030914-fe4d6282115f/go.mod h1:9nx3DQGgdP8bBQD5qxJ1jj9UTztislL4KSBs9R2vV5Y=
@@ -559,7 +552,6 @@ golang.org/x/sys v0.0.0-20200515095857-1151b9dac4a9/go.mod h1:h1NjWce9XRLGQEsW7w
 golang.org/x/sys v0.0.0-20200519105757-fe76b779f299/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
 golang.org/x/sys v0.0.0-20200523222454-059865788121/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
 golang.org/x/sys v0.0.0-20200803210538-64077c9b5642/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
-golang.org/x/sys v0.0.0-20200923182605-d9f96fdee20d/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
 golang.org/x/sys v0.0.0-20200930185726-fdedc70b468f/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
 golang.org/x/sys v0.0.0-20201119102817-f84b799fce68/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
 golang.org/x/sys v0.0.0-20210112080510-489259a85091/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
@@ -567,10 +559,8 @@ golang.org/x/sys v0.0.0-20210124154548-22da62e12c0c/go.mod h1:h1NjWce9XRLGQEsW7w
 golang.org/x/sys v0.0.0-20210320140829-1e4c9ba3b0c4/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
 golang.org/x/sys v0.0.0-20210324051608-47abb6519492/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
 golang.org/x/sys v0.0.0-20210423082822-04245dca01da/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
-golang.org/x/sys v0.0.0-20210615035016-665e8c7367d1/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
 golang.org/x/sys v0.0.0-20210616094352-59db8d763f22/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
 golang.org/x/sys v0.0.0-20210630005230-0f9fa26af87c/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
-golang.org/x/sys v0.0.0-20210806184541-e5e7981a1069/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
 golang.org/x/sys v0.0.0-20210927094055-39ccf1dd6fa6/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
 golang.org/x/sys v0.0.0-20211216021012-1d35b9e2eb4e h1:fLOSk5Q00efkSvAm+4xcoXD+RRmLmmulPn5I3Y9F2EM=
 golang.org/x/sys v0.0.0-20211216021012-1d35b9e2eb4e/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
@@ -747,6 +737,10 @@ gopkg.in/yaml.v3 v3.0.0-20200313102051-9f266ea9e77c/go.mod h1:K4uyk7z7BCEPqu6E+C
 gopkg.in/yaml.v3 v3.0.0-20200615113413-eeeca48fe776/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM=
 gopkg.in/yaml.v3 v3.0.0-20210107192922-496545a6307b h1:h8qDotaEPuJATrMmW04NCwg7v22aHH28wwpauUhK9Oo=
 gopkg.in/yaml.v3 v3.0.0-20210107192922-496545a6307b/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM=
+gorm.io/driver/sqlite v1.4.2 h1:F6vYJcmR4Cnh0ErLyoY8JSfabBGyR0epIGuhgHJuNws=
+gorm.io/driver/sqlite v1.4.2/go.mod h1:0Aq3iPO+v9ZKbcdiz8gLWRw5VOPcBOPUQJFLq5e2ecI=
+gorm.io/gorm v1.24.0 h1:j/CoiSm6xpRpmzbFJsQHYj+I8bGYWLXVHeYEyyKlF74=
+gorm.io/gorm v1.24.0/go.mod h1:DVrVomtaYTbqs7gB/x2uVvqnXzv0nqjB396B8cG4dBA=
 gotest.tools/v3 v3.0.2/go.mod h1:3SzNCllyD9/Y+b5r9JIKQ474KzkZyqLqEfYqMsX94Bk=
 gotest.tools/v3 v3.0.3 h1:4AuOwCGf4lLR9u3YOe2awrHygurzhO/HeQ6laiA6Sx0=
 gotest.tools/v3 v3.0.3/go.mod h1:Z7Lb0S5l+klDB31fvDQX8ss/FlKDxtlFlw3Oa8Ymbl8=

api/http/handler/backup/backup.go

@@ -1,14 +1,9 @@
 package backup
 
 import (
-	"fmt"
 	"net/http"
-	"os"
-	"path/filepath"
 
 	httperror "github.com/portainer/libhttp/error"
-	"github.com/portainer/libhttp/request"
-	operations "github.com/portainer/portainer/api/backup"
 )
 
 type (
@@ -36,20 +31,20 @@ func (p *backupPayload) Validate(r *http.Request) error {
 // @failure 500 "Server error"
 // @router /backup [post]
 func (h *Handler) backup(w http.ResponseWriter, r *http.Request) *httperror.HandlerError {
-	var payload backupPayload
-	err := request.DecodeAndValidateJSONPayload(r, &payload)
-	if err != nil {
-		return httperror.BadRequest("Invalid request payload", err)
-	}
+	// var payload backupPayload
+	// err := request.DecodeAndValidateJSONPayload(r, &payload)
+	// if err != nil {
+	// 	return httperror.BadRequest("Invalid request payload", err)
+	// }
 
-	archivePath, err := operations.CreateBackupArchive(payload.Password, h.gate, h.dataStore, h.filestorePath)
-	if err != nil {
-		return httperror.InternalServerError("Failed to create backup", err)
-	}
-	defer os.RemoveAll(filepath.Dir(archivePath))
+	// archivePath, err := operations.CreateBackupArchive(payload.Password, h.gate, h.dataStore, h.filestorePath)
+	// if err != nil {
+	// 	return httperror.InternalServerError("Failed to create backup", err)
+	// }
+	// defer os.RemoveAll(filepath.Dir(archivePath))
 
-	w.Header().Set("Content-Disposition", fmt.Sprintf("attachment; filename=%s", fmt.Sprintf("portainer-backup_%s", filepath.Base(archivePath))))
-	http.ServeFile(w, r, archivePath)
+	// w.Header().Set("Content-Disposition", fmt.Sprintf("attachment; filename=%s", fmt.Sprintf("portainer-backup_%s", filepath.Base(archivePath))))
+	// http.ServeFile(w, r, archivePath)
 
 	return nil
 }

api/http/handler/backup/restore.go

@@ -1,21 +1,16 @@
 package backup
 
 import (
-	"bytes"
-	"io"
 	"net/http"
 
-	"github.com/pkg/errors"
 	httperror "github.com/portainer/libhttp/error"
-	"github.com/portainer/libhttp/request"
-	operations "github.com/portainer/portainer/api/backup"
 )
 
-type restorePayload struct {
-	FileContent []byte
-	FileName    string
-	Password    string
-}
+// type restorePayload struct {
+// 	FileContent []byte
+// 	FileName    string
+// 	Password    string
+// }
 
 // @id Restore
 // @summary Triggers a system restore using provided backup file
@@ -29,40 +24,40 @@ type restorePayload struct {
 // @failure 500 "Server error"
 // @router /restore [post]
 func (h *Handler) restore(w http.ResponseWriter, r *http.Request) *httperror.HandlerError {
-	initialized, err := h.adminMonitor.WasInitialized()
-	if err != nil {
-		return httperror.InternalServerError("Failed to check system initialization", err)
-	}
-	if initialized {
-		return httperror.BadRequest("Cannot restore already initialized instance", errors.New("system already initialized"))
-	}
-	h.adminMonitor.Stop()
-	defer h.adminMonitor.Start()
+	// initialized, err := h.adminMonitor.WasInitialized()
+	// if err != nil {
+	// 	return httperror.InternalServerError("Failed to check system initialization", err)
+	// }
+	// if initialized {
+	// 	return httperror.BadRequest("Cannot restore already initialized instance", errors.New("system already initialized"))
+	// }
+	// h.adminMonitor.Stop()
+	// defer h.adminMonitor.Start()
 
-	var payload restorePayload
-	err = decodeForm(r, &payload)
-	if err != nil {
-		return httperror.BadRequest("Invalid request payload", err)
-	}
+	// var payload restorePayload
+	// err = decodeForm(r, &payload)
+	// if err != nil {
+	// 	return httperror.BadRequest("Invalid request payload", err)
+	// }
 
-	var archiveReader io.Reader = bytes.NewReader(payload.FileContent)
-	err = operations.RestoreArchive(archiveReader, payload.Password, h.filestorePath, h.gate, h.dataStore, h.shutdownTrigger)
-	if err != nil {
-		return httperror.InternalServerError("Failed to restore the backup", err)
-	}
+	// var archiveReader io.Reader = bytes.NewReader(payload.FileContent)
+	// err = operations.RestoreArchive(archiveReader, payload.Password, h.filestorePath, h.gate, h.dataStore, h.shutdownTrigger)
+	// if err != nil {
+	// 	return httperror.InternalServerError("Failed to restore the backup", err)
+	// }
 
 	return nil
 }
 
-func decodeForm(r *http.Request, p *restorePayload) error {
-	content, name, err := request.RetrieveMultiPartFormFile(r, "file")
-	if err != nil {
-		return err
-	}
-	p.FileContent = content
-	p.FileName = name
+// func decodeForm(r *http.Request, p *restorePayload) error {
+// 	content, name, err := request.RetrieveMultiPartFormFile(r, "file")
+// 	if err != nil {
+// 		return err
+// 	}
+// 	p.FileContent = content
+// 	p.FileName = name
 
-	password, _ := request.RetrieveMultiPartFormValue(r, "password", true)
-	p.Password = password
-	return nil
-}
+// 	password, _ := request.RetrieveMultiPartFormValue(r, "password", true)
+// 	p.Password = password
+// 	return nil
+// }

api/http/handler/endpointedge/endpointedge_status_inspect_test.go

@@ -1,445 +1,445 @@
 package endpointedge
 
-import (
-	"context"
-	"encoding/json"
-	"fmt"
-	"net/http"
-	"net/http/httptest"
-	"testing"
-	"time"
-
-	portainer "github.com/portainer/portainer/api"
-	"github.com/portainer/portainer/api/apikey"
-	"github.com/portainer/portainer/api/chisel"
-	"github.com/portainer/portainer/api/datastore"
-	"github.com/portainer/portainer/api/filesystem"
-	"github.com/portainer/portainer/api/http/security"
-	"github.com/portainer/portainer/api/jwt"
-
-	"github.com/stretchr/testify/assert"
-)
-
-type endpointTestCase struct {
-	endpoint           portainer.Endpoint
-	endpointRelation   portainer.EndpointRelation
-	expectedStatusCode int
-}
-
-var endpointTestCases = []endpointTestCase{
-	{
-		portainer.Endpoint{},
-		portainer.EndpointRelation{},
-		http.StatusNotFound,
-	},
-	{
-		portainer.Endpoint{
-			ID:     -1,
-			Name:   "endpoint-id--1",
-			Type:   portainer.EdgeAgentOnDockerEnvironment,
-			URL:    "https://portainer.io:9443",
-			EdgeID: "edge-id",
-		},
-		portainer.EndpointRelation{
-			EndpointID: -1,
-		},
-		http.StatusNotFound,
-	},
-	{
-		portainer.Endpoint{
-			ID:     2,
-			Name:   "endpoint-id-2",
-			Type:   portainer.EdgeAgentOnDockerEnvironment,
-			URL:    "https://portainer.io:9443",
-			EdgeID: "",
-		},
-		portainer.EndpointRelation{
-			EndpointID: 2,
-		},
-		http.StatusForbidden,
-	},
-	{
-		portainer.Endpoint{
-			ID:     4,
-			Name:   "endpoint-id-4",
-			Type:   portainer.EdgeAgentOnDockerEnvironment,
-			URL:    "https://portainer.io:9443",
-			EdgeID: "edge-id",
-		},
-		portainer.EndpointRelation{
-			EndpointID: 4,
-		},
-		http.StatusOK,
-	},
-}
-
-func setupHandler(t *testing.T) (*Handler, func(), error) {
-	tmpDir := t.TempDir()
-	fs, err := filesystem.NewService(tmpDir, "")
-	if err != nil {
-		return nil, nil, fmt.Errorf("could not start a new filesystem service: %w", err)
-	}
-
-	_, store, storeTeardown := datastore.MustNewTestStore(t, true, true)
-
-	ctx := context.Background()
-	shutdownCtx, cancelFn := context.WithCancel(ctx)
-
-	teardown := func() {
-		cancelFn()
-		storeTeardown()
-	}
-
-	jwtService, err := jwt.NewService("1h", store)
-	if err != nil {
-		teardown()
-		return nil, nil, fmt.Errorf("could not start a new jwt service: %w", err)
-	}
-
-	apiKeyService := apikey.NewAPIKeyService(nil, nil)
-
-	settings, err := store.Settings().Settings()
-	if err != nil {
-		teardown()
-		return nil, nil, fmt.Errorf("could not create new settings: %w", err)
-	}
-	settings.TrustOnFirstConnect = true
-
-	err = store.Settings().UpdateSettings(settings)
-	if err != nil {
-		teardown()
-		return nil, nil, fmt.Errorf("could not update settings: %w", err)
-	}
-
-	handler := NewHandler(
-		security.NewRequestBouncer(store, jwtService, apiKeyService),
-		store,
-		fs,
-		chisel.NewService(store, shutdownCtx),
-	)
-
-	handler.ReverseTunnelService = chisel.NewService(store, shutdownCtx)
-
-	return handler, teardown, nil
-}
-
-func createEndpoint(handler *Handler, endpoint portainer.Endpoint, endpointRelation portainer.EndpointRelation) (err error) {
-	// Avoid setting ID below 0 to generate invalid test cases
-	if endpoint.ID <= 0 {
-		return nil
-	}
-
-	err = handler.DataStore.Endpoint().Create(&endpoint)
-	if err != nil {
-		return err
-	}
-
-	return handler.DataStore.EndpointRelation().Create(&endpointRelation)
-}
-
-func TestMissingEdgeIdentifier(t *testing.T) {
-	handler, teardown, err := setupHandler(t)
-	defer teardown()
-
-	if err != nil {
-		t.Fatal(err)
-	}
-
-	endpointID := portainer.EndpointID(45)
-	err = createEndpoint(handler, portainer.Endpoint{
-		ID:     endpointID,
-		Name:   "endpoint-id-45",
-		Type:   portainer.EdgeAgentOnDockerEnvironment,
-		URL:    "https://portainer.io:9443",
-		EdgeID: "edge-id",
-	}, portainer.EndpointRelation{EndpointID: endpointID})
-
-	if err != nil {
-		t.Fatal(err)
-	}
-
-	req, err := http.NewRequest(http.MethodGet, fmt.Sprintf("/%d/edge/status", endpointID), nil)
-	if err != nil {
-		t.Fatal("request error:", err)
-	}
-
-	rec := httptest.NewRecorder()
-	handler.ServeHTTP(rec, req)
-
-	if rec.Code != http.StatusForbidden {
-		t.Fatalf(fmt.Sprintf("expected a %d response, found: %d without Edge identifier", http.StatusForbidden, rec.Code))
-	}
-}
-
-func TestWithEndpoints(t *testing.T) {
-	handler, teardown, err := setupHandler(t)
-	defer teardown()
-
-	if err != nil {
-		t.Fatal(err)
-	}
-
-	for _, test := range endpointTestCases {
-		err = createEndpoint(handler, test.endpoint, test.endpointRelation)
-		if err != nil {
-			t.Fatal(err)
-		}
-
-		req, err := http.NewRequest(http.MethodGet, fmt.Sprintf("/%d/edge/status", test.endpoint.ID), nil)
-		if err != nil {
-			t.Fatal("request error:", err)
-		}
-
-		req.Header.Set(portainer.PortainerAgentEdgeIDHeader, test.endpoint.EdgeID)
-		req.Header.Set(portainer.HTTPResponseAgentPlatform, "1")
-
-		rec := httptest.NewRecorder()
-		handler.ServeHTTP(rec, req)
-
-		if rec.Code != test.expectedStatusCode {
-			t.Fatalf(fmt.Sprintf("expected a %d response, found: %d for endpoint ID: %d", test.expectedStatusCode, rec.Code, test.endpoint.ID))
-		}
-	}
-}
-
-func TestLastCheckInDateIncreases(t *testing.T) {
-	handler, teardown, err := setupHandler(t)
-	defer teardown()
-
-	if err != nil {
-		t.Fatal(err)
-	}
-
-	endpointID := portainer.EndpointID(56)
-	endpoint := portainer.Endpoint{
-		ID:              endpointID,
-		Name:            "test-endpoint-56",
-		Type:            portainer.EdgeAgentOnDockerEnvironment,
-		URL:             "https://portainer.io:9443",
-		EdgeID:          "edge-id",
-		LastCheckInDate: time.Now().Unix(),
-	}
-
-	endpointRelation := portainer.EndpointRelation{
-		EndpointID: endpoint.ID,
-	}
-
-	err = createEndpoint(handler, endpoint, endpointRelation)
-	if err != nil {
-		t.Fatal(err)
-	}
-
-	time.Sleep(1 * time.Second)
-
-	req, err := http.NewRequest(http.MethodGet, fmt.Sprintf("/%d/edge/status", endpoint.ID), nil)
-	if err != nil {
-		t.Fatal("request error:", err)
-	}
-	req.Header.Set(portainer.PortainerAgentEdgeIDHeader, "edge-id")
-	req.Header.Set(portainer.HTTPResponseAgentPlatform, "1")
-
-	rec := httptest.NewRecorder()
-	handler.ServeHTTP(rec, req)
-
-	if rec.Code != http.StatusOK {
-		t.Fatalf(fmt.Sprintf("expected a %d response, found: %d", http.StatusOK, rec.Code))
-	}
-
-	updatedEndpoint, err := handler.DataStore.Endpoint().Endpoint(endpoint.ID)
-	if err != nil {
-		t.Fatal(err)
-	}
-
-	assert.Greater(t, updatedEndpoint.LastCheckInDate, endpoint.LastCheckInDate)
-}
-
-func TestEmptyEdgeIdWithAgentPlatformHeader(t *testing.T) {
-	handler, teardown, err := setupHandler(t)
-	defer teardown()
-
-	if err != nil {
-		t.Fatal(err)
-	}
-
-	endpointID := portainer.EndpointID(44)
-	edgeId := "edge-id"
-	endpoint := portainer.Endpoint{
-		ID:     endpointID,
-		Name:   "test-endpoint-44",
-		Type:   portainer.EdgeAgentOnDockerEnvironment,
-		URL:    "https://portainer.io:9443",
-		EdgeID: "",
-	}
-	endpointRelation := portainer.EndpointRelation{
-		EndpointID: endpoint.ID,
-	}
-
-	err = createEndpoint(handler, endpoint, endpointRelation)
-	if err != nil {
-		t.Fatal(err)
-	}
-
-	req, err := http.NewRequest(http.MethodGet, fmt.Sprintf("/%d/edge/status", endpoint.ID), nil)
-	if err != nil {
-		t.Fatal("request error:", err)
-	}
-	req.Header.Set(portainer.PortainerAgentEdgeIDHeader, edgeId)
-	req.Header.Set(portainer.HTTPResponseAgentPlatform, "1")
-
-	rec := httptest.NewRecorder()
-	handler.ServeHTTP(rec, req)
-
-	if rec.Code != http.StatusOK {
-		t.Fatalf(fmt.Sprintf("expected a %d response, found: %d with empty edge ID", http.StatusOK, rec.Code))
-	}
-
-	updatedEndpoint, err := handler.DataStore.Endpoint().Endpoint(endpoint.ID)
-	if err != nil {
-		t.Fatal(err)
-	}
-
-	assert.Equal(t, updatedEndpoint.EdgeID, edgeId)
-}
-
-func TestEdgeStackStatus(t *testing.T) {
-	handler, teardown, err := setupHandler(t)
-	defer teardown()
-
-	if err != nil {
-		t.Fatal(err)
-	}
-
-	endpointID := portainer.EndpointID(7)
-	endpoint := portainer.Endpoint{
-		ID:              endpointID,
-		Name:            "test-endpoint-7",
-		Type:            portainer.EdgeAgentOnDockerEnvironment,
-		URL:             "https://portainer.io:9443",
-		EdgeID:          "edge-id",
-		LastCheckInDate: time.Now().Unix(),
-	}
-
-	edgeStackID := portainer.EdgeStackID(17)
-	edgeStack := portainer.EdgeStack{
-		ID:   edgeStackID,
-		Name: "test-edge-stack-17",
-		Status: map[portainer.EndpointID]portainer.EdgeStackStatus{
-			endpointID: {Type: portainer.StatusOk, Error: "", EndpointID: endpoint.ID},
-		},
-		CreationDate:   time.Now().Unix(),
-		EdgeGroups:     []portainer.EdgeGroupID{1, 2},
-		ProjectPath:    "/project/path",
-		EntryPoint:     "entrypoint",
-		Version:        237,
-		ManifestPath:   "/manifest/path",
-		DeploymentType: 1,
-	}
-
-	endpointRelation := portainer.EndpointRelation{
-		EndpointID: endpoint.ID,
-		EdgeStacks: map[portainer.EdgeStackID]bool{
-			edgeStack.ID: true,
-		},
-	}
-	handler.DataStore.EdgeStack().Create(edgeStack.ID, &edgeStack)
-
-	err = createEndpoint(handler, endpoint, endpointRelation)
-	if err != nil {
-		t.Fatal(err)
-	}
-
-	req, err := http.NewRequest(http.MethodGet, fmt.Sprintf("/%d/edge/status", endpoint.ID), nil)
-	if err != nil {
-		t.Fatal("request error:", err)
-	}
-	req.Header.Set(portainer.PortainerAgentEdgeIDHeader, "edge-id")
-	req.Header.Set(portainer.HTTPResponseAgentPlatform, "1")
-
-	rec := httptest.NewRecorder()
-	handler.ServeHTTP(rec, req)
-
-	if rec.Code != http.StatusOK {
-		t.Fatalf(fmt.Sprintf("expected a %d response, found: %d", http.StatusOK, rec.Code))
-	}
-
-	var data endpointEdgeStatusInspectResponse
-	err = json.NewDecoder(rec.Body).Decode(&data)
-	if err != nil {
-		t.Fatal("error decoding response:", err)
-	}
-
-	assert.Len(t, data.Stacks, 1)
-	assert.Equal(t, edgeStack.ID, data.Stacks[0].ID)
-	assert.Equal(t, edgeStack.Version, data.Stacks[0].Version)
-}
-
-func TestEdgeJobsResponse(t *testing.T) {
-	handler, teardown, err := setupHandler(t)
-	defer teardown()
-
-	if err != nil {
-		t.Fatal(err)
-	}
-
-	endpointID := portainer.EndpointID(77)
-	endpoint := portainer.Endpoint{
-		ID:              endpointID,
-		Name:            "test-endpoint-77",
-		Type:            portainer.EdgeAgentOnDockerEnvironment,
-		URL:             "https://portainer.io:9443",
-		EdgeID:          "edge-id",
-		LastCheckInDate: time.Now().Unix(),
-	}
-
-	endpointRelation := portainer.EndpointRelation{
-		EndpointID: endpoint.ID,
-	}
-
-	err = createEndpoint(handler, endpoint, endpointRelation)
-	if err != nil {
-		t.Fatal(err)
-	}
-
-	path, err := handler.FileService.StoreEdgeJobFileFromBytes("test-script", []byte("pwd"))
-	if err != nil {
-		t.Fatal(err)
-	}
-
-	edgeJobID := portainer.EdgeJobID(35)
-	edgeJob := portainer.EdgeJob{
-		ID:             edgeJobID,
-		Created:        time.Now().Unix(),
-		CronExpression: "* * * * *",
-		Name:           "test-edge-job",
-		ScriptPath:     path,
-		Recurring:      true,
-		Version:        57,
-	}
-
-	handler.ReverseTunnelService.AddEdgeJob(endpoint.ID, &edgeJob)
-
-	req, err := http.NewRequest(http.MethodGet, fmt.Sprintf("/%d/edge/status", endpoint.ID), nil)
-	if err != nil {
-		t.Fatal("request error:", err)
-	}
-	req.Header.Set(portainer.PortainerAgentEdgeIDHeader, "edge-id")
-	req.Header.Set(portainer.HTTPResponseAgentPlatform, "1")
-
-	rec := httptest.NewRecorder()
-	handler.ServeHTTP(rec, req)
-
-	if rec.Code != http.StatusOK {
-		t.Fatalf(fmt.Sprintf("expected a %d response, found: %d", http.StatusOK, rec.Code))
-	}
-
-	var data endpointEdgeStatusInspectResponse
-	err = json.NewDecoder(rec.Body).Decode(&data)
-	if err != nil {
-		t.Fatal("error decoding response:", err)
-	}
-
-	assert.Len(t, data.Schedules, 1)
-	assert.Equal(t, edgeJob.ID, data.Schedules[0].ID)
-	assert.Equal(t, edgeJob.CronExpression, data.Schedules[0].CronExpression)
-	assert.Equal(t, edgeJob.Version, data.Schedules[0].Version)
-}
+// import (
+// 	"context"
+// 	"encoding/json"
+// 	"fmt"
+// 	"net/http"
+// 	"net/http/httptest"
+// 	"testing"
+// 	"time"
+
+// 	portainer "github.com/portainer/portainer/api"
+// 	"github.com/portainer/portainer/api/apikey"
+// 	"github.com/portainer/portainer/api/chisel"
+// 	"github.com/portainer/portainer/api/datastore"
+// 	"github.com/portainer/portainer/api/filesystem"
+// 	"github.com/portainer/portainer/api/http/security"
+// 	"github.com/portainer/portainer/api/jwt"
+
+// 	"github.com/stretchr/testify/assert"
+// )
+
+// type endpointTestCase struct {
+// 	endpoint           portainer.Endpoint
+// 	endpointRelation   portainer.EndpointRelation
+// 	expectedStatusCode int
+// }
+
+// var endpointTestCases = []endpointTestCase{
+// 	{
+// 		portainer.Endpoint{},
+// 		portainer.EndpointRelation{},
+// 		http.StatusNotFound,
+// 	},
+// 	{
+// 		portainer.Endpoint{
+// 			ID:     -1,
+// 			Name:   "endpoint-id--1",
+// 			Type:   portainer.EdgeAgentOnDockerEnvironment,
+// 			URL:    "https://portainer.io:9443",
+// 			EdgeID: "edge-id",
+// 		},
+// 		portainer.EndpointRelation{
+// 			EndpointID: -1,
+// 		},
+// 		http.StatusNotFound,
+// 	},
+// 	{
+// 		portainer.Endpoint{
+// 			ID:     2,
+// 			Name:   "endpoint-id-2",
+// 			Type:   portainer.EdgeAgentOnDockerEnvironment,
+// 			URL:    "https://portainer.io:9443",
+// 			EdgeID: "",
+// 		},
+// 		portainer.EndpointRelation{
+// 			EndpointID: 2,
+// 		},
+// 		http.StatusForbidden,
+// 	},
+// 	{
+// 		portainer.Endpoint{
+// 			ID:     4,
+// 			Name:   "endpoint-id-4",
+// 			Type:   portainer.EdgeAgentOnDockerEnvironment,
+// 			URL:    "https://portainer.io:9443",
+// 			EdgeID: "edge-id",
+// 		},
+// 		portainer.EndpointRelation{
+// 			EndpointID: 4,
+// 		},
+// 		http.StatusOK,
+// 	},
+// }
+
+// func setupHandler(t *testing.T) (*Handler, func(), error) {
+// 	tmpDir := t.TempDir()
+// 	fs, err := filesystem.NewService(tmpDir, "")
+// 	if err != nil {
+// 		return nil, nil, fmt.Errorf("could not start a new filesystem service: %w", err)
+// 	}
+
+// 	_, store, storeTeardown := datastore.MustNewTestStore(t, true, true)
+
+// 	ctx := context.Background()
+// 	shutdownCtx, cancelFn := context.WithCancel(ctx)
+
+// 	teardown := func() {
+// 		cancelFn()
+// 		storeTeardown()
+// 	}
+
+// 	jwtService, err := jwt.NewService("1h", store)
+// 	if err != nil {
+// 		teardown()
+// 		return nil, nil, fmt.Errorf("could not start a new jwt service: %w", err)
+// 	}
+
+// 	apiKeyService := apikey.NewAPIKeyService(nil, nil)
+
+// 	settings, err := store.Settings().Settings()
+// 	if err != nil {
+// 		teardown()
+// 		return nil, nil, fmt.Errorf("could not create new settings: %w", err)
+// 	}
+// 	settings.TrustOnFirstConnect = true
+
+// 	err = store.Settings().UpdateSettings(settings)
+// 	if err != nil {
+// 		teardown()
+// 		return nil, nil, fmt.Errorf("could not update settings: %w", err)
+// 	}
+
+// 	handler := NewHandler(
+// 		security.NewRequestBouncer(store, jwtService, apiKeyService),
+// 		store,
+// 		fs,
+// 		chisel.NewService(store, shutdownCtx),
+// 	)
+
+// 	handler.ReverseTunnelService = chisel.NewService(store, shutdownCtx)
+
+// 	return handler, teardown, nil
+// }
+
+// func createEndpoint(handler *Handler, endpoint portainer.Endpoint, endpointRelation portainer.EndpointRelation) (err error) {
+// 	// Avoid setting ID below 0 to generate invalid test cases
+// 	if endpoint.ID <= 0 {
+// 		return nil
+// 	}
+
+// 	err = handler.DataStore.Endpoint().Create(&endpoint)
+// 	if err != nil {
+// 		return err
+// 	}
+
+// 	return handler.DataStore.EndpointRelation().Create(&endpointRelation)
+// }
+
+// func TestMissingEdgeIdentifier(t *testing.T) {
+// 	handler, teardown, err := setupHandler(t)
+// 	defer teardown()
+
+// 	if err != nil {
+// 		t.Fatal(err)
+// 	}
+
+// 	endpointID := portainer.EndpointID(45)
+// 	err = createEndpoint(handler, portainer.Endpoint{
+// 		ID:     endpointID,
+// 		Name:   "endpoint-id-45",
+// 		Type:   portainer.EdgeAgentOnDockerEnvironment,
+// 		URL:    "https://portainer.io:9443",
+// 		EdgeID: "edge-id",
+// 	}, portainer.EndpointRelation{EndpointID: endpointID})
+
+// 	if err != nil {
+// 		t.Fatal(err)
+// 	}
+
+// 	req, err := http.NewRequest(http.MethodGet, fmt.Sprintf("/%d/edge/status", endpointID), nil)
+// 	if err != nil {
+// 		t.Fatal("request error:", err)
+// 	}
+
+// 	rec := httptest.NewRecorder()
+// 	handler.ServeHTTP(rec, req)
+
+// 	if rec.Code != http.StatusForbidden {
+// 		t.Fatalf(fmt.Sprintf("expected a %d response, found: %d without Edge identifier", http.StatusForbidden, rec.Code))
+// 	}
+// }
+
+// func TestWithEndpoints(t *testing.T) {
+// 	handler, teardown, err := setupHandler(t)
+// 	defer teardown()
+
+// 	if err != nil {
+// 		t.Fatal(err)
+// 	}
+
+// 	for _, test := range endpointTestCases {
+// 		err = createEndpoint(handler, test.endpoint, test.endpointRelation)
+// 		if err != nil {
+// 			t.Fatal(err)
+// 		}
+
+// 		req, err := http.NewRequest(http.MethodGet, fmt.Sprintf("/%d/edge/status", test.endpoint.ID), nil)
+// 		if err != nil {
+// 			t.Fatal("request error:", err)
+// 		}
+
+// 		req.Header.Set(portainer.PortainerAgentEdgeIDHeader, test.endpoint.EdgeID)
+// 		req.Header.Set(portainer.HTTPResponseAgentPlatform, "1")
+
+// 		rec := httptest.NewRecorder()
+// 		handler.ServeHTTP(rec, req)
+
+// 		if rec.Code != test.expectedStatusCode {
+// 			t.Fatalf(fmt.Sprintf("expected a %d response, found: %d for endpoint ID: %d", test.expectedStatusCode, rec.Code, test.endpoint.ID))
+// 		}
+// 	}
+// }
+
+// func TestLastCheckInDateIncreases(t *testing.T) {
+// 	handler, teardown, err := setupHandler(t)
+// 	defer teardown()
+
+// 	if err != nil {
+// 		t.Fatal(err)
+// 	}
+
+// 	endpointID := portainer.EndpointID(56)
+// 	endpoint := portainer.Endpoint{
+// 		ID:              endpointID,
+// 		Name:            "test-endpoint-56",
+// 		Type:            portainer.EdgeAgentOnDockerEnvironment,
+// 		URL:             "https://portainer.io:9443",
+// 		EdgeID:          "edge-id",
+// 		LastCheckInDate: time.Now().Unix(),
+// 	}
+
+// 	endpointRelation := portainer.EndpointRelation{
+// 		EndpointID: endpoint.ID,
+// 	}
+
+// 	err = createEndpoint(handler, endpoint, endpointRelation)
+// 	if err != nil {
+// 		t.Fatal(err)
+// 	}
+
+// 	time.Sleep(1 * time.Second)
+
+// 	req, err := http.NewRequest(http.MethodGet, fmt.Sprintf("/%d/edge/status", endpoint.ID), nil)
+// 	if err != nil {
+// 		t.Fatal("request error:", err)
+// 	}
+// 	req.Header.Set(portainer.PortainerAgentEdgeIDHeader, "edge-id")
+// 	req.Header.Set(portainer.HTTPResponseAgentPlatform, "1")
+
+// 	rec := httptest.NewRecorder()
+// 	handler.ServeHTTP(rec, req)
+
+// 	if rec.Code != http.StatusOK {
+// 		t.Fatalf(fmt.Sprintf("expected a %d response, found: %d", http.StatusOK, rec.Code))
+// 	}
+
+// 	updatedEndpoint, err := handler.DataStore.Endpoint().Endpoint(endpoint.ID)
+// 	if err != nil {
+// 		t.Fatal(err)
+// 	}
+
+// 	assert.Greater(t, updatedEndpoint.LastCheckInDate, endpoint.LastCheckInDate)
+// }
+
+// func TestEmptyEdgeIdWithAgentPlatformHeader(t *testing.T) {
+// 	handler, teardown, err := setupHandler(t)
+// 	defer teardown()
+
+// 	if err != nil {
+// 		t.Fatal(err)
+// 	}
+
+// 	endpointID := portainer.EndpointID(44)
+// 	edgeId := "edge-id"
+// 	endpoint := portainer.Endpoint{
+// 		ID:     endpointID,
+// 		Name:   "test-endpoint-44",
+// 		Type:   portainer.EdgeAgentOnDockerEnvironment,
+// 		URL:    "https://portainer.io:9443",
+// 		EdgeID: "",
+// 	}
+// 	endpointRelation := portainer.EndpointRelation{
+// 		EndpointID: endpoint.ID,
+// 	}
+
+// 	err = createEndpoint(handler, endpoint, endpointRelation)
+// 	if err != nil {
+// 		t.Fatal(err)
+// 	}
+
+// 	req, err := http.NewRequest(http.MethodGet, fmt.Sprintf("/%d/edge/status", endpoint.ID), nil)
+// 	if err != nil {
+// 		t.Fatal("request error:", err)
+// 	}
+// 	req.Header.Set(portainer.PortainerAgentEdgeIDHeader, edgeId)
+// 	req.Header.Set(portainer.HTTPResponseAgentPlatform, "1")
+
+// 	rec := httptest.NewRecorder()
+// 	handler.ServeHTTP(rec, req)
+
+// 	if rec.Code != http.StatusOK {
+// 		t.Fatalf(fmt.Sprintf("expected a %d response, found: %d with empty edge ID", http.StatusOK, rec.Code))
+// 	}
+
+// 	updatedEndpoint, err := handler.DataStore.Endpoint().Endpoint(endpoint.ID)
+// 	if err != nil {
+// 		t.Fatal(err)
+// 	}
+
+// 	assert.Equal(t, updatedEndpoint.EdgeID, edgeId)
+// }
+
+// func TestEdgeStackStatus(t *testing.T) {
+// 	handler, teardown, err := setupHandler(t)
+// 	defer teardown()
+
+// 	if err != nil {
+// 		t.Fatal(err)
+// 	}
+
+// 	endpointID := portainer.EndpointID(7)
+// 	endpoint := portainer.Endpoint{
+// 		ID:              endpointID,
+// 		Name:            "test-endpoint-7",
+// 		Type:            portainer.EdgeAgentOnDockerEnvironment,
+// 		URL:             "https://portainer.io:9443",
+// 		EdgeID:          "edge-id",
+// 		LastCheckInDate: time.Now().Unix(),
+// 	}
+
+// 	edgeStackID := portainer.EdgeStackID(17)
+// 	edgeStack := portainer.EdgeStack{
+// 		ID:   edgeStackID,
+// 		Name: "test-edge-stack-17",
+// 		Status: map[portainer.EndpointID]portainer.EdgeStackStatus{
+// 			endpointID: {Type: portainer.StatusOk, Error: "", EndpointID: endpoint.ID},
+// 		},
+// 		CreationDate:   time.Now().Unix(),
+// 		EdgeGroups:     []portainer.EdgeGroupID{1, 2},
+// 		ProjectPath:    "/project/path",
+// 		EntryPoint:     "entrypoint",
+// 		Version:        237,
+// 		ManifestPath:   "/manifest/path",
+// 		DeploymentType: 1,
+// 	}
+
+// 	endpointRelation := portainer.EndpointRelation{
+// 		EndpointID: endpoint.ID,
+// 		EdgeStacks: map[portainer.EdgeStackID]bool{
+// 			edgeStack.ID: true,
+// 		},
+// 	}
+// 	handler.DataStore.EdgeStack().Create(edgeStack.ID, &edgeStack)
+
+// 	err = createEndpoint(handler, endpoint, endpointRelation)
+// 	if err != nil {
+// 		t.Fatal(err)
+// 	}
+
+// 	req, err := http.NewRequest(http.MethodGet, fmt.Sprintf("/%d/edge/status", endpoint.ID), nil)
+// 	if err != nil {
+// 		t.Fatal("request error:", err)
+// 	}
+// 	req.Header.Set(portainer.PortainerAgentEdgeIDHeader, "edge-id")
+// 	req.Header.Set(portainer.HTTPResponseAgentPlatform, "1")
+
+// 	rec := httptest.NewRecorder()
+// 	handler.ServeHTTP(rec, req)
+
+// 	if rec.Code != http.StatusOK {
+// 		t.Fatalf(fmt.Sprintf("expected a %d response, found: %d", http.StatusOK, rec.Code))
+// 	}
+
+// 	var data endpointEdgeStatusInspectResponse
+// 	err = json.NewDecoder(rec.Body).Decode(&data)
+// 	if err != nil {
+// 		t.Fatal("error decoding response:", err)
+// 	}
+
+// 	assert.Len(t, data.Stacks, 1)
+// 	assert.Equal(t, edgeStack.ID, data.Stacks[0].ID)
+// 	assert.Equal(t, edgeStack.Version, data.Stacks[0].Version)
+// }
+
+// func TestEdgeJobsResponse(t *testing.T) {
+// 	handler, teardown, err := setupHandler(t)
+// 	defer teardown()
+
+// 	if err != nil {
+// 		t.Fatal(err)
+// 	}
+
+// 	endpointID := portainer.EndpointID(77)
+// 	endpoint := portainer.Endpoint{
+// 		ID:              endpointID,
+// 		Name:            "test-endpoint-77",
+// 		Type:            portainer.EdgeAgentOnDockerEnvironment,
+// 		URL:             "https://portainer.io:9443",
+// 		EdgeID:          "edge-id",
+// 		LastCheckInDate: time.Now().Unix(),
+// 	}
+
+// 	endpointRelation := portainer.EndpointRelation{
+// 		EndpointID: endpoint.ID,
+// 	}
+
+// 	err = createEndpoint(handler, endpoint, endpointRelation)
+// 	if err != nil {
+// 		t.Fatal(err)
+// 	}
+
+// 	path, err := handler.FileService.StoreEdgeJobFileFromBytes("test-script", []byte("pwd"))
+// 	if err != nil {
+// 		t.Fatal(err)
+// 	}
+
+// 	edgeJobID := portainer.EdgeJobID(35)
+// 	edgeJob := portainer.EdgeJob{
+// 		ID:             edgeJobID,
+// 		Created:        time.Now().Unix(),
+// 		CronExpression: "* * * * *",
+// 		Name:           "test-edge-job",
+// 		ScriptPath:     path,
+// 		Recurring:      true,
+// 		Version:        57,
+// 	}
+
+// 	handler.ReverseTunnelService.AddEdgeJob(endpoint.ID, &edgeJob)
+
+// 	req, err := http.NewRequest(http.MethodGet, fmt.Sprintf("/%d/edge/status", endpoint.ID), nil)
+// 	if err != nil {
+// 		t.Fatal("request error:", err)
+// 	}
+// 	req.Header.Set(portainer.PortainerAgentEdgeIDHeader, "edge-id")
+// 	req.Header.Set(portainer.HTTPResponseAgentPlatform, "1")
+
+// 	rec := httptest.NewRecorder()
+// 	handler.ServeHTTP(rec, req)
+
+// 	if rec.Code != http.StatusOK {
+// 		t.Fatalf(fmt.Sprintf("expected a %d response, found: %d", http.StatusOK, rec.Code))
+// 	}
+
+// 	var data endpointEdgeStatusInspectResponse
+// 	err = json.NewDecoder(rec.Body).Decode(&data)
+// 	if err != nil {
+// 		t.Fatal("error decoding response:", err)
+// 	}
+
+// 	assert.Len(t, data.Schedules, 1)
+// 	assert.Equal(t, edgeJob.ID, data.Schedules[0].ID)
+// 	assert.Equal(t, edgeJob.CronExpression, data.Schedules[0].CronExpression)
+// 	assert.Equal(t, edgeJob.Version, data.Schedules[0].Version)
+// }

api/http/handler/endpoints/endpoint_list_test.go

@@ -1,242 +1,242 @@
 package endpoints
 
-import (
-	"encoding/json"
-	"fmt"
-	"io"
-	"net/http"
-	"net/http/httptest"
-	"testing"
+// import (
+// 	"encoding/json"
+// 	"fmt"
+// 	"io"
+// 	"net/http"
+// 	"net/http/httptest"
+// 	"testing"
 
-	portainer "github.com/portainer/portainer/api"
-	"github.com/portainer/portainer/api/datastore"
-	"github.com/portainer/portainer/api/http/security"
-	"github.com/portainer/portainer/api/internal/snapshot"
-	"github.com/portainer/portainer/api/internal/testhelpers"
-	helper "github.com/portainer/portainer/api/internal/testhelpers"
-	"github.com/stretchr/testify/assert"
-)
+// 	portainer "github.com/portainer/portainer/api"
+// 	"github.com/portainer/portainer/api/datastore"
+// 	"github.com/portainer/portainer/api/http/security"
+// 	"github.com/portainer/portainer/api/internal/snapshot"
+// 	"github.com/portainer/portainer/api/internal/testhelpers"
+// 	helper "github.com/portainer/portainer/api/internal/testhelpers"
+// 	"github.com/stretchr/testify/assert"
+// )
 
-type endpointListTest struct {
-	title    string
-	expected []portainer.EndpointID
-}
+// type endpointListTest struct {
+// 	title    string
+// 	expected []portainer.EndpointID
+// }
 
-func Test_EndpointList_AgentVersion(t *testing.T) {
+// func Test_EndpointList_AgentVersion(t *testing.T) {
 
-	version1Endpoint := portainer.Endpoint{
-		ID:      1,
-		GroupID: 1,
-		Type:    portainer.AgentOnDockerEnvironment,
-		Agent: struct {
-			Version string "example:\"1.0.0\""
-		}{
-			Version: "1.0.0",
-		},
-	}
-	version2Endpoint := portainer.Endpoint{ID: 2, GroupID: 1, Type: portainer.AgentOnDockerEnvironment, Agent: struct {
-		Version string "example:\"1.0.0\""
-	}{Version: "2.0.0"}}
-	noVersionEndpoint := portainer.Endpoint{ID: 3, Type: portainer.AgentOnDockerEnvironment, GroupID: 1}
-	notAgentEnvironments := portainer.Endpoint{ID: 4, Type: portainer.DockerEnvironment, GroupID: 1}
+// 	version1Endpoint := portainer.Endpoint{
+// 		ID:      1,
+// 		GroupID: 1,
+// 		Type:    portainer.AgentOnDockerEnvironment,
+// 		Agent: struct {
+// 			Version string "example:\"1.0.0\""
+// 		}{
+// 			Version: "1.0.0",
+// 		},
+// 	}
+// 	version2Endpoint := portainer.Endpoint{ID: 2, GroupID: 1, Type: portainer.AgentOnDockerEnvironment, Agent: struct {
+// 		Version string "example:\"1.0.0\""
+// 	}{Version: "2.0.0"}}
+// 	noVersionEndpoint := portainer.Endpoint{ID: 3, Type: portainer.AgentOnDockerEnvironment, GroupID: 1}
+// 	notAgentEnvironments := portainer.Endpoint{ID: 4, Type: portainer.DockerEnvironment, GroupID: 1}
 
-	handler, teardown := setup(t, []portainer.Endpoint{
-		notAgentEnvironments,
-		version1Endpoint,
-		version2Endpoint,
-		noVersionEndpoint,
-	})
+// 	handler, teardown := setup(t, []portainer.Endpoint{
+// 		notAgentEnvironments,
+// 		version1Endpoint,
+// 		version2Endpoint,
+// 		noVersionEndpoint,
+// 	})
 
-	defer teardown()
+// 	defer teardown()
 
-	type endpointListAgentVersionTest struct {
-		endpointListTest
-		filter []string
-	}
+// 	type endpointListAgentVersionTest struct {
+// 		endpointListTest
+// 		filter []string
+// 	}
 
-	tests := []endpointListAgentVersionTest{
-		{
-			endpointListTest{
-				"should show version 1 agent endpoints and non-agent endpoints",
-				[]portainer.EndpointID{version1Endpoint.ID, notAgentEnvironments.ID},
-			},
-			[]string{version1Endpoint.Agent.Version},
-		},
-		{
-			endpointListTest{
-				"should show version 2 endpoints and non-agent endpoints",
-				[]portainer.EndpointID{version2Endpoint.ID, notAgentEnvironments.ID},
-			},
-			[]string{version2Endpoint.Agent.Version},
-		},
-		{
-			endpointListTest{
-				"should show version 1 and 2 endpoints and non-agent endpoints",
-				[]portainer.EndpointID{version2Endpoint.ID, notAgentEnvironments.ID, version1Endpoint.ID},
-			},
-			[]string{version2Endpoint.Agent.Version, version1Endpoint.Agent.Version},
-		},
-	}
+// 	tests := []endpointListAgentVersionTest{
+// 		{
+// 			endpointListTest{
+// 				"should show version 1 agent endpoints and non-agent endpoints",
+// 				[]portainer.EndpointID{version1Endpoint.ID, notAgentEnvironments.ID},
+// 			},
+// 			[]string{version1Endpoint.Agent.Version},
+// 		},
+// 		{
+// 			endpointListTest{
+// 				"should show version 2 endpoints and non-agent endpoints",
+// 				[]portainer.EndpointID{version2Endpoint.ID, notAgentEnvironments.ID},
+// 			},
+// 			[]string{version2Endpoint.Agent.Version},
+// 		},
+// 		{
+// 			endpointListTest{
+// 				"should show version 1 and 2 endpoints and non-agent endpoints",
+// 				[]portainer.EndpointID{version2Endpoint.ID, notAgentEnvironments.ID, version1Endpoint.ID},
+// 			},
+// 			[]string{version2Endpoint.Agent.Version, version1Endpoint.Agent.Version},
+// 		},
+// 	}
 
-	for _, test := range tests {
-		t.Run(test.title, func(t *testing.T) {
-			is := assert.New(t)
-			query := ""
-			for _, filter := range test.filter {
-				query += fmt.Sprintf("agentVersions[]=%s&", filter)
-			}
+// 	for _, test := range tests {
+// 		t.Run(test.title, func(t *testing.T) {
+// 			is := assert.New(t)
+// 			query := ""
+// 			for _, filter := range test.filter {
+// 				query += fmt.Sprintf("agentVersions[]=%s&", filter)
+// 			}
 
-			req := buildEndpointListRequest(query)
+// 			req := buildEndpointListRequest(query)
 
-			resp, err := doEndpointListRequest(req, handler, is)
-			is.NoError(err)
+// 			resp, err := doEndpointListRequest(req, handler, is)
+// 			is.NoError(err)
 
-			is.Equal(len(test.expected), len(resp))
+// 			is.Equal(len(test.expected), len(resp))
 
-			respIds := []portainer.EndpointID{}
+// 			respIds := []portainer.EndpointID{}
 
-			for _, endpoint := range resp {
-				respIds = append(respIds, endpoint.ID)
-			}
+// 			for _, endpoint := range resp {
+// 				respIds = append(respIds, endpoint.ID)
+// 			}
 
-			is.ElementsMatch(test.expected, respIds)
-		})
-	}
-}
+// 			is.ElementsMatch(test.expected, respIds)
+// 		})
+// 	}
+// }
 
-func Test_endpointList_edgeDeviceFilter(t *testing.T) {
+// func Test_endpointList_edgeDeviceFilter(t *testing.T) {
 
-	trustedEdgeDevice := portainer.Endpoint{ID: 1, UserTrusted: true, IsEdgeDevice: true, GroupID: 1, Type: portainer.EdgeAgentOnDockerEnvironment}
-	untrustedEdgeDevice := portainer.Endpoint{ID: 2, UserTrusted: false, IsEdgeDevice: true, GroupID: 1, Type: portainer.EdgeAgentOnDockerEnvironment}
-	regularUntrustedEdgeEndpoint := portainer.Endpoint{ID: 3, UserTrusted: false, IsEdgeDevice: false, GroupID: 1, Type: portainer.EdgeAgentOnDockerEnvironment}
-	regularTrustedEdgeEndpoint := portainer.Endpoint{ID: 4, UserTrusted: true, IsEdgeDevice: false, GroupID: 1, Type: portainer.EdgeAgentOnDockerEnvironment}
-	regularEndpoint := portainer.Endpoint{ID: 5, UserTrusted: false, IsEdgeDevice: false, GroupID: 1, Type: portainer.DockerEnvironment}
+// 	trustedEdgeDevice := portainer.Endpoint{ID: 1, UserTrusted: true, IsEdgeDevice: true, GroupID: 1, Type: portainer.EdgeAgentOnDockerEnvironment}
+// 	untrustedEdgeDevice := portainer.Endpoint{ID: 2, UserTrusted: false, IsEdgeDevice: true, GroupID: 1, Type: portainer.EdgeAgentOnDockerEnvironment}
+// 	regularUntrustedEdgeEndpoint := portainer.Endpoint{ID: 3, UserTrusted: false, IsEdgeDevice: false, GroupID: 1, Type: portainer.EdgeAgentOnDockerEnvironment}
+// 	regularTrustedEdgeEndpoint := portainer.Endpoint{ID: 4, UserTrusted: true, IsEdgeDevice: false, GroupID: 1, Type: portainer.EdgeAgentOnDockerEnvironment}
+// 	regularEndpoint := portainer.Endpoint{ID: 5, UserTrusted: false, IsEdgeDevice: false, GroupID: 1, Type: portainer.DockerEnvironment}
 
-	handler, teardown := setup(t, []portainer.Endpoint{
-		trustedEdgeDevice,
-		untrustedEdgeDevice,
-		regularUntrustedEdgeEndpoint,
-		regularTrustedEdgeEndpoint,
-		regularEndpoint,
-	})
+// 	handler, teardown := setup(t, []portainer.Endpoint{
+// 		trustedEdgeDevice,
+// 		untrustedEdgeDevice,
+// 		regularUntrustedEdgeEndpoint,
+// 		regularTrustedEdgeEndpoint,
+// 		regularEndpoint,
+// 	})
 
-	defer teardown()
+// 	defer teardown()
 
-	type endpointListEdgeDeviceTest struct {
-		endpointListTest
-		edgeDevice          *bool
-		edgeDeviceUntrusted bool
-	}
+// 	type endpointListEdgeDeviceTest struct {
+// 		endpointListTest
+// 		edgeDevice          *bool
+// 		edgeDeviceUntrusted bool
+// 	}
 
-	tests := []endpointListEdgeDeviceTest{
-		{
-			endpointListTest: endpointListTest{
-				"should show all endpoints except of the untrusted devices",
-				[]portainer.EndpointID{trustedEdgeDevice.ID, regularUntrustedEdgeEndpoint.ID, regularTrustedEdgeEndpoint.ID, regularEndpoint.ID},
-			},
-			edgeDevice: nil,
-		},
-		{
-			endpointListTest: endpointListTest{
-				"should show only trusted edge devices and regular endpoints",
-				[]portainer.EndpointID{trustedEdgeDevice.ID, regularEndpoint.ID},
-			},
-			edgeDevice: BoolAddr(true),
-		},
-		{
-			endpointListTest: endpointListTest{
-				"should show only untrusted edge devices and regular endpoints",
-				[]portainer.EndpointID{untrustedEdgeDevice.ID, regularEndpoint.ID},
-			},
-			edgeDevice:          BoolAddr(true),
-			edgeDeviceUntrusted: true,
-		},
-		{
-			endpointListTest: endpointListTest{
-				"should show no edge devices",
-				[]portainer.EndpointID{regularEndpoint.ID, regularUntrustedEdgeEndpoint.ID, regularTrustedEdgeEndpoint.ID},
-			},
-			edgeDevice: BoolAddr(false),
-		},
-	}
+// 	tests := []endpointListEdgeDeviceTest{
+// 		{
+// 			endpointListTest: endpointListTest{
+// 				"should show all endpoints except of the untrusted devices",
+// 				[]portainer.EndpointID{trustedEdgeDevice.ID, regularUntrustedEdgeEndpoint.ID, regularTrustedEdgeEndpoint.ID, regularEndpoint.ID},
+// 			},
+// 			edgeDevice: nil,
+// 		},
+// 		{
+// 			endpointListTest: endpointListTest{
+// 				"should show only trusted edge devices and regular endpoints",
+// 				[]portainer.EndpointID{trustedEdgeDevice.ID, regularEndpoint.ID},
+// 			},
+// 			edgeDevice: BoolAddr(true),
+// 		},
+// 		{
+// 			endpointListTest: endpointListTest{
+// 				"should show only untrusted edge devices and regular endpoints",
+// 				[]portainer.EndpointID{untrustedEdgeDevice.ID, regularEndpoint.ID},
+// 			},
+// 			edgeDevice:          BoolAddr(true),
+// 			edgeDeviceUntrusted: true,
+// 		},
+// 		{
+// 			endpointListTest: endpointListTest{
+// 				"should show no edge devices",
+// 				[]portainer.EndpointID{regularEndpoint.ID, regularUntrustedEdgeEndpoint.ID, regularTrustedEdgeEndpoint.ID},
+// 			},
+// 			edgeDevice: BoolAddr(false),
+// 		},
+// 	}
 
-	for _, test := range tests {
-		t.Run(test.title, func(t *testing.T) {
-			is := assert.New(t)
+// 	for _, test := range tests {
+// 		t.Run(test.title, func(t *testing.T) {
+// 			is := assert.New(t)
 
-			query := fmt.Sprintf("edgeDeviceUntrusted=%v&", test.edgeDeviceUntrusted)
-			if test.edgeDevice != nil {
-				query += fmt.Sprintf("edgeDevice=%v&", *test.edgeDevice)
-			}
+// 			query := fmt.Sprintf("edgeDeviceUntrusted=%v&", test.edgeDeviceUntrusted)
+// 			if test.edgeDevice != nil {
+// 				query += fmt.Sprintf("edgeDevice=%v&", *test.edgeDevice)
+// 			}
 
-			req := buildEndpointListRequest(query)
-			resp, err := doEndpointListRequest(req, handler, is)
-			is.NoError(err)
+// 			req := buildEndpointListRequest(query)
+// 			resp, err := doEndpointListRequest(req, handler, is)
+// 			is.NoError(err)
 
-			is.Equal(len(test.expected), len(resp))
+// 			is.Equal(len(test.expected), len(resp))
 
-			respIds := []portainer.EndpointID{}
+// 			respIds := []portainer.EndpointID{}
 
-			for _, endpoint := range resp {
-				respIds = append(respIds, endpoint.ID)
-			}
+// 			for _, endpoint := range resp {
+// 				respIds = append(respIds, endpoint.ID)
+// 			}
 
-			is.ElementsMatch(test.expected, respIds)
-		})
-	}
-}
+// 			is.ElementsMatch(test.expected, respIds)
+// 		})
+// 	}
+// }
 
-func setup(t *testing.T, endpoints []portainer.Endpoint) (handler *Handler, teardown func()) {
-	is := assert.New(t)
-	_, store, teardown := datastore.MustNewTestStore(t, true, true)
+// func setup(t *testing.T, endpoints []portainer.Endpoint) (handler *Handler, teardown func()) {
+// 	is := assert.New(t)
+// 	_, store, teardown := datastore.MustNewTestStore(t, true, true)
 
-	for _, endpoint := range endpoints {
-		err := store.Endpoint().Create(&endpoint)
-		is.NoError(err, "error creating environment")
-	}
+// 	for _, endpoint := range endpoints {
+// 		err := store.Endpoint().Create(&endpoint)
+// 		is.NoError(err, "error creating environment")
+// 	}
 
-	err := store.User().Create(&portainer.User{Username: "admin", Role: portainer.AdministratorRole})
-	is.NoError(err, "error creating a user")
+// 	err := store.User().Create(&portainer.User{Username: "admin", Role: portainer.AdministratorRole})
+// 	is.NoError(err, "error creating a user")
 
-	bouncer := helper.NewTestRequestBouncer()
-	handler = NewHandler(bouncer, nil)
-	handler.DataStore = store
-	handler.ComposeStackManager = testhelpers.NewComposeStackManager()
+// 	bouncer := helper.NewTestRequestBouncer()
+// 	handler = NewHandler(bouncer, nil)
+// 	handler.DataStore = store
+// 	handler.ComposeStackManager = testhelpers.NewComposeStackManager()
 
-	handler.SnapshotService, _ = snapshot.NewService("1s", store, nil, nil, nil)
+// 	handler.SnapshotService, _ = snapshot.NewService("1s", store, nil, nil, nil)
 
-	return handler, teardown
-}
+// 	return handler, teardown
+// }
 
-func buildEndpointListRequest(query string) *http.Request {
-	req := httptest.NewRequest(http.MethodGet, fmt.Sprintf("/endpoints?%s", query), nil)
+// func buildEndpointListRequest(query string) *http.Request {
+// 	req := httptest.NewRequest(http.MethodGet, fmt.Sprintf("/endpoints?%s", query), nil)
 
-	ctx := security.StoreTokenData(req, &portainer.TokenData{ID: 1, Username: "admin", Role: 1})
-	req = req.WithContext(ctx)
+// 	ctx := security.StoreTokenData(req, &portainer.TokenData{ID: 1, Username: "admin", Role: 1})
+// 	req = req.WithContext(ctx)
 
-	restrictedCtx := security.StoreRestrictedRequestContext(req, &security.RestrictedRequestContext{UserID: 1, IsAdmin: true})
-	req = req.WithContext(restrictedCtx)
+// 	restrictedCtx := security.StoreRestrictedRequestContext(req, &security.RestrictedRequestContext{UserID: 1, IsAdmin: true})
+// 	req = req.WithContext(restrictedCtx)
 
-	req.Header.Add("Authorization", "Bearer dummytoken")
+// 	req.Header.Add("Authorization", "Bearer dummytoken")
 
-	return req
-}
+// 	return req
+// }
 
-func doEndpointListRequest(req *http.Request, h *Handler, is *assert.Assertions) ([]portainer.Endpoint, error) {
-	rr := httptest.NewRecorder()
-	h.ServeHTTP(rr, req)
+// func doEndpointListRequest(req *http.Request, h *Handler, is *assert.Assertions) ([]portainer.Endpoint, error) {
+// 	rr := httptest.NewRecorder()
+// 	h.ServeHTTP(rr, req)
 
-	is.Equal(http.StatusOK, rr.Code, "Status should be 200")
-	body, err := io.ReadAll(rr.Body)
-	if err != nil {
-		return nil, err
-	}
+// 	is.Equal(http.StatusOK, rr.Code, "Status should be 200")
+// 	body, err := io.ReadAll(rr.Body)
+// 	if err != nil {
+// 		return nil, err
+// 	}
 
-	resp := []portainer.Endpoint{}
-	err = json.Unmarshal(body, &resp)
-	if err != nil {
-		return nil, err
-	}
+// 	resp := []portainer.Endpoint{}
+// 	err = json.Unmarshal(body, &resp)
+// 	if err != nil {
+// 		return nil, err
+// 	}
 
-	return resp, nil
-}
+// 	return resp, nil
+// }

api/http/handler/endpoints/filter_test.go

@@ -1,177 +1,177 @@
 package endpoints
 
-import (
-	"testing"
+// import (
+// 	"testing"
 
-	portainer "github.com/portainer/portainer/api"
-	"github.com/portainer/portainer/api/datastore"
-	"github.com/portainer/portainer/api/internal/testhelpers"
-	helper "github.com/portainer/portainer/api/internal/testhelpers"
-	"github.com/stretchr/testify/assert"
-)
+// 	portainer "github.com/portainer/portainer/api"
+// 	"github.com/portainer/portainer/api/datastore"
+// 	"github.com/portainer/portainer/api/internal/testhelpers"
+// 	helper "github.com/portainer/portainer/api/internal/testhelpers"
+// 	"github.com/stretchr/testify/assert"
+// )
 
-type filterTest struct {
-	title    string
-	expected []portainer.EndpointID
-	query    EnvironmentsQuery
-}
+// type filterTest struct {
+// 	title    string
+// 	expected []portainer.EndpointID
+// 	query    EnvironmentsQuery
+// }
 
-func Test_Filter_AgentVersion(t *testing.T) {
+// func Test_Filter_AgentVersion(t *testing.T) {
 
-	version1Endpoint := portainer.Endpoint{ID: 1, GroupID: 1,
-		Type: portainer.AgentOnDockerEnvironment,
-		Agent: struct {
-			Version string "example:\"1.0.0\""
-		}{Version: "1.0.0"}}
-	version2Endpoint := portainer.Endpoint{ID: 2, GroupID: 1,
-		Type: portainer.AgentOnDockerEnvironment,
-		Agent: struct {
-			Version string "example:\"1.0.0\""
-		}{Version: "2.0.0"}}
-	noVersionEndpoint := portainer.Endpoint{ID: 3, GroupID: 1,
-		Type: portainer.AgentOnDockerEnvironment,
-	}
-	notAgentEnvironments := portainer.Endpoint{ID: 4, Type: portainer.DockerEnvironment, GroupID: 1}
+// 	version1Endpoint := portainer.Endpoint{ID: 1, GroupID: 1,
+// 		Type: portainer.AgentOnDockerEnvironment,
+// 		Agent: struct {
+// 			Version string "example:\"1.0.0\""
+// 		}{Version: "1.0.0"}}
+// 	version2Endpoint := portainer.Endpoint{ID: 2, GroupID: 1,
+// 		Type: portainer.AgentOnDockerEnvironment,
+// 		Agent: struct {
+// 			Version string "example:\"1.0.0\""
+// 		}{Version: "2.0.0"}}
+// 	noVersionEndpoint := portainer.Endpoint{ID: 3, GroupID: 1,
+// 		Type: portainer.AgentOnDockerEnvironment,
+// 	}
+// 	notAgentEnvironments := portainer.Endpoint{ID: 4, Type: portainer.DockerEnvironment, GroupID: 1}
 
-	endpoints := []portainer.Endpoint{
-		version1Endpoint,
-		version2Endpoint,
-		noVersionEndpoint,
-		notAgentEnvironments,
-	}
+// 	endpoints := []portainer.Endpoint{
+// 		version1Endpoint,
+// 		version2Endpoint,
+// 		noVersionEndpoint,
+// 		notAgentEnvironments,
+// 	}
 
-	handler, teardown := setupFilterTest(t, endpoints)
+// 	handler, teardown := setupFilterTest(t, endpoints)
 
-	defer teardown()
+// 	defer teardown()
 
-	tests := []filterTest{
-		{
-			"should show version 1 endpoints",
-			[]portainer.EndpointID{version1Endpoint.ID},
-			EnvironmentsQuery{
-				agentVersions: []string{version1Endpoint.Agent.Version},
-				types:         []portainer.EndpointType{portainer.AgentOnDockerEnvironment},
-			},
-		},
-		{
-			"should show version 2 endpoints",
-			[]portainer.EndpointID{version2Endpoint.ID},
-			EnvironmentsQuery{
-				agentVersions: []string{version2Endpoint.Agent.Version},
-				types:         []portainer.EndpointType{portainer.AgentOnDockerEnvironment},
-			},
-		},
-		{
-			"should show version 1 and 2 endpoints",
-			[]portainer.EndpointID{version2Endpoint.ID, version1Endpoint.ID},
-			EnvironmentsQuery{
-				agentVersions: []string{version2Endpoint.Agent.Version, version1Endpoint.Agent.Version},
-				types:         []portainer.EndpointType{portainer.AgentOnDockerEnvironment},
-			},
-		},
-	}
+// 	tests := []filterTest{
+// 		{
+// 			"should show version 1 endpoints",
+// 			[]portainer.EndpointID{version1Endpoint.ID},
+// 			EnvironmentsQuery{
+// 				agentVersions: []string{version1Endpoint.Agent.Version},
+// 				types:         []portainer.EndpointType{portainer.AgentOnDockerEnvironment},
+// 			},
+// 		},
+// 		{
+// 			"should show version 2 endpoints",
+// 			[]portainer.EndpointID{version2Endpoint.ID},
+// 			EnvironmentsQuery{
+// 				agentVersions: []string{version2Endpoint.Agent.Version},
+// 				types:         []portainer.EndpointType{portainer.AgentOnDockerEnvironment},
+// 			},
+// 		},
+// 		{
+// 			"should show version 1 and 2 endpoints",
+// 			[]portainer.EndpointID{version2Endpoint.ID, version1Endpoint.ID},
+// 			EnvironmentsQuery{
+// 				agentVersions: []string{version2Endpoint.Agent.Version, version1Endpoint.Agent.Version},
+// 				types:         []portainer.EndpointType{portainer.AgentOnDockerEnvironment},
+// 			},
+// 		},
+// 	}
 
-	runTests(tests, t, handler, endpoints)
-}
+// 	runTests(tests, t, handler, endpoints)
+// }
 
-func Test_Filter_edgeDeviceFilter(t *testing.T) {
+// func Test_Filter_edgeDeviceFilter(t *testing.T) {
 
-	trustedEdgeDevice := portainer.Endpoint{ID: 1, UserTrusted: true, IsEdgeDevice: true, GroupID: 1, Type: portainer.EdgeAgentOnDockerEnvironment}
-	untrustedEdgeDevice := portainer.Endpoint{ID: 2, UserTrusted: false, IsEdgeDevice: true, GroupID: 1, Type: portainer.EdgeAgentOnDockerEnvironment}
-	regularUntrustedEdgeEndpoint := portainer.Endpoint{ID: 3, UserTrusted: false, IsEdgeDevice: false, GroupID: 1, Type: portainer.EdgeAgentOnDockerEnvironment}
-	regularTrustedEdgeEndpoint := portainer.Endpoint{ID: 4, UserTrusted: true, IsEdgeDevice: false, GroupID: 1, Type: portainer.EdgeAgentOnDockerEnvironment}
-	regularEndpoint := portainer.Endpoint{ID: 5, GroupID: 1, Type: portainer.DockerEnvironment}
+// 	trustedEdgeDevice := portainer.Endpoint{ID: 1, UserTrusted: true, IsEdgeDevice: true, GroupID: 1, Type: portainer.EdgeAgentOnDockerEnvironment}
+// 	untrustedEdgeDevice := portainer.Endpoint{ID: 2, UserTrusted: false, IsEdgeDevice: true, GroupID: 1, Type: portainer.EdgeAgentOnDockerEnvironment}
+// 	regularUntrustedEdgeEndpoint := portainer.Endpoint{ID: 3, UserTrusted: false, IsEdgeDevice: false, GroupID: 1, Type: portainer.EdgeAgentOnDockerEnvironment}
+// 	regularTrustedEdgeEndpoint := portainer.Endpoint{ID: 4, UserTrusted: true, IsEdgeDevice: false, GroupID: 1, Type: portainer.EdgeAgentOnDockerEnvironment}
+// 	regularEndpoint := portainer.Endpoint{ID: 5, GroupID: 1, Type: portainer.DockerEnvironment}
 
-	endpoints := []portainer.Endpoint{
-		trustedEdgeDevice,
-		untrustedEdgeDevice,
-		regularUntrustedEdgeEndpoint,
-		regularTrustedEdgeEndpoint,
-		regularEndpoint,
-	}
+// 	endpoints := []portainer.Endpoint{
+// 		trustedEdgeDevice,
+// 		untrustedEdgeDevice,
+// 		regularUntrustedEdgeEndpoint,
+// 		regularTrustedEdgeEndpoint,
+// 		regularEndpoint,
+// 	}
 
-	handler, teardown := setupFilterTest(t, endpoints)
+// 	handler, teardown := setupFilterTest(t, endpoints)
 
-	defer teardown()
+// 	defer teardown()
 
-	tests := []filterTest{
-		{
-			"should show all edge endpoints except of the untrusted devices",
-			[]portainer.EndpointID{trustedEdgeDevice.ID, regularUntrustedEdgeEndpoint.ID, regularTrustedEdgeEndpoint.ID},
-			EnvironmentsQuery{
-				types: []portainer.EndpointType{portainer.EdgeAgentOnDockerEnvironment, portainer.EdgeAgentOnKubernetesEnvironment},
-			},
-		},
-		{
-			"should show only trusted edge devices and other regular endpoints",
-			[]portainer.EndpointID{trustedEdgeDevice.ID, regularEndpoint.ID},
-			EnvironmentsQuery{
-				edgeDevice: BoolAddr(true),
-			},
-		},
-		{
-			"should show only untrusted edge devices and other regular endpoints",
-			[]portainer.EndpointID{untrustedEdgeDevice.ID, regularEndpoint.ID},
-			EnvironmentsQuery{
-				edgeDevice:          BoolAddr(true),
-				edgeDeviceUntrusted: true,
-			},
-		},
-		{
-			"should show no edge devices",
-			[]portainer.EndpointID{regularEndpoint.ID, regularUntrustedEdgeEndpoint.ID, regularTrustedEdgeEndpoint.ID},
-			EnvironmentsQuery{
-				edgeDevice: BoolAddr(false),
-			},
-		},
-	}
+// 	tests := []filterTest{
+// 		{
+// 			"should show all edge endpoints except of the untrusted devices",
+// 			[]portainer.EndpointID{trustedEdgeDevice.ID, regularUntrustedEdgeEndpoint.ID, regularTrustedEdgeEndpoint.ID},
+// 			EnvironmentsQuery{
+// 				types: []portainer.EndpointType{portainer.EdgeAgentOnDockerEnvironment, portainer.EdgeAgentOnKubernetesEnvironment},
+// 			},
+// 		},
+// 		{
+// 			"should show only trusted edge devices and other regular endpoints",
+// 			[]portainer.EndpointID{trustedEdgeDevice.ID, regularEndpoint.ID},
+// 			EnvironmentsQuery{
+// 				edgeDevice: BoolAddr(true),
+// 			},
+// 		},
+// 		{
+// 			"should show only untrusted edge devices and other regular endpoints",
+// 			[]portainer.EndpointID{untrustedEdgeDevice.ID, regularEndpoint.ID},
+// 			EnvironmentsQuery{
+// 				edgeDevice:          BoolAddr(true),
+// 				edgeDeviceUntrusted: true,
+// 			},
+// 		},
+// 		{
+// 			"should show no edge devices",
+// 			[]portainer.EndpointID{regularEndpoint.ID, regularUntrustedEdgeEndpoint.ID, regularTrustedEdgeEndpoint.ID},
+// 			EnvironmentsQuery{
+// 				edgeDevice: BoolAddr(false),
+// 			},
+// 		},
+// 	}
 
-	runTests(tests, t, handler, endpoints)
-}
+// 	runTests(tests, t, handler, endpoints)
+// }
 
-func runTests(tests []filterTest, t *testing.T, handler *Handler, endpoints []portainer.Endpoint) {
-	for _, test := range tests {
-		t.Run(test.title, func(t *testing.T) {
-			runTest(t, test, handler, endpoints)
-		})
-	}
-}
+// func runTests(tests []filterTest, t *testing.T, handler *Handler, endpoints []portainer.Endpoint) {
+// 	for _, test := range tests {
+// 		t.Run(test.title, func(t *testing.T) {
+// 			runTest(t, test, handler, endpoints)
+// 		})
+// 	}
+// }
 
-func runTest(t *testing.T, test filterTest, handler *Handler, endpoints []portainer.Endpoint) {
-	is := assert.New(t)
+// func runTest(t *testing.T, test filterTest, handler *Handler, endpoints []portainer.Endpoint) {
+// 	is := assert.New(t)
 
-	filteredEndpoints, _, err := handler.filterEndpointsByQuery(endpoints, test.query, []portainer.EndpointGroup{}, &portainer.Settings{})
+// 	filteredEndpoints, _, err := handler.filterEndpointsByQuery(endpoints, test.query, []portainer.EndpointGroup{}, &portainer.Settings{})
 
-	is.NoError(err)
+// 	is.NoError(err)
 
-	is.Equal(len(test.expected), len(filteredEndpoints))
+// 	is.Equal(len(test.expected), len(filteredEndpoints))
 
-	respIds := []portainer.EndpointID{}
+// 	respIds := []portainer.EndpointID{}
 
-	for _, endpoint := range filteredEndpoints {
-		respIds = append(respIds, endpoint.ID)
-	}
+// 	for _, endpoint := range filteredEndpoints {
+// 		respIds = append(respIds, endpoint.ID)
+// 	}
 
-	is.ElementsMatch(test.expected, respIds)
+// 	is.ElementsMatch(test.expected, respIds)
 
-}
+// }
 
-func setupFilterTest(t *testing.T, endpoints []portainer.Endpoint) (handler *Handler, teardown func()) {
-	is := assert.New(t)
-	_, store, teardown := datastore.MustNewTestStore(t, true, true)
+// func setupFilterTest(t *testing.T, endpoints []portainer.Endpoint) (handler *Handler, teardown func()) {
+// 	is := assert.New(t)
+// 	_, store, teardown := datastore.MustNewTestStore(t, true, true)
 
-	for _, endpoint := range endpoints {
-		err := store.Endpoint().Create(&endpoint)
-		is.NoError(err, "error creating environment")
-	}
+// 	for _, endpoint := range endpoints {
+// 		err := store.Endpoint().Create(&endpoint)
+// 		is.NoError(err, "error creating environment")
+// 	}
 
-	err := store.User().Create(&portainer.User{Username: "admin", Role: portainer.AdministratorRole})
-	is.NoError(err, "error creating a user")
+// 	err := store.User().Create(&portainer.User{Username: "admin", Role: portainer.AdministratorRole})
+// 	is.NoError(err, "error creating a user")
 
-	bouncer := helper.NewTestRequestBouncer()
-	handler = NewHandler(bouncer, nil)
-	handler.DataStore = store
-	handler.ComposeStackManager = testhelpers.NewComposeStackManager()
+// 	bouncer := helper.NewTestRequestBouncer()
+// 	handler = NewHandler(bouncer, nil)
+// 	handler.DataStore = store
+// 	handler.ComposeStackManager = testhelpers.NewComposeStackManager()
 
-	return handler, teardown
-}
+// 	return handler, teardown
+// }