Take ignore policy into account when working with automated resources

cluster/cluster.go

@@ -6,6 +6,7 @@ import (
 	"github.com/weaveworks/flux"
 	"github.com/weaveworks/flux/resource"
 	"github.com/weaveworks/flux/ssh"
+	"github.com/weaveworks/flux/policy"
 )
 
 // Constants for workload ready status. These are defined here so that
@@ -69,6 +70,7 @@ type Controller struct {
 	// in this field.
 	Antecedent flux.ResourceID
 	Labels     map[string]string
+	Policies   policy.Set
 	Rollout    RolloutStatus
 	// Errors during the recurring sync from the Git repository to the
 	// cluster will surface here.

cluster/kubernetes/resourcekinds.go

@@ -1,6 +1,8 @@
 package kubernetes
 
 import (
+	"strings"
+
 	apiapps "k8s.io/api/apps/v1"
 	apibatch "k8s.io/api/batch/v1beta1"
 	apiv1 "k8s.io/api/core/v1"
@@ -12,6 +14,7 @@ import (
 	"github.com/weaveworks/flux/image"
 	fhr_v1beta1 "github.com/weaveworks/flux/integrations/apis/flux.weave.works/v1beta1"
 	fhr_v1alpha2 "github.com/weaveworks/flux/integrations/apis/helm.integrations.flux.weave.works/v1alpha2"
+	"github.com/weaveworks/flux/policy"
 	"github.com/weaveworks/flux/resource"
 )
 
@@ -85,13 +88,26 @@ func (pc podController) toClusterController(resourceID flux.ResourceID) cluster.
 		}
 	}
 
+	var policies policy.Set
+	for k, v := range pc.GetAnnotations() {
+		if strings.HasPrefix(k, kresource.PolicyPrefix) {
+			p := strings.TrimPrefix(k, kresource.PolicyPrefix)
+			if v == "true" {
+				policies = policies.Add(policy.Policy(p))
+			} else {
+				policies = policies.Set(policy.Policy(p), v)
+			}
+		}
+	}
+
 	return cluster.Controller{
 		ID:         resourceID,
 		Status:     pc.status,
 		Rollout:    pc.rollout,
 		SyncError:  pc.syncError,
 		Antecedent: antecedent,
 		Labels:     pc.GetLabels(),
+		Policies:   policies,
 		Containers: cluster.ContainersOrExcuse{Containers: clusterContainers, Excuse: excuse},
 	}
 }

daemon/images.go

@@ -18,7 +18,7 @@ func (d *Daemon) pollForNewImages(logger log.Logger) {
 
 	ctx := context.Background()
 
-	candidateServices, err := d.getUnlockedAutomatedResources(ctx)
+	candidateServices, err := d.getAllowedAutomatedResources(ctx)
 	if err != nil {
 		logger.Log("error", errors.Wrap(err, "getting unlocked automated resources"))
 		return
@@ -95,9 +95,10 @@ func (r resources) IDs() (ids []flux.ResourceID) {
 	return ids
 }
 
-// getUnlockedAutomatedServices returns all the resources that are
-// both automated, and not locked.
-func (d *Daemon) getUnlockedAutomatedResources(ctx context.Context) (resources, error) {
+// getAllowedAutomatedResources returns all the resources that are
+// automated but do not have policies set to restrain them from
+// getting updated.
+func (d *Daemon) getAllowedAutomatedResources(ctx context.Context) (resources, error) {
 	resources, _, err := d.getResources(ctx)
 	if err != nil {
 		return nil, err
@@ -106,7 +107,7 @@ func (d *Daemon) getUnlockedAutomatedResources(ctx context.Context) (resources,
 	result := map[flux.ResourceID]resource.Resource{}
 	for _, resource := range resources {
 		policies := resource.Policy()
-		if policies.Has(policy.Automated) && !policies.Has(policy.Locked) {
+		if policies.Has(policy.Automated) && !policies.Has(policy.Locked) && !policies.Has(policy.Ignore) {
 			result[resource.ResourceID()] = resource
 		}
 	}

update/automated.go

@@ -28,9 +28,13 @@ func (a *Automated) CalculateRelease(rc ReleaseContext, logger log.Logger) ([]*C
 	prefilters := []ControllerFilter{
 		&IncludeFilter{a.serviceIDs()},
 	}
+	postfilters := []ControllerFilter{
+		&LockedFilter{},
+		&IgnoreFilter{},
+	}
 
 	result := Result{}
-	updates, err := rc.SelectServices(result, prefilters, nil)
+	updates, err := rc.SelectServices(result, prefilters, postfilters)
 	if err != nil {
 		return nil, nil, err
 	}

update/filter.go

@@ -8,6 +8,7 @@ import (
 
 const (
 	Locked               = "locked"
+	Ignore               = "ignore"
 	NotIncluded          = "not included"
 	Excluded             = "excluded"
 	DifferentImage       = "a different image"
@@ -89,3 +90,16 @@ func (f *LockedFilter) Filter(u ControllerUpdate) ControllerResult {
 	}
 	return ControllerResult{}
 }
+
+type IgnoreFilter struct {
+}
+
+func (f *IgnoreFilter) Filter(u ControllerUpdate) ControllerResult {
+	if u.Controller.Policies.Has(policy.Ignore) {
+		return ControllerResult{
+			Status: ReleaseStatusSkipped,
+			Error:  Ignore,
+		}
+	}
+	return ControllerResult{}
+}

update/release_containers.go

@@ -64,7 +64,7 @@ func (s ReleaseContainersSpec) filters() ([]ControllerFilter, []ControllerFilter
 	pre := []ControllerFilter{&IncludeFilter{IDs: rids}}
 
 	if !s.Force {
-		return pre, []ControllerFilter{&LockedFilter{}}
+		return pre, []ControllerFilter{&LockedFilter{}, &IgnoreFilter{}}
 	}
 	return pre, []ControllerFilter{}
 }

update/release_image.go

@@ -151,7 +151,7 @@ func (s ReleaseImageSpec) filters(rc ReleaseContext) ([]ControllerFilter, []Cont
 
 	// Filter out locked controllers unless given a specific controller(s) and forced
 	if !(len(ids) > 0 && s.Force) {
-		postfilters = append(postfilters, &LockedFilter{})
+		postfilters = append(postfilters, &LockedFilter{}, &IgnoreFilter{})
 	}
 
 	return prefilters, postfilters, nil