func()

in internal/vulnerability/worker.go [82:158]

• 73 lines of code
• 5 McCabe index (conditional complexity)

func (f *VulnerabilityWorker) Run(ctx context.Context) {
	f.log.Info("Starting VulnerabilityWorker.work")
	defer func() {
		if err := f.runner.Close(ctx); err != nil {
			f.log.Warnf("error during runner closing %s", err.Error())
		}
	}()

	if ctx.Err() != nil {
		f.log.Info("VulnerabilityWorker.work context canceled")
		return
	}

	defer f.manager.Cleanup(ctx)

	jobs := []struct {
		name string
		fn   func(ctx context.Context) error
	}{
		{
			name: "DeleteOldSnapshots",
			fn: func(ctx context.Context) error {
				f.manager.DeleteOldSnapshots(ctx)
				return nil
			},
		},
		{
			name: "FetchInstances",
			fn:   f.fetcher.FetchInstances,
		},
		{
			name: "SnapshotInstance",
			fn: func(ctx context.Context) error {
				f.replicator.SnapshotInstance(ctx, f.fetcher.GetChan())
				return nil
			},
		},
		{
			name: "VerifySnapshot",
			fn: func(ctx context.Context) error {
				f.verifier.VerifySnapshot(ctx, f.replicator.GetChan())
				return nil
			},
		},
		{
			name: "ScanSnapshot",
			fn: func(ctx context.Context) error {
				f.evaluator.ScanSnapshot(ctx, f.verifier.GetChan())
				return nil
			},
		},
		{
			name: "CreateEvents",
			fn: func(ctx context.Context) error {
				f.eventsCreator.CreateEvents(ctx, f.evaluator.GetChan())
				return nil
			},
		},
	}
	var wg sync.WaitGroup
	wg.Add(len(jobs))
	for _, job := range jobs {
		go func() {
			defer wg.Done()
			err := job.fn(ctx)
			if err != nil {
				f.log.Errorf("VulnerabilityWorker.work job %s failed: %s", job.name, err.Error())
			} else {
				f.log.Infof("VulnerabilityWorker.work job %s finished", job.name)
			}
		}()
	}

	f.log.Info("VulnerabilityWorker.work waiting on workers")
	wg.Wait()
	f.log.Info("VulnerabilityWorker.work finished waiting on workers")
}