summaryrefslogtreecommitdiffhomepage
path: root/policy
diff options
context:
space:
mode:
Diffstat (limited to 'policy')
-rw-r--r--policy/policy.go261
-rw-r--r--policy/policy_test.go322
2 files changed, 475 insertions, 108 deletions
diff --git a/policy/policy.go b/policy/policy.go
index 977116fd..a13aeebc 100644
--- a/policy/policy.go
+++ b/policy/policy.go
@@ -23,8 +23,8 @@ import (
"github.com/osrg/gobgp/packet"
"github.com/osrg/gobgp/table"
"net"
- "regexp"
"reflect"
+ "regexp"
"strconv"
"strings"
)
@@ -102,19 +102,22 @@ func NewPolicy(pd config.PolicyDefinition, ds config.DefinedSets) *Policy {
conditions = append(conditions, cc)
}
- action := &RoutingActions{
- AcceptRoute: false,
- }
+ // routeing action
+ ra := NewRoutingAction(statement.Actions)
- if statement.Actions.AcceptRoute {
- action.AcceptRoute = true
+ // modification action
+ mda := make([]Action, 0)
+ com := NewCommunityAction(statement.Actions.BgpActions.SetCommunity)
+ if com != nil {
+ mda = append(mda, com)
}
s := &Statement{
- Name: statement.Name,
- Conditions: conditions,
- Actions: action,
- MatchSetOptions: statement.Conditions.MatchSetOptions,
+ Name: statement.Name,
+ Conditions: conditions,
+ routingAction: ra,
+ modificationActions: mda,
+ MatchSetOptions: statement.Conditions.MatchSetOptions,
}
st = append(st, s)
@@ -124,10 +127,11 @@ func NewPolicy(pd config.PolicyDefinition, ds config.DefinedSets) *Policy {
}
type Statement struct {
- Name string
- Conditions []Condition
- Actions Actions
- MatchSetOptions config.MatchSetOptionsType
+ Name string
+ Conditions []Condition
+ routingAction *RoutingAction
+ modificationActions []Action
+ MatchSetOptions config.MatchSetOptionsType
}
// evaluate each condition in the statement according to MatchSetOptions
@@ -489,75 +493,24 @@ type CommunityElement struct {
// CommunityCondition supports uint and string like 65000:100
// and also supports regular expressions that are available in golang.
// if GoBGP can't parse the regular expression, it return nil and an error message is logged.
-func NewCommunityCondition(communitySetName string, defAsPathSetList []config.CommunitySet) *CommunityCondition {
-
- // check format
- regUint, _ := regexp.Compile("^([0-9]+)$")
- regString, _ := regexp.Compile("([0-9]+):([0-9]+)")
- regWellKnown, _ := regexp.Compile("^(" +
- COMMUNITY_INTERNET + "|" +
- COMMUNITY_NO_EXPORT + "|" +
- COMMUNITY_NO_ADVERTISE + "|" +
- COMMUNITY_NO_EXPORT_SUBCONFED + ")$")
+func NewCommunityCondition(communitySetName string, defCommunitySetList []config.CommunitySet) *CommunityCondition {
communityList := make([]*CommunityElement, 0)
- for _, asPathSet := range defAsPathSetList {
- if asPathSet.CommunitySetName == communitySetName {
- for _, as := range asPathSet.CommunityMembers {
+ for _, communitySet := range defCommunitySetList {
+ if communitySet.CommunitySetName == communitySetName {
+ for _, c := range communitySet.CommunityMembers {
e := &CommunityElement{
- isRegExp: false,
+ isRegExp: false,
+ communityStr: c,
}
- if regUint.MatchString(as) {
- // specified by Uint
- community, err := strconv.ParseUint(as, 10, 32)
- if err != nil {
- log.WithFields(log.Fields{
- "Topic": "Policy",
- "Type": "Community Condition",
- }).Error("failed to parse the community value.")
- return nil
- }
-
- e.community = uint32(community)
- e.communityStr = as
-
- } else if regString.MatchString(as) {
- // specified by string containing ":"
- group := regString.FindStringSubmatch(as)
- asn, errAsn := strconv.ParseUint(group[1], 10, 16)
- val, errVal := strconv.ParseUint(group[2], 10, 16)
-
- if errAsn != nil || errVal != nil {
- log.WithFields(log.Fields{
- "Topic": "Policy",
- "Type": "Community Condition",
- }).Error("failed to parser as number or community value.")
- return nil
- }
- e.community = uint32(asn<<16 | val)
- e.communityStr = as
-
- } else if regWellKnown.MatchString(as) {
- // specified by well known community name
- e.communityStr = as
- switch as {
- case COMMUNITY_INTERNET:
- e.community = COMMUNITY_INTERNET_VAL
- case COMMUNITY_NO_EXPORT:
- e.community = COMMUNITY_NO_EXPORT_VAL
- case COMMUNITY_NO_ADVERTISE:
- e.community = COMMUNITY_NO_ADVERTISE_VAL
- case COMMUNITY_NO_EXPORT_SUBCONFED:
- e.community = COMMUNITY_NO_EXPORT_SUBCONFED_VAL
- }
-
+ if matched, v := getCommunityValue(c); matched {
+ e.community = v
} else {
// specified by regular expression
e.isRegExp = true
- e.communityStr = as
- reg, err := regexp.Compile(as)
+ reg, err := regexp.Compile(c)
if err != nil {
log.WithFields(log.Fields{
"Topic": "Policy",
@@ -579,6 +532,63 @@ func NewCommunityCondition(communitySetName string, defAsPathSetList []config.Co
return nil
}
+// getCommunityValue returns uint32 community value converted from the string.
+// if the string doesn't match a number or string like "65000:1000" or well known
+// community name, it returns false and 0, otherwise returns true and its uint32 value.
+func getCommunityValue(comStr string) (bool, uint32) {
+ // community regexp
+ regUint, _ := regexp.Compile("^([0-9]+)$")
+ regString, _ := regexp.Compile("([0-9]+):([0-9]+)")
+ regWellKnown, _ := regexp.Compile("^(" +
+ COMMUNITY_INTERNET + "|" +
+ COMMUNITY_NO_EXPORT + "|" +
+ COMMUNITY_NO_ADVERTISE + "|" +
+ COMMUNITY_NO_EXPORT_SUBCONFED + ")$")
+
+ if regUint.MatchString(comStr) {
+ // specified by Uint
+ community, err := strconv.ParseUint(comStr, 10, 32)
+ if err != nil {
+ log.WithFields(log.Fields{
+ "Topic": "Policy",
+ "Type": "Community Condition",
+ }).Error("failed to parse the community value.")
+ }
+ return true, uint32(community)
+
+ } else if regString.MatchString(comStr) {
+ // specified by string containing ":"
+ group := regString.FindStringSubmatch(comStr)
+ asn, errAsn := strconv.ParseUint(group[1], 10, 16)
+ val, errVal := strconv.ParseUint(group[2], 10, 16)
+
+ if errAsn != nil || errVal != nil {
+ log.WithFields(log.Fields{
+ "Topic": "Policy",
+ "Type": "Community Condition",
+ }).Error("failed to parser as number or community value.")
+ }
+ community := uint32(asn<<16 | val)
+ return true, community
+
+ } else if regWellKnown.MatchString(comStr) {
+ // specified by well known community name
+ var community uint32
+ switch comStr {
+ case COMMUNITY_INTERNET:
+ community = COMMUNITY_INTERNET_VAL
+ case COMMUNITY_NO_EXPORT:
+ community = COMMUNITY_NO_EXPORT_VAL
+ case COMMUNITY_NO_ADVERTISE:
+ community = COMMUNITY_NO_ADVERTISE_VAL
+ case COMMUNITY_NO_EXPORT_SUBCONFED:
+ community = COMMUNITY_NO_EXPORT_SUBCONFED_VAL
+ }
+ return true, community
+ }
+ return false, 0
+}
+
// compare community in the message's attribute with
// the one in the condition.
func (c *CommunityCondition) evaluate(path table.Path) bool {
@@ -626,23 +636,30 @@ func (c *CommunityCondition) evaluate(path table.Path) bool {
return false
}
-type Actions interface {
+type Action interface {
apply(table.Path) table.Path
}
-type DefaultActions struct {
+type DefaultAction struct {
}
-func (a *DefaultActions) apply(path table.Path) table.Path {
+func (a *DefaultAction) apply(path table.Path) table.Path {
return path
}
-type RoutingActions struct {
- DefaultActions
+type RoutingAction struct {
+ DefaultAction
AcceptRoute bool
}
-func (r *RoutingActions) apply(path table.Path) table.Path {
+func NewRoutingAction(action config.Actions) *RoutingAction {
+ r := &RoutingAction{
+ AcceptRoute: action.AcceptRoute,
+ }
+ return r
+}
+
+func (r *RoutingAction) apply(path table.Path) table.Path {
if r.AcceptRoute {
return path
} else {
@@ -650,10 +667,76 @@ func (r *RoutingActions) apply(path table.Path) table.Path {
}
}
-type ModificationActions struct {
- DefaultActions
- AttrType bgp.BGPAttrType
- Value string
+type ActionType int
+
+type CommunityAction struct {
+ DefaultAction
+ Values []uint32
+ action ActionType
+}
+
+const (
+ COMMUNITY_ACTION_ADD string = "ADD"
+ COMMUNITY_ACTION_REPLACE = "REPLACE"
+ COMMUNITY_ACTION_REMOVE = "REMOVE"
+ COMMUNITY_ACTION_NULL = "NULL"
+)
+
+// NewCommunityAction creates CommunityAction object.
+// If it cannot parse community string, then return nil.
+// Similarly, if option string is invalid, return nil.
+func NewCommunityAction(action config.SetCommunity) *CommunityAction {
+
+ m := &CommunityAction{}
+
+ values := make([]uint32, len(action.Communities))
+ for i, com := range action.Communities {
+ matched, value := getCommunityValue(com)
+ if matched {
+ values[i] = value
+ } else {
+ log.WithFields(log.Fields{
+ "Topic": "Policy",
+ "Type": "Community Action",
+ }).Error("community string invalid.")
+ return nil
+ }
+ }
+ m.Values = values
+
+ switch action.Options {
+ case COMMUNITY_ACTION_ADD:
+ m.action = config.BGP_SET_COMMUNITY_OPTION_TYPE_ADD
+ case COMMUNITY_ACTION_REMOVE:
+ m.action = config.BGP_SET_COMMUNITY_OPTION_TYPE_REMOVE
+ case COMMUNITY_ACTION_REPLACE:
+ m.action = config.BGP_SET_COMMUNITY_OPTION_TYPE_REPLACE
+ case COMMUNITY_ACTION_NULL:
+ m.action = config.BGP_SET_COMMUNITY_OPTION_TYPE_NULL
+ default:
+ log.WithFields(log.Fields{
+ "Topic": "Policy",
+ "Type": "Community Action",
+ }).Error("action string should be ADD or REMOVE or REPLACE or NULL.")
+ return nil
+ }
+ return m
+}
+
+func (a *CommunityAction) apply(path table.Path) table.Path {
+
+ list := a.Values
+ switch a.action {
+ case config.BGP_SET_COMMUNITY_OPTION_TYPE_ADD:
+ path.SetCommunities(list, false)
+ case config.BGP_SET_COMMUNITY_OPTION_TYPE_REMOVE:
+ path.RemoveCommunities(list)
+ case config.BGP_SET_COMMUNITY_OPTION_TYPE_REPLACE:
+ path.SetCommunities(list, true)
+ case config.BGP_SET_COMMUNITY_OPTION_TYPE_NULL:
+ path.ClearCommunities()
+ }
+ return path
}
type Prefix struct {
@@ -724,8 +807,13 @@ func (p *Policy) Apply(path table.Path) (bool, RouteType, table.Path) {
var p table.Path
if result {
- p = statement.Actions.apply(path)
+ //Routing action
+ p = statement.routingAction.apply(path)
if p != nil {
+ // apply all modification actions
+ for _, action := range statement.modificationActions {
+ p = action.apply(p)
+ }
return true, ROUTE_TYPE_ACCEPT, p
} else {
return true, ROUTE_TYPE_REJECT, nil
@@ -851,7 +939,8 @@ func (p *Policy) ToApiStruct() *api.PolicyDefinition {
AcceptRoute: false,
RejectRoute: true,
}
- if st.Actions.(*RoutingActions).AcceptRoute {
+
+ if st.routingAction.AcceptRoute {
resAction.AcceptRoute = true
resAction.RejectRoute = false
}
diff --git a/policy/policy_test.go b/policy/policy_test.go
index 8a0467bb..054d4d9f 100644
--- a/policy/policy_test.go
+++ b/policy/policy_test.go
@@ -926,13 +926,6 @@ func TestConditionConditionEvaluate(t *testing.T) {
log.SetLevel(log.DebugLevel)
- strToCom := func(s string) uint32 {
- elem := strings.Split(s, ":")
- asn, _ := strconv.ParseUint(elem[0], 10, 16)
- val, _ := strconv.ParseUint(elem[1], 10, 16)
- return uint32(asn<<16 | val)
- }
-
// setup
// create path
peer := &table.PeerInfo{AS: 65001, Address: net.ParseIP("10.0.0.1")}
@@ -945,10 +938,10 @@ func TestConditionConditionEvaluate(t *testing.T) {
nexthop := bgp.NewPathAttributeNextHop("10.0.0.1")
med := bgp.NewPathAttributeMultiExitDisc(0)
communities := bgp.NewPathAttributeCommunities([]uint32{
- strToCom("65001:100"),
- strToCom("65001:200"),
- strToCom("65001:300"),
- strToCom("65001:400"),
+ stringToCommunityValue("65001:100"),
+ stringToCommunityValue("65001:200"),
+ stringToCommunityValue("65001:300"),
+ stringToCommunityValue("65001:400"),
0x00000000,
0xFFFFFF01,
0xFFFFFF02,
@@ -1029,13 +1022,6 @@ func TestConditionConditionEvaluateWithOtherCondition(t *testing.T) {
log.SetLevel(log.DebugLevel)
- strToCom := func(s string) uint32 {
- elem := strings.Split(s, ":")
- asn, _ := strconv.ParseUint(elem[0], 10, 16)
- val, _ := strconv.ParseUint(elem[1], 10, 16)
- return uint32(asn<<16 | val)
- }
-
// setup
// create path
peer := &table.PeerInfo{AS: 65001, Address: net.ParseIP("10.0.0.1")}
@@ -1048,10 +1034,10 @@ func TestConditionConditionEvaluateWithOtherCondition(t *testing.T) {
nexthop := bgp.NewPathAttributeNextHop("10.0.0.1")
med := bgp.NewPathAttributeMultiExitDisc(0)
communities := bgp.NewPathAttributeCommunities([]uint32{
- strToCom("65001:100"),
- strToCom("65001:200"),
- strToCom("65001:300"),
- strToCom("65001:400"),
+ stringToCommunityValue("65001:100"),
+ stringToCommunityValue("65001:200"),
+ stringToCommunityValue("65001:300"),
+ stringToCommunityValue("65001:400"),
0x00000000,
0xFFFFFF01,
0xFFFFFF02,
@@ -1162,4 +1148,296 @@ func TestConditionConditionEvaluateWithOtherCondition(t *testing.T) {
assert.Equal(t, ROUTE_TYPE_NONE, pType)
assert.Equal(t, nil, newPath)
+}
+
+
+func TestPolicyMatchAndAddCommunities(t *testing.T) {
+
+ // create path
+ peer := &table.PeerInfo{AS: 65001, Address: net.ParseIP("10.0.0.1")}
+ origin := bgp.NewPathAttributeOrigin(0)
+ aspathParam := []bgp.AsPathParamInterface{bgp.NewAsPathParam(2, []uint16{65001})}
+ aspath := bgp.NewPathAttributeAsPath(aspathParam)
+ nexthop := bgp.NewPathAttributeNextHop("10.0.0.1")
+ med := bgp.NewPathAttributeMultiExitDisc(0)
+ pathAttributes := []bgp.PathAttributeInterface{origin, aspath, nexthop, med}
+ nlri := []bgp.NLRInfo{*bgp.NewNLRInfo(24, "10.10.0.101")}
+ withdrawnRoutes := []bgp.WithdrawnRoute{}
+ updateMsg := bgp.NewBGPUpdateMessage(withdrawnRoutes, pathAttributes, nlri)
+ path := table.ProcessMessage(updateMsg, peer)[0]
+ // create policy
+ ps := config.PrefixSet{
+ PrefixSetName: "ps1",
+ PrefixList: []config.Prefix{
+ config.Prefix{
+ Address: net.ParseIP("10.10.0.0"),
+ Masklength: 16,
+ MasklengthRange: "21..24",
+ }},
+ }
+ ns := config.NeighborSet{
+ NeighborSetName: "ns1",
+ NeighborInfoList: []config.NeighborInfo{
+ config.NeighborInfo{
+ Address: net.ParseIP("10.0.0.1"),
+ }},
+ }
+ ds := config.DefinedSets{
+ PrefixSetList: []config.PrefixSet{ps},
+ NeighborSetList: []config.NeighborSet{ns},
+ }
+
+ community := "65000:100"
+
+ s := config.Statement{
+ Name: "statement1",
+ Conditions: config.Conditions{
+ MatchPrefixSet: "ps1",
+ MatchNeighborSet: "ns1",
+ MatchSetOptions: config.MATCH_SET_OPTIONS_TYPE_ALL,
+ },
+ Actions: config.Actions{
+ AcceptRoute: true,
+ BgpActions: config.BgpActions{
+ SetCommunity: config.SetCommunity{
+ Communities: []string{community},
+ Options: "ADD",
+ },
+ },
+ },
+ }
+
+ pd := config.PolicyDefinition{"pd1", []config.Statement{s}}
+ pl := config.RoutingPolicy{ds, []config.PolicyDefinition{pd}}
+ //test
+ df := pl.DefinedSets
+ p := NewPolicy(pl.PolicyDefinitionList[0], df)
+ match, pType, newPath := p.Apply(path)
+ assert.Equal(t, true, match)
+ assert.Equal(t, ROUTE_TYPE_ACCEPT, pType)
+ assert.NotEqual(t, nil, newPath)
+ assert.Equal(t, []uint32{stringToCommunityValue(community)}, path.GetCommunities())
+}
+
+
+func TestPolicyMatchAndReplaceCommunities(t *testing.T) {
+
+ // create path
+ peer := &table.PeerInfo{AS: 65001, Address: net.ParseIP("10.0.0.1")}
+ origin := bgp.NewPathAttributeOrigin(0)
+ aspathParam := []bgp.AsPathParamInterface{bgp.NewAsPathParam(2, []uint16{65001})}
+ aspath := bgp.NewPathAttributeAsPath(aspathParam)
+ nexthop := bgp.NewPathAttributeNextHop("10.0.0.1")
+ med := bgp.NewPathAttributeMultiExitDisc(0)
+ communities := bgp.NewPathAttributeCommunities([]uint32{
+ stringToCommunityValue("65001:200"),
+ })
+ pathAttributes := []bgp.PathAttributeInterface{origin, aspath, nexthop, med, communities}
+ nlri := []bgp.NLRInfo{*bgp.NewNLRInfo(24, "10.10.0.101")}
+ withdrawnRoutes := []bgp.WithdrawnRoute{}
+ updateMsg := bgp.NewBGPUpdateMessage(withdrawnRoutes, pathAttributes, nlri)
+ path := table.ProcessMessage(updateMsg, peer)[0]
+ // create policy
+ ps := config.PrefixSet{
+ PrefixSetName: "ps1",
+ PrefixList: []config.Prefix{
+ config.Prefix{
+ Address: net.ParseIP("10.10.0.0"),
+ Masklength: 16,
+ MasklengthRange: "21..24",
+ }},
+ }
+ ns := config.NeighborSet{
+ NeighborSetName: "ns1",
+ NeighborInfoList: []config.NeighborInfo{
+ config.NeighborInfo{
+ Address: net.ParseIP("10.0.0.1"),
+ }},
+ }
+ ds := config.DefinedSets{
+ PrefixSetList: []config.PrefixSet{ps},
+ NeighborSetList: []config.NeighborSet{ns},
+ }
+
+ community := "65000:100"
+
+ s := config.Statement{
+ Name: "statement1",
+ Conditions: config.Conditions{
+ MatchPrefixSet: "ps1",
+ MatchNeighborSet: "ns1",
+ MatchSetOptions: config.MATCH_SET_OPTIONS_TYPE_ALL,
+ },
+ Actions: config.Actions{
+ AcceptRoute: true,
+ BgpActions: config.BgpActions{
+ SetCommunity: config.SetCommunity{
+ Communities: []string{community},
+ Options: "REPLACE",
+ },
+ },
+ },
+ }
+
+ pd := config.PolicyDefinition{"pd1", []config.Statement{s}}
+ pl := config.RoutingPolicy{ds, []config.PolicyDefinition{pd}}
+ //test
+ df := pl.DefinedSets
+ p := NewPolicy(pl.PolicyDefinitionList[0], df)
+ match, pType, newPath := p.Apply(path)
+ assert.Equal(t, true, match)
+ assert.Equal(t, ROUTE_TYPE_ACCEPT, pType)
+ assert.NotEqual(t, nil, newPath)
+ assert.Equal(t, []uint32{stringToCommunityValue(community)}, path.GetCommunities())
+}
+
+func TestPolicyMatchAndRemoveCommunities(t *testing.T) {
+
+ // create path
+ community1 := "65000:100"
+ community2 := "65000:200"
+ peer := &table.PeerInfo{AS: 65001, Address: net.ParseIP("10.0.0.1")}
+ origin := bgp.NewPathAttributeOrigin(0)
+ aspathParam := []bgp.AsPathParamInterface{bgp.NewAsPathParam(2, []uint16{65001})}
+ aspath := bgp.NewPathAttributeAsPath(aspathParam)
+ nexthop := bgp.NewPathAttributeNextHop("10.0.0.1")
+ med := bgp.NewPathAttributeMultiExitDisc(0)
+ communities := bgp.NewPathAttributeCommunities([]uint32{
+ stringToCommunityValue(community1),
+ stringToCommunityValue(community2),
+ })
+ pathAttributes := []bgp.PathAttributeInterface{origin, aspath, nexthop, med, communities}
+ nlri := []bgp.NLRInfo{*bgp.NewNLRInfo(24, "10.10.0.101")}
+ withdrawnRoutes := []bgp.WithdrawnRoute{}
+ updateMsg := bgp.NewBGPUpdateMessage(withdrawnRoutes, pathAttributes, nlri)
+ path := table.ProcessMessage(updateMsg, peer)[0]
+ // create policy
+ ps := config.PrefixSet{
+ PrefixSetName: "ps1",
+ PrefixList: []config.Prefix{
+ config.Prefix{
+ Address: net.ParseIP("10.10.0.0"),
+ Masklength: 16,
+ MasklengthRange: "21..24",
+ }},
+ }
+ ns := config.NeighborSet{
+ NeighborSetName: "ns1",
+ NeighborInfoList: []config.NeighborInfo{
+ config.NeighborInfo{
+ Address: net.ParseIP("10.0.0.1"),
+ }},
+ }
+ ds := config.DefinedSets{
+ PrefixSetList: []config.PrefixSet{ps},
+ NeighborSetList: []config.NeighborSet{ns},
+ }
+
+ s := config.Statement{
+ Name: "statement1",
+ Conditions: config.Conditions{
+ MatchPrefixSet: "ps1",
+ MatchNeighborSet: "ns1",
+ MatchSetOptions: config.MATCH_SET_OPTIONS_TYPE_ALL,
+ },
+ Actions: config.Actions{
+ AcceptRoute: true,
+ BgpActions: config.BgpActions{
+ SetCommunity: config.SetCommunity{
+ Communities: []string{community1},
+ Options: "REMOVE",
+ },
+ },
+ },
+ }
+
+ pd := config.PolicyDefinition{"pd1", []config.Statement{s}}
+ pl := config.RoutingPolicy{ds, []config.PolicyDefinition{pd}}
+ //test
+ df := pl.DefinedSets
+ p := NewPolicy(pl.PolicyDefinitionList[0], df)
+ match, pType, newPath := p.Apply(path)
+ assert.Equal(t, true, match)
+ assert.Equal(t, ROUTE_TYPE_ACCEPT, pType)
+ assert.NotEqual(t, nil, newPath)
+ assert.Equal(t, []uint32{stringToCommunityValue(community2)}, path.GetCommunities())
+}
+
+func TestPolicyMatchAndClearCommunities(t *testing.T) {
+
+ // create path
+ community1 := "65000:100"
+ community2 := "65000:200"
+ peer := &table.PeerInfo{AS: 65001, Address: net.ParseIP("10.0.0.1")}
+ origin := bgp.NewPathAttributeOrigin(0)
+ aspathParam := []bgp.AsPathParamInterface{bgp.NewAsPathParam(2, []uint16{65001})}
+ aspath := bgp.NewPathAttributeAsPath(aspathParam)
+ nexthop := bgp.NewPathAttributeNextHop("10.0.0.1")
+ med := bgp.NewPathAttributeMultiExitDisc(0)
+ communities := bgp.NewPathAttributeCommunities([]uint32{
+ stringToCommunityValue(community1),
+ stringToCommunityValue(community2),
+ })
+ pathAttributes := []bgp.PathAttributeInterface{origin, aspath, nexthop, med, communities}
+ nlri := []bgp.NLRInfo{*bgp.NewNLRInfo(24, "10.10.0.101")}
+ withdrawnRoutes := []bgp.WithdrawnRoute{}
+ updateMsg := bgp.NewBGPUpdateMessage(withdrawnRoutes, pathAttributes, nlri)
+ path := table.ProcessMessage(updateMsg, peer)[0]
+ // create policy
+ ps := config.PrefixSet{
+ PrefixSetName: "ps1",
+ PrefixList: []config.Prefix{
+ config.Prefix{
+ Address: net.ParseIP("10.10.0.0"),
+ Masklength: 16,
+ MasklengthRange: "21..24",
+ }},
+ }
+ ns := config.NeighborSet{
+ NeighborSetName: "ns1",
+ NeighborInfoList: []config.NeighborInfo{
+ config.NeighborInfo{
+ Address: net.ParseIP("10.0.0.1"),
+ }},
+ }
+ ds := config.DefinedSets{
+ PrefixSetList: []config.PrefixSet{ps},
+ NeighborSetList: []config.NeighborSet{ns},
+ }
+
+ s := config.Statement{
+ Name: "statement1",
+ Conditions: config.Conditions{
+ MatchPrefixSet: "ps1",
+ MatchNeighborSet: "ns1",
+ MatchSetOptions: config.MATCH_SET_OPTIONS_TYPE_ALL,
+ },
+ Actions: config.Actions{
+ AcceptRoute: true,
+ BgpActions: config.BgpActions{
+ SetCommunity: config.SetCommunity{
+ Communities: []string{community1},
+ Options: "NULL",
+ },
+ },
+ },
+ }
+
+ pd := config.PolicyDefinition{"pd1", []config.Statement{s}}
+ pl := config.RoutingPolicy{ds, []config.PolicyDefinition{pd}}
+ //test
+ df := pl.DefinedSets
+ p := NewPolicy(pl.PolicyDefinitionList[0], df)
+ match, pType, newPath := p.Apply(path)
+ assert.Equal(t, true, match)
+ assert.Equal(t, ROUTE_TYPE_ACCEPT, pType)
+ assert.NotEqual(t, nil, newPath)
+ assert.Equal(t, []uint32{}, path.GetCommunities())
+}
+
+func stringToCommunityValue(comStr string) uint32 {
+ elem := strings.Split(comStr, ":")
+ asn, _ := strconv.ParseUint(elem[0], 10, 16)
+ val, _ := strconv.ParseUint(elem[1], 10, 16)
+ return uint32(asn<<16 | val)
} \ No newline at end of file
generated by cgit v1.2.3 (git 2.39.1) at 2024-11-15 16:43:39 +0000