108 lines
3.5 KiB
Go
108 lines
3.5 KiB
Go
package pipeline
|
|
|
|
import (
|
|
"fmt"
|
|
|
|
"gitea.maximumdirect.net/eric/notarius/internal/core/source"
|
|
"gitea.maximumdirect.net/eric/notarius/internal/framework/contracts"
|
|
frameworkdiagnostics "gitea.maximumdirect.net/eric/notarius/internal/framework/diagnostics"
|
|
)
|
|
|
|
func terminalDiagnosticGroups(terminal producerAttemptTerminal, origin contracts.DiagnosticOrigin, chunk *source.Chunk) ([]contracts.DiagnosticGroup, error) {
|
|
groups, err := promoteProducerDiagnostics(terminal.Diagnostics, origin, chunk)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
for _, record := range terminal.Validation.Diagnostics() {
|
|
validatorOrigin := origin
|
|
validatorOrigin.ValidatorKey = record.validatorName
|
|
promoted, err := promoteProducerDiagnostics([]contracts.ProducerDiagnostic{record.diagnostic}, validatorOrigin, chunk)
|
|
if err != nil {
|
|
return nil, fmt.Errorf("validator %q diagnostic: %w", record.validatorName, err)
|
|
}
|
|
groups = append(groups, promoted...)
|
|
}
|
|
return groups, nil
|
|
}
|
|
|
|
func promoteProducerDiagnostics(diagnostics []contracts.ProducerDiagnostic, origin contracts.DiagnosticOrigin, chunk *source.Chunk) ([]contracts.DiagnosticGroup, error) {
|
|
if err := contracts.ValidateProducerDiagnostics(diagnostics); err != nil {
|
|
return nil, err
|
|
}
|
|
if len(diagnostics) == 0 {
|
|
return nil, nil
|
|
}
|
|
groups := make([]contracts.DiagnosticGroup, len(diagnostics))
|
|
for index, diagnostic := range diagnostics {
|
|
group := contracts.DiagnosticGroup{
|
|
Disposition: diagnostic.Disposition,
|
|
Category: diagnostic.Category,
|
|
ReasonCode: diagnostic.ReasonCode,
|
|
Origin: origin,
|
|
OccurrenceCount: diagnostic.OccurrenceCount,
|
|
Samples: cloneDiagnosticSamples(diagnostic.Samples, chunk),
|
|
OmittedSampleCount: diagnostic.OmittedSampleCount,
|
|
}
|
|
if err := group.Validate(); err != nil {
|
|
return nil, err
|
|
}
|
|
groups[index] = group
|
|
}
|
|
return groups, nil
|
|
}
|
|
|
|
func cloneDiagnosticSamples(samples []contracts.DiagnosticSample, chunk *source.Chunk) []contracts.DiagnosticSample {
|
|
if len(samples) == 0 {
|
|
return nil
|
|
}
|
|
cloned := make([]contracts.DiagnosticSample, len(samples))
|
|
for index, sample := range samples {
|
|
if chunk != nil {
|
|
chunkIndex := chunk.Index
|
|
sample.ChunkID = chunk.ID
|
|
sample.ChunkIndex = &chunkIndex
|
|
} else if sample.ChunkIndex != nil {
|
|
chunkIndex := *sample.ChunkIndex
|
|
sample.ChunkIndex = &chunkIndex
|
|
}
|
|
cloned[index] = sample
|
|
}
|
|
return cloned
|
|
}
|
|
|
|
func appendDiagnosticGroups(output *RunOutput, groups []contracts.DiagnosticGroup) {
|
|
if output == nil || len(groups) == 0 {
|
|
return
|
|
}
|
|
cloned := contracts.CloneDiagnosticCollection(contracts.DiagnosticCollection{Groups: groups}).Groups
|
|
output.diagnosticGroups = append(output.diagnosticGroups, cloned...)
|
|
seen := make(map[contracts.Warning]struct{}, len(output.Warnings))
|
|
for _, warning := range output.Warnings {
|
|
seen[warning] = struct{}{}
|
|
}
|
|
for _, group := range cloned {
|
|
for _, sample := range group.Samples {
|
|
warning := contracts.Warning{Scope: sample.Scope, ReasonCode: group.ReasonCode, Message: sample.Message}
|
|
if _, exists := seen[warning]; exists {
|
|
continue
|
|
}
|
|
output.Warnings = append(output.Warnings, warning)
|
|
seen[warning] = struct{}{}
|
|
}
|
|
}
|
|
}
|
|
|
|
func finalizeDiagnostics(output *RunOutput) error {
|
|
if output == nil {
|
|
return nil
|
|
}
|
|
aggregator := frameworkdiagnostics.Aggregator{}
|
|
for _, group := range output.diagnosticGroups {
|
|
if err := aggregator.Add(group); err != nil {
|
|
return err
|
|
}
|
|
}
|
|
output.Diagnostics = aggregator.Collection()
|
|
return nil
|
|
}
|