diff options
| -rw-r--r-- | policy/policy.go | 71 | ||||
| -rw-r--r-- | server/peer.go | 21 | ||||
| -rw-r--r-- | test/scenario_test/constant.py | 2 | ||||
| -rw-r--r-- | test/scenario_test/docker_control.py | 41 | ||||
| -rw-r--r-- | test/scenario_test/gobgp_test.py | 28 | ||||
| -rw-r--r-- | test/scenario_test/quagga-rsconfig.go | 528 | ||||
| -rw-r--r-- | test/scenario_test/quagga_access.py | 17 | ||||
| -rw-r--r-- | test/scenario_test/route_server_policy_test.py | 992 |
8 files changed, 1572 insertions, 128 deletions
diff --git a/policy/policy.go b/policy/policy.go index b97f055f..32799d43 100644 --- a/policy/policy.go +++ b/policy/policy.go @@ -238,7 +238,11 @@ func (c *PrefixCondition) evaluate(path table.Path) bool { for _, cp := range c.PrefixList { if ipPrefixCalculate(path, cp) { - log.Debug("prefix matched : ", cp) + log.WithFields(log.Fields{ + "Topic": "Policy", + "Prefix": cp.Address.String(), + }).Debug("prefix matched") + return true } } @@ -284,7 +288,10 @@ func (c *NeighborCondition) evaluate(path table.Path) bool { cAddr := neighbor pAddr := path.GetSource().Address if pAddr.Equal(cAddr) { - log.Debug("neighbor matched : ", pAddr.String()) + log.WithFields(log.Fields{ + "Topic": "Policy", + "NeighborAddress": pAddr.String(), + }).Debug("neighbor matched") return true } } @@ -329,20 +336,30 @@ func NewAsPathLengthCondition(defAsPathLength config.AsPathLength) *AsPathLength func (c *AsPathLengthCondition) evaluate(path table.Path) bool { length := uint32(path.GetAsPathLen()) + result := false switch c.Operator { case ATTRIBUTE_EQ: - return c.Value == length + result = c.Value == length case ATTRIBUTE_GE: - return c.Value <= length + result = c.Value <= length case ATTRIBUTE_LE: - return c.Value >= length + result = c.Value >= length default: return false } + if result { + log.WithFields(log.Fields{ + "Topic": "Policy", + "Condition": "aspath length", + "Reason": c.Operator, + }).Debug("condition matched") + } + + return result } type AsPathCondition struct { @@ -455,7 +472,12 @@ func (c *AsPathCondition) evaluate(path table.Path) bool { } if matched { - log.Debugf("aspath matched : asn=%d, pos=%v)", member.asn, member.postiion) + log.WithFields(log.Fields{ + "Topic": "Policy", + "Condition": "aspath length", + "ASN": member.asn, + "Position": member.postiion, + }).Debug("condition matched") return true } @@ -599,25 +621,38 @@ func (c *CommunityCondition) evaluate(path table.Path) bool { return false } - // create community string in advance. - strCommunities := make([]string, len(communities)) - for i, c := range communities { + makeStr := func(c uint32) string { upper := strconv.FormatUint(uint64(c&0xFFFF0000>>16), 10) lower := strconv.FormatUint(uint64(c&0x0000FFFF), 10) - strCommunities[i] = upper + ":" + lower + return upper + ":" + lower } + var strCommunities []string = nil matched := false idx := -1 for _, member := range c.CommunityList { if member.isRegExp { + + if strCommunities == nil { + // create community string. + strCommunities = make([]string, len(communities)) + for i, c := range communities { + strCommunities[i] = makeStr(c) + } + } + for i, c := range strCommunities { if member.communityRegExp.MatchString(c) { matched = true idx = i + log.WithFields(log.Fields{ + "Topic": "Policy", + "RegExp": member.communityRegExp.String(), + }).Debug("community regexp used") break } } + } else { for i, c := range communities { if c == member.community { @@ -629,7 +664,12 @@ func (c *CommunityCondition) evaluate(path table.Path) bool { } if matched { - log.Debugf("community matched : community=%s)", strCommunities[idx]) + log.WithFields(log.Fields{ + "Topic": "Policy", + "Condition": "Community", + "Community": makeStr(communities[idx]), + }).Debug("condition matched") + return true } } @@ -689,6 +729,10 @@ func NewCommunityAction(action config.SetCommunity) *CommunityAction { m := &CommunityAction{} + if len(action.Communities) == 0 && action.Options != COMMUNITY_ACTION_NULL{ + return nil + } + values := make([]uint32, len(action.Communities)) for i, com := range action.Communities { matched, value := getCommunityValue(com) @@ -811,10 +855,11 @@ func (p *Policy) Apply(path table.Path) (bool, RouteType, table.Path) { p = statement.routingAction.apply(path) if p != nil { // apply all modification actions + cloned := path.Clone(p.IsWithdraw()) for _, action := range statement.modificationActions { - p = action.apply(p) + cloned = action.apply(cloned) } - return true, ROUTE_TYPE_ACCEPT, p + return true, ROUTE_TYPE_ACCEPT, cloned } else { return true, ROUTE_TYPE_REJECT, nil } diff --git a/server/peer.go b/server/peer.go index 46db99a9..63c907ee 100644 --- a/server/peer.go +++ b/server/peer.go @@ -695,20 +695,23 @@ func (peer *Peer) sendUpdateMsgFromPaths(pList []table.Path) { } if !path.IsWithdraw() { - applied, path := peer.applyPolicies(peer.exportPolicies, path) - if applied && path == nil { - log.WithFields(log.Fields{ - "Topic": "Peer", - "Key": peer.peerConfig.NeighborAddress, - "Data": path, - }).Debug("Export policy applied, reject.") - continue + var applied bool = false + applied, path = peer.applyPolicies(peer.exportPolicies, path) + if applied { + if path == nil { + log.WithFields(log.Fields{ + "Topic": "Peer", + "Key": peer.peerConfig.NeighborAddress, + "Data": path, + }).Debug("Export policy applied and rejected.") + continue + } } else if peer.defaultExportPolicy != config.DEFAULT_POLICY_TYPE_ACCEPT_ROUTE { log.WithFields(log.Fields{ "Topic": "Peer", "Key": peer.peerConfig.NeighborAddress, "Data": path, - }).Debug("Default export policy applied, reject.") + }).Debug("Default export policy applied and rejected.") continue } } diff --git a/test/scenario_test/constant.py b/test/scenario_test/constant.py index a5132022..ebcf897c 100644 --- a/test/scenario_test/constant.py +++ b/test/scenario_test/constant.py @@ -33,6 +33,7 @@ EXABGP_CONTAINER_NAME = "exabgp" EXABGP_ADDRESS = "10.0.0.100/16" EXABGP_CONFDIR = SHARE_VOLUME + "/exabgp_test_conf" EXABGP_LOG_FILE = "exabgpd.log" +EXABGP_COMMON_CONF = "exabgp-gobgp-common.conf" STARTUP_FILE_NAME = "gobgp_startup.sh" STARTUP_FILE = SHARE_VOLUME + "/" + STARTUP_FILE_NAME INSTALL_FILE_NAME = "gobgp_install.sh" @@ -59,6 +60,7 @@ BASE_MASK = {IPv4: "/16", IPv6: "/64"} A_PART_OF_CURRENT_DIR = "/test/scenario_test" + ADJ_RIB_IN = "adj-in" ADJ_RIB_OUT = "adj-out" LOCAL_RIB = "local" diff --git a/test/scenario_test/docker_control.py b/test/scenario_test/docker_control.py index ec2d8397..13118ea8 100644 --- a/test/scenario_test/docker_control.py +++ b/test/scenario_test/docker_control.py @@ -278,7 +278,7 @@ def get_notification_from_exabgp_log(): return err_mgs -def make_config(quagga_num, go_path, bridge, peer_opts=""): +def make_config(quagga_num, go_path, bridge, peer_opts="", policy_pattern=""): if go_path != "": print "specified go path is [ " + go_path + " ]." if os.path.isdir(go_path): @@ -286,8 +286,13 @@ def make_config(quagga_num, go_path, bridge, peer_opts=""): else: print "specified go path do not use." pwd = local("pwd", capture=True) + + pp = '' + if policy_pattern: + pp = " -p " + policy_pattern + cmd = go_path + "go run " + pwd + "/quagga-rsconfig.go -n " + str(quagga_num) +\ - " -c /tmp/gobgp -v " + IP_VERSION + " -i " + bridge["BRIDGE_NAME"][-1] + " " + peer_opts + " -c /tmp/gobgp -v " + IP_VERSION + pp +" -i " + bridge["BRIDGE_NAME"][-1] + " " + peer_opts local(cmd, capture=True) @@ -319,7 +324,7 @@ def update_policy_config(go_path, policy_pattern=""): reload_config() -def make_config_append(quagga_num, go_path, bridge, peer_opts=""): +def make_config_append(quagga_num, go_path, bridge, peer_opts="", policy_pattern=""): if go_path != "": print "specified go path is [ " + go_path + " ]." if os.path.isdir(go_path): @@ -327,8 +332,13 @@ def make_config_append(quagga_num, go_path, bridge, peer_opts=""): else: print "specified go path do not use." pwd = local("pwd", capture=True) + + pp = '' + if policy_pattern: + pp = " -p " + policy_pattern + cmd = go_path + "go run " + pwd + "/quagga-rsconfig.go -a " + str(quagga_num) +\ - " -c /tmp/gobgp -v " + IP_VERSION + " -i " + bridge["BRIDGE_NAME"][-1] + " " + peer_opts + " -c /tmp/gobgp -v " + IP_VERSION + pp +" -i " + bridge["BRIDGE_NAME"][-1] + " " + peer_opts local(cmd, capture=True) @@ -390,7 +400,8 @@ def init_test_env_executor(quagga_num, use_local, go_path, log_debug=False, is_r print "complete initialization of test environment." -def init_policy_test_env_executor(quagga_num, use_local, go_path, log_debug=False, policy="", use_ipv6=False): +def init_policy_test_env_executor(quagga_num, use_local, go_path, log_debug=False, policy="", + use_ipv6=False, use_exabgp=False): print "start initialization of test environment." if docker_container_check() or bridge_setting_check(): @@ -404,13 +415,23 @@ def init_policy_test_env_executor(quagga_num, use_local, go_path, log_debug=Fals if use_ipv6: global IP_VERSION IP_VERSION = IPv6 + else: + global IP_VERSION + IP_VERSION = IPv4 bridge_setting_for_docker_connection(BRIDGES) - make_config_with_policy(quagga_num, go_path, BRIDGE_0, policy_pattern=policy) + make_config(quagga_num, go_path, BRIDGE_0, policy_pattern=policy) # run gobgp docker container docker_container_run_gobgp(BRIDGE_0) + if use_exabgp: + # run exabgp + make_config_append(100, go_path, BRIDGE_0, peer_opts="--none-peer", policy_pattern=policy) + docker_container_run_exabgp(BRIDGE_0) + cmd = "docker exec exabgp cp -rf " + SHARE_VOLUME + "/exabgp /root/" + local(cmd, capture=True) + # set log option opt = "-l debug" if log_debug else "" @@ -425,8 +446,8 @@ def init_policy_test_env_executor(quagga_num, use_local, go_path, log_debug=Fals local(cmd, capture=True) make_install_file(use_local=True) else: - print "scenario_test directory is not." - print "execute gobgp program of osrg/master in github." + print "local gobgp dosen't exist." + print "get the latest master gobgp from github." make_install_file() else: print "execute gobgp program of osrg/master in github." @@ -439,6 +460,10 @@ def init_policy_test_env_executor(quagga_num, use_local, go_path, log_debug=Fals for num in range(1, quagga_num + 1): docker_container_run_quagga(num, BRIDGE_0) + # start exabgp + if use_exabgp: + start_exabgp(EXABGP_COMMON_CONF) + print "complete initialization of test environment." diff --git a/test/scenario_test/gobgp_test.py b/test/scenario_test/gobgp_test.py index 4fc39ffc..030bf9c4 100644 --- a/test/scenario_test/gobgp_test.py +++ b/test/scenario_test/gobgp_test.py @@ -297,6 +297,34 @@ class GoBGPTestBase(unittest.TestCase): print "route : %s is none" % target_prefix return None + + # get route information on quagga + def check_community(self, neighbor_address, target_addr, community, retry=3, interval=-1, af=IPv4): + if interval < 0: + interval = self.wait_per_retry + print "check route %s on quagga : %s" % (target_addr, neighbor_address) + retry_count = 0 + + while True: + tn = qaccess.login(neighbor_address) + result = qaccess.check_community(tn, target_addr, community, af) + qaccess.logout(tn) + + if result: + return True + else: + print "target path %s with community %s is none" % (target_addr, community) + + retry_count += 1 + if retry_count > retry: + break + else: + print "wait (" + str(interval) + " seconds)" + time.sleep(interval) + + return False + + def compare_rib_with_quagga_configs(self, rib_owner_addr, local_rib): for quagga_config in self.quagga_configs: diff --git a/test/scenario_test/quagga-rsconfig.go b/test/scenario_test/quagga-rsconfig.go index 577c1f83..0551959f 100644 --- a/test/scenario_test/quagga-rsconfig.go +++ b/test/scenario_test/quagga-rsconfig.go @@ -98,10 +98,7 @@ func create_config_files(nr int, outputDir string, IPVersion string, nonePeer bo }, } - var binding *PolicyBinding - if policyPattern != "" { - binding = bindPolicy(policyPattern) - } + var policyConf *config.RoutingPolicy for i := 1; i < nr+1; i++ { c := config.Neighbor{ @@ -114,17 +111,7 @@ func create_config_files(nr int, outputDir string, IPVersion string, nonePeer bo PeerType: config.PEER_TYPE_EXTERNAL, } - if binding != nil { - ip := net.ParseIP(binding.NeighborAddress) - if ip.String() == c.NeighborAddress.String() { - ap := config.ApplyPolicy{ - ImportPolicies: binding.ImportPolicyNames, - ExportPolicies: binding.ExportPolicyNames, - } - c.ApplyPolicy = ap - } - - } + policyConf = bindPolicy(&c, policyPattern) gobgpConf.NeighborList = append(gobgpConf.NeighborList, c) if !nonePeer { @@ -146,8 +133,8 @@ func create_config_files(nr int, outputDir string, IPVersion string, nonePeer bo var buffer bytes.Buffer encoder := toml.NewEncoder(&buffer) encoder.Encode(gobgpConf) - if binding != nil { - encoder.Encode(binding.Policy) + if policyConf != nil { + encoder.Encode(policyConf) } err := ioutil.WriteFile(fmt.Sprintf("%s/gobgpd.conf", outputDir), buffer.Bytes(), 0644) @@ -156,7 +143,7 @@ func create_config_files(nr int, outputDir string, IPVersion string, nonePeer bo } } -func append_config_files(ar int, outputDir string, IPVersion string, nonePeer bool, normalBGP bool) { +func append_config_files(ar int, outputDir string, IPVersion string, noQuagga bool, normalBGP bool, policyPattern string) { gobgpConf := config.Bgp{ Global: config.Global{ @@ -173,7 +160,10 @@ func append_config_files(ar int, outputDir string, IPVersion string, nonePeer bo Timers: config.Timers{HoldTime: 30, KeepaliveInterval: 10, IdleHoldTimeAfterReset: 10}, PeerType: config.PEER_TYPE_EXTERNAL, } - if !nonePeer { + + bindPolicy(&c, policyPattern) + + if !noQuagga { q := NewQuaggaConfig(ar, &gobgpConf.Global, &c, net.ParseIP(serverAddress[IPVersion])) os.Mkdir(fmt.Sprintf("%s/q%d", outputDir, ar), 0755) var err error @@ -195,6 +185,17 @@ func append_config_files(ar int, outputDir string, IPVersion string, nonePeer bo var buffer bytes.Buffer encoder := toml.NewEncoder(&buffer) encoder.Encode(newConf) + + policyConf := &config.RoutingPolicy{} + _, p_err := toml.DecodeFile(fmt.Sprintf("%s/gobgpd.conf", outputDir), policyConf) + if p_err != nil { + log.Fatal(p_err) + } + + if policyConf != nil && len(policyConf.PolicyDefinitionList) != 0 { + encoder.Encode(policyConf) + } + e_err := ioutil.WriteFile(fmt.Sprintf("%s/gobgpd.conf", outputDir), buffer.Bytes(), 0644) if e_err != nil { log.Fatal(e_err) @@ -265,32 +266,79 @@ func createPolicyConfig() *config.RoutingPolicy { }}, } - ns0 := config.NeighborSet{ - NeighborSetName: "ns0", + nsPeer2 := config.NeighborSet{ + NeighborSetName: "nsPeer2", NeighborInfoList: []config.NeighborInfo{ config.NeighborInfo{ Address: net.ParseIP("10.0.0.2"), }}, } - ns1 := config.NeighborSet{ - NeighborSetName: "ns1", + nsPeer2V6 := config.NeighborSet{ + NeighborSetName: "nsPeer2V6", NeighborInfoList: []config.NeighborInfo{ config.NeighborInfo{ Address: net.ParseIP("2001::0:192:168:0:2"), }}, } + nsExabgp := config.NeighborSet{ + NeighborSetName: "nsExabgp", + NeighborInfoList: []config.NeighborInfo{ + config.NeighborInfo{ + Address: net.ParseIP("10.0.0.100"), + }}, + } + + psExabgp := config.PrefixSet{ + PrefixSetName: "psExabgp", + PrefixList: []config.Prefix{ + config.Prefix{ + Address: net.ParseIP("192.168.100.0"), + Masklength: 24, + MasklengthRange: "16..24", + }}, + } + + aspathFrom := config.AsPathSet{ + AsPathSetName: "aspathFrom", + AsPathSetMembers: []string{"^65100"}, + } + + aspathAny := config.AsPathSet{ + AsPathSetName: "aspAny", + AsPathSetMembers: []string{"65098"}, + } + + aspathOrigin := config.AsPathSet{ + AsPathSetName: "aspOrigin", + AsPathSetMembers: []string{"65091$"}, + } + + aspathOnly := config.AsPathSet{ + AsPathSetName: "aspOnly", + AsPathSetMembers: []string{"^65100$"}, + } + + comStr := config.CommunitySet{ + CommunitySetName: "comStr", + CommunityMembers: []string{"65100:10"}, + } + + comRegExp := config.CommunitySet{ + CommunitySetName: "comRegExp", + CommunityMembers: []string{"6[0-9]+:[0-9]+"}, + } + st0 := config.Statement{ Name: "st0", Conditions: config.Conditions{ MatchPrefixSet: "ps0", - MatchNeighborSet: "ns0", + MatchNeighborSet: "nsPeer2", MatchSetOptions: config.MATCH_SET_OPTIONS_TYPE_ALL, }, Actions: config.Actions{ AcceptRoute: false, - RejectRoute: true, }, } @@ -298,12 +346,11 @@ func createPolicyConfig() *config.RoutingPolicy { Name: "st1", Conditions: config.Conditions{ MatchPrefixSet: "ps1", - MatchNeighborSet: "ns0", + MatchNeighborSet: "nsPeer2", MatchSetOptions: config.MATCH_SET_OPTIONS_TYPE_ALL, }, Actions: config.Actions{ AcceptRoute: false, - RejectRoute: true, }, } @@ -311,12 +358,11 @@ func createPolicyConfig() *config.RoutingPolicy { Name: "st3", Conditions: config.Conditions{ MatchPrefixSet: "ps3", - MatchNeighborSet: "ns1", + MatchNeighborSet: "nsPeer2V6", MatchSetOptions: config.MATCH_SET_OPTIONS_TYPE_ALL, }, Actions: config.Actions{ AcceptRoute: false, - RejectRoute: true, }, } @@ -324,44 +370,297 @@ func createPolicyConfig() *config.RoutingPolicy { Name: "st4", Conditions: config.Conditions{ MatchPrefixSet: "ps4", - MatchNeighborSet: "ns1", + MatchNeighborSet: "nsPeer2V6", MatchSetOptions: config.MATCH_SET_OPTIONS_TYPE_ALL, }, Actions: config.Actions{ AcceptRoute: false, - RejectRoute: true, }, } - pd0 := config.PolicyDefinition{ - Name: "policy0", + st_aspathlen := config.Statement{ + Name: "st_aspathlen", + Conditions: config.Conditions{ + MatchPrefixSet: "psExabgp", + MatchNeighborSet: "nsExabgp", + BgpConditions: config.BgpConditions{ + AsPathLength: config.AsPathLength{ + Operator: "ge", + Value: 10, + }, + }, + MatchSetOptions: config.MATCH_SET_OPTIONS_TYPE_ALL, + }, + Actions: config.Actions{ + AcceptRoute: false, + }, + } + + st_aspathFrom := config.Statement{ + Name: "st_aspathlen", + Conditions: config.Conditions{ + MatchPrefixSet: "psExabgp", + MatchNeighborSet: "nsExabgp", + BgpConditions: config.BgpConditions{ + MatchAsPathSet: "aspathFrom", + }, + MatchSetOptions: config.MATCH_SET_OPTIONS_TYPE_ALL, + }, + Actions: config.Actions{ + AcceptRoute: false, + }, + } + + st_aspathAny := config.Statement{ + Name: "st_aspathlen", + Conditions: config.Conditions{ + MatchPrefixSet: "psExabgp", + MatchNeighborSet: "nsExabgp", + BgpConditions: config.BgpConditions{ + MatchAsPathSet: "aspAny", + }, + MatchSetOptions: config.MATCH_SET_OPTIONS_TYPE_ALL, + }, + Actions: config.Actions{ + AcceptRoute: false, + }, + } + + st_aspathOrigin := config.Statement{ + Name: "st_aspathlen", + Conditions: config.Conditions{ + MatchPrefixSet: "psExabgp", + MatchNeighborSet: "nsExabgp", + BgpConditions: config.BgpConditions{ + MatchAsPathSet: "aspOrigin", + }, + MatchSetOptions: config.MATCH_SET_OPTIONS_TYPE_ALL, + }, + Actions: config.Actions{ + AcceptRoute: false, + }, + } + + st_aspathOnly := config.Statement{ + Name: "st_aspathlen", + Conditions: config.Conditions{ + MatchPrefixSet: "psExabgp", + MatchNeighborSet: "nsExabgp", + BgpConditions: config.BgpConditions{ + MatchAsPathSet: "aspOnly", + }, + MatchSetOptions: config.MATCH_SET_OPTIONS_TYPE_ALL, + }, + Actions: config.Actions{ + AcceptRoute: false, + }, + } + + st_comStr := config.Statement{ + Name: "st_community", + Conditions: config.Conditions{ + MatchPrefixSet: "psExabgp", + MatchNeighborSet: "nsExabgp", + BgpConditions: config.BgpConditions{ + MatchCommunitySet: "comStr", + }, + MatchSetOptions: config.MATCH_SET_OPTIONS_TYPE_ALL, + }, + Actions: config.Actions{ + AcceptRoute: false, + }, + } + + st_comRegExp := config.Statement{ + Name: "st_community_regexp", + Conditions: config.Conditions{ + MatchPrefixSet: "psExabgp", + MatchNeighborSet: "nsExabgp", + BgpConditions: config.BgpConditions{ + MatchCommunitySet: "comRegExp", + }, + MatchSetOptions: config.MATCH_SET_OPTIONS_TYPE_ALL, + }, + Actions: config.Actions{ + AcceptRoute: false, + }, + } + + st_comAdd := config.Statement{ + Name: "st_community_regexp", + Conditions: config.Conditions{ + MatchPrefixSet: "psExabgp", + MatchNeighborSet: "nsExabgp", + BgpConditions: config.BgpConditions{ + MatchCommunitySet: "comStr", + }, + MatchSetOptions: config.MATCH_SET_OPTIONS_TYPE_ALL, + }, + Actions: config.Actions{ + AcceptRoute: true, + BgpActions: config.BgpActions{ + SetCommunity: config.SetCommunity{ + Communities: []string{"65100:20"}, + Options: "ADD", + }, + }, + }, + } + + st_comReplace := config.Statement{ + Name: "st_community_regexp", + Conditions: config.Conditions{ + MatchPrefixSet: "psExabgp", + MatchNeighborSet: "nsExabgp", + BgpConditions: config.BgpConditions{ + MatchCommunitySet: "comStr", + }, + MatchSetOptions: config.MATCH_SET_OPTIONS_TYPE_ALL, + }, + Actions: config.Actions{ + AcceptRoute: true, + BgpActions: config.BgpActions{ + SetCommunity: config.SetCommunity{ + Communities: []string{"65100:20", "65100:30"}, + Options: "REPLACE", + }, + }, + }, + } + + st_comRemove := config.Statement{ + Name: "st_community_regexp", + Conditions: config.Conditions{ + MatchPrefixSet: "psExabgp", + MatchNeighborSet: "nsExabgp", + BgpConditions: config.BgpConditions{ + MatchCommunitySet: "comStr", + }, + MatchSetOptions: config.MATCH_SET_OPTIONS_TYPE_ALL, + }, + Actions: config.Actions{ + AcceptRoute: true, + BgpActions: config.BgpActions{ + SetCommunity: config.SetCommunity{ + Communities: []string{"65100:20", "65100:30"}, + Options: "REMOVE", + }, + }, + }, + } + + st_comNull := config.Statement{ + Name: "st_community_regexp", + Conditions: config.Conditions{ + MatchPrefixSet: "psExabgp", + MatchNeighborSet: "nsExabgp", + BgpConditions: config.BgpConditions{ + MatchCommunitySet: "comStr", + }, + MatchSetOptions: config.MATCH_SET_OPTIONS_TYPE_ALL, + }, + Actions: config.Actions{ + AcceptRoute: true, + BgpActions: config.BgpActions{ + SetCommunity: config.SetCommunity{ + Communities: []string{}, + Options: "NULL", + }, + }, + }, + } + + pdImportV4 := config.PolicyDefinition{ + Name: "policy_use_ps0", StatementList: []config.Statement{st0}, } - pd1 := config.PolicyDefinition{ - Name: "policy1", + pdExportV4 := config.PolicyDefinition{ + Name: "policy_use_ps1", StatementList: []config.Statement{st1}, } - pd2 := config.PolicyDefinition{ - Name: "policy2", + pdImportV6 := config.PolicyDefinition{ + Name: "policy_use_ps3", StatementList: []config.Statement{st3}, } - pd3 := config.PolicyDefinition{ - Name: "policy3", + pdExportV6 := config.PolicyDefinition{ + Name: "policy_use_ps4", StatementList: []config.Statement{st4}, } + pdAspathlen := config.PolicyDefinition{ + Name: "policy_aspathlen", + StatementList: []config.Statement{st_aspathlen}, + } + + pdaspathFrom := config.PolicyDefinition{ + Name: "policy_aspathFrom", + StatementList: []config.Statement{st_aspathFrom}, + } + + pdaspathAny := config.PolicyDefinition{ + Name: "policy_aspathAny", + StatementList: []config.Statement{st_aspathAny}, + } + + pdaspathOrigin := config.PolicyDefinition{ + Name: "policy_aspathOrigin", + StatementList: []config.Statement{st_aspathOrigin}, + } + + pdaspathOnly := config.PolicyDefinition{ + Name: "policy_aspathOnly", + StatementList: []config.Statement{st_aspathOnly}, + } + + pdCommunity := config.PolicyDefinition{ + Name: "policy_community", + StatementList: []config.Statement{st_comStr}, + } + + pdCommunityRegExp := config.PolicyDefinition{ + Name: "policy_community_regexp", + StatementList: []config.Statement{st_comRegExp}, + } + + pdCommunityAdd := config.PolicyDefinition{ + Name: "policy_community_add", + StatementList: []config.Statement{st_comAdd}, + } + + pdCommunityReplace := config.PolicyDefinition{ + Name: "policy_community_replace", + StatementList: []config.Statement{st_comReplace}, + } + + pdCommunityRemove := config.PolicyDefinition{ + Name: "policy_community_remove", + StatementList: []config.Statement{st_comRemove}, + } + + pdCommunityNull := config.PolicyDefinition{ + Name: "policy_community_null", + StatementList: []config.Statement{st_comNull}, + } + ds := config.DefinedSets{ - PrefixSetList: []config.PrefixSet{ps0, ps1, ps2, ps3, ps4, ps5}, - NeighborSetList: []config.NeighborSet{ns0, ns1}, + PrefixSetList: []config.PrefixSet{ps0, ps1, ps2, ps3, ps4, ps5, psExabgp}, + NeighborSetList: []config.NeighborSet{nsPeer2, nsPeer2V6, nsExabgp}, + BgpDefinedSets: config.BgpDefinedSets{ + AsPathSetList: []config.AsPathSet{aspathFrom, aspathAny, aspathOrigin, aspathOnly}, + CommunitySetList: []config.CommunitySet{comStr, comRegExp}, + }, } p := &config.RoutingPolicy{ - DefinedSets: ds, - PolicyDefinitionList: []config.PolicyDefinition{pd0, pd1, pd2, pd3}, + DefinedSets: ds, + PolicyDefinitionList: []config.PolicyDefinition{pdImportV4, pdExportV4, pdImportV6, pdExportV6, + pdAspathlen, pdaspathFrom, pdaspathAny, pdaspathOrigin, pdaspathOnly, + pdCommunity, pdCommunityRegExp, pdCommunityAdd, pdCommunityReplace, pdCommunityRemove, pdCommunityNull}, } + return p } @@ -385,7 +684,7 @@ func updatePolicyConfig(outputDir string, pattern string) { Name: "st2", Conditions: config.Conditions{ MatchPrefixSet: "ps2", - MatchNeighborSet: "ns0", + MatchNeighborSet: "nsPeer2", MatchSetOptions: config.MATCH_SET_OPTIONS_TYPE_ALL, }, Actions: config.Actions{ @@ -398,7 +697,7 @@ func updatePolicyConfig(outputDir string, pattern string) { Name: "st5", Conditions: config.Conditions{ MatchPrefixSet: "ps5", - MatchNeighborSet: "ns1", + MatchNeighborSet: "nsPeer2V6", MatchSetOptions: config.MATCH_SET_OPTIONS_TYPE_ALL, }, Actions: config.Actions{ @@ -407,11 +706,11 @@ func updatePolicyConfig(outputDir string, pattern string) { }, } - if pattern == "p3" || pattern == "p4" { + if pattern == "test_03_import_policy_update" || pattern == "test_04_export_policy_update" { policyConf.PolicyDefinitionList[1].StatementList = []config.Statement{st2} } - if pattern == "p7" || pattern == "p8" { + if pattern == "test_07_import_policy_update" || pattern == "test_08_export_policy_update" { policyConf.PolicyDefinitionList[3].StatementList = []config.Statement{st5} } @@ -434,51 +733,130 @@ type PolicyBinding struct { ExportPolicyNames []string } -func bindPolicy(pattern string) *PolicyBinding { +func getPolicyBinding(pattern string) *PolicyBinding { var pb *PolicyBinding = &PolicyBinding{Policy: createPolicyConfig()} switch pattern { - case "p1": + case "test_01_import_policy_initial": pb.NeighborAddress = "10.0.0.3" - pb.ImportPolicyNames = []string{"policy0"} + pb.ImportPolicyNames = []string{"policy_use_ps0"} pb.ExportPolicyNames = nil - case "p2": + case "test_02_export_policy_initial": pb.NeighborAddress = "10.0.0.3" pb.ImportPolicyNames = nil - pb.ExportPolicyNames = []string{"policy0"} + pb.ExportPolicyNames = []string{"policy_use_ps0"} - case "p3": + case "test_03_import_policy_update": pb.NeighborAddress = "10.0.0.3" - pb.ImportPolicyNames = []string{"policy1"} + pb.ImportPolicyNames = []string{"policy_use_ps1"} pb.ExportPolicyNames = nil - case "p4": + case "test_04_export_policy_update": pb.NeighborAddress = "10.0.0.3" pb.ImportPolicyNames = nil - pb.ExportPolicyNames = []string{"policy1"} + pb.ExportPolicyNames = []string{"policy_use_ps1"} - case "p5": + case "test_05_import_policy_initial_ipv6": pb.NeighborAddress = "2001::0:192:168:0:3" - pb.ImportPolicyNames = []string{"policy2"} + pb.ImportPolicyNames = []string{"policy_use_ps3"} pb.ExportPolicyNames = nil - case "p6": + case "test_06_export_policy_initial_ipv6": pb.NeighborAddress = "2001::0:192:168:0:3" pb.ImportPolicyNames = nil - pb.ExportPolicyNames = []string{"policy2"} + pb.ExportPolicyNames = []string{"policy_use_ps3"} - case "p7": + case "test_07_import_policy_update": pb.NeighborAddress = "2001::0:192:168:0:3" - pb.ImportPolicyNames = []string{"policy3"} + pb.ImportPolicyNames = []string{"policy_use_ps4"} pb.ExportPolicyNames = nil - case "p8": + case "test_08_export_policy_update": pb.NeighborAddress = "2001::0:192:168:0:3" pb.ImportPolicyNames = nil - pb.ExportPolicyNames = []string{"policy3"} + pb.ExportPolicyNames = []string{"policy_use_ps4"} + + case "test_09_aspath_length_condition_import": + pb.NeighborAddress = "10.0.0.2" + pb.ImportPolicyNames = []string{"policy_aspathlen"} + pb.ExportPolicyNames = nil + + case "test_10_aspath_from_condition_import": + pb.NeighborAddress = "10.0.0.2" + pb.ImportPolicyNames = []string{"policy_aspathFrom"} + pb.ExportPolicyNames = nil + + case "test_11_aspath_any_condition_import": + pb.NeighborAddress = "10.0.0.2" + pb.ImportPolicyNames = []string{"policy_aspathAny"} + pb.ExportPolicyNames = nil + + case "test_12_aspath_origin_condition_import": + pb.NeighborAddress = "10.0.0.2" + pb.ImportPolicyNames = []string{"policy_aspathOrigin"} + pb.ExportPolicyNames = nil + + case "test_13_aspath_only_condition_import": + pb.NeighborAddress = "10.0.0.2" + pb.ImportPolicyNames = []string{"policy_aspathOnly"} + pb.ExportPolicyNames = nil + + case "test_14_aspath_only_condition_import": + pb.NeighborAddress = "10.0.0.2" + pb.ImportPolicyNames = []string{"policy_aspathOnly"} + pb.ExportPolicyNames = nil + + case "test_15_community_condition_import": + pb.NeighborAddress = "10.0.0.2" + pb.ImportPolicyNames = []string{"policy_community"} + pb.ExportPolicyNames = nil + + case "test_16_community_condition_regexp_import": + pb.NeighborAddress = "10.0.0.2" + pb.ImportPolicyNames = []string{"policy_community_regexp"} + pb.ExportPolicyNames = nil + + case "test_17_community_add_action_import": + pb.NeighborAddress = "10.0.0.2" + pb.ImportPolicyNames = []string{"policy_community_add"} + pb.ExportPolicyNames = nil + + case "test_18_community_replace_action_import": + pb.NeighborAddress = "10.0.0.2" + pb.ImportPolicyNames = []string{"policy_community_replace"} + pb.ExportPolicyNames = nil + + case "test_19_community_remove_action_import": + pb.NeighborAddress = "10.0.0.2" + pb.ImportPolicyNames = []string{"policy_community_remove"} + pb.ExportPolicyNames = nil + + case "test_20_community_null_action_import": + pb.NeighborAddress = "10.0.0.2" + pb.ImportPolicyNames = []string{"policy_community_null"} + pb.ExportPolicyNames = nil + + case "test_21_community_add_action_export": + pb.NeighborAddress = "10.0.0.2" + pb.ImportPolicyNames = nil + pb.ExportPolicyNames = []string{"policy_community_add"} + + case "test_22_community_replace_action_export": + pb.NeighborAddress = "10.0.0.2" + pb.ImportPolicyNames = nil + pb.ExportPolicyNames = []string{"policy_community_replace"} + + case "test_23_community_remove_action_export": + pb.NeighborAddress = "10.0.0.2" + pb.ImportPolicyNames = nil + pb.ExportPolicyNames = []string{"policy_community_remove"} + case "test_24_community_null_action_export": + pb.NeighborAddress = "10.0.0.2" + pb.ImportPolicyNames = nil + pb.ExportPolicyNames = []string{"policy_community_null"} default: pb = nil } @@ -487,6 +865,26 @@ func bindPolicy(pattern string) *PolicyBinding { } +func bindPolicy(c *config.Neighbor, policyPattern string) *config.RoutingPolicy { + var binding *PolicyBinding + if policyPattern != "" { + binding = getPolicyBinding(policyPattern) + } + + if binding != nil { + ip := net.ParseIP(binding.NeighborAddress) + if ip.String() == c.NeighborAddress.String() { + ap := config.ApplyPolicy{ + ImportPolicies: binding.ImportPolicyNames, + ExportPolicies: binding.ExportPolicyNames, + } + c.ApplyPolicy = ap + return binding.Policy + } + } + return nil +} + func main() { var opts struct { ClientNumber int `short:"n" long:"client-number" description:"specfying the number of clients" default:"8"` @@ -537,7 +935,7 @@ func main() { if opts.UpdatePolicy { updatePolicyConfig(opts.OutputDir, opts.PolicyPattern) } else { - append_config_files(opts.AppendClient, opts.OutputDir, opts.IPVersion, opts.NonePeer, opts.NormalBGP) + append_config_files(opts.AppendClient, opts.OutputDir, opts.IPVersion, opts.NonePeer, opts.NormalBGP, opts.PolicyPattern) } } } diff --git a/test/scenario_test/quagga_access.py b/test/scenario_test/quagga_access.py index f29cb301..634dc439 100644 --- a/test/scenario_test/quagga_access.py +++ b/test/scenario_test/quagga_access.py @@ -142,4 +142,19 @@ def lookup_prefix(tn, prefix, af): path['Next Hop'] = nexthop paths.append(path) - return paths
\ No newline at end of file + return paths + +def check_community(tn, addr, community, af=IPv4): + if af == IPv4: + tn.write("show ip bgp community " + community + "\n") + elif af == IPv6: + tn.write("show bgp ipv6 community " + community + "\n") + else: + print "invalid af: ", af + return + result = tn.read_until("bgpd#") + for line in result.split("\n"): + if addr in line: + return True + + return False
\ No newline at end of file diff --git a/test/scenario_test/route_server_policy_test.py b/test/scenario_test/route_server_policy_test.py index 47b2abc6..f673747d 100644 --- a/test/scenario_test/route_server_policy_test.py +++ b/test/scenario_test/route_server_policy_test.py @@ -22,27 +22,41 @@ from noseplugin import OptionParser from noseplugin import parser_option from gobgp_test import GoBGPTestBase from constant import * +from fabric.api import local class GoBGPTest(GoBGPTestBase): quagga_num = 3 + retry_count_common = 2 + initial_wait_time = 5 def __init__(self, *args, **kwargs): super(GoBGPTest, self).__init__(*args, **kwargs) + + def setUp(self): + self.quagga_configs = [] + self.use_ipv6_gobgp = False + self.use_exa_bgp = False + self.retry_count_common = 2 + self.initial_wait_time = 5 + + def initialize(self, policy_pattern=None): use_local = parser_option.use_local go_path = parser_option.go_path log_debug = parser_option.gobgp_log_debug + fab.init_policy_test_env_executor(self.quagga_num, use_local, go_path, log_debug, policy=policy_pattern, - use_ipv6=self.use_ipv6_gobgp) + use_ipv6=self.use_ipv6_gobgp, + use_exabgp=self.use_exa_bgp) print "please wait " + str(self.initial_wait_time) + " second" time.sleep(self.initial_wait_time) - self.assertTrue(self.check_load_config()) + """ import-policy test --------------------------------------- @@ -56,7 +70,7 @@ class GoBGPTest(GoBGPTestBase): # initialize test environment # policy_pattern:p1 attaches a policy to reject route 192.168.0.0/16 (16...24) # coming from peer2(10.0.0.2) to peer3(10.0.0.3)'s import-policy. - self.initialize(policy_pattern="p1") + self.initialize(policy_pattern="test_01_import_policy_initial") addresses = self.get_neighbor_address(self.gobgp_config) self.retry_routine_for_state(addresses, "BGP_FSM_ESTABLISHED") @@ -64,16 +78,16 @@ class GoBGPTest(GoBGPTestBase): peer2 = "10.0.0.2" peer3 = "10.0.0.3" prefix1 = "192.168.2.0/24" - path = self.get_paths_in_localrib(peer1, prefix1, retry=3) + path = self.get_paths_in_localrib(peer1, prefix1, retry=self.retry_count_common) self.assertIsNotNone(path) # check show ip bgp on peer1(quagga1) - qpath = self.get_route(peer1,prefix1, retry=3) + qpath = self.get_route(peer1,prefix1, retry=self.retry_count_common) print qpath self.assertIsNotNone(qpath) # check adj-rib-out in peer2 - path = self.get_adj_rib_in(peer2, prefix1, retry=3) + path = self.get_adj_rib_in(peer2, prefix1, retry=self.retry_count_common) # print path self.assertIsNotNone(path) @@ -82,7 +96,7 @@ class GoBGPTest(GoBGPTestBase): self.assertIsNone(path) # check show ip bgp on peer1(quagga3) - qpath = self.get_route(peer3,prefix1, retry=3) + qpath = self.get_route(peer3,prefix1, retry=self.retry_count_common) # print qpath self.assertIsNone(qpath) @@ -100,7 +114,7 @@ class GoBGPTest(GoBGPTestBase): # initialize test environment # policy_pattern:p1 attaches a policy to reject route 192.168.0.0/16 (16...24) # coming from peer2(10.0.0.2) to peer3(10.0.0.3)'s export-policy. - self.initialize(policy_pattern="p2") + self.initialize(policy_pattern="test_02_export_policy_initial") addresses = self.get_neighbor_address(self.gobgp_config) self.retry_routine_for_state(addresses, "BGP_FSM_ESTABLISHED") @@ -109,12 +123,12 @@ class GoBGPTest(GoBGPTestBase): peer3 = "10.0.0.3" prefix1 = "192.168.2.0/24" - paths = self.get_paths_in_localrib(peer1, prefix1, retry=3) + paths = self.get_paths_in_localrib(peer1, prefix1, retry=self.retry_count_common) # print paths self.assertIsNotNone(paths) # check show ip bgp on peer1(quagga1) - qpath = self.get_route(peer1, prefix1, retry=3) + qpath = self.get_route(peer1, prefix1, retry=self.retry_count_common) # print qpath self.assertIsNotNone(qpath) @@ -132,7 +146,7 @@ class GoBGPTest(GoBGPTestBase): self.assertIsNone(path) # check show ip bgp on peer1(quagga3) - qpath = self.get_route(peer3,prefix1, retry=3) + qpath = self.get_route(peer3,prefix1, retry=self.retry_count_common) # print qpath self.assertIsNone(qpath) @@ -166,7 +180,7 @@ class GoBGPTest(GoBGPTestBase): # policy_pattern:p3 attaches a policy to reject route # 192.168.2.0/24, 192.168.20.0/24, 192.168.200.0/24 # coming from peer2(10.0.0.2) to peer3(10.0.0.3)'s import-policy. - self.initialize(policy_pattern="p3") + self.initialize(policy_pattern="test_03_import_policy_update") peer1 = "10.0.0.1" peer2 = "10.0.0.2" @@ -226,7 +240,7 @@ class GoBGPTest(GoBGPTestBase): # update policy print "update_policy_config" - fab.update_policy_config(parser_option.go_path, policy_pattern="p3") + fab.update_policy_config(parser_option.go_path, policy_pattern="test_03_import_policy_update") time.sleep(self.initial_wait_time) # soft reset @@ -274,7 +288,7 @@ class GoBGPTest(GoBGPTestBase): # policy_pattern:p4 attaches a policy to reject route # 192.168.2.0/24, 192.168.20.0/24, 192.168.200.0/24 # coming from peer2(10.0.0.2) to peer3(10.0.0.3)'s export-policy. - self.initialize(policy_pattern="p4") + self.initialize(policy_pattern="test_04_export_policy_update") peer1 = "10.0.0.1" peer2 = "10.0.0.2" @@ -345,7 +359,7 @@ class GoBGPTest(GoBGPTestBase): # update policy print "update_policy_config" - fab.update_policy_config(parser_option.go_path, policy_pattern="p4") + fab.update_policy_config(parser_option.go_path, policy_pattern="test_04_export_policy_update") time.sleep(self.initial_wait_time) # soft reset @@ -375,7 +389,7 @@ class GoBGPTest(GoBGPTestBase): | | | ->x peer3-rib | -------------------------------------------------- - """ + """ def test_05_import_policy_initial_ipv6(self): # initialize test environment @@ -383,7 +397,7 @@ class GoBGPTest(GoBGPTestBase): # coming from peer2(2001::192:168:0:2) to peer3(2001::192:168:0:3)'s # import-policy. self.use_ipv6_gobgp = True - self.initialize(policy_pattern="p5") + self.initialize(policy_pattern="test_05_import_policy_initial_ipv6") addresses = self.get_neighbor_address(self.gobgp_config) self.retry_routine_for_state(addresses, "BGP_FSM_ESTABLISHED") @@ -394,18 +408,15 @@ class GoBGPTest(GoBGPTestBase): r1 = "2001:0:10:2::/64" w = self.wait_per_retry - # path = util.get_paths_in_localrib(peer1, r1, retry=3, interval=w, rf=IPv6) - path = self.get_paths_in_localrib(peer1, r1, retry=3, af=IPv6, interval=w) + path = self.get_paths_in_localrib(peer1, r1, retry=self.retry_count_common, af=IPv6, interval=w) self.assertIsNotNone(path) # check show ip bgp on peer1(quagga1) - # qpath = util.get_route(peer1, r1_pref, retry=3, interval=w, rf=IPv6) - qpath = self.get_route(peer1, r1, retry=3, af=IPv6) + qpath = self.get_route(peer1, r1, retry=self.retry_count_common, af=IPv6) self.assertIsNotNone(qpath) # check adj-rib-out in peer2 - # path = util.get_adj_rib_in(base_url, peer2, r1_pref, retry=3, interval=w, rf=IPv6) - path = self.get_adj_rib_in(peer2, r1, retry=3, af=IPv6) + path = self.get_adj_rib_in(peer2, r1, retry=self.retry_count_common, af=IPv6) # print path self.assertIsNotNone(path) @@ -415,8 +426,7 @@ class GoBGPTest(GoBGPTestBase): self.assertIsNone(path) # check show ip bgp on peer1(quagga3) - # qpath = util.get_route(peer3, r1_pref, retry=3, interval=w, rf=IPv6) - qpath = self.get_route(peer3, r1, retry=3, interval=w, af=IPv6) + qpath = self.get_route(peer3, r1, retry=self.retry_count_common, interval=w, af=IPv6) print qpath self.assertIsNone(qpath) @@ -436,7 +446,7 @@ class GoBGPTest(GoBGPTestBase): # policy_pattern:p6 attaches a policy to reject route 2001:0:10:2:: (64...128) # coming from peer2(2001::192:168:0:2) to peer3(2001::192:168:0:3)'s export-policy. self.use_ipv6_gobgp = True - self.initialize(policy_pattern="p6") + self.initialize(policy_pattern="test_06_export_policy_initial_ipv6") addresses = self.get_neighbor_address(self.gobgp_config) self.retry_routine_for_state(addresses, "BGP_FSM_ESTABLISHED") @@ -446,13 +456,13 @@ class GoBGPTest(GoBGPTestBase): r1 = "2001:0:10:2::/64" w = self.wait_per_retry - paths = self.get_paths_in_localrib(peer1, r1, retry=3, interval=w, af=IPv6) + paths = self.get_paths_in_localrib(peer1, r1, retry=self.retry_count_common, interval=w, af=IPv6) # print paths self.assertIsNotNone(paths) # check show ip bgp on peer1(quagga1) - qpath = self.get_route(peer1, r1, retry=3, interval=w, af=IPv6) + qpath = self.get_route(peer1, r1, retry=self.retry_count_common, interval=w, af=IPv6) # print qpath self.assertIsNotNone(qpath) @@ -470,7 +480,7 @@ class GoBGPTest(GoBGPTestBase): self.assertIsNone(path) # check show ip bgp on peer1(quagga3) - qpath = self.get_route(peer3, r1, retry=3, interval=w, af=IPv6) + qpath = self.get_route(peer3, r1, retry=self.retry_count_common, interval=w, af=IPv6) # print qpath self.assertIsNone(qpath) @@ -506,7 +516,7 @@ class GoBGPTest(GoBGPTestBase): # coming from peer2(2001::192:168:0:2) to peer3(2001::192:168:0:3)'s # import-policy. self.use_ipv6_gobgp = True - self.initialize(policy_pattern="p7") + self.initialize(policy_pattern="test_07_import_policy_update") peer1 = "2001::192:168:0:1" peer2 = "2001::192:168:0:2" @@ -569,7 +579,7 @@ class GoBGPTest(GoBGPTestBase): # update policy print "update_policy_config" - fab.update_policy_config(parser_option.go_path, policy_pattern="p7") + fab.update_policy_config(parser_option.go_path, policy_pattern="test_07_import_policy_update") time.sleep(self.initial_wait_time) # soft reset @@ -618,7 +628,7 @@ class GoBGPTest(GoBGPTestBase): # coming from peer2(2001::192:168:0:2) to peer3(2001::192:168:0:3)'s # export-policy. self.use_ipv6_gobgp = True - self.initialize(policy_pattern="p8") + self.initialize(policy_pattern="test_08_export_policy_update") peer1 = "2001::192:168:0:1" peer2 = "2001::192:168:0:2" @@ -715,6 +725,924 @@ class GoBGPTest(GoBGPTestBase): self.assertTrue(path_exists_in_routing_table(peer3, r3)) + """ + import-policy test + --------------------------------------- + exabgp ->(aspath_length=10)->| -> peer1-rib -> peer1-adj-rib-out | --> peer1 + | | + | ->x peer2-rib | + --------------------------------------- + + """ + def test_09_aspath_length_condition_import(self): + + # initialize test environment + # policy_pattern:p9 attaches a policy to reject a path whose aspath length is greater than or equal 10 + # to peer2(10.0.0.2)'s import-policy. + + # generate exabgp configuration file + prefix1 = "192.168.100.0/24" + asns = ['65100'] + [ str(asn) for asn in range(65099, 65090, -1) ] + as_path = reduce(lambda a,b: a + " " + b, asns) + generate_exabgp_config(prefix1, aspath=as_path) + + self.quagga_num = 2 + self.use_exa_bgp = True + + self.initialize(policy_pattern="test_09_aspath_length_condition_import") + addresses = self.get_neighbor_address(self.gobgp_config) + self.retry_routine_for_state(addresses, "BGP_FSM_ESTABLISHED") + + peer1 = "10.0.0.1" + peer2 = "10.0.0.2" + + path = self.get_paths_in_localrib(peer1, prefix1, retry=self.retry_count_common) + self.assertIsNotNone(path) + + # check show ip bgp on peer1(quagga1) + qpath = self.get_route(peer1,prefix1, retry=self.retry_count_common) + print qpath + self.assertIsNotNone(qpath) + + # check adj-rib-out in peer2 + path = self.get_paths_in_localrib(peer2, prefix1,retry=0) + # print path + self.assertIsNone(path) + + # check show ip bgp on peer2(quagga2) + qpath = self.get_route(peer2,prefix1, retry=self.retry_count_common) + # print qpath + self.assertIsNone(qpath) + + + """ + import-policy test + --------------------------------------- + exabgp ->(aspath=[65100,...])->| -> peer1-rib -> peer1-adj-rib-out | --> peer1 + | | + | ->x peer2-rib | + --------------------------------------- + + """ + def test_10_aspath_from_condition_import(self): + + # initialize test environment + # policy_pattern:AspFrom attaches a policy to reject a path that is from 65100 + # to peer2(10.0.0.2)'s import-policy. + + # generate exabgp configuration file + prefix1 = "192.168.100.0/24" + asns = ['65100'] + [ str(asn) for asn in range(65099, 65090, -1) ] + as_path = reduce(lambda a,b: a + " " + b, asns) + generate_exabgp_config(prefix1, aspath=as_path) + + self.quagga_num = 2 + self.use_exa_bgp = True + self.use_ipv6_gobgp = False + + self.initialize(policy_pattern="test_10_aspath_from_condition_import") + addresses = self.get_neighbor_address(self.gobgp_config) + self.retry_routine_for_state(addresses, "BGP_FSM_ESTABLISHED") + + peer1 = "10.0.0.1" + peer2 = "10.0.0.2" + + path = self.get_paths_in_localrib(peer1, prefix1, retry=self.retry_count_common) + self.assertIsNotNone(path) + + # check show ip bgp on peer1(quagga1) + qpath = self.get_route(peer1,prefix1, retry=self.retry_count_common) + print qpath + self.assertIsNotNone(qpath) + + # check adj-rib-out in peer2 + path = self.get_paths_in_localrib(peer2, prefix1,retry=0) + # print path + self.assertIsNone(path) + + # check show ip bgp on peer2(quagga2) + qpath = self.get_route(peer2,prefix1, retry=self.retry_count_common) + # print qpath + self.assertIsNone(qpath) + + + """ + import-policy test + --------------------------------------- + exabgp ->(aspath=[...65098,...])->| -> peer1-rib -> peer1-adj-rib-out | --> peer1 + | | + | ->x peer2-rib | + --------------------------------------- + + """ + def test_11_aspath_any_condition_import(self): + + # initialize test environment + # policy_pattern:AspFrom attaches a policy to reject a path that contains 65098 in its aspath attr + # to peer2(10.0.0.2)'s import-policy. + + # generate exabgp configuration file + prefix1 = "192.168.100.0/24" + asns = ['65100'] + [ str(asn) for asn in range(65099, 65090, -1) ] + as_path = reduce(lambda a,b: a + " " + b, asns) + generate_exabgp_config(prefix1, aspath=as_path) + + self.quagga_num = 2 + self.use_exa_bgp = True + self.use_ipv6_gobgp = False + + self.initialize(policy_pattern="test_11_aspath_any_condition_import") + addresses = self.get_neighbor_address(self.gobgp_config) + self.retry_routine_for_state(addresses, "BGP_FSM_ESTABLISHED") + + peer1 = "10.0.0.1" + peer2 = "10.0.0.2" + + path = self.get_paths_in_localrib(peer1, prefix1, retry=self.retry_count_common) + self.assertIsNotNone(path) + + # check show ip bgp on peer1(quagga1) + qpath = self.get_route(peer1,prefix1, retry=self.retry_count_common) + print qpath + self.assertIsNotNone(qpath) + + # check adj-rib-out in peer2 + path = self.get_paths_in_localrib(peer2, prefix1,retry=0) + # print path + self.assertIsNone(path) + + # check show ip bgp on peer2(quagga2) + qpath = self.get_route(peer2,prefix1, retry=self.retry_count_common) + # print qpath + self.assertIsNone(qpath) + + """ + import-policy test + --------------------------------------- + exabgp ->(aspath=[...,65090])->| -> peer1-rib -> peer1-adj-rib-out | --> peer1 + | | + | ->x peer2-rib | + --------------------------------------- + + """ + def test_12_aspath_origin_condition_import(self): + + # initialize test environment + # policy_pattern:AspFrom attaches a policy for rejecting a path that has 65090 at last in its aspath attr + # to peer2(10.0.0.2)'s import-policy. + + # generate exabgp configuration file + prefix1 = "192.168.100.0/24" + asns = ['65100'] + [ str(asn) for asn in range(65099, 65090, -1) ] + as_path = reduce(lambda a,b: a + " " + b, asns) + generate_exabgp_config(prefix1, aspath=as_path) + + self.quagga_num = 2 + self.use_exa_bgp = True + self.use_ipv6_gobgp = False + + self.initialize(policy_pattern="test_12_aspath_origin_condition_import") + addresses = self.get_neighbor_address(self.gobgp_config) + self.retry_routine_for_state(addresses, "BGP_FSM_ESTABLISHED") + + peer1 = "10.0.0.1" + peer2 = "10.0.0.2" + + path = self.get_paths_in_localrib(peer1, prefix1, retry=self.retry_count_common) + self.assertIsNotNone(path) + + # check show ip bgp on peer1(quagga1) + qpath = self.get_route(peer1,prefix1, retry=self.retry_count_common) + print qpath + self.assertIsNotNone(qpath) + + # check adj-rib-out in peer2 + path = self.get_paths_in_localrib(peer2, prefix1,retry=0) + # print path + self.assertIsNone(path) + + # check show ip bgp on peer2(quagga2) + qpath = self.get_route(peer2,prefix1, retry=self.retry_count_common) + # print qpath + self.assertIsNone(qpath) + + + """ + import-policy test + --------------------------------------- + exabgp -> (aspath=[65100]) -> | -> peer1-rib -> peer1-adj-rib-out | --> peer1 + | | + | ->x peer2-rib | + --------------------------------------- + + """ + def test_13_aspath_only_condition_import(self): + + # initialize test environment + # policy_pattern:AspFrom attaches a policy for rejecting a path that has only 65100 in its aspath attr + # to peer2(10.0.0.2)'s import-policy. + + # generate exabgp configuration file + prefix1 = "192.168.100.0/24" + asn = '65100' + generate_exabgp_config(prefix1, aspath=asn) + + self.quagga_num = 2 + self.use_exa_bgp = True + self.use_ipv6_gobgp = False + + self.initialize(policy_pattern="test_13_aspath_only_condition_import") + addresses = self.get_neighbor_address(self.gobgp_config) + self.retry_routine_for_state(addresses, "BGP_FSM_ESTABLISHED") + + peer1 = "10.0.0.1" + peer2 = "10.0.0.2" + + path = self.get_paths_in_localrib(peer1, prefix1, retry=self.retry_count_common) + self.assertIsNotNone(path) + + # check show ip bgp on peer1(quagga1) + qpath = self.get_route(peer1,prefix1, retry=self.retry_count_common) + print qpath + self.assertIsNotNone(qpath) + + # check adj-rib-out in peer2 + path = self.get_paths_in_localrib(peer2, prefix1,retry=0) + # print path + self.assertIsNone(path) + + # check show ip bgp on peer2(quagga2) + qpath = self.get_route(peer2,prefix1, retry=self.retry_count_common) + # print qpath + self.assertIsNone(qpath) + + + """ + import-policy test + --------------------------------------- + exabgp ->(aspath=[...,65090])->| -> peer1-rib -> peer1-adj-rib-out | --> peer1 + | | + | -> peer2-rib -> peer2-adj-rib-out | --> peer2 + --------------------------------------- + This case check if policy passes the path to peer2 because of condition mismatch. + """ + def test_14_aspath_only_condition_import(self): + + # initialize test environment + # policy_pattern:AspFrom attaches a policy for rejecting a path that has 65090 at last in its aspath attr + # to peer2(10.0.0.2)'s import-policy. + + # generate exabgp configuration file + prefix1 = "192.168.100.0/24" + asns = ['65100'] + [ str(asn) for asn in range(65099, 65090, -1) ] + as_path = reduce(lambda a,b: a + " " + b, asns) + generate_exabgp_config(prefix1, aspath=as_path) + + self.quagga_num = 2 + self.use_exa_bgp = True + self.use_ipv6_gobgp = False + + self.initialize(policy_pattern="test_14_aspath_only_condition_import") + addresses = self.get_neighbor_address(self.gobgp_config) + self.retry_routine_for_state(addresses, "BGP_FSM_ESTABLISHED") + + peer1 = "10.0.0.1" + peer2 = "10.0.0.2" + + path = self.get_paths_in_localrib(peer1, prefix1, retry=self.retry_count_common) + self.assertIsNotNone(path) + + # check show ip bgp on peer1(quagga1) + qpath = self.get_route(peer1,prefix1, retry=self.retry_count_common) + print qpath + self.assertIsNotNone(qpath) + + # check adj-rib-out in peer2 + path = self.get_paths_in_localrib(peer2, prefix1,retry=0) + print path + self.assertIsNotNone(path) + + # check show ip bgp on peer2(quagga2) + qpath = self.get_route(peer2,prefix1, retry=self.retry_count_common) + print qpath + self.assertIsNotNone(qpath) + + + """ + import-policy test + --------------------------------------- + exabgp ->(community=65100:10)->| -> peer1-rib -> peer1-adj-rib-out | --> peer1 + | | + | ->x peer2-rib | + --------------------------------------- + """ + def test_15_community_condition_import(self): + + # initialize test environment + # policy_pattern:AspFrom attaches a policy for rejecting a path that has 65100:10 in its community attr + # to peer2(10.0.0.2)'s import-policy. + + # generate exabgp configuration file + prefix1 = "192.168.100.0/24" + asns = ['65100'] + [ str(asn) for asn in range(65099, 65090, -1) ] + community = '65100:10' + as_path = reduce(lambda a,b: a + " " + b, asns) + generate_exabgp_config(prefix1, aspath=as_path, community=community) + + self.quagga_num = 2 + self.use_exa_bgp = True + self.use_ipv6_gobgp = False + + self.initialize(policy_pattern="test_15_community_condition_import") + addresses = self.get_neighbor_address(self.gobgp_config) + self.retry_routine_for_state(addresses, "BGP_FSM_ESTABLISHED") + + peer1 = "10.0.0.1" + peer2 = "10.0.0.2" + + path = self.get_paths_in_localrib(peer1, prefix1, retry=self.retry_count_common) + self.assertIsNotNone(path) + + # check show ip bgp on peer1(quagga1) + qpath = self.get_route(peer1,prefix1, retry=self.retry_count_common) + print qpath + self.assertIsNotNone(qpath) + + # check adj-rib-out in peer2 + path = self.get_paths_in_localrib(peer2, prefix1,retry=0) + # print path + self.assertIsNone(path) + + # check show ip bgp on peer2(quagga2) + qpath = self.get_route(peer2,prefix1, retry=self.retry_count_common) + # print qpath + self.assertIsNone(qpath) + + + """ + import-policy test + --------------------------------------- + exabgp ->(community=65100:10)->| -> peer1-rib -> peer1-adj-rib-out | --> peer1 + | | + | ->x peer2-rib | + --------------------------------------- + """ + def test_16_community_condition_regexp_import(self): + + # initialize test environment + # policy_pattern:AspFrom attaches a policy for rejecting a path that has 65100:10 in its community attr + # to peer2(10.0.0.2)'s import-policy. + # this policy uses a regexp as the community condition. + + # generate exabgp configuration file + prefix1 = "192.168.100.0/24" + asns = ['65100'] + [ str(asn) for asn in range(65099, 65090, -1) ] + community = '65100:10' + as_path = reduce(lambda a,b: a + " " + b, asns) + generate_exabgp_config(prefix1, aspath=as_path, community=community) + + self.quagga_num = 2 + self.use_exa_bgp = True + self.use_ipv6_gobgp = False + + self.initialize(policy_pattern="test_16_community_condition_regexp_import") + addresses = self.get_neighbor_address(self.gobgp_config) + self.retry_routine_for_state(addresses, "BGP_FSM_ESTABLISHED") + + peer1 = "10.0.0.1" + peer2 = "10.0.0.2" + + path = self.get_paths_in_localrib(peer1, prefix1, retry=self.retry_count_common) + self.assertIsNotNone(path) + + # check show ip bgp on peer1(quagga1) + qpath = self.get_route(peer1,prefix1, retry=self.retry_count_common) + print qpath + self.assertIsNotNone(qpath) + + # check adj-rib-out in peer2 + path = self.get_paths_in_localrib(peer2, prefix1,retry=0) + # print path + self.assertIsNone(path) + + # check show ip bgp on peer2(quagga2) + qpath = self.get_route(peer2,prefix1, retry=self.retry_count_common) + # print qpath + self.assertIsNone(qpath) + + """ + import-policy test + --------------------------------------- + exabgp ->(community=65100:10)->| -> peer1-rib -> peer1-adj-rib-out | --> peer1 + | | + | -> peer2-rib -> peer2-adj-rib-out | --> peer2 + | apply action | + --------------------------------------- + """ + def test_17_community_add_action_import(self): + + # initialize test environment + # policy_pattern:AspFrom attaches a policy for addition community 65100:10 to its community attr + # to peer2(10.0.0.2)'s import-policy. + + # generate exabgp configuration file + prefix1 = "192.168.100.0/24" + asns = ['65100'] + [ str(asn) for asn in range(65099, 65090, -1) ] + community = '65100:10' + as_path = reduce(lambda a,b: a + " " + b, asns) + generate_exabgp_config(prefix1, aspath=as_path, community=community) + + self.quagga_num = 2 + self.use_exa_bgp = True + self.use_ipv6_gobgp = False + + self.initialize(policy_pattern="test_17_community_add_action_import") + addresses = self.get_neighbor_address(self.gobgp_config) + self.retry_routine_for_state(addresses, "BGP_FSM_ESTABLISHED") + + peer1 = "10.0.0.1" + peer2 = "10.0.0.2" + + path = self.get_paths_in_localrib(peer1, prefix1, retry=self.retry_count_common) + self.assertIsNotNone(path) + + # check show ip bgp on peer1(quagga1) + qpath = self.get_route(peer1,prefix1, retry=self.retry_count_common) + print qpath + self.assertIsNotNone(qpath) + + # check adj-rib-out in peer2 + path = self.get_paths_in_localrib(peer2, prefix1,retry=0) + print path + self.assertIsNotNone(path) + attrs = [x for x in path[0]['attrs'] if 'communites' in x ] + self.assertTrue((65100 << 16 | 20) in attrs[0]['communites']) + + # check show ip bgp on peer2(quagga2) + qpath = self.get_route(peer2,prefix1, retry=self.retry_count_common) + print qpath + self.assertIsNotNone(qpath) + self.assertTrue(self.check_community(peer2, prefix1.split('/')[0], '65100:20')) + + + """ + import-policy test + --------------------------------------- + exabgp ->(community=65100:10)->| -> peer1-rib -> peer1-adj-rib-out | --> peer1 + | | + | -> peer2-rib -> peer2-adj-rib-out | --> peer2 + | apply action | + --------------------------------------- + """ + def test_18_community_replace_action_import(self): + + # initialize test environment + # policy_pattern:AspFrom attaches a policy to replace community 65100:10 in its community attr + # to peer2(10.0.0.2)'s import-policy. + + # generate exabgp configuration file + prefix1 = "192.168.100.0/24" + asns = ['65100'] + [ str(asn) for asn in range(65099, 65090, -1) ] + community = '65100:10' + as_path = reduce(lambda a,b: a + " " + b, asns) + generate_exabgp_config(prefix1, aspath=as_path, community=community) + + self.quagga_num = 2 + self.use_exa_bgp = True + self.use_ipv6_gobgp = False + + self.initialize(policy_pattern="test_18_community_replace_action_import") + addresses = self.get_neighbor_address(self.gobgp_config) + self.retry_routine_for_state(addresses, "BGP_FSM_ESTABLISHED") + + peer1 = "10.0.0.1" + peer2 = "10.0.0.2" + + path = self.get_paths_in_localrib(peer1, prefix1, retry=self.retry_count_common) + self.assertIsNotNone(path) + + # check show ip bgp on peer1(quagga1) + qpath = self.get_route(peer1,prefix1, retry=self.retry_count_common) + print qpath + self.assertIsNotNone(qpath) + + # check adj-rib-out in peer2 + path = self.get_paths_in_localrib(peer2, prefix1,retry=0) + print path + self.assertIsNotNone(path) + attrs = [x for x in path[0]['attrs'] if 'communites' in x ] + self.assertTrue((65100 << 16 | 20) in attrs[0]['communites']) + self.assertTrue((65100 << 16 | 30) in attrs[0]['communites']) + + # check show ip bgp on peer2(quagga2) + qpath = self.get_route(peer2,prefix1, retry=self.retry_count_common) + print qpath + self.assertIsNotNone(qpath) + self.assertTrue(self.check_community(peer2, prefix1.split('/')[0], '65100:20')) + self.assertTrue(self.check_community(peer2, prefix1.split('/')[0], '65100:30')) + self.assertFalse(self.check_community(peer2, prefix1.split('/')[0], '65100:10', retry=1)) + + """ + import-policy test + --------------------------------------- + exabgp ->(community=65100:10)->| -> peer1-rib -> peer1-adj-rib-out | --> peer1 + (community=65100:20) | | + (community=65100:30) | -> peer2-rib -> peer2-adj-rib-out | --> peer2 + | apply action | + --------------------------------------- + """ + def test_19_community_remove_action_import(self): + + # initialize test environment + # policy_pattern:AspFrom attaches a policy to remove community 65100:20 65100:30 in its community attr + # to peer2(10.0.0.2)'s import-policy. + + # generate exabgp configuration file + prefix1 = "192.168.100.0/24" + asns = ['65100'] + [ str(asn) for asn in range(65099, 65090, -1) ] + community = ' 65100:10 65100:20 65100:30 ' + as_path = reduce(lambda a,b: a + " " + b, asns) + generate_exabgp_config(prefix1, aspath=as_path, community=community) + + self.quagga_num = 2 + self.use_exa_bgp = True + self.use_ipv6_gobgp = False + + self.initialize(policy_pattern="test_19_community_remove_action_import") + addresses = self.get_neighbor_address(self.gobgp_config) + self.retry_routine_for_state(addresses, "BGP_FSM_ESTABLISHED") + + peer1 = "10.0.0.1" + peer2 = "10.0.0.2" + + path = self.get_paths_in_localrib(peer1, prefix1, retry=self.retry_count_common) + self.assertIsNotNone(path) + + # check show ip bgp on peer1(quagga1) + qpath = self.get_route(peer1,prefix1, retry=self.retry_count_common) + print qpath + self.assertIsNotNone(qpath) + + # check adj-rib-out in peer2 + path = self.get_paths_in_localrib(peer2, prefix1,retry=0) + print path + self.assertIsNotNone(path) + attrs = [x for x in path[0]['attrs'] if 'communites' in x ] + self.assertTrue((65100 << 16 | 20) not in attrs[0]['communites']) + self.assertTrue((65100 << 16 | 30) not in attrs[0]['communites']) + + # check show ip bgp on peer2(quagga2) + qpath = self.get_route(peer2,prefix1, retry=self.retry_count_common) + print qpath + self.assertIsNotNone(qpath) + self.assertFalse(self.check_community(peer2, prefix1.split('/')[0], '65100:20', retry=1)) + self.assertFalse(self.check_community(peer2, prefix1.split('/')[0], '65100:30', retry=1)) + self.assertTrue(self.check_community(peer2, prefix1.split('/')[0], '65100:10', retry=1)) + + + """ + import-policy test + --------------------------------------- + exabgp ->(community=65100:10)->| -> peer1-rib -> peer1-adj-rib-out | --> peer1 + (community=65100:20) | | + (community=65100:30) | -> peer2-rib -> peer2-adj-rib-out | --> peer2 + | apply action | + --------------------------------------- + """ + def test_20_community_null_action_import(self): + + # initialize test environment + # policy_pattern:AspFrom attaches a policy to remove its community attr + # to peer2(10.0.0.2)'s import-policy. + + # generate exabgp configuration file + prefix1 = "192.168.100.0/24" + asns = ['65100'] + [ str(asn) for asn in range(65099, 65090, -1) ] + community = ' 65100:10 65100:20 65100:30 ' + as_path = reduce(lambda a,b: a + " " + b, asns) + generate_exabgp_config(prefix1, aspath=as_path, community=community) + + self.quagga_num = 2 + self.use_exa_bgp = True + self.use_ipv6_gobgp = False + + self.initialize(policy_pattern="test_20_community_null_action_import") + addresses = self.get_neighbor_address(self.gobgp_config) + self.retry_routine_for_state(addresses, "BGP_FSM_ESTABLISHED") + + peer1 = "10.0.0.1" + peer2 = "10.0.0.2" + + path = self.get_paths_in_localrib(peer1, prefix1, retry=self.retry_count_common) + self.assertIsNotNone(path) + + # check show ip bgp on peer1(quagga1) + qpath = self.get_route(peer1,prefix1, retry=self.retry_count_common) + print qpath + self.assertIsNotNone(qpath) + + # check adj-rib-out in peer2 + path = self.get_paths_in_localrib(peer2, prefix1,retry=0) + print path + self.assertIsNotNone(path) + attrs = [x for x in path[0]['attrs'] if 'communites' in x ] + self.assertFalse('communites' in attrs) + # self.assertTrue((65100 << 16 | 20) not in attrs[0]['communites']) + # self.assertTrue((65100 << 16 | 30) not in attrs[0]['communites']) + + # check show ip bgp on peer2(quagga2) + qpath = self.get_route(peer2,prefix1, retry=self.retry_count_common) + print qpath + self.assertIsNotNone(qpath) + self.assertFalse(self.check_community(peer2, prefix1.split('/')[0], '65100:20', retry=1)) + self.assertFalse(self.check_community(peer2, prefix1.split('/')[0], '65100:30', retry=1)) + self.assertFalse(self.check_community(peer2, prefix1.split('/')[0], '65100:10', retry=1)) + + """ + import-policy test + --------------------------------------- + exabgp ->(community=65100:10)->| -> peer1-rib -> peer1-adj-rib-out | --> peer1 + | | + | -> peer2-rib -> peer2-adj-rib-out | --> peer2 + | apply action | + --------------------------------------- + """ + def test_21_community_add_action_export(self): + + # initialize test environment + # policy_pattern:CommunityAddEXP attaches a policy to add community 65100:20 into its community attr + # to peer2(10.0.0.2)'s export-policy. + + # generate exabgp configuration file + prefix1 = "192.168.100.0/24" + asns = ['65100'] + [ str(asn) for asn in range(65099, 65090, -1) ] + community = '65100:10' + as_path = reduce(lambda a,b: a + " " + b, asns) + generate_exabgp_config(prefix1, aspath=as_path, community=community) + + self.quagga_num = 2 + self.use_exa_bgp = True + self.use_ipv6_gobgp = False + + self.initialize(policy_pattern="test_21_community_add_action_export") + addresses = self.get_neighbor_address(self.gobgp_config) + self.retry_routine_for_state(addresses, "BGP_FSM_ESTABLISHED") + + peer1 = "10.0.0.1" + peer2 = "10.0.0.2" + + path = self.get_paths_in_localrib(peer1, prefix1, retry=self.retry_count_common) + self.assertIsNotNone(path) + + # check show ip bgp on peer1(quagga1) + qpath = self.get_route(peer1,prefix1, retry=self.retry_count_common) + print qpath + self.assertIsNotNone(qpath) + + # check adj-rib-out in peer2 + path = self.get_paths_in_localrib(peer2, prefix1,retry=0) + print path + self.assertIsNotNone(path) + attrs = [x for x in path[0]['attrs'] if 'communites' in x ] + self.assertFalse((65100 << 16 | 20) in attrs[0]['communites']) + # check out-rib + path = self.get_adj_rib_out(peer2, prefix1, retry=0) + print path + attrs = [x for x in path['attrs'] if 'communites' in x ] + self.assertTrue((65100 << 16 | 20) in attrs[0]['communites']) + + # check show ip bgp on peer2(quagga2) + qpath = self.get_route(peer2,prefix1, retry=self.retry_count_common) + print qpath + self.assertIsNotNone(qpath) + self.assertTrue(self.check_community(peer2, prefix1.split('/')[0], '65100:20')) + + + """ + import-policy test + --------------------------------------- + exabgp ->(community=65100:10)->| -> peer1-rib -> peer1-adj-rib-out | --> peer1 + | | + | -> peer2-rib -> peer2-adj-rib-out | --> peer2 + | apply action | + --------------------------------------- + """ + def test_22_community_replace_action_export(self): + + # initialize test environment + # policy_pattern:CommunityReplaceEXP attaches a policy to replace its community + # with 65100:20 and 65100:30 in its community attr to peer2(10.0.0.2)'s export-policy. + + # generate exabgp configuration file + prefix1 = "192.168.100.0/24" + asns = ['65100'] + [ str(asn) for asn in range(65099, 65090, -1) ] + community = '65100:10' + as_path = reduce(lambda a,b: a + " " + b, asns) + generate_exabgp_config(prefix1, aspath=as_path, community=community) + + self.quagga_num = 2 + self.use_exa_bgp = True + self.use_ipv6_gobgp = False + + self.initialize(policy_pattern="test_22_community_replace_action_export") + addresses = self.get_neighbor_address(self.gobgp_config) + self.retry_routine_for_state(addresses, "BGP_FSM_ESTABLISHED") + + peer1 = "10.0.0.1" + peer2 = "10.0.0.2" + + path = self.get_paths_in_localrib(peer1, prefix1, retry=self.retry_count_common) + self.assertIsNotNone(path) + + # check show ip bgp on peer1(quagga1) + qpath = self.get_route(peer1,prefix1, retry=self.retry_count_common) + print qpath + self.assertIsNotNone(qpath) + + # check adj-rib-out in peer2 + path = self.get_paths_in_localrib(peer2, prefix1,retry=0) + print path + self.assertIsNotNone(path) + attrs = [x for x in path[0]['attrs'] if 'communites' in x ] + self.assertFalse((65100 << 16 | 20) in attrs[0]['communites']) + self.assertFalse((65100 << 16 | 30) in attrs[0]['communites']) + # check out-rib + path = self.get_adj_rib_out(peer2, prefix1, retry=1) + print path + attrs = [x for x in path['attrs'] if 'communites' in x ] + self.assertTrue((65100 << 16 | 20) in attrs[0]['communites']) + self.assertTrue((65100 << 16 | 30) in attrs[0]['communites']) + + + # check show ip bgp on peer2(quagga2) + qpath = self.get_route(peer2,prefix1, retry=self.retry_count_common) + print qpath + self.assertIsNotNone(qpath) + self.assertTrue(self.check_community(peer2, prefix1.split('/')[0], '65100:20')) + self.assertTrue(self.check_community(peer2, prefix1.split('/')[0], '65100:30')) + self.assertFalse(self.check_community(peer2, prefix1.split('/')[0], '65100:10', retry=1)) + + """ + import-policy test + --------------------------------------- + exabgp ->(community=65100:10)->| -> peer1-rib -> peer1-adj-rib-out | --> peer1 + (community=65100:20) | | + (community=65100:30) | -> peer2-rib -> peer2-adj-rib-out | --> peer2 + | apply action | + --------------------------------------- + """ + def test_23_community_remove_action_export(self): + + # initialize test environment + # policy_pattern:CommunityRemoveEXP attaches a policy to remove 65100:20 and 65100:30 + # in its community attr to peer2(10.0.0.2)'s import-policy. + + # generate exabgp configuration file + prefix1 = "192.168.100.0/24" + asns = ['65100'] + [ str(asn) for asn in range(65099, 65090, -1) ] + community = ' 65100:10 65100:20 65100:30 ' + as_path = reduce(lambda a,b: a + " " + b, asns) + generate_exabgp_config(prefix1, aspath=as_path, community=community) + + self.quagga_num = 2 + self.use_exa_bgp = True + self.use_ipv6_gobgp = False + + self.initialize(policy_pattern="test_23_community_remove_action_export") + addresses = self.get_neighbor_address(self.gobgp_config) + self.retry_routine_for_state(addresses, "BGP_FSM_ESTABLISHED") + + peer1 = "10.0.0.1" + peer2 = "10.0.0.2" + + path = self.get_paths_in_localrib(peer1, prefix1, retry=self.retry_count_common) + self.assertIsNotNone(path) + + # check show ip bgp on peer1(quagga1) + qpath = self.get_route(peer1,prefix1, retry=self.retry_count_common) + print qpath + self.assertIsNotNone(qpath) + + # check adj-rib-out in peer2 + path = self.get_paths_in_localrib(peer2, prefix1,retry=1) + print path + self.assertIsNotNone(path) + attrs = [x for x in path[0]['attrs'] if 'communites' in x ] + self.assertTrue((65100 << 16 | 20) in attrs[0]['communites']) + self.assertTrue((65100 << 16 | 30) in attrs[0]['communites']) + # check out-rib + path = self.get_adj_rib_out(peer2, prefix1, retry=1) + print path + attrs = [x for x in path['attrs'] if 'communites' in x ] + self.assertFalse((65100 << 16 | 20) in attrs[0]['communites']) + self.assertFalse((65100 << 16 | 30) in attrs[0]['communites']) + + + # check show ip bgp on peer2(quagga2) + qpath = self.get_route(peer2,prefix1, retry=self.retry_count_common) + print qpath + self.assertIsNotNone(qpath) + self.assertFalse(self.check_community(peer2, prefix1.split('/')[0], '65100:20', retry=1)) + self.assertFalse(self.check_community(peer2, prefix1.split('/')[0], '65100:30', retry=1)) + self.assertTrue(self.check_community(peer2, prefix1.split('/')[0], '65100:10', retry=1)) + + + """ + import-policy test + --------------------------------------- + exabgp ->(community=65100:10)->| -> peer1-rib -> peer1-adj-rib-out | --> peer1 + (community=65100:20) | | + (community=65100:30) | -> peer2-rib -> peer2-adj-rib-out | --> peer2 + | apply action | + --------------------------------------- + """ + def test_24_community_null_action_export(self): + + # initialize test environment + # policy_pattern:CommunityNullEXP attaches a policy to remove its community attr + # to peer2(10.0.0.2)'s export-policy. + + # generate exabgp configuration file + prefix1 = "192.168.100.0/24" + asns = ['65100'] + [ str(asn) for asn in range(65099, 65090, -1) ] + community = ' 65100:10 65100:20 65100:30 ' + as_path = reduce(lambda a,b: a + " " + b, asns) + generate_exabgp_config(prefix1, aspath=as_path, community=community) + + self.quagga_num = 2 + self.use_exa_bgp = True + self.use_ipv6_gobgp = False + + self.initialize(policy_pattern="test_24_community_null_action_export") + addresses = self.get_neighbor_address(self.gobgp_config) + self.retry_routine_for_state(addresses, "BGP_FSM_ESTABLISHED") + + peer1 = "10.0.0.1" + peer2 = "10.0.0.2" + + path = self.get_paths_in_localrib(peer1, prefix1, retry=self.retry_count_common) + self.assertIsNotNone(path) + + # check show ip bgp on peer1(quagga1) + qpath = self.get_route(peer1,prefix1, retry=self.retry_count_common) + print qpath + self.assertIsNotNone(qpath) + + # check adj-rib-out in peer2 + path = self.get_paths_in_localrib(peer2, prefix1,retry=0) + print path + self.assertIsNotNone(path) + attrs = [x for x in path[0]['attrs'] if 'communites' in x ] + self.assertTrue((65100 << 16 | 10) in attrs[0]['communites']) + self.assertTrue((65100 << 16 | 20) in attrs[0]['communites']) + self.assertTrue((65100 << 16 | 30) in attrs[0]['communites']) + # check out-rib + path = self.get_adj_rib_out(peer2, prefix1, retry=1) + print path + attrs = [x for x in path['attrs'] if 'communites' in x ] + self.assertFalse('communites' in attrs) + + # check show ip bgp on peer2(quagga2) + qpath = self.get_route(peer2,prefix1, retry=self.retry_count_common) + print qpath + self.assertIsNotNone(qpath) + self.assertFalse(self.check_community(peer2, prefix1.split('/')[0], '65100:20', retry=1)) + self.assertFalse(self.check_community(peer2, prefix1.split('/')[0], '65100:30', retry=1)) + self.assertFalse(self.check_community(peer2, prefix1.split('/')[0], '65100:10', retry=1)) + + +def generate_exabgp_config(pref, aspath='', community=''): + value = {'prefix': pref, + 'aspath': aspath, + 'community': community} + + pwd = local("pwd", capture=True) + conf_dir = pwd + "/exabgp_test_conf" + f = open(conf_dir+ "/" + EXABGP_COMMON_CONF, 'w') + f.write(EXABGP_COMMON_TEMPLATE % value) + f.close() + + +EXABGP_COMMON_TEMPLATE = ''' +neighbor 10.0.255.1 { + router-id 192.168.0.7; + local-address 10.0.0.100; + local-as 65100; + peer-as 65000; + hold-time 90; + md5 "hoge100"; + graceful-restart; + + family { + inet unicast; + } + static { + # static routes + route %(prefix)s next-hop 10.0.0.100 as-path [%(aspath)s] community [%(community)s]; + } +} +''' + if __name__ == '__main__': if fab.test_user_check() is False: print "you are not root." |