Making filters usable

config/peer.go

@@ -5,6 +5,7 @@ import (
 	"time"
 
 	"github.com/bio-routing/bio-rd/routingtable"
+	"github.com/bio-routing/bio-rd/routingtable/filter"
 )
 
 type Peer struct {
@@ -20,4 +21,6 @@ type Peer struct {
 	RouterID          uint32
 	AddPathSend       routingtable.ClientOptions
 	AddPathRecv       bool
+	ImportFilter      *filter.Filter
+	ExportFilter      *filter.Filter
 }

main.go

@@ -11,6 +11,7 @@ import (
 	"github.com/bio-routing/bio-rd/config"
 	"github.com/bio-routing/bio-rd/protocols/bgp/server"
 	"github.com/bio-routing/bio-rd/routingtable"
+	"github.com/bio-routing/bio-rd/routingtable/filter"
 	"github.com/bio-routing/bio-rd/routingtable/locRIB"
 )
 
@@ -45,6 +46,8 @@ func main() {
 		AddPathSend: routingtable.ClientOptions{
 			MaxPaths: 10,
 		},
+		ExportFilter: filter.NewAcceptAllFilter(),
+		ImportFilter: filter.NewDrainFilter(),
 	}, rib)
 
 	//time.Sleep(time.Second * 15)
@@ -63,7 +66,9 @@ func main() {
 		AddPathSend: routingtable.ClientOptions{
 			MaxPaths: 10,
 		},
-		AddPathRecv: true,
+		AddPathRecv:  true,
+		ImportFilter: filter.NewDrainFilter(),
+		ExportFilter: filter.NewAcceptAllFilter(),
 	}, rib)
 
 	go func() {

protocols/bgp/server/fsm_established.go

@@ -53,7 +53,9 @@ func (s establishedState) run() (state, string) {
 
 func (s *establishedState) init() {
 	s.fsm.adjRIBIn = adjRIBIn.New()
-	s.fsm.adjRIBIn.Register(s.fsm.rib)
+
+	s.fsm.peer.importFilter.Register(s.fsm.rib)
+	s.fsm.adjRIBIn.Register(s.fsm.peer.importFilter)
 
 	n := &routingtable.Neighbor{
 		Type:    route.BGPPathType,
@@ -71,7 +73,8 @@ func (s *establishedState) init() {
 	}
 
 	s.fsm.adjRIBOut.Register(s.fsm.updateSender)
-	s.fsm.rib.RegisterWithOptions(s.fsm.adjRIBOut, clientOptions)
+	s.fsm.peer.exportFilter.Register(s.fsm.adjRIBOut)
+	s.fsm.rib.RegisterWithOptions(s.fsm.peer.exportFilter, clientOptions)
 
 	s.fsm.ribsInitialized = true
 }

protocols/bgp/server/peer.go

@@ -96,6 +96,8 @@ func NewPeer(c config.Peer, rib routingtable.RouteTableClient, server *BGPServer
 		keepaliveTime:     c.KeepAlive,
 		holdTime:          c.HoldTime,
 		optOpenParams:     make([]packet.OptParam, 0),
+		importFilter:      filterOrDefault(c.ImportFilter),
+		exportFilter:      filterOrDefault(c.ExportFilter),
 	}
 	p.fsms = append(p.fsms, NewActiveFSM2(p))
 
@@ -130,6 +132,14 @@ func NewPeer(c config.Peer, rib routingtable.RouteTableClient, server *BGPServer
 	return p, nil
 }
 
+func filterOrDefault(f *filter.Filter) *filter.Filter {
+	if f != nil {
+		return f
+	}
+
+	return filter.NewDrainFilter()
+}
+
 // GetAddr returns the IP address of the peer
 func (p *Peer) GetAddr() net.IP {
 	return p.addr

routingtable/filter/helper.go

+package filter
+
+import (
+	"github.com/bio-routing/bio-rd/routingtable/filter/actions"
+)
+
+// NewAcceptAllFilter returns a filter accepting any paths/prefixes
+func NewAcceptAllFilter() *Filter {
+	return NewFilter(
+		[]*Term{
+			NewTerm(
+				[]*TermCondition{},
+				[]FilterAction{
+					&actions.AcceptAction{},
+				}),
+		})
+}
+
+// NewDrainFilter returns a filter rejecting any paths/prefixes
+func NewDrainFilter() *Filter {
+	return NewFilter(
+		[]*Term{
+			NewTerm(
+				[]*TermCondition{},
+				[]FilterAction{
+					&actions.RejectAction{},
+				}),
+		})
+}

routingtable/filter/helper_test.go

+package filter
+
+import (
+	"testing"
+
+	"github.com/bio-routing/bio-rd/net"
+	"github.com/bio-routing/bio-rd/route"
+)
+
+func TestNewAcceptAllFilter(t *testing.T) {
+	f := NewAcceptAllFilter()
+
+	m := &clientMock{}
+	f.Register(m)
+
+	f.AddPath(net.NewPfx(0, 0), &route.Path{})
+
+	if !m.addPathCalled {
+		t.Fatalf("expected accepted, but was filtered")
+	}
+}
+
+func TestNewDrainFilter(t *testing.T) {
+	f := NewDrainFilter()
+
+	m := &clientMock{}
+	f.Register(m)
+
+	f.AddPath(net.NewPfx(0, 0), &route.Path{})
+
+	if m.addPathCalled {
+		t.Fatalf("expected filtered, but was accepted")
+	}
+}

routingtable/filter/term.go

@@ -39,7 +39,7 @@ func (t *Term) Process(p net.Prefix, pa *route.Path) (modPath *route.Path, rejec
 		}
 	}
 
-	return orig, true
+	return orig, false
 }
 
 func (t *Term) processActions(p net.Prefix, pa *route.Path) (modPath *route.Path, reject bool) {

routingtable/filter/term_condition.go

@@ -19,6 +19,18 @@ func NewTermCondition(prefixLists []*PrefixList, routeFilters []*RouteFilter) *T
 	}
 }
 
+func NewTermConditionWithRouteFilters(filters ...*RouteFilter) *TermCondition {
+	return &TermCondition{
+		routeFilters: filters,
+	}
+}
+
+func NewTermConditionWithPrefixLists(filters ...*PrefixList) *TermCondition {
+	return &TermCondition{
+		prefixLists: filters,
+	}
+}
+
 func (f *TermCondition) Matches(p net.Prefix, pa *route.Path) bool {
 	return f.matchesPrefixListFilters(p) &&
 		f.machtchesRouteFilters(p) &&

routingtable/filter/term_test.go

@@ -45,11 +45,8 @@ func TestProcess(t *testing.T) {
 			prefix: net.NewPfx(strAddr("100.64.0.1"), 8),
 			path:   &route.Path{},
 			from: []*TermCondition{
-				{
-					prefixLists: []*PrefixList{
-						NewPrefixList(net.NewPfx(strAddr("100.64.0.1"), 8)),
-					},
-				},
+				NewTermConditionWithPrefixLists(
+					NewPrefixList(net.NewPfx(strAddr("100.64.0.1"), 8))),
 			},
 			then: []FilterAction{
 				&actions.AcceptAction{},
@@ -62,16 +59,13 @@ func TestProcess(t *testing.T) {
 			prefix: net.NewPfx(strAddr("100.64.0.1"), 8),
 			path:   &route.Path{},
 			from: []*TermCondition{
-				{
-					prefixLists: []*PrefixList{
-						NewPrefixList(net.NewPfx(0, 32)),
-					},
-				},
+				NewTermConditionWithPrefixLists(
+					NewPrefixList(net.NewPfx(0, 32))),
 			},
 			then: []FilterAction{
 				&actions.AcceptAction{},
 			},
-			expectReject:   true,
+			expectReject:   false,
 			expectModified: false,
 		},
 		{
@@ -79,11 +73,8 @@ func TestProcess(t *testing.T) {
 			prefix: net.NewPfx(strAddr("100.64.0.1"), 8),
 			path:   &route.Path{},
 			from: []*TermCondition{
-				{
-					prefixLists: []*PrefixList{
-						NewPrefixList(net.NewPfx(strAddr("100.64.0.1"), 8)),
-					},
-				},
+				NewTermConditionWithPrefixLists(
+					NewPrefixList(net.NewPfx(strAddr("100.64.0.1"), 8))),
 			},
 			then: []FilterAction{
 				&mockAction{},
@@ -96,11 +87,8 @@ func TestProcess(t *testing.T) {
 			prefix: net.NewPfx(strAddr("100.64.0.1"), 8),
 			path:   &route.Path{},
 			from: []*TermCondition{
-				{
-					prefixLists: []*PrefixList{
-						NewPrefixList(net.NewPfx(strAddr("100.64.0.1"), 8)),
-					},
-				},
+				NewTermConditionWithRouteFilters(
+					NewRouteFilter(net.NewPfx(strAddr("100.64.0.1"), 8), Exact())),
 			},
 			then: []FilterAction{
 				&mockAction{},