summaryrefslogtreecommitdiffhomepage
path: root/policy/policy.go
diff options
context:
space:
mode:
Diffstat (limited to 'policy/policy.go')
-rw-r--r--policy/policy.go640
1 files changed, 415 insertions, 225 deletions
diff --git a/policy/policy.go b/policy/policy.go
index 0a8af9b8..b0eb3809 100644
--- a/policy/policy.go
+++ b/policy/policy.go
@@ -62,7 +62,7 @@ type Policy struct {
}
func NewPolicy(pd config.PolicyDefinition, ds config.DefinedSets) *Policy {
- stmtList := pd.StatementList
+ stmtList := pd.Statements.StatementList
st := make([]*Statement, 0)
p := &Policy{
Name: pd.Name,
@@ -73,14 +73,16 @@ func NewPolicy(pd config.PolicyDefinition, ds config.DefinedSets) *Policy {
conditions := make([]Condition, 0)
// prefix match
- prefixSetName := statement.Conditions.MatchPrefixSet
- pc := NewPrefixCondition(prefixSetName, ds.PrefixSetList)
- conditions = append(conditions, pc)
+ pc := NewPrefixCondition(statement.Conditions.MatchPrefixSet, ds.PrefixSets.PrefixSetList)
+ if pc != nil {
+ conditions = append(conditions, pc)
+ }
// neighbor match
- neighborSetName := statement.Conditions.MatchNeighborSet
- nc := NewNeighborCondition(neighborSetName, ds.NeighborSetList)
- conditions = append(conditions, nc)
+ nc := NewNeighborCondition(statement.Conditions.MatchNeighborSet, ds.NeighborSets.NeighborSetList)
+ if nc != nil {
+ conditions = append(conditions, nc)
+ }
// AsPathLengthCondition
c := statement.Conditions.BgpConditions.AsPathLength
@@ -89,23 +91,22 @@ func NewPolicy(pd config.PolicyDefinition, ds config.DefinedSets) *Policy {
conditions = append(conditions, ac)
}
+ bgpDefset := &ds.BgpDefinedSets
+ bgpConditions := &statement.Conditions.BgpConditions
// AsPathCondition
- asPathSetName := statement.Conditions.BgpConditions.MatchAsPathSet
- asc := NewAsPathCondition(asPathSetName, ds.BgpDefinedSets.AsPathSetList)
+ asc := NewAsPathCondition(bgpConditions.MatchAsPathSet, bgpDefset.AsPathSets.AsPathSetList)
if asc != nil {
conditions = append(conditions, asc)
}
// CommunityCondition
- communitySetName := statement.Conditions.BgpConditions.MatchCommunitySet
- cc := NewCommunityCondition(communitySetName, ds.BgpDefinedSets.CommunitySetList)
+ cc := NewCommunityCondition(bgpConditions.MatchCommunitySet, bgpDefset.CommunitySets.CommunitySetList)
if cc != nil {
conditions = append(conditions, cc)
}
// ExtendedCommunityCondition
- extCommunitySetName := statement.Conditions.BgpConditions.MatchExtCommunitySet
- ecc := NewExtCommunityCondition(extCommunitySetName, ds.BgpDefinedSets.ExtCommunitySetList)
+ ecc := NewExtCommunityCondition(bgpConditions.MatchExtCommunitySet, bgpDefset.ExtCommunitySets.ExtCommunitySetList)
if ecc != nil {
conditions = append(conditions, ecc)
}
@@ -137,7 +138,6 @@ func NewPolicy(pd config.PolicyDefinition, ds config.DefinedSets) *Policy {
Conditions: conditions,
routingAction: ra,
modificationActions: mda,
- MatchSetOptions: statement.Conditions.MatchSetOptions,
}
st = append(st, s)
@@ -151,52 +151,18 @@ type Statement struct {
Conditions []Condition
routingAction *RoutingAction
modificationActions []Action
- MatchSetOptions config.MatchSetOptionsType
}
// evaluate each condition in the statement according to MatchSetOptions
func (s *Statement) evaluate(p *table.Path) bool {
- optionType := s.MatchSetOptions
-
- result := false
- if optionType == config.MATCH_SET_OPTIONS_TYPE_ALL {
- result = true
- }
-
for _, condition := range s.Conditions {
-
r := condition.evaluate(p)
-
- switch optionType {
- case config.MATCH_SET_OPTIONS_TYPE_ALL:
- result = result && r
- if !result {
- return false
- }
-
- case config.MATCH_SET_OPTIONS_TYPE_ANY:
- result = result || r
- if result {
- return true
- }
-
- case config.MATCH_SET_OPTIONS_TYPE_INVERT:
- result = result || r
- if result {
- return false
- }
-
- default:
+ if !r {
return false
}
}
-
- if optionType == config.MATCH_SET_OPTIONS_TYPE_INVERT {
- return !result
- } else {
- return result
- }
+ return true
}
type Condition interface {
@@ -215,15 +181,21 @@ type PrefixCondition struct {
DefaultCondition
PrefixConditionName string
PrefixList []Prefix
+ MatchOption config.MatchSetOptionsRestrictedType
}
-func NewPrefixCondition(prefixSetName string, defPrefixList []config.PrefixSet) *PrefixCondition {
+func NewPrefixCondition(matchPref config.MatchPrefixSet, defPrefixList []config.PrefixSet) *PrefixCondition {
+
+ prefixSetName := matchPref.PrefixSet
+ options := matchPref.MatchSetOptions
prefixList := make([]Prefix, 0)
for _, ps := range defPrefixList {
if ps.PrefixSetName == prefixSetName {
- for _, pl := range ps.PrefixList {
- prefix, e := NewPrefix(pl.Address, pl.Masklength, pl.MasklengthRange)
+ for _, prefix := range ps.PrefixList {
+ addr := prefix.IpPrefix.IP
+ maskLength, _ := prefix.IpPrefix.Mask.Size()
+ prefix, e := NewPrefix(addr, uint8(maskLength), prefix.MasklengthRange)
if e != nil {
log.WithFields(log.Fields{
"Topic": "Policy",
@@ -237,13 +209,17 @@ func NewPrefixCondition(prefixSetName string, defPrefixList []config.PrefixSet)
}
}
+ if len(prefixList) == 0 {
+ return nil
+ }
+
pc := &PrefixCondition{
PrefixConditionName: prefixSetName,
PrefixList: prefixList,
+ MatchOption: options,
}
return pc
-
}
// compare prefixes in this condition and nlri of path and
@@ -256,26 +232,38 @@ func (c *PrefixCondition) evaluate(path *table.Path) bool {
return true
}
+ result := false
for _, cp := range c.PrefixList {
if ipPrefixCalculate(path, cp) {
- log.WithFields(log.Fields{
- "Topic": "Policy",
- "Prefix": cp.Address.String(),
- }).Debug("prefix matched")
-
- return true
+ result = true
+ break
}
}
- return false
+ if c.MatchOption == config.MATCH_SET_OPTIONS_RESTRICTED_TYPE_INVERT {
+ result = !result
+ }
+
+ log.WithFields(log.Fields{
+ "Topic": "Policy",
+ "Condition": "prefix",
+ "Path": path,
+ "Matched": result,
+ }).Debug("evaluate prefix")
+
+ return result
}
type NeighborCondition struct {
DefaultCondition
NeighborConditionName string
NeighborList []net.IP
+ MatchOption config.MatchSetOptionsRestrictedType
}
-func NewNeighborCondition(neighborSetName string, defNeighborSetList []config.NeighborSet) *NeighborCondition {
+func NewNeighborCondition(matchNeighborSet config.MatchNeighborSet, defNeighborSetList []config.NeighborSet) *NeighborCondition {
+
+ neighborSetName := matchNeighborSet.NeighborSet
+ options := matchNeighborSet.MatchSetOptions
neighborList := make([]net.IP, 0)
for _, neighborSet := range defNeighborSetList {
@@ -286,9 +274,14 @@ func NewNeighborCondition(neighborSetName string, defNeighborSetList []config.Ne
}
}
+ if len(neighborList) == 0 {
+ return nil
+ }
+
nc := &NeighborCondition{
NeighborConditionName: neighborSetName,
NeighborList: neighborList,
+ MatchOption: options,
}
return nc
@@ -304,18 +297,27 @@ func (c *NeighborCondition) evaluate(path *table.Path) bool {
return true
}
+ sAddr := path.GetSource().Address
+ result := false
for _, neighbor := range c.NeighborList {
- cAddr := neighbor
- pAddr := path.GetSource().Address
- if pAddr.Equal(cAddr) {
- log.WithFields(log.Fields{
- "Topic": "Policy",
- "NeighborAddress": pAddr.String(),
- }).Debug("neighbor matched")
- return true
+ if sAddr.Equal(neighbor) {
+ result = true
+ break
}
}
- return false
+
+ if c.MatchOption == config.MATCH_SET_OPTIONS_RESTRICTED_TYPE_INVERT {
+ result = !result
+ }
+
+ log.WithFields(log.Fields{
+ "Topic": "Policy",
+ "Condition": "neighbor",
+ "NeighborAddress": sAddr.String(),
+ "Matched": result,
+ }).Debug("evaluate neighbor")
+
+ return result
}
type AsPathLengthCondition struct {
@@ -368,23 +370,23 @@ func (c *AsPathLengthCondition) evaluate(path *table.Path) bool {
case ATTRIBUTE_LE:
result = c.Value >= length
default:
- return false
+ result = false
}
- if result {
- log.WithFields(log.Fields{
- "Topic": "Policy",
- "Condition": "aspath length",
- "Reason": c.Operator,
- }).Debug("condition matched")
- }
+ log.WithFields(log.Fields{
+ "Topic": "Policy",
+ "Condition": "aspath length",
+ "Reason": c.Operator,
+ "Matched": result,
+ }).Debug("evaluate aspath length")
return result
}
type AsPathCondition struct {
DefaultCondition
- AsPathList []*AsPathElement
+ AsPathList []*AsPathElement
+ MatchOption config.MatchSetOptionsType
}
type AsnPos int
@@ -407,14 +409,16 @@ type AsPathElement struct {
// - ^100$ (from as100 and originated by as100)
// - 100$ (originated by as100)
// - 100 (from or through or originated by as100)
-func NewAsPathCondition(asPathSetName string, defAsPathSetList []config.AsPathSet) *AsPathCondition {
+func NewAsPathCondition(matchSet config.MatchAsPathSet, defAsPathSetList []config.AsPathSet) *AsPathCondition {
- regAsn, _ := regexp.Compile("^(\\^?)([0-9]+)(\\$?)$")
+ asPathSetName := matchSet.AsPathSet
+ options := matchSet.MatchSetOptions
+ regAsn, _ := regexp.Compile("^(\\^?)([0-9]+)(\\$?)$")
asPathList := make([]*AsPathElement, 0)
for _, asPathSet := range defAsPathSetList {
if asPathSet.AsPathSetName == asPathSetName {
- for _, as := range asPathSet.AsPathSetMembers {
+ for _, as := range asPathSet.AsPathSetMember {
if regAsn.MatchString(as) {
group := regAsn.FindStringSubmatch(as)
@@ -452,7 +456,8 @@ func NewAsPathCondition(asPathSetName string, defAsPathSetList []config.AsPathSe
}
c := &AsPathCondition{
- AsPathList: asPathList,
+ AsPathList: asPathList,
+ MatchOption: options,
}
return c
}
@@ -460,19 +465,14 @@ func NewAsPathCondition(asPathSetName string, defAsPathSetList []config.AsPathSe
return nil
}
-// compare AS_PATH in the message's AS_PATH attribute with
-// the one in condition.
-func (c *AsPathCondition) evaluate(path *table.Path) bool {
-
- aspath := path.GetAsSeqList()
-
- if len(aspath) == 0 {
- return false
+func (c *AsPathCondition) checkMembers(aspath []uint32, checkAll bool) bool {
+ result := false
+ if checkAll {
+ result = true
}
- matched := false
for _, member := range c.AsPathList {
-
+ matched := false
switch member.postiion {
case AS_FROM:
matched = aspath[0] == member.asn
@@ -497,17 +497,57 @@ func (c *AsPathCondition) evaluate(path *table.Path) bool {
"Condition": "aspath length",
"ASN": member.asn,
"Position": member.postiion,
- }).Debug("condition matched")
- return true
+ }).Debug("aspath condition matched")
+
+ if !checkAll {
+ result = true
+ break
+ }
+
+ } else {
+ if checkAll {
+ result = false
+ break
+ }
}
+ }
+
+ return result
+}
+
+// compare AS_PATH in the message's AS_PATH attribute with
+// the one in condition.
+func (c *AsPathCondition) evaluate(path *table.Path) bool {
+
+ aspath := path.GetAsSeqList()
+
+ if len(aspath) == 0 {
+ return false
+ }
+ result := false
+ if c.MatchOption == config.MATCH_SET_OPTIONS_TYPE_ALL {
+ result = c.checkMembers(aspath, true)
+ } else if c.MatchOption == config.MATCH_SET_OPTIONS_TYPE_ANY {
+ result = c.checkMembers(aspath, false)
+ } else if c.MatchOption == config.MATCH_SET_OPTIONS_TYPE_INVERT {
+ result = !c.checkMembers(aspath, false)
}
- return false
+
+ log.WithFields(log.Fields{
+ "Topic": "Policy",
+ "Condition": "aspath",
+ "MatchOption": c.MatchOption,
+ "Matched": result,
+ }).Debug("evaluate aspath")
+
+ return result
}
type CommunityCondition struct {
DefaultCondition
CommunityList []*CommunityElement
+ MatchOption config.MatchSetOptionsType
}
const (
@@ -535,12 +575,15 @@ 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, defCommunitySetList []config.CommunitySet) *CommunityCondition {
+func NewCommunityCondition(matchSet config.MatchCommunitySet, defCommunitySetList []config.CommunitySet) *CommunityCondition {
+
+ communitySetName := matchSet.CommunitySet
+ options := matchSet.MatchSetOptions
communityList := make([]*CommunityElement, 0)
for _, communitySet := range defCommunitySetList {
if communitySet.CommunitySetName == communitySetName {
- for _, c := range communitySet.CommunityMembers {
+ for _, c := range communitySet.CommunityMember {
e := &CommunityElement{
isRegExp: false,
@@ -567,6 +610,7 @@ func NewCommunityCondition(communitySetName string, defCommunitySetList []config
c := &CommunityCondition{
CommunityList: communityList,
+ MatchOption: options,
}
return c
}
@@ -631,14 +675,11 @@ func getCommunityValue(comStr string) (bool, uint32) {
return false, 0
}
-// compare community in the message's attribute with
-// the one in the condition.
-func (c *CommunityCondition) evaluate(path *table.Path) bool {
+func (c *CommunityCondition) checkMembers(communities []uint32, checkAll bool) bool {
- communities := path.GetCommunities()
-
- if len(communities) == 0 {
- return false
+ result := false
+ if checkAll {
+ result = true
}
makeStr := func(c uint32) string {
@@ -690,15 +731,62 @@ func (c *CommunityCondition) evaluate(path *table.Path) bool {
"Community": makeStr(communities[idx]),
}).Debug("condition matched")
- return true
+ if !checkAll {
+ result = true
+ break
+ }
+
+ } else {
+ if checkAll {
+ result = false
+ break
+ }
}
}
- return false
+
+ return result
+
+}
+
+// compare community in the message's attribute with
+// the one in the condition.
+func (c *CommunityCondition) evaluate(path *table.Path) bool {
+
+ communities := path.GetCommunities()
+
+ if len(communities) == 0 {
+ log.WithFields(log.Fields{
+ "Topic": "Policy",
+ "Condition": "community",
+ "MatchOption": c.MatchOption,
+ "Matched": false,
+ }).Debug("community length is zero")
+ return false
+ }
+
+ result := false
+ if c.MatchOption == config.MATCH_SET_OPTIONS_TYPE_ALL {
+ result = c.checkMembers(communities, true)
+ } else if c.MatchOption == config.MATCH_SET_OPTIONS_TYPE_ANY {
+ result = c.checkMembers(communities, false)
+ } else if c.MatchOption == config.MATCH_SET_OPTIONS_TYPE_INVERT {
+ result = !c.checkMembers(communities, false)
+ }
+
+ log.WithFields(log.Fields{
+ "Topic": "Policy",
+ "Condition": "community",
+ "MatchOption": c.MatchOption,
+ "Matched": result,
+ }).Debug("evaluate community")
+
+ return result
}
type ExtCommunityCondition struct {
DefaultCondition
ExtCommunityList []*ExtCommunityElement
+ MatchOption config.MatchSetOptionsType
}
type ExtCommunityElement struct {
@@ -711,15 +799,19 @@ type ExtCommunityElement struct {
regExp *regexp.Regexp
}
-func NewExtCommunityCondition(extComSetName string, defExtComSetList []config.ExtCommunitySet) *ExtCommunityCondition {
+func NewExtCommunityCondition(matchSet config.MatchExtCommunitySet, defExtComSetList []config.ExtCommunitySet) *ExtCommunityCondition {
+
+ extComSetName := matchSet.ExtCommunitySet
+ option := matchSet.MatchSetOptions
+
extCommunityElemList := make([]*ExtCommunityElement, 0)
for _, extComSet := range defExtComSetList {
if extComSet.ExtCommunitySetName == extComSetName {
- for _, c := range extComSet.ExtCommunityMembers {
+ for _, c := range extComSet.ExtCommunityMember {
matchAll := false
e := &ExtCommunityElement{
isRegExp: false,
- comStr: c,
+ comStr: c,
}
matchType, val := getECommunitySubType(c)
if !matchType {
@@ -770,6 +862,7 @@ func NewExtCommunityCondition(extComSetName string, defExtComSetList []config.Ex
}
ce := &ExtCommunityCondition{
ExtCommunityList: extCommunityElemList,
+ MatchOption: option,
}
return ce
}
@@ -827,9 +920,13 @@ func getECommunityElem(gAdmin string) (bool, bgp.ExtendedCommunityAttrType, inte
return false, bgp.ExtendedCommunityAttrType(0xFF), nil
}
-// compare extended community in the message's attribute with
-// the one in the condition.
-func (c *ExtCommunityCondition) evaluate(path *table.Path) bool {
+func (c *ExtCommunityCondition) checkMembers(eCommunities []interface{}, checkAll bool) bool {
+
+ result := false
+ if checkAll {
+ result = true
+ }
+
makeAs4Str := func(ec *ExtCommunityElement) string {
t := ec.ecType
str := fmt.Sprintf("%d", ec.localAdmin)
@@ -857,10 +954,6 @@ func (c *ExtCommunityCondition) evaluate(path *table.Path) bool {
}
return subStr
}
- eCommunities := path.GetExtCommunities()
- if len(eCommunities) == 0 || c == nil {
- return false
- }
matched := false
matchStr := ""
@@ -890,15 +983,59 @@ func (c *ExtCommunityCondition) evaluate(path *table.Path) bool {
}
if matched {
log.WithFields(log.Fields{
- "Topic": "Policy",
- "Condition": "Extended Community",
+ "Topic": "Policy",
+ "Condition": "Extended Community",
"Extended Community": matchStr,
}).Debug("condition matched")
- return true
+ if !checkAll {
+ result = true
+ break
+ }
+
+ } else {
+ if checkAll {
+ result = false
+ break
+ }
}
}
- return false
+ return result
+}
+
+// compare extended community in the message's attribute with
+// the one in the condition.
+func (c *ExtCommunityCondition) evaluate(path *table.Path) bool {
+
+ eCommunities := path.GetExtCommunities()
+ if len(eCommunities) == 0 {
+ log.WithFields(log.Fields{
+ "Topic": "Policy",
+ "Condition": "extended community",
+ "Matched": false,
+ "Path": path,
+ }).Debug("extended community length is zero")
+ return false
+ }
+
+ result := false
+ if c.MatchOption == config.MATCH_SET_OPTIONS_TYPE_ALL {
+ result = c.checkMembers(eCommunities, true)
+ } else if c.MatchOption == config.MATCH_SET_OPTIONS_TYPE_ANY {
+ result = c.checkMembers(eCommunities, false)
+ } else if c.MatchOption == config.MATCH_SET_OPTIONS_TYPE_INVERT {
+ result = !c.checkMembers(eCommunities, false)
+ }
+
+ log.WithFields(log.Fields{
+ "Topic": "Policy",
+ "Condition": "extended community",
+ "MatchOption": c.MatchOption,
+ "Matched": result,
+ "Path": path,
+ }).Debug("evaluate extended community")
+
+ return result
}
type Action interface {
@@ -919,7 +1056,7 @@ type RoutingAction struct {
func NewRoutingAction(action config.Actions) *RoutingAction {
r := &RoutingAction{
- AcceptRoute: action.AcceptRoute,
+ AcceptRoute: action.RouteDisposition.AcceptRoute,
}
return r
}
@@ -932,12 +1069,10 @@ func (r *RoutingAction) apply(path *table.Path) *table.Path {
}
}
-type ActionType int
-
type CommunityAction struct {
DefaultAction
Values []uint32
- action ActionType
+ action config.BgpSetCommunityOptionType
}
const (
@@ -953,13 +1088,13 @@ const (
func NewCommunityAction(action config.SetCommunity) *CommunityAction {
m := &CommunityAction{}
-
- if len(action.Communities) == 0 && action.Options != COMMUNITY_ACTION_NULL {
+ communities := action.SetCommunityMethod.Communities
+ if len(communities) == 0 && action.Options != COMMUNITY_ACTION_REPLACE {
return nil
}
- values := make([]uint32, len(action.Communities))
- for i, com := range action.Communities {
+ values := make([]uint32, len(communities))
+ for i, com := range communities {
matched, value := getCommunityValue(com)
if matched {
values[i] = value
@@ -980,8 +1115,6 @@ func NewCommunityAction(action config.SetCommunity) *CommunityAction {
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",
@@ -1002,12 +1135,20 @@ func (a *CommunityAction) apply(path *table.Path) *table.Path {
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()
}
+
+ log.WithFields(log.Fields{
+ "Topic": "Policy",
+ "Action": "community",
+ "Values": list,
+ "Method": a.action,
+ }).Debug("community action applied")
+
return path
}
+type ActionType int
+
type MedAction struct {
DefaultAction
Value int64
@@ -1084,6 +1225,13 @@ func (a *MedAction) apply(path *table.Path) *table.Path {
"Topic": "Policy",
"Type": "Med Action",
}).Warn(err)
+ } else {
+ log.WithFields(log.Fields{
+ "Topic": "Policy",
+ "Action": "med",
+ "Value": a.Value,
+ "ActionType": a.action,
+ }).Debug("med action applied")
}
return path
@@ -1149,6 +1297,14 @@ func (a *AsPathPrependAction) apply(path *table.Path) *table.Path {
}
path.PrependAsn(asn, a.repeat)
+
+ log.WithFields(log.Fields{
+ "Topic": "Policy",
+ "Action": "aspath prepend",
+ "ASN": asn,
+ "Repeat": a.repeat,
+ }).Debug("aspath prepend action applied")
+
return path
}
@@ -1216,7 +1372,7 @@ func (p *Policy) Apply(path *table.Path) (bool, RouteType, *table.Path) {
"Topic": "Policy",
"Path": path,
"PolicyName": p.Name,
- }).Debug("statement.Conditions.evaluate : ", result)
+ }).Debug("statement evaluate : ", result)
var p *table.Path
if result {
@@ -1290,24 +1446,49 @@ const (
)
const (
- OPTIONS_ALL string = "ALL"
- OPTIONS_ANY = "ANY"
+ OPTIONS_ANY string = "ANY"
+ OPTIONS_ALL = "ALL"
OPTIONS_INVERT = "INVERT"
)
func MatchSetOptionToString(option config.MatchSetOptionsType) string {
- var op string
+ op := OPTIONS_ANY
switch option {
case config.MATCH_SET_OPTIONS_TYPE_ALL:
op = OPTIONS_ALL
- case config.MATCH_SET_OPTIONS_TYPE_ANY:
- op = OPTIONS_ANY
case config.MATCH_SET_OPTIONS_TYPE_INVERT:
op = OPTIONS_INVERT
}
return op
}
+func MatchSetOptionsRestrictedToString(option config.MatchSetOptionsRestrictedType) string {
+ op := OPTIONS_ANY
+ if option == config.MATCH_SET_OPTIONS_RESTRICTED_TYPE_INVERT {
+ op = OPTIONS_INVERT
+ }
+ return op
+}
+
+func MatchSetOptionsToType(option string) config.MatchSetOptionsType {
+ op := config.MATCH_SET_OPTIONS_TYPE_ANY
+ switch option {
+ case OPTIONS_ALL:
+ op = config.MATCH_SET_OPTIONS_TYPE_ALL
+ case OPTIONS_INVERT:
+ op = config.MATCH_SET_OPTIONS_TYPE_INVERT
+ }
+ return op
+}
+
+func MatchSetOptionsRestrictedToType(option string) config.MatchSetOptionsRestrictedType {
+ op := config.MATCH_SET_OPTIONS_RESTRICTED_TYPE_ANY
+ if option == OPTIONS_INVERT {
+ op = config.MATCH_SET_OPTIONS_RESTRICTED_TYPE_INVERT
+ }
+ return op
+}
+
// find index PrefixSet of request from PrefixSet of configuration file.
// Return the idxPrefixSet of the location where the name of PrefixSet matches,
// and idxPrefix of the location where element of PrefixSet matches
@@ -1321,7 +1502,7 @@ func IndexOfPrefixSet(conPrefixSetList []config.PrefixSet, reqPrefixSet config.P
return idxPrefixSet, idxPrefix
}
for j, conPrefix := range conPrefixSet.PrefixList {
- if reflect.DeepEqual(conPrefix.Address, reqPrefixSet.PrefixList[0].Address) && conPrefix.Masklength == reqPrefixSet.PrefixList[0].Masklength &&
+ if reflect.DeepEqual(conPrefix.IpPrefix, reqPrefixSet.PrefixList[0].IpPrefix) &&
conPrefix.MasklengthRange == reqPrefixSet.PrefixList[0].MasklengthRange {
idxPrefix = j
return idxPrefixSet, idxPrefix
@@ -1364,11 +1545,11 @@ func IndexOfAsPathSet(conAsPathSetList []config.AsPathSet, reqAsPathSet config.A
for i, conAsPathSet := range conAsPathSetList {
if conAsPathSet.AsPathSetName == reqAsPathSet.AsPathSetName {
idxAsPathSet = i
- if len(reqAsPathSet.AsPathSetMembers) == 0 {
+ if len(reqAsPathSet.AsPathSetMember) == 0 {
return idxAsPathSet, idxAsPath
}
- for j, conAsPath := range conAsPathSet.AsPathSetMembers {
- if conAsPath == reqAsPathSet.AsPathSetMembers[0] {
+ for j, conAsPath := range conAsPathSet.AsPathSetMember {
+ if conAsPath == reqAsPathSet.AsPathSetMember[0] {
idxAsPath = j
return idxAsPathSet, idxAsPath
}
@@ -1387,11 +1568,11 @@ func IndexOfCommunitySet(conCommunitySetList []config.CommunitySet, reqCommunity
for i, conCommunitySet := range conCommunitySetList {
if conCommunitySet.CommunitySetName == reqCommunitySet.CommunitySetName {
idxCommunitySet = i
- if len(reqCommunitySet.CommunityMembers) == 0 {
+ if len(reqCommunitySet.CommunityMember) == 0 {
return idxCommunitySet, idxCommunity
}
- for j, conCommunity := range conCommunitySet.CommunityMembers {
- if conCommunity == reqCommunitySet.CommunityMembers[0] {
+ for j, conCommunity := range conCommunitySet.CommunityMember {
+ if conCommunity == reqCommunitySet.CommunityMember[0] {
idxCommunity = j
return idxCommunitySet, idxCommunity
}
@@ -1410,11 +1591,11 @@ func IndexOfExtCommunitySet(conExtCommunitySetList []config.ExtCommunitySet, req
for i, conExtCommunitySet := range conExtCommunitySetList {
if conExtCommunitySet.ExtCommunitySetName == reqExtCommunitySet.ExtCommunitySetName {
idxExtCommunitySet = i
- if len(reqExtCommunitySet.ExtCommunityMembers) == 0 {
+ if len(reqExtCommunitySet.ExtCommunityMember) == 0 {
return idxExtCommunitySet, idxExtCommunity
}
- for j, conExtCommunity := range conExtCommunitySet.ExtCommunityMembers {
- if conExtCommunity == reqExtCommunitySet.ExtCommunityMembers[0] {
+ for j, conExtCommunity := range conExtCommunitySet.ExtCommunityMember {
+ if conExtCommunity == reqExtCommunitySet.ExtCommunityMember[0] {
idxExtCommunity = j
return idxExtCommunitySet, idxExtCommunity
}
@@ -1433,11 +1614,11 @@ func IndexOfPolicyDefinition(conPolicyList []config.PolicyDefinition, reqPolicy
for i, conPolicy := range conPolicyList {
if conPolicy.Name == reqPolicy.Name {
idxPolicyDefinition = i
- if reqPolicy.StatementList == nil {
+ if reqPolicy.Statements.StatementList == nil {
return idxPolicyDefinition, idxStatement
}
- for j, conStatement := range conPolicy.StatementList {
- if conStatement.Name == reqPolicy.StatementList[0].Name {
+ for j, conStatement := range conPolicy.Statements.StatementList {
+ if conStatement.Name == reqPolicy.Statements.StatementList[0].Name {
idxStatement = j
return idxPolicyDefinition, idxStatement
}
@@ -1450,9 +1631,13 @@ func IndexOfPolicyDefinition(conPolicyList []config.PolicyDefinition, reqPolicy
func PrefixSetToApiStruct(ps config.PrefixSet) *api.PrefixSet {
resPrefixList := make([]*api.Prefix, 0)
for _, p := range ps.PrefixList {
+
+ addr := p.IpPrefix.IP
+ length, _ := p.IpPrefix.Mask.Size()
+
resPrefix := &api.Prefix{
- Address: p.Address.String(),
- MaskLength: uint32(p.Masklength),
+ Address: addr.String(),
+ MaskLength: uint32(length),
MaskLengthRange: p.MasklengthRange,
}
resPrefixList = append(resPrefixList, resPrefix)
@@ -1461,6 +1646,7 @@ func PrefixSetToApiStruct(ps config.PrefixSet) *api.PrefixSet {
PrefixSetName: ps.PrefixSetName,
PrefixList: resPrefixList,
}
+
return resPrefixSet
}
@@ -1469,9 +1655,13 @@ func PrefixSetToConfigStruct(reqPrefixSet *api.PrefixSet) (bool, config.PrefixSe
var prefixSet config.PrefixSet
isReqPrefixSet := true
if reqPrefixSet.PrefixList != nil {
+
+ prefItem := reqPrefixSet.PrefixList[0]
+ prefStr := prefItem.Address + "/" + strconv.Itoa(int(prefItem.MaskLength))
+ _, ipprefix, _ := net.ParseCIDR(prefStr)
+
prefix = config.Prefix{
- Address: net.ParseIP(reqPrefixSet.PrefixList[0].Address),
- Masklength: uint8(reqPrefixSet.PrefixList[0].MaskLength),
+ IpPrefix: *ipprefix,
MasklengthRange: reqPrefixSet.PrefixList[0].MaskLengthRange,
}
prefixList := []config.Prefix{prefix}
@@ -1531,7 +1721,7 @@ func NeighborSetToConfigStruct(reqNeighborSet *api.NeighborSet) (bool, config.Ne
func AsPathSetToApiStruct(as config.AsPathSet) *api.AsPathSet {
resAsPathMembers := make([]string, 0)
- for _, m := range as.AsPathSetMembers {
+ for _, m := range as.AsPathSetMember {
resAsPathMembers = append(resAsPathMembers, m)
}
resAsPathSet := &api.AsPathSet{
@@ -1547,15 +1737,15 @@ func AsPathSetToConfigStruct(reqAsPathSet *api.AsPathSet) (bool, config.AsPathSe
isAsPathSetSet = false
}
asPathSet := config.AsPathSet{
- AsPathSetName: reqAsPathSet.AsPathSetName,
- AsPathSetMembers: reqAsPathSet.AsPathMembers,
+ AsPathSetName: reqAsPathSet.AsPathSetName,
+ AsPathSetMember: reqAsPathSet.AsPathMembers,
}
return isAsPathSetSet, asPathSet
}
func CommunitySetToApiStruct(cs config.CommunitySet) *api.CommunitySet {
resCommunityMembers := make([]string, 0)
- for _, m := range cs.CommunityMembers {
+ for _, m := range cs.CommunityMember {
resCommunityMembers = append(resCommunityMembers, m)
}
resCommunitySet := &api.CommunitySet{
@@ -1572,14 +1762,14 @@ func CommunitySetToConfigStruct(reqCommunitySet *api.CommunitySet) (bool, config
}
communitySet := config.CommunitySet{
CommunitySetName: reqCommunitySet.CommunitySetName,
- CommunityMembers: reqCommunitySet.CommunityMembers,
+ CommunityMember: reqCommunitySet.CommunityMembers,
}
return isCommunitySet, communitySet
}
func ExtCommunitySetToApiStruct(es config.ExtCommunitySet) *api.ExtCommunitySet {
resExtCommunityMembers := make([]string, 0)
- for _, m := range es.ExtCommunityMembers {
+ for _, m := range es.ExtCommunityMember {
resExtCommunityMembers = append(resExtCommunityMembers, m)
}
resExtCommunitySet := &api.ExtCommunitySet{
@@ -1596,7 +1786,7 @@ func ExtCommunitySetToConfigStruct(reqExtCommunitySet *api.ExtCommunitySet) (boo
}
ExtCommunitySet := config.ExtCommunitySet{
ExtCommunitySetName: reqExtCommunitySet.ExtCommunitySetName,
- ExtCommunityMembers: reqExtCommunitySet.ExtCommunityMembers,
+ ExtCommunityMember: reqExtCommunitySet.ExtCommunityMembers,
}
return isExtCommunitySet, ExtCommunitySet
}
@@ -1630,44 +1820,46 @@ func ConditionsToConfigStruct(reqConditions *api.Conditions) config.Conditions {
return conditions
}
if reqConditions.MatchPrefixSet != nil {
- conditions.MatchPrefixSet = reqConditions.MatchPrefixSet.PrefixSetName
+ conditions.MatchPrefixSet.PrefixSet = reqConditions.MatchPrefixSet.PrefixSetName
+ conditions.MatchPrefixSet.MatchSetOptions =
+ MatchSetOptionsRestrictedToType(reqConditions.MatchPrefixSet.MatchSetOptions)
}
if reqConditions.MatchNeighborSet != nil {
- conditions.MatchNeighborSet = reqConditions.MatchNeighborSet.NeighborSetName
+ conditions.MatchNeighborSet.NeighborSet = reqConditions.MatchNeighborSet.NeighborSetName
+ conditions.MatchNeighborSet.MatchSetOptions =
+ MatchSetOptionsRestrictedToType(reqConditions.MatchNeighborSet.MatchSetOptions)
}
if reqConditions.MatchAsPathSet != nil {
- conditions.BgpConditions.MatchAsPathSet = reqConditions.MatchAsPathSet.AsPathSetName
+ conditions.BgpConditions.MatchAsPathSet.AsPathSet = reqConditions.MatchAsPathSet.AsPathSetName
+ conditions.BgpConditions.MatchAsPathSet.MatchSetOptions =
+ MatchSetOptionsToType(reqConditions.MatchAsPathSet.MatchSetOptions)
}
if reqConditions.MatchCommunitySet != nil {
- conditions.BgpConditions.MatchCommunitySet = reqConditions.MatchCommunitySet.CommunitySetName
+ conditions.BgpConditions.MatchCommunitySet.CommunitySet = reqConditions.MatchCommunitySet.CommunitySetName
+ conditions.BgpConditions.MatchCommunitySet.MatchSetOptions =
+ MatchSetOptionsToType(reqConditions.MatchCommunitySet.MatchSetOptions)
}
if reqConditions.MatchExtCommunitySet != nil {
- conditions.BgpConditions.MatchExtCommunitySet = reqConditions.MatchExtCommunitySet.ExtCommunitySetName
+ conditions.BgpConditions.MatchExtCommunitySet.ExtCommunitySet = reqConditions.MatchExtCommunitySet.ExtCommunitySetName
+ conditions.BgpConditions.MatchExtCommunitySet.MatchSetOptions =
+ MatchSetOptionsToType(reqConditions.MatchExtCommunitySet.MatchSetOptions)
}
if reqConditions.MatchAsPathLength != nil {
conditions.BgpConditions.AsPathLength =
AsPathLengthToConfigStruct(reqConditions.MatchAsPathLength)
}
- var setOption config.MatchSetOptionsType
- switch reqConditions.MatchSetOptions {
- case OPTIONS_ALL:
- setOption = config.MATCH_SET_OPTIONS_TYPE_ALL
- case OPTIONS_ANY:
- setOption = config.MATCH_SET_OPTIONS_TYPE_ANY
- case OPTIONS_INVERT:
- setOption = config.MATCH_SET_OPTIONS_TYPE_INVERT
- }
- conditions.MatchSetOptions = setOption
return conditions
}
func ActionsToApiStruct(conActions config.Actions) *api.Actions {
action := ROUTE_REJECT
- if conActions.AcceptRoute {
+ if conActions.RouteDisposition.AcceptRoute {
action = ROUTE_ACCEPT
}
+
+ //TODO: support CommunitySetRef
communityAction := &api.CommunityAction{
- Communities: conActions.BgpActions.SetCommunity.Communities,
+ Communities: conActions.BgpActions.SetCommunity.SetCommunityMethod.Communities,
Options: conActions.BgpActions.SetCommunity.Options,
}
medAction := fmt.Sprintf("%s", conActions.BgpActions.SetMed)
@@ -1691,7 +1883,7 @@ func ActionsToConfigStruct(reqActions *api.Actions) config.Actions {
return actions
}
if reqActions.Community != nil {
- actions.BgpActions.SetCommunity.Communities = reqActions.Community.Communities
+ actions.BgpActions.SetCommunity.SetCommunityMethod.Communities = reqActions.Community.Communities
actions.BgpActions.SetCommunity.Options = reqActions.Community.Options
}
if reqActions.Med != "" {
@@ -1704,9 +1896,9 @@ func ActionsToConfigStruct(reqActions *api.Actions) config.Actions {
switch reqActions.RouteAction {
case ROUTE_ACCEPT:
- actions.AcceptRoute = true
+ actions.RouteDisposition.AcceptRoute = true
case ROUTE_REJECT:
- actions.RejectRoute = true
+ actions.RouteDisposition.RejectRoute = true
}
return actions
}
@@ -1727,7 +1919,7 @@ func PolicyDefinitionToConfigStruct(reqPolicy *api.PolicyDefinition) (bool, conf
}
if reqPolicy.StatementList != nil {
statement := StatementToConfigStruct(reqPolicy.StatementList[0])
- policy.StatementList = []config.Statement{statement}
+ policy.Statements.StatementList = []config.Statement{statement}
} else {
isReqStatement = false
}
@@ -1735,67 +1927,65 @@ func PolicyDefinitionToConfigStruct(reqPolicy *api.PolicyDefinition) (bool, conf
}
func PolicyDefinitionToApiStruct(pd config.PolicyDefinition, df config.DefinedSets) *api.PolicyDefinition {
- conPrefixSetList := df.PrefixSetList
- conNeighborSetList := df.NeighborSetList
- conAsPathSetList := df.BgpDefinedSets.AsPathSetList
- conCommunitySetList := df.BgpDefinedSets.CommunitySetList
- conExtCommunitySetList := df.BgpDefinedSets.ExtCommunitySetList
+ conPrefixSetList := df.PrefixSets.PrefixSetList
+ conNeighborSetList := df.NeighborSets.NeighborSetList
+ conAsPathSetList := df.BgpDefinedSets.AsPathSets.AsPathSetList
+ conCommunitySetList := df.BgpDefinedSets.CommunitySets.CommunitySetList
+ conExtCommunitySetList := df.BgpDefinedSets.ExtCommunitySets.ExtCommunitySetList
resStatementList := make([]*api.Statement, 0)
- for _, st := range pd.StatementList {
- conditions := st.Conditions
- actions := st.Actions
+ for _, st := range pd.Statements.StatementList {
+ co := st.Conditions
+ bco := co.BgpConditions
+ ac := st.Actions
- prefixSet := &api.PrefixSet{
- PrefixSetName: conditions.MatchPrefixSet,
- }
- neighborSet := &api.NeighborSet{
- NeighborSetName: conditions.MatchNeighborSet,
- }
- asPathSet := &api.AsPathSet{
- AsPathSetName: conditions.BgpConditions.MatchAsPathSet,
- }
- communitySet := &api.CommunitySet{
- CommunitySetName: conditions.BgpConditions.MatchCommunitySet,
- }
- extCommunitySet := &api.ExtCommunitySet{
- ExtCommunitySetName: conditions.BgpConditions.MatchExtCommunitySet,
- }
- // consider later whether treatment of here need
- _, conPrefixSet := PrefixSetToConfigStruct(prefixSet)
- _, conNeighborSet := NeighborSetToConfigStruct(neighborSet)
- _, conAsPathSet := AsPathSetToConfigStruct(asPathSet)
- _, conCommunitySet := CommunitySetToConfigStruct(communitySet)
- _, conExtCommunitySet := ExtCommunitySetToConfigStruct(extCommunitySet)
+ prefixSet := &api.PrefixSet{PrefixSetName: co.MatchPrefixSet.PrefixSet}
+ conPrefixSet := config.PrefixSet{PrefixSetName: co.MatchPrefixSet.PrefixSet}
idxPrefixSet, _ := IndexOfPrefixSet(conPrefixSetList, conPrefixSet)
- idxNeighborSet, _ := IndexOfNeighborSet(conNeighborSetList, conNeighborSet)
- idxAsPathSet, _ := IndexOfAsPathSet(conAsPathSetList, conAsPathSet)
- idxCommunitySet, _ := IndexOfCommunitySet(conCommunitySetList, conCommunitySet)
- idxExtCommunitySet, _ := IndexOfExtCommunitySet(conExtCommunitySetList, conExtCommunitySet)
if idxPrefixSet != -1 {
prefixSet = PrefixSetToApiStruct(conPrefixSetList[idxPrefixSet])
+ prefixSet.MatchSetOptions = MatchSetOptionsRestrictedToString(st.Conditions.MatchPrefixSet.MatchSetOptions)
}
+ neighborSet := &api.NeighborSet{NeighborSetName: co.MatchNeighborSet.NeighborSet}
+ conNeighborSet := config.NeighborSet{NeighborSetName: co.MatchNeighborSet.NeighborSet}
+ idxNeighborSet, _ := IndexOfNeighborSet(conNeighborSetList, conNeighborSet)
if idxNeighborSet != -1 {
neighborSet = NeighborSetToApiStruct(conNeighborSetList[idxNeighborSet])
+ neighborSet.MatchSetOptions = MatchSetOptionsRestrictedToString(st.Conditions.MatchNeighborSet.MatchSetOptions)
}
+
+ asPathSet := &api.AsPathSet{AsPathSetName: bco.MatchAsPathSet.AsPathSet}
+ conAsPathSet := config.AsPathSet{AsPathSetName: bco.MatchAsPathSet.AsPathSet}
+ idxAsPathSet, _ := IndexOfAsPathSet(conAsPathSetList, conAsPathSet)
if idxAsPathSet != -1 {
asPathSet = AsPathSetToApiStruct(conAsPathSetList[idxAsPathSet])
+ asPathSet.MatchSetOptions = MatchSetOptionToString(bco.MatchAsPathSet.MatchSetOptions)
}
+
+ communitySet := &api.CommunitySet{CommunitySetName: bco.MatchCommunitySet.CommunitySet}
+ conCommunitySet := config.CommunitySet{CommunitySetName: bco.MatchCommunitySet.CommunitySet}
+ idxCommunitySet, _ := IndexOfCommunitySet(conCommunitySetList, conCommunitySet)
if idxCommunitySet != -1 {
communitySet = CommunitySetToApiStruct(conCommunitySetList[idxCommunitySet])
+ communitySet.MatchSetOptions = MatchSetOptionToString(bco.MatchCommunitySet.MatchSetOptions)
}
+
+ extCommunitySet := &api.ExtCommunitySet{ExtCommunitySetName: bco.MatchExtCommunitySet.ExtCommunitySet}
+ conExtCommunitySet := config.ExtCommunitySet{ExtCommunitySetName: bco.MatchExtCommunitySet.ExtCommunitySet}
+ idxExtCommunitySet, _ := IndexOfExtCommunitySet(conExtCommunitySetList, conExtCommunitySet)
if idxExtCommunitySet != -1 {
extCommunitySet = ExtCommunitySetToApiStruct(conExtCommunitySetList[idxExtCommunitySet])
+ extCommunitySet.MatchSetOptions = MatchSetOptionToString(bco.MatchExtCommunitySet.MatchSetOptions)
}
+
resConditions := &api.Conditions{
- MatchPrefixSet: prefixSet,
- MatchNeighborSet: neighborSet,
- MatchAsPathSet: asPathSet,
- MatchCommunitySet: communitySet,
+ MatchPrefixSet: prefixSet,
+ MatchNeighborSet: neighborSet,
+ MatchAsPathSet: asPathSet,
+ MatchCommunitySet: communitySet,
MatchExtCommunitySet: extCommunitySet,
- MatchAsPathLength: AsPathLengthToApiStruct(st.Conditions.BgpConditions.AsPathLength),
- MatchSetOptions: MatchSetOptionToString(conditions.MatchSetOptions),
+ MatchAsPathLength: AsPathLengthToApiStruct(st.Conditions.BgpConditions.AsPathLength),
}
- resActions := ActionsToApiStruct(actions)
+ resActions := ActionsToApiStruct(ac)
resStatement := &api.Statement{
StatementNeme: st.Name,
Conditions: resConditions,
generated by cgit v1.2.3 (git 2.39.1) at 2024-11-16 02:31:29 +0000