export results per family scan

cli/cmd/root.go

@@ -111,22 +111,15 @@ var rootCmd = &cobra.Command{
 		}
 
 		logger.Infof("Running scanners...")
-		res, familiesErr := families.New(logger, config).Run(abortCtx)
+		runErrors := families.New(logger, config).Run(abortCtx, cli)
 
-		logger.Infof("Exporting results...")
-		errs := cli.ExportResults(abortCtx, res, familiesErr)
-
-		if len(familiesErr) > 0 {
-			errs = append(errs, fmt.Errorf("at least one family failed to run"))
-		}
-
-		err = cli.MarkDone(ctx, errs)
+		err = cli.MarkDone(ctx, runErrors)
 		if err != nil {
 			return fmt.Errorf("failed to inform the server %v the scan was completed: %w", server, err)
 		}
 
-		if len(familiesErr) > 0 {
-			return fmt.Errorf("failed to run families: %+v", familiesErr)
+		if len(runErrors) > 0 {
+			logger.Errorf("Errors when running families: %+v", runErrors)
 		}
 
 		return nil

cli/pkg/cli/cli.go

@@ -28,7 +28,7 @@ import (
 	"github.com/openclarity/vmclarity/cli/pkg/presenter"
 	"github.com/openclarity/vmclarity/cli/pkg/state"
 	"github.com/openclarity/vmclarity/shared/pkg/families"
-	"github.com/openclarity/vmclarity/shared/pkg/families/results"
+	"github.com/openclarity/vmclarity/shared/pkg/families/types"
 )
 
 const (
@@ -43,6 +43,14 @@ type CLI struct {
 	FamiliesConfig *families.Config
 }
 
+func (c *CLI) FamilyStarted(ctx context.Context, famType types.FamilyType) error {
+	return c.Manager.MarkFamilyScanInProgress(ctx, famType)
+}
+
+func (c *CLI) FamilyFinished(ctx context.Context, res families.FamilyResult) error {
+	return c.Presenter.ExportFamilyResult(ctx, res)
+}
+
 func (c *CLI) MountVolumes(ctx context.Context) ([]string, error) {
 	var mountPoints []string
 
@@ -69,65 +77,6 @@ func (c *CLI) MountVolumes(ctx context.Context) ([]string, error) {
 	return mountPoints, nil
 }
 
-//nolint:cyclop
-func (c *CLI) ExportResults(ctx context.Context, res *results.Results, errs families.RunErrors) []error {
-	familiesSet := []struct {
-		enabled  bool
-		name     string
-		exporter func(context.Context, *results.Results, families.RunErrors) error
-	}{
-		{
-			c.FamiliesConfig.SBOM.Enabled,
-			"sbom",
-			c.ExportSbomResult,
-		},
-		{
-			c.FamiliesConfig.Vulnerabilities.Enabled,
-			"vulnerabilities",
-			c.ExportVulResult,
-		},
-		{
-			c.FamiliesConfig.Secrets.Enabled,
-			"secrets",
-			c.ExportSecretsResult,
-		},
-		{
-			c.FamiliesConfig.Exploits.Enabled,
-			"exploits",
-			c.ExportExploitsResult,
-		},
-		{
-			c.FamiliesConfig.Malware.Enabled,
-			"malware",
-			c.ExportMalwareResult,
-		},
-		{
-			c.FamiliesConfig.Misconfiguration.Enabled,
-			"misconfiguration",
-			c.ExportMisconfigurationResult,
-		},
-		{
-			c.FamiliesConfig.Rootkits.Enabled,
-			"rootkits",
-			c.ExportRootkitResult,
-		},
-	}
-
-	result := make([]error, 0, len(familiesSet))
-	for _, f := range familiesSet {
-		if !f.enabled {
-			continue
-		}
-		if err := f.exporter(ctx, res, errs); err != nil {
-			err = fmt.Errorf("failed to export %s result to server: %w", f.name, err)
-			log.Error(err)
-			result = append(result, err)
-		}
-	}
-
-	return result
-}
-
 func (c *CLI) WatchForAbort(ctx context.Context, cancel context.CancelFunc, interval time.Duration) {
 	go func() {
 		timer := time.NewTicker(interval)

cli/pkg/presenter/default.go

@@ -23,10 +23,10 @@ import (
 	"github.com/openclarity/vmclarity/shared/pkg/families"
 	"github.com/openclarity/vmclarity/shared/pkg/families/exploits"
 	"github.com/openclarity/vmclarity/shared/pkg/families/malware"
-	"github.com/openclarity/vmclarity/shared/pkg/families/results"
 	"github.com/openclarity/vmclarity/shared/pkg/families/rootkits"
 	"github.com/openclarity/vmclarity/shared/pkg/families/sbom"
 	"github.com/openclarity/vmclarity/shared/pkg/families/secrets"
+	"github.com/openclarity/vmclarity/shared/pkg/families/types"
 	"github.com/openclarity/vmclarity/shared/pkg/families/vulnerabilities"
 )
 
@@ -36,10 +36,33 @@ type DefaultPresenter struct {
 	FamiliesConfig *families.Config
 }
 
-func (p *DefaultPresenter) ExportSbomResult(_ context.Context, res *results.Results, _ families.RunErrors) error {
-	sbomResults, err := results.GetResult[*sbom.Results](res)
-	if err != nil {
-		return fmt.Errorf("failed to get sbom results: %w", err)
+func (p *DefaultPresenter) ExportFamilyResult(ctx context.Context, res families.FamilyResult) error {
+	var err error
+
+	switch res.FamilyType {
+	case types.SBOM:
+		err = p.ExportSbomResult(ctx, res)
+	case types.Vulnerabilities:
+		err = p.ExportVulResult(ctx, res)
+	case types.Secrets:
+		err = p.ExportSecretsResult(ctx, res)
+	case types.Exploits:
+		err = p.ExportExploitsResult(ctx, res)
+	case types.Misconfiguration:
+		err = p.ExportMisconfigurationResult(ctx, res)
+	case types.Rootkits:
+		err = p.ExportRootkitResult(ctx, res)
+	case types.Malware:
+		err = p.ExportMalwareResult(ctx, res)
+	}
+
+	return err
+}
+
+func (p *DefaultPresenter) ExportSbomResult(_ context.Context, res families.FamilyResult) error {
+	sbomResults, ok := res.Result.(*sbom.Results)
+	if !ok {
+		return fmt.Errorf("failed to convert to sbom results")
 	}
 
 	outputFormat := p.FamiliesConfig.SBOM.AnalyzersConfig.Analyzer.OutputFormat
@@ -55,10 +78,10 @@ func (p *DefaultPresenter) ExportSbomResult(_ context.Context, res *results.Resu
 	return nil
 }
 
-func (p *DefaultPresenter) ExportVulResult(_ context.Context, res *results.Results, _ families.RunErrors) error {
-	vulnerabilitiesResults, err := results.GetResult[*vulnerabilities.Results](res)
-	if err != nil {
-		return fmt.Errorf("failed to get sbom results: %w", err)
+func (p *DefaultPresenter) ExportVulResult(_ context.Context, res families.FamilyResult) error {
+	vulnerabilitiesResults, ok := res.Result.(*vulnerabilities.Results)
+	if !ok {
+		return fmt.Errorf("failed to convert to vulnerabilities results")
 	}
 
 	bytes, err := json.Marshal(vulnerabilitiesResults.MergedResults)
@@ -72,10 +95,10 @@ func (p *DefaultPresenter) ExportVulResult(_ context.Context, res *results.Resul
 	return nil
 }
 
-func (p *DefaultPresenter) ExportSecretsResult(_ context.Context, res *results.Results, _ families.RunErrors) error {
-	secretsResults, err := results.GetResult[*secrets.Results](res)
-	if err != nil {
-		return fmt.Errorf("failed to get secrets results: %w", err)
+func (p *DefaultPresenter) ExportSecretsResult(_ context.Context, res families.FamilyResult) error {
+	secretsResults, ok := res.Result.(*secrets.Results)
+	if !ok {
+		return fmt.Errorf("failed to convert to secrets results")
 	}
 
 	bytes, err := json.Marshal(secretsResults)
@@ -89,10 +112,10 @@ func (p *DefaultPresenter) ExportSecretsResult(_ context.Context, res *results.R
 	return nil
 }
 
-func (p *DefaultPresenter) ExportMalwareResult(_ context.Context, res *results.Results, _ families.RunErrors) error {
-	malwareResults, err := results.GetResult[*malware.MergedResults](res)
-	if err != nil {
-		return fmt.Errorf("failed to get malware results: %w", err)
+func (p *DefaultPresenter) ExportMalwareResult(_ context.Context, res families.FamilyResult) error {
+	malwareResults, ok := res.Result.(*malware.MergedResults)
+	if !ok {
+		return fmt.Errorf("failed to convert to malware results")
 	}
 
 	bytes, err := json.Marshal(malwareResults)
@@ -106,10 +129,10 @@ func (p *DefaultPresenter) ExportMalwareResult(_ context.Context, res *results.R
 	return nil
 }
 
-func (p *DefaultPresenter) ExportExploitsResult(_ context.Context, res *results.Results, _ families.RunErrors) error {
-	exploitsResults, err := results.GetResult[*exploits.Results](res)
-	if err != nil {
-		return fmt.Errorf("failed to get exploits results: %w", err)
+func (p *DefaultPresenter) ExportExploitsResult(_ context.Context, res families.FamilyResult) error {
+	exploitsResults, ok := res.Result.(*exploits.Results)
+	if !ok {
+		return fmt.Errorf("failed to convert to exploits results")
 	}
 
 	bytes, err := json.Marshal(exploitsResults)
@@ -123,15 +146,15 @@ func (p *DefaultPresenter) ExportExploitsResult(_ context.Context, res *results.
 	return nil
 }
 
-func (p *DefaultPresenter) ExportMisconfigurationResult(context.Context, *results.Results, families.RunErrors) error {
+func (p *DefaultPresenter) ExportMisconfigurationResult(context.Context, families.FamilyResult) error {
 	// TODO: implement
 	return nil
 }
 
-func (p *DefaultPresenter) ExportRootkitResult(_ context.Context, res *results.Results, _ families.RunErrors) error {
-	rootkitsResults, err := results.GetResult[*rootkits.Results](res)
-	if err != nil {
-		return fmt.Errorf("failed to get rootkits results: %w", err)
+func (p *DefaultPresenter) ExportRootkitResult(_ context.Context, res families.FamilyResult) error {
+	rootkitsResults, ok := res.Result.(*rootkits.Results)
+	if !ok {
+		return fmt.Errorf("failed to convert to rootkits results")
 	}
 
 	bytes, err := json.Marshal(rootkitsResults)

cli/pkg/presenter/multi.go

@@ -20,76 +20,15 @@ import (
 	"fmt"
 
 	"github.com/openclarity/vmclarity/shared/pkg/families"
-	"github.com/openclarity/vmclarity/shared/pkg/families/results"
 )
 
 type MultiPresenter struct {
 	Presenters []Presenter
 }
 
-func (m *MultiPresenter) ExportSbomResult(ctx context.Context, res *results.Results, famErr families.RunErrors) error {
+func (m *MultiPresenter) ExportFamilyResult(ctx context.Context, res families.FamilyResult) error {
 	for _, p := range m.Presenters {
-		if err := p.ExportSbomResult(ctx, res, famErr); err != nil {
-			return fmt.Errorf("failed to export result: %w", err)
-		}
-	}
-
-	return nil
-}
-
-func (m *MultiPresenter) ExportVulResult(ctx context.Context, res *results.Results, famErr families.RunErrors) error {
-	for _, p := range m.Presenters {
-		if err := p.ExportVulResult(ctx, res, famErr); err != nil {
-			return fmt.Errorf("failed to export result: %w", err)
-		}
-	}
-
-	return nil
-}
-
-func (m *MultiPresenter) ExportSecretsResult(ctx context.Context, res *results.Results, famErr families.RunErrors) error {
-	for _, p := range m.Presenters {
-		if err := p.ExportSecretsResult(ctx, res, famErr); err != nil {
-			return fmt.Errorf("failed to export result: %w", err)
-		}
-	}
-
-	return nil
-}
-
-func (m *MultiPresenter) ExportMalwareResult(ctx context.Context, res *results.Results, famErr families.RunErrors) error {
-	for _, p := range m.Presenters {
-		if err := p.ExportMalwareResult(ctx, res, famErr); err != nil {
-			return fmt.Errorf("failed to export result: %w", err)
-		}
-	}
-
-	return nil
-}
-
-func (m *MultiPresenter) ExportExploitsResult(ctx context.Context, res *results.Results, famErr families.RunErrors) error {
-	for _, p := range m.Presenters {
-		if err := p.ExportExploitsResult(ctx, res, famErr); err != nil {
-			return fmt.Errorf("failed to export result: %w", err)
-		}
-	}
-
-	return nil
-}
-
-func (m *MultiPresenter) ExportMisconfigurationResult(ctx context.Context, res *results.Results, famErr families.RunErrors) error {
-	for _, p := range m.Presenters {
-		if err := p.ExportMisconfigurationResult(ctx, res, famErr); err != nil {
-			return fmt.Errorf("failed to export result: %w", err)
-		}
-	}
-
-	return nil
-}
-
-func (m *MultiPresenter) ExportRootkitResult(ctx context.Context, res *results.Results, famErr families.RunErrors) error {
-	for _, p := range m.Presenters {
-		if err := p.ExportRootkitResult(ctx, res, famErr); err != nil {
+		if err := p.ExportFamilyResult(ctx, res); err != nil {
 			return fmt.Errorf("failed to export result: %w", err)
 		}
 	}

cli/pkg/presenter/presenter.go

@@ -19,15 +19,8 @@ import (
 	"context"
 
 	"github.com/openclarity/vmclarity/shared/pkg/families"
-	"github.com/openclarity/vmclarity/shared/pkg/families/results"
 )
 
 type Presenter interface {
-	ExportSbomResult(context.Context, *results.Results, families.RunErrors) error
-	ExportVulResult(context.Context, *results.Results, families.RunErrors) error
-	ExportSecretsResult(context.Context, *results.Results, families.RunErrors) error
-	ExportMalwareResult(context.Context, *results.Results, families.RunErrors) error
-	ExportExploitsResult(context.Context, *results.Results, families.RunErrors) error
-	ExportMisconfigurationResult(context.Context, *results.Results, families.RunErrors) error
-	ExportRootkitResult(context.Context, *results.Results, families.RunErrors) error
+	ExportFamilyResult(ctx context.Context, res families.FamilyResult) error
 }