108 lines
3.2 KiB
Go
108 lines
3.2 KiB
Go
package state
|
|
|
|
import (
|
|
"fmt"
|
|
|
|
"gitea.maximumdirect.net/eric/distributor/internal/bundle"
|
|
"gitea.maximumdirect.net/eric/distributor/internal/storage"
|
|
)
|
|
|
|
const (
|
|
OutputKindSource = "source"
|
|
OutputKindGenerated = "generated"
|
|
)
|
|
|
|
func Validate(s DistributorState) error {
|
|
if s.SchemaVersion != SchemaVersion {
|
|
return fmt.Errorf("state schema_version must be %d", SchemaVersion)
|
|
}
|
|
if s.PipelineID == "" {
|
|
return fmt.Errorf("state pipeline_id is required")
|
|
}
|
|
if s.DestinationID == "" {
|
|
return fmt.Errorf("state destination_id is required")
|
|
}
|
|
if s.PublishedAt.IsZero() {
|
|
return fmt.Errorf("state published_at is required")
|
|
}
|
|
if err := validateEmbeddedManifest(s.Source.Manifest); err != nil {
|
|
return fmt.Errorf("state source.manifest: %w", err)
|
|
}
|
|
if s.Outputs == nil {
|
|
return fmt.Errorf("state outputs is required")
|
|
}
|
|
seen := make(map[string]struct{}, len(s.Outputs))
|
|
for index, output := range s.Outputs {
|
|
if err := validateOutput(index, output); err != nil {
|
|
return err
|
|
}
|
|
if _, exists := seen[output.Path]; exists {
|
|
return fmt.Errorf("state outputs[%d].path duplicates %q", index, output.Path)
|
|
}
|
|
seen[output.Path] = struct{}{}
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func validateEmbeddedManifest(manifest bundle.Manifest) error {
|
|
if manifest.SchemaVersion != 1 {
|
|
return fmt.Errorf("schema_version must be 1")
|
|
}
|
|
if manifest.ID == "" {
|
|
return fmt.Errorf("id is required")
|
|
}
|
|
if err := bundle.ValidateDigest(manifest.Digest); err != nil {
|
|
return fmt.Errorf("digest: %w", err)
|
|
}
|
|
if manifest.Created.IsZero() {
|
|
return fmt.Errorf("created is required")
|
|
}
|
|
if len(manifest.Files) == 0 {
|
|
return fmt.Errorf("files is required")
|
|
}
|
|
seen := make(map[string]struct{}, len(manifest.Files))
|
|
for index, file := range manifest.Files {
|
|
if err := bundle.ValidateSourcePath(file.Path); err != nil {
|
|
return fmt.Errorf("files[%d].path: %w", index, err)
|
|
}
|
|
if err := bundle.ValidateDigest(file.SHA256); err != nil {
|
|
return fmt.Errorf("files[%d].sha256: %w", index, err)
|
|
}
|
|
if file.Size < 0 {
|
|
return fmt.Errorf("files[%d].size must be non-negative", index)
|
|
}
|
|
if _, exists := seen[file.Path]; exists {
|
|
return fmt.Errorf("files[%d].path duplicates %q", index, file.Path)
|
|
}
|
|
seen[file.Path] = struct{}{}
|
|
}
|
|
if actual := bundle.BundleDigest(manifest.Files); actual != manifest.Digest {
|
|
return fmt.Errorf("digest mismatch: got %s want %s", actual, manifest.Digest)
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func validateOutput(index int, output OutputFile) error {
|
|
if err := storage.ValidatePath(output.Path); err != nil {
|
|
return fmt.Errorf("state outputs[%d].path: %w", index, err)
|
|
}
|
|
switch output.Kind {
|
|
case OutputKindSource, OutputKindGenerated:
|
|
default:
|
|
return fmt.Errorf("state outputs[%d].kind must be source or generated", index)
|
|
}
|
|
if err := storage.ValidatePath(output.SourcePath); err != nil {
|
|
return fmt.Errorf("state outputs[%d].source_path: %w", index, err)
|
|
}
|
|
if output.Kind == OutputKindGenerated && output.Transform == "" {
|
|
return fmt.Errorf("state outputs[%d].transform is required for generated output", index)
|
|
}
|
|
if err := bundle.ValidateDigest(output.SHA256); err != nil {
|
|
return fmt.Errorf("state outputs[%d].sha256: %w", index, err)
|
|
}
|
|
if output.Size < 0 {
|
|
return fmt.Errorf("state outputs[%d].size must be non-negative", index)
|
|
}
|
|
return nil
|
|
}
|