test: remove unused files

now all scenario_test uses scenario_test/lib. remove unused files.

Signed-off-by: ISHIDA Wataru <ishida.wataru@lab.ntt.co.jp>

6 files changed, 0 insertions, 1587 deletions

diff --git a/test/scenario_test/constant.py b/test/scenario_test/constant.py
deleted file mode 100644
index 33572c8d..00000000
--- a/test/scenario_test/constant.py
+++ /dev/null
@@ -1,73 +0,0 @@
-# Copyright (C) 2015 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.
-
-
-IPv4 = 'ipv4'
-IPv6 = 'ipv6'
-GOBGP_IP = "10.0.255.1"
-GOBGP_CONTAINER_NAME = "gobgp"
-GOBGP_ADDRESS_0 = {IPv4: GOBGP_IP,
-                   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"
-CONFIG_DIR = "/tmp/gobgp"
-CONFIG_DIRR = "/tmp/gobgp/"
-SHARE_VOLUME = "/root/share_volume"
-CLI_CMD = "docker exec gobgp /go/bin/gobgp"
-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"
-INSTALL_FILE = SHARE_VOLUME + "/" + INSTALL_FILE_NAME
-
-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"
-
-
-ADJ_RIB_IN = "adj-in"
-ADJ_RIB_OUT = "adj-out"
-LOCAL_RIB = "local"
-GLOBAL_RIB = "global rib"
-NEIGHBOR = "neighbor"
-POLICY = "policy"
-
-BGP_ATTR_TYPE_AS_PATH= 2
-BGP_ATTR_TYPE_MED = 4
-BGP_ATTR_TYPE_COMMUNITIES = 8
diff --git a/test/scenario_test/docker_control.py b/test/scenario_test/docker_control.py
deleted file mode 100644
index 3232f566..00000000
--- a/test/scenario_test/docker_control.py
+++ /dev/null
@@ -1,566 +0,0 @@
-# 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.
-
-from fabric.api import local
-import re
-import os
-import time
-from constant import *
-
-def test_user_check():
-    root = False
-    outbuf = local("echo $USER", capture=True)
-    user = outbuf
-    if user == "root":
-        root = True
-
-    return root
-
-
-def install_docker_and_tools():
-    print "start install packages of test environment."
-    if test_user_check() is False:
-        print "you are not root"
-        return
-
-    local("apt-key adv --keyserver hkp://keyserver.ubuntu.com:80 --recv-keys "
-          "36A1D7869245C8950F966E92D8576A8BA88D21E9", capture=True)
-    local('sh -c "echo deb https://get.docker.io/ubuntu docker main > /etc/apt/sources.list.d/docker.list"',
-          capture=True)
-    local("apt-get update", capture=True)
-    local("apt-get install -y --force-yes lxc-docker-1.3.2", capture=True)
-    local("ln -sf /usr/bin/docker.io /usr/local/bin/docker", capture=True)
-    local("gpasswd -a `whoami` docker", capture=True)
-    local("apt-get install -y --force-yes emacs23-nox", capture=True)
-    local("apt-get install -y --force-yes wireshark", capture=True)
-    local("apt-get install -y --force-yes iputils-arping", capture=True)
-    local("apt-get install -y --force-yes bridge-utils", capture=True)
-    local("apt-get install -y --force-yes tcpdump", capture=True)
-    local("apt-get install -y --force-yes lv", capture=True)
-    local("wget https://raw.github.com/jpetazzo/pipework/master/pipework -O /usr/local/bin/pipework",
-          capture=True)
-    local("chmod 755 /usr/local/bin/pipework", capture=True)
-    local("docker pull osrg/quagga", capture=True)
-    local("docker pull osrg/gobgp", capture=True)
-    local("docker pull osrg/exabgp", capture=True)
-
-
-def docker_pkg_check():
-    docker_exists = False
-    outbuf = local("dpkg -l | grep docker | awk '{print $2}'", capture=True)
-    dpkg_list = outbuf.split('\n')
-    for dpkg in dpkg_list:
-        if "lxc-docker" in dpkg:
-            docker_exists = True
-    return docker_exists
-
-
-def go_path_check():
-    go_path_exist = False
-    outbuf = local("echo `which go`", capture=True)
-    if "go" in outbuf:
-        go_path_exist = True
-    return go_path_exist
-
-
-def docker_container_check():
-    container_exists = False
-    outbuf = local("docker ps -a", capture=True)
-    docker_ps = outbuf.split('\n')
-    for container in docker_ps:
-        container_name = container.split()[-1]
-        if (container_name == GOBGP_CONTAINER_NAME) or \
-                (container_name == EXABGP_CONTAINER_NAME) or ("q" in container_name):
-            container_exists = True
-    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}'"
-    outbuf = local(cmd, capture=True)
-    docker_ps = outbuf.split('\n')
-    for container in docker_ps:
-        if container != "NAMES":
-            containers.append(container.split()[-1])
-    return containers
-
-
-def docker_container_set_ipaddress(bridge, name, address):
-    cmd = "pipework " + bridge["BRIDGE_NAME"] + " -i e" + bridge["BRIDGE_NAME"]\
-          + " " + name + " " + address
-    local(cmd, capture=True)
-
-
-def docker_container_run_quagga(quagga_num, bridge):
-    quagga_name = "q" + str(quagga_num)
-    cmd = "docker run --privileged=true -v " + CONFIG_DIR + "/" + quagga_name +\
-          ":/etc/quagga --name " + quagga_name + " -id osrg/quagga"
-    local(cmd, capture=True)
-    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)
-    # restart the quagga after the docker container has become IP reachable
-    cmd = 'docker kill --signal="HUP" ' + quagga_name
-    local(cmd, capture=True)
-
-
-def docker_container_run_gobgp(bridge, image='osrg/gobgp'):
-    cmd = "docker run --privileged=true -v " + CONFIG_DIR + ":" + SHARE_VOLUME + " -d --name "\
-          + GOBGP_CONTAINER_NAME + " -id " + image
-    local(cmd, capture=True)
-    docker_container_set_ipaddress(bridge, GOBGP_CONTAINER_NAME, GOBGP_ADDRESS_0[IP_VERSION] + BASE_MASK[IP_VERSION])
-
-
-def docker_container_run_exabgp(bridge):
-    pwd = local("pwd", capture=True)
-    test_pattern_dir = pwd + "/exabgp_test_conf"
-    cmd = "cp -r " + test_pattern_dir + " " + CONFIG_DIRR
-    local(cmd, capture=True)
-    cmd = "docker run --privileged=true -v " + CONFIG_DIR + ":" + SHARE_VOLUME + " -d --name "\
-          + EXABGP_CONTAINER_NAME + " -id osrg/exabgp"
-    local(cmd, capture=True)
-    docker_container_set_ipaddress(bridge, EXABGP_CONTAINER_NAME, EXABGP_ADDRESS)
-
-
-def change_owner_to_root(target):
-    cmd = "chown -R root:root " + target
-    local(cmd, capture=True)
-
-
-def create_config_dir():
-    cmd = "mkdir " + CONFIG_DIR
-    local(cmd, capture=True)
-
-
-def recreate_conf_dir(dirname):
-    cmd = "rm -rf " + dirname
-    local(cmd, capture=True)
-    cmd = "mkdir " + dirname
-    local(cmd, capture=True)
-
-
-def make_startup_file(log_opt=""):
-    file_buff = '#!/bin/bash' + '\n'
-    file_buff += "cd /go/bin" + '\n'
-    file_buff += "./gobgpd -f " + SHARE_VOLUME + "/gobgpd.conf " + log_opt + " > " + SHARE_VOLUME + "/gobgpd.log 2>&1 "
-
-    cmd = "echo \"" + file_buff + "\" > " + CONFIG_DIR + "/" + STARTUP_FILE_NAME
-    local(cmd, capture=True)
-    cmd = "chmod 755 " + CONFIG_DIRR + STARTUP_FILE_NAME
-    local(cmd, capture=True)
-
-
-def make_install_file():
-    file_buff = '#!/bin/bash' + '\n'
-    file_buff += 'rm -rf  /go/src/github.com/osrg/gobgp' + '\n'
-    file_buff += 'cp -r ' + SHARE_VOLUME + '/gobgp /go/src/github.com/osrg/' + '\n'
-    file_buff += 'go get github.com/osrg/gobgp/gobgpd' + '\n'
-    file_buff += 'go get github.com/osrg/gobgp/gobgp' + '\n'
-    cmd = "echo \"" + file_buff + "\" > " + CONFIG_DIR + "/" + INSTALL_FILE_NAME
-    local(cmd, capture=True)
-    cmd = "chmod 755 " + CONFIG_DIRR + INSTALL_FILE_NAME
-    local(cmd, capture=True)
-
-
-def docker_container_stop_quagga(quagga):
-    if docker_check_running(quagga):
-        cmd = "docker stop " + quagga
-        local(cmd, capture=True)
-
-    cmd = "docker rm " + quagga
-    local(cmd, capture=True)
-    cmd = "rm -rf " + CONFIG_DIRR + quagga
-    local(cmd, capture=True)
-
-
-def docker_container_stop_gobgp(remove=True):
-    if docker_check_running(GOBGP_CONTAINER_NAME):
-        cmd = "docker stop --time=0 " + GOBGP_CONTAINER_NAME
-        local(cmd, capture=True)
-
-    if remove:
-        cmd = "docker rm " + GOBGP_CONTAINER_NAME
-        local(cmd, capture=True)
-
-
-def docker_container_stop_exabgp():
-    if docker_check_running(EXABGP_CONTAINER_NAME):
-        cmd = "docker stop --time=0 " + EXABGP_CONTAINER_NAME
-        local(cmd, capture=True)
-
-    cmd = "docker rm  " + EXABGP_CONTAINER_NAME
-    local(cmd, capture=True)
-
-
-def docker_containers_destroy(gobgp_remove=True, confdir_remove=True):
-    containers = docker_containers_get()
-    for container in containers:
-        if re.match(r'q[0-9][0-9]*', container) is not None:
-            docker_container_stop_quagga(container)
-        if container == GOBGP_CONTAINER_NAME:
-            docker_container_stop_gobgp(remove=gobgp_remove)
-        if container == EXABGP_CONTAINER_NAME:
-            docker_container_stop_exabgp()
-    bridge_unsetting_for_docker_connection()
-    if confdir_remove:
-        cmd = "rm -rf " + CONFIG_DIRR
-        local(cmd, capture=True)
-
-
-def docker_check_running(cname):
-    cmd = "docker ps | awk '{print $NF}'"
-    outbuf = local(cmd, capture=True)
-    docker_ps = outbuf.split('\n')
-    if cname in docker_ps:
-        return True
-
-
-def docker_container_quagga_append(quagga_num, bridge):
-    print "start append docker container."
-    docker_container_run_quagga(quagga_num, bridge)
-
-
-def docker_container_quagga_removed(quagga_num):
-    print "start removed docker container."
-    quagga = "q" + str(quagga_num)
-    docker_container_stop_quagga(quagga)
-    print "complete removed docker container."
-
-
-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)
-        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)
-
-
-def bridge_unsetting_for_docker_connection():
-    for bridge in BRIDGES:
-        sysfs_name = "/sys/class/net/" + bridge["BRIDGE_NAME"]
-        if os.path.exists(sysfs_name):
-            cmd = "ifconfig " + bridge["BRIDGE_NAME"] + " down"
-            local(cmd, capture=True)
-            cmd = "brctl delbr " + bridge["BRIDGE_NAME"]
-            local(cmd, capture=True)
-
-
-def build_gobgp():
-    cmd = "docker exec gobgp " + INSTALL_FILE
-    local(cmd, capture=True)
-
-
-def start_gobgp(build=False):
-    if build:
-        build_gobgp()
-    cmd = "docker exec -d gobgp " + STARTUP_FILE
-    local(cmd, capture=True)
-
-
-def start_exabgp(conf_file):
-    # run exabgp docker container
-    docker_container_run_exabgp(BRIDGE_0)
-
-    cmd = "docker exec exabgp cp -f " + SHARE_VOLUME + "/exabgp_test_conf/exabgp.env /root/exabgp/etc/exabgp/exabgp.env"
-    local(cmd, capture=True)
-    conf_path = EXABGP_CONFDIR + "/" + conf_file
-    cmd = "docker exec exabgp /root/exabgp/sbin/exabgp " + conf_path + " > /dev/null 2>&1 &"
-    local(cmd, capture=True)
-
-
-def stop_exabgp():
-    docker_container_stop_exabgp()
-    log_path = CONFIG_DIRR + EXABGP_LOG_FILE
-    clean_log(log_path)
-
-
-def clean_log(file_path):
-    cmd = ": > " + file_path
-    local(cmd, capture=True)
-
-
-def get_notification_from_exabgp_log():
-    log_path = CONFIG_DIRR + EXABGP_LOG_FILE
-    cmd = "grep notification " + log_path + " | head -1"
-    err_mgs = local(cmd, capture=True)
-    return err_mgs
-
-
-def make_config(quagga_num, go_path, bridge, peer_opts="", use_compiled=False, ipver=''):
-    if go_path != "":
-        print "specified go path is [ " + go_path + " ]."
-        if os.path.isdir(go_path):
-            go_path += "/"
-        else:
-            print "specified go path do not use."
-    pwd = local("pwd", capture=True)
-
-    tool = go_path + "go run " + pwd + "/quagga-rsconfig.go "
-    if use_compiled:
-        tool = pwd + "/quagga-rsconfig "
-
-    # I want to avoid a global variable.
-    ip_version = ipver if ipver else IP_VERSION
-    cmd = tool + " -n " + str(quagga_num) +\
-          " -c /tmp/gobgp -v " + ip_version + " -i " + bridge["BRIDGE_NAME"][-1] + " " + peer_opts
-    local(cmd, capture=True)
-
-
-def update_policy_config(go_path, neighbor, policy_name, target, isReplace=False, defaultReject=False):
-    if go_path != "":
-        print "specified go path is [ " + go_path + " ]."
-        if os.path.isdir(go_path):
-            go_path += "/"
-        else:
-            print "specified go path is not used."
-
-    pwd = local("pwd", capture=True)
-    replace = ' -r' if isReplace else ''
-    reject = ' -j' if defaultReject else ''
-    cmd = pwd + "/policy_generator -d /tmp/gobgp -n " + neighbor + " -t " + target + " -p " + policy_name + replace + reject
-    local(cmd, capture=True)
-    # reload_config()
-
-
-def make_config_append(quagga_num, go_path, bridge, peer_opts="", use_compiled=False, ipver=''):
-    if go_path != "":
-        print "specified go path is [ " + go_path + " ]."
-        if os.path.isdir(go_path):
-            go_path += "/"
-        else:
-            print "specified go path do not use."
-    pwd = local("pwd", capture=True)
-    ip_version = ipver if ipver else IP_VERSION
-
-    tool = go_path + "go run " + pwd + "/quagga-rsconfig.go "
-    if use_compiled:
-        tool = pwd + "/quagga-rsconfig "
-
-    cmd = tool + " -a " + str(quagga_num) +\
-          " -c /tmp/gobgp -v " + ip_version + " -i " + bridge["BRIDGE_NAME"][-1] + " " + peer_opts
-    local(cmd, capture=True)
-
-
-def reload_config():
-    cmd = "docker exec gobgp /usr/bin/pkill gobgpd -SIGHUP"
-    local(cmd, capture=True)
-    print "gobgp config reloaded."
-
-
-def build_config_tools(go_path):
-    if go_path != "":
-        print "specified go path is [ " + go_path + " ]."
-        if os.path.isdir(go_path):
-            go_path += "/"
-        else:
-            print "the specified go path is not directory.."
-
-    pwd = local("pwd", capture=True)
-    cmd = go_path + "go build " + pwd + "/quagga-rsconfig.go"
-    local(cmd, capture=True)
-    cmd = go_path + "go build " + pwd + "/policy/policy_generator.go"
-    local(cmd, capture=True)
-
-
-def prepare_gobgp(log_debug, image='osrg/gobgp'):
-
-    # cleanup gobgp container
-    containers = docker_containers_get()
-    if GOBGP_CONTAINER_NAME in containers:
-        docker_container_stop_gobgp(remove=True)
-    recreate_conf_dir(CONFIG_DIRR)
-    # set log option
-    opt = "-l debug" if log_debug else ""
-    do_build = False
-    make_startup_file(log_opt=opt)
-    change_owner_to_root(CONFIG_DIR)
-    cmd = "docker run --privileged=true -v " + CONFIG_DIR + ":" + SHARE_VOLUME + " -d --name " \
-          + GOBGP_CONTAINER_NAME + " -id " + image
-    local(cmd, capture=True)
-    if do_build:
-        build_gobgp()
-
-
-def init_test_env_executor(quagga_num, image, go_path, log_debug=False, is_route_server=True):
-    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."
-    create_config_dir()
-    bridge_setting_for_docker_connection(BRIDGES)
-    make_config(quagga_num, go_path, BRIDGE_0, ("" if is_route_server else "--normal-bgp"))
-
-    # run gobgp docker container
-    docker_container_run_gobgp(BRIDGE_0, image)
-
-    # set log option
-    opt = "-l debug" if log_debug else ""
-    do_build = False
-    # execute local gobgp program in the docker container if the input option is local
-    make_startup_file(log_opt=opt)
-    change_owner_to_root(CONFIG_DIR)
-    start_gobgp(build=do_build)
-
-    # run quagga docker container
-    for num in range(1, quagga_num + 1):
-        docker_container_run_quagga(num, BRIDGE_0)
-
-    print "complete initialization of test environment."
-
-
-def init_policy_test_env_executor(quagga_num, use_ipv6=False, use_exabgp=False):
-    print "start initialization of test environment."
-
-    global IP_VERSION
-    IP_VERSION = IPv6 if use_ipv6 else IPv4
-
-    bridge_setting_for_docker_connection(BRIDGES)
-
-    cmd = "docker start %s" % GOBGP_CONTAINER_NAME
-    local(cmd, capture=True)
-    docker_container_set_ipaddress(BRIDGE_0, GOBGP_CONTAINER_NAME, GOBGP_ADDRESS_0[IP_VERSION] + BASE_MASK[IP_VERSION])
-
-    if use_exabgp:
-        # run exabgp
-        start_exabgp(EXABGP_COMMON_CONF)
-
-    start_gobgp()
-
-    # run quagga docker container
-    for num in range(1, quagga_num + 1):
-        docker_container_run_quagga(num, BRIDGE_0)
-
-    print "complete initialization of test environment."
-
-
-def init_ipv6_test_env_executor(quagga_num, image, go_path, log_debug=False):
-    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."
-    create_config_dir()
-    bridge_setting_for_docker_connection([BRIDGE_0])
-    make_config(quagga_num, go_path, BRIDGE_0)
-
-    # run gobgp docker container
-    docker_container_run_gobgp(BRIDGE_0, image)
-
-    # set log option
-    opt = "-l debug" if log_debug else ""
-    do_build = False
-    make_startup_file(log_opt=opt)
-    change_owner_to_root(CONFIG_DIR)
-    start_gobgp(do_build)
-
-    # run quagga docker container
-    for num in range(1, quagga_num + 1):
-        docker_container_run_quagga(num, BRIDGE_0)
-
-    print "complete initialization of test environment."
-
-
-def init_malformed_test_env_executor(image,  go_path, exabgp_path, log_debug=False):
-    print "start initialization of exabgp 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."
-    peer_opts = "--none-peer"
-    create_config_dir()
-    bridge_setting_for_docker_connection(BRIDGES)
-    make_config(1, go_path, BRIDGE_0)
-    make_config_append(100, go_path, BRIDGE_0, peer_opts)
-
-    # run gobgp docker container
-    docker_container_run_gobgp(BRIDGE_0, image)
-
-    # set log option
-    opt = "-l debug" if log_debug else ""
-    do_build = False
-    make_startup_file(log_opt=opt)
-    change_owner_to_root(CONFIG_DIR)
-
-    if exabgp_path != "":
-        cmd = "cp -rf %s %s" % (exabgp_path, CONFIG_DIR)
-        local(cmd, capture=True)
-        cmd = "docker exec exabgp cp -rf " + SHARE_VOLUME + "/exabgp /root/"
-        local(cmd, capture=True)
-
-    start_gobgp(do_build)
-
-    # run quagga docker container
-    docker_container_run_quagga(1, BRIDGE_0)
-
-
-def docker_container_quagga_append_executor(quagga_num, go_path, is_route_server=True):
-    make_config_append(quagga_num, go_path, BRIDGE_0, ("" if is_route_server else "--normal-bgp"))
-    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)
-
-
-def docker_container_make_bestpath_env_executor(append_quagga_num, go_path, is_route_server=True):
-    print "start make bestpath environment"
-    make_config_append(append_quagga_num, go_path, BRIDGE_1, ("" if is_route_server else "--normal-bgp"))
-    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/gobgp_test.py b/test/scenario_test/gobgp_test.py
deleted file mode 100644
index 34a94c7d..00000000
--- a/test/scenario_test/gobgp_test.py
+++ /dev/null
@@ -1,452 +0,0 @@
-# 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
-from fabric.api import local
-import json
-import toml
-import os
-import time
-from ciscoconfparse import CiscoConfParse
-from peer_info import Peer
-from peer_info import Destination
-from peer_info import Path
-from constant import *
-import quagga_access as qaccess
-
-class GoBGPTestBase(unittest.TestCase):
-
-    gobgp_ip = GOBGP_IP
-    gobgp_ipv6 = GOBGP_ADDRESS_0[IPv6]
-    base_dir = CONFIG_DIRR
-    gobgp_config_file = CONFIG_DIRR + "gobgpd.conf"
-    gobgp_config = None
-    initial_wait_time = 10
-    wait_per_retry = 5
-    retry_limit = (60 - initial_wait_time) / wait_per_retry
-    dest_check_limit = 3
-
-    def __init__(self, *args, **kwargs):
-        super(GoBGPTestBase, self).__init__(*args, **kwargs)
-
-    def setUp(self):
-        self.quagga_configs = []
-        self.use_ipv6_gobgp = False
-
-    def get_neighbor_state(self, neighbor_address):
-        print "check neighbor state for %s" % (neighbor_address)
-        state = None
-        try:
-            neighbor = self.ask_gobgp(NEIGHBOR, neighbor_address)
-            state = neighbor['info']['bgp_state']
-            remote_ip = neighbor['conf']['remote_ip']
-            assert remote_ip == neighbor_address
-            return state
-        except Exception as e:
-            print e
-        return state
-
-    def retry_routine_for_state(self, addresses, allow_state):
-        in_prepare_quagga = True
-        retry_count = 0
-        while in_prepare_quagga:
-            if retry_count != 0:
-                print "please wait more (" + str(self.wait_per_retry) + " second)"
-                time.sleep(self.wait_per_retry)
-            if retry_count >= self.retry_limit:
-                print "retry limit"
-                break
-            retry_count += 1
-            success_count = 0
-            for address in addresses:
-                # get neighbor state and remote ip from gobgp connections
-                state = self.get_neighbor_state(address)
-                if state == allow_state:
-                    success_count += 1
-            if success_count == len(addresses):
-                in_prepare_quagga = False
-
-    def retry_routine_for_bestpath(self, check_address, target_network, ans_nexthop):
-        # get rib
-        if check_address == "":
-            rib = self.ask_gobgp(GLOBAL_RIB)
-        else:
-            rib = self.ask_gobgp(LOCAL_RIB, check_address)
-
-        target_exist = False
-        for g_dest in rib:
-            best_path_idx = g_dest['best_path_idx'] if 'best_path_idx' in g_dest else 0
-            if target_network == g_dest['prefix']:
-                target_exist = True
-                g_paths = g_dest['paths']
-                idx = 0
-                if len(g_paths) < 2:
-                    print "target path has not been bestpath selected yet."
-                    print "please wait more (" + str(self.wait_per_retry) + " second)"
-                    time.sleep(self.wait_per_retry)
-                    self.retry_routine_for_bestpath(check_address, target_network, ans_nexthop)
-                    return
-                for g_path in g_paths:
-                    print "best_path_Idx: " + str(best_path_idx) + ", idx: " + str(idx)
-                    print g_dest
-                    print "pre: ", g_dest['prefix'], "net: ", g_path['nlri']['prefix'], "next: ", g_path['nexthop']
-                    if str(best_path_idx) == str(idx):
-                        rep_nexthop = g_path['nexthop']
-                    idx += 1
-        if target_exist is False:
-            print "target path has not been receive yet."
-            print "please wait more (" + str(self.wait_per_retry) + " second)"
-            time.sleep(self.wait_per_retry)
-            self.retry_routine_for_bestpath(check_address, target_network, ans_nexthop)
-            return
-        self.assertEqual(ans_nexthop, rep_nexthop)
-
-    def extract_bgp_section(self):
-        with open(self.gobgp_config_file) as f:
-            dst = ''
-            for line in f:
-                if 'DefinedSets' in line:
-                    break
-                dst += line
-
-            return dst.encode('utf8')
-
-    def load_gobgp_config(self):
-        try:
-            t = self.extract_bgp_section()
-            self.gobgp_config = toml.loads(t)
-        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(" ")
-                network = elems[1]
-                nexthop = peer_ip
-                path = Path(network, nexthop)
-                dest = Destination(network)
-                dest.paths.append(path)
-                quagga_config.destinations[network] = 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], 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['Neighbors']['NeighborList']
-        for neighbor_config in neighbors_config:
-            neighbor_ip = neighbor_config['NeighborConfig']['NeighborAddress']
-            address.append(neighbor_ip)
-        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
-
-    def ask_gobgp(self, what, who="", af="ipv4"):
-        af = "-a %s" % af
-        cmd = "%s -j " % CLI_CMD
-        if what == GLOBAL_RIB:
-            cmd += " ".join([what, af])
-        elif what == NEIGHBOR:
-            cmd += " ".join([NEIGHBOR, who])
-        else:
-            cmd += " ".join([NEIGHBOR, who, what, af])
-        j = local(cmd, capture=True)
-        result = json.loads(j)
-        return result
-
-    def soft_reset(self, neighbor_address, af, type="in"):
-        cmd = "%s -j " % CLI_CMD
-        cmd += "neighbor %s " % neighbor_address
-        cmd += "softreset%s -a %s" % (type, af)
-        local(cmd)
-
-    def set_policy(self, peer, target, policy_name, default_accept=True):
-        default_policy = "ACCEPT" if default_accept else "REJECT"
-        cmd = "%s " % CLI_CMD
-        cmd += NEIGHBOR + " %s " % peer
-        cmd += POLICY + " add %s %s %s" % (target, policy_name, default_policy)
-        local(cmd)
-
-    def get_paths_in_localrib(self, neighbor_address, target_prefix, af="ipv4", retry=3, interval=5):
-        retry_count = 0
-        while True:
-            local_rib = self.ask_gobgp(LOCAL_RIB, neighbor_address, af)
-            g_dest = [dest for dest in local_rib if dest['prefix'] == target_prefix]
-            if len(g_dest) > 0:
-                assert len(g_dest) == 1
-                d = g_dest[0]
-                return d['paths'][0]
-            else:
-                retry_count += 1
-                if retry_count > retry:
-                    break
-                else:
-                    print "destination is none : %s" % neighbor_address
-                    print "please wait more (" + str(interval) + " second)"
-                    time.sleep(interval)
-
-        print "destination is none"
-        return None
-
-    def get_adj_rib_in(self, neighbor_address, target_prefix, retry=3, interval=-1, af=IPv4):
-        if interval < 0:
-            interval = self.wait_per_retry
-        return self.get_adj_rib(neighbor_address, target_prefix, af, retry, interval, type=ADJ_RIB_IN)
-
-
-    def get_adj_rib_out(self, neighbor_address, target_prefix, retry=3, interval=-1, af=IPv4):
-        if interval < 0:
-            interval = self.wait_per_retry
-        return self.get_adj_rib(neighbor_address, target_prefix, af, retry, interval, type=ADJ_RIB_OUT)
-
-
-    def get_adj_rib(self, neighbor_address, target_prefix, af, retry, interval, type=ADJ_RIB_IN):
-        retry_count = 0
-        while True:
-            rib = self.ask_gobgp(type, neighbor_address, af)
-            paths = [p for p in rib if p['prefix'] == target_prefix]
-
-            if len(paths) > 0:
-                assert len(paths) == 1
-                assert len(paths[0]['paths']) == 1
-                return paths[0]['paths'][0]
-            else:
-                retry_count += 1
-                if retry_count > retry:
-                    break
-                else:
-                    print "adj_rib_%s is none" % type
-                    print "wait (" + str(interval) + " seconds)"
-                    time.sleep(interval)
-
-        print "adj_rib_%s is none" % type
-        return None
-
-    # quagga login check
-    def try_login_quagga(self, peer, retry=3, interval=1):
-        print "try login to quagga : %s" % peer
-        if interval < 0:
-            interval = self.wait_per_retry
-        retry_count = 0
-        while True:
-            try:
-                tn = qaccess.login(peer)
-                return tn
-            except:
-                retry_count += 1
-                if retry_count > retry:
-                    break
-                print "failed to login to %s" % peer
-                print "wait (" + str(interval) + " seconds)"
-                time.sleep(interval)
-        return None
-
-
-    # get route information on quagga
-    def get_route(self, neighbor_address, target_prefix, retry=3, interval=-1, af=IPv4):
-        if interval < 0:
-            interval = self.wait_per_retry
-        print "check route %s on quagga : %s" % (target_prefix, neighbor_address)
-        retry_count = 0
-
-        while True:
-            tn = qaccess.login(neighbor_address)
-            q_rib = qaccess.lookup_prefix(tn, target_prefix, af)
-            qaccess.logout(tn)
-            for q_path in q_rib:
-                if target_prefix == q_path['Network']:
-                    return q_path
-
-            retry_count += 1
-            if retry_count > retry:
-                break
-            else:
-                print "target_prefix %s is none" % target_prefix
-                print "wait (" + str(interval) + " seconds)"
-                time.sleep(interval)
-
-        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, extended=False):
-        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 = False
-            if extended:
-                result = qaccess.check_ext_community(tn, target_addr, community, af)
-            else:
-                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
-
-
-    # get route information on quagga
-    def check_med(self, neighbor_address, target_addr, med, 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_med(tn, target_addr, med, af)
-            qaccess.logout(tn)
-
-            if result:
-                return True
-            else:
-                print "target path %s with med %s is none" % (target_addr, med)
-
-            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:
-            if quagga_config.peer_ip == rib_owner_addr:
-                # check local_rib doesn't contain own destinations.
-                for destination in quagga_config.destinations.itervalues():
-                    for rib_destination in local_rib:
-                        if destination.prefix == rib_destination['prefix']:
-                            return False
-
-            else:
-                # check local_rib contains destinations that other quaggas
-                # advertised.
-                for destination in quagga_config.destinations.itervalues():
-                    found = False
-                    for rib_destination in local_rib:
-                        if destination.prefix == rib_destination['prefix']:
-                            found = True
-                            break
-
-                    if not found:
-                        return False
-
-        return True
-
-    def compare_route_with_quagga_configs(self, address, quagga_rib, route_server=True):
-        for quagga_config in self.quagga_configs:
-            for destination in quagga_config.destinations.itervalues():
-                for path in destination.paths:
-                    network = path.network.split("/")[0]
-
-                    if quagga_config.peer_ip == address:
-                        nexthop = "0.0.0.0"
-                    else:
-                        if route_server:
-                            nexthop = path.nexthop
-                        else:
-                            nexthop = self.gobgp_ip
-
-                    found = False
-                    for quagga_path in quagga_rib:
-                        if network == quagga_path['Network'] and nexthop == quagga_path['Next Hop']:
-                            found = True
-                            break
-                    if not found:
-                        return False
-
-        return True
-
-    def compare_global_rib_with_quagga_configs(self, rib):
-        for quagga_config in self.quagga_configs:
-            peer_ip = quagga_config.peer_ip
-            for d in quagga_config.destinations.itervalues():
-                for p in d.paths:
-                    print "check of %s's route %s existence in gobgp global rib" % (
-                    peer_ip, p.network)
-                    exist = False
-                    for dst in rib:
-                        for path in dst['paths']:
-                            if path['nlri']['prefix'] == p.network:
-                                exist = True
-                                if exist:
-                                    is_nexthop_same = path['nexthop'] == p.nexthop
-                                    if not is_nexthop_same:
-                                        return False
-                    if not exist:
-                        return False
-        return True
diff --git a/test/scenario_test/peer_info.py b/test/scenario_test/peer_info.py
deleted file mode 100644
index 5a965f7b..00000000
--- a/test/scenario_test/peer_info.py
+++ /dev/null
@@ -1,39 +0,0 @@
-# Copyright (C) 2015 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.
-
-
-class Peer:
-    def __init__(self, peer_ip, peer_id, peer_as, ip_version):
-        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
diff --git a/test/scenario_test/quagga-rsconfig.go b/test/scenario_test/quagga-rsconfig.go
deleted file mode 100644
index 60ae9fd0..00000000
--- a/test/scenario_test/quagga-rsconfig.go
+++ /dev/null
@@ -1,249 +0,0 @@
-package main
-
-import (
-	"bytes"
-	"fmt"
-	"github.com/BurntSushi/toml"
-	"github.com/jessevdk/go-flags"
-	"github.com/osrg/gobgp/config"
-	"io/ioutil"
-	"log"
-	"net"
-	"os"
-	"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.Neighbor
-	gobgpConfig *config.Global
-	serverIP    net.IP
-}
-
-func NewQuaggaConfig(id int, gConfig *config.Global, myConfig *config.Neighbor, server net.IP) *QuaggaConfig {
-	return &QuaggaConfig{
-		id:          id,
-		config:      myConfig,
-		gobgpConfig: gConfig,
-		serverIP:    server,
-	}
-}
-
-func (qt *QuaggaConfig) IPv4Config() *bytes.Buffer {
-	buf := bytes.NewBuffer(nil)
-	buf.WriteString(fmt.Sprintf("! my address %s\n", qt.config.NeighborConfig.NeighborAddress))
-	buf.WriteString(fmt.Sprintf("! my ip_version %s\n", IPv4))
-	buf.WriteString("hostname bgpd\n")
-	buf.WriteString("password zebra\n")
-	buf.WriteString(fmt.Sprintf("router bgp %d\n", qt.config.NeighborConfig.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.GlobalConfig.As))
-	buf.WriteString(fmt.Sprintf("neighbor %s password %s\n", qt.serverIP, qt.config.NeighborConfig.AuthPassword))
-	buf.WriteString("debug bgp as4\n")
-	buf.WriteString("debug bgp fsm\n")
-	buf.WriteString("debug bgp updates\n")
-	buf.WriteString("debug bgp events\n")
-	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.NeighborConfig.NeighborAddress))
-	buf.WriteString(fmt.Sprintf("! my ip_version %s\n", IPv6))
-	buf.WriteString("hostname bgpd\n")
-	buf.WriteString("password zebra\n")
-	buf.WriteString(fmt.Sprintf("router bgp %d\n", qt.config.NeighborConfig.PeerAs))
-	buf.WriteString(fmt.Sprintf("bgp router-id 192.168.0.%d\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.GlobalConfig.As))
-	buf.WriteString(fmt.Sprintf("neighbor %s password %s\n", qt.serverIP, qt.config.NeighborConfig.AuthPassword))
-	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.NeighborConfig.NeighborAddress))
-	buf.WriteString("debug bgp as4\n")
-	buf.WriteString("debug bgp fsm\n")
-	buf.WriteString("debug bgp updates\n")
-	buf.WriteString("debug bgp events\n")
-	buf.WriteString("log file /var/log/quagga/bgpd.log\n")
-
-	return buf
-}
-
-func create_config_files(nr int, outputDir string, IPVersion string, nonePeer bool, normalBGP bool) {
-	quaggaConfigList := make([]*QuaggaConfig, 0)
-
-	gobgpConf := config.Bgp{}
-	gobgpConf.Global.GlobalConfig.As = 65000
-	gobgpConf.Global.GlobalConfig.RouterId = net.ParseIP("192.168.255.1")
-
-	for i := 1; i < nr+1; i++ {
-
-		c := config.Neighbor{}
-		c.NeighborConfig.PeerAs = 65000 + uint32(i)
-		c.NeighborConfig.NeighborAddress = net.ParseIP(fmt.Sprintf("%s%d", baseNeighborAddress[IPVersion], i))
-		c.NeighborConfig.AuthPassword = fmt.Sprintf("hoge%d", i)
-		c.Transport.TransportConfig.PassiveMode = true
-		c.RouteServer.RouteServerConfig.RouteServerClient = !normalBGP
-
-		timers := config.Timers{}
-		timers.TimersConfig.HoldTime = 30
-		timers.TimersConfig.KeepaliveInterval = 10
-		timers.TimersConfig.IdleHoldTimeAfterReset = 10
-
-		c.Timers = timers
-		c.NeighborConfig.PeerType = config.PEER_TYPE_EXTERNAL
-
-		gobgpConf.Neighbors.NeighborList = append(gobgpConf.Neighbors.NeighborList, c)
-		if !nonePeer {
-			q := NewQuaggaConfig(i, &gobgpConf.Global, &c, net.ParseIP(serverAddress[IPVersion]))
-			quaggaConfigList = append(quaggaConfigList, q)
-			os.Mkdir(fmt.Sprintf("%s/q%d", outputDir, i), 0755)
-			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)
-			}
-		}
-	}
-
-	var buffer bytes.Buffer
-	encoder := toml.NewEncoder(&buffer)
-	encoder.Encode(gobgpConf)
-
-	err := ioutil.WriteFile(fmt.Sprintf("%s/gobgpd.conf", outputDir), buffer.Bytes(), 0644)
-	if err != nil {
-		log.Fatal(err)
-	}
-}
-
-func append_config_files(ar int, outputDir string, IPVersion string, noQuagga bool, normalBGP bool) {
-
-	gobgpConf := config.Bgp{}
-	gobgpConf.Global.GlobalConfig.As = 65000
-	gobgpConf.Global.GlobalConfig.RouterId = net.ParseIP("192.168.255.1")
-
-	c := config.Neighbor{}
-	c.NeighborConfig.PeerAs = 65000 + uint32(ar)
-	c.NeighborConfig.NeighborAddress = net.ParseIP(fmt.Sprintf("%s%d", baseNeighborAddress[IPVersion], ar))
-	c.NeighborConfig.AuthPassword = fmt.Sprintf("hoge%d", ar)
-	c.RouteServer.RouteServerConfig.RouteServerClient = !normalBGP
-	c.Transport.TransportConfig.PassiveMode = true
-
-	timers := config.Timers{}
-	timers.TimersConfig.HoldTime = 30
-	timers.TimersConfig.KeepaliveInterval = 10
-	timers.TimersConfig.IdleHoldTimeAfterReset = 10
-
-	c.Timers = timers
-	c.NeighborConfig.PeerType = config.PEER_TYPE_EXTERNAL
-
-	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
-		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)
-		}
-	}
-	newConf := config.Bgp{}
-	_, d_err := toml.DecodeFile(fmt.Sprintf("%s/gobgpd.conf", outputDir), &newConf)
-	if d_err != nil {
-		log.Fatal(d_err)
-	}
-	newConf.Neighbors.NeighborList = append(newConf.Neighbors.NeighborList, c)
-	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.PolicyDefinitions.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)
-	}
-}
-
-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"`
-		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"`
-		NonePeer      bool   `long:"none-peer" description:"disable make quagga config"`
-		NormalBGP     bool   `long:"normal-bgp" description:"generate normal bgp server configuration"`
-	}
-	parser := flags.NewParser(&opts, flags.Default)
-	_, err := parser.Parse()
-	if err != nil {
-		fmt.Print(err)
-		os.Exit(1)
-	}
-	if opts.OutputDir == "" {
-		opts.OutputDir, _ = filepath.Abs(".")
-	} else {
-		if _, err := os.Stat(opts.OutputDir); os.IsNotExist(err) {
-			os.Mkdir(opts.OutputDir, 0755)
-		}
-	}
-
-	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"
-	}
-
-	isCreateMode := opts.AppendClient == 0
-
-	if isCreateMode {
-		create_config_files(opts.ClientNumber, opts.OutputDir, opts.IPVersion, opts.NonePeer, opts.NormalBGP)
-	} 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, opts.IPVersion, opts.NonePeer, opts.NormalBGP)
-	}
-}
diff --git a/test/scenario_test/quagga_access.py b/test/scenario_test/quagga_access.py
deleted file mode 100644
index 51008b02..00000000
--- a/test/scenario_test/quagga_access.py
+++ /dev/null
@@ -1,208 +0,0 @@
-# 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 sys
-import telnetlib
-from constant import *
-
-PASSWORD = "zebra"
-CONN_PASSWORD = "hogehoge"
-QLPORT = 2605
-
-
-def login(host):
-    tn = telnetlib.Telnet(host, QLPORT)
-    tn.read_until("Password: ")
-    tn.write(PASSWORD + "\n")
-    tn.write("enable\n")
-    tn.read_until("bgpd#")
-    return tn
-
-
-def logout(tn):
-    tn.write("exit\n")
-    tn.read_all()
-
-
-def add_neighbor(tn, as_number, neighbor_address, remote_as):
-    tn.write("configure terminal\n")
-    tn.write("router bgp "+str(as_number)+"\n")
-    tn.write("neighbor " + neighbor_address + " remote-as " + remote_as + "\n")
-    tn.write("neighbor " + neighbor_address + " password " + CONN_PASSWORD + "\n")
-    tn.write("exit\n")
-    tn.write("exit\n")
-    tn.read_until("bgpd#")
-
-
-def add_neighbor_metric(tn, as_number, neighbor_address, metric):
-    tn.write("configure terminal\n")
-    tn.write("router bgp "+str(as_number)+"\n")
-    tn.write("neighbor " + neighbor_address + " route-map MED" + metric + " out\n")
-    tn.write("exit\n")
-    tn.write("exit\n")
-    tn.read_until("bgpd#")
-
-
-def add_network(tn, as_number, network, use_ipv6=False):
-    tn.write("configure terminal\n")
-    tn.write("router bgp "+str(as_number)+"\n")
-    if use_ipv6:
-        tn.write("address-family ipv6\n")
-        tn.write("network "+ network + " \n")
-        tn.write("exit\n")
-    else:
-        tn.write("network "+ network + " \n")
-
-    tn.write("exit\n")
-    tn.write("exit\n")
-    tn.read_until("bgpd#")
-
-
-def add_metric(tn, metric, network):
-    tn.write("configure terminal\n")
-    tn.write("access-list 1 permit " + network + " 0.0.0.255\n")
-    tn.write("route-map MED" + metric + " permit 10\n")
-    tn.write("match ip address 1\n")
-    tn.write("set metric " + metric + "\n")
-    tn.write("route-map MED" + metric + " permit 10\n")
-    tn.write("set metric\n")
-    tn.read_until("bgpd(config-route-map)#")
-    tn.write("exit\n")
-    tn.write("exit\n")
-    return tn
-
-
-def show_config(tn):
-    tn.write("show run\n")
-    print tn.read_until("bgpd#")
-    tn.write("exit\n")
-    print tn.read_all()
-
-
-def show_rib(tn, af=IPv4):
-    if af == IPv4:
-        tn.write("show ip bgp\n")
-    elif af == IPv6:
-        tn.write("show bgp ipv6\n")
-    else:
-        print "invalid af: ", af
-        return
-    tn.read_until("   Network          Next Hop            Metric LocPrf Weight Path")
-    rib = tn.read_until("bgpd#")
-    return rib_parser(rib)
-
-
-def clear_ip_bgp(tn):
-    tn.write("clear ip bgp *\n")
-    tn.read_until("bgpd#")
-
-
-def rib_parser(rib):
-    lines = rib.split("\n")
-    paths = []
-    for line in lines:
-        path = {}
-        if line[0] == "*":
-            elems = line.split()
-            path['Network'] = elems[1]
-            path['Next Hop'] = elems[2]
-        if len(path) > 0:
-            paths.append(path)
-    return paths
-
-
-def lookup_prefix(tn, prefix, af):
-    if af == IPv4:
-        tn.write("show ip bgp " + prefix + "\n")
-    elif af == IPv6:
-        tn.write("show bgp ipv6 " + prefix + "\n")
-    else:
-        print "invalid af: ", af
-        return
-
-    info = tn.read_until("bgpd#")
-    lines = info.split("\n")
-    paths = []
-
-    if len(lines) > 1 and "BGP routing table entry for " + prefix in lines[1]:
-        idx_nw = -1
-        nexthop = ''
-        # check if the prefix is originated route by its own or not.
-        for idx, line in enumerate(lines):
-            if "from" in line:
-                nexthop = line.split()[0]
-                idx_nw = idx
-                if nexthop == "0.0.0.0":
-                    return paths
-
-        path = {}
-        path['aspath'] = lines[idx_nw - 1].strip().split(" ")
-        path['Network'] = prefix
-        path['Next Hop'] = nexthop
-        paths.append(path)
-
-    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
-
-
-def check_ext_community(tn, addr, community, af=IPv4):
-    if af == IPv4:
-        tn.write("show ip bgp " + addr + "\n")
-    elif af == IPv6:
-        tn.write("show bgp ipv6 " + addr + "\n")
-    else:
-        print "invalid af: ", af
-        return
-    result = tn.read_until("bgpd#")
-    for line in result.split("\n"):
-        if "Extended Community:" in line:
-            extcomms = line.split()[2:]
-            for e in extcomms:
-                if community == e:
-                    return True
-
-    return False
-
-
-def check_med(tn, addr, med, af=IPv4):
-    if af == IPv4:
-        tn.write("show ip bgp " + addr[0] + "\n")
-    elif af == IPv6:
-        tn.write("show bgp ipv6 " + addr[0] + "\n")
-    else:
-        print "invalid af: ", af
-        return
-    result = tn.read_until("bgpd#")
-    for line in result.split("\n"):
-        if "metric" in line:
-            if str(med) in line.split()[3]:
-                return True
-
-    return False