# This test should always succeed. it runs cases 1,2,3,4
#CASE1: Get and Build ONOS
#CASE2: Package and Install ONOS
#CASE3: Start Mininet and check flows
#CASE4: Ping all
#CASE5: Link Failure
#CASE6: Switch Failure
#CASE7: ONOS Failure
#CASE8: CLUSTER Failure
#CASE10: Logging

class SRSanity:

    def __init__( self ):
        self.default = ''

    def CASE1( self, main ):
        import time
        import os
        import imp
        import re

        """
        - 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" )
        main.step( "Constructing test variables" )
        stepResult = main.FALSE

        # Test variables
        main.cellName = main.params[ 'ENV' ][ 'cellName' ]
        main.apps = main.params[ 'ENV' ][ 'cellApps' ]
        main.diff = []
        main.diff.extend(( main.params[ 'ENV' ][ 'diffApps' ] ).split(";"))
        main.diff=main.diff*2
        gitBranch = main.params[ 'GIT' ][ 'branch' ]
        main.path = os.path.dirname( main.testFile )
        main.dependencyPath = main.path +"/../dependencies/"
        main.topology = main.params[ 'DEPENDENCY' ][ 'topology' ]
        main.json = ["2x2"]*4
        main.args = [" "]*4
        main.scale = ( main.params[ 'SCALE' ][ 'size' ] ).split( "," )
        main.maxNodes = int( main.params[ 'SCALE' ][ 'max' ] )
        main.ONOSport = main.params[ 'CTRL' ][ 'port' ]
        wrapperFile1 = main.params[ 'DEPENDENCY' ][ 'wrapper1' ]
        main.startUpSleep = int( main.params[ 'SLEEP' ][ 'startup' ] )
        gitPull = main.params[ 'GIT' ][ 'pull' ]
        main.cellData = {} # for creating cell file
        main.CLIs = []
        main.ONOSip = []

        # Assigning ONOS cli handles to a list
        for i in range( 1,  main.maxNodes + 1 ):
            main.CLIs.append( getattr( main, 'ONOScli' + 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" )

        if gitPull == 'True':
            main.step( "Building ONOS in " + gitBranch + " branch" )
            onosBuildResult = main.startUp.onosBuild( main, gitBranch )
            stepResult = onosBuildResult
            utilities.assert_equals( expect=main.TRUE,
                                     actual=stepResult,
                                     onpass="Successfully compiled " +
                                            "latest ONOS",
                                     onfail="Failed to compile " +
                                            "latest ONOS" )
        else:
            main.log.warn( "Did not pull new code so skipping mvn " +
                           "clean install" )
        main.numCtrls = int( main.scale[ 0 ] )
         
    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
        """

        # main.scale[ 0 ] determines the current number of ONOS controller
        main.numCtrls = int( main.scale[ 0 ] )
        main.scale.remove( main.scale[ 0 ] )
        apps=main.apps
        if main.diff:
            apps = main.apps+","+main.diff.pop(0)
        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" )
        main.jsonFile=main.json.pop(0)
        main.ONOSbench.handle.sendline( "cp "+main.dependencyPath+"/"+main.jsonFile+".json ~/onos/tools/package/config/network-cfg.json")
        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 = 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( "Checking if ONOS CLI is ready" )
        main.CLIs[0].startCellCli()
        cliResult = main.CLIs[0].startOnosCli( main.ONOSip[ 0 ],
                                           commandlineTimeout=60, onosStartTimeout=100 )
        utilities.assert_equals( expect=main.TRUE,
                             actual=cliResult,
                             onpass="ONOS CLI is ready",
                             onfail="ONOS CLI is not ready" )
        for i in range( 10 ):
            ready = True
            output = main.CLIs[0].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" )

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

    def CASE3( self, main ):
        """
            Start mininet
        """
        main.case( "Start Leaf-Spine "+main.jsonFile+" Mininet Topology" )
        main.log.report( "Start Mininet topology" )

        main.step( "Starting Mininet Topology" )
        args,topo=" "," "
        if main.args:
            args = "--onos %d %s" % (main.numCtrls, main.args.pop(0))
        else: main.log.error( "Argument list is empty" )
 
        topoResult = main.Mininet1.startNet( topoFile= main.dependencyPath + main.topology, args=args )
        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()
        main.step(" Check whether the flow count is bigger than 116" )
        count =  utilities.retry( main.CLIs[0].checkFlowCount,
                                 main.FALSE,
                                 kwargs={'min':116},
                                 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[0].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[0],
                 main.logdir, "flowsBefore" + main.jsonFile)
        main.ONOSbench.dumpGroups( main.ONOSip[0],
                                   main.logdir, "groupsBefore" + main.jsonFile)
        main.count=1

    def CASE4( self, main ):
        main.case( "Check full connectivity" )
        main.log.report( "Check full connectivity" )

        main.step("Check full connectivity"+str(main.count))
        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[0],
                 main.logdir, "flowsAfter" + str(main.count) + main.jsonFile)
        main.ONOSbench.dumpGroups( main.ONOSip[0],
                           main.logdir, "groupsAfter" + str(main.count) + main.jsonFile)

    def CASE5( self, main ):
        """
        Link spine101-leaf2 down
        Pingall
        Link spine101-leaf2 up
        Pingall
        """
        import time
        assert main.numCtrls, "main.numCtrls not defined"
        assert main, "main not defined"
        assert utilities.assert_equals, "utilities.assert_equals not defined"
        assert main.CLIs, "main.CLIs not defined"

        linkSleep = float( main.params[ 'timers' ][ 'LinkDiscovery' ] )

        description = "Turn off a link to ensure that Segment Routing reroutes traffic " + \
                      "properly"
        main.case( description )

        main.step( "Kill Link between spine101 and leaf2" )
        LinkDown = main.Mininet1.link( END1="spine101", END2="leaf2", OPTION="down" )
        main.log.info( "Waiting %s seconds for link up to be discovered" % (linkSleep) )
        # TODO Maybe parameterize number of expected links
        time.sleep( linkSleep )
        topology =  utilities.retry( main.CLIs[0].checkStatus,
                                      main.FALSE,
                                      kwargs={'numoswitch':'4', 'numolink':'6'},
                                      attempts=10,
                                      sleep=linkSleep)
        result = topology & LinkDown
        utilities.assert_equals( expect=main.TRUE, actual=result,
                                 onpass="Link down successful",
                                 onfail="Failed to turn off link?" )

        main.step( "Check connectivity after link failure" )
        pa = main.Mininet1.pingall()
        utilities.assert_equals( expect=main.TRUE, actual=pa,
                                 onpass="Survived link failure successfully",
                                 onfail="Did not survive link failure" )
        main.ONOSbench.dumpFlows( main.ONOSip[0],
                                  main.logdir,
                                  "flowsAfterLinkFailure" + main.jsonFile)
        main.ONOSbench.dumpGroups( main.ONOSip[0],
                                   main.logdir,
                                   "groupsAfterLinkFailure" + main.jsonFile)

        main.step( "Restore link between spine101 and leaf2" )

        result = False
        count=0
        while True:
            count+=0
            main.Mininet1.link( END1="spine101", END2="leaf2", OPTION="up" )
            main.Mininet1.link( END2="spine101", END1="leaf2", OPTION="up" )
            main.log.info( "Waiting %s seconds for link up to be discovered" % (linkSleep) )
            time.sleep( linkSleep )

            main.CLIs[0].portstate(dpid='of:0000000000000002', port='1')
            main.CLIs[0].portstate(dpid='of:0000000000000101', port='2')
            time.sleep( linkSleep )

            result = main.CLIs[0].checkStatus(numoswitch='4', numolink='8')
            if count>10 or result:
                break
        utilities.assert_equals( expect=main.TRUE, actual=result,
                                 onpass="Link up successful",
                                 onfail="Failed to bring link up" )

        main.step( "Check connectivity after link recovery" )
        pa = main.Mininet1.pingall()
        utilities.assert_equals( expect=main.TRUE, actual=pa,
                                 onpass="Survived link recovery successfully",
                                 onfail="Did not survive link recovery" )
        main.ONOSbench.dumpFlows( main.ONOSip[0],
                                  main.logdir,
                                  "flowsAfterLinkRecovery" + main.jsonFile)
        main.ONOSbench.dumpGroups( main.ONOSip[0],
                                   main.logdir,
                                   "groupsAfterLinkRecovery" + main.jsonFile)

    def CASE6( self, main ):
        """
        Switch Down
        Pingall
        Switch up
        Pingall
        """
        import time
        assert main.numCtrls, "main.numCtrls not defined"
        assert main, "main not defined"
        assert utilities.assert_equals, "utilities.assert_equals not defined"
        assert main.CLIs, "main.CLIs not defined"
    
        switchSleep = float( main.params[ 'timers' ][ 'SwitchDiscovery' ] )
    
        description = "Killing a switch to ensure it is discovered correctly"
        onosCli = main.CLIs[0]
        main.case( description )
        switch = main.params[ 'kill' ][ 'switch' ]
        switchDPID = main.params[ 'kill' ][ 'dpid' ]

        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" %(switchSleep))
        time.sleep( switchSleep )
        topology =  utilities.retry( main.CLIs[0].checkStatus,
                                      main.FALSE,
                                     kwargs={'numoswitch':'3', 'numolink':'4'},
                                      attempts=10,
                                     sleep=switchSleep)
        utilities.assert_equals( expect=main.TRUE, actual=topology,
                                 onpass="Kill switch successful",
                                 onfail="Failed to kill switch?" )

        main.step( "Check connectivity after switch failure" )
        pa = main.Mininet1.pingall()
        utilities.assert_equals( expect=main.TRUE, actual=pa,
                                 onpass="Survived switch failure successfully",
                                 onfail="Did not survive switch failure" )
        main.ONOSbench.dumpFlows( main.ONOSip[0],
                                  main.logdir,
                                  "flowsAfterSwitchFailure" + main.jsonFile)
        main.ONOSbench.dumpGroups( main.ONOSip[0],
                                   main.logdir,
                                   "groupsAfterSwitchFailure" + main.jsonFile)

        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" %(switchSleep))
        time.sleep( switchSleep )
        topology =  utilities.retry( main.CLIs[0].checkStatus,
                                     main.FALSE,
                                     kwargs={'numoswitch':'4', 'numolink':'8'},
                                     attempts=10,
                                     sleep=switchSleep)
        utilities.assert_equals( expect=main.TRUE, actual=topology,
                                 onpass="Switch recovery successful",
                                 onfail="Failed to recover switch?" )

        main.step( "Check connectivity after switch recovery" )
        pa = main.Mininet1.pingall()
        utilities.assert_equals( expect=main.TRUE, actual=pa,
                                 onpass="Survived switch recovery successfully",
                                 onfail="Did not survive switch recovery" )
        main.ONOSbench.dumpFlows( main.ONOSip[0],
                                  main.logdir,
                                  "flowsAfterSwitchRecovery" + main.jsonFile)
        main.ONOSbench.dumpGroups( main.ONOSip[0],
                                   main.logdir,
                                   "groupsAfterSwitchRecovery" + main.jsonFile)

    def CASE7( self, main ):
        """
        OnosInstance1 Down
        Pingall
        OnosInstance1 up
        Pingall
        """

        description = "Killing single instance to test controlplane resilience of Segment Routing"
        main.case( description )
        main.step( "Killing ONOS instance" )
        killResult = main.ONOSbench.onosDie( main.CLIs[0].ip_address )
        utilities.assert_equals( expect=main.TRUE, actual=killResult,
                                 onpass="ONOS instance Killed",
                                 onfail="Error killing ONOS instance" )
        time.sleep( 12 )
        topology =  utilities.retry( main.CLIs[1].checkStatus,
                                     main.FALSE,
                                     kwargs={'numoswitch':'4', 'numolink':'8', 'numoctrl':'2'},
                                     attempts=10,
                                     sleep=12)
        utilities.assert_equals( expect=main.TRUE, actual=topology,
                                 onpass="ONOS Instance down successful",
                                 onfail="Failed to turn off ONOS Instance" )
        main.step( "Check connectivity after ONOS instance failure" )
        pa = main.Mininet1.pingall()
        utilities.assert_equals( expect=main.TRUE, actual=pa,
                                 onpass="Survived instance failure successfully",
                                 onfail="Did not survive instance failure" )
        main.ONOSbench.dumpFlows( main.ONOSip[1], main.logdir,
                                  "flowsAfterSwitchFailure" + main.jsonFile)
        main.ONOSbench.dumpGroups( main.ONOSip[1], main.logdir,
                                   "groupsAfterSwitchFailure" + main.jsonFile)
        main.step( "Recovering ONOS instance" )
        startResult = main.ONOSbench.onosStart( main.CLIs[0].ip_address )
        isUp = main.ONOSbench.isup( main.ONOSip[ 0 ] )
        utilities.assert_equals( expect=main.TRUE, actual=isUp,
                                 onpass="ONOS service is ready",
                                 onfail="ONOS service did not start properly" )
        main.step( "Checking if ONOS CLI is ready" )
        main.CLIs[0].startCellCli()
        cliResult = main.CLIs[0].startOnosCli( main.ONOSip[ 0 ],
                                               commandlineTimeout=60, onosStartTimeout=100 )
        utilities.assert_equals( expect=main.TRUE,
                                 actual=cliResult,
                                 onpass="ONOS CLI is ready",
                                 onfail="ONOS CLI is not ready" )
        for i in range( 10 ):
            ready = True
            output = main.CLIs[0].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" )
        if not ready:
            main.log.error( "ONOS startup failed!" )
            main.cleanup()
            main.exit()
        main.step(" Check whether the flow count is bigger than 116" )
        count =  utilities.retry( main.CLIs[0].checkFlowCount,
                                  main.FALSE,
                                  kwargs={'min':116},
                                  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 connectivity after ONOS instance recovery" )
        pa = main.Mininet1.pingall()
        utilities.assert_equals( expect=main.TRUE, actual=pa,
                                 onpass="Survived instance recovery successfully",
                                 onfail="Did not survive recovery failure" )
        main.ONOSbench.dumpFlows( main.ONOSip[0], main.logdir,
                                  "flowsAfterCtrlFailure" + main.jsonFile)
        main.ONOSbench.dumpGroups( main.ONOSip[0], main.logdir,
                                   "groupsAfterCtrlFailure" + main.jsonFile)

    def CASE8( self, main ):
        """
        Cluster Down
        Pingall
        Cluster up
        Pingall
        """
        description = "Killing all instances to test controlplane resilience of Segment Routing"
        main.case( description )
        main.step( "Shutting down ONOS Cluster" )
        for i in range( main.numCtrls ):
            killResult = main.ONOSbench.onosDie( main.CLIs[i].ip_address )
            utilities.assert_equals( expect=main.TRUE, actual=killResult,
                                 onpass="ONOS instance Killed",
                                 onfail="Error killing ONOS instance" )
        time.sleep(12)
        main.step( "Check connectivity after ONOS instance failure" )
        pa = main.Mininet1.pingall()
        utilities.assert_equals( expect=main.TRUE, actual=pa,
                                 onpass="Survived instance failure successfully",
                                 onfail="Did not survive instance failure" )
        main.step( "Recovering ONOS Cluster" )
        for i in range( main.numCtrls ):
            startResult = main.ONOSbench.onosStart( main.CLIs[i].ip_address )
            isUp = main.ONOSbench.isup( main.ONOSip[ i ] )
            utilities.assert_equals( expect=main.TRUE, actual=isUp,
                                 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" )
        for i in range( 10 ):
            ready = True
            output = main.CLIs[0].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" )
        if not ready:
            main.log.error( "ONOS startup failed!" )
            main.cleanup()
            main.exit()

        main.step(" Check whether the flow count is bigger than 116" )
        count =  utilities.retry( main.CLIs[0].checkFlowCount,
                                  main.FALSE,
                                  kwargs={'min':116},
                                  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 connectivity after CLUSTER recovery" )
        pa = main.Mininet1.pingall()
        utilities.assert_equals( expect=main.TRUE, actual=pa,
                                 onpass="Survived instance recovery successfully",
                                 onfail="Did not survive recovery failure" )
        main.ONOSbench.dumpFlows( main.ONOSip[0], main.logdir,
                                  "flowsAfterCtrlFailure" + main.jsonFile)
        main.ONOSbench.dumpGroups( main.ONOSip[0], main.logdir,
                                   "groupsAfterCtrlFailure" + main.jsonFile)

    def CASE10( self, main ):
        '''
            Report errors/warnings/exceptions
        '''
        main.case( "Logging test for " + main.jsonFile )
        for i in range(main.numCtrls):
            main.ONOSbench.onosStop( main.ONOSip[i] )
        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.jsonFile+str(len(main.json)))
        #main.ONOSbench.logReport( main.ONOSip[ 0 ],
        #                          [ "INFO" ],
        #                          "a" )
        #main.log.info("Error report: \n" )
        main.ONOSbench.logReport( main.ONOSip[ 0 ],
                                  [ "INFO",
                                    "FOLLOWER",
                                    "WARN",
                                    "flow",
                                    "ERROR",
                                    "Except" ],
                                  "s" )