Added ignore event typs into notifications

Signed-off-by: elsanli(李楠) <elsanli@tencent.com>

notifications/endpoint.go

@@ -1,6 +1,7 @@
 package notifications
 
 import (
+	"github.com/docker/distribution/configuration"
 	"net/http"
 	"time"
 )
@@ -14,6 +15,7 @@ type EndpointConfig struct {
 	Backoff           time.Duration
 	IgnoredMediaTypes []string
 	Transport         *http.Transport `json:"-"`
+	Ignore            configuration.Ignore
 }
 
 // defaults set any zero-valued fields to a reasonable default.
@@ -63,7 +65,8 @@ func NewEndpoint(name, url string, config EndpointConfig) *Endpoint {
 		endpoint.Transport, endpoint.metrics.httpStatusListener())
 	endpoint.Sink = newRetryingSink(endpoint.Sink, endpoint.Threshold, endpoint.Backoff)
 	endpoint.Sink = newEventQueue(endpoint.Sink, endpoint.metrics.eventQueueListener())
-	endpoint.Sink = newIgnoredMediaTypesSink(endpoint.Sink, config.IgnoredMediaTypes)
+	mediaTypes := append(config.Ignore.MediaTypes, config.IgnoredMediaTypes...)
+	endpoint.Sink = newIgnoredSink(endpoint.Sink, mediaTypes, config.Ignore.Actions)
 
 	register(&endpoint)
 	return &endpoint

notifications/sinks.go

@@ -210,14 +210,15 @@ func (eq *eventQueue) next() []Event {
 	return block
 }
 
-// ignoredMediaTypesSink discards events with ignored target media types and
+// ignoredSink discards events with ignored target media types and actions.
 // passes the rest along.
-type ignoredMediaTypesSink struct {
+type ignoredSink struct {
 	Sink
-	ignored map[string]bool
+	ignoreMediaTypes map[string]bool
+	ignoreActions    map[string]bool
 }
 
-func newIgnoredMediaTypesSink(sink Sink, ignored []string) Sink {
+func newIgnoredSink(sink Sink, ignored []string, ignoreActions []string) Sink {
 	if len(ignored) == 0 {
 		return sink
 	}
@@ -227,25 +228,41 @@ func newIgnoredMediaTypesSink(sink Sink, ignored []string) Sink {
 		ignoredMap[mediaType] = true
 	}
 
-	return &ignoredMediaTypesSink{
-		Sink:    sink,
-		ignored: ignoredMap,
+	ignoredActionsMap := make(map[string]bool)
+	for _, action := range ignoreActions {
+		ignoredActionsMap[action] = true
+	}
+
+	return &ignoredSink{
+		Sink:             sink,
+		ignoreMediaTypes: ignoredMap,
+		ignoreActions:    ignoredActionsMap,
 	}
 }
 
 // Write discards events with ignored target media types and passes the rest
 // along.
-func (imts *ignoredMediaTypesSink) Write(events ...Event) error {
+func (imts *ignoredSink) Write(events ...Event) error {
 	var kept []Event
 	for _, e := range events {
-		if !imts.ignored[e.Target.MediaType] {
+		if !imts.ignoreMediaTypes[e.Target.MediaType] {
 			kept = append(kept, e)
 		}
 	}
 	if len(kept) == 0 {
 		return nil
 	}
-	return imts.Sink.Write(kept...)
+
+	var results []Event
+	for _, e := range kept {
+		if !imts.ignoreActions[e.Action] {
+			results = append(results, e)
+		}
+	}
+	if len(results) == 0 {
+		return nil
+	}
+	return imts.Sink.Write(results...)
 }
 
 // retryingSink retries the write until success or an ErrSinkClosed is

notifications/sinks_test.go

@@ -113,25 +113,29 @@ func TestEventQueue(t *testing.T) {
 	}
 }
 
-func TestIgnoredMediaTypesSink(t *testing.T) {
+func TestIgnoredSink(t *testing.T) {
 	blob := createTestEvent("push", "library/test", "blob")
-	manifest := createTestEvent("push", "library/test", "manifest")
+	manifest := createTestEvent("pull", "library/test", "manifest")
 
 	type testcase struct {
-		ignored  []string
-		expected []Event
+		ignoreMediaTypes []string
+		ignoreActions    []string
+		expected         []Event
 	}
 
 	cases := []testcase{
-		{nil, []Event{blob, manifest}},
-		{[]string{"other"}, []Event{blob, manifest}},
-		{[]string{"blob"}, []Event{manifest}},
-		{[]string{"blob", "manifest"}, nil},
+		{nil, nil, []Event{blob, manifest}},
+		{[]string{"other"}, []string{"other"}, []Event{blob, manifest}},
+		{[]string{"blob"}, []string{"other"}, []Event{manifest}},
+		{[]string{"blob", "manifest"}, []string{"other"}, nil},
+		{[]string{"other"}, []string{"push"}, []Event{manifest}},
+		{[]string{"other"}, []string{"pull"}, []Event{blob}},
+		{[]string{"other"}, []string{"pull", "push"}, nil},
 	}
 
 	for _, c := range cases {
 		ts := &testSink{}
-		s := newIgnoredMediaTypesSink(ts, c.ignored)
+		s := newIgnoredSink(ts, c.ignoreMediaTypes, c.ignoreActions)
 
 		if err := s.Write(blob, manifest); err != nil {
 			t.Fatalf("error writing event: %v", err)