fix(pendingactions): refactor pending actions [EE-7011] (#11780)

api/pendingactions/pendingactions.go

@@ -1,62 +1,44 @@
 package pendingactions
 
 import (
-	"context"
 	"fmt"
 	"sync"
 
 	portainer "github.com/portainer/portainer/api"
 	"github.com/portainer/portainer/api/dataservices"
-	"github.com/portainer/portainer/api/datastore/postinit"
-	dockerClient "github.com/portainer/portainer/api/docker/client"
-	"github.com/portainer/portainer/api/internal/authorization"
 	"github.com/portainer/portainer/api/internal/endpointutils"
 	kubecli "github.com/portainer/portainer/api/kubernetes/cli"
-	"github.com/portainer/portainer/api/pendingactions/actions"
 	"github.com/rs/zerolog/log"
 )
 
-type (
-	PendingActionsService struct {
-		authorizationService *authorization.Service
-		kubeFactory          *kubecli.ClientFactory
-		dockerFactory        *dockerClient.ClientFactory
-		dataStore            dataservices.DataStore
-		shutdownCtx          context.Context
-		assetsPath           string
-		kubernetesDeployer   portainer.KubernetesDeployer
+type PendingActionsService struct {
+	kubeFactory *kubecli.ClientFactory
+	dataStore   dataservices.DataStore
+	mu          sync.Mutex
+}
 
-		mu sync.Mutex
-	}
-)
+var handlers = make(map[string]portainer.PendingActionHandler)
 
 func NewService(
 	dataStore dataservices.DataStore,
 	kubeFactory *kubecli.ClientFactory,
-	dockerFactory *dockerClient.ClientFactory,
-	authorizationService *authorization.Service,
-	shutdownCtx context.Context,
-	assetsPath string,
-	kubernetesDeployer portainer.KubernetesDeployer,
 ) *PendingActionsService {
 	return &PendingActionsService{
-		dataStore:            dataStore,
-		shutdownCtx:          shutdownCtx,
-		authorizationService: authorizationService,
-		kubeFactory:          kubeFactory,
-		dockerFactory:        dockerFactory,
-		assetsPath:           assetsPath,
-		kubernetesDeployer:   kubernetesDeployer,
-		mu:                   sync.Mutex{},
+		dataStore:   dataStore,
+		kubeFactory: kubeFactory,
+		mu:          sync.Mutex{},
 	}
 }
 
-func (service *PendingActionsService) Create(r portainer.PendingActions) error {
+func (service *PendingActionsService) RegisterHandler(name string, handler portainer.PendingActionHandler) {
+	handlers[name] = handler
+}
+
+func (service *PendingActionsService) Create(r portainer.PendingAction) error {
 	return service.dataStore.PendingActions().Create(&r)
 }
 
 func (service *PendingActionsService) Execute(id portainer.EndpointID) error {
-
 	service.mu.Lock()
 	defer service.mu.Unlock()
 
@@ -108,73 +90,18 @@ func (service *PendingActionsService) Execute(id portainer.EndpointID) error {
 	return nil
 }
 
-func (service *PendingActionsService) executePendingAction(pendingAction portainer.PendingActions, endpoint *portainer.Endpoint) error {
+func (service *PendingActionsService) executePendingAction(pendingAction portainer.PendingAction, endpoint *portainer.Endpoint) error {
 	log.Debug().Msgf("Executing pending action %s for environment %d", pendingAction.Action, pendingAction.EndpointID)
 
 	defer func() {
 		log.Debug().Msgf("End executing pending action %s for environment %d", pendingAction.Action, pendingAction.EndpointID)
 	}()
 
-	switch pendingAction.Action {
-	case actions.CleanNAPWithOverridePolicies:
-		pendingActionData, err := actions.ConvertCleanNAPWithOverridePoliciesPayload(pendingAction.ActionData)
-		if err != nil {
-			return fmt.Errorf("failed to parse pendingActionData for CleanNAPWithOverridePoliciesPayload")
-		}
-
-		if pendingActionData == nil || pendingActionData.EndpointGroupID == 0 {
-			service.authorizationService.CleanNAPWithOverridePolicies(service.dataStore, endpoint, nil)
-			return nil
-		}
-
-		endpointGroupID := pendingActionData.EndpointGroupID
-
-		endpointGroup, err := service.dataStore.EndpointGroup().Read(portainer.EndpointGroupID(endpointGroupID))
-		if err != nil {
-			log.Error().Err(err).Msgf("Error reading environment group to clean NAP with override policies for environment %d and environment group %d", endpoint.ID, endpointGroup.ID)
-			return fmt.Errorf("failed to retrieve environment group %d: %w", endpointGroupID, err)
-		}
-		err = service.authorizationService.CleanNAPWithOverridePolicies(service.dataStore, endpoint, endpointGroup)
-		if err != nil {
-			log.Error().Err(err).Msgf("Error cleaning NAP with override policies for environment %d and environment group %d", endpoint.ID, endpointGroup.ID)
-			return fmt.Errorf("failed to clean NAP with override policies for environment %d and environment group %d: %w", endpoint.ID, endpointGroup.ID, err)
-		}
-
-		return nil
-	case actions.DeletePortainerK8sRegistrySecrets:
-		if pendingAction.ActionData == nil {
-			return nil
-		}
-
-		registryData, err := convertToDeletePortainerK8sRegistrySecretsData(pendingAction.ActionData)
-		if err != nil {
-			return fmt.Errorf("failed to parse pendingActionData: %w", err)
-		}
-
-		err = service.DeleteKubernetesRegistrySecrets(endpoint, registryData)
-		if err != nil {
-			log.Warn().Err(err).Int("endpoint_id", int(endpoint.ID)).Msgf("Unable to delete kubernetes registry secrets")
-			return fmt.Errorf("failed to delete kubernetes registry secrets for environment %d: %w", endpoint.ID, err)
-		}
-
-		return nil
-
-	case actions.PostInitMigrateEnvironment:
-		postInitMigrator := postinit.NewPostInitMigrator(
-			service.kubeFactory,
-			service.dockerFactory,
-			service.dataStore,
-			service.assetsPath,
-			service.kubernetesDeployer,
-		)
-		err := postInitMigrator.MigrateEnvironment(endpoint)
-		if err != nil {
-			log.Error().Err(err).Msgf("Error running post-init migrations for edge environment %d", endpoint.ID)
-			return fmt.Errorf("failed running post-init migrations for edge environment %d: %w", endpoint.ID, err)
-		}
-
+	handler, ok := handlers[pendingAction.Action]
+	if !ok {
+		log.Warn().Msgf("No handler found for pending action %s", pendingAction.Action)
 		return nil
 	}
 
-	return nil
+	return handler.Execute(pendingAction, endpoint)
 }