Change return from nil to pointer struct

- Instead of returning nil the functions now return a pointer struct

internal/am/delete_transfer.go

@@ -33,8 +33,8 @@ func (a *DeleteTransferActivity) Execute(ctx context.Context, params *DeleteTran
 
 	err := a.client.Delete(ctx, params.Destination)
 	if err != nil {
-		return nil, fmt.Errorf("delete transfer: path: %q: %v", params.Destination, err)
+		return &DeleteTransferActivityResult{}, fmt.Errorf("delete transfer: path: %q: %v", params.Destination, err)
 	}
 
-	return nil, nil
+	return &DeleteTransferActivityResult{}, nil
 }

internal/storage/activities/copy.go

@@ -20,40 +20,40 @@ func NewCopyToPermanentLocationActivity(storagesvc storage.Service) *CopyToPerma
 func (a *CopyToPermanentLocationActivity) Execute(ctx context.Context, params *storage.CopyToPermanentLocationActivityParams) (*CopyToPermanentLocationActivityResult, error) {
 	p, err := a.storagesvc.ReadPackage(ctx, params.AIPID)
 	if err != nil {
-		return nil, err
+		return &CopyToPermanentLocationActivityResult{}, err
 	}
 
 	reader, err := a.storagesvc.PackageReader(ctx, p)
 	if err != nil {
-		return nil, err
+		return &CopyToPermanentLocationActivityResult{}, err
 	}
 	defer reader.Close()
 
 	l, err := a.storagesvc.Location(ctx, params.LocationID)
 	if err != nil {
-		return nil, err
+		return &CopyToPermanentLocationActivityResult{}, err
 	}
 
 	bucket, err := l.OpenBucket(ctx)
 	if err != nil {
-		return nil, err
+		return &CopyToPermanentLocationActivityResult{}, err
 	}
 	defer bucket.Close()
 
 	writer, err := bucket.NewWriter(ctx, params.AIPID.String(), nil)
 	if err != nil {
-		return nil, err
+		return &CopyToPermanentLocationActivityResult{}, err
 	}
 
 	_, copyErr := io.Copy(writer, reader)
 	closeErr := writer.Close()
 
 	if copyErr != nil {
-		return nil, copyErr
+		return &CopyToPermanentLocationActivityResult{}, copyErr
 	}
 	if closeErr != nil {
-		return nil, closeErr
+		return &CopyToPermanentLocationActivityResult{}, closeErr
 	}
 
-	return nil, nil
+	return &CopyToPermanentLocationActivityResult{}, nil
 }

internal/workflow/activities/bundle.go

@@ -72,7 +72,7 @@ func (a *BundleActivity) Execute(ctx context.Context, params *BundleActivityPara
 	if params.TransferDir == "" {
 		params.TransferDir, err = os.MkdirTemp("", "*-enduro-transfer")
 		if err != nil {
-			return nil, err
+			return &BundleActivityResult{}, err
 		}
 	}
 
@@ -96,24 +96,24 @@ func (a *BundleActivity) Execute(ctx context.Context, params *BundleActivityPara
 		}
 	}
 	if err != nil {
-		return nil, temporal_tools.NewNonRetryableError(err)
+		return &BundleActivityResult{}, temporal_tools.NewNonRetryableError(err)
 	}
 
 	err = unbag(res.FullPath)
 	if err != nil {
-		return nil, temporal_tools.NewNonRetryableError(err)
+		return &BundleActivityResult{}, temporal_tools.NewNonRetryableError(err)
 	}
 
 	res.RelPath, err = filepath.Rel(params.TransferDir, res.FullPath)
 	if err != nil {
-		return nil, temporal_tools.NewNonRetryableError(fmt.Errorf(
+		return &BundleActivityResult{}, temporal_tools.NewNonRetryableError(fmt.Errorf(
 			"error calculating relative path to transfer (base=%q, target=%q): %v",
 			params.TransferDir, res.FullPath, err,
 		))
 	}
 
 	if err = setPermissions(res.FullPath); err != nil {
-		return nil, temporal_tools.NewNonRetryableError(
+		return &BundleActivityResult{}, temporal_tools.NewNonRetryableError(
 			fmt.Errorf("set permissions: %v", err),
 		)
 	}

internal/workflow/activities/cleanup.go

@@ -21,12 +21,12 @@ type CleanUpActivityResult struct{}
 
 func (a *CleanUpActivity) Execute(ctx context.Context, params *CleanUpActivityParams) (*CleanUpActivityResult, error) {
 	if params == nil || params.FullPath == "" {
-		return nil, fmt.Errorf("error processing parameters: missing or empty")
+		return &CleanUpActivityResult{}, fmt.Errorf("error processing parameters: missing or empty")
 	}
 
 	if err := os.RemoveAll(params.FullPath); err != nil {
-		return nil, fmt.Errorf("error removing transfer directory: %v", err)
+		return &CleanUpActivityResult{}, fmt.Errorf("error removing transfer directory: %v", err)
 	}
 
-	return nil, nil
+	return &CleanUpActivityResult{}, nil
 }

internal/workflow/activities/download.go

@@ -42,12 +42,12 @@ func (a *DownloadActivity) Execute(ctx context.Context, params *DownloadActivity
 
 	destDir, err := os.MkdirTemp("", "enduro")
 	if err != nil {
-		return nil, temporal_tools.NewNonRetryableError(fmt.Errorf("make temp dir: %v", err))
+		return &DownloadActivityResult{}, temporal_tools.NewNonRetryableError(fmt.Errorf("make temp dir: %v", err))
 	}
 
 	dest := filepath.Clean(filepath.Join(destDir, params.Key))
 	if err := a.wsvc.Download(ctx, dest, params.WatcherName, params.Key); err != nil {
-		return nil, temporal_tools.NewNonRetryableError(fmt.Errorf("download: %v", err))
+		return &DownloadActivityResult{}, temporal_tools.NewNonRetryableError(fmt.Errorf("download: %v", err))
 	}
 
 	return &DownloadActivityResult{Path: dest}, nil

internal/workflow/activities/storage.go

@@ -37,7 +37,7 @@ func (a *MoveToPermanentStorageActivity) Execute(ctx context.Context, params *Mo
 		LocationID: params.LocationID,
 	})
 
-	return nil, err
+	return &MoveToPermanentStorageActivityResult{}, err
 }
 
 type PollMoveToPermanentStorageActivityParams struct {
@@ -109,7 +109,7 @@ func (a *PollMoveToPermanentStorageActivity) Execute(ctx context.Context, params
 	}
 
 	err := g.Run()
-	return nil, err
+	return &PollMoveToPermanentStorageActivityResult{}, err
 }
 
 type RejectPackageActivityParams struct {
@@ -136,5 +136,5 @@ func (a *RejectPackageActivity) Execute(ctx context.Context, params *RejectPacka
 		AipID: params.AIPID,
 	})
 
-	return nil, err
+	return &RejectPackageActivityResult{}, err
 }

internal/workflow/activities/upload.go

@@ -36,43 +36,43 @@ func (a *UploadActivity) Execute(ctx context.Context, params *UploadActivityPara
 		Name:  params.Name,
 	})
 	if err != nil {
-		return nil, err
+		return &UploadActivityResult{}, err
 	}
 
 	// Upload to MinIO using the upload pre-signed URL.
 	{
 		f, err := os.Open(params.AIPPath)
 		if err != nil {
-			return nil, err
+			return &UploadActivityResult{}, err
 		}
 		defer f.Close() //#nosec G307 -- Errors returned by Close() here do not require specific handling.
 
 		uploadReq, err := http.NewRequestWithContext(ctx, http.MethodPut, res.URL, f)
 		if err != nil {
-			return nil, nil
+			return &UploadActivityResult{}, nil
 		}
 		fi, err := f.Stat()
 		if err != nil {
-			return nil, err
+			return &UploadActivityResult{}, err
 		}
 		uploadReq.ContentLength = fi.Size()
 		if err != nil {
-			return nil, err
+			return &UploadActivityResult{}, err
 		}
 
 		minioClient := &http.Client{}
 		resp, err := minioClient.Do(uploadReq)
 		if err != nil {
-			return nil, err
+			return &UploadActivityResult{}, err
 		}
 		if resp.StatusCode != http.StatusOK {
-			return nil, errors.New("unexpected status code returned")
+			return &UploadActivityResult{}, errors.New("unexpected status code returned")
 		}
 	}
 
 	childCtx, cancel = context.WithTimeout(ctx, time.Second*5)
 	defer cancel()
 	err = a.storageClient.Update(childCtx, &goastorage.UpdatePayload{AipID: params.AIPID})
 
-	return nil, err
+	return &UploadActivityResult{}, err
 }

internal/workflow/activities/zip.go

@@ -40,7 +40,7 @@ func (a *zipActivity) Execute(ctx context.Context, params *ZipActivityParams) (*
 	)
 
 	if params.SourceDir == "" {
-		return nil, fmt.Errorf("%s: missing source dir", ZipActivityName)
+		return &ZipActivityResult{}, fmt.Errorf("%s: missing source dir", ZipActivityName)
 	}
 
 	dest := params.DestPath
@@ -51,7 +51,7 @@ func (a *zipActivity) Execute(ctx context.Context, params *ZipActivityParams) (*
 
 	w, err := os.Create(dest) // #nosec G304 -- trusted path
 	if err != nil {
-		return nil, fmt.Errorf("%s: create: %v", ZipActivityName, err)
+		return &ZipActivityResult{}, fmt.Errorf("%s: create: %v", ZipActivityName, err)
 	}
 	defer w.Close()
 
@@ -91,7 +91,7 @@ func (a *zipActivity) Execute(ctx context.Context, params *ZipActivityParams) (*
 		return nil
 	})
 	if err != nil {
-		return nil, fmt.Errorf("%s: add files: %v", ZipActivityName, err)
+		return &ZipActivityResult{}, fmt.Errorf("%s: add files: %v", ZipActivityName, err)
 	}
 
 	return &ZipActivityResult{Path: dest}, nil

internal/workflow/local_activities.go

@@ -60,28 +60,28 @@ func updatePackageLocalActivity(ctx context.Context, logger logr.Logger, pkgsvc
 	)
 	if err != nil {
 		logger.Error(err, "Error updating package")
-		return nil, err
+		return &updatePackageLocalActivityResult{}, err
 	}
 
-	return nil, nil
+	return &updatePackageLocalActivityResult{}, nil
 }
 
 type setStatusInProgressLocalActivityResult struct{}
 
 func setStatusInProgressLocalActivity(ctx context.Context, pkgsvc package_.Service, pkgID uint, startedAt time.Time) (*setStatusInProgressLocalActivityResult, error) {
-	return nil, pkgsvc.SetStatusInProgress(ctx, pkgID, startedAt)
+	return &setStatusInProgressLocalActivityResult{}, pkgsvc.SetStatusInProgress(ctx, pkgID, startedAt)
 }
 
 type setStatusLocalActivityResult struct{}
 
 func setStatusLocalActivity(ctx context.Context, pkgsvc package_.Service, pkgID uint, status package_.Status) (*setStatusLocalActivityResult, error) {
-	return nil, pkgsvc.SetStatus(ctx, pkgID, status)
+	return &setStatusLocalActivityResult{}, pkgsvc.SetStatus(ctx, pkgID, status)
 }
 
 type setLocationIDLocalActivityResult struct{}
 
 func setLocationIDLocalActivity(ctx context.Context, pkgsvc package_.Service, pkgID uint, locationID uuid.UUID) (*setLocationIDLocalActivityResult, error) {
-	return nil, pkgsvc.SetLocationID(ctx, pkgID, locationID)
+	return &setLocationIDLocalActivityResult{}, pkgsvc.SetLocationID(ctx, pkgID, locationID)
 }
 
 type saveLocationMovePreservationActionLocalActivityParams struct {
@@ -106,7 +106,7 @@ func saveLocationMovePreservationActionLocalActivity(ctx context.Context, pkgsvc
 		PackageID:   params.PackageID,
 	})
 	if err != nil {
-		return nil, err
+		return &saveLocationMovePreservationActionLocalActivityResult{}, err
 	}
 
 	actionStatusToTaskStatus := map[package_.PreservationActionStatus]package_.PreservationTaskStatus{
@@ -126,7 +126,7 @@ func saveLocationMovePreservationActionLocalActivity(ctx context.Context, pkgsvc
 	pt.StartedAt.Time = params.StartedAt
 	pt.CompletedAt.Time = params.CompletedAt
 
-	return nil, pkgsvc.CreatePreservationTask(ctx, &pt)
+	return &saveLocationMovePreservationActionLocalActivityResult{}, pkgsvc.CreatePreservationTask(ctx, &pt)
 }
 
 type createPreservationActionLocalActivityParams struct {
@@ -158,7 +158,7 @@ func createPreservationActionLocalActivity(ctx context.Context, pkgsvc package_.
 type setPreservationActionStatusLocalActivityResult struct{}
 
 func setPreservationActionStatusLocalActivity(ctx context.Context, pkgsvc package_.Service, ID uint, status package_.PreservationActionStatus) (*setPreservationActionStatusLocalActivityResult, error) {
-	return nil, pkgsvc.SetPreservationActionStatus(ctx, ID, status)
+	return &setPreservationActionStatusLocalActivityResult{}, pkgsvc.SetPreservationActionStatus(ctx, ID, status)
 }
 
 type completePreservationActionLocalActivityParams struct {
@@ -170,7 +170,7 @@ type completePreservationActionLocalActivityParams struct {
 type completePreservationActionLocalActivityResult struct{}
 
 func completePreservationActionLocalActivity(ctx context.Context, pkgsvc package_.Service, params *completePreservationActionLocalActivityParams) (*completePreservationActionLocalActivityResult, error) {
-	return nil, pkgsvc.CompletePreservationAction(ctx, params.PreservationActionID, params.Status, params.CompletedAt)
+	return &completePreservationActionLocalActivityResult{}, pkgsvc.CompletePreservationAction(ctx, params.PreservationActionID, params.Status, params.CompletedAt)
 }
 
 type createPreservationTaskLocalActivityParams struct {
@@ -211,5 +211,5 @@ type completePreservationTaskLocalActivityParams struct {
 type completePreservationTaskLocalActivityResult struct{}
 
 func completePreservationTaskLocalActivity(ctx context.Context, pkgsvc package_.Service, params *completePreservationTaskLocalActivityParams) (*completePreservationTaskLocalActivityResult, error) {
-	return nil, pkgsvc.CompletePreservationTask(ctx, params.ID, params.Status, params.CompletedAt, params.Note)
+	return &completePreservationTaskLocalActivityResult{}, pkgsvc.CompletePreservationTask(ctx, params.ID, params.Status, params.CompletedAt, params.Note)
 }

internal/workflow/processing_test.go

@@ -181,7 +181,7 @@ func (s *ProcessingWorkflowTestSuite) TestPackageConfirmation() {
 	s.env.OnActivity(createPreservationTaskLocalActivity, mock.Anything, mock.Anything, mock.Anything).Return(uint(0), nil)
 	s.env.OnActivity(activities.UploadActivityName, mock.Anything, mock.Anything).Return(nil, nil)
 	s.env.OnActivity(setStatusLocalActivity, mock.Anything, mock.Anything, mock.Anything, mock.Anything).Return(nil, nil)
-	s.env.OnActivity(setPreservationActionStatusLocalActivity, mock.Anything, mock.Anything, mock.Anything, mock.Anything).Return(nil,nil)
+	s.env.OnActivity(setPreservationActionStatusLocalActivity, mock.Anything, mock.Anything, mock.Anything, mock.Anything).Return(nil, nil)
 	s.env.OnActivity(completePreservationTaskLocalActivity, mock.Anything, mock.Anything, mock.Anything).Return(nil, nil)
 	s.env.OnActivity(activities.MoveToPermanentStorageActivityName, mock.Anything, mock.Anything).Return(nil, nil)
 	s.env.OnActivity(activities.PollMoveToPermanentStorageActivityName, mock.Anything, mock.Anything).Return(nil, nil)