Merge pull request #887 from IamTheFij/global-defaults

Global defaults for image configs

internal/app/diun.go

@@ -153,32 +153,32 @@ func (di *Diun) Run() {
 	defer di.pool.Release()
 
 	// Docker provider
-	for _, job := range dockerPrd.New(di.cfg.Providers.Docker).ListJob() {
+	for _, job := range dockerPrd.New(di.cfg.Providers.Docker, di.cfg.Watch.ImageDefaults).ListJob() {
 		di.createJob(job)
 	}
 
 	// Swarm provider
-	for _, job := range swarmPrd.New(di.cfg.Providers.Swarm).ListJob() {
+	for _, job := range swarmPrd.New(di.cfg.Providers.Swarm, di.cfg.Watch.ImageDefaults).ListJob() {
 		di.createJob(job)
 	}
 
 	// Kubernetes provider
-	for _, job := range kubernetesPrd.New(di.cfg.Providers.Kubernetes).ListJob() {
+	for _, job := range kubernetesPrd.New(di.cfg.Providers.Kubernetes, di.cfg.Watch.ImageDefaults).ListJob() {
 		di.createJob(job)
 	}
 
 	// File provider
-	for _, job := range filePrd.New(di.cfg.Providers.File).ListJob() {
+	for _, job := range filePrd.New(di.cfg.Providers.File, di.cfg.Watch.ImageDefaults).ListJob() {
 		di.createJob(job)
 	}
 
 	// Dockerfile provider
-	for _, job := range dockerfilePrd.New(di.cfg.Providers.Dockerfile).ListJob() {
+	for _, job := range dockerfilePrd.New(di.cfg.Providers.Dockerfile, di.cfg.Watch.ImageDefaults).ListJob() {
 		di.createJob(job)
 	}
 
 	// Nomad provider
-	for _, job := range nomadPrd.New(di.cfg.Providers.Nomad).ListJob() {
+	for _, job := range nomadPrd.New(di.cfg.Providers.Nomad, di.cfg.Watch.ImageDefaults).ListJob() {
 		di.createJob(job)
 	}
 

internal/app/job.go

@@ -63,7 +63,7 @@ func (di *Diun) createJob(job model.Job) {
 	// Set defaults
 	if err := mergo.Merge(&job.Image, model.Image{
 		Platform:  model.ImagePlatform{},
-		WatchRepo: false,
+		WatchRepo: utl.NewFalse(),
 		MaxTags:   0,
 	}); err != nil {
 		sublog.Error().Err(err).Msg("Cannot set default values")
@@ -118,7 +118,7 @@ func (di *Diun) createJob(job model.Job) {
 		sublog.Error().Err(err).Msgf("Invoking job")
 	}
 
-	if !job.Image.WatchRepo || len(job.RegImage.Domain) == 0 {
+	if job.Image.WatchRepo == nil || !*job.Image.WatchRepo || len(job.RegImage.Domain) == 0 {
 		return
 	}
 

internal/config/config_test.go

@@ -7,6 +7,7 @@ import (
 
 	"github.com/crazy-max/diun/v4/internal/config"
 	"github.com/crazy-max/diun/v4/internal/model"
+	"github.com/crazy-max/diun/v4/pkg/registry"
 	"github.com/crazy-max/diun/v4/pkg/utl"
 	"github.com/crazy-max/gonfig/env"
 	"github.com/stretchr/testify/assert"
@@ -58,6 +59,10 @@ func TestLoadFile(t *testing.T) {
 						BaseURL: "https://hc-ping.com/",
 						UUID:    "5bf66975-d4c7-4bf5-bcc8-b8d8a82ea278",
 					},
+					ImageDefaults: &model.Image{
+						NotifyOn: model.NotifyOnDefaults,
+						SortTags: registry.SortTagReverse,
+					},
 				},
 				Notif: &model.Notif{
 					Amqp: &model.NotifAmqp{

internal/model/image.go

@@ -1,13 +1,15 @@
 package model
 
-import "github.com/crazy-max/diun/v4/pkg/registry"
+import (
+	"github.com/crazy-max/diun/v4/pkg/registry"
+)
 
 // Image holds image configuration
 type Image struct {
 	Name        string            `yaml:"name,omitempty" json:",omitempty"`
 	Platform    ImagePlatform     `yaml:"platform,omitempty" json:",omitempty"`
 	RegOpt      string            `yaml:"regopt,omitempty" json:",omitempty"`
-	WatchRepo   bool              `yaml:"watch_repo,omitempty" json:",omitempty"`
+	WatchRepo   *bool             `yaml:"watch_repo,omitempty" json:",omitempty"`
 	NotifyOn    []NotifyOn        `yaml:"notify_on,omitempty" json:",omitempty"`
 	MaxTags     int               `yaml:"max_tags,omitempty" json:",omitempty"`
 	SortTags    registry.SortTag  `yaml:"sort_tags,omitempty" json:",omitempty"`

internal/model/watch.go

@@ -3,6 +3,7 @@ package model
 import (
 	"time"
 
+	"github.com/crazy-max/diun/v4/pkg/registry"
 	"github.com/crazy-max/diun/v4/pkg/utl"
 )
 
@@ -15,6 +16,7 @@ type Watch struct {
 	RunOnStartup    *bool          `yaml:"runOnStartup,omitempty" json:"runOnStartup,omitempty" validate:"required"`
 	CompareDigest   *bool          `yaml:"compareDigest,omitempty" json:"compareDigest,omitempty" validate:"required"`
 	Healthchecks    *Healthchecks  `yaml:"healthchecks,omitempty" json:"healthchecks,omitempty"`
+	ImageDefaults   *Image         `yaml:"defaults,omitempty" json:"defaults,omitempty"`
 }
 
 // GetDefaults gets the default values
@@ -31,4 +33,8 @@ func (s *Watch) SetDefaults() {
 	s.FirstCheckNotif = utl.NewFalse()
 	s.RunOnStartup = utl.NewTrue()
 	s.CompareDigest = utl.NewTrue()
+	s.ImageDefaults = &Image{
+		NotifyOn: NotifyOnDefaults,
+		SortTags: registry.SortTagReverse,
+	}
 }

internal/provider/common.go

@@ -1,6 +1,7 @@
 package provider
 
 import (
+	"errors"
 	"fmt"
 	"regexp"
 	"strconv"
@@ -9,30 +10,33 @@ import (
 	"github.com/containerd/containerd/platforms"
 	"github.com/crazy-max/diun/v4/internal/model"
 	"github.com/crazy-max/diun/v4/pkg/registry"
-	"github.com/pkg/errors"
+	"github.com/imdario/mergo"
 )
 
 var (
 	metadataKeyChars  = `a-zA-Z0-9_`
 	metadataKeyRegexp = regexp.MustCompile(`^[` + metadataKeyChars + `]+$`)
+	ErrInvalidLabel   = errors.New("invalid label error")
 )
 
 // ValidateImage returns a standard image through Docker labels
-func ValidateImage(image string, metadata, labels map[string]string, watchByDef bool) (img model.Image, err error) {
+func ValidateImage(image string, metadata, labels map[string]string, watchByDef bool, imageDefaults model.Image) (img model.Image, err error) {
 	if i := strings.Index(image, "@sha256:"); i > 0 {
 		image = image[:i]
 	}
+
 	img = model.Image{
-		Name:     image,
-		Metadata: metadata,
-		NotifyOn: model.NotifyOnDefaults,
-		SortTags: registry.SortTagReverse,
+		Name: image,
+	}
+
+	if err := mergo.Merge(&img, imageDefaults); err != nil {
+		return img, fmt.Errorf("failed to merge image defaults for image %s", image)
 	}
 
 	if enableStr, ok := labels["diun.enable"]; ok {
 		enable, err := strconv.ParseBool(enableStr)
 		if err != nil {
-			return img, fmt.Errorf("cannot parse %s value of label diun.enable", enableStr)
+			return img, fmt.Errorf("cannot parse %q value of label diun.enable: %w", enableStr, ErrInvalidLabel)
 		}
 		if !enable {
 			return model.Image{}, nil
@@ -46,8 +50,10 @@ func ValidateImage(image string, metadata, labels map[string]string, watchByDef
 		case key == "diun.regopt":
 			img.RegOpt = value
 		case key == "diun.watch_repo":
-			if img.WatchRepo, err = strconv.ParseBool(value); err != nil {
-				return img, fmt.Errorf("cannot parse %s value of label %s", value, key)
+			if watchRepo, err := strconv.ParseBool(value); err == nil {
+				img.WatchRepo = &watchRepo
+			} else {
+				return img, fmt.Errorf("cannot parse %q value of label %s: %w", value, key, ErrInvalidLabel)
 			}
 		case key == "diun.notify_on":
 			if len(value) == 0 {
@@ -57,7 +63,7 @@ func ValidateImage(image string, metadata, labels map[string]string, watchByDef
 			for _, no := range strings.Split(value, ";") {
 				notifyOn := model.NotifyOn(no)
 				if !notifyOn.Valid() {
-					return img, fmt.Errorf("unknown notify status %q", value)
+					return img, fmt.Errorf("unknown notify status %q: %w", value, ErrInvalidLabel)
 				}
 				img.NotifyOn = append(img.NotifyOn, notifyOn)
 			}
@@ -67,12 +73,12 @@ func ValidateImage(image string, metadata, labels map[string]string, watchByDef
 			}
 			sortTags := registry.SortTag(value)
 			if !sortTags.Valid() {
-				return img, fmt.Errorf("unknown sort tags type %q", value)
+				return img, fmt.Errorf("unknown sort tags type %q: %w", value, ErrInvalidLabel)
 			}
 			img.SortTags = sortTags
 		case key == "diun.max_tags":
 			if img.MaxTags, err = strconv.Atoi(value); err != nil {
-				return img, fmt.Errorf("cannot parse %s value of label %s", value, key)
+				return img, fmt.Errorf("cannot parse %q value of label %s: %w", value, key, ErrInvalidLabel)
 			}
 		case key == "diun.include_tags":
 			img.IncludeTags = strings.Split(value, ";")
@@ -85,7 +91,7 @@ func ValidateImage(image string, metadata, labels map[string]string, watchByDef
 		case key == "diun.platform":
 			platform, err := platforms.Parse(value)
 			if err != nil {
-				return img, fmt.Errorf("cannot parse %s platform of label %s", value, key)
+				return img, fmt.Errorf("cannot parse %q platform of label %s: %w", value, key, ErrInvalidLabel)
 			}
 			img.Platform = model.ImagePlatform{
 				OS:      platform.OS,
@@ -98,7 +104,7 @@ func ValidateImage(image string, metadata, labels map[string]string, watchByDef
 				break
 			}
 			if err := validateMetadataKey(mkey); err != nil {
-				return img, errors.Wrapf(err, "invalid metadata key %q", mkey)
+				return img, fmt.Errorf("invalid metadata key %q: %w: %w", mkey, err, ErrInvalidLabel)
 			}
 			if img.Metadata == nil {
 				img.Metadata = map[string]string{}
@@ -107,12 +113,17 @@ func ValidateImage(image string, metadata, labels map[string]string, watchByDef
 		}
 	}
 
+	// Update provider metadata with metadata from img labels
+	if err := mergo.Merge(&img.Metadata, metadata); err != nil {
+		return img, fmt.Errorf("failed merging metadata: %w", err)
+	}
+
 	return img, nil
 }
 
 func validateMetadataKey(key string) error {
 	if !metadataKeyRegexp.MatchString(key) {
-		return errors.Errorf("only %q are allowed", metadataKeyChars)
+		return fmt.Errorf("only %q are allowed", metadataKeyChars)
 	}
 	return nil
 }