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 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])
downLinks = []
for i in range(0, linkGroupSize):
with main.variableLock:
graphHelper = GraphHelper()
availableLinks = graphHelper.getNonCutEdges()
if len(availableLinks) == 0:
main.log.warn("All links are cut edges, aborting event")
continue
link = random.sample(availableLinks, 1)
if i == 0:
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()
downLinks.append(link[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 link in downLinks:
main.eventScheduler.scheduleEvent(
EventType().NETWORK_LINK_UP, scheduleMethod,
[link.deviceA.name, link.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)
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 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 ] )
downLinks = []
for i in range( 0, linkGroupSize ):
with main.variableLock:
graphHelper = GraphHelper()
availableLinks = graphHelper.getNonCutEdges()
if len( availableLinks ) == 0:
main.log.warn( "All links are cut edges, aborting event" )
continue
link = random.sample( availableLinks, 1 )
if i == 0:
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()
downLinks.append( link[ 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 link in downLinks:
main.eventScheduler.scheduleEvent( EventType().NETWORK_LINK_UP,
scheduleMethod,
[ link.deviceA.name, link.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 )
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()
