TestON/tests/USECASE/SegmentRouting/dependencies/Testcaselib.py

import os
import imp
import time
import json

from core import utilities


class Testcaselib:
    @staticmethod
    def initTest( main ):
        """
        - Construct tests variables
        - GIT ( optional )
            - Checkout ONOS master branch
            - Pull latest ONOS code
        - Building ONOS ( optional )
            - Install ONOS package
            - Build ONOS package
        """
        main.step( "Constructing test variables" )
        # Test variables
        main.cellName = main.params[ 'ENV' ][ 'cellName' ]
        main.apps = main.params[ 'ENV' ][ 'cellApps' ]
        main.diff = main.params[ 'ENV' ][ 'diffApps' ]
        gitBranch = main.params[ 'GIT' ][ 'branch' ]
        main.path = os.path.dirname( main.testFile )
        main.dependencyPath = main.path +"/../dependencies/"
        main.topology = main.params[ 'DEPENDENCY' ][ 'topology' ]
        wrapperFile1 = main.params[ 'DEPENDENCY' ][ 'wrapper1' ]
        main.scale = ( main.params[ 'SCALE' ][ 'size' ] ).split( "," )
        main.maxNodes = int( main.params[ 'SCALE' ][ 'max' ] )
        #main.ONOSport = main.params[ 'CTRL' ][ 'port' ]
        main.startUpSleep = int( main.params[ 'SLEEP' ][ 'startup' ] )
        main.cellData = {} # for creating cell file
        main.CLIs = []
        main.ONOSip = []
        main.RESTs= []

        # Assigning ONOS cli handles to a list
        for i in range( 1,  main.maxNodes + 1 ):
            main.CLIs.append( getattr( main, 'ONOScli' + str( i ) ) )
            main.RESTs.append( getattr( main, 'ONOSrest' + str( i ) ) )
            main.ONOSip.append( main.CLIs[i-1].ip_address )
        # -- INIT SECTION, ONLY RUNS ONCE -- #
        main.startUp = imp.load_source( wrapperFile1,
                                        main.dependencyPath +
                                        wrapperFile1 +
                                        ".py" )

        copyResult1 = main.ONOSbench.scp( main.Mininet1,
                                          main.dependencyPath +
                                          main.topology,
                                          main.Mininet1.home,
                                          direction="to" )
        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" )

    @staticmethod
    def installOnos( 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
        """
        # main.scale[ 0 ] determines the current number of ONOS controller
        apps=main.apps
        if main.diff:
            apps = main.apps + "," + main.diff
        else: main.log.error( "App list is empty" )
        main.case( "Package and start ONOS using apps:" + apps)
        print "NODE COUNT = ", main.numCtrls
        print main.ONOSip
        tempOnosIp = []
        for i in range( main.numCtrls ):
            tempOnosIp.append( main.ONOSip[i] )
        onosUser = main.params[ 'ENV' ][ 'cellUser' ]
        main.step("Create and Apply cell file")
        main.ONOSbench.createCellFile( main.ONOSbench.ip_address,
                                       "temp",
                                       main.Mininet1.ip_address,
                                       apps,
                                       tempOnosIp,
                                       onosUser )
        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 " )
        #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.step( "Create and Install ONOS package" )
        packageResult = main.ONOSbench.onosPackage()

        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" )
        main.step( "Starting ONOS service" )
        stopResult,startResult, onosIsUp= main.TRUE, main.TRUE, 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( "Checking if ONOS CLI is ready" )
        for i in range( main.numCtrls ):
            main.CLIs[i].startCellCli()
            cliResult = main.CLIs[i].startOnosCli( main.ONOSip[ i ],
                                               commandlineTimeout=60, onosStartTimeout=100 )
        utilities.assert_equals( expect=main.TRUE,
                                 actual=cliResult,
                                 onpass="ONOS CLI is ready",
                                 onfail="ONOS CLI is not ready" )
        main.active=0
        for i in range( 10 ):
            ready = True
            output = main.CLIs[main.active].summary()
            if not output:
                ready = False
            if ready:
                break
            time.sleep( 10 )
        utilities.assert_equals( expect=True, actual=ready,
                                 onpass="ONOS summary command succeded",
                                 onfail="ONOS summary command failed" )

        with open( main.dependencyPath + "/" + main.cfgName + ".json" ) as cfg:
            main.RESTs[main.active].setNetCfg( json.load(cfg) )

        if not ready:
            main.log.error( "ONOS startup failed!" )
            main.cleanup()
            main.exit()

        for i in range( main.numCtrls ):
            main.CLIs[i].logSet( "DEBUG", "org.onosproject.segmentrouting" )
            main.CLIs[i].logSet( "DEBUG", "org.onosproject.driver.pipeline" )
            main.CLIs[i].logSet( "DEBUG", "org.onosproject.store.group.impl" )
            main.CLIs[i].logSet( "DEBUG", "org.onosproject.net.flowobjective.impl" )

    @staticmethod
    def startMininet( main, topology, args="" ):
        main.step( "Starting Mininet Topology" )
        arg = "--onos %d %s" % (main.numCtrls, args)
        main.topology=topology
        topoResult = main.Mininet1.startNet( topoFile= main.dependencyPath + main.topology, args=arg )
        stepResult = topoResult
        utilities.assert_equals( expect=main.TRUE,
                                 actual=stepResult,
                                 onpass="Successfully loaded topology",
                                 onfail="Failed to load topology" )
        # Exit if topology did not load properly
        if not topoResult:
            main.cleanup()
            main.exit()

    @staticmethod
    def checkFlows(main, minFlowCount):
        main.step(" Check whether the flow count is bigger than %s" % minFlowCount)
        count =  utilities.retry(main.CLIs[main.active].checkFlowCount,
                                 main.FALSE,
                                 kwargs={'min':minFlowCount},
                                 attempts=10,
                                 sleep=10)
        utilities.assertEquals( \
                expect=True,
                actual=(count>0),
                onpass="Flow count looks correct: "+str(count),
                onfail="Flow count looks wrong: "+str(count) )

        main.step( "Check whether all flow status are ADDED" )
        flowCheck = utilities.retry( main.CLIs[main.active].checkFlowsState,
                                     main.FALSE,
                                     kwargs={'isPENDING':False},
                                     attempts=10,
                                     sleep=10)
        utilities.assertEquals( \
                expect=main.TRUE,
                actual=flowCheck,
                onpass="Flow status is correct!",
                onfail="Flow status is wrong!" )
        main.ONOSbench.dumpFlows( main.ONOSip[main.active],
                                  main.logdir, "flowsBefore" + main.cfgName)
        main.ONOSbench.dumpGroups( main.ONOSip[0],
                                   main.logdir, "groupsBefore" + main.cfgName)

    @staticmethod
    def pingAll( main, tag=""):
        main.log.report( "Check full connectivity" )
        main.step("Check full connectivity %s" %tag)
        pa = main.Mininet1.pingall()
        utilities.assert_equals( expect=main.TRUE, actual=pa,
                                 onpass="Full connectivity successfully tested",
                                 onfail="Full connectivity failed" )
        main.ONOSbench.dumpFlows( main.ONOSip[main.active],
                                  main.logdir, "flowsOn" + tag)
        main.ONOSbench.dumpGroups( main.ONOSip[main.active],
                                   main.logdir, "groupsOn" + tag)

    @staticmethod
    def killLink( main, end1, end2, switches, links ):
        """
        end1,end2: identify the switches, ex.: 'leaf1', 'spine1'
        switches, links: number of expected switches and links after linkDown, ex.: '4', '6'
        Kill a link and verify ONOS can see the proper link change
        """
        main.linkSleep = float( main.params[ 'timers' ][ 'LinkDiscovery' ] )
        main.step( "Kill link between %s and %s" %(end1, end2))
        LinkDown = main.Mininet1.link( END1=end1, END2=end2, OPTION="down" )
        main.log.info( "Waiting %s seconds for link down to be discovered" % main.linkSleep )
        time.sleep( main.linkSleep )
        topology =  utilities.retry( main.CLIs[ main.active ].checkStatus,
                                     main.FALSE,
                                     kwargs={'numoswitch':switches, 'numolink':links},
                                     attempts=10,
                                     sleep=main.linkSleep)
        result = topology & LinkDown
        utilities.assert_equals( expect=main.TRUE, actual=result,
                                 onpass="Link down successful",
                                 onfail="Failed to turn off link?" )

    @staticmethod
    def restoreLink( main, end1, end2, dpid1, dpid2, port1, port2, switches, links ):
        """
        Params:
            end1,end2: identify the end switches, ex.: 'leaf1', 'spine1'
            dpid1, dpid2: dpid of the end switches respectively, ex.: 'of:0000000000000002'
            port1, port2: respective port of the end switches that connects to the link, ex.:'1'
            switches, links: number of expected switches and links after linkDown, ex.: '4', '6'
        Kill a link and verify ONOS can see the proper link change
        """
        main.step( "Restore link between %s and %s" %( end1, end2 ) )
        result = False
        count=0
        while True:
            count+=0
            main.Mininet1.link( END1=end1, END2=end2, OPTION="up" )
            main.Mininet1.link( END2=end1, END1=end2, OPTION="up" )
            main.log.info( "Waiting %s seconds for link up to be discovered" % main.linkSleep )
            time.sleep( main.linkSleep )
            main.CLIs[main.active].portstate( dpid=dpid1, port=port1 )
            main.CLIs[main.active].portstate( dpid=dpid2, port=port2 )
            time.sleep( main.linkSleep )

            result = main.CLIs[main.active].checkStatus( numoswitch=switches, numolink=links )
            if count>5 or result:
                break
        utilities.assert_equals( expect=main.TRUE, actual=result,
                                 onpass="Link up successful",
                                 onfail="Failed to bring link up" )

    @staticmethod
    def killSwitch( main, switch, switches, links ):
        """
        Params: switches, links: number of expected switches and links after SwitchDown, ex.: '4', '6'
        Completely kill a switch and verify ONOS can see the proper change
        """
        main.switchSleep = float( main.params[ 'timers' ][ 'SwitchDiscovery' ] )
        main.step( "Kill " + switch )
        main.log.info( "Stopping" + switch )
        main.Mininet1.switch( SW=switch, OPTION="stop" )
        main.log.info( "Waiting %s seconds for switch down to be discovered" % ( main.switchSleep ) )
        time.sleep( main.switchSleep )
        topology =  utilities.retry( main.CLIs[main.active].checkStatus,
                                     main.FALSE,
                                     kwargs={'numoswitch':switches, 'numolink':links},
                                     attempts=10,
                                     sleep=main.switchSleep)
        utilities.assert_equals( expect=main.TRUE, actual=topology,
                                 onpass="Kill switch successful",
                                 onfail="Failed to kill switch?" )

    @staticmethod
    def recoverSwitch( main, switch, switches, links ):
        """
        Params: switches, links: number of expected switches and links after SwitchUp, ex.: '4', '6'
        Recover a switch and verify ONOS can see the proper change
        """
        main.step( "Recovering " + switch )
        main.log.info( "Starting" + switch )
        main.Mininet1.switch( SW=switch, OPTION="start")
        main.log.info( "Waiting %s seconds for switch up to be discovered" %(main.switchSleep))
        time.sleep( main.switchSleep )
        topology =  utilities.retry( main.CLIs[main.active].checkStatus,
                                     main.FALSE,
                                     kwargs={'numoswitch':switches, 'numolink':links},
                                     attempts=10,
                                     sleep=main.switchSleep)
        utilities.assert_equals( expect=main.TRUE, actual=topology,
                                 onpass="Switch recovery successful",
                                 onfail="Failed to recover switch?" )

    @staticmethod
    def cleanup( main ):
        """
        Stop Onos-cluster.
        Stops Mininet
        Copies ONOS log
        """
        main.Mininet1.stopNet()
        main.ONOSbench.scp( main.ONOScli1, "/opt/onos/log/karaf.log",
                           "/tmp/karaf.log", direction="from" )
        main.ONOSbench.cpLogsToDir( "/tmp/karaf.log", main.logdir,
                                   copyFileName="karaf.log."+main.cfgName )
        for i in range( main.numCtrls ):
            main.ONOSbench.onosStop( main.ONOSip[i] )