Node prep execution

Co-authored-by: Vivin Thomas Wilson <vivintwilson@gmail.com>
Co-authored-by: Vivin <vivin@netapp.com>

cli/cmd/install.go

@@ -24,7 +24,7 @@ import (
 	"github.com/netapp/trident/cli/api"
 	k8sclient "github.com/netapp/trident/cli/k8s_client"
 	tridentconfig "github.com/netapp/trident/config"
-	"github.com/netapp/trident/internal/nodeprep/validation"
+	"github.com/netapp/trident/internal/nodeprep/protocol"
 	. "github.com/netapp/trident/logging"
 	"github.com/netapp/trident/utils"
 	"github.com/netapp/trident/utils/crypto"
@@ -425,7 +425,7 @@ func processInstallationArguments(_ *cobra.Command) {
 
 	persistentObjectLabelKey = TridentPersistentObjectLabelKey
 	persistentObjectLabelValue = TridentPersistentObjectLabelValue
-	nodePrep = validation.FormatProtocols(nodePrep)
+	nodePrep = protocol.FormatProtocols(nodePrep)
 }
 
 func validateInstallationArguments() error {
@@ -436,7 +436,7 @@ func validateInstallationArguments() error {
 		return fmt.Errorf("'%s' is not a valid namespace name; %s", TridentPodNamespace, labelFormat)
 	}
 
-	if err := validation.ValidateProtocols(nodePrep); err != nil {
+	if err := protocol.ValidateProtocols(nodePrep); err != nil {
 		return err
 	}
 

cmd/node_prep/main.go

@@ -3,6 +3,7 @@
 package main
 
 import (
+	"context"
 	"flag"
 	"fmt"
 	"os"
@@ -24,7 +25,15 @@ func main() {
 		"binary":     os.Args[0],
 	}).Info("Running Trident node preparation.")
 
-	nodeprep.NewNodePrep().PrepareNode(strings.Split(strings.ToLower(*flags.nodePrep), ","))
+	ctx := context.Background()
+
+	// This is a work-around for osutils because getting system information checks for this environment variable
+	// to decide if this is running inside a container.  osutils should be refactored to not rely on this.
+	if err := os.Setenv("CSI_ENDPOINT", "unix://run/csi/socket"); err != nil {
+		Log().Fatal("Failed to set environment variable.")
+	}
+
+	os.Exit(nodeprep.New().Prepare(ctx, strings.Split(strings.ToLower(*flags.nodePrep), ",")))
 }
 
 func initLogging(flags appFlags) {

internal/nodeprep/execution/executor.go

@@ -0,0 +1,24 @@
+package execution
+
+import (
+	"context"
+
+	"github.com/netapp/trident/internal/nodeprep/instruction"
+	. "github.com/netapp/trident/logging"
+)
+
+func Execute(ctx context.Context, instructions []instruction.Instructions) (err error) {
+	for _, i := range instructions {
+		Log().WithField("instructions", i.GetName()).Info("Preparing node")
+		if err = i.PreCheck(ctx); err != nil {
+			return
+		}
+		if err = i.Apply(ctx); err != nil {
+			return
+		}
+		if err = i.PostCheck(ctx); err != nil {
+			return
+		}
+	}
+	return
+}

internal/nodeprep/execution/executor_test.go

@@ -0,0 +1,126 @@
+// Copyright 2024 NetApp, Inc. All Rights Reserved.
+
+package execution_test
+
+import (
+	"context"
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+	"go.uber.org/mock/gomock"
+
+	"github.com/netapp/trident/internal/nodeprep/execution"
+	"github.com/netapp/trident/internal/nodeprep/instruction"
+	"github.com/netapp/trident/mocks/mock_internal/mock_nodeprep/mock_instruction"
+	"github.com/netapp/trident/utils/errors"
+)
+
+func TestExecute(t *testing.T) {
+	type parameters struct {
+		getInstructions func(controller *gomock.Controller) []instruction.Instructions
+		assertError     assert.ErrorAssertionFunc
+	}
+
+	tests := map[string]parameters{
+		"execute single instruction successfully": {
+			getInstructions: func(controller *gomock.Controller) []instruction.Instructions {
+				mockInstruction := mock_instruction.NewMockInstructions(controller)
+				mockInstruction.EXPECT().GetName().Return("mockInstruction")
+				mockInstruction.EXPECT().PreCheck(gomock.Any()).Return(nil)
+				mockInstruction.EXPECT().Apply(gomock.Any()).Return(nil)
+				mockInstruction.EXPECT().PostCheck(gomock.Any()).Return(nil)
+				return []instruction.Instructions{mockInstruction}
+			},
+			assertError: assert.NoError,
+		},
+		"execute single instruction pre check failure": {
+			getInstructions: func(controller *gomock.Controller) []instruction.Instructions {
+				mockInstruction := mock_instruction.NewMockInstructions(controller)
+				mockInstruction.EXPECT().GetName().Return("mockInstruction")
+				mockInstruction.EXPECT().PreCheck(gomock.Any()).Return(errors.New("mock error"))
+				return []instruction.Instructions{mockInstruction}
+			},
+			assertError: assert.Error,
+		},
+		"execute single instruction apply failure": {
+			getInstructions: func(controller *gomock.Controller) []instruction.Instructions {
+				mockInstruction := mock_instruction.NewMockInstructions(controller)
+				mockInstruction.EXPECT().GetName().Return("mockInstruction")
+				mockInstruction.EXPECT().PreCheck(gomock.Any()).Return(nil)
+				mockInstruction.EXPECT().Apply(gomock.Any()).Return(errors.New("mock error"))
+				return []instruction.Instructions{mockInstruction}
+			},
+			assertError: assert.Error,
+		},
+		"execute single instruction post check failure": {
+			getInstructions: func(controller *gomock.Controller) []instruction.Instructions {
+				mockInstruction := mock_instruction.NewMockInstructions(controller)
+				mockInstruction.EXPECT().GetName().Return("mockInstruction")
+				mockInstruction.EXPECT().PreCheck(gomock.Any()).Return(nil)
+				mockInstruction.EXPECT().Apply(gomock.Any()).Return(nil)
+				mockInstruction.EXPECT().PostCheck(gomock.Any()).Return(errors.New("mock error"))
+				return []instruction.Instructions{mockInstruction}
+			},
+			assertError: assert.Error,
+		},
+		"execute  multi instruction successfully": {
+			getInstructions: func(controller *gomock.Controller) []instruction.Instructions {
+				mockInstruction1 := mock_instruction.NewMockInstructions(controller)
+				mockInstruction1.EXPECT().GetName().Return("mockInstruction")
+				mockInstruction1.EXPECT().PreCheck(gomock.Any()).Return(nil)
+				mockInstruction1.EXPECT().Apply(gomock.Any()).Return(nil)
+				mockInstruction1.EXPECT().PostCheck(gomock.Any()).Return(nil)
+
+				mockInstruction2 := mock_instruction.NewMockInstructions(controller)
+				mockInstruction2.EXPECT().GetName().Return("mockInstruction")
+				mockInstruction2.EXPECT().PreCheck(gomock.Any()).Return(nil)
+				mockInstruction2.EXPECT().Apply(gomock.Any()).Return(nil)
+				mockInstruction2.EXPECT().PostCheck(gomock.Any()).Return(nil)
+
+				return []instruction.Instructions{mockInstruction1, mockInstruction2}
+			},
+			assertError: assert.NoError,
+		},
+		"execute  multi instruction first instruction failure": {
+			getInstructions: func(controller *gomock.Controller) []instruction.Instructions {
+				mockInstruction1 := mock_instruction.NewMockInstructions(controller)
+				mockInstruction1.EXPECT().GetName().Return("mockInstruction")
+				mockInstruction1.EXPECT().PreCheck(gomock.Any()).Return(nil)
+				mockInstruction1.EXPECT().Apply(gomock.Any()).Return(errors.New("mock error"))
+
+				mockInstruction2 := mock_instruction.NewMockInstructions(controller)
+
+				return []instruction.Instructions{mockInstruction1, mockInstruction2}
+			},
+			assertError: assert.Error,
+		},
+		"execute  multi instruction second instruction failure": {
+			getInstructions: func(controller *gomock.Controller) []instruction.Instructions {
+				mockInstruction1 := mock_instruction.NewMockInstructions(controller)
+				mockInstruction1.EXPECT().GetName().Return("mockInstruction")
+				mockInstruction1.EXPECT().PreCheck(gomock.Any()).Return(nil)
+				mockInstruction1.EXPECT().Apply(gomock.Any()).Return(nil)
+				mockInstruction1.EXPECT().PostCheck(gomock.Any()).Return(nil)
+
+				mockInstruction2 := mock_instruction.NewMockInstructions(controller)
+				mockInstruction2.EXPECT().GetName().Return("mockInstruction")
+				mockInstruction2.EXPECT().PreCheck(gomock.Any()).Return(nil)
+				mockInstruction2.EXPECT().Apply(gomock.Any()).Return(errors.New("mock error"))
+
+				return []instruction.Instructions{mockInstruction1, mockInstruction2}
+			},
+			assertError: assert.Error,
+		},
+	}
+
+	for name, params := range tests {
+		t.Run(name, func(t *testing.T) {
+			ctrl := gomock.NewController(t)
+
+			err := execution.Execute(context.TODO(), params.getInstructions(ctrl))
+			if params.assertError != nil {
+				params.assertError(t, err)
+			}
+		})
+	}
+}

internal/nodeprep/instruction/default.go

@@ -0,0 +1,62 @@
+// Copyright 2024 NetApp, Inc. All Rights Reserved.
+
+package instruction
+
+import (
+	"context"
+
+	"github.com/netapp/trident/internal/nodeprep/step"
+	. "github.com/netapp/trident/logging"
+)
+
+const defaultInstructionName = "default instructions"
+
+type Default struct {
+	name  string
+	steps []step.Step
+}
+
+func (r *Default) GetName() string {
+	if r.name == "" {
+		return defaultInstructionName
+	}
+	return r.name
+}
+
+func (r *Default) GetSteps() []step.Step {
+	return r.steps
+}
+
+func (r *Default) PreCheck(_ context.Context) error {
+	return nil
+}
+
+func (r *Default) Apply(ctx context.Context) error {
+	Log().Infof("Applying %s", r.GetName())
+	for _, s := range r.steps {
+		if err := executeStep(ctx, s); err != nil {
+			return err
+		}
+	}
+	return nil
+}
+
+func executeStep(context context.Context, step step.Step) error {
+	Log().WithField("step", step.GetName()).Info("Executing step")
+
+	if err := step.Apply(context); err != nil {
+		if step.IsRequired() {
+			return err
+		}
+		Log().WithError(err).WithField("step", step.GetName()).
+			Info("apply failed but step is not required, continuing")
+	}
+
+	Log().WithField("step", step.GetName()).
+		Info("successfully applied step")
+	return nil
+}
+
+func (r *Default) PostCheck(_ context.Context) error {
+	return nil
+}

internal/nodeprep/instruction/instructions.go

@@ -0,0 +1,63 @@
+// Copyright 2024 NetApp, Inc. All Rights Reserved.
+
+package instruction
+
+//go:generate mockgen -destination=../../../mocks/mock_internal/mock_nodeprep/mock_instruction/mock_instruction.go github.com/netapp/trident/internal/nodeprep/instruction  Instructions
+
+import (
+	"context"
+	"fmt"
+
+	"github.com/netapp/trident/internal/nodeprep/nodeinfo"
+	"github.com/netapp/trident/internal/nodeprep/protocol"
+	"github.com/netapp/trident/internal/nodeprep/step"
+	utilserrors "github.com/netapp/trident/utils/errors"
+)
+
+// Planning for future distros and protocols which may not align easily with each other and need different instructions
+// For example windows might need different instructions for iSCSI than linux or ROSA might be very different from amazon linux
+// And some may not need package managers and some will
+
+type Key struct {
+	Protocol protocol.Protocol
+	Distro   nodeinfo.Distro
+	PkgMgr   nodeinfo.PkgMgr
+}
+
+var instructionMap = map[Key]Instructions{}
+
+func init() {
+	instructionMap[Key{Protocol: protocol.ISCSI, Distro: nodeinfo.DistroAmzn, PkgMgr: nodeinfo.PkgMgrYum}] = newAmznYumISCSI()
+	instructionMap[Key{Protocol: protocol.ISCSI, Distro: nodeinfo.DistroUbuntu, PkgMgr: nodeinfo.PkgMgrApt}] = newDebianAptISCSI()
+}
+
+type Instructions interface {
+	GetName() string
+	PreCheck(ctx context.Context) error
+	Apply(ctx context.Context) error
+	PostCheck(ctx context.Context) error
+	GetSteps() []step.Step
+}
+
+// ScopedInstructions is used to mock out the default instructions for testing,
+// this should not be called anywhere else other than tests
+func ScopedInstructions(instructions map[Key]Instructions) func() {
+	existingInstructions := instructionMap
+	instructionMap = instructions
+	return func() {
+		instructionMap = existingInstructions
+	}
+}
+
+func GetInstructions(nodeInfo *nodeinfo.NodeInfo, protocols []protocol.Protocol) ([]Instructions, error) {
+	instructions := make([]Instructions, 0)
+	for _, p := range protocols {
+		if instruction, ok := instructionMap[Key{Protocol: p, Distro: nodeInfo.Distro, PkgMgr: nodeInfo.PkgMgr}]; ok {
+			instructions = append(instructions, instruction)
+		}
+	}
+	if len(instructions) == 0 {
+		return nil, utilserrors.UnsupportedError(fmt.Sprintf("distribution %s for protocols %s is not supported", nodeInfo.Distro, protocols))
+	}
+	return instructions, nil
+}

internal/nodeprep/instruction/iscsi.go

@@ -0,0 +1,37 @@
+// Copyright 2024 NetApp, Inc. All Rights Reserved.
+
+package instruction
+
+import (
+	"github.com/netapp/trident/internal/nodeprep/packagemanager"
+	"github.com/netapp/trident/internal/nodeprep/packagemanager/apt"
+	"github.com/netapp/trident/internal/nodeprep/packagemanager/yum"
+	"github.com/netapp/trident/internal/nodeprep/step"
+	"github.com/netapp/trident/internal/nodeprep/systemmanager"
+	"github.com/netapp/trident/internal/nodeprep/systemmanager/amzn"
+	"github.com/netapp/trident/internal/nodeprep/systemmanager/debian"
+)
+
+type ISCSI struct {
+	Default
+}
+
+func newDebianAptISCSI() (instruction Instructions) {
+	return newISCSI(apt.New(), debian.New())
+}
+
+func newAmznYumISCSI() (instruction Instructions) {
+	return newISCSI(yum.New(), amzn.New())
+}
+
+func newISCSI(packageManager packagemanager.PackageManager, systemManager systemmanager.SystemManager) (instruction *ISCSI) {
+	instruction = &ISCSI{}
+	instruction.name = "iscsi instructions"
+	// ordering of steps matter here, multipath must be configured before installing iscsi tools to be idempotent
+	instruction.steps = []step.Step{
+		step.NewMultipathConfigureStep(packageManager),
+		step.NewInstallIscsiTools(packageManager),
+		step.NewEnableIscsiServices(systemManager),
+	}
+	return
+}

internal/nodeprep/mpathconfig/configuration.go

@@ -2,7 +2,7 @@
 
 package mpathconfig
 
-//go:generate mockgen -destination=../../../mocks/mock_nodeprep/mock_mpathconfig/mock_config.go  github.com/netapp/trident/internal/nodeprep/mpathconfig MpathConfiguration
+//go:generate mockgen -destination=../../../mocks/mock_internal/mock_nodeprep/mock_mpathconfig/mock_config.go  github.com/netapp/trident/internal/nodeprep/mpathconfig MpathConfiguration
 
 import (
 	"bufio"

internal/nodeprep/mpathconfig/section.go

@@ -2,7 +2,7 @@
 
 package mpathconfig
 
-//go:generate mockgen -destination=../../../mocks/mock_nodeprep/mock_mpathconfig/mock_section.go  github.com/netapp/trident/internal/nodeprep/mpathconfig MpathConfigurationSection
+//go:generate mockgen -destination=../../../mocks/mock_internal/mock_nodeprep/mock_mpathconfig/mock_section.go  github.com/netapp/trident/internal/nodeprep/mpathconfig MpathConfigurationSection
 
 import (
 	"fmt"