move lib to parent directory

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

1 files changed, 0 insertions, 260 deletions

diff --git a/test/scenario_test/lib/quagga.py b/test/scenario_test/lib/quagga.py
deleted file mode 100644
index 17f855a9..00000000
--- a/test/scenario_test/lib/quagga.py
+++ /dev/null
@@ -1,260 +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.
-
-from base import *
-import telnetlib
-from nsenter import Namespace
-
-
-class QuaggaTelnetDaemon(object):
-    TELNET_PASSWORD = "zebra"
-    TELNET_PORT = 2605
-
-    def __init__(self, ctn):
-        self.ns = Namespace(ctn.get_pid(), 'net')
-
-    def __enter__(self):
-        self.ns.__enter__()
-        self.tn = telnetlib.Telnet('127.0.0.1', self.TELNET_PORT)
-        self.tn.read_until("Password: ")
-        self.tn.write(self.TELNET_PASSWORD + "\n")
-        self.tn.write("enable\n")
-        self.tn.read_until('bgpd#')
-        return self.tn
-
-    def __exit__(self, type, value, traceback):
-        self.tn.close()
-        self.ns.__exit__(type, value, traceback)
-
-
-class QuaggaBGPContainer(BGPContainer):
-
-    WAIT_FOR_BOOT = 1
-    SHARED_VOLUME = '/etc/quagga'
-
-    def __init__(self, name, asn, router_id, ctn_image_name='osrg/quagga', zebra=False):
-        super(QuaggaBGPContainer, self).__init__(name, asn, router_id,
-                                                 ctn_image_name)
-        self.shared_volumes.append((self.config_dir, self.SHARED_VOLUME))
-        self.zebra = zebra
-
-    def run(self):
-        super(QuaggaBGPContainer, self).run()
-        return self.WAIT_FOR_BOOT
-
-    def get_global_rib(self, prefix='', rf='ipv4'):
-        rib = []
-        if prefix != '':
-            return self.get_global_rib_with_prefix(prefix, rf)
-        with QuaggaTelnetDaemon(self) as tn:
-            tn.write('show bgp {0} unicast\n'.format(rf))
-            tn.read_until('   Network          Next Hop            Metric '
-                          'LocPrf Weight Path')
-            read_next = False
-            for line in tn.read_until('bgpd#').split('\n'):
-                if line[:2] == '*>':
-                    line = line[2:]
-                    ibgp = False
-                    if line[0] == 'i':
-                        line = line[1:]
-                        ibgp = True
-                elif not read_next:
-                    continue
-
-                elems = line.split()
-
-                if len(elems) == 1:
-                    read_next = True
-                    prefix = elems[0]
-                    continue
-                elif read_next:
-                    nexthop = elems[0]
-                else:
-                    prefix = elems[0]
-                    nexthop = elems[1]
-                read_next = False
-
-                rib.append({'prefix': prefix, 'nexthop': nexthop,
-                            'ibgp': ibgp})
-
-        return rib
-
-    def get_global_rib_with_prefix(self, prefix, rf):
-        rib = []
-        with QuaggaTelnetDaemon(self) as tn:
-            tn.write('show bgp {0} unicast {1}\n'.format(rf, prefix))
-            lines = [line.strip() for line in tn.read_until('bgpd#').split('\n')]
-            lines.pop(0)  # throw away first line contains 'show bgp...'
-            if lines[0] == '% Network not in table':
-                return rib
-
-            lines = lines[2:]
-
-            if lines[0].startswith('Not advertised'):
-                lines.pop(0)  # another useless line
-            elif lines[0].startswith('Advertised to non peer-group peers:'):
-                lines = lines[2:]  # other useless lines
-            else:
-                raise Exception('unknown output format {0}'.format(lines))
-            aspath = [int(asn) for asn in lines[0].split()]
-            nexthop = lines[1].split()[0].strip()
-            info = [s.strip(',') for s in lines[2].split()]
-            attrs = []
-            if 'metric' in info:
-                med = info[info.index('metric') + 1]
-                attrs.append({'type': BGP_ATTR_TYPE_MULTI_EXIT_DISC, 'metric': int(med)})
-            if 'localpref' in info:
-                localpref = info[info.index('localpref') + 1]
-                attrs.append({'type': BGP_ATTR_TYPE_LOCAL_PREF, 'value': int(localpref)})
-
-            rib.append({'prefix': prefix, 'nexthop': nexthop,
-                        'aspath': aspath, 'attrs': attrs})
-        return rib
-
-    def get_neighbor_state(self, peer):
-        if peer not in self.peers:
-            raise Exception('not found peer {0}'.format(peer.router_id))
-
-        neigh_addr = self.peers[peer]['neigh_addr'].split('/')[0]
-
-        with QuaggaTelnetDaemon(self) as tn:
-            tn.write('show bgp neighbors\n')
-            neighbor_info = []
-            curr_info = []
-            for line in tn.read_until('bgpd#').split('\n'):
-                line = line.strip()
-                if line.startswith('BGP neighbor is'):
-                    neighbor_info.append(curr_info)
-                    curr_info = []
-                curr_info.append(line)
-            neighbor_info.append(curr_info)
-
-            for info in neighbor_info:
-                if not info[0].startswith('BGP neighbor is'):
-                    continue
-                idx1 = info[0].index('BGP neighbor is ')
-                idx2 = info[0].index(',')
-                n_addr = info[0][idx1+len('BGP neighbor is '):idx2]
-                if n_addr == neigh_addr:
-                    idx1 = info[2].index('= ')
-                    state = info[2][idx1+len('= '):]
-                    if state.startswith('Idle'):
-                        return BGP_FSM_IDLE
-                    elif state.startswith('Active'):
-                        return BGP_FSM_ACTIVE
-                    elif state.startswith('Established'):
-                        return BGP_FSM_ESTABLISHED
-                    else:
-                        return state
-
-            raise Exception('not found peer {0}'.format(peer.router_id))
-
-    def send_route_refresh(self):
-        with QuaggaTelnetDaemon(self) as tn:
-            tn.write('clear ip bgp * soft\n')
-            #tn.read_until('bgpd#')
-
-    def create_config(self):
-        self._create_config_bgp()
-        if self.zebra:
-            self._create_config_zebra()
-
-    def _create_config_bgp(self):
-
-        c = CmdBuffer()
-        c << 'hostname bgpd'
-        c << 'password zebra'
-        c << 'router bgp {0}'.format(self.asn)
-        c << 'bgp router-id {0}'.format(self.router_id)
-
-        version = 4
-        for peer, info in self.peers.iteritems():
-            version = netaddr.IPNetwork(info['neigh_addr']).version
-            n_addr = info['neigh_addr'].split('/')[0]
-            if version == 6:
-                c << 'no bgp default ipv4-unicast'
-
-            c << 'neighbor {0} remote-as {1}'.format(n_addr, peer.asn)
-            for name, policy in info['policies'].iteritems():
-                direction = policy['direction']
-                c << 'neighbor {0} route-map {1} {2}'.format(n_addr, name,
-                                                             direction)
-            if info['passwd']:
-                c << 'neighbor {0} password {1}'.format(n_addr, info['passwd'])
-            if version == 6:
-                c << 'address-family ipv6 unicast'
-                c << 'neighbor {0} activate'.format(n_addr)
-                c << 'exit-address-family'
-
-        for route in self.routes.itervalues():
-            if route['rf'] == 'ipv4':
-                c << 'network {0}'.format(route['prefix'])
-            elif route['rf'] == 'ipv6':
-                c << 'address-family ipv6 unicast'
-                c << 'network {0}'.format(route['prefix'])
-                c << 'exit-address-family'
-            else:
-                raise Exception('unsupported route faily: {0}'.format(route['rf']))
-
-        if self.zebra:
-            if version == 6:
-                c << 'address-family ipv6 unicast'
-                c << 'redistribute connected'
-                c << 'exit-address-family'
-            else:
-                c << 'redistribute connected'
-
-        for name, policy in self.policies.iteritems():
-            c << 'access-list {0} {1} {2}'.format(name, policy['type'],
-                                                  policy['match'])
-            c << 'route-map {0} permit 10'.format(name)
-            c << 'match ip address {0}'.format(name)
-            c << 'set metric {0}'.format(policy['med'])
-
-        c << 'debug bgp as4'
-        c << 'debug bgp fsm'
-        c << 'debug bgp updates'
-        c << 'debug bgp events'
-        c << 'log file {0}/bgpd.log'.format(self.SHARED_VOLUME)
-
-        with open('{0}/bgpd.conf'.format(self.config_dir), 'w') as f:
-            print colors.yellow('[{0}\'s new config]'.format(self.name))
-            print colors.yellow(indent(str(c)))
-            f.writelines(str(c))
-
-    def _create_config_zebra(self):
-        c = CmdBuffer()
-        c << 'hostname zebra'
-        c << 'password zebra'
-        c << 'log file {0}/zebra.log'.format(self.SHARED_VOLUME)
-        c << 'debug zebra packet'
-        c << 'debug zebra kernel'
-        c << 'debug zebra rib'
-        c << ''
-
-        with open('{0}/zebra.conf'.format(self.config_dir), 'w') as f:
-            print colors.yellow('[{0}\'s new config]'.format(self.name))
-            print colors.yellow(indent(str(c)))
-            f.writelines(str(c))
-
-    def reload_config(self):
-        daemon = []
-        daemon.append('bgpd')
-        if self.zebra:
-            daemon.append('zebra')
-        for d in daemon:
-            cmd = '/usr/bin/pkill {0} -SIGHUP'.format(d)
-            self.local(cmd)
-