summaryrefslogtreecommitdiffhomepage
diff options
context:
space:
mode:
Diffstat
-rw-r--r--test/scenario_test/docker_control.py150
-rw-r--r--test/scenario_test/peer_info.py24
-rw-r--r--test/scenario_test/quagga-rsconfig.go99
-rw-r--r--test/scenario_test/quagga_access.py13
-rw-r--r--test/scenario_test/route_server_ipv4_v6_test.py239
-rw-r--r--test/scenario_test/route_server_test.py45
6 files changed, 486 insertions, 84 deletions
diff --git a/test/scenario_test/docker_control.py b/test/scenario_test/docker_control.py
index baff3109..0cfc8361 100644
--- a/test/scenario_test/docker_control.py
+++ b/test/scenario_test/docker_control.py
@@ -18,22 +18,42 @@ import re
import os
GOBGP_CONTAINER_NAME = "gobgp"
-GOBGP_ADDRESS = "10.0.255.1/16"
+GOBGP_ADDRESS_0 = {"IPv4": "10.0.255.1",
+ "IPv6": "2001::0:192:168:255:1"}
+GOBGP_ADDRESS_1 = {"IPv4": "11.0.255.1",
+ "IPv6": "2001::1:192:168:255:1"}
+GOBGP_ADDRESS_2 = {"IPv4": "12.0.255.1",
+ "IPv6": "2001::2:192:168:255:1"}
GOBGP_CONFIG_FILE = "gobgpd.conf"
EXABGP_CONTAINER_NAME = "exabgp"
EXABGP_ADDRESS = "10.0.0.100/16"
EXABGP_CONFDIR = "/etc/exabgp/"
EXABGP_LOG_FILE = "exabgpd.log"
-BRIDGE_ADDRESS = "10.0.255.2"
CONFIG_DIR = "/usr/local/gobgp"
CONFIG_DIRR = "/usr/local/gobgp/"
CONFIG_DIRRR = "/usr/local/gobgp/*"
STARTUP_FILE_NAME = "gobgp_startup.sh"
STARTUP_FILE = "/mnt/" + STARTUP_FILE_NAME
-BRIDGE_0 = {"BRIDGE_NAME": "br0", "BRIDGE_ADDRESS": "10.0.255.2"}
-BRIDGE_1 = {"BRIDGE_NAME": "br1", "BRIDGE_ADDRESS": "11.0.255.2"}
-BRIDGE_2 = {"BRIDGE_NAME": "br2", "BRIDGE_ADDRESS": "12.0.255.2"}
+
+IP_VERSION = "IPv4"
+IF_CONFIG_OPTION = {"IPv4": "inet", "IPv6": "inet6"}
+BRIDGE_0 = {"BRIDGE_NAME": "br0",
+ "IPv4": "10.0.255.2",
+ "IPv6": "2001::0:192:168:255:2"}
+BRIDGE_1 = {"BRIDGE_NAME": "br1",
+ "IPv4": "11.0.255.2",
+ "IPv6": "2001::1:192:168:255:2"}
+BRIDGE_2 = {"BRIDGE_NAME": "br2",
+ "IPv4": "12.0.255.2",
+ "IPv6": "2001::2:192:168:255:2"}
BRIDGES = [BRIDGE_0, BRIDGE_1, BRIDGE_2]
+
+BASE_NET = {BRIDGE_0["BRIDGE_NAME"]: {"IPv4": "10.0.0.", "IPv6": "2001::0:192:168:0:"},
+ BRIDGE_1["BRIDGE_NAME"]: {"IPv4": "11.0.0.", "IPv6": "2001::1:192:168:0:"},
+ BRIDGE_2["BRIDGE_NAME"]: {"IPv4": "12.0.0.", "IPv6": "2001::2:192:168:0:"}}
+
+BASE_MASK = {"IPv4": "/16", "IPv6": "/64"}
+
A_PART_OF_CURRENT_DIR = "/test/scenario_test"
@@ -94,7 +114,7 @@ def go_path_check():
return go_path_exist
-def docker_container_checks():
+def docker_container_check():
container_exists = False
outbuf = local("docker ps -a", capture=True)
docker_ps = outbuf.split('\n')
@@ -106,6 +126,17 @@ def docker_container_checks():
return container_exists
+def bridge_setting_check():
+ setting_exists = False
+ for bridge in BRIDGES:
+ sysfs_name = "/sys/class/net/" + bridge["BRIDGE_NAME"]
+ if os.path.exists(sysfs_name):
+ setting_exists = True
+ return setting_exists
+ return setting_exists
+
+
+
def docker_containers_get():
containers = []
cmd = "docker ps -a | awk '{print $NF}'"
@@ -117,9 +148,9 @@ def docker_containers_get():
return containers
-def docker_container_set_ipaddress(bridge, quagga_name, address):
+def docker_container_set_ipaddress(bridge, name, address):
cmd = "pipework " + bridge["BRIDGE_NAME"] + " -i eth-" + bridge["BRIDGE_NAME"]\
- + " " + quagga_name + " " + address
+ + " " + name + " " + address
local(cmd, capture=True)
@@ -128,8 +159,7 @@ def docker_container_run_quagga(quagga_num, bridge):
cmd = "docker run --privileged=true -v " + CONFIG_DIR + "/" + quagga_name +\
":/etc/quagga --name " + quagga_name + " -id osrg/quagga"
local(cmd, capture=True)
- aff_net = bridge["BRIDGE_NAME"][-1]
- quagga_address = "1" + aff_net + ".0.0." + str(quagga_num) + "/16"
+ quagga_address = BASE_NET[bridge["BRIDGE_NAME"]][IP_VERSION] + str(quagga_num) + BASE_MASK[IP_VERSION]
docker_container_set_ipaddress(bridge, quagga_name, quagga_address)
@@ -137,7 +167,7 @@ def docker_container_run_gobgp(bridge):
cmd = "docker run --privileged=true -v " + CONFIG_DIR + ":/mnt -d --name "\
+ GOBGP_CONTAINER_NAME + " -id osrg/gobgp"
local(cmd, capture=True)
- docker_container_set_ipaddress(bridge, GOBGP_CONTAINER_NAME, GOBGP_ADDRESS)
+ docker_container_set_ipaddress(bridge, GOBGP_CONTAINER_NAME, GOBGP_ADDRESS_0[IP_VERSION] + BASE_MASK[IP_VERSION])
def docker_container_run_exabgp(bridge):
@@ -210,9 +240,6 @@ def docker_containers_destroy():
def docker_container_quagga_append(quagga_num, bridge):
print "start append docker container."
docker_container_run_quagga(quagga_num, bridge)
- cmd = "docker exec gobgp /usr/bin/pkill gobgp -SIGHUP"
- local(cmd, capture=True)
- print "complete append docker container."
def docker_container_quagga_removed(quagga_num):
@@ -222,12 +249,16 @@ def docker_container_quagga_removed(quagga_num):
print "complete removed docker container."
-def bridge_setting_for_docker_connection():
- bridge_unsetting_for_docker_connection()
- for bridge in BRIDGES:
+def bridge_setting_for_docker_connection(bridges):
+ # bridge_unsetting_for_docker_connection()
+ for bridge in bridges:
cmd = "brctl addbr " + bridge["BRIDGE_NAME"]
local(cmd, capture=True)
- cmd = "ifconfig " + bridge["BRIDGE_NAME"] + " " + bridge["BRIDGE_ADDRESS"]
+ if IP_VERSION == "IPv6":
+ cmd = "ifconfig " + bridge["BRIDGE_NAME"] + " " + IF_CONFIG_OPTION[IP_VERSION] +\
+ " add " + bridge[IP_VERSION] + BASE_MASK[IP_VERSION]
+ else:
+ cmd = "ifconfig " + bridge["BRIDGE_NAME"] + " " + bridge[IP_VERSION]
local(cmd, capture=True)
cmd = "ifconfig " + bridge["BRIDGE_NAME"] + " up"
local(cmd, capture=True)
@@ -261,7 +292,7 @@ def get_notification_from_exabgp_log():
return err_mgs
-def make_config(quagga_num, go_path):
+def make_config(quagga_num, go_path, bridge):
if go_path != "":
print "specified go path is [ " + go_path + " ]."
if os.path.isdir(go_path):
@@ -269,11 +300,12 @@ def make_config(quagga_num, go_path):
else:
print "specified go path do not use."
pwd = local("pwd", capture=True)
- cmd = go_path + "go run " + pwd + "/quagga-rsconfig.go -n " + str(quagga_num) + " -c /usr/local/gobgp"
+ cmd = go_path + "go run " + pwd + "/quagga-rsconfig.go -n " + str(quagga_num) +\
+ " -c /usr/local/gobgp -v " + IP_VERSION + " -i " + bridge["BRIDGE_NAME"][-1]
local(cmd, capture=True)
-def make_config_append(quagga_num, go_path):
+def make_config_append(quagga_num, go_path, bridge):
if go_path != "":
print "specified go path is [ " + go_path + " ]."
if os.path.isdir(go_path):
@@ -281,21 +313,67 @@ def make_config_append(quagga_num, go_path):
else:
print "specified go path do not use."
pwd = local("pwd", capture=True)
- cmd = go_path + "go run " + pwd + "/quagga-rsconfig.go -a " + str(quagga_num) + " -c /usr/local/gobgp"
+ cmd = go_path + "go run " + pwd + "/quagga-rsconfig.go -a " + str(quagga_num) +\
+ " -c /usr/local/gobgp -v " + IP_VERSION + " -i " + bridge["BRIDGE_NAME"][-1]
local(cmd, capture=True)
+def reload_config():
+ cmd = "docker exec gobgp /usr/bin/pkill gobgp -SIGHUP"
+ local(cmd, capture=True)
+ print "complete append docker container."
+
+
def init_test_env_executor(quagga_num, use_local, go_path):
print "start initialization of test environment."
- if docker_container_checks():
+ if docker_container_check() or bridge_setting_check():
+ print "gobgp test environment already exists."
+ print "so that remake gobgp test environment."
+ docker_containers_destroy()
+
+ print "make gobgp test environment."
+ bridge_setting_for_docker_connection(BRIDGES)
+ make_config(quagga_num, go_path, BRIDGE_0)
+
+ # run each docker container
+ for num in range(1, quagga_num + 1):
+ docker_container_run_quagga(num, BRIDGE_0)
+ docker_container_run_gobgp(BRIDGE_0)
+
+ # execute local gobgp program in the docker container if the input option is local
+ if use_local:
+ print "execute gobgp program in local machine."
+ pwd = local("pwd", capture=True)
+ if A_PART_OF_CURRENT_DIR in pwd:
+ gobgp_path = re.sub(A_PART_OF_CURRENT_DIR, "", pwd)
+ cmd = "cp -r " + gobgp_path + " " + CONFIG_DIRR
+ local(cmd, capture=True)
+ make_startup_file_use_local_gobgp()
+ else:
+ print "scenario_test directory is not."
+ print "execute gobgp program of osrg/master in github."
+ make_startup_file()
+ else:
+ print "execute gobgp program of osrg/master in github."
+ make_startup_file()
+
+ start_gobgp()
+
+ print "complete initialization of test environment."
+
+
+def init_ipv6_test_env_executor(quagga_num, use_local, go_path):
+ print "start initialization of test environment."
+
+ if docker_container_check() or bridge_setting_check():
print "gobgp test environment already exists."
print "so that remake gobgp test environment."
docker_containers_destroy()
print "make gobgp test environment."
- bridge_setting_for_docker_connection()
- make_config(quagga_num, go_path)
+ bridge_setting_for_docker_connection([BRIDGE_0])
+ make_config(quagga_num, go_path, BRIDGE_0)
# run each docker container
for num in range(1, quagga_num + 1):
@@ -326,13 +404,14 @@ def init_test_env_executor(quagga_num, use_local, go_path):
def init_malformed_test_env_executor(conf_file, use_local):
print "start initialization of exabgp test environment."
- if docker_container_checks():
+
+ if docker_container_check() or bridge_setting_check():
print "gobgp test environment already exists."
print "so that remake gobgp test environment."
docker_containers_destroy()
print "make gobgp test environment."
- bridge_setting_for_docker_connection()
+ bridge_setting_for_docker_connection(BRIDGES)
pwd = local("pwd", capture=True)
gobgp_file = pwd + "/exabgp_test_conf/gobgpd.conf"
cmd = "cp " + gobgp_file + " " + CONFIG_DIRR
@@ -370,9 +449,21 @@ def init_malformed_test_env_executor(conf_file, use_local):
def docker_container_quagga_append_executor(quagga_num, go_path):
- make_config_append(quagga_num, go_path)
+ make_config_append(quagga_num, go_path, BRIDGE_0)
docker_container_quagga_append(quagga_num, BRIDGE_0)
+ reload_config()
+
+def docker_container_ipv6_quagga_append_executor(quagga_nums, go_path):
+ print "append ipv6 quagga container."
+ global IP_VERSION
+ IP_VERSION = "IPv6"
+ bridge_setting_for_docker_connection([BRIDGE_1])
+ docker_container_set_ipaddress(BRIDGE_1, GOBGP_CONTAINER_NAME, GOBGP_ADDRESS_1[IP_VERSION] + BASE_MASK[IP_VERSION])
+ for quagga_num in quagga_nums:
+ make_config_append(quagga_num, go_path, BRIDGE_1)
+ docker_container_quagga_append(quagga_num, BRIDGE_1)
+ reload_config()
def docker_container_quagga_removed_executor(quagga_num):
docker_container_quagga_removed(quagga_num)
@@ -380,9 +471,10 @@ def docker_container_quagga_removed_executor(quagga_num):
def docker_container_make_bestpath_env_executor(append_quagga_num, go_path):
print "start make bestpath environment"
- make_config_append(append_quagga_num, go_path)
+ make_config_append(append_quagga_num, go_path, BRIDGE_1)
append_quagga_name = "q" + str(append_quagga_num)
docker_container_quagga_append(append_quagga_num, BRIDGE_1)
+ reload_config()
docker_container_set_ipaddress(BRIDGE_1, "q2", "11.0.0.2/16")
docker_container_set_ipaddress(BRIDGE_2, append_quagga_name, "12.0.0.20/16")
docker_container_set_ipaddress(BRIDGE_2, "q3", "12.0.0.3/16")
diff --git a/test/scenario_test/peer_info.py b/test/scenario_test/peer_info.py
new file mode 100644
index 00000000..00490d09
--- /dev/null
+++ b/test/scenario_test/peer_info.py
@@ -0,0 +1,24 @@
+class Peer:
+ def __init__(self, peer_ip, peer_id, peer_as, ip_version):
+ # def __init__(self, peer_ip, peer_id, peer_as):
+ self.peer_ip = peer_ip
+ self.peer_id = peer_id
+ self.peer_as = peer_as
+ self.ip_version = ip_version
+ self.neighbors = []
+ self.destinations = {}
+
+
+class Destination:
+ def __init__(self, prefix):
+ self.prefix = prefix
+ self.paths = []
+
+
+class Path:
+ def __init__(self, network, nexthop):
+ self.network = network
+ self.nexthop = nexthop
+ self.origin = None
+ self.as_path = []
+ self.metric = None \ No newline at end of file
diff --git a/test/scenario_test/quagga-rsconfig.go b/test/scenario_test/quagga-rsconfig.go
index bede8326..870c5d60 100644
--- a/test/scenario_test/quagga-rsconfig.go
+++ b/test/scenario_test/quagga-rsconfig.go
@@ -13,6 +13,16 @@ import (
"path/filepath"
)
+var serverAddress = make(map[string]string)
+var baseNeighborAddress = make(map[string]string)
+var baseNeighborNetwork = make(map[string]string)
+var baseNeighborNetMask = make(map[string]string)
+
+const (
+ IPv4 = "IPv4"
+ IPv6 = "IPv6"
+)
+
type QuaggaConfig struct {
id int
config *config.NeighborType
@@ -29,21 +39,48 @@ func NewQuaggaConfig(id int, gConfig *config.GlobalType, myConfig *config.Neighb
}
}
-func (qt *QuaggaConfig) Config() *bytes.Buffer {
+func (qt *QuaggaConfig) IPv4Config() *bytes.Buffer {
buf := bytes.NewBuffer(nil)
+ buf.WriteString(fmt.Sprintf("! my address %s\n", qt.config.NeighborAddress))
+ buf.WriteString("! my ip_version IPv4\n")
+ buf.WriteString("hostname bgpd\n")
+ buf.WriteString("password zebra\n")
+ buf.WriteString(fmt.Sprintf("router bgp %d\n", qt.config.PeerAs))
+ buf.WriteString(fmt.Sprintf("bgp router-id 192.168.0.%d\n", qt.id))
+ buf.WriteString(fmt.Sprintf("network %s%d%s\n", baseNeighborNetwork["IPv4"], qt.id, baseNeighborNetMask["IPv4"]))
+ buf.WriteString(fmt.Sprintf("neighbor %s remote-as %d\n", qt.serverIP, qt.gobgpConfig.As))
+ buf.WriteString(fmt.Sprintf("neighbor %s password %s\n", qt.serverIP, qt.config.AuthPassword))
+ buf.WriteString("log file /var/log/quagga/bgpd.log\n")
+
+ return buf
+}
+func (qt *QuaggaConfig) IPv6Config() *bytes.Buffer {
+ buf := bytes.NewBuffer(nil)
+ buf.WriteString(fmt.Sprintf("! my address %s\n", qt.config.NeighborAddress))
+ buf.WriteString("! my ip_version IPv6\n")
buf.WriteString("hostname bgpd\n")
buf.WriteString("password zebra\n")
buf.WriteString(fmt.Sprintf("router bgp %d\n", qt.config.PeerAs))
buf.WriteString(fmt.Sprintf("bgp router-id 192.168.0.%d\n", qt.id))
- buf.WriteString(fmt.Sprintf("network 192.168.%d.0/24\n", qt.id))
+ buf.WriteString("no bgp default ipv4-unicast\n")
buf.WriteString(fmt.Sprintf("neighbor %s remote-as %d\n", qt.serverIP, qt.gobgpConfig.As))
buf.WriteString(fmt.Sprintf("neighbor %s password %s\n", qt.serverIP, qt.config.AuthPassword))
- buf.WriteString("log file /var/log/quagga/bgpd.log")
+ buf.WriteString("address-family ipv6\n")
+ buf.WriteString(fmt.Sprintf("network %s%d%s\n", baseNeighborNetwork["IPv6"], qt.id, baseNeighborNetMask["IPv6"]))
+ buf.WriteString(fmt.Sprintf("neighbor %s activate\n", qt.serverIP))
+ buf.WriteString(fmt.Sprintf("neighbor %s route-map IPV6-OUT out\n", qt.serverIP))
+ buf.WriteString("exit-address-family\n")
+ buf.WriteString("ipv6 prefix-list pl-ipv6 seq 10 permit any\n")
+ buf.WriteString("route-map IPV6-OUT permit 10\n")
+ buf.WriteString("match ipv6 address prefix-list pl-ipv6\n")
+ buf.WriteString(fmt.Sprintf("set ipv6 next-hop global %s\n", qt.config.NeighborAddress))
+ buf.WriteString("log file /var/log/quagga/bgpd.log\n")
+
return buf
}
-func create_config_files(nr int, outputDir string) {
+func create_config_files(nr int, outputDir string, IPVersion string) {
quaggaConfigList := make([]*QuaggaConfig, 0)
gobgpConf := config.BgpType{
@@ -56,14 +93,19 @@ func create_config_files(nr int, outputDir string) {
for i := 1; i < nr+1; i++ {
c := config.NeighborType{
PeerAs: 65000 + uint32(i),
- NeighborAddress: net.ParseIP(fmt.Sprintf("10.0.0.%d", i)),
+ NeighborAddress: net.ParseIP(fmt.Sprintf("%s%d", baseNeighborAddress[IPVersion], i)),
AuthPassword: fmt.Sprintf("hoge%d", i),
}
gobgpConf.NeighborList = append(gobgpConf.NeighborList, c)
- q := NewQuaggaConfig(i, &gobgpConf.Global, &c, net.ParseIP("10.0.255.1"))
+ q := NewQuaggaConfig(i, &gobgpConf.Global, &c, net.ParseIP(serverAddress[IPVersion]))
quaggaConfigList = append(quaggaConfigList, q)
os.Mkdir(fmt.Sprintf("%s/q%d", outputDir, i), 0755)
- err := ioutil.WriteFile(fmt.Sprintf("%s/q%d/bgpd.conf", outputDir, i), q.Config().Bytes(), 0644)
+ var err error
+ if IPVersion == "IPv6" {
+ err = ioutil.WriteFile(fmt.Sprintf("%s/q%d/bgpd.conf", outputDir, i), q.IPv6Config().Bytes(), 0644)
+ } else {
+ err = ioutil.WriteFile(fmt.Sprintf("%s/q%d/bgpd.conf", outputDir, i), q.IPv4Config().Bytes(), 0644)
+ }
if err != nil {
log.Fatal(err)
}
@@ -79,7 +121,8 @@ func create_config_files(nr int, outputDir string) {
}
}
-func append_config_files(ar int, outputDir string) {
+func append_config_files(ar int, outputDir string, IPVersion string) {
+
gobgpConf := config.BgpType{
Global: config.GlobalType{
As: 65000,
@@ -87,14 +130,18 @@ func append_config_files(ar int, outputDir string) {
},
}
c := config.NeighborType{
- PeerAs: 65000 + uint32(ar),
-
- NeighborAddress: net.ParseIP(fmt.Sprintf("10.0.0.%d", ar)),
+ PeerAs: 65000 + uint32(ar),
+ NeighborAddress: net.ParseIP(fmt.Sprintf("%s%d", baseNeighborAddress[IPVersion], ar)),
AuthPassword: fmt.Sprintf("hoge%d", ar),
}
- q := NewQuaggaConfig(ar, &gobgpConf.Global, &c, net.ParseIP("10.0.255.1"))
+ q := NewQuaggaConfig(ar, &gobgpConf.Global, &c, net.ParseIP(serverAddress[IPVersion]))
os.Mkdir(fmt.Sprintf("%s/q%d", outputDir, ar), 0755)
- err := ioutil.WriteFile(fmt.Sprintf("%s/q%d/bgpd.conf", outputDir, ar), q.Config().Bytes(), 0644)
+ var err error
+ if IPVersion == "IPv6" {
+ err = ioutil.WriteFile(fmt.Sprintf("%s/q%d/bgpd.conf", outputDir, ar), q.IPv6Config().Bytes(), 0644)
+ } else {
+ err = ioutil.WriteFile(fmt.Sprintf("%s/q%d/bgpd.conf", outputDir, ar), q.IPv4Config().Bytes(), 0644)
+ }
if err != nil {
log.Fatal(err)
}
@@ -115,14 +162,17 @@ func append_config_files(ar int, outputDir string) {
func main() {
var opts struct {
- ClientNumber int `short:"n" long:"client-number" description:"specfying the number of clients" default:"8"`
- OutputDir string `short:"c" long:"output" description:"specifing the output directory"`
- AppendClient int `short:"a" long:"append" description:"specifing the add client number" default:"0"`
+ ClientNumber int `short:"n" long:"client-number" description:"specfying the number of clients" default:"8"`
+ OutputDir string `short:"c" long:"output" description:"specifing the output directory"`
+ AppendClient int `short:"a" long:"append" description:"specifing the add client number" default:"0"`
+ IPVersion string `short:"v" long:"ip-version" description:"specifing the use ip version" default:"IPv4"`
+ NetIdentifier int `short:"i" long:"net-identifer" description:"specifing the use network identifier" default:"0"`
}
parser := flags.NewParser(&opts, flags.Default)
_, err := parser.Parse()
if err != nil {
+ fmt.Print(err)
os.Exit(1)
}
@@ -134,12 +184,25 @@ func main() {
}
}
+ if opts.IPVersion == IPv6 {
+ serverAddress[IPv6] = fmt.Sprintf("2001::%d:192:168:255:1", opts.NetIdentifier)
+ baseNeighborAddress[IPv6] = fmt.Sprintf("2001::%d:192:168:0:", opts.NetIdentifier)
+ baseNeighborNetwork[IPv6] = "2001:0:10:"
+ baseNeighborNetMask[IPv6] = "::/64"
+ } else {
+ opts.IPVersion = IPv4
+ serverAddress[IPv4] = fmt.Sprintf("1%d.0.255.1", opts.NetIdentifier)
+ baseNeighborAddress[IPv4] = fmt.Sprintf("1%d.0.0.", opts.NetIdentifier)
+ baseNeighborNetwork[IPv4] = "192.168."
+ baseNeighborNetMask[IPv4] = ".0/24"
+ }
+
if opts.AppendClient == 0 {
- create_config_files(opts.ClientNumber, opts.OutputDir)
+ create_config_files(opts.ClientNumber, opts.OutputDir, opts.IPVersion)
} else {
if _, err := os.Stat(fmt.Sprintf("%s/gobgpd.conf", opts.OutputDir)); os.IsNotExist(err) {
log.Fatal(err)
}
- append_config_files(opts.AppendClient, opts.OutputDir)
+ append_config_files(opts.AppendClient, opts.OutputDir, opts.IPVersion)
}
}
diff --git a/test/scenario_test/quagga_access.py b/test/scenario_test/quagga_access.py
index df2eb938..1e51afaf 100644
--- a/test/scenario_test/quagga_access.py
+++ b/test/scenario_test/quagga_access.py
@@ -82,7 +82,13 @@ def show_rib(tn):
tn.write("show ip bgp\n")
tn.read_until(" Network Next Hop Metric LocPrf Weight Path")
rib = tn.read_until("bgpd#")
- # print header
+ return rib_parser(rib)
+
+
+def show_ipv6_rib(tn):
+ tn.write("show bgp ipv6\n")
+ tn.read_until(" Network Next Hop Metric LocPrf Weight Path")
+ rib = tn.read_until("bgpd#")
return rib_parser(rib)
@@ -90,6 +96,7 @@ def clear_ip_bgp(tn):
tn.write("clear ip bgp *\n")
tn.read_until("bgpd#")
+
def rib_parser(rib):
lines = rib.split("\n")
paths = []
@@ -99,10 +106,6 @@ def rib_parser(rib):
elems = line.split()
path['Network'] = elems[1]
path['Next Hop'] = elems[2]
- # path['Metric'] = elems[3]
- # path['LocPrf'] = elems[4]
- # path['Weight'] = elems[5]
- # path['Path'] = elems[6]
if len(path) > 0:
paths.append(path)
return paths
diff --git a/test/scenario_test/route_server_ipv4_v6_test.py b/test/scenario_test/route_server_ipv4_v6_test.py
new file mode 100644
index 00000000..8fbfafd0
--- /dev/null
+++ b/test/scenario_test/route_server_ipv4_v6_test.py
@@ -0,0 +1,239 @@
+# Copyright (C) 2014 Nippon Telegraph and Telephone Corporation.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+# implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+import unittest
+import requests
+import json
+import toml
+import os
+import time
+import sys
+import nose
+import quagga_access as qaccess
+from peer_info import Peer
+from peer_info import Destination
+from peer_info import Path
+from ciscoconfparse import CiscoConfParse
+import docker_control as fab
+from noseplugin import OptionParser
+from noseplugin import parser_option
+
+
+class GoBGPIPv6Test(unittest.TestCase):
+
+ gobgp_ip = "10.0.255.1"
+ gobgp_port = "8080"
+ base_dir = "/usr/local/gobgp/"
+ gobgp_config_file = "/usr/local/gobgp/gobgpd.conf"
+ gobgp_config = None
+ quagga_num = 2
+ append_quagga = 10
+ remove_quagga = 10
+ append_quagga_best = 20
+ sleep_time = 20
+
+ def __init__(self, *args, **kwargs):
+ super(GoBGPIPv6Test, self).__init__(*args, **kwargs)
+
+ def setUp(self):
+ self.quagga_configs = []
+
+ # test each neighbor state is turned establish
+ def test_01_ipv4_ipv6_neighbor_established(self):
+ print "test_ipv4_ipv6_neighbor_established"
+
+ use_local = parser_option.use_local
+ go_path = parser_option.go_path
+ fab.init_ipv6_test_env_executor(self.quagga_num, use_local, go_path)
+ time.sleep(self.sleep_time)
+ print "please wait"
+ fab.docker_container_ipv6_quagga_append_executor([3, 4], go_path)
+ print "please wait"
+ time.sleep(self.sleep_time)
+ if self.check_load_config() is False:
+ return
+
+ addresses = self.get_neighbor_address(self.gobgp_config)
+
+ for address in addresses:
+ # get neighbor state and remote ip from gobgp connections
+ print "check of [ " + address[0] + " : " + address[1] + " ]"
+ url = "http://" + self.gobgp_ip + ":" + self.gobgp_port + "/v1/bgp/neighbor/" + address[0]
+ r = requests.get(url)
+ neighbor = json.loads(r.text)
+ state = neighbor['info']['bgp_state']
+ remote_ip = neighbor['conf']['remote_ip']
+ self.assertEqual(address[0], remote_ip)
+ self.assertEqual(state, "BGP_FSM_ESTABLISHED")
+
+ def test_02_ipv4_ipv6_received_route(self):
+ print "test_ipv4_ipv6_received_route"
+ if self.check_load_config() is False:
+ return
+
+ for address in self.get_neighbor_address(self.gobgp_config):
+ print "check of [ " + address[0] + " : " + address[1] + " ]"
+ # get local-rib per peer
+ url = "http://" + self.gobgp_ip + ":" + self.gobgp_port + "/v1/bgp/neighbor/" + address[0] + "/local-rib"
+ r = requests.get(url)
+ local_rib = json.loads(r.text)
+
+ for quagga_config in self.quagga_configs:
+ # print quagga_config.peer_ip + " : " + address[0] + " | " + quagga_config.ip_version + " : " + address[1]
+ if quagga_config.peer_ip == address[0] or quagga_config.ip_version != address[1]:
+ for c_dest in quagga_config.destinations.itervalues():
+ # print "config : ", c_dest.prefix, "my ip or different ip version!!!"
+ g_dests = local_rib['Destinations']
+ exist_n = 0
+ for g_dest in g_dests:
+ # print "gobgp : ", g_dest['Prefix']
+ if c_dest.prefix == g_dest['Prefix']:
+ exist_n += 1
+ self.assertEqual(exist_n, 0)
+ else:
+ for c_dest in quagga_config.destinations.itervalues():
+ # print "config : ", c_dest.prefix"
+ g_dests = local_rib['Destinations']
+ exist_n = 0
+ for g_dest in g_dests:
+ # print "gobgp : ", g_dest['Prefix']
+ if c_dest.prefix == g_dest['Prefix']:
+ exist_n += 1
+ self.assertEqual(exist_n, 1)
+
+ def test_03_advertising_route(self):
+ print "test_advertising_route"
+ if self.check_load_config() is False:
+ return
+
+ for address in self.get_neighbor_address(self.gobgp_config):
+ print "check of [ " + address[0] + " : " + address[1] + " ]"
+ tn = qaccess.login(address[0])
+ if address[1] == "IPv6":
+ q_rib = qaccess.show_ipv6_rib(tn)
+ else:
+ q_rib = qaccess.show_rib(tn)
+ for quagga_config in self.quagga_configs:
+ if quagga_config.peer_ip == address[0] or quagga_config.ip_version != address[1]:
+ for c_dest in quagga_config.destinations.itervalues():
+ exist_n = 0
+ for c_path in c_dest.paths:
+ # print "conf : ", c_path.network, c_path.nexthop, "my ip or different ip version!!!"
+ for q_path in q_rib:
+ # print "quag : ", q_path['Network'], q_path['Next Hop']
+ if "0.0.0.0" == q_path['Next Hop'] or "::" == q_path['Next Hop']:
+ continue
+ if c_path.network.split("/")[0] == q_path['Network']:
+ exist_n += 1
+ self.assertEqual(exist_n, 0)
+
+ else:
+ for c_dest in quagga_config.destinations.itervalues():
+ exist_n = 0
+ for c_path in c_dest.paths:
+ # print "conf : ", c_path.network, c_path.nexthop
+ for q_path in q_rib:
+ # print "quag : ", q_path['Network'], q_path['Next Hop']
+ if quagga_config.ip_version != "IPv6":
+ c_path.network = c_path.network.split("/")[0]
+ if c_path.network == q_path['Network'] and c_path.nexthop == q_path['Next Hop']:
+ exist_n += 1
+ self.assertEqual(exist_n, 1)
+
+ def load_gobgp_config(self):
+ try:
+ self.gobgp_config = toml.loads(open(self.gobgp_config_file).read())
+ except IOError, (errno, strerror):
+ print "I/O error(%s): %s" % (errno, strerror)
+
+ # load configration from quagga(bgpd.conf)
+ def load_quagga_config(self):
+ dirs = []
+ try:
+ content = os.listdir(self.base_dir)
+ for item in content:
+ if "q" != item[0]:
+ continue
+ if os.path.isdir(os.path.join(self.base_dir, item)):
+ dirs.append(item)
+ except OSError, (errno, strerror):
+ print "I/O error(%s): %s" % (errno, strerror)
+
+ for dir in dirs:
+ config_path = self.base_dir + dir + "/bgpd.conf"
+ config = CiscoConfParse(config_path)
+
+ peer_ip = config.find_objects(r"^!\smy\saddress")[0].text.split(" ")[3]
+ peer_ip_version = config.find_objects(r"^!\smy\sip_version")[0].text.split(" ")[3]
+ peer_id = config.find_objects(r"^bgp\srouter-id")[0].text.split(" ")[2]
+ peer_as = config.find_objects(r"^router\sbgp")[0].text.split(" ")[2]
+ quagga_config = Peer(peer_ip, peer_id, peer_as, peer_ip_version)
+
+ networks = config.find_objects(r"^network")
+ if len(networks) == 0:
+ continue
+ for network in networks:
+ elems = network.text.split(" ")
+ prefix = elems[1].split("/")[0]
+ network = elems[1]
+ nexthop = peer_ip
+ path = Path(network, nexthop)
+ dest = Destination(prefix)
+ dest.paths.append(path)
+ quagga_config.destinations[prefix] = dest
+
+ neighbors = config.find_objects(r"^neighbor\s.*\sremote-as")
+ if len(neighbors) == 0:
+ continue
+ for neighbor in neighbors:
+ elems = neighbor.text.split(" ")
+ neighbor = Peer(elems[1], None, elems[3], None)
+ quagga_config.neighbors.append(neighbor)
+ self.quagga_configs.append(quagga_config)
+
+ # get address of each neighbor from gobpg configration
+ def get_neighbor_address(self, config):
+ address = []
+ neighbors_config = config['NeighborList']
+ for neighbor_config in neighbors_config:
+ neighbor_ip = neighbor_config['NeighborAddress']
+ address_version = "IPv4"
+ if ":" in neighbor_ip:
+ address_version = "IPv6"
+ neighbor_ip_info = [neighbor_ip, address_version]
+ address.append(neighbor_ip_info)
+ return address
+
+ def check_load_config(self):
+ self.load_gobgp_config()
+ self.load_quagga_config()
+ if self.gobgp_config is None:
+ print "Failed to read the gobgp configuration file"
+ return False
+ if len(self.quagga_configs) == 0:
+ print "Failed to read the quagga configuration file"
+ return False
+ return True
+
+
+if __name__ == '__main__':
+ if fab.test_user_check() is False:
+ print "you are not root."
+ sys.exit(1)
+ if fab.docker_pkg_check() is False:
+ print "not install docker package."
+ sys.exit(1)
+
+ nose.main(argv=sys.argv, addplugins=[OptionParser()], defaultTest=sys.argv[0])
diff --git a/test/scenario_test/route_server_test.py b/test/scenario_test/route_server_test.py
index 36bac41a..7f6eb9c3 100644
--- a/test/scenario_test/route_server_test.py
+++ b/test/scenario_test/route_server_test.py
@@ -22,6 +22,9 @@ import time
import sys
import nose
import quagga_access as qaccess
+from peer_info import Peer
+from peer_info import Destination
+from peer_info import Path
from ciscoconfparse import CiscoConfParse
import docker_control as fab
from noseplugin import OptionParser
@@ -395,7 +398,6 @@ class GoBGPTest(unittest.TestCase):
return
self.assertEqual(ans_nexthop, rep_nexthop)
-
def load_gobgp_config(self):
try:
self.gobgp_config = toml.loads(open(self.gobgp_config_file).read())
@@ -418,10 +420,12 @@ class GoBGPTest(unittest.TestCase):
for dir in dirs:
config_path = self.base_dir + dir + "/bgpd.conf"
config = CiscoConfParse(config_path)
- peer_ip = "10.0.0." + str(dir).replace("q", "")
- peer_id = config.find_objects(r"^bgp\srouter-id")[0].text
- peer_as = config.find_objects(r"^router\sbgp")[0].text
- quagga_config = Peer(peer_ip, peer_id, peer_as)
+
+ peer_ip = config.find_objects(r"^!\smy\saddress")[0].text.split(" ")[3]
+ peer_ip_version = config.find_objects(r"^!\smy\sip_version")[0].text.split(" ")[3]
+ peer_id = config.find_objects(r"^bgp\srouter-id")[0].text.split(" ")[2]
+ peer_as = config.find_objects(r"^router\sbgp")[0].text.split(" ")[2]
+ quagga_config = Peer(peer_ip, peer_id, peer_as, peer_ip_version)
networks = config.find_objects(r"^network")
if len(networks) == 0:
@@ -435,15 +439,17 @@ class GoBGPTest(unittest.TestCase):
dest = Destination(prefix)
dest.paths.append(path)
quagga_config.destinations[prefix] = dest
+ # print "prefix: " + prefix
+ # print "network: " + network
+ # print "nexthop: " + nexthop
neighbors = config.find_objects(r"^neighbor\s.*\sremote-as")
if len(neighbors) == 0:
continue
for neighbor in neighbors:
elems = neighbor.text.split(" ")
- neighbor = Peer(elems[1], None, elems[3])
+ neighbor = Peer(elems[1], None, elems[3], None)
quagga_config.neighbors.append(neighbor)
-
self.quagga_configs.append(quagga_config)
# get address of each neighbor from gobpg configration
@@ -467,29 +473,6 @@ class GoBGPTest(unittest.TestCase):
return True
-class Peer:
- def __init__(self, peer_ip, peer_id, peer_as):
- self.peer_ip = peer_ip
- self.peer_id = peer_id
- self.peer_as = peer_as
- self.neighbors = []
- self.destinations = {}
-
-
-class Destination:
- def __init__(self, prefix):
- self.prefix = prefix
- self.paths = []
-
-
-class Path:
- def __init__(self, network, nexthop):
- self.network = network
- self.nexthop = nexthop
- self.origin = None
- self.as_path = []
- self.metric = None
-
if __name__ == '__main__':
if fab.test_user_check() is False:
print "you are not root."
@@ -497,7 +480,5 @@ if __name__ == '__main__':
if fab.docker_pkg_check() is False:
print "not install docker package."
sys.exit(1)
- if fab.go_path_check() is False:
- print "can not find path of go"
nose.main(argv=sys.argv, addplugins=[OptionParser()], defaultTest=sys.argv[0])
generated by cgit v1.2.3 (git 2.39.1) at 2024-11-15 18:36:33 +0000