new: improved control over events.stream verbosity ( ref #70 )

modules/events_ignore_list.go

@@ -0,0 +1,113 @@
+package modules
+
+import (
+	"errors"
+	"fmt"
+	"strings"
+	"sync"
+
+	"github.com/bettercap/bettercap/core"
+	"github.com/bettercap/bettercap/session"
+)
+
+var (
+	ErrEmptyExpression = errors.New("Expression can not be empty.")
+)
+
+type IgnoreFilter string
+
+func (f IgnoreFilter) Matches(s string) bool {
+	return string(f) == s || strings.HasPrefix(s, string(f))
+}
+
+type IgnoreList struct {
+	sync.RWMutex
+	filters []IgnoreFilter
+}
+
+func NewIgnoreList() *IgnoreList {
+	return &IgnoreList{
+		filters: make([]IgnoreFilter, 0),
+	}
+}
+
+func (l *IgnoreList) checkExpression(expr string) (string, error) {
+	expr = core.Trim(expr)
+	if expr == "" {
+		return "", ErrEmptyExpression
+	}
+
+	return expr, nil
+}
+
+func (l *IgnoreList) Add(expr string) (err error) {
+	if expr, err = l.checkExpression(expr); err != nil {
+		return err
+	}
+
+	l.Lock()
+	defer l.Unlock()
+
+	// first check for duplicates
+	for _, filter := range l.filters {
+		if filter.Matches(expr) {
+			return fmt.Errorf("Filter '%s' already matches the expression '%s'.", filter, expr)
+		}
+	}
+
+	// all good
+	l.filters = append(l.filters, IgnoreFilter(expr))
+
+	return nil
+}
+
+func (l *IgnoreList) Remove(expr string) (err error) {
+	if expr, err = l.checkExpression(expr); err != nil {
+		return err
+	}
+
+	l.Lock()
+	defer l.Unlock()
+
+	// build a new list with everything that does not match
+	toRemove := IgnoreFilter(expr)
+	newList := make([]IgnoreFilter, 0)
+	for _, filter := range l.filters {
+		if toRemove.Matches(string(filter)) == false {
+			newList = append(newList, filter)
+		}
+	}
+
+	if len(newList) == len(l.filters) {
+		return fmt.Errorf("Expression '%s' did not match any filter.", expr)
+	}
+
+	// swap
+	l.filters = newList
+
+	return nil
+}
+
+func (l *IgnoreList) Ignored(e session.Event) bool {
+	l.RLock()
+	defer l.RUnlock()
+
+	for _, filter := range l.filters {
+		if filter.Matches(e.Tag) {
+			return true
+		}
+	}
+
+	return false
+}
+
+func (l *IgnoreList) Empty() bool {
+	l.RLock()
+	defer l.RUnlock()
+
+	return len(l.filters) == 0
+}
+
+func (l *IgnoreList) Filters() []IgnoreFilter {
+	return l.filters
+}