refactor(cli): modularize current state management code (#493)

Signed-off-by: Miguel Martinez Trivino <[email protected]>

Author: migmartri

app/cli/cmd/attestation_add.go

@@ -17,6 +17,7 @@ package cmd
 
 import (
 	"errors"
+	"fmt"
 
 	"github.com/spf13/cobra"
 	"github.com/spf13/viper"
@@ -37,21 +38,24 @@ func newAttestationAddCmd() *cobra.Command {
 			useWorkflowRobotAccount: "true",
 		},
 		RunE: func(cmd *cobra.Command, args []string) error {
-			a := action.NewAttestationAdd(
+			a, err := action.NewAttestationAdd(
 				&action.AttestationAddOpts{
 					ActionsOpts:        actionOpts,
 					CASURI:             viper.GetString(confOptions.CASAPI.viperKey),
 					ConnectionInsecure: flagInsecure,
 				},
 			)
+			if err != nil {
+				return fmt.Errorf("failed to load action: %w", err)
+			}
 
 			// Extract annotations
 			annotations, err := extractAnnotations(annotationsFlag)
 			if err != nil {
 				return err
 			}
 
-			if err := a.Run(name, value, annotations); err != nil {
+			if err := a.Run("", name, value, annotations); err != nil {
 				if errors.Is(err, action.ErrAttestationNotInitialized) {
 					return err
 				}

app/cli/cmd/attestation_init.go

@@ -26,7 +26,6 @@ import (
 
 func newAttestationInitCmd() *cobra.Command {
 	var (
-		replaceRun        bool
 		contractRevision  int
 		attestationDryRun bool
 	)
@@ -38,16 +37,18 @@ func newAttestationInitCmd() *cobra.Command {
 			useWorkflowRobotAccount: "true",
 		},
 		RunE: func(cmd *cobra.Command, args []string) error {
-			a := action.NewAttestationInit(
+			a, err := action.NewAttestationInit(
 				&action.AttestationInitOpts{
 					ActionsOpts: actionOpts,
-					Override:    replaceRun,
 					DryRun:      attestationDryRun,
 				},
 			)
+			if err != nil {
+				return fmt.Errorf("failed to initialize attestation: %w", err)
+			}
 
 			// Initialize it
-			err := a.Run(contractRevision)
+			err = a.Run(contractRevision)
 			if err != nil {
 				if errors.Is(err, action.ErrAttestationAlreadyExist) {
 					return err
@@ -61,7 +62,12 @@ func newAttestationInitCmd() *cobra.Command {
 			logger.Info().Msg("Attestation initialized! now you can check its status or add materials to it")
 
 			// Show the status information
-			res, err := action.NewAttestationStatus(&action.AttestationStatusOpts{ActionsOpts: actionOpts}).Run()
+			statusAction, err := action.NewAttestationStatus(&action.AttestationStatusOpts{ActionsOpts: actionOpts})
+			if err != nil {
+				return newGracefulError(err)
+			}
+
+			res, err := statusAction.Run("")
 			if err != nil {
 				return newGracefulError(err)
 			}
@@ -70,7 +76,6 @@ func newAttestationInitCmd() *cobra.Command {
 		},
 	}
 
-	cmd.Flags().BoolVarP(&replaceRun, "replace", "f", false, "replace any existing run")
 	cmd.Flags().BoolVar(&attestationDryRun, "dry-run", false, "do not record attestation in the control plane, useful for development")
 	cmd.Flags().IntVar(&contractRevision, "contract-revision", 0, "revision of the contract to retrieve, \"latest\" by default")
 

app/cli/cmd/attestation_push.go

@@ -61,16 +61,19 @@ func newAttestationPushCmd() *cobra.Command {
 			if err != nil {
 				return fmt.Errorf("getting executable information: %w", err)
 			}
-			a := action.NewAttestationPush(&action.AttestationPushOpts{
+			a, err := action.NewAttestationPush(&action.AttestationPushOpts{
 				ActionsOpts: actionOpts, KeyPath: pkPath, CLIVersion: info.Version, CLIDigest: info.Digest,
 			})
+			if err != nil {
+				return fmt.Errorf("failed to load action: %w", err)
+			}
 
 			annotations, err := extractAnnotations(annotationsFlag)
 			if err != nil {
 				return err
 			}
 
-			res, err := a.Run(annotations)
+			res, err := a.Run("", annotations)
 			if err != nil {
 				if errors.Is(err, action.ErrAttestationNotInitialized) {
 					return err

app/cli/cmd/attestation_reset.go

@@ -41,9 +41,12 @@ func newAttestationResetCmd() *cobra.Command {
 			return nil
 		},
 		RunE: func(cmd *cobra.Command, args []string) error {
-			a := action.NewAttestationReset(actionOpts)
+			a, err := action.NewAttestationReset(actionOpts)
+			if err != nil {
+				return fmt.Errorf("failed to load action: %w", err)
+			}
 
-			if err := a.Run(trigger, reason); err != nil {
+			if err := a.Run("", trigger, reason); err != nil {
 				return newGracefulError(err)
 			}
 

app/cli/cmd/attestation_status.go

@@ -34,13 +34,16 @@ func newAttestationStatusCmd() *cobra.Command {
 		Use:   "status",
 		Short: "check the status of the current attestation process",
 		RunE: func(cmd *cobra.Command, args []string) error {
-			a := action.NewAttestationStatus(
+			a, err := action.NewAttestationStatus(
 				&action.AttestationStatusOpts{
 					ActionsOpts: actionOpts,
 				},
 			)
+			if err != nil {
+				return fmt.Errorf("failed to load action: %w", err)
+			}
 
-			res, err := a.Run()
+			res, err := a.Run("")
 			if err != nil {
 				return err
 			}

app/cli/internal/action/action.go

@@ -16,8 +16,13 @@
 package action
 
 import (
+	"fmt"
+	"os"
+	"path/filepath"
 	"time"
 
+	"github.com/chainloop-dev/chainloop/internal/attestation/crafter"
+	"github.com/chainloop-dev/chainloop/internal/attestation/crafter/statemanager/filesystem"
 	"github.com/rs/zerolog"
 	"google.golang.org/grpc"
 )
@@ -30,3 +35,15 @@ type ActionsOpts struct {
 func toTimePtr(t time.Time) *time.Time {
 	return &t
 }
+
+// load a crafter with local state manager
+// TODO: We'll enable the ability to load a crafter that relies on a remote state manager
+func newCrafter(_ *grpc.ClientConn, logger *zerolog.Logger) (*crafter.Crafter, error) {
+	statePath := filepath.Join(os.TempDir(), "chainloop-attestation.tmp.json")
+	localStateManager, err := filesystem.New(statePath)
+	if err != nil {
+		return nil, fmt.Errorf("failed to create local state manager: %w", err)
+	}
+
+	return crafter.NewCrafter(localStateManager, crafter.WithLogger(logger))
+}

app/cli/internal/action/attestation_add.go

@@ -41,25 +41,28 @@ type AttestationAdd struct {
 	connectionInsecure bool
 }
 
-func NewAttestationAdd(cfg *AttestationAddOpts) *AttestationAdd {
+func NewAttestationAdd(cfg *AttestationAddOpts) (*AttestationAdd, error) {
+	c, err := newCrafter(cfg.CPConnection, &cfg.Logger)
+	if err != nil {
+		return nil, fmt.Errorf("failed to load crafter: %w", err)
+	}
+
 	return &AttestationAdd{
-		ActionsOpts: cfg.ActionsOpts,
-		c: crafter.NewCrafter(
-			crafter.WithLogger(&cfg.Logger),
-		),
+		ActionsOpts:        cfg.ActionsOpts,
+		c:                  c,
 		casURI:             cfg.CASURI,
 		connectionInsecure: cfg.ConnectionInsecure,
-	}
+	}, nil
 }
 
 var ErrAttestationNotInitialized = errors.New("attestation not yet initialized")
 
-func (action *AttestationAdd) Run(k, v string, annotations map[string]string) error {
-	if initialized := action.c.AlreadyInitialized(); !initialized {
+func (action *AttestationAdd) Run(attestationID, materialName, materialValue string, annotations map[string]string) error {
+	if initialized := action.c.AlreadyInitialized(attestationID); !initialized {
 		return ErrAttestationNotInitialized
 	}
 
-	if err := action.c.LoadCraftingState(); err != nil {
+	if err := action.c.LoadCraftingState(attestationID); err != nil {
 		action.Logger.Err(err).Msg("loading existing attestation")
 		return err
 	}
@@ -98,7 +101,7 @@ func (action *AttestationAdd) Run(k, v string, annotations map[string]string) er
 		casBackend.Uploader = casclient.New(artifactCASConn, casclient.WithLogger(action.Logger))
 	}
 
-	if err := action.c.AddMaterial(k, v, casBackend, annotations); err != nil {
+	if err := action.c.AddMaterial(attestationID, materialName, materialValue, casBackend, annotations); err != nil {
 		return fmt.Errorf("adding material: %w", err)
 	}
 

app/cli/internal/action/attestation_init.go

@@ -28,13 +28,13 @@ import (
 
 type AttestationInitOpts struct {
 	*ActionsOpts
-	Override, DryRun bool
+	DryRun bool
 }
 
 type AttestationInit struct {
 	*ActionsOpts
-	override, dryRun bool
-	c                *crafter.Crafter
+	dryRun bool
+	c      *crafter.Crafter
 }
 
 // ErrAttestationAlreadyExist means that there is an attestation in progress
@@ -48,20 +48,20 @@ func (e ErrRunnerContextNotFound) Error() string {
 	return fmt.Sprintf("The contract expects the attestation to be crafted in a runner of type %q but couldn't be detected", e.RunnerType)
 }
 
-func NewAttestationInit(cfg *AttestationInitOpts) *AttestationInit {
+func NewAttestationInit(cfg *AttestationInitOpts) (*AttestationInit, error) {
+	c, err := newCrafter(cfg.CPConnection, &cfg.Logger)
+	if err != nil {
+		return nil, fmt.Errorf("failed to load crafter: %w", err)
+	}
+
 	return &AttestationInit{
 		ActionsOpts: cfg.ActionsOpts,
-		override:    cfg.Override,
-		c:           crafter.NewCrafter(crafter.WithLogger(&cfg.Logger)),
+		c:           c,
 		dryRun:      cfg.DryRun,
-	}
+	}, nil
 }
 
 func (action *AttestationInit) Run(contractRevision int) error {
-	if initialized := action.c.AlreadyInitialized(); initialized && !action.override {
-		return ErrAttestationAlreadyExist
-	}
-
 	action.Logger.Debug().Msg("Retrieving attestation definition")
 	client := pb.NewAttestationServiceClient(action.ActionsOpts.CPConnection)
 	// get information of the workflow
@@ -92,6 +92,9 @@ func (action *AttestationInit) Run(contractRevision int) error {
 		return ErrRunnerContextNotFound{runnerContext.String()}
 	}
 
+	// Identifier of this attestation instance
+	var attestationID string
+
 	// Init in the control plane if needed including the runner context
 	if !action.dryRun {
 		runResp, err := client.Init(
@@ -108,27 +111,29 @@ func (action *AttestationInit) Run(contractRevision int) error {
 		workflowRun := runResp.GetResult().GetWorkflowRun()
 		workflowMeta.WorkflowRunId = workflowRun.GetId()
 		action.Logger.Debug().Str("workflow-run-id", workflowRun.GetId()).Msg("attestation initialized in the control plane")
+		attestationID = workflowRun.GetId()
 	}
 
 	// Initialize the local attestation crafter
 	// NOTE: important to run this initialization here since workflowMeta is populated
 	// with the workflowRunId that comes from the control plane
 	initOpts := &crafter.InitOpts{
 		WfInfo: workflowMeta, SchemaV1: contractVersion.GetV1(),
-		DryRun: action.dryRun,
+		DryRun:        action.dryRun,
+		AttestationID: attestationID,
 	}
 
 	if err := action.c.Init(initOpts); err != nil {
 		return err
 	}
 
 	// Load the env variables both the system populated and the user predefined ones
-	if err := action.c.ResolveEnvVars(); err != nil {
+	if err := action.c.ResolveEnvVars(attestationID); err != nil {
 		if action.dryRun {
 			return nil
 		}
 
-		_ = action.c.Reset()
+		_ = action.c.Reset(attestationID)
 		return err
 	}
 

app/cli/internal/action/attestation_push.go

@@ -45,22 +45,27 @@ type AttestationPush struct {
 	keyPath, cliVersion, cliDigest string
 }
 
-func NewAttestationPush(cfg *AttestationPushOpts) *AttestationPush {
+func NewAttestationPush(cfg *AttestationPushOpts) (*AttestationPush, error) {
+	c, err := newCrafter(cfg.CPConnection, &cfg.Logger)
+	if err != nil {
+		return nil, fmt.Errorf("failed to load crafter: %w", err)
+	}
+
 	return &AttestationPush{
 		ActionsOpts: cfg.ActionsOpts,
-		c:           crafter.NewCrafter(crafter.WithLogger(&cfg.Logger)),
+		c:           c,
 		keyPath:     cfg.KeyPath,
 		cliVersion:  cfg.CLIVersion,
 		cliDigest:   cfg.CLIDigest,
-	}
+	}, nil
 }
 
-func (action *AttestationPush) Run(runtimeAnnotations map[string]string) (*AttestationResult, error) {
-	if initialized := action.c.AlreadyInitialized(); !initialized {
+func (action *AttestationPush) Run(attestationID string, runtimeAnnotations map[string]string) (*AttestationResult, error) {
+	if initialized := action.c.AlreadyInitialized(attestationID); !initialized {
 		return nil, ErrAttestationNotInitialized
 	}
 
-	if err := action.c.LoadCraftingState(); err != nil {
+	if err := action.c.LoadCraftingState(attestationID); err != nil {
 		action.Logger.Err(err).Msg("loading existing attestation")
 		return nil, err
 	}
@@ -128,7 +133,7 @@ func (action *AttestationPush) Run(runtimeAnnotations map[string]string) (*Attes
 	if action.c.CraftingState.DryRun {
 		action.Logger.Info().Msg("dry-run completed, push skipped")
 		// We are done, remove the existing att state
-		if err := action.c.Reset(); err != nil {
+		if err := action.c.Reset(attestationID); err != nil {
 			return nil, err
 		}
 
@@ -143,7 +148,7 @@ func (action *AttestationPush) Run(runtimeAnnotations map[string]string) (*Attes
 	action.Logger.Info().Msg("push completed")
 
 	// We are done, remove the existing att state
-	if err := action.c.Reset(); err != nil {
+	if err := action.c.Reset(attestationID); err != nil {
 		return nil, err
 	}