class FUNCgroup: | |
def __init__( self ): | |
self.default = '' | |
def CASE1( self, main ): | |
import os | |
import imp | |
""" | |
- Construct tests variables | |
- GIT ( optional ) | |
- Checkout ONOS master branch | |
- Pull latest ONOS code | |
- Building ONOS ( optional ) | |
- Install ONOS package | |
- Build ONOS package | |
""" | |
main.case( "Constructing test variables and building ONOS package" ) | |
main.step( "Constructing test variables" ) | |
# Test variables | |
main.testOnDirectory = os.path.dirname( os.getcwd() ) | |
main.cellName = main.params[ 'ENV' ][ 'cellName' ] | |
main.apps = main.params[ 'ENV' ][ 'cellApps' ] | |
gitBranch = main.params[ 'GIT' ][ 'branch' ] | |
gitPull = main.params[ 'GIT' ][ 'pull' ] | |
main.ONOSport = main.params[ 'CTRL' ][ 'port' ] | |
main.dependencyPath = main.testOnDirectory + \ | |
main.params[ 'DEPENDENCY' ][ 'path' ] | |
wrapperFile1 = main.params[ 'DEPENDENCY' ][ 'wrapper1' ] | |
wrapperFile2 = main.params[ 'DEPENDENCY' ][ 'wrapper2' ] | |
main.topology = main.params[ 'DEPENDENCY' ][ 'topology' ] | |
bucket = main.params[ 'DEPENDENCY' ][ 'bucket' ] | |
main.maxNodes = int( main.params[ 'SCALE' ][ 'max' ] ) | |
main.startUpSleep = int( main.params[ 'SLEEP' ][ 'startup' ] ) | |
main.startMNSleep = int( main.params[ 'SLEEP' ][ 'startMN' ] ) | |
main.addFlowSleep = int( main.params[ 'SLEEP' ][ 'addFlow' ] ) | |
main.delFlowSleep = int( main.params[ 'SLEEP' ][ 'delFlow' ] ) | |
main.addGroupSleep = int( main.params[ 'SLEEP' ][ 'addGroup' ] ) | |
main.delGroupSleep = int( main.params[ 'SLEEP' ][ 'delGroup' ] ) | |
main.debug = main.params[ 'DEBUG' ] | |
main.swDPID = main.params[ 'TEST' ][ 'swDPID' ] | |
egressPort1 = main.params[ 'TEST' ][ 'egressPort1' ] | |
egressPort2 = main.params[ 'TEST' ][ 'egressPort2' ] | |
egressPort3 = main.params[ 'TEST' ][ 'egressPort3' ] | |
ingressPort = main.params[ 'TEST' ][ 'ingressPort' ] | |
appCookie = main.params[ 'TEST' ][ 'appCookie' ] | |
type1 = main.params[ 'TEST' ][ 'type1' ] | |
type2 = main.params[ 'TEST' ][ 'type2' ] | |
groupId = main.params[ 'TEST' ][ 'groupId' ] | |
priority = main.params[ 'TEST' ][ 'priority' ] | |
deviceId = main.params[ 'TEST' ][ 'swDPID' ] | |
main.cellData = {} # for creating cell file | |
main.CLIs = [] | |
main.ONOSip = [] | |
main.debug = True if "on" in main.debug else False | |
main.ONOSip = main.ONOSbench.getOnosIps() | |
# Assigning ONOS cli handles to a list | |
for i in range( 1, main.maxNodes + 1 ): | |
main.CLIs.append( getattr( main, 'ONOScli' + str( i ) ) ) | |
# -- INIT SECTION, ONLY RUNS ONCE -- # | |
main.startUp = imp.load_source( wrapperFile1, | |
main.dependencyPath + | |
wrapperFile1 + | |
".py" ) | |
main.topo = imp.load_source( wrapperFile2, | |
main.dependencyPath + | |
wrapperFile2 + | |
".py" ) | |
main.buckets = imp.load_source( bucket, | |
main.dependencyPath + | |
bucket + | |
".py" ) | |
copyResult = main.ONOSbench.scp( main.Mininet1, | |
main.dependencyPath + main.topology, | |
main.Mininet1.home + '/custom/', | |
direction="to" ) | |
utilities.assert_equals( expect=main.TRUE, | |
actual=copyResult, | |
onpass="Successfully copy " + "test variables ", | |
onfail="Failed to copy test variables" ) | |
if main.CLIs: | |
stepResult = main.TRUE | |
else: | |
main.log.error( "Did not properly created list of ONOS CLI handle" ) | |
stepResult = main.FALSE | |
utilities.assert_equals( expect=main.TRUE, | |
actual=stepResult, | |
onpass="Successfully construct " + "test variables ", | |
onfail="Failed to construct test variables" ) | |
def CASE2( self, main ): | |
""" | |
- Set up cell | |
- Create cell file | |
- Set cell file | |
- Verify cell file | |
- Kill ONOS process | |
- Uninstall ONOS cluster | |
- Verify ONOS start up | |
- Install ONOS cluster | |
- Connect to cli | |
""" | |
import time | |
main.numCtrls = int( main.maxNodes ) | |
main.case( "Starting up " + str( main.numCtrls ) + | |
" node(s) ONOS cluster" ) | |
#kill off all onos processes | |
main.log.info( "Safety check, killing all ONOS processes" + | |
" before initiating environment setup" ) | |
for i in range( main.maxNodes ): | |
main.ONOSbench.onosDie( main.ONOSip[ i ] ) | |
main.log.info( "NODE COUNT = " + str( main.numCtrls ) ) | |
tempOnosIp = [] | |
for i in range( main.numCtrls ): | |
tempOnosIp.append( main.ONOSip[ i ] ) | |
main.ONOSbench.createCellFile( main.ONOSbench.ip_address, | |
"temp", | |
main.Mininet1.ip_address, | |
main.apps, | |
tempOnosIp, main.ONOScli1.user_name ) | |
main.step( "Apply cell to environment" ) | |
cellResult = main.ONOSbench.setCell( "temp" ) | |
verifyResult = main.ONOSbench.verifyCell() | |
stepResult = cellResult and verifyResult | |
utilities.assert_equals( expect=main.TRUE, | |
actual=stepResult, | |
onpass="Successfully applied cell to " + "environment", | |
onfail="Failed to apply cell to environment " ) | |
main.step( "Creating ONOS package" ) | |
packageResult = main.ONOSbench.buckBuild() | |
stepResult = packageResult | |
utilities.assert_equals( expect=main.TRUE, | |
actual=stepResult, | |
onpass="Successfully created ONOS package", | |
onfail="Failed to create ONOS package" ) | |
time.sleep( main.startUpSleep ) | |
main.step( "Uninstalling ONOS package" ) | |
onosUninstallResult = main.TRUE | |
for ip in main.ONOSip: | |
onosUninstallResult = onosUninstallResult and \ | |
main.ONOSbench.onosUninstall( nodeIp=ip ) | |
stepResult = onosUninstallResult | |
utilities.assert_equals( expect=main.TRUE, | |
actual=stepResult, | |
onpass="Successfully uninstalled ONOS package", | |
onfail="Failed to uninstall ONOS package" ) | |
time.sleep( main.startUpSleep ) | |
main.step( "Installing ONOS package" ) | |
onosInstallResult = main.TRUE | |
for i in range( main.numCtrls ): | |
onosInstallResult = onosInstallResult and \ | |
main.ONOSbench.onosInstall( node=main.ONOSip[ i ] ) | |
stepResult = onosInstallResult | |
utilities.assert_equals( expect=main.TRUE, | |
actual=stepResult, | |
onpass="Successfully installed ONOS package", | |
onfail="Failed to install ONOS package" ) | |
time.sleep( main.startUpSleep ) | |
main.step( "Starting ONOS service" ) | |
stopResult = main.TRUE | |
startResult = main.TRUE | |
onosIsUp = main.TRUE | |
for i in range( main.numCtrls ): | |
onosIsUp = onosIsUp and main.ONOSbench.isup( main.ONOSip[ i ] ) | |
if onosIsUp == main.TRUE: | |
main.log.report( "ONOS instance is up and ready" ) | |
else: | |
main.log.report( "ONOS instance may not be up, stop and " + | |
"start ONOS again " ) | |
for i in range( main.numCtrls ): | |
stopResult = stopResult and \ | |
main.ONOSbench.onosStop( main.ONOSip[ i ] ) | |
for i in range( main.numCtrls ): | |
startResult = startResult and \ | |
main.ONOSbench.onosStart( main.ONOSip[ i ] ) | |
stepResult = onosIsUp and stopResult and startResult | |
utilities.assert_equals( expect=main.TRUE, | |
actual=stepResult, | |
onpass="ONOS service is ready", | |
onfail="ONOS service did not start properly" ) | |
main.step( "Set up ONOS secure SSH" ) | |
secureSshResult = main.TRUE | |
for i in range( int( main.numCtrls ) ): | |
secureSshResult = secureSshResult and main.ONOSbench.onosSecureSSH( node=main.ONOSip[ i ] ) | |
utilities.assert_equals( expect=main.TRUE, actual=secureSshResult, | |
onpass="Test step PASS", | |
onfail="Test step FAIL" ) | |
main.step( "Start ONOS cli" ) | |
cliResult = main.TRUE | |
for i in range( main.numCtrls ): | |
cliResult = cliResult and \ | |
main.CLIs[ i ].startOnosCli( main.ONOSip[ i ] ) | |
stepResult = cliResult | |
utilities.assert_equals( expect=main.TRUE, | |
actual=stepResult, | |
onpass="Successfully start ONOS cli", | |
onfail="Failed to start ONOS cli" ) | |
def CASE3( self, main ): | |
""" | |
Start Mininet | |
""" | |
import json | |
main.case( "Setup mininet and compare ONOS topology view to Mininet topology" ) | |
main.caseExplanation = "Start mininet with custom topology and compare topology " +\ | |
"elements between Mininet and ONOS" | |
main.step( "Setup Mininet Topology" ) | |
topology = main.Mininet1.home + '/custom/' + main.topology | |
stepResult = main.Mininet1.startNet( topoFile=topology ) | |
utilities.assert_equals( expect=main.TRUE, | |
actual=stepResult, | |
onpass="Successfully loaded topology", | |
onfail="Failed to load topology" ) | |
main.step( "Assign switch to controller" ) | |
stepResult = main.Mininet1.assignSwController( "s1", main.ONOSip[ 0 ] ) | |
utilities.assert_equals( expect=main.TRUE, | |
actual=stepResult, | |
onpass="Successfully assigned switch to controller", | |
onfail="Failed to assign switch to controller" ) | |
time.sleep( main.startMNSleep ) | |
main.step( "Comparing MN topology to ONOS topology" ) | |
main.log.info( "Gathering topology information" ) | |
devices = main.topo.getAllDevices( main ) | |
hosts = main.topo.getAllHosts( main ) | |
ports = main.topo.getAllPorts( main ) | |
links = main.topo.getAllLinks( main ) | |
mnSwitches = main.Mininet1.getSwitches() | |
mnLinks = main.Mininet1.getLinks() | |
mnHosts = main.Mininet1.getHosts() | |
for controller in range( main.numCtrls ): | |
controllerStr = str( controller + 1 ) | |
if devices[ controller ] and ports[ controller ] and\ | |
"Error" not in devices[ controller ] and\ | |
"Error" not in ports[ controller ]: | |
currentDevicesResult = main.Mininet1.compareSwitches( | |
mnSwitches, | |
json.loads( devices[ controller ] ), | |
json.loads( ports[ controller ] ) ) | |
else: | |
currentDevicesResult = main.FALSE | |
utilities.assert_equals( expect=main.TRUE, | |
actual=currentDevicesResult, | |
onpass="ONOS" + controllerStr + | |
" Switches view is correct", | |
onfail="ONOS" + controllerStr + | |
" Switches view is incorrect" ) | |
if links[ controller ] and "Error" not in links[ controller ]: | |
currentLinksResult = main.Mininet1.compareLinks( | |
mnSwitches, mnLinks, | |
json.loads( links[ controller ] ) ) | |
else: | |
currentLinksResult = main.FALSE | |
utilities.assert_equals( expect=main.TRUE, | |
actual=currentLinksResult, | |
onpass="ONOS" + controllerStr + | |
" links view is correct", | |
onfail="ONOS" + controllerStr + | |
" links view is incorrect" ) | |
if hosts[ controller ] or "Error" not in hosts[ controller ]: | |
currentHostsResult = main.Mininet1.compareHosts( | |
mnHosts, | |
json.loads( hosts[ controller ] ) ) | |
else: | |
currentHostsResult = main.FALSE | |
utilities.assert_equals( expect=main.TRUE, | |
actual=currentHostsResult, | |
onpass="ONOS" + controllerStr + | |
" hosts exist in Mininet", | |
onfail="ONOS" + controllerStr + | |
" hosts don't match Mininet" ) | |
def CASE4( self, main ): | |
""" | |
Testing scapy | |
""" | |
main.case( "Testing scapy" ) | |
main.step( "Creating Host1 component" ) | |
main.Scapy.createHostComponent( "h1" ) | |
main.Scapy.createHostComponent( "h2" ) | |
hosts = [ main.h1, main.h2 ] | |
for host in hosts: | |
host.startHostCli() | |
host.startScapy() | |
host.updateSelf() | |
main.log.debug( host.name ) | |
main.log.debug( host.hostIp ) | |
main.log.debug( host.hostMac ) | |
main.step( "Sending/Receiving Test packet - Filter doesn't match" ) | |
main.log.info( "Starting Filter..." ) | |
main.h2.startFilter() | |
main.log.info( "Building Ether frame..." ) | |
main.h1.buildEther( dst=main.h2.hostMac ) | |
main.log.info( "Sending Packet..." ) | |
main.h1.sendPacket() | |
main.log.info( "Checking Filter..." ) | |
finished = main.h2.checkFilter() | |
main.log.debug( finished ) | |
i = "" | |
if finished: | |
a = main.h2.readPackets() | |
for i in a.splitlines(): | |
main.log.info( i ) | |
else: | |
kill = main.h2.killFilter() | |
main.log.debug( kill ) | |
main.h2.handle.sendline( "" ) | |
main.h2.handle.expect( main.h2.scapyPrompt ) | |
main.log.debug( main.h2.handle.before ) | |
utilities.assert_equals( expect=True, | |
actual="dst=00:00:00:00:00:02 src=00:00:00:00:00:01" in i, | |
onpass="Pass", | |
onfail="Fail" ) | |
main.step( "Sending/Receiving Test packet - Filter matches" ) | |
main.h2.startFilter() | |
main.h1.buildEther( dst=main.h2.hostMac ) | |
main.h1.buildIP( dst=main.h2.hostIp ) | |
main.h1.sendPacket() | |
finished = main.h2.checkFilter() | |
i = "" | |
if finished: | |
a = main.h2.readPackets() | |
for i in a.splitlines(): | |
main.log.info( i ) | |
else: | |
kill = main.h2.killFilter() | |
main.log.debug( kill ) | |
main.h2.handle.sendline( "" ) | |
main.h2.handle.expect( main.h2.scapyPrompt ) | |
main.log.debug( main.h2.handle.before ) | |
utilities.assert_equals( expect=True, | |
actual="dst=00:00:00:00:00:02 src=00:00:00:00:00:01" in i, | |
onpass="Pass", | |
onfail="Fail" ) | |
main.step( "Clean up host components" ) | |
for host in hosts: | |
host.stopScapy() | |
main.Mininet1.removeHostComponent( "h1" ) | |
main.Mininet1.removeHostComponent( "h2" ) | |
def CASE5( self, main ): | |
""" | |
Adding Group of type "ALL" using Rest api | |
""" | |
import json | |
import time | |
isAdded = main.FALSE | |
main.case( "Verify Group of type All are successfully Added" ) | |
main.caseExplanation = " Install a Group of type ALL " +\ | |
" Verify the Group is Added " +\ | |
" Add a flow using the group " +\ | |
" Send a packet that verifies the action bucket of the group" | |
main.step( "Add Group using Rest api" ) | |
bucketList = [] | |
bucket = main.buckets.addBucket( main, egressPort=egressPort1 ) | |
bucketList.append( bucket ) | |
bucket = main.buckets.addBucket( main, egressPort=egressPort2 ) | |
bucketList.append( bucket ) | |
bucket = main.buckets.addBucket( main, egressPort=egressPort3 ) | |
bucketList.append( bucket ) | |
response = main.ONOSrest.addGroup( deviceId=deviceId, | |
groupType=type1, | |
bucketList=bucketList, | |
appCookie=appCookie, | |
groupId=groupId ) | |
utilities.assert_equals( expect=main.TRUE, | |
actual=response, | |
onpass="Successfully added Groups of type ALL", | |
onfail="Failed to add Groups of type ALL" ) | |
# Giving ONOS time to add the group | |
time.sleep( main.addGroupSleep ) | |
main.step( "Check groups are in ADDED state" ) | |
response = main.ONOSrest.getGroups( deviceId=deviceId, | |
appCookie=appCookie ) | |
responsejson = json.loads( response ) | |
for item in responsejson: | |
if item[ "state" ] == "ADDED": | |
isAdded = main.TRUE | |
utilities.assert_equals( expect=main.TRUE, | |
actual=isAdded, | |
onpass="All Group is in Added State", | |
onfail="All Group is not in Added State" ) | |
""" | |
Adding flow using rest api | |
""" | |
isAdded = main.FALSE | |
main.step( "Adding flow with Group using rest api" ) | |
response = main.ONOSrest.addFlow( deviceId=deviceId, | |
priority=priority, | |
ingressPort=ingressPort, | |
groupId=groupId ) | |
utilities.assert_equals( expect=main.TRUE, | |
actual=response, | |
onpass="Successfully Added Flows", | |
onfail="Failed to Add flows" ) | |
# Giving ONOS time to add the flow | |
time.sleep( main.addFlowSleep ) | |
response = main.ONOSrest.getFlows( deviceId=deviceId ) | |
responsejson = json.loads( response ) | |
for item in responsejson: | |
if item[ "priority" ] == int( priority ) and item[ "state" ] == "ADDED": | |
isAdded = main.TRUE | |
utilities.assert_equals( expect=main.TRUE, | |
actual=isAdded, | |
onpass="Flow is in Added State", | |
onfail="Flow is not in Added State" ) | |
""" | |
Sends a packet using scapy | |
""" | |
main.step( "Testing Group by sending packet using Scapy" ) | |
main.log.info( "Creating host components" ) | |
main.Scapy.createHostComponent( "h1" ) | |
main.Scapy.createHostComponent( "h2" ) | |
main.Scapy.createHostComponent( "h3" ) | |
main.Scapy.createHostComponent( "h4" ) | |
hosts = [ main.h1, main.h2, main.h3, main.h4 ] | |
for host in hosts: | |
host.startHostCli() | |
host.startScapy() | |
host.updateSelf() | |
main.log.info( "Constructing Packet" ) | |
main.h1.buildEther( dst=main.h1.hostMac ) | |
main.h1.buildIP( dst=main.h1.hostIp ) | |
main.log.info( "Start Filter on host2,host3,host4" ) | |
main.h2.startFilter( pktFilter="ether host %s and ip host %s" % ( main.h1.hostMac, main.h1.hostIp ) ) | |
main.h3.startFilter( pktFilter="ether host %s and ip host %s" % ( main.h1.hostMac, main.h1.hostIp ) ) | |
main.h4.startFilter( pktFilter="ether host %s and ip host %s" % ( main.h1.hostMac, main.h1.hostIp ) ) | |
main.log.info( "sending packet to Host" ) | |
main.h1.sendPacket() | |
main.log.info( "Checking filter for our packet" ) | |
stepResultH2 = main.h2.checkFilter() | |
stepResultH3 = main.h3.checkFilter() | |
stepResultH4 = main.h4.checkFilter() | |
if stepResultH2: | |
main.log.info( "Packet : %s" % main.h2.readPackets() ) | |
else: | |
main.h2.killFilter() | |
if stepResultH3: | |
main.log.info( "Packet : %s" % main.h3.readPackets() ) | |
else: | |
main.h2.killFilter() | |
if stepResultH4: | |
main.log.info( "Packet : %s" % main.h4.readPackets() ) | |
else: | |
main.h4.killFilter() | |
if stepResultH2 and stepResultH3 and stepResultH4: | |
main.log.info( "Success!!!Packet sent to port 1 is received at port 2,3 and 4" ) | |
stepResult = main.TRUE | |
else: | |
main.log.info( "Failure!!!Packet sent to port 1 is not received at port 2,3 and 4" ) | |
stepResult = main.FALSE | |
main.log.info( "Clean up host components" ) | |
for host in hosts: | |
host.stopScapy() | |
main.Mininet1.removeHostComponent( "h1" ) | |
main.Mininet1.removeHostComponent( "h2" ) | |
main.Mininet1.removeHostComponent( "h3" ) | |
main.Mininet1.removeHostComponent( "h4" ) | |
utilities.assert_equals( expect=main.TRUE, | |
actual=stepResult, | |
onpass="Packet sent to port 1 is received at port 2,3,4 ", | |
onfail="Packet sent to port 1 is not received at port 2,3,4 " ) | |
def CASE6( self, main ): | |
""" | |
Deleting the Group and Flow | |
""" | |
import json | |
import time | |
respFlowId = 1 | |
main.case( "Delete the Group and Flow added through Rest api " ) | |
main.step( "Deleting Group and Flows" ) | |
#Get Flow ID | |
response = main.ONOSrest.getFlows( deviceId=deviceId ) | |
responsejson = json.loads( response ) | |
for item in responsejson: | |
if item[ "priority" ] == int( priority ): | |
respFlowId = item[ "id" ] | |
main.step( "Deleting the created flow by deviceId and flowId" ) | |
flowResponse = main.ONOSrest.removeFlow( deviceId=deviceId, | |
flowId=respFlowId ) | |
utilities.assert_equals( expect=main.TRUE, | |
actual=flowResponse, | |
onpass="Deleting flow is successful!!!", | |
onfail="Deleting flow is failure!!!" ) | |
# Giving ONOS time to delete the flow | |
time.sleep( main.delFlowSleep ) | |
main.step( "Deleting the created group by deviceId and appCookie" ) | |
groupResponse = main.ONOSrest.removeGroup( deviceId=deviceId, | |
appCookie=appCookie ) | |
utilities.assert_equals( expect=main.TRUE, | |
actual=groupResponse, | |
onpass="Deleting Group is successful!!!", | |
onfail="Deleting Group is failure!!!" ) | |
# Giving ONOS time to delete the group | |
time.sleep( main.delGroupSleep ) | |
def CASE7( self, main ): | |
""" | |
Adding Group of type "INDIRECT" using Rest api. | |
""" | |
import json | |
import time | |
isAdded = main.FALSE | |
main.case( "Verify Group of type INDIRECT are successfully Added" ) | |
main.caseExplanation = " Install a Group of type INDIRECT " +\ | |
" Verify the Group is Added " +\ | |
" Add a flow using the group " +\ | |
" Send a packet that verifies the action bucket of the group" | |
main.step( "Add Group using Rest api" ) | |
bucketList = [] | |
bucket = main.buckets.addBucket( main, egressPort=egressPort1 ) | |
bucketList.append( bucket ) | |
response = main.ONOSrest.addGroup( deviceId=deviceId, | |
groupType=type2, | |
bucketList=bucketList, | |
appCookie=appCookie, | |
groupId=groupId ) | |
utilities.assert_equals( expect=main.TRUE, | |
actual=response, | |
onpass="Successfully added Groups of type INDIRECT", | |
onfail="Failed to add Groups of type INDIRECT" ) | |
# Giving ONOS time to add the group | |
time.sleep( main.addGroupSleep ) | |
main.step( "Check groups are in ADDED state" ) | |
response = main.ONOSrest.getGroups( deviceId=deviceId, | |
appCookie=appCookie ) | |
responsejson = json.loads( response ) | |
for item in responsejson: | |
if item[ "state" ] == "ADDED": | |
isAdded = main.TRUE | |
utilities.assert_equals( expect=main.TRUE, | |
actual=isAdded, | |
onpass="INDIRECT Group is in Added State", | |
onfail="INDIRECT Group is not in Added State" ) | |
""" | |
Adding flows using rest api | |
""" | |
isAdded = main.FALSE | |
main.step( "Adding flow with Group using rest api" ) | |
response = main.ONOSrest.addFlow( deviceId=deviceId, | |
priority=priority, | |
ingressPort=ingressPort, | |
groupId=groupId ) | |
utilities.assert_equals( expect=main.TRUE, | |
actual=response, | |
onpass="Successfully Added Flows", | |
onfail="Failed to Add flows" ) | |
# Giving ONOS time to add the flow | |
time.sleep( main.addFlowSleep ) | |
response = main.ONOSrest.getFlows( deviceId=deviceId ) | |
responsejson = json.loads( response ) | |
for item in responsejson: | |
if item[ "priority" ] == int( priority ) and item[ "state" ] == "ADDED": | |
isAdded = main.TRUE | |
utilities.assert_equals( expect=main.TRUE, | |
actual=isAdded, | |
onpass="Flow is in Added State", | |
onfail="Flow is not in Added State" ) | |
""" | |
Sends a packet using scapy | |
""" | |
main.step( "Testing Group by sending packet using Scapy" ) | |
main.log.info( "Creating host components" ) | |
main.Scapy.createHostComponent( "h1" ) | |
main.Scapy.createHostComponent( "h2" ) | |
hosts = [ main.h1, main.h2 ] | |
for host in hosts: | |
host.startHostCli() | |
host.startScapy() | |
host.updateSelf() | |
main.log.info( "Constructing Packet" ) | |
main.h1.buildEther( dst=main.h1.hostMac ) | |
main.h1.buildIP( dst=main.h1.hostIp ) | |
main.log.info( "Start Filter on host2" ) | |
main.h2.startFilter( pktFilter="ether host %s and ip host %s" % ( main.h1.hostMac, main.h1.hostIp ) ) | |
main.log.info( "sending packet to Host" ) | |
main.h1.sendPacket() | |
main.log.info( "Checking filter for our packet" ) | |
stepResultH2 = main.h2.checkFilter() | |
if stepResultH2: | |
main.log.info( "Packet : %s" % main.h2.readPackets() ) | |
else: | |
main.h2.killFilter() | |
main.log.info( "Clean up host components" ) | |
for host in hosts: | |
host.stopScapy() | |
main.Mininet1.removeHostComponent( "h1" ) | |
main.Mininet1.removeHostComponent( "h2" ) | |
utilities.assert_equals( expect=main.TRUE, | |
actual=stepResultH2, | |
onpass="Packet sent to port 1 is received at port 2 successfully!!!", | |
onfail="Failure!!!Packet sent to port 1 is not received at port 2" ) | |
def CASE8( self, main ): | |
""" | |
Deleting the Group and Flow | |
""" | |
import json | |
import time | |
respFlowId = 1 | |
main.case( "Delete the Group and Flow added through Rest api " ) | |
main.step( "Deleting Group and Flows" ) | |
#Getting Flow ID | |
response = main.ONOSrest.getFlows( deviceId=deviceId ) | |
responsejson = json.loads( response ) | |
for item in responsejson: | |
if item[ "priority" ] == int( priority ): | |
respFlowId = item[ "id" ] | |
main.step( "Deleting the created flow by deviceId and flowId" ) | |
flowResponse = main.ONOSrest.removeFlow( deviceId=deviceId, | |
flowId=respFlowId ) | |
utilities.assert_equals( expect=main.TRUE, | |
actual=flowResponse, | |
onpass="Deleting flow is successful!!!", | |
onfail="Deleting flow is failure!!!" ) | |
# Giving ONOS time to delete the flow | |
time.sleep( main.delFlowSleep ) | |
groupResponse = main.ONOSrest.removeGroup( deviceId=deviceId, | |
appCookie=appCookie ) | |
utilities.assert_equals( expect=main.TRUE, | |
actual=groupResponse, | |
onpass="Deleting Group is successful!!!", | |
onfail="Deleting Group is failure!!!" ) | |
# Giving ONOS time to delete the group | |
time.sleep( main.delGroupSleep ) | |
def CASE100( self, main ): | |
""" | |
Report errors/warnings/exceptions | |
""" | |
main.log.info( "Error report: \n" ) | |
main.ONOSbench.logReport( main.ONOSip[ 0 ], | |
[ "INFO", | |
"FOLLOWER", | |
"WARN", | |
"flow", | |
"group", | |
"ERROR", | |
"Except" ], | |
"s" ) |