wip

Signed-off-by: Carolyn Van Slyck <[email protected]>

Author: carolynvs

pkg/cnab/bundleruntime/action.go

@@ -125,11 +125,11 @@ func (r *Runtime) AddRelocation(args ActionArguments) cnabaction.OperationConfig
 	}
 }
 
-func (r *Runtime) Execute(ctx context.Context, args ActionArguments) error {
+func (r *Runtime) Execute(ctx context.Context, args ActionArguments) (storage.Run, storage.Result, error) {
 	// Check if we've been asked to stop before executing long blocking calls
 	select {
 	case <-ctx.Done():
-		return ctx.Err()
+		return storage.Run{}, storage.Result{}, ctx.Err()
 	default:
 		ctx, log := tracing.StartSpan(ctx,
 			attribute.String("action", args.Action),
@@ -140,33 +140,33 @@ func (r *Runtime) Execute(ctx context.Context, args ActionArguments) error {
 		args.Installation.AddToTrace(ctx)
 
 		if args.Action == "" {
-			return log.Error(errors.New("action is required"))
+			return storage.Run{}, storage.Result{}, log.Error(errors.New("action is required"))
 		}
 
 		b, err := r.ProcessBundle(ctx, args.BundleReference.Definition)
 		if err != nil {
-			return log.Error(err)
+			return storage.Run{}, storage.Result{}, log.Error(err)
 		}
 
 		currentRun, err := r.CreateRun(ctx, args, b)
 		if err != nil {
-			return log.Error(err)
+			return storage.Run{}, storage.Result{}, log.Error(err)
 		}
 
 		// Validate the action
 		if _, err := b.GetAction(currentRun.Action); err != nil {
-			return log.Error(fmt.Errorf("invalid action '%s' specified for bundle %s: %w", currentRun.Action, b.Name, err))
+			return storage.Run{}, storage.Result{}, log.Error(fmt.Errorf("invalid action '%s' specified for bundle %s: %w", currentRun.Action, b.Name, err))
 		}
 
 		creds, err := r.loadCredentials(ctx, b, args)
 		if err != nil {
-			return log.Error(fmt.Errorf("not load credentials: %w", err))
+			return storage.Run{}, storage.Result{}, log.Error(fmt.Errorf("not load credentials: %w", err))
 		}
 
 		log.Debugf("Using runtime driver %s\n", args.Driver)
 		driver, err := r.newDriver(args.Driver, args)
 		if err != nil {
-			return log.Error(fmt.Errorf("unable to instantiate driver: %w", err))
+			return storage.Run{}, storage.Result{}, log.Error(fmt.Errorf("unable to instantiate driver: %w", err))
 		}
 
 		a := cnabaction.New(driver)
@@ -175,7 +175,7 @@ func (r *Runtime) Execute(ctx context.Context, args ActionArguments) error {
 		if currentRun.ShouldRecord() {
 			err = r.SaveRun(ctx, args.Installation, currentRun, cnab.StatusRunning)
 			if err != nil {
-				return log.Error(fmt.Errorf("could not save the pending action's status, the bundle was not executed: %w", err))
+				return currentRun, storage.Result{}, log.Error(fmt.Errorf("could not save the pending action's status, the bundle was not executed: %w", err))
 			}
 		}
 
@@ -187,19 +187,20 @@ func (r *Runtime) Execute(ctx context.Context, args ActionArguments) error {
 			tracing.ObjectAttribute("cnab-credentials", cnabCreds))
 		opResult, result, err := a.Run(cnabClaim, cnabCreds, r.ApplyConfig(ctx, args)...)
 
+		currentResult := currentRun.NewResultFrom(result)
 		if currentRun.ShouldRecord() {
 			if err != nil {
 				err = r.appendFailedResult(ctx, err, currentRun)
-				return log.Error(fmt.Errorf("failed to record that %s for installation %s failed: %w", args.Action, args.Installation.Name, err))
+				return currentRun, currentResult, log.Error(fmt.Errorf("failed to record that %s for installation %s failed: %w", args.Action, args.Installation.Name, err))
 			}
-			return r.SaveOperationResult(ctx, opResult, args.Installation, currentRun, currentRun.NewResultFrom(result))
+			return currentRun, currentResult, r.SaveOperationResult(ctx, opResult, args.Installation, currentRun, currentResult)
 		}
 
 		if err != nil {
-			return log.Error(fmt.Errorf("execution of %s for installation %s failed: %w", args.Action, args.Installation.Name, err))
+			return currentRun, currentResult, log.Error(fmt.Errorf("execution of %s for installation %s failed: %w", args.Action, args.Installation.Name, err))
 		}
 
-		return nil
+		return currentRun, currentResult, nil
 	}
 }
 

pkg/cnab/bundleruntime/helpers.go

@@ -69,7 +69,7 @@ func (t *TestRuntime) LoadTestBundle(bundleFile string) cnab.ExtendedBundle {
 	return bun
 }
 
-func (t *TestRuntime) Execute(ctx context.Context, args ActionArguments) error {
+func (t *TestRuntime) Execute(ctx context.Context, args ActionArguments) (storage.Run, storage.Result, error) {
 	if args.Driver == "" {
 		args.Driver = debugDriver
 	}

pkg/cnab/bundleruntime/provider.go

@@ -3,11 +3,13 @@ package bundleruntime
 import (
 	"context"
 
+	"get.porter.sh/porter/pkg/storage"
+
 	"get.porter.sh/porter/pkg/cnab"
 )
 
 // CNABProvider is the interface Porter uses to communicate with the CNAB runtime
 type CNABProvider interface {
 	LoadBundle(bundleFile string) (cnab.ExtendedBundle, error)
-	Execute(ctx context.Context, arguments ActionArguments) error
+	Execute(ctx context.Context, arguments ActionArguments) (storage.Run, storage.Result, error)
 }

pkg/porter/action.go

@@ -95,17 +95,18 @@ func (p *Porter) ExecuteBundleAndDependencies(ctx context.Context, installation
 			return err
 		}
 
-		return p.CNAB.Execute(ctx, actionArgs)
+		_, _, err = p.CNAB.Execute(ctx, actionArgs)
+		return err
 	}
 }
 
 // ExecuteRootBundleOnly runs a single bundle that has already had its dependencies resolved by a workflow.
 // The workflow is responsible identifying the bundles to run, their order, what to pass between them, etc.
 // It is only intended to be used with the deps-v2 feature.
-func (p *Porter) ExecuteRootBundleOnly(ctx context.Context, installation storage.Installation, action BundleAction) error {
+func (p *Porter) ExecuteRootBundleOnly(ctx context.Context, installation storage.Installation, action BundleAction) (storage.Run, storage.Result, error) {
 	// Callers should check for a noop action (because the installation is up-to-date, but let's check too just in case
 	if action == nil {
-		return nil
+		return storage.Run{}, storage.Result{}, nil
 	}
 
 	opts := action.GetOptions()
@@ -118,7 +119,7 @@ func (p *Porter) ExecuteRootBundleOnly(ctx context.Context, installation storage
 
 	actionArgs, err := p.BuildActionArgs(ctx, installation, action)
 	if err != nil {
-		return err
+		return storage.Run{}, storage.Result{}, err
 	}
 
 	return p.CNAB.Execute(ctx, actionArgs)

pkg/porter/dependencies.go

@@ -310,7 +310,7 @@ func (e *dependencyExecutioner) executeDependency(ctx context.Context, dep *queu
 
 	var executeErrs error
 	span.Infof("Executing dependency %s...", dep.Alias)
-	err = e.CNAB.Execute(ctx, depArgs)
+	_, _, err = e.CNAB.Execute(ctx, depArgs)
 	if err != nil {
 		executeErrs = multierror.Append(executeErrs, fmt.Errorf("error executing dependency %s: %w", dep.Alias, err))
 

pkg/porter/reconcile.go

@@ -59,18 +59,18 @@ func (p *Porter) ReconcileInstallationAndDependencies(ctx context.Context, opts
 // This is only used for install/upgrade actions triggered by applying a file
 // to an installation. For uninstall or invoke, you should call those directly.
 // This should only be used with deps-v2 feature workflows.
-func (p *Porter) ReconcileInstallationInWorkflow(ctx context.Context, opts ReconcileOptions) error {
+func (p *Porter) ReconcileInstallationInWorkflow(ctx context.Context, opts ReconcileOptions) (storage.Run, storage.Result, error) {
 	ctx, span := tracing.StartSpan(ctx)
 	defer span.EndSpan()
 
 	installation, actionOpts, err := p.reconcileInstallation(ctx, opts)
 	if err != nil {
-		return err
+		return storage.Run{}, storage.Result{}, err
 	}
 
 	// Nothing to do, the installation is up-to-date
 	if actionOpts == nil {
-		return nil
+		return storage.Run{}, storage.Result{}, nil
 	}
 
 	return p.ExecuteRootBundleOnly(ctx, installation, actionOpts)

pkg/porter/uninstall.go

@@ -132,7 +132,7 @@ func (p *Porter) UninstallBundle(ctx context.Context, opts UninstallOptions) err
 	}
 
 	log.Infof("%s bundle", opts.GetActionVerb())
-	err = p.CNAB.Execute(ctx, actionArgs)
+	_, _, err = p.CNAB.Execute(ctx, actionArgs)
 
 	var uninstallErrs error
 	if err != nil {

pkg/porter/workflow_engine.go

@@ -328,11 +328,11 @@ func (t Engine) executeJob(ctx context.Context, j *storage.Job, jobs chan *stora
 	opts := ReconcileOptions{
 		Installation: j.Installation,
 	}
-	err := t.p.ReconcileInstallationInWorkflow(ctx, opts)
+	run, result, err := t.p.ReconcileInstallationInWorkflow(ctx, opts)
+	j.Status.LastRunID = run.ID
+	j.Status.LastResultID = result.ID
+	j.Status.ResultIDs = append(j.Status.ResultIDs, result.ID)
 	if err != nil {
-		// TODO(PEP003): Let's consider the relationship between jobs, runs and results.
-		// How much should we duplicate on job?
-		// How do we want to link the job to the run (e.g. should job status include runid or something?)
 		j.Status.Status = cnab.StatusFailed
 		j.Status.Message = err.Error()
 	} else {

pkg/storage/workflow.go

@@ -100,8 +100,11 @@ func (j *Job) Prepare(workflowId string, jobKey string) {
 }
 
 type JobStatus struct {
-	Status  string `json:"status"`
-	Message string `json:"message"`
+	LastRunID    string   `json:lastRunID`
+	LastResultID string   `json:lastResultID`
+	ResultIDs    []string `json:resultIDs`
+	Status       string   `json:"status"`
+	Message      string   `json:"message"`
 }
 
 func (s JobStatus) IsSucceeded() bool {