def CASE40(self, main): """ Randomly bring down one ONOS node """ import time import random from tests.CHOTestMonkey.dependencies.events.Event import EventType from tests.CHOTestMonkey.dependencies.EventScheduler import EventScheduleMethod main.log.report("Randomly bring down one ONOS node") main.log.report("__________________________________________________") main.case("Randomly bring down one ONOS node") main.step("Randomly bring down one ONOS node") main.caseResult = main.TRUE availableControllers = [] for controller in main.controllers: if controller.isUp(): availableControllers.append(controller.index) if len(availableControllers) == 0: main.log.warn("No available controllers") main.caseResult = main.FALSE else: index = random.sample(availableControllers, 1) main.eventGenerator.triggerEvent(EventType().ONOS_ONOS_DOWN, EventScheduleMethod().RUN_BLOCK, index[0]) with main.eventScheduler.idleCondition: while not main.eventScheduler.isIdle(): main.eventScheduler.idleCondition.wait() utilities.assert_equals(expect=main.TRUE, actual=main.caseResult, onpass="******", onfail="Randomly bring down ONOS test failed") time.sleep(int(main.params['CASE40']['sleepSec']))
def CASE21(self, main): """ Bring down/up a group of links and check topology and ping """ import time from tests.CHOTestMonkey.dependencies.events.Event import EventType from tests.CHOTestMonkey.dependencies.EventScheduler import EventScheduleMethod main.log.report( "Bring down/up a group of links and check topology and ping") main.log.report("__________________________________________________") main.case("Bring down/up a group of links and check topology and ping") main.step("Bring down/up a group of links and check topology and ping") main.caseResult = main.TRUE linkGroupSize = int(main.params['CASE21']['linkGroupSize']) linkDownDownInterval = int( main.params['CASE21']['linkDownDownInterval']) linkDownUpInterval = int(main.params['CASE21']['linkDownUpInterval']) main.eventGenerator.triggerEvent( EventType().NETWORK_LINK_GROUP_RANDOM_TOGGLE, EventScheduleMethod().RUN_BLOCK, linkGroupSize, linkDownDownInterval, linkDownUpInterval) with main.eventScheduler.idleCondition: while not main.eventScheduler.isIdle(): main.eventScheduler.idleCondition.wait() utilities.assert_equals(expect=main.TRUE, actual=main.caseResult, onpass="******", onfail="Toggle network link group test failed") time.sleep(main.caseSleep)
def CASE41(self, main): """ Randomly bring up one ONOS node that is down """ import time import random from tests.CHOTestMonkey.dependencies.events.Event import EventType from tests.CHOTestMonkey.dependencies.EventScheduler import EventScheduleMethod main.log.report("Randomly bring up one ONOS node that is down") main.log.report("__________________________________________________") main.case("Randomly bring up one ONOS node that is down") main.step("Randomly bring up one ONOS node that is down") main.caseResult = main.TRUE targetControllers = [] for controller in main.controllers: if not controller.isUp(): targetControllers.append(controller.index) if len(targetControllers) == 0: main.log.warn("All controllers are up") main.caseResult = main.FALSE else: index = random.sample(targetControllers, 1) main.eventGenerator.triggerEvent(EventType().ONOS_ONOS_UP, EventScheduleMethod().RUN_BLOCK, index[0]) with main.eventScheduler.idleCondition: while not main.eventScheduler.isIdle(): main.eventScheduler.idleCondition.wait() utilities.assert_equals(expect=main.TRUE, actual=main.caseResult, onpass="******", onfail="Randomly bring up ONOS test failed") time.sleep(main.caseSleep)
def CASE90(self, main): """ Sleep for some time """ import time from tests.CHOTestMonkey.dependencies.events.Event import EventType from tests.CHOTestMonkey.dependencies.EventScheduler import EventScheduleMethod main.log.report("Sleep for some time") main.log.report("__________________________________________________") main.case("Sleep for some time") main.step("Sleep for some time") main.caseResult = main.TRUE sleepSec = int(main.params['CASE90']['sleepSec']) main.eventGenerator.triggerEvent(EventType().TEST_SLEEP, EventScheduleMethod().RUN_BLOCK, sleepSec) with main.eventScheduler.idleCondition: while not main.eventScheduler.isIdle(): main.eventScheduler.idleCondition.wait() utilities.assert_equals(expect=main.TRUE, actual=main.caseResult, onpass="******", onfail="Sleep test failed") time.sleep(main.caseSleep)
def insertAllChecks( self, args=None ): """ Acquire eventGeneratorLock before calling this funtion """ for eventType in main.enabledEvents.keys(): if eventType < 100 and EventType().map[ eventType ].startswith( 'CHECK' ): main.eventScheduler.scheduleEvent( eventType, EventScheduleMethod().RUN_NON_BLOCK, args )
def removeAllPointIntents(self, scheduleMethod, args=None): """ This function removes point intents for all device pairs After all intent events are inserted, this funciton also insert intent and traffic checks """ import itertools with self.eventGeneratorLock: if scheduleMethod == EventScheduleMethod().RUN_BLOCK: main.eventScheduler.scheduleEvent( EventType().NULL, EventScheduleMethod().RUN_BLOCK) availableControllers = [] for controller in main.controllers: if controller.isUp(): availableControllers.append(controller.index) if len(availableControllers) == 0: main.log.warn("Event Generator - No available controllers") return deviceCombos = list(itertools.permutations(main.devices, 2)) for i in xrange(0, len(deviceCombos), len(availableControllers)): for CLIIndex in availableControllers: if i >= len(deviceCombos): break main.eventScheduler.scheduleEvent( EventType().APP_INTENT_POINT_DEL, EventScheduleMethod().RUN_NON_BLOCK, [ deviceCombos[i][0].name, deviceCombos[i][1].name, CLIIndex ]) i += 1 # Pending checks after removing all intents if scheduleMethod == EventScheduleMethod().RUN_BLOCK: main.eventScheduler.scheduleEvent( EventType().NULL, EventScheduleMethod().RUN_BLOCK) sleepTime = int(main.params['EVENT']['removeAllPointIntents'] ['sleepBeforeCheck']) main.eventScheduler.scheduleEvent(EventType().TEST_SLEEP, EventScheduleMethod().RUN_BLOCK, [sleepTime]) self.insertAllChecks(EventScheduleMethod().RUN_NON_BLOCK) if scheduleMethod == EventScheduleMethod().RUN_BLOCK: main.eventScheduler.scheduleEvent( EventType().NULL, EventScheduleMethod().RUN_BLOCK)
def randomDeviceToggle(self, scheduleMethod, args=[5], blocking=True): """ The function randomly removes a device and then adds it back After each individual device event, all checks are inserted into the scheduler param: args[0] is the average interval between device down and device up events blocking means blocking other events from being scheduled between device down and device up """ import random import time if len(args) < 1: main.log.warn( "Event Generator - Not enough arguments for randomDeviceToggle: %s" % (args)) elif len(args) > 1: main.log.warn( "Event Generator - Too many arguments for randomDeviceToggle: %s" % (args)) else: downUpAvgInterval = int(args[0]) self.eventGeneratorLock.acquire() main.eventScheduler.scheduleEvent(EventType().NETWORK_DEVICE_DOWN, scheduleMethod, ['random']) sleepTime = int( main.params['EVENT']['randomLinkToggle']['sleepBeforeCheck']) main.eventScheduler.scheduleEvent(EventType().TEST_SLEEP, EventScheduleMethod().RUN_BLOCK, [sleepTime]) self.insertAllChecks(EventScheduleMethod().RUN_NON_BLOCK) if scheduleMethod == EventScheduleMethod().RUN_BLOCK: # Insert a NULL BLOCK event main.eventScheduler.scheduleEvent(EventType().NULL, EventScheduleMethod().RUN_BLOCK) downUpInterval = abs(random.gauss(downUpAvgInterval, 1)) if not blocking: self.eventGeneratorLock.release() time.sleep(downUpInterval) self.eventGeneratorLock.acquire() else: time.sleep(downUpInterval) main.eventScheduler.scheduleEvent(EventType().NETWORK_DEVICE_UP, scheduleMethod, ['random']) main.eventScheduler.scheduleEvent(EventType().TEST_SLEEP, EventScheduleMethod().RUN_BLOCK, [sleepTime]) self.insertAllChecks(EventScheduleMethod().RUN_NON_BLOCK) if scheduleMethod == EventScheduleMethod().RUN_BLOCK: main.eventScheduler.scheduleEvent(EventType().NULL, EventScheduleMethod().RUN_BLOCK) self.eventGeneratorLock.release()
def triggerEvent( self, typeIndex, scheduleMethod, *args ): """ This function triggers an event from inside of CHOTestMonkey """ import time if typeIndex not in EventType().map.keys(): main.log.warn( "Event Generator - Unknown event type: " + str( typeIndex ) ) return if scheduleMethod not in EventScheduleMethod().map.keys(): main.log.warn( "Event Generator - Unknown event schedule method: " + str( scheduleMethod ) ) return while not main.eventScheduler.isAvailable(): time.sleep( int( main.params[ 'GENERATOR' ][ 'insertEventRetryInterval' ] ) ) self.insertEvent( typeIndex, scheduleMethod, list( args ) )
def CASE80(self, main): """ Replay events from log file """ import time from tests.CHOTestMonkey.dependencies.events.Event import EventType from tests.CHOTestMonkey.dependencies.EventScheduler import EventScheduleMethod main.log.report("Replay events from log file") main.log.report("__________________________________________________") main.case("Replay events from log file") main.step("Replay events from log file") main.caseResult = main.TRUE try: f = open(main.params['CASE80']['filePath'], 'r') for line in f.readlines(): if 'CHOTestMonkey' in line and 'Event recorded' in line: line = line.split() eventIndex = int(line[9]) eventName = line[10] args = line[11:] assert eventName.startswith( 'CHECK' )\ or eventName.startswith( 'NETWORK' )\ or eventName.startswith( 'APP' )\ or eventName.startswith( 'ONOS' ) if main.params['CASE80'][ 'skipChecks'] == 'on' and eventName.startswith( 'CHECK'): continue with main.eventScheduler.idleCondition: while not main.eventScheduler.isIdle(): main.eventScheduler.idleCondition.wait() main.eventGenerator.triggerEvent( eventIndex, EventScheduleMethod().RUN_BLOCK, *args) time.sleep(float(main.params['CASE80']['sleepTime'])) except Exception as e: print e utilities.assert_equals(expect=main.TRUE, actual=main.caseResult, onpass="******", onfail="Replay from log file failed")
def handleConnection(self, conn): """ Handle connections from event triggers """ request = conn.recv() if isinstance( request, list) and (request[0] == MessageType().EVENT_REQUEST or request[0] == MessageType().EVENT_REQUEST_DEBUG): if len(request) < 3: response = MessageType().NOT_ENOUGH_ARGUMENT elif request[0] == MessageType( ).EVENT_REQUEST and not main.eventScheduler.isAvailable(): response = MessageType().EVENT_DENIED else: typeString = str(request[1]) scheduleMethodString = str(request[2]) if len(request) > 3: args = request[3:] else: args = None for key, value in EventType().map.items(): if value == typeString: typeIndex = key break if not value == typeString: response = MessageType().UNKNOWN_EVENT_TYPE else: for key, value in EventScheduleMethod().map.items(): if value == scheduleMethodString: scheduleMethod = key break if not value == scheduleMethodString: response = MessageType().UNKNOWN_SCHEDULE_METHOD else: self.insertEvent(typeIndex, scheduleMethod, args) response = MessageType().EVENT_INSERTED else: response = MessageType().UNKNOWN_MESSAGE conn.send(response) conn.close()
def CASE51( self, main ): """ Set FlowObjective to False """ import time from tests.CHOTestMonkey.dependencies.events.Event import EventType from tests.CHOTestMonkey.dependencies.EventScheduler import EventScheduleMethod main.log.report( "Set FlowObjective to False" ) main.log.report( "__________________________________________________" ) main.case( "Set FlowObjective to False" ) main.step( "Set FlowObjective to False" ) main.caseResult = main.TRUE main.eventGenerator.triggerEvent( EventType().ONOS_SET_FLOWOBJ, EventScheduleMethod().RUN_BLOCK, 'false' ) with main.eventScheduler.idleCondition: while not main.eventScheduler.isIdle(): main.eventScheduler.idleCondition.wait() utilities.assert_equals( expect=main.TRUE, actual=main.caseResult, onpass="******", onfail="Set FlowObjective test failed" ) time.sleep( main.caseSleep )
def CASE60( self, main ): """ Balance device masters """ import time from tests.CHOTestMonkey.dependencies.events.Event import EventType from tests.CHOTestMonkey.dependencies.EventScheduler import EventScheduleMethod main.log.report( "Balance device masters" ) main.log.report( "__________________________________________________" ) main.case( "Balance device masters" ) main.step( "Balance device masters" ) main.caseResult = main.TRUE main.eventGenerator.triggerEvent( EventType().ONOS_BALANCE_MASTERS, EventScheduleMethod().RUN_BLOCK ) with main.eventScheduler.idleCondition: while not main.eventScheduler.isIdle(): main.eventScheduler.idleCondition.wait() utilities.assert_equals( expect=main.TRUE, actual=main.caseResult, onpass="******", onfail="Balance masters test failed" ) time.sleep( main.caseSleep )
def CASE33( self, main ): """ Uninstall point intents and check intent states and ping """ import time from tests.CHOTestMonkey.dependencies.events.Event import EventType from tests.CHOTestMonkey.dependencies.EventScheduler import EventScheduleMethod main.log.report( "Uninstall point intents and check intent states and ping" ) main.log.report( "__________________________________________________" ) main.case( "Uninstall point intents and check intent states and ping" ) main.step( "Uninstall point intents and check intent states and ping" ) main.caseResult = main.TRUE main.eventGenerator.triggerEvent( EventType().APP_INTENT_POINT_DEL_ALL, EventScheduleMethod().RUN_BLOCK ) with main.eventScheduler.idleCondition: while not main.eventScheduler.isIdle(): main.eventScheduler.idleCondition.wait() utilities.assert_equals( expect=main.TRUE, actual=main.caseResult, onpass="******", onfail="Uninstall point intents test failed" ) time.sleep( main.caseSleep )
def CASE10( self, main ): """ Run all enabled checks """ import time from tests.CHOTestMonkey.dependencies.events.Event import EventType from tests.CHOTestMonkey.dependencies.EventScheduler import EventScheduleMethod main.log.report( "Run all enabled checks" ) main.log.report( "__________________________________________________" ) main.case( "Run all enabled checks" ) main.step( "Run all enabled checks" ) main.caseResult = main.TRUE main.eventGenerator.triggerEvent( EventType().CHECK_ALL, EventScheduleMethod().RUN_BLOCK ) # Wait for the scheduler to become idle before going to the next testcase with main.eventScheduler.idleCondition: while not main.eventScheduler.isIdle(): main.eventScheduler.idleCondition.wait() utilities.assert_equals( expect=main.TRUE, actual=main.caseResult, onpass="******", onfail="Not all enabled checks passed" ) time.sleep( main.caseSleep )
def installAllHostIntents(self, scheduleMethod, args=None): """ This function installs host intents for all host pairs After all intent events are inserted, this funciton also insert intent and traffic checks """ import itertools with self.eventGeneratorLock: if scheduleMethod == EventScheduleMethod().RUN_BLOCK: main.eventScheduler.scheduleEvent( EventType().NULL, EventScheduleMethod().RUN_BLOCK) availableControllers = [] for controller in main.controllers: if controller.isUp(): availableControllers.append(controller.index) if len(availableControllers) == 0: main.log.warn("Event Generator - No available controllers") return hostCombos = list(itertools.combinations(main.hosts, 2)) for i in xrange(0, len(hostCombos), len(availableControllers)): for CLIIndex in availableControllers: if i >= len(hostCombos): break main.eventScheduler.scheduleEvent( EventType().APP_INTENT_HOST_ADD, EventScheduleMethod().RUN_NON_BLOCK, [ hostCombos[i][0].name, hostCombos[i][1].name, CLIIndex ]) i += 1 # Pending checks after installing all intents if scheduleMethod == EventScheduleMethod().RUN_BLOCK: main.eventScheduler.scheduleEvent( EventType().NULL, EventScheduleMethod().RUN_BLOCK) sleepTime = int(main.params['EVENT']['installAllHostIntents'] ['sleepBeforeCheck']) main.eventScheduler.scheduleEvent(EventType().TEST_SLEEP, EventScheduleMethod().RUN_BLOCK, [sleepTime]) main.eventScheduler.scheduleEvent( EventType().CHECK_INTENT, EventScheduleMethod().RUN_NON_BLOCK) main.eventScheduler.scheduleEvent( EventType().CHECK_FLOW, EventScheduleMethod().RUN_NON_BLOCK) main.eventScheduler.scheduleEvent( EventType().CHECK_TRAFFIC, EventScheduleMethod().RUN_NON_BLOCK) if scheduleMethod == EventScheduleMethod().RUN_BLOCK: main.eventScheduler.scheduleEvent( EventType().NULL, EventScheduleMethod().RUN_BLOCK)
def randomDeviceGroupToggle(self, scheduleMethod, args=None, blocking=True): """ The function randomly adds a group of device down-up events into the scheduler After each device down or up, all checks are inserted into the scheduler param: args[0] is the number of devices that are to be brought down args[1] is the average interval between device down events args[2] is the average interval between device group down and group up events blocking means blocking other events from being scheduled between device events """ import random import time if len(args) < 3: main.log.warn( "Event Generator - Not enough arguments for randomDeviceGroupToggle: %s" % (args)) elif len(args) > 3: main.log.warn( "Event Generator - Too many arguments for randomDeviceGroupToggle: %s" % (args)) else: deviceGroupSize = int(args[0]) downDownAvgInterval = int(args[1]) downUpAvgInterval = int(args[2]) downDevices = [] for i in range(0, deviceGroupSize): with main.variableLock: graphHelper = GraphHelper() availableDevices = graphHelper.getNonCutVertices() if len(availableDevices) == 0: main.log.warn( "All devices are cut vertices, aborting event") continue device = random.sample(availableDevices, 1) if i == 0: self.eventGeneratorLock.acquire() main.eventScheduler.scheduleEvent(EventType().NETWORK_DEVICE_DOWN, scheduleMethod, [device[0].name]) with main.variableLock: device[0].setPendingDown() downDevices.append(device[0]) sleepTime = int(main.params['EVENT']['randomLinkGroupToggle'] ['sleepBeforeCheck']) main.eventScheduler.scheduleEvent(EventType().TEST_SLEEP, EventScheduleMethod().RUN_BLOCK, [sleepTime]) self.insertAllChecks(EventScheduleMethod().RUN_NON_BLOCK) if scheduleMethod == EventScheduleMethod().RUN_BLOCK: # Insert a NULL BLOCK event main.eventScheduler.scheduleEvent( EventType().NULL, EventScheduleMethod().RUN_BLOCK) downDownInterval = abs(random.gauss(downDownAvgInterval, 1)) if not blocking: self.eventGeneratorLock.release() time.sleep(downDownInterval) self.eventGeneratorLock.acquire() else: time.sleep(downDownInterval) downUpInterval = abs(random.gauss(downUpAvgInterval, 1)) if not blocking: self.eventGeneratorLock.release() time.sleep(downUpInterval) self.eventGeneratorLock.acquire() else: time.sleep(downUpInterval) for device in downDevices: main.eventScheduler.scheduleEvent(EventType().NETWORK_DEVICE_UP, scheduleMethod, [device.name]) main.eventScheduler.scheduleEvent(EventType().TEST_SLEEP, EventScheduleMethod().RUN_BLOCK, [sleepTime]) self.insertAllChecks(EventScheduleMethod().RUN_NON_BLOCK) if scheduleMethod == EventScheduleMethod().RUN_BLOCK: main.eventScheduler.scheduleEvent( EventType().NULL, EventScheduleMethod().RUN_BLOCK) upUpInterval = abs(random.gauss(downDownAvgInterval, 1)) if not blocking: self.eventGeneratorLock.release() time.sleep(upUpInterval) self.eventGeneratorLock.acquire() else: time.sleep(upUpInterval) self.eventGeneratorLock.release()
def randomLinkToggle(self, scheduleMethod, args=[5], blocking=True): """ The function randomly adds a link down-up event pair into the scheduler After each individual link event, all checks are inserted into the scheduler param: args[0] is the average interval between link down and link up events blocking means blocking other events from being scheduled between link down and link up """ import random import time if len(args) < 1: main.log.warn( "Event Generator - Not enough arguments for randomLinkToggle: %s" % (args)) elif len(args) > 1: main.log.warn( "Event Generator - Too many arguments for randomLinkToggle: %s" % (args)) else: downUpAvgInterval = int(args[0]) with main.variableLock: graphHelper = GraphHelper() availableLinks = graphHelper.getNonCutEdges() if len(availableLinks) == 0: main.log.warn("All links are cut edges, aborting event") return link = random.sample(availableLinks, 1) self.eventGeneratorLock.acquire() main.eventScheduler.scheduleEvent( EventType().NETWORK_LINK_DOWN, scheduleMethod, [link[0].deviceA.name, link[0].deviceB.name]) with main.variableLock: link[0].setPendingDown() link[0].backwardLink.setPendingDown() sleepTime = int( main.params['EVENT']['randomLinkToggle']['sleepBeforeCheck']) main.eventScheduler.scheduleEvent(EventType().TEST_SLEEP, EventScheduleMethod().RUN_BLOCK, [sleepTime]) self.insertAllChecks(EventScheduleMethod().RUN_NON_BLOCK) if scheduleMethod == EventScheduleMethod().RUN_BLOCK: # Insert a NULL BLOCK event main.eventScheduler.scheduleEvent(EventType().NULL, EventScheduleMethod().RUN_BLOCK) downUpInterval = abs(random.gauss(downUpAvgInterval, 1)) if not blocking: self.eventGeneratorLock.release() time.sleep(downUpInterval) self.eventGeneratorLock.acquire() else: time.sleep(downUpInterval) main.eventScheduler.scheduleEvent( EventType().NETWORK_LINK_UP, scheduleMethod, [link[0].deviceA.name, link[0].deviceB.name]) main.eventScheduler.scheduleEvent(EventType().TEST_SLEEP, EventScheduleMethod().RUN_BLOCK, [sleepTime]) self.insertAllChecks(EventScheduleMethod().RUN_NON_BLOCK) if scheduleMethod == EventScheduleMethod().RUN_BLOCK: main.eventScheduler.scheduleEvent(EventType().NULL, EventScheduleMethod().RUN_BLOCK) self.eventGeneratorLock.release()
def CASE70(self, main): """ Randomly generate events """ import time import random from tests.CHOTestMonkey.dependencies.events.Event import EventType from tests.CHOTestMonkey.dependencies.EventScheduler import EventScheduleMethod main.log.report("Randomly generate events") main.log.report("__________________________________________________") main.case("Randomly generate events") main.step("Randomly generate events") main.caseResult = main.TRUE sleepSec = int(main.params['CASE70']['sleepSec']) hostIntentNum = 0 pointIntentNum = 0 downDeviceNum = 0 downLinkNum = 0 flowObj = False upControllers = [1, 2, 3] while True: events = [] for i in range(int(main.params['CASE70']['toggleFlowObj'])): events.append('toggle-flowobj') for i in range(int(main.params['CASE70']['addHostIntentWeight'])): events.append('add-host-intent') for i in range(int(main.params['CASE70']['addPointIntentWeight'])): events.append('add-point-intent') for i in range(int(main.params['CASE70']['linkDownWeight'])): events.append('link-down') for i in range(int(main.params['CASE70']['deviceDownWeight'])): events.append('device-down') for i in range(int(pow(hostIntentNum, 1.5) / 100)): events.append('del-host-intent') for i in range(int(pow(pointIntentNum, 1.5) / 100)): events.append('del-point-intent') for i in range(pow(2, downLinkNum) - 1): events.append('link-up') for i in range(pow(5, downDeviceNum) - 1): events.append('device-up') main.log.debug(events) event = random.sample(events, 1)[0] if event == 'add-host-intent': n = random.randint(5, 50) for i in range(n): cliIndex = random.sample(upControllers, 1)[0] main.eventGenerator.triggerEvent( EventType().APP_INTENT_HOST_ADD, EventScheduleMethod().RUN_BLOCK, 'random', 'random', cliIndex) hostIntentNum += 1 elif event == 'del-host-intent': n = random.randint(5, hostIntentNum) for i in range(n): cliIndex = random.sample(upControllers, 1)[0] main.eventGenerator.triggerEvent( EventType().APP_INTENT_HOST_DEL, EventScheduleMethod().RUN_BLOCK, 'random', 'random', cliIndex) hostIntentNum -= 1 elif event == 'add-point-intent': n = random.randint(5, 50) for i in range(n): cliIndex = random.sample(upControllers, 1)[0] main.eventGenerator.triggerEvent( EventType().APP_INTENT_POINT_ADD, EventScheduleMethod().RUN_BLOCK, 'random', 'random', cliIndex, 'bidirectional') pointIntentNum += 2 elif event == 'del-point-intent': n = random.randint(5, pointIntentNum / 2) for i in range(n): cliIndex = random.sample(upControllers, 1)[0] main.eventGenerator.triggerEvent( EventType().APP_INTENT_POINT_DEL, EventScheduleMethod().RUN_BLOCK, 'random', 'random', cliIndex, 'bidirectional') pointIntentNum -= 2 elif event == 'link-down': main.eventGenerator.triggerEvent( EventType().NETWORK_LINK_DOWN, EventScheduleMethod().RUN_BLOCK, 'random', 'random') downLinkNum += 1 elif event == 'link-up': main.eventGenerator.triggerEvent( EventType().NETWORK_LINK_UP, EventScheduleMethod().RUN_BLOCK, 'random', 'random') downLinkNum -= 1 elif event == 'device-down': main.eventGenerator.triggerEvent( EventType().NETWORK_DEVICE_DOWN, EventScheduleMethod().RUN_BLOCK, 'random') downDeviceNum += 1 elif event == 'device-up': main.eventGenerator.triggerEvent( EventType().NETWORK_DEVICE_UP, EventScheduleMethod().RUN_BLOCK, 'random') downDeviceNum -= 1 elif event == 'toggle-flowobj': if not flowObj: main.eventGenerator.triggerEvent( EventType().ONOS_SET_FLOWOBJ, EventScheduleMethod().RUN_BLOCK, 'true') else: main.eventGenerator.triggerEvent( EventType().ONOS_SET_FLOWOBJ, EventScheduleMethod().RUN_BLOCK, 'false') flowObj = not flowObj else: pass main.eventGenerator.triggerEvent( EventType().CHECK_TOPO, EventScheduleMethod().RUN_NON_BLOCK) main.eventGenerator.triggerEvent( EventType().CHECK_ONOS, EventScheduleMethod().RUN_NON_BLOCK) main.eventGenerator.triggerEvent( EventType().CHECK_TRAFFIC, EventScheduleMethod().RUN_NON_BLOCK) main.eventGenerator.triggerEvent( EventType().CHECK_FLOW, EventScheduleMethod().RUN_NON_BLOCK) main.eventGenerator.triggerEvent( EventType().CHECK_INTENT, EventScheduleMethod().RUN_NON_BLOCK) main.eventGenerator.triggerEvent( EventType().CHECK_RAFT_LOG_SIZE, EventScheduleMethod().RUN_NON_BLOCK) with main.eventScheduler.idleCondition: while not main.eventScheduler.isIdle(): main.eventScheduler.idleCondition.wait() time.sleep(sleepSec) utilities.assert_equals(expect=main.TRUE, actual=main.caseResult, onpass="******", onfail="Randomly generate events test failed") time.sleep(main.caseSleep)
def randomLinkGroupToggle( self, scheduleMethod, args=None, blocking=True ): """ The function randomly adds a group of link down-up events into the scheduler After each link down or up, all checks are inserted into the scheduler param: args[ 0 ] is the number of links that are to be brought down args[ 1 ] is the average interval between link down events args[ 2 ] is the average interval between link group down and group up events blocking means blocking other events from being scheduled between link events """ import random import time if len( args ) < 3: main.log.warn( "Event Generator - Not enough arguments for randomLinkGroupToggle: %s" % ( args ) ) elif len( args ) > 3: main.log.warn( "Event Generator - Too many arguments for randomLinkGroupToggle: %s" % ( args ) ) else: linkGroupSize = int( args[ 0 ] ) downDownAvgInterval = int( args[ 1 ] ) downUpAvgInterval = int( args[ 2 ] ) for i in range( 0, linkGroupSize ): if i == 0: self.eventGeneratorLock.acquire() main.eventScheduler.scheduleEvent( EventType().NETWORK_LINK_DOWN, scheduleMethod, [ 'random', 'random' ] ) sleepTime = int( main.params[ 'EVENT' ][ 'randomLinkGroupToggle' ][ 'sleepBeforeCheck' ] ) main.eventScheduler.scheduleEvent( EventType().TEST_SLEEP, EventScheduleMethod().RUN_BLOCK, [ sleepTime ] ) self.insertAllChecks( EventScheduleMethod().RUN_NON_BLOCK ) if scheduleMethod == EventScheduleMethod().RUN_BLOCK: # Insert a NULL BLOCK event main.eventScheduler.scheduleEvent( EventType().NULL, EventScheduleMethod().RUN_BLOCK ) downDownInterval = abs( random.gauss( downDownAvgInterval, 1 ) ) if not blocking: self.eventGeneratorLock.release() time.sleep( downDownInterval ) self.eventGeneratorLock.acquire() else: time.sleep( downDownInterval ) downUpInterval = abs( random.gauss( downUpAvgInterval, 1 ) ) if not blocking: self.eventGeneratorLock.release() time.sleep( downUpInterval ) self.eventGeneratorLock.acquire() else: time.sleep( downUpInterval ) for i in range( 0, linkGroupSize ): main.eventScheduler.scheduleEvent( EventType().NETWORK_LINK_UP, scheduleMethod, [ 'random', 'random' ] ) main.eventScheduler.scheduleEvent( EventType().TEST_SLEEP, EventScheduleMethod().RUN_BLOCK, [ sleepTime ] ) self.insertAllChecks( EventScheduleMethod().RUN_NON_BLOCK ) if scheduleMethod == EventScheduleMethod().RUN_BLOCK: main.eventScheduler.scheduleEvent( EventType().NULL, EventScheduleMethod().RUN_BLOCK ) upUpInterval = abs( random.gauss( downDownAvgInterval, 1 ) ) if not blocking: self.eventGeneratorLock.release() time.sleep( upUpInterval ) self.eventGeneratorLock.acquire() else: time.sleep( upUpInterval ) self.eventGeneratorLock.release()