feat(backup): Add backup/restore to the server

api/internal/edge/edgejob.go

@@ -0,0 +1,19 @@
+package edge
+
+import portainer "github.com/portainer/portainer/api"
+
+// LoadEdgeJobs registers all edge jobs inside corresponding endpoint tunnel
+func LoadEdgeJobs(dataStore portainer.DataStore, reverseTunnelService portainer.ReverseTunnelService) error {
+	edgeJobs, err := dataStore.EdgeJob().EdgeJobs()
+	if err != nil {
+		return err
+	}
+
+	for _, edgeJob := range edgeJobs {
+		for endpointID := range edgeJob.Endpoints {
+			reverseTunnelService.AddEdgeJob(endpointID, &edgeJob)
+		}
+	}
+
+	return nil
+}

api/internal/snapshot/snapshot.go

@@ -1,6 +1,7 @@
 package snapshot
 
 import (
+	"context"
 	"log"
 	"time"
 
@@ -16,10 +17,11 @@ type Service struct {
 	snapshotIntervalInSeconds float64
 	dockerSnapshotter         portainer.DockerSnapshotter
 	kubernetesSnapshotter     portainer.KubernetesSnapshotter
+	shutdownCtx               context.Context
 }
 
 // NewService creates a new instance of a service
-func NewService(snapshotInterval string, dataStore portainer.DataStore, dockerSnapshotter portainer.DockerSnapshotter, kubernetesSnapshotter portainer.KubernetesSnapshotter) (*Service, error) {
+func NewService(snapshotInterval string, dataStore portainer.DataStore, dockerSnapshotter portainer.DockerSnapshotter, kubernetesSnapshotter portainer.KubernetesSnapshotter, shutdownCtx context.Context) (*Service, error) {
 	snapshotFrequency, err := time.ParseDuration(snapshotInterval)
 	if err != nil {
 		return nil, err
@@ -30,6 +32,7 @@ func NewService(snapshotInterval string, dataStore portainer.DataStore, dockerSn
 		snapshotIntervalInSeconds: snapshotFrequency.Seconds(),
 		dockerSnapshotter:         dockerSnapshotter,
 		kubernetesSnapshotter:     kubernetesSnapshotter,
+		shutdownCtx:               shutdownCtx,
 	}, nil
 }
 
@@ -43,7 +46,7 @@ func (service *Service) Start() {
 	service.startSnapshotLoop()
 }
 
-func (service *Service) stop() {
+func (service *Service) Stop() {
 	if service.refreshSignal == nil {
 		return
 	}
@@ -55,7 +58,7 @@ func (service *Service) stop() {
 
 // SetSnapshotInterval sets the snapshot interval and resets the service
 func (service *Service) SetSnapshotInterval(snapshotInterval string) error {
-	service.stop()
+	service.Stop()
 
 	snapshotFrequency, err := time.ParseDuration(snapshotInterval)
 	if err != nil {
@@ -132,9 +135,12 @@ func (service *Service) startSnapshotLoop() error {
 				if err != nil {
 					log.Printf("[ERROR] [internal,snapshot] [message: background schedule error (endpoint snapshot).] [error: %s]", err)
 				}
-
+			case <-service.shutdownCtx.Done():
+				log.Println("[DEBUG] [internal,snapshot] [message: shutting down snapshotting]")
+				ticker.Stop()
+				return
 			case <-service.refreshSignal:
-				log.Println("[DEBUG] [internal,snapshot] [message: shutting down Snapshot service]")
+				log.Println("[DEBUG] [internal,snapshot] [message: shutting down snapshotting]")
 				ticker.Stop()
 				return
 			}

api/internal/testhelpers/datastore.go

@@ -0,0 +1,114 @@
+package testhelpers
+
+import (
+	"io"
+
+	portainer "github.com/portainer/portainer/api"
+)
+
+type datastore struct {
+	dockerHub        portainer.DockerHubService
+	customTemplate   portainer.CustomTemplateService
+	edgeGroup        portainer.EdgeGroupService
+	edgeJob          portainer.EdgeJobService
+	edgeStack        portainer.EdgeStackService
+	endpoint         portainer.EndpointService
+	endpointGroup    portainer.EndpointGroupService
+	endpointRelation portainer.EndpointRelationService
+	registry         portainer.RegistryService
+	resourceControl  portainer.ResourceControlService
+	role             portainer.RoleService
+	settings         portainer.SettingsService
+	stack            portainer.StackService
+	tag              portainer.TagService
+	teamMembership   portainer.TeamMembershipService
+	team             portainer.TeamService
+	tunnelServer     portainer.TunnelServerService
+	user             portainer.UserService
+	version          portainer.VersionService
+	webhook          portainer.WebhookService
+}
+
+func (d *datastore) BackupTo(io.Writer) error                            { return nil }
+func (d *datastore) Open() error                                         { return nil }
+func (d *datastore) Init() error                                         { return nil }
+func (d *datastore) Close() error                                        { return nil }
+func (d *datastore) CheckCurrentEdition() error                          { return nil }
+func (d *datastore) IsNew() bool                                         { return false }
+func (d *datastore) MigrateData(force bool) error                        { return nil }
+func (d *datastore) RollbackToCE() error                                 { return nil }
+func (d *datastore) DockerHub() portainer.DockerHubService               { return d.dockerHub }
+func (d *datastore) CustomTemplate() portainer.CustomTemplateService     { return d.customTemplate }
+func (d *datastore) EdgeGroup() portainer.EdgeGroupService               { return d.edgeGroup }
+func (d *datastore) EdgeJob() portainer.EdgeJobService                   { return d.edgeJob }
+func (d *datastore) EdgeStack() portainer.EdgeStackService               { return d.edgeStack }
+func (d *datastore) Endpoint() portainer.EndpointService                 { return d.endpoint }
+func (d *datastore) EndpointGroup() portainer.EndpointGroupService       { return d.endpointGroup }
+func (d *datastore) EndpointRelation() portainer.EndpointRelationService { return d.endpointRelation }
+func (d *datastore) Registry() portainer.RegistryService                 { return d.registry }
+func (d *datastore) ResourceControl() portainer.ResourceControlService   { return d.resourceControl }
+func (d *datastore) Role() portainer.RoleService                         { return d.role }
+func (d *datastore) Settings() portainer.SettingsService                 { return d.settings }
+func (d *datastore) Stack() portainer.StackService                       { return d.stack }
+func (d *datastore) Tag() portainer.TagService                           { return d.tag }
+func (d *datastore) TeamMembership() portainer.TeamMembershipService     { return d.teamMembership }
+func (d *datastore) Team() portainer.TeamService                         { return d.team }
+func (d *datastore) TunnelServer() portainer.TunnelServerService         { return d.tunnelServer }
+func (d *datastore) User() portainer.UserService                         { return d.user }
+func (d *datastore) Version() portainer.VersionService                   { return d.version }
+func (d *datastore) Webhook() portainer.WebhookService                   { return d.webhook }
+
+type datastoreOption = func(d *datastore)
+
+// NewDatastore creates new instance of datastore.
+// Will apply options before returning, opts will be applied from left to right.
+func NewDatastore(options ...datastoreOption) *datastore {
+	d := datastore{}
+	for _, o := range options {
+		o(&d)
+	}
+	return &d
+}
+
+type stubUserService struct {
+	users []portainer.User
+}
+
+func (s *stubUserService) User(ID portainer.UserID) (*portainer.User, error)       { return nil, nil }
+func (s *stubUserService) UserByUsername(username string) (*portainer.User, error) { return nil, nil }
+func (s *stubUserService) Users() ([]portainer.User, error)                        { return s.users, nil }
+func (s *stubUserService) UsersByRole(role portainer.UserRole) ([]portainer.User, error) {
+	return s.users, nil
+}
+func (s *stubUserService) CreateUser(user *portainer.User) error                      { return nil }
+func (s *stubUserService) UpdateUser(ID portainer.UserID, user *portainer.User) error { return nil }
+func (s *stubUserService) DeleteUser(ID portainer.UserID) error                       { return nil }
+
+// WithUsers datastore option that will instruct datastore to return provided users
+func WithUsers(us []portainer.User) datastoreOption {
+	return func(d *datastore) {
+		d.user = &stubUserService{users: us}
+	}
+}
+
+type stubEdgeJobService struct {
+	jobs []portainer.EdgeJob
+}
+
+func (s *stubEdgeJobService) EdgeJobs() ([]portainer.EdgeJob, error) { return s.jobs, nil }
+func (s *stubEdgeJobService) EdgeJob(ID portainer.EdgeJobID) (*portainer.EdgeJob, error) {
+	return nil, nil
+}
+func (s *stubEdgeJobService) CreateEdgeJob(edgeJob *portainer.EdgeJob) error { return nil }
+func (s *stubEdgeJobService) UpdateEdgeJob(ID portainer.EdgeJobID, edgeJob *portainer.EdgeJob) error {
+	return nil
+}
+func (s *stubEdgeJobService) DeleteEdgeJob(ID portainer.EdgeJobID) error { return nil }
+func (s *stubEdgeJobService) GetNextIdentifier() int                     { return 0 }
+
+// WithEdgeJobs option will instruct datastore to return provided jobs
+func WithEdgeJobs(js []portainer.EdgeJob) datastoreOption {
+	return func(d *datastore) {
+		d.edgeJob = &stubEdgeJobService{jobs: js}
+	}
+}

api/internal/testhelpers/reverse_tunnel_service.go

@@ -0,0 +1,23 @@
+package testhelpers
+
+import portainer "github.com/portainer/portainer/api"
+
+type ReverseTunnelService struct{}
+
+func (r ReverseTunnelService) StartTunnelServer(addr, port string, snapshotService portainer.SnapshotService) error {
+	return nil
+}
+func (r ReverseTunnelService) GenerateEdgeKey(url, host string, endpointIdentifier int) string {
+	return "nil"
+}
+func (r ReverseTunnelService) SetTunnelStatusToActive(endpointID portainer.EndpointID) {}
+func (r ReverseTunnelService) SetTunnelStatusToRequired(endpointID portainer.EndpointID) error {
+	return nil
+}
+func (r ReverseTunnelService) SetTunnelStatusToIdle(endpointID portainer.EndpointID) {}
+func (r ReverseTunnelService) GetTunnelDetails(endpointID portainer.EndpointID) *portainer.TunnelDetails {
+	return nil
+}
+func (r ReverseTunnelService) AddEdgeJob(endpointID portainer.EndpointID, edgeJob *portainer.EdgeJob) {
+}
+func (r ReverseTunnelService) RemoveEdgeJob(edgeJobID portainer.EdgeJobID) {}