Chetan Gaonker | cb122cc | 2016-05-10 10:58:34 -0700 | [diff] [blame] | 1 | #!/usr/bin/env python |
A.R Karthick | 95d044e | 2016-06-10 18:44:36 -0700 | [diff] [blame] | 2 | # |
Chetan Gaonker | cfcce78 | 2016-05-10 10:10:42 -0700 | [diff] [blame] | 3 | # Copyright 2016-present Ciena Corporation |
| 4 | # |
| 5 | # Licensed under the Apache License, Version 2.0 (the "License"); |
| 6 | # you may not use this file except in compliance with the License. |
| 7 | # You may obtain a copy of the License at |
A.R Karthick | 95d044e | 2016-06-10 18:44:36 -0700 | [diff] [blame] | 8 | # |
Chetan Gaonker | cfcce78 | 2016-05-10 10:10:42 -0700 | [diff] [blame] | 9 | # http://www.apache.org/licenses/LICENSE-2.0 |
A.R Karthick | 95d044e | 2016-06-10 18:44:36 -0700 | [diff] [blame] | 10 | # |
Chetan Gaonker | cfcce78 | 2016-05-10 10:10:42 -0700 | [diff] [blame] | 11 | # Unless required by applicable law or agreed to in writing, software |
| 12 | # distributed under the License is distributed on an "AS IS" BASIS, |
| 13 | # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| 14 | # See the License for the specific language governing permissions and |
| 15 | # limitations under the License. |
| 16 | # |
Chetan Gaonker | 93e302d | 2016-04-05 10:51:07 -0700 | [diff] [blame] | 17 | from argparse import ArgumentParser |
A R Karthick | 14118c6 | 2016-07-27 14:54:04 -0700 | [diff] [blame] | 18 | import os,sys,time,socket,errno |
A R Karthick | 07608ef | 2016-08-23 16:51:19 -0700 | [diff] [blame] | 19 | import shutil, platform |
Chetan Gaonker | 4d842ad | 2016-04-26 10:04:24 -0700 | [diff] [blame] | 20 | utils_dir = os.path.join( os.path.dirname(os.path.realpath(__file__)), '../utils') |
Chetan Gaonker | 7142a34 | 2016-04-07 14:53:12 -0700 | [diff] [blame] | 21 | sys.path.append(utils_dir) |
Chetan Gaonker | 93e302d | 2016-04-05 10:51:07 -0700 | [diff] [blame] | 22 | from OnosCtrl import OnosCtrl |
Chetan Gaonker | 4ca5cca | 2016-04-11 13:59:35 -0700 | [diff] [blame] | 23 | from OltConfig import OltConfig |
A R Karthick | 1f03e91 | 2016-05-18 11:39:22 -0700 | [diff] [blame] | 24 | from threadPool import ThreadPool |
Chetan Gaonker | 3533faa | 2016-04-25 17:50:14 -0700 | [diff] [blame] | 25 | from CordContainer import * |
A R Karthick | 81acbff | 2016-06-17 14:45:16 -0700 | [diff] [blame] | 26 | from CordTestServer import cord_test_server_start, cord_test_server_stop, CORD_TEST_HOST, CORD_TEST_PORT |
A R Karthick | 07608ef | 2016-08-23 16:51:19 -0700 | [diff] [blame] | 27 | from TestManifest import TestManifest |
| 28 | try: |
| 29 | from Fabric import FabricMAAS |
| 30 | except: |
| 31 | FabricMAAS = None |
Chetan Gaonker | 93e302d | 2016-04-05 10:51:07 -0700 | [diff] [blame] | 32 | |
Chetan Gaonker | 93e302d | 2016-04-05 10:51:07 -0700 | [diff] [blame] | 33 | class CordTester(Container): |
Chetan Gaonker | 93e302d | 2016-04-05 10:51:07 -0700 | [diff] [blame] | 34 | sandbox = '/root/test' |
Chetan Gaonker | 7142a34 | 2016-04-07 14:53:12 -0700 | [diff] [blame] | 35 | sandbox_setup = '/root/test/src/test/setup' |
Chetan Gaonker | 4d842ad | 2016-04-26 10:04:24 -0700 | [diff] [blame] | 36 | tester_base = os.path.dirname(os.path.realpath(__file__)) |
| 37 | tester_paths = os.path.realpath(__file__).split(os.path.sep) |
A R Karthick | b7e8090 | 2016-05-17 09:38:31 -0700 | [diff] [blame] | 38 | tester_path_index = tester_paths.index('src') - 1 |
Chetan Gaonker | 7142a34 | 2016-04-07 14:53:12 -0700 | [diff] [blame] | 39 | sandbox_host = os.path.sep.join(tester_paths[:tester_path_index+1]) |
Chetan Gaonker | 93e302d | 2016-04-05 10:51:07 -0700 | [diff] [blame] | 40 | |
| 41 | host_guest_map = ( (sandbox_host, sandbox), |
Chetan Gaonker | 85b7bd5 | 2016-04-20 10:29:12 -0700 | [diff] [blame] | 42 | ('/lib/modules', '/lib/modules'), |
| 43 | ('/var/run/docker.sock', '/var/run/docker.sock') |
Chetan Gaonker | 93e302d | 2016-04-05 10:51:07 -0700 | [diff] [blame] | 44 | ) |
| 45 | basename = 'cord-tester' |
A R Karthick | 36cfcef | 2016-08-18 15:20:07 -0700 | [diff] [blame] | 46 | switch_on_olt = False |
Chetan Gaonker | 503032a | 2016-05-12 12:06:29 -0700 | [diff] [blame] | 47 | IMAGE = 'cord-test/nose' |
ChetanGaonker | f0dd5bb | 2016-07-28 16:22:06 -0700 | [diff] [blame] | 48 | ALL_TESTS = ('tls', 'dhcp', 'dhcprelay','igmp', 'subscriber', 'cordSubscriber', 'vrouter', 'flows', 'proxyarp', 'acl') |
Chetan Gaonker | 93e302d | 2016-04-05 10:51:07 -0700 | [diff] [blame] | 49 | |
A R Karthick | a013a27 | 2016-08-16 16:40:19 -0700 | [diff] [blame] | 50 | def __init__(self, tests, instance = 0, num_instances = 1, ctlr_ip = None, |
A R Karthick | 07608ef | 2016-08-23 16:51:19 -0700 | [diff] [blame] | 51 | name = '', image = IMAGE, prefix = '', tag = 'candidate', |
Chetan Gaonker | 85b7bd5 | 2016-04-20 10:29:12 -0700 | [diff] [blame] | 52 | env = None, rm = False, update = False): |
A R Karthick | 1f03e91 | 2016-05-18 11:39:22 -0700 | [diff] [blame] | 53 | self.tests = tests |
Chetan Gaonker | 4ca5cca | 2016-04-11 13:59:35 -0700 | [diff] [blame] | 54 | self.ctlr_ip = ctlr_ip |
Chetan Gaonker | 93e302d | 2016-04-05 10:51:07 -0700 | [diff] [blame] | 55 | self.rm = rm |
A R Karthick | a013a27 | 2016-08-16 16:40:19 -0700 | [diff] [blame] | 56 | self.name = name or self.get_name() |
A R Karthick | 07608ef | 2016-08-23 16:51:19 -0700 | [diff] [blame] | 57 | super(CordTester, self).__init__(self.name, image = image, prefix = prefix, tag = tag) |
Chetan Gaonker | 93e302d | 2016-04-05 10:51:07 -0700 | [diff] [blame] | 58 | host_config = self.create_host_config(host_guest_map = self.host_guest_map, privileged = True) |
| 59 | volumes = [] |
Chetan Gaonker | b84835f | 2016-04-19 15:12:10 -0700 | [diff] [blame] | 60 | for _, g in self.host_guest_map: |
Chetan Gaonker | 93e302d | 2016-04-05 10:51:07 -0700 | [diff] [blame] | 61 | volumes.append(g) |
Chetan Gaonker | 85b7bd5 | 2016-04-20 10:29:12 -0700 | [diff] [blame] | 62 | if update is True or not self.img_exists(): |
A R Karthick | 07608ef | 2016-08-23 16:51:19 -0700 | [diff] [blame] | 63 | self.build_image(self.image_name) |
A R Karthick | a013a27 | 2016-08-16 16:40:19 -0700 | [diff] [blame] | 64 | self.create = True |
| 65 | #check if are trying to run tests on existing container |
| 66 | if not name or not self.exists(): |
| 67 | ##Remove test container if any |
| 68 | self.remove_container(self.name, force=True) |
| 69 | else: |
| 70 | self.create = False |
A R Karthick | 078e63a | 2016-07-28 13:59:31 -0700 | [diff] [blame] | 71 | self.olt = False |
Chetan Gaonker | 4ca5cca | 2016-04-11 13:59:35 -0700 | [diff] [blame] | 72 | if env is not None and env.has_key('OLT_CONFIG'): |
| 73 | self.olt = True |
A R Karthick | 078e63a | 2016-07-28 13:59:31 -0700 | [diff] [blame] | 74 | olt_conf_file = os.path.join(self.tester_base, 'olt_config.json') |
| 75 | olt_config = OltConfig(olt_conf_file) |
| 76 | self.port_map, _ = olt_config.olt_port_map() |
| 77 | #Try using the host interface in olt conf to setup the switch |
| 78 | if self.port_map.has_key('host'): |
| 79 | self.switch = self.port_map['host'] |
Chetan Gaonker | 4ca5cca | 2016-04-11 13:59:35 -0700 | [diff] [blame] | 80 | else: |
A R Karthick | 078e63a | 2016-07-28 13:59:31 -0700 | [diff] [blame] | 81 | self.switch = 'ovsbr0' |
A R Karthick | 1f03e91 | 2016-05-18 11:39:22 -0700 | [diff] [blame] | 82 | if env is not None: |
A R Karthick | 078e63a | 2016-07-28 13:59:31 -0700 | [diff] [blame] | 83 | env['TEST_SWITCH'] = self.switch |
A R Karthick | 1f03e91 | 2016-05-18 11:39:22 -0700 | [diff] [blame] | 84 | env['TEST_HOST'] = self.name |
| 85 | env['TEST_INSTANCE'] = instance |
| 86 | env['TEST_INSTANCES'] = num_instances |
A R Karthick | a013a27 | 2016-08-16 16:40:19 -0700 | [diff] [blame] | 87 | if self.create: |
| 88 | print('Starting test container %s, image %s, tag %s' %(self.name, self.image, self.tag)) |
| 89 | self.start(rm = False, volumes = volumes, environment = env, |
| 90 | host_config = host_config, tty = True) |
Chetan Gaonker | 4ca5cca | 2016-04-11 13:59:35 -0700 | [diff] [blame] | 91 | |
| 92 | def execute_switch(self, cmd, shell = False): |
| 93 | if self.olt: |
| 94 | return os.system(cmd) |
| 95 | return self.execute(cmd, shell = shell) |
| 96 | |
A R Karthick | 078e63a | 2016-07-28 13:59:31 -0700 | [diff] [blame] | 97 | def start_switch(self, boot_delay = 2): |
Chetan Gaonker | 4ca5cca | 2016-04-11 13:59:35 -0700 | [diff] [blame] | 98 | """Start OVS""" |
| 99 | ##Determine if OVS has to be started locally or not |
| 100 | s_file,s_sandbox = ('of-bridge-local.sh',self.tester_base) if self.olt else ('of-bridge.sh',self.sandbox_setup) |
A R Karthick | 078e63a | 2016-07-28 13:59:31 -0700 | [diff] [blame] | 101 | ovs_cmd = os.path.join(s_sandbox, s_file) + ' {0}'.format(self.switch) |
Chetan Gaonker | 4ca5cca | 2016-04-11 13:59:35 -0700 | [diff] [blame] | 102 | if self.olt: |
A R Karthick | 36cfcef | 2016-08-18 15:20:07 -0700 | [diff] [blame] | 103 | if CordTester.switch_on_olt is True: |
| 104 | return |
| 105 | CordTester.switch_on_olt = True |
Chetan Gaonker | 4ca5cca | 2016-04-11 13:59:35 -0700 | [diff] [blame] | 106 | ovs_cmd += ' {0}'.format(self.ctlr_ip) |
| 107 | print('Starting OVS on the host') |
| 108 | else: |
| 109 | print('Starting OVS on test container %s' %self.name) |
| 110 | self.execute_switch(ovs_cmd) |
Chetan Gaonker | 93e302d | 2016-04-05 10:51:07 -0700 | [diff] [blame] | 111 | status = 1 |
| 112 | ## Wait for the LLDP flows to be added to the switch |
| 113 | tries = 0 |
Chetan Gaonker | a52016e | 2016-05-05 15:19:59 -0700 | [diff] [blame] | 114 | while status != 0 and tries < 200: |
A R Karthick | 078e63a | 2016-07-28 13:59:31 -0700 | [diff] [blame] | 115 | cmd = 'sudo ovs-ofctl dump-flows {0} | grep \"type=0x8942\"'.format(self.switch) |
Chetan Gaonker | 4ca5cca | 2016-04-11 13:59:35 -0700 | [diff] [blame] | 116 | status = self.execute_switch(cmd, shell = True) |
Chetan Gaonker | 93e302d | 2016-04-05 10:51:07 -0700 | [diff] [blame] | 117 | tries += 1 |
| 118 | if tries % 10 == 0: |
| 119 | print('Waiting for test switch to be connected to ONOS controller ...') |
| 120 | |
| 121 | if status != 0: |
| 122 | print('Test Switch not connected to ONOS container.' |
| 123 | 'Please remove ONOS container and restart the test') |
| 124 | if self.rm: |
| 125 | self.kill() |
| 126 | sys.exit(1) |
| 127 | |
Chetan Gaonker | 4ca5cca | 2016-04-11 13:59:35 -0700 | [diff] [blame] | 128 | if boot_delay: |
| 129 | time.sleep(boot_delay) |
| 130 | |
A R Karthick | 1f03e91 | 2016-05-18 11:39:22 -0700 | [diff] [blame] | 131 | def setup_intfs(self, port_num = 0): |
Chetan Gaonker | 4ca5cca | 2016-04-11 13:59:35 -0700 | [diff] [blame] | 132 | tester_intf_subnet = '192.168.100' |
| 133 | res = 0 |
Chetan Gaonker | 5209fe8 | 2016-04-19 10:09:53 -0700 | [diff] [blame] | 134 | host_intf = self.port_map['host'] |
| 135 | start_vlan = self.port_map['start_vlan'] |
A R Karthick | 0776936 | 2016-07-28 17:36:15 -0700 | [diff] [blame] | 136 | start_vlan += port_num |
| 137 | uplink = self.port_map['uplink'] |
| 138 | wan = self.port_map['wan'] |
A R Karthick | 36cfcef | 2016-08-18 15:20:07 -0700 | [diff] [blame] | 139 | port_list = self.port_map['ports'] + self.port_map['relay_ports'] |
| 140 | for port in port_list: |
Chetan Gaonker | 5209fe8 | 2016-04-19 10:09:53 -0700 | [diff] [blame] | 141 | guest_if = port |
A R Karthick | 1f03e91 | 2016-05-18 11:39:22 -0700 | [diff] [blame] | 142 | local_if = '{0}_{1}'.format(guest_if, port_num+1) |
| 143 | guest_ip = '{0}.{1}/24'.format(tester_intf_subnet, port_num+1) |
Chetan Gaonker | 5209fe8 | 2016-04-19 10:09:53 -0700 | [diff] [blame] | 144 | ##Use pipeworks to configure container interfaces on host/bridge interfaces |
A R Karthick | 0776936 | 2016-07-28 17:36:15 -0700 | [diff] [blame] | 145 | pipework_cmd = 'pipework {0} -i {1} -l {2} {3} {4}'.format(host_intf, guest_if, |
| 146 | local_if, self.name, guest_ip) |
| 147 | #if the wan interface is specified for uplink, then use it instead |
| 148 | if wan and port == self.port_map[uplink]: |
| 149 | pipework_cmd = 'pipework {0} -i {1} -l {2} {3} {4}'.format(wan, guest_if, |
| 150 | local_if, self.name, guest_ip) |
| 151 | else: |
| 152 | if start_vlan != 0: |
| 153 | pipework_cmd += ' @{}'.format(start_vlan) |
| 154 | start_vlan += 1 |
A.R Karthick | 95d044e | 2016-06-10 18:44:36 -0700 | [diff] [blame] | 155 | |
Chetan Gaonker | 4ca5cca | 2016-04-11 13:59:35 -0700 | [diff] [blame] | 156 | res += os.system(pipework_cmd) |
Chetan Gaonker | 5209fe8 | 2016-04-19 10:09:53 -0700 | [diff] [blame] | 157 | port_num += 1 |
Chetan Gaonker | 4ca5cca | 2016-04-11 13:59:35 -0700 | [diff] [blame] | 158 | |
A R Karthick | 1f03e91 | 2016-05-18 11:39:22 -0700 | [diff] [blame] | 159 | return res, port_num |
Chetan Gaonker | 93e302d | 2016-04-05 10:51:07 -0700 | [diff] [blame] | 160 | |
| 161 | @classmethod |
A R Karthick | b50f559 | 2016-07-26 12:19:29 -0700 | [diff] [blame] | 162 | def cleanup_intfs(cls): |
| 163 | olt_conf_file = os.path.join(cls.tester_base, 'olt_config.json') |
| 164 | olt_config = OltConfig(olt_conf_file) |
A R Karthick | b03cecd | 2016-07-27 10:27:55 -0700 | [diff] [blame] | 165 | port_map, _ = olt_config.olt_port_map() |
A R Karthick | b50f559 | 2016-07-26 12:19:29 -0700 | [diff] [blame] | 166 | port_num = 0 |
| 167 | intf_host = port_map['host'] |
| 168 | start_vlan = port_map['start_vlan'] |
A R Karthick | 0776936 | 2016-07-28 17:36:15 -0700 | [diff] [blame] | 169 | uplink = port_map['uplink'] |
| 170 | wan = port_map['wan'] |
A R Karthick | b50f559 | 2016-07-26 12:19:29 -0700 | [diff] [blame] | 171 | intf_type = 0 |
| 172 | if os.path.isdir('/sys/class/net/{}/bridge'.format(intf_host)): |
| 173 | intf_type = 1 ##linux bridge |
| 174 | else: |
| 175 | cmd = 'ovs-vsctl list-br | grep -q "^{0}$"'.format(intf_host) |
| 176 | res = os.system(cmd) |
| 177 | if res == 0: ##ovs bridge |
| 178 | intf_type = 2 |
| 179 | cmds = () |
| 180 | res = 0 |
| 181 | for port in port_map['ports']: |
| 182 | local_if = '{0}_{1}'.format(port, port_num+1) |
A R Karthick | 0776936 | 2016-07-28 17:36:15 -0700 | [diff] [blame] | 183 | if wan and port_map[uplink] == port: |
| 184 | continue |
A R Karthick | b50f559 | 2016-07-26 12:19:29 -0700 | [diff] [blame] | 185 | if intf_type == 0: |
| 186 | if start_vlan != 0: |
A R Karthick | 0776936 | 2016-07-28 17:36:15 -0700 | [diff] [blame] | 187 | cmds = ('ip link del {}.{}'.format(intf_host, start_vlan),) |
| 188 | start_vlan += 1 |
A R Karthick | b50f559 | 2016-07-26 12:19:29 -0700 | [diff] [blame] | 189 | else: |
| 190 | if intf_type == 1: |
| 191 | cmds = ('brctl delif {} {}'.format(intf_host, local_if), |
| 192 | 'ip link del {}'.format(local_if)) |
| 193 | else: |
| 194 | cmds = ('ovs-vsctl del-port {} {}'.format(intf_host, local_if),) |
| 195 | |
| 196 | for cmd in cmds: |
| 197 | res += os.system(cmd) |
| 198 | |
| 199 | port_num += 1 |
| 200 | |
| 201 | @classmethod |
Chetan Gaonker | 93e302d | 2016-04-05 10:51:07 -0700 | [diff] [blame] | 202 | def get_name(cls): |
| 203 | cnt_name = '/{0}'.format(cls.basename) |
| 204 | cnt_name_len = len(cnt_name) |
| 205 | names = list(flatten(n['Names'] for n in cls.dckr.containers(all=True))) |
| 206 | test_names = filter(lambda n: n.startswith(cnt_name), names) |
| 207 | last_cnt_number = 0 |
| 208 | if test_names: |
| 209 | last_cnt_name = reduce(lambda n1, n2: n1 if int(n1[cnt_name_len:]) > \ |
| 210 | int(n2[cnt_name_len:]) else n2, |
| 211 | test_names) |
| 212 | last_cnt_number = int(last_cnt_name[cnt_name_len:]) |
| 213 | test_cnt_name = cls.basename + str(last_cnt_number+1) |
| 214 | return test_cnt_name |
| 215 | |
| 216 | @classmethod |
| 217 | def build_image(cls, image): |
| 218 | print('Building test container docker image %s' %image) |
Chetan Gaonker | b6064fa | 2016-05-02 16:29:57 -0700 | [diff] [blame] | 219 | ovs_version = '2.5.0' |
| 220 | image_format = (ovs_version,)*4 |
Chetan Gaonker | 93e302d | 2016-04-05 10:51:07 -0700 | [diff] [blame] | 221 | dockerfile = ''' |
| 222 | FROM ubuntu:14.04 |
| 223 | MAINTAINER chetan@ciena.com |
A R Karthick | c762df4 | 2016-05-25 10:09:21 -0700 | [diff] [blame] | 224 | RUN apt-get update && \ |
| 225 | apt-get install -y git git-core autoconf automake autotools-dev pkg-config \ |
| 226 | make gcc g++ libtool libc6-dev cmake libpcap-dev libxerces-c2-dev \ |
| 227 | unzip libpcre3-dev flex bison libboost-dev \ |
| 228 | python python-pip python-setuptools python-scapy tcpdump doxygen doxypy wget \ |
| 229 | openvswitch-common openvswitch-switch \ |
A R Karthick | 07608ef | 2016-08-23 16:51:19 -0700 | [diff] [blame] | 230 | python-twisted python-sqlite sqlite3 python-pexpect telnet arping isc-dhcp-server \ |
| 231 | python-paramiko python-maas-client |
Chetan Gaonker | 93e302d | 2016-04-05 10:51:07 -0700 | [diff] [blame] | 232 | RUN easy_install nose |
Chetan Gaonker | 93e302d | 2016-04-05 10:51:07 -0700 | [diff] [blame] | 233 | RUN mkdir -p /root/ovs |
| 234 | WORKDIR /root |
Chetan Gaonker | b6064fa | 2016-05-02 16:29:57 -0700 | [diff] [blame] | 235 | RUN wget http://openvswitch.org/releases/openvswitch-{}.tar.gz -O /root/ovs/openvswitch-{}.tar.gz && \ |
| 236 | (cd /root/ovs && tar zxpvf openvswitch-{}.tar.gz && \ |
| 237 | cd openvswitch-{} && \ |
Chetan Gaonker | 93e302d | 2016-04-05 10:51:07 -0700 | [diff] [blame] | 238 | ./configure --prefix=/usr --sysconfdir=/etc --localstatedir=/var --disable-ssl && make && make install) |
| 239 | RUN service openvswitch-switch restart || /bin/true |
A R Karthick | 81acbff | 2016-06-17 14:45:16 -0700 | [diff] [blame] | 240 | RUN pip install -U scapy scapy-ssl_tls monotonic configObj docker-py pyyaml nsenter pyroute2 netaddr python-daemon |
Chetan Gaonker | 93e302d | 2016-04-05 10:51:07 -0700 | [diff] [blame] | 241 | RUN mv /usr/sbin/tcpdump /sbin/ |
| 242 | RUN ln -sf /sbin/tcpdump /usr/sbin/tcpdump |
A R Karthick | f499947 | 2016-07-01 16:42:13 -0700 | [diff] [blame] | 243 | RUN mv /usr/sbin/dhcpd /sbin/ |
| 244 | RUN ln -sf /sbin/dhcpd /usr/sbin/dhcpd |
A R Karthick | b7e8090 | 2016-05-17 09:38:31 -0700 | [diff] [blame] | 245 | WORKDIR /root |
| 246 | RUN wget -nc http://de.archive.ubuntu.com/ubuntu/pool/main/b/bison/bison_2.5.dfsg-2.1_amd64.deb \ |
| 247 | http://de.archive.ubuntu.com/ubuntu/pool/main/b/bison/libbison-dev_2.5.dfsg-2.1_amd64.deb |
| 248 | RUN sudo dpkg -i bison_2.5.dfsg-2.1_amd64.deb libbison-dev_2.5.dfsg-2.1_amd64.deb |
| 249 | RUN rm bison_2.5.dfsg-2.1_amd64.deb libbison-dev_2.5.dfsg-2.1_amd64.deb |
| 250 | RUN wget -nc http://www.nbee.org/download/nbeesrc-jan-10-2013.zip && \ |
| 251 | unzip nbeesrc-jan-10-2013.zip && \ |
| 252 | cd nbeesrc-jan-10-2013/src && cmake . && make && \ |
| 253 | cp ../bin/libn*.so /usr/local/lib && ldconfig && \ |
| 254 | cp -R ../include/* /usr/include/ |
| 255 | WORKDIR /root |
| 256 | RUN git clone https://github.com/CPqD/ofsoftswitch13.git && \ |
| 257 | cd ofsoftswitch13 && \ |
A R Karthick | b7e8090 | 2016-05-17 09:38:31 -0700 | [diff] [blame] | 258 | ./boot.sh && \ |
| 259 | ./configure --prefix=/usr --sysconfdir=/etc --localstatedir=/var --disable-ssl && \ |
| 260 | make && make install |
Chetan Gaonker | 93e302d | 2016-04-05 10:51:07 -0700 | [diff] [blame] | 261 | CMD ["/bin/bash"] |
Chetan Gaonker | b6064fa | 2016-05-02 16:29:57 -0700 | [diff] [blame] | 262 | '''.format(*image_format) |
Chetan Gaonker | 93e302d | 2016-04-05 10:51:07 -0700 | [diff] [blame] | 263 | super(CordTester, cls).build_image(dockerfile, image) |
| 264 | print('Done building docker image %s' %image) |
| 265 | |
A R Karthick | 1f03e91 | 2016-05-18 11:39:22 -0700 | [diff] [blame] | 266 | def run_tests(self): |
Chetan Gaonker | 93e302d | 2016-04-05 10:51:07 -0700 | [diff] [blame] | 267 | '''Run the list of tests''' |
A R Karthick | 9a5edc4 | 2016-08-24 19:10:22 -0700 | [diff] [blame] | 268 | res = 0 |
A R Karthick | 1f03e91 | 2016-05-18 11:39:22 -0700 | [diff] [blame] | 269 | print('Running tests: %s' %self.tests) |
| 270 | for t in self.tests: |
Chetan Gaonker | 93e302d | 2016-04-05 10:51:07 -0700 | [diff] [blame] | 271 | test = t.split(':')[0] |
A R Karthick | 24f1de6 | 2016-05-12 15:16:38 -0700 | [diff] [blame] | 272 | test_file = '{}Test.py'.format(test) |
Chetan Gaonker | 93e302d | 2016-04-05 10:51:07 -0700 | [diff] [blame] | 273 | if t.find(':') >= 0: |
A R Karthick | 24f1de6 | 2016-05-12 15:16:38 -0700 | [diff] [blame] | 274 | test_case = '{0}:{1}'.format(test_file, t.split(':')[1]) |
Chetan Gaonker | 93e302d | 2016-04-05 10:51:07 -0700 | [diff] [blame] | 275 | else: |
| 276 | test_case = test_file |
Chetan Gaonker | 7142a34 | 2016-04-07 14:53:12 -0700 | [diff] [blame] | 277 | cmd = 'nosetests -v {0}/src/test/{1}/{2}'.format(self.sandbox, test, test_case) |
Chetan Gaonker | 93e302d | 2016-04-05 10:51:07 -0700 | [diff] [blame] | 278 | status = self.execute(cmd, shell = True) |
A R Karthick | 9a5edc4 | 2016-08-24 19:10:22 -0700 | [diff] [blame] | 279 | if status > 255: |
| 280 | status = 1 |
| 281 | res |= status |
Chetan Gaonker | 93e302d | 2016-04-05 10:51:07 -0700 | [diff] [blame] | 282 | print('Test %s %s' %(test_case, 'Success' if status == 0 else 'Failure')) |
| 283 | print('Done running tests') |
| 284 | if self.rm: |
| 285 | print('Removing test container %s' %self.name) |
| 286 | self.kill(remove=True) |
| 287 | |
A R Karthick | 9a5edc4 | 2016-08-24 19:10:22 -0700 | [diff] [blame] | 288 | return res |
| 289 | |
Chetan Gaonker | fb3cb5e | 2016-05-06 11:55:44 -0700 | [diff] [blame] | 290 | @classmethod |
| 291 | def list_tests(cls, tests): |
| 292 | print('Listing test cases') |
| 293 | for test in tests: |
A R Karthick | 24f1de6 | 2016-05-12 15:16:38 -0700 | [diff] [blame] | 294 | test_file = '{}Test.py'.format(test) |
Chetan Gaonker | fb3cb5e | 2016-05-06 11:55:44 -0700 | [diff] [blame] | 295 | cmd = 'nosetests -v --collect-only {0}/../{1}/{2}'.format(cls.tester_base, test, test_file) |
| 296 | os.system(cmd) |
| 297 | |
A R Karthick | a013a27 | 2016-08-16 16:40:19 -0700 | [diff] [blame] | 298 | |
Chetan Gaonker | 93e302d | 2016-04-05 10:51:07 -0700 | [diff] [blame] | 299 | ##default onos/radius/test container images and names |
| 300 | onos_image_default='onosproject/onos:latest' |
A R Karthick | 07608ef | 2016-08-23 16:51:19 -0700 | [diff] [blame] | 301 | nose_image_default= '{}:candidate'.format(CordTester.IMAGE) |
Chetan Gaonker | 93e302d | 2016-04-05 10:51:07 -0700 | [diff] [blame] | 302 | test_type_default='dhcp' |
A.R Karthick | 95d044e | 2016-06-10 18:44:36 -0700 | [diff] [blame] | 303 | onos_app_version = '2.0-SNAPSHOT' |
Chetan Gaonker | 4d842ad | 2016-04-26 10:04:24 -0700 | [diff] [blame] | 304 | cord_tester_base = os.path.dirname(os.path.realpath(__file__)) |
Chetan Gaonker | 4ca5cca | 2016-04-11 13:59:35 -0700 | [diff] [blame] | 305 | onos_app_file = os.path.abspath('{0}/../apps/ciena-cordigmp-'.format(cord_tester_base) + onos_app_version + '.oar') |
A R Karthick | 81acbff | 2016-06-17 14:45:16 -0700 | [diff] [blame] | 306 | cord_test_server_address = '{}:{}'.format(CORD_TEST_HOST, CORD_TEST_PORT) |
A R Karthick | 07608ef | 2016-08-23 16:51:19 -0700 | [diff] [blame] | 307 | identity_file_default = '/etc/maas/ansible/id_rsa' |
| 308 | |
| 309 | ##sets up the ssh key file for the test container |
| 310 | def set_ssh_key_file(identity_file): |
| 311 | ssh_key_file = None |
| 312 | if os.access(identity_file, os.F_OK): |
| 313 | ##copy it to setup directory |
| 314 | identity_dest = os.path.join(CordTester.tester_base, 'id_rsa') |
| 315 | if os.path.abspath(identity_file) != identity_dest: |
| 316 | try: |
| 317 | shutil.copy(identity_file, identity_dest) |
| 318 | ssh_key_file = os.path.join(CordTester.sandbox_setup, 'id_rsa') |
| 319 | except: pass |
| 320 | |
| 321 | return ssh_key_file |
Chetan Gaonker | 93e302d | 2016-04-05 10:51:07 -0700 | [diff] [blame] | 322 | |
| 323 | def runTest(args): |
Chetan Gaonker | 823cdc5 | 2016-05-09 15:51:23 -0700 | [diff] [blame] | 324 | #Start the cord test tcp server |
A R Karthick | 81acbff | 2016-06-17 14:45:16 -0700 | [diff] [blame] | 325 | test_server_params = args.server.split(':') |
| 326 | test_host = test_server_params[0] |
| 327 | test_port = CORD_TEST_PORT |
| 328 | if len(test_server_params) > 1: |
| 329 | test_port = int(test_server_params[1]) |
| 330 | try: |
| 331 | test_server = cord_test_server_start(daemonize = False, cord_test_host = test_host, cord_test_port = test_port) |
| 332 | except: |
| 333 | ##Most likely a server instance is already running (daemonized earlier) |
| 334 | test_server = None |
| 335 | |
A R Karthick | 1f03e91 | 2016-05-18 11:39:22 -0700 | [diff] [blame] | 336 | test_containers = [] |
| 337 | #These tests end up restarting ONOS/quagga/radius |
A R Karthick | 4e0c091 | 2016-08-17 16:57:42 -0700 | [diff] [blame] | 338 | tests_exempt = ('vrouter', 'cordSubscriber', 'proxyarp', 'dhcprelay') |
Chetan Gaonker | 503032a | 2016-05-12 12:06:29 -0700 | [diff] [blame] | 339 | if args.test_type.lower() == 'all': |
| 340 | tests = CordTester.ALL_TESTS |
Chetan Gaonker | 503032a | 2016-05-12 12:06:29 -0700 | [diff] [blame] | 341 | args.quagga = True |
| 342 | else: |
A R Karthick | acae3b4 | 2016-05-12 15:27:24 -0700 | [diff] [blame] | 343 | tests = args.test_type.split('-') |
Chetan Gaonker | 503032a | 2016-05-12 12:06:29 -0700 | [diff] [blame] | 344 | |
A R Karthick | 1f03e91 | 2016-05-18 11:39:22 -0700 | [diff] [blame] | 345 | tests_parallel = [ t for t in tests if t.split(':')[0] not in tests_exempt ] |
| 346 | tests_not_parallel = [ t for t in tests if t.split(':')[0] in tests_exempt ] |
Chetan Gaonker | 93e302d | 2016-04-05 10:51:07 -0700 | [diff] [blame] | 347 | onos_cnt = {'tag':'latest'} |
A R Karthick | 07608ef | 2016-08-23 16:51:19 -0700 | [diff] [blame] | 348 | nose_cnt = {'image': CordTester.IMAGE, 'tag': 'candidate'} |
Chetan Gaonker | 503032a | 2016-05-12 12:06:29 -0700 | [diff] [blame] | 349 | update_map = { 'quagga' : False, 'test' : False, 'radius' : False } |
| 350 | update_map[args.update.lower()] = True |
A.R Karthick | 95d044e | 2016-06-10 18:44:36 -0700 | [diff] [blame] | 351 | |
Chetan Gaonker | 503032a | 2016-05-12 12:06:29 -0700 | [diff] [blame] | 352 | if args.update.lower() == 'all': |
| 353 | for c in update_map.keys(): |
| 354 | update_map[c] = True |
A.R Karthick | 95d044e | 2016-06-10 18:44:36 -0700 | [diff] [blame] | 355 | |
A R Karthick | 07608ef | 2016-08-23 16:51:19 -0700 | [diff] [blame] | 356 | onos_ip = None |
Chetan Gaonker | 5209fe8 | 2016-04-19 10:09:53 -0700 | [diff] [blame] | 357 | radius_ip = None |
A R Karthick | 07608ef | 2016-08-23 16:51:19 -0700 | [diff] [blame] | 358 | head_node = platform.node() |
| 359 | use_manifest = False |
| 360 | if args.manifest: |
| 361 | if os.access(args.manifest, os.F_OK): |
| 362 | ##copy it to setup directory |
| 363 | dest = os.path.join(CordTester.tester_base, 'manifest.json') |
| 364 | if os.path.abspath(args.manifest) != dest: |
| 365 | try: |
| 366 | shutil.copy(args.manifest, dest) |
| 367 | except: pass |
| 368 | test_manifest = TestManifest(dest) |
| 369 | onos_ip = test_manifest.onos_ip |
| 370 | radius_ip = test_manifest.radius_ip |
| 371 | head_node = test_manifest.head_node |
| 372 | use_manifest = True |
| 373 | else: |
| 374 | print('Unable to access test manifest: %s' %args.manifest) |
Chetan Gaonker | fb3cb5e | 2016-05-06 11:55:44 -0700 | [diff] [blame] | 375 | |
Chetan Gaonker | 5209fe8 | 2016-04-19 10:09:53 -0700 | [diff] [blame] | 376 | #don't spawn onos if the user has specified external test controller with test interface config |
| 377 | if args.test_controller: |
| 378 | ips = args.test_controller.split('/') |
| 379 | onos_ip = ips[0] |
| 380 | if len(ips) > 1: |
| 381 | radius_ip = ips[1] |
| 382 | else: |
| 383 | radius_ip = None |
Chetan Gaonker | 93e302d | 2016-04-05 10:51:07 -0700 | [diff] [blame] | 384 | |
A R Karthick | 07608ef | 2016-08-23 16:51:19 -0700 | [diff] [blame] | 385 | Container.IMAGE_PREFIX = args.prefix |
| 386 | if onos_ip is None: |
| 387 | image_names = args.onos.rsplit(':', 1) |
| 388 | onos_cnt['image'] = image_names[0] |
| 389 | if len(image_names) > 1: |
| 390 | if image_names[1].find('/') < 0: |
| 391 | onos_cnt['tag'] = image_names[1] |
| 392 | else: |
| 393 | #tag cannot have slashes |
| 394 | onos_cnt['image'] = args.onos |
| 395 | |
| 396 | Onos.IMAGE = onos_cnt['image'] |
| 397 | Onos.PREFIX = args.prefix |
| 398 | Onos.TAG = onos_cnt['tag'] |
| 399 | onos = Onos(image = Onos.IMAGE, |
| 400 | tag = Onos.TAG, boot_delay = 60) |
Chetan Gaonker | 5209fe8 | 2016-04-19 10:09:53 -0700 | [diff] [blame] | 401 | onos_ip = onos.ip() |
| 402 | |
A R Karthick | eaf1c4e | 2016-07-19 12:22:35 -0700 | [diff] [blame] | 403 | print('Onos IP %s, Test type %s' %(onos_ip, args.test_type)) |
A R Karthick | 07608ef | 2016-08-23 16:51:19 -0700 | [diff] [blame] | 404 | if use_manifest or args.test_controller: |
A R Karthick | bd9b8a3 | 2016-07-21 09:56:45 -0700 | [diff] [blame] | 405 | print('Installing ONOS cord apps') |
A R Karthick | 07608ef | 2016-08-23 16:51:19 -0700 | [diff] [blame] | 406 | try: |
| 407 | Onos.install_cord_apps(onos_ip = onos_ip) |
| 408 | except: pass |
A R Karthick | eaf1c4e | 2016-07-19 12:22:35 -0700 | [diff] [blame] | 409 | |
| 410 | print('Installing cord tester ONOS app %s' %onos_app_file) |
A R Karthick | 07608ef | 2016-08-23 16:51:19 -0700 | [diff] [blame] | 411 | try: |
| 412 | OnosCtrl.install_app(args.app, onos_ip = onos_ip) |
| 413 | except: pass |
A R Karthick | eaf1c4e | 2016-07-19 12:22:35 -0700 | [diff] [blame] | 414 | |
| 415 | if radius_ip is None: |
A R Karthick | a661b55 | 2016-05-25 10:18:50 -0700 | [diff] [blame] | 416 | ##Start Radius container |
A R Karthick | 07608ef | 2016-08-23 16:51:19 -0700 | [diff] [blame] | 417 | radius = Radius(prefix = Container.IMAGE_PREFIX, update = update_map['radius']) |
A R Karthick | a661b55 | 2016-05-25 10:18:50 -0700 | [diff] [blame] | 418 | radius_ip = radius.ip() |
A.R Karthick | 95d044e | 2016-06-10 18:44:36 -0700 | [diff] [blame] | 419 | |
A R Karthick | eaf1c4e | 2016-07-19 12:22:35 -0700 | [diff] [blame] | 420 | print('Radius server running with IP %s' %radius_ip) |
A.R Karthick | 95d044e | 2016-06-10 18:44:36 -0700 | [diff] [blame] | 421 | |
Chetan Gaonker | b84835f | 2016-04-19 15:12:10 -0700 | [diff] [blame] | 422 | if args.quagga == True: |
| 423 | #Start quagga. Builds container if required |
A R Karthick | 07608ef | 2016-08-23 16:51:19 -0700 | [diff] [blame] | 424 | quagga = Quagga(prefix = Container.IMAGE_PREFIX, update = update_map['quagga']) |
A R Karthick | 81acbff | 2016-06-17 14:45:16 -0700 | [diff] [blame] | 425 | |
A R Karthick | 07608ef | 2016-08-23 16:51:19 -0700 | [diff] [blame] | 426 | try: |
| 427 | maas_api_key = FabricMAAS.get_api_key() |
| 428 | except: |
| 429 | maas_api_key = 'UNKNOWN' |
| 430 | |
| 431 | ssh_key_file = set_ssh_key_file(args.identity_file) |
Chetan Gaonker | 93e302d | 2016-04-05 10:51:07 -0700 | [diff] [blame] | 432 | test_cnt_env = { 'ONOS_CONTROLLER_IP' : onos_ip, |
Chetan Gaonker | c170f3f | 2016-04-19 17:24:45 -0700 | [diff] [blame] | 433 | 'ONOS_AAA_IP' : radius_ip if radius_ip is not None else '', |
A R Karthick | 8d03cc5 | 2016-06-28 14:51:59 -0700 | [diff] [blame] | 434 | 'QUAGGA_IP': test_host, |
A R Karthick | 81acbff | 2016-06-17 14:45:16 -0700 | [diff] [blame] | 435 | 'CORD_TEST_HOST' : test_host, |
| 436 | 'CORD_TEST_PORT' : test_port, |
A R Karthick | 4e0c091 | 2016-08-17 16:57:42 -0700 | [diff] [blame] | 437 | 'ONOS_RESTART' : 0 if args.olt and args.test_controller else 1, |
A R Karthick | 07608ef | 2016-08-23 16:51:19 -0700 | [diff] [blame] | 438 | 'MANIFEST': int(use_manifest), |
| 439 | 'HEAD_NODE': head_node if head_node else CORD_TEST_HOST, |
| 440 | 'MAAS_API_KEY': maas_api_key |
Chetan Gaonker | 93e302d | 2016-04-05 10:51:07 -0700 | [diff] [blame] | 441 | } |
A R Karthick | 07608ef | 2016-08-23 16:51:19 -0700 | [diff] [blame] | 442 | |
| 443 | if ssh_key_file: |
| 444 | test_cnt_env['SSH_KEY_FILE'] = ssh_key_file |
| 445 | |
Chetan Gaonker | 93e302d | 2016-04-05 10:51:07 -0700 | [diff] [blame] | 446 | if args.olt: |
Chetan Gaonker | 7142a34 | 2016-04-07 14:53:12 -0700 | [diff] [blame] | 447 | olt_conf_test_loc = os.path.join(CordTester.sandbox_setup, 'olt_config.json') |
Chetan Gaonker | 93e302d | 2016-04-05 10:51:07 -0700 | [diff] [blame] | 448 | test_cnt_env['OLT_CONFIG'] = olt_conf_test_loc |
| 449 | |
A R Karthick | a013a27 | 2016-08-16 16:40:19 -0700 | [diff] [blame] | 450 | if args.num_containers > 1 and args.container: |
| 451 | print('Cannot specify number of containers with container option') |
| 452 | sys.exit(1) |
| 453 | if args.container: |
| 454 | args.keep = True |
A R Karthick | 1f03e91 | 2016-05-18 11:39:22 -0700 | [diff] [blame] | 455 | port_num = 0 |
| 456 | num_tests = len(tests_parallel) |
| 457 | tests_per_container = max(1, num_tests/args.num_containers) |
| 458 | test_slice_start = 0 |
| 459 | test_slice_end = test_slice_start + tests_per_container |
| 460 | num_test_containers = min(num_tests, args.num_containers) |
| 461 | if tests_parallel: |
| 462 | print('Running %s tests across %d containers in parallel' %(tests_parallel, num_test_containers)) |
| 463 | for container in range(num_test_containers): |
| 464 | test_cnt = CordTester(tests_parallel[test_slice_start:test_slice_end], |
| 465 | instance = container, num_instances = num_test_containers, |
A R Karthick | a013a27 | 2016-08-16 16:40:19 -0700 | [diff] [blame] | 466 | ctlr_ip = onos_ip, |
A R Karthick | 07608ef | 2016-08-23 16:51:19 -0700 | [diff] [blame] | 467 | name = args.container, |
| 468 | image = nose_cnt['image'], |
| 469 | prefix = Container.IMAGE_PREFIX, |
| 470 | tag = nose_cnt['tag'], |
A R Karthick | 1f03e91 | 2016-05-18 11:39:22 -0700 | [diff] [blame] | 471 | env = test_cnt_env, |
| 472 | rm = False if args.keep else True, |
| 473 | update = update_map['test']) |
| 474 | test_slice_start = test_slice_end |
| 475 | test_slice_end = test_slice_start + tests_per_container |
| 476 | update_map['test'] = False |
| 477 | test_containers.append(test_cnt) |
A R Karthick | a013a27 | 2016-08-16 16:40:19 -0700 | [diff] [blame] | 478 | if not test_cnt.create: |
| 479 | continue |
| 480 | if test_cnt.create and (args.start_switch or not args.olt): |
A R Karthick | 07608ef | 2016-08-23 16:51:19 -0700 | [diff] [blame] | 481 | if not args.no_switch: |
| 482 | test_cnt.start_switch() |
A R Karthick | a013a27 | 2016-08-16 16:40:19 -0700 | [diff] [blame] | 483 | if test_cnt.create and test_cnt.olt: |
A R Karthick | 1f03e91 | 2016-05-18 11:39:22 -0700 | [diff] [blame] | 484 | _, port_num = test_cnt.setup_intfs(port_num = port_num) |
| 485 | |
A R Karthick | 9a5edc4 | 2016-08-24 19:10:22 -0700 | [diff] [blame] | 486 | status = 0 |
| 487 | if len(test_containers) > 1: |
| 488 | thread_pool = ThreadPool(len(test_containers), queue_size = 1, wait_timeout=1) |
| 489 | for test_cnt in test_containers: |
| 490 | thread_pool.addTask(test_cnt.run_tests) |
| 491 | thread_pool.cleanUpThreads() |
| 492 | else: |
| 493 | status = test_containers[0].run_tests() |
A R Karthick | 1f03e91 | 2016-05-18 11:39:22 -0700 | [diff] [blame] | 494 | |
| 495 | ##Run the linear tests |
| 496 | if tests_not_parallel: |
| 497 | test_cnt = CordTester(tests_not_parallel, |
A R Karthick | a013a27 | 2016-08-16 16:40:19 -0700 | [diff] [blame] | 498 | ctlr_ip = onos_ip, |
A R Karthick | 07608ef | 2016-08-23 16:51:19 -0700 | [diff] [blame] | 499 | name = args.container, |
| 500 | image = nose_cnt['image'], |
| 501 | prefix = Container.IMAGE_PREFIX, |
| 502 | tag = nose_cnt['tag'], |
A R Karthick | 1f03e91 | 2016-05-18 11:39:22 -0700 | [diff] [blame] | 503 | env = test_cnt_env, |
| 504 | rm = False if args.keep else True, |
| 505 | update = update_map['test']) |
A R Karthick | a013a27 | 2016-08-16 16:40:19 -0700 | [diff] [blame] | 506 | if test_cnt.create and (args.start_switch or not args.olt): |
A R Karthick | 36cfcef | 2016-08-18 15:20:07 -0700 | [diff] [blame] | 507 | #For non parallel tests, we just restart the switch also for OLT's |
| 508 | CordTester.switch_on_olt = False |
A R Karthick | 07608ef | 2016-08-23 16:51:19 -0700 | [diff] [blame] | 509 | if not args.no_switch: |
| 510 | test_cnt.start_switch() |
A R Karthick | a013a27 | 2016-08-16 16:40:19 -0700 | [diff] [blame] | 511 | if test_cnt.create and test_cnt.olt: |
A R Karthick | 1f03e91 | 2016-05-18 11:39:22 -0700 | [diff] [blame] | 512 | test_cnt.setup_intfs(port_num = port_num) |
| 513 | test_cnt.run_tests() |
| 514 | |
A R Karthick | 81acbff | 2016-06-17 14:45:16 -0700 | [diff] [blame] | 515 | if test_server: |
| 516 | cord_test_server_stop(test_server) |
| 517 | |
A R Karthick | 9a5edc4 | 2016-08-24 19:10:22 -0700 | [diff] [blame] | 518 | return status |
| 519 | |
A R Karthick | 81acbff | 2016-06-17 14:45:16 -0700 | [diff] [blame] | 520 | ##Starts onos/radius/quagga containers as appropriate |
| 521 | def setupCordTester(args): |
| 522 | onos_cnt = {'tag':'latest'} |
A R Karthick | 07608ef | 2016-08-23 16:51:19 -0700 | [diff] [blame] | 523 | nose_cnt = {'image': CordTester.IMAGE, 'tag': 'candidate'} |
A R Karthick | 92a0e5a | 2016-06-22 17:11:05 -0700 | [diff] [blame] | 524 | update_map = { 'quagga' : False, 'radius' : False, 'test': False } |
A R Karthick | 81acbff | 2016-06-17 14:45:16 -0700 | [diff] [blame] | 525 | update_map[args.update.lower()] = True |
| 526 | |
| 527 | if args.update.lower() == 'all': |
| 528 | for c in update_map.keys(): |
| 529 | update_map[c] = True |
| 530 | |
| 531 | onos_ip = None |
| 532 | radius_ip = None |
A R Karthick | d44cea1 | 2016-07-20 12:16:41 -0700 | [diff] [blame] | 533 | onos_cord_loc = args.onos_cord |
| 534 | if onos_cord_loc: |
| 535 | if onos_cord_loc.find(os.path.sep) < 0: |
| 536 | onos_cord_loc = os.path.join(os.getenv('HOME'), onos_cord_loc) |
| 537 | if not os.access(onos_cord_loc, os.F_OK): |
| 538 | print('ONOS cord config location %s is not accessible' %onos_cord_loc) |
| 539 | sys.exit(1) |
| 540 | #Disable test container provisioning on the ONOS compute node |
| 541 | args.dont_provision = True |
A R Karthick | 81acbff | 2016-06-17 14:45:16 -0700 | [diff] [blame] | 542 | |
A R Karthick | 07608ef | 2016-08-23 16:51:19 -0700 | [diff] [blame] | 543 | head_node = platform.node() |
| 544 | use_manifest = False |
| 545 | if args.manifest: |
| 546 | if os.access(args.manifest, os.F_OK): |
| 547 | ##copy it to setup directory |
| 548 | dest = os.path.join(CordTester.tester_base, 'manifest.json') |
| 549 | if os.path.abspath(args.manifest) != dest: |
| 550 | try: |
| 551 | shutil.copy(args.manifest, dest) |
| 552 | except: pass |
| 553 | test_manifest = TestManifest(dest) |
| 554 | onos_ip = test_manifest.onos_ip |
| 555 | radius_ip = test_manifest.radius_ip |
| 556 | head_node = test_manifest.head_node |
| 557 | use_manifest = True |
| 558 | |
A R Karthick | 81acbff | 2016-06-17 14:45:16 -0700 | [diff] [blame] | 559 | ##If onos/radius was already started |
| 560 | if args.test_controller: |
| 561 | ips = args.test_controller.split('/') |
| 562 | onos_ip = ips[0] |
| 563 | if len(ips) > 1: |
| 564 | radius_ip = ips[1] |
| 565 | else: |
| 566 | radius_ip = None |
| 567 | |
A R Karthick | d44cea1 | 2016-07-20 12:16:41 -0700 | [diff] [blame] | 568 | onos_cord = None |
| 569 | if onos_cord_loc: |
| 570 | if not args.test_controller: |
| 571 | ##Unexpected case. Specify the external controller ip when running on cord node |
| 572 | print('Specify ONOS ip using \"-e\" option when running the cord-tester on cord node') |
| 573 | sys.exit(1) |
A R Karthick | bd9b8a3 | 2016-07-21 09:56:45 -0700 | [diff] [blame] | 574 | onos_cord = OnosCord(onos_ip, onos_cord_loc) |
A R Karthick | d44cea1 | 2016-07-20 12:16:41 -0700 | [diff] [blame] | 575 | |
A R Karthick | 07608ef | 2016-08-23 16:51:19 -0700 | [diff] [blame] | 576 | Container.IMAGE_PREFIX = args.prefix |
A R Karthick | 81acbff | 2016-06-17 14:45:16 -0700 | [diff] [blame] | 577 | #don't spawn onos if the user had started it externally |
A R Karthick | 07608ef | 2016-08-23 16:51:19 -0700 | [diff] [blame] | 578 | image_names = args.onos.rsplit(':', 1) |
| 579 | onos_cnt['image'] = image_names[0] |
| 580 | if len(image_names) > 1: |
| 581 | if image_names[1].find('/') < 0: |
| 582 | onos_cnt['tag'] = image_names[1] |
| 583 | else: |
| 584 | #tag cannot have slashes |
| 585 | onos_cnt['image'] = args.onos |
A R Karthick | 81acbff | 2016-06-17 14:45:16 -0700 | [diff] [blame] | 586 | |
A R Karthick | 07608ef | 2016-08-23 16:51:19 -0700 | [diff] [blame] | 587 | Onos.IMAGE = onos_cnt['image'] |
| 588 | Onos.PREFIX = args.prefix |
| 589 | Onos.TAG = onos_cnt['tag'] |
A R Karthick | 81acbff | 2016-06-17 14:45:16 -0700 | [diff] [blame] | 590 | if onos_ip is None: |
A R Karthick | 07608ef | 2016-08-23 16:51:19 -0700 | [diff] [blame] | 591 | onos = Onos(image = Onos.IMAGE, tag = Onos.TAG, boot_delay = 60) |
A R Karthick | 81acbff | 2016-06-17 14:45:16 -0700 | [diff] [blame] | 592 | onos_ip = onos.ip() |
| 593 | |
A R Karthick | eaf1c4e | 2016-07-19 12:22:35 -0700 | [diff] [blame] | 594 | print('Onos IP %s' %onos_ip) |
A R Karthick | 07608ef | 2016-08-23 16:51:19 -0700 | [diff] [blame] | 595 | if use_manifest or args.test_controller: |
A R Karthick | bd9b8a3 | 2016-07-21 09:56:45 -0700 | [diff] [blame] | 596 | print('Installing ONOS cord apps') |
A R Karthick | 07608ef | 2016-08-23 16:51:19 -0700 | [diff] [blame] | 597 | try: |
| 598 | Onos.install_cord_apps(onos_ip = onos_ip) |
| 599 | except: pass |
A R Karthick | bd9b8a3 | 2016-07-21 09:56:45 -0700 | [diff] [blame] | 600 | |
A R Karthick | eaf1c4e | 2016-07-19 12:22:35 -0700 | [diff] [blame] | 601 | print('Installing cord tester ONOS app %s' %onos_app_file) |
A R Karthick | 07608ef | 2016-08-23 16:51:19 -0700 | [diff] [blame] | 602 | try: |
| 603 | OnosCtrl.install_app(args.app, onos_ip = onos_ip) |
| 604 | except: pass |
A R Karthick | eaf1c4e | 2016-07-19 12:22:35 -0700 | [diff] [blame] | 605 | |
A R Karthick | 81acbff | 2016-06-17 14:45:16 -0700 | [diff] [blame] | 606 | ##Start Radius container if not started |
| 607 | if radius_ip is None: |
A R Karthick | 07608ef | 2016-08-23 16:51:19 -0700 | [diff] [blame] | 608 | radius = Radius(prefix = Container.IMAGE_PREFIX, update = update_map['radius']) |
A R Karthick | 81acbff | 2016-06-17 14:45:16 -0700 | [diff] [blame] | 609 | radius_ip = radius.ip() |
| 610 | |
| 611 | print('Radius server running with IP %s' %radius_ip) |
A R Karthick | 81acbff | 2016-06-17 14:45:16 -0700 | [diff] [blame] | 612 | |
| 613 | if args.quagga == True: |
| 614 | #Start quagga. Builds container if required |
A R Karthick | 07608ef | 2016-08-23 16:51:19 -0700 | [diff] [blame] | 615 | quagga = Quagga(prefix = Container.IMAGE_PREFIX, update = update_map['quagga']) |
A R Karthick | 8d03cc5 | 2016-06-28 14:51:59 -0700 | [diff] [blame] | 616 | print('Quagga started') |
A R Karthick | 81acbff | 2016-06-17 14:45:16 -0700 | [diff] [blame] | 617 | |
A R Karthick | 81acbff | 2016-06-17 14:45:16 -0700 | [diff] [blame] | 618 | params = args.server.split(':') |
| 619 | ip = params[0] |
| 620 | port = CORD_TEST_PORT |
| 621 | if len(params) > 1: |
| 622 | port = int(params[1]) |
A R Karthick | 92a0e5a | 2016-06-22 17:11:05 -0700 | [diff] [blame] | 623 | |
A R Karthick | 07608ef | 2016-08-23 16:51:19 -0700 | [diff] [blame] | 624 | try: |
| 625 | maas_api_key = FabricMAAS.get_api_key() |
| 626 | except: |
| 627 | maas_api_key = 'UNKNOWN' |
| 628 | |
| 629 | ssh_key_file = set_ssh_key_file(args.identity_file) |
| 630 | |
A R Karthick | 92a0e5a | 2016-06-22 17:11:05 -0700 | [diff] [blame] | 631 | #provision the test container |
| 632 | if not args.dont_provision: |
| 633 | test_cnt_env = { 'ONOS_CONTROLLER_IP' : onos_ip, |
| 634 | 'ONOS_AAA_IP' : radius_ip, |
A R Karthick | 8d03cc5 | 2016-06-28 14:51:59 -0700 | [diff] [blame] | 635 | 'QUAGGA_IP': ip, |
A R Karthick | 92a0e5a | 2016-06-22 17:11:05 -0700 | [diff] [blame] | 636 | 'CORD_TEST_HOST' : ip, |
| 637 | 'CORD_TEST_PORT' : port, |
A R Karthick | 4e0c091 | 2016-08-17 16:57:42 -0700 | [diff] [blame] | 638 | 'ONOS_RESTART' : 0 if args.olt and args.test_controller else 1, |
A R Karthick | 07608ef | 2016-08-23 16:51:19 -0700 | [diff] [blame] | 639 | 'MANIFEST': int(use_manifest), |
| 640 | 'HEAD_NODE': head_node if head_node else CORD_TEST_HOST, |
| 641 | 'MAAS_API_KEY': maas_api_key |
A R Karthick | 92a0e5a | 2016-06-22 17:11:05 -0700 | [diff] [blame] | 642 | } |
A R Karthick | 07608ef | 2016-08-23 16:51:19 -0700 | [diff] [blame] | 643 | |
| 644 | if ssh_key_file: |
| 645 | test_cnt_env['SSH_KEY_FILE'] = ssh_key_file |
A R Karthick | 92a0e5a | 2016-06-22 17:11:05 -0700 | [diff] [blame] | 646 | if args.olt: |
| 647 | olt_conf_test_loc = os.path.join(CordTester.sandbox_setup, 'olt_config.json') |
| 648 | test_cnt_env['OLT_CONFIG'] = olt_conf_test_loc |
| 649 | |
| 650 | test_cnt = CordTester((), |
| 651 | ctlr_ip = onos_ip, |
| 652 | image = nose_cnt['image'], |
A R Karthick | 07608ef | 2016-08-23 16:51:19 -0700 | [diff] [blame] | 653 | prefix = Container.IMAGE_PREFIX, |
A R Karthick | 92a0e5a | 2016-06-22 17:11:05 -0700 | [diff] [blame] | 654 | tag = nose_cnt['tag'], |
| 655 | env = test_cnt_env, |
| 656 | rm = False, |
| 657 | update = update_map['test']) |
| 658 | |
| 659 | if args.start_switch or not args.olt: |
| 660 | test_cnt.start_switch() |
| 661 | if test_cnt.olt: |
| 662 | test_cnt.setup_intfs(port_num = 0) |
| 663 | print('Test container %s started and provisioned to run tests using nosetests' %(test_cnt.name)) |
| 664 | |
| 665 | #Finally start the test server and daemonize |
A R Karthick | 14118c6 | 2016-07-27 14:54:04 -0700 | [diff] [blame] | 666 | try: |
| 667 | cord_test_server_start(daemonize = True, cord_test_host = ip, cord_test_port = port, |
| 668 | onos_cord = onos_cord) |
| 669 | except socket.error, e: |
| 670 | #the test agent address could be remote or already running. Exit gracefully |
| 671 | sys.exit(0) |
Chetan Gaonker | 93e302d | 2016-04-05 10:51:07 -0700 | [diff] [blame] | 672 | |
A R Karthick | 9a5edc4 | 2016-08-24 19:10:22 -0700 | [diff] [blame] | 673 | return 0 |
| 674 | |
Chetan Gaonker | 503032a | 2016-05-12 12:06:29 -0700 | [diff] [blame] | 675 | def cleanupTests(args): |
A R Karthick | 07608ef | 2016-08-23 16:51:19 -0700 | [diff] [blame] | 676 | prefix = args.prefix |
| 677 | if prefix: |
| 678 | prefix += '/' |
| 679 | test_container = '{}{}:candidate'.format(prefix, CordTester.IMAGE) |
Chetan Gaonker | 503032a | 2016-05-12 12:06:29 -0700 | [diff] [blame] | 680 | print('Cleaning up Test containers ...') |
| 681 | Container.cleanup(test_container) |
A R Karthick | b50f559 | 2016-07-26 12:19:29 -0700 | [diff] [blame] | 682 | if args.olt: |
| 683 | print('Cleaning up test container OLT configuration') |
| 684 | CordTester.cleanup_intfs() |
A R Karthick | 9a5edc4 | 2016-08-24 19:10:22 -0700 | [diff] [blame] | 685 | return 0 |
Chetan Gaonker | 503032a | 2016-05-12 12:06:29 -0700 | [diff] [blame] | 686 | |
| 687 | def listTests(args): |
| 688 | if args.test == 'all': |
| 689 | tests = CordTester.ALL_TESTS |
| 690 | else: |
A R Karthick | acae3b4 | 2016-05-12 15:27:24 -0700 | [diff] [blame] | 691 | tests = args.test.split('-') |
Chetan Gaonker | 503032a | 2016-05-12 12:06:29 -0700 | [diff] [blame] | 692 | CordTester.list_tests(tests) |
A R Karthick | 9a5edc4 | 2016-08-24 19:10:22 -0700 | [diff] [blame] | 693 | return 0 |
Chetan Gaonker | 503032a | 2016-05-12 12:06:29 -0700 | [diff] [blame] | 694 | |
| 695 | def buildImages(args): |
A R Karthick | 07608ef | 2016-08-23 16:51:19 -0700 | [diff] [blame] | 696 | tag = 'candidate' |
| 697 | prefix = args.prefix |
| 698 | if prefix: |
| 699 | prefix += '/' |
Chetan Gaonker | 503032a | 2016-05-12 12:06:29 -0700 | [diff] [blame] | 700 | if args.image == 'all' or args.image == 'quagga': |
A R Karthick | 07608ef | 2016-08-23 16:51:19 -0700 | [diff] [blame] | 701 | image_name = '{}{}:{}'.format(prefix, Quagga.IMAGE, tag) |
| 702 | Quagga.build_image(image_name) |
A.R Karthick | 95d044e | 2016-06-10 18:44:36 -0700 | [diff] [blame] | 703 | |
Chetan Gaonker | 503032a | 2016-05-12 12:06:29 -0700 | [diff] [blame] | 704 | if args.image == 'all' or args.image == 'radius': |
A R Karthick | 07608ef | 2016-08-23 16:51:19 -0700 | [diff] [blame] | 705 | image_name = '{}{}:{}'.format(prefix, Radius.IMAGE, tag) |
| 706 | Radius.build_image(image_name) |
Chetan Gaonker | 503032a | 2016-05-12 12:06:29 -0700 | [diff] [blame] | 707 | |
| 708 | if args.image == 'all' or args.image == 'test': |
A R Karthick | 07608ef | 2016-08-23 16:51:19 -0700 | [diff] [blame] | 709 | image_name = '{}{}:{}'.format(prefix, CordTester.IMAGE, tag) |
| 710 | CordTester.build_image(image_name) |
Chetan Gaonker | 503032a | 2016-05-12 12:06:29 -0700 | [diff] [blame] | 711 | |
A R Karthick | 9a5edc4 | 2016-08-24 19:10:22 -0700 | [diff] [blame] | 712 | return 0 |
| 713 | |
A R Karthick | bec2776 | 2016-07-28 10:59:34 -0700 | [diff] [blame] | 714 | def startImages(args): |
A R Karthick | bec2776 | 2016-07-28 10:59:34 -0700 | [diff] [blame] | 715 | ##starts the latest ONOS image |
A R Karthick | 07608ef | 2016-08-23 16:51:19 -0700 | [diff] [blame] | 716 | onos_cnt = {'tag': 'latest'} |
| 717 | image_names = args.onos.rsplit(':', 1) |
| 718 | onos_cnt['image'] = image_names[0] |
| 719 | if len(image_names) > 1: |
| 720 | if image_names[1].find('/') < 0: |
| 721 | onos_cnt['tag'] = image_names[1] |
| 722 | else: |
| 723 | #tag cannot have slashes |
| 724 | onos_cnt['image'] = args.onos |
| 725 | |
A R Karthick | bec2776 | 2016-07-28 10:59:34 -0700 | [diff] [blame] | 726 | if args.image == 'all' or args.image == 'onos': |
A R Karthick | 07608ef | 2016-08-23 16:51:19 -0700 | [diff] [blame] | 727 | onos = Onos(image = onos_cnt['image'], tag = onos_cnt['tag']) |
A R Karthick | bec2776 | 2016-07-28 10:59:34 -0700 | [diff] [blame] | 728 | print('ONOS started with ip %s' %(onos.ip())) |
| 729 | |
| 730 | if args.image == 'all' or args.image == 'quagga': |
A R Karthick | 07608ef | 2016-08-23 16:51:19 -0700 | [diff] [blame] | 731 | quagga = Quagga(prefix = args.prefix) |
A R Karthick | bec2776 | 2016-07-28 10:59:34 -0700 | [diff] [blame] | 732 | print('Quagga started with ip %s' %(quagga.ip())) |
| 733 | |
| 734 | if args.image == 'all' or args.image == 'radius': |
A R Karthick | 07608ef | 2016-08-23 16:51:19 -0700 | [diff] [blame] | 735 | radius = Radius(prefix = args.prefix) |
A R Karthick | bec2776 | 2016-07-28 10:59:34 -0700 | [diff] [blame] | 736 | print('Radius started with ip %s' %(radius.ip())) |
| 737 | |
A R Karthick | 9a5edc4 | 2016-08-24 19:10:22 -0700 | [diff] [blame] | 738 | return 0 |
| 739 | |
Chetan Gaonker | 93e302d | 2016-04-05 10:51:07 -0700 | [diff] [blame] | 740 | if __name__ == '__main__': |
Chetan Gaonker | 678743f | 2016-04-26 09:54:31 -0700 | [diff] [blame] | 741 | parser = ArgumentParser(description='Cord Tester') |
Chetan Gaonker | 503032a | 2016-05-12 12:06:29 -0700 | [diff] [blame] | 742 | subparser = parser.add_subparsers() |
| 743 | parser_run = subparser.add_parser('run', help='Run cord tester') |
| 744 | parser_run.add_argument('-t', '--test-type', default=test_type_default, help='Specify test type or test case to run') |
| 745 | parser_run.add_argument('-o', '--onos', default=onos_image_default, type=str, help='ONOS container image') |
Chetan Gaonker | 503032a | 2016-05-12 12:06:29 -0700 | [diff] [blame] | 746 | parser_run.add_argument('-q', '--quagga',action='store_true',help='Provision quagga container for vrouter') |
| 747 | parser_run.add_argument('-a', '--app', default=onos_app_file, type=str, help='Cord ONOS app filename') |
A R Karthick | 07608ef | 2016-08-23 16:51:19 -0700 | [diff] [blame] | 748 | parser_run.add_argument('-l', '--olt', action='store_true', help='Use OLT config') |
Chetan Gaonker | 503032a | 2016-05-12 12:06:29 -0700 | [diff] [blame] | 749 | parser_run.add_argument('-e', '--test-controller', default='', type=str, help='External test controller ip for Onos and/or radius server. ' |
Chetan Gaonker | 5209fe8 | 2016-04-19 10:09:53 -0700 | [diff] [blame] | 750 | 'Eg: 10.0.0.2/10.0.0.3 to specify ONOS and Radius ip to connect') |
A R Karthick | 81acbff | 2016-06-17 14:45:16 -0700 | [diff] [blame] | 751 | parser_run.add_argument('-r', '--server', default=cord_test_server_address, type=str, |
| 752 | help='ip:port address to connect for cord test server for container requests') |
Chetan Gaonker | 503032a | 2016-05-12 12:06:29 -0700 | [diff] [blame] | 753 | parser_run.add_argument('-k', '--keep', action='store_true', help='Keep test container after tests') |
| 754 | parser_run.add_argument('-s', '--start-switch', action='store_true', help='Start OVS when running under OLT config') |
| 755 | parser_run.add_argument('-u', '--update', default='none', choices=['test','quagga','radius', 'all'], type=str, help='Update cord tester container images. ' |
| 756 | 'Eg: --update=quagga to rebuild quagga image.' |
| 757 | ' --update=radius to rebuild radius server image.' |
| 758 | ' --update=test to rebuild cord test image.(Default)' |
| 759 | ' --update=all to rebuild all cord tester images.') |
A R Karthick | 1f03e91 | 2016-05-18 11:39:22 -0700 | [diff] [blame] | 760 | parser_run.add_argument('-n', '--num-containers', default=1, type=int, |
| 761 | help='Specify number of test containers to spawn for tests') |
A R Karthick | a013a27 | 2016-08-16 16:40:19 -0700 | [diff] [blame] | 762 | parser_run.add_argument('-c', '--container', default='', type=str, help='Test container name for running tests') |
A R Karthick | 07608ef | 2016-08-23 16:51:19 -0700 | [diff] [blame] | 763 | parser_run.add_argument('-m', '--manifest', default='', type=str, help='Provide test configuration manifest') |
| 764 | parser_run.add_argument('-p', '--prefix', default='', type=str, help='Provide container image prefix') |
| 765 | parser_run.add_argument('-d', '--no-switch', action='store_true', help='Dont start test switch.') |
| 766 | parser_run.add_argument('-i', '--identity-file', default=identity_file_default, |
| 767 | type=str, help='ssh identity file to access compute nodes from test container') |
Chetan Gaonker | 503032a | 2016-05-12 12:06:29 -0700 | [diff] [blame] | 768 | parser_run.set_defaults(func=runTest) |
| 769 | |
A R Karthick | 81acbff | 2016-06-17 14:45:16 -0700 | [diff] [blame] | 770 | |
| 771 | parser_setup = subparser.add_parser('setup', help='Setup cord tester environment') |
| 772 | parser_setup.add_argument('-o', '--onos', default=onos_image_default, type=str, help='ONOS container image') |
| 773 | parser_setup.add_argument('-r', '--server', default=cord_test_server_address, type=str, |
| 774 | help='ip:port address for cord test server to listen for container restart requests') |
| 775 | parser_setup.add_argument('-q', '--quagga',action='store_true',help='Provision quagga container for vrouter') |
| 776 | parser_setup.add_argument('-a', '--app', default=onos_app_file, type=str, help='Cord ONOS app filename') |
| 777 | parser_setup.add_argument('-e', '--test-controller', default='', type=str, help='External test controller ip for Onos and/or radius server. ' |
| 778 | 'Eg: 10.0.0.2/10.0.0.3 to specify ONOS and Radius ip to connect') |
| 779 | parser_setup.add_argument('-u', '--update', default='none', choices=['quagga','radius', 'all'], type=str, help='Update cord tester container images. ' |
| 780 | 'Eg: --update=quagga to rebuild quagga image.' |
| 781 | ' --update=radius to rebuild radius server image.' |
| 782 | ' --update=all to rebuild all cord tester images.') |
A R Karthick | 92a0e5a | 2016-06-22 17:11:05 -0700 | [diff] [blame] | 783 | parser_setup.add_argument('-d', '--dont-provision', action='store_true', help='Dont start test container.') |
A R Karthick | 07608ef | 2016-08-23 16:51:19 -0700 | [diff] [blame] | 784 | parser_setup.add_argument('-l', '--olt', action='store_true', help='Use OLT config') |
A R Karthick | 92a0e5a | 2016-06-22 17:11:05 -0700 | [diff] [blame] | 785 | parser_setup.add_argument('-s', '--start-switch', action='store_true', help='Start OVS when running under OLT config') |
A R Karthick | d44cea1 | 2016-07-20 12:16:41 -0700 | [diff] [blame] | 786 | parser_setup.add_argument('-c', '--onos-cord', default='', type=str, |
| 787 | help='Specify cord location for ONOS cord when running on podd') |
A R Karthick | 07608ef | 2016-08-23 16:51:19 -0700 | [diff] [blame] | 788 | parser_setup.add_argument('-m', '--manifest', default='', type=str, help='Provide test configuration manifest') |
| 789 | parser_setup.add_argument('-p', '--prefix', default='', type=str, help='Provide container image prefix') |
| 790 | parser_setup.add_argument('-i', '--identity-file', default=identity_file_default, |
| 791 | type=str, help='ssh identity file to access compute nodes from test container') |
A R Karthick | 81acbff | 2016-06-17 14:45:16 -0700 | [diff] [blame] | 792 | parser_setup.set_defaults(func=setupCordTester) |
| 793 | |
Chetan Gaonker | 503032a | 2016-05-12 12:06:29 -0700 | [diff] [blame] | 794 | parser_list = subparser.add_parser('list', help='List test cases') |
| 795 | parser_list.add_argument('-t', '--test', default='all', help='Specify test type to list test cases. ' |
| 796 | 'Eg: -t tls to list tls test cases.' |
| 797 | ' -t tls-dhcp-vrouter to list tls,dhcp and vrouter test cases.' |
| 798 | ' -t all to list all test cases.') |
| 799 | parser_list.set_defaults(func=listTests) |
| 800 | |
| 801 | parser_build = subparser.add_parser('build', help='Build cord test container images') |
| 802 | parser_build.add_argument('image', choices=['quagga', 'radius', 'test', 'all']) |
A R Karthick | 07608ef | 2016-08-23 16:51:19 -0700 | [diff] [blame] | 803 | parser_build.add_argument('-p', '--prefix', default='', type=str, help='Provide container image prefix') |
Chetan Gaonker | 503032a | 2016-05-12 12:06:29 -0700 | [diff] [blame] | 804 | parser_build.set_defaults(func=buildImages) |
| 805 | |
A R Karthick | bec2776 | 2016-07-28 10:59:34 -0700 | [diff] [blame] | 806 | parser_start = subparser.add_parser('start', help='Start cord tester containers') |
A R Karthick | 07608ef | 2016-08-23 16:51:19 -0700 | [diff] [blame] | 807 | parser_start.add_argument('-p', '--prefix', default='', type=str, help='Provide container image prefix') |
| 808 | parser_start.add_argument('-o', '--onos', default=onos_image_default, type=str, help='ONOS container image') |
A R Karthick | bec2776 | 2016-07-28 10:59:34 -0700 | [diff] [blame] | 809 | parser_start.add_argument('image', choices=['onos', 'quagga', 'radius', 'all']) |
| 810 | parser_start.set_defaults(func=startImages) |
| 811 | |
Chetan Gaonker | 503032a | 2016-05-12 12:06:29 -0700 | [diff] [blame] | 812 | parser_cleanup = subparser.add_parser('cleanup', help='Cleanup test containers') |
A R Karthick | 07608ef | 2016-08-23 16:51:19 -0700 | [diff] [blame] | 813 | parser_cleanup.add_argument('-p', '--prefix', default='', type=str, help='Provide container image prefix') |
| 814 | parser_cleanup.add_argument('-l', '--olt', action = 'store_true', help = 'Cleanup OLT config') |
Chetan Gaonker | 503032a | 2016-05-12 12:06:29 -0700 | [diff] [blame] | 815 | parser_cleanup.set_defaults(func=cleanupTests) |
| 816 | |
Chetan Gaonker | 93e302d | 2016-04-05 10:51:07 -0700 | [diff] [blame] | 817 | args = parser.parse_args() |
A R Karthick | 9a5edc4 | 2016-08-24 19:10:22 -0700 | [diff] [blame] | 818 | res = args.func(args) |
| 819 | sys.exit(res) |