optimize Listen bucket notification implementation (#9444)

this commit avoids lots of tiny allocations, repeated
channel creates which are performed when filtering
the incoming events, unescaping a key just for matching.

also remove deprecated code which is not needed
anymore, avoids unexpected data structure transformations
from the map to slice.

pkg/event/targetlist.go

@@ -61,8 +61,9 @@ func (list *TargetList) Exists(id TargetID) bool {
 	return found
 }
 
-// TargetIDErr returns error associated for a targetID
-type TargetIDErr struct {
+// TargetIDResult returns result of Remove/Send operation, sets err if
+// any for the associated TargetID
+type TargetIDResult struct {
 	// ID where the remove or send were initiated.
 	ID TargetID
 	// Stores any error while removing a target or while sending an event.
@@ -70,40 +71,17 @@ type TargetIDErr struct {
 }
 
 // Remove - closes and removes targets by given target IDs.
-func (list *TargetList) Remove(targetids ...TargetID) <-chan TargetIDErr {
-	errCh := make(chan TargetIDErr)
+func (list *TargetList) Remove(targetIDSet TargetIDSet) {
+	list.Lock()
+	defer list.Unlock()
 
-	go func() {
-		defer close(errCh)
-
-		var wg sync.WaitGroup
-		for _, id := range targetids {
-			list.RLock()
-			target, ok := list.targets[id]
-			list.RUnlock()
-			if ok {
-				wg.Add(1)
-				go func(id TargetID, target Target) {
-					defer wg.Done()
-					if err := target.Close(); err != nil {
-						errCh <- TargetIDErr{
-							ID:  id,
-							Err: err,
-						}
-					}
-				}(id, target)
-			}
-		}
-		wg.Wait()
-
-		list.Lock()
-		for _, id := range targetids {
+	for id := range targetIDSet {
+		target, ok := list.targets[id]
+		if ok {
+			target.Close()
 			delete(list.targets, id)
 		}
-		list.Unlock()
-	}()
-
-	return errCh
+	}
 }
 
 // Targets - list all targets
@@ -140,14 +118,10 @@ func (list *TargetList) TargetMap() map[TargetID]Target {
 }
 
 // Send - sends events to targets identified by target IDs.
-func (list *TargetList) Send(event Event, targetIDs ...TargetID) <-chan TargetIDErr {
-	errCh := make(chan TargetIDErr)
-
+func (list *TargetList) Send(event Event, targetIDset TargetIDSet, resCh chan<- TargetIDResult) {
 	go func() {
-		defer close(errCh)
-
 		var wg sync.WaitGroup
-		for _, id := range targetIDs {
+		for id := range targetIDset {
 			list.RLock()
 			target, ok := list.targets[id]
 			list.RUnlock()
@@ -155,19 +129,18 @@ func (list *TargetList) Send(event Event, targetIDs ...TargetID) <-chan TargetID
 				wg.Add(1)
 				go func(id TargetID, target Target) {
 					defer wg.Done()
+					tgtRes := TargetIDResult{ID: id}
 					if err := target.Save(event); err != nil {
-						errCh <- TargetIDErr{
-							ID:  id,
-							Err: err,
-						}
+						tgtRes.Err = err
 					}
+					resCh <- tgtRes
 				}(id, target)
+			} else {
+				resCh <- TargetIDResult{ID: id}
 			}
 		}
 		wg.Wait()
 	}()
-
-	return errCh
 }
 
 // NewTargetList - creates TargetList.