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 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':
import random
if self.typeIndex == EventType().NETWORK_LINK_DOWN:
with main.variableLock:
graphHelper = GraphHelper()
availableLinks = graphHelper.getNonCutEdges()
if len( availableLinks ) == 0:
main.log.warn( "All links are cut edges, aborting event" )
return EventStates().ABORT
linkList = random.sample( availableLinks, 1 )
self.linkA = linkList[ 0 ]
self.linkB = linkList[ 0 ].backwardLink
elif self.typeIndex == EventType().NETWORK_LINK_UP:
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
else:
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 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 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 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 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])
with main.variableLock:
graphHelper = GraphHelper()
availableDevices = graphHelper.getNonCutVertices()
if len(availableDevices) == 0:
main.log.warn("All devices are Cut vertices, aborting event")
return
device = random.sample(availableDevices, 1)
self.eventGeneratorLock.acquire()
main.eventScheduler.scheduleEvent(EventType().NETWORK_DEVICE_DOWN,
scheduleMethod, [device[0].name])
with main.variableLock:
device[0].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_DEVICE_UP,
scheduleMethod, [device[0].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 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 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':
import random
if self.typeIndex == EventType().NETWORK_LINK_DOWN:
with main.variableLock:
graphHelper = GraphHelper()
availableLinks = graphHelper.getNonCutEdges()
if len(availableLinks) == 0:
main.log.warn(
"All links are cut edges, aborting event")
return EventStates().ABORT
linkList = random.sample(availableLinks, 1)
self.linkA = linkList[0]
self.linkB = linkList[0].backwardLink
elif self.typeIndex == EventType().NETWORK_LINK_UP:
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
else:
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()
