def test(self):
# add dummy flows to test removal when there are already some flows in operational
self.__set_active_map(MapNames.DUMMY)
self.adder = FlowAdderThread(self, 0, self.host, self.port, self.net,
MultiTest.flows + 1, MultiTest.flows + 11)
self.adder.run()
self.__set_active_map(MapNames.TEST)
self.adder = FlowAdderThread(self, 1, self.host, self.port, self.net,
1, MultiTest.flows + 1)
self.adder.run()
# if we didn't manage to get any flows on controller there is no point doing test
assert len(MultiTest.active_map) > 0, (
'Stored flows should be greater than 0, actual is {0}'.format(
len(MultiTest.active_map)))
# check numer of flows before deletion
MultiTest.log.debug(
'{0} flows are stored by results from threads, {1} errors'.format(
len(MultiTest.active_map), MultiTest.total_errors))
MultiTest.log.debug('{0} flows are stored in controller config'.format(
self.check_config_flows(self.host, self.port, self.active_map)))
MultiTest.log.info(
'{0} flows are stored in controller operational'.format(
self.check_oper_flows_loop(self.host, self.port,
self.active_map)))
self.remover = FlowRemoverThread(self, 0, self.host, self.port,
self.net,
list(MultiTest.active_map.items()))
self.remover.run()
MultiTest.log.info(
'\n\n---------- preparation finished, running test ----------')
# check and test after deletion
flows_oper_after = self.check_oper_flows_loop(self.host, self.port,
self.active_map)
MultiTest.log.debug('{0} flows are stored in controller config'.format(
self.check_config_flows(self.host, self.port, self.active_map)))
MultiTest.log.info(
'{0} flows are stored in controller operational'.format(
flows_oper_after))
# check if we have managed to delete all test
if len(MultiTest.active_map) <> 0:
MultiTest.log.warning(
'Not all flows added during test have been deleted, ids of remaining flows are: {0}'
.format(sorted(MultiTest.active_map)))
# if we didn't manage to get any flows on controller there is no point doing test
assert flows_oper_after == len(
MultiTest.active_map
), 'Number of flows added during test stored in operational should be {0}, is {1}'.format(
len(MultiTest.active_map), flows_oper_after)
def test(self):
# add dummy flows to test removal when there are already some flows in operational
self.__set_active_map(MapNames.DUMMY)
self.adder = FlowAdderThread(self, 0, self.host, self.port, self.net, MultiTest.flows + 1, MultiTest.flows + 11)
self.adder.run()
self.__set_active_map(MapNames.TEST)
self.adder = FlowAdderThread(self, 1, self.host, self.port, self.net, 1, MultiTest.flows + 1)
self.adder.run()
# if we didn't manage to get any flows on controller there is no point doing test
assert len(MultiTest.active_map) > 0, ('Stored flows should be greater than 0, actual is {0}'.format(len(MultiTest.active_map)))
# check numer of flows before deletion
MultiTest.log.debug('{0} flows are stored by results from threads, {1} errors'.format(len(MultiTest.active_map), MultiTest.total_errors))
MultiTest.log.debug('{0} flows are stored in controller config'.format(self.check_config_flows(self.host, self.port, self.active_map)))
MultiTest.log.info('{0} flows are stored in controller operational'.format(self.check_oper_flows_loop(self.host, self.port, self.active_map)))
self.remover = FlowRemoverThread(self, 0, self.host, self.port, self.net, list(MultiTest.active_map.items()))
self.remover.run()
MultiTest.log.info('\n\n---------- preparation finished, running test ----------')
# check and test after deletion
flows_oper_after = self.check_oper_flows_loop(self.host, self.port, self.active_map)
MultiTest.log.debug('{0} flows are stored in controller config'.format(self.check_config_flows(self.host, self.port, self.active_map)))
MultiTest.log.info('{0} flows are stored in controller operational'.format(flows_oper_after))
# check if we have managed to delete all test
if len(MultiTest.active_map) <> 0:
MultiTest.log.warning('Not all flows added during test have been deleted, ids of remaining flows are: {0}'.format(sorted(MultiTest.active_map)))
# if we didn't manage to get any flows on controller there is no point doing test
assert flows_oper_after == len(MultiTest.active_map), 'Number of flows added during test stored in operational should be {0}, is {1}'.format(len(MultiTest.active_map), flows_oper_after)
def tearDown(self):
MultiTest.log.info('test cleanup...')
self.__set_active_map(MapNames.DUMMY)
self.remover = FlowRemoverThread(self, 1, self.host, self.port, self.net, list(MultiTest.active_map.items()))
self.remover.run()
for k, v in MultiTest.id_maps.items():
if len(v) > 0:
MultiTest.log.warning('not all flows were deleted, remaining test flows: {0}, from map: {1}'.format(len(v),k))
def __delete_flows(self):
flows_deleted = 0
flows_on_controller = 0
MultiTest.log.info('deleting flows added during test')
# using threads to delete to speed up cleanup
items_to_delete = list(self.active_map.items())
self.thread_pool = []
thread_id = 0
slice_from = REMOVE_FLOWS_PER_THREAD * thread_id
slice_to = REMOVE_FLOWS_PER_THREAD * (thread_id + 1)
total_flows = len(self.active_map.keys())
total_deleted = 0
while (slice_from < len(items_to_delete)):
self.thread_pool.append(
FlowRemoverThread(self, thread_id, self.host, self.port,
self.net,
items_to_delete[slice_from:slice_to]))
thread_id += 1
slice_from = REMOVE_FLOWS_PER_THREAD * thread_id
slice_to = REMOVE_FLOWS_PER_THREAD * (thread_id + 1)
for t in self.thread_pool:
t.start()
for t in self.thread_pool:
t.join()
for t in self.thread_pool:
total_deleted += t.removed
MultiTest.log.info('deleted {0} flows'.format(total_deleted))
if total_flows <> total_deleted:
raise StandardError('Not all flows have been deleted, flows added'\
' during test: {0} <> deleted flows: {1},\nflows ids left on controller: {2}'.format(\
total_flows, total_deleted, sorted(self.active_map.values())))
def __delete_flows(self):
MultiTest.log.info('deleting flows added during test')
# using threads to delete to speed up cleanup
items_to_delete = list(self.active_map.items())
self.thread_pool = []
thread_id = 0
slice_from = REMOVE_FLOWS_PER_THREAD * thread_id
slice_to = REMOVE_FLOWS_PER_THREAD * (thread_id + 1)
while (slice_from < len(items_to_delete)):
self.thread_pool.append(
FlowRemoverThread(self, thread_id, self.host, self.port,
self.net,
items_to_delete[slice_from:slice_to]))
thread_id += 1
slice_from = REMOVE_FLOWS_PER_THREAD * thread_id
slice_to = REMOVE_FLOWS_PER_THREAD * (thread_id + 1)
for t in self.thread_pool:
t.start()
for t in self.thread_pool:
t.join()
class MultiTest(unittest.TestCase):
log = logging.getLogger('MultiTest')
total_errors = 0
total_flows = 0
ids = []
def setUp(self):
MultiTest.log.info('setUp')
self.threads_count = 50
self.thread_pool = list()
self.__start_MN()
self.__setup_threads()
self.__run_threads()
def tearDown(self):
MultiTest.log.info('tearDown')
self.net.stop()
@staticmethod
def inc_error(value=1):
MultiTest.total_errors += value
@staticmethod
def inc_flow(value=1):
MultiTest.total_flows += 1
@staticmethod
def add_flow_id(flow_id=None):
if (flow_id > None) :
MultiTest.ids.append(flow_id)
def __start_MN(self):
self.net = MininetTools.create_network(self.host, self.mn_port)
self.net.start()
MultiTest.log.info('mininet stared')
MultiTest.log.info('waiting {0} seconds...'.format(WAIT_TIME))
time.sleep(WAIT_TIME)
def test(self):
# add dummy flows to test removal when there are already some flows in operational
self.__set_active_map(MapNames.DUMMY)
self.adder = FlowAdderThread(self, 0, self.host, self.port, self.net, MultiTest.flows + 1, MultiTest.flows + 11)
self.adder.run()
self.__set_active_map(MapNames.TEST)
self.adder = FlowAdderThread(self, 1, self.host, self.port, self.net, 1, MultiTest.flows + 1)
self.adder.run()
# if we didn't manage to get any flows on controller there is no point doing test
assert len(MultiTest.active_map) > 0, ('Stored flows should be greater than 0, actual is {0}'.format(len(MultiTest.active_map)))
# check numer of flows before deletion
MultiTest.log.debug('{0} flows are stored by results from threads, {1} errors'.format(len(MultiTest.active_map), MultiTest.total_errors))
MultiTest.log.debug('{0} flows are stored in controller config'.format(self.check_config_flows(self.host, self.port, self.active_map)))
MultiTest.log.info('{0} flows are stored in controller operational'.format(self.check_oper_flows_loop(self.host, self.port, self.active_map)))
self.remover = FlowRemoverThread(self, 0, self.host, self.port, self.net, list(MultiTest.active_map.items()))
self.remover.run()
MultiTest.log.info('\n\n---------- preparation finished, running test ----------')
# check and test after deletion
flows_oper_after = self.check_oper_flows_loop(self.host, self.port, self.active_map)
MultiTest.log.debug('{0} flows are stored in controller config'.format(self.check_config_flows(self.host, self.port, self.active_map)))
MultiTest.log.info('{0} flows are stored in controller operational'.format(flows_oper_after))
# check if we have managed to delete all test
if len(MultiTest.active_map) <> 0:
MultiTest.log.warning('Not all flows added during test have been deleted, ids of remaining flows are: {0}'.format(sorted(MultiTest.active_map)))
# if we didn't manage to get any flows on controller there is no point doing test
assert flows_oper_after == len(MultiTest.active_map), 'Number of flows added during test stored in operational should be {0}, is {1}'.format(len(MultiTest.active_map), flows_oper_after)
def __setup_threads(self):
if in_args.threads is not None:
self.threads_count = int(in_args.threads)
for i in range(0, self.threads_count):
#thread will have predetermined flows id to avoid using shared resource
t = FlowAdderThread(i, self.host, self.port, self.net, flows_ids_from=i*MultiTest.flows + 1, flows_ids_to=(i+1)*MultiTest.flows + 1)
self.thread_pool.append(t)
def __run_threads(self):
# start threads
for t in self.thread_pool:
t.start()
# wait for them to finish
for t in self.thread_pool:
t.join()
class MultiTest(unittest.TestCase):
log = logging.getLogger('MultiTest')
total_errors = 0
total_flows = 0
ids = []
def setUp(self):
MultiTest.log.info('setUp')
self.threads_count = 50
self.thread_pool = list()
self.__start_MN()
self.__setup_threads()
self.__run_threads()
def tearDown(self):
MultiTest.log.info('tearDown')
self.net.stop()
@staticmethod
def inc_error(value=1):
MultiTest.total_errors += value
@staticmethod
def inc_flow(value=1):
MultiTest.total_flows += 1
@staticmethod
def add_flow_id(flow_id=None):
if (flow_id > None):
MultiTest.ids.append(flow_id)
def __start_MN(self):
self.net = MininetTools.create_network(self.host, self.mn_port)
self.net.start()
MultiTest.log.info('mininet stared')
MultiTest.log.info('waiting {0} seconds...'.format(WAIT_TIME))
time.sleep(WAIT_TIME)
def test(self):
# add dummy flows to test removal when there are already some flows in operational
self.__set_active_map(MapNames.DUMMY)
self.adder = FlowAdderThread(self, 0, self.host, self.port, self.net,
MultiTest.flows + 1, MultiTest.flows + 11)
self.adder.run()
self.__set_active_map(MapNames.TEST)
self.adder = FlowAdderThread(self, 1, self.host, self.port, self.net,
1, MultiTest.flows + 1)
self.adder.run()
# if we didn't manage to get any flows on controller there is no point doing test
assert len(MultiTest.active_map) > 0, (
'Stored flows should be greater than 0, actual is {0}'.format(
len(MultiTest.active_map)))
# check numer of flows before deletion
MultiTest.log.debug(
'{0} flows are stored by results from threads, {1} errors'.format(
len(MultiTest.active_map), MultiTest.total_errors))
MultiTest.log.debug('{0} flows are stored in controller config'.format(
self.check_config_flows(self.host, self.port, self.active_map)))
MultiTest.log.info(
'{0} flows are stored in controller operational'.format(
self.check_oper_flows_loop(self.host, self.port,
self.active_map)))
self.remover = FlowRemoverThread(self, 0, self.host, self.port,
self.net,
list(MultiTest.active_map.items()))
self.remover.run()
MultiTest.log.info(
'\n\n---------- preparation finished, running test ----------')
# check and test after deletion
flows_oper_after = self.check_oper_flows_loop(self.host, self.port,
self.active_map)
MultiTest.log.debug('{0} flows are stored in controller config'.format(
self.check_config_flows(self.host, self.port, self.active_map)))
MultiTest.log.info(
'{0} flows are stored in controller operational'.format(
flows_oper_after))
# check if we have managed to delete all test
if len(MultiTest.active_map) <> 0:
MultiTest.log.warning(
'Not all flows added during test have been deleted, ids of remaining flows are: {0}'
.format(sorted(MultiTest.active_map)))
# if we didn't manage to get any flows on controller there is no point doing test
assert flows_oper_after == len(
MultiTest.active_map
), 'Number of flows added during test stored in operational should be {0}, is {1}'.format(
len(MultiTest.active_map), flows_oper_after)
def __setup_threads(self):
if in_args.threads is not None:
self.threads_count = int(in_args.threads)
for i in range(0, self.threads_count):
#thread will have predetermined flows id to avoid using shared resource
t = FlowAdderThread(i,
self.host,
self.port,
self.net,
flows_ids_from=i * MultiTest.flows + 1,
flows_ids_to=(i + 1) * MultiTest.flows + 1)
self.thread_pool.append(t)
def __run_threads(self):
# start threads
for t in self.thread_pool:
t.start()
# wait for them to finish
for t in self.thread_pool:
t.join()
class MultiTest(unittest.TestCase, TestClassAdd, TestClassRemove, CheckConfigFlowsComponent, CheckOperFlowsComponent):
log = logging.getLogger('MultiTest')
total_errors = 0
id_maps = dict()
active_map = dict()
def setUp(self):
MultiTest.log.info('test setup...')
self.__start_MN()
MultiTest.id_maps[MapNames.TEST] = dict()
MultiTest.id_maps[MapNames.DUMMY] = dict()
MultiTest.active_map = MultiTest.id_maps[MapNames.TEST]
def tearDown(self):
MultiTest.log.info('test cleanup...')
self.__set_active_map(MapNames.DUMMY)
self.remover = FlowRemoverThread(self, 1, self.host, self.port, self.net, list(MultiTest.active_map.items()))
self.remover.run()
for k, v in MultiTest.id_maps.items():
if len(v) > 0:
MultiTest.log.warning('not all flows were deleted, remaining test flows: {0}, from map: {1}'.format(len(v),k))
def __set_active_map(self, key):
try:
MultiTest.active_map = MultiTest.id_maps[key]
except KeyError as e:
MultiTest.log.warning('Error switching between map ids: {0}'.format(str(e)))
def inc_error(self, value=1):
MultiTest.total_errors += value
def inc_flow(self, flow_id= None, cookie_id=1):
if flow_id is not None and cookie_id is not None:
#we dont care about actual value, just need to store flow_id as unique identifier
MultiTest.active_map[flow_id] = flow_id
def delete_flow_from_map(self, flow_id, cookie_id=None):
del MultiTest.active_map[flow_id]
def __start_MN(self):
self.net = MininetTools.create_network(self.host, self.mn_port)
self.net.start()
MultiTest.log.info('mininet stared')
MultiTest.log.info('waiting {0} seconds...'.format(WAIT_TIME))
time.sleep(WAIT_TIME)
def test(self):
# add dummy flows to test removal when there are already some flows in operational
self.__set_active_map(MapNames.DUMMY)
self.adder = FlowAdderThread(self, 0, self.host, self.port, self.net, MultiTest.flows + 1, MultiTest.flows + 11)
self.adder.run()
self.__set_active_map(MapNames.TEST)
self.adder = FlowAdderThread(self, 1, self.host, self.port, self.net, 1, MultiTest.flows + 1)
self.adder.run()
# if we didn't manage to get any flows on controller there is no point doing test
assert len(MultiTest.active_map) > 0, ('Stored flows should be greater than 0, actual is {0}'.format(len(MultiTest.active_map)))
# check numer of flows before deletion
MultiTest.log.debug('{0} flows are stored by results from threads, {1} errors'.format(len(MultiTest.active_map), MultiTest.total_errors))
MultiTest.log.debug('{0} flows are stored in controller config'.format(self.check_config_flows(self.host, self.port, self.active_map)))
MultiTest.log.info('{0} flows are stored in controller operational'.format(self.check_oper_flows_loop(self.host, self.port, self.active_map)))
self.remover = FlowRemoverThread(self, 0, self.host, self.port, self.net, list(MultiTest.active_map.items()))
self.remover.run()
MultiTest.log.info('\n\n---------- preparation finished, running test ----------')
# check and test after deletion
flows_oper_after = self.check_oper_flows_loop(self.host, self.port, self.active_map)
MultiTest.log.debug('{0} flows are stored in controller config'.format(self.check_config_flows(self.host, self.port, self.active_map)))
MultiTest.log.info('{0} flows are stored in controller operational'.format(flows_oper_after))
# check if we have managed to delete all test
if len(MultiTest.active_map) <> 0:
MultiTest.log.warning('Not all flows added during test have been deleted, ids of remaining flows are: {0}'.format(sorted(MultiTest.active_map)))
# if we didn't manage to get any flows on controller there is no point doing test
assert flows_oper_after == len(MultiTest.active_map), 'Number of flows added during test stored in operational should be {0}, is {1}'.format(len(MultiTest.active_map), flows_oper_after)
