Test-DhcpL2Relay:
Added a module to automate testing of dhcp layer 2 relay.
Updated apps in cord tester with dhcpl2relay-1.0.0.oar and sadis-app-1.0.0-SNAPSHOT.oar
Change-Id: I04cdd3e259e654f3fd9b90a1a2f2bcdbfd2625a1
diff --git a/src/test/apps/dhcpl2relay-1.0.0.oar b/src/test/apps/dhcpl2relay-1.0.0.oar
new file mode 100644
index 0000000..7de11dc
--- /dev/null
+++ b/src/test/apps/dhcpl2relay-1.0.0.oar
Binary files differ
diff --git a/src/test/apps/sadis-app-1.0.0-SNAPSHOT.oar b/src/test/apps/sadis-app-1.0.0-SNAPSHOT.oar
new file mode 100644
index 0000000..3f59f5a
--- /dev/null
+++ b/src/test/apps/sadis-app-1.0.0-SNAPSHOT.oar
Binary files differ
diff --git a/src/test/dhcpl2relay/__init__.py b/src/test/dhcpl2relay/__init__.py
new file mode 100644
index 0000000..038b5c8
--- /dev/null
+++ b/src/test/dhcpl2relay/__init__.py
@@ -0,0 +1,44 @@
+
+# Copyright 2017-present Open Networking Foundation
+#
+# 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.
+
+
+#
+# Copyright 2016-present Ciena 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 os,sys
+import logging
+logging.getLogger('scapy.runtime').setLevel(logging.ERROR)
+##add the python path to lookup the utils
+working_dir = os.path.dirname(os.path.realpath(sys.argv[-1]))
+utils_dir = os.path.join(working_dir, '../utils')
+fsm_dir = os.path.join(working_dir, '../fsm')
+subscriber_dir = os.path.join(working_dir, '../subscriber')
+__path__.append(utils_dir)
+__path__.append(fsm_dir)
+__path__.append(subscriber_dir)
+cli_dir = os.path.join(working_dir, '../cli')
+__path__.append(cli_dir)
diff --git a/src/test/dhcpl2relay/dhcpl2relayTest.py b/src/test/dhcpl2relay/dhcpl2relayTest.py
new file mode 100644
index 0000000..24130bb
--- /dev/null
+++ b/src/test/dhcpl2relay/dhcpl2relayTest.py
@@ -0,0 +1,1426 @@
+
+# Copyright 2017-present Open Networking Foundation
+#
+# 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.
+
+
+#
+# Copyright 2016-present Ciena 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 AeY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+import unittest
+from nose.tools import *
+from nose.twistedtools import reactor, deferred
+from twisted.internet import defer
+import time
+import os, sys
+from DHCP import DHCPTest
+from CordTestUtils import get_mac, log_test
+from OnosCtrl import OnosCtrl
+from OltConfig import OltConfig
+from CordTestServer import cord_test_onos_restart
+from CordLogger import CordLogger
+from portmaps import g_subscriber_port_map
+import threading, random
+from threading import current_thread
+log_test.setLevel('INFO')
+
+class dhcpl2relay_exchange(CordLogger):
+
+ app = 'org.opencord.dhcpl2relay'
+ sadis_app = 'org.opencord.sadis'
+ app_dhcp = 'org.onosproject.dhcp'
+ relay_interfaces_last = ()
+ interface_to_mac_map = {}
+ host_ip_map = {}
+ test_path = os.path.dirname(os.path.realpath(__file__))
+ dhcp_data_dir = os.path.join(test_path, '..', 'setup')
+ olt_conf_file = os.getenv('OLT_CONFIG_FILE', os.path.join(test_path, '..', 'setup/olt_config.json'))
+ default_config = { 'default-lease-time' : 600, 'max-lease-time' : 7200, }
+ default_options = [ ('subnet-mask', '255.255.255.0'),
+ ('broadcast-address', '192.168.1.255'),
+ ('domain-name-servers', '192.168.1.1'),
+ ('domain-name', '"mydomain.cord-tester"'),
+ ]
+ default_subnet_config = [ ('192.168.1.2',
+'''
+subnet 192.168.1.0 netmask 255.255.255.0 {
+ range 192.168.1.10 192.168.1.100;
+}
+'''), ]
+
+ lock = threading.Condition()
+ ip_count = 0
+ failure_count = 0
+ start_time = 0
+ diff = 0
+
+ transaction_count = 0
+ transactions = 0
+ running_time = 0
+ total_success = 0
+ total_failure = 0
+ #just in case we want to reset ONOS to default network cfg after relay tests
+ onos_restartable = bool(int(os.getenv('ONOS_RESTART', 0)))
+ configs = {}
+
+ @classmethod
+ def setUpClass(cls):
+ ''' Activate the cord dhcpl2relay app'''
+ OnosCtrl(cls.app_dhcp).deactivate()
+ time.sleep(3)
+ cls.onos_ctrl = OnosCtrl(cls.app)
+ status, _ = cls.onos_ctrl.activate()
+ assert_equal(status, True)
+ time.sleep(3)
+ cls.onos_ctrl = OnosCtrl(cls.sadis_app)
+ status, _ = cls.onos_ctrl.activate()
+ assert_equal(status, True)
+ time.sleep(3)
+ cls.dhcp_l2_relay_setup()
+ ##start dhcpd initially with default config
+ cls.dhcpd_start()
+
+ @classmethod
+ def tearDownClass(cls):
+ '''Deactivate the cord dhcpl2relay app'''
+ try:
+ os.unlink('{}/dhcpd.conf'.format(cls.dhcp_data_dir))
+ os.unlink('{}/dhcpd.leases'.format(cls.dhcp_data_dir))
+ except: pass
+ cls.onos_ctrl.deactivate()
+ cls.dhcpd_stop()
+ cls.dhcp_l2_relay_cleanup()
+
+ @classmethod
+ def dhcp_l2_relay_setup(cls):
+ did = OnosCtrl.get_device_id()
+ cls.relay_device_id = did
+ cls.olt = OltConfig(olt_conf_file = cls.olt_conf_file)
+ cls.port_map, _ = cls.olt.olt_port_map()
+ if cls.port_map:
+ ##Per subscriber, we use 1 relay port
+ try:
+ relay_port = cls.port_map[cls.port_map['relay_ports'][0]]
+ except:
+ relay_port = cls.port_map['uplink']
+ cls.relay_interface_port = relay_port
+ cls.relay_interfaces = (cls.port_map[cls.relay_interface_port],)
+ else:
+ cls.relay_interface_port = 100
+ cls.relay_interfaces = (g_subscriber_port_map[cls.relay_interface_port],)
+ cls.relay_interfaces_last = cls.relay_interfaces
+ if cls.port_map:
+ ##generate a ip/mac client virtual interface config for onos
+ interface_list = []
+ for port in cls.port_map['ports']:
+ port_num = cls.port_map[port]
+ if port_num == cls.port_map['uplink']:
+ continue
+ ip = cls.get_host_ip(port_num)
+ mac = cls.get_mac(port)
+ interface_list.append((port_num, ip, mac))
+
+ #configure dhcp server virtual interface on the same subnet as first client interface
+ relay_ip = cls.get_host_ip(interface_list[0][0])
+ relay_mac = cls.get_mac(cls.port_map[cls.relay_interface_port])
+ interface_list.append((cls.relay_interface_port, relay_ip, relay_mac))
+ cls.onos_interface_load(interface_list)
+
+ @classmethod
+ def dhcp_l2_relay_cleanup(cls):
+ ##reset the ONOS port configuration back to default
+ for config in cls.configs.items():
+ OnosCtrl.delete(config)
+ # if cls.onos_restartable is True:
+ # log_test.info('Cleaning up dhcp relay config by restarting ONOS with default network cfg')
+ # return cord_test_onos_restart(config = {})
+
+ @classmethod
+ def onos_load_config(cls, config):
+ status, code = OnosCtrl.config(config)
+ if status is False:
+ log_test.info('JSON request returned status %d' %code)
+ assert_equal(status, True)
+ time.sleep(3)
+
+ @classmethod
+ def onos_interface_load(cls, interface_list):
+ interface_dict = { 'ports': {} }
+ for port_num, ip, mac in interface_list:
+ port_map = interface_dict['ports']
+ port = '{}/{}'.format(cls.relay_device_id, port_num)
+ port_map[port] = { 'interfaces': [] }
+ interface_list = port_map[port]['interfaces']
+ interface_map = { 'ips' : [ '{}/{}'.format(ip, 24) ],
+ 'mac' : mac,
+ 'name': 'vir-{}'.format(port_num)
+ }
+ interface_list.append(interface_map)
+
+ cls.onos_load_config(interface_dict)
+ cls.configs['interface_config'] = interface_dict
+
+ @classmethod
+ def cord_l2_relay_load(cls):
+ relay_device_id = '{}'.format(cls.relay_device_id)
+ dhcp_dict = {'apps':{'org.opencord.dhcpl2relay':{'dhcpl2relay':
+ {'dhcpserverConnectPoint':[relay_device_id]}
+ }
+ }
+ }
+ cls.onos_load_config(dhcp_dict)
+ cls.configs['relay_config'] = dhcp_dict
+
+ @classmethod
+ def cord_sadis_load(cls):
+ relay_device_id = '{}'.format(cls.relay_device_id)
+ sadis_dict = {'apps':{ "org.opencord.sadis" : {
+ "sadis" : {
+ "integration" : {
+ "cache" : {
+ "enabled" : true,
+ "maxsize" : 50,
+ "ttl" : "PT1m"
+ }
+ },
+ "entries" : [ {
+ "id" : "uni-254", # (This is an entry for a subscriber) Same as the portName of the Port as seen in onos ports command
+ "cTag" : 202, # C-tag of the subscriber
+ "sTag" : 222, # S-tag of the subscriber
+ "nasPortId" : "uni-254" # NAS Port Id of the subscriber, could be different from the id above
+ }, {
+ "id" : "eaf78b733390456d80fb24113f5150fd", # (This is an entry for an OLT device) Same as the serial of the OLT logical device as seen in the onos devices command
+ "hardwareIdentifier" : "00:1b:22:00:b1:78", # MAC address to be used for this OLT
+ "ipAddress" : "192.168.1.252", # IP address to be used for this OLT
+ "nasId" : "B100-NASID", # NAS ID to be used for this OLT
+ "circuitId" : "",
+ "remoteId" : ""
+ } ]
+ }
+ }
+ }
+ }
+ cls.onos_load_config(sadis_dict)
+ cls.configs['relay_config'] = sadis_dict
+
+ @classmethod
+ def get_host_ip(cls, port):
+ if cls.host_ip_map.has_key(port):
+ return cls.host_ip_map[port]
+ cls.host_ip_map[port] = '192.168.1.{}'.format(port)
+ return cls.host_ip_map[port]
+
+ @classmethod
+ def host_load(cls, iface):
+ '''Have ONOS discover the hosts for dhcp-relay responses'''
+ port = g_subscriber_port_map[iface]
+ host = '173.17.1.{}'.format(port)
+ cmds = ( 'ifconfig {} 0'.format(iface),
+ 'ifconfig {0} {1}'.format(iface, host),
+ 'arping -I {0} {1} -c 2'.format(iface, host),
+ 'ifconfig {} 0'.format(iface), )
+ for c in cmds:
+ os.system(c)
+
+ @classmethod
+ def dhcpd_conf_generate(cls, config = default_config, options = default_options,
+ subnet = default_subnet_config):
+ conf = ''
+ for k, v in config.items():
+ conf += '{} {};\n'.format(k, v)
+
+ opts = ''
+ for k, v in options:
+ opts += 'option {} {};\n'.format(k, v)
+
+ subnet_config = ''
+ for _, v in subnet:
+ subnet_config += '{}\n'.format(v)
+
+ return '{}{}{}'.format(conf, opts, subnet_config)
+
+ @classmethod
+ def dhcpd_start(cls, intf_list = None,
+ config = default_config, options = default_options,
+ subnet = default_subnet_config):
+ '''Start the dhcpd server by generating the conf file'''
+ if intf_list is None:
+ intf_list = cls.relay_interfaces
+ ##stop dhcpd if already running
+ cls.dhcpd_stop()
+ dhcp_conf = cls.dhcpd_conf_generate(config = config, options = options,
+ subnet = subnet)
+ ##first touch dhcpd.leases if it doesn't exist
+ lease_file = '{}/dhcpd.leases'.format(cls.dhcp_data_dir)
+ if os.access(lease_file, os.F_OK) is False:
+ with open(lease_file, 'w') as fd: pass
+
+ conf_file = '{}/dhcpd.conf'.format(cls.dhcp_data_dir)
+ with open(conf_file, 'w') as fd:
+ fd.write(dhcp_conf)
+
+ #now configure the dhcpd interfaces for various subnets
+ index = 0
+ intf_info = []
+ for ip,_ in subnet:
+ intf = intf_list[index]
+ mac = cls.get_mac(intf)
+ intf_info.append((ip, mac))
+ index += 1
+ os.system('ifconfig {} {}'.format(intf, ip))
+
+ intf_str = ','.join(intf_list)
+ dhcpd_cmd = '/usr/sbin/dhcpd -4 --no-pid -cf {0} -lf {1} {2}'.format(conf_file, lease_file, intf_str)
+ log_test.info('Starting DHCPD server with command: %s' %dhcpd_cmd)
+ ret = os.system(dhcpd_cmd)
+ assert_equal(ret, 0)
+ time.sleep(3)
+ cls.relay_interfaces_last = cls.relay_interfaces
+ cls.relay_interfaces = intf_list
+ cls.cord_l2_relay_load()
+ cls.cord_sadis_load()
+
+ @classmethod
+ def dhcpd_stop(cls):
+ os.system('pkill -9 dhcpd')
+ for intf in cls.relay_interfaces:
+ os.system('ifconfig {} 0'.format(intf))
+
+ cls.relay_interfaces = cls.relay_interfaces_last
+
+ @classmethod
+ def get_mac(cls, iface):
+ if cls.interface_to_mac_map.has_key(iface):
+ return cls.interface_to_mac_map[iface]
+ mac = get_mac(iface, pad = 0)
+ cls.interface_to_mac_map[iface] = mac
+ return mac
+
+ def stats(self,success_rate = False, only_discover = False, iface = 'veth0'):
+
+ self.ip_count = 0
+ self.failure_count = 0
+ self.start_time = 0
+ self.diff = 0
+ self.transaction_count = 0
+
+ mac = self.get_mac(iface)
+ self.host_load(iface)
+ ##we use the defaults for this test that serves as an example for others
+ ##You don't need to restart dhcpd server if retaining default config
+ config = self.default_config
+ options = self.default_options
+ subnet = self.default_subnet_config
+ dhcpd_interface_list = self.relay_interfaces
+ self.dhcpd_start(intf_list = dhcpd_interface_list,
+ config = config,
+ options = options,
+ subnet = subnet)
+ self.dhcp = DHCPTest(seed_ip = '182.17.0.1', iface = iface)
+ self.start_time = time.time()
+
+ while self.diff <= 60:
+
+ if only_discover:
+ cip, sip, mac, _ = self.dhcp.only_discover(multiple = True)
+ log_test.info('Got dhcp client IP %s from server %s for mac %s' %
+ (cip, sip, mac))
+ else:
+ cip, sip = self.send_recv(mac=mac, update_seed = True, validate = False)
+
+ if cip:
+ self.ip_count +=1
+ elif cip == None:
+ self.failure_count += 1
+ log_test.info('Failed to get ip')
+ if success_rate and self.ip_count > 0:
+ break
+
+ self.diff = round(time.time() - self.start_time, 0)
+
+ self.transaction_count = round((self.ip_count+self.failure_count)/self.diff, 2)
+ self.transactions += (self.ip_count+self.failure_count)
+ self.running_time += self.diff
+ self.total_success += self.ip_count
+ self.total_failure += self.failure_count
+
+ def send_recv(self, mac=None, update_seed = False, validate = True):
+ cip, sip = self.dhcp.discover(mac = mac, update_seed = update_seed)
+ if validate:
+ assert_not_equal(cip, None)
+ assert_not_equal(sip, None)
+ log_test.info('Got dhcp client IP %s from server %s for mac %s' %
+ (cip, sip, self.dhcp.get_mac(cip)[0]))
+ return cip,sip
+
+ def test_dhcpl2relay_with_one_request(self, iface = 'veth0'):
+ mac = self.get_mac(iface)
+ self.host_load(iface)
+ ##we use the defaults for this test that serves as an example for others
+ ##You don't need to restart dhcpd server if retaining default config
+ config = self.default_config
+ options = self.default_options
+ subnet = self.default_subnet_config
+ dhcpd_interface_list = self.relay_interfaces
+ self.dhcpd_start(intf_list = dhcpd_interface_list,
+ config = config,
+ options = options,
+ subnet = subnet)
+ self.dhcp = DHCPTest(seed_ip = '10.10.10.1', iface = iface)
+ self.send_recv(mac=mac)
+
+ def test_dhcpl2relay_for_one_request_with_invalid_source_mac_broadcast(self, iface = 'veth0'):
+ mac = self.get_mac(iface)
+ self.host_load(iface)
+ ##we use the defaults for this test that serves as an example for others
+ ##You don't need to restart dhcpd server if retaining default config
+ config = self.default_config
+ options = self.default_options
+ subnet = self.default_subnet_config
+ dhcpd_interface_list = self.relay_interfaces
+ self.dhcpd_start(intf_list = dhcpd_interface_list,
+ config = config,
+ options = options,
+ subnet = subnet)
+ self.dhcp = DHCPTest(seed_ip = '10.10.10.1', iface = iface)
+ cip, sip, mac, _ = self.dhcp.only_discover(mac='ff:ff:ff:ff:ff:ff')
+ assert_equal(cip,None)
+ log_test.info('dhcp server rejected client discover with invalid source mac, as expected')
+
+ def test_dhcpl2relay_for_one_request_with_invalid_source_mac_multicast(self, iface = 'veth0'):
+ mac = self.get_mac(iface)
+ self.host_load(iface)
+ ##we use the defaults for this test that serves as an example for others
+ ##You don't need to restart dhcpd server if retaining default config
+ config = self.default_config
+ options = self.default_options
+ subnet = self.default_subnet_config
+ dhcpd_interface_list = self.relay_interfaces
+ self.dhcpd_start(intf_list = dhcpd_interface_list,
+ config = config,
+ options = options,
+ subnet = subnet)
+ self.dhcp = DHCPTest(seed_ip = '10.10.10.1', iface = iface)
+ cip, sip, mac, _ = self.dhcp.only_discover(mac='01:80:c2:01:98:05')
+ assert_equal(cip,None)
+ log_test.info('dhcp server rejected client discover with invalid source mac, as expected')
+
+ def test_dhcpl2relay_for_one_request_with_invalid_source_mac_zero(self, iface = 'veth0'):
+ mac = self.get_mac(iface)
+ self.host_load(iface)
+ ##we use the defaults for this test that serves as an example for others
+ ##You don't need to restart dhcpd server if retaining default config
+ config = self.default_config
+ options = self.default_options
+ subnet = self.default_subnet_config
+ dhcpd_interface_list = self.relay_interfaces
+ self.dhcpd_start(intf_list = dhcpd_interface_list,
+ config = config,
+ options = options,
+ subnet = subnet)
+ self.dhcp = DHCPTest(seed_ip = '10.10.10.1', iface = iface)
+ cip, sip, mac, _ = self.dhcp.only_discover(mac='00:00:00:00:00:00')
+ assert_equal(cip,None)
+ log_test.info('dhcp server rejected client discover with invalid source mac, as expected')
+
+ def test_dhcpl2relay_with_N_requests(self, iface = 'veth0',requests=10):
+ mac = self.get_mac(iface)
+ self.host_load(iface)
+ ##we use the defaults for this test that serves as an example for others
+ ##You don't need to restart dhcpd server if retaining default config
+ config = self.default_config
+ options = self.default_options
+ subnet = self.default_subnet_config
+ dhcpd_interface_list = self.relay_interfaces
+ self.dhcpd_start(intf_list = dhcpd_interface_list,
+ config = config,
+ options = options,
+ subnet = subnet)
+ self.dhcp = DHCPTest(seed_ip = '192.169.1.1', iface = iface)
+ ip_map = {}
+ for i in range(requests):
+ #mac = RandMAC()._fix()
+ #log_test.info('mac is %s'%mac)
+ cip, sip = self.send_recv(update_seed = True)
+ if ip_map.has_key(cip):
+ log_test.info('IP %s given out multiple times' %cip)
+ assert_equal(False, ip_map.has_key(cip))
+ ip_map[cip] = sip
+ time.sleep(1)
+
+ def test_dhcpl2relay_with_one_release(self, iface = 'veth0'):
+ mac = self.get_mac(iface)
+ self.host_load(iface)
+ ##we use the defaults for this test that serves as an example for others
+ ##You don't need to restart dhcpd server if retaining default config
+ config = self.default_config
+ options = self.default_options
+ subnet = self.default_subnet_config
+ dhcpd_interface_list = self.relay_interfaces
+ self.dhcpd_start(intf_list = dhcpd_interface_list,
+ config = config,
+ options = options,
+ subnet = subnet)
+ self.dhcp = DHCPTest(seed_ip = '10.10.100.10', iface = iface)
+ cip, sip = self.send_recv(mac=mac)
+ log_test.info('Releasing ip %s to server %s' %(cip, sip))
+ assert_equal(self.dhcp.release(cip), True)
+ log_test.info('Triggering DHCP discover again after release')
+ cip2, sip2 = self.send_recv(mac=mac)
+ log_test.info('Verifying released IP was given back on rediscover')
+ assert_equal(cip, cip2)
+ log_test.info('Test done. Releasing ip %s to server %s' %(cip2, sip2))
+ assert_equal(self.dhcp.release(cip2), True)
+
+ def test_dhcpl2relay_with_Nreleases(self, iface = 'veth0'):
+ mac = None
+ self.host_load(iface)
+ ##we use the defaults for this test that serves as an example for others
+ ##You don't need to restart dhcpd server if retaining default config
+ config = self.default_config
+ options = self.default_options
+ subnet = self.default_subnet_config
+ dhcpd_interface_list = self.relay_interfaces
+ self.dhcpd_start(intf_list = dhcpd_interface_list,
+ config = config,
+ options = options,
+ subnet = subnet)
+ self.dhcp = DHCPTest(seed_ip = '192.170.1.10', iface = iface)
+ ip_map = {}
+ for i in range(10):
+ cip, sip = self.send_recv(mac=mac, update_seed = True)
+ if ip_map.has_key(cip):
+ log_test.info('IP %s given out multiple times' %cip)
+ assert_equal(False, ip_map.has_key(cip))
+ ip_map[cip] = sip
+
+ for ip in ip_map.keys():
+ log_test.info('Releasing IP %s' %ip)
+ assert_equal(self.dhcp.release(ip), True)
+
+ ip_map2 = {}
+ log_test.info('Triggering DHCP discover again after release')
+ self.dhcp = DHCPTest(seed_ip = '192.170.1.10', iface = iface)
+ for i in range(len(ip_map.keys())):
+ cip, sip = self.send_recv(mac=mac, update_seed = True)
+ ip_map2[cip] = sip
+
+ log_test.info('Verifying released IPs were given back on rediscover')
+ if ip_map != ip_map2:
+ log_test.info('Map before release %s' %ip_map)
+ log_test.info('Map after release %s' %ip_map2)
+ assert_equal(ip_map, ip_map2)
+
+ def test_dhcpl2relay_starvation(self, iface = 'veth0'):
+ mac = self.get_mac(iface)
+ self.host_load(iface)
+ ##we use the defaults for this test that serves as an example for others
+ ##You don't need to restart dhcpd server if retaining default config
+ config = self.default_config
+ options = self.default_options
+ subnet = self.default_subnet_config
+ dhcpd_interface_list = self.relay_interfaces
+ self.dhcpd_start(intf_list = dhcpd_interface_list,
+ config = config,
+ options = options,
+ subnet = subnet)
+ self.dhcp = DHCPTest(seed_ip = '182.17.0.1', iface = iface)
+ log_test.info('Verifying 1 ')
+ count = 0
+ while True:
+ #mac = RandMAC()._fix()
+ cip, sip = self.send_recv(update_seed = True,validate = False)
+ if cip is None:
+ break
+ else:
+ count += 1
+ assert_equal(count,91)
+ log_test.info('Verifying 2 ')
+ cip, sip = self.send_recv(mac=mac, update_seed = True, validate = False)
+ assert_equal(cip, None)
+ assert_equal(sip, None)
+
+ def test_dhcpl2relay_with_same_client_and_multiple_discovers(self, iface = 'veth0'):
+ mac = self.get_mac(iface)
+ self.host_load(iface)
+ ##we use the defaults for this test that serves as an example for others
+ ##You don't need to restart dhcpd server if retaining default config
+ config = self.default_config
+ options = self.default_options
+ subnet = self.default_subnet_config
+ dhcpd_interface_list = self.relay_interfaces
+ self.dhcpd_start(intf_list = dhcpd_interface_list,
+ config = config,
+ options = options,
+ subnet = subnet)
+ self.dhcp = DHCPTest(seed_ip = '10.10.10.1', iface = iface)
+ cip, sip, mac, _ = self.dhcp.only_discover()
+ log_test.info('Got dhcp client IP %s from server %s for mac %s . Not going to send DHCPREQUEST.' %
+ (cip, sip, mac) )
+ assert_not_equal(cip, None)
+ log_test.info('Triggering DHCP discover again.')
+ new_cip, new_sip, new_mac, _ = self.dhcp.only_discover()
+ assert_equal(new_cip, cip)
+ log_test.info('got same ip to smae the client when sent discover again, as expected')
+
+ def test_dhcpl2relay_with_same_client_and_multiple_requests(self, iface = 'veth0'):
+ mac = self.get_mac(iface)
+ self.host_load(iface)
+ ##we use the defaults for this test that serves as an example for others
+ ##You don't need to restart dhcpd server if retaining default config
+ config = self.default_config
+ options = self.default_options
+ subnet = self.default_subnet_config
+ dhcpd_interface_list = self.relay_interfaces
+ self.dhcpd_start(intf_list = dhcpd_interface_list,
+ config = config,
+ options = options,
+ subnet = subnet)
+ self.dhcp = DHCPTest(seed_ip = '10.10.10.1', iface = iface)
+ log_test.info('Sending DHCP discover and DHCP request.')
+ cip, sip = self.send_recv(mac=mac)
+ mac = self.dhcp.get_mac(cip)[0]
+ log_test.info("Sending DHCP request again.")
+ new_cip, new_sip = self.dhcp.only_request(cip, mac)
+ assert_equal(new_cip, cip)
+ log_test.info('got same ip to smae the client when sent request again, as expected')
+
+ def test_dhcpl2relay_with_clients_desired_address(self, iface = 'veth0'):
+ mac = self.get_mac(iface)
+ self.host_load(iface)
+ ##we use the defaults for this test that serves as an example for others
+ ##You don't need to restart dhcpd server if retaining default config
+ config = self.default_config
+ options = self.default_options
+ subnet = self.default_subnet_config
+ dhcpd_interface_list = self.relay_interfaces
+ self.dhcpd_start(intf_list = dhcpd_interface_list,
+ config = config,
+ options = options,
+ subnet = subnet)
+ self.dhcp = DHCPTest(seed_ip = '192.168.1.31', iface = iface)
+ cip, sip, mac, _ = self.dhcp.only_discover(desired = True)
+ assert_equal(cip,self.dhcp.seed_ip)
+ log_test.info('Got dhcp client desired IP %s from server %s for mac %s as expected' %
+ (cip, sip, mac) )
+
+ def test_dhcpl2relay_with_clients_desired_address_in_out_of_pool(self, iface = 'veth0'):
+ mac = self.get_mac(iface)
+
+ self.host_load(iface)
+ ##we use the defaults for this test that serves as an example for others
+ ##You don't need to restart dhcpd server if retaining default config
+ config = self.default_config
+ options = self.default_options
+ subnet = self.default_subnet_config
+ dhcpd_interface_list = self.relay_interfaces
+ self.dhcpd_start(intf_list = dhcpd_interface_list,
+ config = config,
+ options = options,
+ subnet = subnet)
+ self.dhcp = DHCPTest(seed_ip = '20.20.20.35', iface = iface)
+ cip, sip, mac, _ = self.dhcp.only_discover(desired = True)
+ assert_not_equal(cip,None)
+ assert_not_equal(cip,self.dhcp.seed_ip)
+ log_test.info('server offered IP from its pool when requested out of pool IP, as expected')
+
+ def test_dhcpl2relay_nak_packet(self, iface = 'veth0'):
+ mac = self.get_mac(iface)
+ self.host_load(iface)
+ ##we use the defaults for this test that serves as an example for others
+ ##You don't need to restart dhcpd server if retaining default config
+ config = self.default_config
+ options = self.default_options
+ subnet = self.default_subnet_config
+ dhcpd_interface_list = self.relay_interfaces
+ self.dhcpd_start(intf_list = dhcpd_interface_list,
+ config = config,
+ options = options,
+ subnet = subnet)
+ self.dhcp = DHCPTest(seed_ip = '10.10.10.1', iface = iface)
+ cip, sip, mac, _ = self.dhcp.only_discover()
+ log_test.info('Got dhcp client IP %s from server %s for mac %s .' %
+ (cip, sip, mac) )
+ assert_not_equal(cip, None)
+ new_cip, new_sip = self.dhcp.only_request('20.20.20.31', mac)
+ assert_equal(new_cip, None)
+ log_test.info('server sent NAK packet when requested other IP than that server offered')
+
+ def test_dhcpl2relay_client_requests_with_specific_lease_time_in_discover_message(self, iface = 'veth0',lease_time=700):
+ mac = self.get_mac(iface)
+ self.host_load(iface)
+ ##we use the defaults for this test that serves as an example for others
+ ##You don't need to restart dhcpd server if retaining default config
+ config = self.default_config
+ options = self.default_options
+ subnet = self.default_subnet_config
+ dhcpd_interface_list = self.relay_interfaces
+ self.dhcpd_start(intf_list = dhcpd_interface_list,
+ config = config,
+ options = options,
+ subnet = subnet)
+ self.dhcp = DHCPTest(seed_ip = '10.10.10.70', iface = iface)
+ self.dhcp.return_option = 'lease'
+ cip, sip, mac, lval = self.dhcp.only_discover(lease_time=True,lease_value=lease_time)
+ assert_equal(lval, lease_time)
+ log_test.info('dhcp server offered IP address with client requested lease time')
+
+ def test_dhcpl2relay_client_request_after_reboot(self, iface = 'veth0'):
+ mac = self.get_mac(iface)
+ self.host_load(iface)
+ ##we use the defaults for this test that serves as an example for others
+ ##You don't need to restart dhcpd server if retaining default config
+ config = self.default_config
+ options = self.default_options
+ subnet = self.default_subnet_config
+ dhcpd_interface_list = self.relay_interfaces
+ self.dhcpd_start(intf_list = dhcpd_interface_list,
+ config = config,
+ options = options,
+ subnet = subnet)
+ self.dhcp = DHCPTest(seed_ip = '20.20.20.45', iface = iface)
+ cip, sip, mac, _ = self.dhcp.only_discover()
+ log_test.info('Got dhcp client IP %s from server %s for mac %s .' %
+ (cip, sip, mac) )
+ assert_not_equal(cip, None)
+ new_cip, new_sip = self.dhcp.only_request(cip, mac)
+ log_test.info('client rebooting...')
+ os.system('ifconfig '+iface+' down')
+ time.sleep(5)
+ os.system('ifconfig '+iface+' up')
+ new_cip2, new_sip = self.dhcp.only_request(cip, mac, cl_reboot = True)
+ assert_equal(new_cip2, cip)
+ log_test.info('client got same IP after reboot, as expected')
+
+
+ def test_dhcpl2relay_after_server_reboot(self, iface = 'veth0'):
+ mac = self.get_mac(iface)
+ self.host_load(iface)
+ ##we use the defaults for this test that serves as an example for others
+ ##You don't need to restart dhcpd server if retaining default config
+ config = self.default_config
+ options = self.default_options
+ subnet = self.default_subnet_config
+ dhcpd_interface_list = self.relay_interfaces
+ self.dhcpd_start(intf_list = dhcpd_interface_list,
+ config = config,
+ options = options,
+ subnet = subnet)
+ self.dhcp = DHCPTest(seed_ip = '20.20.20.45', iface = iface)
+ cip, sip, mac, _ = self.dhcp.only_discover()
+ log_test.info('Got dhcp client IP %s from server %s for mac %s .' %
+ (cip, sip, mac) )
+ assert_not_equal(cip, None)
+ new_cip, new_sip = self.dhcp.only_request(cip, mac)
+ log_test.info('server rebooting...')
+ self.tearDownClass()
+ new_cip, new_sip = self.dhcp.only_request(cip, mac)
+ assert_equal(new_cip,None)
+ self.setUpClass()
+ new_cip, new_sip = self.dhcp.only_request(cip, mac)
+ assert_equal(new_cip, cip)
+ log_test.info('client got same IP after server rebooted, as expected')
+
+ def test_dhcpl2relay_specific_lease_time_only_in_discover_but_not_in_request_packet(self, iface = 'veth0',lease_time=700):
+ mac = self.get_mac(iface)
+ self.host_load(iface)
+ ##we use the defaults for this test that serves as an example for others
+ ##You don't need to restart dhcpd server if retaining default config
+ config = self.default_config
+ options = self.default_options
+ subnet = self.default_subnet_config
+ dhcpd_interface_list = self.relay_interfaces
+ self.dhcpd_start(intf_list = dhcpd_interface_list,
+ config = config,
+ options = options,
+ subnet = subnet)
+ self.dhcp = DHCPTest(seed_ip = '20.20.20.45', iface = iface)
+ self.dhcp.return_option = 'lease'
+ log_test.info('Sending DHCP discover with lease time of 700')
+ cip, sip, mac, lval = self.dhcp.only_discover(lease_time = True, lease_value=lease_time)
+ assert_equal(lval,lease_time)
+ new_cip, new_sip, lval = self.dhcp.only_request(cip, mac, lease_time = True)
+ assert_equal(new_cip,cip)
+ assert_not_equal(lval, lease_time) #Negative Test Case
+ log_test.info('client requested lease time in discover packer is not seen in server ACK packet as expected')
+
+ def test_dhcpl2relay_specific_lease_time_only_in_request_but_not_in_discover_packet(self, iface = 'veth0',lease_time=800):
+ mac = self.get_mac(iface)
+ self.host_load(iface)
+ ##we use the defaults for this test that serves as an example for others
+ ##You don't need to restart dhcpd server if retaining default config
+ config = self.default_config
+ options = self.default_options
+ subnet = self.default_subnet_config
+ dhcpd_interface_list = self.relay_interfaces
+ self.dhcpd_start(intf_list = dhcpd_interface_list,
+ config = config,
+ options = options,
+ subnet = subnet)
+ self.dhcp = DHCPTest(seed_ip = '20.20.20.45', iface = iface)
+ cip, sip, mac, _ = self.dhcp.only_discover()
+ new_cip, new_sip, lval = self.dhcp.only_request(cip, mac, lease_time = True,lease_value=lease_time)
+ assert_equal(new_cip,cip)
+ assert_equal(lval, lease_time)
+ log_test.info('client requested lease time in request packet seen in servre replied ACK packet as expected')
+
+ def test_dhcpl2relay_client_renew_time(self, iface = 'veth0'):
+ mac = self.get_mac(iface)
+ self.host_load(iface)
+ ##we use the defaults for this test that serves as an example for others
+ ##You don't need to restart dhcpd server if retaining default config
+ config = self.default_config
+ new_options = [('dhcp-renewal-time', 100), ('dhcp-rebinding-time', 125)]
+ options = self.default_options + new_options
+ subnet = self.default_subnet_config
+ dhcpd_interface_list = self.relay_interfaces
+ self.dhcpd_start(intf_list = dhcpd_interface_list,
+ config = config,
+ options = options,
+ subnet = subnet)
+ self.dhcp = DHCPTest(seed_ip = '20.20.20.45', iface = iface)
+ cip, sip, mac, _ = self.dhcp.only_discover()
+ log_test.info('Got dhcp client IP %s from server %s for mac %s .' %
+ (cip, sip, mac) )
+ assert_not_equal(cip,None)
+ new_cip, new_sip, lval = self.dhcp.only_request(cip, mac, renew_time = True)
+ log_test.info('waiting for renew time..')
+ time.sleep(lval)
+ latest_cip, latest_sip = self.dhcp.only_request(new_cip, mac, unicast = True)
+ assert_equal(latest_cip, cip)
+ log_test.info('server renewed client IP when client sends request after renew time, as expected')
+
+ def test_dhcpl2relay_client_rebind_time(self, iface = 'veth0'):
+ mac = self.get_mac(iface)
+ self.host_load(iface)
+ ##we use the defaults for this test that serves as an example for others
+ ##You don't need to restart dhcpd server if retaining default config
+ config = self.default_config
+ new_options = [('dhcp-renewal-time', 100), ('dhcp-rebinding-time', 125)]
+ options = self.default_options + new_options
+ subnet = self.default_subnet_config
+ dhcpd_interface_list = self.relay_interfaces
+ self.dhcpd_start(intf_list = dhcpd_interface_list,
+ config = config,
+ options = options,
+ subnet = subnet)
+ self.dhcp = DHCPTest(seed_ip = '20.20.20.45', iface = iface)
+ cip, sip, mac, _ = self.dhcp.only_discover()
+ log_test.info('Got dhcp client IP %s from server %s for mac %s .' %
+ (cip, sip, mac) )
+ assert_not_equal(cip,None)
+ new_cip, new_sip, lval = self.dhcp.only_request(cip, mac, rebind_time = True)
+ log_test.info('waiting for rebind time..')
+ time.sleep(lval)
+ latest_cip, latest_sip = self.dhcp.only_request(new_cip, mac)
+ assert_equal(latest_cip, cip)
+ log_test.info('server renewed client IP when client sends request after rebind time, as expected')
+
+ def test_dhcpl2relay_client_expected_subnet_mask(self, iface = 'veth0'):
+ mac = self.get_mac(iface)
+ self.host_load(iface)
+ ##we use the defaults for this test that serves as an example for others
+ ##You don't need to restart dhcpd server if retaining default config
+ config = self.default_config
+ options = self.default_options
+ subnet = self.default_subnet_config
+ dhcpd_interface_list = self.relay_interfaces
+ self.dhcpd_start(intf_list = dhcpd_interface_list,
+ config = config,
+ options = options,
+ subnet = subnet)
+ self.dhcp = DHCPTest(seed_ip = '20.20.20.45', iface = iface)
+ expected_subnet = '255.255.255.0'
+ self.dhcp.return_option = 'subnet'
+
+ cip, sip, mac, subnet_mask = self.dhcp.only_discover()
+ log_test.info('Got dhcp client IP %s from server %s for mac %s .' %
+ (cip, sip, mac) )
+ assert_equal(subnet_mask,expected_subnet)
+ log_test.info('subnet mask in server offer packet is same as configured subnet mask in dhcp server')
+
+ def test_dhcpl2relay_client_sends_dhcp_request_with_wrong_subnet_mask(self, iface = 'veth0'):
+ mac = self.get_mac(iface)
+ self.host_load(iface)
+ ##we use the defaults for this test that serves as an example for others
+ ##You don't need to restart dhcpd server if retaining default config
+ config = self.default_config
+ options = self.default_options
+ subnet = self.default_subnet_config
+ dhcpd_interface_list = self.relay_interfaces
+ self.dhcpd_start(intf_list = dhcpd_interface_list,
+ config = config,
+ options = options,
+ subnet = subnet)
+ self.dhcp = DHCPTest(seed_ip = '20.20.20.45', iface = iface)
+
+ cip, sip, mac, _ = self.dhcp.only_discover()
+ log_test.info('Got dhcp client IP %s from server %s for mac %s .' %
+ (cip, sip, mac) )
+ assert_not_equal(cip,None)
+ self.dhcp.send_different_option = 'subnet'
+ new_cip, new_sip = self.dhcp.only_request(cip, mac)
+ assert_equal(new_cip, cip)
+ log_test.info("Got DHCP Ack despite of specifying wrong Subnet Mask in DHCP Request.")
+
+ def test_dhcpl2relay_client_expected_router_address(self, iface = 'veth0'):
+ mac = self.get_mac(iface)
+ self.host_load(iface)
+ ##we use the defaults for this test that serves as an example for others
+ ##You don't need to restart dhcpd server if retaining default config
+ config = self.default_config
+ config = self.default_config
+ new_options = [('routers', '20.20.20.1')]
+ options = self.default_options + new_options
+ subnet = self.default_subnet_config
+ dhcpd_interface_list = self.relay_interfaces
+ self.dhcpd_start(intf_list = dhcpd_interface_list,
+ config = config,
+ options = options,
+ subnet = subnet)
+ self.dhcp = DHCPTest(seed_ip = '20.20.20.45', iface = iface)
+ expected_router_address = '20.20.20.1'
+ self.dhcp.return_option = 'router'
+
+ cip, sip, mac, router_address_value = self.dhcp.only_discover()
+ log_test.info('Got dhcp client IP %s from server %s for mac %s .' %
+ (cip, sip, mac) )
+ assert_equal(expected_router_address, router_address_value)
+ log_test.info('router address in server offer packet is same as configured router address in dhcp server')
+
+ def test_dhcpl2relay_client_sends_dhcp_request_with_wrong_router_address(self, iface = 'veth0'):
+ mac = self.get_mac(iface)
+ self.host_load(iface)
+ ##we use the defaults for this test that serves as an example for others
+ ##You don't need to restart dhcpd server if retaining default config
+ config = self.default_config
+ options = self.default_options
+ subnet = self.default_subnet_config
+ dhcpd_interface_list = self.relay_interfaces
+ self.dhcpd_start(intf_list = dhcpd_interface_list,
+ config = config,
+ options = options,
+ subnet = subnet)
+ self.dhcp = DHCPTest(seed_ip = '20.20.20.45', iface = iface)
+
+ cip, sip, mac, _ = self.dhcp.only_discover()
+ log_test.info('Got dhcp client IP %s from server %s for mac %s .' %
+ (cip, sip, mac) )
+ assert_not_equal(cip,None)
+ self.dhcp.send_different_option = 'router'
+ new_cip, new_sip = self.dhcp.only_request(cip, mac)
+ assert_equal(new_cip, cip)
+ log_test.info("Got DHCP Ack despite of specifying wrong Router Address in DHCP Request.")
+
+ def test_dhcpl2relay_with_client_expecting_broadcast_address(self, iface = 'veth0'):
+ mac = self.get_mac(iface)
+ self.host_load(iface)
+ ##we use the defaults for this test that serves as an example for others
+ ##You don't need to restart dhcpd server if retaining default config
+ config = self.default_config
+ options = self.default_options
+ subnet = self.default_subnet_config
+ dhcpd_interface_list = self.relay_interfaces
+ self.dhcpd_start(intf_list = dhcpd_interface_list,
+ config = config,
+ options = options,
+ subnet = subnet)
+ self.dhcp = DHCPTest(seed_ip = '20.20.20.45', iface = iface)
+ expected_broadcast_address = '192.168.1.255'
+ self.dhcp.return_option = 'broadcast_address'
+
+ cip, sip, mac, broadcast_address_value = self.dhcp.only_discover()
+ log_test.info('Got dhcp client IP %s from server %s for mac %s .' %
+ (cip, sip, mac) )
+ assert_equal(expected_broadcast_address, broadcast_address_value)
+ log_test.info('broadcast address in server offer packet is same as configured broadcast address in dhcp server')
+
+ def test_dhcpl2relay_client_sends_dhcp_request_with_wrong_broadcast_address(self, iface = 'veth0'):
+ mac = self.get_mac(iface)
+ self.host_load(iface)
+ ##we use the defaults for this test that serves as an example for others
+ ##You don't need to restart dhcpd server if retaining default config
+ config = self.default_config
+ options = self.default_options
+ subnet = self.default_subnet_config
+ dhcpd_interface_list = self.relay_interfaces
+ self.dhcpd_start(intf_list = dhcpd_interface_list,
+ config = config,
+ options = options,
+ subnet = subnet)
+ self.dhcp = DHCPTest(seed_ip = '20.20.20.45', iface = iface)
+
+ cip, sip, mac, _ = self.dhcp.only_discover()
+ log_test.info('Got dhcp client IP %s from server %s for mac %s .' %
+ (cip, sip, mac) )
+ assert_not_equal(cip,None)
+ self.dhcp.send_different_option = 'broadcast_address'
+ new_cip, new_sip = self.dhcp.only_request(cip, mac)
+ assert_equal(new_cip, cip)
+ log_test.info("Got DHCP Ack despite of specifying wrong Broadcast Address in DHCP Request.")
+
+ def test_dhcpl2relay_client_expecting_dns_address(self, iface = 'veth0'):
+ mac = self.get_mac(iface)
+ self.host_load(iface)
+ ##we use the defaults for this test that serves as an example for others
+ ##You don't need to restart dhcpd server if retaining default config
+ config = self.default_config
+ options = self.default_options
+ subnet = self.default_subnet_config
+ dhcpd_interface_list = self.relay_interfaces
+ self.dhcpd_start(intf_list = dhcpd_interface_list,
+ config = config,
+ options = options,
+ subnet = subnet)
+ self.dhcp = DHCPTest(seed_ip = '20.20.20.45', iface = iface)
+ expected_dns_address = '192.168.1.1'
+ self.dhcp.return_option = 'dns'
+
+ cip, sip, mac, dns_address_value = self.dhcp.only_discover()
+ log_test.info('Got dhcp client IP %s from server %s for mac %s .' %
+ (cip, sip, mac) )
+ assert_equal(expected_dns_address, dns_address_value)
+ log_test.info('dns address in server offer packet is same as configured dns address in dhcp server')
+
+ def test_dhcpl2relay_client_sends_request_with_wrong_dns_address(self, iface = 'veth0'):
+ mac = self.get_mac(iface)
+ self.host_load(iface)
+ ##we use the defaults for this test that serves as an example for others
+ ##You don't need to restart dhcpd server if retaining default config
+ config = self.default_config
+ options = self.default_options
+ subnet = self.default_subnet_config
+ dhcpd_interface_list = self.relay_interfaces
+ self.dhcpd_start(intf_list = dhcpd_interface_list,
+ config = config,
+ options = options,
+ subnet = subnet)
+ self.dhcp = DHCPTest(seed_ip = '20.20.20.45', iface = iface)
+
+ cip, sip, mac, _ = self.dhcp.only_discover()
+ log_test.info('Got dhcp client IP %s from server %s for mac %s .' %
+ (cip, sip, mac) )
+ assert_not_equal(cip,None)
+ self.dhcp.send_different_option = 'dns'
+ new_cip, new_sip = self.dhcp.only_request(cip, mac)
+ assert_equal(new_cip, cip)
+ log_test.info("Got DHCP Ack despite of specifying wrong DNS Address in DHCP Request.")
+
+
+ def test_dhcpl2relay_transactions_per_second(self, iface = 'veth0'):
+
+ for i in range(1,4):
+ self.stats()
+ log_test.info("Statistics for run %d",i)
+ log_test.info("----------------------------------------------------------------------------------")
+ log_test.info("No. of transactions No. of successes No. of failures Running Time ")
+ log_test.info(" %d %d %d %d" %(self.ip_count+self.failure_count, self.ip_count, self.failure_count, self.diff))
+ log_test.info("----------------------------------------------------------------------------------")
+ log_test.info("No. of transactions per second in run %d:%f" %(i, self.transaction_count))
+
+ log_test.info("Final Statistics for total transactions")
+ log_test.info("----------------------------------------------------------------------------------")
+ log_test.info("Total transactions Total No. of successes Total No. of failures Running Time ")
+ log_test.info(" %d %d %d %d" %(self.transactions,
+ self.total_success, self.total_failure, self.running_time))
+ log_test.info("----------------------------------------------------------------------------------")
+ log_test.info("Average no. of transactions per second: %d", round(self.transactions/self.running_time,0))
+
+ def test_dhcpl2relay_consecutive_successes_per_second(self, iface = 'veth0'):
+
+ for i in range(1,4):
+ self.stats(success_rate = True)
+ log_test.info("Statistics for run %d",i)
+ log_test.info("----------------------------------------------------------------------------------")
+ log_test.info("No. of consecutive successful transactions Running Time ")
+ log_test.info(" %d %d " %(self.ip_count, self.diff))
+ log_test.info("----------------------------------------------------------------------------------")
+ log_test.info("No. of successful transactions per second in run %d:%f" %(i, self.transaction_count))
+ log_test.info("----------------------------------------------------------------------------------")
+
+ log_test.info("Final Statistics for total successful transactions")
+ log_test.info("----------------------------------------------------------------------------------")
+ log_test.info("Total transactions Total No. of consecutive successes Running Time ")
+ log_test.info(" %d %d %d " %(self.transactions,
+ self.total_success, self.running_time))
+ log_test.info("----------------------------------------------------------------------------------")
+ log_test.info("Average no. of consecutive successful transactions per second: %d", round(self.total_success/self.running_time,0))
+ log_test.info("----------------------------------------------------------------------------------")
+
+ def test_dhcpl2relay_with_max_clients_per_second(self, iface = 'veth0'):
+
+ for i in range(1,4):
+ self.stats(only_discover = True)
+ log_test.info("----------------------------------------------------------------------------------")
+ log_test.info("Statistics for run %d of sending only DHCP Discover",i)
+ log_test.info("----------------------------------------------------------------------------------")
+ log_test.info("No. of transactions No. of successes No. of failures Running Time ")
+ log_test.info(" %d %d %d %d" %(self.ip_count+self.failure_count, self.ip_count, self.failure_count, self.diff))
+ log_test.info("----------------------------------------------------------------------------------")
+ log_test.info("No. of clients per second in run %d:%f "
+ %(i, self.transaction_count))
+ log_test.info("----------------------------------------------------------------------------------")
+ log_test.info("Final Statistics for total transactions of sending only DHCP Discover")
+ log_test.info("----------------------------------------------------------------------------------")
+ log_test.info("Total transactions Total No. of successes Total No. of failures Running Time ")
+ log_test.info(" %d %d %d %d" %(self.transactions,
+ self.total_success, self.total_failure, self.running_time))
+ log_test.info("----------------------------------------------------------------------------------")
+ log_test.info("Average no. of clients per second: %d ",
+ round(self.transactions/self.running_time,0))
+ log_test.info("----------------------------------------------------------------------------------")
+
+ def test_dhcpl2relay_consecutive_successful_clients_per_second(self, iface = 'veth0'):
+
+ for i in range(1,4):
+ self.stats(success_rate = True, only_discover = True)
+ log_test.info("----------------------------------------------------------------------------------")
+ log_test.info("Statistics for run %d for sending only DHCP Discover",i)
+ log_test.info("----------------------------------------------------------------------------------")
+ log_test.info("No. of consecutive successful transactions Running Time ")
+ log_test.info(" %d %d " %(self.ip_count, self.diff))
+ log_test.info("----------------------------------------------------------------------------------")
+ log_test.info("No. of consecutive successful clients per second in run %d:%f" %(i, self.transaction_count))
+ log_test.info("----------------------------------------------------------------------------------")
+
+ log_test.info("Final Statistics for total successful transactions")
+ log_test.info("----------------------------------------------------------------------------------")
+ log_test.info("Total transactions Total No. of consecutive successes Running Time ")
+ log_test.info(" %d %d %d " %(self.transactions,
+ self.total_success, self.running_time))
+ log_test.info("----------------------------------------------------------------------------------")
+ log_test.info("Average no. of consecutive successful clients per second: %d", round(self.total_success/self.running_time,0))
+ log_test.info("----------------------------------------------------------------------------------")
+
+ def test_dhcpl2relay_concurrent_transactions_per_second(self, iface = 'veth0'):
+
+ config = self.default_config
+ options = self.default_options
+ subnet = [ ('192.168.1.2',
+'''
+subnet 192.168.0.0 netmask 255.255.0.0 {
+ range 192.168.1.10 192.168.2.100;
+}
+'''), ]
+
+ dhcpd_interface_list = self.relay_interfaces
+ self.dhcpd_start(intf_list = dhcpd_interface_list,
+ config = config,
+ options = options,
+ subnet = subnet)
+
+ for key in (key for key in g_subscriber_port_map if key < 100):
+ self.host_load(g_subscriber_port_map[key])
+
+ def thread_fun(i):
+ mac = self.get_mac('veth{}'.format(i))
+ cip, sip = DHCPTest(iface = 'veth{}'.format(i)).discover(mac = mac)
+ log_test.info('Got dhcp client IP %s from server %s for mac %s'%(cip, sip, mac))
+ self.lock.acquire()
+
+ if cip:
+ self.ip_count += 1
+
+ elif cip is None:
+ self.failure_count += 1
+
+ self.lock.notify_all()
+ self.lock.release()
+
+ for i in range (1,4):
+ self.ip_count = 0
+ self.failure_count = 0
+ self.start_time = 0
+ self.diff = 0
+ self.transaction_count = 0
+ self.start_time = time.time()
+
+ while self.diff <= 60:
+ t = threading.Thread(target = thread_fun, kwargs = {'i': random.randrange(0, random.randrange(1,40,1), 1)})
+ t1 = threading.Thread(target = thread_fun, kwargs = {'i': random.randrange(42, random.randrange(43,80,1), 1)})
+ t2 = threading.Thread(target = thread_fun, kwargs = {'i': random.randrange(82, random.randrange(83,120,1), 1)})
+ t3 = threading.Thread(target = thread_fun, kwargs = {'i': random.randrange(122, random.randrange(123,160,1), 1)})
+ t4 = threading.Thread(target = thread_fun, kwargs = {'i': random.randrange(162, random.randrange(163,180,1), 1)})
+ t5 = threading.Thread(target = thread_fun, kwargs = {'i': random.randrange(182, random.randrange(183,196,1), 1)})
+
+ t.start()
+ t1.start()
+ t2.start()
+ t3.start()
+ t4.start()
+ t5.start()
+
+ t.join()
+ t1.join()
+ t2.join()
+ t3.join()
+ t4.join()
+ t5.join()
+
+ self.diff = round(time.time() - self.start_time, 0)
+
+ self.transaction_count = round((self.ip_count+self.failure_count)/self.diff, 2)
+
+ self.transactions += (self.ip_count+self.failure_count)
+ self.running_time += self.diff
+ self.total_success += self.ip_count
+ self.total_failure += self.failure_count
+
+
+ log_test.info("----------------------------------------------------------------------------------")
+ log_test.info("Statistics for run %d",i)
+ log_test.info("----------------------------------------------------------------------------------")
+ log_test.info("No. of transactions No. of successes No. of failures Running Time ")
+ log_test.info(" %d %d %d %d"
+ %(self.ip_count+self.failure_count,self.ip_count, self.failure_count, self.diff))
+ log_test.info("----------------------------------------------------------------------------------")
+ log_test.info("No. of transactions per second in run %d:%f" %(i, self.transaction_count))
+ log_test.info("----------------------------------------------------------------------------------")
+
+ log_test.info("----------------------------------------------------------------------------------")
+ log_test.info("Final Statistics for total transactions")
+ log_test.info("----------------------------------------------------------------------------------")
+ log_test.info("Total transactions Total No. of successes Total No. of failures Running Time ")
+ log_test.info(" %d %d %d %d" %(self.transactions,
+ self.total_success, self.total_failure, self.running_time))
+
+ log_test.info("----------------------------------------------------------------------------------")
+ log_test.info("Average no. of transactions per second: %d", round(self.transactions/self.running_time,0))
+ log_test.info("----------------------------------------------------------------------------------")
+
+ def test_dhcpl2relay_concurrent_consecutive_successes_per_second(self, iface = 'veth0'):
+
+ config = self.default_config
+ options = self.default_options
+ subnet = [ ('192.168.1.2',
+'''
+subnet 192.168.0.0 netmask 255.255.0.0 {
+ range 192.168.1.10 192.168.2.100;
+}
+'''), ]
+
+ dhcpd_interface_list = self.relay_interfaces
+ self.dhcpd_start(intf_list = dhcpd_interface_list,
+ config = config,
+ options = options,
+ subnet = subnet)
+ failure_dir = {}
+
+ for key in (key for key in g_subscriber_port_map if key != 100):
+ self.host_load(g_subscriber_port_map[key])
+
+ def thread_fun(i, j):
+# log_test.info("Thread Name:%s",current_thread().name)
+# failure_dir[current_thread().name] = True
+ while failure_dir.has_key(current_thread().name) is False:
+ mac = RandMAC()._fix()
+ cip, sip = DHCPTest(iface = 'veth{}'.format(i)).discover(mac = mac)
+ i += 2
+ log_test.info('Got dhcp client IP %s from server %s for mac %s'%(cip, sip, mac))
+ self.lock.acquire()
+
+ if cip:
+ self.ip_count += 1
+ self.lock.notify_all()
+ self.lock.release()
+ elif cip is None:
+ self.failure_count += 1
+ failure_dir[current_thread().name] = True
+ self.lock.notify_all()
+ self.lock.release()
+ break
+# self.lock.notify_all()
+# self.lock.release()
+
+ for i in range (1,4):
+ failure_dir = {}
+ self.ip_count = 0
+ self.failure_count = 0
+ self.start_time = 0
+ self.diff = 0
+ self.transaction_count = 0
+ self.start_time = time.time()
+
+ while len(failure_dir) != 6:
+ t = threading.Thread(target = thread_fun, kwargs = {'i': 0, 'j': 2})
+ t1 = threading.Thread(target = thread_fun, kwargs = {'i': 0, 'j': 2})
+ t2 = threading.Thread(target = thread_fun, kwargs = {'i': 0, 'j': 2})
+ t3 = threading.Thread(target = thread_fun, kwargs = {'i': 0, 'j': 2})
+ t4 = threading.Thread(target = thread_fun, kwargs = {'i': 0, 'j': 2})
+ t5 = threading.Thread(target = thread_fun, kwargs = {'i': 0, 'j': 2})
+
+ t.start()
+ t1.start()
+ t2.start()
+ t3.start()
+ t4.start()
+ t5.start()
+
+ t.join()
+ t1.join()
+ t2.join()
+ t3.join()
+ t4.join()
+ t5.join()
+
+ self.diff = round(time.time() - self.start_time, 0)
+ self.transaction_count = round((self.ip_count)/self.diff, 2)
+
+ self.transactions += (self.ip_count+self.failure_count)
+ self.running_time += self.diff
+ self.total_success += self.ip_count
+ self.total_failure += self.failure_count
+
+
+ log_test.info("Statistics for run %d",i)
+ log_test.info("----------------------------------------------------------------------------------")
+ log_test.info("No. of consecutive successful transactions Running Time ")
+ log_test.info(" %d %d " %(self.ip_count, self.diff))
+ log_test.info("----------------------------------------------------------------------------------")
+ log_test.info("No. of successful transactions per second in run %d:%f" %(i, self.transaction_count))
+ log_test.info("----------------------------------------------------------------------------------")
+
+ log_test.info("Final Statistics for total successful transactions")
+ log_test.info("----------------------------------------------------------------------------------")
+ log_test.info("Total transactions Total No. of consecutive successes Running Time ")
+ log_test.info(" %d %d %d " %(self.transactions,
+ self.total_success, self.running_time))
+ log_test.info("----------------------------------------------------------------------------------")
+ log_test.info("Average no. of consecutive successful transactions per second: %d", round(self.total_success/self.running_time,2))
+ log_test.info("----------------------------------------------------------------------------------")
+
+ def test_dhcpl2relay_concurrent_clients_per_second(self, iface = 'veth0'):
+
+ config = self.default_config
+ options = self.default_options
+ subnet = [ ('192.168.1.2',
+'''
+subnet 192.168.0.0 netmask 255.255.0.0 {
+ range 192.168.1.10 192.168.2.100;
+}
+'''), ]
+
+ dhcpd_interface_list = self.relay_interfaces
+ self.dhcpd_start(intf_list = dhcpd_interface_list,
+ config = config,
+ options = options,
+ subnet = subnet)
+
+ for key in (key for key in g_subscriber_port_map if key < 100):
+ self.host_load(g_subscriber_port_map[key])
+
+ def thread_fun(i):
+# mac = self.get_mac('veth{}'.format(i))
+ cip, sip, mac, _ = DHCPTest(iface = 'veth{}'.format(i)).only_discover(mac = RandMAC()._fix())
+ log_test.info('Got dhcp client IP %s from server %s for mac %s'%(cip, sip, mac))
+ self.lock.acquire()
+
+ if cip:
+ self.ip_count += 1
+ elif cip is None:
+ self.failure_count += 1
+
+ self.lock.notify_all()
+ self.lock.release()
+
+ for i in range (1,4):
+ self.ip_count = 0
+ self.failure_count = 0
+ self.start_time = 0
+ self.diff = 0
+ self.transaction_count = 0
+ self.start_time = time.time()
+
+ while self.diff <= 60:
+ t = threading.Thread(target = thread_fun, kwargs = {'i': random.randrange(0, random.randrange(1,40,1), 1)})
+ t1 = threading.Thread(target = thread_fun, kwargs = {'i': random.randrange(42, random.randrange(43,80,1), 1)})
+ t2 = threading.Thread(target = thread_fun, kwargs = {'i': random.randrange(82, random.randrange(83,120,1), 1)})
+ t3 = threading.Thread(target = thread_fun, kwargs = {'i': random.randrange(122, random.randrange(123,160,1), 1)})
+ t4 = threading.Thread(target = thread_fun, kwargs = {'i': random.randrange(162, random.randrange(163,180,1), 1)})
+ t5 = threading.Thread(target = thread_fun, kwargs = {'i': random.randrange(182, random.randrange(183,196,1), 1)})
+
+ t.start()
+ t1.start()
+ t2.start()
+ t3.start()
+ t4.start()
+ t5.start()
+
+ t.join()
+ t1.join()
+ t2.join()
+ t3.join()
+ t4.join()
+ t5.join()
+
+ self.diff = round(time.time() - self.start_time, 0)
+ self.transaction_count = round((self.ip_count+self.failure_count)/self.diff, 2)
+ self.transactions += (self.ip_count+self.failure_count)
+ self.running_time += self.diff
+ self.total_success += self.ip_count
+ self.total_failure += self.failure_count
+
+ log_test.info("----------------------------------------------------------------------------------")
+ log_test.info("Statistics for run %d of sending only DHCP Discover",i)
+ log_test.info("----------------------------------------------------------------------------------")
+ log_test.info("No. of transactions No. of successes No. of failures Running Time ")
+ log_test.info(" %d %d %d %d" %(self.ip_count+self.failure_count, self.ip_count, self.failure_count, self.diff))
+ log_test.info("----------------------------------------------------------------------------------")
+ log_test.info("No. of clients per second in run %d:%f "
+ %(i, self.transaction_count))
+ log_test.info("----------------------------------------------------------------------------------")
+
+ log_test.info("Final Statistics for total transactions of sending only DHCP Discover")
+ log_test.info("----------------------------------------------------------------------------------")
+ log_test.info("Total transactions Total No. of successes Total No. of failures Running Time ")
+ log_test.info(" %d %d %d %d" %(self.transactions,
+ self.total_success, self.total_failure, self.running_time))
+ log_test.info("----------------------------------------------------------------------------------")
+ log_test.info("Average no. of clients per second: %d ",
+ round(self.transactions/self.running_time,0))
+ log_test.info("----------------------------------------------------------------------------------")
+
+ def test_dhcpl2relay_client_conflict(self, iface = 'veth0'):
+ mac = self.get_mac(iface)
+ self.host_load(iface)
+ self.dhcp = DHCPTest(seed_ip = '10.10.10.1', iface = iface)
+ cip, sip, mac, _ = self.dhcp.only_discover()
+ log_test.info('Got dhcp client IP %s from server %s for mac %s.' %
+ (cip, sip, mac) )
+ self.dhcp1 = DHCPTest(seed_ip = cip, iface = iface)
+ new_cip, new_sip, new_mac, _ = self.dhcp1.only_discover(desired = True)
+ new_cip, new_sip = self.dhcp1.only_request(new_cip, new_mac)
+ log_test.info('Got dhcp client IP %s from server %s for mac %s.' %
+ (new_cip, new_sip, new_mac) )
+ log_test.info("IP %s alredy consumed by mac %s." % (new_cip, new_mac))
+ log_test.info("Now sending DHCP Request for old DHCP discover.")
+ new_cip, new_sip = self.dhcp.only_request(cip, mac)
+ if new_cip is None:
+ log_test.info('Got dhcp client IP %s from server %s for mac %s.Which is expected behavior.'
+ %(new_cip, new_sip, new_mac) )
+ elif new_cip:
+ log_test.info('Got dhcp client IP %s from server %s for mac %s.Which is not expected behavior as IP %s is already consumed.'
+ %(new_cip, new_sip, new_mac, new_cip) )
+ assert_equal(new_cip, None)