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 startEvent(self, args): """ args are the names of the two link ends, e.g. ['s1', 's2'] """ with self.eventLock: #main.log.info( "%s - starting event" % ( self.typeString ) ) if len(args) < 2: main.log.warn("%s - Not enough arguments: %s" % (self.typeString, args)) return EventStates().ABORT elif len(args) > 2: main.log.warn("%s - Too many arguments: %s" % (self.typeString, args)) return EventStates().ABORT if args[0] == 'random' or args[1] == 'random': if self.typeIndex == EventType().NETWORK_LINK_DOWN: with main.mininetLock: linkRandom = main.Mininet1.getLinkRandom() if linkRandom == None: main.log.warn("No link available, aborting event") return EventStates().ABORT args[0] = linkRandom[0] args[1] = linkRandom[1] elif self.typeIndex == EventType().NETWORK_LINK_UP: import random with main.variableLock: downLinks = [] for link in main.links: if link.isDown(): downLinks.append(link) if len(downLinks) == 0: main.log.warn( "None of the links are in 'down' state, aborting event" ) return EventStates().ABORT linkList = random.sample(downLinks, 1) self.linkA = linkList[0] self.linkB = linkList[0].backwardLink elif args[0] == args[1]: main.log.warn("%s - invalid arguments: %s" % (self.typeString, args)) return EventStates().ABORT if self.linkA == None or self.linkB == None: for link in main.links: if link.deviceA.name == args[ 0] and link.deviceB.name == args[1]: self.linkA = link elif link.deviceA.name == args[ 1] and link.deviceB.name == args[0]: self.linkB = link if self.linkA != None and self.linkB != None: break if self.linkA == None or self.linkB == None: main.log.warn( "Bidirectional link %s - %s does not exist: " % (args[0], args[1])) return EventStates().ABORT main.log.debug("%s - %s" % (self.typeString, self.linkA)) return self.startLinkEvent()
def addAllChecks( self, scheduleMethod, args=None ): """ The function adds all check events into the scheduler """ with self.eventGeneratorLock: if scheduleMethod == EventScheduleMethod().RUN_BLOCK: main.eventScheduler.scheduleEvent( EventType().NULL, EventScheduleMethod().RUN_BLOCK ) self.insertAllChecks( args ) if scheduleMethod == EventScheduleMethod().RUN_BLOCK: main.eventScheduler.scheduleEvent( EventType().NULL, EventScheduleMethod().RUN_BLOCK )
def startEvent( self, args ): with self.eventLock: #main.log.info( "%s - starting event" % ( self.typeString ) ) if self.typeIndex == EventType().APP_INTENT_HOST_ADD or self.typeIndex == EventType().APP_INTENT_HOST_DEL: if len( args ) < 3: main.log.warn( "%s - Not enough arguments: %s" % ( self.typeString, args ) ) return EventStates().ABORT elif len( args ) > 3: main.log.warn( "%s - Too many arguments: %s" % ( self.typeString, args ) ) return EventStates().ABORT try: if args[ 0 ] == 'random' or args[ 1 ] == 'random': if self.typeIndex == EventType().APP_INTENT_HOST_ADD: hostPairRandom = self.getRandomHostPair( connected=False ) if hostPairRandom == None: main.log.warn( "All host pairs are connected, aborting event" ) return EventStates().ABORT self.hostA = hostPairRandom[ 0 ] self.hostB = hostPairRandom[ 1 ] elif self.typeIndex == EventType().APP_INTENT_HOST_DEL: intent = self.getRandomIntentByType( 'INTENT_HOST' ) if intent == None: main.log.warn( "No host intent for deletion, aborting event" ) return EventStates().ABORT self.hostA = intent.hostA self.hostB = intent.hostB elif args[ 0 ] == args[ 1 ]: main.log.warn( "%s - invalid argument: %s, %s" % ( self.typeString, args[ 0 ], args[ 1 ] ) ) return EventStates().ABORT else: for host in main.hosts: if host.name == args[ 0 ]: self.hostA = host elif host.name == args[ 1 ]: self.hostB = host if self.hostA != None and self.hostB != None: break if self.hostA == None: main.log.warn( "Host %s does not exist: " % ( args[ 0 ] ) ) return EventStates().ABORT if self.hostB == None: main.log.warn( "Host %s does not exist: " % ( args[ 1 ] ) ) return EventStates().ABORT index = int( args[ 2 ] ) if index < 1 or index > int( main.numCtrls ): main.log.warn( "%s - invalid argument: %s" % ( self.typeString, index ) ) return EventStates().ABORT if not main.controllers[ index - 1 ].isUp(): main.log.warn( self.typeString + " - invalid argument: onos %s is down" % ( controller.index ) ) return EventStates().ABORT self.CLIIndex = index return self.startHostIntentEvent() except Exception: main.log.warn( "Caught exception, aborting event" ) return EventStates().ABORT
def startEvent(self, args): """ args are the names of the device, e.g. 's1' """ with self.eventLock: main.log.info("%s - starting event" % (self.typeString)) if len(args) < 1: main.log.warn("%s - Not enough arguments: %s" % (self.typeString, args)) return EventStates().ABORT elif len(args) > 1: main.log.warn("%s - Too many arguments: %s" % (self.typeString, args)) return EventStates().ABORT if args[0] == 'random': import random if self.typeIndex == EventType().NETWORK_DEVICE_DOWN: with main.variableLock: graphHelper = GraphHelper() availableDevices = graphHelper.getNonCutVertices() if len(availableDevices) == 0: main.log.warn( "All devices are cut vertices, aborting event") return EventStates().ABORT deviceList = random.sample(availableDevices, 1) self.device = deviceList[0] elif self.typeIndex == EventType().NETWORK_DEVICE_UP: with main.variableLock: removedDevices = [] for device in main.devices: if device.isRemoved(): removedDevices.append(device) if len(removedDevices) == 0: main.log.warn( "None of the devices are removed, aborting event" ) return EventStates().ABORT deviceList = random.sample(removedDevices, 1) self.device = deviceList[0] else: for device in main.devices: if device.name == args[0]: self.device = device if self.device == None: main.log.warn("Device %s does not exist: " % (args[0])) return EventStates().ABORT main.log.debug("%s - %s" % (self.typeString, self.device)) return self.startDeviceEvent()
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(main.caseSleep)
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(int(main.params['CASE41']['sleepSec']))
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 scheduleEvent( self, typeIndex, scheduleMethod, args=None, index=-1 ): """ Insert an event to pendingEvents param: index: the position to insert into pendingEvents, default value -1 implies the tail of pendingEvents """ if typeIndex not in main.enabledEvents.keys(): main.log.warn( "Event Scheduler - event type %s not enabled" % ( typeIndex ) ) return if main.enabledEvents[ typeIndex ] in main.params[ 'EVENT' ].keys(): if 'rerunInterval' in main.params[ 'EVENT' ][ main.enabledEvents[ typeIndex ] ].keys(): rerunInterval = int( main.params[ 'EVENT' ][ main.enabledEvents[ typeIndex ] ][ 'rerunInterval' ] ) maxRerunNum = int( main.params[ 'EVENT' ][ main.enabledEvents[ typeIndex ] ][ 'maxRerunNum' ] ) else: rerunInterval = int( main.params[ 'EVENT' ][ 'Event' ][ 'rerunInterval' ] ) maxRerunNum = int( main.params[ 'EVENT' ][ 'Event' ][ 'maxRerunNum' ] ) eventTuple = EventTuple( main.eventID, main.enabledEvents[ typeIndex ], EventType().map[ typeIndex ], typeIndex, scheduleMethod, args, rerunInterval, maxRerunNum ) with main.variableLock: main.eventID += 1 main.log.debug( "Event Scheduler - Event added: %s, %s, %s" % ( typeIndex, scheduleMethod, args ) ) with self.pendingEventsCondition: if index == -1: self.pendingEvents.append( eventTuple ) elif index > -1 and index <= len( self.pendingEvents ): self.pendingEvents.insert( index, eventTuple ) else: main.log.warn( "Event Scheduler - invalid index when isnerting event: %s" % ( index ) ) self.pendingEventsCondition.notify()
def startEvent(self, args): """ args are the names of the device, e.g. 's1' """ with self.eventLock: # main.log.info( "%s - starting event" % ( self.typeString ) ) if len(args) < 1: main.log.warn("%s - Not enough arguments: %s" % (self.typeString, args)) return EventStates().ABORT elif len(args) > 1: main.log.warn("%s - Too many arguments: %s" % (self.typeString, args)) return EventStates().ABORT if args[0] == 'random': import random if self.typeIndex == EventType().NETWORK_DEVICE_DOWN: with main.networkLock: switchRandom = main.Network.getSwitchRandom( excludeNodes=main.excludeNodes, skipSwitches=main.skipSwitches) if switchRandom is None: main.log.warn("No switch available, aborting event") return EventStates().ABORT args[0] = switchRandom elif self.typeIndex == EventType().NETWORK_DEVICE_UP: with main.variableLock: removedDevices = [] for device in main.devices: if device.isRemoved(): removedDevices.append(device) if len(removedDevices) == 0: main.log.warn( "None of the devices are removed, aborting event" ) return EventStates().ABORT deviceList = random.sample(removedDevices, 1) self.device = deviceList[0] if self.device is None: for device in main.devices: if device.name == args[0]: self.device = device if self.device is None: main.log.warn("Device %s does not exist: " % (args[0])) return EventStates().ABORT main.log.debug("%s - %s" % (self.typeString, self.device)) return self.startDeviceEvent()
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 startEvent(self, args): with self.eventLock: main.log.info("%s - starting event" % (self.typeString)) if self.typeIndex == EventType( ).APP_INTENT_HOST_ADD or self.typeIndex == EventType( ).APP_INTENT_HOST_DEL: if len(args) < 3: main.log.warn("%s - Not enough arguments: %s" % (self.typeString, args)) return EventStates().ABORT elif len(args) > 3: main.log.warn("%s - Too many arguments: %s" % (self.typeString, args)) return EventStates().ABORT else: if args[0] == args[1]: main.log.warn("%s - invalid argument: %s" % (self.typeString, index)) return EventStates().ABORT for host in main.hosts: if host.name == args[0]: self.hostA = host elif host.name == args[1]: self.hostB = host if self.hostA != None and self.hostB != None: break if self.hostA == None: main.log.warn("Host %s does not exist: " % (args[0])) return EventStates().ABORT if self.hostB == None: main.log.warn("Host %s does not exist: " % (args[1])) return EventStates().ABORT index = int(args[2]) if index < 1 or index > int(main.numCtrls): main.log.warn("%s - invalid argument: %s" % (self.typeString, index)) return EventStates().ABORT if not main.controllers[index - 1].isUp(): main.log.warn(self.typeString + " - invalid argument: onos %s is down" % (controller.index)) return EventStates().ABORT self.CLIIndex = index return self.startHostIntentEvent()
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 startEvent( self, args ): with self.eventLock: main.log.info( "%s - starting event" % ( self.typeString ) ) result = EventStates().PASS if self.typeIndex == EventType().ONOS_ONOS_DOWN or self.typeIndex == EventType().ONOS_ONOS_UP: if len( args ) < 1: main.log.warn( "%s - Not enough arguments: %s" % ( self.typeString, args ) ) result = EventStates().ABORT elif len( args ) > 1: main.log.warn( "%s - Too many arguments: %s" % ( self.typeString, args ) ) result = EventStates().ABORT else: index = int( args[ 0 ] ) if index < 1 or index > int( main.numCtrls ): main.log.warn( "%s - invalid argument: %s" % ( self.typeString, index ) ) result = EventStates().ABORT else: self.ONOSIndex = index result = self.startONOSEvent() return result
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 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 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 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 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 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 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 startEvent(self, args): """ args are the device name and port number, e.g. [ 's1', '5' ] """ with self.eventLock: # main.log.info( "%s - starting event" % ( self.typeString ) ) if len(args) < 2: main.log.warn("%s - Not enough arguments: %s" % (self.typeString, args)) return EventStates().ABORT elif len(args) > 2: main.log.warn("%s - Too many arguments: %s" % (self.typeString, args)) return EventStates().ABORT if args[0] == 'random' or args[1] == 'random': if self.typeIndex == EventType().NETWORK_PORT_DOWN: with main.networkLock: linkRandom = main.Network.getLinkRandom( excludeNodes=main.excludeNodes, skipLinks=main.skipLinks) if linkRandom is None: main.log.warn("No link available, aborting event") return EventStates().ABORT for link in main.links: if link.deviceA.name == linkRandom[ 0] and link.deviceB.name == linkRandom[1]: self.device = link.deviceA self.port = int(link.portA) if not self.device: main.log.warn( "Failed to get a radnom device port, aborting event" ) return EventStates().ABORT elif self.typeIndex == EventType().NETWORK_PORT_UP: import random with main.variableLock: downPorts = {} for link in main.links: if link.isDown(): if int(link.portA) in link.deviceA.downPorts: downPorts[link.deviceA] = link.portA if len(downPorts) == 0: main.log.warn( "None of the links are in 'down' state, aborting event" ) return EventStates().ABORT deviceList = random.sample(downPorts, 1) self.device = deviceList[0] self.port = int(downPorts[self.device]) if self.device is None: for device in main.devices: if device.name == args[0]: self.device = device if self.device is None: main.log.warn("Device %s does not exist: " % (args[0])) return EventStates().ABORT if self.port is None: try: self.port = int(args[1]) except Exception: main.log.warn("Device port is not a number: {}".format( args[1])) return EventStates().ABORT if self.link is None: for link in main.links: if link.deviceA.name == self.device.name and int( link.portA) == self.port: self.link = link if self.link is None: main.log.warn( "There's no link on device {} port {}".format( self.device.name, self.port)) return EventStates().ABORT main.log.debug("%s - %s:%s" % (self.typeString, self.device, self.port)) return self.startPortEvent()
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()
def startEvent(self, args): with self.eventLock: # main.log.info( "%s - starting event" % ( self.typeString ) ) if self.typeIndex == EventType( ).APP_INTENT_POINT_ADD or self.typeIndex == EventType( ).APP_INTENT_POINT_DEL: if len(args) < 3: main.log.warn("%s - Not enough arguments: %s" % (self.typeString, args)) return EventStates().ABORT elif len(args) > 4: main.log.warn("%s - Too many arguments: %s" % (self.typeString, args)) return EventStates().ABORT try: if args[0] == 'random' or args[1] == 'random': if self.typeIndex == EventType().APP_INTENT_POINT_ADD: hostPairRandom = self.getRandomHostPair( connected=False) if hostPairRandom is None: main.log.warn( "All host pairs are connected, aborting event" ) return EventStates().ABORT self.deviceA = hostPairRandom[0].device self.deviceB = hostPairRandom[1].device elif self.typeIndex == EventType( ).APP_INTENT_POINT_DEL: intent = self.getRandomIntentByType('INTENT_POINT') if intent is None: main.log.warn( "No point intent for deletion, aborting event" ) return EventStates().ABORT self.deviceA = intent.deviceA self.deviceB = intent.deviceB elif args[0] == args[1]: main.log.warn("%s - invalid argument: %s" % (self.typeString, args[0], args[1])) return EventStates().ABORT else: for device in main.devices: if device.name == args[0]: self.deviceA = device elif device.name == args[1]: self.deviceB = device if self.deviceA is not None and self.deviceB is not None: break if self.deviceA is None: main.log.warn("Device %s does not exist: " % (args[0])) return EventStates().ABORT if self.deviceB is None: main.log.warn("Device %s does not exist: " % (args[1])) return EventStates().ABORT index = int(args[2]) if index < 1 or index > int(main.Cluster.numCtrls): main.log.warn("%s - invalid argument: %s" % (self.typeString, index)) return EventStates().ABORT if not main.controllers[index - 1].isUp(): main.log.warn(self.typeString + " - invalid argument: onos %s is down" % (controller.index)) return EventStates().ABORT self.CLIIndex = index if len(args) == 4 and args[3] == 'bidirectional': # Install point intents for both directions resultA = self.startPointIntentEvent() [self.deviceA, self.deviceB] = [self.deviceB, self.deviceA] resultB = self.startPointIntentEvent() if resultA == EventStates( ).PASS and resultB == EventStates().PASS: return EventStates().PASS else: return EventStates().FAIL else: return self.startPointIntentEvent() except Exception: main.log.warn("Caught exception, aborting event") return EventStates().ABORT