From eaa7810893c10d2768e61306e38859e80da01111 Mon Sep 17 00:00:00 2001 From: ISHIDA Wataru Date: Wed, 30 Sep 2015 14:56:42 +0900 Subject: server: kill LocalRib Signed-off-by: ISHIDA Wataru --- server/peer.go | 169 +++++++++++++++++++------------------------------- server/server.go | 184 ++++++++++++++++--------------------------------------- 2 files changed, 117 insertions(+), 236 deletions(-) (limited to 'server') diff --git a/server/peer.go b/server/peer.go index 2d3b4083..3b0bd44b 100644 --- a/server/peer.go +++ b/server/peer.go @@ -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_IN: + return peer.inPolicies + case POLICY_DIRECTION_IMPORT: + return peer.importPolicies case POLICY_DIRECTION_EXPORT: - policies = loc.exportPolicies + return peer.exportPolicies + } + return nil +} + +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: - policies = loc.importPolicies + def = peer.defaultImportPolicy + case POLICY_DIRECTION_EXPORT: + def = peer.defaultExportPolicy } - return applyPolicy("Loc", loc.OwnerName(), d, policies, original) + + if def == config.DEFAULT_POLICY_TYPE_ACCEPT_ROUTE { + return policy.ROUTE_TYPE_ACCEPT + } + return policy.ROUTE_TYPE_REJECT } -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) 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 } diff --git a/server/server.go b/server/server.go index a989e48d..9d444a32 100644 --- a/server/server.go +++ b/server/server.go @@ -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 -- cgit v1.2.3