Add sequential action

Author: bukka

.mockery.yaml

@@ -88,6 +88,11 @@ packages:
       dir: mocks/generated/run/actions/action/restart
     interfaces:
       Maker: {}
+  github.com/wstool/wst/run/actions/action/sequential:
+    config:
+      dir: mocks/generated/run/actions/action/sequential
+    interfaces:
+      Maker: {}
   github.com/wstool/wst/run/actions/action/start:
     config:
       dir: mocks/generated/run/actions/action/start

TODO.md

@@ -47,8 +47,6 @@ in the future.
 
 #### Structure - Instances, Actions, Servers, Services
 
-- introduce sequential action for more complex scenarios (e.g. seq task in parallel action)
-  - might be worth to consider whether top action should be wrapped to reduce code needed
 - custom server actions for sequential action
   - useful to wrap multiple action - e.g. fpm start + expectations
 - introduce new command action and make it work with output

conf/parser/factory/actions.go

@@ -172,6 +172,11 @@ func (f *NativeActionsFactory) parseAction(
 		restartAction := &types.RestartAction{Service: meta.serviceName}
 		err = f.structParser(data, restartAction, path)
 		action = restartAction
+	case "sequential":
+		serviceNameAllowed = false
+		sequentialAction := &types.SequentialAction{}
+		err = f.structParser(data, sequentialAction, path)
+		action = sequentialAction
 	case "start":
 		startAction := &types.StartAction{Service: meta.serviceName}
 		err = f.structParser(data, startAction, path)

conf/parser/factory/actions_test.go

@@ -589,6 +589,29 @@ func TestNativeActionsFactory_ParseActions(t *testing.T) {
 			},
 			wantErr: false,
 		},
+		{
+			name: "Valid sequential action",
+			actions: []interface{}{
+				map[string]interface{}{
+					"sequential": map[string]interface{}{"actions": []map[string]interface{}{}},
+				},
+			},
+			mockParseCalls: []struct {
+				data map[string]interface{}
+				path string
+				err  error
+			}{
+				{
+					data: map[string]interface{}{"actions": []map[string]interface{}{}},
+					path: staticPath,
+					err:  nil,
+				},
+			},
+			want: []types.Action{
+				&types.SequentialAction{},
+			},
+			wantErr: false,
+		},
 		{
 			name: "Valid start action",
 			actions: []interface{}{

conf/types/action.go

@@ -114,6 +114,12 @@ type ParallelAction struct {
 	When    string   `wst:"when,enum=always|on_success|on_fail,default=on_success"`
 }
 
+type SequentialAction struct {
+	Actions []Action `wst:"actions,factory=createActions"`
+	Timeout int      `wst:"timeout"`
+	When    string   `wst:"when,enum=always|on_success|on_fail,default=on_success"`
+}
+
 type NotAction struct {
 	Action  Action `wst:"action,factory=createAction"`
 	Timeout int    `wst:"timeout"`

mocks/generated/run/actions/action/sequential/mock_Maker.go

@@ -275,21 +275,21 @@ func TestAction_Execute(t *testing.T) {
 			runDataMock := runtimeMocks.NewMockData(t)
 			runMakerMock := runtimeMocks.NewMockMaker(t)
 			runMakerMock.On("MakeContextWithTimeout", baseCtx, timeout).Return(actCtx, cancel)
-			actionMocks := []*actionMocks.MockAction{
+			actMocks := []*actionMocks.MockAction{
 				actionMocks.NewMockAction(t),
 				actionMocks.NewMockAction(t),
 				actionMocks.NewMockAction(t),
 			}
-			for _, actionMock := range actionMocks {
-				actionMock.On("Timeout").Return(timeout).Maybe()
+			for _, act := range actMocks {
+				act.On("Timeout").Return(timeout)
 			}
 
 			mockLogger := external.NewMockLogger()
 			fndMock.On("Logger").Return(mockLogger.SugaredLogger)
 
-			tt.setupMocks(t, fndMock, actionMocks, runDataMock, actCtx)
+			tt.setupMocks(t, fndMock, actMocks, runDataMock, actCtx)
 
-			actions := []action.Action{actionMocks[0], actionMocks[1], actionMocks[2]}
+			actions := []action.Action{actMocks[0], actMocks[1], actMocks[2]}
 
 			a := &Action{
 				fnd:          fndMock,

run/actions/action/parallel/parallel_test.go

@@ -0,0 +1,138 @@
+// Copyright 2024 Jakub Zelenka and The WST Authors
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package sequential
+
+import (
+	"context"
+	"github.com/pkg/errors"
+	"github.com/wstool/wst/app"
+	"github.com/wstool/wst/conf/types"
+	"github.com/wstool/wst/run/actions/action"
+	"github.com/wstool/wst/run/instances/runtime"
+	"github.com/wstool/wst/run/services"
+	"time"
+)
+
+type Maker interface {
+	Make(
+		config *types.SequentialAction,
+		sl services.ServiceLocator,
+		defaultTimeout int,
+		actionMaker action.Maker,
+	) (action.Action, error)
+}
+
+type ActionMaker struct {
+	fnd          app.Foundation
+	runtimeMaker runtime.Maker
+}
+
+func CreateActionMaker(fnd app.Foundation, runtimeMaker runtime.Maker) *ActionMaker {
+	return &ActionMaker{
+		fnd:          fnd,
+		runtimeMaker: runtimeMaker,
+	}
+}
+
+func (m *ActionMaker) Make(
+	config *types.SequentialAction,
+	sl services.ServiceLocator,
+	defaultTimeout int,
+	actionMaker action.Maker,
+) (action.Action, error) {
+	if config.Timeout == 0 {
+		config.Timeout = defaultTimeout
+	}
+
+	var sequentialActions []action.Action
+	for _, configAction := range config.Actions {
+		newAction, err := actionMaker.MakeAction(configAction, sl, config.Timeout)
+		if err != nil {
+			return nil, err
+		}
+		sequentialActions = append(sequentialActions, newAction)
+	}
+	return &Action{
+		fnd:          m.fnd,
+		runtimeMaker: m.runtimeMaker,
+		actions:      sequentialActions,
+		timeout:      time.Duration(config.Timeout * 1e6),
+		when:         action.When(config.When),
+	}, nil
+}
+
+type Action struct {
+	fnd          app.Foundation
+	runtimeMaker runtime.Maker
+	actions      []action.Action
+	timeout      time.Duration
+	when         action.When
+}
+
+func (a *Action) When() action.When {
+	return a.when
+}
+
+func (a *Action) Timeout() time.Duration {
+	return a.timeout
+}
+
+func (a *Action) Execute(ctx context.Context, runData runtime.Data) (bool, error) {
+	logger := a.fnd.Logger()
+	logger.Infof("Executing sequential action")
+
+	failedActionsCount := 0
+	var lastErr error = nil
+	for pos, act := range a.actions {
+		// Execute action with context
+		when := act.When()
+		if when == action.Always ||
+			(failedActionsCount == 0 && when == action.OnSuccess) ||
+			(failedActionsCount > 0 && when == action.OnFailure) {
+			actTimeout := act.Timeout()
+			logger.Debugf("Executing sequential action %d with timeout %s", pos, actTimeout)
+			// Create context for action
+			actCtx, cancel := a.runtimeMaker.MakeContextWithTimeout(ctx, actTimeout)
+			success, err := act.Execute(actCtx, runData)
+			cancel() // Cancel the context immediately after action completion
+
+			if err != nil {
+				lastErr = err
+				logger.Errorf("Sequential action %d failed with error: %v", pos, err)
+			}
+
+			if !success {
+				failedActionsCount++
+				logger.Debugf("Sequential action %d failed", pos)
+			}
+		}
+	}
+
+	if a.fnd.DryRun() {
+		return true, nil
+	}
+
+	result := true
+	if failedActionsCount > 0 {
+		logger.Debugf("Sequential action failed on %d actions", failedActionsCount)
+		result = false
+	}
+
+	if lastErr != nil {
+		return result, errors.Errorf("Sequential action failed with error: %v", lastErr)
+	}
+
+	return result, lastErr
+}