mirror/osrg-gobgp
1
0
Fork 0
mirror of https://github.com/osrg/gobgp.git synced 2024-05-11 05:55:10 +00:00
Code Issues Releases Activity

server: kill LocalRib

Browse Source 
Signed-off-by: ISHIDA Wataru <[email protected]>
This commit is contained in:
ISHIDA Wataru
2015-09-30 15:29:08 +09:00
parent c81fad9103
commit eaa7810893
4 changed files with 175 additions and 322 deletions
Download Patch File Download Diff File Expand all files Collapse all files
policy/policy.go
+16 -17
View File
@@ -996,18 +996,16 @@ type RoutingAction struct {
}
func NewRoutingAction(action config.Actions) *RoutingAction {
r := &RoutingAction{
return &RoutingAction{
AcceptRoute: action.RouteDisposition.AcceptRoute,
}
return r
}
func (r *RoutingAction) apply(path *table.Path) *table.Path {
if r.AcceptRoute {
return path
} else {
return nil
}
return nil
}
type CommunityAction struct {
@@ -1346,7 +1344,7 @@ func NewPrefix(prefixStr string, maskRange string) (Prefix, error) {
// Compare path with a policy's condition in stored order in the policy.
// If a condition match, then this function stops evaluation and
// subsequent conditions are skipped.
func (p *Policy) Apply(path *table.Path) (bool, RouteType, *table.Path) {
func (p *Policy) Apply(path *table.Path) (RouteType, *table.Path) {
for _, statement := range p.Statements {
result := statement.evaluate(path)
@@ -1356,23 +1354,24 @@ func (p *Policy) Apply(path *table.Path) (bool, RouteType, *table.Path) {
"PolicyName": p.Name,
}).Debug("statement evaluate : ", result)
var p *table.Path
if result {
//Routing action
p = statement.routingAction.apply(path)
if p != nil {
// apply all modification actions
cloned := path.Clone(p.IsWithdraw)
for _, action := range statement.modificationActions {
cloned = action.apply(cloned)
}
return true, ROUTE_TYPE_ACCEPT, cloned
} else {
return true, ROUTE_TYPE_REJECT, nil
p := statement.routingAction.apply(path)
if p == nil {
return ROUTE_TYPE_REJECT, path
}
if len(statement.modificationActions) == 0 {
return ROUTE_TYPE_ACCEPT, path
}
// apply all modification actions
cloned := path.Clone(p.IsWithdraw)
for _, action := range statement.modificationActions {
cloned = action.apply(cloned)
}
return ROUTE_TYPE_ACCEPT, cloned
}
}
return false, ROUTE_TYPE_NONE, nil
return ROUTE_TYPE_NONE, path
}
func ipPrefixCalculate(path *table.Path, cPrefix Prefix) bool {
policy/policy_test.go
+41 -68
View File
@@ -243,10 +243,9 @@ func TestPolicyNotMatch(t *testing.T) {
//test
df := pl.DefinedSets
p := NewPolicy(pl.PolicyDefinitions.PolicyDefinitionList[0], df)
match, pType, newPath := p.Apply(path)
assert.Equal(t, false, match)
pType, newPath := p.Apply(path)
assert.Equal(t, ROUTE_TYPE_NONE, pType)
assert.Nil(t, newPath)
assert.Equal(t, newPath, path)
}
func TestPolicyMatchAndReject(t *testing.T) {
@@ -275,10 +274,9 @@ func TestPolicyMatchAndReject(t *testing.T) {
//test
df := pl.DefinedSets
p := NewPolicy(pl.PolicyDefinitions.PolicyDefinitionList[0], df)
match, pType, newPath := p.Apply(path)
assert.Equal(t, true, match)
pType, newPath := p.Apply(path)
assert.Equal(t, ROUTE_TYPE_REJECT, pType)
assert.Nil(t, newPath)
assert.Equal(t, newPath, path)
}
func TestPolicyMatchAndAccept(t *testing.T) {
@@ -307,8 +305,7 @@ func TestPolicyMatchAndAccept(t *testing.T) {
//test
df := pl.DefinedSets
p := NewPolicy(pl.PolicyDefinitions.PolicyDefinitionList[0], df)
match, pType, newPath := p.Apply(path)
assert.Equal(t, true, match)
pType, newPath := p.Apply(path)
assert.Equal(t, ROUTE_TYPE_ACCEPT, pType)
assert.Equal(t, path, newPath)
}
@@ -349,15 +346,13 @@ func TestPolicyRejectOnlyPrefixSet(t *testing.T) {
//test
df := pl.DefinedSets
p := NewPolicy(pl.PolicyDefinitions.PolicyDefinitionList[0], df)
match, pType, newPath := p.Apply(path1)
assert.Equal(t, true, match)
pType, newPath := p.Apply(path1)
assert.Equal(t, ROUTE_TYPE_REJECT, pType)
assert.Nil(t, newPath)
assert.Equal(t, newPath, path1)
match2, pType2, newPath2 := p.Apply(path2)
assert.Equal(t, false, match2)
pType2, newPath2 := p.Apply(path2)
assert.Equal(t, ROUTE_TYPE_NONE, pType2)
assert.Nil(t, newPath2)
assert.Equal(t, newPath2, path2)
}
func TestPolicyRejectOnlyNeighborSet(t *testing.T) {
@@ -396,15 +391,13 @@ func TestPolicyRejectOnlyNeighborSet(t *testing.T) {
//test
df := pl.DefinedSets
p := NewPolicy(pl.PolicyDefinitions.PolicyDefinitionList[0], df)
match, pType, newPath := p.Apply(path1)
assert.Equal(t, true, match)
pType, newPath := p.Apply(path1)
assert.Equal(t, ROUTE_TYPE_REJECT, pType)
assert.Nil(t, newPath)
assert.Equal(t, newPath, path1)
match2, pType2, newPath2 := p.Apply(path2)
assert.Equal(t, false, match2)
pType2, newPath2 := p.Apply(path2)
assert.Equal(t, ROUTE_TYPE_NONE, pType2)
assert.Nil(t, newPath2)
assert.Equal(t, newPath2, path2)
}
func TestPolicyDifferentRoutefamilyOfPathAndPolicy(t *testing.T) {
@@ -450,15 +443,13 @@ func TestPolicyDifferentRoutefamilyOfPathAndPolicy(t *testing.T) {
//test
df := pl.DefinedSets
p := NewPolicy(pl.PolicyDefinitions.PolicyDefinitionList[0], df)
match1, pType1, newPath1 := p.Apply(pathIPv4)
assert.Equal(t, true, match1)
pType1, newPath1 := p.Apply(pathIPv4)
assert.Equal(t, ROUTE_TYPE_REJECT, pType1)
assert.Nil(t, newPath1)
assert.Equal(t, newPath1, pathIPv4)
match2, pType2, newPath2 := p.Apply(pathIPv6)
assert.Equal(t, true, match2)
pType2, newPath2 := p.Apply(pathIPv6)
assert.Equal(t, ROUTE_TYPE_REJECT, pType2)
assert.Nil(t, newPath2)
assert.Equal(t, newPath2, pathIPv6)
}
func TestAsPathLengthConditionEvaluate(t *testing.T) {
@@ -550,10 +541,9 @@ func TestAsPathLengthConditionWithOtherCondition(t *testing.T) {
//test
df := pl.DefinedSets
p := NewPolicy(pl.PolicyDefinitions.PolicyDefinitionList[0], df)
match, pType, newPath := p.Apply(path)
assert.Equal(t, true, match)
pType, newPath := p.Apply(path)
assert.Equal(t, ROUTE_TYPE_REJECT, pType)
assert.Nil(t, newPath)
assert.Equal(t, newPath, path)
}
@@ -889,10 +879,9 @@ func TestAsPathConditionWithOtherCondition(t *testing.T) {
//test
df := pl.DefinedSets
p := NewPolicy(pl.PolicyDefinitions.PolicyDefinitionList[0], df)
match, pType, newPath := p.Apply(path)
assert.Equal(t, true, match)
pType, newPath := p.Apply(path)
assert.Equal(t, ROUTE_TYPE_REJECT, pType)
assert.Nil(t, newPath)
assert.Equal(t, newPath, path)
}
@@ -1121,17 +1110,15 @@ func TestCommunityConditionEvaluateWithOtherCondition(t *testing.T) {
//test
df := pl.DefinedSets
p := NewPolicy(pl.PolicyDefinitions.PolicyDefinitionList[0], df)
match, pType, newPath := p.Apply(path)
assert.Equal(t, true, match)
pType, newPath := p.Apply(path)
assert.Equal(t, ROUTE_TYPE_REJECT, pType)
assert.Nil(t, newPath)
assert.Equal(t, newPath, path)
df = pl.DefinedSets
p = NewPolicy(pl.PolicyDefinitions.PolicyDefinitionList[1], df)
match, pType, newPath = p.Apply(path)
assert.Equal(t, false, match)
pType, newPath = p.Apply(path)
assert.Equal(t, ROUTE_TYPE_NONE, pType)
assert.Nil(t, newPath)
assert.Equal(t, newPath, path)
}
@@ -1168,8 +1155,7 @@ func TestPolicyMatchAndAddCommunities(t *testing.T) {
df := pl.DefinedSets
p := NewPolicy(pl.PolicyDefinitions.PolicyDefinitionList[0], df)
match, pType, newPath := p.Apply(path)
assert.Equal(t, true, match)
pType, newPath := p.Apply(path)
assert.Equal(t, ROUTE_TYPE_ACCEPT, pType)
assert.NotEqual(t, nil, newPath)
log.Debug(newPath)
@@ -1212,8 +1198,7 @@ func TestPolicyMatchAndReplaceCommunities(t *testing.T) {
df := pl.DefinedSets
p := NewPolicy(pl.PolicyDefinitions.PolicyDefinitionList[0], df)
match, pType, newPath := p.Apply(path)
assert.Equal(t, true, match)
pType, newPath := p.Apply(path)
assert.Equal(t, ROUTE_TYPE_ACCEPT, pType)
assert.NotEqual(t, nil, newPath)
assert.Equal(t, []uint32{stringToCommunityValue(community)}, newPath.GetCommunities())
@@ -1255,8 +1240,7 @@ func TestPolicyMatchAndRemoveCommunities(t *testing.T) {
//test
df := pl.DefinedSets
p := NewPolicy(pl.PolicyDefinitions.PolicyDefinitionList[0], df)
match, pType, newPath := p.Apply(path)
assert.Equal(t, true, match)
pType, newPath := p.Apply(path)
assert.Equal(t, ROUTE_TYPE_ACCEPT, pType)
assert.NotEqual(t, nil, newPath)
assert.Equal(t, []uint32{stringToCommunityValue(community2)}, newPath.GetCommunities())
@@ -1301,8 +1285,7 @@ func TestPolicyMatchAndClearCommunities(t *testing.T) {
df := pl.DefinedSets
p := NewPolicy(pl.PolicyDefinitions.PolicyDefinitionList[0], df)
match, pType, newPath := p.Apply(path)
assert.Equal(t, true, match)
pType, newPath := p.Apply(path)
assert.Equal(t, ROUTE_TYPE_ACCEPT, pType)
assert.NotEqual(t, nil, newPath)
//assert.Equal(t, []uint32{}, newPath.GetCommunities())
@@ -1632,16 +1615,14 @@ func TestExtCommunityConditionEvaluateWithOtherCondition(t *testing.T) {
//test
df := pl.DefinedSets
p := NewPolicy(pl.PolicyDefinitions.PolicyDefinitionList[0], df)
match, pType, newPath := p.Apply(path)
assert.Equal(t, false, match)
pType, newPath := p.Apply(path)
assert.Equal(t, ROUTE_TYPE_NONE, pType)
assert.Nil(t, newPath)
assert.Equal(t, newPath, path)
p = NewPolicy(pl.PolicyDefinitions.PolicyDefinitionList[1], df)
match, pType, newPath = p.Apply(path)
assert.Equal(t, true, match)
pType, newPath = p.Apply(path)
assert.Equal(t, ROUTE_TYPE_REJECT, pType)
assert.Nil(t, newPath)
assert.Equal(t, newPath, path)
}
@@ -1678,8 +1659,7 @@ func TestPolicyMatchAndReplaceMed(t *testing.T) {
df := pl.DefinedSets
p := NewPolicy(pl.PolicyDefinitions.PolicyDefinitionList[0], df)
match, pType, newPath := p.Apply(path)
assert.Equal(t, true, match)
pType, newPath := p.Apply(path)
assert.Equal(t, ROUTE_TYPE_ACCEPT, pType)
assert.NotEqual(t, nil, newPath)
v, err := newPath.GetMed()
@@ -1720,8 +1700,7 @@ func TestPolicyMatchAndAddingMed(t *testing.T) {
//test
df := pl.DefinedSets
p := NewPolicy(pl.PolicyDefinitions.PolicyDefinitionList[0], df)
match, pType, newPath := p.Apply(path)
assert.Equal(t, true, match)
pType, newPath := p.Apply(path)
assert.Equal(t, ROUTE_TYPE_ACCEPT, pType)
assert.NotEqual(t, nil, newPath)
@@ -1765,8 +1744,7 @@ func TestPolicyMatchAndAddingMedOverFlow(t *testing.T) {
df := pl.DefinedSets
p := NewPolicy(pl.PolicyDefinitions.PolicyDefinitionList[0], df)
match, pType, newPath := p.Apply(path)
assert.Equal(t, true, match)
pType, newPath := p.Apply(path)
assert.Equal(t, ROUTE_TYPE_ACCEPT, pType)
assert.NotEqual(t, nil, newPath)
@@ -1810,8 +1788,7 @@ func TestPolicyMatchAndSubtractMed(t *testing.T) {
df := pl.DefinedSets
p := NewPolicy(pl.PolicyDefinitions.PolicyDefinitionList[0], df)
match, pType, newPath := p.Apply(path)
assert.Equal(t, true, match)
pType, newPath := p.Apply(path)
assert.Equal(t, ROUTE_TYPE_ACCEPT, pType)
assert.NotEqual(t, nil, newPath)
@@ -1855,8 +1832,7 @@ func TestPolicyMatchAndSubtractMedUnderFlow(t *testing.T) {
df := pl.DefinedSets
p := NewPolicy(pl.PolicyDefinitions.PolicyDefinitionList[0], df)
match, pType, newPath := p.Apply(path)
assert.Equal(t, true, match)
pType, newPath := p.Apply(path)
assert.Equal(t, ROUTE_TYPE_ACCEPT, pType)
assert.NotEqual(t, nil, newPath)
@@ -1897,8 +1873,7 @@ func TestPolicyMatchWhenPathHaveNotMed(t *testing.T) {
df := pl.DefinedSets
p := NewPolicy(pl.PolicyDefinitions.PolicyDefinitionList[0], df)
match, pType, newPath := p.Apply(path)
assert.Equal(t, true, match)
pType, newPath := p.Apply(path)
assert.Equal(t, ROUTE_TYPE_ACCEPT, pType)
assert.NotEqual(t, nil, newPath)
@@ -1944,8 +1919,7 @@ func TestPolicyAsPathPrepend(t *testing.T) {
df := pl.DefinedSets
p := NewPolicy(pl.PolicyDefinitions.PolicyDefinitionList[0], df)
match, pType, newPath := p.Apply(path)
assert.Equal(true, match)
pType, newPath := p.Apply(path)
assert.Equal(ROUTE_TYPE_ACCEPT, pType)
assert.NotEqual(nil, newPath)
assert.Equal([]uint32{65002, 65002, 65002, 65002, 65002, 65002, 65002, 65002, 65002, 65002, 65001, 65000}, newPath.GetAsSeqList())
@@ -1988,8 +1962,7 @@ func TestPolicyAsPathPrependLastAs(t *testing.T) {
df := pl.DefinedSets
p := NewPolicy(pl.PolicyDefinitions.PolicyDefinitionList[0], df)
match, pType, newPath := p.Apply(path)
assert.Equal(true, match)
pType, newPath := p.Apply(path)
assert.Equal(ROUTE_TYPE_ACCEPT, pType)
assert.NotEqual(nil, newPath)
assert.Equal([]uint32{65002, 65002, 65002, 65002, 65002, 65002, 65001, 65000}, newPath.GetAsSeqList())
server/peer.go
+65 -106
View File
@@ -43,6 +43,10 @@ type Peer struct {
outgoing chan *bgp.BGPMessage
inPolicies []*policy.Policy
defaultInPolicy config.DefaultPolicyType
importPolicies []*policy.Policy
defaultImportPolicy config.DefaultPolicyType
exportPolicies []*policy.Policy
defaultExportPolicy config.DefaultPolicyType
isConfederationMember bool
recvOpen *bgp.BGPMessage
}
@@ -213,10 +217,10 @@ func (peer *Peer) handleBGPmessage(m *bgp.BGPMessage) ([]*table.Path, bool, []*b
return pathList, update, bgpMsgList
}
func (peer *Peer) getBests(loc *LocalRib) []*table.Path {
func (peer *Peer) getBests(rib *table.TableManager) []*table.Path {
pathList := []*table.Path{}
for _, rf := range peer.configuredRFlist() {
for _, paths := range loc.rib.GetBestPathList(rf) {
for _, paths := range rib.GetBestPathList(rf) {
pathList = append(pathList, paths)
}
}
@@ -293,13 +297,7 @@ func (peer *Peer) ToApiStruct() *api.Peer {
advertized += uint32(peer.adjRib.GetOutCount(rf))
received += uint32(peer.adjRib.GetInCount(rf))
// FIXME: we should store 'accepted' in memory
for _, p := range peer.adjRib.GetInPathList(rf) {
applied, path := peer.applyPolicies(POLICY_DIRECTION_IN, p)
if applied && path == nil || !applied && peer.defaultInPolicy != config.DEFAULT_POLICY_TYPE_ACCEPT_ROUTE {
continue
}
accepted += 1
}
accepted += uint32(len(peer.ApplyPolicy(POLICY_DIRECTION_IN, peer.adjRib.GetInPathList(rf))))
}
}
@@ -364,43 +362,8 @@ func (peer *Peer) setPolicy(policyMap map[string]*policy.Policy) {
}
peer.inPolicies = inPolicies
peer.defaultInPolicy = policyConf.ApplyPolicyConfig.DefaultInPolicy
}
func (peer *Peer) applyPolicies(d Direction, original *table.Path) (bool, *table.Path) {
var policies []*policy.Policy
switch d {
case POLICY_DIRECTION_IN:
policies = peer.inPolicies
}
return applyPolicy("Peer", peer.conf.NeighborConfig.NeighborAddress.String(), d, policies, original)
}
type LocalRib struct {
rib *table.TableManager
importPolicies []*policy.Policy
defaultImportPolicy config.DefaultPolicyType
exportPolicies []*policy.Policy
defaultExportPolicy config.DefaultPolicyType
}
func NewLocalRib(owner string, rfList []bgp.RouteFamily, minLabel, maxLabel uint32) *LocalRib {
return &LocalRib{
rib: table.NewTableManager(owner, rfList, minLabel, maxLabel),
}
}
func (loc *LocalRib) OwnerName() string {
return loc.rib.OwnerName()
}
func (loc *LocalRib) isGlobal() bool {
return loc.OwnerName() == "global"
}
func (loc *LocalRib) setPolicy(peer *Peer, policyMap map[string]*policy.Policy) {
// configure import policy
policyConf := peer.conf.ApplyPolicy
inPolicies := make([]*policy.Policy, 0)
importPolicies := make([]*policy.Policy, 0)
for _, policyName := range policyConf.ApplyPolicyConfig.ImportPolicy {
log.WithFields(log.Fields{
"Topic": "Peer",
@@ -409,14 +372,14 @@ func (loc *LocalRib) setPolicy(peer *Peer, policyMap map[string]*policy.Policy)
}).Info("import policy installed")
if pol, ok := policyMap[policyName]; ok {
log.Debug("import policy : ", pol)
inPolicies = append(inPolicies, pol)
importPolicies = append(importPolicies, pol)
}
}
loc.importPolicies = inPolicies
loc.defaultImportPolicy = policyConf.ApplyPolicyConfig.DefaultImportPolicy
peer.importPolicies = importPolicies
peer.defaultImportPolicy = policyConf.ApplyPolicyConfig.DefaultImportPolicy
// configure export policy
outPolicies := make([]*policy.Policy, 0)
exportPolicies := make([]*policy.Policy, 0)
for _, policyName := range policyConf.ApplyPolicyConfig.ExportPolicy {
log.WithFields(log.Fields{
"Topic": "Peer",
@@ -425,73 +388,69 @@ func (loc *LocalRib) setPolicy(peer *Peer, policyMap map[string]*policy.Policy)
}).Info("export policy installed")
if pol, ok := policyMap[policyName]; ok {
log.Debug("export policy : ", pol)
outPolicies = append(outPolicies, pol)
exportPolicies = append(exportPolicies, pol)
}
}
loc.exportPolicies = outPolicies
loc.defaultExportPolicy = policyConf.ApplyPolicyConfig.DefaultExportPolicy
peer.exportPolicies = exportPolicies
peer.defaultExportPolicy = policyConf.ApplyPolicyConfig.DefaultExportPolicy
}
// apply policies to the path
// if multiple policies are defined,
// this function applies each policy to the path in the order that
// policies are stored in the array passed to this function.
//
// the way of applying statements inside a single policy
// - apply statement until the condition in the statement matches.
// if the condition matches the path, apply the action on the statement and
// return value that indicates 'applied' to caller of this function
// - if no statement applied, then process the next policy
//
// if no policy applied, return value that indicates 'not applied' to the caller of this function
//
// return values:
// bool -- indicates that any of policy applied to the path that is passed to this function
// table.Path -- indicates new path object that is the result of modification according to
// policy's action.
// If the applied policy doesn't have a modification action,
// then return the path itself that is passed to this function, otherwise return
// modified path.
// If action of the policy is 'reject', return nil
//
func (loc *LocalRib) applyPolicies(d Direction, original *table.Path) (bool, *table.Path) {
var policies []*policy.Policy
func (peer *Peer) GetPolicy(d PolicyDirection) []*policy.Policy {
switch d {
case POLICY_DIRECTION_EXPORT:
policies = loc.exportPolicies
case POLICY_DIRECTION_IN:
return peer.inPolicies
case POLICY_DIRECTION_IMPORT:
policies = loc.importPolicies
return peer.importPolicies
case POLICY_DIRECTION_EXPORT:
return peer.exportPolicies
}
return applyPolicy("Loc", loc.OwnerName(), d, policies, original)
return nil
}
func applyPolicy(component, owner string, d Direction, policies []*policy.Policy, original *table.Path) (bool, *table.Path) {
var applied bool = true
for _, pol := range policies {
if result, action, newpath := pol.Apply(original); result {
log.Debug("newpath: ", newpath)
if action == policy.ROUTE_TYPE_REJECT {
log.WithFields(log.Fields{
"Topic": component,
"Key": owner,
"NLRI": original.GetNlri(),
"Dir": d,
}).Debug("path was rejected")
// return applied, nil, this means path was rejected
return applied, nil
} else {
// return applied, new path
return applied, newpath
func (peer *Peer) GetDefaultPolicy(d PolicyDirection) policy.RouteType {
var def config.DefaultPolicyType
switch d {
case POLICY_DIRECTION_IN:
def = peer.defaultInPolicy
case POLICY_DIRECTION_IMPORT:
def = peer.defaultImportPolicy
case POLICY_DIRECTION_EXPORT:
def = peer.defaultExportPolicy
}
if def == config.DEFAULT_POLICY_TYPE_ACCEPT_ROUTE {
return policy.ROUTE_TYPE_ACCEPT
}
return policy.ROUTE_TYPE_REJECT
}
func (peer *Peer) ApplyPolicy(d PolicyDirection, paths []*table.Path) []*table.Path {
newpaths := make([]*table.Path, 0, len(paths))
for _, path := range paths {
result := policy.ROUTE_TYPE_NONE
newpath := path
for _, p := range peer.GetPolicy(d) {
result, newpath = p.Apply(path)
if result != policy.ROUTE_TYPE_NONE {
break
}
}
}
log.WithFields(log.Fields{
"Topic": component,
"Key": owner,
"Len": len(policies),
"NLRI": original,
"Dir": d,
}).Debug("no policy applied")
return !applied, original
if result == policy.ROUTE_TYPE_NONE {
result = peer.GetDefaultPolicy(d)
}
switch result {
case policy.ROUTE_TYPE_ACCEPT:
newpaths = append(newpaths, newpath)
case policy.ROUTE_TYPE_REJECT:
log.WithFields(log.Fields{
"Topic": "Peer",
"Key": peer.conf.NeighborConfig.NeighborAddress,
"Path": path,
"Direction": d,
}).Debug("reject")
}
}
return newpaths
}
server/server.go
+53 -131
View File
@@ -37,12 +37,12 @@ const (
GLOBAL_RIB_NAME = "global"
)
type Direction string
type PolicyDirection int
const (
POLICY_DIRECTION_IMPORT Direction = "import"
POLICY_DIRECTION_EXPORT = "export"
POLICY_DIRECTION_IN = "in"
POLICY_DIRECTION_IMPORT PolicyDirection = iota
POLICY_DIRECTION_EXPORT
POLICY_DIRECTION_IN
)
type SenderMsg struct {
@@ -101,7 +101,7 @@ type BgpServer struct {
broadcastReqs []*GrpcRequest
broadcastMsgs []broadcastMsg
neighborMap map[string]*Peer
localRibMap map[string]*LocalRib
localRibMap map[string]*table.TableManager
zclient *zebra.Client
roaClient *roaClient
bmpClient *bmpClient
@@ -119,7 +119,7 @@ func NewBgpServer(port int) *BgpServer {
b.bmpConnCh = make(chan *bmpConn)
b.GrpcReqCh = make(chan *GrpcRequest, 1)
b.policyUpdateCh = make(chan config.RoutingPolicy)
b.localRibMap = make(map[string]*LocalRib)
b.localRibMap = make(map[string]*table.TableManager)
b.neighborMap = make(map[string]*Peer)
b.listenPort = port
b.roaClient, _ = newROAClient(config.RpkiServers{})
@@ -150,7 +150,7 @@ func listenAndAccept(proto string, port int, ch chan *net.TCPConn) (*net.TCPList
return l, nil
}
func (server *BgpServer) addLocalRib(rib *LocalRib) {
func (server *BgpServer) addLocalRib(rib *table.TableManager) {
server.localRibMap[rib.OwnerName()] = rib
}
@@ -224,7 +224,7 @@ func (server *BgpServer) Serve() {
return rfList
}(g.AfiSafis.AfiSafiList)
server.addLocalRib(NewLocalRib(GLOBAL_RIB_NAME, rfList, g.MplsLabelRange.MinLabel, g.MplsLabelRange.MaxLabel))
server.addLocalRib(table.NewTableManager(GLOBAL_RIB_NAME, rfList, g.MplsLabelRange.MinLabel, g.MplsLabelRange.MaxLabel))
listenerMap := make(map[string]*net.TCPListener)
acceptCh := make(chan *net.TCPConn)
@@ -354,10 +354,8 @@ func (server *BgpServer) Serve() {
name := config.NeighborConfig.NeighborAddress.String()
if config.RouteServer.RouteServerConfig.RouteServerClient {
loc := NewLocalRib(name, peer.configuredRFlist(), g.MplsLabelRange.MinLabel, g.MplsLabelRange.MaxLabel)
server.addLocalRib(loc)
loc.setPolicy(peer, server.policyMap)
// set in policy
rib := table.NewTableManager(name, peer.configuredRFlist(), g.MplsLabelRange.MinLabel, g.MplsLabelRange.MaxLabel)
server.addLocalRib(rib)
peer.setPolicy(server.policyMap)
pathList := make([]*table.Path, 0)
@@ -369,9 +367,9 @@ func (server *BgpServer) Serve() {
pathList = append(pathList, p.adjRib.GetInPathList(rf)...)
}
}
pathList = applyPolicies(peer, loc, POLICY_DIRECTION_IMPORT, pathList)
pathList = peer.ApplyPolicy(POLICY_DIRECTION_IMPORT, pathList)
if len(pathList) > 0 {
loc.rib.ProcessPaths(pathList)
rib.ProcessPaths(pathList)
}
}
server.neighborMap[name] = peer
@@ -411,8 +409,6 @@ func (server *BgpServer) Serve() {
peer := server.neighborMap[addr]
if peer.isRouteServerClient() {
peer.conf.ApplyPolicy = config.ApplyPolicy
loc := server.localRibMap[addr]
loc.setPolicy(peer, server.policyMap)
peer.setPolicy(server.policyMap)
}
case e := <-incoming:
@@ -555,12 +551,12 @@ func (server *BgpServer) dropPeerAllRoutes(peer *Peer) []*SenderMsg {
for _, rf := range peer.configuredRFlist() {
if peer.isRouteServerClient() {
for _, loc := range server.localRibMap {
targetPeer := server.neighborMap[loc.OwnerName()]
if loc.isGlobal() || loc.OwnerName() == peer.conf.NeighborConfig.NeighborAddress.String() {
for _, rib := range server.localRibMap {
targetPeer := server.neighborMap[rib.OwnerName()]
if rib.OwnerName() == GLOBAL_RIB_NAME || rib.OwnerName() == peer.conf.NeighborConfig.NeighborAddress.String() {
continue
}
pathList, _ := loc.rib.DeletePathsforPeer(peer.peerInfo, rf)
pathList, _ := rib.DeletePathsforPeer(peer.peerInfo, rf)
pathList = dropSameAsPath(targetPeer.conf.NeighborConfig.PeerAs, pathList)
if targetPeer.fsm.state != bgp.BGP_FSM_ESTABLISHED || len(pathList) == 0 {
continue
@@ -570,8 +566,8 @@ func (server *BgpServer) dropPeerAllRoutes(peer *Peer) []*SenderMsg {
targetPeer.adjRib.UpdateOut(pathList)
}
} else {
loc := server.localRibMap[GLOBAL_RIB_NAME]
pathList, _ := loc.rib.DeletePathsforPeer(peer.peerInfo, rf)
rib := server.localRibMap[GLOBAL_RIB_NAME]
pathList, _ := rib.DeletePathsforPeer(peer.peerInfo, rf)
if len(pathList) == 0 {
continue
}
@@ -591,59 +587,6 @@ func (server *BgpServer) dropPeerAllRoutes(peer *Peer) []*SenderMsg {
return msgs
}
func applyPolicies(peer *Peer, loc *LocalRib, d Direction, pathList []*table.Path) []*table.Path {
var defaultPolicy config.DefaultPolicyType
ret := make([]*table.Path, 0, len(pathList))
switch d {
case POLICY_DIRECTION_EXPORT:
defaultPolicy = loc.defaultExportPolicy
case POLICY_DIRECTION_IMPORT:
defaultPolicy = loc.defaultImportPolicy
case POLICY_DIRECTION_IN:
defaultPolicy = peer.defaultInPolicy
default:
log.WithFields(log.Fields{
"Topic": "Server",
"Key": peer.conf.NeighborConfig.NeighborAddress,
}).Error("direction is not specified.")
return ret
}
for _, path := range pathList {
if !path.IsWithdraw {
var applied bool = false
switch d {
case POLICY_DIRECTION_IN:
applied, path = peer.applyPolicies(d, path)
case POLICY_DIRECTION_IMPORT, POLICY_DIRECTION_EXPORT:
applied, path = loc.applyPolicies(d, path)
}
if applied {
if path == nil {
log.WithFields(log.Fields{
"Topic": "Peer",
"Key": peer.conf.NeighborConfig.NeighborAddress,
"Data": path,
}).Debug("Policy applied and rejected.")
continue
}
} else if defaultPolicy != config.DEFAULT_POLICY_TYPE_ACCEPT_ROUTE {
log.WithFields(log.Fields{
"Topic": "Peer",
"Key": peer.conf.NeighborConfig.NeighborAddress,
"Data": path,
}).Debug("Default policy applied and rejected.")
continue
}
}
// FIXME: probably we already clone.
ret = append(ret, path.Clone(path.IsWithdraw))
}
return ret
}
func (server *BgpServer) broadcastBests(bests []*table.Path) {
for _, path := range bests {
if !path.IsFromZebra {
@@ -717,19 +660,19 @@ func (server *BgpServer) propagateUpdate(peer *Peer, pathList []*table.Path) []*
msgs := make([]*SenderMsg, 0)
if peer != nil && peer.isRouteServerClient() {
newPathList := applyPolicies(peer, nil, POLICY_DIRECTION_IN, pathList)
for _, loc := range server.localRibMap {
targetPeer := server.neighborMap[loc.OwnerName()]
newPathList := peer.ApplyPolicy(POLICY_DIRECTION_IN, pathList)
for _, rib := range server.localRibMap {
targetPeer := server.neighborMap[rib.OwnerName()]
neighborAddress := peer.conf.NeighborConfig.NeighborAddress.String()
if loc.isGlobal() || loc.OwnerName() == neighborAddress {
if rib.OwnerName() == GLOBAL_RIB_NAME || rib.OwnerName() == neighborAddress {
continue
}
sendPathList, _ := loc.rib.ProcessPaths(applyPolicies(targetPeer, loc, POLICY_DIRECTION_IMPORT,
sendPathList, _ := rib.ProcessPaths(targetPeer.ApplyPolicy(POLICY_DIRECTION_IMPORT,
dropSameAsPath(targetPeer.conf.NeighborConfig.PeerAs, filterpath(targetPeer, newPathList))))
if targetPeer.fsm.state != bgp.BGP_FSM_ESTABLISHED || len(sendPathList) == 0 {
continue
}
sendPathList = applyPolicies(targetPeer, loc, POLICY_DIRECTION_EXPORT, sendPathList)
sendPathList = targetPeer.ApplyPolicy(POLICY_DIRECTION_EXPORT, sendPathList)
if len(sendPathList) == 0 {
continue
}
@@ -738,8 +681,8 @@ func (server *BgpServer) propagateUpdate(peer *Peer, pathList []*table.Path) []*
msgs = append(msgs, newSenderMsg(targetPeer, msgList))
}
} else {
globalLoc := server.localRibMap[GLOBAL_RIB_NAME]
sendPathList, _ := globalLoc.rib.ProcessPaths(pathList)
rib := server.localRibMap[GLOBAL_RIB_NAME]
sendPathList, _ := rib.ProcessPaths(pathList)
if len(sendPathList) == 0 {
return msgs
}
@@ -775,7 +718,6 @@ func (server *BgpServer) handleFSMMessage(peer *Peer, e *fsmMsg, incoming chan *
oldState := bgp.FSMState(peer.conf.NeighborState.SessionState)
peer.conf.NeighborState.SessionState = uint32(nextState)
peer.fsm.StateChange(nextState)
globalRib := server.localRibMap[GLOBAL_RIB_NAME]
if oldState == bgp.BGP_FSM_ESTABLISHED {
if ch := server.bmpClient.send(); ch != nil {
@@ -811,12 +753,13 @@ func (server *BgpServer) handleFSMMessage(peer *Peer, e *fsmMsg, incoming chan *
}
pathList := make([]*table.Path, 0)
if peer.isRouteServerClient() {
loc := server.localRibMap[peer.conf.NeighborConfig.NeighborAddress.String()]
pathList = applyPolicies(peer, loc, POLICY_DIRECTION_EXPORT, peer.getBests(loc))
rib := server.localRibMap[peer.conf.NeighborConfig.NeighborAddress.String()]
pathList = peer.ApplyPolicy(POLICY_DIRECTION_EXPORT, peer.getBests(rib))
} else {
rib := server.localRibMap[GLOBAL_RIB_NAME]
l, _ := peer.fsm.LocalHostPort()
peer.conf.Transport.TransportConfig.LocalAddress = net.ParseIP(l)
for _, path := range filterpath(peer, peer.getBests(globalRib)) {
for _, path := range filterpath(peer, peer.getBests(rib)) {
p := path.Clone(path.IsWithdraw)
p.UpdatePathAttrs(&server.bgpConfig.Global, &peer.conf)
pathList = append(pathList, p)
@@ -939,17 +882,15 @@ func (server *BgpServer) SetPolicy(pl config.RoutingPolicy) {
func (server *BgpServer) handlePolicy(pl config.RoutingPolicy) {
server.SetPolicy(pl)
for _, loc := range server.localRibMap {
if loc.isGlobal() {
for _, rib := range server.localRibMap {
if rib.OwnerName() == GLOBAL_RIB_NAME {
continue
}
targetPeer := server.neighborMap[loc.OwnerName()]
targetPeer := server.neighborMap[rib.OwnerName()]
log.WithFields(log.Fields{
"Topic": "Peer",
"Key": targetPeer.conf.NeighborConfig.NeighborAddress,
}).Info("call set policy")
loc.setPolicy(targetPeer, server.policyMap)
// set distribute policy
targetPeer.setPolicy(server.policyMap)
}
}
@@ -1132,12 +1073,12 @@ func (server *BgpServer) handleModPathRequest(grpcReq *GrpcRequest) []*table.Pat
rf = bgp.AfiSafiToRouteFamily(nlri.AFI(), nlri.SAFI())
if arg.Resource == api.Resource_VRF {
label, err := server.localRibMap[GLOBAL_RIB_NAME].rib.GetNextLabel(arg.Name, nexthop, path.IsWithdraw)
label, err := server.localRibMap[GLOBAL_RIB_NAME].GetNextLabel(arg.Name, nexthop, path.IsWithdraw)
if err != nil {
result.ResponseErr = err
goto ERR
}
vrf := server.localRibMap[GLOBAL_RIB_NAME].rib.Vrfs[arg.Name]
vrf := server.localRibMap[GLOBAL_RIB_NAME].Vrfs[arg.Name]
switch rf {
case bgp.RF_IPv4_UC:
n := nlri.(*bgp.IPAddrPrefix)
@@ -1172,7 +1113,7 @@ func (server *BgpServer) handleModPathRequest(grpcReq *GrpcRequest) []*table.Pat
macIpAdv := evpnNlri.RouteTypeData.(*bgp.EVPNMacIPAdvertisementRoute)
etag := macIpAdv.ETag
mac := macIpAdv.MacAddress
paths := server.localRibMap[GLOBAL_RIB_NAME].rib.GetBestPathList(bgp.RF_EVPN)
paths := server.localRibMap[GLOBAL_RIB_NAME].GetBestPathList(bgp.RF_EVPN)
if m := getMacMobilityExtendedCommunity(etag, mac, paths); m != nil {
extcomms = append(extcomms, m)
}
@@ -1196,7 +1137,7 @@ ERR:
}
func (server *BgpServer) handleVrfMod(arg *api.ModVrfArguments) ([]*table.Path, error) {
manager := server.localRibMap[GLOBAL_RIB_NAME].rib
rib := server.localRibMap[GLOBAL_RIB_NAME]
var msgs []*table.Path
switch arg.Operation {
case api.Operation_ADD:
@@ -1224,13 +1165,13 @@ func (server *BgpServer) handleVrfMod(arg *api.ModVrfArguments) ([]*table.Path,
AS: server.bgpConfig.Global.GlobalConfig.As,
LocalID: server.bgpConfig.Global.GlobalConfig.RouterId,
}
msgs, err = manager.AddVrf(arg.Vrf.Name, rd, importRt, exportRt, pi)
msgs, err = rib.AddVrf(arg.Vrf.Name, rd, importRt, exportRt, pi)
if err != nil {
return nil, err
}
case api.Operation_DEL:
var err error
msgs, err = manager.DeleteVrf(arg.Vrf.Name)
msgs, err = rib.DeleteVrf(arg.Vrf.Name)
if err != nil {
return nil, err
}
@@ -1247,7 +1188,7 @@ func (server *BgpServer) handleVrfRequest(req *GrpcRequest) []*table.Path {
switch req.RequestType {
case REQ_VRF:
name := req.Name
rib := server.localRibMap[GLOBAL_RIB_NAME].rib
rib := server.localRibMap[GLOBAL_RIB_NAME]
vrfs := rib.Vrfs
if _, ok := vrfs[name]; !ok {
result.ResponseErr = fmt.Errorf("vrf %s not found", name)
@@ -1279,7 +1220,7 @@ func (server *BgpServer) handleVrfRequest(req *GrpcRequest) []*table.Path {
}
goto END
case REQ_VRFS:
vrfs := server.localRibMap[GLOBAL_RIB_NAME].rib.Vrfs
vrfs := server.localRibMap[GLOBAL_RIB_NAME].Vrfs
for _, vrf := range vrfs {
req.ResponseCh <- &GrpcResponse{
Data: vrf.ToApiStruct(),
@@ -1336,11 +1277,11 @@ func (server *BgpServer) handleGrpc(grpcReq *GrpcRequest) []*SenderMsg {
switch grpcReq.RequestType {
case REQ_GLOBAL_RIB:
var results []*GrpcResponse
if t, ok := server.localRibMap[GLOBAL_RIB_NAME].rib.Tables[grpcReq.RouteFamily]; ok {
if t, ok := server.localRibMap[GLOBAL_RIB_NAME].Tables[grpcReq.RouteFamily]; ok {
results = make([]*GrpcResponse, len(t.GetDestinations()))
switch grpcReq.RouteFamily {
case bgp.RF_IPv4_UC, bgp.RF_IPv6_UC:
results = sortedDsts(server.localRibMap[GLOBAL_RIB_NAME].rib.Tables[grpcReq.RouteFamily])
results = sortedDsts(server.localRibMap[GLOBAL_RIB_NAME].Tables[grpcReq.RouteFamily])
default:
i := 0
for _, dst := range t.GetDestinations() {
@@ -1392,11 +1333,11 @@ func (server *BgpServer) handleGrpc(grpcReq *GrpcRequest) []*SenderMsg {
var results []*GrpcResponse
if peer.isRouteServerClient() && peer.fsm.adminState != ADMIN_STATE_DOWN {
remoteAddr := grpcReq.Name
if t, ok := server.localRibMap[remoteAddr].rib.Tables[grpcReq.RouteFamily]; ok {
if t, ok := server.localRibMap[remoteAddr].Tables[grpcReq.RouteFamily]; ok {
results = make([]*GrpcResponse, len(t.GetDestinations()))
switch grpcReq.RouteFamily {
case bgp.RF_IPv4_UC, bgp.RF_IPv6_UC:
results = sortedDsts(server.localRibMap[remoteAddr].rib.Tables[grpcReq.RouteFamily])
results = sortedDsts(server.localRibMap[remoteAddr].Tables[grpcReq.RouteFamily])
default:
i := 0
for _, dst := range t.GetDestinations() {
@@ -1547,15 +1488,6 @@ func (server *BgpServer) handleGrpc(grpcReq *GrpcRequest) []*SenderMsg {
if err != nil {
break
}
loc := server.localRibMap[peer.conf.NeighborConfig.NeighborAddress.String()]
if loc == nil {
result := &GrpcResponse{
ResponseErr: fmt.Errorf("no local rib for %s", peer.conf.NeighborConfig.NeighborAddress.String()),
}
grpcReq.ResponseCh <- result
close(grpcReq.ResponseCh)
break
}
extract := func(policyNames []string) []*api.PolicyDefinition {
pdList := server.routingPolicy.PolicyDefinitions.PolicyDefinitionList
@@ -1593,10 +1525,10 @@ func (server *BgpServer) handleGrpc(grpcReq *GrpcRequest) []*SenderMsg {
defaultImportPolicy := policy.ROUTE_REJECT
defaultExportPolicy := policy.ROUTE_REJECT
defaultInPolicy := policy.ROUTE_REJECT
if loc.defaultImportPolicy == config.DEFAULT_POLICY_TYPE_ACCEPT_ROUTE {
if peer.defaultImportPolicy == config.DEFAULT_POLICY_TYPE_ACCEPT_ROUTE {
defaultImportPolicy = policy.ROUTE_ACCEPT
}
if loc.defaultExportPolicy == config.DEFAULT_POLICY_TYPE_ACCEPT_ROUTE {
if peer.defaultExportPolicy == config.DEFAULT_POLICY_TYPE_ACCEPT_ROUTE {
defaultExportPolicy = policy.ROUTE_ACCEPT
}
if peer.defaultInPolicy == config.DEFAULT_POLICY_TYPE_ACCEPT_ROUTE {
@@ -1655,17 +1587,7 @@ func (server *BgpServer) handleGrpc(grpcReq *GrpcRequest) []*SenderMsg {
applyPolicy.InPolicy = make([]string, 0)
}
if grpcReq.RequestType == REQ_NEIGHBOR_POLICY_ADD_IN ||
grpcReq.RequestType == REQ_NEIGHBOR_POLICY_DEL_IN {
peer.setPolicy(reqPolicyMap)
} else {
loc, ok := server.localRibMap[peer.conf.NeighborConfig.NeighborAddress.String()]
if ok {
loc.setPolicy(peer, reqPolicyMap)
} else {
result.ResponseErr = fmt.Errorf("no local rib for %s", peer.conf.NeighborConfig.NeighborAddress.String())
}
}
peer.setPolicy(reqPolicyMap)
grpcReq.ResponseCh <- result
close(grpcReq.ResponseCh)
@@ -2318,24 +2240,24 @@ func (server *BgpServer) handleMrt(grpcReq *GrpcRequest) {
now := uint32(time.Now().Unix())
view := ""
result := &GrpcResponse{}
var manager *table.TableManager
var rib *table.TableManager
switch grpcReq.RequestType {
case REQ_MRT_GLOBAL_RIB:
manager = server.localRibMap[GLOBAL_RIB_NAME].rib
rib = server.localRibMap[GLOBAL_RIB_NAME]
case REQ_MRT_LOCAL_RIB:
_, err := server.checkNeighborRequest(grpcReq)
if err != nil {
return
}
loc, ok := server.localRibMap[grpcReq.Name]
var ok bool
rib, ok = server.localRibMap[grpcReq.Name]
if !ok {
result.ResponseErr = fmt.Errorf("no local rib for %s", grpcReq.Name)
grpcReq.ResponseCh <- result
close(grpcReq.ResponseCh)
return
}
manager = loc.rib
view = grpcReq.Name
}
@@ -2354,7 +2276,7 @@ func (server *BgpServer) handleMrt(grpcReq *GrpcRequest) {
return
}
tbl, ok := manager.Tables[grpcReq.RouteFamily]
tbl, ok := rib.Tables[grpcReq.RouteFamily]
if !ok {
result.ResponseErr = fmt.Errorf("unsupported route family: %s", grpcReq.RouteFamily)
grpcReq.ResponseCh <- result