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()
